io-reactor 0.05 → 1.0.4

data/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2008, Michael Granger
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the name of the author/s, nor the names of the project's
+    contributors may be used to endorse or promote products derived from this
+    software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README

@@ -69,7 +69,7 @@ INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND
 FITNESS FOR A PARTICULAR PURPOSE.
 
 
- $Id: README,v 1.5 2003/07/21 15:04:50 deveiant Exp $
+ $Id: README 85 2008-08-19 20:30:57Z deveiant $
 
 
 

data/Rakefile

@@ -0,0 +1,257 @@
+#!rake
+#
+# IO-Reactor rakefile
+#
+# Based on various other Rakefiles, especially one by Ben Bleything
+#
+# Copyright (c) 2008 The FaerieMUD Consortium
+#
+# Authors:
+#  * Michael Granger <ged@FaerieMUD.org>
+#
+
+BEGIN {
+	require 'pathname'
+	basedir = Pathname.new( __FILE__ ).dirname
+
+	libdir = basedir + "lib"
+	extdir = basedir + "ext"
+
+	$LOAD_PATH.unshift( libdir.to_s ) unless $LOAD_PATH.include?( libdir.to_s )
+	$LOAD_PATH.unshift( extdir.to_s ) unless $LOAD_PATH.include?( extdir.to_s )
+}
+
+
+require 'rbconfig'
+require 'rubygems'
+require 'rake'
+require 'rake/rdoctask'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/clean'
+
+$dryrun = false
+
+### Config constants
+BASEDIR       = Pathname.new( __FILE__ ).dirname.relative_path_from( Pathname.getwd )
+LIBDIR        = BASEDIR + 'lib'
+EXTDIR        = BASEDIR + 'ext'
+DOCSDIR       = BASEDIR + 'docs'
+PKGDIR        = BASEDIR + 'pkg'
+
+PKG_NAME      = 'io-reactor'
+PKG_SUMMARY   = 'Multiplexed IO Reactor class'
+VERSION_FILE  = LIBDIR + 'io/reactor.rb'
+PKG_VERSION   = VERSION_FILE.read[ /VERSION = '(\d+\.\d+\.\d+)'/, 1 ]
+PKG_FILE_NAME = "#{PKG_NAME.downcase}-#{PKG_VERSION}"
+GEM_FILE_NAME = "#{PKG_FILE_NAME}.gem"
+
+ARTIFACTS_DIR = Pathname.new( ENV['CC_BUILD_ARTIFACTS'] || 'artifacts' )
+
+TEXT_FILES    = %w( Rakefile ChangeLog README LICENSE ).collect {|filename| BASEDIR + filename }
+LIB_FILES     = Pathname.glob( LIBDIR + '**/*.rb' ).delete_if {|item| item =~ /\.svn/ }
+EXT_FILES     = Pathname.glob( EXTDIR + '**/*.{c,h,rb}' ).delete_if {|item| item =~ /\.svn/ }
+
+SPECDIR       = BASEDIR + 'spec'
+SPEC_FILES    = Pathname.glob( SPECDIR + '**/*_spec.rb' ).delete_if {|item| item =~ /\.svn/ }
+
+TESTDIR       = BASEDIR + 'tests'
+TEST_FILES    = Pathname.glob( TESTDIR + '**/*.tests.rb' ).delete_if {|item| item =~ /\.svn/ }
+
+RAKE_TASKDIR  = BASEDIR + 'rake'
+RAKE_TASKLIBS = Pathname.glob( RAKE_TASKDIR + '*.rb' )
+
+LOCAL_RAKEFILE = BASEDIR + 'Rakefile.local'
+
+EXTRA_PKGFILES = []
+EXTRA_PKGFILES.concat Pathname.glob( BASEDIR + 'examples/*.rb' ).delete_if {|item| item =~ /\.svn/ } 
+
+RELEASE_FILES = TEXT_FILES + 
+	SPEC_FILES + 
+	TEST_FILES + 
+	LIB_FILES + 
+	EXT_FILES + 
+	RAKE_TASKLIBS +
+	EXTRA_PKGFILES
+
+RELEASE_FILES << LOCAL_RAKEFILE if LOCAL_RAKEFILE.exist?
+
+COVERAGE_MINIMUM = ENV['COVERAGE_MINIMUM'] ? Float( ENV['COVERAGE_MINIMUM'] ) : 85.0
+RCOV_EXCLUDES = 'spec,tests,/Library/Ruby,/var/lib,/usr/local/lib'
+RCOV_OPTS = [
+	'--exclude', RCOV_EXCLUDES,
+	'--xrefs',
+	'--save',
+	'--callsites',
+	#'--aggregate', 'coverage.data' # <- doesn't work as of 0.8.1.2.0
+  ]
+
+
+# Subversion constants -- directory names for releases and tags
+SVN_TRUNK_DIR    = 'trunk'
+SVN_RELEASES_DIR = 'releases'
+SVN_BRANCHES_DIR = 'branches'
+SVN_TAGS_DIR     = 'tags'
+
+SVN_DOTDIR       = BASEDIR + '.svn'
+SVN_ENTRIES      = SVN_DOTDIR + 'entries'
+
+
+### Load some task libraries that need to be loaded early
+require RAKE_TASKDIR + 'helpers.rb'
+require RAKE_TASKDIR + 'svn.rb'
+require RAKE_TASKDIR + 'verifytask.rb'
+
+# Define some constants that depend on the 'svn' tasklib
+PKG_BUILD = get_svn_rev( BASEDIR ) || 0
+SNAPSHOT_PKG_NAME = "#{PKG_FILE_NAME}.#{PKG_BUILD}"
+SNAPSHOT_GEM_NAME = "#{SNAPSHOT_PKG_NAME}.gem"
+
+# Documentation constants
+RDOC_OPTIONS = [
+	'-w', '4',
+	'-SHN',
+	'-i', '.',
+	'-m', 'README',
+	'-W', 'http://deveiate.org/projects/IO-Reactor//browser/trunk/'
+  ]
+
+# Release constants
+SMTP_HOST = 'mail.faeriemud.org'
+SMTP_PORT = 465 # SMTP + SSL
+
+# Project constants
+PROJECT_HOST = 'deveiate.org'
+PROJECT_PUBDIR = "/usr/local/www/public/code"
+PROJECT_DOCDIR = "#{PROJECT_PUBDIR}/#{PKG_NAME}"
+PROJECT_SCPPUBURL = "#{PROJECT_HOST}:#{PROJECT_PUBDIR}"
+PROJECT_SCPDOCURL = "#{PROJECT_HOST}:#{PROJECT_DOCDIR}"
+
+# Rubyforge stuff
+RUBYFORGE_GROUP = 'deveiate'
+RUBYFORGE_PROJECT = 'io-reactor'
+
+# Gem dependencies: gemname => version
+DEPENDENCIES = {
+}
+
+# Non-gem requirements: packagename => version
+REQUIREMENTS = {
+}
+
+# RubyGem specification
+GEMSPEC   = Gem::Specification.new do |gem|
+	gem.name              = PKG_NAME.downcase
+	gem.version           = PKG_VERSION
+
+	gem.summary           = PKG_SUMMARY
+	gem.description       = <<-EOD
+	A pure-Ruby implementation of an asynchronous multiplexed IO
+	Reactor which is based on the Reactor design pattern found in _Pattern-Oriented
+	Software Architecture, Volume 2: Patterns for Concurrent and Networked
+	Objects_. It allows a single thread to demultiplex and dispatch events from one
+	or more IO objects to the appropriate handler.
+	EOD
+
+	gem.authors           = 'Michael Granger'
+	gem.email             = 'ged@FaerieMUD.org'
+	gem.homepage          = 'http://deveiate.org/projects/IO-Reactor/'
+	gem.rubyforge_project = RUBYFORGE_PROJECT
+
+	gem.has_rdoc          = true
+	gem.rdoc_options      = RDOC_OPTIONS
+
+	gem.files             = RELEASE_FILES.
+		collect {|f| f.relative_path_from(BASEDIR).to_s }
+	gem.test_files        = SPEC_FILES.
+		collect {|f| f.relative_path_from(BASEDIR).to_s }
+		
+	DEPENDENCIES.each do |name, version|
+		version = '>= 0' if version.length.zero?
+		gem.add_dependency( name, version )
+	end
+	
+	REQUIREMENTS.each do |name, version|
+		gem.requirements << [ name, version ].compact.join(' ')
+	end
+end
+
+$trace = Rake.application.options.trace ? true : false
+$dryrun = Rake.application.options.dryrun ? true : false
+
+
+# Load any remaining task libraries
+RAKE_TASKLIBS.each do |tasklib|
+	next if tasklib =~ %r{/(helpers|svn|verifytask)\.rb$}
+	begin
+		require tasklib
+	rescue ScriptError => err
+		fail "Task library '%s' failed to load: %s: %s" %
+			[ tasklib, err.class.name, err.message ]
+		trace "Backtrace: \n  " + err.backtrace.join( "\n  " )
+	rescue => err
+		log "Task library '%s' failed to load: %s: %s. Some tasks may not be available." %
+			[ tasklib, err.class.name, err.message ]
+		trace "Backtrace: \n  " + err.backtrace.join( "\n  " )
+	end
+end
+
+# Load any project-specific rules defined in 'Rakefile.local' if it exists
+import LOCAL_RAKEFILE if LOCAL_RAKEFILE.exist?
+
+
+#####################################################################
+###	T A S K S 	
+#####################################################################
+
+### Default task
+task :default  => [:clean, :local, :spec, :rdoc, :package]
+
+### Task the local Rakefile can append to -- no-op by default
+task :local
+
+
+### Task: clean
+CLEAN.include 'coverage'
+CLOBBER.include 'artifacts', 'coverage.info', PKGDIR
+
+# Target to hinge on ChangeLog updates
+file SVN_ENTRIES
+
+### Task: changelog
+file 'ChangeLog' => SVN_ENTRIES.to_s do |task|
+	log "Updating #{task.name}"
+
+	changelog = make_svn_changelog()
+	File.open( task.name, 'w' ) do |fh|
+		fh.print( changelog )
+	end
+end
+
+
+### Task: cruise (Cruisecontrol task)
+desc "Cruisecontrol build"
+task :cruise => [:clean, :spec, :package] do |task|
+	raise "Artifacts dir not set." if ARTIFACTS_DIR.to_s.empty?
+	artifact_dir = ARTIFACTS_DIR.cleanpath
+	artifact_dir.mkpath
+	
+	coverage = BASEDIR + 'coverage'
+	if coverage.exist? && coverage.directory?
+		$stderr.puts "Copying coverage stats..."
+		FileUtils.cp_r( 'coverage', artifact_dir )
+	end
+	
+	$stderr.puts "Copying packages..."
+	FileUtils.cp_r( FileList['pkg/*'].to_a, artifact_dir )
+end
+
+
+desc "Update the build system to the latest version"
+task :update_build do
+	log "Updating the build system"
+	sh 'svn', 'up', RAKE_TASKDIR
+	log "Updating the Rakefile"
+	sh 'rake', '-f', RAKE_TASKDIR + 'Metarakefile'
+end
+

