Struct ForgeDaemon 

pub struct ForgeDaemon<SetupOutput> { /* private fields */ }

Main constructor to configure and launch the daemon process.

SetupOutput represents the return type of the privileged setup action. The daemonized process will return this value wrapped in a DaemonResult.

Implementations

impl ForgeDaemon<()>

pub fn new() -> Self

Creates a new default configuration.

Defaults

• Working directory: / (Unix) or C:\ (Windows)
• Stdio: /dev/null
• Umask: 0o027 (Unix)

Examples found in repository

examples/tick_daemon.rs (line 35)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. Definir rutas
    let pwd = env::current_dir().unwrap();
    let log_path = pwd.join("ticker.log");
    let err_path = pwd.join("ticker.err");
    let pid_path = pwd.join("ticker.pid");

    // 2. Abrir archivos de log (Append mode)
    let stdout_file = OpenOptions::new()
        .create(true)
        .append(true)
        .open(&log_path)
        .expect("Couldn't open stdout");

    let stderr_file = OpenOptions::new()
        .create(true)
        .append(true)
        .open(&err_path)
        .expect("Couldn't open stderr");

    println!("Launching a simple ticker Daemon...");
    println!("Logs will be written to: {:?}", log_path);

    // 3. Configurar el Daemon
    let daemon = ForgeDaemon::new()
        .name("tick_daemon")
        .pid_file(&pid_path)
        .working_directory(&pwd)
        .stdout(stdout_file)
        .stderr(stderr_file)
        // AQUÍ está el cambio principal: Pasamos la lógica como un closure
        .privileged_action(move || {
            
            // --- INICIO CÓDIGO DEL DAEMON ---
            
            // A. Configurar manejo de señales para parada limpia (SIGTERM / SIGINT)
            let term = Arc::new(AtomicBool::new(false));
            flag::register(SIGTERM, Arc::clone(&term))?; // Systemd Stop
            flag::register(SIGINT, Arc::clone(&term))?;  // Ctrl+C (Manual)

            println!("[Ticker] Servicio iniciado. PID: {}", std::process::id());

            let frases = [
                "Estan vivos",
                "I have no mouth",
                "I must scream",
                "Hello world",
                "Adios mundo :0"
            ];

            let mut i = 0;

            // B. Bucle principal que respeta la señal de parada
            while !term.load(Ordering::Relaxed) {
                let frase = frases[i % frases.len()];
                
                // C. Usamos println!: La librería ya redirigió esto al archivo .log
                println!("[Ticker] Ping #{} - {}", i, frase);
                
                i += 1;
                
                // Dormir en intervalos cortos para revisar la señal de parada frecuentemente
                thread::sleep(Duration::from_secs(3));
            }

            println!("[Ticker] Señal de parada recibida. Cerrando limpiamente.");
            Ok(())
        });

    // 4. Arrancar usando la lógica refactorizada (Systemd o Fork)
    // Nota: Usamos la función del módulo unix directamente
    daemon_forge::ForgeDaemon::start(daemon)?;

    Ok(())
}

impl<SetupOutput> ForgeDaemon<SetupOutput>

pub fn get_name(&self) -> Option<&str>

Returns the daemon name if set.

pub fn pid_file_path(&self) -> Option<&Path>

Returns the configured PID file path, if any.

pub fn environment(&self) -> &HashMap<String, String>

Returns a reference to the environment variables map.

pub fn working_directory_path(&self) -> &Path

Returns the configured working directory.

pub fn name(self, name: &str) -> Self

Sets the internal name of the daemon.

On Windows, this name is used to create a Global Mutex for single-instance locking.

Examples found in repository

