simpler_workflow 0.2.7 → 0.3.0.beta

data/.gitignore

@@ -15,3 +15,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+test.log

data/.travis.yml

@@ -1,9 +1,7 @@
 language: ruby
 rvm:
-  - 1.8.7
+  - 2.0.0
   - 1.9.2
   - 1.9.3
-  - jruby-18mode # JRuby in 1.8 mode
   - jruby-19mode # JRuby in 1.9 mode
-  - rbx-18mode
   - rbx-19mode

data/lib/simpler_workflow.rb

@@ -54,12 +54,7 @@ module SimplerWorkflow
   autoload :Domain,   'simpler_workflow/domain'
   autoload :Workflow, 'simpler_workflow/workflow'
   autoload :Activity, 'simpler_workflow/activity'
+  autoload :ActivityRegistry, 'simpler_workflow/activity_registry'
   autoload :OptionsAsMethods, 'simpler_workflow/options_as_methods'
   autoload :DefaultExceptionReporter, 'simpler_workflow/default_exception_reporter'
 end
-
-class Map
-  def Map.from_json(json)
-    from_hash(JSON.parse(json))
-  end
-end

data/lib/simpler_workflow/activity.rb

@@ -2,30 +2,27 @@ module SimplerWorkflow
   class Activity
     include OptionsAsMethods
 
+    DEFAULT_OPTIONS = {
+      :default_task_list => name,
+      :default_task_start_to_close_timeout => 5 * 60,
+      :default_task_schedule_to_start_timeout => 5 * 60,
+      :default_task_schedule_to_close_timeout => 10 * 60,
+      :default_task_heartbeat_timeout => :none
+    }
+
     attr_reader :domain, :name, :version, :options, :next_activity
 
-    def initialize(domain, name, version, options = {})
-      Activity.activities[[name, version]] ||= begin
-        default_options = {
-          :default_task_list => name,
-          :default_task_start_to_close_timeout => 5 * 60,
-          :default_task_schedule_to_start_timeout => 5 * 60,
-          :default_task_schedule_to_close_timeout => 10 * 60,
-          :default_task_heartbeat_timeout => :none
-        }
-        @options = default_options.merge(options)
-        @domain = domain
-        @name = name
-        @version = version
-        @failure_policy = :fail
-        self
-      end
+    def initialize(domain, name, version)
+      @options = DEFAULT_OPTIONS.dup
+      @domain = domain
+      @name = name
+      @version = version
+      @failure_policy = :fail
     end
 
     def on_success(activity, version = nil)
       case activity
       when Hash
-        activity.symbolize_keys!
         name = activity[:name].to_sym
         version = activity[:version]
       when String
@@ -33,7 +30,8 @@ module SimplerWorkflow
       when Symbol
         name = activity
       end
-      @next_activity = { :name => name, :version => version }
+
+      @next_activity = Activity[domain, name, version]
     end
 
     def on_fail(failure_policy)
@@ -48,6 +46,10 @@ module SimplerWorkflow
       @perform_task = block
     end
 
+    def name
+      @name.to_s
+    end
+
     def perform_task(task)
       logger.info("Performing task #{name}")
       @perform_task.call(task)
@@ -61,7 +63,31 @@ module SimplerWorkflow
     end
 
     def to_activity_type
-      domain.activity_types[name.to_s, version]
+      domain.activity_types[name, version]
+    end
+
+    def persist_attributes
+      activities.persist_attributes(self)
+    end
+
+    def simple_db_attributes
+      attributes = {
+        domain: domain.name,
+        name: name,
+        version: version,
+        failure_policy: failure_policy
+      }
+
+      if (next_activity)
+        attributes[:next_activity_name] = next_activity.name
+        attributes[:next_activity_version] = next_activity.version
+      end
+
+      attributes
+    end
+
+    def simple_db_name
+      "#{name}-#{version}"
     end
 
     def start_activity_loop
@@ -129,25 +155,26 @@ module SimplerWorkflow
       domain.activity_tasks.count(name).to_i
     end
 
-    def self.[](name, version = nil)
-      case name
-      when String
-        name = name.to_sym
-      when Hash
-        name.symbolize_keys!
-        version = name[:version]
-        name = name[:name]
-      end
-      activities[[name, version]]
+    def self.[](*activity_tuple)
+      activities[*activity_tuple]
     end
 
-    def self.register(name, version, activity)
-      activities[[name, version]] = activity
+    def self.[]=(*activity_tuple)
+      activities.[]=(*activity_tuple)
+    end
+
+    def self.register(domain, name, version, activity)
+      activities.register(domain, name, version, activity)
     end
 
     protected
+
+    def activities
+      self.class.activities
+    end
+
     def self.activities
-      @activities ||= {}
+      @activities ||= ActivityRegistry.new
     end
 
     def self.swf

data/lib/simpler_workflow/activity_registry.rb

