Add LZ4 as a built in compression engine (part 2)

src/compression.rs

@@ -37,8 +37,8 @@ pub struct CompressionProgram {
 
 
 lazy_static! {
-    static ref COMPRESSION_PROGRAMS: EnumMap<CompressionType, Option<CompressionProgram>> = enum_map! {
+    pub static ref COMPRESSION_PROGRAMS: EnumMap<CompressionType, Option<CompressionProgram>> = enum_map! {
-        CompressionType::LZ4 => Some(CompressionProgram::new("lz4", vec!["-qcf"], vec!["-dcf"])),
+        CompressionType::LZ4 => None,
         CompressionType::GZip => Some(CompressionProgram::new("gzip", vec!["-qcf"], vec!["-dcf"])),
         CompressionType::BZip2 => Some(CompressionProgram::new("bzip2", vec!["-qcf"], vec!["-dcf"])),
         CompressionType::XZ => Some(CompressionProgram::new("xz", vec!["-qcf"], vec!["-dcf"])),
@@ -61,14 +61,12 @@ impl CompressionProgram {
     }
 }
 
-
 pub trait CompressionEngine {
     fn is_supported(&self) -> bool;
     fn cat(&self, file_path: PathBuf) -> Result<()>;
     fn create(&self, file_path: PathBuf) -> Result<Box<dyn Write>>;
 }
 
-
 impl CompressionEngine for CompressionProgram {
     fn is_supported(&self) -> bool {
         self.supported
@@ -120,9 +118,10 @@ impl CompressionEngine for CompressionProgram {
     }
 }
 
-#[derive(Debug, Eq, PartialEq, Clone)]
+
-pub struct CompressionEngineNone {
+
-}
+#[derive(Debug, Eq, PartialEq, Clone, Default)]
+pub struct CompressionEngineNone {}
 
 impl CompressionEngineNone {
     pub fn new() -> CompressionEngineNone {
@@ -130,12 +129,6 @@ impl CompressionEngineNone {
     }
 }
 
-impl Default for CompressionEngineNone {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 impl CompressionEngine for CompressionEngineNone {
     fn is_supported(&self) -> bool {
         true
@@ -159,6 +152,45 @@ impl CompressionEngine for CompressionEngineNone {
 }
 
 
+
+#[derive(Debug, Eq, PartialEq, Clone, Default)]
+pub struct CompressionEngineLZ4 {}
+
+impl CompressionEngineLZ4 {
+    pub fn new() -> CompressionEngineLZ4 {
+        CompressionEngineLZ4 {}
+    }
+}
+
+impl CompressionEngine for CompressionEngineLZ4 {
+    fn is_supported(&self) -> bool {
+        true
+    }
+
+    fn cat(&self, file_path: PathBuf) -> Result<()> {
+        debug!("COMPRESSION: Outputting {:?} to STDOUT using {:?}", file_path, *self);
+
+        let mut stdout = io::stdout().lock();
+        let file = File::open(file_path)?;
+        let mut lz4_read = lz4_flex::frame::FrameDecoder::new(file);
+
+        io::copy(&mut lz4_read, &mut stdout)?;
+        stdout.flush()?;
+
+        Ok(())
+    }
+
+    fn create(&self, file_path: PathBuf) -> Result<Box<dyn Write>> {
+        debug!("COMPRESSION: Writting to {:?} using {:?}", file_path, *self);
+
+        let file = File::create(file_path)?;
+        let lz4_write = lz4_flex::frame::FrameEncoder::new(file).auto_finish();
+
+        Ok(Box::new(lz4_write))
+    }
+}
+
+
 fn get_program_path(program: &str) -> Result<String> {
     debug!("COMPRESSION: Looking for executable: {}", program);
     if let Ok(path) = env::var("PATH") {
@@ -178,17 +210,10 @@ fn get_program_path(program: &str) -> Result<String> {
 }
 
 
-pub fn get_program(compression_type: CompressionType) -> Result<CompressionProgram> {
-    match &COMPRESSION_PROGRAMS[compression_type.clone()] {
-        Some(compression_program) => Ok(compression_program.clone()),
-        None => Err(anyhow!("Compression type {} has no program", compression_type))
-    }
-}
-
-
 pub fn get_engine(compression_type: CompressionType) -> Result<Box<dyn CompressionEngine>> {
     match compression_type {
         CompressionType::None => Ok(Box::new(CompressionEngineNone::new())),
+        CompressionType::LZ4 => Ok(Box::new(CompressionEngineLZ4::new())),
         compression_type => Ok(Box::new(COMPRESSION_PROGRAMS[compression_type.clone()].clone().unwrap()))
     }
 }