aws-flow 2.4.0 → 3.0.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MDQyOWZlMGM0YjZiZDcwMmQyNjhjNGFhODY3NzE1ZjZhZDhiNmE4YQ==
+    MmMyMmUwNjY1YWUzZWExMDUxNDc2MGM3YTRmYTQzYmEzZWExN2YwMw==
   data.tar.gz: !binary |-
-    ZTUxM2MwZTJlNzMzMmMxOWY5NTM0MGM2Y2UyMjA2MjE5NWQxMmJkOA==
+    ZWJhNjZjMDgzNTE0NDgwYzI1NjQ4ZDVmNjA2MjM5YzYzODI2MzA5ZQ==
 SHA512:
   metadata.gz: !binary |-
-    MTJiNjFiODFlY2IyN2Q5ODc2YTViNjY4MTM0NGIwZTc0MzE1Y2FmYzM5NjUw
-    MDM5YzkyZTFkNDYzOWFmMDA4YjVmNmY5ODM3MGVkMzQwYjMyMmNiNTlmNmU0
-    NzYyYWNjNmUwYTJkNDg4OTU4ZDVkMjE5MWUxZjA0MDFkZmZiZTM=
+    MTg4NTYwYmU3YTI1NzAxYzZhZWUyMWZlZGVlNGVmNWE3MGQ2NDQzYzJlYWM3
+    ZmM2MjE0NGNhODhkOWNhYjRkMDM4OGNkMzU5YzU4ZjUzYmE3NmU3NDYxMDRi
+    YTFiYjJmOTZmODUxNzk2NDJjYjczOGNhMGY1NTU2NjkxZDhhYjQ=
   data.tar.gz: !binary |-
-    ZWY5NmZjZTE2OTg3NjdiMzg5MjBmNjk3OGUyODY5ODQ5NGJlMjc1OGZkMjI5
-    YTA2NjM3MTA4MjFkMWNmZTVmODVjZTQ2ODZmZDFlMGM5Njk2MGNiMzAxMDc3
-    M2EwOGNmODg2OWQzZjAwM2EyNjhjYTAxYjQyMjJmYjI0OGI1YzE=
+    MTAxY2Y4ZWMwYmIyYThiOGE5MGNmODc5NTE3MTM3NDkxYTYxYTNkYTU4MmM1
+    NmI2Njk4NzlhMmI0MTlhZTUzODIzOTZkNTRkMjRlODFhY2FmMDlhZjQ2ZDFm
+    Zjg1NTE3ZWU0NGE4MmNjYmQyNjhhYTZlMDU0MmI3YjBhZWM4YzQ=

data/aws-flow.gemspec

@@ -4,6 +4,7 @@ Gem::Specification.new do |s|
   s.name        = 'aws-flow'
   s.version     = AWS::Flow::version
   s.date        = Time.now
+  s.license     = "Apache-2.0"
   s.summary     = "AWS Flow Framework for Ruby"
   s.description = "Library to provide the AWS Flow Framework for Ruby"
   s.authors     = "Michael Steger, Paritosh Mohan, Jacques Thomas"

data/lib/aws/decider.rb

@@ -15,7 +15,6 @@
 
 require 'aws/flow'
 include AWS::Flow::Core
-
 require 'aws-sdk-v1'
 require 'securerandom'
 

data/lib/aws/decider/starter.rb

@@ -150,13 +150,11 @@ module AWS
     # @param [Hash] opts
     #   Additional options to configure the workflow or activity execution.
     #
-    # @option opts [true, false] :wait
-    #   *Optional* This boolean flag can be set to true if the result of the
-    #   task is required. Default value is false.
-    #
-    # @option opts [Integer] :wait_timeout
-    #   *Optional* This sets the timeout value for :wait. Default value is
-    #   nil.
+    # @option opts [true, false] :get_result
+    #   *Optional* This boolean flag can be set to true if the result future
+    #   if required. The future can be waited on by using the
+    #   AWS::Flow::wait_for_all, AWS::Flow::wait_for_any methods or by
+    #   calling the ExternalFuture#get method. Default value is false.
     #
     # @option opts [Hash] :exponential_retry
     #   A hash of {AWS::Flow::ExponentialRetryOptions}. Default value is -