examples/tick_daemon.rs (line 36)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. Definir rutas
    let pwd = env::current_dir().unwrap();
    let log_path = pwd.join("ticker.log");
    let err_path = pwd.join("ticker.err");
    let pid_path = pwd.join("ticker.pid");

    // 2. Abrir archivos de log (Append mode)
    let stdout_file = OpenOptions::new()
        .create(true)
        .append(true)
        .open(&log_path)
        .expect("Couldn't open stdout");

    let stderr_file = OpenOptions::new()
        .create(true)
        .append(true)
        .open(&err_path)
        .expect("Couldn't open stderr");

    println!("Launching a simple ticker Daemon...");
    println!("Logs will be written to: {:?}", log_path);

    // 3. Configurar el Daemon
    let daemon = ForgeDaemon::new()
        .name("tick_daemon")
        .pid_file(&pid_path)
        .working_directory(&pwd)
        .stdout(stdout_file)
        .stderr(stderr_file)
        // AQUÍ está el cambio principal: Pasamos la lógica como un closure
        .privileged_action(move || {
            
            // --- INICIO CÓDIGO DEL DAEMON ---
            
            // A. Configurar manejo de señales para parada limpia (SIGTERM / SIGINT)
            let term = Arc::new(AtomicBool::new(false));
            flag::register(SIGTERM, Arc::clone(&term))?; // Systemd Stop
            flag::register(SIGINT, Arc::clone(&term))?;  // Ctrl+C (Manual)

            println!("[Ticker] Servicio iniciado. PID: {}", std::process::id());

            let frases = [
                "Estan vivos",
                "I have no mouth",
                "I must scream",
                "Hello world",
                "Adios mundo :0"
            ];

            let mut i = 0;

            // B. Bucle principal que respeta la señal de parada
            while !term.load(Ordering::Relaxed) {
                let frase = frases[i % frases.len()];
                
                // C. Usamos println!: La librería ya redirigió esto al archivo .log
                println!("[Ticker] Ping #{} - {}", i, frase);
                
                i += 1;
                
                // Dormir en intervalos cortos para revisar la señal de parada frecuentemente
                thread::sleep(Duration::from_secs(3));
            }

            println!("[Ticker] Señal de parada recibida. Cerrando limpiamente.");
            Ok(())
        });

    // 4. Arrancar usando la lógica refactorizada (Systemd o Fork)
    // Nota: Usamos la función del módulo unix directamente
    daemon_forge::ForgeDaemon::start(daemon)?;

    Ok(())
}

pub fn pid_file<P: Into<PathBuf>>(self, path: P) -> Self

Sets the path to the PID file. This file is used for locking to ensure only one instance runs.

Examples found in repository

examples/tick_daemon.rs (line 37)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. Definir rutas
    let pwd = env::current_dir().unwrap();
    let log_path = pwd.join("ticker.log");
    let err_path = pwd.join("ticker.err");
    let pid_path = pwd.join("ticker.pid");

    // 2. Abrir archivos de log (Append mode)
    let stdout_file = OpenOptions::new()
        .create(true)
        .append(true)
        .open(&log_path)
        .expect("Couldn't open stdout");

    let stderr_file = OpenOptions::new()
        .create(true)
        .append(true)
        .open(&err_path)
        .expect("Couldn't open stderr");

    println!("Launching a simple ticker Daemon...");
    println!("Logs will be written to: {:?}", log_path);

    // 3. Configurar el Daemon
    let daemon = ForgeDaemon::new()
        .name("tick_daemon")
        .pid_file(&pid_path)
        .working_directory(&pwd)
        .stdout(stdout_file)
        .stderr(stderr_file)
        // AQUÍ está el cambio principal: Pasamos la lógica como un closure
        .privileged_action(move || {
            
            // --- INICIO CÓDIGO DEL DAEMON ---
            
            // A. Configurar manejo de señales para parada limpia (SIGTERM / SIGINT)
            let term = Arc::new(AtomicBool::new(false));
            flag::register(SIGTERM, Arc::clone(&term))?; // Systemd Stop
            flag::register(SIGINT, Arc::clone(&term))?;  // Ctrl+C (Manual)

            println!("[Ticker] Servicio iniciado. PID: {}", std::process::id());

            let frases = [
                "Estan vivos",
                "I have no mouth",
                "I must scream",
                "Hello world",
                "Adios mundo :0"
            ];

            let mut i = 0;

            // B. Bucle principal que respeta la señal de parada
            while !term.load(Ordering::Relaxed) {
                let frase = frases[i % frases.len()];
                
                // C. Usamos println!: La librería ya redirigió esto al archivo .log
                println!("[Ticker] Ping #{} - {}", i, frase);
                
                i += 1;
                
                // Dormir en intervalos cortos para revisar la señal de parada frecuentemente
                thread::sleep(Duration::from_secs(3));
            }

            println!("[Ticker] Señal de parada recibida. Cerrando limpiamente.");
            Ok(())
        });

    // 4. Arrancar usando la lógica refactorizada (Systemd o Fork)
    // Nota: Usamos la función del módulo unix directamente
    daemon_forge::ForgeDaemon::start(daemon)?;

    Ok(())
}

