io-extra 1.0.1

data/CHANGES

@@ -0,0 +1,10 @@
+== 1.0.1 - 7-Jul-2006
+* Added a gemspec.
+* Added or improved the inline rdoc comments in the source.
+
+== 1.0.0 - 16-Jun-2005
+* Moved project to RubyForge.
+* Added a CHANGES file.
+
+== 0.1.0 - 26-Jan-2005
+* Initial release

data/README

@@ -0,0 +1,39 @@
+= Description
+The io-extra package provides a few extra IO methods that you may find
+handy.  They are IO.closefrom, IO.fdwalk, IO#directio? and IO#directio=.
+	
+Not supported on MS Windows.
+
+= Installation
+   ruby extconf.rb
+   make
+   ruby test/tc_ioextra.rb (optional)
+   make site-install
+
+= Developer's Notes
+== Q) What is the difference between your implementation of IO.closefrom and a 
+pure Ruby version that looks something like this?
+
+   def IO.closefrom(n)
+      0.upto n do |fd|
+         IO.for_fd(fd).close
+      end
+   end
+
+The primary difference is that this walks all file descriptors, rather
+than only open file descriptors.  However, I should note that this only
+applies if your platform supports the closefrom() function.  In that case,
+the only advantage is speed.
+
+== Q) What is the difference between your implementation of IO.fdwalk and a
+pure Ruby version that looks something like this?
+
+   def IO.fdwalk(n)
+      ObjectSpace.each_object(File){ |f|
+         yield f if f.fileno >= n
+      }
+   end
+
+The primary difference is that this only closes Ruby file objects, not
+necessarily every filehandle opened by the Ruby process.  Think system(), for
+example.

data/doc/io_extra.txt

@@ -0,0 +1,89 @@
+= Description
+   The io-extra package provides a few extra IO methods that you may find
+   handy.  They are IO.closefrom, IO.fdwalk and IO.directio.
+	
+   Not supported on Win32.
+
+= Synopsis
+   require "io/extra"
+   
+   # Print the fileno of each file handle and then close it
+   IO.fdwalk(0){ |fh|
+      p fh.fileno
+      fh.close
+   }
+   
+   # Close all file handles with a fileno greater than or equal to 2.
+   IO.closefrom(2)
+   
+= Class Methods
+IO.closefrom(low_fd)
+   Closes all open file descriptors greater than or equal to 'low_fd'.
+   
+   This uses your systems native closefrom() function, if supported.  If not,
+   this method uses a slightly less efficient manual approach that uses
+   getrlimit() behind the scenes.
+   
+IO.fdwalk(low_fd){ |fh| ... }
+   Iterates over each open file descriptor and yields back a File object.
+   Note that it is up to you to close file handles, if desired, when this
+   method is used.
+	
+   Not supported by all platforms.
+
+= Instance methods
+IO#directio?
+   Returns true or false, based on whether directio has been set for the
+   current handle.  The default is false.
+   
+   Note supported on all platforms.
+   
+IO#directio=(io_const)
+   Sets the advice for the current file descriptor using directio().  Valid
+   values are IO::DIRECTIO_ON and IO::DIRECTIO_OFF.
+   
+   All file descriptors start at DIRECTIO_OFF, unless your filesystem has
+   been mounted using 'forcedirectio' (and supports that option).
+   
+   Not supported on all platforms
+   
+= Constants
+IO::DIRECTIO_ON
+   This value can be passed to IO#directio= in order to turn directio on for
+   the given file handle.
+   
+   This value is only defined if your platform supports the directio()
+   function.
+IO::DIRECTIO_OFF
+   This value can be passed to IO#directio= in order to turn directio off for
+   the given file handle.
+   
+   This value is only defined if your platform supports the directio()
+   function.
+   
+IO::EXTRA_VERSION
+   Returns the current version number of this package as a String.
+
+= Known Bugs
+   You may receive a warning about implicit declaration during the build
+   process.  You can ignore this.
+   
+= Future Plans
+   Eliminate warnings that occur during the build process.
+   
+= License
+   Ruby's
+
+= Copyright
+   (C) 2003-2005 Daniel J. Berger
+   All Rights Reserved
+    
+= Warranty
+   This package is provided "as is" and without any express or
+   implied warranties, including, without limitation, the implied
+   warranties of merchantability and fitness for a particular purpose.
+	 
+= Author
+   Daniel J. Berger
+   djberg96 at gmail dot com
+   imperator on IRC (irc.freenode.net)