@@ -200,7 +198,7 @@ module AWS
     #    )
     #
     def self.start(name_or_klass, input, options = {})
-      AWS::Flow::Templates.start(name_or_klass, input, options)
+      AWS::Flow::Templates::Starter.start(name_or_klass, input, options)
     end
 
   end

data/lib/aws/decider/utilities.rb

@@ -17,6 +17,12 @@ require 'tmpdir'
 
 module AWS
   module Flow
+
+    def self.on_windows?
+      require 'rbconfig'
+      (RbConfig::CONFIG['host_os'] =~ /mswin|mingw/).nil? == false
+    end
+
     # Utilities for the AWS Flow Framework for Ruby.
     module Utilities
       # @api private

data/lib/aws/decider/version.rb

@@ -16,7 +16,7 @@
 module AWS
   module Flow
     def self.version
-      "2.4.0"
+      "3.0.0"
     end
   end
 end

data/lib/aws/decider/worker.rb

@@ -290,14 +290,20 @@ module AWS
         if @options
           @logger = @options.logger || Utilities::LogFactory.make_logger(self)
           @options.logger ||= @logger
+          # Set the number of execution workers to 0 if it's not already set and
+          # if the platform is Windows
+          @options.execution_workers ||= 0 if AWS::Flow.on_windows?
           max_workers = @options.execution_workers
+          # If max_workers is set to 0, then turn forking off
           @options.use_forking = false if (max_workers && max_workers.zero?)
         end
         max_workers = 20 if (max_workers.nil?)
+
         @executor = ForkingExecutor.new(
           :max_workers => max_workers,
           :logger => @logger
         )
+
         @shutdown_first_time_function = lambda do
           @executor.shutdown Float::INFINITY
           Kernel.exit

data/lib/aws/flow/future.rb

@@ -34,6 +34,11 @@ module AWS
       #
       class Future
 
+        def initialize
+          @conditional = FiberConditionVariable.new
+          @set = false
+        end
+
         # Sets the value of the {Future}, and notifies all of the fibers that
         # tried to call {#get} when this future wasn't ready.
         # @api private
@@ -41,8 +46,8 @@ module AWS
           raise AlreadySetException if @set
           @set = true
           @result = result
-          @conditional.broadcast if @conditional
           @listeners.each { |b| b.call(self) } if @listeners
+          @conditional.broadcast if @conditional
           self
         end
 
@@ -62,10 +67,7 @@ module AWS
         # @raise CancellationError
         #   when the task is cancelled.
         def get
-          until @set
-            @conditional ||= FiberConditionVariable.new
-            @conditional.wait
-          end
+          @conditional.wait until @set
           @result
         end
 
@@ -79,7 +81,7 @@ module AWS
         #
         # @api private
         def unset
-          @set = nil
+          @set = false
           @result = nil
         end
 
@@ -135,6 +137,84 @@ module AWS
           self
         end
       end
