aws-flow 2.1.0 → 2.2.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YzZjOTA1Y2MzMjE0MTg0N2I2ZjAwMjQ0ZjY0NDBhNGQ1YjhjMTA1NQ==
+    ZmU2NjA0NjgwNTFlYTY1N2IzNDYzNGI3Y2RkYWRlOWQyZjdmYTM1ZA==
   data.tar.gz: !binary |-
-    MzI3ZjhmNTE4ZTZhNWFkOTc2NGFiYTgxYjhlN2JiMDNmYWIwYmUwYw==
+    ZTNkYzFmOWQwNzA3MzE1YzkyYjJiZGQwZTFiYjhmZDU2MjRjMTA2Nw==
 SHA512:
   metadata.gz: !binary |-
-    Mzc5NDdjMzcyMGZlNmZmODQ1YTMxYzU5ZTU2MjVhZDZhZjcyMWZmZjMzZDU0
-    ODgyNmU3ZjdlZDk5MDc1MWYyMDVlY2IzZjk4NGFlN2Q2NDkwYTI1YjAxOWFl
-    M2Q0NDQ3MDI3NTkyNzZiNTZiNGM5ZDYwNGZiMDM2MDhhMjRlMGQ=
+    NjZiZTRjNTA3MWQ5M2NiZGUyYmJiOTc2MWNlZjUyNjhlMzdmZjc3MmM4NTgw
+    YzE5NmEyM2U3MDdlN2FhODA0MjVkMzljYzY3NGE3YTdjNjNkODcwNjkzMzdh
+    MjZiMGQ5NGNkZWI0NzMyODhhZWYwZDFiMmU2Yjc2MTM5MDYzZWM=
   data.tar.gz: !binary |-
-    Njk4Y2ZkMzUxNGY5ZGI3MjA1NGI2YTQ5N2QwYTBlZDFiMzU3ZWIxZDIxOGZl
-    NjViN2YyZjE3ODgzZjBjMGNhYzA2YjU5MTllODI5ODdiMjFkZjQ4M2QzYTM1
-    NzZhNmFmNTYxM2E2MTMyMTQyOGI5NjY5OTU0N2I0YzBiZGI3N2Q=
+    NThjYjAzMDkxMjYwYTU0OTE2MGJlOWJkZGVmYzE5NDA1YTQ1ZTRkNGMzNzg5
+    ZjVhYTIzMDUwOGQ4NTU1OGIzMDM1NjBlMjkzM2FiYTk4OGRjNzA5NzZlODIx
+    MTkxZGZlZWUwYTNjNWNlN2M0NDc4MWQ3ZGRhN2IyOThkNmEwNDY=

data/lib/aws/decider/task_handler.rb

@@ -21,6 +21,15 @@ module AWS
     # `DecisionTaskHandler` and pass it to {WorkflowTaskPoller} on
     # {WorkflowTaskPoller#initialize construction}.
     class DecisionTaskHandler
+
+      class << self
+        # Factory method to create a DecisionTaskHandler instance given a
+        # workflow class
+        def from_workflow_class workflow_class
+          self.new(WorkflowDefinitionFactory.generate_definition_map(workflow_class))
+        end
+      end
+
       attr_reader :workflow_definition_map
 
       # Creates a new `DecisionTaskHandler`.

data/lib/aws/decider/version.rb

@@ -16,7 +16,7 @@
 module AWS
   module Flow
     def self.version
-      "2.1.0"
+      "2.2.0"
     end
   end
 end

data/lib/aws/decider/worker.rb

@@ -153,26 +153,15 @@ module AWS
         workflow_class.workflows.delete_if do |workflow_type|
           workflow_type.version.nil? || workflow_type.name.nil?
         end
+
+        @workflow_definition_map.merge!(
+          WorkflowDefinitionFactory.generate_definition_map(workflow_class)
+        )
+
         workflow_class.workflows.each do |workflow_type|
-          options = workflow_type.options
-          execution_method = options.execution_method
-          version = workflow_type.version
-          registration_options = options.get_registration_options
-          implementation_options = nil
-          get_state_method = workflow_class.get_state_method
-          signals = workflow_class.signals
-
-          @workflow_definition_map[workflow_type] = WorkflowDefinitionFactory.new(
-            workflow_class,
-            workflow_type,
-            registration_options,
-            options,
-            execution_method,
-            signals,
-            get_state_method
-          )
           # TODO should probably do something like
           # GenericWorkflowWorker#registerWorkflowTypes
