Started rewriting project in TypeScript

src/cmd/core.rs

@@ -1,20 +0,0 @@
-use config::Config;
-use crate::settings;
-use crate::transcoder::repository::Repository;
-
-pub fn setup_command() {
-  // load configuration
-  let c: Config = settings::load_config();
-
-  // resolve repository path
-  let repository_dir_raw: &str = &c.get_string("transcoder.repository").unwrap();
-  let repository_dir: &str = &shellexpand::tilde(repository_dir_raw);
-
-  // alert the user to what's happening
-  println!("Initializing video repository at {}...", repository_dir);
-
-  // create and initialize our repository object
-  let r: Repository = Repository::new(repository_dir);
-  // initialize the video repository
-  r.initialize();
-}

src/cmd/mod.rs

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

src/main.rs

@@ -1,52 +0,0 @@
-use clap::{Parser, Subcommand};
-use log4rs;
-use config::Config;
-use transcoder::repository::Repository;
-use transcoder::transcoder::Transcoder;
-
-mod cmd;
-mod settings;
-mod transcoder;
-mod util;
-
-#[derive(Parser)]
-#[clap(author, version, about, long_about = None)]
-struct Cli {
-  /// Number of times to greet
-  #[clap(short = 'l', long, default_value_t = String::from("./log4rs.yaml"))]
-  log_config: String,
-
-  #[clap(subcommand)]
-  command: Option<Commands>,
-}
-
-#[derive(Subcommand)]
-enum Commands {
-  /// displays version info about this program
-  Setup {},
-}
-
-fn main() {
-  // initialize the clap CLI
-  let cli = Cli::parse();
-
-  // grab the log4rs config file path, then initialize log4rs
-  let log4rs_config: String = cli.log_config;
-  log4rs::init_file(&log4rs_config, Default::default()).unwrap();
-
-  match &cli.command {
-    // sub-commands will be handled here
-    Some(Commands::Setup {}) => cmd::core::setup_command(),
-
-    // run the main program without any commands
-    None => {
-      // create and initialize our config and repository objects
-      let c: Config = settings::load_config();
-      let r: Repository = Repository::new(&shellexpand::tilde(&c.get_string("transcoder.repository").unwrap()));
-
-      // create and start the video transcoder object
-      let t: Transcoder = Transcoder::new(c, r);
-      t.start();
-    },
-  }
-}

src/repository.ts

@@ -0,0 +1,40 @@
+import fs from 'fs';
+import path from 'path';
+import { resolveTilde } from './util';
+
+export default class Repository {
+
+  base_path: string;
+  ingest_path: string;
+  archive_path: string;
+  output_path: string;
+
+  constructor(base_path: string) {
+    // set base path
+    this.base_path = resolveTilde(base_path);
+
+    // set sub-directory paths
+    this.ingest_path = path.join(this.base_path, 'ingest');
+    this.archive_path = path.join(this.base_path, 'archive');
+    this.output_path = path.join(this.base_path, 'output');
+  }
+  
+  initialize(): void {
+    console.log(`Initializing video repository at ${this.base_path}.`);
+
+    // ensure each directory exists
+    if (!fs.existsSync(this.base_path)) {
+      fs.mkdirSync(this.base_path);
+    }
+    if (!fs.existsSync(this.ingest_path)) {
+      fs.mkdirSync(this.ingest_path);
+    }
+    if (!fs.existsSync(this.archive_path)) {
+      fs.mkdirSync(this.archive_path);
+    }
+    if (!fs.existsSync(this.output_path)) {
+      fs.mkdirSync(this.output_path);
+    }
+  }
+
+}

src/settings.rs

@@ -1,33 +0,0 @@
-use config::Config;
-
-pub fn load_config() -> Config {
-  let global_config_path: String = find_global_config_path();
-  let home_config_path: String = find_home_config_path();
-
-  let settings = Config::builder()
-    // Add in `./Settings.toml`
-    .add_source(config::File::with_name(&global_config_path).required(false))
-    .add_source(config::File::with_name(&home_config_path).required(false))
-    .build()
-    .unwrap();
-
-  return settings;
-}
-
-fn find_global_config_path() -> String {
-  if cfg!(windows) {
-    return String::from("C:\\Program Files\\Zealot\\config.toml");
-  }
-
-  return String::from("/etc/zealot/config.toml");
-}
-
-fn find_home_config_path() -> String {
-  let home_path: &str = &shellexpand::tilde("~/.config/zealot.toml");
-
-  if cfg!(windows) {
-    return String::from(home_path.replace("/", "\\"));
-  }
-
-  return String::from(home_path);
-}

src/transcoder/mod.rs

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

src/transcoder/repository.rs

@@ -1,91 +0,0 @@
-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 {
-    let ingest_path = Path::new(base_path).join("ingest");
-    let archive_path = Path::new(base_path).join("archive");
-    let output_path = Path::new(base_path).join("output");
-
-    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 initialize(&self) {
-    // create the base directory path
-    create_directory(&self.base_dir);
-
-    // create the needed sub-directories
-    create_directory(&self.ingest_dir.as_str());
-    create_directory(&self.archive_dir.as_str());
-    create_directory(&self.output_dir.as_str());
-  }
-
-  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

@@ -1,88 +0,0 @@
-use config::Config;
-use std::path::Path;
-use std::process;
-use std::{thread, time};
-use log::{debug, info};
-
-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.get_int("transcoder.interval").unwrap() as u64 * 60).into());
-      thread::sleep(sleep_minutes);
-    }
-  }
-
-  fn transcode(&self, file: &str) {
-    let ingest_file = Path::new(&self.repository.ingest_dir).join(file);
-    let video_format = &self.config.get_string("transcoder.video_format").unwrap();
-    let output_stem = Path::new(file).file_stem().unwrap();
-    let output_bits = vec![output_stem.to_str().unwrap(), &video_format];
-    let output_name = output_bits.join(".");
-    let output_file = Path::new(&self.repository.output_dir).join(output_name);
-
-    let video_codec = &self.config.get_string("transcoder.video_codec").unwrap();
-    info!("Transcoding {} to {} with the {} encoder.", ingest_file.display(), output_file.display(), video_codec);
-
-    let cmd_output = process::Command::new("/usr/bin/ffmpeg")
-      .arg("-i")        .arg(&*ingest_file.to_string_lossy())
-      .arg("-y")
-      .arg("-f")        .arg(&video_format)
-      .arg("-c:v")      .arg(&video_codec)
-      .arg("-s")        .arg(&self.config.get_string("transcoder.video_resolution").unwrap())
-      .arg("-r")        .arg(format!("{}", self.config.get_string("transcoder.video_framerate").unwrap()))
-      .arg("-vf")       .arg(format!("format={}", &self.config.get_string("transcoder.video_color").unwrap()))
-      .arg("-profile:v").arg(&self.config.get_string("transcoder.video_profile").unwrap())
-      .arg("-c:a")      .arg(&self.config.get_string("transcoder.audio_codec").unwrap())
-      .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);
-    debug!("{}", results_raw);
-  }
-}

src/util.ts

@@ -0,0 +1,11 @@
+import path from 'path';
+
+export function resolveTilde(filepath: string): string {
+  // if the first character is a tilde, replace it with the user's home
+  if (filepath[0] === '~') {
+    return path.join(process.env.HOME, filepath.slice(1));
+  }
+
+  // return the path untouched
+  return filepath;
+}

src/util/io.rs

@@ -1,61 +0,0 @@
-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

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