Struct ServiceSpec 

pub struct ServiceSpec {
    pub path: PathBuf,
    pub args: Vec<OsString>,
    pub display_name: Option<OsString>,
    pub description: Option<OsString>,
    pub autostart: bool,
    pub restart_on_failure: bool,
    pub user: Option<OsString>,
    pub password: Option<OsString>,
    pub group: Option<OsString>,
}

A specification of a service to be installed.

Fields

path: PathBuf

The path to the executable to run when the service starts.

args: Vec<OsString>

The arguments to pass to the executable.

display_name: Option<OsString>

The display name of the service.

description: Option<OsString>

The description of the service.

autostart: bool

Whether the service should start automatically when the system boots or user logs in.

restart_on_failure: bool

Whether the service should be restarted if it fails.

user: Option<OsString>

User to run the service as.

password: Option<OsString>

Password to use for the user.

group: Option<OsString>

Group to run the service as.

Implementations

impl ServiceSpec

pub fn new(path: impl Into<PathBuf>) -> Self

Creates a new service specification with the given path to the executable.

Examples found in repository

examples/manager.rs (line 30)

fn run(
    service_name: &str,
    display_name: &str,
    description: &str,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    // Windows user services require a new logon before they can be started, so we will use a system service on Windows.
    // NOTE: Windows services always require elevated privileges to install, so run this example as administrator.
    let user = !UniServiceManager::capabilities()
        .contains(ServiceCapabilities::USER_SERVICES_REQUIRE_NEW_LOGON);
    let user_manager = UniServiceManager::new(service_name, "com.example.", user)?;

    let mut bin_path = std::env::current_exe().unwrap();
    bin_path.set_file_name(service_name);

    if !bin_path.exists() {
        return Err(format!(
            "Executable not found: {}. Make sure to build the service examples first.",
            bin_path.display()
        )
        .into());
    }

    let spec = ServiceSpec::new(bin_path)
        .arg("service")?
        .display_name(display_name)?
        .description(description)?;

    print!("Installing service '{service_name}'...",);
    user_manager.install_and_wait(&spec, TIMEOUT)?;
    println!("done");

    print!("Starting service '{service_name}'...");
    user_manager.start_and_wait(TIMEOUT)?;
    println!("done");

    io::stdout().flush()?;
    println!("Press Enter to stop the service...");
    let mut buffer = String::new();
    io::stdin().read_line(&mut buffer)?;

    print!("Stopping service '{service_name}'...");
    user_manager.stop_and_wait(TIMEOUT)?;
    println!("done");

    print!("Uninstalling service '{service_name}'...");
    user_manager.uninstall_and_wait(TIMEOUT)?;
    println!("done");

    Ok(())
}

pub fn arg(self, arg: impl Into<OsString>) -> UniResult<Self, ServiceErrKind>

Adds an argument to the executable.

Examples found in repository

examples/manager.rs (line 31)

fn run(
    service_name: &str,
    display_name: &str,
    description: &str,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    // Windows user services require a new logon before they can be started, so we will use a system service on Windows.
    // NOTE: Windows services always require elevated privileges to install, so run this example as administrator.
    let user = !UniServiceManager::capabilities()
        .contains(ServiceCapabilities::USER_SERVICES_REQUIRE_NEW_LOGON);
    let user_manager = UniServiceManager::new(service_name, "com.example.", user)?;

    let mut bin_path = std::env::current_exe().unwrap();
    bin_path.set_file_name(service_name);

    if !bin_path.exists() {
        return Err(format!(
            "Executable not found: {}. Make sure to build the service examples first.",
            bin_path.display()
        )
        .into());
    }

    let spec = ServiceSpec::new(bin_path)
        .arg("service")?
        .display_name(display_name)?
        .description(description)?;

    print!("Installing service '{service_name}'...",);
    user_manager.install_and_wait(&spec, TIMEOUT)?;
    println!("done");

    print!("Starting service '{service_name}'...");
    user_manager.start_and_wait(TIMEOUT)?;
    println!("done");

    io::stdout().flush()?;
    println!("Press Enter to stop the service...");
    let mut buffer = String::new();
    io::stdin().read_line(&mut buffer)?;

    print!("Stopping service '{service_name}'...");
    user_manager.stop_and_wait(TIMEOUT)?;
    println!("done");

    print!("Uninstalling service '{service_name}'...");
    user_manager.uninstall_and_wait(TIMEOUT)?;
    println!("done");

    Ok(())
}

