daemonize2

Struct Daemonize

Source 
pub struct Daemonize<T> { /* private fields */ }
Expand description

Daemonization options.

Fork the process in the background, disassociate from its process group and the control terminal. Change umask value to 0o027, redirect all standard streams to /dev/null.

Optionally:

  • change working directory to provided value;
  • maintain and lock the pid-file;
  • drop user privileges;
  • drop group privileges;
  • change root directory;
  • change the pid-file ownership to provided user (and/or) group;
  • execute any provided action just before dropping privileges.

Implementations§

Source§

impl Daemonize<()>

Source

pub fn new() -> Self

Examples found in repository?
examples/complex.rs (line 39)
33    pub fn main() {
34        let stdout = File::create("/tmp/daemon.out").unwrap();
35        let stderr = File::create("/tmp/daemon.err").unwrap();
36
37        // Every method except `new` and `start` is optional. See `Daemonize` documentation for
38        // default behaviour.
39        let mut daemonize = Daemonize::new();
40
41        daemonize = daemonize
42            .pid_file("/tmp/test.pid")
43            .chown_pid_file_user("nobody")
44            .chown_pid_file_group("daemon")
45            .working_directory("/tmp");
46
47        // User and group IDs can be either strings or integers.
48        daemonize = daemonize.user("nobody").group("daemon").group(2);
49
50        // Set umask. `0o027` by default.
51        daemonize = daemonize.umask(0o777);
52
53        // Redirect standard output and standard error.
54        daemonize = daemonize.stdout(stdout).stderr(stderr);
55
56        // Run a final privileged action.
57        let daemonize = daemonize.privileged_action(|| "Executed before drop privileges");
58
59        // Start the daemon.
60        match unsafe { daemonize.start() } {
61            Ok(_) => println!("Success, daemonized"),
62            Err(e) => eprintln!("Error, {}", e),
63        }
64    }
Source§

impl<T> Daemonize<T>

Source

pub fn pid_file<F: AsRef<Path>>(self, path: F) -> Self

Create pid-file at path, lock it exclusive and write daemon pid.

Examples found in repository?
examples/complex.rs (line 42)
33    pub fn main() {
34        let stdout = File::create("/tmp/daemon.out").unwrap();
35        let stderr = File::create("/tmp/daemon.err").unwrap();
36
37        // Every method except `new` and `start` is optional. See `Daemonize` documentation for
38        // default behaviour.
39        let mut daemonize = Daemonize::new();
40
41        daemonize = daemonize
42            .pid_file("/tmp/test.pid")
43            .chown_pid_file_user("nobody")
44            .chown_pid_file_group("daemon")
45            .working_directory("/tmp");
46
47        // User and group IDs can be either strings or integers.
48        daemonize = daemonize.user("nobody").group("daemon").group(2);
49
50        // Set umask. `0o027` by default.
51        daemonize = daemonize.umask(0o777);
52
53        // Redirect standard output and standard error.
54        daemonize = daemonize.stdout(stdout).stderr(stderr);
55
56        // Run a final privileged action.
57        let daemonize = daemonize.privileged_action(|| "Executed before drop privileges");
58
59        // Start the daemon.
60        match unsafe { daemonize.start() } {
61            Ok(_) => println!("Success, daemonized"),
62            Err(e) => eprintln!("Error, {}", e),
63        }
64    }
Source

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

Changes the pid-file ownership to user.

Examples found in repository?
examples/complex.rs (line 43)
33    pub fn main() {
34        let stdout = File::create("/tmp/daemon.out").unwrap();
35        let stderr = File::create("/tmp/daemon.err").unwrap();
36
37        // Every method except `new` and `start` is optional. See `Daemonize` documentation for
38        // default behaviour.
39        let mut daemonize = Daemonize::new();
40
41        daemonize = daemonize
42            .pid_file("/tmp/test.pid")
43            .chown_pid_file_user("nobody")
44            .chown_pid_file_group("daemon")
45            .working_directory("/tmp");
46
47        // User and group IDs can be either strings or integers.
48        daemonize = daemonize.user("nobody").group("daemon").group(2);
49
50        // Set umask. `0o027` by default.
51        daemonize = daemonize.umask(0o777);
52
53        // Redirect standard output and standard error.
54        daemonize = daemonize.stdout(stdout).stderr(stderr);
55
56        // Run a final privileged action.
57        let daemonize = daemonize.privileged_action(|| "Executed before drop privileges");
58
59        // Start the daemon.
60        match unsafe { daemonize.start() } {
61            Ok(_) => println!("Success, daemonized"),
62            Err(e) => eprintln!("Error, {}", e),
63        }
64    }
Source

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

