implement graceful shutdown on windows

components/core/src/error.rs

@@ -94,6 +94,8 @@ pub enum Error {
     GetExitCodeProcessFailed(String),
     /// Occurs when a `HabChild` constructor fails to return a process.
     GetHabChildFailed(String),
+    /// Occurs when a `TerminateProcess` win32 call returns an error.
+    TerminateProcessFailed(String),
     /// When an error occurs attempting to interpret a sequence of u8 as a string.
     Utf8Error(str::Utf8Error),
 }
@@ -170,6 +172,7 @@ impl fmt::Display for Error {
             Error::SignalFailed(ref e) => format!("Failed to send a signal to the child process: {}", e),
             Error::GetExitCodeProcessFailed(ref e) => format!("{}", e),
             Error::GetHabChildFailed(ref e) => format!("{}", e),
+            Error::TerminateProcessFailed(ref e) => format!("{}", e),
             Error::Utf8Error(ref e) => format!("{}", e),
         };
         write!(f, "{}", msg)
@@ -225,6 +228,7 @@ impl error::Error for Error {
             Error::WaitpidFailed(_) => "waitpid failed",
             Error::GetExitCodeProcessFailed(_) => "GetExitCodeProcess failed",
             Error::GetHabChildFailed(_) => "Failed to return a HabChild",
+            Error::TerminateProcessFailed(_) => "Failed to call TerminateProcess",
             Error::Utf8Error(_) => "Failed to interpret a sequence of bytes as a string",
         }
     }

components/core/src/os/process/linux.rs

@@ -21,7 +21,7 @@ use time::{Duration, SteadyTime};
 
 use error::{Error, Result};
 
-use super::{HabExitStatus, ExitStatusExt};
+use super::{HabExitStatus, ExitStatusExt, ShutdownMethod};
 
 pub fn become_command(command: PathBuf, args: Vec<OsString>) -> Result<()> {
     become_exec_command(command, args)
@@ -84,7 +84,7 @@ impl Child {
         }
     }
 
-    pub fn kill(&mut self) -> Result<i32> {
+    pub fn kill(&mut self) -> Result<ShutdownMethod> {
         try!(send_signal(self.pid, libc::SIGTERM));
 
         let stop_time = SteadyTime::now() + Duration::seconds(8);
@@ -96,10 +96,10 @@ impl Child {
 
             if SteadyTime::now() > stop_time {
                 try!(send_signal(self.pid, libc::SIGKILL));
-                return Ok(libc::SIGKILL);
+                return Ok(ShutdownMethod::Killed);
             }
         }
-        Ok(libc::SIGTERM)
+        Ok(ShutdownMethod::GracefulTermination)
     }
 }
 

components/core/src/os/process/mod.rs

@@ -28,6 +28,23 @@ mod imp;
 
 pub use self::imp::{become_command};
 
+pub enum ShutdownMethod {
+    AlreadyExited,
+    GracefulTermination,
+    Killed,
+}
+
+impl fmt::Display for ShutdownMethod {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let printable = match *self {
+            ShutdownMethod::AlreadyExited => "Already Exited",
+            ShutdownMethod::GracefulTermination => "Graceful Termination",
+            ShutdownMethod::Killed => "Killed",
+        };
+        write!(f, "{}", printable)
+    }
+}
+
 pub struct HabChild {
     inner: imp::Child,
 }
@@ -48,7 +65,7 @@ impl HabChild {
         self.inner.status()
     }
 
-    pub fn kill(&mut self) -> Result<i32> {
+    pub fn kill(&mut self) -> Result<ShutdownMethod> {
         self.inner.kill()
     }
 }

components/core/src/os/process/windows.rs

@@ -17,13 +17,14 @@ use std::path::PathBuf;
 use std::process::{self, Command};
 use std::ptr;
 use std::io;
+use time::{Duration, SteadyTime};
 
 use kernel32;
 use winapi;
 
 use error::{Error, Result};
 
-use super::{HabExitStatus, ExitStatusExt};
+use super::{HabExitStatus, ExitStatusExt, ShutdownMethod};
 
 const STILL_ACTIVE: u32 = 259;
 
@@ -49,7 +50,7 @@ fn become_child_command(command: PathBuf, args: Vec<OsString>) -> Result<()> {
 
 fn handle_from_pid(pid: u32) -> Option<winapi::HANDLE> {
     unsafe {
-        let proc_handle = kernel32::OpenProcess(winapi::PROCESS_QUERY_LIMITED_INFORMATION,
+        let proc_handle = kernel32::OpenProcess(winapi::PROCESS_QUERY_LIMITED_INFORMATION | winapi::PROCESS_TERMINATE,
                                                 winapi::FALSE,
                                                 pid as winapi::DWORD);
 
@@ -134,8 +135,69 @@ impl Child {
         Ok(HabExitStatus { status: Some(exit_status) })
     }
 
-    pub fn kill(&mut self) -> Result<i32> {
-        unimplemented!();
+    pub fn kill(&mut self) -> Result<ShutdownMethod> {
+        if self.last_status.is_some() {
+            return Ok(ShutdownMethod::AlreadyExited);
+        }
+
+        let mut ret;
+        unsafe {
+            // Turn off ctrl-C handling for current process
+            ret = kernel32::SetConsoleCtrlHandler(None, winapi::TRUE);
+            if ret == 0 {
+                debug!("Failed to call SetConsoleCtrlHandler on pid {}: {}",
+                           self.pid,
+                           io::Error::last_os_error());
+            }
+
+            if ret != 0 {
+                // Send a ctrl-C
+                ret = kernel32::GenerateConsoleCtrlEvent(0, 0);
+                if ret == 0 {
+                    debug!("Failed to send ctrl-c to pid {}: {}",
+                               self.pid,
+                               io::Error::last_os_error());
+                }
+            }
+        }
+
+        let stop_time = SteadyTime::now() + Duration::seconds(8);
+
+        let result;
+        loop {
+            if ret == 0 || SteadyTime::now() > stop_time {
+                unsafe {
+                    ret = kernel32::TerminateProcess(self.handle.unwrap(), 1);
+                    if ret == 0 {
+                        result = Err(Error::TerminateProcessFailed(format!("Failed to call terminate pid {}: {}",
+                                                                           self.pid,
+                                                                           io::Error::last_os_error())));
+                    }
+                    else {
+                        result = Ok(ShutdownMethod::Killed);
+                    }
+                    break;
+                }
+            }
+
+            match self.status() {
+                Ok(status) => if !status.no_status() {
+                    result = Ok(ShutdownMethod::GracefulTermination);
+                    break;
+                },
+                _ => {}
+            }
+        };
+
+        // turn Ctrl-C handling back on for current process
+        ret = unsafe { kernel32::SetConsoleCtrlHandler(None, winapi::FALSE) };
+        if ret == 0 {
+            debug!("Failed to call SetConsoleCtrlHandler on pid {}: {}",
+                       self.pid,
+                       io::Error::last_os_error());
+        }
+
+        result
     }
 }
 

components/sup/src/supervisor.rs

@@ -153,8 +153,8 @@ impl Supervisor {
         match self.child {
             Some(ref mut child) => {
                 outputln!(preamble & self.preamble, "Stopping...");
-                let signal = try!(child.kill());
-                outputln!("{} - Killed with signal {}", self.preamble, signal);
+                let shutdown = try!(child.kill());
+                outputln!("{} - Shutdown method: {}", self.preamble, shutdown);
             }
             None => {},
         };