aws-flow 1.0.0

data/aws-flow-core/test/aws/rubyflow.rb

@@ -0,0 +1,22 @@
+##
+# 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.
+##
+
+#!/usr/bin/ruby -wKU
+
+def require_all(path)
+  Dir[File.join(File.dirname(__FILE__), path, "*.rb")].each {|f| require f}
+end
+
+require_all('rubyflow/')

data/aws-flow-core/test/aws/simple_dfa_spec.rb

@@ -0,0 +1,63 @@
+##
+# 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.
+##
+
+describe SimpleDFA do
+  before(:each) do
+    class Tester
+      attr_accessor :trace
+
+      extend SimpleDFA
+      init(:start_state)
+
+      def initialize
+        @trace = []
+      end
+
+      add_transition(:start_state, :a) do |t|
+        t.trace << :start_to_second
+        t.current_state = :second_state
+      end
+      add_transition(:second_state, :b) do |t|
+        t.trace << :second_to_third
+        t.current_state = :third_state
+      end
+      add_transition(:third_state, :c) do |t|
+        t.trace << :third_to_start
+        t.current_state = :start_state
+      end
+    end
+    @this_dfa = Tester.new
+
+  end
+
+  it "ensures that consume works as expected" do
+    @this_dfa.consume(:a)
+    @this_dfa.trace.should == [:start_to_second]
+    @this_dfa.current_state.should == :second_state
+  end
+
+  it "ensures that define_general defines general transitions for a state" do
+    class Tester
+      define_general(:start_state) {|t| t.current_state = :new_state }
+    end
+    @this_dfa.consume(:c)
+    @this_dfa.current_state.should == :new_state
+  end
+
+  it "ensures that uncovered_transitions raises on those transitions" do
+    expect { @this_dfa.consume(:b) }.to raise_error
+  end
+
+end

data/aws-flow-core/test/aws/spec_helper.rb

@@ -0,0 +1,36 @@
+##
+# 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 'rubygems'
+
+require 'aws/flow'
+
+include AWS::Flow::Core
+
+Spec::DSL::Main.class_eval do
+  if method_defined? :context
+    undef :context
+  end
+end
+
+def constantize(camel_case_word)
+  names = camel_case_word.split('::')
+  names.shift if names.empty? || names.first.empty?
+  constant = Object
+  names.each do |name|
+    constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+  end
+  constant
+end

data/aws-flow.gemspec

@@ -0,0 +1,13 @@
+Gem::Specification.new do |s|
+  s.name        = 'aws-flow'
+  s.version     = '1.0.0'
+  s.date        = Time.now
+  s.summary     = "AWS Flow Decider package decider"
+  s.description = "Library to provide the AWS Flow Framework for Ruby"
+  s.authors     = "Michael Steger"
+  s.email       = ''
+  s.files       = `git ls-files`.split("\n")
+  s.require_paths << "lib/aws/"
+  s.add_dependency "aws-sdk", "~> 1"
+  s.add_dependency "aws-flow-core", "~> 1"
+end

data/lib/aws/decider.rb

@@ -0,0 +1,67 @@
+#--
+# 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.
+#++
+
+# @!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
+
+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'
+require "aws/decider/async_retrying_executor"
+require "aws/decider/activity_definition"
+require "aws/decider/decider"
+require "aws/decider/task_handler"
+require "aws/decider/data_converter"
+require "aws/decider/state_machines"
+require "aws/decider/workflow_definition"
+
+require "aws/decider/executor"
+require "aws/decider/workflow_enabled"
+require "aws/decider/options"
+require "aws/decider/activity"
+require "aws/decider/async_decider"
+require "aws/decider/workflow_clock"
+require "aws/decider/decision_context"
+require "aws/decider/workflow_definition_factory"
+require "aws/decider/workflow_client"
+require "aws/decider/history_helper"
+require "aws/decider/exceptions"
+require "aws/decider/task_poller"
+require "aws/decider/flow_defaults"
+require "aws/decider/implementation"
+
+# @!visibility private
+def get_const(name)
+  name = name.split('::').reverse
+  current = Object
+  while ! name.empty?
+    current = current.const_get(name.pop)
+  end
+  current
+end

data/lib/aws/decider/activity.rb