+
+      # Represents the result of an asynchronous computation. Methods are
+      # provided to:
+      #
+      # * retrieve the result of the computation, once it is complete ({ExternalFuture#get}).
+      # * check if the computation is complete ({ExternalFuture#set?})
+      # * execute a block when computation is complete ({ExternalFuture#on_set})
+      #
+      # The result of a Future can only be retrieved when the computation has
+      # completed.  {ExternalFuture#get} blocks execution, if necessary, until the
+      # ExternalFuture is ready.
+      #
+      # Unlike {Future}, {ExternalFuture#get} doesn't block Fibers. Instead it
+      # blocks the current thread by waiting on a ruby {ConditionVariable}. The
+      # condition variable is signalled when the future is set, which allows the
+      # thread to continue execution when the result is ready. This lets us use
+      # the future outside of an {AsyncScope}
+      #
+      class ExternalFuture < Future
+
+        def initialize
+          @conditional = ConditionVariable.new
+          @mutex = Mutex.new
+          @set = false
+        end
+
+        # Blocks if future is not set. Returns the result of the future once
+        # {#set} is true.
+        #
+        # @return
+        #   The result of the future.
+        #
+        # @raise CancellationError
+        #   when the task is cancelled.
+        def get(timeout=nil)
+          @mutex.synchronize do
+            unless @set
+              @conditional.wait(@mutex, timeout)
+              raise Timeout::Error.new unless @set
+            end
+          end
+          @result
+        end
+
+        def method_missing(method, *args, &block)
+          @mutex.synchronize do
+            super(method, *args, &block)
+          end
+        end
+
+      end
+
+      # Wrapper around a ruby {Mutex} and {ConditionVariable} to avoid
+      # writing the synchronization lines repeatedly.
+      # {ExternalConditionVariable#wait} will block the thread until
+      # {ConditionVariable} @cond is signalled
+      #
+      class ExternalConditionVariable
+
+        attr_reader :mutex, :cond
+
+        def initialize
+          @mutex = Mutex.new
+          @cond = ConditionVariable.new
+        end
+
+        # Block the thread till @cond is signalled
+        def wait(timeout=nil)
+          @mutex.synchronize { @cond.wait(@mutex, timeout) }
+        end
+
+        # Pass all messages to the encapsulated {ConditionVariable}
+        def method_missing(method, *args)
+          @cond.send(method, *args)
+        end
+
+      end
+
     end
   end
 end

data/lib/aws/flow/implementation.rb

@@ -124,19 +124,7 @@ module AWS
       #   A list of the set futures, in the order of being set.
       #
       def wait_for_function(function, *futures)
-        conditional = FiberConditionVariable.new
-        futures.flatten!
-        return nil if futures.empty?
-        result = futures.select(&:set?)
-        return futures.find(&:set?)if function.call(result, futures)
-        futures.each do |f|
-          f.on_set do |set_one|
-            result << set_one
-            conditional.broadcast if function.call(result, futures)
-          end
-        end
-        conditional.wait
-        result
+        wait_for_function_helper(nil, function, *futures)
       end
 
       # Blocks until *any* of the arguments are set.
@@ -162,6 +150,89 @@ module AWS
       def wait_for_all(*futures)
         wait_for_function(lambda {|result, future_list| result.size == future_list.size}, futures)
       end
+
+      # Blocks until *any* of the arguments are set.
+      #
+      # @param [Array<Future>] futures
+      #   A list of futures to wait for. The function will return when at least one of these is set.
+      #
+      # @param [Integer] timeout
+      #   The timeout value after which it will raise a Timeout::Error
+      #
+      # @return [Array<Future>]
+      #   A list of the set futures, in the order of being set.
+      #
+      def timed_wait_for_any(timeout, *futures)
+        timed_wait_for_function(timeout, lambda {|result, future_list| result.length >= 1 }, futures)
+      end
+
+      # Blocks until *all* of the arguments are set or until timeout expires
+      #
+      # @param [Array<Future>] futures
+      #   A list of futures to wait for. The function will return only when all of them are set.
+      #
+      # @param [Integer] timeout
+      #   The timeout value after which it will raise a Timeout::Error
+      #
+      # @return [Array<Future>]
+      #   A list of the set futures, in the order of being set.
+      #
+      def timed_wait_for_all(timeout, *futures)
+        timed_wait_for_function(timeout, lambda {|result, future_list| result.size == future_list.size}, futures)
+      end
+
+      # Waits for the passed-in function to complete, setting values for the provided futures when it does.
+      #
+      # @param function
+      #   The function to wait for.
+      #
+      # @param [Array<Future>] futures
+      #   A list of futures to provide values for when the function completes.
+      #
+      # @param [Integer] timeout
+      #   The timeout value after which it will raise a Timeout::Error
+      #
+      # @return [Array<Future>]
+      #   A list of the set futures, in the order of being set.
+      #
+      def timed_wait_for_function(timeout, function, *futures)
+        wait_for_function_helper(timeout, function, *futures)
+      end
+
+      # Helper method to refactor away the common implementation of
+      # wait_for_function and timed_wait_for_function.
+      def wait_for_function_helper(timeout, function, *futures)
+        futures.flatten!
+
+        f = futures.select { |x| x.is_a?(ExternalFuture) }
+
+        if f.size > 0 && f.size != futures.size
+          raise ArgumentError, "The futures array must contain either all "\
+            "objects of Future or all objects of ExternalFuture"
+        end
+
+        conditional = f.size == 0 ? FiberConditionVariable.new :
+          ExternalConditionVariable.new
+
+        return nil if futures.empty?
+        result = futures.select(&:set?)
+        return futures.find(&:set?)if function.call(result, futures)
+        futures.each do |f|
+          f.on_set do |set_one|
+            result << set_one
+            conditional.broadcast if function.call(result, futures)
+          end
+        end
+
+        if conditional.is_a?(FiberConditionVariable)
+          conditional.wait
+        else
+          conditional.wait(timeout)
+          raise Timeout::Error.new unless function.call(result, futures)
+        end
+        result
+      end
+
     end
   end
 end

