aws-swf 0.1.2

data/lib/swf/decision_task_handler.rb

@@ -0,0 +1,105 @@
+require 'swf/task_handler'
+
+module SWF
+
+  class MissingWorkflowStartedEvent < StandardError; end
+
+  # subclass must call .register(name, version), and define #handle(runner, task)
+  class DecisionTaskHandler
+    extend TaskHandler
+
+    @@handler_classes_by_name_version = {}
+
+    # Register statically self (subclass) to handle workflow_type with given name and version
+    def self.register(name, version)
+      @@handler_classes_by_name_version [ [name.to_s, version.to_s] ] = self
+    end
+
+    def self.fail!(task, args={})
+      task.fail_workflow_execution(args)
+    end
+
+    def self.find_handler_class(task)
+      type = task.workflow_type
+      @@handler_classes_by_name_version[ [type.name, type.version] ]
+    end
+
+    def self.configuration_help_message
+      "Each decision task handler running on this task list in this domain must know how to handle this workflow_type's name and version.\n" +
+      "I only know: #{@@handler_classes_by_name_version.inspect}"
+    end
+
+    attr_reader :runner, :decision_task
+
+    def initialize(runner, decision_task)
+      @runner = runner
+      @decision_task = decision_task
+    end
+
+    def call_handle
+      handle
+    end
+
+    def events
+      # make events into an array to avoid token timeout issues
+      # see https://forums.aws.amazon.com/thread.jspa?threadID=98925
+      @events ||= decision_task.events.to_a
+    end
+
+    def new_events
+      enum_for(:_new_events)
+    end
+
+    def _new_events(&block)
+      events.each {|e|
+        yield(e) if e.new?
+      }
+    end
+
+    # slot time of 51.2 microseconds is way too little
+    # even 1 second still results in collision growing
+    # but it doesn't seem to get to 10 so we'll leave
+    # it at that for now
+    def slot_time
+      #5.12e-5 # you wish
+      1
+    end
+
+    # exponential backoff handles rate limiting exceptions
+    # when querying tags on a workflow execution.
+    def tags
+      runner.tag_lists[decision_task.workflow_execution] ||= begin
+        collision = 0
+        begin
+          decision_task.workflow_execution.tags
+        rescue => e
+          collision += 1 if collision < 10
+          max_slot_delay = 2**collision - 1
+          sleep(slot_time * rand(0 .. max_slot_delay))
+          retry
+        end
+      end
+    end
+
+
+    def workflow_started_event
+      @workflow_started_event ||= begin
+        events.find {|e| e.event_type == 'WorkflowExecutionStarted' } or raise MissingWorkflowStartedEvent, "Missing WorkflowExecutionStarted event in #{runner}"
+      end
+    end
+
+    def workflow_task_list
+      @workflow_task_list ||= workflow_started_event.attributes.task_list
+    end
+
+    def workflow_input
+      @workflow_input ||= JSON.parse(workflow_started_event.attributes.input)
+    end
+
+    def event_input(event)
+      JSON.parse(event.attributes.input)
+    end
+
+  end
+
+end

data/lib/swf/runner.rb

@@ -0,0 +1,52 @@
+require 'swf'
+
+module SWF
+  class Runner
+
+    attr_reader :domain_name, :task_list_name
+
+    def initialize(domain_name, task_list_name)
+      @domain_name    = domain_name
+      @task_list_name = task_list_name
+    end
+
+    def be_decider
+      domain.decision_tasks.poll(task_list) {|decision_task|
+        DecisionTaskHandler.handle(self, decision_task)
+      }
+    end
+
+    def be_worker
+      domain.activity_tasks.poll(task_list) {|activity_task|
+        ActivityTaskHandler.handle(self, activity_task)
+      }
+    end
+
+    # these are static for workflow executions
+    # so no need to refetch per decision_task
+    def tag_lists
+      @tag_lists ||= {}
+    end
+
+    def domain
+      @domain ||= begin
+        SWF.domain_name = domain_name
+        SWF.domain
+      end
+    end
+
+    def task_list
+      @task_list ||= begin
+        SWF.task_list = task_list_name
+      end
+    end
+
+
+    def effect_activity_type(name, version, options={})
+      @activity_types ||= {}
+      @activity_types[[name, version]] ||= domain.activity_types.find {|t| [t.name, t.version] == [name, version] }
+      @activity_types[[name, version]] ||= domain.activity_types.create(name, version, options)
+    end
+
+  end
+end