data/examples/chatserver.rb

@@ -35,7 +35,7 @@
 #
 # == Version
 #
-#  $Id: chatserver.rb,v 1.4 2003/08/04 23:53:32 deveiant Exp $
+#  $Id: chatserver.rb 85 2008-08-19 20:30:57Z deveiant $
 # 
 
 require 'io/reactor'

data/examples/simple.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+
+require 'io/reactor'
+
+def debug( msg )
+	return unless $DEBUG
+	$stderr.puts( "  " + msg )
+end
+
+reactor = IO::Reactor.new
+data_to_send = "some stuff to send"
+
+reader, writer = IO.pipe
+
+# Read from the reader end of the pipe until the writer finishes
+reactor.register( reader, :read ) do |io,event|
+	if io.eof?
+		debug "done with reading, closing reader"
+		reactor.unregister( io )
+		io.close
+	else
+		debug "reading..."
+		puts io.read( 256 )
+	end
+end
+
+# Write to the writer end of the pipe until there's no data left
+reactor.register( writer, :write ) do |io,event|
+	debug "writing..."
+	bytes = io.write( data_to_send )
+	data_to_send.slice!( 0, bytes )
+
+	if data_to_send.empty?
+		debug "done with writing; closing writer."
+		reactor.unregister( io )
+		io.close
+	end
+end
+
+# Now pump the reactor until both sides are done
+puts "Starting IO"
+until reactor.empty?
+	debug "polling..."
+	reactor.poll
+end
+puts "done, exiting."
+
+
+# $ ruby -d -Ilib examples/simple.rb
+# Starting IO
+#   polling...
+#   writing...
+#   done with writing; closing writer.
+#   polling...
+#   reading...
+# some stuff to send
+#   polling...
+#   done with reading, closing reader
+# done, exiting.

