io-reactor 0.05

data/install.rb

@@ -0,0 +1,85 @@
+#!/usr/bin/ruby
+#
+# $Date: 2003/07/21 14:21:30 $
+# Copyright (c) 2000 Masatoshi SEKI
+#
+# install.rb is copyrighted free software by Masatoshi SEKI.
+# You can redistribute it and/or modify it under the same term as Ruby.
+
+require 'rbconfig'
+require 'find'
+require 'ftools'
+
+include Config
+
+class Installer
+  protected
+  def install(from, to, mode = nil, verbose = false)
+    str = "install '#{from}' to '#{to}'"
+    str += ", mode=#{mode}" if mode
+    puts str if verbose
+  end
+
+  protected
+  def makedirs(*dirs)
+    for d in dirs
+      puts "mkdir #{d}"
+    end
+  end
+
+  def initialize(test=false)
+    @version = CONFIG["MAJOR"]+"."+CONFIG["MINOR"]
+    @libdir = File.join(CONFIG["libdir"], "ruby", @version)
+    @sitelib = find_site_libdir
+    @ftools = (test) ? self : File
+  end
+  public
+  attr_reader(:libdir, :sitelib)
+
+  private
+  def find_site_libdir
+    site_libdir = $:.find {|x| x =~ /site_ruby$/}
+    if !site_libdir
+      site_libdir = File.join(@libdir, "site_ruby")
+    elsif site_libdir !~ Regexp::new( Regexp.quote(@version) )
+      site_libdir = File.join(site_libdir, @version)
+    end
+    site_libdir
+  end
+
+  public
+  def files_in_dir(dir)
+    list = []
+    Find.find(dir) do |f|
+      list.push(f)
+    end
+    list
+  end
+
+  public
+  def install_files(srcdir, files, destdir=@sitelib)
+    path = []
+    dir = []
+
+    for f in files
+      next if (f = f[srcdir.length+1..-1]) == nil
+      path.push f if File.ftype(File.join(srcdir, f)) == 'file'
+      dir |= [ File.dirname(File.join(destdir, f)) ]
+    end
+    @ftools.makedirs(*dir)
+    for f in path
+      @ftools.install(File.join(srcdir, f), File.join(destdir, f), nil, true)
+    end
+  end
+
+  public
+  def install_rb
+    intall_files('lib', files_in_dir('lib'))
+  end
+end
+
+if __FILE__ == $0
+  inst = Installer.new(ARGV.shift == '-n')
+  inst.install_files('lib', ['lib/io/reactor.rb'])
+end
+

data/io-reactor.gemspec