@@ -0,0 +1,95 @@
+module SimplerWorkflow
+  class ActivityRegistry
+    def register(*activity_tuple)
+      domain = activity_tuple.shift
+      activity = activity_tuple.pop if activity_tuple.last.is_a?(Activity)
+      raise "Activity missing from registration" unless activity
+
+      registry_for_domain(domain)[activity_tuple] = activity
+    end
+
+    alias :[]= :register
+
+    def get(*activity_tuple)
+      domain = activity_tuple.shift
+      
+      if AWS::SimpleWorkflow::ActivityType === domain
+        name = domain.name.to_sym
+        version = domain.version
+        domain = domain.domain
+      else
+        name = activity_tuple.first
+        
+        case name
+        when Hash
+          version = name[:version]
+          name = name[:name].to_sym
+        when String, Symbol
+          name = name.to_sym
+          version = activity_tuple.last
+        end
+      end
+
+      registry_for_domain(domain)[[name, version]]
+    end
+
+    alias :[] :get
+
+    def persist_attributes(activity)
+      domain = Domain.for(activity.domain)
+
+      sdb_domain(domain).items.create(activity.simple_db_name, activity.simple_db_attributes)
+    end
+
+    protected
+    def registries
+      @registries ||= {}
+    end
+
+    def registry_for_domain(domain)
+      domain = Domain.for(domain)
+
+      unless sdb_domain(domain).exists?
+        sdb.domains.create(sdb_domain_name(domain))
+      end
+
+      registries[domain.name.to_sym] ||= Hash.new do |registry, (name, version)|
+        activity = Activity.new(domain, name, version)
+        attributes = sdb_attributes(domain, activity.simple_db_name)
+        
+        unless attributes.empty? 
+          activity.on_fail(attributes[:failure_policy]) if attributes.has_key?(:failure_policy)
+          activity.on_fail(attributes['failure_policy']) if attributes.has_key?('failure_policy')
+          activity.on_success(name: attributes[:next_activity_name], version: attributes[:next_activity_version]) if attributes.has_key?(:next_activity_name)
+          activity.on_success(name: attributes['next_activity_name'], version: attributes['next_activity_version']) if attributes.has_key?('next_activity_name')
+        end
+        registry[[name, version]] = activity
+      end
+    end
+
+    def sdb_domain_name(domain)
+      "swf-#{domain.name}-activities"
+    end
+
+    def sdb_domain(domain)
+      sdb.domains[sdb_domain_name(domain)]
+    end
+
+    def sdb_attributes(domain, sdb_name)
+      if item = sdb_domain(domain).items[sdb_name]
+        h = item.attributes.to_h
+        h.each { |k, v| h[k] = v.first }
+      else
+        {}
+      end
+    end
+
+    def self.sdb
+      @sdb ||= AWS::SimpleDB.new
+    end
+
+    def sdb
+      self.class.sdb
+    end
+  end
+end

data/lib/simpler_workflow/domain.rb

@@ -18,21 +18,33 @@ module SimplerWorkflow
     end
 
     def Domain.[](domain_name)
-      Domain.domains(domain_name)
+      Domain.domains(domain_name.to_sym)
+    end
+
+    def Domain.for(domain)
+      case domain
+      when String, Symbol
+        Domain[domain]
+      when Domain
+        domain
+      when AWS::SimpleWorkflow::Domain
+        Domain[domain.name]
+      end
     end
 
     def register_workflow(name, version, &block)
       unless workflow = Workflow[name, version]
         workflow = Workflow.new(self, name, version)
-      end
 
-      workflow.instance_eval(&block) if block
+        workflow.instance_eval(&block) if block_given?
 
-      begin
-        self.domain.workflow_types.register(name.to_s, version, workflow.options)
-      rescue ::AWS::SimpleWorkflow::Errors::TypeAlreadyExistsFault => e
-        # Instance already registered...
+        begin
+          self.domain.workflow_types.register(name, version, workflow.options)
+        rescue ::AWS::SimpleWorkflow::Errors::TypeAlreadyExistsFault
+          # Instance already registered...
+        end
       end
+
       workflow
     end
 
@@ -54,18 +66,18 @@ module SimplerWorkflow
       domain.activity_types
     end
 
-    def register_activity(name, version, &block)
-      unless activity = Activity[name, version]
-        logger.info("Registering Activity[#{name},#{version}]")
-        activity = Activity.new(self, name, version)
-      end
+    def register_activity(name, version = nil, &block)
+      logger.info("Registering Activity[#{name},#{version}]")
+      activity = activities[self, name, version]
 
       activity.instance_eval(&block) if block
 
+      activity.persist_attributes
+
       begin
         self.domain.activity_types.register(name.to_s, version, activity.options)
       rescue ::AWS::SimpleWorkflow::Errors::TypeAlreadyExistsFault
-        # Nothing to do, should probably log something here...
+        SimplerWorkflow.logger.info("Activity[#{name}, #{version}] already registered with SWF.")
       end
 
       activity

data/lib/simpler_workflow/version.rb

@@ -1,3 +1,3 @@
 module SimplerWorkflow