pub fn working_directory<P: Into<PathBuf>>(self, path: P) -> Self

Sets the working directory for the daemon.

Examples found in repository

examples/tick_daemon.rs (line 38)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. Definir rutas
    let pwd = env::current_dir().unwrap();
    let log_path = pwd.join("ticker.log");
    let err_path = pwd.join("ticker.err");
    let pid_path = pwd.join("ticker.pid");

    // 2. Abrir archivos de log (Append mode)
    let stdout_file = OpenOptions::new()
        .create(true)
        .append(true)
        .open(&log_path)
        .expect("Couldn't open stdout");

    let stderr_file = OpenOptions::new()
        .create(true)
        .append(true)
        .open(&err_path)
        .expect("Couldn't open stderr");

    println!("Launching a simple ticker Daemon...");
    println!("Logs will be written to: {:?}", log_path);

    // 3. Configurar el Daemon
    let daemon = ForgeDaemon::new()
        .name("tick_daemon")
        .pid_file(&pid_path)
        .working_directory(&pwd)
        .stdout(stdout_file)
        .stderr(stderr_file)
        // AQUÍ está el cambio principal: Pasamos la lógica como un closure
        .privileged_action(move || {
            
            // --- INICIO CÓDIGO DEL DAEMON ---
            
            // A. Configurar manejo de señales para parada limpia (SIGTERM / SIGINT)
            let term = Arc::new(AtomicBool::new(false));
            flag::register(SIGTERM, Arc::clone(&term))?; // Systemd Stop
            flag::register(SIGINT, Arc::clone(&term))?;  // Ctrl+C (Manual)

            println!("[Ticker] Servicio iniciado. PID: {}", std::process::id());

            let frases = [
                "Estan vivos",
                "I have no mouth",
                "I must scream",
                "Hello world",
                "Adios mundo :0"
            ];

            let mut i = 0;

            // B. Bucle principal que respeta la señal de parada
            while !term.load(Ordering::Relaxed) {
                let frase = frases[i % frases.len()];
                
                // C. Usamos println!: La librería ya redirigió esto al archivo .log
                println!("[Ticker] Ping #{} - {}", i, frase);
                
                i += 1;
                
                // Dormir en intervalos cortos para revisar la señal de parada frecuentemente
                thread::sleep(Duration::from_secs(3));
            }

            println!("[Ticker] Señal de parada recibida. Cerrando limpiamente.");
            Ok(())
        });

    // 4. Arrancar usando la lógica refactorizada (Systemd o Fork)
    // Nota: Usamos la función del módulo unix directamente
    daemon_forge::ForgeDaemon::start(daemon)?;

    Ok(())
}

pub fn stdin<S: Into<Stdio>>(self, stdio: S) -> Self

Configures the standard input stream.

pub fn stdout<S: Into<Stdio>>(self, stdio: S) -> Self

Configures the standard output stream.

Examples found in repository