data/lib/swf/task_handler.rb

@@ -0,0 +1,56 @@
+require 'json'
+
+module SWF
+
+  # use extend, not include
+  module TaskHandler
+
+    def handle(runner, task)
+      handler_class = nil
+      handler       = nil
+      begin
+
+        handler_class = get_handler_class_or_fail task
+        return unless handler_class
+        handler = handler_class.new(runner, task)
+        handler.call_handle
+
+      rescue => e
+
+        puts "HANDLER #{self} ERROR:"
+        begin
+          details_json = JSON.pretty_unparse({
+            handler_class: handler_class && handler_class.name,
+            handler:       handler.to_s,
+            error:         e.inspect,
+            backtrace:     e.backtrace,
+            })
+          puts details_json
+          fail!(task, reason: "handler raised error", details: details_json[0...32768])
+        rescue
+          msg = "FAIL to handle fail!!"
+          puts msg
+          # failing again will cause #<RuntimeError: already responded>
+          #fail!(task, reason: msg)
+          raise
+        end
+
+      end
+    end
+
+    private
+
+    def get_handler_class_or_fail(task)
+      find_handler_class(task).tap {|handler_class|
+        unless handler_class
+          details_text = "This is a configuration issue.\n#{configuration_help_message}"
+          puts details_text
+          fail!(task, reason: "unknown type", details: details_text)
+          return
+        end
+      }
+    end
+
+  end
+
+end

data/lib/workflows.rb

@@ -0,0 +1,27 @@
+require 'swf'
+
+module SWF
+  module Workflows
+    extend self
+
+    def effect_workflow_type(name, version, options={})
+      @workflow_types ||= {}
+      @workflow_types[[name, version]] ||= SWF.domain.workflow_types.find {|t| [t.name, t.version] == [name, version] }
+      @workflow_types[[name, version]] ||= SWF.domain.workflow_types.create(name, version, options)
+    end
+
+    def start(options, execution_options)
+      execution_options[:task_list] ||= SWF.task_list
+      execution_options.merge!({
+        input: options.to_json
+      })
+      workflow_type.start_execution(execution_options)
+    end
+
+    def wait_for_workflow_execution_complete(workflow_execution)
+      sleep 1 while :open == (status = workflow_execution.status)
+      raise "workflow_execution #{workflow_execution} did not succeed: #{workflow_execution.status}" unless status == :completed
+    end
+
+  end
+end

data/spec/swf/activity_task_handler_spec.rb

@@ -0,0 +1,58 @@
+require './lib/swf/activity_task_handler.rb'
+
+subject_class = SWF::ActivityTaskHandler
+describe subject_class do
+
+  describe ' .register, .find_handler_class' do
+    before { mock_subclass }
+
+    let(:mock_subclass) {
+      Class.new(subject_class) {
+        register
+        def handle_fake_activity; end
+      }
+    }
+
+    it "registers and finds a subclass with a handle_* method matching a given activity name" do
+      subject_class.find_handler_class(double(:task, activity_type: double(name: 'fake_activity', version: 'fake_version'))).should == mock_subclass
+    end
+  end
+
+  let(:subject){ subject_class.new(:runner_placeholder, task) }
+  let(:input) { {"some" => "data"} }
+  let(:task){ double(:task, activity_type: double(name: 'fake_activity'), input: input.to_json) }
+  describe '#initialize' do
+    it 'sets runner & decision_task' do
+      subject.runner.should == :runner_placeholder
+      subject.activity_task.should == task
+    end
+  end
+
+  describe '#call_handle' do
+    it "calls #handle_* method" do
+      subject.should_receive(:handle_fake_activity)
+
+      subject.call_handle
+    end
+  end
+
+  describe '#activity_task_input' do
+    it 'JSON parses activity_task.input' do
+      subject.activity_task_input.should == input
+    end
+  end
+
+  describe '.fail!' do
+    it 'fails the activity task' do
+      task = double(:task).tap {|o| o.should_receive(:fail!).with(:args_placeholder) }
+      subject_class.fail! task, :args_placeholder
+    end
+  end
+
+  describe '.configuration_help_message' do
+    it { subject_class.configuration_help_message.should be_is_a String }
+    it { subject_class.configuration_help_message.length.should > 100 }
+    it { subject_class.configuration_help_message.should include 'activity' }
+  end
+
+end

