eventmachine 0.8.1 → 0.9.0

data/lib/svn-commit.tmp

@@ -0,0 +1,4 @@
+added per-instance configurability to SmtpServer
+--This line, and those below, will be ignored--
+
+M    protocols/smtpserver.rb

data/tests/test_basic.rb

@@ -1,4 +1,4 @@
-# $Id: test_basic.rb 452 2007-07-21 13:35:16Z blackhedd $
+# $Id: test_basic.rb 500 2007-08-17 09:45:20Z blackhedd $
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com
@@ -93,6 +93,18 @@ class TestBasic < Test::Unit::TestCase
 
   #--------------------------------------
 
+  # EventMachine#run_block starts the reactor loop, runs the supplied block, and then STOPS
+  # the loop automatically. Contrast with EventMachine#run, which keeps running the reactor
+  # even after the supplied block completes.
+  def test_run_block
+	  a = nil
+	  EM.run_block { a = "Worked" }
+	  assert a
+  end
+
+
+  #--------------------------------------
+
 end
 
 

data/tests/test_futures.rb

@@ -1,4 +1,4 @@
-# $Id: test_futures.rb 323 2007-05-22 22:22:43Z blackhedd $
+# $Id: test_futures.rb 534 2007-09-15 23:06:15Z blackhedd $
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com
@@ -126,11 +126,88 @@ class TestFutures < Test::Unit::TestCase
       assert_equal(3, n)
   end
 
-  def test_syntactic_sugar
-	  rc = RecursiveCallback.new
-	  rc.set_deferred_success 100
-	  rc.set_deferred_failure 200
-  end
+
+
+	def test_syntactic_sugar
+		rc = RecursiveCallback.new
+		rc.set_deferred_success 100
+		rc.set_deferred_failure 200
+	end
+
+
+
+	# It doesn't raise an error to set deferred status more than once.
+	# In fact, this is a desired and useful idiom when it happens INSIDE
+	# a callback or errback.
+	# However, it's less useful otherwise, and in fact would generally be
+	# indicative of a programming error. However, we would like to be resistant
+	# to such errors. So whenever we set deferred status, we also clear BOTH
+	# stacks of handlers.
+	#
+	def test_double_calls
+		s = 0
+		e = 0
+
+		d = EM::DefaultDeferrable.new
+		d.callback {s += 1}
+		d.errback {e += 1}
+
+		d.succeed	# We expect the callback to be called, and the errback to be DISCARDED.
+		d.fail	# Presumably an error. We expect the errback NOT to be called.
+		d.succeed	# We expect the callback to have been discarded and NOT to be called again.
+
+		assert_equal(1, s)
+		assert_equal(0, e)
+	end
+
+
+	# Adding a callback to a Deferrable that is already in a success state executes the callback
+	# immediately. The same applies to a an errback added to an already-failed Deferrable.
+	# HOWEVER, we expect NOT to be able to add errbacks to succeeded Deferrables, or callbacks
+	# to failed ones.
+	#
+	# We illustrate this with a rather contrived test. The test calls #fail after #succeed,
+	# which ordinarily would not happen in a real program.
+	#
+	# What we're NOT attempting to specify is what happens if a Deferrable is succeeded and then
+	# failed (or vice-versa). Should we then be able to add callbacks/errbacks of the appropriate
+	# type for immediate execution? For now at least, the official answer is "don't do that."
+	#
+	def test_delayed_callbacks
+		s1 = 0
+		s2 = 0
+		e = 0
+
+		d = EM::DefaultDeferrable.new
+		d.callback {s1 += 1}
+
+		d.succeed	# Triggers and discards the callback.
+
+		d.callback {s2 += 1}	# This callback is executed immediately and discarded.
+
+		d.errback {e += 1}	# This errback should be DISCARDED and never execute.
+		d.fail		# To prove it, let's 
+
+		assert_equal( [1,1], [s1,s2] )
+		assert_equal( 0, e )
+	end
+
+
+
+
+	#
+	#
+	#
+	def test_timeout
+		n = 0
+		EM.run {
+			d = EM::DefaultDeferrable.new
+			d.callback {n = 1; EM.stop}
+			d.errback {n = 2; EM.stop}
+			d.timeout(1)
+		}
+		assert_equal( 2, n )
+	end
 
 end
 

data/tests/test_httpclient.rb

