aws-flow 1.0.5 → 1.0.6

data/lib/aws/decider.rb

@@ -13,12 +13,6 @@
 # permissions and limitations under the License.
 #++
 
-# @!visibility private
-def require_all(path)
-  glob = File.join(path, "*.rb")
-  Dir[glob].each { |f| require f}
-  Dir[glob].map { |f| File.basename(f) }
-end
 
 require 'aws/flow'
 include AWS::Flow::Core
@@ -27,9 +21,6 @@ require 'aws-sdk'
 # Setting the user-agent as ruby-flow for all calls to the service
 AWS.config(:user_agent_prefix => "ruby-flow")
 
-#LOAD_PATH << File.dirname(File.expand_path(__FILE__))
-
-
 require "aws/decider/utilities"
 require "aws/decider/worker"
 require 'aws/decider/generic_client'

data/lib/aws/decider/async_decider.rb

@@ -132,7 +132,7 @@ module AWS
       # @!visibility private
       def get_next_state_machine_which_will_schedule(list)
         return if list.empty?
-        ele = list.first
+        ele = list.shift
         ele = list.shift until (list.empty? || ele.get_decision != nil)
         ele
       end
@@ -159,18 +159,19 @@ module AWS
           end
           decision_state_machine.consume(:handle_decision_task_started_event)
           decision_state_machine = next_decision_state_machine
-          if (next_decision_state_machine != nil &&
-              count < DecisionHelper.maximum_decisions_per_completion)
-            next_decision_state_machine.consume(:handle_decision_task_started_event)
-          end
+        end
+        if (next_decision_state_machine != nil &&
+            count < DecisionHelper.maximum_decisions_per_completion)
+          next_decision_state_machine.consume(:handle_decision_task_started_event)
         end
       end
 
-      # @!visibility private
-      def method_missing(method_name, *args)
-        if [:[]=, :[]].include? method_name
-          @decision_map.send(method_name, *args)
-        end
+
+      def [](key)
+        return @decision_map[key]
+      end
+      def []=(key, val)
+        return @decision_map[key] = val
       end
 
       # Returns the activity ID for a scheduled activity
@@ -336,7 +337,7 @@ module AWS
       #
       def complete_workflow
         return unless @completed && ! @unhandled_decision
-        decision_id = DecisionID.new(:Self, nil)
+        decision_id = [:SELF, nil]
         if @failure
           @decision_helper[decision_id] = make_fail_decision(decision_id, @failure)
         elsif @cancel_requested
@@ -459,7 +460,7 @@ module AWS
 
       def handle_closing_failure
         @unhandled_decision = true
-        @decision_helper[:SELF, nil].consume(:handle_initiation_failed_event)
+        @decision_helper[[:SELF, nil]].consume(:handle_initiation_failed_event)
       end
 
       # Handler for the `:CompleteWorkflowExecutionFailed` event.

data/lib/aws/decider/decider.rb

@@ -198,7 +198,7 @@ module AWS
                        :consume_symbol => :handle_completion_event,
                        :decision_helper_scheduled => :scheduled_signals,
                        :handle_open_request => lambda do |event, open_request|
-                         workflow_execution = AWS::SimpleWorkflow::WorkflowExecution.new("",event.attributes.workflow_id, event.attributes.run_id)
+                         workflow_execution = AWS::Flow::MinimalWorkflowExecution.new("",event.attributes.workflow_id, event.attributes.run_id)
                          failure = SignalExternalWorkflowException(event.id, workflow_execution, event.attributes.cause)
                          open_request.completion_handle.fail(failure)
                        end
@@ -215,7 +215,7 @@ module AWS
                      :consume_symbol => :handle_initiation_failed_event,
                      :decision_helper_scheduled => :scheduled_external_workflows,
                      :handle_open_request => lambda do |event, open_request|
-                         workflow_execution = AWS::SimpleWorkflow::WorkflowExecution.new("",event.attributes.workflow_id, nil)
+                         workflow_execution = AWS::Flow::MinimalWorkflowExecution.new("",event.attributes.workflow_id, nil)
                        workflow_type = event.attributes.workflow_type
                        cause = event.attributes.cause
                        failure = StartChildWorkflowFailedException.new(event.id, workflow_execution, workflow_type, cause)

data/lib/aws/decider/generic_client.rb

@@ -80,12 +80,16 @@ module AWS
         elsif block.arity == 0
           modified_options = Proc.new do
             result = block.call
