Vendor dependencies

notes-service/vendor/compression-codecs/src/flate/decoder.rs

@@ -0,0 +1,95 @@
+use crate::DecodeV2;
+use compression_core::util::{PartialBuffer, WriteBuffer};
+use flate2::{Decompress, FlushDecompress, Status};
+use std::io;
+
+#[derive(Debug)]
+pub struct FlateDecoder {
+    zlib_header: bool,
+    decompress: Decompress,
+}
+
+impl FlateDecoder {
+    pub(crate) fn new(zlib_header: bool) -> Self {
+        Self {
+            zlib_header,
+            decompress: Decompress::new(zlib_header),
+        }
+    }
+
+    fn decode(
+        &mut self,
+        input: &mut PartialBuffer<&[u8]>,
+        output: &mut WriteBuffer<'_>,
+        flush: FlushDecompress,
+    ) -> io::Result<Status> {
+        let prior_in = self.decompress.total_in();
+        let prior_out = self.decompress.total_out();
+
+        let status = self
+            .decompress
+            // Safety: We **trust** flate2 to not write uninitialized bytes into buffer
+            .decompress_uninit(input.unwritten(), unsafe { output.unwritten_mut() }, flush)?;
+
+        input.advance((self.decompress.total_in() - prior_in) as usize);
+        // Safety: We **trust** flate2 to write bytes into buffer properly
+        unsafe {
+            output.assume_init_and_advance((self.decompress.total_out() - prior_out) as usize)
+        };
+
+        Ok(status)
+    }
+}
+
+impl DecodeV2 for FlateDecoder {
+    fn reinit(&mut self) -> io::Result<()> {
+        self.decompress.reset(self.zlib_header);
+        Ok(())
+    }
+
+    fn decode(
+        &mut self,
+        input: &mut PartialBuffer<&[u8]>,
+        output: &mut WriteBuffer<'_>,
+    ) -> io::Result<bool> {
+        match self.decode(input, output, FlushDecompress::None)? {
+            Status::Ok => Ok(false),
+            Status::StreamEnd => Ok(true),
+            Status::BufError => Err(io::Error::other("unexpected BufError")),
+        }
+    }
+
+    fn flush(&mut self, output: &mut WriteBuffer<'_>) -> io::Result<bool> {
+        self.decode(
+            &mut PartialBuffer::new(&[][..]),
+            output,
+            FlushDecompress::Sync,
+        )?;
+
+        loop {
+            let old_len = output.written_len();
+            self.decode(
+                &mut PartialBuffer::new(&[][..]),
+                output,
+                FlushDecompress::None,
+            )?;
+            if output.written_len() == old_len {
+                break;
+            }
+        }
+
+        Ok(!output.has_no_spare_space())
+    }
+
+    fn finish(&mut self, output: &mut WriteBuffer<'_>) -> io::Result<bool> {
+        match self.decode(
+            &mut PartialBuffer::new(&[][..]),
+            output,
+            FlushDecompress::Finish,
+        )? {
+            Status::Ok => Ok(false),
+            Status::StreamEnd => Ok(true),
+            Status::BufError => Err(io::Error::other("unexpected BufError")),
+        }
+    }
+}

notes-service/vendor/compression-codecs/src/flate/encoder.rs

