Service Manager

https://docs.rs/service-manager/latest/service_manager
Admin
A Rust library that provides a unified interface for managing services across multiple platforms...
Tokens:19,424
Snippets:279
Trust Score:9.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### ServiceManager::start

Source: https://docs.rs/service-manager/latest/service_manager/index.html?search=std%3A%3Avec

Starts an installed service.

```APIDOC
## start(ServiceStartCtx)

### Description
Starts a previously installed service identified by its label.

### Parameters
- **ServiceStartCtx** (struct) - Required - Context containing the service label to start.
```

--------------------------------

### ServiceManager::start

Source: https://docs.rs/service-manager/latest/service_manager/index.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Starts an installed service.

```APIDOC
## start(ServiceStartCtx)

### Description
Starts a previously installed service identified by its label.

### Parameters
- **ServiceStartCtx** (struct) - Required - Contains the ServiceLabel of the service to start.
```

--------------------------------

### ServiceManager::start

Source: https://docs.rs/service-manager/latest/service_manager/index.html?search=

Starts an installed service.

```APIDOC
## fn start(&self, ctx: ServiceStartCtx) -> Result<()>

### Description
Starts a previously installed service identified by the label in the provided context.

### Parameters
- **ctx** (ServiceStartCtx) - Required - The context containing the service label.
```

--------------------------------

### Generic Service Management with service_manager

Source: https://docs.rs/service-manager/latest/service_manager/index.html

Demonstrates installing, starting, stopping, and uninstalling a service using the native service management platform detected on the OS. Requires Rust 1.58.1 or higher.

```rust
use service_manager::*
use std::ffi::OsString;
use std::path::PathBuf;

// Create a label for our service
let label: ServiceLabel = "com.example.my-service".parse().unwrap();

// Get generic service by detecting what is available on the platform
let manager = <dyn ServiceManager>::native()
    .expect("Failed to detect management platform");

// Install our service using the underlying service management platform
manager.install(ServiceInstallCtx {
    label: label.clone(),
    program: PathBuf::from("path/to/my-service-executable"),
    args: vec![OsString::from("--some-arg")],
    contents: None, // Optional String for system-specific service content.
    username: None, // Optional String for alternative user to run service.
    working_directory: None, // Optional String for the working directory for the service process.
    environment: None, // Optional list of environment variables to supply the service process.
    autostart: true, // Specify whether the service should automatically start upon OS reboot.
    restart_policy: RestartPolicy::default(), // Restart on failure by default.
}).expect("Failed to install");

// Start our service using the underlying service management platform
manager.start(ServiceStartCtx {
    label: label.clone()
}).expect("Failed to start");

// Stop our service using the underlying service management platform
manager.stop(ServiceStopCtx {
    label: label.clone()
}).expect("Failed to stop");

// Uninstall our service using the underlying service management platform
manager.uninstall(ServiceUninstallCtx {
    label: label.clone()
}).expect("Failed to stop");

```

--------------------------------

### LaunchdServiceManager::install

Source: https://docs.rs/service-manager/latest/service_manager/struct.LaunchdServiceManager.html

Installs a new service using the launchd manager.

```APIDOC
## fn install(&self, ctx: ServiceInstallCtx) -> Result<()>

### Description
Installs a new service using the manager.

### Parameters
- **ctx** (ServiceInstallCtx) - Required - Context containing installation details.
```

--------------------------------

### LaunchdServiceManager::start

Source: https://docs.rs/service-manager/latest/service_manager/struct.LaunchdServiceManager.html

Starts a service managed by launchd.

```APIDOC
## fn start(&self, ctx: ServiceStartCtx) -> Result<()>

### Description
Starts a service using the manager.

### Parameters
- **ctx** (ServiceStartCtx) - Required - Context containing start details.
```

--------------------------------

### Install Service with Specific Launchd Configuration

Source: https://docs.rs/service-manager/latest/service_manager/index.html

Use this to install a service with a specific `LaunchdServiceManager` configuration, such as disabling the KeepAlive flag. Ensure the `service_manager` crate is imported.

```rust
use service_manager::*
use std::ffi::OsString;
use std::path::PathBuf;

// Create a label for our service
let label: ServiceLabel = "com.example.my-service".parse().unwrap();

// Instantiate a specific service manager
let mut manager = LaunchdServiceManager::system();

// Update an install configuration property where installing a service
// will NOT add the KeepAlive flag
manager.config.install.keep_alive = Some(false);

// Install our service using the explicit service manager
manager.install(ServiceInstallCtx {
    label: label.clone(),
    program: PathBuf::from("path/to/my-service-executable"),
    args: vec![OsString::from("--some-arg")],
    contents: None, // Optional String for system-specific service content.
    username: None, // Optional String for alternative user to run service.
    working_directory: None, // Optional String for the working directory for the service process.
    environment: None, // Optional list of environment variables to supply the service process.
    autostart: true, // Specify whether the service should automatically start upon OS reboot.
    restart_policy: RestartPolicy::default(), // Restart on failure by default.
}).expect("Failed to install");

```

--------------------------------

### LaunchdInstallConfig Struct Definition

Source: https://docs.rs/service-manager/latest/service_manager/struct.LaunchdInstallConfig.html

The primary structure definition for launchd installation configuration.

```rust
pub struct LaunchdInstallConfig {
    pub keep_alive: Option<bool>,
}
```

--------------------------------

### ServiceManager::install

Source: https://docs.rs/service-manager/latest/service_manager/index.html?search=std%3A%3Avec

Installs a service using the detected platform-specific service manager.

```APIDOC
## install(ServiceInstallCtx)

### Description
Installs a service on the host operating system using the detected service management platform.

### Parameters
- **ServiceInstallCtx** (struct) - Required - Context containing service configuration:
  - **label** (ServiceLabel) - Required - Unique identifier for the service.
  - **program** (PathBuf) - Required - Path to the service executable.
  - **args** (Vec<OsString>) - Optional - Arguments for the service process.
  - **contents** (Option<String>) - Optional - System-specific service configuration content.
  - **username** (Option<String>) - Optional - User to run the service as.
  - **working_directory** (Option<String>) - Optional - Working directory for the service.
  - **environment** (Option<Vec<(String, String)>>) - Optional - Environment variables.
  - **autostart** (bool) - Required - Whether to start on reboot.
  - **restart_policy** (RestartPolicy) - Required - Policy for service restarts.
```

--------------------------------

### LaunchdConfig Struct Definition

Source: https://docs.rs/service-manager/latest/service_manager/struct.LaunchdConfig.html?search=

The primary structure definition for LaunchdConfig, containing the installation configuration.

```rust
pub struct LaunchdConfig {
    pub install: LaunchdInstallConfig,
}
```

--------------------------------

### Configure Service Restart Policies

