eventmachine-win32 0.7.0 → 0.7.2

data/LEGAL

@@ -0,0 +1,25 @@
+LEGAL NOTICE INFORMATION
+------------------------
+
+EventMachine is Copyright (C) 2006-07 by Francis Cianfrocca.
+
+EventMachine is copyrighted software owned by Francis Cianfrocca
+(blackhedd ... gmail.com). You may redistribute and/or modify this
+software as long as you comply with either the terms of the GPL
+(see the file GPL), or Ruby's license (see the file COPYING).
+
+Your use of all the files in this distribution is controlled by these
+license terms, except for those files specifically mentioned below:
+
+
+
+setup.rb
+	This file is Copyright (C) 2000-2005 by Minero Aoki
+	You can distribute/modify this file under the terms of
+	the GNU LGPL, Lesser General Public License version 2.1.
+
+
+lib/protocols/buftok.rb
+	This file is Copyright (C) 2007 by Tony Arcieri. This file is
+	covered by the terms of Ruby's License (see the file COPYING).
+

data/README

@@ -1,12 +1,14 @@
-$Id: README 47 2006-05-15 21:42:38Z blackhedd $
+$Id: README 317 2007-05-22 21:55:43Z blackhedd $
 
 = RUBY/EventMachine
 
 Homepage::  http://rubyeventmachine.com