Changes the pid-file ownership to group.

Examples found in repository?
examples/complex.rs (line 44)
33    pub fn main() {
34        let stdout = File::create("/tmp/daemon.out").unwrap();
35        let stderr = File::create("/tmp/daemon.err").unwrap();
36
37        // Every method except `new` and `start` is optional. See `Daemonize` documentation for
38        // default behaviour.
39        let mut daemonize = Daemonize::new();
40
41        daemonize = daemonize
42            .pid_file("/tmp/test.pid")
43            .chown_pid_file_user("nobody")
44            .chown_pid_file_group("daemon")
45            .working_directory("/tmp");
46
47        // User and group IDs can be either strings or integers.
48        daemonize = daemonize.user("nobody").group("daemon").group(2);
49
50        // Set umask. `0o027` by default.
51        daemonize = daemonize.umask(0o777);
52
53        // Redirect standard output and standard error.
54        daemonize = daemonize.stdout(stdout).stderr(stderr);
55
56        // Run a final privileged action.
57        let daemonize = daemonize.privileged_action(|| "Executed before drop privileges");
58
59        // Start the daemon.
60        match unsafe { daemonize.start() } {
61            Ok(_) => println!("Success, daemonized"),
62            Err(e) => eprintln!("Error, {}", e),
63        }
64    }
Source

pub fn working_directory<F: AsRef<Path>>(self, path: F) -> Self

Change working directory to path.

Examples found in repository?
examples/complex.rs (line 45)
33    pub fn main() {
34        let stdout = File::create("/tmp/daemon.out").unwrap();
35        let stderr = File::create("/tmp/daemon.err").unwrap();
36
37        // Every method except `new` and `start` is optional. See `Daemonize` documentation for
38        // default behaviour.
39        let mut daemonize = Daemonize::new();
40
41        daemonize = daemonize
42            .pid_file("/tmp/test.pid")
43            .chown_pid_file_user("nobody")
44            .chown_pid_file_group("daemon")
45            .working_directory("/tmp");
46
47        // User and group IDs can be either strings or integers.
48        daemonize = daemonize.user("nobody").group("daemon").group(2);
49
50        // Set umask. `0o027` by default.
51        daemonize = daemonize.umask(0o777);
52
53        // Redirect standard output and standard error.
54        daemonize = daemonize.stdout(stdout).stderr(stderr);
55
56        // Run a final privileged action.
57        let daemonize = daemonize.privileged_action(|| "Executed before drop privileges");
58
59        // Start the daemon.
60        match unsafe { daemonize.start() } {
61            Ok(_) => println!("Success, daemonized"),
62            Err(e) => eprintln!("Error, {}", e),
63        }
64    }
Source

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

Drop privileges to user.

Examples found in repository?
examples/complex.rs (line 48)
33    pub fn main() {
34        let stdout = File::create("/tmp/daemon.out").unwrap();
35        let stderr = File::create("/tmp/daemon.err").unwrap();
36
37        // Every method except `new` and `start` is optional. See `Daemonize` documentation for
38        // default behaviour.
39        let mut daemonize = Daemonize::new();
40
41        daemonize = daemonize
42            .pid_file("/tmp/test.pid")
43            .chown_pid_file_user("nobody")
44            .chown_pid_file_group("daemon")
45            .working_directory("/tmp");
46
47        // User and group IDs can be either strings or integers.
48        daemonize = daemonize.user("nobody").group("daemon").group(2);
49
50        // Set umask. `0o027` by default.
51        daemonize = daemonize.umask(0o777);
52
53        // Redirect standard output and standard error.
54        daemonize = daemonize.stdout(stdout).stderr(stderr);
55
56        // Run a final privileged action.
57        let daemonize = daemonize.privileged_action(|| "Executed before drop privileges");
58
59        // Start the daemon.
60        match unsafe { daemonize.start() } {
61            Ok(_) => println!("Success, daemonized"),
62            Err(e) => eprintln!("Error, {}", e),
63        }
64    }
Source

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

Drop privileges to group.

