Struct spirit_daemonize::UserDaemon

#[non_exhaustive]pub struct UserDaemon {
    pub pid_file: Option<PathBuf>,
    pub workdir: Option<PathBuf>,
    pub daemonize: bool,
}

A stripped-down version of Daemon without the user-switching options.

Sometimes, the daemon either needs to keep the root privileges or is started with the appropriate user right away, therefore the user should not be able to configure the user and group options.

This configuration fragment serves the role. Convert it to Daemon first, by into_daemon (or using the Into trait).

Examples

use spirit_daemonize::{Daemon, UserDaemon};

// No way to access the `pid_file` and others inside this thing and can't call `.daemonize()`.
let user_daemon = UserDaemon::default();

let daemon: Daemon = user_daemon.into();
assert!(daemon.pid_file.is_none());
assert_eq!(daemon, Daemon::default());

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

pid_file: Option<PathBuf>

Where to store a PID file.

If not set, no PID file is created.

workdir: Option<PathBuf>

Switch to this working directory at startup.

If not set, working directory is not switched.

daemonize: bool

Enable the daemonization.

Even if this is false, some activity (setting PID file, etc) is still done, but it doesn't go to background.

Implementations

impl UserDaemon

pub fn into_daemon(self) -> Daemon

Converts to full-featured Daemon.

All the useful functionality is on Daemon, therefore to use it, convert it first.

It can be also converted using the usual From/Into traits.

Trait Implementations

impl Clone for UserDaemon

fn clone(&self) -> UserDaemon

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for UserDaemon

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

Formats the value using the given formatter.

impl Default for UserDaemon

fn default() -> UserDaemon

Returns the "default value" for a type.

impl<'de> Deserialize<'de> for UserDaemon

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Eq for UserDaemon

impl Fragment for UserDaemon

type Driver = OnceDriver<Self>

The default driver to be used by the fragment.

type Resource = Daemonize

The actual product this Fragment creates.

type Installer = DaemonizeInstaller

The default installer to be used unless a transformation or the user doesn't provide one.

type Seed = ()

The intermediate product if the fragment supports two-stage creation of Resources. If not, it can be set to ().

fn make_seed(&self, _: &'static str) -> Result<(), AnyError>

Runs the first stage of creation.

fn make_resource(
    &self,
    _: &mut (),
    _: &'static str
) -> Result<Daemonize, AnyError>

Runs the second stage of creation.

const RUN_BEFORE_CONFIG: bool

Configuration if the pipeline should be run once even before the config is loaded.

fn create(
    &self,
    name: &'static str
) -> Result<Self::Resource, Box<dyn Error + 'static + Sync + Send>>

Runs both stages of creation at once.

fn init<B>(
    builder: B,
    &'static str
) -> Result<B, Box<dyn Error + 'static + Sync + Send>> where
    B: Extensible<Ok = B>,
    <B as Extensible>::Config: DeserializeOwned,
    <B as Extensible>::Config: Send,
    <B as Extensible>::Config: Sync,
    <B as Extensible>::Config: 'static,
    <B as Extensible>::Opts: StructOpt,
    <B as Extensible>::Opts: Send,
    <B as Extensible>::Opts: Sync,
    <B as Extensible>::Opts: 'static, 

An initialization routine.

impl From<UserDaemon> for Daemon

fn from(ud: UserDaemon) -> Daemon

Performs the conversion.

impl PartialEq<UserDaemon> for UserDaemon

fn eq(&self, other: &UserDaemon) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &UserDaemon) -> bool

This method tests for !=.

impl Serialize for UserDaemon

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl StructDoc for UserDaemon

fn document() -> Documentation

Returns the documentation for the type.

impl StructuralEq for UserDaemon

impl StructuralPartialEq for UserDaemon