aws-flow 2.4.0 → 3.0.0

data/lib/aws/templates/utilities.rb

@@ -0,0 +1,59 @@
+module AWS
+  module Flow
+    module Templates
+
+      module Utils
+
+        # This method calls the given block. If an UnknownResourceFault is
+        # returned, then it tries to register AWS Flow defaults with the service
+        # and calls the block again.
+        def self.register_on_failure(domain, &block)
+          begin
+            block.call(domain)
+          rescue AWS::SimpleWorkflow::Errors::UnknownResourceFault => e
+            register_defaults(domain)
+            block.call(domain)
+          end
+        end
+
+        # Registers the relevant defaults with the Simple Workflow Service. If
+        # domain name is not provided, it registers the FlowDefault domain
+        # @api private
+        def self.register_defaults(name=nil)
+          name ||= FlowConstants.defaults[:domain]
+          domain = AWS::Flow::Utilities.register_domain(name)
+
+          register_default_workflow(domain)
+          register_default_result_activity(domain)
+        end
+
+        # Registers the default workflow type FlowDefaultWorkflowRuby with the
+        # Simple Workflow Service
+        # @api private
+        def self.register_default_workflow(domain)
+          AWS::Flow::WorkflowWorker.new(
+            domain.client,
+            domain,
+            nil,
+            AWS::Flow::Templates.default_workflow
+          ).register
+        end
+
+        # Registers the default result activity type FlowDefaultResultActivityRuby
+        # with the Simple Workflow Service
+        # @api private
+        def self.register_default_result_activity(domain)
+          worker = AWS::Flow::ActivityWorker.new(
+            domain.client,
+            domain,
+            nil,
+            AWS::Flow::Templates.result_activity
+          ) {{ use_forking: false }}
+          worker.register
+        end
+
+      end
+
+    end
+  end
+end

data/spec/aws/decider/integration/activity_spec.rb

@@ -5,6 +5,7 @@ describe Activities do
     @bucket = ENV['AWS_SWF_BUCKET_NAME']
     ENV['AWS_SWF_BUCKET_NAME'] = nil
     @swf, @domain = setup_swf
+    kill_executors
   end
 
   after(:all) do

data/spec/aws/decider/integration/options_spec.rb

@@ -4,6 +4,7 @@ describe "task_priority" do
 
   before(:all) do
     @swf, @domain = setup_swf
+    kill_executors
   end
 
   context "activities and workflows" do
@@ -117,7 +118,8 @@ describe "task_priority" do
           {
             version: "1.0",
             default_task_priority: 50,
-            default_execution_start_to_close_timeout: 60
+            default_execution_start_to_close_timeout: 60,
+            default_tag_list: ["continue_task_priority_test"]
           }
         end
         def entry_point
@@ -140,6 +142,7 @@ describe "task_priority" do
       execution.status.should == :continued_as_new
       events = execution.events.select { |x| x.event_type == "WorkflowExecutionContinuedAsNew" }
       events.first.attributes.task_priority.should == 50
+      @domain.workflow_executions.tagged("continue_task_priority_test").each { |x| x.terminate }
     end
 
 
@@ -162,13 +165,14 @@ describe "task_priority" do
       execution.status.should == :continued_as_new
       events = execution.events.select { |x| x.event_type == "WorkflowExecutionContinuedAsNew" }
       events.first.attributes.task_priority.should == 100
+      @domain.workflow_executions.tagged("continue_task_priority_test").each { |x| x.terminate }
     end
   end
 
   context "child_workflows" do
 
     it "test whether task priority is overridden for child workflow" do
