work

Author: MikailBag

Cargo.lock

@@ -20,5 +20,9 @@ nix = {git = "https://github.com/nix-rust/nix"}
 libc = "0.2.68"
 errno = "0.2.5"
 
+[target.'cfg(target_os="windows")'.dependencies]
+winapi = { version = "0.3.9", features = ["std", "processthreadsapi", "jobapi2", "errhandlingapi",
+ "namedpipeapi", "fileapi", "synchapi", "winnt"] }
+
 [workspace]
 members = ["minion-ffi", ".", "minion-tests", "minion-cli"]

Cargo.toml

@@ -4,11 +4,14 @@ version = "0.1.0"
 authors = ["Mikail Bagishov <bagishov.mikail@yandex.ru>"]
 edition = "2018"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [dependencies]
 once_cell = "1.4.0"
 minion = {path = ".."}
 clap = "2.33.1"
-nix = "0.17.0"
 tempfile = "3.1.0"
+
+[target.'cfg(target_os="linux")'.dependencies]
+nix = "0.17.0"
+
+[target.'cfg(target_os="windows")'.dependencies]
+winapi = { version = "0.3.9", features = ["processthreadsapi"] }

minion-tests/Cargo.toml

@@ -50,7 +50,10 @@ impl crate::TestCase for TTlFork {
         (TODO: verify this is not wall-clock time limit)"
     }
     fn test(&self) -> ! {
+        #[cfg(target_os = "linux")]
         nix::unistd::fork().unwrap();
+        #[cfg(target_os = "winfows")]
+        winapi::um::
         exceed_time_limit()
     }
     fn check(&self, cp: &mut dyn ChildProcess, _: &dyn Sandbox) {

minion-tests/src/tests/simple.rs

@@ -59,7 +59,7 @@ pub trait ChildProcess {
         timeout: Option<std::time::Duration>,
     ) -> anyhow::Result<crate::WaitOutcome>;
     fn poll(&self) -> anyhow::Result<()>;
-    fn is_finished(&self) -> anyhow::Result<bool>;
+    fn is_finished(&self) -> bool;
 }
 
 impl<C: crate::ChildProcess> ChildProcess for C {
@@ -93,8 +93,8 @@ impl<C: crate::ChildProcess> ChildProcess for C {
     fn poll(&self) -> anyhow::Result<()> {
         self.poll().map_err(Into::into)
     }
-    fn is_finished(&self) -> anyhow::Result<bool> {
-        self.is_finished().map_err(Into::into)
+    fn is_finished(&self) -> bool {
+        self.is_finished()
     }
 }
 
@@ -133,7 +133,11 @@ pub type ChildProcessOptions = crate::ChildProcessOptions<Box<dyn Sandbox>>;
 
 /// Returns backend instance
 pub fn setup() -> anyhow::Result<Box<dyn Backend>> {
-    Ok(Box::new(crate::linux::LinuxBackend::new(
+    #[cfg(target_os = "linux")]
+    return Ok(Box::new(crate::linux::LinuxBackend::new(
         crate::linux::Settings::new(),
-    )?))
+    )?));
+
+    #[cfg(target_os = "windows")]
+    return Ok(Box::new(crate::windows::WindowsBackend::new()));
 }

src/erased.rs

@@ -12,6 +12,9 @@ mod command;
 #[cfg(target_os = "linux")]
 pub mod linux;
 
+#[cfg(target_os = "windows")]
+pub mod windows;
+
 pub mod erased;
 
 use serde::{Deserialize, Serialize};
@@ -172,9 +175,17 @@ impl InputSpecification {
 
     /// # Safety
     /// See requirements of `handle`
+    #[cfg(target_os = "linux")]
     pub unsafe fn handle_of<T: std::os::unix::io::IntoRawFd>(obj: T) -> Self {
         unsafe { Self::handle(obj.into_raw_fd() as u64) }
     }
+
+    /// # Safety
+    /// See requirements of `handle`
+    #[cfg(target_os = "windows")]
+    pub unsafe fn handle_of<T: std::os::windows::io::IntoRawHandle>(obj: T) -> Self {
+        unsafe { Self::handle(obj.into_raw_handle() as u64) }
+    }
 }
 
 /// Configures stdout and stderr for child
@@ -217,9 +228,17 @@ impl OutputSpecification {
 
     /// # Safety
     /// See requirements of `handle`
+    #[cfg(target_os = "linux")]
     pub unsafe fn handle_of<T: std::os::unix::io::IntoRawFd>(obj: T) -> Self {
         unsafe { Self::handle(obj.into_raw_fd() as u64) }
     }
+
+    /// # Safety
+    /// See requirements of `handle`
+    #[cfg(target_os = "windows")]
+    pub unsafe fn handle_of<T: std::os::windows::io::IntoRawHandle>(obj: T) -> Self {
+        unsafe { Self::handle(obj.into_raw_handle() as u64) }
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -306,10 +325,8 @@ pub trait ChildProcess: Debug + 'static {
     /// If timeout is None, `wait_for_exit` will block until child has exited
     fn wait_for_exit(&self, timeout: Option<Duration>) -> Result<WaitOutcome, Self::Error>;
 
-    /// Refreshes information about process
-    fn poll(&self) -> Result<(), Self::Error>;
-
-    /// Returns whether child process has exited by the moment of call
-    /// This function doesn't blocks on waiting (see `wait_for_exit`).
-    fn is_finished(&self) -> Result<bool, Self::Error>;
+    /// Returns whether child process is known to be finished
+    /// (I.e. whether last `wait_for_exit` has not timed out)
+    /// This function doesn't wait child (see `wait_for_exit`).
+    fn is_finished(&self) -> bool;
 }

src/lib.rs

@@ -93,13 +93,7 @@ impl ChildProcess for LinuxChildProcess {
         }
     }
 
-    fn poll(&self) -> Result<(), Error> {
-        self.wait_for_exit(Some(Duration::from_nanos(1)))
-            .map(|_w| ())
-    }
-
     fn is_finished(&self) -> Result<bool, Error> {
-        self.poll()?;
         Ok(self.exit_code.load(Ordering::SeqCst) != EXIT_CODE_STILL_RUNNING)
     }
 }

src/linux.rs

@@ -0,0 +1,39 @@
+//! Minion on windows
+
+pub mod error;
+mod pipe;
+mod sandbox;
+mod child;
+
+pub use error::Error;
+pub use pipe::{ReadPipe, WritePipe};
+pub use sandbox::WindowsSandbox;
+
+use error::Cvt;
+
+/// Minion backend, supporting Windows.
+#[derive(Debug)]
+pub struct WindowsBackend {}
+
+impl WindowsBackend {
+    pub fn new() -> WindowsBackend {
+        WindowsBackend {}
+    }
+}
+
+impl crate::Backend for WindowsBackend {
+    type Error = Error;
+    type Sandbox = WindowsSandbox;
+    type ChildProcess = child::WindowsChildProcess;
+
+    fn new_sandbox(&self, options: crate::SandboxOptions) -> Result<Self::Sandbox, Self::Error> {
+        todo!()
+    }
+
+    fn spawn(
+        &self,
+        options: crate::ChildProcessOptions<Self::Sandbox>,
+    ) -> Result<Self::ChildProcess, Self::Error> {
+        todo!()
+    }
+}

src/windows.rs

@@ -0,0 +1,87 @@
+use crate::{
+    windows::{Cvt, Error, ReadPipe, WritePipe, },
+    WaitOutcome,
+};
+use std::{
+    convert::TryInto,
+    sync::atomic::{AtomicU32, Ordering::Relaxed},
+    time::Duration,
+};
+use winapi::um::{minwinbase::STILL_ACTIVE, winnt::HANDLE};
+
+#[derive(Debug)]
+pub struct WindowsChildProcess {
+    /// Handle to winapi Process object
+    child: HANDLE,
+
+    /// Contains exit code or STILL_ACTIVE otherwise
+    exit_code: AtomicU32,
+
+    /// Stdin
+    stdin: Option<WritePipe>,
+    /// Stdout
+    stdout: Option<ReadPipe>,
+    /// Stderr
+    stderr: Option<ReadPipe>,
+}
+
+impl WindowsChildProcess {}
+
+impl crate::ChildProcess for WindowsChildProcess {
+    type Error = Error;
+    type PipeIn = WritePipe;
+    type PipeOut = ReadPipe;
+
+    fn get_exit_code(&self) -> Result<Option<i64>, Self::Error> {
+        let ec = self.exit_code.load(Relaxed);
+        if ec != STILL_ACTIVE {
+            return Ok(Some(ec.into()));
+        }
+        let mut exit_code = 0;
+        unsafe {
+            Cvt::nonzero(winapi::um::processthreadsapi::GetExitCodeProcess(
+                self.child,
+                &mut exit_code,
+            ))?;
+        }
+        if exit_code == STILL_ACTIVE {
+            return Ok(None);
+        }
+        self.exit_code.store(exit_code, Relaxed);
+        Ok(Some(exit_code.into()))
+    }
+
+    fn stdin(&mut self) -> Option<Self::PipeIn> {
+        self.stdin.take()
+    }
+    fn stdout(&mut self) -> Option<Self::PipeOut> {
+        self.stdout.take()
+    }
+    fn stderr(&mut self) -> Option<Self::PipeOut> {
+        self.stderr.take()
+    }
+    fn wait_for_exit(&self, timeout: Option<Duration>) -> Result<WaitOutcome, Self::Error> {
+        if self.exit_code.load(Relaxed) != STILL_ACTIVE {
+            return Ok(WaitOutcome::AlreadyFinished);
+        }
+        let timeout = match timeout {
+            Some(dur) => dur
+                .as_millis()
+                .max(1)
+                .try_into()
+                .unwrap_or(u32::max_value()),
+            None => winapi::um::winbase::INFINITE,
+        };
+        let res = unsafe { winapi::um::synchapi::WaitForSingleObject(self.child, timeout) };
+        if res == winapi::um::winbase::WAIT_FAILED {
+            return Err(Error::last());
+        }
+        match self.get_exit_code()? {
+            Some(_) => Ok(WaitOutcome::Exited),
+            None => Ok(WaitOutcome::Timeout),
+        }
+    }
+    fn is_finished(&self) -> bool {
+        self.exit_code.load(Relaxed) != STILL_ACTIVE
+    }
+}

src/windows/child.rs

@@ -0,0 +1,35 @@
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    #[error("winapi call failed")]
+    Syscall { errno: u32 },
+}
+
+impl From<u32> for Error {
+    fn from(errno: u32) -> Self {
+        Error::Syscall { errno }
+    }
+}
+
+impl Error {
+    pub(crate) fn last() -> Self {
+        Error::Syscall {
+            errno: unsafe { winapi::um::errhandlingapi::GetLastError() },
+        }
+    }
+}
+
+/// Helper for checking return values
+pub(crate) struct Cvt {
+    _priv: (),
+}
+
+impl Cvt {
+    /// checks that operation returned non-zero
+    pub fn nonzero(ret: i32) -> Result<i32, Error> {
+        if ret != 0 {
+            Ok(ret)
+        } else {
+            Err(Error::last())
+        }
+    }
+}