Version bump to v0.1.3

Cargo.toml

@@ -1,13 +1,15 @@
 [package]
 name = "adept"
 description = "Bit Goblin automated video transcoding service."
-version = "0.1.0"
+version = "0.1.3"
 edition = "2021"
 readme = "README.md"
 license = "BSD 2-Clause"
 authors = ["Gregory Ballantine <gballantine@bitgoblin.tech>"]
 
 [dependencies]
+log = "0.4"
+log4rs = "1.1"
 toml = "0.5"
 serde = "1.0"
 serde_derive = "1.0"
@@ -15,7 +17,7 @@ shellexpand = "2.1"
 
 [package.metadata.deb]
 license-file = "LICENSE"
-maintainer-scripts = "build/debian/scripts"
+maintainer-scripts = "build/scripts"
 depends = "ffmpeg (>= 4)"
 section = "video"
 assets = [
@@ -35,6 +37,6 @@ assets = [
   { source = "build/etc/example.toml", dest = "/etc/adept/example.toml", mode = "755"},
   { source = "README.md", dest = "/usr/share/doc/adept/README", mode = "644"}
 ]
-post_install_script = "build/script/postinst"
+post_install_script = "build/scripts/postinst"
 [package.metadata.generate-rpm.requires]
 ffmpeg = ">= 4"

build/scripts/postinst

@@ -20,3 +20,7 @@ fi
 
 # Change the directory ownership of /etc
 chown -R adept:adept /etc/adept
+
+#DEBHELPER#
+
+exit 0

log4rs.yaml

@@ -0,0 +1,12 @@
+appenders:
+  stdout:
+    kind: console
+    encoder:
+      pattern: "{d(%+)(utc)} {h({l})}: {m}{n}"
+    filters:
+      - kind: threshold
+        level: info
+root:
+  level: info
+  appenders:
+    - stdout

src/config.rs

@@ -3,32 +3,32 @@ use std::fs;
 
 #[derive(Deserialize)]
 pub struct Config {
-	pub transcoder: Transcoder,
+  pub transcoder: Transcoder,
 }
 
 impl Config {
-	pub fn new(config_path: &str) -> Config {
+  pub fn new(config_path: &str) -> Config {
-		let resolved_path = shellexpand::tilde(config_path);
+    let resolved_path = shellexpand::tilde(config_path);
-		let config_text = fs::read_to_string(&*resolved_path).unwrap();
+    let config_text = fs::read_to_string(&*resolved_path).unwrap();
-		let c: Config = toml::from_str(&config_text).unwrap();
+    let c: Config = toml::from_str(&config_text).unwrap();
-		return c;
+    return c;
-	}
+  }
 
-	pub fn get_repository(&self) -> String {
+  pub fn get_repository(&self) -> String {
-		let resolved_path = shellexpand::tilde(&self.transcoder.repository);
+    let resolved_path = shellexpand::tilde(&self.transcoder.repository);
-		return String::from(&*resolved_path);
+    return String::from(&*resolved_path);
-	}
+  }
 }
 
 #[derive(Deserialize)]
 pub struct Transcoder {
-	pub repository:       String,
+  pub repository:       String,
-	pub interval:         u16,
+  pub interval:         u16,
-	pub video_format:     String,
+  pub video_format:     String,
-	pub video_codec:      String,
+  pub video_codec:      String,
-	pub video_profile:    String,
+  pub video_profile:    String,
-	pub video_resolution: String,
+  pub video_resolution: String,
-	pub video_framerate:  u8,
+  pub video_framerate:  u8,
-	pub video_color:      String,
+  pub video_color:      String,
-	pub audio_codec:      String,
+  pub audio_codec:      String,
 }

src/main.rs

@@ -1,12 +1,16 @@
+use log4rs;
 use config::Config;
-use repository::Repository;
+use transcoder::repository::Repository;
-use transcoder::Transcoder;
+use transcoder::transcoder::Transcoder;
 
 mod config;
-mod repository;
 mod transcoder;
+mod util;
 
 fn main() {
+  // initialize the log4rs logger
+  log4rs::init_file("./log4rs.yaml", Default::default()).unwrap();
+
   // create and initialize our config and repository objects
   let c: Config = Config::new("~/.config/adept.toml");
   let r: Repository = Repository::new(&c.get_repository());

src/repository.rs

@@ -1,87 +0,0 @@
-use std::fs;
-use std::path::Path;
-
-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(_) => {
-				println!("Archiving video file {}.", ingest_file.to_str().unwrap());
-			},
-			Err(e) => {
-				eprintln!("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() {
-		println!("Directory {} already exists.", path);
-	} else {
-		match fs::create_dir(path) {
-			Ok(_) => {
-				println!("Creating directory {}.", path);
-			},
-			Err(e) => {
-				eprintln!("Error creating {}: {}", path, e);
-				std::process::exit(1);
-			}
-		}
-	}
-}

src/transcoder.rs

@@ -1,61 +0,0 @@
-use std::path::Path;
-use std::process;
-
-use crate::config::Config;
-use crate::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) {
-		println!("Starting transcoder...");
-
-		// search for files in ingest
-		let ingest_files = self.repository.search_ingest();
-
-		for i in ingest_files {
-			// 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);
-		}
-	}
-
-	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);
-		println!("{}", results_raw);
-	}
-}

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);
+  }
+}

src/util/io.rs

@@ -0,0 +1,61 @@
+use std::process;
+
+// checks whether a file is currently open in another program (e.g. still being written)
+pub fn is_file_locked(filepath: &str) -> bool {
+  let cmd = process::Command::new("/usr/bin/lsof")
+    .arg(filepath)
+    .output()
+    .expect("Failed to execute command");
+
+  let results = &String::from_utf8_lossy(&cmd.stdout);
+  println!("{}", results);
+  if results.contains(filepath) {
+    return true;
+  }
+
+  return false;
+}
+
+#[cfg(test)]
+mod tests {
+  use std::fs;
+  use std::mem::drop;
+  use std::path::Path;
+
+  use super::*;
+
+  #[test]
+  fn file_should_not_be_locked() {
+    setup("test-not-locked.txt");
+    assert!(!is_file_locked("test-not-locked.txt"));
+    teardown("test-not-locked.txt");
+  }
+
+  #[test]
+  fn file_should_be_locked() {
+    setup("test-locked.txt");
+    let path = Path::new("test-locked.txt");
+    match fs::File::open(&path) {
+      Err(e) => panic!("couldn't open {}: {}", "test-locked.txt", e),
+      Ok(_) => assert!(is_file_locked("test-locked.txt")),
+    };
+    teardown("test-locked.txt");
+  }
+
+  // get things ready for our tests
+  fn setup(test_file: &str) {
+    let f = match fs::File::create(test_file) {
+      Ok(file) => file,
+      Err(e) => panic!("{:?}", e),
+    };
+    drop(f);
+  }
+
+  // clean up after running tests
+  fn teardown(test_file: &str) {
+    match fs::remove_file(test_file) {
+      Ok(_) => {},
+      Err(e) => panic!("{:?}", e),
+    };
+  }
+}

src/util/mod.rs

@@ -0,0 +1 @@
+pub mod io;