eventmachine 0.12.6 → 0.12.8

data/lib/em/protocols/stomp.rb

@@ -0,0 +1,200 @@
+#--
+#
+# Author:: Francis Cianfrocca (gmail: blackhedd)
+# Homepage::  http://rubyeventmachine.com
+# Date:: 15 November 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
+
+    # Implements Stomp (http://docs.codehaus.org/display/STOMP/Protocol).
+    #
+    # == Usage example
+    #
+    #  module StompClient
+    #    include EM::Protocols::Stomp
+    #
+    #    def connection_completed
+    #      connect :login => 'guest', :passcode => 'guest'
+    #    end
+    #
+    #    def receive_msg msg
+    #      if msg.command == "CONNECTED"
+    #        subscribe '/some/topic'
+    #      else
+    #        p ['got a message', msg]
+    #        puts msg.body
+    #      end
+    #    end
+    #  end
+    #
+    #  EM.run{
+    #    EM.connect 'localhost', 61613, StompClient
+    #  }
+    #
+    module Stomp
+      include LineText2
+
+      class Message
+        # The command associated with the message, usually 'CONNECTED' or 'MESSAGE'
+        attr_accessor :command
+        # Hash containing headers such as destination and message-id
+        attr_accessor :header
+        alias :headers :header
+        # Body of the message
+        attr_accessor :body
+
+        def initialize # :nodoc:
+          @header = {}
+          @state = :precommand
+          @content_length = nil
+        end
+        def consume_line line # :nodoc:
+          if @state == :precommand
+            unless line =~ /\A\s*\Z/
+              @command = line
+              @state = :headers
+            end
+          elsif @state == :headers
+            if line == ""
+              if @content_length
+                yield( [:sized_text, @content_length+1] )
+              else
+                @state = :body
+                yield( [:unsized_text] )
+              end
+            elsif line =~ /\A([^:]+):(.+)\Z/
+              k = $1.dup.strip
+              v = $2.dup.strip
+              @header[k] = v
+              if k == "content-length"
+                @content_length = v.to_i
+              end
+            else
+              # This is a protocol error. How to signal it?
+            end
+          elsif @state == :body
+            @body = line
+            yield( [:dispatch] )
+          end
+        end
+      end
+
+      # :stopdoc:
+
+      def send_frame verb, headers={}, body=""
+        ary = [verb, "\n"]
+        headers.each {|k,v| ary << "#{k}:#{v}\n" }
+        ary << "content-length: #{body.to_s.length}\n"
+        ary << "content-type: text/plain; charset=UTF-8\n"
+        ary << "\n"
+        ary << body.to_s
+        ary << "\0"
+        send_data ary.join
+      end
+
+      def receive_line line
+        @stomp_initialized || init_message_reader
+        @stomp_message.consume_line(line) {|outcome|
+          if outcome.first == :sized_text
+            set_text_mode outcome[1]
+          elsif outcome.first == :unsized_text
+            set_delimiter "\0"
+          elsif outcome.first == :dispatch
+            receive_msg(@stomp_message) if respond_to?(:receive_msg)
+            init_message_reader
+          end
+        }
+      end
+
+      def receive_binary_data data
+        @stomp_message.body = data[0..-2]
+        receive_msg(@stomp_message) if respond_to?(:receive_msg)
+        init_message_reader
+      end
+
+      def init_message_reader
+        @stomp_initialized = true
+        set_delimiter "\n"
+        set_line_mode
+        @stomp_message = Message.new
+      end
+
+      # :startdoc:
+
+      # Invoked with an incoming Stomp::Message received from the STOMP server
+      def receive_msg msg
+        # stub, overwrite this in your handler
+      end
+
+      # CONNECT command, for authentication
+      #
+      #  connect :login => 'guest', :passcode => 'guest'
+      #
+      def connect parms={}
+        send_frame "CONNECT", parms
+      end
+
+      # SEND command, for publishing messages to a topic
+      #
+      #  send '/topic/name', 'some message here'
+      #
+      def send destination, body, parms={}
+        send_frame "SEND", parms.merge( :destination=>destination ), body.to_s
+      end
+
+      # SUBSCRIBE command, for subscribing to topics
+      #
+      #  subscribe '/topic/name', false
+      #
+      def subscribe dest, ack=false
+        send_frame "SUBSCRIBE", {:destination=>dest, :ack=>(ack ? "client" : "auto")}
+      end
+
+      # ACK command, for acknowledging receipt of messages
+      #
+      #  module StompClient
+      #    include EM::P::Stomp
+      #
+      #    def connection_completed
+      #      connect :login => 'guest', :passcode => 'guest'
+      #      # subscribe with ack mode
+      #      subscribe '/some/topic', true
+      #    end
+      #
+      #    def receive_msg msg
+      #      if msg.command == "MESSAGE"
+      #        ack msg.headers['message-id']
+      #        puts msg.body
+      #      end
+      #    end
+      #  end
+      #
+      def ack msgid
+        send_frame "ACK", 'message-id'=> msgid
+      end
+
+    end
+  end
+end
+

