event_state 0.0.1 → 0.1.0

data/README.rdoc

@@ -2,6 +2,8 @@
 
 * http://github.com/jdleesmiller/event_state
 
+{<img src="https://secure.travis-ci.org/jdleesmiller/event_state.png"/>}[http://travis-ci.org/jdleesmiller/event_state]
+
 == SYNOPSIS
 
 A small embedded DSL for implementing stateful protocols in EventMachine using
@@ -98,8 +100,6 @@ Output:
 
 == INSTALLATION
 
-Not yet released; will eventually be installable with:
-
   gem install event_state
 
 == RELATED PROJECTS

data/lib/event_state/machine.rb

@@ -208,7 +208,9 @@ module EventState
       #
       # @return [nil]
       #
-      def on_send *message_names, next_state_name
+      def on_send *args
+        next_state_name = args.pop
+        message_names = args
         raise "on_send must be called from a state block" unless @state
         message_names.flatten.each do |name|
           @state.on_sends[name] = next_state_name
@@ -241,13 +243,42 @@ module EventState
       #
       # @return [nil]
       #
-      def on_recv *message_names, next_state_name
+      def on_recv *args
+        next_state_name = args.pop
+        message_names = args
         raise "on_recv must be called from a state block" unless @state
         message_names.flatten.each do |name|
           @state.on_recvs[name] = next_state_name
         end
       end
 
+      #
+      # Set maximum time (in seconds) that the machine should spend in this
+      # state. By default, there is no limit. If you set a timeout without
+      # passing a block, the default action is to call +close_connection+.
+      #
+      # Note that the timeout block will not be executed if unbind is called in
+      # this state. However, if the timeout block calls close_connection, the
+      # state's on_unbind handler will be called.
+      #
+      # Note that the timeout applies to all machines. If you want to set a
+      # timeout 'at run time' that applies to the machine only while it is in a
+      # particular state, see {#add_state_timer}.
+      #
+      # Internally, this uses EventMachine's +add_timer+ method. It is
+      # independent of EventMachine's +comm_inactivity_timeout+.
+      #
+      # @yield [] called once timeout elapses
+      #
+      # @return [nil]
+      #
+      def timeout timeout, &block
+        raise "on_recv must be called from a state block" unless @state
+        @state.timeout = timeout
+        @state.on_timeout = block if block_given?
+        nil
+      end
+
       #
       # @return [Hash<Symbol, State>] map from state names (ruby symbols) to
       #         {State}s
@@ -338,6 +369,11 @@ module EventState
       end 
     end
 
+    #
+    # @return [State] the machine's current state
+    #
+    attr_reader :state
+
     #
     # Called by +EventMachine+ when a new connection has been established. This
     # calls the +on_enter+ handler for the machine's start state with a +nil+
@@ -350,13 +386,16 @@ module EventState
     #
     def post_init
       @state = self.class.start_state
+      @state_timer_sigs = []
+      add_state_timer @state.timeout, &@state.on_timeout if @state.timeout
       @state.call_on_enter self, nil, nil
       nil
     end
 
     #
     # Called by +EventMachine+ when a connection is closed. This calls the
-    # {on_unbind} handler for the current state. 
+    # {on_unbind} handler for the current state and then cancels all state
+    # timers. 
     #
     # @return [nil]
     #
@@ -364,7 +403,7 @@ module EventState
       #puts "#{self.class} UNBIND"
       handler = @state.on_unbind
       self.instance_exec(&handler) if handler 
-      nil
+      cancel_state_timers
     end
 
     #
@@ -452,16 +491,52 @@ module EventState
       nil
     end
 
+    #
+    # Add a timer that will be fired only while the machine is in the current
+    # state; the timer is cancelled when the machine leaves the current state
+    # (either by sending or receiving a message, or when unbind is called). 
+    #
+    # Internally, this uses EventMachine's +add_timer+ method.
+    #
+    # @param [Numeric] timeout in seconds
+    #
+    # @yield [] handler called after timeout
+    #
+    # @return [Integer] EventMachine timer signature
+    #
+    def add_state_timer timeout, &handler
+      sig = EM.add_timer(timeout) do
+        self.instance_exec(&handler)
+      end
+      @state_timer_sigs << sig
+      sig
+    end
+
     private
     
     #
     # Update @state and call appropriate on_exit and on_enter handlers.
     #
     def transition message_name, message, next_state_name
+      cancel_state_timers
       @state.call_on_exit  self, message_name, message
       @state = self.class.states[next_state_name]
+      add_state_timer @state.timeout, &@state.on_timeout if @state.timeout
       @state.call_on_enter self, message_name, message
     end
+
+    #
+    # Cancel all EM timers added by {#add_state_timer}.
+    #
+    # @return [nil]
+    #
+    def cancel_state_timers
+      @state_timer_sigs.each do |sig|
+        EM.cancel_timer(sig)
+      end
+      @state_timer_sigs.clear
+      nil
+    end
   end
 end
 

data/lib/event_state/state.rb

@@ -25,16 +25,24 @@ module EventState
   # @attr [Hash<Symbol, Symbol>] on_recvs map from message names to successor
   #       state names
   #
+  # @attr [Numeric, nil] timeout limit on the number of seconds to spend in this
+  #       state; the +on_timeout+ block is called after this elapses
+  #
+  # @attr [Proc] on_timeout called when the timeout elapses; by default, it
+  #       calls +close_connection+
+  #
   State = Struct.new(:name,
     :on_enters, :default_on_enter,
     :on_exits,  :default_on_exit,
-    :on_unbind, :on_sends,  :on_recvs) do
+    :on_unbind, :on_sends,  :on_recvs,
+    :timeout, :on_timeout) do
     def initialize(*)
       super
