daemon-base 0.1.1

A flexible and configurable Rust daemon library with lifecycle management, logging, callbacks, and optional async support. Works on Linux, macOS, and Windows.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

//! Binary management for the daemon library.
//!
//! This module provides functionality to load and unload binaries or resources
//! in a specified order.

use log::{info};
use std::path::Path;
use std::process::Command;
use crate::error::DaemonError;

/// Represents a binary or resource to be loaded.
pub struct Binary {
    path: String,
}

impl Binary {
    /// Creates a new `Binary` instance.
    pub fn new(path: String) -> Self {
        Binary { path }
    }

    /// Loads the binary or resource.
    pub fn load(&self) -> Result<(), DaemonError> {
        info!("Loading binary: {}", self.path);

        if !Path::new(&self.path).exists() {
            return Err(DaemonError::CustomError(format!("Binary not found: {}", self.path)));
        }

        // Example: Execute the binary (replace with actual logic)
        let output = Command::new(&self.path)
            .output()
            .map_err(|e| DaemonError::CustomError(format!("Failed to execute binary: {}", e)))?;

        if !output.status.success() {
            return Err(DaemonError::CustomError(format!(
                "Binary failed with output: {}",
                String::from_utf8_lossy(&output.stderr)
            )));
        }

        info!("Successfully loaded binary: {}", self.path);
        Ok(())
    }

    /// Unloads the binary or resource.
    pub fn unload(&self) -> Result<(), DaemonError> {
        info!("Unloading binary: {}", self.path);

        // Example: Kill the process (replace with actual logic)
        let output = Command::new("pkill")
            .arg(&self.path)
            .output()
            .map_err(|e| DaemonError::CustomError(format!("Failed to unload binary: {}", e)))?;

        if !output.status.success() {
            return Err(DaemonError::CustomError(format!(
                "Failed to unload binary: {}",
                String::from_utf8_lossy(&output.stderr)
            )));
        }

        info!("Successfully unloaded binary: {}", self.path);
        Ok(())
    }
}

/// Manages a list of binaries or resources.
pub struct BinaryManager {
    binaries: Vec<Binary>,
}

impl BinaryManager {
    /// Creates a new `BinaryManager` instance.
    pub fn new(binaries: Vec<String>) -> Self {
        BinaryManager {
            binaries: binaries.into_iter().map(Binary::new).collect(),
        }
    }

    /// Loads all binaries or resources.
    pub fn load_all(&self) -> Result<(), DaemonError> {
        for binary in &self.binaries {
            binary.load()?;
        }
        Ok(())
    }

    /// Unloads all binaries or resources.
    pub fn unload_all(&self) -> Result<(), DaemonError> {
        for binary in &self.binaries {
            binary.unload()?;
        }
        Ok(())
    }
}