Factored out unix dependency

Author: rmliddle

vm/src/exceptions.rs

@@ -92,6 +92,7 @@ pub struct ExceptionZoo {
     pub module_not_found_error: PyObjectRef,
     pub name_error: PyObjectRef,
     pub not_implemented_error: PyObjectRef,
+    pub os_error: PyObjectRef,
     pub permission_error: PyObjectRef,
     pub runtime_error: PyObjectRef,
     pub stop_iteration: PyObjectRef,
@@ -135,6 +136,7 @@ impl ExceptionZoo {
         let syntax_error = create_type("SyntaxError", &type_type, &exception_type, &dict_type);
         let type_error = create_type("TypeError", &type_type, &exception_type, &dict_type);
         let value_error = create_type("ValueError", &type_type, &exception_type, &dict_type);
+        let os_error = create_type("OSError", &type_type, &exception_type.clone(), &dict_type);
 
         let file_not_found_error =
             create_type("FileNotFoundError", &type_type, &import_error, &dict_type);
@@ -167,6 +169,7 @@ impl ExceptionZoo {
             syntax_error,
             type_error,
             value_error,
+            os_error,
         }
     }
 }

vm/src/stdlib/io.rs

@@ -2,23 +2,23 @@
  * I/O core tools.
  */
 
+//library imports
 use std::collections::HashSet;
-
-use std::io::prelude::*;
-use std::os::unix::io::{FromRawFd, IntoRawFd};
-
 use std::fs::File;
+use std::io::prelude::*;
 use std::io::BufReader;
 
+//3rd party imports
+use num_bigint::ToBigInt;
+use num_traits::ToPrimitive;
+
+//custom imports
 use super::super::obj::objbytes;
 use super::super::obj::objint;
 use super::super::obj::objstr;
 use super::super::obj::objtype;
 use super::os;
 
