aws-flow 1.3.0 → 2.0.0

data/spec/aws/decider/unit/retry_spec.rb

@@ -0,0 +1,217 @@
+require_relative 'setup'
+
+$error = "--- !ruby/exception:ArgumentError\nmessage: asdfasdf\n---\n- helloworld_activity.rb:21:in `say_hello'\n- /home/paritom/.rvm/gems/ruby-1.9.3-p429/gems/aws-flow-1.2.0/lib/aws/decider/activity_definition.rb:69:in\n  `execute'\n- /home/paritom/.rvm/gems/ruby-1.9.3-p429/gems/aws-flow-1.2.0/lib/aws/decider/task_poller.rb:144:in\n  `execute'\n- /home/paritom/.rvm/gems/ruby-1.9.3-p429/gems/aws-flow-1.2.0/lib/aws/decider/task_poller.rb:287:in\n  `process_single_task'\n- /home/paritom/.rvm/gems/ruby-1.9.3-p429/gems/aws-flow-1.2.0/lib/aws/decider/task_poller.rb:344:in\n  `block in poll_and_process_single_task'\n- /home/paritom/.rvm/gems/ruby-1.9.3-p429/gems/aws-flow-1.2.0/lib/aws/decider/executor.rb:75:in\n  `call'\n- /home/paritom/.rvm/gems/ruby-1.9.3-p429/gems/aws-flow-1.2.0/lib/aws/decider/executor.rb:75:in\n  `block in execute'\n- /home/paritom/.rvm/gems/ruby-1.9.3-p429/gems/aws-flow-1.2.0/lib/aws/decider/executor.rb:68:in\n  `fork'\n- /home/paritom/.rvm/gems/ruby-1.9.3-p429/gems/aws-flow-1.2.0/lib/aws/decider/executor.rb:68:in\n  `execute'\n- /home/paritom/.rvm/gems/ruby-1.9.3-p429/gems/aws-flow-1.2.0/lib/aws/decider/task_poller.rb:344:in\n  `poll_and_process_single_task'\n- /home/paritom/.rvm/gems/ruby-1.9.3-p429/gems/aws-flow-1.2.0/lib/aws/decider/worker.rb:439:in\n  `run_once'\n- /home/paritom/.rvm/gems/ruby-1.9.3-p429/gems/aws-flow-1.2.0/lib/aws/decider/worker.rb:412:in\n  `block in start'\n- /home/paritom/.rvm/gems/ruby-1.9.3-p429/gems/aws-flow-1.2.0/lib/aws/decider/worker.rb:411:in\n  `loop'\n- /home/paritom/.rvm/gems/ruby-1.9.3-p429/gems/aws-flow-1.2.0/lib/aws/decider/worker.rb:411:in\n  `start'\n- helloworld_activity.rb:27:in `<main>'\n"
+
+def get_history_array 
+  [
+    "WorkflowExecutionStarted",
+    "DecisionTaskScheduled",
+    "DecisionTaskStarted",
+    "DecisionTaskCompleted",
+    ["ActivityTaskScheduled", {activity_id: "Activity1"}],
+    "ActivityTaskStarted",
+    ["ActivityTaskFailed", {scheduled_event_id: 5, :activity_id => "Activity1", cause: AWS::Flow::ActivityFailureException, details: $error } ],
+    "DecisionTaskScheduled",
+    "DecisionTaskStarted",
+  ]
+end
+
+
+describe "ExponentialRetry" do
+
+  context "ActivityRetry" do
+    # The following tests for github issue # 57
+    before(:all) do
+      class RetryTestActivity
+        extend AWS::Flow::Activities
+        activity :retryable do
+          {
+            :version => "1.0",
+            :default_task_list => 'default',
+            :default_task_schedule_to_start_timeout => 20,
+            :default_task_start_to_close_timeout => 20,
+            :exponential_retry => {
+              :maximum_attempts => 3,
+              :retry_expiration_interval_seconds => 10,
+              :backoff_coefficient => 4,
+              :should_jitter => false
+            },
+          }
+        end
+        def retryable
+          raise ArgumentError.new("TEST SIMULATION")
+        end
+      end
+
+      class RetryTestWorkflow
+        extend AWS::Flow::Workflows
+        workflow(:start) { { version: "1.0" } }
+        activity_client(:client) { { from_class: "RetryTestActivity" } }
+        def start
+          client.retryable
+        end
+      end
+    end
+
+    
+    it "tests part 1 - timer gets scheduled after activity fails" do
+
+      class SynchronousWorkflowTaskPoller < WorkflowTaskPoller
+        def get_decision_task
+          fake_workflow_type =  FakeWorkflowType.new(nil, "RetryTestWorkflow.start", "1.0")
+          TestHistoryWrapper.new(fake_workflow_type, FakeWorkflowExecution.new(nil, nil), FakeEvents.new(get_history_array))
+        end
+      end
+
+      workflow_type_object = FakeWorkflowType.new(nil, "RetryTestWorkflow.start", "1.0")
+      domain = FakeDomain.new(workflow_type_object)
+
+      swf_client = FakeServiceClient.new
+      task_list = "default"
+      my_workflow_factory = workflow_factory(swf_client, domain) do |options|
+        options.workflow_name = "RetryTestWorkflow"
+        options.execution_start_to_close_timeout = 120
+        options.task_list = "default"
+        options.task_start_to_close_timeout = 30
+      end
+
+      worker = SynchronousWorkflowWorker.new(swf_client, domain, task_list, RetryTestWorkflow)
+      my_workflow = my_workflow_factory.get_client
+      workflow_execution = my_workflow.start_execution
+      worker.start
+      swf_client.trace.first[:decisions].first[:decision_type].should == "StartTimer"
+      swf_client.trace.first[:decisions].first[:start_timer_decision_attributes].should == {:timer_id=>"Timer1", :start_to_fire_timeout=>"2"}
+    end
+
+    it "tests part 2 - activity gets retried the first time after timer fires" do
+
+      class SynchronousWorkflowTaskPoller < WorkflowTaskPoller
+        def get_decision_task
+          fake_workflow_type =  FakeWorkflowType.new(nil, "RetryTestWorkflow.start", "1.0")
+          TestHistoryWrapper.new(fake_workflow_type, FakeWorkflowExecution.new(nil, nil),
+                                 FakeEvents.new(get_history_array().push(*[
+                                   "DecisionTaskCompleted",
+                                   ["TimerStarted", {decision_task_completed_event_id: 10, timer_id: "Timer1", start_to_fire_timeout: 2 }],
+                                   ["TimerFired", {timer_id: "Timer1", started_event_id: 11}],
+                                   "DecisionTaskScheduled",
+                                   "DecisionTaskStarted",
+          ])))
+        end
+      end
+
+      workflow_type_object = FakeWorkflowType.new(nil, "RetryTestWorkflow.start", "1.0")
+      domain = FakeDomain.new(workflow_type_object)
+
+      swf_client = FakeServiceClient.new
+      task_list = "default"
+      my_workflow_factory = workflow_factory(swf_client, domain) do |options|
+        options.workflow_name = "RetryTestWorkflow"
+        options.execution_start_to_close_timeout = 120
+        options.task_list = "default"
+        options.task_start_to_close_timeout = 30
+      end
+
+      worker = SynchronousWorkflowWorker.new(swf_client, domain, task_list, RetryTestWorkflow)
+      my_workflow = my_workflow_factory.get_client
+      workflow_execution = my_workflow.start_execution
+      worker.start
+      swf_client.trace.first[:decisions].first[:decision_type].should == "ScheduleActivityTask"
+      swf_client.trace.first[:decisions].first[:schedule_activity_task_decision_attributes][:activity_id] == "Activity2"
+    end
+
+    it "tests part 3 - timer gets scheduled for retry after activity fails again" do
+
+      class SynchronousWorkflowTaskPoller < WorkflowTaskPoller
+        def get_decision_task
+          fake_workflow_type =  FakeWorkflowType.new(nil, "RetryTestWorkflow.start", "1.0")
+          TestHistoryWrapper.new(fake_workflow_type, FakeWorkflowExecution.new(nil, nil),
+                                 FakeEvents.new(get_history_array().push(*[
+                                   "DecisionTaskCompleted",
+                                   ["TimerStarted", {decision_task_completed_event_id: 10, timer_id: "Timer1", start_to_fire_timeout: 2 }],
+                                   ["TimerFired", {timer_id: "Timer1", started_event_id: 11}],
+                                   "DecisionTaskScheduled",
+                                   "DecisionTaskStarted",
+                                   "DecisionTaskCompleted",
+                                   ["ActivityTaskScheduled", {activity_id: "Activity2"}],
+                                   "ActivityTaskStarted",
+                                   ["ActivityTaskFailed", {scheduled_event_id: 16, :activity_id => "Activity2", cause: ActivityTaskFailedException, details: $error} ],
+                                   "DecisionTaskScheduled",
+                                   "DecisionTaskStarted",
+          ])))
+        end
+      end
+
+      workflow_type_object = FakeWorkflowType.new(nil, "RetryTestWorkflow.start", "1.0")
+      domain = FakeDomain.new(workflow_type_object)
+
+      swf_client = FakeServiceClient.new
+      task_list = "default"
+      my_workflow_factory = workflow_factory(swf_client, domain) do |options|
+        options.workflow_name = "RetryTestWorkflow"
+        options.execution_start_to_close_timeout = 120
+        options.task_list = "default"
+        options.task_start_to_close_timeout = 30
+      end
+
+      worker = SynchronousWorkflowWorker.new(swf_client, domain, task_list, RetryTestWorkflow)
+      my_workflow = my_workflow_factory.get_client
+      workflow_execution = my_workflow.start_execution
+      worker.start
+      swf_client.trace.first[:decisions].first[:decision_type].should == "StartTimer"
+      swf_client.trace.first[:decisions].first[:start_timer_decision_attributes].should == {:timer_id=>"Timer2", :start_to_fire_timeout=>"8"}
+    end
+
+    it "tests part 4 - the workflow fails because retry_expiration_interval_seconds is breached by exponential retry" do
+
+      class SynchronousWorkflowTaskPoller < WorkflowTaskPoller
+        def get_decision_task
+          fake_workflow_type =  FakeWorkflowType.new(nil, "RetryTestWorkflow.start", "1.0")
+          TestHistoryWrapper.new(fake_workflow_type, FakeWorkflowExecution.new(nil, nil),
+                                 FakeEvents.new(get_history_array().push(*[
+                                   "DecisionTaskCompleted",
+                                   ["TimerStarted", {decision_task_completed_event_id: 10, timer_id: "Timer1", start_to_fire_timeout: 2 }],
+                                   ["TimerFired", {timer_id: "Timer1", started_event_id: 11}],
+                                   "DecisionTaskScheduled",
+                                   "DecisionTaskStarted",
+                                   "DecisionTaskCompleted",
+                                   ["ActivityTaskScheduled", {activity_id: "Activity2"}],
+                                   "ActivityTaskStarted",
+                                   ["ActivityTaskFailed", {scheduled_event_id: 16, :activity_id => "Activity2", cause: AWS::Flow::ActivityFailureException, details: $error } ],
+                                   "DecisionTaskScheduled",
+                                   "DecisionTaskStarted",
+                                   "DecisionTaskCompleted",
+                                   ["TimerStarted", {decision_task_completed_event_id: 21, timer_id: "Timer2", start_to_fire_timeout: 8 }],
+                                   ["TimerFired", {timer_id: "Timer2", started_event_id: 22}],
+                                   "DecisionTaskScheduled",
+                                   "DecisionTaskStarted",
+                                   "DecisionTaskCompleted",
+                                   ["ActivityTaskScheduled", {activity_id: "Activity3"}],
+                                   "ActivityTaskStarted",
+                                   ["ActivityTaskFailed", {scheduled_event_id: 27, :activity_id => "Activity3", cause: ActivityTaskFailedException, details: $error } ],
+                                   "DecisionTaskScheduled",
+                                   "DecisionTaskStarted",
+          ])))
+        end
+      end
+
+      workflow_type_object = FakeWorkflowType.new(nil, "RetryTestWorkflow.start", "1.0")
+      domain = FakeDomain.new(workflow_type_object)
+
+      swf_client = FakeServiceClient.new
+      task_list = "default"
+      my_workflow_factory = workflow_factory(swf_client, domain) do |options|
+        options.workflow_name = "RetryTestWorkflow"
+        options.execution_start_to_close_timeout = 120
+        options.task_list = "default"
+        options.task_start_to_close_timeout = 30
+      end
+
+      worker = SynchronousWorkflowWorker.new(swf_client, domain, task_list, RetryTestWorkflow)
+      my_workflow = my_workflow_factory.get_client
+      workflow_execution = my_workflow.start_execution
+      worker.start
+      swf_client.trace.first[:decisions].first[:decision_type].should == "FailWorkflowExecution"
+      swf_client.trace.first[:decisions].first[:fail_workflow_execution_decision_attributes][:details].should =~ /ArgumentError/
+    end
+  end
+end