Examples found in repository?
examples/complex.rs (line 48)
33    pub fn main() {
34        let stdout = File::create("/tmp/daemon.out").unwrap();
35        let stderr = File::create("/tmp/daemon.err").unwrap();
36
37        // Every method except `new` and `start` is optional. See `Daemonize` documentation for
38        // default behaviour.
39        let mut daemonize = Daemonize::new();
40
41        daemonize = daemonize
42            .pid_file("/tmp/test.pid")
43            .chown_pid_file_user("nobody")
44            .chown_pid_file_group("daemon")
45            .working_directory("/tmp");
46
47        // User and group IDs can be either strings or integers.
48        daemonize = daemonize.user("nobody").group("daemon").group(2);
49
50        // Set umask. `0o027` by default.
51        daemonize = daemonize.umask(0o777);
52
53        // Redirect standard output and standard error.
54        daemonize = daemonize.stdout(stdout).stderr(stderr);
55
56        // Run a final privileged action.
57        let daemonize = daemonize.privileged_action(|| "Executed before drop privileges");
58
59        // Start the daemon.
60        match unsafe { daemonize.start() } {
61            Ok(_) => println!("Success, daemonized"),
62            Err(e) => eprintln!("Error, {}", e),
63        }
64    }
Source

pub fn umask<M: Into<Mask>>(self, mask: M) -> Self

Change umask to mask or 0o027 by default.

Examples found in repository?
examples/complex.rs (line 51)
33    pub fn main() {
34        let stdout = File::create("/tmp/daemon.out").unwrap();
35        let stderr = File::create("/tmp/daemon.err").unwrap();
36
37        // Every method except `new` and `start` is optional. See `Daemonize` documentation for
38        // default behaviour.
39        let mut daemonize = Daemonize::new();
40
41        daemonize = daemonize
42            .pid_file("/tmp/test.pid")
43            .chown_pid_file_user("nobody")
44            .chown_pid_file_group("daemon")
45            .working_directory("/tmp");
46
47        // User and group IDs can be either strings or integers.
48        daemonize = daemonize.user("nobody").group("daemon").group(2);
49
50        // Set umask. `0o027` by default.
51        daemonize = daemonize.umask(0o777);
52
53        // Redirect standard output and standard error.
54        daemonize = daemonize.stdout(stdout).stderr(stderr);
55
56        // Run a final privileged action.
57        let daemonize = daemonize.privileged_action(|| "Executed before drop privileges");
58
59        // Start the daemon.
60        match unsafe { daemonize.start() } {
61            Ok(_) => println!("Success, daemonized"),
62            Err(e) => eprintln!("Error, {}", e),
63        }
64    }
Source

pub fn chroot<F: AsRef<Path>>(self, path: F) -> Self

Change root to path

Source

pub fn privileged_action<N, F: FnOnce() -> N + 'static>( self, action: F, ) -> Daemonize<N>

Execute action just before dropping privileges. Most common use case is to open listening socket. Result of action execution will be returned by start method.

Examples found in repository?
examples/complex.rs (line 57)
33    pub fn main() {
34        let stdout = File::create("/tmp/daemon.out").unwrap();
35        let stderr = File::create("/tmp/daemon.err").unwrap();
36
37        // Every method except `new` and `start` is optional. See `Daemonize` documentation for
38        // default behaviour.
39        let mut daemonize = Daemonize::new();
40
41        daemonize = daemonize
42            .pid_file("/tmp/test.pid")
43            .chown_pid_file_user("nobody")
44            .chown_pid_file_group("daemon")
45            .working_directory("/tmp");
46
47        // User and group IDs can be either strings or integers.
48        daemonize = daemonize.user("nobody").group("daemon").group(2);
49
50        // Set umask. `0o027` by default.
51        daemonize = daemonize.umask(0o777);
52
53        // Redirect standard output and standard error.
54        daemonize = daemonize.stdout(stdout).stderr(stderr);
55
56        // Run a final privileged action.
57        let daemonize = daemonize.privileged_action(|| "Executed before drop privileges");
58
59        // Start the daemon.
60        match unsafe { daemonize.start() } {
61            Ok(_) => println!("Success, daemonized"),
62            Err(e) => eprintln!("Error, {}", e),
63        }
64    }
Source

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

Configuration for the child process’s standard output stream.

