fixed path handling issue; looking for services only happens in passed configuration directory

Author: maximevanhees

src/app/client.rs

@@ -104,16 +104,25 @@ impl Client {
         let data = String::from_utf8(buffer)?;
         let data = data.trim_end();
 
-        // Parse the JSON-RPC response
-        let response: JsonRpcResponse = encoder::from_str(data)?;
+        // Parse the JSON-RPC response - improved error handling
+        let response: JsonRpcResponse = match encoder::from_str(&data) {
+            Ok(response) => response,
+            Err(e) => {
+                // If we can't parse the response as JSON-RPC, this is an error
+                error!("Failed to parse JSON-RPC response: {}", e);
+                error!("Raw response: {}", data);
+                bail!("Invalid response from server: failed to parse JSON-RPC")
+            }
+        };
 
-        // Handle the response
+        // Handle the response according to JSON-RPC 2.0 spec
         if let Some(error) = response.error {
+            // Error response - has 'error' field
             bail!("RPC error ({}): {}", error.code, error.message);
-        } else if let Some(result) = response.result {
-            Ok(result)
         } else {
-            bail!("Invalid JSON-RPC response: missing both result and error");
+            // Success response - return result (which might be null)
+            // This properly handles all success responses including null values
+            Ok(response.result.unwrap_or(Value::Null))
         }
     }
 

src/app/server.rs

@@ -87,18 +87,28 @@ pub struct Status {
 pub struct Api {
     zinit: ZInit,
     socket: PathBuf,
-    // http_port removed as it's now in a separate binary
+    config_dir: PathBuf,  // Configuration directory path
 }
 
 impl 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
+        // Default to /etc/zinit if not specified
+        let config_dir = PathBuf::from("/etc/zinit");
+        
         Api {
             zinit,
             socket: socket.as_ref().to_path_buf(),
+            config_dir,
         }
     }
 
+    // Add a way to explicitly set the config directory
+    pub fn with_config_dir<P: AsRef<Path>>(mut self, config_dir: P) -> Self {
+        self.config_dir = config_dir.as_ref().to_path_buf();
+        self
+    }
+
     // HTTP proxy functionality has been moved to a separate binary (zinit-http)
 
     pub async fn serve(&self) -> Result<()> {
@@ -625,8 +635,11 @@ impl Api {
     }
 
     async fn monitor<S: AsRef<str>>(name: S, zinit: ZInit) -> Result<Value> {
+        // Use the existing working directory which should be set to the config dir
+        // when Zinit is started with the -c flag (default /etc/zinit)
         let (name, service) = config::load(format!("{}.yaml", name.as_ref()))
             .context("failed to load service config")?;
+        
         zinit.monitor(name, service).await?;
         Ok(Value::Null)
     }
@@ -712,11 +725,11 @@ impl Api {
             bail!("Invalid service name: must not contain '/', '\\', or '.'");
         }
 
-        // Construct the file path
-        let file_path = PathBuf::from(format!("{}.yaml", name));
+        // Use the daemon's working directory which should be the config dir
+        let file_path = format!("{}.yaml", name);
 
         // Check if the service file already exists
-        if file_path.exists() {
+        if Path::new(&file_path).exists() {
             bail!("Service '{}' already exists", name);
         }
 
@@ -745,11 +758,11 @@ impl Api {
             bail!("Invalid service name: must not contain '/', '\\', or '.'");
         }
 
-        // Construct the file path
-        let file_path = PathBuf::from(format!("{}.yaml", name));
+        // Use the daemon's working directory which should be the config dir
+        let file_path = format!("{}.yaml", name);
 
         // Check if the service file exists
-        if !file_path.exists() {
+        if !Path::new(&file_path).exists() {
             bail!("Service '{}' not found", name);
         }
 
@@ -772,11 +785,11 @@ impl Api {
             bail!("Invalid service name: must not contain '/', '\\', or '.'");
         }
 
-        // Construct the file path
-        let file_path = PathBuf::from(format!("{}.yaml", name));
+        // Use the daemon's working directory which should be the config dir
+        let file_path = format!("{}.yaml", name);
 
         // Check if the service file exists
-        if !file_path.exists() {
+        if !Path::new(&file_path).exists() {
             bail!("Service '{}' not found", name);
         }
 

src/bin/zinit-http.rs

@@ -265,14 +265,8 @@ async fn run_http_server(socket: &str, port: u16) -> Result<()> {
                             .and_then(|p| p.get("name"))
                             .and_then(|v| v.as_str())
                         {
-                            // For monitoring, we need to check if the service file exists first
-                            let file_path = format!("{}.yaml", name);
-                            if !std::path::Path::new(&file_path).exists() {
-                                return Err((
-                                    StatusCode::BAD_REQUEST,
-                                    format!("Service file '{}' not found", file_path),
-                                ));
-                            }
+                            // We don't need to manually check for file existence here as the zinit daemon will handle it
+                            // The actual path resolution is handled properly by the daemon in the monitor method
 
                             // Now we can call monitor
                             client.monitor(name).await.map_err(|e| {