eventmachine 0.12.6-x86-mswin32-60 → 0.12.8-x86-mswin32-60

data/lib/em/messages.rb

@@ -1,4 +1,4 @@
-# $Id$
+#--
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com

data/lib/em/process_watch.rb

@@ -0,0 +1,44 @@
+module EventMachine
+
+  # This is subclassed from EventMachine::Connection for use with the process monitoring API. Read the
+  # documentation on the instance methods of this class, and for a full explanation see EventMachine.watch_process.
+  class ProcessWatch < Connection
+    # :stopdoc:
+    Cfork = 'fork'.freeze
+    Cexit = 'exit'.freeze
+    # :startdoc:
+
+    def receive_data(data) # :nodoc:
+      case data
+      when Cfork
+        process_forked
+      when Cexit
+        process_exited
+      end
+    end
+
+    # Returns the pid that EventMachine::watch_process was originally called with.
+    def pid
+      @pid
+    end
+
+    # Should be redefined with the user's custom callback that will be fired when the prcess is forked.
+    #
+    # There is currently not an easy way to get the pid of the forked child.
+    def process_forked
+    end
+
+    # Should be redefined with the user's custom callback that will be fired when the process exits.
+    #
+    # stop_watching is called automatically after this callback
+    def process_exited
+    end
+
+    # Discontinue monitoring of the process.
+    # This will be called automatically when a process dies. User code may call it as well.
+    def stop_watching
+      EventMachine::unwatch_pid(@signature)
+    end
+  end
+
+end

data/lib/em/processes.rb