@@ -0,0 +1,21 @@
+require 'date'
+Gem::Specification.new do |s|
+  s.name = %q{io-reactor}
+  s.version = "0.05"
+  s.date = Date.today.to_s
+  s.summary = %q{An implementation of the Reactor design pattern for multiplexed asynchronous single-thread IO.}
+  s.description =<<DESCRIPTION
+An implementation of the Reactor design pattern for multiplexed asynchronous single-thread IO.
+DESCRIPTION
+  s.author = %q{Michael Granger}
+  s.email = %q{ged@FaerieMUD.org}
+  s.homepage = %q{http://www.deveiate.org/code/IO-Reactor.html}
+  s.files = Dir.glob('**/*') 
+  s.require_paths = %w{lib .}
+  s.autorequire = %q{io/reactor}
+  s.has_rdoc = true
+  s.rdoc_options = ["--main", "README"]
+  s.extra_rdoc_files = ["README"]
+  s.test_files = %w{test.rb}
+  s.required_ruby_version = Gem::Version::Requirement.new(">= 1.8.0")
+end

data/lib/io/reactor.rb

@@ -0,0 +1,317 @@
+#!/usr/bin/ruby
+# 
+# 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? }
+#
+# == Author
+# 
+# Michael Granger <ged@FaerieMUD.org>
+# 
+# Copyright (c) 2002, 2003 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.
+# 
+# This library is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+# == Version
+#
+#  $Id: reactor.rb,v 1.13 2003/08/04 23:56:14 deveiant Exp $
+# 
+
+require 'delegate'
+require 'rbconfig'
+
+class IO
+
+### An object-oriented multiplexing asynchronous IO reactor class.
+class Reactor
+
+	### 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 $
+
+	ValidEvents = [:read, :write, :error]
+
+	### Create and return a new IO reactor object.
+	def initialize
+		@handles		= Hash::new {|hsh,key|
+			hsh[ key ] = {
+				:events		=> [],
+				:handler	=> nil,
+				:args		=> [],
+			}
+		}
+		@pendingEvents	= Hash::new {|hsh,key| hsh[ key ] = []}
+	end
+
+
+	######
+	public
+	######
+
+	# The Hash of handles (instances of IO or its subclasses) associated with
+	# the reactor. The keys are the IO objects, and the values are a Hash of
+	# event/s => handler.
+	attr_reader :handles
+
+	# The Hash of unhandled events which occurred in the last call to #poll,
+	# keyed by handle.
+	attr_reader :pendingEvents
+
+
+	### Register the specified IO object with the reactor for events given as
+	### <tt>args</tt>. The reactor will test the given <tt>io</tt> for the
+	### events specified whenever #poll is called. See the #poll method for a
+	### list of valid events. If no events are specified, only <tt>:error</tt>
+	### events will be polled for.
+	###
+	### If a <tt>handler</tt> is specified, it will be called whenever the
+	### <tt>io</tt> has any of the specified <tt>events</tt> occur to it. It
+	### should take at least two parameters: the <tt>io</tt> and the event.
+	###
+	### If +args+ contains any objects except the Symbols '<tt>:read</tt>',
+	### '<tt>:write</tt>', or '<tt>:error</tt>', and a +handler+ is specified,
+	### they will be saved and passed to handler for each event.
+	### 
+	### 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
+		args -= events
+
+		self.unregister( io )
+		self.enableEvents( io, *events )
+		if handler
+			self.setHandler( io, *args, &handler )
+		else
+			self.setArgs( io, *args )
+		end
+
+		return self
+	end
+	alias_method :add, :register
+
+
+	### Add the specified +events+ to the list that will be polled for on the
+	### given +io+ handle.
+	def enableEvents( io, *events )
+		@handles[ io ][:events] |= events
+	end
+
+
+	### Remove the specified +events+ from the list that will be polled for on
+	### the given +io+ handle.
+	def disableEvents( io, *events )
+		raise RuntimeError, "Cannot disable the :error event" if
+			events.include?( :error )
+		@handles[ io ][:events] -= events
+	end
+
+
+	### 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 )
+		rval = @handles[ io ][:handler]
+		@handles[ io ][:handler] = handler
+		self.setArgs( io, *args )
+		return rval
+	end
+
+
+	### Remove and return the handler for events on the given +io+ handle.
+	def removeHandler( io )
+		rval = @handles[ io ][:handler]
+		@handles[ io ][:handler] = nil
+		self.removeArgs( io )
+		return rval
+	end
+
+
+	### 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 )
+		rval = @handles[ io ][:args]
+		@handles[ io ][:args] = args
+		return rval
+	end
+
+
+	### Remove the arguments for the given handle to the given +args+.
+	def removeArgs( io )
+		return @handles[ io ][:args].clear
+	end
+
+
+	### 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 )
+		@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
+		@handles.clear
+
+		return rv
+	end
+
+
+	
+	### Poll the handles registered to the reactor for pending events. The
+	### following event types are defined:
+	###
+	### [<tt>:read</tt>]
+	###   Data may be read from the handle without blocking.
+	### [<tt>:write</tt>]
+	###   Data may be written to the handle without blocking.
+	### [<tt>:error</tt>]
+	###   An error has occurred on the handle. This event type is always
+	###   enabled, regardless of whether or not it is passed as one of the
+	###   <tt>events</tt>.
+	###
+	### Any handlers specified when the handles were registered are run for
+	### 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.
+	###
+	### The <tt>timeout</tt> argument is the number of floating-point seconds to
+	### wait for an event before returning (ie., fourth argument to the
+	### underlying <tt>select()</tt> call); negative timeout values will cause
+	### #poll to block until there is at least one event to report.
+	###
+	### This method returns the number of handles on which one or more events
+	### occurred.
+	def poll( timeout=-1 ) # :yields: io, eventMask
+		timeout = timeout.to_f
+		@pendingEvents.clear
+		count = 0
+
+		unless @handles.empty?
+			timeout = nil if timeout < 0
+			eventedHandles = self.getPendingEvents( 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|
+				count += 1
+				events.each {|ev|
+					args = @handles[ io ][:args]
+
+					if @handles[ io ][:handler]
+						@handles[ io ][:handler].call( io, ev, *args )
+					elsif block_given?
+						yield( io, ev, *args )
+					else
+						@pendingEvents[io].push( ev )
+					end
+				}
+			}
+		end
+
+		return count
+	end
+
+
+	### Returns <tt>true</tt> if no handles are associated with the receiver.
+	def empty?
+		@handles.empty?
+	end
+
+
+	#########
+	protected
+	#########
+
+	### 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,
+			@handles.keys, timeout ) or return {}
+		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|
+			eventHandles[i].each {|io| eventHash[io].push( event )}
+		}
+		return eventHash
+	end
+
+
+	### Return an Array of handles which have handlers for the <tt>:read</tt>
+	### event.
+	def getReadHandles
+		@handles.
+			find_all {|io,hsh| hsh[:events].include?( :read )}.
+			collect {|io,hsh| io}
+	end
+
+
+	### Return an Array of handles which have handlers for the <tt>:write</tt>
+	### event.
+	def getWriteHandles
+		@handles.
+			find_all {|io,hsh| hsh[:events].include?( :write )}.
+			collect {|io,hsh| io}
+	end
+
+
+end # class Reactor
+end # class IO
+