data/examples/simpleserver.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+require 'socket'
+require 'io/reactor'
+
+listener = TCPServer.new( '127.0.0.1', 18181 )
+reactor = IO::Reactor.new
+
+Signal.trap( 'HUP' ) { reactor.clear }
+Signal.trap( 'INT' ) { reactor.clear }
+
+reactor.register( listener, :read ) do |sock, _|
+	client = sock.accept
+	$stderr.puts "Accepted client from %s:%d" % [ client.peeraddr[2], client.peeraddr[1] ]
+	# message = Time.now.to_s + "\r\n\r\n"
+	message = File.read(__FILE__) + "\r\n\r\n"
+
+	reactor.register( client, message, :write ) do |io, event, buf|
+		bytes = io.write( buf )
+		buf.slice!( 0, bytes )
+
+		if buf.empty?
+			reactor.unregister( io )
+			io.close
+		end
+	end
+end
+
+
+$stdout.puts "Starting up..."
+until reactor.empty?
+	reactor.poll( 0.1 ) do |io, event|
+		case event
+		when :error
+			$stderr.puts "  %p: in the error event handler" % [ io ]
+			reactor.unregister( io )
+			io.close
+		else
+			fail "Reactor got unexpected event %p on %p" % [ event, io ]
+		end
+	end
+end
+$stdout.puts "Server shut down."
+