data/spec/swf/boot_spec.rb

@@ -0,0 +1,107 @@
+require './lib/swf/boot'
+
+describe SWF::Boot do
+  before do
+    $stdout.stub(:write)
+
+    SWF::Boot.stub(:settings) {
+      { domain_name: 'phony_domain', task_list_name: 'phony_task_list'}
+    }
+  end
+
+  describe '.swf_runner' do
+    it "creates a new Runner object with the proper arguments" do
+      SWF::Runner.should_receive(:new).with('phony_domain', 'phony_task_list')
+      SWF::Boot.swf_runner
+    end
+  end
+
+  describe '.startup' do
+    before do
+      SWF::Boot.stub(:swf_runner) { double(:runner, be_worker: 'worker', be_decider: 'decider') }
+    end
+
+    context 'without waiting for children' do
+      it 'forks deciders' do
+        Process.should_receive(:fork).exactly(5).times do |&blk|
+          Process.should_receive(:daemon).with(true)
+          SWF::Boot.should_receive(:swf_runner).once
+          blk.call
+        end
+        Process.should_receive(:detach).with('decider').exactly(5).times
+        SWF::Boot.startup(5,0)
+      end
+      it 'forks workers' do
+        Process.should_receive(:fork).exactly(5).times do |&blk|
+          Process.should_receive(:daemon).with(true)
+          SWF::Boot.should_receive(:swf_runner).once
+          blk.call
+        end
+        Process.should_receive(:detach).with('worker').exactly(5).times
+        SWF::Boot.startup(0,5)
+      end
+    end
+
+    context 'with waiting for children' do
+      it 'forks deciders' do
+        Process.should_receive(:fork).exactly(5).times do |&blk|
+          Process.should_not_receive(:daemon)
+          SWF::Boot.should_receive(:swf_runner).once
+          blk.call
+        end
+        Process.should_receive(:wait).with('decider').exactly(5).times
+        SWF::Boot.startup(5,0,true)
+      end
+      it 'forks workers' do
+        Process.should_receive(:fork).exactly(5).times do |&blk|
+          Process.should_not_receive(:daemon)
+          SWF::Boot.should_receive(:swf_runner).once
+          blk.call
+        end
+        Process.should_receive(:wait).with('worker').exactly(5).times
+        SWF::Boot.startup(0,5,true)
+      end
+    end
+
+    context 'error handling' do
+      before do
+        SWF::Boot.stub(:swf_runner) {
+          double(:runner).tap {|runner|
+            runner.stub(:be_worker) { raise StandardError }
+            runner.stub(:be_decider) { raise StandardError }
+          }
+        }
+      end
+      it 'fails on deciders' do
+        Process.should_receive(:fork).exactly(5).times do |&blk|
+          Process.should_receive(:daemon)
+          SWF::Boot.should_receive(:swf_runner).twice
+          ->{blk.call}.should raise_exception(SWF::Boot::DeciderStartupFailure)
+        end
+        Process.should_receive(:detach).exactly(5).times
+        SWF::Boot.startup(5,0,false)
+      end
+
+      it 'fails on workers' do
+          Process.should_receive(:fork).exactly(5).times do |&blk|
+          Process.should_receive(:daemon)
+          SWF::Boot.should_receive(:swf_runner).twice
+          ->{blk.call}.should raise_exception(SWF::Boot::WorkerStartupFailure)
+        end
+        Process.should_receive(:detach).exactly(5).times
+        SWF::Boot.startup(0,5,false)
+
+      end
+    end
+  end
+
+  describe '.terminate_children' do
+    it 'calls Process.kill for each pid passed' do
+      [1,2,3].each {|pid|
+        Process.should_receive(:kill).with("TERM", pid).once
+      }
+      SWF::Boot.terminate_children([1,2,3])
+    end
+  end
+
+end

data/spec/swf/decision_task_handler_spec.rb