@@ -1,4 +1,4 @@
-# $Id: test_httpclient.rb 398 2007-07-11 02:46:22Z blackhedd $
+# $Id: test_httpclient.rb 518 2007-08-30 10:17:02Z blackhedd $
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com
@@ -172,6 +172,22 @@ class TestHttpClient < Test::Unit::TestCase
       assert_equal( "0123456789", response[:content] )
   end
 
+
+  # TODO, need a more intelligent cookie tester.
+  # In fact, this whole test-harness needs a beefier server implementation.
+  def test_cookie
+    ok = false
+    EM.run {
+      c = EM::Protocols::HttpClient.send :request, :host => "www.bayshorenetworks.com", :port => 80, :cookie=>"aaa=bbb"
+      c.callback {|result|
+        ok = true;
+        EventMachine.stop
+      }
+      c.errback {EventMachine.stop}
+    }
+    assert ok
+  end
+
 end
 
 

data/tests/test_kb.rb

@@ -0,0 +1,60 @@
+# $Id: test_kb.rb 502 2007-08-24 09:29:53Z 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'
+
+class TestKeyboardEvents < Test::Unit::TestCase
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  module KbHandler
+	  include EM::Protocols::LineText2
+	  def receive_line d
+		  EM::stop if d == "STOP"
+	  end
+  end
+
+  # This test doesn't actually do anything useful but is here to
+  # illustrate the usage. If you removed the timer and ran this test
+  # by itself on a console, and then typed into the console, it would
+  # work.
+  # I don't know how to get the test harness to simulate actual keystrokes.
+  # When someone figures that out, then we can make this a real test.
+  #
+  def test_kb
+	  EM.run {
+		  EM.open_keyboard KbHandler
+		  EM::Timer.new(1) { EM.stop }
+	  }
+  end
+
+end
+

data/tests/test_running.rb

@@ -0,0 +1,46 @@
+# $Id: test_running.rb 493 2007-08-13 20:10:46Z 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'
+
+class TestRunning < Test::Unit::TestCase
+	def setup
+	end
+	def teardown
+	end
+
+	def test_running
+		assert_equal( false, EM::reactor_running? )
+		r = false
+		EM.run {
+			r = EM::reactor_running?
+			EM.stop
+		}
+		assert_equal( true, r )
+	end
+end
+

data/tests/test_smtpclient.rb

@@ -0,0 +1,80 @@
+# $Id: test_smtpclient.rb 535 2007-09-16 19:35:05Z 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'
+
+class TestSmtpClient < Test::Unit::TestCase
+
+	Localhost = "127.0.0.1"
+	Localport = 9801
+
+	def setup
+	end
+
+	def teardown
+	end
+
+	def test_a
+		# No real tests until we have a server implementation to test against.
+		# This is what the call looks like, though:
+
+		EM.run {
+			d = EM::Protocols::SmtpClient.send :domain=>"example.com",
+				:host=>Localhost,
+				:port=>Localport, # optional, defaults 25
+				:starttls=>true,
+				:from=>"sender@example.com",
+				:to=> ["to_1@example.com", "to_2@example.com"],
+				:header=> {"Subject" => "This is a subject line"},
+				:body=> "This is the body of the email",
+				:verbose=>true
+			d.errback {|e|
+				p e
+				EM.stop
+			}
+		}
+	end
+
+	def test_content
+
+		EM.run {
+			d = EM::Protocols::SmtpClient.send :domain=>"example.com",
+				:host=>Localhost,
+				:port=>Localport, # optional, defaults 25
+				:starttls=>true,
+				:from=>"sender@example.com",
+				:to=> ["to_1@example.com", "to_2@example.com"],
+				:content => ["Subject: xxx\r\n\r\ndata\r\n.\r\n"],
+				:verbose=>true
+			d.errback {|e|
+				p e
+				EM.stop
+			}
+		}
+	end
+
+end

data/tests/test_smtpserver.rb