examples/tick_daemon.rs (line 39)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. Definir rutas
    let pwd = env::current_dir().unwrap();
    let log_path = pwd.join("ticker.log");
    let err_path = pwd.join("ticker.err");
    let pid_path = pwd.join("ticker.pid");

    // 2. Abrir archivos de log (Append mode)
    let stdout_file = OpenOptions::new()
        .create(true)
        .append(true)
        .open(&log_path)
        .expect("Couldn't open stdout");

    let stderr_file = OpenOptions::new()
        .create(true)
        .append(true)
        .open(&err_path)
        .expect("Couldn't open stderr");

    println!("Launching a simple ticker Daemon...");
    println!("Logs will be written to: {:?}", log_path);

    // 3. Configurar el Daemon
    let daemon = ForgeDaemon::new()
        .name("tick_daemon")
        .pid_file(&pid_path)
        .working_directory(&pwd)
        .stdout(stdout_file)
        .stderr(stderr_file)
        // AQUÍ está el cambio principal: Pasamos la lógica como un closure
        .privileged_action(move || {
            
            // --- INICIO CÓDIGO DEL DAEMON ---
            
            // A. Configurar manejo de señales para parada limpia (SIGTERM / SIGINT)
            let term = Arc::new(AtomicBool::new(false));
            flag::register(SIGTERM, Arc::clone(&term))?; // Systemd Stop
            flag::register(SIGINT, Arc::clone(&term))?;  // Ctrl+C (Manual)

            println!("[Ticker] Servicio iniciado. PID: {}", std::process::id());

            let frases = [
                "Estan vivos",
                "I have no mouth",
                "I must scream",
                "Hello world",
                "Adios mundo :0"
            ];

            let mut i = 0;

            // B. Bucle principal que respeta la señal de parada
            while !term.load(Ordering::Relaxed) {
                let frase = frases[i % frases.len()];
                
                // C. Usamos println!: La librería ya redirigió esto al archivo .log
                println!("[Ticker] Ping #{} - {}", i, frase);
                
                i += 1;
                
                // Dormir en intervalos cortos para revisar la señal de parada frecuentemente
                thread::sleep(Duration::from_secs(3));
            }

            println!("[Ticker] Señal de parada recibida. Cerrando limpiamente.");
            Ok(())
        });

    // 4. Arrancar usando la lógica refactorizada (Systemd o Fork)
    // Nota: Usamos la función del módulo unix directamente
    daemon_forge::ForgeDaemon::start(daemon)?;

    Ok(())
}

pub fn stderr<S: Into<Stdio>>(self, stdio: S) -> Self

Configures the standard error stream.

Examples found in repository

examples/tick_daemon.rs (line 40)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. Definir rutas
    let pwd = env::current_dir().unwrap();
    let log_path = pwd.join("ticker.log");
    let err_path = pwd.join("ticker.err");
    let pid_path = pwd.join("ticker.pid");

    // 2. Abrir archivos de log (Append mode)
    let stdout_file = OpenOptions::new()
        .create(true)
        .append(true)
        .open(&log_path)
        .expect("Couldn't open stdout");

    let stderr_file = OpenOptions::new()
        .create(true)
        .append(true)
        .open(&err_path)
        .expect("Couldn't open stderr");

    println!("Launching a simple ticker Daemon...");
    println!("Logs will be written to: {:?}", log_path);

    // 3. Configurar el Daemon
    let daemon = ForgeDaemon::new()
        .name("tick_daemon")
        .pid_file(&pid_path)
        .working_directory(&pwd)
        .stdout(stdout_file)
        .stderr(stderr_file)
        // AQUÍ está el cambio principal: Pasamos la lógica como un closure
        .privileged_action(move || {
            
            // --- INICIO CÓDIGO DEL DAEMON ---
            
            // A. Configurar manejo de señales para parada limpia (SIGTERM / SIGINT)
            let term = Arc::new(AtomicBool::new(false));
            flag::register(SIGTERM, Arc::clone(&term))?; // Systemd Stop
            flag::register(SIGINT, Arc::clone(&term))?;  // Ctrl+C (Manual)

            println!("[Ticker] Servicio iniciado. PID: {}", std::process::id());

            let frases = [
                "Estan vivos",
                "I have no mouth",
                "I must scream",
                "Hello world",
                "Adios mundo :0"
            ];

            let mut i = 0;

            // B. Bucle principal que respeta la señal de parada
            while !term.load(Ordering::Relaxed) {
                let frase = frases[i % frases.len()];
                
                // C. Usamos println!: La librería ya redirigió esto al archivo .log
                println!("[Ticker] Ping #{} - {}", i, frase);
                
                i += 1;
                
                // Dormir en intervalos cortos para revisar la señal de parada frecuentemente
                thread::sleep(Duration::from_secs(3));
            }

            println!("[Ticker] Señal de parada recibida. Cerrando limpiamente.");
            Ok(())
        });

    // 4. Arrancar usando la lógica refactorizada (Systemd o Fork)
    // Nota: Usamos la función del módulo unix directamente
    daemon_forge::ForgeDaemon::start(daemon)?;

    Ok(())
}