data/makedocs.rb

@@ -0,0 +1,79 @@
+#!/usr/bin/ruby
+#
+#	MUES Documentation Generation Script
+#	$Id: makedocs.rb,v 1.3 2002/09/18 12:33:35 deveiant Exp $
+#
+#	Copyright (c) 2001,2002 The FaerieMUD Consortium.
+#
+#	This is free software. You may use, modify, and/or redistribute this
+#	software under the terms of the Perl Artistic License. (See
+#	http://language.perl.com/misc/Artistic.html)
+#
+
+# Muck with the load path and the cwd
+$basedir = File::expand_path( $0 ).sub( %r{/makedocs.rb}, '' )
+unless $basedir.empty? || Dir.getwd == $basedir
+	$stderr.puts "Changing working directory from '#{Dir.getwd}' to '#$basedir'"
+	Dir.chdir( $basedir ) 
+end
+
+$LOAD_PATH.unshift "docs/lib"
+
+# Load modules
+require 'getoptlong'
+require 'rdoc/rdoc'
+require "utils"
+include UtilityFunctions
+
+opts = GetoptLong.new
+opts.set_options(
+	[ '--debug',	'-d',	GetoptLong::NO_ARGUMENT ],
+	[ '--verbose',	'-v',	GetoptLong::NO_ARGUMENT ]
+)
+
+$docsdir = "docs/html"
+$libdirs = %w{poll.c lib examples README}
+opts.each {|opt,val|
+	case opt
+
+	when '--debug'
+		$debug = true
+
+	when '--verbose'
+		$verbose = true
+
+	when '--upload'
+		$upload = true
+
+	end
+}
+
+
+header "Making documentation in #$docsdir from files in #{$libdirs.join(', ')}."
+
+flags = [
+	'--main', 'README',
+	'--fmt', 'html',
+	'--include', 'docs',
+	'--op', $docsdir,
+	'--title', "Ruby-Poll"
+]
+
+message "Running 'rdoc #{flags.join(' ')} #{$libdirs.join(' ')}'\n" if $verbose
+
+unless $debug
+	begin
+		r = RDoc::RDoc.new
+		r.document( flags + $libdirs  )
+	rescue RDoc::RDocError => e
+		$stderr.puts e.message
+		exit(1)
+	end
+end
+
+# rdoc \
+#	--all \
+#	--inline_source \
+#	--main "lib/mues.rb" \
+#	--title "Multi-User Environment Server (MUES)" \
+#		lib server