main.rs

use std::fs::File;
use std::sync::{Arc};
use daemonize::Daemonize;

use tokio::net::TcpListener;
use tokio::runtime::Builder;
use tokio::sync::Mutex;

fn setup(listener: Arc<Mutex<Option<TcpListener>>>) {
    let runtime = Builder::new_multi_thread()
        .worker_threads(4)
        .enable_io()
        .thread_stack_size(3 * 1024 * 1024)
        .build()
        .unwrap();

    runtime.block_on(async {
        match TcpListener::bind("127.0.0.1:8080").await {
            Err(e) => {
                eprintln!("Error binding: {}", e);
                return;
            }
            Ok(l) => {
                let mut lock = listener.lock().await;

                lock.insert(l);
            }
        };
    });
}

fn run(listener: Arc<Mutex<Option<TcpListener>>>) {
    let runtime = Builder::new_multi_thread()
        .worker_threads(4)
        .enable_io()
        .thread_stack_size(3 * 1024 * 1024)
        .build()
        .unwrap();

    runtime.block_on(async {
        let lock = listener.lock().await;

        match lock.as_ref().unwrap().accept().await {
            Err(e) => {
                eprintln!("Error accepting connection: {}", e);
                return
            }
            Ok((_socket, addr)) => {
                eprintln!("Got connection from: {:?}", addr);
            }
        }
    });
}

fn main() {
    eprintln!("BEFORE DAEMONIZE");

    let log_file = File::create("/tmp/log").unwrap();
    let log_file_clone = log_file.try_clone().unwrap();

    let listener = Arc::new(Mutex::new(None));
    let listener_clone = listener.clone();

    let daemonize = Daemonize::new()
        .pid_file("/tmp/test.pid")
        .user("nobody")
        .group("nobody")
        .stdout(log_file)
        .stderr(log_file_clone)
        .privileged_action(move || {
            setup(listener_clone);
        });

    if let Err(e) = daemonize.start() {
        eprintln!("Error daemonizing: {}", e);
    }

    eprintln!("AFTER DAEMONIZE");

    run(listener);
}