data/lib/{protocols → em/protocols}/tcptest.rb

@@ -1,4 +1,4 @@
-# $Id$
+#--
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com
@@ -24,34 +24,30 @@
 #
 # 
 
-
-
 module EventMachine
-module Protocols
+  module Protocols
 
-class TcpConnectTester < Connection
-  include EventMachine::Deferrable
+    class TcpConnectTester < Connection # :nodoc:
+      include EventMachine::Deferrable
 
-  def self.test( host, port )
-    EventMachine.connect( host, port, self )
-  end
+      def self.test( host, port )
+        EventMachine.connect( host, port, self )
+      end
 
-  def post_init
-    @start_time = Time.now
-  end
+      def post_init
+        @start_time = Time.now
+      end
 
-  def connection_completed
-    @completed = true
-    set_deferred_status :succeeded, (Time.now - @start_time)
-    close_connection
-  end
-
-  def unbind
-    set_deferred_status :failed, (Time.now - @start_time)  unless @completed
-  end
-end
+      def connection_completed
+        @completed = true
+        set_deferred_status :succeeded, (Time.now - @start_time)
+        close_connection
+      end
 
+      def unbind
+        set_deferred_status :failed, (Time.now - @start_time)  unless @completed
+      end
+    end
 
-end
-end
-
+  end
+end

data/lib/em/queue.rb

@@ -0,0 +1,61 @@
+module EventMachine
+  # A cross thread, reactor scheduled, linear queue.
+  #
+  # This class provides a simple "Queue" like abstraction on top of the reactor
+  # scheduler. It services two primary purposes:
+  # * API sugar for stateful protocols
+  # * Pushing processing onto the same thread as the reactor
+  #
+  # See examples/ex_queue.rb for a detailed example.
+  #
+  #  q = EM::Queue.new
+  #  q.push('one', 'two', 'three')
+  #  3.times do
+  #    q.pop{ |msg| puts(msg) }
+  #  end
+  #
+  class Queue
+    # Create a new queue
+    def initialize
+      @items = []
+      @popq  = []
+    end
+
+    # Pop items off the queue, running the block on the reactor thread. The pop
+    # will not happen immediately, but at some point in the future, either in 
+    # the next tick, if the queue has data, or when the queue is populated.
+    def pop(*a, &b)
+      cb = EM::Callback(*a, &b)
+      EM.schedule do
+        if @items.empty?
+          @popq << cb
+        else
+          cb.call @items.shift
+        end
+      end
+      nil # Always returns nil
+    end
+
+    # Push items onto the queue in the reactor thread. The items will not appear
+    # in the queue immediately, but will be scheduled for addition during the 
+    # next reactor tick.
+    def push(*items)
+      EM.schedule do
+        @items.concat items
+        @popq.shift.call @items.shift until @items.empty? || @popq.empty?
+      end
+    end
+
+    # N.B. This is a peek, it's not thread safe, and may only tend toward 
+    # accuracy.
+    def empty?
+      @items.empty?
+    end
+
+    # N.B. This is a peek, it's not thread safe, and may only tend toward 
+    # accuracy.
+    def size
+      @items.size
+    end
+  end
+end

data/lib/em/spawnable.rb

@@ -1,4 +1,4 @@
-# $Id$
+#--
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com
@@ -21,68 +21,65 @@
 #
 #---------------------------------------------------------------------------
 #
-# 
-
-
-# Support for Erlang-style processes.
 #
 
-
 module EventMachine
-	class SpawnedProcess
-		#attr_accessor :receiver
-		def notify *x
-			me = self
-			EM.next_tick {
-				# A notification executes in the context of this
-				# SpawnedProcess object. That makes self and notify
-				# work as one would expect.
-				#
-				y = me.call(*x)
-				if y and y.respond_to?(:pull_out_yield_block)
-					a,b = y.pull_out_yield_block
-					set_receiver a
-					self.notify if b
-				end
-			}
-		end
-		alias_method :resume, :notify
-		alias_method :run, :notify # for formulations like (EM.spawn {xxx}).run
+  # Support for Erlang-style processes.
+  #
+  class SpawnedProcess
+    # Send a message to the spawned process
+    def notify *x
+      me = self
+      EM.next_tick {
+        # A notification executes in the context of this
+        # SpawnedProcess object. That makes self and notify
+        # work as one would expect.
+        #
+        y = me.call(*x)
+        if y and y.respond_to?(:pull_out_yield_block)
+          a,b = y.pull_out_yield_block
+          set_receiver a
+          self.notify if b
+        end
+      }
+    end
+    alias_method :resume, :notify
+    alias_method :run, :notify # for formulations like (EM.spawn {xxx}).run
+    #attr_accessor :receiver
 
-		# I know I'm missing something stupid, but the inside of class << s
-		# can't see locally-bound values. It can see globals, though.
-		def set_receiver blk
-			$em______tmpglobal = blk
-			class << self
-				define_method :call, $em______tmpglobal.dup
-			end
-		end
+    #--
+    # I know I'm missing something stupid, but the inside of class << s
+    # can't see locally-bound values. It can see globals, though.
+    def set_receiver blk
+      $em______tmpglobal = blk
+      class << self
+        define_method :call, $em______tmpglobal.dup
+      end
+    end
 
-	end
+  end
 
-	class YieldBlockFromSpawnedProcess
-		def initialize block, notify
-			@block = [block,notify]
-		end
-		def pull_out_yield_block
-			@block
-		end
-	end
+  class YieldBlockFromSpawnedProcess # :nodoc:
+    def initialize block, notify
+      @block = [block,notify]
+    end
+    def pull_out_yield_block
+      @block
+    end
+  end
 
-	def EventMachine.spawn &block
-		s = SpawnedProcess.new
-		s.set_receiver block
-		s
-	end
+  # Spawn an erlang-style process
+  def self.spawn &block
+    s = SpawnedProcess.new
+    s.set_receiver block
+    s
+  end
 
-	def EventMachine.yield &block
-		return YieldBlockFromSpawnedProcess.new( block, false )
-	end
+  def self.yield &block # :nodoc:
+    return YieldBlockFromSpawnedProcess.new( block, false )
+  end
 
-	def EventMachine.yield_and_notify &block
-		return YieldBlockFromSpawnedProcess.new( block, true )
-	end
+  def self.yield_and_notify &block # :nodoc:
+    return YieldBlockFromSpawnedProcess.new( block, true )
+  end
 end
-
-
-

data/lib/em/streamer.rb

@@ -1,4 +1,4 @@
-# $Id$
+#--
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com
@@ -25,88 +25,106 @@
 
 
 module EventMachine
-	class FileStreamer
-		MappingThreshold = 16384
-		BackpressureLevel = 50000
-		ChunkSize = 16384
+  class FileStreamer
+    include Deferrable
 
-		include Deferrable
-		def initialize connection, filename, args
-			@connection = connection
-			@http_chunks = args[:http_chunks]
+    # Use mapped streamer for files bigger than 16k
+    MappingThreshold = 16384
+    # Wait until next tick to send more data when 50k is still in the outgoing buffer
+    BackpressureLevel = 50000
+    # Send 16k chunks at a time
+    ChunkSize = 16384
 
-			if File.exist?(filename)
-				@size = File.size?(filename)
-				if @size <= MappingThreshold
-					stream_without_mapping filename
-				else
-					stream_with_mapping filename
-				end
-			else
-				fail "file not found"
-			end
-		end
+    # Stream a file over a given connection. An optional :http_chunks => true argument will
+    # use HTTP 1.1 style chunked-encoding semantics.
+    #
+    #  module FileSender
+    #    def post_init
+    #      streamer = EventMachine::FileStreamer.new(self, '/tmp/bigfile.tar')
+    #      streamer.callback{
+    #        # file was sent successfully
+    #        close_connection_after_writing
+    #      }
+    #    end
+    #  end
+    #
+    def initialize connection, filename, args = {}
+      @connection = connection
+      @http_chunks = args[:http_chunks]
 
