Struct spirit_daemonize::Daemon

#[non_exhaustive]pub struct Daemon {
    pub user: SecId,
    pub group: SecId,
    pub pid_file: Option<PathBuf>,
    pub workdir: Option<PathBuf>,
    pub daemonize: bool,
}

A configuration fragment for configuration of daemonization.

This describes how to go into background with some details.

The fields can be manipulated by the user of this crate. However, it is not possible to create the struct manually. This is on purpose, some future versions might add more fields. If you want to create one, use Daemon::default and modify certain fields as needed.

Examples

let mut daemon = Daemon::default();
daemon.workdir = Some("/".into());

See also

If you want to daemonize, but not to switch users (or allow switching users), either because the daemon needs to keep root privileges or because it is expected to be already started as ordinary user, use the UserDaemon instead.

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.

user: SecId

The user to drop privileges to.

The user is not changed if not provided.

group: SecId

The group to drop privileges to.

The group is not changed if not provided.

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 (changing users, setting PID file, etc) is still done, but it doesn't go to background.

Implementations

impl Daemon

pub fn prepare(&self) -> Result<Daemonize, AnyError>

Prepare for daemonization.

This does the fist (fallible) phase of daemonization and schedules the rest, though the Daemonize. This is mostly used through spirit::Pipeline (see the crate examples), if used outside of them, prefer the daemonize.

pub fn daemonize(&self) -> Result<(), AnyError>

Perform the daemonization according to the setup inside.

This is the routine one would call if using the fragments manually, not through the spirit management and Pipelines.

Trait Implementations

impl Clone for Daemon

fn clone(&self) -> Daemon

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Daemon

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

Formats the value using the given formatter.

impl Default for Daemon

fn default() -> Daemon

Returns the "default value" for a type.

impl<'de> Deserialize<'de> for Daemon

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

Deserialize this value from the given Serde deserializer.

impl Eq for Daemon

impl Fragment for Daemon

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<Daemon> for Daemon

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

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

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

This method tests for !=.

impl Serialize for Daemon

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 Daemon

fn document() -> Documentation

Returns the documentation for the type.

impl StructuralEq for Daemon

impl StructuralPartialEq for Daemon