+            # We need to copy the hash to make sure that we don't mutate it
+            result = result.dup
             result[:return_on_start] = true
             result
           end
           # Otherwise, it will expect an options object passed in, and will do things on that object. So make our new Proc do that, and add an option
         else modified_options = Proc.new do |x|
             result = block.call(x)
+            # We need to copy the hash to make sure that we don't mutate it
+            result = result.dup
             result.return_on_start = true
             result
           end

data/lib/aws/decider/task_poller.rb

@@ -99,7 +99,10 @@ module AWS
           raise "This activity worker was told to work on activity type #{activity_type.name}, but this activity worker only knows how to work on #{@activity_definition_map.keys.map(&:name).join' '}" unless activity_implementation
           output = activity_implementation.execute(task.input, context)
           @logger.debug "Responding on task_token #{task.task_token} for task #{task}"
-          if ! activity_implementation.execution_options.manual_completion
+          if output.length > 32768
+            output = output.slice(0..32767)
+            respond_activity_task_failed_with_retry(task.task_token, "You cannot send a response with a result greater thank 32768. Please reduce the response size. The first part of the output is included in the details field.", output )
+          elsif ! activity_implementation.execution_options.manual_completion
             @service.respond_activity_task_completed(:task_token => task.task_token, :result => output)
           end
         rescue ActivityFailureException => e
@@ -133,7 +136,7 @@ module AWS
       end
 
       def process_single_task(task)
-        @service = AWS::SimpleWorkflow.new.client.with_http_handler(AWS::Core::Http::NetHttpHandler.new(:ssl_ca_file => AWS.config.ssl_ca_file))
+        @service = AWS::SimpleWorkflow.new.client.with_http_handler(AWS::Core::Http::NetHttpHandler.new(AWS.config.to_h))
         begin
           begin
             execute(task)

data/lib/aws/decider/version.rb

@@ -16,7 +16,7 @@
 module AWS
   module Flow
     def self.version
-      "1.0.5"
+      "1.0.6"
     end
   end
 end

data/lib/aws/decider/workflow_client.rb

@@ -16,11 +16,24 @@
 module AWS
   module Flow
 
+    class MinimalDomain
+      attr_accessor :name
+      def initialize(domain); @domain = domain; end
+    end
+
+    class MinimalWorkflowExecution
+      attr_accessor :workflow_id, :run_id, :domain
+      def initialize(domain, workflow_id, run_id)
+        @domain = domain
+        @workflow_id = workflow_id
+        @run_id = run_id
+      end
+    end
 
     # A future provided by a [WorkflowExecution](http://docs.aws.amazon.com/AWSRubySDK/latest/AWS/SimpleWorkflow/WorkflowExecution.html).
     #
     # @!attribute _workflow_execution
-    #   The [WorkflowExecution](http://docs.aws.amazon.com/AWSRubySDK/latest/AWS/SimpleWorkflow/WorkflowExecution.html)
+    #   A MinimalWorkflowExecution
     #   instance that this future belongs to.
     #
     # @!attribute return_value
@@ -35,7 +48,7 @@ module AWS
       # @param workflow_execution
       #
       def initialize(workflow_execution)
-        @_workflow_execution = workflow_execution
+        @_workflow_execution = workflow_execution.dup
         @return_value = Future.new
       end
 
@@ -208,7 +221,8 @@ module AWS
         get_decision_context
         options = Utilities::interpret_block_for_options(StartWorkflowOptions, block)
         workflow_id_future, run_id_future = Future.new, Future.new
-        output = WorkflowFuture.new(AWS::SimpleWorkflow::WorkflowExecution.new(@domain, workflow_id_future, run_id_future))
+        minimal_domain = MinimalDomain.new(@domain.name.to_s)
+        output = WorkflowFuture.new(AWS::Flow::MinimalWorkflowExecution.new(minimal_domain, workflow_id_future, run_id_future))
         options = Utilities::merge_all_options(@options, options)
         new_options = StartWorkflowOptions.new(options)
         open_request = OpenRequestInfo.new

data/lib/aws/flow.rb

