Added a basic check to make sure we don't try to transcode a partially written file

src/transcoder/mod.rs

@@ -0,0 +1,2 @@
+pub mod repository;
+pub mod transcoder;

src/transcoder/repository.rs

@@ -0,0 +1,88 @@
+use std::fs;
+use std::path::Path;
+use log::{error, info};
+
+pub struct Repository {
+  pub base_dir: String,
+  pub ingest_dir: String,
+  pub archive_dir: String,
+  pub output_dir: String,
+}
+
+impl Repository {
+  pub fn new(base_path: &str) -> Repository {
+    // create the base directory path
+    create_directory(base_path);
+
+    // create the needed sub-directories
+    let ingest_path = Path::new(base_path).join("ingest");
+    create_directory(ingest_path.to_str().unwrap());
+    let archive_path = Path::new(base_path).join("archive");
+    create_directory(archive_path.to_str().unwrap());
+    let output_path = Path::new(base_path).join("output");
+    create_directory(output_path.to_str().unwrap());
+
+    return Repository {
+      base_dir: String::from(base_path),
+      ingest_dir: String::from(ingest_path.to_str().unwrap()),
+      archive_dir: String::from(archive_path.to_str().unwrap()),
+      output_dir: String::from(output_path.to_str().unwrap()),
+    };
+  }
+
+  pub fn search_ingest(&self) -> Vec<String> {
+    // read file entries from ingest
+    let files = fs::read_dir(&self.ingest_dir).unwrap();
+
+    // create vec object and loop through entries to find what we want
+    let mut ingest_files: Vec<String> = vec![];
+    for f in files {
+      let f = f.unwrap();
+      let path = f.path();
+      if path.is_file() {
+        let file_path = path.file_name().unwrap().to_str();
+        ingest_files.push(String::from(file_path.unwrap()));
+      }
+    }
+
+    return ingest_files;
+  }
+
+  pub fn archive_file(&self, file: &str) {
+    let ingest_file = Path::new(&self.ingest_dir).join(file);
+    let archive_file = Path::new(&self.archive_dir).join(file);
+
+    match fs::copy(&ingest_file, &archive_file) {
+      Ok(_) => {
+        info!("Archiving video file {}.", ingest_file.to_str().unwrap());
+      },
+      Err(e) => {
+        error!("Error archiving file {}: {}", ingest_file.to_str().unwrap(), e);
+        std::process::exit(1);
+      }
+    }
+  }
+
+  pub fn cleanup_file(&self, file: &str) {
+    let ingest_file = Path::new(&self.ingest_dir).join(file);
+    fs::remove_file(&ingest_file)
+      .expect("File deletion failed.");
+  }
+}
+
+fn create_directory(path: &str) {
+  let d = Path::new(path);
+  if d.is_dir() {
+    info!("Directory {} already exists.", path);
+  } else {
+    match fs::create_dir(path) {
+      Ok(_) => {
+        info!("Creating directory {}.", path);
+      },
+      Err(e) => {
+        error!("Error creating {}: {}", path, e);
+        std::process::exit(1);
+      }
+    }
+  }
+}

src/transcoder/transcoder.rs

@@ -0,0 +1,81 @@
+use std::path::Path;
+use std::process;
+use std::{thread, time};
+use log::{info};
+
+use crate::config::Config;
+use crate::util::io;
+use super::repository::Repository;
+
+pub struct Transcoder {
+  config: Config,
+  repository: Repository,
+}
+
+impl Transcoder {
+  pub fn new(config: Config, repository: Repository) -> Transcoder {
+    return Transcoder{
+      config: config,
+      repository: repository,
+    }
+  }
+
+  pub fn start(self) {
+    info!("Starting transcoder...");
+
+    loop {
+      // search for files in ingest
+      let ingest_files = self.repository.search_ingest();
+
+      // check if we found any files to transcode
+      if ingest_files.len() < 1 {
+        info!("There were no files found in ingest to transcode; skipping run.");
+      } else {
+        for i in ingest_files {
+          let ingest_path = Path::new(&self.repository.ingest_dir).join(&i);
+          if io::is_file_locked(&ingest_path.to_str().unwrap()) {
+            info!("{} is currently open in another program; skipping it for this run.", &i);
+            continue;
+          }
+
+          // copy the file to the archive
+          self.repository.archive_file(&i);
+
+          // perform the video transcode
+          self.transcode(&i);
+
+          // remove the source file
+          self.repository.cleanup_file(&i);
+        }
+      }
+
+      // put the loop to sleep for X minutes
+      let sleep_minutes = time::Duration::from_secs((self.config.transcoder.interval * 60).into());
+      thread::sleep(sleep_minutes);
+    }
+  }
+
+  fn transcode(&self, file: &str) {
+    let ingest_file = Path::new(&self.repository.ingest_dir).join(file);
+    let output_file = Path::new(&self.repository.output_dir).join(file);
+
+    let cmd_output = process::Command::new("/usr/bin/ffmpeg")
+      .arg("-i")        .arg(&*ingest_file.to_string_lossy())
+      .arg("-y")
+      .arg("-f")        .arg(&self.config.transcoder.video_format)
+      .arg("-c:v")      .arg(&self.config.transcoder.video_codec)
+      .arg("-s")        .arg(&self.config.transcoder.video_resolution)
+      .arg("-r")        .arg(format!("{}", self.config.transcoder.video_framerate))
+      .arg("-vf")       .arg(format!("format={}", &self.config.transcoder.video_color))
+      .arg("-profile:v").arg(&self.config.transcoder.video_profile)
+      .arg("-c:a")      .arg(&self.config.transcoder.audio_codec)
+      .arg(&*output_file.to_string_lossy())
+      .output()
+      .expect("Failed to execute command");
+
+    assert!(cmd_output.status.success());
+
+    let results_raw = &String::from_utf8_lossy(&cmd_output.stderr);
+    info!("{}", results_raw);
+  }
+}