-  VERSION = "0.2.7"
+  VERSION = "0.3.0.beta"
 end

data/lib/simpler_workflow/workflow.rb

@@ -21,11 +21,8 @@ module SimplerWorkflow
     end
 
     def initial_activity(name, version = nil)
-      if activity = Activity[name.to_sym, version]
-        @initial_activity_type = activity.to_activity_type
-      elsif activity = domain.activity_types[name.to_s, version]
-        @initial_activity_type = activity
-      end
+      activity = Activity[domain, name.to_sym, version]
+      @initial_activity_type = activity.to_activity_type
     end
 
     def decision_loop
@@ -47,26 +44,11 @@ module SimplerWorkflow
           SimplerWorkflow.after_fork.call
         end
 
-
         loop do
           begin
             logger.info("Waiting for a decision task for #{name.to_s}, #{version} listening to #{task_list}")
             domain.decision_tasks.poll_for_single_task(task_list) do |decision_task|
-              decision_task.extend AWS::SimpleWorkflow::DecisionTaskAdditions
-              logger.info("Received decision task")
-              decision_task.new_events.each do |event|
-                logger.info("Processing #{event.event_type}")
-                case event.event_type
-                when 'WorkflowExecutionStarted'
-                  start_execution(decision_task, event)
-                when 'ActivityTaskCompleted'
-                  activity_completed(decision_task, event)
-                when 'ActivityTaskFailed'
-                  activity_failed(decision_task, event)
-                when 'ActivityTaskTimedOut'
-                  activity_timed_out(decision_task, event)
-                end
-              end
+              handle_decision_task(decision_task)
             end
             Process.exit 0 if @time_to_exit
           rescue Timeout::Error => e
@@ -77,9 +59,7 @@ module SimplerWorkflow
             end
           rescue => e
             context = {
-              :workflow_execution => decision_task.workflow_execution,
-              :workflow => to_workflow_type,
-              :decision_task => decision_task
+              :workflow => to_workflow_type
             }
             SimplerWorkflow.exception_reporter.report(e, context)
             raise e
@@ -89,69 +69,7 @@ module SimplerWorkflow
     end
 
     def task_list
-      @options[:default_task_list][:name].to_s
-    end
-
-    def start_execution(decision_task, event)
-      logger.info "Starting the execution of the job."
-      if @on_start_execution && @on_start_execution.respond_to?(:call)
-        @on_start_execution.call(decision_task, event)
-      else
-        decision_task.schedule_activity_task initial_activity_type, :input => event.attributes.input
-      end
-    end
-
-    def activity_completed(decision_task, event)
-      if @on_activity_completed && @on_activity_completed.respond_to?(:call)
-        @on_activity_completed.call(decision_task, event)
-      else
-        if event.attributes.keys.include?(:result)
-          result = Map.from_json(event.attributes.result)
-          next_activity = result[:next_activity]
-          activity_type = domain.activity_types[next_activity[:name], next_activity[:version]]
-          decision_task.schedule_activity_task activity_type, :input => scheduled_event(decision_task, event).attributes.input
-        else
-          logger.info("Workflow #{name}, #{version} completed")
-          decision_task.complete_workflow_execution :result => 'success'
-        end
-      end
-    end
-
-    def activity_failed(decision_task, event)
-      logger.info("Activity failed.")
-      if @on_activity_failed && @on_activity_failed.respond_to?(:call)
-        @on_activity_failed.call(decision_task, event)
-      else
-        if event.attributes.keys.include?(:details)
-          details = Map.from_json(event.attributes.details)
-          case details.failure_policy.to_sym
-          when :abort, :cancel
-            decision_task.cancel_workflow_execution
-          when :fail
-            decision_task.fail_workflow_execution
-          when :retry
-            logger.info("Retrying activity #{last_activity(decision_task, event).name} #{last_activity(decision_task, event).version}")
-            decision_task.schedule_activity_task last_activity(decision_task, event), :input => last_input(decision_task, event)
-          end
-        else
-          decision_task.cancel_workflow_execution
-        end
-      end
-    end
-
-    def activity_timed_out(decision_task, event)
-      logger.info("Activity timed out.")
-      if @on_activity_timed_out && @on_activity_timed_out.respond_to?(:call)
-        @on_activity_timed_out.call(decision_task, event)
-      else
-        case event.attributes.timeoutType
-        when 'START_TO_CLOSE', 'SCHEDULE_TO_START', 'SCHEDULE_TO_CLOSE'
-          logger.info("Retrying activity #{last_activity(decision_task, event).name} #{last_activity(decision_task, event).version} due to timeout.")
-          decision_task.schedule_activity_task last_activity(decision_task, event), :input => last_input(decision_task, event)
-        when 'HEARTBEAT'
-          decision_task.cancel_workflow_execution
-        end
-      end
+      options[:default_task_list][:name].to_s
     end
 
     def to_workflow_type
@@ -164,19 +82,19 @@ module SimplerWorkflow
     end
 
     def on_start_execution(&block)