@@ -0,0 +1,103 @@
+use crate::{flate::params::FlateEncoderParams, EncodeV2};
+use compression_core::util::{PartialBuffer, WriteBuffer};
+use flate2::{Compress, FlushCompress, Status};
+use std::io;
+
+#[derive(Debug)]
+pub struct FlateEncoder {
+    compress: Compress,
+    flushed: bool,
+}
+
+impl FlateEncoder {
+    pub fn new(level: FlateEncoderParams, zlib_header: bool) -> Self {
+        let level = flate2::Compression::from(level);
+        Self {
+            compress: Compress::new(level, zlib_header),
+            flushed: true,
+        }
+    }
+
+    pub fn get_ref(&self) -> &Compress {
+        &self.compress
+    }
+
+    fn encode(
+        &mut self,
+        input: &mut PartialBuffer<&[u8]>,
+        output: &mut WriteBuffer<'_>,
+        flush: FlushCompress,
+    ) -> io::Result<Status> {
+        let prior_in = self.compress.total_in();
+        let prior_out = self.compress.total_out();
+
+        let status = self
+            .compress
+            // Safety: We **trust** flate2 to not write uninitialized bytes into buffer
+            .compress_uninit(input.unwritten(), unsafe { output.unwritten_mut() }, flush)?;
+
+        input.advance((self.compress.total_in() - prior_in) as usize);
+        // Safety: We **trust** flate2 to write bytes properly into buffer
+        unsafe { output.assume_init_and_advance((self.compress.total_out() - prior_out) as usize) };
+
+        Ok(status)
+    }
+}
+
+impl EncodeV2 for FlateEncoder {
+    fn encode(
+        &mut self,
+        input: &mut PartialBuffer<&[u8]>,
+        output: &mut WriteBuffer<'_>,
+    ) -> io::Result<()> {
+        self.flushed = false;
+        match self.encode(input, output, FlushCompress::None)? {
+            Status::Ok => Ok(()),
+            Status::StreamEnd => unreachable!(),
+            Status::BufError => Err(io::Error::other("unexpected BufError")),
+        }
+    }
+
+    fn flush(&mut self, output: &mut WriteBuffer<'_>) -> io::Result<bool> {
+        // We need to keep track of whether we've already flushed otherwise we'll just keep writing
+        // out sync blocks continuously and probably never complete flushing.
+        if self.flushed {
+            return Ok(true);
+        }
+
+        self.encode(
+            &mut PartialBuffer::new(&[][..]),
+            output,
+            FlushCompress::Sync,
+        )?;
+
+        loop {
+            let old_len = output.written_len();
+            self.encode(
+                &mut PartialBuffer::new(&[][..]),
+                output,
+                FlushCompress::None,
+            )?;
+            if output.written_len() == old_len {
+                break;
+            }
+        }
+
+        let internal_flushed = !output.has_no_spare_space();
+        self.flushed = internal_flushed;
+        Ok(internal_flushed)
+    }
+
+    fn finish(&mut self, output: &mut WriteBuffer<'_>) -> io::Result<bool> {
+        self.flushed = false;
+        match self.encode(
+            &mut PartialBuffer::new(&[][..]),
+            output,
+            FlushCompress::Finish,
+        )? {
+            Status::Ok => Ok(false),
+            Status::StreamEnd => Ok(true),
+            Status::BufError => Err(io::Error::other("unexpected BufError")),
+        }
+    }
+}

notes-service/vendor/compression-codecs/src/flate/mod.rs

@@ -0,0 +1,5 @@
+mod decoder;
+mod encoder;
+pub mod params;
+
+pub use self::{decoder::FlateDecoder, encoder::FlateEncoder};

notes-service/vendor/compression-codecs/src/flate/params.rs

@@ -0,0 +1,40 @@
+use std::convert::TryInto;
+
+use compression_core::Level;
+
+#[derive(Debug, Clone)]
+pub struct FlateEncoderParams {
+    inner: flate2::Compression,
+}
+
+impl From<flate2::Compression> for FlateEncoderParams {
+    fn from(inner: flate2::Compression) -> Self {
+        Self { inner }
+    }
+}
+impl From<FlateEncoderParams> for flate2::Compression {
+    fn from(value: FlateEncoderParams) -> Self {
+        value.inner
+    }
+}
+
+impl From<Level> for FlateEncoderParams {
+    fn from(value: Level) -> Self {
+        let fastest = flate2::Compression::fast();
+        let best = flate2::Compression::best();
+        let none = flate2::Compression::none();
+
+        let inner = match value {
+            Level::Fastest => fastest,
+            Level::Best => best,
+            Level::Precise(quality) => flate2::Compression::new(
+                quality
+                    .try_into()
+                    .unwrap_or(0)
+                    .clamp(none.level(), best.level()),
+            ),
+            _ => flate2::Compression::default(),
+        };
+        Self { inner }
+    }
+}