@@ -0,0 +1,29 @@
+##
+# 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.
+##
+
+
+# Everything depends on fiber, so we have to require that before anything else
+require 'aws/flow/fiber'
+
+# Require everything else
+require 'aws/flow/async_backtrace.rb'
+require 'aws/flow/async_scope.rb'
+require 'aws/flow/begin_rescue_ensure.rb'
+require 'aws/flow/flow_utils.rb'
+require 'aws/flow/future.rb'
+require 'aws/flow/implementation.rb'
+require 'aws/flow/simple_dfa.rb'
+require 'aws/flow/tasks.rb'
+$RUBY_FLOW_FILES = ["async_backtrace.rb","tasks.rb","simple_dfa.rb","implementation.rb","future.rb","flow_utils.rb","begin_rescue_ensure.rb","async_scope.rb"]

data/lib/aws/flow/async_backtrace.rb

@@ -0,0 +1,134 @@
+##
+# 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.
+##
+
+# This file contains AsyncBacktrace, which takes care of decorating and properly filtering backtraces
+
+module AWS
+  module Flow
+    module Core
+      # @!visibility private
+      class AsyncBacktrace
+
+        # @!visibility private
+        def initialize(parent, backtrace)
+          @backtrace = AsyncBacktrace.filter(backtrace)
+          @parent = parent
+        end
+
+        # @!visibility private
+        def backtrace
+          if @parent
+            AsyncBacktrace.merge(@backtrace, @parent.backtrace)
+          else
+            @backtrace
+          end
+        end
+
+        # @!visibility private
+        class << self
+
+          # @!visibility private
+          def create(parent, frames_to_skip)
+
+            unless @disable_async_backtrace
+              b = AsyncBacktrace.caller(frames_to_skip)
+              AsyncBacktrace.new(parent, b)
+            end
+          end
+
+          # @!visibility private
+          def create_from_exception(parent, exception)
+            unless @disable_async_backtrace
+              AsyncBacktrace.new(parent, exception.backtrace);
+            end
+          end
+
+          # Remove all framework related frames after application frames. Keep framework frames before application
+          # frames.
+          #
+          # @todo
+          #   The correct implementation should not have framework frames before application frames as it is expected to
+          #   call Kernel.caller with the correct number.  But in cases when due to changes this number is not correct
+          #   the frames are kept to not create confusion.
+          #
+          def filter(backtrace)
+            if @disable_filtering
+              backtrace
+            else
+              do_filter(backtrace)
+            end
+          end
+
+          # @!visibility private
+          def merge(*backtraces)
+            result = []
+            backtraces.each do | b |
+              if b
+                result << "------ continuation ------" if result.size > 0
+                result += b
+              end
+            end
+            result
+          end
+
+          # @!visibility private
+          def disable_filtering
+            @disable_filtering = true
+          end
+
+          # @!visibility private
+          def enable_filtering
+            @disable_filtering = false
+          end
+
+          # @!visibility private
+          def disable
+            @disable_async_backtrace = true
+          end
+
+          # @!visibility private
+          def enable
+            @disable_async_backtrace = false
+          end
+
+          # @!visibility private
+          def caller(skip)
+            random_var = Kernel.caller 0
+            this_stuff =  1.upto(6).map { |x| Kernel.caller(x) }
+            other_var = Kernel.caller skip
+            Kernel.caller(@disable_filtering ? 0 : skip)
+          end
+
+          private
+
+          # @!visibility private
+          def do_filter(backtrace)
+            return nil unless backtrace
+            # keep asynchrony frames at the top of the backtrace only
+            # then cut all frames starting from asynchrony frame
+            skip_asynchrony_frames = false
+            @backtrace = backtrace.take_while do |frame|
+              if ! $RUBY_FLOW_FILES.select {|file| Regexp.new(file) =~ frame}.empty?
+                !skip_asynchrony_frames
+              else
+                skip_asynchrony_frames = true
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws/flow/async_scope.rb