Source: https://docs.rs/service-manager/latest/service_manager/index.html

Demonstrates installing services with different `RestartPolicy` settings using the native service manager. Note platform-specific support for these policies.

```rust
use service_manager::*
use std::ffi::OsString;
use std::path::PathBuf;

let label: ServiceLabel = "com.example.my-service".parse().unwrap();
let manager = <dyn ServiceManager>::native()
    .expect("Failed to detect management platform");

// Example 1: Never restart the service
manager.install(ServiceInstallCtx {
    label: label.clone(),
    program: PathBuf::from("path/to/my-service-executable"),
    args: vec![OsString::from("--some-arg")],
    contents: None,
    username: None,
    working_directory: None,
    environment: None,
    autostart: true,
    restart_policy: RestartPolicy::Never,
}).expect("Failed to install");

// Example 2: Always restart regardless of exit status
manager.install(ServiceInstallCtx {
    label: label.clone(),
    program: PathBuf::from("path/to/my-service-executable"),
    args: vec![OsString::from("--some-arg")],
    contents: None,
    username: None,
    working_directory: None,
    environment: None,
    autostart: true,
    restart_policy: RestartPolicy::Always { delay_secs: Some(10) },
}).expect("Failed to install");

// Example 3: Restart only on failure (non-zero exit)
manager.install(ServiceInstallCtx {
    label: label.clone(),
    program: PathBuf::from("path/to/my-service-executable"),
    args: vec![OsString::from("--some-arg")],
    contents: None,
    username: None,
    working_directory: None,
    environment: None,
    autostart: true,
    restart_policy: RestartPolicy::OnFailure {
        delay_secs: Some(5),
        max_retries: Some(3),
        reset_after_secs: Some(3600),
    },
}).expect("Failed to install");

```

--------------------------------

### ServiceManager::install

Source: https://docs.rs/service-manager/latest/service_manager/index.html?search=

Installs a service using the underlying platform-specific service management tool.

```APIDOC
## fn install(&self, ctx: ServiceInstallCtx) -> Result<()>

### Description
Installs a service defined by the provided ServiceInstallCtx context.

### Parameters
- **ctx** (ServiceInstallCtx) - Required - The configuration context for the service, including label, program path, arguments, and restart policy.
```

--------------------------------

### ServiceManager::install

Source: https://docs.rs/service-manager/latest/service_manager/index.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Installs a service using the underlying platform's service management system.

```APIDOC
## install(ServiceInstallCtx)

### Description
Installs a service defined by the provided context on the host operating system.

### Parameters
- **ServiceInstallCtx** (struct) - Required - Contains service configuration including label, program path, arguments, and restart policy.
```

--------------------------------

### ServiceInstallCtx Struct Definition

Source: https://docs.rs/service-manager/latest/service_manager/struct.ServiceInstallCtx.html

The structure definition for ServiceInstallCtx, detailing the fields required for service installation.

```rust
pub struct ServiceInstallCtx {
    pub label: ServiceLabel,
    pub program: PathBuf,
    pub args: Vec<OsString>,
    pub contents: Option<String>,
    pub username: Option<String>,
    pub working_directory: Option<PathBuf>,
    pub environment: Option<Vec<(String, String)>>,
    pub autostart: bool,
    pub restart_policy: RestartPolicy,
}
```

--------------------------------

### Install Rust Service Manager Dependency

Source: https://docs.rs/service-manager/latest/service_manager/index.html

Add the service-manager crate to your Cargo.toml to include it in your project.

```toml
[dependencies]
service-manager = "0.10"
```

--------------------------------

### Run system tests

Source: https://docs.rs/service-manager/latest/service_manager/index.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Execute platform-specific tests using the system-tests crate, requiring elevated permissions for system-level installations.

```bash
cargo test -p system-tests systemd_for_user -- --nocapture
```

```bash
sudo -E cargo test -p system-tests systemd_for_system -- --nocapture
```

--------------------------------

### Run systemd System Test

Source: https://docs.rs/service-manager/latest/service_manager/index.html

Execute a systemd system test using the `system-tests` crate. `sudo -E` is required to maintain necessary permissions for system-level installation.

```bash
sudo -E cargo test -p system-tests systemd_for_system -- --nocapture

```

--------------------------------

### Configure a specific service manager

Source: https://docs.rs/service-manager/latest/service_manager/index.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Instantiate a platform-specific service manager and modify its installation configuration properties before deployment.

```rust
use service_manager::*;
use std::ffi::OsString;
use std::path::PathBuf;

// Create a label for our service
let label: ServiceLabel = "com.example.my-service".parse().unwrap();

// Instantiate a specific service manager
let mut manager = LaunchdServiceManager::system();

// Update an install configuration property where installing a service
// will NOT add the KeepAlive flag
manager.config.install.keep_alive = Some(false);

// Install our service using the explicit service manager
manager.install(ServiceInstallCtx {
    label: label.clone(),
    program: PathBuf::from("path/to/my-service-executable"),
    args: vec![OsString::from("--some-arg")],
    contents: None, // Optional String for system-specific service content.
    username: None, // Optional String for alternative user to run service.
    working_directory: None, // Optional String for the working directory for the service process.
    environment: None, // Optional list of environment variables to supply the service process.
    autostart: true, // Specify whether the service should automatically start upon OS reboot.
    restart_policy: RestartPolicy::default(), // Restart on failure by default.
}).expect("Failed to install");
```

--------------------------------

### SystemdInstallConfig Struct Definition

Source: https://docs.rs/service-manager/latest/service_manager/struct.SystemdInstallConfig.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

The structure definition for systemd installation configuration, containing optional fields for service management.

```rust
pub struct SystemdInstallConfig {
    pub start_limit_interval_sec: Option<u32>,
    pub start_limit_burst: Option<u32>,
    pub restart: Option<SystemdServiceRestartType>,
    pub restart_sec: Option<u32>,
}
```

--------------------------------

### Service Level Methods

Source: https://docs.rs/service-manager/latest/service_manager/struct.ScServiceManager.html

Methods for getting and setting the target service level.

```APIDOC
### fn level(&self) -> ServiceLevel
Returns the current target level for the manager.

### fn set_level(&mut self, level: ServiceLevel) -> Result<()>
Sets the target level for the manager.
```

--------------------------------

### Get Systemd Global Directory Path

Source: https://docs.rs/service-manager/latest/service_manager/fn.systemd_global_dir_path.html

Returns the PathBuf for the systemd global directory. This is useful for locating systemd unit files.

```rust
pub fn systemd_global_dir_path() -> PathBuf
```

--------------------------------

### Get systemd user directory path

Source: https://docs.rs/service-manager/latest/service_manager/fn.systemd_user_dir_path.html?search=

Retrieves the path for the systemd user directory as a Result containing a PathBuf.

