ntswf 1.0.6 → 1.0.7

data/README.md

@@ -44,7 +44,7 @@ class Decider
 end
 
 config = {domain: 'my_domain', unit: 'my_app'} # ...
-loop { Decider.new(config).process_decision_task }
+Decider.new(config).process_decisions
 ```
 
 ### Activity worker
@@ -62,7 +62,7 @@ class Worker
 end
 
 config = {domain: 'my_domain', unit: 'my_worker'} # ...
-loop { Worker.new(config).process_activity_task }
+Worker.new(config).process_activities
 ```
 
 ### Setup helpers

data/lib/ntswf/activity_worker.rb

@@ -5,6 +5,11 @@ module Ntswf
   module ActivityWorker
     include Ntswf::Worker
 
+    # Start the worker loop for activity tasks.
+    def process_activities
+      loop { in_subprocess :process_activity_task }
+    end
+
     def process_activity_task
       announce("polling for activity task #{activity_task_list}")
       domain.activity_tasks.poll_for_single_task(activity_task_list) do |task|

data/lib/ntswf/base.rb

@@ -9,6 +9,7 @@ module Ntswf
     # @option config [String] :decision_task_list The task list name for decisions
     # @option config [String] :domain The SWF domain name
     # @option config [Numeric] :execution_version Value allowing clients to reject future execution versions
+    # @option config [Numeric] :subprocess_retries (0) see {Worker#in_subprocess}
     # @option config [String] :secret_access_key AWS credential
     # @option config [String] :unit This worker/client's activity task list key
     def initialize(config)
@@ -74,16 +75,16 @@ module Ntswf
       ";"
     end
 
+    def activity_type
+      @activity_type ||= domain.activity_types[activity_name, workflow_version]
+    end
+
     protected
 
     def activity_name
       "#{default_unit}-activity"
     end
 
-    def activity_type
-      @activity_type ||= domain.activity_types[activity_name, workflow_version]
-    end
-
     def announce(s)
       $0 = s
       log(s)

data/lib/ntswf/decision_worker.rb

@@ -5,6 +5,11 @@ module Ntswf
   module DecisionWorker
     include Ntswf::Worker
 
+    # Start the worker loop for decision tasks.
+    def process_decisions
+      loop { in_subprocess :process_decision_task }
+    end
+
     # Process a decision task.
     # The following task values are interpreted:
     # input:: see {Ntswf::Client#start_execution}

data/lib/ntswf/worker.rb

@@ -6,5 +6,33 @@ module Ntswf
 
     # *reason* value to force task reschedule, may be set if the worker is unable process the task
     RETRY = "Retry"
+
+    # Run a method in a separate thread.
+    # This will ensure the call lives on if the master process is terminated.
+    # If the *:subprocess_retries* configuration is set {StandardError}s during the
+    # method call will be retried accordingly.
+    def in_subprocess(method)
+      $stdout.sync = true
+      if child = fork
+        srand
+        now = Time.now
+        announce("#{method}: forked #{child} at #{now} (#{now.to_i})")
+        Process.wait(child)
+      else
+        with_retry(@config.subprocess_retries || 0) { send method }
+        exit!
+      end
+    end
+
+    protected
+
+    def with_retry(allowed_failures)
+      yield
+    rescue StandardError => e
+      raise if allowed_failures.zero?
+      allowed_failures -= 1
+      log("retrying. exception raised: #{e.message}\n  #{e.backtrace.join("\n  ")}")
+      retry
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ntswf
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 1.0.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-23 00:00:00.000000000 Z
+date: 2014-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -58,8 +58,6 @@ files:
 - lib/ntswf/client.rb
 - lib/ntswf/base.rb
 - lib/ntswf.rb
-- spec/decision_worker_spec.rb
-- spec/activity_worker_spec.rb
 homepage: https://github.com/infopark/ntswf
 licenses:
 - LGPLv3