@@ -0,0 +1,195 @@
+##
+# 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.
+##
+
+# This module contains the Root of the heirarchy for calls into flow, the AsyncScope
+
+module AWS
+  module Flow
+    module Core
+
+      def gate_by_version(version, method, &block)
+        if RUBY_VERSION.send(method, version)
+          block.call
+        end
+      end
+
+      # @!visibility private
+      class AsyncScope
+        attr_accessor :stackTrace, :root, :failure, :root_context
+
+        def is_complete?
+          @root_context.complete
+        end
+
+        def get_closest_containing_scope
+          @root_error_handler
+        end
+
+        def cancel(error); @root_error_handler.cancel(error); end
+
+        def initialize(&block)
+          @root_context = RootAsyncScope.new
+
+
+
+          # 1 for the function that skips frames
+          # 1 for the create function
+          # 1 for the the initialize of the backtrace
+
+          # "./lib/aws/rubyflow/asyncBacktrace.rb:75:in `caller'"
+          # "./lib/aws/rubyflow/asyncBacktrace.rb:21:in `create'"
+          # "./lib/aws/rubyflow/asyncScope.rb:18:in `initialize'"
+
+          @root_context.backtrace = AsyncBacktrace.create(nil, 3)
+          @root_error_handler = BeginRescueEnsure.new(:parent => @root_context)
+          begin
+            @root_error_handler.begin lambda { block.call if ! block.nil? }
+            @root_error_handler.rescue(Exception, lambda { |e| raise e })
+          end
+          @root_context << @root_error_handler
+        end
+
+        # Collects all the heirs of a task for use in async_stack_dump
+        def get_heirs
+          @root_error_handler.get_heirs
+        end
+
+        # Execute all queued tasks. If execution of those tasks results in addition of new tasks to the queue, execute
+        # them as well.
+        #
+        # Unless there are external dependencies or bugs in the tasks to be executed, a single call to this method
+        # performs the complete asynchronous execution.
+        #
+        # @note In the presence of external dependencies, it is expected that {AsyncScope#eventLoop} is called every
+        # time after a change in the state in a dependency can unblock asynchronous execution.
+        #
+        def eventLoop
+          #TODO Figure out when to raise Done raise "Done" if ! @root_task.alive?
+          raise IllegalStateException, "Already complete" if is_complete?
+          @root_context.eventLoop
+          # TODO Does this need to be taken care of? It's supposed to protect
+          # against people having errors that are classes, so like, passing
+          # Exception into cancel. We might want to just catch that at the
+          # entry point
+          if @root_context.failure
+            if @root_context.failure.respond_to? :message
+              failure_message = @root_context.failure.message + "\n" +
+                @root_context.failure.backtrace.join("\n")
+              raise @root_context.failure, failure_message
+            else
+              raise @root_context.failure
+            end
+          end
+
+          return is_complete?
+        end
+
+        def <<(task)
+          @root_context << task
+          task.parent = @root_context
+        end
+      end
+
+      # @!visibility private
+      class RootAsyncScope < FlowFiber
+
+        attr_accessor :backtrace, :failure, :executor, :complete
+
+        def initialize(options = {}, &block)
+          @parent = options[:parent_context]
+          @daemon = options[:daemon]
+          @context = @parent
+          @executor = AsyncEventLoop.new
+          @task_queue = []
+          @complete = false
+          @task_queue << Task.new(context, &block) if block
+        end
+
+        # The only thing that should be removed from the RootAsyncScope is the
+        # root BeginRescueEnsure, so upon removal we are complete
+        def remove(task)
+          @complete = true
+        end
+
+        # As with remove, the only thing that is under RootAsyncScope should be
+        # the root BeginRescueEnsure, so upon failure we will be complete. Also
+        # sets failure variable for later raising.
+        def fail(task, error)
+          @failure = error
+          @complete = true
+        end
+
+        def <<(this_task)
+          @executor << this_task
+        end
+
+        # Reture self, a RootAsyncScope is the closest containing scope
+        def get_closest_containing_scope
+          self
+        end
+
+        # Call out to the AsyncEventLoop
+        def eventLoop
+          @executor.executeQueuedTasks
+        end
+
+
+        private
+        DELEGATED_METHODS = [:push, :<<, :enq, :empty?, :length, :size, :delete, :shift]
+
+        def method_missing(method_name, *args)
+          if DELEGATED_METHODS.include? method_name
+            @executor.send(method_name, *args)
+          else
+            super
+          end
+        end
+      end
+
+      # @!visibility private
+      class AsyncEventLoop
+
+        def initialize
+          @tasks = []
+        end
+
+        def remove(task)
+          @tasks.delete(task)
+        end
+        # TODO Make sure that it's okay to fail from the AsyncEventLoop, and that
+        # this is the correct behavior
+        def fail(task, error)
+          raise error
+        end
+        def <<(task)
+          @tasks << task
+
+        end
+
+
+        # TODO should this be synchronized somehow?
+
+        # Actually executes the eventLoop
+        def executeQueuedTasks
+          until @tasks.empty?
+            task = @tasks.shift
+            task.resume if task.alive?
+          end
+        end
+      end
+
+    end
+  end
+end