+          options = workflow_type.options
           workflow_hash = options.get_options(
             [
               :default_task_start_to_close_timeout,
@@ -181,7 +170,7 @@ module AWS
             ], {
               :domain => @domain.name,
               :name => workflow_type.name,
-              :version => version
+              :version => workflow_type.version
             }
           )
 

data/lib/aws/decider/workflow_definition_factory.rb

@@ -17,6 +17,38 @@ module AWS
   module Flow
 
     class WorkflowDefinitionFactory
+
+      class << self
+        # Method to create a workflow definition map from a workflow class
+        def generate_definition_map(workflow_class)
+
+          unless workflow_class.respond_to?(:workflows)
+            raise ArgumentError.new("workflow_class must extend module AWS::Flow::Workflows")
+          end
+
+          workflow_definition_map = {}
+
+          workflow_class.workflows.each do |workflow_type|
+            options = workflow_type.options
+            execution_method = options.execution_method
+            registration_options = options.get_registration_options
+            get_state_method = workflow_class.get_state_method
+            signals = workflow_class.signals
+
+            workflow_definition_map[workflow_type] = self.new(
+              workflow_class,
+              workflow_type,
+              registration_options,
+              options,
+              execution_method,
+              signals,
+              get_state_method
+            )
+          end
+          workflow_definition_map
+        end
+      end
+
       attr_reader :converter
       def initialize(klass, workflow_type, registration_options, implementation_options, workflow_method, signals, get_state_method)
         @klass = klass

data/lib/aws/replayer.rb

@@ -0,0 +1,158 @@
+module AWS
+  module Flow
+    module Replayer
+
+      # This class is used by the Replayer to fetch the DecisionTask which will
+      # be used by the DecisionTaskHandler. This is an 'abstract' class. We need
+      # to extend it and implement get_history_page and get_execution_info
+      # methods to use it.
+      class DecisionTaskProvider
+
+        # This method fetches the workflow history and wraps all the history events,
+        # workflow type, workflow execution inside a decision task for the
+        # decider to work on
+        def get_decision_task(replay_upto = nil)
+          # Get workflow execution info so that we can populate the workflowType
+          # and execution fields of the DecisionTask.
+          execution_info = get_execution_info
+          events = get_history
+
+          # Truncate history if replay_upto variable is set so that we only
+          # replay the history till the specified event
+          events = truncate_history(events, replay_upto)
+          return nil if events.nil?
+
+          # Generate the hash to instantiate a DecisionTask. We can set
+          # taskToken and nextPageToken to nil since we don't need the values
+          # in the replayer
+          data = {
+            'taskToken' => nil,
+            'workflowExecution' => execution_info["execution"],
+            'workflowType' => execution_info["workflowType"],
+            'events' => events,
+            'nextPageToken' => nil
+          }
+          AWS::SimpleWorkflow::DecisionTask.new(nil, nil, data)
+        end
+
+        # This method truncates the workflow history to the event_id specified
+        # by the replay_upto variable
+        def truncate_history(events, replay_upto = nil)
+          return nil if events.nil? || events.empty?
+
+          # Just return the original array of events if replay_upto is not set
+          # or if the number of events is less than replay_upto
+          return events if replay_upto.nil? || events.last['eventId'] <= replay_upto
+
+          # Select the events whose eventId is lesser than replay_upto
+          truncated = events.select { |event| event['eventId'] <= replay_upto }
+          return nil if truncated.empty?
+          truncated
+        end
+
+        # This method is used to fetch the actual history. Implementing classes
+        # must override this method.
+        def get_history(page_token = nil); end
+
+        # This method is used to fetch the WorkflowExecutionInfo to fill in the
+        # DecisionTask details. Implementing classes must override this method
+        def get_execution_info; end
+
+      end
+
+      # This DecisionTaskProvider loads the decision task directly from the
+      # SimpleWorkflowService
+      class ServiceDecisionTaskProvider < DecisionTaskProvider
+        attr_reader :domain, :execution, :swf
+
+        def initialize(options = {})
+          raise ArgumentError.new("options hash must contain :domain") if options[:domain].nil?
+          raise ArgumentError.new("options hash must contain :execution") if options[:execution].nil?
+          @execution = options[:execution]
+          @domain = options[:domain]
+          @swf = AWS::SimpleWorkflow.new.client
+        end
+
+        def get_history
+          events = []
+          # Get the first page of the workflow history
+          page = get_history_page
+          page["events"].each { |x| events << x }
+
+          # Get the remaining pages of the workflow history
+          until page["nextPageToken"].nil?
+            page = get_history_page(page["nextPageToken"])
+            page["events"].each { |x| events << x }
+          end
+          events
+        end
+
+        # This method calls the service to fetch a page of workflow history
+        def get_history_page(page_token = nil)
+          # generate the request options for the service call. Optionally merge
+          # next_page_token to the hash if the page_token value is not nil.
+          request_opts = {
+            domain: @domain,
+            execution: @execution,
+          }.merge(page_token ? { next_page_token: page_token } : {})
+
+          @swf.get_workflow_execution_history(request_opts)
+        end
+
+        # This method calls the service to get the workflow execution
+        # information
+        def get_execution_info
+          execution = @swf.describe_workflow_execution(
+            domain: @domain,
+            execution: @execution
+          )
+          execution["executionInfo"]
+        end
+
+      end
+
+      # WorkflowReplayer is an AWS Flow Framework utility that is used to
+      # 'replay' a workflow history in the decider against the workflow
+      # implementation. It is a useful debugging tool.
+      #
+      # Usage -
+      #
+      # # Create an instance of the replayer with the required options -
+      #
+      # replayer = AWS::Flow::Replayer::WorkflowReplayer.new(
+      #   domain: '<domain_name>',
+      #   execution: {
+      #     workflow_id: "<workflow_id",
+      #     run_id: "<run_id>"
+      #   },
+      #   workflow_class: WorkflowClass
+      # )
+      #
+      # # Call the replay method (optionally) with the replay_upto event_id number -
+      #
+      # decision = replayer.replay(20)
+      #
+      class WorkflowReplayer
+        attr_reader :task_handler, :task_provider
+
+        def initialize(options)
+          raise ArgumentError.new("You must pass in an options hash") if options.nil?
+          raise ArgumentError.new("options hash must contain :workflow_class") if options[:workflow_class].nil?
+
+          # Create the service decision task helper to fetch and truncate the
+          # history
+          @task_provider = ServiceDecisionTaskProvider.new(options)
+          @task_handler = DecisionTaskHandler.from_workflow_class(options[:workflow_class])
+        end
+
+        # This method performs the actual replay.
+        def replay(replay_upto = nil)
+          task = @task_provider.get_decision_task(replay_upto)
+          @task_handler.handle_decision_task(task) unless task.nil?
+        end
+
+      end
+
+    end
+  end
+end