-      @on_start_execution = block
+      event_handlers['WorkflowExecutionStarted'] = WorkflowEventHandler.new(&block)
     end
 
     def on_activity_completed(&block)
-      @on_activity_completed = block
+      event_handlers['ActivityTaskCompleted'] = WorkflowEventHandler.new(&block)
     end
 
     def on_activity_failed(&block)
-      @on_activity_failed = block
+      event_handlers['ActivityTaskFailed'] = WorkflowEventHandler.new(&block)
     end
 
     def on_activity_timed_out(&block)
-      @on_activity_timed_out = block
+      event_handlers['ActivityTaskTimedOut'] = WorkflowEventHandler.new(&block)
     end
 
     def self.[](name, version)
@@ -187,6 +105,18 @@ module SimplerWorkflow
       workflows[[name, version]] = workflow
     end
 
+    def scheduled_event(decision_task, event)
+      decision_task.scheduled_event(event)
+    end
+
+    def last_activity(decision_task, event)
+      scheduled_event(decision_task, event).attributes.activity_type
+    end
+
+    def last_input(decision_task, event)
+      scheduled_event(decision_task, event).attributes.input
+    end
+
     protected
     def self.workflows
       @workflows ||= {}
@@ -196,20 +126,121 @@ module SimplerWorkflow
       SimplerWorkflow.swf
     end
 
-    def scheduled_event(decision_task, event)
-      decision_task.scheduled_event(event)
+    def logger
+      SimplerWorkflow.logger
     end
 
-    def last_activity(decision_task, event)
-      scheduled_event(decision_task, event).attributes.activity_type
+    def handle_decision_task(decision_task)
+      decision_task.extend AWS::SimpleWorkflow::DecisionTaskAdditions
+      logger.info("Received decision task")
+      decision_task.new_events.each do |event|
+        logger.info("Processing #{event.event_type}")
+        event_handlers.fetch(event.event_type, DefaultEventHandler.new(self)).process(decision_task, event)
+      end
     end
 
-    def last_input(decision_task, event)
-      scheduled_event(decision_task, event).attributes.input
+    def event_handlers
+      @event_handlers ||= Map[
+        :WorkflowExecutionStarted , WorkflowExecutionStartedHandler.new(self) , 
+        :ActivityTaskCompleted    , ActivityTaskCompletedHandler.new(self)    , 
+        :ActivityTaskFailed       , ActivityTaskFailedHandler.new(self)       , 
+        :ActivityTaskTimedOut     , ActivityTaskTimedOutHandler.new(self)
+        ]
     end
 
-    def logger
-      $logger || Rails.logger
+    class DefaultEventHandler
+      attr_accessor :workflow
+
+      def initialize(workflow)
+        @workflow = workflow
+      end
+
+      def scheduled_event(*args)
+        workflow.scheduled_event(*args)
+      end
+
+      def domain
+        workflow.domain
+      end
+
+      def last_activity(*args)
+        workflow.last_activity(*args)
+      end
+
+      def last_input(*args)
+        workflow.last_input(*args)
+      end
+
+      def initial_activity_type
+        workflow.initial_activity_type
+      end
+
+      def process(*args); end
+    end
+
+    class WorkflowEventHandler
+      attr_accessor :handler
+ 
+      def initialize(&block)
+        @handler = block
+      end
+
+      def process(decision_task, event)
+        handler.call(decision_task, event)
+      end
+    end
+
+    class ActivityTaskTimedOutHandler < DefaultEventHandler
+      def process(decision_task, event)
+        case event.attributes.timeoutType
+        when 'START_TO_CLOSE', 'SCHEDULE_TO_START', 'SCHEDULE_TO_CLOSE'
+          last_activity_type = last_activity(decision_task, event)
+          SimplerWorkflow.logger.info("Retrying activity #{last_activity_type.name} #{last_activity_type.version} due to timeout.")
+          decision_task.schedule_activity_task last_activity_type, :input => last_input(decision_task, event)
+        when 'HEARTBEAT'
+          decision_task.fail_workflow_execution
+        end
+      end
+    end
+
+    class ActivityTaskFailedHandler < DefaultEventHandler
+      def process(decision_task, event)
+        last_activity_type = last_activity(decision_task, event)
+        failed_activity = domain.activities[last_activity_type]
+        
+        case failed_activity.failure_policy
+        when :abort, :cancel
+          SimplerWorkflow.logger.info("Cancelling workflow execution.")
+          decision_task.cancel_workflow_execution
+        when :retry
+          SimplerWorkflow.logger.info("Retrying activity #{last_activity_type.name} #{last_activity_type.version}")
+          decision_task.schedule_activity_task last_activity_type, :input => last_input(decision_task, event)
+        else
+          SimplerWorkflow.logger.info("Failing the workflow execution.")
+          decision_task.fail_workflow_execution
+        end
+      end
+    end
+
+    class ActivityTaskCompletedHandler < DefaultEventHandler
+      def process(decision_task, event)
+        last_activity_type = last_activity(decision_task, event)
+
+        completed_activity = domain.activities[last_activity_type]
+
+        if next_activity = completed_activity.next_activity
+          activity_type = domain.activity_types[next_activity.name, next_activity.version]
+          decision_task.schedule_activity activity_type, input: scheduled_event(decision_task, event).attributes.input
+        else
+          decision_task.complete_workflow_execution(result: 'success')
+        end
+      end
+    end
+
+    class WorkflowExecutionStartedHandler < DefaultEventHandler
+      def process(decision_task, event)
+        decision_task.schedule_activity_task initial_activity_type, input: event.attributes.input
+      end
     end
   end
 end