```rust
pub fn systemd_user_dir_path() -> Result<PathBuf>
```

--------------------------------

### ScInstallConfig Struct Definition

Source: https://docs.rs/service-manager/latest/service_manager/struct.ScInstallConfig.html

The structure definition for ScInstallConfig, containing fields for service type, start type, and error severity.

```rust
pub struct ScInstallConfig {
    pub service_type: WindowsServiceType,
    pub start_type: WindowsStartType,
    pub error_severity: WindowsErrorSeverity,
}
```

--------------------------------

### WinSwServiceManager::system

Source: https://docs.rs/service-manager/latest/service_manager/struct.WinSwServiceManager.html

Creates a new instance of WinSwServiceManager with default settings.

```APIDOC
## pub fn system() -> Self

### Description
Creates a new instance of the WinSwServiceManager.

### Signature
`pub fn system() -> Self`
```

--------------------------------

### WinSwServiceManager::with_config

Source: https://docs.rs/service-manager/latest/service_manager/struct.WinSwServiceManager.html

Creates a new instance of WinSwServiceManager with a specific configuration.

```APIDOC
## pub fn with_config(self, config: WinSwConfig) -> Self

### Description
Configures the service manager with the provided WinSwConfig.

### Parameters
- **config** (WinSwConfig) - The configuration object to apply.
```

--------------------------------

### LaunchdServiceManager::system

Source: https://docs.rs/service-manager/latest/service_manager/struct.LaunchdServiceManager.html

Creates a new manager instance configured to work with system-level services.

```APIDOC
## pub fn system() -> Self

### Description
Creates a new manager instance working with system services.

### Signature
`pub fn system() -> Self`
```

--------------------------------

### SystemdServiceManager Methods

Source: https://docs.rs/service-manager/latest/service_manager/struct.SystemdServiceManager.html?search=std%3A%3Avec

Methods for initializing and configuring a SystemdServiceManager instance.

```APIDOC
## pub fn system() -> Self
Creates a new manager instance working with system services.

## pub fn user() -> Self
Creates a new manager instance working with user services.

## pub fn into_system(self) -> Self
Change manager to work with system services.

## pub fn into_user(self) -> Self
Change manager to work with user services.

## pub fn with_config(self, config: SystemdConfig) -> Self
Update manager to use the specified config.
```

--------------------------------

### ScServiceManager Initialization

Source: https://docs.rs/service-manager/latest/service_manager/struct.ScServiceManager.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods to create and configure a new ScServiceManager instance.

```APIDOC
## pub fn system() -> Self

Creates a new manager instance configured for system services.

## pub fn with_config(self, config: ScConfig) -> Self

Updates the manager instance to use the specified configuration.
```

--------------------------------

### LaunchdServiceManager Constructors

Source: https://docs.rs/service-manager/latest/service_manager/struct.LaunchdServiceManager.html?search=std%3A%3Avec

Methods to initialize a new LaunchdServiceManager instance for either system or user-level service management.

```APIDOC
## pub fn system() -> Self

### Description
Creates a new manager instance configured for system-level services.

## pub fn user() -> Self

### Description
Creates a new manager instance configured for user-level services.
```

--------------------------------

### pub fn systemd_global_dir_path() -> PathBuf

Source: https://docs.rs/service-manager/latest/service_manager/fn.systemd_global_dir_path.html?search=

Retrieves the global directory path for systemd configurations.

```APIDOC
## Function: systemd_global_dir_path

### Description
Returns the global directory path used by systemd as a `PathBuf`.

### Signature
`pub fn systemd_global_dir_path() -> PathBuf`

### Returns
- **PathBuf** - The path to the global systemd directory.
```

--------------------------------

### LaunchdServiceManager::with_config

Source: https://docs.rs/service-manager/latest/service_manager/struct.LaunchdServiceManager.html

Updates the manager instance to use a specific LaunchdConfig.

```APIDOC
## pub fn with_config(self, config: LaunchdConfig) -> Self

### Description
Update manager to use the specified config.

### Parameters
- **config** (LaunchdConfig) - Required - Configuration settings tied to launchd services.
```

--------------------------------

### PartialEq Implementation for SystemdInstallConfig

Source: https://docs.rs/service-manager/latest/service_manager/struct.SystemdInstallConfig.html?search=u32+-%3E+bool

Implementation of equality testing for the SystemdInstallConfig struct.

```rust
fn eq(&self, other: &SystemdInstallConfig) -> bool
```

--------------------------------

### LaunchdServiceManager::user

Source: https://docs.rs/service-manager/latest/service_manager/struct.LaunchdServiceManager.html

Creates a new manager instance configured to work with user-level services.

```APIDOC
## pub fn user() -> Self

### Description
Creates a new manager instance working with user services.

### Signature
`pub fn user() -> Self`
```

--------------------------------

### equivalent

Source: https://docs.rs/service-manager/latest/service_manager/fn.systemd_global_dir_path.html?search=u32+-%3E+bool

A collection of equivalent methods for various service manager configurations and types.

```APIDOC
## method equivalent

### Description
Checks for equivalence between the current instance and another instance of type K.

### Signature
`&, &K -> bool`

### Supported Types
- ServiceManagerKind
- LaunchdConfig
- LaunchdInstallConfig
- LaunchdServiceManager
- OpenRcConfig
- OpenRcServiceManager
- RcdConfig
- RcdServiceManager
- ScConfig
- ScInstallConfig
- WindowsServiceType
- WindowsStartType
- WindowsErrorSeverity
- ScServiceManager
- SystemdConfig
- SystemdInstallConfig
- SystemdServiceRestartType
- SystemdServiceManager
- TypedServiceManager
- WinSwConfig
- WinSwInstallConfig
- WinSwOptionsConfig
- WinSwOnFailureAction
- WinSwStartType
- WinSwPriority
- WinSwServiceManager
- ServiceLevel
- RestartPolicy
- ServiceStatus
- ServiceLabel
- ServiceInstallCtx
- ServiceUninstallCtx
- ServiceStartCtx
- ServiceStopCtx
- ServiceStatusCtx
```

--------------------------------

### Run systemd User Test

Source: https://docs.rs/service-manager/latest/service_manager/index.html

Execute a systemd user test using the `system-tests` crate. The `--nocapture` flag is used to display test output.

```bash
cargo test -p system-tests systemd_for_user -- --nocapture

```

--------------------------------

### equivalent(K) -> bool

Source: https://docs.rs/service-manager/latest/service_manager/fn.native_service_manager.html?search=u32+-%3E+bool

Checks if the current instance is equivalent to the provided generic parameter K.

```APIDOC
## Method: equivalent

### Description
Compares the current object instance with a generic parameter K (where u32 matches K) to determine equivalence.

### Signature
`fn equivalent(&self, other: &K) -> bool`

### Parameters
- **other** (&K) - The value to compare against.

### Returns
- **bool** - Returns true if the instances are equivalent, false otherwise.
```