data/spec/aws/replayer/integration/replayer_spec.rb

@@ -0,0 +1,91 @@
+require "spec_helper"
+include Test::Integ
+
+describe Replayer do
+  before(:all) do
+
+    @swf, @domain = setup_swf("ReplayerTest")
+
+    class ReplayerTestActivity
+      extend Activities
+      activity :activity_a do
+        {
+          version: "1.0"
+        }
+      end
+      def activity_a; end
+    end
+
+    class ReplayerTestWorkflow
+      extend Workflows
+      workflow :small, :large do
+        {
+          version: "1.0",
+          default_execution_start_to_close_timeout: 600
+        }
+      end
+      activity_client(:client) { { from_class: "ReplayerTestActivity" } }
+      def small
+        client.activity_a
+      end
+      def large
+        25.times { client.send_async(:activity_a) }
+        create_timer(1)
+      end
+    end
+
+    class ReplayerIntegTest
+      class << self
+        def run(domain, method)
+          workflow_worker = AWS::Flow::WorkflowWorker.new(domain.client, domain, "replayer_wf_tasklist", ReplayerTestWorkflow)
+          activity_worker = AWS::Flow::ActivityWorker.new(domain.client, domain, "replayer_act_tasklist", ReplayerTestActivity)
+          workflow_worker.register
+          activity_worker.register
+
+          executor = AWS::Flow::ForkingExecutor.new(max_workers: 5)
+          executor.execute { activity_worker.start }
+          executor.execute { workflow_worker.start }
+
+          client = AWS::Flow::workflow_client(domain.client, domain) { { from_class: "ReplayerTestWorkflow" } }
+          execution = client.send(method)
+          wait_for_execution(execution)
+          executor.shutdown(1)
+          execution
+        end
+      end
+    end
+  end
+
+  it "tests a small workflow history as a sanity test" do
+    execution = ReplayerIntegTest.run(@domain, :small)
+    replayer = WorkflowReplayer.new(
+      domain: @domain.name,
+      execution: {
+        workflow_id: execution.workflow_id,
+        run_id: execution.run_id
+      },
+      workflow_class: ReplayerTestWorkflow
+    )
+
+    replayer.replay(32)[:decisions].first[:decision_type].should == "CompleteWorkflowExecution"
+  end
+
+  it "tests a large workflow history to ensure paged histories are loaded correctly" do
+    execution = ReplayerIntegTest.run(@domain, :large)
+    replayer = WorkflowReplayer.new(
+      domain: @domain.name,
+      execution: {
+        workflow_id: execution.workflow_id,
+        run_id: execution.run_id
+      },
+      workflow_class: ReplayerTestWorkflow
+    )
+
+    decisions = replayer.replay(3)
+    decisions = decisions[:decisions].map{ |x| x[:decision_type] }
+    decisions.select { |x| x == "ScheduleActivityTask" }.size.should == 25
+    decisions.select { |x| x == "StartTimer" }.size.should == 1
+
+  end
+
+end