data/lib/aws/runner.rb

@@ -240,7 +240,7 @@ module AWS
 
         if json_config['default_workers']
           # Also register the default result activity type in the given domain
-          AWS::Flow::Templates.register_default_result_activity(domain)
+          AWS::Flow::Templates::Utils.register_default_result_activity(domain)
 
           klass = AWS::Flow::Templates.default_workflow
           task_list = FlowConstants.defaults[:task_list]

data/lib/aws/templates.rb

@@ -1,4 +1,6 @@
 require 'aws/templates/base'
 require 'aws/templates/activity'
 require 'aws/templates/default'
+require 'aws/templates/result'
+require 'aws/templates/utilities'
 require 'aws/templates/starter'

data/lib/aws/templates/activity.rb

@@ -64,6 +64,47 @@ module AWS
         ActivityTemplate.new(name, opts)
       end
 
+      # This template represents a Result Activity in SWF.
+      class ResultActivityTemplate < ActivityTemplate
+        attr_reader :key
+
+        def initialize(key, opts = {})
+          @key = key
+
+          # Get the name of the result activity
+          name = "#{FlowConstants.defaults[:result_activity_prefix]}."\
+            "#{FlowConstants.defaults[:result_activity_method]}"
+
+          super(name, opts)
+        end
+
+        # Wraps the input into a result hash and calls the ActivityTemplate#run
+        # method to report the result
+        def run(input, context)
+          result = {}
+          result[:key] = @key
+          result[:result] = input
+          super(result, context)
+        end
+      end
+
+      # Initializes a result activity template
+      # @param {String} key
+      #   A unique key that identifies the result of an activity execution
+      # @param {Hash} options
+      def result(key, opts = {})
+        AWS::Flow::Templates.send(:result, key, opts)
+      end
+
+      # Initializes a result activity template
+      # @param {String} key
+      #   A unique key that identifies the result of an activity execution
+      # @param {Hash} options
+      def self.result(key, opts = {})
+        ResultActivityTemplate.new(key, opts)
+      end
+
+
     end
   end
 end

data/lib/aws/templates/default.rb

@@ -104,8 +104,6 @@ module AWS
       class FlowDefaultResultActivityRuby
         extend AWS::Flow::Activities
 
-        attr_reader :result
-
         # Create the activity type with default options
         activity FlowConstants.defaults[:result_activity_method] do
           {
@@ -116,15 +114,20 @@ module AWS
           }
         end
 
-        # Initialize the future upon instantiation
-        def initialize
-          @result = Future.new
+        # @param writer IO
+        #   An optional IO file descripter to write the result to.
+        #
+        def initialize(writer=nil)
+          @writer = writer
         end
 
-        # Set the future when the activity is run
+        # Serialize the input and write it to an IO writer if provided
         def run(input)
-          @result.set(input)
-          input
+          unless input.is_a?(Hash) && input.include?(:key) && input.include?(:result)
+            raise ArgumentError, "Incorrect input format for "\
+              "FlowDefaultResultActivityRuby.run"
+          end
+          @writer.puts Marshal.dump(input) if @writer
         end
 
       end