@@ -0,0 +1,408 @@
+#--
+# 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.
+#++
+
+module AWS
+  module Flow
+
+    # Represents information about an open request.
+    # @!visibility private
+    class OpenRequestInfo
+      attr_accessor :completion_handle, :result, :blocking_promise, :description, :run_id
+    end
+
+    class ActivityMetadata
+      attr_reader :activity_id
+      def initialize(activity_id); @activity_id = activity_id; end
+    end
+
+
+    # A generic activity client that can be used to perform standard activity actions.
+    class GenericActivityClient < GenericClient
+      # The data converter used for serializing/deserializing data when sending requests to and receiving results from
+      # workflow executions of this workflow type. By default, this is {YAMLDataConverter}.
+      attr_accessor :data_converter
+
+      # The decision helper used by the activity client.
+      attr_accessor :decision_helper
+
+      # A hash of ActivityRuntimeOptions for the activity client
+      attr_accessor :options
+
+       # Returns the default option class for the activity client, which is {ActivityRuntimeOptions}.
+      def self.default_option_class; ActivityRuntimeOptions; end
+
+      # Separates the activity name from the activity type at the point of the last (.) symbol.
+      #
+      # @param [String] name
+      #   The name of the activity type.
+      #
+      def activity_name_from_activity_type(name)
+        return name.to_s.split(".").last.to_sym
+      end
+
+      # Creates a new GenericActivityClient instance.
+      #
+      # @param [DecisionHelper] decision_helper
+      #   The decision helper to use for the activity client.
+      #
+      # @param [ActivityOptions] options ActivityOptions to set for the activity client.
+      #
+      def initialize(decision_helper, options)
+        @decision_helper = decision_helper
+        @options = options
+        @activity_option_map = @decision_helper.activity_options
+        @failure_map = {}
+        @data_converter ||= YAMLDataConverter.new
+        super
+      end
+
+      # Runs an activity given a name and block of options.
+      #
+      # @param method_name
+      #   The name of the activity type to define
+      #
+      # @param args
+      #   Arguments for the method
+      #
+      # @param block
+      #   A block of {ActivityOptions}
+      #
+      def method_missing(method_name, *args, &block)
+        options = Utilities::interpret_block_for_options(ActivityOptions, block)
+        options = Utilities::merge_all_options(@options,
+                                    @activity_option_map[method_name.to_sym],
+                                    @option_map[method_name.to_sym],
+                                    options
+                                    )
+        new_options = ActivityOptions.new(options)
+
+        activity_type = ActivityType.new("#{new_options.prefix_name}.#{method_name.to_s}", new_options.version, new_options.get_default_options)
+        if new_options._exponential_retry
+          retry_function = new_options._exponential_retry.retry_function || FlowConstants.exponential_retry_function
+          new_options._exponential_retry.return_on_start ||= new_options.return_on_start
+          future = _retry_with_options(lambda { self.schedule_activity(activity_type.name, activity_type, args, new_options ) }, retry_function, new_options._exponential_retry, args)
+          return future if new_options.return_on_start
+          result = Utilities::drill_on_future(future)
+        else
+          result = schedule_activity(activity_type.name, activity_type, args, new_options)
+        end
+        result
+      end
+
+      # @!visibility private
+      def retry_alias_to_method(retry_alias)
+        retry_alias.to_s[/__(.*)_retry/, 1].to_sym
+      end
+
+      # @!visibility private
+      def method_to_retry_alias(method_name)
+        "#{__method_name.to_s + "_retry"}".to_sym
+      end
+
+      # Requests that the activity is canceled.
+      #
+      # @param [Future] to_cancel
+      #   The Future for the task to be canceled.
+      #
+      def request_cancel_activity_task(to_cancel)
+        metadata = to_cancel.metadata
+        if ! metadata.respond_to? :activity_id
+          raise "You need to use a future obtained from an activity"
+        end
+        @decision_helper[metadata.activity_id].consume(:cancel)
+      end
+
+      # A handler for the ActivityClassCanceled event.
+      #
+      # @param [ActivityClassCanceled] event
+      #   The event data.
+      #
+      def handle_activity_task_canceled(event)
+        activity_id = @decision_helper.get_activity_id(event.attributes[:scheduled_event_id])
+        @decision_helper[activity_id].consume(:handle_cancellation_event)
+        if @decision_helper[activity_id].done?
+          open_request = @decision_helper.scheduled_activities.delete(activity_id)
+          exception = CancellationException.new("Cancelled from ActivityTaskCanceledEvent", nil)
+          if ! open_request.nil?
+            open_request.completion_handle.fail(exception)
+          end
+        end
+      end
+
+      # A handler for the ActivityClassTimedOut event.
+      #
+      # @param [ActivityClassTimedOut] event
+      #   The event data.
+      #
+      def handle_activity_task_timed_out(event)
+        activity_id = @decision_helper.get_activity_id(event.attributes[:scheduled_event_id])
+        activity_state_machine = @decision_helper[activity_id]
+        activity_state_machine.consume(:handle_completion_event)
+        if activity_state_machine.done?
+          open_request = @decision_helper.scheduled_activities.delete(activity_id)
+          if ! open_request.nil?
+            timeout_type = event.attributes[:timeout_type]
+            failure = ActivityTaskTimedOutException.new(event.id, activity_id, timeout_type, "Time out")
+            open_request.completion_handle.fail(failure)
+          end
+        end
+      end
+
+      # A handler for the {ActivityTaskFailed} event.
+      #
+      # @param [ActivityClassFailed] event
+      #   The event data.
+      #
+      def handle_activity_task_failed(event)
+        attributes = event.attributes
+        activity_id = @decision_helper.get_activity_id(attributes[:scheduled_event_id])
+        @decision_helper[activity_id].consume(:handle_completion_event)
+        open_request_info = @decision_helper.scheduled_activities.delete(activity_id)
+        reason = attributes[:reason]
+        details = attributes[:details]
+        # TODO consider adding user_context to open request, and adding it here
+        # @decision_helper[@decision_helper.activity_scheduling_event_id_to_activity_id[event.attributes.scheduled_event_id]].attributes[:options].data_converter
+        failure = ActivityTaskFailedException.new(event.id, activity_id, reason, details)
+        open_request_info.completion_handle.fail(failure)
+      end
+
+      # A handler for the {ScheduleActivityTaskFailed} event.
+      #
+      # @param [ScheduleActivityTaskFailed] event
+      #   The event data.
+      #
+      def handle_schedule_activity_task_failed(event)
+        attributes = event.attributes
+        activity_id = attributes[:activity_id]
+        open_request_info = @decision_helper.scheduled_activities.delete(activity_id)
+        activity_state_machine = @decision_helper[activity_id]
+        activity_state_machine.consume(:handle_initiation_failed_event)
+        if activity_state_machine.done?
+          # TODO Fail task correctly
+          failure = ScheduleActivityTaskFailedException.new(event.id, event.attributes.activity_type, activity_id, event.attributes.cause)
+          open_request_info.completion_handle.fail(failure)
+        end
+      end
+
+      # A handler for the {ActivityClassCompleted} event.
+      #
+      # @param [ActivityClassCompleted] event
+      #   The event data.
+      #
+      def handle_activity_task_completed(event)
+        scheduled_id = event.attributes[:scheduled_event_id]
+        activity_id = @decision_helper.activity_scheduling_event_id_to_activity_id[scheduled_id]
+        @decision_helper[activity_id].consume(:handle_completion_event)
+        if @decision_helper[activity_id].done?
+          open_request = @decision_helper.scheduled_activities.delete(activity_id)
+          open_request.result = event.attributes[:result]
+          open_request.completion_handle.complete
+        end
+      end
+
+      # Schedules the named activity.
+      #
+      # @param [String] name
+      #   The name of the activity to schedule.
+      #
+      # @param [String]
+      #   activity_type The activity type for this scheduled activity.
+      #
+      # @param [Object]
+      #   input Optional data passed to the activity.
+      #
+      # @param [ActivityOptions]
+      #   options ActivityOptions to set for the scheduled activity.
+      #
+      def schedule_activity(name, activity_type, input, options)
+        options = Utilities::merge_all_options(@option_map[activity_name_from_activity_type(name)], options)
+        new_options = ActivityOptions.new(options)
+        output = Utilities::AddressableFuture.new
+        open_request = OpenRequestInfo.new
+        decision_id = @decision_helper.get_next_id(:Activity)
+        output._metadata = ActivityMetadata.new(decision_id)
+        error_handler do |t|
+          t.begin do
+            @data_converter = new_options.data_converter
+
+            #input = input.map { |input_part| @data_converter.dump input_part } unless input.nil?
+            input = @data_converter.dump input unless input.empty?
+            attributes = {}
+            new_options.input ||= input unless input.empty?
+            attributes[:options] = new_options
+            attributes[:activity_type] = activity_type
+            attributes[:decision_id] = decision_id
+            @completion_handle = nil
+            external_task do |t|
+              t.initiate_task do |handle|
+                open_request.completion_handle = handle
+
+                @decision_helper.scheduled_activities[decision_id.to_s] = open_request
+                @decision_helper[decision_id.to_s] = ActivityDecisionStateMachine.new(decision_id, attributes)
+              end
+              t.cancellation_handler do |this_handle, cause|
+                state_machine = @decision_helper[decision_id.to_s]
+                if state_machine.current_state == :created
+                  open_request = @decision_helper.scheduled_activities.delete(decision_id.to_s)
+                  open_request.completion_handle.complete
+                end
+                state_machine.consume(:cancel)
+              end
+            end
+          end
+          t.rescue(Exception) do |error|
+            @data_converter = new_options.data_converter
+            # If we have an ActivityTaskFailedException, then we should figure
+            # out what the cause was, and pull that out. If it's anything else,
+            # we should serialize the error, and stuff that into details, so
+            # that things above us can pull it out correctly. We don't have to
+            # do this for ActivityTaskFailedException, as the details is
+            # *already* serialized
+            if error.is_a? ActivityTaskFailedException
+              details = @data_converter.load(error.details)
+              error.cause = details
+            else
+              details = @data_converter.dump(error)
+              error.details = details
+            end
+            @failure_map[decision_id.to_s] = error
+          end
+          t.ensure do
+            @data_converter = new_options.data_converter
+            result = @data_converter.load open_request.result
+            output.set(result)
+            raise @failure_map[decision_id.to_s] if @failure_map[decision_id.to_s] && new_options.return_on_start
+          end
+        end
+        return output if new_options.return_on_start
+        output.get
+        this_failure = @failure_map[decision_id.to_s]
+        raise this_failure if this_failure
+        return output.get
+      end
+    end
+
+    # Represents an activity client.
+    class ActivityClient < Module
+      # Gets the data converter for the Activity Client.
+      def data_converter
+        @generic_client.data_converter
+      end
+
+      # Sets the data converter for the Activity Client.
+      def data_converter=(other)
+        @generic_client.data_converter = other
+      end
+
+      # Exponentially retries the supplied method with optional settings.
+      #
+      # @param [String] method_name The method name to retry.
+      #
+      # @param [ExponentialRetryOptions] block A hash of ExponentialRetryOptions to use.
+      #
+      def exponential_retry(method_name, &block)
+        @generic_client.retry(method_name, lambda {|first, time_of_failure, attempts| 1}, block)
+      end
+    end
+
+    # Methods and constants related to activities.
+    #
+    # @!attribute activity_client
+    #   Gets the [ActivityClient] for this Activity.
+    #
+    # @!attribute activities
+    #   Gets an list of activities for this Activity.
+    #
+    module Activities
+      @precursors ||= []
+      attr_accessor :activity_client, :activities
+      def self.extended(base)
+        base.send :include, InstanceMethods
+      end
+      module InstanceMethods
+        attr_writer :_activity_execution_context
+        def activity_execution_context
+          raise IllegalStateException.new("No activity execution context") unless @_activity_execution_context
+          @_activity_execution_context
+        end
+        def record_activity_heartbeat(details)
+          @_activity_execution_context.record_activity_heartbeat(details)
+        end
+      end
+
+
+      # @!visibility private
+      extend Utilities::UpwardLookups
+
+      # @!visibility private
+      def look_upwards(variable)
+        precursors = self.ancestors.dup
+        precursors.delete(self)
+        results = precursors.map { |x| x.send(variable) if x.methods.map(&:to_sym).include? variable }.compact.flatten.uniq
+      end
+      property(:activities, [])
+
+      # @!visibility private
+      def _options; @activities.map(&:options); end
+
+      # Defines one or more activities, with {ActivityOptions} provided in the supplied block.
+      #
+      # @param [Array] activity_names
+      #   The names of the activities to define.
+      #
+      # @param [Hash] block
+      #   {ActivityOptions} to use on the defined activities.
+      #
+      # @example Defining an activity
+      #   new_activity_class = Class.new(MyActivity) do
+      #     extend Activities
+      #     activity :run_activity1 do
+      #     {
+      #       :default_task_heartbeat_timeout => "3600",
+      #       :default_task_list => task_list,
+      #       :default_task_schedule_to_close_timeout => "20",
+      #       :default_task_schedule_to_start_timeout => "20",
+      #       :default_task_start_to_close_timeout => "20",
+      #       :version => "1",
+      #       :prefix_name => "#{class_name}Activity"
+      #     }
+      #     end
+      #     def run_activity1
+      #     end
+      #   end
+      def activity(*activity_names, &block)
+        options = Utilities::interpret_block_for_options(ActivityOptions, block)
+        activity_names.each do |activity_name|
+          prefix_name = options.prefix_name || self.to_s
+          activity_type = ActivityType.new(prefix_name + "." + activity_name.to_s, options.version, options)
+          @activities ||= []
+          @activities << activity_type
+        end
+      end
+    end
+
+    #  This module is for internal use only and may be changed or removed
+    #  without prior notice. Use {Activities} instead.
+    # @!visibility private
+    module Activity
+      include Activities
+      def self.extended(base)
+        base.send :include, InstanceMethods
+      end
+    end
+
+
+  end
+end