-Copyright:: (C) 2006 by Francis Cianfrocca. All Rights Reserved.
+Copyright:: (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
 Email:: gmail address: garbagecat10
 
-This program is made available under the terms of the Lesser-GPL version 2.
+EventMachine is copyrighted free software made available under the terms
+of either the GPL or Ruby's License. See the file COPYING for full licensing
+information.
 See EventMachine and EventMachine::Connection for documentation and
 usage examples.
 

data/RELEASE_NOTES

@@ -1,9 +1,14 @@
-$Id: RELEASE_NOTES 223 2006-08-08 20:30:41Z blackhedd $
+$Id: RELEASE_NOTES 286 2006-11-28 03:18:18Z blackhedd $
 
 RUBY/EventMachine RELEASE NOTES
 
 --------------------------------------------------
-Version: 0.7.0, released xxAug06
+Version: 0.7.1, released xxNov06
+Added protocol handlers for line-oriented protocols.
+Various bug fixes.
+
+--------------------------------------------------
+Version: 0.7.0, released 20Nov06
 Added a fix in em.cpp/ConnectToServer to fix a fatal exception that
 occurred in FreeBSD when connecting successfully to a remote server.
 

data/lib/em/deferrable.rb

@@ -1,34 +1,23 @@
-# $Id: deferrable.rb 216 2006-07-17 10:20:42Z blackhedd $
+# $Id: deferrable.rb 320 2007-05-22 22:12:59Z blackhedd $
 #
-# Author:: blackhedd (gmail address: garbagecat10).
-# Date:: 16 July 2006
+# Author:: Francis Cianfrocca (gmail: blackhedd)
+# Homepage::  http://rubyeventmachine.com
+# Date:: 16 Jul 2006
 # 
-# Copyright (C) 2006 by Francis Cianfrocca. All Rights Reserved.
-#
-# This program is made available under the terms of the GPL version 2.
-#
 # See EventMachine and EventMachine::Connection for documentation and
 # usage examples.
 #
 #----------------------------------------------------------------------------
 #
-# Copyright (C) 2006 by Francis Cianfrocca. All Rights Reserved.
-#
-# Gmail: garbagecat10
-#
+# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
+# Gmail: blackhedd
+# 
 # This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# This program 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.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+# it under the terms of either: 1) the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
 #
 #---------------------------------------------------------------------------
 #
@@ -42,7 +31,7 @@ module Deferrable
   def callback &block
     return unless block
     if @deferred_status == :succeeded
-      block.call
+      block.call(*@deferred_args)
     else
       @callbacks ||= []
       @callbacks << block
@@ -52,7 +41,7 @@ module Deferrable
   def errback &block
     return unless block
     if @deferred_status == :failed
-      block.call
+      block.call(*@deferred_args)
     else
       @errbacks ||= []
       @errbacks << block
@@ -65,6 +54,18 @@ module Deferrable
   # user code will throw an argument exception.
   # Implementors of deferrable classes <b>must</b>
   # document the arguments they will supply to user callbacks.
+  #
+  # OBSERVE SOMETHING VERY SPECIAL here: you may call this method even
+  # on the INSIDE of a callback. This is very useful when a previously-registered
+  # callback wants to change the parameters that will be passed to subsequently-registered
+  # ones.
+  # --
+  # We're shifting callbacks off and discarding them as we execute them.
+  # This is valid because by definition callbacks are executed no more than
+  # once. It also has the magic effect of permitting recursive calls, which
+  # means that a callback can call #set_deferred_status and change the parameters
+  # that will be sent to subsequent callbacks down the chain.
+  #
   def set_deferred_status arg, *args
     @deferred_status = arg
     @deferred_args = args
@@ -72,18 +73,30 @@ module Deferrable
     when :succeeded
       if @callbacks
         while cb = @callbacks.shift
-          cb.call *@deferred_args
+          cb.call(*@deferred_args)
         end
       end
     when :failed
       if @errbacks
         while eb = @errbacks.shift
-          eb.call *@deferred_args
+          eb.call(*@deferred_args)
         end
       end
     end
   end
 
+  # Equivalent to set_deferred_status(:succeeded, ...)
+  #
+  def set_deferred_success *args
+	  set_deferred_status :succeeded, *args
+  end
+
+  # Equivalent to set_deferred_status(:failed, ...)
+  #
+  def set_deferred_failure *args
+	  set_deferred_status :failed, *args
+  end
+
 end
 end
 

data/lib/em/eventable.rb

@@ -1,34 +1,23 @@
-# $Id: eventable.rb 252 2006-09-02 19:23:20Z blackhedd $
+# $Id: eventable.rb 320 2007-05-22 22:12:59Z blackhedd $
 #
-# Author:: blackhedd (gmail address: garbagecat10).
-# Date:: 16 July 2006
+# Author:: Francis Cianfrocca (gmail: blackhedd)
+# Homepage::  http://rubyeventmachine.com
+# Date:: 16 Jul 2006
 # 
-# Copyright (C) 2006 by Francis Cianfrocca. All Rights Reserved.
-#
-# This program is made available under the terms of the GPL version 2.
-#
 # See EventMachine and EventMachine::Connection for documentation and
 # usage examples.
 #
 #----------------------------------------------------------------------------
 #
-# Copyright (C) 2006 by Francis Cianfrocca. All Rights Reserved.
-#
-# Gmail: garbagecat10
-#
+# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
+# Gmail: blackhedd
+# 
 # This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# This program 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.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+# it under the terms of either: 1) the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
 #
 #---------------------------------------------------------------------------
 #

data/lib/em/future.rb

@@ -0,0 +1,62 @@
+# $Id: future.rb 320 2007-05-22 22:12:59Z blackhedd $
+#
+# Author:: Francis Cianfrocca (gmail: blackhedd)
+# Homepage::  http://rubyeventmachine.com
+# Date:: 16 Jul 2006
+# 
+# See EventMachine and EventMachine::Connection for documentation and
+# usage examples.
+#
+#----------------------------------------------------------------------------
+#
+# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
+# Gmail: blackhedd
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#
+#---------------------------------------------------------------------------
+#
+# 
+
+# This defines EventMachine::Deferrable#future, which requires
+# that the rest of EventMachine::Deferrable has already been seen.
+# (It's in deferrable.rb.)
+#
+# A future is a sugaring of a typical deferrable usage.
+
+module EventMachine
+    module Deferrable
+
+	class << self
+	    # Evaluate arg (which may be an expression or a block).
+	    # What's the class of arg?
+	    # If arg is an ordinary expression, then return it.
+	    # If arg is deferrable (responds to :set_deferred_status),
+	    # then look at the arguments. If either callback or errback
+	    # are defined, then use them. If neither are defined, then
+	    # use the supplied block (if any) as the callback.
+	    # Then return arg.
+	    def future arg, cb=nil, eb=nil, &blk
+		arg = arg.call if arg.respond_to?(:call)
+
+		if arg.respond_to?(:set_deferred_status)
+		    if cb || eb
+			arg.callback(&cb) if cb
+			arg.errback(&eb) if eb
+		    else
+			arg.callback(&blk) if blk
+		    end
+		end
+
+		arg
+	    end
+	end
+
+    end
+end
+

data/lib/eventmachine.rb

@@ -1,34 +1,23 @@
-# $Id: eventmachine.rb 283 2006-11-22 14:44:38Z blackhedd $
+# $Id: eventmachine.rb 319 2007-05-22 22:11:18Z blackhedd $
 #
-# Author:: blackhedd (gmail address: garbagecat10).
+# Author:: Francis Cianfrocca (gmail: blackhedd)
+# Homepage::  http://rubyeventmachine.com
 # Date:: 8 Apr 2006
 # 
-# Copyright (C) 2006 by Francis Cianfrocca. All Rights Reserved.
-#
-# This program is made available under the terms of the GPL version 2.
-#
 # See EventMachine and EventMachine::Connection for documentation and
 # usage examples.
 #
 #----------------------------------------------------------------------------
 #
-# Copyright (C) 2006 by Francis Cianfrocca. All Rights Reserved.
-#
-# Gmail: garbagecat10
-#
+# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
+# Gmail: blackhedd
+# 
 # This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# This program 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.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+# it under the terms of either: 1) the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
 #
 #---------------------------------------------------------------------------
 #
@@ -36,6 +25,7 @@
 
 
 #-- Select in a library based on a global variable.
+$eventmachine_library ||= nil
 case $eventmachine_library
 when :pure_ruby
   require 'pr_eventmachine'
@@ -54,6 +44,7 @@ end
 
 require "eventmachine_version"
 require 'em/deferrable'
+require 'em/future'
 require 'em/eventable'
 #-- Additional requires are at the BOTTOM of this file, because they
 #-- depend on stuff defined in here. Refactor that someday.
@@ -157,50 +148,59 @@ require 'em/eventable'
 module EventMachine
 
 
-  # EventMachine::run initializes and runs an event loop.
-  # This method only returns if user-callback code calls stop_event_loop.
-  # Use the supplied block to define your clients and servers.
-  # The block is called by EventMachine::run immediately after initializing
-  # its internal event loop but <i>before</i> running the loop.
-  # Therefore this block is the right place to call start_server if you
-  # want to accept connections from remote clients.
-  #
-  # For programs that are structured as servers, it's usually appropriate
-  # to start an event loop by calling EventMachine::run, and let it
-  # run forever. It's also possible to use EventMachine::run to make a single
-  # client-connection to a remote server, process the data flow from that
-  # single connection, and then call stop_event_loop to force EventMachine::run
-  # to return. Your program will then continue from the point immediately
-  # following the call to EventMachine::run.
-  #
-  # You can of course do both client and servers simultaneously in the same program.
-  # One of the strengths of the event-driven programming model is that the
-  # handling of network events on many different connections will be interleaved,
-  # and scheduled according to the actual events themselves. This maximizes
-  # efficiency.
-  #
-  # === Server usage example
-  #
-  # See the text at the top of this file for an example of an echo server.
-  #
-  # === Client usage example
-  #
-  # See the description of stop_event_loop for an extremely simple client example.
-  #
-  #--
-  # Obsoleted the use_threads mechanism.
-  #
-  def EventMachine::run &block
-  #def EventMachine::run use_threads = true, &block
-    @conns = {}
-    @acceptors = {}
-    @timers = {}
-    initialize_event_machine
-    block and add_timer 0, block
-    #use_threads ? run_machine : run_machine_without_threads
-    run_machine
-    release_machine
-  end
+    # EventMachine::run initializes and runs an event loop.
+    # This method only returns if user-callback code calls stop_event_loop.
+    # Use the supplied block to define your clients and servers.
+    # The block is called by EventMachine::run immediately after initializing
+    # its internal event loop but <i>before</i> running the loop.
+    # Therefore this block is the right place to call start_server if you
+    # want to accept connections from remote clients.
+    #
+    # For programs that are structured as servers, it's usually appropriate
+    # to start an event loop by calling EventMachine::run, and let it
+    # run forever. It's also possible to use EventMachine::run to make a single
+    # client-connection to a remote server, process the data flow from that
+    # single connection, and then call stop_event_loop to force EventMachine::run
+    # to return. Your program will then continue from the point immediately
+    # following the call to EventMachine::run.
+    #
+    # You can of course do both client and servers simultaneously in the same program.
+    # One of the strengths of the event-driven programming model is that the
+    # handling of network events on many different connections will be interleaved,
+    # and scheduled according to the actual events themselves. This maximizes
+    # efficiency.
+    #
+    # === Server usage example
+    #
+    # See the text at the top of this file for an example of an echo server.
+    #
+    # === Client usage example
+    #
+    # See the description of stop_event_loop for an extremely simple client example.
+    #
+    #--
+    # Obsoleted the use_threads mechanism.
+    # 25Nov06: Added the begin/ensure block. We need to be sure that release_machine
+    # gets called even if an exception gets thrown within any of the user code
+    # that the event loop runs. The best way to see this is to run a unit
+    # test with two functions, each of which calls EventMachine#run and each of
+    # which throws something inside of #run. Without the ensure, the second test
+    # will start without release_machine being called and will immediately throw
+    # a C++ runtime error.
+    #
+    def EventMachine::run &block
+	@conns = {}
+	@acceptors = {}
+	@timers = {}
+	begin
+	    initialize_event_machine
+	    block and add_timer 0, block
+	    run_machine
+	ensure
+	    release_machine
+	end
+    end
+
 
   # +deprecated+
   #--
@@ -259,6 +259,7 @@ module EventMachine
       # check too many timers!
       s = add_oneshot_timer((interval * 1000).to_i)
       @timers[s] = code
+      s
     end
   end
 
@@ -290,6 +291,13 @@ module EventMachine
     end
   end
 
+	#--
+	#
+	def EventMachine::cancel_timer signature
+		@timers[signature] = proc{} if @timers.has_key?(signature)
+	end
+	private_class_method :cancel_timer
+
 
   # stop_event_loop may called from within a callback method
   # while EventMachine's processing loop is running.
@@ -594,6 +602,37 @@ module EventMachine
     end
 
 
+
+
+	# Make a connection to a Unix-domain socket. This is not implemented on Windows platforms.
+	# The parameter socketname is a String which identifies the Unix-domain socket you want
+	# to connect to. socketname is the name of a file on your local system, and in most cases
+	# is a fully-qualified path name. Make sure that your process has enough local permissions
+	# to open the Unix-domain socket.
+	# See also the documentation for #connect_server. This method behaves like #connect_server
+	# in all respects except for the fact that it connects to a local Unix-domain
+	# socket rather than a TCP socket.
+	# NOTE: this functionality will soon be subsumed into the #connect method. This method
+	# will still be supported as an alias.
+	#--
+	# For making connections to Unix-domain sockets.
+	# Eventually this has to get properly documented and unified with the TCP-connect methods.
+	# Note how nearly identical this is to EventMachine#connect
+	def EventMachine::connect_unix_domain socketname, handler=nil
+		klass = if (handler and handler.is_a?(Class))
+			handler
+		else
+			Class.new( Connection ) {handler and include handler}
+		end
+
+		s = connect_unix_server socketname
+		c = klass.new s
+		@conns[s] = c
+		block_given? and yield c
+		c
+	end
+
+
   # EventMachine#open_datagram_socket is for support of UDP-based
   # protocols. Its usage is similar to that of EventMachine#start_server.
   # It takes three parameters: an IP address (which must be valid
@@ -763,6 +802,18 @@ module EventMachine
     @threadqueue << [op,callback]
   end
 
+  # A wrapper over the setuid system call. Particularly useful when opening a network
+  # server on a privileged port because you can use this call to drop privileges
+  # after opening the port.
+  # This method has no effective implementation on Windows or in the pure-Ruby
+  # implementation of EventMachine.
+  # Call #set_effective_user by passing it a string containing the effective name
+  # of the user whose privilege-level your process should attain.
+  # This method is intended for use in enforcing security requirements, consequently
+  # it will throw a fatal error and end your program if it fails.
+  def self::set_effective_user username
+      EventMachine::setuid_string username
+  end
 
 
   private
@@ -1055,6 +1106,45 @@ class Connection
       EventMachine::reconnect server, port, self
   end
 
+
+
+
+	#
+	#
+	#
+	class EventMachine::PeriodicTimer
+		def initialize *args, &block
+			@interval = args.shift
+			@code = args.shift || block
+			schedule
+		end
+		def schedule
+			EventMachine::add_timer @interval, proc {self.fire}
+		end
+		def fire
+			@code.call
+			schedule unless @cancelled
+		end
+		def cancel
+			@cancelled = true
+		end
+	end
+
+	#
+	#
+	#
+	class EventMachine::Timer
+		def initialize *args, &block
+			@signature = EventMachine::add_timer(*args, &block)
+		end
+		def cancel
+			EventMachine.send :cancel_timer, @signature
+		end
+	end
+
+
+
+
 end