data/simpler_workflow.gemspec

@@ -26,10 +26,16 @@ EOM
   gem.name          = "simpler_workflow"
   gem.require_paths = ["lib"]
   gem.version       = SimplerWorkflow::VERSION
+  gem.required_ruby_version = '>= 1.9.0'
 
-  gem.add_dependency 'aws-sdk', '~> 1.6.0'
+  gem.add_dependency 'aws-sdk'
   gem.add_dependency 'map'
+  gem.add_development_dependency 'map'
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'rspec'
   gem.add_development_dependency 'travis-lint'
+  gem.add_development_dependency 'pry'
+  gem.add_development_dependency 'pry-nav'
+	gem.add_development_dependency 'logging'
+
 end

data/spec/activity_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+module SimplerWorkflow
+  describe Activity do
+    let(:client) { AWS.config.simple_workflow_client }
+    let(:describe_domain_response) { client.stub_for(:describe_domain) }
+    let(:list_domains_response) { client.stub_for(:list_domains) }
+
+    let(:decision_task) { mock(AWS::SimpleWorkflow::DecisionTask) }
+
+    let(:domain) { SimplerWorkflow.domain('test-domain') }
+
+    let(:domain_desc) {{
+      'configuration' => { 'workflowExecutionRetentionPeriodInDays' => '2' },
+      'domainInfo' => {
+        'name' => domain.name,
+        'description' => 'desc',
+        'status' => 'REGISTERED',
+      },
+    }}
+
+    let(:domains_desc) {
+      {
+        'domainInfos' => [
+          domain_desc['domainInfo']
+        ]
+      }
+    }
+
+    let(:sdb) { AWS::SimpleDB.new }
+
+    before :each do
+      describe_domain_response.stub(:data).and_return(domain_desc)
+      client.stub(:describe_domain).and_return(describe_domain_response)
+      list_domains_response.stub(:data).and_return(domains_desc)
+      client.stub(:list_domains).and_return(list_domains_response)
+    end
+
+    context "Registering a new activity" do
+      context "default activity" do
+        subject(:activity) { domain.register_activity('test-activity', '1.0.0') }
+
+        its(:name) { should == 'test-activity' }
+        its(:version) { should == '1.0.0' }
+        its(:domain) { should == domain }
+        its(:failure_policy) { should == :fail }
+      end
+
+      context "Setting the failure policy" do
+        subject(:activity) do
+          domain.register_activity('test-activity', '1.0.1') do
+            on_fail :retry
+          end
+        end
+
+        its(:failure_policy) { should == :retry }
+      end
+
+      context "Setting the next activity" do
+        subject(:activity) do
+          domain.register_activity('test-success', '1.0.0') do
+            on_success 'next-activity', '1.0.0'
+          end
+        end
+
+        its(:next_activity) { should == Activity[domain, 'next-activity', '1.0.0'] }
+      end
+
+      context "performing a task" do
+        subject(:activity) do
+          domain.register_activity('test-task', '1.0.0') do
+            perform_activity do |task|
+              task.complete! 'result' => "success"
+            end
+          end
+        end
+
+        it "should execute the task handler." do
+          task = mock(AWS::SimpleWorkflow::ActivityTask)
+          task.should_receive(:complete!).with("result" => "success")
+
+          activity.perform_task(task)
+        end
+      end
+
+      context "We should always return an activity from the registry" do
+        subject(:activity) { Activity[domain, 'not-a-real-activity', '1.0.0'] }
+
+        its(:name) { should == 'not-a-real-activity' }
+        its(:version) { should == '1.0.0' }
+        its(:failure_policy) { should == :fail }
+      end
+
+      context "We are retrieving an activity that was register in a different process" do
+        subject(:activity) { Activity[domain, 'registered-somewhere-else', '1.0.0'] }
+
+        it "should build the activity from the SDB data..." do
+          Activity.activities.should_receive(:sdb_attributes).with(domain, "registered-somewhere-else-1.0.0").and_return({
+            :failure_policy => 'retry',
+            :next_activity_name => 'yet-another-activity',
+            :next_activity_version => '1.0.0'
+          })
+
+          Activity.activities.should_receive(:sdb_attributes).with(domain, 'yet-another-activity-1.0.0').and_return({})
+
+          activity.failure_policy.should == :retry
+          activity.next_activity.should == Activity[domain, 'yet-another-activity', '1.0.0']
+          activity.next_activity.failure_policy.should == :fail
+        end
+
+      end
+
+      context "Just in case we get strings from amazon SDB..." do
+        subject(:activity) { Activity[domain, 'registered-somewhere-else', '2.0.0'] }
+
+        it "should build the activity from the SDB data... with Strings this time..." do
+          Activity.activities.should_receive(:sdb_attributes).with(domain, "registered-somewhere-else-2.0.0").and_return({
+            'failure_policy' => 'retry',
+            'next_activity_name' => 'yet-another-activity',
+            'next_activity_version' => '2.0.0'
+          })
+
+          Activity.activities.should_receive(:sdb_attributes).with(domain, 'yet-another-activity-2.0.0').and_return({})
+
+          activity.failure_policy.should == :retry
+          activity.next_activity.should == Activity[domain, 'yet-another-activity', '2.0.0']
+          activity.next_activity.failure_policy.should == :fail
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -7,6 +7,9 @@
 #
 
 require 'simpler_workflow'