--------------------------------

### OpenRcServiceManager::system

Source: https://docs.rs/service-manager/latest/service_manager/struct.OpenRcServiceManager.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new instance of the OpenRcServiceManager configured for system services.

```APIDOC
## pub fn system() -> Self

### Description
Creates a new manager instance working with system services.

### Returns
- **Self** - A new instance of OpenRcServiceManager.
```

--------------------------------

### LaunchdServiceManager Constructors

Source: https://docs.rs/service-manager/latest/service_manager/struct.LaunchdServiceManager.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods to instantiate a new LaunchdServiceManager for system or user-level service management.

```APIDOC
## pub fn system() -> Self

### Description
Creates a new manager instance working with system services.

## pub fn user() -> Self

### Description
Creates a new manager instance working with user services.
```

--------------------------------

### Define WinSwStartType Enum

Source: https://docs.rs/service-manager/latest/service_manager/enum.WinSwStartType.html

The enumeration defining the available startup types for a Windows service.

```rust
pub enum WinSwStartType {
    Automatic,
    Boot,
    Manual,
    System,
}
```

--------------------------------

### Manage services with native platform detection

Source: https://docs.rs/service-manager/latest/service_manager/index.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Detect the host's service manager and perform lifecycle operations on a service.

```rust
use service_manager::*;
use std::ffi::OsString;
use std::path::PathBuf;

// Create a label for our service
let label: ServiceLabel = "com.example.my-service".parse().unwrap();

// Get generic service by detecting what is available on the platform
let manager = <dyn ServiceManager>::native()
    .expect("Failed to detect management platform");

// Install our service using the underlying service management platform
manager.install(ServiceInstallCtx {
    label: label.clone(),
    program: PathBuf::from("path/to/my-service-executable"),
    args: vec![OsString::from("--some-arg")],
    contents: None, // Optional String for system-specific service content.
    username: None, // Optional String for alternative user to run service.
    working_directory: None, // Optional String for the working directory for the service process.
    environment: None, // Optional list of environment variables to supply the service process.
    autostart: true, // Specify whether the service should automatically start upon OS reboot.
    restart_policy: RestartPolicy::default(), // Restart on failure by default.
}).expect("Failed to install");

// Start our service using the underlying service management platform
manager.start(ServiceStartCtx {
    label: label.clone()
}).expect("Failed to start");

// Stop our service using the underlying service management platform
manager.stop(ServiceStopCtx {
    label: label.clone()
}).expect("Failed to stop");

// Uninstall our service using the underlying service management platform
manager.uninstall(ServiceUninstallCtx {
    label: label.clone()
}).expect("Failed to stop");
```

--------------------------------

### RcdServiceManager Initialization

Source: https://docs.rs/service-manager/latest/service_manager/struct.RcdServiceManager.html

Methods for creating and configuring an instance of the RcdServiceManager.

```APIDOC
## pub fn system() -> Self

### Description
Creates a new manager instance working with system services.

## pub fn with_config(self, config: RcdConfig) -> Self

### Description
Update manager to use the specified config.
```

--------------------------------

### ServiceManager Factory Methods

Source: https://docs.rs/service-manager/latest/service_manager/trait.ServiceManager.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Static methods to instantiate a ServiceManager based on the host operating system or specific requirements.

```APIDOC
## ServiceManager Factory Methods

### target_or_native(kind: Option<ServiceManagerKind>)
Creates a new service manager of the specified kind, or falls back to the native manager for the current OS if no kind is provided.

### target(kind: ServiceManagerKind)
Creates a new service manager targeting the specific service manager kind.

### native()
Attempts to select and return the native service manager for the current operating system (e.g., systemd, launchd, or sc).
```

--------------------------------

### Service Management Operations

Source: https://docs.rs/service-manager/latest/service_manager/struct.RcdServiceManager.html

Methods for managing service lifecycles and status on FreeBSD systems.

```APIDOC
## fn available(&self) -> Result<bool>
Determines if the service manager exists and can be used.

## fn install(&self, ctx: ServiceInstallCtx) -> Result<()>
Installs a new service using the manager.

## fn uninstall(&self, ctx: ServiceUninstallCtx) -> Result<()>
Uninstalls an existing service using the manager.

## fn start(&self, ctx: ServiceStartCtx) -> Result<()>
Starts a service using the manager.

## fn stop(&self, ctx: ServiceStopCtx) -> Result<()>
Stops a running service using the manager.

## fn status(&self, ctx: ServiceStatusCtx) -> Result<ServiceStatus>
Return the service status info.
```

--------------------------------

### Define ScConfig struct

Source: https://docs.rs/service-manager/latest/service_manager/struct.ScConfig.html?search=

The primary structure for holding service configuration settings.

```rust
pub struct ScConfig {
    pub install: ScInstallConfig,
}
```

--------------------------------

### User-Level Service Management with service_manager

Source: https://docs.rs/service-manager/latest/service_manager/index.html

Configures the service manager to interact with user-level services, which is supported by platforms like systemd and launchd. This allows managing services specific to a user's session.

```rust
use service_manager::*

// Create a label for our service
let label: ServiceLabel = "com.example.my-service".parse().unwrap();

// Get generic service by detecting what is available on the platform
let mut manager = <dyn ServiceManager>::native()
    .expect("Failed to detect management platform");

// Update our manager to work with user-level services
manager.set_level(ServiceLevel::User)
    .expect("Service manager does not support user-level services");

// Continue operating as usual via install/uninstall/start/stop
// ...

```

--------------------------------

### ServiceStartCtx Struct Definition

Source: https://docs.rs/service-manager/latest/service_manager/struct.ServiceStartCtx.html

The definition of the ServiceStartCtx struct containing the service label.

```rust
pub struct ServiceStartCtx {
    pub label: ServiceLabel,
}
```

--------------------------------

### SystemdServiceManager::with_config

Source: https://docs.rs/service-manager/latest/service_manager/struct.SystemdServiceManager.html?search=

Updates the manager instance to use the specified SystemdConfig.

```APIDOC
### pub fn with_config(self, config: SystemdConfig) -> Self

Update manager to use the specified config.
```

--------------------------------

### ServiceManagerKind::native

Source: https://docs.rs/service-manager/latest/service_manager/enum.ServiceManagerKind.html?search=std%3A%3Avec

Looks up the kind of service management platform native to the operating system.

```APIDOC
## fn native()

### Description
Looks up the kind of service management platform native to the operating system.

### Signature
`pub fn native() -> Result<ServiceManagerKind>`

### Returns
- **Result<ServiceManagerKind>** - Returns the detected ServiceManagerKind or an error if the platform is not supported.
```