@@ -0,0 +1,92 @@
+# $Id: test_smtpserver.rb 523 2007-09-05 23:29:02Z 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'
+
+class TestSmtpServer < Test::Unit::TestCase
+
+	# Don't test on port 25. It requires superuser and there's probably
+	# a mail server already running there anyway.
+	Localhost = "127.0.0.1"
+	Localport = 25001
+
+	# This class is an example of what you need to write in order
+	# to implement a mail server. You override the methods you are
+	# interested in. Some, but not all, of these are illustrated here.
+	#
+	class Mailserver < EM::Protocols::SmtpServer
+
+		attr_reader :my_msg_body, :my_sender, :my_recipients
+
+		def initialize *args
+			super
+		end
+		def receive_sender sender
+			@my_sender = sender
+			p sender
+			true
+		end
+		def receive_recipient rcpt
+			@my_recipients ||= []
+			@my_recipients << rcpt
+			true
+		end
+		def receive_data_chunk c
+			@my_msg_body = c.last
+		end
+		def connection_ended
+			EM.stop
+		end
+	end
+
+
+	def setup
+	end
+
+	def teardown
+	end
+
+	def test_mail
+		c = nil
+		EM.run {
+			EM.start_server( Localhost, Localport, Mailserver ) {|conn| c = conn}
+			EM::Timer.new(2) {EM.stop} # prevent hanging the test suite in case of error
+			EM::Protocols::SmtpClient.send :host=>Localhost,
+				:port=>Localport,
+				:domain=>"bogus",
+				:from=>"me@example.com",
+				:to=>"you@example.com",
+				:header=> {"Subject"=>"Email subject line", "Reply-to"=>"me@example.com"},
+				:body=>"Not much of interest here."
+
+		}
+		assert_equal( "Not much of interest here.", c.my_msg_body )
+		assert_equal( "<me@example.com>", c.my_sender )
+		assert_equal( ["<you@example.com>"], c.my_recipients )
+	end
+end
+

data/tests/test_spawn.rb

