Directly call binary to start server

harness/src/build.rs

@@ -26,15 +26,13 @@
 
 use crate::util;
 use crate::HarnessResult;
-use std::{
-    path::{Path, PathBuf},
-    process::Command,
-};
+use std::{path::PathBuf, process::Command};
 
 /// The binaries that will be present in a bundle
 pub const BINARIES: [&str; 4] = ["skyd", "sky-bench", "skysh", "sky-migrate"];
 
 /// The build mode
+#[derive(Copy, Clone)]
 pub enum BuildMode {
     Debug,
     Release,
@@ -59,20 +57,11 @@ impl ToString for BuildMode {
     }
 }
 
-/// Returns `{body}/{binary_name}(.exe if on windows)`
-fn concat_path(binary_name: &str, body: impl AsRef<Path>) -> PathBuf {
-    let mut pb = PathBuf::from(body.as_ref());
-    #[cfg(windows)]
-    let binary_name = format!("{}.exe", binary_name);
-    pb.push(binary_name);
-    pb
-}
-
 /// Returns the paths of the files for the given target folder
 pub fn get_files_index(target_folder: &PathBuf) -> Vec<PathBuf> {
     let mut paths = Vec::with_capacity(3);
     for binary in BINARIES {
-        paths.push(concat_path(binary, target_folder));
+        paths.push(util::concat_path(binary, target_folder));
     }
     paths
 }