-      self.on_enters ||= {}
-      self.on_exits  ||= {}
-      self.on_sends  ||= {}
-      self.on_recvs  ||= {}
+      self.on_enters  ||= {}
+      self.on_exits   ||= {}
+      self.on_sends   ||= {}
+      self.on_recvs   ||= {}
+      self.on_timeout ||= lambda { close_connection }
     end
 
     #

data/lib/event_state/version.rb

@@ -2,9 +2,9 @@ module EventState
   # Major version number.
   VERSION_MAJOR = 0
   # Minor version number.
-  VERSION_MINOR = 0
+  VERSION_MINOR = 1
   # Patch number.
-  VERSION_PATCH = 1
+  VERSION_PATCH = 0
   # Version string.
   VERSION = [VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH].join('.')
 end

data/test/event_state/event_state_test.rb

@@ -1,3 +1,6 @@
+#require 'simplecov'
+#SimpleCov.start
+
 require 'event_state'
 require 'test/unit'
 
@@ -5,6 +8,7 @@ require 'test/unit'
 require 'event_state/ex_echo'
 require 'event_state/ex_readme'
 require 'event_state/ex_secret'
+require 'event_state/ex_job'
 
 # give more helpful errors
 Thread.abort_on_exception = true
@@ -15,6 +19,9 @@ class TestEventState < Test::Unit::TestCase
   DEFAULT_HOST = 'localhost'
   DEFAULT_PORT = 14159
 
+  #
+  # Run server and client in the same EventMachine reactor. Returns the client.
+  #
   def run_server_and_client server_class, client_class, opts={}, &block
     host = opts[:host] || DEFAULT_HOST
     port = opts[:port] || DEFAULT_PORT
@@ -34,11 +41,45 @@ class TestEventState < Test::Unit::TestCase
     client
   end
 
+  #
+  # Spawn the given server in a new process (fork) and yield once it's up and
+  # running.
+  #
+  # This works by spawning a child process and starting an EventMachine reactor
+  # in the child process. You should start a new one in the given block, if you
+  # want to connect a client.
+  #
+  def with_forked_server server_class, server_args=[], opts={}, &block
+    host = opts[:host] || DEFAULT_HOST
+    port = opts[:port] || DEFAULT_PORT
+
+    # use a pipe to signal the parent that the child server has started
+    p_r, p_w = IO.pipe
+    child_pid = fork do
+      p_r.close
+      EventMachine.run do
+        EventMachine.start_server(host, port, server_class, *server_args)
+        p_w.puts
+        p_w.close
+      end
+    end
+    p_w.close
+    p_r.gets # wait for child process to start server
+    p_r.close
+
+    begin
+      yield host, port
+    ensure
+      Process.kill 'TERM', child_pid
+      Process.wait
+    end
+  end
+
   def run_echo_test client_class
     server_log = []
     recorder = run_server_and_client(LoggingEchoServer, client_class,
-      server_args: [server_log],
-      client_args: [%w(foo bar baz), []]).recorder
+      :server_args => [server_log],
+      :client_args => [%w(foo bar baz), []]).recorder
 
     assert_equal [
       "entering listening state", # on_enter called on the start state
@@ -59,14 +100,14 @@ class TestEventState < Test::Unit::TestCase
   def test_echo_basic
     assert_equal %w(foo bar baz), 
       run_server_and_client(EchoServer, EchoClient,
-        client_args: [%w(foo bar baz), []]).recorder
+        :client_args => [%w(foo bar baz), []]).recorder
   end
 
   def test_delayed_echo
     assert_equal %w(foo bar baz), 
       run_server_and_client(DelayedEchoServer, EchoClient,
-        server_args: [0.5],
-        client_args: [%w(foo bar baz), []]).recorder
+        :server_args => [0.5],
+        :client_args => [%w(foo bar baz), []]).recorder
   end
 
   def test_echo_with_object_protocol_client
@@ -83,7 +124,9 @@ class TestEventState < Test::Unit::TestCase
 
   def test_print_state_machine_dot
     dot = EchoClient.print_state_machine_dot(:graph_options => 'rankdir=LR;')
