eventmachine 0.8.0 → 0.8.1

data/lib/protocols/linetext2.rb

@@ -0,0 +1,145 @@
+# $Id: linetext2.rb 486 2007-07-29 17:15:12Z blackhedd $
+#
+# 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.
+#
+#---------------------------------------------------------------------------
+#
+# 
+# 
+
+
+# In the grand, time-honored tradition of re-inventing the wheel, we offer
+# here YET ANOTHER protocol that handles line-oriented data with interspersed
+# binary text. This one trades away some of the performance optimizations of
+# EventMachine::Protocols::LineAndTextProtocol in order to get better correctness
+# with regard to binary text blocks that can switch back to line mode. It also
+# permits the line-delimiter to change in midstream.
+# This was originally written to support Stomp.
+
+# TODO! We're not enforcing the limits on header lengths and text-lengths.
+# When we get around to that, call #receive_error if the user defined it, otherwise
+# throw exceptions.
+
+module EventMachine
+	module Protocols
+		module LineText2
+			MaxLineLength = 16*1024
+			MaxBinaryLength = 32*1024*1024
+
+			#--
+			# Will be called recursively until there's no data to read.
+			# That way the user-defined handlers we call can modify the
+			# handling characteristics on a per-token basis.
+			#
+			def receive_data data
+				return unless (data and data.length > 0)
+
+				# Do this stuff in lieu of a constructor.
+				@lt2_mode ||= :lines
+				@lt2_delimiter ||= "\n"
+				@lt2_linebuffer ||= []
+
+				if @lt2_mode == :lines
+					if ix = data.index( @lt2_delimiter )
+						@lt2_linebuffer << data[0...ix]
+						ln = @lt2_linebuffer.join
+						@lt2_linebuffer.clear
+						if @lt2_delimiter == "\n"
+							ln.chomp!
+						end
+						receive_line ln
+						receive_data data[(ix+@lt2_delimiter.length)..-1]
+					else
+						@lt2_linebuffer << data
+					end
+				elsif @lt2_mode == :text
+					if @lt2_textsize
+						needed = @lt2_textsize - @lt2_textpos
+						will_take = if data.length > needed
+							needed
+						else
+							data.length
+						end
+
+						@lt2_textbuffer << data[0...will_take]
+						tail = data[will_take..-1]
+
+						@lt2_textpos += will_take
+						if @lt2_textpos >= @lt2_textsize
+							receive_binary_data @lt2_textbuffer.join
+							set_line_mode
+						end
+
+						receive_data tail
+					else
+						receive_binary_data data
+					end
+				end
+			end
+
+
+			def set_delimiter delim
+				@lt2_delimiter = delim.to_s
+			end
+
+			# Called internally but also exposed to user code, for the case in which
+			# processing of binary data creates a need to transition back to line mode.
+			# We support an optional parameter to "throw back" some data, which might
+			# be an umprocessed chunk of the transmitted binary data, or something else
+			# entirely.
+			def set_line_mode data=""
+				@lt2_mode = :lines
+				(@lt2_linebuffer ||= []).clear
+				receive_data data.to_s
+			end
+
+			def set_text_mode size=nil
+				if size == 0
+					set_line_mode
+				else
+					@lt2_mode = :text
+					(@lt2_textbuffer ||= []).clear
+					@lt2_textsize = size # which can be nil, signifying no limit
+					@lt2_textpos = 0
+				end
+			end
+
+			# In case of a dropped connection, we'll send a partial buffer to user code
+			# when in sized text mode. User overrides of #receive_binary_data need to
+			# be aware that they may get a short buffer.
+			def unbind
+				if @lt2_mode == :text and @lt2_textpos > 0
+					receive_binary_data @lt2_textbuffer.join
+				end
+			end
+
+			# Stub. Should be subclassed by user code.
+			def receive_line ln
+				# no-op
+			end
+
+			# Stub. Should be subclassed by user code.
+			def receive_binary_data data
+				# no-op
+			end
+		end
+	end
+end
+

data/lib/protocols/stomp.rb

@@ -0,0 +1,127 @@
+# $Id: stomp.rb 488 2007-07-30 05:09:40Z blackhedd $
+#
+# 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).
+		#
+		module Stomp
+			include LineText2
+
+			class Message
+				attr_accessor :command, :header, :body
+				def initialize
+					@header = {}
+					@state = :precommand
+					@content_length = nil
+				end
+				def consume_line line
+					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
+
+			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
+
+
+			# STOMP verbs
+			def connect parms={}
+				send_frame "CONNECT", parms
+			end
+			def send destination, body, parms={}
+				send_frame "SEND", parms.merge( :destination=>destination ), body.to_s
+			end
+			def subscribe dest, ack=false
+				send_frame "SUBSCRIBE", {:destination=>dest, :ack=>(ack ? "client" : "auto")}
+			end
+
+		end
+	end
+end
+

data/tests/test_basic.rb

@@ -1,4 +1,4 @@
-# $Id: test_basic.rb 323 2007-05-22 22:22:43Z blackhedd $
+# $Id: test_basic.rb 452 2007-07-21 13:35:16Z blackhedd $
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com
@@ -44,6 +44,8 @@ class TestBasic < Test::Unit::TestCase
       assert_equal( :pure_ruby, lt )
     when :extension
       assert_equal( :extension, lt )
+    when :java
+      assert_equal( :java, lt )
     else
       assert_equal( :extension, lt )
     end
@@ -74,19 +76,19 @@ class TestBasic < Test::Unit::TestCase
 
   #-------------------------------------
 
-  # This test throws an already-running exception. WHY?
+  # This test once threw an already-running exception.
   module Trivial
     def post_init
-      EentMachine.stop
+      EventMachine.stop
     end
   end
 
   def test_server
-    #EventMachine.run {
-    #  EventMachine.start_server "localhost", 9000, Trivial
-    #  EventMachine.connect "localhost", 9000
-    #}
-
+    EventMachine.run {
+      EventMachine.start_server "localhost", 9000, Trivial
+      EventMachine.connect "localhost", 9000
+    }
+    assert( true ) # make sure it halts
   end
 
   #--------------------------------------

data/tests/test_epoll.rb

@@ -1,4 +1,4 @@
-# $Id: test_epoll.rb 373 2007-06-08 16:09:01Z blackhedd $
+# $Id: test_epoll.rb 449 2007-07-21 00:15:30Z blackhedd $
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com
@@ -67,11 +67,14 @@ class TestEpoll < Test::Unit::TestCase
 	# We can set the rlimit/nofile of a process but we can only set it
 	# higher if we're running as root.
 	# On most systems, the default value is 1024.
+	# Java doesn't (currently) implement this.
 	def test_rlimit
-		a = EM.set_descriptor_table_size
-		assert( a <= 1024 )
-		a = EM.set_descriptor_table_size( 1024 )
-		assert( a == 1024 )
+		unless RUBY_PLATFORM =~ /java/
+			a = EM.set_descriptor_table_size
+			assert( a <= 1024 )
+			a = EM.set_descriptor_table_size( 1024 )
+			assert( a == 1024 )
+		end
 	end
 
 	# Run a high-volume version of this test by kicking the number of connections

data/tests/test_ltp.rb

@@ -1,4 +1,4 @@
-# $Id: test_ltp.rb 396 2007-07-11 01:49:34Z blackhedd $
+# $Id: test_ltp.rb 448 2007-07-21 00:15:05Z blackhedd $
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com
@@ -43,6 +43,9 @@ class TestLineAndTextProtocol < Test::Unit::TestCase
     end
 
     def test_simple_lines