@@ -1,113 +1,119 @@
-# $Id$
-#
-# Author:: Francis Cianfrocca (gmail: blackhedd)
-# Homepage::  http://rubyeventmachine.com
-# Date:: 13 Dec 07
-# 
-# See EventMachine and EventMachine::Connection for documentation and
-# usage examples.
-#
-#----------------------------------------------------------------------------
-#
-# Copyright (C) 2006-08 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.
-#
-#---------------------------------------------------------------------------
-#
-# 
-
-
-module EventMachine
-
-	# EM::DeferrableChildProcess is a sugaring of a common use-case
-	# involving EM::popen.
-	# Call the #open method on EM::DeferrableChildProcess, passing
-	# a command-string. #open immediately returns an EM::Deferrable
-	# object. It also schedules the forking of a child process, which
-	# will execute the command passed to #open.
-	# When the forked child terminates, the Deferrable will be signalled
-	# and execute its callbacks, passing the data that the child process
-	# wrote to stdout.
-	#
-	class DeferrableChildProcess < EventMachine::Connection
-		include EventMachine::Deferrable
-
-		# Sugars a common use-case involving forked child processes.
-		# #open takes a String argument containing an shell command
-		# string (including arguments if desired). #open immediately
-		# returns an EventMachine::Deferrable object, without blocking.
-		#
-		# It also invokes EventMachine#popen to run the passed-in
-		# command in a forked child process.
-		#
-		# When the forked child terminates, the Deferrable that
-		# #open calls its callbacks, passing the data returned
-		# from the child process.
-		#
-		def self.open cmd
-			EventMachine.popen( cmd, DeferrableChildProcess )
-		end
-
-		def receive_data data
-			(@data ||= []) << data
-		end
-
-		def unbind
-			succeed( @data.join )
-		end
-	end
-
-  class SystemCmd < EventMachine::Connection # :nodoc:
-    def initialize cb
-      @cb = cb
-      @output = []
-    end
-    def receive_data data
-      @output << data
-    end
-    def unbind
-      @cb.call @output.join(''), get_status if @cb
-    end
-  end
-
-  # EM::system is a simple wrapper for EM::popen. It is similar to Kernel::system, but requires a
-  # single string argument for the command and performs no shell expansion.
-  #
-  # The block or proc passed to EM::system is called with two arguments: the output generated by the command,
-  # and a Process::Status that contains information about the command's execution.
-  #
-  #   EM.run{
-  #     EM.system('ls'){ |output,status| puts output if status.exitstatus == 0 }
-  #   }
-  #
-  # You can also supply an additional proc to send some data to the process:
-  #
-  #   EM.run{
-  #     EM.system('sh', proc{ |process|
-  #       process.send_data("echo hello\n")
-  #       process.send_data("exit\n")
-  #     }, proc{ |out,status|
-  #       puts(out)
-  #     })
-  #   }
-  #
-  # Like EM::popen, EM::system currently does not work on windows.
-  #
-  def EventMachine::system cmd, *args, &cb
-    cb ||= args.pop if args.last.is_a? Proc
-    init = args.pop if args.last.is_a? Proc
-
-    EM.popen(cmd, SystemCmd, cb) do |c|
-      init[c] if init
-    end
-  end
-end
-
-
+#--
+#
+# Author:: Francis Cianfrocca (gmail: blackhedd)
+# Homepage::  http://rubyeventmachine.com
+# Date:: 13 Dec 07
+# 
+# See EventMachine and EventMachine::Connection for documentation and
+# usage examples.
+#
+#----------------------------------------------------------------------------
+#
+# Copyright (C) 2006-08 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.
+#
+#---------------------------------------------------------------------------
+#
+# 
+
+
+module EventMachine
+
+  # EM::DeferrableChildProcess is a sugaring of a common use-case
+  # involving EM::popen.
+  # Call the #open method on EM::DeferrableChildProcess, passing
+  # a command-string. #open immediately returns an EM::Deferrable
+  # object. It also schedules the forking of a child process, which
+  # will execute the command passed to #open.
+  # When the forked child terminates, the Deferrable will be signalled
+  # and execute its callbacks, passing the data that the child process
+  # wrote to stdout.
+  #
+  class DeferrableChildProcess < EventMachine::Connection
+    include EventMachine::Deferrable
+
+    def initialize # :nodoc:
+      super
+      @data = []
+    end
+
+    # Sugars a common use-case involving forked child processes.
+    # #open takes a String argument containing an shell command
+    # string (including arguments if desired). #open immediately
+    # returns an EventMachine::Deferrable object, without blocking.
+    #
+    # It also invokes EventMachine#popen to run the passed-in
+    # command in a forked child process.
+    #
+    # When the forked child terminates, the Deferrable that
+    # #open calls its callbacks, passing the data returned
+    # from the child process.
+    #
+    def self.open cmd
+      EventMachine.popen( cmd, DeferrableChildProcess )
+    end
+
+    def receive_data data # :nodoc:
+      @data << data
+    end
+
+    def unbind # :nodoc:
+      succeed( @data.join )
+    end
+  end
+
+  class SystemCmd < EventMachine::Connection # :nodoc:
+    def initialize cb
+      @cb = cb
+      @output = []
+    end
+    def receive_data data
+      @output << data
+    end
+    def unbind
+      @cb.call @output.join(''), get_status if @cb
+    end
+  end
+
+  # EM::system is a simple wrapper for EM::popen. It is similar to Kernel::system, but requires a
+  # single string argument for the command and performs no shell expansion.
+  #
+  # The block or proc passed to EM::system is called with two arguments: the output generated by the command,
+  # and a Process::Status that contains information about the command's execution.
+  #
+  #  EM.run{
+  #    EM.system('ls'){ |output,status| puts output if status.exitstatus == 0 }
+  #  }
+  #
+  # You can also supply an additional proc to send some data to the process:
+  #
+  #  EM.run{
+  #    EM.system('sh', proc{ |process|
+  #      process.send_data("echo hello\n")
+  #      process.send_data("exit\n")
+  #    }, proc{ |out,status|
+  #      puts(out)
+  #    })
+  #  }
+  #
+  # Like EventMachine.popen, EventMachine.system currently does not work on windows.
+  # It returns the pid of the spawned process.
+  def EventMachine::system cmd, *args, &cb
+    cb ||= args.pop if args.last.is_a? Proc
+    init = args.pop if args.last.is_a? Proc
+
+    # merge remaining arguments into the command
+    cmd = ([cmd] + args.map{|a|a.to_s.dump}).join(' ')
+
+    EM.get_subprocess_pid(EM.popen(cmd, SystemCmd, cb) do |c|
+      init[c] if init
+    end.signature)
+  end
+end

data/lib/em/protocols.rb