--------------------------------

### ServiceManagerKind::native()

Source: https://docs.rs/service-manager/latest/service_manager/enum.ServiceManagerKind.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves the service manager kind native to the current operating system.

```APIDOC
## fn native() -> Result<ServiceManagerKind>

### Description
Looks up the kind of service management platform native to the operating system.

### Returns
- **Result<ServiceManagerKind>** - Returns the detected service manager or an error if detection fails.
```

--------------------------------

### WinSwOptionsConfig Struct Definition

Source: https://docs.rs/service-manager/latest/service_manager/struct.WinSwOptionsConfig.html?search=

The primary structure defining configuration fields for Windows Service Wrapper integration.

```rust
pub struct WinSwOptionsConfig {
    pub priority: Option<WinSwPriority>,
    pub stop_timeout: Option<String>,
    pub stop_executable: Option<PathBuf>,
    pub stop_args: Option<Vec<OsString>>,
    pub start_mode: Option<WinSwStartType>,
    pub delayed_autostart: Option<bool>,
    pub dependent_services: Option<Vec<String>>,
    pub interactive: Option<bool>,
    pub beep_on_shutdown: Option<bool>,
}
```

--------------------------------

### SystemdServiceManager::with_config

Source: https://docs.rs/service-manager/latest/service_manager/struct.SystemdServiceManager.html

Updates the manager instance to use a specific SystemdConfig.

```APIDOC
## pub fn with_config(self, config: SystemdConfig) -> Self

### Description
Update manager to use the specified config.

### Parameters
- **config** (SystemdConfig) - Required - The configuration settings to apply.
```

--------------------------------

### ScServiceManager::with_config

Source: https://docs.rs/service-manager/latest/service_manager/struct.ScServiceManager.html

Updates the manager instance to use a specific configuration.

```APIDOC
### pub fn with_config(self, config: ScConfig) -> Self

Update manager to use the specified config.
```

--------------------------------

### WindowsStartType Enum Definition

Source: https://docs.rs/service-manager/latest/service_manager/enum.WindowsStartType.html

The definition of the WindowsStartType enum, listing all available startup configuration variants.

```rust
pub enum WindowsStartType {
    Boot,
    System,
    Auto,
    Demand,
    Disabled,
}
```

--------------------------------

### systemd_user_dir_path()

Source: https://docs.rs/service-manager/latest/service_manager/fn.systemd_user_dir_path.html?search=

Retrieves the path to the systemd user directory as a PathBuf.

```APIDOC
## Function: systemd_user_dir_path()

### Description
Returns the path to the systemd user directory.

### Signature
`pub fn systemd_user_dir_path() -> Result<PathBuf>`

### Returns
- **Result<PathBuf>** - Returns the path to the systemd user directory on success, or an error if the path cannot be determined.
```

--------------------------------

### SystemdServiceManager Constructors

Source: https://docs.rs/service-manager/latest/service_manager/struct.SystemdServiceManager.html?search=u32+-%3E+bool

Methods to instantiate a new SystemdServiceManager for system or user-level operations.

```APIDOC
## pub fn system() -> Self

Creates a new manager instance working with system services.

## pub fn user() -> Self

Creates a new manager instance working with user services.
```

--------------------------------

### Service Management Methods

Source: https://docs.rs/service-manager/latest/service_manager/struct.ScServiceManager.html

Methods for managing the lifecycle and status of services.

```APIDOC
### fn available(&self) -> Result<bool>
Determines if the service manager exists and can be used.

### fn install(&self, ctx: ServiceInstallCtx) -> Result<()>
Installs a new service using the manager.

### fn uninstall(&self, ctx: ServiceUninstallCtx) -> Result<()>
Uninstalls an existing service using the manager.

### fn start(&self, ctx: ServiceStartCtx) -> Result<()>
Starts a service using the manager.

### fn stop(&self, ctx: ServiceStopCtx) -> Result<()>
Stops a running service using the manager.

### fn status(&self, ctx: ServiceStatusCtx) -> Result<ServiceStatus>
Return the service status info.
```

--------------------------------

### WinSwServiceManager::write_service_configuration

Source: https://docs.rs/service-manager/latest/service_manager/struct.WinSwServiceManager.html

Writes the service configuration to the specified path.

```APIDOC
## pub fn write_service_configuration(path: &PathBuf, ctx: &ServiceInstallCtx, config: &WinSwConfig) -> Result<()>

### Description
Persists the service configuration to the filesystem.

### Parameters
- **path** (&PathBuf) - The destination path for the configuration file.
- **ctx** (&ServiceInstallCtx) - The installation context.
- **config** (&WinSwConfig) - The configuration data to write.
```

--------------------------------

### native_service_manager

Source: https://docs.rs/service-manager/latest/service_manager/fn.native_service_manager.html

Attempts to select a native service manager for the current operating system. It selects different implementations based on the OS: LaunchdServiceManager for MacOS, ScServiceManager for Windows, RcdServiceManager for BSD variants, and either SystemdServiceManager or OpenRcServiceManager for Linux variants.

```APIDOC
## Function native_service_manager

### Description
Attempts to select a native service manager for the current operating system.

### Returns
- `Result<Box<dyn ServiceManager>>`: A boxed trait object representing the selected service manager, or an error if selection fails.
```

--------------------------------

### cmd_iter

Source: https://docs.rs/service-manager/latest/service_manager/struct.ServiceInstallCtx.html?search=u32+-%3E+bool

Returns an iterator over the program and its arguments.

```APIDOC
## pub fn cmd_iter(&self) -> impl Iterator<Item = &OsStr>

### Description
Returns an iterator over the program and its arguments.
```

--------------------------------

### WinSwInstallConfig Struct Definition

Source: https://docs.rs/service-manager/latest/service_manager/struct.WinSwInstallConfig.html

The structure definition for WinSwInstallConfig, containing optional fields for WinSW-specific service settings.

```rust
pub struct WinSwInstallConfig {
    pub failure_action: Option<WinSwOnFailureAction>,
    pub reset_failure_time: Option<String>,
    pub security_descriptor: Option<String>,
}
```

--------------------------------

### From Trait Implementation

Source: https://docs.rs/service-manager/latest/service_manager/enum.ServiceManagerKind.html

Returns the argument unchanged.

```rust
fn from(t: T) -> T
```

--------------------------------

### OpenRcServiceManager::with_config

Source: https://docs.rs/service-manager/latest/service_manager/struct.OpenRcServiceManager.html

Updates the manager instance to use a specific OpenRcConfig.

```APIDOC
## pub fn with_config(self, config: OpenRcConfig) -> Self

### Description
Update manager to use the specified config.

### Parameters
- **config** (OpenRcConfig) - Required - The configuration settings to apply to the manager.
```

--------------------------------