data/lib/io/reactor.rb

@@ -1,48 +1,45 @@
-#!/usr/bin/ruby
-# 
+#!/usr/bin/env ruby
+
+class IO # :nodoc:
+
 # An object-oriented multiplexing asynchronous IO mechanism for Ruby.
 # 
 # == Synopsis
 # 
-#   require 'io/reactor'
-#   require 'socket'
-#  
-#   reactorobj = IO::Reactor::new
-# 
-#   # Open a listening socket on port 1138 and register it with the
-#   # reactor. When a :read event occurs on it, it means an incoming
-#   # connection has been established
-#   sock = TCPServer::new('localhost', 1138)
-#   reactorobj.register( sock, :read ) {|sock,event|
-#       case event
-#
-#       # Accept the incoming connection, registering it also with
-#       # the reactor; events on client sockets are handled by the
-#       # #clientHandler method.
-#       when :read
-#           clsock = sock.accept
-#           reactorobj.register( clsock, :read, :write,
-#               &method(:clientHandler) )
-#
-#       # Errors on the main listening socket cause the whole
-#       # reactor to be shut down
-#       when :error
-#           reactorobj.clear
-#           $stderr.puts "Server error: Shutting down"
-#
-#       else
-#           $stderr.puts "Unhandled event: #{event}"
-#       end
-#   }
-#
-#   # Drive the reactor until it's empty with a single thread
-#   Thread::new { reactorobj.poll until reactorobj.empty? }
+#    reactor = IO::Reactor.new
+#    data_to_send = "some stuff to send"
+#    
+#    reader, writer = IO.pipe
+#    
+#    # Read from the reader end of the pipe until the writer finishes
+#    reactor.register( reader, :read ) do |io,event|
+#        if io.eof?
+#            reactor.unregister( io )
+#            io.close
+#        else
+#            puts io.read( 256 )
+#        end
+#    end
+#    
+#    # Write to the writer end of the pipe until there's no data left
+#    reactor.register( writer, :write ) do |io,event|
+#        bytes = io.write( data_to_send )
+#        data_to_send.slice!( 0, bytes )
+#    
+#        if data_to_send.empty?
+#            reactor.unregister( io )
+#            io.close
+#        end
+#    end
+#    
+#    # Now pump the reactor until both sides are done
+#    reactor.poll until reactor.empty?
 #
 # == Author
 # 
 # Michael Granger <ged@FaerieMUD.org>
 # 
-# Copyright (c) 2002, 2003 The FaerieMUD Consortium. All rights reserved.
+# Copyright (c) 2002-2008 The FaerieMUD Consortium. All rights reserved.
 # 
 # This module is free software. You may use, modify, and/or redistribute this
 # software under the same terms as Ruby itself.
@@ -53,33 +50,40 @@
 #
 # == Version
 #
-#  $Id: reactor.rb,v 1.13 2003/08/04 23:56:14 deveiant Exp $
+#  $Id: reactor.rb 86 2008-08-19 23:41:58Z deveiant $
 # 
+class Reactor
 
-require 'delegate'
-require 'rbconfig'
+	### Class constants
 
-class IO
+	# SVN Revision
+	SVNRev = %q$Rev: 86 $
 
-### An object-oriented multiplexing asynchronous IO reactor class.
-class Reactor
+	# SVN Id
+	SVNId = %q$Id: reactor.rb 86 2008-08-19 23:41:58Z deveiant $
 
