使用Rust实现Windows服务

#[macro_use]extern crate windows_service;
use std::ffi::OsString;use windows_service::service_dispatcher;
define_windows_service!(ffi_service_main, my_service_main);
fn my_service_main(arguments: Vec<OsString>) {    // The entry point where execution will start on a background thread after a call to    // `service_dispatcher::start` from `main`.}
fn main() -> Result<(), windows_service::Error> {    // Register generated `ffi_service_main` with the system and start the service, blocking    // this thread until the service is stopped.    service_dispatcher::start("myservice", ffi_service_main)?;    Ok(())}

extern crate windows_service;
use std::ffi::OsString;use windows_service::service::ServiceControl;use windows_service::service_control_handler::{self, ServiceControlHandlerResult};
fn my_service_main(arguments: Vec<OsString>) {    if let Err(_e) = run_service(arguments) {        // Handle errors in some way.    }}
fn run_service(arguments: Vec<OsString>) -> Result<(), windows_service::Error> {    let event_handler = move |control_event| -> ServiceControlHandlerResult {        match control_event {            ServiceControl::Stop => {                // Handle stop event and return control back to the system.                ServiceControlHandlerResult::NoError            }            // All services must accept Interrogate even if it's a no-op.            ServiceControl::Interrogate => ServiceControlHandlerResult::NoError,            _ => ServiceControlHandlerResult::NotImplemented,        }    };
    // Register system service event handler    let status_handle = service_control_handler::register("myservice", event_handler)?;    Ok(())}

extern crate windows_service;
use std::ffi::OsString;use std::time::Duration;use windows_service::service::{    ServiceControl, ServiceControlAccept, ServiceExitCode, ServiceState, ServiceStatus,    ServiceType,};use windows_service::service_control_handler::{self, ServiceControlHandlerResult};
fn my_service_main(arguments: Vec<OsString>) {    if let Err(_e) = run_service(arguments) {        // Handle error in some way.    }}
fn run_service(arguments: Vec<OsString>) -> windows_service::Result<()> {    let event_handler = move |control_event| -> ServiceControlHandlerResult {        match control_event {            ServiceControl::Stop | ServiceControl::Interrogate => {                ServiceControlHandlerResult::NoError            }            _ => ServiceControlHandlerResult::NotImplemented,        }    };
    // Register system service event handler    let status_handle = service_control_handler::register("my_service_name", event_handler)?;
    let next_status = ServiceStatus {        // Should match the one from system service registry        service_type: ServiceType::OWN_PROCESS,        // The new state        current_state: ServiceState::Running,        // Accept stop events when running        controls_accepted: ServiceControlAccept::STOP,        // Used to report an error when starting or stopping only, otherwise must be zero        exit_code: ServiceExitCode::Win32(0),        // Only used for pending states, otherwise must be zero        checkpoint: 0,        // Only used for pending states, otherwise must be zero        wait_hint: Duration::default(),    };
    // Tell the system that the service is running now    status_handle.set_service_status(next_status)?;
    // Do some work
    Ok(())}