pub fn clear_env(self, clear: bool) -> Self

If true, clears all inherited environment variables for security.

pub fn env(self, key: &str, value: &str) -> Self

Adds or overwrites an environment variable.

pub fn env_opt(self, key: &str, value: Option<&str>) -> Self

Adds an environment variable only if value is Some.

pub fn inherit_env(self) -> Self

Inherits current environment variables into the configuration.

Useful when combined with clear_env(true) to selectively keep variables, or to ensure specific variables are captured before cleaning.

pub fn build(self) -> DaemonResult<Self>

Validates configuration without starting the daemon. Checks if the PID file directory exists.

pub fn privileged_action<N, F>(self, action: F) -> ForgeDaemon<N>

where F: FnOnce() -> DaemonResult<N> + 'static,

Executes an action before dropping privileges (Unix) or before entering the main loop.

The action MUST return a DaemonResult. If it returns Err, the daemon will abort startup. This consumes the current builder and returns a new one with the updated generic type N.

Examples found in repository

examples/tick_daemon.rs (lines 42-78)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. Definir rutas
    let pwd = env::current_dir().unwrap();
    let log_path = pwd.join("ticker.log");
    let err_path = pwd.join("ticker.err");
    let pid_path = pwd.join("ticker.pid");

    // 2. Abrir archivos de log (Append mode)
    let stdout_file = OpenOptions::new()
        .create(true)
        .append(true)
        .open(&log_path)
        .expect("Couldn't open stdout");

    let stderr_file = OpenOptions::new()
        .create(true)
        .append(true)
        .open(&err_path)
        .expect("Couldn't open stderr");

    println!("Launching a simple ticker Daemon...");
    println!("Logs will be written to: {:?}", log_path);

    // 3. Configurar el Daemon
    let daemon = ForgeDaemon::new()
        .name("tick_daemon")
        .pid_file(&pid_path)
        .working_directory(&pwd)
        .stdout(stdout_file)
        .stderr(stderr_file)
        // AQUÍ está el cambio principal: Pasamos la lógica como un closure
        .privileged_action(move || {
            
            // --- INICIO CÓDIGO DEL DAEMON ---
            
            // A. Configurar manejo de señales para parada limpia (SIGTERM / SIGINT)
            let term = Arc::new(AtomicBool::new(false));
            flag::register(SIGTERM, Arc::clone(&term))?; // Systemd Stop
            flag::register(SIGINT, Arc::clone(&term))?;  // Ctrl+C (Manual)

            println!("[Ticker] Servicio iniciado. PID: {}", std::process::id());

            let frases = [
                "Estan vivos",
                "I have no mouth",
                "I must scream",
                "Hello world",
                "Adios mundo :0"
            ];

            let mut i = 0;

            // B. Bucle principal que respeta la señal de parada
            while !term.load(Ordering::Relaxed) {
                let frase = frases[i % frases.len()];
                
                // C. Usamos println!: La librería ya redirigió esto al archivo .log
                println!("[Ticker] Ping #{} - {}", i, frase);
                
                i += 1;
                
                // Dormir en intervalos cortos para revisar la señal de parada frecuentemente
                thread::sleep(Duration::from_secs(3));
            }

            println!("[Ticker] Señal de parada recibida. Cerrando limpiamente.");
            Ok(())
        });

    // 4. Arrancar usando la lógica refactorizada (Systemd o Fork)
    // Nota: Usamos la función del módulo unix directamente
    daemon_forge::ForgeDaemon::start(daemon)?;

    Ok(())
}