-    assert_equal <<DOT, dot.string
+
+    # order isn't determined, but we'll get one of the following two
+    match_1 = dot.string == <<DOT
 digraph "EventState::EchoClient" {
   rankdir=LR;
   speaking [peripheries=2];
@@ -91,6 +134,15 @@ digraph "EventState::EchoClient" {
   listening -> speaking [color=blue,label="String"];
 }
 DOT
+    match_2 = dot.string == <<DOT
+digraph "EventState::EchoClient" {
+  rankdir=LR;
+  speaking [peripheries=2];
+  listening -> speaking [color=blue,label="String"];
+  speaking -> listening [color=red,label="String"];
+}
+DOT
+    assert match_1 || match_2
   end
 
   class TestDSLBasic < EventState::Machine; end
@@ -113,13 +165,13 @@ DOT
     end
 
     assert_equal [
-      [:foo, [:recv, :hello], :bar],
-      [:bar, [:recv, :good_bye], :foo]], trans
+      [:bar, [:recv, :good_bye], :foo],
+      [:foo, [:recv, :hello], :bar]], trans.sort_by {|x| x.first.to_s}
   end
 
   class TestDSLNoNestedProtocols < EventState::Machine; end
 
-  def test_dsl_no_nested_states
+  def test_dsl_no_nested_protocols
     #
     # nested protocol blocks are illegal
     #
@@ -252,8 +304,8 @@ DOT
     server_log = []
     client_log = []
     run_server_and_client(TestUnbindServer, TestDelayClient,
-                          server_args: [server_log,  1],
-                          client_args: [client_log, [2,2]])
+                          :server_args => [server_log,  1],
+                          :client_args => [client_log, [2,2]])
     assert_equal [
       "entered foo",
       "unbound in foo"], server_log
@@ -267,8 +319,8 @@ DOT
     server_log = []
     client_log = []
     run_server_and_client(TestUnbindServer, TestDelayClient,
-                          server_args: [server_log,  1],
-                          client_args: [client_log, [0.5,2]])
+                          :server_args => [server_log,  1],
+                          :client_args => [client_log, [0.5,2]])
     assert_equal [
       "entered foo",
       "entered bar",
@@ -355,5 +407,54 @@ DOT
     assert_equal   Fixnum, error.message_name
     assert_equal   42, error.data
   end
+
+  def test_job_server_timeouts
+    client_logs = [[],[],[],[]]
+    with_forked_server JobServer do |host, port|
+      EM.run do
+        EM.add_timer 0.1 do
+          EventMachine.connect(host, port, JobClient, 0.1, 1.0, client_logs[0])
+        end
+        EM.add_timer 0.5 do
+          EventMachine.connect(host, port, JobClient, 0.1, 1.0, client_logs[1])
+        end
+        EM.add_timer 1.5 do
+          EventMachine.connect(host, port, JobClient, 0.1, 2.5, client_logs[2])
+        end
+        EM.add_timer 4.5 do
+          EventMachine.connect(host, port, JobClient, 1.5, 0.5, client_logs[3])
+        end
+        EM.add_timer 7 do
+          EM.stop
+        end
+      end
+    end
+
+    # first client gets its job processed
+    assert_equal [
+      'starting',
+      'entering sending state',
+      'sending job',
+      'closed: work: 1.0'], client_logs[0]
+
+    # second client tries while job is still being processed
+    assert_equal [
+      'starting',
+      'busy'], client_logs[1]
+
+    # third client's job time gets sent but times out
+    assert_equal [
+      'starting',
+      'entering sending state',
+      'sending job',
+      'timed out in waiting state',
+      'unbind in waiting state'], client_logs[2]
+
+    # fourth client waits too long to send the job; server gives up
+    assert_equal [
+      'starting',
+      'entering sending state',
+      'unbind in sending state'], client_logs[3]
+  end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: event_state
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-30 00:00:00.000000000Z
+date: 2012-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine
-  requirement: &80005190 !ruby/object:Gem::Requirement
+  requirement: &85328870 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 0.12.10
   type: :runtime
   prerelease: false
-  version_requirements: *80005190
+  version_requirements: *85328870
 - !ruby/object:Gem::Dependency
   name: gemma
-  requirement: &80004940 !ruby/object:Gem::Requirement
+  requirement: &85328600 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,7 +32,7 @@ dependencies:
         version: 2.0.0
   type: :development
   prerelease: false
-  version_requirements: *80004940
+  version_requirements: *85328600
 description: A small embedded DSL for implementing stateful protocols in EventMachine
   using finite state machines.
 email:
@@ -56,7 +56,7 @@ rdoc_options:
 - --main
 - README.rdoc
 - --title
-- event_state-0.0.1 Documentation
+- event_state-0.1.0 Documentation
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
@@ -67,7 +67,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 304276877
+      hash: 112961203
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -76,7 +76,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 304276877
+      hash: 112961203
 requirements: []
 rubyforge_project: event_state
 rubygems_version: 1.8.10
@@ -85,3 +85,4 @@ specification_version: 3
 summary: StateMachines for EventMachines.
 test_files:
 - test/event_state/event_state_test.rb
+has_rdoc: