added common flags and refactored some code

1 files changed, 77 insertions, 33 deletions

diff --git a/fctdrive/src/main.rs b/fctdrive/src/main.rs
index 1d1e174..4f8f85f 100644
--- a/fctdrive/src/main.rs
+++ b/fctdrive/src/main.rs
@@ -659,6 +659,12 @@ struct Cli {
     cmd: Cmd,
 }
 
+#[derive(Debug, Parser)]
+struct CliCommon {
+    #[clap(long, default_value = "./", env = "FCTDRIVE_PATH")]
+    drive: PathBuf,
+}
+
 #[derive(Debug, Subcommand)]
 enum Cmd {
     CreateFile(CreateFileArgs),
@@ -671,6 +677,9 @@ enum Cmd {
 
 #[derive(Debug, Args)]
 struct CreateFileArgs {
+    #[clap(flatten)]
+    common: CliCommon,
+
     #[clap(long)]
     timestamp: Option<u64>,
 
@@ -686,6 +695,9 @@ struct CreateFileArgs {
 
 #[derive(Debug, Args)]
 struct CreateDirArgs {
+    #[clap(flatten)]
+    common: CliCommon,
+
     #[clap(long)]
     timestamp: Option<u64>,
 
@@ -698,6 +710,9 @@ struct CreateDirArgs {
 
 #[derive(Debug, Args)]
 struct RemoveArgs {
+    #[clap(flatten)]
+    common: CliCommon,
+
     #[clap(long)]
     timestamp: Option<u64>,
 
@@ -710,6 +725,9 @@ struct RemoveArgs {
 
 #[derive(Debug, Args)]
 struct RenameArgs {
+    #[clap(flatten)]
+    common: CliCommon,
+
     #[clap(long)]
     timestamp: Option<u64>,
 
@@ -725,6 +743,9 @@ struct RenameArgs {
 
 #[derive(Debug, Args)]
 struct LsArgs {
+    #[clap(flatten)]
+    common: CliCommon,
+
     #[clap(short, long)]
     recursive: bool,
 
@@ -733,6 +754,9 @@ struct LsArgs {
 
 #[derive(Debug, Args)]
 struct ImportArgs {
+    #[clap(flatten)]
+    common: CliCommon,
+
     #[clap(long)]
     timestamp: Option<u64>,
 
@@ -757,11 +781,11 @@ fn main() {
 
 fn cmd_create_file(args: CreateFileArgs) {
     let file_blob_id = blob_hash_file(&args.file).unwrap();
-    let _lock = write_lock();
 
+    let _lock = common_write_lock(&args.common);
     let mut fs = Fs::default();
-    let mut ops = read_log_file();
-    let store = BlobStore::new("blobs");
+    let mut ops = common_read_log_file(&args.common);
+    let store = common_create_blob_store(&args.common);
     ops.iter().for_each(|op| apply(&mut fs, op).unwrap());
 
     let timestamp = args.timestamp.unwrap_or_else(get_timestamp);
@@ -781,13 +805,13 @@ fn cmd_create_file(args: CreateFileArgs) {
     };
     apply(&mut fs, &new_op).unwrap();
     ops.push(new_op);
-    write_log_file(&ops);
+    common_write_log_file(&args.common, &ops);
 }
 
 fn cmd_create_dir(args: CreateDirArgs) {
-    let _lock = write_lock();
+    let _lock = common_write_lock(&args.common);
     let mut fs = Fs::default();
-    let mut ops = read_log_file();
+    let mut ops = common_read_log_file(&args.common);
     ops.iter().for_each(|op| apply(&mut fs, op).unwrap());
 
     let timestamp = args.timestamp.unwrap_or_else(get_timestamp);
@@ -803,13 +827,13 @@ fn cmd_create_dir(args: CreateDirArgs) {
     };
     apply(&mut fs, &new_op).unwrap();
     ops.push(new_op);
-    write_log_file(&ops);
+    common_write_log_file(&args.common, &ops);
 }
 
 fn cmd_remove(args: RemoveArgs) {
-    let _lock = write_lock();
+    let _lock = common_write_lock(&args.common);
     let mut fs = Fs::default();
-    let mut ops = read_log_file();
+    let mut ops = common_read_log_file(&args.common);
     ops.iter().for_each(|op| apply(&mut fs, op).unwrap());
 
     let timestamp = args.timestamp.unwrap_or_else(get_timestamp);
@@ -825,13 +849,13 @@ fn cmd_remove(args: RemoveArgs) {
     };
     apply(&mut fs, &new_op).unwrap();
     ops.push(new_op);
-    write_log_file(&ops);
+    common_write_log_file(&args.common, &ops);
 }
 
 fn cmd_rename(args: RenameArgs) {
-    let _lock = write_lock();
+    let _lock = common_write_lock(&args.common);
     let mut fs = Fs::default();
-    let mut ops = read_log_file();
+    let mut ops = common_read_log_file(&args.common);
     ops.iter().for_each(|op| apply(&mut fs, op).unwrap());
 
     let timestamp = args.timestamp.unwrap_or_else(get_timestamp);
@@ -851,7 +875,7 @@ fn cmd_rename(args: RenameArgs) {
 
     apply(&mut fs, &new_op).unwrap();
     ops.push(new_op);
-    write_log_file(&ops);
+    common_write_log_file(&args.common, &ops);
 }
 
 type FsNodeWriter<'a> = std::io::BufWriter<std::io::StdoutLock<'a>>;
@@ -860,7 +884,7 @@ fn cmd_ls(args: LsArgs) {
     let stdout = std::io::stdout().lock();
     let mut writer = BufWriter::new(stdout);
     let mut fs = Fs::default();
-    let ops = read_log_file();
+    let ops = common_read_log_file(&args.common);
     ops.iter().for_each(|op| apply(&mut fs, op).unwrap());
     let node_id = match args.path {
         Some(path) => find_node(&fs, &path),
@@ -941,9 +965,9 @@ impl<T> Queue<T> {
 }
 
 fn cmd_import(args: ImportArgs) {
-    let _lock = write_lock();
+    let _lock = common_write_lock(&args.common);
 
-    let mut ops = read_log_file();
+    let mut ops = common_read_log_file(&args.common);
 
     let store = BlobStore::new("blobs");
     let timestamp = args.timestamp.unwrap_or_else(get_timestamp);
@@ -993,7 +1017,7 @@ fn cmd_import(args: ImportArgs) {
         ops.extend(task_ops);
     }
     ops.iter().for_each(|op| apply(&mut fs, op).unwrap());
-    write_log_file(&ops);
+    common_write_log_file(&args.common, &ops);
 }
 
 fn collect_all_file_paths(root: &Path) -> Vec<PathBuf> {
@@ -1013,10 +1037,23 @@ fn collect_all_file_paths(root: &Path) -> Vec<PathBuf> {
     files
 }
 
-fn read_log_file() -> Vec<Operation> {
+fn common_create_blob_store(common: &CliCommon) -> BlobStore {
+    BlobStore::new(common.drive.join("blobs"))
+}
+
+fn common_log_file_path(common: &CliCommon) -> PathBuf {
+    common.drive.join("log.txt")
+}
+
+fn common_log_temp_file_path(common: &CliCommon) -> PathBuf {
+    common.drive.join("log.txt.tmp")
+}
+
+fn common_read_log_file(common: &CliCommon) -> Vec<Operation> {
+    let log_file_path = common_log_file_path(common);
     let mut operations = Vec::default();
-    if std::fs::exists("log.txt").unwrap() {
-        let contents = std::fs::read_to_string("log.txt").unwrap();
+    if std::fs::exists(&log_file_path).unwrap() {
+        let contents = std::fs::read_to_string(&log_file_path).unwrap();
         for line in contents.lines() {
             let operation = line.parse().unwrap();
             operations.push(operation);
@@ -1025,13 +1062,15 @@ fn read_log_file() -> Vec<Operation> {
     operations
 }
 
-fn write_log_file(ops: &[Operation]) {
+fn common_write_log_file(common: &CliCommon, ops: &[Operation]) {
+    let log_file_path = common_log_file_path(common);
+    let log_temp_file_path = common_log_temp_file_path(common);
     {
         let file = File::options()
             .create(true)
             .write(true)
             .truncate(true)
-            .open("log.txt.tmp")
+            .open(&log_temp_file_path)
             .unwrap();
         let mut writer = BufWriter::new(file);
         for op in ops {
@@ -1039,7 +1078,22 @@ fn write_log_file(ops: &[Operation]) {
         }
         writer.flush().unwrap();
     }
-    std::fs::rename("log.txt.tmp", "log.txt").unwrap();
+    std::fs::rename(&log_temp_file_path, &log_file_path).unwrap();
+}
+
+fn common_write_lock_path(common: &CliCommon) -> PathBuf {
+    common.drive.join("write.lock")
+}
+
+fn common_write_lock(common: &CliCommon) -> File {
+    let lock_path = common_write_lock_path(common);
+    let file = std::fs::OpenOptions::new()
+        .write(true)
+        .create(true)
+        .open(lock_path)
+        .unwrap();
+    file.lock().unwrap();
+    file
 }
 
 fn get_timestamp() -> u64 {
@@ -1055,13 +1109,3 @@ fn get_next_revision(ops: &[Operation]) -> u64 {
         None => 0,
     }
 }
-
-fn write_lock() -> File {
-    let file = std::fs::OpenOptions::new()
-        .write(true)
-        .create(true)
-        .open("write.lock")
-        .unwrap();
-    file.lock().unwrap();
-    file
-}