@@ -80,16 +69,14 @@ pub fn get_files_index(target_folder: &PathBuf) -> Vec<PathBuf> {
 /// Runs `cargo build` with the provided mode. `TARGET` is handled automatically
 pub fn build(mode: BuildMode) -> HarnessResult<PathBuf> {
     let mut build_args = vec!["build".to_owned()];
-    let mut target_folder = PathBuf::from("target");
+    let target_folder = util::get_target_folder(mode);
     match util::get_var(util::VAR_TARGET) {
         Some(t) => {
             build_args.push("--target".to_owned());
             build_args.push(t.to_string());
-            target_folder.push(&t);
         }
         None => {}
     };
-    target_folder.push(mode.to_string());
 
     // assemble build args
     for binary in BINARIES {

harness/src/cli.rs

@@ -41,6 +41,7 @@ SUBCOMMANDS:
     bundle  Build the bundle\
 ";
 
+#[derive(Copy, Clone)]
 pub enum HarnessWhat {
     Test,
     Bundle(BuildMode),
@@ -75,6 +76,13 @@ impl HarnessWhat {
         };
         Ok(ret)
     }
+    pub fn description(&self) -> String {
+        match self {
+            HarnessWhat::Test => "test suite".to_owned(),
+            HarnessWhat::Bundle(mode) => format!("{} bundle", mode.to_string()),
+            HarnessWhat::LinuxPackage(pkg) => format!("Linux package {}", pkg.to_string()),
+        }
+    }
 }
 
 fn display_help() -> ! {

harness/src/linuxpkg.rs

@@ -30,6 +30,7 @@ use libsky::VERSION;
 use std::process::Command;
 
 /// The Linux package type
+#[derive(Copy, Clone)]
 pub enum LinuxPackageType {
     /// Debian packages
     Deb,
@@ -57,6 +58,14 @@ impl LinuxPackageType {
     }
 }
 
+impl ToString for LinuxPackageType {
+    fn to_string(&self) -> String {
+        match self {
+            Self::Deb => "deb".to_owned(),
+        }
+    }
+}
+
 /// Creates a Linux package for the provided Linux package type
 pub fn create_linuxpkg(package_type: LinuxPackageType) -> HarnessResult<()> {
     info!("Building binaries for Linux package");

harness/src/main.rs

@@ -47,7 +47,7 @@ fn main() {
         .parse_filters(&env::var("SKYHARNESS_LOG").unwrap_or_else(|_| "info".to_owned()))
         .init();
     if let Err(e) = runner() {
-        eprintln!("harness failed with: {}", e);
+        error!("harness failed with: {}", e);
         process::exit(0x01);
     }
 }
@@ -60,5 +60,9 @@ fn runner() -> HarnessResult<()> {
         HarnessWhat::Bundle(bundle_mode) => bundle::bundle(bundle_mode)?,
         HarnessWhat::LinuxPackage(pkg) => linuxpkg::create_linuxpkg(pkg)?,
     }
+    info!(
+        "Successfully finished running harness for {}",
+        harness.description()
+    );
     Ok(())
 }

harness/src/test.rs

@@ -24,7 +24,7 @@
  *
 */
 
-use crate::{util, HarnessError, HarnessResult};
+use crate::{build::BuildMode, util, HarnessError, HarnessResult};
 use openssl::{
     asn1::Asn1Time,
     bn::{BigNum, MsbOption},
@@ -39,10 +39,11 @@ use openssl::{
 };
 use std::fs;
 use std::io::Write;
-use std::process::Child;
-use std::process::Command;
 #[cfg(windows)]
 use std::os::windows::process::CommandExt;
+use std::path::{Path, PathBuf};
+use std::process::Child;
+use std::process::Command;
 
 /// The workspace root
 const WORKSPACE_ROOT: &str = env!("ROOT_DIR");
@@ -54,12 +55,14 @@ const POWERSHELL_SCRIPT: &str = include_str!("../../ci/windows/stop.ps1");
 const CREATE_NEW_CONSOLE: u32 = 0x00000010;
 
 /// Get the command to start the provided server1
-pub fn get_run_server_cmd(server_id: &'static str, cmd_payload: &[String]) -> Command {
-    let mut cmd = Command::new("cargo");
-    cmd.args(cmd_payload);
-    cmd.arg("--");
+pub fn get_run_server_cmd(server_id: &'static str, target_folder: impl AsRef<Path>) -> Command {
+    let cfg_file_path = PathBuf::from(format!("{WORKSPACE_ROOT}ci/{server_id}.toml"));
+    let binpath = util::concat_path("skyd", target_folder)
+        .to_string_lossy()
+        .to_string();
+    let mut cmd = Command::new(binpath);
     cmd.arg("--withconfig");
-    cmd.arg(format!("{WORKSPACE_ROOT}ci/{server_id}.toml"));
+    cmd.arg(cfg_file_path);
     cmd.current_dir(server_id);
     #[cfg(windows)]
     cmd.creation_flags(CREATE_NEW_CONSOLE);
@@ -106,7 +109,9 @@ fn kill_servers_inner() -> HarnessResult<()> {
 /// Run the test suite
 pub fn run_test() -> HarnessResult<()> {
     let ret = run_test_inner();
-    kill_servers()?;
+    if let Err(e) = kill_servers() {
+        error!("Failed to kill servers with error: {e}");
+    }
 
     // clean up
     fs::remove_dir_all("server1").map_err(|e| {
@@ -139,14 +144,12 @@ fn run_test_inner() -> HarnessResult<()> {
     })?;
 
     // assemble commands
-    let mut cmd: Vec<String> = vec!["run".to_string(), "-p".to_string(), "skyd".to_string()];
+    let target_folder = util::get_target_folder(BuildMode::Debug);
     let standard_test_suite;
     let persist_test_suite;
     let build_cmd;
     match util::get_var(util::VAR_TARGET) {
         Some(target) => {
-            cmd.push("--target".into());
-            cmd.push(target.to_string());
             standard_test_suite = cmd!("cargo", "test", "--target", &target);
             persist_test_suite = cmd!(
                 "cargo",
@@ -171,8 +174,8 @@ fn run_test_inner() -> HarnessResult<()> {
 
     // start the servers, run tests and kill
     info!("Starting servers ...");
-    let s1_cmd = get_run_server_cmd("server1", &cmd);
-    let s2_cmd = get_run_server_cmd("server2", &cmd);
+    let s1_cmd = get_run_server_cmd("server1", &target_folder);
+    let s2_cmd = get_run_server_cmd("server2", &target_folder);
     let (_s1, _s2) = start_servers(s1_cmd, s2_cmd)?;
     info!("All servers started. Now running standard test suite ...");
     util::handle_child("standard test suite", standard_test_suite)?;
@@ -180,8 +183,8 @@ fn run_test_inner() -> HarnessResult<()> {
 
     // start server up again, run tests and kill
     info!("Starting servers ...");
-    let s1_cmd = get_run_server_cmd("server1", &cmd);
-    let s2_cmd = get_run_server_cmd("server2", &cmd);
+    let s1_cmd = get_run_server_cmd("server1", &target_folder);
+    let s2_cmd = get_run_server_cmd("server2", &target_folder);
     let (_s1, _s2) = start_servers(s1_cmd, s2_cmd)?;
     info!("All servers started. Now running persistence test suite ...");
     util::handle_child("standard test suite", persist_test_suite)?;

harness/src/util.rs

@@ -24,16 +24,19 @@
  *
 */
 
+use crate::build::BuildMode;
 use crate::process::ExitStatus;
 use crate::{HarnessError, HarnessResult};
 use std::env;
 use std::io::Result as IoResult;
+use std::path::{Path, PathBuf};
 use std::process::Child;
 use std::process::Command;
 pub type ExitCode = Option<i32>;
 
 pub const VAR_TARGET: &str = "TARGET";
 pub const VAR_ARTIFACT: &str = "ARTIFACT";
+pub const WORKSPACE_ROOT: &str = env!("ROOT_DIR");
 
 pub fn get_var(var: &str) -> Option<String> {
     env::var_os(var).map(|v| v.to_string_lossy().to_string())
@@ -72,6 +75,22 @@ pub fn sleep_sec(secs: u64) {
     std::thread::sleep(std::time::Duration::from_secs(secs))
 }
 
+pub fn get_target_folder(mode: BuildMode) -> PathBuf {
+    match env::var_os(VAR_TARGET).map(|v| v.to_string_lossy().to_string()) {
+        Some(target) => format!("{WORKSPACE_ROOT}/target/{target}/{}", mode.to_string()).into(),
+        None => format!("{WORKSPACE_ROOT}/target/{}", mode.to_string()).into(),
+    }
+}
+
+/// Returns `{body}/{binary_name}(.exe if on windows)`
+pub fn concat_path(binary_name: &str, body: impl AsRef<Path>) -> PathBuf {
+    let mut pb = PathBuf::from(body.as_ref());
+    #[cfg(windows)]
+    let binary_name = format!("{}.exe", binary_name);
+    pb.push(binary_name);
+    pb
+}
+
 #[macro_export]
 macro_rules! cmd {
     ($base:expr, $($cmd:expr),*) => {{