...

Author: despiegk

Cargo.lock

@@ -26,6 +26,7 @@ thiserror = "1.0"
 clap = "2.33"
 git-version = "0.3.5"
 command-group = "1.0.8"
+dirs = "5.0"
 hyper = "1.6"
 # axum = { version = "0.7.4", features = ["http1"] }
 bytes = "1.0"
@@ -46,4 +47,3 @@ path = "src/lib.rs"
 [[bin]]
 name = "zinit"
 path = "src/main.rs"
-

Cargo.toml

@@ -0,0 +1,70 @@
+# macOS Installation Guide for Cross-Compilation to aarch64-unknown-linux-musl
+
+This guide outlines the steps to set up your macOS environment for cross-compiling Rust projects to the `aarch64-unknown-linux-musl` target. This is particularly useful for building binaries that can run on ARM-based Linux systems (e.g., Raspberry Pi, AWS Graviton) using musl libc.
+
+## Prerequisites
+
+*   Homebrew (https://brew.sh/) installed on your macOS system.
+*   Rust and Cargo installed (e.g., via `rustup`).
+
+## Step 1: Install the `aarch64-linux-musl-gcc` Toolchain
+
+The `aarch64-linux-musl-gcc` toolchain is required for linking when cross-compiling to `aarch64-unknown-linux-musl`. You can install it using Homebrew:
+
+```bash
+brew install messense/macos-cross-toolchains/aarch64-linux-musl-cross
+```
+
+## Step 2: Link `musl-gcc`
+
+Some build scripts or tools might look for `musl-gcc`. To ensure compatibility, create a symbolic link:
+
+```bash
+sudo ln -s /opt/homebrew/bin/aarch64-linux-musl-gcc /opt/homebrew/bin/musl-gcc
+```
+
+You might be prompted for your system password to complete this operation.
+
+## Step 3: Add the Rust Target
+
+Add the `aarch64-unknown-linux-musl` target to your Rust toolchain:
+
+```bash
+rustup target add aarch64-unknown-linux-musl
+```
+
+## Step 4: Build Your Project
+
+Now you can build your Rust project for the `aarch64-unknown-linux-musl` target using Cargo:
+
+```bash
+cargo build --release --target aarch64-unknown-linux-musl
+```
+
+Alternatively, if you are using the provided `Makefile`, you can use the new target:
+
+```bash
+make release-aarch64-musl
+```
+
+This will produce a release binary located in `target/aarch64-unknown-linux-musl/release/`.
+
+## Step 5: Running Zinit
+
+After building, you can run `zinit`. First, you need to start the `zinit` daemon using the `init` subcommand. On macOS, `zinit` will now default to using `~/hero/cfg/zinit` as its configuration directory. This will create the Unix socket at `/tmp/zinit.sock` and start managing services.
+
+Once the directory is created (if it doesn't exist, `zinit` will create it automatically), you can run the `init` command:
+
+```bash
+/path/to/your/zinit init
+```
+
+Replace `/path/to/your/zinit` with the actual path to your compiled `zinit` binary (e.g., `~/hero/bin/zinit` if you copied it there).
+
+Once the daemon is running, you can interact with it using other `zinit` commands. For example, to list services:
+
+```bash
+/path/to/your/zinit list
+```
+
+If you encounter a "failed to connect to socket" error, ensure that the `zinit init` command is running in the background.

osx_install.md

@@ -58,7 +58,9 @@ pub async fn init(
     container: bool,
     debug: bool,
 ) -> Result<ApiServer> {
-    //std::fs::create_dir_all(config)?;
+    fs::create_dir_all(config)
+        .await
+        .with_context(|| format!("failed to create config directory '{}'", config))?;
     if let Err(err) = logger(if debug {
         log::LevelFilter::Debug
     } else {

src/app/mod.rs

@@ -15,7 +15,7 @@ async fn main() -> Result<()> {
         .author("ThreeFold Tech, https://github.com/threefoldtech")
         .version(GIT_VERSION)
         .about("A runit replacement")
-        .arg(Arg::with_name("socket").value_name("SOCKET").short("s").long("socket").default_value("/var/run/zinit.sock").help("path to unix socket"))
+        .arg(Arg::with_name("socket").value_name("SOCKET").short("s").long("socket").default_value("/tmp/zinit.sock").help("path to unix socket"))
         .arg(Arg::with_name("debug").short("d").long("debug").help("run in debug mode"))
         .subcommand(
             SubCommand::with_name("init")
@@ -24,8 +24,7 @@ async fn main() -> Result<()> {
                         .value_name("DIR")
                         .short("c")
                         .long("config")
-                        .help("service configurations directory")
-                        .default_value("/etc/zinit/"),
+                        .help("service configurations directory"),
                 )
                 .arg(
                     Arg::with_name("buffer")
@@ -158,14 +157,30 @@ async fn main() -> Result<()> {
         )
         .get_matches();
 
+use dirs; // Add this import
+
     let socket = matches.value_of("socket").unwrap();
     let debug = matches.is_present("debug");
-    //let debug = true;
+
+    let config_path = if let Some(config_arg) = matches.value_of("config") {
+        config_arg.to_string()
+    } else {
+        #[cfg(target_os = "macos")]
+        {
+            let home_dir = dirs::home_dir().ok_or_else(|| anyhow::anyhow!("Could not determine home directory"))?;
+            home_dir.join("hero").join("cfg").join("zinit").to_str().ok_or_else(|| anyhow::anyhow!("Invalid path for config directory"))?.to_string()
+        }
+        #[cfg(not(target_os = "macos"))]
+        {
+            "/etc/zinit/".to_string()
+        }
+    };
+
     let result = match matches.subcommand() {
         ("init", Some(matches)) => {
             let _server = app::init(
                 matches.value_of("buffer").unwrap().parse().unwrap(),
-                matches.value_of("config").unwrap(),
+                &config_path, // Use the determined config_path
                 socket,
                 matches.is_present("container"),
                 debug,