+require 'aws/simple_workflow'
+require 'pry'
+require 'logging'
 
 RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true
@@ -17,8 +20,12 @@ RSpec.configure do |config|
     AWS.stub!
     AWS.config(:access_key_id => 'TESTKEY', :secret_access_key => 'TESTSECRET')
   end
-end
 
-def stub_list_domains
+	$logger = Logging.logger("test.log")
+end
 
+class SimplerWorkflow::Workflow::WorkflowEventHandler
+  def workflow_event_handler?
+    is_a?(SimplerWorkflow::Workflow::WorkflowEventHandler)
+  end
 end

data/spec/workflow_spec.rb

@@ -0,0 +1,245 @@
+require 'spec_helper'
+
+module SimplerWorkflow
+  describe Workflow do
+    let(:client) { AWS.config.simple_workflow_client }
+    let(:describe_domain_response) { client.stub_for(:describe_domain) }
+    let(:list_domains_response) { client.stub_for(:list_domains) }
+
+    let(:decision_task) { mock(AWS::SimpleWorkflow::DecisionTask) }
+
+    let(:domain) { SimplerWorkflow.domain('test-domain') }
+
+    let(:domain_desc) {{
+      'configuration' => { 'workflowExecutionRetentionPeriodInDays' => '2' },
+      'domainInfo' => {
+        'name' => domain.name,
+        'description' => 'desc',
+        'status' => 'REGISTERED',
+      },
+    }}
+
+    let(:domains_desc) {
+      {
+        'domainInfos' => [
+          domain_desc['domainInfo']
+        ]
+      }
+    }
+
+    before :each do
+      describe_domain_response.stub(:data).and_return(domain_desc)
+      client.stub(:describe_domain).and_return(describe_domain_response)
+      list_domains_response.stub(:data).and_return(domains_desc)
+      client.stub(:list_domains).and_return(list_domains_response)
+    end
+
+    context "Registering a new workflow." do
+      before :each do 
+        Workflow.send :public, :event_handlers
+      end
+
+      context "default workflows" do
+        let(:workflow) { domain.register_workflow('test-workflow', '1.0.0') }
+
+        let(:event_handlers) { workflow.event_handlers }
+
+        it "should allow the registration of a domain." do
+          workflow.name.should == 'test-workflow'
+          workflow.version.should == '1.0.0'
+        end
+
+        it "should have a default tasklist" do
+          workflow.task_list.should == workflow.name
+        end
+
+        it "should have a default task start to close timeout" do
+          workflow.options[:default_task_start_to_close_timeout].should == "120"
+        end
+
+        it "should have a default execution start to close timeout" do
+          workflow.options[:default_execution_start_to_close_timeout].should == "120"
+        end
+
+        it "should have a default child policy of terminate" do
+          workflow.options[:default_child_policy].should == 'TERMINATE'
+        end
+
+        it 'should have default handlers' do
+          event_handlers.should_not be_nil
+        end
+
+        %w(WorkflowExecutionStarted ActivityTaskCompleted ActivityTaskFailed ActivityTaskTimedOut).each do |event|
+          it "should have a default event handler for #{event}" do
+            handler = event_handlers[event]
+            handler.should_not be_nil
+            handler.class.name.should == "SimplerWorkflow::Workflow::#{event}Handler"
+          end
+
+          it "should call the right handler for #{event}" do
+            new_event = Map.new
+            new_event.set(:event_type, event)
+
+            decision_task.should_receive(:new_events).and_return([new_event])
+
+            event_handlers[new_event.event_type].should_receive(:process).with(decision_task, new_event)
+
+            workflow.send :handle_decision_task, decision_task
+          end
+        end
+
+				context "The workflow's initial activity" do
+					before :each do
+						workflow.initial_activity :test_activity, '1.0.0'
+					end
+
+
+					it "should store the initial activity" do
+						workflow.send(:initial_activity_type).should == domain.activity_types[:test_activity, '1.0.0']
+					end
+
+					it "should start a workflow based on the declared initial activity" do
+						event = stub( :attributes => stub( :input => "Mary had a little lamb"))
+						decision_task.should_receive(:schedule_activity_task).with(domain.activity_types[:test_activity, '1.0.0'], input: event.attributes.input)
+
+						event_handlers[:WorkflowExecutionStarted].process(decision_task, event)
+					end
+				end
+
+				context "An activity completed." do
+					it "should complete the execution if we have results but to not provide a next activity" do
+						event = Map.new
+						event.set(:attributes, :result, '{"blah":"Hello"}')
+
+            scheduled_activity = domain.register_activity(:completion_activity, '1.0.0')
+
+						scheduled_event = Map.new
+						scheduled_event.set(:attributes, :input, "mary had a little lamb")
+            scheduled_event.set(:attributes, :activity_type, scheduled_activity.to_activity_type)
+
+            decision_task.should_receive(:scheduled_event).with(event).and_return(scheduled_event)
+						decision_task.should_receive(:complete_workflow_execution).with(result: 'success')
+
+						event_handlers[:ActivityTaskCompleted].process(decision_task, event)
+					end
+
+					it "should schedule the next activity if the current one declares one" do
+						event = Map.new
+						event.set(:attributes, :result, "success")
+
+            test_activity = domain.register_activity(:test_activity, '1.0.0')
+
+            scheduled_activity = domain.register_activity(:success_activity, '1.0.0') do 
+              on_success :test_activity, '1.0.0'
+            end
+
+						next_activity = test_activity.to_activity_type
+
+						scheduled_event = Map.new
+						scheduled_event.set(:attributes, :input, "mary had a little lamb")
+            scheduled_event.set(:attributes, :activity_type, scheduled_activity.to_activity_type)
+
+            decision_task.should_receive(:scheduled_event).with(event).twice.and_return(scheduled_event)
+						decision_task.should_receive(:schedule_activity).with(next_activity, input: scheduled_event.attributes.input)
+
+						event_handlers[:ActivityTaskCompleted].process(decision_task, event)
+					end
+				end
+
+				context "An activity task failed" do
+					it "should fail the execution if instructed to do so" do
+						event = Map.new
+
+            test_activity = domain.register_activity(:failed_activity, '1.0.0')
+
+            scheduled_event = Map.new
+            scheduled_event.set(:attributes, :input, "Mary had a little lamb")
+            scheduled_event.set(:attributes, :activity_type, test_activity.to_activity_type)
+
+						decision_task.should_receive(:fail_workflow_execution)
+            decision_task.should_receive(:scheduled_event).with(event).and_return(scheduled_event)
+
+						event_handlers[:ActivityTaskFailed].process(decision_task, event)
+					end
+
+					it "should cancel the execution if instructed to abort" do
+						event = Map.new
+            test_activity = domain.register_activity(:failed_activity, '1.0.1') do
+              on_fail :abort
+            end
+
+            scheduled_event = Map.new
+            scheduled_event.set(:attributes, :input, "Mary had a little lamb")
+            scheduled_event.set(:attributes, :activity_type, test_activity.to_activity_type)
+
+            decision_task.should_receive(:scheduled_event).with(event).and_return(scheduled_event)
+						decision_task.should_receive(:cancel_workflow_execution)
+
+						event_handlers[:ActivityTaskFailed].process(decision_task, event)
+					end
+
+					it "should cancel the execution if instructed to do so" do
+						event = Map.new
+
+            test_activity = domain.register_activity(:failed_activity, '1.0.2') do
+              on_fail :cancel
+            end
+
+            scheduled_event = Map.new
+            scheduled_event.set(:attributes, :input, "Mary had a little lamb")
+            scheduled_event.set(:attributes, :activity_type, test_activity.to_activity_type)
+
+            decision_task.should_receive(:scheduled_event).with(event).and_return(scheduled_event)
+						decision_task.should_receive(:cancel_workflow_execution)
+
+						event_handlers[:ActivityTaskFailed].process(decision_task, event)
+					end
+
+          it "should reschedule the activity if requested" do
+            event = Map.new
+
+            test_activity = domain.register_activity(:failed_activity, '1.0.3') do
+              on_fail :retry
+            end
+
+            scheduled_event = Map.new
+            scheduled_event.set(:attributes, :input, "Mary had a little lamb")
+            scheduled_event.set(:attributes, :activity_type, test_activity.to_activity_type)
+
+            decision_task.should_receive(:scheduled_event).with(event).twice.and_return(scheduled_event)
+            decision_task.should_receive(:schedule_activity_task).with(test_activity.to_activity_type, input: scheduled_event.attributes.input)
+
+            event_handlers[:ActivityTaskFailed].process(decision_task, event)
+          end
+
+				end
+
+        context "an activity timed out" do
+          %w(START_TO_CLOSE SCHEDULE_TO_CLOSE SCHEDULE_TO_START).each do |timeout_type|
+            it "should retry a timed out decision task on #{timeout_type}" do
+              activity_type = domain.activity_types[:test_activity, "1.0.0"]
+              event = Map.new
+              event.set(:attributes, :timeoutType, timeout_type)
+              scheduled_event = Map.new
+              scheduled_event.set(:attributes, :input, "Mary had a little lamb")
+              scheduled_event.set(:attributes, :activity_type, activity_type)
+
+              decision_task.should_receive(:scheduled_event).twice.and_return(scheduled_event)
+              decision_task.should_receive(:schedule_activity_task).with(activity_type, input: scheduled_event.attributes.input)
+              event_handlers[:ActivityTaskTimedOut].process(decision_task, event)
+            end
+          end
+
+          it "should fail a workflow execution when the heartbeat fails" do
+            event = Map.new
+            event.set(:attributes, :timeoutType, 'HEARTBEAT')
+
+            decision_task.should_receive(:fail_workflow_execution)
+
+            event_handlers[:ActivityTaskTimedOut].process(decision_task, event)
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,34 +1,41 @@
 --- !ruby/object:Gem::Specification
 name: simpler_workflow
 version: !ruby/object:Gem::Version
