separated the http proxy and zinit itself. 2 separate binaries now

maximevanhees · maximevanhees · commit c86e96a6cb6a · 2025-04-10T14:26:03.000+02:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -37,4 +37,7 @@ path = "src/main.rs"
 [[bin]]
 name = "testapp"
 path = "src/bin/testapp.rs"
+[[bin]]
+name = "zinit-http"
+path = "src/bin/zinit-http.rs"
 
diff --git a/README.md b/README.md
@@ -1,3 +1,61 @@
+# Zinit - A Process Manager
+
+Zinit is a process manager designed to manage services and their lifecycle. It provides both a Unix socket interface and an HTTP API for interacting with the process manager.
+
+## Components
+
+Zinit now consists of two separate binaries:
+
+1. **zinit** - The core process manager that handles service lifecycle management
+2. **zinit-http** - An HTTP proxy that forwards JSON-RPC requests to the Zinit Unix socket
+
+This separation allows for more flexibility and reduced resource usage when the HTTP API is not needed.
+
+## Usage
+
+### Process Manager (zinit)
+
+```bash
+# Run zinit in init mode
+zinit init --config /etc/zinit/ --socket /var/run/zinit.sock
+
+# List services
+zinit list
+
+# Start a service
+zinit start <service-name>
+
+# Stop a service
+zinit stop <service-name>
+```
+
+### HTTP Proxy (zinit-http)
+
+```bash
+# Start the HTTP proxy on the default port (8080)
+zinit-http --socket /var/run/zinit.sock
+
+# Start the HTTP proxy on a custom port
+zinit-http --socket /var/run/zinit.sock --port 3000
+```
+
+## JSON-RPC API
+
+The HTTP proxy provides a JSON-RPC 2.0 API for interacting with Zinit. You can send JSON-RPC requests to the HTTP endpoint:
+
+```bash
+curl -X POST -H "Content-Type: application/json" -d '{"jsonrpc":"2.0","id":1,"method":"service.list","params":{}}' http://localhost:8080/
+```
+
+## Building from Source
+
+```bash
+# Build both binaries
+cargo build --release
+
+# The binaries will be available in target/release/
+```
+
 # Zinit [![Rust](https://github.com/threefoldtech/zinit/actions/workflows/rust.yml/badge.svg)](https://github.com/threefoldtech/zinit/actions/workflows/rust.yml)
 
 A lightweight PID 1 replacement inspired by runit, written in Rust using Tokio for async I/O.
diff --git a/docker/Dockerfile b/docker/Dockerfile
@@ -2,5 +2,6 @@ FROM ubuntu:18.04
 
 RUN mkdir -p /etc/zinit
 ADD zinit /sbin/zinit
+ADD zinit-http /sbin/zinit-http
 
 ENTRYPOINT ["/sbin/zinit", "init"] 
diff --git a/src/app/api.rs b/src/app/api.rs
@@ -96,185 +96,22 @@ pub struct Status {
 pub struct Api {
     zinit: ZInit,
     socket: PathBuf,
-    http_port: Option<u16>,
+    // http_port removed as it's now in a separate binary
 }
 
 impl Api {
-    pub fn new<P: AsRef<Path>>(zinit: ZInit, socket: P, http_port: Option<u16>) -> Api {
+    pub fn new<P: AsRef<Path>>(zinit: ZInit, socket: P, _http_port: Option<u16>) -> Api {
+        // _http_port parameter kept for backward compatibility but not used
         Api {
             zinit,
             socket: socket.as_ref().to_path_buf(),
-            http_port,
         }
     }
 
-    // Serve HTTP proxy for JSON-RPC API
-    async fn serve_http(port: u16, zinit: ZInit) -> Result<()> {
-        // Handle JSON-RPC requests
-        async fn handle_json_rpc(
-            body: Bytes,
-            zinit: ZInit,
-        ) -> Result<Response, (StatusCode, String)> {
-            // Process the JSON-RPC request
-            let request: JsonRpcRequest = serde_json::from_slice(&body).map_err(|e| {
-                (
-                    StatusCode::BAD_REQUEST,
-                    format!("Invalid JSON-RPC request: {}", e),
-                )
-            })?;
-
-            // We can't use Api::process_jsonrpc directly from an inner function
-            // So we'll manually create a JsonRpcResponse
-            let id = request.id.unwrap_or(Value::Null);
-            let method = request.method.clone();
-            let params = request.params.clone();
-
-            // Serialize the request parameters for the Unix socket
-            let response_bytes = match method.as_str() {
-                "rpc.discover" => {
-                    // For discover, we can directly return the OpenRPC spec
-                    let spec: Value = match serde_json::from_str(OPENRPC_SPEC) {
-                        Ok(value) => value,
-                        Err(err) => {
-                            return Err((
-                                StatusCode::INTERNAL_SERVER_ERROR,
-                                format!("Failed to parse OpenRPC spec: {}", err),
-                            ));
-                        }
-                    };
-
-                    let response = JsonRpcResponse {
-                        jsonrpc: "2.0".to_string(),
-                        id,
-                        result: Some(spec),
-                        error: None,
-                    };
-
-                    serde_json::to_vec(&response).map_err(|e| {
-                        (
-                            StatusCode::INTERNAL_SERVER_ERROR,
-                            format!("Failed to serialize response: {}", e),
-                        )
-                    })?
-                }
-                _ => {
-                    // For other methods, create a new JSON-RPC request to send to the Unix socket
-                    let unix_request = JsonRpcRequest {
-                        jsonrpc: "2.0".to_string(),
-                        id: Some(id.clone()),
-                        method,
-                        params,
-                    };
-
-                    // Serialize the request
-                    let request_bytes = serde_json::to_vec(&unix_request).map_err(|e| {
-                        (
-                            StatusCode::INTERNAL_SERVER_ERROR,
-                            format!("Failed to serialize request: {}", e),
-                        )
-                    })?;
-
-                    // Create a Unix socket connection
-                    let mut socket =
-                        UnixStream::connect("/var/run/zinit.sock")
-                            .await
-                            .map_err(|e| {
-                                (
-                                    StatusCode::INTERNAL_SERVER_ERROR,
-                                    format!("Failed to connect to Zinit socket: {}", e),
-                                )
-                            })?;
-
-                    // Send the request
-                    socket.write_all(&request_bytes).await.map_err(|e| {
-                        (
-                            StatusCode::INTERNAL_SERVER_ERROR,
-                            format!("Failed to write to Zinit socket: {}", e),
-                        )
-                    })?;
-
-                    socket.write_all(b"\n").await.map_err(|e| {
-                        (
-                            StatusCode::INTERNAL_SERVER_ERROR,
-                            format!("Failed to write newline to Zinit socket: {}", e),
-                        )
-                    })?;
-
-                    // Read the response
-                    let mut response_data = Vec::new();
-                    socket.read_to_end(&mut response_data).await.map_err(|e| {
-                        (
-                            StatusCode::INTERNAL_SERVER_ERROR,
-                            format!("Failed to read from Zinit socket: {}", e),
-                        )
-                    })?;
-
-                    response_data
-                }
-            };
-
-            // Create response with CORS headers
-            let mut headers = HeaderMap::new();
-            headers.insert("Content-Type", "application/json".parse().unwrap());
-            headers.insert("Access-Control-Allow-Origin", "*".parse().unwrap());
-            headers.insert(
-                "Access-Control-Allow-Methods",
-                "POST, OPTIONS".parse().unwrap(),
-            );
-            headers.insert(
-                "Access-Control-Allow-Headers",
-                "Content-Type".parse().unwrap(),
-            );
-
-            // Return the response
-            Ok((headers, Bytes::from(response_bytes)).into_response())
-        }
-
-        // Handle OPTIONS requests for CORS
-        async fn handle_cors() -> Response {
-            // Create response with CORS headers
-            let mut headers = HeaderMap::new();
-            headers.insert("Access-Control-Allow-Origin", "*".parse().unwrap());
-            headers.insert(
-                "Access-Control-Allow-Methods",
-                "POST, OPTIONS".parse().unwrap(),
-            );
-            headers.insert(
-                "Access-Control-Allow-Headers",
-                "Content-Type".parse().unwrap(),
-            );
-
-            (headers, "").into_response()
-        }
-
-        // Build the router
-        let app = Router::new()
-            .route(
-                "/",
-                post(move |body: Bytes| handle_json_rpc(body, zinit.clone())),
-            )
-            .route("/", options(handle_cors));
-
-        // Run the server
-        let addr = SocketAddr::from(([0, 0, 0, 0], port));
-        info!("Zinit HTTP proxy listening on http://{}", addr);
-
-        let listener = TcpListener::bind(addr).await?;
-        axum::serve(listener, app).await?;
-
-        Ok(())
-    }
+    // HTTP proxy functionality has been moved to a separate binary (zinit-http)
 
     pub async fn serve(&self) -> Result<()> {
-        // Start HTTP proxy server if http_port is provided
-        if let Some(port) = self.http_port {
-            let zinit_clone = self.zinit.clone();
-            tokio::spawn(async move {
-                if let Err(e) = Self::serve_http(port, zinit_clone).await {
-                    error!("HTTP proxy server error: {}", e);
-                }
-            });
-        }
+        // HTTP proxy functionality has been moved to a separate binary (zinit-http)
 
         // Start Unix socket server
         let listener = UnixListener::bind(&self.socket).context("failed to listen for socket")?;
diff --git a/src/app/mod.rs b/src/app/mod.rs
@@ -47,7 +47,6 @@ pub async fn init(
     socket: &str,
     container: bool,
     debug: bool,
-    http_port: Option<u16>,
 ) -> Result<()> {
     //std::fs::create_dir_all(config)?;
     if let Err(err) = logger(if debug {
@@ -87,7 +86,7 @@ pub async fn init(
             error!("failed to monitor service {}: {}", k, err);
         };
     }
-    let a = api::Api::new(init, socket, http_port);
+    let a = api::Api::new(init, socket, None); // HTTP proxy is now a separate binary
     a.serve().await?;
     Ok(())
 }
diff --git a/src/bin/zinit-http.rs b/src/bin/zinit-http.rs
diff --git a/src/main.rs b/src/main.rs