-      class ChildWorkflowsTestChildWorkflow
+      class ChildWorkflowsTaskPriorityTestChildWorkflow
         extend AWS::Flow::Workflows
         workflow :child do
           {
@@ -181,7 +185,7 @@ describe "task_priority" do
         def child; sleep 1; end
       end
 
-      class ChildWorkflowsTestParentWorkflow
+      class ChildWorkflowsTaskPriorityTestParentWorkflow
         extend AWS::Flow::Workflows
         workflow :parent do
           {
@@ -192,15 +196,14 @@ describe "task_priority" do
         end
         def parent
           domain = get_test_domain
-          client = AWS::Flow::workflow_client(domain.client, domain) { { from_class: "ChildWorkflowsTestChildWorkflow", task_list: "test2" } }
-          client.send_async(:start_execution)
-          client.send_async(:start_execution)
+          client = AWS::Flow::workflow_client(domain.client, domain) { { from_class: "ChildWorkflowsTaskPriorityTestChildWorkflow", task_list: "test2" } }
+          client.start_execution
         end
       end
 
-      parent_client = AWS::Flow::workflow_client(@domain.client, @domain) { { from_class: "ChildWorkflowsTestParentWorkflow" } }
-      @child_worker = WorkflowWorker.new(@domain.client, @domain, "test2", ChildWorkflowsTestChildWorkflow)
-      @parent_worker = WorkflowWorker.new(@domain.client, @domain, "test", ChildWorkflowsTestParentWorkflow)
+      parent_client = AWS::Flow::workflow_client(@domain.client, @domain) { { from_class: "ChildWorkflowsTaskPriorityTestParentWorkflow" } }
+      @child_worker = WorkflowWorker.new(@domain.client, @domain, "test2", ChildWorkflowsTaskPriorityTestChildWorkflow)
+      @parent_worker = WorkflowWorker.new(@domain.client, @domain, "test", ChildWorkflowsTaskPriorityTestParentWorkflow)
       @child_worker.register
       @parent_worker.register
 
@@ -221,4 +224,8 @@ describe "task_priority" do
 
   end
 
+  after(:all) do
+    Test::Integ.kill_executors
+  end
+
 end

data/spec/aws/decider/integration/starter_spec.rb

@@ -54,20 +54,17 @@ describe "AWS::Flow" do
         task_list: "bar",
         version: "2.0",
         tag_list: ['overriden_test'],
-        wait: true,
+        get_result: true,
         domain: @domain.name
       }
 
-      executor = ForkingExecutor.new
-      executor.execute { AWS::Flow::start("StarterTestActivity.foo", {input: "Hello"}, options) }
-
-      executor.shutdown(1)
+      future = AWS::Flow::start("StarterTestActivity.foo", {input: "Hello"}, options)
 
       until @domain.workflow_executions.count.count > 0
         sleep 2
       end
 
-      @domain.workflow_executions.each do |x|
+      @domain.workflow_executions.tagged("overriden_test").each do |x|
         x.execution_start_to_close_timeout.should == 100
         x.workflow_type.name.should == "#{FlowConstants.defaults[:prefix_name]}.#{FlowConstants.defaults[:execution_method]}"
         x.workflow_type.version.should == "#{FlowConstants.defaults[:version]}"
@@ -82,7 +79,7 @@ describe "AWS::Flow" do
         root.should be_kind_of(AWS::Flow::Templates::RootTemplate)
         root.result_step.should_not be_nil
         result = root.result_step
-        result.should be_kind_of(AWS::Flow::Templates::ActivityTemplate)
+        result.should be_kind_of(AWS::Flow::Templates::ResultActivityTemplate)
 
         activity = root.step
         activity.should be_kind_of(AWS::Flow::Templates::ActivityTemplate)
@@ -100,6 +97,8 @@ describe "AWS::Flow" do
         x.terminate
       end
 
+      Test::Integ.kill_executors
+
     end
 
   end

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

@@ -4,9 +4,9 @@ describe "AWS::Flow" do
 
   context "#start" do
 
-    it "calls AWS::Flow::Templates#start" do
+    it "calls AWS::Flow::Templates::Starter#start" do
       AWS::Flow::stub(:start_workflow)
-      expect(AWS::Flow::Templates).to receive(:start)
+      expect(AWS::Flow::Templates::Starter).to receive(:start)
       AWS::Flow::start("HelloWorld.hello", { foo: "foo" })
     end
 

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

@@ -180,6 +180,48 @@ end
 
 describe ActivityWorker do
 
+  context "#initialize" do
+
+    context "windows platform" do
+
+      before(:all) do
+        @platform = RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+        RbConfig::CONFIG['host_os'] = 'mswin'
+      end
+
+      after(:all) do
+        RbConfig::CONFIG['host_os'] = @platform
+      end
+
+      it "turns forking off by default" do
+        ActivityWorker.any_instance.stub(:add_implementation)
+        worker = AWS::Flow::ActivityWorker.new(nil, nil, "task_list")
+        options = worker.instance_variable_get("@options")
+        options.use_forking.should be_false
+        options.execution_workers.should be_zero
+      end
+
+      it "turns forking on if user explicitely specifies execution workers" do
+        ActivityWorker.any_instance.stub(:add_implementation)
+        worker = AWS::Flow::ActivityWorker.new(nil, nil, "task_list") { { execution_workers: 5 }}
+        options = worker.instance_variable_get("@options")
+        options.use_forking.should be_true
+        options.execution_workers.should == 5
+      end
+    end
+
+    # This test is to ensure that the default behavior of forking is overriden
+    # by setting execution_workers to 0. This is added to ensure that forking
+    # can be turned off from the json spec for the runner.
+    it "turns forking on if execution_workers is 0 and use_forking is true" do
+      worker = AWS::Flow::ActivityWorker.new(nil, nil, "task_list") { { execution_workers: 0, use_forking: true }}
+      options = worker.instance_variable_get("@options")
+      options.use_forking.should be_false
+      options.execution_workers.should be_zero
+    end
+
+  end
+
   context "#register" do
     it "ensures that worker uses the right task list to register type" do
       class DefaultTasklistTestActivity

data/spec/aws/flow/unit/external_condition_variable_spec.rb

@@ -0,0 +1,59 @@
+##
+# Copyright 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License").
+# You may not use this file except in compliance with the License.
+# A copy of the License is located at
+#
+#  http://aws.amazon.com/apache2.0
+#
+# or in the "license" file accompanying this file. This file is distributed
+# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+# express or implied. See the License for the specific language governing
+# permissions and limitations under the License.
+##
+
+require 'spec_helper'
+
+describe ExternalConditionVariable do
+  let(:condition) { ExternalConditionVariable.new }
+
+  it "blocks a thread and wakes it up on signal" do
+    t = Thread.new { condition.wait }
+    sleep 1
+    t.status.should == "sleep"
+    condition.signal
+    t.status.should == false
+  end
+
+  it "blocks multiple threads and wakes one up on signal" do
+    t1 = Thread.new { condition.wait }
+    t2 = Thread.new { condition.wait }
+    sleep 1
+    t1.status.should == "sleep"
+    t2.status.should == "sleep"
+    condition.signal
+    (t1.status == false && t2.status == false).should == false
+    condition.signal
+    (t1.status == false && t2.status == false).should == true
+  end
+
+  it "blocks a thread and wakes it up on broadcast" do
+    t = Thread.new { condition.wait }
+    sleep 1
+    t.status.should == "sleep"
+    condition.broadcast
+    t.status.should == false
+  end
+
+  it "blocks multiple threads and wakes them up on broadcast" do
+    t1 = Thread.new { condition.wait }
+    t2 = Thread.new { condition.wait }
+    sleep 1
+    t1.status.should == "sleep"
+    t2.status.should == "sleep"
+    condition.broadcast
+    (t1.status == false && t2.status == false).should == true
+  end
+
+end

data/spec/aws/flow/{future_spec.rb → unit/future_spec.rb}

@@ -1,3 +1,5 @@
+require 'spec_helper'
+
 ##
 # Copyright 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 #
@@ -208,3 +210,189 @@ describe Future do
   end
 
 end
+
+describe ExternalFuture do
+  let(:future) { ExternalFuture.new }
+  let(:trace) { [] }
+  context "#set" do
+    it "throws an exception when set multiple times" do
+      future.set(:foo)
+      expect { future.set(:bar) }.to raise_error AlreadySetException
+    end
+  end
+
+  context "#get" do
+
+    it "returns the value which was set" do
+      value = :foo
+      future.set(value)
+      future.get.should == value
+    end
+
+    it "blocks a thread until a value is ready" do
+      future = ExternalFuture.new
+
+      t1 = Thread.new { future.get }
+      sleep 1
+      t1.status.should == "sleep"
+      future.set
+      t1.status.should == false
+    end
+
+    it "works with an already set future" do
+      future = ExternalFuture.new.set
+      future.get
+      # future.get will be a non blocking call if it is already set. If not,
+      # then the next line will never be executed
+      future.set?.should == true
+    end
+
+    it "blocks multiple threads until a value is ready" do
+      future = ExternalFuture.new
+      t1 = Thread.new { future.get }
+      t2 = Thread.new { future.get }
+      t3 = Thread.new { future.get }
+
+      sleep 1
+
+      t1.status.should == "sleep"
+      t2.status.should == "sleep"
+      t3.status.should == "sleep"
+
+      future.set
+
+      t1.status.should == false
+      t2.status.should == false
+      t3.status.should == false
+    end
+
+    context "#timeout" do
+      it "raises an exception if timeout occurs and leaves future unset" do
+        future = ExternalFuture.new
+        expect{future.get(1)}.to raise_error(Timeout::Error)
+        future.set?.should == false
+      end
+
+      it "raises an exception if timeout occurs multiple times" do
+        future = ExternalFuture.new
+        expect{future.get(1)}.to raise_error(Timeout::Error)
+        expect{future.get(1)}.to raise_error(Timeout::Error)
+        expect{future.get(1)}.to raise_error(Timeout::Error)
+      end
+
+      it "nil timeout will block until the future is set" do
+        future = ExternalFuture.new
+        t = Thread.new { future.get(nil) }
+        sleep 1
+        t.status.should == "sleep"
+        future.set
+        t.status.should == false
+      end
+
+    end
+
+  end
+
+  context "#wait_for_any" do
+
+    it "works with multiple futures" do
+      f1 = ExternalFuture.new
+      f2 = ExternalFuture.new
+      f3 = ExternalFuture.new
+      t = Thread.new do
+        f1.set("foo")
+      end
+      r1, r2, r3 = AWS::Flow::Core.wait_for_any(f1, f2, f3)
+      r1.get.should == "foo"
+      f2.set?.should be_false
+      f3.set?.should be_false
+    end
+
+    it "works with no futures" do
+      wait_for_any
+      # Just need to check if the test completes
+      true.should == true
+    end
+
+    it "works with an already set future" do
+      future = ExternalFuture.new.set
+      wait_for_any(future)
+      future.set?.should == true
+    end
+
+    it "works with one set and one unset future" do
+      future = ExternalFuture.new.set
+      future2 = ExternalFuture.new
+      wait_for_any(future, future2)
+      future.set?.should == true
+      future2.set?.should be_false
+    end
+
+  end
+
+  context "#wait_for_all" do
+
+    it "works with multiple futures" do
+      f1 = ExternalFuture.new
+      f2 = ExternalFuture.new
+      f3 = ExternalFuture.new
+      t = Thread.new do
+        f1.set("foo")
+        f2.set("bar")
+        f3.set("baz")
+      end
+      r1, r2, r3 = AWS::Flow::Core.wait_for_all(f1, f2, f3)
+      r1.get.should == "foo"
+      r2.get.should == "bar"
+      r3.get.should == "baz"
+    end
+
+    it "works with no futures" do
+      wait_for_all
+      # Just need to check if the test completes
+      true.should == true
+    end
+
+    it "works with an already set future" do
+      future = ExternalFuture.new.set
+      wait_for_all(future)
+      future.set?.should == true
+    end
+
+    it "works with one set and one unset future" do
+      future = ExternalFuture.new.set
+      future2 = ExternalFuture.new
+      Thread.new { future2.set }
+      wait_for_all(future, future2)
+      future.set?.should == true
+      future2.set?.should == true
+    end
+
+  end
+
+
+  [:timed_wait_for_all, :timed_wait_for_any].each do |method|
+
+    context "#{method}" do
+
+      it "raises when timeout expires" do
+        future = ExternalFuture.new
+        expect { AWS::Flow.send(method, 1, future) }.to raise_error(Timeout::Error)
+      end
+
+      it "doesn't raise when timeout doesn't expires" do
+        future = ExternalFuture.new
+        Thread.new { sleep 1; future.set }
+        expect { AWS::Flow.send(method, 10, future) }.to_not raise_error
+      end
+
+      it "doesn't raise when timeout is nil" do
+        future = ExternalFuture.new
+        Thread.new { sleep 1; future.set }
+        expect { AWS::Flow.send(method, nil, future) }.to_not raise_error
+      end
+
+    end
+  end
+
+end