-  version: 0.2.7
-  prerelease: 
+  prerelease: 6
+  version: 0.3.0.beta
 platform: ruby
 authors:
 - Frederic Jean
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-04 00:00:00.000000000 Z
+date: 2013-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   name: aws-sdk
+  prerelease: false
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.6.0
+        version: '0'
   type: :runtime
-  prerelease: false
+- !ruby/object:Gem::Dependency
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.6.0
-- !ruby/object:Gem::Dependency
+        version: '0'
   name: map
+  prerelease: false
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -36,15 +43,31 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
-  prerelease: false
+- !ruby/object:Gem::Dependency
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+  name: map
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
 - !ruby/object:Gem::Dependency
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   name: rake
+  prerelease: false
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -52,15 +75,15 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
-  prerelease: false
+- !ruby/object:Gem::Dependency
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
   name: rspec
+  prerelease: false
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -68,15 +91,31 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
-  prerelease: false
+- !ruby/object:Gem::Dependency
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
   name: travis-lint
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+- !ruby/object:Gem::Dependency
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: pry
+  prerelease: false
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -84,13 +123,38 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
+- !ruby/object:Gem::Dependency
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: pry-nav
   prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+- !ruby/object:Gem::Dependency
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+  name: logging
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
 description: A wrapper around Amazon's Simple Workflow Service
 email:
 - fred@snugghome.com