data/spec/aws/replayer/unit/replayer_spec.rb

@@ -0,0 +1,290 @@
+require "spec_helper"
+
+describe Replayer do
+
+  describe DecisionTaskProvider do
+
+    context "#get_decision_task" do
+
+      it "constructs the correct DecisionTask object" do
+        task_provider = DecisionTaskProvider.new
+
+        allow(task_provider).to receive(:get_history).and_return(
+          ["event_1", "event_2", "event_3"]
+        )
+
+        AWS::SimpleWorkflow::HistoryEvent.stub(:new) { |x,y| y }
+
+        allow(task_provider).to receive(:get_execution_info).and_return({
+          'execution' => {
+            'workflowId' => 'workflow_id',
+            'runId' => 'run_id'
+          },
+          'workflowType' => {
+            'name' => 'FooWorkflow',
+            'version' => '1.0'
+          }
+        })
+
+        task = task_provider.get_decision_task
+        (task.is_a? AWS::SimpleWorkflow::DecisionTask).should be_true
+        task.workflow_execution.workflow_id.should == 'workflow_id'
+        task.workflow_execution.run_id.should == 'run_id'
+        task.workflow_type.name.should == 'FooWorkflow'
+        task.workflow_type.version.should == '1.0'
+        task.next_token.should be_nil
+        task.task_token.should be_nil
+        task.events.to_a.should == ["event_1", "event_2", "event_3"]
+
+      end
+
+      it "returns nil if event list is empty" do
+        task_provider = DecisionTaskProvider.new
+        allow(task_provider).to receive(:get_history_page).and_return([])
+        allow(task_provider).to receive(:get_execution_info).and_return({
+          'execution'=> {
+            workflow_id: '',
+            run_id: ''
+          },
+          'nextPageToken'=>'foo'
+        })
+        task = task_provider.get_decision_task
+        task.should be_nil
+      end
+
+      it "truncates history correctly" do
+        task_provider = DecisionTaskProvider.new
+
+        allow(task_provider).to receive(:get_history).and_return(
+          [ { "eventId" => 1 }, { "eventId" => 2 }, { "eventId" => 3 } ]
+        )
+
+        AWS::SimpleWorkflow::HistoryEvent.stub(:new) { |x,y| y }
+
+        allow(task_provider).to receive(:get_execution_info).and_return({
+          'execution' => {
+            'workflowId' => 'workflow_id',
+            'runId' => 'run_id'
+          },
+          'workflowType' => {
+            'name' => 'FooWorkflow',
+            'version' => '1.0'
+          }
+        })
+
+        task = task_provider.get_decision_task(2)
+        task.events.to_a.should == [ { "eventId" => 1 }, { "eventId" => 2 } ]
+
+        task = task_provider.get_decision_task(5)
+        task.events.to_a.should == [ { "eventId" => 1 }, { "eventId" => 2 }, { "eventId" => 3 } ]
+
+        task = task_provider.get_decision_task(0)
+        task.should be_nil
+
+        task = task_provider.get_decision_task(-1)
+        task.should be_nil
+      end
+
+    end
+
+  end
+
+  describe ServiceDecisionTaskProvider do
+
+    context "#get_history" do
+
+      it "concatenates paginated history correctly" do
+        task_provider = ServiceDecisionTaskProvider.new(
+          domain: 'foo',
+          execution: 'bar'
+        )
+
+        allow(task_provider).to receive(:get_history_page).and_return(
+          { 'events' => ["event_1", "event_2", "event_3"], 'nextPageToken' => "foo" },
+        )
+        allow(task_provider).to receive(:get_history_page).with("foo").and_return(
+          { 'events' => ["event_4", "event_5", "event_6"], 'nextPageToken' => nil },
+        )
+
+        history = task_provider.get_history
+        history.should == ["event_1", "event_2", "event_3", "event_4", "event_5", "event_6"]
+
+      end
+
+      it "returns nil if event list is empty" do
+        task_provider = ServiceDecisionTaskProvider.new(
+          domain: 'foo',
+          execution: 'bar'
+        )
+
+        allow(task_provider).to receive(:get_history_page).and_return(
+          {'events'=>[], 'nextPageToken'=>nil}
+        )
+
+        history = task_provider.get_history
+        history.should be_empty
+      end
+
+    end
+
+    context "#get_history_page" do
+
+      it "calls the service with the correct parameters" do
+        expect_any_instance_of(AWS::SimpleWorkflow::Client::V20120125)
+        .to receive(:get_workflow_execution_history).once.with(
+          domain: 'foo',
+          execution: 'bar',
+        )
+        expect_any_instance_of(AWS::SimpleWorkflow::Client::V20120125)
+        .to receive(:get_workflow_execution_history).once.with(
+          domain: 'foo',
+          execution: 'bar',
+          next_page_token: 'next_page'
+        )
+
+        task_provider = ServiceDecisionTaskProvider.new(
+          domain: 'foo',
+          execution: 'bar'
+        )
+
+        task_provider.get_history_page
+        task_provider.get_history_page("next_page")
+      end
+
+    end
+
+    context "#get_execution_info" do
+
+      it "calls the service with the correct parameters" do
+        expect_any_instance_of(AWS::SimpleWorkflow::Client::V20120125)
+        .to receive(:describe_workflow_execution).once.with(
+          domain: 'foo',
+          execution: 'bar',
+        ).and_return( { "executionInfo" => "foo" } )
+
+        task_provider = ServiceDecisionTaskProvider.new(
+          domain: 'foo',
+          execution: 'bar'
+        )
+
+        task_provider.get_execution_info
+      end
+
+    end
+
+  end
+
+  describe WorkflowReplayer do
+
+    context "#initialize" do
+
+      it "initializes WorkflowReplayer with the correct options" do
+        expect{WorkflowReplayer.new(nil)}.to raise_error(ArgumentError)
+        expect{WorkflowReplayer.new({})}.to raise_error(ArgumentError)
+      end
+
+      it "initializes :task_handler correctly" do
+        class ReplayerTestWorkflowClass
+          extend AWS::Flow::Workflows
+          workflow :a, :b, :c do
+            {
+              version: "1.0",
+            }
+          end
+        end
+
+        expect_any_instance_of(AWS::SimpleWorkflow).to receive(:client).and_return(nil)
+        WorkflowDefinitionFactory.stub(:new).and_return("MyWorkflowDefinitionFactory")
+
+        replayer = WorkflowReplayer.new(
+          domain: 'Foo',
+          execution: 'Bar',
+          workflow_class: ReplayerTestWorkflowClass
+        )
+        (replayer.task_handler.is_a? DecisionTaskHandler).should be_true
+
+        definitons = replayer.task_handler.workflow_definition_map.map do |key, value|
+          [key.name, value]
+        end
+        definitons.should == [
+          ["ReplayerTestWorkflowClass.a", "MyWorkflowDefinitionFactory"],
+          ["ReplayerTestWorkflowClass.b", "MyWorkflowDefinitionFactory"],
+          ["ReplayerTestWorkflowClass.c", "MyWorkflowDefinitionFactory"],
+        ]
+
+      end
+
+      it "initializes :task_provider correctly" do
+        expect_any_instance_of(AWS::SimpleWorkflow).to receive(:client).and_return(nil)
+
+        DecisionTaskHandler.stub(:from_workflow_class)
+
+        replayer = WorkflowReplayer.new(
+          domain: 'Foo',
+          execution: 'Bar',
+          workflow_class: ReplayerTestWorkflowClass
+        )
+        (replayer.task_provider.is_a? ServiceDecisionTaskProvider).should be_true
+        replayer.task_provider.domain.should == 'Foo'
+        replayer.task_provider.execution.should == 'Bar'
+        replayer.task_provider.swf.should be_nil
+
+      end
+
+    end
+
+    context "#replay" do
+
+      before(:all) do
+        class ReplayerTestWorkflowClass
+          extend AWS::Flow::Workflows
+          workflow :a do
+            {
+              version: "1.0",
+            }
+          end
+        end
+      end
+
+      it "uses correct logic" do
+        expect_any_instance_of(AWS::SimpleWorkflow).to receive(:client).and_return(nil)
+        expect_any_instance_of(ServiceDecisionTaskProvider).to receive(:get_decision_task).and_return("foo")
+        expect_any_instance_of(DecisionTaskHandler).to receive(:handle_decision_task).with("foo")
+
+        WorkflowDefinitionFactory.stub(:new).and_return("MyWorkflowDefinitionFactory")
+
+        replayer = WorkflowReplayer.new(
+          domain: 'Foo',
+          execution: 'Bar',
+          workflow_class: ReplayerTestWorkflowClass
+        )
+
+        replayer.replay
+      end
+
+      it "can replay multiple times for same execution" do
+        expect_any_instance_of(AWS::SimpleWorkflow).to receive(:client).and_return(nil)
+        expect_any_instance_of(ServiceDecisionTaskProvider).to receive(:get_decision_task).with(nil).and_return("foo")
+        expect_any_instance_of(ServiceDecisionTaskProvider).to receive(:get_decision_task).with(1).and_return("foo")
+        expect_any_instance_of(ServiceDecisionTaskProvider).to receive(:get_decision_task).with(10).and_return("foo")
+        expect_any_instance_of(DecisionTaskHandler).to receive(:handle_decision_task).with("foo").exactly(3).times
+
+        WorkflowDefinitionFactory.stub(:new).and_return("MyWorkflowDefinitionFactory")
+
+        replayer = WorkflowReplayer.new(
+          domain: 'Foo',
+          execution: 'Bar',
+          workflow_class: ReplayerTestWorkflowClass
+        )
+
+        replayer.replay
+        replayer.replay(1)
+        replayer.replay(10)
+
+      end
+
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -16,9 +16,11 @@
 require 'bundler/setup'
 require 'aws/flow'
 require 'aws/decider'