@@ -85,7 +83,5 @@ rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Not That Simple Workflow
-test_files:
-- spec/decision_worker_spec.rb
-- spec/activity_worker_spec.rb
+test_files: []
 has_rdoc: 

data/spec/activity_worker_spec.rb

@@ -1,26 +0,0 @@
-require "ntswf"
-
-describe Ntswf::ActivityWorker do
-  class Worker
-    include Ntswf::ActivityWorker
-  end
-
-  before { Worker.any_instance.stub(announce: nil, log: nil) }
-
-  let(:config) { { unit: "test", activity_task_lists: { "test" => "task_list" } } }
-  let(:worker) { Worker.new config }
-  let(:activity_task) { mock input: "{}" }
-
-  describe "processing an activity task" do
-    before do
-      AWS::SimpleWorkflow::ActivityTaskCollection.any_instance.stub(:poll_for_single_task).
-          and_yield activity_task
-    end
-
-    context "given foreign activity type" do
-      before { activity_task.stub activity_type: :some_random_thing }
-      subject { worker.process_activity_task { :accepted } }
-      it { should eq :accepted }
-    end
-  end
-end

data/spec/decision_worker_spec.rb

@@ -1,214 +0,0 @@
-require "ntswf"
-require "json"
-
-describe Ntswf::DecisionWorker do
-  class Worker
-    include Ntswf::DecisionWorker
-  end
-
-  let(:atl_config) { { "test" => "atl" } }
-  let(:dtl_config) { "dtl" }
-  let(:unit) { "testt" }
-  let(:config) { { unit: unit, decision_task_list: dtl_config, activity_task_lists: atl_config } }
-  let(:worker) { Worker.new config }
-
-  let(:options) { {} }
-  let(:input) { options.merge('params' => {'test' => 'value'}).to_json }
-  let(:reason) { nil }
-  let(:result) { nil }
-  let(:attributes_hash) { { input: input, reason: reason, result: result } }
-  let(:attributes) { double("Attributes", attributes_hash.merge(to_h: attributes_hash)) }
-  let(:workflow_execution) { double("Workflow Execution", workflow_type: double(name: 'test-wf')) }
-  let(:event) do
-    double("Event", attributes: attributes, event_type: event_type, workflow_execution:
-        workflow_execution)
-  end
-  let(:task) { double("Task", new_events: [event], events: [event]).as_null_object }
-
-  before { worker.stub(announce: nil, log: nil, activity_type: "test_activity") }
-
-  describe "processing a decision task" do
-    it "should only query for the configured task list" do
-      AWS::SimpleWorkflow::DecisionTaskCollection.any_instance.
-          should_receive(:poll_for_single_task).with("dtl")
-      worker.process_decision_task
-    end
-
-    describe "handling event" do
-      before do
-        AWS::SimpleWorkflow::DecisionTaskCollection.any_instance.stub(
-            :poll_for_single_task).and_yield(task)
-      end
-
-      describe "ActivityTaskTimedOut" do
-        let(:event_type) {"ActivityTaskTimedOut"}
-
-        it "should cancel the execution" do
-          task.should_receive :cancel_workflow_execution
-          worker.process_decision_task
-        end
-
-        it "should notify" do
-          worker.should_receive :notify
-          worker.process_decision_task
-        end
-      end
-
-      describe "ActivityTaskCompleted" do
-        let(:event_type) {"ActivityTaskCompleted"}
-
-        context "when requesting re-execution per seconds_until_retry" do
-          let(:result) { {seconds_until_retry: 321}.to_json }
-
-          it "schedules a timer event" do
-            task.should_receive(:start_timer).with(321)
-            worker.process_decision_task
-          end
-        end
-
-        context "when not requesting re-execution" do
-          let(:result) { {outcome: "some_data"}.to_json }
-
-          it "schedules a workflow completed event" do
-            task.should_receive(:complete_workflow_execution).with(result: result)
-            worker.process_decision_task
-          end
-        end
-      end
-
-      describe "WorkflowExecutionStarted" do
-        let(:event_type) {"WorkflowExecutionStarted"}
-
-        it "should schedule an activity task avoiding defaults" do
-          task.should_receive(:schedule_activity_task).with("test_activity", hash_including(
-            heartbeat_timeout: :none,
-            input: anything,
-            schedule_to_close_timeout: anything,
-            schedule_to_start_timeout: anything,
-            start_to_close_timeout: anything,
-            task_list: "atl",
-          ))
-          worker.process_decision_task
-        end
-
-        context "given no app in charge" do
-          let(:input) { ["legacy_stuff", {}].to_json }
-
-          it "should schedule an activity task for a guessed task list" do
-            task.should_receive(:schedule_activity_task).with("test_activity", hash_including(
-                task_list: "atl"))
-            worker.process_decision_task
-          end
-        end
-      end
-
-      describe "ActivityTaskFailed" do
-        let(:event_type) {"ActivityTaskFailed"}
-
-        context "without retry" do
-          let(:reason) { "Error" }
-
-          it "should fail" do
-            task.should_receive(:fail_workflow_execution)
-            worker.process_decision_task
-          end
-
-          it "should not re-schedule the task" do
-            task.should_not_receive(:schedule_activity_task)
-            worker.process_decision_task
-          end
-        end
-
-        context "with retry" do
-          let(:reason) { "Retry" }
-
-          it "should not fail" do
-            task.should_not_receive(:fail_workflow_execution)
-            worker.process_decision_task
-          end
-
-          it "should re-schedule the task" do
-            task.should_receive(:schedule_activity_task).with("test_activity", hash_including(
-              heartbeat_timeout: :none,
-              input: input,
-              schedule_to_close_timeout: anything,
-              schedule_to_start_timeout: anything,
-              start_to_close_timeout: anything,
-              task_list: "atl",
-            ))
-            worker.process_decision_task
-          end
-        end
-      end
-
-      describe "TimerFired" do
-        let(:event_type) {"TimerFired"}
-        let(:attributes_hash) do
-          {
-            child_policy: 1,
-            execution_start_to_close_timeout: 2,
-            input: input,
-            tag_list: ["tag"],
-            task_list: "list",
-            task_start_to_close_timeout: 3,
-          }
-        end
-
-        context "given an interval option" do
-          let(:options) { {interval: 1234} }
-
-          it "should continue wiht mandatory attributes" do
-            task.should_receive(:continue_as_new_workflow_execution).with(hash_including(
-                attributes_hash))
-            worker.process_decision_task
-          end
-        end
-
-        context "given no interval" do
-          it "should re-schedule, assuming seconds_until_retry was set" do
-            task.should_receive(:schedule_activity_task).with("test_activity", hash_including(
-              heartbeat_timeout: :none,
-              input: input,
-              schedule_to_close_timeout: anything,
-              schedule_to_start_timeout: anything,
-              start_to_close_timeout: anything,
-              task_list: "atl",
-            ))
-            worker.process_decision_task
-          end
-        end
-      end
-
-      context "given an interval" do
-        let(:options) { {interval: 1234} }
-
-        events = %w(
-          ActivityTaskCompleted
-          ActivityTaskFailed
-          ActivityTaskTimedOut
-        )
-
-        events.each do |event|
-          describe event do
-            let(:event_type) { event }
-
-            it "should start a timer" do
-              task.should_receive(:start_timer).with(1234)
-              worker.process_decision_task
-            end
-          end
-        end
-
-        describe "string options for compatibility" do
-          let(:event_type) { "ActivityTaskCompleted" }
-          let(:input) { ["interval", {}].to_json }
-
-          it "should not be interpreted" do
-            task.should_not_receive :start_timer
-            worker.process_decision_task
-          end
-        end
-      end
-    end
-  end
-end