-use num_bigint::ToBigInt;
-use num_traits::ToPrimitive;
-
 use super::super::pyobject::{
     AttributeProtocol, BufferProtocol, PyContext, PyFuncArgs, PyObjectPayload, PyObjectRef,
     PyResult, TypeProtocol,
@@ -117,6 +117,9 @@ fn file_io_init(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
 
             vm.ctx.set_attr(&file_io, "name", name.clone());
             vm.ctx.set_attr(&file_io, "fileno", file_no);
+            vm.ctx.set_attr(&file_io, "closefd", vm.new_bool(false));
+            vm.ctx.set_attr(&file_io, "closed", vm.new_bool(false));
+
             Ok(vm.get_none())
         }
         None => Err(vm.new_type_error(format!("invalid mode {}", rust_mode))),
@@ -164,10 +167,8 @@ fn file_io_readinto(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     let file_no = file_io.get_attr("fileno").unwrap();
     let raw_fd = objint::get_value(&file_no).to_i32().unwrap();
 
-    //unsafe block - creates file handle from the UNIX file descriptor
-    //raw_fd is supported on UNIX only. This will need to be extended
-    //to support windows - i.e. raw file_handles
-    let handle = unsafe { File::from_raw_fd(raw_fd) };
+    //extract unix file descriptor.
+    let handle = os::rust_file(raw_fd);
 
     let mut f = handle.take(length);
     match obj.borrow_mut().payload {
@@ -182,9 +183,9 @@ fn file_io_readinto(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
         _ => {}
     };
 
-    let new_handle = f.into_inner().into_raw_fd().to_bigint();
+    let updated = os::raw_file_number(f.into_inner()).to_bigint();
     vm.ctx
-        .set_attr(&file_io, "fileno", vm.ctx.new_int(new_handle.unwrap()));
+        .set_attr(&file_io, "fileno", vm.ctx.new_int(updated.unwrap()));
     Ok(vm.get_none())
 }
 
@@ -201,16 +202,16 @@ fn file_io_write(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     //unsafe block - creates file handle from the UNIX file descriptor
     //raw_fd is supported on UNIX only. This will need to be extended
     //to support windows - i.e. raw file_handles
-    let mut handle = unsafe { File::from_raw_fd(raw_fd) };
+    let mut handle = os::rust_file(raw_fd);
 
     match obj.borrow_mut().payload {
         PyObjectPayload::Bytes { ref mut value } => {
             match handle.write(&value[..]) {
                 Ok(len) => {
                     //reset raw fd on the FileIO object
-                    let new_handle = handle.into_raw_fd().to_bigint();
+                    let updated = os::raw_file_number(handle).to_bigint();
                     vm.ctx
-                        .set_attr(&file_io, "fileno", vm.ctx.new_int(new_handle.unwrap()));
+                        .set_attr(&file_io, "fileno", vm.ctx.new_int(updated.unwrap()));
 
                     //return number of bytes written
                     Ok(vm.ctx.new_int(len.to_bigint().unwrap()))
@@ -279,7 +280,7 @@ pub fn io_open(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
 
     let mut raw_modes = HashSet::new();
 
-    // Add some books.
+    //add raw modes
     raw_modes.insert("a".to_string());
     raw_modes.insert("r".to_string());
     raw_modes.insert("x".to_string());

vm/src/stdlib/os.rs

@@ -1,18 +1,61 @@
+//library imports
+use std::fs::File;
 use std::fs::OpenOptions;
 use std::io::ErrorKind;
-use std::os::unix::io::IntoRawFd;
 
+//3rd party imports
 use num_bigint::ToBigInt;
 use num_traits::cast::ToPrimitive;
 
+//custom imports
 use super::super::obj::objint;
 use super::super::obj::objstr;
 use super::super::obj::objtype;
 
 use super::super::pyobject::{PyContext, PyFuncArgs, PyObjectRef, PyResult, TypeProtocol};
-
 use super::super::vm::VirtualMachine;
 
+#[cfg(target_family = "unix")]
+pub fn raw_file_number(handle: File) -> i32 {
+    use std::os::unix::io::IntoRawFd;
+
+    handle.into_raw_fd()
+}
+
+#[cfg(target_family = "unix")]
+pub fn rust_file(raw_fileno: i32) -> File {
+    use std::os::unix::io::FromRawFd;
+
+    unsafe { File::from_raw_fd(raw_fileno) }
+}
+
+#[cfg(target_family = "windows")]
+pub fn rust_file(handle: File) -> i32 {
+    use std::os::windows::io::IntoRawHandle;
+
+    handle.into_raw_handle()
+}
+
+#[cfg(target_family = "windows")]
+pub fn rust_file(raw_fileno: i32) -> File {
+    use std::os::unix::io::FromRawHandle;
+
+    unsafe { File::from_raw_handle(raw_fileno) }
+}
+
+pub fn os_close(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(vm, args, required = [(fileno, Some(vm.ctx.int_type()))]);
+
+    let raw_fileno = objint::get_value(&fileno);
+
+    //The File type automatically closes when it goes out of scope.
+    //To enable us to close these file desciptors (and hence prevent leaks)
+    //we seek to create the relevant File and simply let it pass out of scope!
+    rust_file(raw_fileno.to_i32().unwrap());
+
+    Ok(vm.get_none())
+}
+
 pub fn os_open(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(
         vm,
@@ -43,11 +86,8 @@ pub fn os_open(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
         _ => vm.new_value_error("Unhandled file IO error".to_string()),
     })?;
 
-    //raw_fd is supported on UNIX only. This will need to be extended
-    //to support windows - i.e. raw file_handles
     Ok(vm.ctx.new_int(
-        handle
-            .into_raw_fd()
+        raw_file_number(handle)
             .to_bigint()
             .expect("Invalid file descriptor"),
     ))
@@ -56,6 +96,8 @@ pub fn os_open(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
 pub fn mk_module(ctx: &PyContext) -> PyObjectRef {
     let py_mod = ctx.new_module(&"io".to_string(), ctx.new_scope(None));
     ctx.set_attr(&py_mod, "open", ctx.new_rustfunc(os_open));
+    ctx.set_attr(&py_mod, "close", ctx.new_rustfunc(os_close));
+
     ctx.set_attr(&py_mod, "O_RDONLY", ctx.new_int(0.to_bigint().unwrap()));
     ctx.set_attr(&py_mod, "O_WRONLY", ctx.new_int(1.to_bigint().unwrap()));
     ctx.set_attr(&py_mod, "O_RDWR", ctx.new_int(2.to_bigint().unwrap()));

vm/src/vm.rs

@@ -100,6 +100,11 @@ impl VirtualMachine {
         self.new_exception(type_error, msg)
     }
 
+    pub fn new_os_error(&mut self, msg: String) -> PyObjectRef {
+        let os_error = self.ctx.exceptions.os_error.clone();
+        self.new_exception(os_error, msg)
+    }
+
     /// Create a new python ValueError object. Useful for raising errors from
     /// python functions implemented in rust.
     pub fn new_value_error(&mut self, msg: String) -> PyObjectRef {