update windows service with error handling

src/bin/windows_service.rs

@@ -1,13 +1,19 @@
-#![windows_subsystem = "windows"]
+#[cfg(windows)]
+fn main() -> windows_service::Result<()> {
+    winserv::run()
+}
 
-#[macro_use]
+#[cfg(not(windows))]
-extern crate windows_service;
+fn main() {
+    //do nothing on *nix
+}
 
-use irc_rpc::start_loop;
+#[cfg(windows)]
+mod winserv {
 
-use std::ffi::OsString;
+    use std::ffi::OsString;
-use std::time::Duration;
+    use std::time::Duration;
-use windows_service::{
+    use windows_service::{
         define_windows_service,
         service::{
             ServiceControl, ServiceControlAccept, ServiceExitCode, ServiceState, ServiceStatus,
@@ -15,13 +21,18 @@ use windows_service::{
         },
         service_control_handler::{self, ServiceControlHandlerResult},
         service_dispatcher, Result,
-};
+    };
+    use irc_rpc::start_loop;
 
-const SERVICE_TYPE: ServiceType = ServiceType::OWN_PROCESS;
+    const SERVICE_TYPE: ServiceType = ServiceType::OWN_PROCESS;
 
-define_windows_service!(ffi_service_main, my_service_main);
+    define_windows_service!(ffi_service_main, my_service_main);
 
-fn my_service_main(arguments: Vec<OsString>) {
+    pub fn run() -> Result<()> {
+        service_dispatcher::start("irc-rpc", ffi_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`.
 
@@ -32,9 +43,7 @@ fn my_service_main(arguments: Vec<OsString>) {
                 ServiceControl::Interrogate => ServiceControlHandlerResult::NoError,
 
                 // Handle stop
-            ServiceControl::Stop => {
+                ServiceControl::Stop => ServiceControlHandlerResult::NoError,
-                ServiceControlHandlerResult::NoError
-            }
 
                 _ => ServiceControlHandlerResult::NotImplemented,
             }
@@ -42,7 +51,8 @@ fn my_service_main(arguments: Vec<OsString>) {
 
         let status_handle = service_control_handler::register("irc-rpc", event_handler).unwrap();
 
-    status_handle.set_service_status(ServiceStatus {
+        status_handle
+            .set_service_status(ServiceStatus {
                 service_type: SERVICE_TYPE,
                 current_state: ServiceState::Running,
                 controls_accepted: ServiceControlAccept::STOP,
@@ -50,14 +60,23 @@ fn my_service_main(arguments: Vec<OsString>) {
                 checkpoint: 0,
                 wait_hint: Duration::default(),
                 process_id: None,
-    }).unwrap();
+            })
+            .unwrap();
 
-    start_loop();
+        if let Err(_) = start_loop() {
-}
+            //log error
+        }
 
-fn main() -> windows_service::Result<()> {
+        status_handle
-    // Register generated `ffi_service_main` with the system and start the service, blocking
+            .set_service_status(ServiceStatus {
-    // this thread until the service is stopped.
+                service_type: SERVICE_TYPE,
-    service_dispatcher::start("irc-rpc", ffi_service_main)?;
+                current_state: ServiceState::Stopped,
-    Ok(())
+                controls_accepted: ServiceControlAccept::empty(),
+                exit_code: ServiceExitCode::Win32(0),
+                checkpoint: 0,
+                wait_hint: Duration::default(),
+                process_id: None,
+            })
+            .unwrap();
+    }
 }

src/lib.rs

@@ -4,14 +4,12 @@ use std::{collections::HashMap, process};
 
 static ART: &str = include_str!("ouch.txt");
 
-pub fn start_loop() {
+pub fn start_loop() -> Result<(), failure::Error> {
     tokio::runtime::Builder::new_multi_thread()
         .enable_all()
         .build()
         .unwrap()
-        .block_on(async {
+        .block_on(async { event_loop().await })
-            event_loop().await.unwrap();
-        });
 }
 
 async fn event_loop() -> Result<(), failure::Error> {

src/main.rs

@@ -3,5 +3,5 @@
 use irc_rpc::start_loop;
 
 fn main() {
-    start_loop();
+    start_loop().unwrap();
 }