@@ -0,0 +1,141 @@
+require './lib/swf/decision_task_handler.rb'
+
+subject_class = SWF::DecisionTaskHandler
+describe subject_class do
+
+  describe ' .register, .find_handler_class' do
+    before { mock_subclass }
+
+    let(:mock_subclass) {
+      Class.new(subject_class) {
+        register :fake_name, "fake_version"
+      }
+    }
+
+    it "registers and finds a subclass for a given workflow name/version" do
+      subject_class.find_handler_class(double(:task, workflow_type: double(name: 'fake_name', version: 'fake_version'))).should == mock_subclass
+    end
+  end
+
+  let(:decision_task) { double(:decision_task, events: []) }
+  let(:subject){ subject_class.new(:runner_placeholder, decision_task ) }
+
+  describe '#initialize' do
+    it 'sets runner & decision_task' do
+      subject.runner.should == :runner_placeholder
+      subject.decision_task.should == decision_task
+    end
+  end
+
+  describe '#call_handle' do
+    it "calls #handle" do
+      subject.should_receive(:handle)
+      subject.call_handle
+    end
+  end
+
+  describe '#events' do
+    it 'calls decision_task.events if no @events' do
+      subject.instance_variable_set(:@events, nil)
+      subject.decision_task.should_receive(:events)
+      subject.events.should == []
+    end
+    it 'otherwise just returns @events' do
+      subject.instance_variable_set(:@events, :foobar)
+      subject.decision_task.should_not_receive(:events)
+      subject.events.should == :foobar
+    end
+  end
+
+  let(:new_events) {[
+    double(:event,
+      event_type: 'new_event',
+      new?: true
+    ),
+    double(:event,
+      event_type: 'another_new_event',
+      new?: true
+    )
+  ]}
+
+  let(:old_events) {[
+    double(:event,
+      event_type: 'old_event',
+      new?: false
+    ),
+    double(:event,
+      event_type: 'another_old_event',
+      new?: false
+    )
+  ]}
+
+  describe '#new_events' do
+    before do
+      subject.decision_task.stub(:events) {
+        new_events + old_events
+      }
+    end
+
+    it 'enumerates over new events' do
+      subject.send(:new_events).each {|e|
+        new_events.include?(e).should be_true
+        old_events.include?(e).should be_false
+      }
+    end
+
+  end
+
+  let(:workflow_started_input){ {"foo" => "bar"} }
+  let(:task_list) { 'foobar' }
+  let(:workflow_started_event) {
+    double(:event,
+      event_type: 'WorkflowExecutionStarted',
+      attributes: double(:attributes,
+        task_list: task_list,
+        input: workflow_started_input.to_json
+      )
+    )
+  }
+
+  describe '#workflow_started_event' do
+    it 'raises FeatureMatrix::Workflows::MissingWorkflowStartedEvent if there is no WorkflowExecutionStartedEvent' do
+      ->{ subject.send(:workflow_started_event) }.should raise_exception(SWF::MissingWorkflowStartedEvent)
+    end
+    it 'otherwise returns the workflow started event' do
+      subject.decision_task.stub(:events){ [ workflow_started_event] }
+      subject.send(:workflow_started_event).should == workflow_started_event
+    end
+  end
+
+    context 'with a workflow_started_event' do
+      before do
+        subject.stub(:workflow_started_event) { workflow_started_event }
+      end
+
+      describe '#workflow_task_list' do
+        it 'returns the task list' do
+          subject.send(:workflow_task_list).should == workflow_started_event.attributes.task_list
+        end
+      end
+      describe '#workflow_input' do
+        it 'returns the workflow input as a hash' do
+          subject.send(:workflow_input).should == workflow_started_input
+        end
+      end
+    end
+
+
+  describe '.fail!' do
+    it 'fails the workflow execution' do
+      task = double(:task).tap {|o| o.should_receive(:fail_workflow_execution).with(:args_placeholder) }
+      subject_class.fail! task, :args_placeholder
+    end
+  end
+
+  describe '.configuration_help_message' do
+    it { subject_class.configuration_help_message.should be_is_a String }
+    it { subject_class.configuration_help_message.length.should > 100 }
+    it { subject_class.configuration_help_message.should include 'decision' }
+  end
+
+end