### Define OpenRcConfig Struct

Source: https://docs.rs/service-manager/latest/service_manager/struct.OpenRcConfig.html

The basic definition of the OpenRcConfig struct.

```rust
pub struct OpenRcConfig {}
```

--------------------------------

### CloneToUninit Trait Implementation

Source: https://docs.rs/service-manager/latest/service_manager/enum.ServiceManagerKind.html

Performs copy-assignment from self to a destination pointer. This is a nightly-only experimental API.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

--------------------------------

### TypedServiceManager::target_or_native

Source: https://docs.rs/service-manager/latest/service_manager/enum.TypedServiceManager.html

Creates a new service manager instance, either by specifying a kind or falling back to the native manager for the current OS.

```APIDOC
## fn target_or_native(kind: impl Into<Option<ServiceManagerKind>>) -> Result<Self>

### Description
Creates a new service manager instance. If a `ServiceManagerKind` is provided, it targets that specific manager; otherwise, it attempts to detect and use the native service manager for the current operating system.

### Parameters
- **kind** (impl Into<Option<ServiceManagerKind>>) - Optional - The specific service manager type to instantiate.
```

--------------------------------

### systemd_global_dir_path Function

Source: https://docs.rs/service-manager/latest/service_manager/all.html

Returns the default directory path for global systemd service unit files.

```APIDOC
## Function: systemd_global_dir_path

### Description
Provides the standard file system path where systemd unit files for system-wide services are typically located. This is often used when installing or managing system services that require systemd integration.

### Returns
- `PathBuf`: The absolute path to the systemd global unit directory.
```

--------------------------------

### systemd_user_dir_path Function

Source: https://docs.rs/service-manager/latest/service_manager/all.html

Returns the default directory path for user-specific systemd service unit files.

```APIDOC
## Function: systemd_user_dir_path

### Description
Provides the standard file system path where systemd unit files for user services are typically located. This is useful for managing services that should run under a specific user's context.

### Returns
- `PathBuf`: The absolute path to the systemd user unit directory.
```

--------------------------------

### RcdConfig Definition

Source: https://docs.rs/service-manager/latest/service_manager/struct.RcdConfig.html

The basic structure definition for RcdConfig.

```rust
pub struct RcdConfig {}
```

--------------------------------

### ServiceManagerKind::native()

Source: https://docs.rs/service-manager/latest/service_manager/enum.ServiceManagerKind.html?search=

Detects and returns the service manager kind native to the current operating system.

```APIDOC
## fn native() -> Result<ServiceManagerKind>

### Description
Looks up the kind of service management platform native to the operating system.

### Returns
- **Result<ServiceManagerKind>** - Returns the detected ServiceManagerKind or an error if the platform is not supported.
```

--------------------------------

### LaunchdServiceManager Configuration

Source: https://docs.rs/service-manager/latest/service_manager/struct.LaunchdServiceManager.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods to modify the configuration or target level of an existing manager instance.

```APIDOC
## pub fn into_system(self) -> Self

### Description
Change manager to work with system services.

## pub fn into_user(self) -> Self

### Description
Change manager to work with user services.

## pub fn with_config(self, config: LaunchdConfig) -> Self

### Description
Update manager to use the specified config.
```

--------------------------------

### LaunchdServiceManager Configuration

Source: https://docs.rs/service-manager/latest/service_manager/struct.LaunchdServiceManager.html?search=std%3A%3Avec

Methods to modify the configuration or target level of an existing manager instance.

```APIDOC
## pub fn into_system(self) -> Self

### Description
Changes the manager instance to operate on system services.

## pub fn into_user(self) -> Self

### Description
Changes the manager instance to operate on user services.

## pub fn with_config(self, config: LaunchdConfig) -> Self

### Description
Updates the manager instance to use the provided LaunchdConfig settings.
```

--------------------------------

### LaunchdServiceManager Definition

Source: https://docs.rs/service-manager/latest/service_manager/struct.LaunchdServiceManager.html?search=

The primary structure for managing launchd services, containing configuration and scope settings.

```rust
pub struct LaunchdServiceManager {
    pub user: bool,
    pub config: LaunchdConfig,
}
```

--------------------------------

### systemd_user_dir_path()

Source: https://docs.rs/service-manager/latest/service_manager/fn.systemd_user_dir_path.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves the path for systemd user directories as a Result containing a PathBuf.

```APIDOC
## Function: systemd_user_dir_path

### Description
Returns the path to the systemd user directory.

### Signature
`pub fn systemd_user_dir_path() -> Result<PathBuf>`

### Returns
- **Result<PathBuf>** - Returns a PathBuf containing the directory path on success, or an error if the path cannot be determined.
```

--------------------------------

### RcdServiceManager::system

Source: https://docs.rs/service-manager/latest/service_manager/struct.RcdServiceManager.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new instance of RcdServiceManager configured for system services.

```APIDOC
## pub fn system() -> Self

### Description
Creates a new manager instance working with system services.

### Returns
- **Self** - A new instance of RcdServiceManager.
```

--------------------------------

### SystemdConfig Struct Definition

Source: https://docs.rs/service-manager/latest/service_manager/struct.SystemdConfig.html

The primary structure used to define systemd service configuration.

```rust
pub struct SystemdConfig {
    pub install: SystemdInstallConfig,
}
```

--------------------------------

### Service Management Operations

Source: https://docs.rs/service-manager/latest/service_manager/struct.LaunchdServiceManager.html?search=std%3A%3Avec

Core service lifecycle operations implemented by the LaunchdServiceManager.

```APIDOC
## fn available(&self) -> Result<bool>
### Description
Checks if the launchd service manager is available on the current system.

## fn install(&self, ctx: ServiceInstallCtx) -> Result<()>
### Description
Installs a new service using the manager.

## fn uninstall(&self, ctx: ServiceUninstallCtx) -> Result<()>
### Description
Uninstalls an existing service. Note: For services with 'KeepAlive' enabled, this should be used instead of stop.

## fn start(&self, ctx: ServiceStartCtx) -> Result<()>
### Description
Starts a service managed by launchd.

## fn stop(&self, ctx: ServiceStopCtx) -> Result<()>
### Description
Stops a service managed by launchd.

## fn status(&self, ctx: ServiceStatusCtx) -> Result<ServiceStatus>
### Description
Retrieves the current status information for a service.
```

--------------------------------

### ServiceManager::uninstall

Source: https://docs.rs/service-manager/latest/service_manager/index.html?search=std%3A%3Avec

Uninstalls a service from the system.

```APIDOC
## uninstall(ServiceUninstallCtx)

### Description
Removes an installed service from the system.

### Parameters
- **ServiceUninstallCtx** (struct) - Required - Context containing the service label to uninstall.
```

--------------------------------

### ServiceManager::uninstall