-	### Class constants
-	Version = /([\d\.]+)/.match( %q{$Revision: 1.13 $} )[1]
-	Rcsid = %q$Id: reactor.rb,v 1.13 2003/08/04 23:56:14 deveiant Exp $
+	# Package version
+	VERSION = '1.0.4'
 
-	ValidEvents = [:read, :write, :error]
+	# List of valid event types, in the order IO#select returns them
+	VALID_EVENTS = [:read, :write, :error]
+	VALID_EVENTS.freeze
+
+
+	#################################################################
+	###	I N S T A N C E   M E T H O D S
+	#################################################################
 
 	### Create and return a new IO reactor object.
 	def initialize
-		@handles		= Hash::new {|hsh,key|
+		@handles		= Hash.new {|hsh,key|
 			hsh[ key ] = {
 				:events		=> [],
 				:handler	=> nil,
 				:args		=> [],
 			}
 		}
-		@pendingEvents	= Hash::new {|hsh,key| hsh[ key ] = []}
+		@pending_events	= Hash.new {|hsh,key| hsh[ key ] = []}
 	end
 
 
@@ -94,7 +98,8 @@ class Reactor
 
 	# The Hash of unhandled events which occurred in the last call to #poll,
 	# keyed by handle.
-	attr_reader :pendingEvents
+	attr_reader :pending_events
+	alias_method :pendingEvents, :pending_events
 
 
 	### Register the specified IO object with the reactor for events given as
@@ -114,15 +119,15 @@ class Reactor
 	### Registering a handle will unregister any previously registered
 	### event/handler+arguments pairs associated with the handle.
 	def register( io, *args, &handler )
-		events = [:read, :write, :error] & args
+		events = VALID_EVENTS & args
 		args -= events
 
 		self.unregister( io )
-		self.enableEvents( io, *events )
+		self.enable_events( io, *events )
 		if handler
-			self.setHandler( io, *args, &handler )
+			self.set_handler( io, *args, &handler )
 		else
-			self.setArgs( io, *args )
+			self.set_args( io, *args )
 		end
 
 		return self
@@ -130,81 +135,95 @@ class Reactor
 	alias_method :add, :register
 
 
+	### Returns +true+ if the given +io+ handle is registered with the reactor.
+	def registered?( io )
+		return @handles.key?( io )
+	end
+
+
 	### Add the specified +events+ to the list that will be polled for on the
 	### given +io+ handle.
-	def enableEvents( io, *events )
+	def enable_events( io, *events )
 		@handles[ io ][:events] |= events
 	end
+	alias_method :enableEvents, :enable_events
 
 
 	### Remove the specified +events+ from the list that will be polled for on
 	### the given +io+ handle.
-	def disableEvents( io, *events )
+	def disable_events( io, *events )
 		raise RuntimeError, "Cannot disable the :error event" if
 			events.include?( :error )
 		@handles[ io ][:events] -= events
 	end
+	alias_method :disableEvents, :disable_events
 
 
+	### Returns +true+ if the specified +event+ is enabled for the given +io+.
+	def event_enabled?( io, event )
+		return false unless @handles.key?( io )
+		return true if event == :error # Error is always enabled for all handles
+		return @handles[ io ][ :events ].include?( event )
+	end
+	alias_method :has_event_enabled?, :event_enabled?
+	
+
 	### Set the handler for events on the given +io+ handle to the specified
 	### +handler+. If any +args+ are present, they will be passed as an exploded
 	### array to the handler for each event. Returns the previously-registered
 	### handler, if any.
-	def setHandler( io, *args, &handler )
+	def set_handler( io, *args, &handler )
 		rval = @handles[ io ][:handler]
 		@handles[ io ][:handler] = handler
-		self.setArgs( io, *args )
+		self.set_args( io, *args )
 		return rval
 	end
+	alias_method :setHandler, :set_handler
 
 
 	### Remove and return the handler for events on the given +io+ handle.
-	def removeHandler( io )
+	def remove_handler( io )
 		rval = @handles[ io ][:handler]
 		@handles[ io ][:handler] = nil
-		self.removeArgs( io )
+		self.remove_args( io )
 		return rval
 	end
+	alias_method :removeHandler, :remove_handler
 
 
 	### Set the additional arguments to pass to the handler for the given +io+
 	### handle on each event to the given +args+.
-	def setArgs( io, *args )
+	def set_args( io, *args )
 		rval = @handles[ io ][:args]
 		@handles[ io ][:args] = args
 		return rval
 	end
+	alias_method :setArgs, :set_args
 
 
 	### Remove the arguments for the given handle to the given +args+.
-	def removeArgs( io )
+	def remove_args( io )
 		return @handles[ io ][:args].clear
 	end
+	alias_method :removeArgs, :remove_args
 
 
 	### Remove the specified <tt>io</tt> from the receiver's list of registered
 	### handles, if present. Returns the handle if it was registered, or
 	### <tt>nil</tt> if it was not.
 	def unregister( io )
-		@pendingEvents.delete( io )
+		@pending_events.delete( io )
 		@handles.delete( io )
 	end
 	alias_method :remove, :unregister
 
 
-	### Returns true if the specified <tt>io</tt> is registered with the poll
-	### object.
-	def registered?( io )
-		return @handles.has_key?( io )
-	end
-
-
 	### Clear all registered handles from the poll object. Returns the handles
 	### that were cleared.
 	def clear
 		rv = @handles.keys
 
-		@pendingEvents.clear
+		@pending_events.clear
 		@handles.clear
 
 		return rv
@@ -228,7 +247,7 @@ class Reactor
 	### those handles with events. If a block is given, it will be invoked once
 	### for each handle which doesn't have an explicit handler. If no block is
 	### given, events without explicit handlers are inserted into the reactor's
-	### <tt>pendingEvents</tt> attribute.
+	### <tt>pending_events</tt> attribute.
 	###
 	### The <tt>timeout</tt> argument is the number of floating-point seconds to
 	### wait for an event before returning (ie., fourth argument to the
@@ -239,19 +258,22 @@ class Reactor
 	### occurred.
 	def poll( timeout=-1 ) # :yields: io, eventMask
 		timeout = timeout.to_f
-		@pendingEvents.clear
+		@pending_events.clear
 		count = 0
 
 		unless @handles.empty?
 			timeout = nil if timeout < 0
-			eventedHandles = self.getPendingEvents( timeout )
+			evented_handles = self.get_pending_events( timeout )
 
 			# For each event of each io that had an event happen, call any
 			# associated callback, or any provided block, or failing both of
 			# those, add the event to the hash of unhandled pending events.
-			eventedHandles.each {|io,events|
+			evented_handles.each do |io,events|
 				count += 1
-				events.each {|ev|
+				events.each do |ev|
+					# Don't continue if the io was unregistered by an earlier handler
+					break unless @handles.key?( io )
+					
 					args = @handles[ io ][:args]
 
 					if @handles[ io ][:handler]
@@ -259,10 +281,10 @@ class Reactor
 					elsif block_given?
 						yield( io, ev, *args )
 					else
-						@pendingEvents[io].push( ev )
+						@pending_events[io].push( ev )
 					end
-				}
-			}
+				end
+			end
 		end
 
 		return count
@@ -281,35 +303,40 @@ class Reactor
 
 	### Select on the registered handles, returning a Hash of handles => events
 	### for handles which had events occur.
-	def getPendingEvents( timeout )
-		eventHandles = IO::select( self.getReadHandles, self.getWriteHandles,
+	def get_pending_events( timeout )
+		@handles.delete_if {|io,_| io.closed? }
+
+		eventHandles = select( self.get_read_handles, self.get_write_handles,
 			@handles.keys, timeout ) or return {}
-		eventHash = Hash::new {|hsh,io| hsh[io] = []}
+		eventHash = Hash.new {|hsh,io| hsh[io] = []}
 
 		# Fill in the hash with pending events of each type
-		[:read, :write, :error].each_with_index {|event,i|
+		VALID_EVENTS.each_with_index do |event,i|
 			eventHandles[i].each {|io| eventHash[io].push( event )}
-		}
+		end
 		return eventHash
 	end
+	alias_method :getPendingEvents, :get_pending_events
 
 
 	### Return an Array of handles which have handlers for the <tt>:read</tt>
 	### event.
-	def getReadHandles
+	def get_read_handles
 		@handles.
 			find_all {|io,hsh| hsh[:events].include?( :read )}.
-			collect {|io,hsh| io}
+			collect {|io,_| io }
 	end
+	alias_method :getReadHandles, :get_read_handles
 
 
 	### Return an Array of handles which have handlers for the <tt>:write</tt>
 	### event.
-	def getWriteHandles
+	def get_write_handles
 		@handles.
 			find_all {|io,hsh| hsh[:events].include?( :write )}.
-			collect {|io,hsh| io}
+			collect {|io,_| io }
 	end
+	alias_method :getWriteHandles, :get_write_handles
 
 
 end # class Reactor