@@ -112,21 +176,23 @@ files:
 - lib/aws/simple_workflow/decision_task_additions.rb
 - lib/simpler_workflow.rb
 - lib/simpler_workflow/activity.rb
+- lib/simpler_workflow/activity_registry.rb
 - lib/simpler_workflow/default_exception_reporter.rb
 - lib/simpler_workflow/domain.rb
 - lib/simpler_workflow/options_as_methods.rb
 - lib/simpler_workflow/tasks.rb
 - lib/simpler_workflow/version.rb
 - lib/simpler_workflow/workflow.rb
-- lib/simpler_workflow/workflow_collection.rb
 - lib/tasks/simpler_workflow.rake
 - simpler_workflow.gemspec
+- spec/activity_spec.rb
 - spec/domain_spec.rb
 - spec/simpler_workflow_spec.rb
 - spec/spec_helper.rb
+- spec/workflow_spec.rb
 homepage: https://github.com/fredjean/simpler_workflow
 licenses: []
-post_install_message: ! "simpler_workflow 0.2.7\n========================\n\nHave
+post_install_message: ! "simpler_workflow 0.3.0.beta\n========================\n\nHave
   a look at https://github.com/fredjean/simpler_workflow/wiki/MIgrating-to-0.2.0 if
   you\nare upgrading from a 0.1.x version of the gem. There is a fundamental change
   in how the \nactivity and decision loops are run. You may need to adjust your application
@@ -140,19 +206,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '0'
-      segments:
-      - 0
-      hash: 618930098461104391
+      version: 1.9.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
-      segments:
-      - 0
-      hash: 618930098461104391
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -161,6 +221,8 @@ specification_version: 3
 summary: A wrapper and DSL around Amazon's Simple Workflow Service with the goal of
   making it almost pleasant to define workflows.
 test_files:
+- spec/activity_spec.rb
 - spec/domain_spec.rb
 - spec/simpler_workflow_spec.rb
 - spec/spec_helper.rb
+- spec/workflow_spec.rb

data/lib/simpler_workflow/workflow_collection.rb

@@ -1,16 +0,0 @@
-module SimplerWorkflow
-  class WorkflowCollection
-    def [](name, version)
-      registry[[name,version]]
-    end
-
-    def []=(name, version, value)
-      registry[[name, version]] = value
-    end
-
-    protected
-    def registry
-      @registry ||= {}
-    end
-  end
-end