Source: https://docs.rs/service-manager/latest/service_manager/index.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Uninstalls a service from the system.

```APIDOC
## uninstall(ServiceUninstallCtx)

### Description
Removes an installed service from the system management platform.

### Parameters
- **ServiceUninstallCtx** (struct) - Required - Contains the ServiceLabel of the service to uninstall.
```

--------------------------------

### ServiceStopCtx Struct Definition

Source: https://docs.rs/service-manager/latest/service_manager/struct.ServiceStopCtx.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

The definition of the ServiceStopCtx struct, which holds the label for a service.

```rust
pub struct ServiceStopCtx {
    pub label: ServiceLabel,
}
```

--------------------------------

### ServiceManager::uninstall

Source: https://docs.rs/service-manager/latest/service_manager/index.html?search=

Uninstalls a service.

```APIDOC
## fn uninstall(&self, ctx: ServiceUninstallCtx) -> Result<()>

### Description
Removes an installed service identified by the label in the provided context.

### Parameters
- **ctx** (ServiceUninstallCtx) - Required - The context containing the service label.
```

--------------------------------

### LaunchdServiceManager::status

Source: https://docs.rs/service-manager/latest/service_manager/struct.LaunchdServiceManager.html

Retrieves the current status information for a service.

```APIDOC
## fn status(&self, ctx: ServiceStatusCtx) -> Result<ServiceStatus>

### Description
Return the service status info.

### Parameters
- **ctx** (ServiceStatusCtx) - Required - Context containing status request details.
```

--------------------------------

### Define OpenRcServiceManager struct

Source: https://docs.rs/service-manager/latest/service_manager/struct.OpenRcServiceManager.html?search=

The primary structure for managing OpenRC services, containing the necessary configuration.

```rust
pub struct OpenRcServiceManager {
    pub config: OpenRcConfig,
}
```

--------------------------------

### native_service_manager Function

Source: https://docs.rs/service-manager/latest/service_manager/all.html

Retrieves a service manager instance that is native to the current operating system.

```APIDOC
## Function: native_service_manager

### Description
This function attempts to detect and return an instance of the `ServiceManager` trait that corresponds to the init system or service management framework native to the current operating system. This is a convenient way to get a default, appropriate service manager without manual configuration.

### Returns
- `Box<dyn ServiceManager>`: A boxed trait object representing the native service manager. The specific type will vary depending on the OS (e.g., `SystemdServiceManager` on Linux with systemd, `WinSwServiceManager` on Windows).
```

--------------------------------

### WinSwConfig Struct Definition

Source: https://docs.rs/service-manager/latest/service_manager/struct.WinSwConfig.html?search=

The primary structure definition for WinSwConfig, which holds configuration data for Windows services.

```rust
pub struct WinSwConfig {
    pub install: WinSwInstallConfig,
    pub options: WinSwOptionsConfig,
    pub service_definition_dir_path: PathBuf,
}
```

--------------------------------

### TypedServiceManager::target_or_native

Source: https://docs.rs/service-manager/latest/service_manager/enum.TypedServiceManager.html?search=

Creates a new service manager instance based on the provided kind, or falls back to the native service manager if no kind is specified.

```APIDOC
## pub fn target_or_native(kind: impl Into<Option<ServiceManagerKind>>) -> Result<Self>

### Description
Creates a new service using the specified type, falling back to selecting based on native service manager for the current operating system if no type provided.

### Parameters
- **kind** (impl Into<Option<ServiceManagerKind>>) - Optional - The specific service manager kind to target.
```

--------------------------------

### Into Trait Implementation

Source: https://docs.rs/service-manager/latest/service_manager/enum.ServiceManagerKind.html

Performs a conversion by calling U::from(self).

```rust
fn into(self) -> U
```

--------------------------------

### TypedServiceManager::native

Source: https://docs.rs/service-manager/latest/service_manager/enum.TypedServiceManager.html

Attempts to automatically detect and return the native service manager for the current operating system.

```APIDOC
## fn native() -> Result<Self>

### Description
Detects the host operating system and returns the corresponding native service manager (e.g., systemd for Linux, Launchd for MacOS, Sc for Windows).
```

--------------------------------

### TypedServiceManager::native

Source: https://docs.rs/service-manager/latest/service_manager/enum.TypedServiceManager.html?search=

Attempts to automatically detect and return the native service manager for the current operating system.

```APIDOC
## pub fn native() -> Result<Self>

### Description
Attempts to select the native service manager for the current operating system. 
- MacOS: LaunchdServiceManager
- Windows: ScServiceManager
- BSD: RcdServiceManager
- Linux: SystemdServiceManager or OpenRcServiceManager
```

--------------------------------

### ServiceManager Trait Methods

Source: https://docs.rs/service-manager/latest/service_manager/struct.LaunchdServiceManager.html?search=u32+-%3E+bool

Methods implemented for LaunchdServiceManager to manage service lifecycles.

```APIDOC
### Service Lifecycle Methods

- **available() -> Result<bool>**: Determines if the service manager exists and can be used.
- **install(ctx: ServiceInstallCtx) -> Result<()>**: Installs a new service.
- **uninstall(ctx: ServiceUninstallCtx) -> Result<()>**: Uninstalls an existing service.
- **start(ctx: ServiceStartCtx) -> Result<()>**: Starts a service.
- **stop(ctx: ServiceStopCtx) -> Result<()>**: Stops a service. Note: For services with 'KeepAlive' enabled, use uninstall instead.
- **status(ctx: ServiceStatusCtx) -> Result<ServiceStatus>**: Returns the current service status information.
```

--------------------------------

### ServiceLabel Struct Definition

Source: https://docs.rs/service-manager/latest/service_manager/struct.ServiceLabel.html

The primary structure used to define a service label.

```rust
pub struct ServiceLabel {
    pub qualifier: Option<String>,
    pub organization: Option<String>,
    pub application: String,
}
```

--------------------------------

### RcdServiceManager::with_config

Source: https://docs.rs/service-manager/latest/service_manager/struct.RcdServiceManager.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Updates the manager instance to use a specific RcdConfig.

```APIDOC
## pub fn with_config(self, config: RcdConfig) -> Self

### Description
Update manager to use the specified configuration.

### Parameters
- **config** (RcdConfig) - The configuration settings to apply.

### Returns
- **Self** - The updated RcdServiceManager instance.
```

--------------------------------

### ServiceUninstallCtx Struct Definition

Source: https://docs.rs/service-manager/latest/service_manager/struct.ServiceUninstallCtx.html

The structure definition for ServiceUninstallCtx, which holds the label of the service to be uninstalled.

```rust
pub struct ServiceUninstallCtx {
    pub label: ServiceLabel,
}
```

--------------------------------

### WinSwServiceManager Struct Definition