pub fn user<U: Into<User>>(self, user: U) -> Self

(Unix) Sets the user to run the daemon as (privilege dropping).

pub fn group<G: Into<Group>>(self, group: G) -> Self

(Unix) Sets the group to run the daemon as.

pub fn umask(self, mask: u32) -> Self

(Unix) Sets the umask for the daemon process.

pub fn chroot<P: Into<PathBuf>>(self, path: P) -> Self

(Unix) Sets a chroot directory for the daemon.

pub fn chown_pid_file(self, chown: bool) -> Self

(Unix) If true, changes ownership of the PID file to the target user/group.

pub fn start(self) -> DaemonResult<SetupOutput>

Starts the daemonization process.

Examples found in repository

examples/tick_daemon.rs (line 82)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. Definir rutas
    let pwd = env::current_dir().unwrap();
    let log_path = pwd.join("ticker.log");
    let err_path = pwd.join("ticker.err");
    let pid_path = pwd.join("ticker.pid");

    // 2. Abrir archivos de log (Append mode)
    let stdout_file = OpenOptions::new()
        .create(true)
        .append(true)
        .open(&log_path)
        .expect("Couldn't open stdout");

    let stderr_file = OpenOptions::new()
        .create(true)
        .append(true)
        .open(&err_path)
        .expect("Couldn't open stderr");

    println!("Launching a simple ticker Daemon...");
    println!("Logs will be written to: {:?}", log_path);

    // 3. Configurar el Daemon
    let daemon = ForgeDaemon::new()
        .name("tick_daemon")
        .pid_file(&pid_path)
        .working_directory(&pwd)
        .stdout(stdout_file)
        .stderr(stderr_file)
        // AQUÍ está el cambio principal: Pasamos la lógica como un closure
        .privileged_action(move || {
            
            // --- INICIO CÓDIGO DEL DAEMON ---
            
            // A. Configurar manejo de señales para parada limpia (SIGTERM / SIGINT)
            let term = Arc::new(AtomicBool::new(false));
            flag::register(SIGTERM, Arc::clone(&term))?; // Systemd Stop
            flag::register(SIGINT, Arc::clone(&term))?;  // Ctrl+C (Manual)

            println!("[Ticker] Servicio iniciado. PID: {}", std::process::id());

            let frases = [
                "Estan vivos",
                "I have no mouth",
                "I must scream",
                "Hello world",
                "Adios mundo :0"
            ];

            let mut i = 0;

            // B. Bucle principal que respeta la señal de parada
            while !term.load(Ordering::Relaxed) {
                let frase = frases[i % frases.len()];
                
                // C. Usamos println!: La librería ya redirigió esto al archivo .log
                println!("[Ticker] Ping #{} - {}", i, frase);
                
                i += 1;
                
                // Dormir en intervalos cortos para revisar la señal de parada frecuentemente
                thread::sleep(Duration::from_secs(3));
            }

            println!("[Ticker] Señal de parada recibida. Cerrando limpiamente.");
            Ok(())
        });

    // 4. Arrancar usando la lógica refactorizada (Systemd o Fork)
    // Nota: Usamos la función del módulo unix directamente
    daemon_forge::ForgeDaemon::start(daemon)?;

    Ok(())
}

Trait Implementations

impl<T> Debug for ForgeDaemon<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ForgeDaemon<()>

fn default() -> Self

Returns the “default value” for a type.