@@ -0,0 +1,328 @@
+# $Id: test_spawn.rb 532 2007-09-13 21:44:23Z blackhedd $
+#
+# Author:: Francis Cianfrocca (gmail: blackhedd)
+# Homepage::  http://rubyeventmachine.com
+# Date:: 25 Aug 2007
+# 
+# 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'
+
+
+
+class TestSpawn < Test::Unit::TestCase
+
+	def setup
+	end
+
+	def teardown
+	end
+
+
+	# Spawn a process that simply stops the reactor.
+	# Assert that the notification runs after the block that calls it.
+	#
+	def test_stop
+		x = nil
+		EM.run {
+			s = EM.spawn {EM.stop}
+			s.notify
+			x = true
+		}
+		assert x
+	end
+
+
+	# Pass a parameter to a spawned process.
+	#
+	def test_parms
+		val = 5
+		EM.run {
+			s = EM.spawn {|v| val *= v; EM.stop}
+			s.notify 3
+		}
+		assert_equal( 15, val )
+	end
+
+	# Pass multiple parameters to a spawned process.
+	#
+	def test_multiparms
+		val = 5
+		EM.run {
+			s = EM.spawn {|v1,v2| val *= (v1 + v2); EM.stop}
+			s.notify 3,4
+		}
+		assert_equal( 35, val )
+	end
+
+
+	# This test demonstrates that a notification does not happen immediately,
+	# but rather is scheduled sometime after the current code path completes.
+	#
+	def test_race
+		x = 0
+		EM.run {
+			s = EM.spawn {x *= 2; EM.stop}
+			s.notify
+			x = 2
+		}
+		assert_equal( 4, x)
+	end
+
+
+	# Spawn a process and notify it 25 times to run fibonacci
+	# on a pair of global variables.
+	#
+	def test_fibonacci
+		x = 1
+		y = 1
+		EM.run {
+			s = EM.spawn {x,y = y,x+y}
+			25.times {s.notify}
+
+			t = EM.spawn {EM.stop}
+			t.notify
+		}
+		assert_equal( 121393, x)
+		assert_equal( 196418, y)
+	end
+
+	# This one spawns 25 distinct processes, and notifies each one once,
+	# rather than notifying a single process 25 times.
+	#
+	def test_another_fibonacci
+		x = 1
+		y = 1
+		EM.run {
+			25.times {
+				s = EM.spawn {x,y = y,x+y}
+				s.notify
+			}
+
+			t = EM.spawn {EM.stop}
+			t.notify
+		}
+		assert_equal( 121393, x)
+		assert_equal( 196418, y)
+	end
+
+
+	# Make a chain of processes that notify each other in turn
+	# with intermediate fibonacci results. The final process in
+	# the chain stops the loop and returns the result.
+	#
+	def test_fibonacci_chain
+		a,b = nil
+
+		EM.run {
+			nextpid = EM.spawn {|x,y|
+				a,b = x,y
+				EM.stop
+			}
+
+			25.times {
+				n = nextpid
+				nextpid = EM.spawn {|x,y| n.notify( y, x+y )}
+			}
+
+			nextpid.notify( 1, 1 )
+		}
+
+		assert_equal( 121393, a)
+		assert_equal( 196418, b)
+	end
+
+
+	# EM#yield gives a spawed process to yield control to other processes
+	# (in other words, to stop running), and to specify a different code block
+	# that will run on its next notification.
+	#
+	def test_yield
+		a = 0
+		EM.run {
+			n = EM.spawn {
+				a += 10
+				EM.yield {
+					a += 20
+					EM.yield {
+						a += 30
+						EM.stop
+					}
+				}
+			}
+			n.notify
+			n.notify
+			n.notify
+		}
+		assert_equal( 60, a )
+	end
+
+	# EM#yield_and_notify behaves like EM#yield, except that it also notifies the
+	# yielding process. This may sound trivial, since the yield block will run very
+	# shortly after with no action by the program, but this actually can be very useful,
+	# because it causes the reactor core to execute once before the yielding process
+	# gets control back. So it can be used to allow heavily-used network connections
+	# to clear buffers, or allow other processes to process their notifications.
+	#
+	# Notice in this test code that only a simple notify is needed at the bottom
+	# of the initial block. Even so, all of the yielded blocks will execute.
+	#
+	def test_yield_and_notify
+		a = 0
+		EM.run {
+			n = EM.spawn {
+				a += 10
+				EM.yield_and_notify {
+					a += 20
+					EM.yield_and_notify {
+						a += 30
+						EM.stop
+					}
+				}
+			}
+			n.notify
+		}
+		assert_equal( 60, a )
+	end
+
+	# resume is an alias for notify.
+	#
+	def test_resume
+		EM.run {
+			n = EM.spawn {EM.stop}
+			n.resume
+		}
+		assert true
+	end
+
+	# run is an idiomatic alias for notify.
+	#
+	def test_run
+		EM.run {
+			(EM.spawn {EM.stop}).run
+		}
+		assert true
+	end
+
+
+	# Clones the ping-pong example from the Erlang tutorial, in much less code.
+	# Illustrates that a spawned block executes in the context of a SpawnableObject.
+	# (Meaning, we can pass self as a parameter to another process that can then
+	# notify us.)
+	#
+	def test_ping_pong
+		n_pongs = 0
+		EM.run {
+			pong = EM.spawn {|x, ping|
+				n_pongs += 1
+				ping.notify( x-1 )
+			}
+			ping = EM.spawn {|x|
+				if x > 0
+					pong.notify x, self
+				else
+					EM.stop
+				end
+			}
+			ping.notify 3
+		}
+		assert_equal( 3, n_pongs )
+	end
+
+	# Illustrates that you can call notify inside a notification, and it will cause
+	# the currently-executing process to be re-notified. Of course, the new notification
+	# won't run until sometime after the current one completes.
+	#
+	def test_self_notify
+		n = 0
+		EM.run {
+			pid = EM.spawn {|x|
+				if x > 0
+					n += x
+					notify( x-1 )
+				else
+					EM.stop
+				end
+			}
+			pid.notify 3
+		}
+		assert_equal( 6, n )
+	end
+
+
+	# Illustrates that the block passed to #spawn executes in the context of a
+	# SpawnedProcess object, NOT in the local context. This can often be deceptive.
+	#
+	class BlockScopeTest
+		attr_reader :var
+		def run
+			# The following line correctly raises a NameError.
+			# The problem is that the programmer expected the spawned block to
+			# execute in the local context, but it doesn't.
+			#
+			# (EM.spawn { do_something }).notify ### NO! BAD!
+
+
+
+			# The following line correctly passes self as a parameter to the
+			# notified process.
+			#
+			(EM.spawn {|obj| obj.do_something }).notify(self)
+
+
+
+			# Here's another way to do it. This works because "myself" is bound
+			# in the local scope, unlike "self," so the spawned block sees it.
+			#
+			myself = self
+			(EM.spawn { myself.do_something }).notify
+
+
+
+			# And we end the loop.
+			# This is a tangential point, but observe that #notify never blocks.
+			# It merely appends a message to the internal queue of a spawned process
+			# and returns. As it turns out, the reactor processes notifications for ALL
+			# spawned processes in the order that #notify is called. So there is a
+			# reasonable expectation that the process which stops the reactor will
+			# execute after the previous ones in this method. HOWEVER, this is NOT
+			# a documented behavior and is subject to change.
+			#
+			(EM.spawn {EM.stop}).notify
+		end
+		def do_something
+			@var ||= 0
+			@var += 100
+		end
+	end
+
+	def test_block_scope
+		bs = BlockScopeTest.new
+		EM.run {
+			bs.run
+		}
+		assert_equal( 200, bs.var )
+	end
+
+end