@@ -0,0 +1,35 @@
+module EventMachine
+  # This module contains various protocol implementations, including:
+  # - HttpClient and HttpClient2
+  # - Stomp
+  # - Memcache
+  # - SmtpClient and SmtpServer
+  # - SASLauth and SASLauthclient
+  # - LineAndTextProtocol and LineText2
+  # - HeaderAndContentProtocol
+  # - Postgres3
+  # - ObjectProtocol
+  #
+  # The protocol implementations live in separate files in the protocols/ subdirectory,
+  # but are auto-loaded when they are first referenced in your application.
+  #
+  # EventMachine::Protocols is also aliased to EM::P for easier usage.
+  #
+  module Protocols
+    # TODO : various autotools are completely useless with the lack of naming
+    # convention, we need to correct that!
+    autoload :TcpConnectTester, 'em/protocols/tcptest'
+    autoload :HttpClient, 'em/protocols/httpclient'
+    autoload :HttpClient2, 'em/protocols/httpclient2'
+    autoload :LineAndTextProtocol, 'em/protocols/line_and_text'
+    autoload :HeaderAndContentProtocol, 'em/protocols/header_and_content'
+    autoload :LineText2, 'em/protocols/linetext2'
+    autoload :Stomp, 'em/protocols/stomp'
+    autoload :SmtpClient, 'em/protocols/smtpclient'
+    autoload :SmtpServer, 'em/protocols/smtpserver'
+    autoload :SASLauth, 'em/protocols/saslauth'
+    autoload :Memcache, 'em/protocols/memcache'
+    autoload :Postgres3, 'em/protocols/postgres3'
+    autoload :ObjectProtocol, 'em/protocols/object_protocol'
+  end
+end

data/lib/em/protocols/header_and_content.rb

@@ -0,0 +1,138 @@
+#--
+#
+# Author:: Francis Cianfrocca (gmail: blackhedd)
+# Homepage::  http://rubyeventmachine.com
+# Date:: 15 Nov 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.
+#
+#---------------------------------------------------------------------------
+#
+#
+
+module EventMachine
+  module Protocols
+
+    # === Usage
+    #
+    #  class RequestHandler < EM::P::HeaderAndContentProtocol
+    #    def receive_request headers, content
+    #      p [:request, headers, content]
+    #    end
+    #  end
+    #
+    #  EM.run{
+    #    EM.start_server 'localhost', 80, RequestHandler
+    #  }
+    #
+    #--
+    # Originally, this subclassed LineAndTextProtocol, which in
+    # turn relies on BufferedTokenizer, which doesn't gracefully
+    # handle the transitions between lines and binary text.
+    # Changed 13Sep08 by FCianfrocca.
+    class HeaderAndContentProtocol < Connection
+      include LineText2
+
+      ContentLengthPattern = /Content-length:\s*(\d+)/i
+
+      def initialize *args
+        super
+        init_for_request
+      end
+
+      def receive_line line
+        case @hc_mode
+        when :discard_blanks
+          unless line == ""
+            @hc_mode = :headers
+            receive_line line
+          end
+        when :headers
+          if line == ""
+            raise "unrecognized state" unless @hc_headers.length > 0
+            if respond_to?(:receive_headers)
+              receive_headers @hc_headers
+            end
+            # @hc_content_length will be nil, not 0, if there was no content-length header.
+            if @hc_content_length.to_i > 0
+              set_binary_mode @hc_content_length
+            else
+              dispatch_request
+            end
+          else
+            @hc_headers << line
+            if ContentLengthPattern =~ line
+              # There are some attacks that rely on sending multiple content-length
+              # headers. This is a crude protection, but needs to become tunable.
+              raise "extraneous content-length header" if @hc_content_length
+              @hc_content_length = $1.to_i
+            end
+            if @hc_headers.length == 1 and respond_to?(:receive_first_header_line)
+              receive_first_header_line line
+            end
+          end
+        else
+          raise "internal error, unsupported mode"
+        end
+      end
+
+      def receive_binary_data text
+        @hc_content = text
+        dispatch_request
+      end
+
+      def dispatch_request
+        if respond_to?(:receive_request)
+          receive_request @hc_headers, @hc_content
+        end
+        init_for_request
+      end
+      private :dispatch_request
+
+      def init_for_request
+        @hc_mode = :discard_blanks
+        @hc_headers = []
+        # originally was @hc_headers ||= []; @hc_headers.clear to get a performance
+        # boost, but it's counterproductive because a subclassed handler will have to
+        # call dup to use the header array we pass in receive_headers.
+
+        @hc_content_length = nil
+        @hc_content = ""
+      end
+      private :init_for_request
+
+      # Basically a convenience method. We might create a subclass that does this
+      # automatically. But it's such a performance killer.
+      def headers_2_hash hdrs
+        self.class.headers_2_hash hdrs
+      end
+
+      class << self
+        def headers_2_hash hdrs
+          hash = {}
+          hdrs.each {|h|
+            if /\A([^\s:]+)\s*:\s*/ =~ h
+              tail = $'.dup
+              hash[ $1.downcase.gsub(/-/,"_").intern ] = tail
+            end
+          }
+          hash
+        end
+      end
+
+    end
+  end
+end