windows_service::service_control_handler

Struct ServiceStatusHandle

pub struct ServiceStatusHandle(/* private fields */);

Expand description

A struct that holds a unique token for updating the status of the corresponding service.

Implementations§

Source §

impl ServiceStatusHandle

Source

pub fn set_service_status(&self, service_status: ServiceStatus) -> Result<()>

Report the new service status to the system.

Examples found in repository ?

examples/ping_service.rs (lines 105-113)

71    pub fn run_service() -> Result<()> {
72        // Create a channel to be able to poll a stop event from the service worker loop.
73        let (shutdown_tx, shutdown_rx) = mpsc::channel();
74
75        // Define system service event handler that will be receiving service events.
76        let event_handler = move |control_event| -> ServiceControlHandlerResult {
77            match control_event {
78                // Notifies a service to report its current status information to the service
79                // control manager. Always return NoError even if not implemented.
80                ServiceControl::Interrogate => ServiceControlHandlerResult::NoError,
81
82                // Handle stop
83                ServiceControl::Stop => {
84                    shutdown_tx.send(()).unwrap();
85                    ServiceControlHandlerResult::NoError
86                }
87
88                // treat the UserEvent as a stop request
89                ServiceControl::UserEvent(code) => {
90                    if code.to_raw() == 130 {
91                        shutdown_tx.send(()).unwrap();
92                    }
93                    ServiceControlHandlerResult::NoError
94                }
95
96                _ => ServiceControlHandlerResult::NotImplemented,
97            }
98        };
99
100        // Register system service event handler.
101        // The returned status handle should be used to report service status changes to the system.
102        let status_handle = service_control_handler::register(SERVICE_NAME, event_handler)?;
103
104        // Tell the system that service is running
105        status_handle.set_service_status(ServiceStatus {
106            service_type: SERVICE_TYPE,
107            current_state: ServiceState::Running,
108            controls_accepted: ServiceControlAccept::STOP,
109            exit_code: ServiceExitCode::Win32(0),
110            checkpoint: 0,
111            wait_hint: Duration::default(),
112            process_id: None,
113        })?;
114
115        // For demo purposes this service sends a UDP packet once a second.
116        let loopback_ip = IpAddr::from(LOOPBACK_ADDR);
117        let sender_addr = SocketAddr::new(loopback_ip, 0);
118        let receiver_addr = SocketAddr::new(loopback_ip, RECEIVER_PORT);
119        let msg = PING_MESSAGE.as_bytes();
120        let socket = UdpSocket::bind(sender_addr).unwrap();
121
122        loop {
123            let _ = socket.send_to(msg, receiver_addr);
124
125            // Poll shutdown event.
126            match shutdown_rx.recv_timeout(Duration::from_secs(1)) {
127                // Break the loop either upon stop or channel disconnect
128                Ok(_) | Err(mpsc::RecvTimeoutError::Disconnected) => break,
129
130                // Continue work if no events were received within the timeout
131                Err(mpsc::RecvTimeoutError::Timeout) => (),
132            };
133        }
134
135        // Tell the system that service has stopped.
136        status_handle.set_service_status(ServiceStatus {
137            service_type: SERVICE_TYPE,
138            current_state: ServiceState::Stopped,
139            controls_accepted: ServiceControlAccept::empty(),
140            exit_code: ServiceExitCode::Win32(0),
141            checkpoint: 0,
142            wait_hint: Duration::default(),
143            process_id: None,
144        })?;
145
146        Ok(())
147    }