+require 'aws/replayer'
 require 'runner'
 
 include AWS::Flow
+include AWS::Flow::Replayer
 
 def constantize(camel_case_word)
   names = camel_case_word.split('::')
@@ -77,7 +79,7 @@ module Test
       #ForkingExecutor.executors = []
     end
 
-    def setup_swf
+    def setup_swf domain_name=nil
       current_date = Time.now.strftime("%d-%m-%Y")
       file_name = "/tmp/" + current_date
       if File.exists?(file_name)
@@ -89,13 +91,8 @@ module Test
       File.open(file_name, 'w+') {|f| f.write(last_run)}
       current_date = Time.now.strftime("%d-%m-%Y")
       swf = AWS::SimpleWorkflow.new
-      $rubyflow_decider_domain = "rubyflow_#{current_date}-#{last_run}"
-      begin
-        domain = swf.domains.create($rubyflow_decider_domain, "10")
-      rescue AWS::SimpleWorkflow::Errors::DomainAlreadyExistsFault => e
-        domain = swf.domains[$rubyflow_decider_domain]
-      end
-      @swf, @domain = swf, domain
+      $rubyflow_decider_domain = domain_name || "rubyflow_#{current_date}-#{last_run}"
+      domain = setup_domain($rubyflow_decider_domain)
       return swf, domain
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aws-flow
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Michael Steger, Paritosh Mohan, Jacques Thomas
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-30 00:00:00.000000000 Z
+date: 2014-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-v1
@@ -79,6 +79,7 @@ files:
 - lib/aws/flow/implementation.rb
 - lib/aws/flow/simple_dfa.rb
 - lib/aws/flow/tasks.rb
+- lib/aws/replayer.rb
 - lib/aws/runner.rb
 - spec/aws/decider/integration/activity_spec.rb
 - spec/aws/decider/integration/integration_spec.rb
@@ -105,6 +106,8 @@ files:
 - spec/aws/flow/flow_spec.rb
 - spec/aws/flow/future_spec.rb
 - spec/aws/flow/simple_dfa_spec.rb
+- spec/aws/replayer/integration/replayer_spec.rb
+- spec/aws/replayer/unit/replayer_spec.rb
 - spec/aws/runner/integration/runner_integration_spec.rb
 - spec/aws/runner/unit/runner_unit_spec.rb
 - spec/spec_helper.rb