data/extconf.rb

@@ -0,0 +1,10 @@
+require "mkmf"
+require "ftools"
+
+File.copy("lib/io/extra.c",".")
+
+have_func("closefrom")
+have_func("fdwalk")
+have_func("directio")
+
+create_makefile("io/extra")

data/lib/io/extra.c

@@ -0,0 +1,147 @@
+/* Extra methods for the IO class */
+#include "ruby.h"
+#include "rubyio.h"
+#include <unistd.h>
+#include <stdlib.h>
+
+#ifndef HAVE_CLOSEFROM
+#include <sys/resource.h>
+#endif
+
+#ifdef HAVE_DIRECTIO
+#include <sys/types.h>
+#include <sys/fcntl.h>
+#endif
+
+/*
+ * call-seq:
+ *    IO.closefrom(lowfd)
+ *
+ * Close all open file descriptors (associated with the current process) that
+ * are greater than or equal to +lowfd+.
+ *
+ * This method uses your system's builtin closefrom() function, if supported.
+ * Otherwise, it uses a manual, and (probably) less efficient approach.
+ * 
+ *--
+ * The manual approach was copied from the closefrom() man page on Solaris 9.
+ */
+static VALUE io_closefrom(VALUE klass, VALUE v_low_fd){
+#ifdef HAVE_CLOSEFROM
+   closefrom(NUM2INT(v_low_fd));
+#else
+   int i, lowfd;
+   struct rlimit limits;
+   getrlimit(RLIMIT_NOFILE, &limits);
+   lowfd = NUM2INT(v_low_fd);
+
+   for(i = lowfd; i < limits.rlim_max; i++){
+      close(i);
+   }
+#endif
+   return klass;
+}
+
+/*
+ * Used by io_fdwalk. Yields a File object back to the block.
+ * It's up to the user to close it.
+ */
+static int close_func(void* lowfd, int fd){
+   VALUE v_args[1];
+   
+   v_args[0] = UINT2NUM(fd);
+   rb_yield(rb_class_new_instance(1, v_args, rb_cFile));
+   return 0;
+}
+
+#ifdef HAVE_FDWALK
+/*
+ * call-seq:
+ *    IO.fdwalk(lowfd){ |fh| ... }
+ *
+ * Iterates over each open file descriptor and yields back a File object.
+ *
+ * Not supported on all platforms.
+ */
+static VALUE io_fdwalk(int argc, VALUE* argv, VALUE klass){
+   VALUE v_low_fd, v_block;
+   int lowfd;
+
+   rb_scan_args(argc, argv, "1&", &v_low_fd, &v_block);
+   lowfd = NUM2INT(v_low_fd);
+
+   fdwalk(close_func, &lowfd);
+   
+   return klass;
+}
+#endif
+
+#ifdef HAVE_DIRECTIO
+/*
+ * call-seq:
+ *    IO#directio?
+ *
+ * Returns true or false, based on whether directio has been set for the
+ * current handle. The default is false.
+ */
+static VALUE io_get_directio(VALUE self){
+   VALUE v_advice = rb_iv_get(self, "directio");
+
+   if(NIL_P(v_advice))
+      v_advice = Qfalse;
+
+   return v_advice;
+}
+
+/*
+ * call-seq:
+ *    IO#directio=(advice)
+ *
+ * Sets the advice for the current file descriptor using directio().  Valid
+ * values are IO::DIRECTIO_ON and IO::DIRECTIO_OFF.
+ *
+ * All file descriptors start at DIRECTIO_OFF, unless your filesystem has
+ * been mounted using 'forcedirectio' (and supports that option).
+ */
+static VALUE io_set_directio(VALUE self, VALUE v_advice){
+   int fd, rv;
+   int advice = NUM2INT(v_advice);
+
+   /* Only two possible valid values */
+   if( (advice != DIRECTIO_OFF) && (advice != DIRECTIO_ON) )
+      rb_raise(rb_eStandardError, "Invalid value passed to IO#directio=");
+
+   /* Retrieve the current file descriptor in order to pass it to directio() */
+   fd = NUM2INT(rb_funcall(self, rb_intern("fileno"), 0, 0));
+
+   rv = directio(fd, advice);
+
+   if(-1 == rv)
+      rb_raise(rb_eStandardError, "The directio() call failed");
+
+   if(advice == DIRECTIO_ON)
+      rb_iv_set(self, "directio", Qtrue);
+
+   return self;
+}
+#endif
+
+/* Adds the IO.closefrom, IO.fdwalk class methods, as well as the IO#directio
+ * and IO#directio? instance methods (if supported on your platform).
+ */
+void Init_extra(){
+   rb_define_singleton_method(rb_cIO, "closefrom", io_closefrom, 1);
+
+#ifdef HAVE_FDWALK
+   rb_define_singleton_method(rb_cIO, "fdwalk", io_fdwalk, -1);
+#endif
+
+#ifdef HAVE_DIRECTIO
+   rb_define_method(rb_cIO, "directio?", io_get_directio, 0);
+   rb_define_method(rb_cIO, "directio=", io_set_directio, 1);
+   rb_define_const(rb_cIO, "DIRECTIO_OFF", UINT2NUM(DIRECTIO_OFF));
+   rb_define_const(rb_cIO, "DIRECTIO_ON", UINT2NUM(DIRECTIO_ON));
+#endif
+
+   rb_define_const(rb_cIO, "EXTRA_VERSION", rb_str_new2("1.0.1"));
+}