pub fn display_name( self, display_name: impl Into<OsString>, ) -> UniResult<Self, ServiceErrKind>

Sets the display name of the service.

Examples found in repository

examples/manager.rs (line 32)

fn run(
    service_name: &str,
    display_name: &str,
    description: &str,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    // Windows user services require a new logon before they can be started, so we will use a system service on Windows.
    // NOTE: Windows services always require elevated privileges to install, so run this example as administrator.
    let user = !UniServiceManager::capabilities()
        .contains(ServiceCapabilities::USER_SERVICES_REQUIRE_NEW_LOGON);
    let user_manager = UniServiceManager::new(service_name, "com.example.", user)?;

    let mut bin_path = std::env::current_exe().unwrap();
    bin_path.set_file_name(service_name);

    if !bin_path.exists() {
        return Err(format!(
            "Executable not found: {}. Make sure to build the service examples first.",
            bin_path.display()
        )
        .into());
    }

    let spec = ServiceSpec::new(bin_path)
        .arg("service")?
        .display_name(display_name)?
        .description(description)?;

    print!("Installing service '{service_name}'...",);
    user_manager.install_and_wait(&spec, TIMEOUT)?;
    println!("done");

    print!("Starting service '{service_name}'...");
    user_manager.start_and_wait(TIMEOUT)?;
    println!("done");

    io::stdout().flush()?;
    println!("Press Enter to stop the service...");
    let mut buffer = String::new();
    io::stdin().read_line(&mut buffer)?;

    print!("Stopping service '{service_name}'...");
    user_manager.stop_and_wait(TIMEOUT)?;
    println!("done");

    print!("Uninstalling service '{service_name}'...");
    user_manager.uninstall_and_wait(TIMEOUT)?;
    println!("done");

    Ok(())
}

pub fn description( self, desc: impl Into<OsString>, ) -> UniResult<Self, ServiceErrKind>

Sets the description of the service.

Examples found in repository

examples/manager.rs (line 33)

fn run(
    service_name: &str,
    display_name: &str,
    description: &str,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    // Windows user services require a new logon before they can be started, so we will use a system service on Windows.
    // NOTE: Windows services always require elevated privileges to install, so run this example as administrator.
    let user = !UniServiceManager::capabilities()
        .contains(ServiceCapabilities::USER_SERVICES_REQUIRE_NEW_LOGON);
    let user_manager = UniServiceManager::new(service_name, "com.example.", user)?;

    let mut bin_path = std::env::current_exe().unwrap();
    bin_path.set_file_name(service_name);

    if !bin_path.exists() {
        return Err(format!(
            "Executable not found: {}. Make sure to build the service examples first.",
            bin_path.display()
        )
        .into());
    }

    let spec = ServiceSpec::new(bin_path)
        .arg("service")?
        .display_name(display_name)?
        .description(description)?;

    print!("Installing service '{service_name}'...",);
    user_manager.install_and_wait(&spec, TIMEOUT)?;
    println!("done");

    print!("Starting service '{service_name}'...");
    user_manager.start_and_wait(TIMEOUT)?;
    println!("done");

    io::stdout().flush()?;
    println!("Press Enter to stop the service...");
    let mut buffer = String::new();
    io::stdin().read_line(&mut buffer)?;

    print!("Stopping service '{service_name}'...");
    user_manager.stop_and_wait(TIMEOUT)?;
    println!("done");

    print!("Uninstalling service '{service_name}'...");
    user_manager.uninstall_and_wait(TIMEOUT)?;
    println!("done");

    Ok(())
}

pub fn set_autostart(self) -> Self

Sets whether the service should start automatically when the system boots or user logs in.

pub fn set_restart_on_failure(self) -> Self

Sets whether the service should be restarted if it fails.

pub fn set_user( self, user: impl Into<OsString>, ) -> UniResult<Self, ServiceErrKind>

Sets the user to run the service as.

pub fn set_password( self, password: impl Into<OsString>, ) -> UniResult<Self, ServiceErrKind>

Sets the password to use for the user.

pub fn set_group( self, group: impl Into<OsString>, ) -> UniResult<Self, ServiceErrKind>

Sets the group to run the service as.