Examples found in repository?
examples/complex.rs (line 54)
33    pub fn main() {
34        let stdout = File::create("/tmp/daemon.out").unwrap();
35        let stderr = File::create("/tmp/daemon.err").unwrap();
36
37        // Every method except `new` and `start` is optional. See `Daemonize` documentation for
38        // default behaviour.
39        let mut daemonize = Daemonize::new();
40
41        daemonize = daemonize
42            .pid_file("/tmp/test.pid")
43            .chown_pid_file_user("nobody")
44            .chown_pid_file_group("daemon")
45            .working_directory("/tmp");
46
47        // User and group IDs can be either strings or integers.
48        daemonize = daemonize.user("nobody").group("daemon").group(2);
49
50        // Set umask. `0o027` by default.
51        daemonize = daemonize.umask(0o777);
52
53        // Redirect standard output and standard error.
54        daemonize = daemonize.stdout(stdout).stderr(stderr);
55
56        // Run a final privileged action.
57        let daemonize = daemonize.privileged_action(|| "Executed before drop privileges");
58
59        // Start the daemon.
60        match unsafe { daemonize.start() } {
61            Ok(_) => println!("Success, daemonized"),
62            Err(e) => eprintln!("Error, {}", e),
63        }
64    }
Source

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

Configuration for the child process’s standard error stream.

Examples found in repository?
examples/complex.rs (line 54)
33    pub fn main() {
34        let stdout = File::create("/tmp/daemon.out").unwrap();
35        let stderr = File::create("/tmp/daemon.err").unwrap();
36
37        // Every method except `new` and `start` is optional. See `Daemonize` documentation for
38        // default behaviour.
39        let mut daemonize = Daemonize::new();
40
41        daemonize = daemonize
42            .pid_file("/tmp/test.pid")
43            .chown_pid_file_user("nobody")
44            .chown_pid_file_group("daemon")
45            .working_directory("/tmp");
46
47        // User and group IDs can be either strings or integers.
48        daemonize = daemonize.user("nobody").group("daemon").group(2);
49
50        // Set umask. `0o027` by default.
51        daemonize = daemonize.umask(0o777);
52
53        // Redirect standard output and standard error.
54        daemonize = daemonize.stdout(stdout).stderr(stderr);
55
56        // Run a final privileged action.
57        let daemonize = daemonize.privileged_action(|| "Executed before drop privileges");
58
59        // Start the daemon.
60        match unsafe { daemonize.start() } {
61            Ok(_) => println!("Success, daemonized"),
62            Err(e) => eprintln!("Error, {}", e),
63        }
64    }
Source

pub unsafe fn start(self) -> Result<T, Error>

Start daemonization process. Terminate parent after first fork. Returns privileged action result to the child.

§Safety

This is not safe to call inside a multi-threaded process. Familiarize yourself with the documentation for fork(2).

Examples found in repository?
examples/complex.rs (line 60)
33    pub fn main() {
34        let stdout = File::create("/tmp/daemon.out").unwrap();
35        let stderr = File::create("/tmp/daemon.err").unwrap();
36
37        // Every method except `new` and `start` is optional. See `Daemonize` documentation for
38        // default behaviour.
39        let mut daemonize = Daemonize::new();
40
41        daemonize = daemonize
42            .pid_file("/tmp/test.pid")
43            .chown_pid_file_user("nobody")
44            .chown_pid_file_group("daemon")
45            .working_directory("/tmp");
46
47        // User and group IDs can be either strings or integers.
48        daemonize = daemonize.user("nobody").group("daemon").group(2);
49
50        // Set umask. `0o027` by default.
51        daemonize = daemonize.umask(0o777);
52
53        // Redirect standard output and standard error.
54        daemonize = daemonize.stdout(stdout).stderr(stderr);
55
56        // Run a final privileged action.
57        let daemonize = daemonize.privileged_action(|| "Executed before drop privileges");
58
59        // Start the daemon.
60        match unsafe { daemonize.start() } {
61            Ok(_) => println!("Success, daemonized"),
62            Err(e) => eprintln!("Error, {}", e),
63        }
64    }
Source

pub unsafe fn execute(self) -> Outcome<T>

Execute daemonization process. Don’t terminate parent after first fork.

§Safety

This is not safe to call inside a multi-threaded process. Familiarize yourself with the documentation for fork(2).

Trait Implementations§

Source§

impl<T> Debug for Daemonize<T>

Source§

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

Formats the value using the given formatter. Read more
Source§

impl Default for Daemonize<()>

Source§

fn default() -> Self

Returns the “default value” for a type. Read more

Auto Trait Implementations§

§

impl<T> Freeze for Daemonize<T>

§

impl<T> !RefUnwindSafe for Daemonize<T>

§

impl<T> !Send for Daemonize<T>

§

impl<T> !Sync for Daemonize<T>

§

impl<T> Unpin for Daemonize<T>

§

impl<T> !UnwindSafe for Daemonize<T>

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.