+        # THIS TEST CURRENTLY FAILS IN JRUBY.
+        assert( RUBY_PLATFORM !~ /java/ )
+
 	lines_received = []
 	Thread.abort_on_exception = true
 	EventMachine.run {
@@ -72,6 +75,9 @@ class TestLineAndTextProtocol < Test::Unit::TestCase
     end
 
     def test_overlength_lines
+        # THIS TEST CURRENTLY FAILS IN JRUBY.
+        assert( RUBY_PLATFORM !~ /java/ )
+
 	lines_received = []
 	Thread.abort_on_exception = true
 	EventMachine.run {

data/tests/test_ltp2.rb

@@ -0,0 +1,260 @@
+# $Id: test_ltp2.rb 486 2007-07-29 17:15:12Z blackhedd $
+#
+# Author:: Francis Cianfrocca (gmail: blackhedd)
+# Homepage::  http://rubyeventmachine.com
+# Date:: 8 April 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.
+#
+#---------------------------------------------------------------------------
+#
+#
+#
+#
+
+$:.unshift "../lib"
+require 'eventmachine'
+
+# TODO!!! Need tests for overlength headers and text bodies.
+
+class TestLineText2 < Test::Unit::TestCase
+
+	# Run each of these tests two ways: passing in the whole test-dataset in one chunk,
+	# and passing it in one character at a time.
+
+	class Basic
+		include EM::Protocols::LineText2
+		attr_reader :lines
+		def receive_line line
+			(@lines ||= []) << line
+		end
+	end
+	def test_basic
+		testdata = "Line 1\nLine 2\r\nLine 3\n"
+
+		a = Basic.new
+		a.receive_data testdata
+		assert_equal( ["Line 1", "Line 2", "Line 3"], a.lines )
+
+		a = Basic.new
+		testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
+		assert_equal( ["Line 1", "Line 2", "Line 3"], a.lines )
+	end
+
+
+	class ChangeDelimiter
+		include EM::Protocols::LineText2
+		attr_reader :lines
+		def initialize *args
+			super
+			@delim = "A"
+			set_delimiter @delim
+		end
+		def receive_line line
+			(@lines ||= []) << line
+			set_delimiter( @delim.succ! )
+		end
+	end
+
+	def test_change_delimiter
+		testdata = %Q(LineaALinebBLinecCLinedD)
+
+		a = ChangeDelimiter.new
+		a.receive_data testdata
+		assert_equal( ["Linea", "Lineb", "Linec", "Lined"], a.lines )
+
+		a = ChangeDelimiter.new
+		testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
+		assert_equal( ["Linea", "Lineb", "Linec", "Lined"], a.lines )
+	end
+
+
+	#--
+	# Test two lines followed by an empty line, ten bytes of binary data, then
+	# two more lines.
+
+	class Binary
+		include EM::Protocols::LineText2
+		attr_reader :lines, :body
+		def initialize *args
+			super
+			@lines = []
+			@body = nil
+		end
+		def receive_line ln
+			if ln == ""
+				set_text_mode 10
+			else
+				@lines << ln
+			end
+		end
+		def receive_binary_data data
+			@body = data
+		end
+	end
+
+	def test_binary
+		testdata = %Q(Line 1
+Line 2
+
+0000000000Line 3
+Line 4
+)
+
+		a = Binary.new
+		a.receive_data testdata
+		assert_equal( ["Line 1", "Line 2", "Line 3", "Line 4"], a.lines)
+		assert_equal( "0000000000", a.body )
+
+		a = Binary.new
+		testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
+		assert_equal( ["Line 1", "Line 2", "Line 3", "Line 4"], a.lines)
+		assert_equal( "0000000000", a.body )
+	end
+
+
+	# Test unsized binary data. The expectation is that each chunk of it
+	# will be passed to us as it it received.
+	class UnsizedBinary
+		include EM::Protocols::LineText2
+		attr_reader :n_calls, :body
+		def initialize *args
+			super
+			set_text_mode
+		end
+		def receive_binary_data data
+			@n_calls ||= 0
+			@n_calls += 1
+			(@body ||= "") << data
+		end
+	end
+
+	def test_unsized_binary
+		testdata = "X\0" * 1000
+
+		a = UnsizedBinary.new
+		a.receive_data testdata
+		assert_equal( 1, a.n_calls )
+		assert_equal( testdata, a.body )
+
+		a = UnsizedBinary.new
+		testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
+		assert_equal( 2000, a.n_calls )
+		assert_equal( testdata, a.body )
+	end
+
+
+	# Test binary data with a "throw back" into line-mode.
+	class ThrowBack
+		include EM::Protocols::LineText2
+		attr_reader :headers
+		def initialize *args
+			super
+			@headers = []
+			@n_bytes = 0
+			set_text_mode
+		end
+		def receive_binary_data data
+			wanted = 25 - @n_bytes
+			will_take = if data.length > wanted
+				data.length - wanted
+			else
+				data.length
+			end
+			@n_bytes += will_take
+
+			if @n_bytes == 25
+				set_line_mode( data[will_take..-1] )
+			end
+		end
+		def receive_line ln
+			@headers << ln
+		end
+	end
+	def test_throw_back
+		testdata = "Line\n" * 10
+
+		a = ThrowBack.new
+		a.receive_data testdata
+		assert_equal( ["Line"] * 5, a.headers )
+
+		a = ThrowBack.new
+		testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
+		assert_equal( ["Line"] * 5, a.headers )
+	end
+
+	# Test multi-character line delimiters.
+	# Also note that the test data has a "tail" with no delimiter, that will be
+	# discarded, but cf. the BinaryTail test.
+	# TODO!!! This test doesn't work in the byte-by-byte case.
+	class Multichar
+		include EM::Protocols::LineText2
+		attr_reader :lines
+		def initialize *args
+			super
+			@lines = []
+			set_delimiter "012"
+		end
+		def receive_line ln
+			@lines << ln
+		end
+	end
+	def test_multichar
+		testdata = "Line012Line012Line012Line"
+
+		a = Multichar.new
+		a.receive_data testdata
+		assert_equal( ["Line"]*3, a.lines )
+
+		a = Multichar.new
+		testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
+		# DOESN'T WORK in this case. Multi-character delimiters are broken.
+		#assert_equal( ["Line"]*3, a.lines )
+	end
+
+	# Test a binary "tail," when a sized binary transfer doesn't complete because
+	# of an unbind. We get a partial result.
+	class BinaryTail
+		include EM::Protocols::LineText2
+		attr_reader :data
+		def initialize *args
+			super
+			@data = ""
+			set_text_mode 1000
+		end
+		def receive_binary_data data
+			# we expect to get all the data in one chunk, even in the byte-by-byte case,
+			# because sized transfers by definition give us exactly one call to
+			# #receive_binary_data.
+			@data = data
+		end
+	end
+	def test_binary_tail
+		testdata = "0" * 500
+
+		a = BinaryTail.new
+		a.receive_data testdata
+		a.unbind
+		assert_equal( "0" * 500, a.data )
+
+		a = BinaryTail.new
+		testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
+		a.unbind
+		assert_equal( "0" * 500, a.data )
+	end
+
+end
+