data/spec/aws/decider/unit/setup.rb

@@ -0,0 +1,3 @@
+require 'spec_helper'
+
+include Test::Unit

data/spec/aws/decider/unit/worker_spec.rb

@@ -0,0 +1,325 @@
+require_relative 'setup'
+
+class TestWorkflow
+  extend Workflows
+  workflow :start do
+    {
+      :default_execution_start_to_close_timeout => 30, :version => "1"
+    }
+  end
+  def start; end
+end
+
+class TestActivity
+  extend Activity
+
+  activity :run_activity1 do |o|
+    o.default_task_heartbeat_timeout = "3600"
+    o.default_task_list = "activity_task_list"
+    o.default_task_schedule_to_close_timeout = "3600"
+    o.default_task_schedule_to_start_timeout = "3600"
+    o.default_task_start_to_close_timeout = "3600"
+    o.version = "1"
+  end
+  def run_activity1
+    "first regular activity"
+  end
+  def run_activity2
+    "second regular activity"
+  end
+end
+
+class TestActivityWorker < ActivityWorker
+
+  attr_accessor :executor
+  def initialize(service, domain, task_list, forking_executor, *args, &block)
+    super(service, domain, task_list, *args, &block)
+    @executor = forking_executor
+  end
+end
+
+class FakeTaskPoller < WorkflowTaskPoller
+  def get_decision_task
+    nil
+  end
+end
+def dumb_fib(n)
+  n < 1 ? 1 : dumb_fib(n - 1) + dumb_fib(n - 2)
+end
+
+describe GenericWorker do
+  context "#resolve_default_task_list" do
+    worker = GenericWorker.new(nil, nil, "worker_task_list")
+    worker.resolve_default_task_list("USE_WORKER_TASK_LIST").should == "worker_task_list"
+    worker.resolve_default_task_list("passed_in_task_list").should == "passed_in_task_list"
+  end
+end
+
+describe WorkflowWorker do
+  context "#register" do
+    it "ensures that worker uses the right task list to register type" do
+      class DefaultTasklistTestWorkflow
+        extend Workflows
+        workflow :workflow do
+          {
+            version: "1.0",
+            default_task_list: "USE_WORKER_TASK_LIST"
+          }
+        end
+        workflow :workflow2 do
+          {
+            version: "1.0",
+            default_task_list: "my_own_task_list"
+          }
+        end
+        workflow :workflow3 do
+          {
+            version: "1.0",
+          }
+        end
+      end
+      workflow_options = {
+        default_task_start_to_close_timeout: "30",
+        default_child_policy: "TERMINATE",
+        domain: "UnitTestDomain",
+        name: "DefaultTasklistTestWorkflow.workflow",
+        version: "1.0",
+        default_task_list: {
+          name: "task_list"
+        }
+      }
+      workflow2_options = {
+        default_task_start_to_close_timeout: "30",
+        default_child_policy: "TERMINATE",
+        domain: "UnitTestDomain",
+        name: "DefaultTasklistTestWorkflow.workflow2",
+        version: "1.0",
+        default_task_list: {
+          name: "my_own_task_list"
+        }
+      }
+      workflow3_options = {
+        default_task_start_to_close_timeout: "30",
+        default_child_policy: "TERMINATE",
+        domain: "UnitTestDomain",
+        name: "DefaultTasklistTestWorkflow.workflow3",
+        version: "1.0",
+        default_task_list: {
+          name: "task_list"
+        }
+      }
+      expect_any_instance_of(AWS::SimpleWorkflow::Client::V20120125).to receive(:register_workflow_type).with(workflow_options)
+      expect_any_instance_of(AWS::SimpleWorkflow::Client::V20120125).to receive(:register_workflow_type).with(workflow2_options)
+      expect_any_instance_of(AWS::SimpleWorkflow::Client::V20120125).to receive(:register_workflow_type).with(workflow3_options)
+
+      worker = AWS::Flow::WorkflowWorker.new(
+        AWS::SimpleWorkflow.new.client,
+        AWS::SimpleWorkflow::Domain.new("UnitTestDomain"),
+        "task_list",
+        DefaultTasklistTestWorkflow
+      )
+
+      worker.register
+    end
+  end
+
+  it "will test whether WorkflowWorker shuts down cleanly when an interrupt is received" do
+    task_list = "TestWorkflow_tasklist"
+    service = FakeServiceClient.new
+    workflow_type_object = double("workflow_type", :name => "TestWorkflow.start", :start_execution => "" )
+    domain = FakeDomain.new(workflow_type_object)
+    workflow_worker = WorkflowWorker.new(service, domain, task_list)
+    workflow_worker.add_workflow_implementation(TestWorkflow)
+    pid = fork do
+      loop do
+        workflow_worker.run_once(true, FakeTaskPoller.new(service, domain, nil, task_list, nil))
+      end
+    end
+    # Send an interrupt to the child process
+    Process.kill("INT", pid)
+    # Adding a sleep to let things get setup correctly (not ideal but going with
+    # this for now)
+    sleep 5
+    return_pid, status = Process.wait2(pid, Process::WNOHANG)
+    Process.kill("KILL", pid) if return_pid.nil?
+    return_pid.should_not be nil
+    status.success?.should be_true
+  end
+
+  it "will test whether WorkflowWorker dies cleanly when two interrupts are received" do
+    class FakeTaskPoller
+      def poll_and_process_single_task
+        dumb_fib(5000)
+      end
+    end
+    task_list = "TestWorkflow_tasklist"
+    service = FakeServiceClient.new
+    workflow_type_object = double("workflow_type", :name => "TestWorkflow.start", :start_execution => "" )
+    domain = FakeDomain.new(workflow_type_object)
+    workflow_worker = WorkflowWorker.new(service, domain, task_list)
+    workflow_worker.add_workflow_implementation(TestWorkflow)
+    pid = fork do
+      loop do
+        workflow_worker.run_once(true, FakeTaskPoller.new(service, domain, nil, task_list, nil))
+      end
+    end
+    # Send an interrupt to the child process
+    sleep 3
+    2.times { Process.kill("INT", pid); sleep 2 }
+    return_pid, status = Process.wait2(pid, Process::WNOHANG)
+
+    Process.kill("KILL", pid) if return_pid.nil?
+    return_pid.should_not be nil
+    status.success?.should be_false
+  end
+
+end
+
+describe ActivityWorker do
+
+  context "#register" do
+    it "ensures that worker uses the right task list to register type" do
+      class DefaultTasklistTestActivity
+        extend Activities
+        activity :activity do
+          {
+            version: "1.0",
+            default_task_list: "USE_WORKER_TASK_LIST"
+          }
+        end
+        activity :activity2 do
+          {
+            version: "1.0",
+            default_task_list: "my_own_task_list"
+          }
+        end
+        activity :activity3 do
+          {
+            version: "1.0"
+          }
+        end
+      end
+      activity_options = {
+        domain: "UnitTestDomain",
+        name: "DefaultTasklistTestActivity.activity",
+        version: "1.0",
+        default_task_heartbeat_timeout: "NONE",
+        default_task_schedule_to_close_timeout: "NONE",
+        default_task_schedule_to_start_timeout: "NONE",
+        default_task_start_to_close_timeout: "NONE",
+        default_task_list: {
+          name: "task_list"
+        }
+      }
+
+      activity2_options = {
+        domain: "UnitTestDomain",
+        name: "DefaultTasklistTestActivity.activity2",
+        version: "1.0",
+        default_task_heartbeat_timeout: "NONE",
+        default_task_schedule_to_close_timeout: "NONE",
+        default_task_schedule_to_start_timeout: "NONE",
+        default_task_start_to_close_timeout: "NONE",
+        default_task_list: {
+          name: "my_own_task_list"
+        }
+      }
+
+      activity3_options = {
+        domain: "UnitTestDomain",
+        name: "DefaultTasklistTestActivity.activity3",
+        version: "1.0",
+        default_task_heartbeat_timeout: "NONE",
+        default_task_schedule_to_close_timeout: "NONE",
+        default_task_schedule_to_start_timeout: "NONE",
+        default_task_start_to_close_timeout: "NONE",
+        default_task_list: {
+          name: "task_list"
+        }
+      }
+
+      expect_any_instance_of(AWS::SimpleWorkflow::Client::V20120125).to receive(:register_activity_type).with(activity_options)
+      expect_any_instance_of(AWS::SimpleWorkflow::Client::V20120125).to receive(:register_activity_type).with(activity2_options)
+      expect_any_instance_of(AWS::SimpleWorkflow::Client::V20120125).to receive(:register_activity_type).with(activity3_options)
+
+      worker = AWS::Flow::ActivityWorker.new(
+        AWS::SimpleWorkflow.new.client,
+        AWS::SimpleWorkflow::Domain.new("UnitTestDomain"),
+        "task_list",
+        DefaultTasklistTestActivity
+      )
+
+      worker.register
+    end
+  end
+
+  class FakeDomain
+    def activity_tasks
+      sleep 30
+    end
+  end
+  it "will test whether the ActivityWorker shuts down cleanly when an interrupt is received" do
+
+    task_list = "TestWorkflow_tasklist"
+    service = FakeServiceClient.new
+    workflow_type_object = double("workflow_type", :name => "TestWorkflow.start", :start_execution => "" )
+    domain = FakeDomain.new(workflow_type_object)
+    forking_executor = ForkingExecutor.new
+    activity_worker = TestActivityWorker.new(service, domain, task_list, forking_executor) { {:logger => FakeLogger.new} }
+    activity_worker.add_activities_implementation(TestActivity)
+    # Starts the activity worker in a forked process. Also, attaches an at_exit
+    # handler to the process. When the process exits, the handler checks whether
+    # the executor's internal is_shutdown variable is set correctly or not.
+    pid = fork do
+      at_exit {
+        activity_worker.executor.is_shutdown.should == true
+      }
+      activity_worker.start true
+    end
+    # Send an interrupt to the child process
+    Process.kill("INT", pid)
+    # Adding a sleep to let things get setup correctly (not ideal but going with
+    # this for now)
+    sleep 5
+    return_pid, status = Process.wait2(pid, Process::WNOHANG)
+    Process.kill("KILL", pid) if return_pid.nil?
+    return_pid.should_not be nil
+
+    status.success?.should be_true
+  end
+
+  # This method will take a long time to run, allowing us to test our shutdown
+  # scenarios
+
+
+  it "will test whether the ActivityWorker shuts down immediately if two or more interrupts are received" do
+    task_list = "TestWorkflow_tasklist"
+    service = FakeServiceClient.new
+    workflow_type_object = double("workflow_type", :name => "TestWorkflow.start", :start_execution => "" )
+    domain = FakeDomain.new(workflow_type_object)
+    forking_executor = ForkingExecutor.new
+    activity_worker = TestActivityWorker.new(service, domain, task_list, forking_executor) { {:logger => FakeLogger.new} }
+
+    activity_worker.add_activities_implementation(TestActivity)
+    # Starts the activity worker in a forked process. Also, executes a task
+    # using the forking executor of the activity worker. The executor will
+    # create a child process to run that task. The task (dumb_fib) is
+    # purposefully designed to be long running so that we can test our shutdown
+    # scenario.
+    pid = fork do
+      activity_worker.executor.execute {
+        dumb_fib(1000)
+      }
+      activity_worker.start true
+    end
+    # Adding a sleep to let things get setup correctly (not idea but going with
+    # this for now)
+    sleep 3
+    # Send 2 interrupts to the child process
+    2.times { Process.kill("INT", pid); sleep 3 }
+    status = Process.waitall
+    status[0][1].success?.should be_false
+  end
+
+end
+