Source: https://docs.rs/service-manager/latest/service_manager/struct.WinSwServiceManager.html?search=

The primary structure containing the configuration for the Windows service manager.

```rust
pub struct WinSwServiceManager {
    pub config: WinSwConfig,
}
```

--------------------------------

### args_iter

Source: https://docs.rs/service-manager/latest/service_manager/struct.ServiceInstallCtx.html?search=u32+-%3E+bool

Returns an iterator over the program arguments.

```APIDOC
## pub fn args_iter(&self) -> impl Iterator<Item = &OsStr>

### Description
Returns an iterator over the program arguments.
```

--------------------------------

### Define SystemdServiceManager struct

Source: https://docs.rs/service-manager/latest/service_manager/struct.SystemdServiceManager.html

The structure definition for SystemdServiceManager, containing the user-level flag and systemd configuration.

```rust
pub struct SystemdServiceManager {
    pub user: bool,
    pub config: SystemdConfig,
}
```

--------------------------------

### Equivalent Trait Implementation

Source: https://docs.rs/service-manager/latest/service_manager/enum.ServiceManagerKind.html

Checks if a value is equivalent to a given key.

```rust
fn equivalent(&self, key: &K) -> bool
```

--------------------------------

### Equivalent Trait Method Signature

Source: https://docs.rs/service-manager/latest/service_manager/fn.native_service_manager.html?search=u32+-%3E+bool

The signature used by various structs in the crate to check for equivalence against a generic type K.

```rust
&, &**K** -> **bool**
where
u32 matches **K**
```

--------------------------------

### Define SystemdServiceRestartType Enum

Source: https://docs.rs/service-manager/latest/service_manager/enum.SystemdServiceRestartType.html?search=

The enumeration defining the available restart types for systemd services.

```rust
pub enum SystemdServiceRestartType {
    No,
    Always,
    OnSuccess,
    OnFailure,
    OnAbnormal,
    OnAbort,
    OnWatch,
}
```

--------------------------------

### native_service_manager function signature

Source: https://docs.rs/service-manager/latest/service_manager/fn.native_service_manager.html?search=

Returns a Result containing a boxed ServiceManager trait object for the current platform.

```rust
pub fn native_service_manager() -> Result<Box<dyn ServiceManager>>
```

--------------------------------

### ToString Trait Implementation

Source: https://docs.rs/service-manager/latest/service_manager/enum.WindowsStartType.html?search=std%3A%3Avec

Converts a value to a String.

```rust
impl<T> ToString for T
where T: Display + ?Sized,
```

```rust
fn to_string(&self) -> String
```

--------------------------------

### TypedServiceManager Methods

Source: https://docs.rs/service-manager/latest/service_manager/enum.TypedServiceManager.html?search=std%3A%3Avec

Methods available for managing services through the TypedServiceManager interface.

```APIDOC
## Service Management Methods

### available()
Determines if the service manager exists and can be used on the current system.

### install(ctx: ServiceInstallCtx)
Installs a new service using the manager.

### uninstall(ctx: ServiceUninstallCtx)
Uninstalls an existing service using the manager.

### start(ctx: ServiceStartCtx)
Starts a service using the manager.

### stop(ctx: ServiceStopCtx)
Stops a running service using the manager.

### level()
Returns the current target level for the manager.

### set_level(level: ServiceLevel)
Sets the target level for the manager.

### status(ctx: ServiceStatusCtx)
Returns the current service status information.
```

--------------------------------

### ServiceManager Trait Methods

Source: https://docs.rs/service-manager/latest/service_manager/struct.OpenRcServiceManager.html?search=std%3A%3Avec

Methods available for managing services via the OpenRcServiceManager implementation.

```APIDOC
## ServiceManager Methods

### available()
Determines if the service manager exists and can be used.

### install(ctx: ServiceInstallCtx)
Installs a new service using the manager.

### uninstall(ctx: ServiceUninstallCtx)
Uninstalls an existing service using the manager.

### start(ctx: ServiceStartCtx)
Starts a service using the manager.

### stop(ctx: ServiceStopCtx)
Stops a running service using the manager.

### level()
Returns the current target level for the manager.

### set_level(level: ServiceLevel)
Sets the target level for the manager.

### status(ctx: ServiceStatusCtx)
Return the service status info.
```

--------------------------------

### Define WindowsServiceType Enum

Source: https://docs.rs/service-manager/latest/service_manager/enum.WindowsServiceType.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

The enumeration defining the supported Windows service types.

```rust
pub enum WindowsServiceType {
    Own,
    Share,
    Kernel,
    FileSys,
    Rec,
}
```

--------------------------------

### ServiceManager Trait Methods

Source: https://docs.rs/service-manager/latest/service_manager/trait.ServiceManager.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

The core methods available on any ServiceManager implementation for managing service lifecycles.

```APIDOC
## ServiceManager Trait Methods

### available()
Determines if the service manager exists and is available on the current system.

### install(ctx: ServiceInstallCtx)
Installs a new service using the manager.

### uninstall(ctx: ServiceUninstallCtx)
Uninstalls an existing service using the manager.

### start(ctx: ServiceStartCtx)
Starts a service using the manager.

### stop(ctx: ServiceStopCtx)
Stops a running service using the manager.

### level()
Returns the current target level for the manager.

### set_level(level: ServiceLevel)
Sets the target level for the manager.

### status(ctx: ServiceStatusCtx)
Returns the current service status information.
```

--------------------------------

### Any Trait Implementation

Source: https://docs.rs/service-manager/latest/service_manager/enum.ServiceManagerKind.html

Provides the type_id method for any type that satisfies the 'static and ?Sized bounds.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### SystemdServiceManager Configuration

Source: https://docs.rs/service-manager/latest/service_manager/struct.SystemdServiceManager.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods to modify the configuration or scope of an existing manager instance.

```APIDOC
## pub fn into_system(self) -> Self

### Description
Changes the manager scope to operate on system services.

## pub fn into_user(self) -> Self

### Description
Changes the manager scope to operate on user services.

## pub fn with_config(self, config: SystemdConfig) -> Self

### Description
Updates the manager to use the provided SystemdConfig settings.
```

--------------------------------

### ServiceStatusCtx Struct Definition

Source: https://docs.rs/service-manager/latest/service_manager/struct.ServiceStatusCtx.html

The definition of the ServiceStatusCtx struct, which holds the label associated with a service.

```rust
pub struct ServiceStatusCtx {
    pub label: ServiceLabel,
}
```

--------------------------------

### ScServiceManager Struct Definition

Source: https://docs.rs/service-manager/latest/service_manager/struct.ScServiceManager.html?search=

The primary structure for managing Windows services via sc.exe.

```rust
pub struct ScServiceManager {
    pub config: ScConfig,
}
```
Tokens:
Raw