-		def stream_without_mapping filename
-			if @http_chunks
-				@connection.send_data "#{@size.to_s(16)}\r\n"
-				@connection.send_file_data filename
-				@connection.send_data "\r\n0\r\n\r\n"
-			else
-				@connection.send_file_data filename
-			end
-			succeed
-		end
-		private :stream_without_mapping
+      if File.exist?(filename)
+        @size = File.size?(filename)
+        if @size <= MappingThreshold
+          stream_without_mapping filename
+        else
+          stream_with_mapping filename
+        end
+      else
+        fail "file not found"
+      end
+    end
 
-		def stream_with_mapping filename
-			ensure_mapping_extension_is_present
+    def stream_without_mapping filename # :nodoc:
+      if @http_chunks
+        @connection.send_data "#{@size.to_s(16)}\r\n"
+        @connection.send_file_data filename
+        @connection.send_data "\r\n0\r\n\r\n"
+      else
+        @connection.send_file_data filename
+      end
+      succeed
+    end
+    private :stream_without_mapping
 
-			@position = 0
-			@mapping = EventMachine::FastFileReader::Mapper.new filename
-			stream_one_chunk
-		end
-		private :stream_with_mapping
+    def stream_with_mapping filename # :nodoc:
+      ensure_mapping_extension_is_present
 
-		def stream_one_chunk
-			loop {
-				if @position < @size
-					if @connection.get_outbound_data_size > BackpressureLevel
-						EventMachine::next_tick {stream_one_chunk}
-						break
-					else
-						len = @size - @position
-						len = ChunkSize if (len > ChunkSize)
+      @position = 0
+      @mapping = EventMachine::FastFileReader::Mapper.new filename
+      stream_one_chunk
+    end
+    private :stream_with_mapping
 
-						@connection.send_data( "#{len.to_s(16)}\r\n" ) if @http_chunks
-						@connection.send_data( @mapping.get_chunk( @position, len ))
-						@connection.send_data("\r\n") if @http_chunks
+    # Used internally to stream one chunk at a time over multiple reactor ticks
+    def stream_one_chunk
+      loop {
+        if @position < @size
+          if @connection.get_outbound_data_size > BackpressureLevel
+            EventMachine::next_tick {stream_one_chunk}
+            break
+          else
+            len = @size - @position
+            len = ChunkSize if (len > ChunkSize)
 
-						@position += len
-					end
-				else
-					@connection.send_data "0\r\n\r\n" if @http_chunks
-					@mapping.close
-					succeed
-					break
-				end
-			}
-		end
+            @connection.send_data( "#{len.to_s(16)}\r\n" ) if @http_chunks
+            @connection.send_data( @mapping.get_chunk( @position, len ))
+            @connection.send_data("\r\n") if @http_chunks
 
-		#--
-		# We use an outboard extension class to get memory-mapped files.
-		# It's outboard to avoid polluting the core distro, but that means
-		# there's a "hidden" dependency on it. The first time we get here in
-		# any run, try to load up the dependency extension. User code will see
-		# a LoadError if it's not available, but code that doesn't require
-		# mapped files will work fine without it. This is a somewhat difficult
-		# compromise between usability and proper modularization.
-		#
-		def ensure_mapping_extension_is_present
-			@@fastfilereader ||= (require 'fastfilereaderext')
-		end
-		private :ensure_mapping_extension_is_present
+            @position += len
+          end
+        else
+          @connection.send_data "0\r\n\r\n" if @http_chunks
+          @mapping.close
+          succeed
+          break
+        end
+      }
+    end
 
-	end
+    #--
+    # We use an outboard extension class to get memory-mapped files.
+    # It's outboard to avoid polluting the core distro, but that means
+    # there's a "hidden" dependency on it. The first time we get here in
+    # any run, try to load up the dependency extension. User code will see
+    # a LoadError if it's not available, but code that doesn't require
+    # mapped files will work fine without it. This is a somewhat difficult
+    # compromise between usability and proper modularization.
+    #
+    def ensure_mapping_extension_is_present # :nodoc:
+      @@fastfilereader ||= (require 'fastfilereaderext')
+    end
+    private :ensure_mapping_extension_is_present
+
+  end
 end