data/test/tc_ioextra.rb

@@ -0,0 +1,65 @@
+#################################################
+# tc_ioextra.rb
+#
+# Test suite for the io-extra package.
+#################################################
+base = File.basename(Dir.pwd)
+
+if base == "test" || base =~ /io-extra/
+   require "ftools"
+   Dir.chdir("..") if base == "test"
+   Dir.mkdir("io") rescue nil
+   File.copy("extra.so","io")
+   $LOAD_PATH.unshift(Dir.pwd)
+   Dir.chdir("test")  rescue nil
+end
+
+require "test/unit"
+require "io/extra"
+
+class TC_IO_Extra < Test::Unit::TestCase
+   def setup
+      @file = "delete_this.txt"
+      @fh = File.open(@file,"w+")
+   end
+     
+   def test_version
+      assert_equal("1.0.1", IO::EXTRA_VERSION)
+   end
+   
+   def test_directio
+      assert_respond_to(@fh,:directio?)
+      assert_nothing_raised{ @fh.directio? }
+   end
+   
+   def test_directio_set
+      assert_respond_to(@fh,:directio=)
+      assert_raises(StandardError){ @fh.directio = 99 }
+      assert_nothing_raised{ @fh.directio = IO::DIRECTIO_ON }
+   end
+  
+   def test_closefrom
+      assert_respond_to(IO,:closefrom)
+      assert_nothing_raised{ IO.closefrom(3) }
+   end
+   
+   def test_fdwalk
+      assert_respond_to(IO,:fdwalk)
+      assert_nothing_raised{ IO.fdwalk(0){ } }
+   end
+   
+   def test_constants
+      assert_not_nil(IO::DIRECTIO_ON)
+      assert_not_nil(IO::DIRECTIO_OFF)
+   end
+  
+   # Ignore EBADF, since some of the tests will close @fh
+   def teardown
+      begin
+         @fh.close
+      rescue Errno::EBADF
+      end
+      @fh = nil
+      File.delete(@file) if File.exists?(@file)
+   end
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: io-extra
+version: !ruby/object:Gem::Version 
+  version: 1.0.1
+date: 2006-07-07 00:00:00 -06:00
+summary: Adds the IO.closefrom and IO.fdwalk class methods as well as the IO#directio and IO#directio? instance methods (for those platforms that support them).
+require_paths: 
+- lib
+email: djberg96@gmail.com
+homepage: http://www.rubyforge.org/projects/shards
+rubyforge_project: shards
+description: Adds the IO.closefrom and IO.fdwalk class methods as well as the IO#directio and IO#directio? instance methods (for those platforms that support them).
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Daniel J. Berger
+files: 
+- doc/io_extra.txt
+- test/tc_ioextra.rb
+- lib/io/extra.c
+- CHANGES
+- README
+test_files: 
+- test/tc_ioextra.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- CHANGES
+- README
+executables: []
+
+extensions: 
+- extconf.rb
+requirements: []
+
+dependencies: []
+