aws-flow 1.0.0

data/lib/aws/decider/state_machines.rb

@@ -0,0 +1,373 @@
+#--
+# 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
+
+    # @!visibility private
+    module DecisionStateMachineDFA
+      attr_accessor :transitions, :symbols, :states, :start_state
+
+      def init(start_state)
+        include InstanceMethods
+        @start_state = start_state
+        @symbols = []
+        @states = []
+        @transitions = {}
+        @states << start_state
+      end
+
+      def get_start_state
+        @start_state
+      end
+
+      def self_transitions(symbol)
+        states.each do |state|
+          add_transition(state, symbol, state) unless @transitions[[state, symbol]]
+        end
+      end
+
+      def get_transitions
+        # Turns out, you are your own ancestor
+        ancestors.slice(1..-1).map {|x| x.transitions if x.respond_to? :transitions}.compact.
+          inject({}) {|x, y| x.merge(y)}.merge(@transitions)
+      end
+
+      def add_transition(state, symbol, next_state, function = nil)
+        @symbols << symbol unless @symbols.include? symbol
+        [state, next_state].each do |this_state|
+          @states << this_state unless @states.include? this_state
+        end
+        @transitions[[state, symbol]] = [next_state, function]
+      end
+
+      def add_transitions(list_of_transitions)
+        list_of_transitions.each {|transition| add_transition(*transition)}
+      end
+
+      def uncovered_transitions
+        @states.product(@symbols) - @transitions.keys
+      end
+
+      module InstanceMethods
+        attr_accessor :current_state
+
+        def consume(symbol)
+          @state_history ||= [self.class.get_start_state]
+          @state_history << @current_state
+          @state_history << symbol
+          transition_tuple = self.class.get_transitions[[@current_state, symbol]]
+          raise "This is not a legal transition, attempting to consume #{symbol} while at state #{current_state}" unless transition_tuple
+          @current_state, func_to_call = transition_tuple
+          @state_history << @current_state
+          func_to_call.call(self) if func_to_call
+        end
+      end
+    end
+
+    # @!visibility private
+    class CompleteWorkflowStateMachine
+      extend DecisionStateMachineDFA
+      attr_reader :id
+      def consume(symbol)
+        return @decision = nil if symbol == :handle_initiation_failed_event
+        return if symbol == :handle_decision_task_started_event
+        raise "UnsupportedOperation"
+      end
+      # Creates a new CompleteWorkflowStateMachine
+      #
+      # @param id
+      #   The decider id.
+      #
+      # @param attributes
+      #
+
+      def done?
+        ! @decision.nil?
+      end
+      def initialize(id, decision)
+        @id = id
+        @decision = decision
+        @current_state = :created
+      end
+      init(:created)
+
+      def get_decision
+        return @decision
+      end
+    end
+
+
+    # @!visibility private
+    class DecisionStateMachineBase
+      extend DecisionStateMachineDFA
+      attr_reader :id
+
+      def initialize(id)
+        @id = id
+        @current_state = :created
+      end
+
+
+      def handle_started_event(event)
+        @state_history << :handle_started_event
+      end
+
+      init(:created)
+
+      add_transitions [
+       [:cancellation_decision_sent, :handle_cancellation_event, :completed],
+       [:cancellation_decision_sent, :handle_cancellation_initiated_event, :cancellation_decision_sent],
+       [:cancellation_decision_sent, :handle_completion_event, :completed_after_cancellation_decision_sent],
+       [:cancelled_after_initiated, :handle_completion_event, :cancelled_after_initiated],
+       [:cancelled_before_initiated, :handle_initiated_event, :cancelled_after_initiated],
+       [:cancelled_before_initiated, :handle_initiation_failed_event, :completed],
+       [:completed_after_cancellation_decision_sent, :handle_cancellation_failure_event, :completed],
+       [:created, :cancel, :completed, lambda { |immediate_cancellation_callback| immediate_cancellation_callback.run }],
+       [:created, :handle_decision_task_started_event, :decision_sent],
+       [:decision_sent, :cancel, :cancelled_before_initiated],
+       [:decision_sent, :handle_initiated_event, :initiated],
+       [:decision_sent, :handle_initiation_failed_event, :decision_sent],
+       [:initiated, :cancel, :cancelled_after_initiated],
+                       [:initiated, :handle_completion_event, :completed],
+                       [:started, :handle_decision_task_started_event, :started],
+                      ]
+      self_transitions(:handle_decision_task_started_event)
+
+      def done?
+        @current_state == :completed || @current_state == :completed_after_cancellation_decision_sent
+      end
+    end
+
+
+    # @!visibility private
+    class ActivityDecisionStateMachine < DecisionStateMachineBase
+
+      attr_reader :attributes
+      # Creates a new `ActivityDecisionStateMachine`.
+      #
+      # @param [DecisionID] decision_id
+      #
+      # @param attributes
+      #
+      def initialize(decision_id, attributes)
+        @attributes = attributes
+        super(decision_id)
+      end
+      init(:created)
+      add_transitions [
+       [:cancelled_after_initiated, :handle_decision_task_started_event, :cancellation_decision_sent],
+       [:cancellation_decision_sent, :handle_cancellation_failure_event, :initiated]
+      ]
+      def get_decision
+        case @current_state
+        when :created
+          return create_schedule_activity_task_decision
+        when :cancelled_after_initiated
+          return create_request_cancel_activity_task_decision
+        end
+      end
+
+      def create_schedule_activity_task_decision
+        options = @attributes[:options]
+        attribute_type = :schedule_activity_task_decision_attributes
+        result = { :decision_type => "ScheduleActivityTask",
+            attribute_type =>
+            {
+              :activity_type =>
+              {
+                :name => @attributes[:activity_type].name.to_s,
+                :version => options.version.to_s
+              },
+              :activity_id => @attributes[:decision_id].to_s,
+            }
+        }
+        task_list = options.task_list ? {:task_list => {:name => options.task_list}} : {}
+        to_add = options.get_options([:heartbeat_timeout, :schedule_to_close_timeout, :schedule_to_start_timeout, :start_to_close_timeout, :input], task_list)
+        result[attribute_type].merge!(to_add)
+        result
+      end
+
+      def create_request_cancel_activity_task_decision
+        { :decision_type => "RequestCancelActivityTask",
+          :request_cancel_activity_task_decision_attributes => {:activity_id => @attributes[:decision_id]} }
+      end
+    end
+
+
+    # @!visibility private
+    class TimerDecisionStateMachine < DecisionStateMachineBase
+      attr_accessor :cancelled
+      def initialize(decision_id, attributes)
+        @attributes = attributes
+        super(decision_id)
+      end
+
+      def create_start_timer_decision
+        {
+          :decision_type => "StartTimer",
+          :start_timer_decision_attributes =>
+          {
+            :timer_id => @attributes[:timer_id].to_s,
+            # TODO find out what the "control" field is, and what it is for
+            :start_to_fire_timeout => @attributes[:start_to_fire_timeout]
+          }
+        }
+      end
+
+      def create_cancel_timer_decision
+        {
+          :decision_type => "CancelTimer",
+          :cancel_timer_decision_attributes => {
+            :timer_id => @attributes[:timer_id].to_s,
+          }
+        }
+      end
+
+      def get_decision
+        case @current_state
+        when :created
+          return create_start_timer_decision
+        when :cancelled_after_initiated
+          return create_cancel_timer_decision
+        end
+      end
+
+      def done?
+        @current_state == :completed || @cancelled
+      end
+
+      init(:created)
+      add_transitions [
+       [:cancelled_after_initiated, :handle_decision_task_started_event, :cancellation_decision_sent],
+       [:cancellation_decision_sent, :handle_cancellation_failure_event, :initiated],
+      ]
+    end
+
+
+    # @!visibility private
+    class SignalDecisionStateMachine < DecisionStateMachineBase
+      def initialize(decision_id, attributes)
+        @attributes = attributes
+        super(decision_id)
+      end
+
+      def get_decision
+        case @current_state
+        when :created
+          return create_signal_external_workflow_execution_decison
+        end
+      end
+
+      def create_signal_external_workflow_execution_decison
+        extra_options = {}
+        [:input, :control, :run_id].each do |type|
+          extra_options[type] = @attributes.send(type) if @attributes.send(type)
+        end
+        result = {
+          :decision_type => "SignalExternalWorkflowExecution",
+          :signal_external_workflow_execution_decision_attributes =>
+          {
+            :signal_name => @attributes.signal_name,
+            :workflow_id => @attributes.workflow_id
+          }
+        }
+        if ! extra_options.empty?
+          result[:signal_external_workflow_execution_decision_attributes].merge! extra_options
+        end
+        result
+      end
+      init(:created)
+      add_transitions [
+                       [:created, :handle_decision_task_started_event, :decision_sent],
+                       [:created, :cancel, :created],
+                       [:initiated, :cancel, :completed, lambda {|immediate_cancellation_callback| immediate_cancellation_callback.run }],
+                       [:decision_sent, :handle_initiated_event, :initiated],
+                       [:cancelled_before_initiated, :handle_initiated_event, :cancelled_before_initiated],
+                       [:decision_sent, :handle_completion_event, :completed],
+                       [:initiated, :handle_completion_event, :completed],
+                       [:cancelled_before_initiated, :handle_completion_event, :completed],
+                       [:completed, :handle_completion_event, :completed]
+                      ]
+
+    end
+
+
+    # @!visibility private
+    class ChildWorkflowDecisionStateMachine < DecisionStateMachineBase
+      attr_accessor :run_id, :attributes
+      def initialize(decision_id, attributes)
+        @attributes = attributes
+        super(decision_id)
+      end
+
+      def create_start_child_workflow_execution_decision
+        options = @attributes[:options]
+        workflow_name = options.workflow_name || options.prefix_name
+        attribute_name = :start_child_workflow_execution_decision_attributes
+        result = {
+          :decision_type => "StartChildWorkflowExecution",
+           attribute_name =>
+          {
+            :workflow_type =>
+            {
+              :name => "#{workflow_name}.#{options.execution_method}",
+              :version => options.version
+            },
+            :workflow_id => @attributes[:workflow_id].to_s,
+            :task_list => {
+              :name => options.task_list
+            },
+            # :control => @attributes[:control]
+            :tag_list => @attributes[:tag_list]
+          }
+        }
+        #TODO Figure out what control is
+        to_add = options.get_options([:execution_start_to_close_timeout, :task_start_to_close_timeout, :child_policy, :tag_list, :input])
+        result[attribute_name].merge!(to_add)
+        result
+      end
+
+      def create_request_cancel_external_workflow_execution_decision
+        result = {
+          :decision_type => "RequestCancelExternalWorkflowExecution",
+          :request_cancel_external_workflow_execution_decision_attributes => {
+            :workflow_id => @attributes[:workflow_id].to_s,
+            :run_id => @run_id.to_s,
+          }
+        }
+      end
+
+      def get_decision
+        case @current_state
+        when :created
+          return create_start_child_workflow_execution_decision
+        when :cancelled_after_started
+          return create_request_cancel_external_workflow_execution_decision
+        end
+      end
+      init(:created)
+      add_transitions [
+                       [:cancelled_after_started, :handle_decision_task_started_event, :cancellation_decision_sent],
+                       [:initiated, :handle_started_event, :started],
+                       [:cancelled_after_initiated, :handle_started_event, :cancelled_after_started],
+                       [:cancellation_decision_sent, :handle_cancellation_failure_event, :started],
+                       [:started, :cancel, :cancelled_after_started],
+                       [:started, :handle_completion_event, :completed],
+                       [:cancelled_after_started, :handle_completion_event, :completed],
+                      ]
+    end
+  end
+end

data/lib/aws/decider/task_handler.rb

@@ -0,0 +1,76 @@
+#--
+# 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
+
+
+    # A decision task handler to work with a {WorkflowTaskPoller}. Create a DecisionTaskHandler and pass it to
+    # WorkflowTaskPoller on {WorkflowTaskPoller#initialize construction}.
+    class DecisionTaskHandler
+
+      # Creates a new DecisionTaskHandler
+      #
+      # @param workflow_definition_map
+      #
+      # @param options
+      #   An optional logger.
+      #
+      def initialize(workflow_definition_map, options=nil)
+        @workflow_definition_map = workflow_definition_map
+        @logger = options.logger if options
+        @logger ||= Utilities::LogFactory.make_logger(self, "debug")
+      end
+
+
+      # Handles a decision task
+      #
+      # @param decision_task_iterator
+      #
+      def handle_decision_task(decision_task_iterator)
+        history_helper = HistoryHelper.new(decision_task_iterator)
+        @logger.debug "made history_helper"
+        decider = create_async_decider(history_helper)
+        @logger.debug "made async_decider"
+        decider.decide
+        @logger.debug "decided"
+        decisions = decider.get_decisions
+        response = {:task_token => decider.task_token}
+        context_data = decider.decision_helper.workflow_context_data
+        response[:execution_context] = context_data.to_s unless context_data.nil?
+        response[:decisions] = decisions unless decisions.nil?
+        return response
+      end
+
+      # Creates a new asynchronous decider.
+      #
+      # @param history_helper
+      #
+      # @return [AsyncDecider] the created AsyncDecider.
+      #
+      def create_async_decider(history_helper)
+        task = history_helper.get_decision_task
+        workflow_type = task.workflow_type
+        # TODO put in context correctly
+        workflow_definition_factory = @workflow_definition_map[workflow_type]
+        raise "No such definition for #{workflow_type}" if workflow_definition_factory.nil?
+        AsyncDecider.new(workflow_definition_factory, history_helper, DecisionHelper.new)
+      end
+
+    end
+
+  end
+
+end

data/lib/aws/decider/task_poller.rb

@@ -0,0 +1,207 @@
+#--
+# 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 'tmpdir'
+
+module AWS
+  module Flow
+
+    class WorkflowTaskPoller
+
+
+      # Creates a new WorkflowTaskPoller
+      #
+      # @param service
+      #   The Amazon SWF service object on which this task poller will operate.
+      #
+      # @param [String] domain
+      #   The name of the domain containing the task lists to poll.
+      #
+      # @param [DecisionTaskHandler] handler
+      #   A {DecisionTaskHandler} to handle polled tasks. The poller will call the {DecisionTaskHandler#handle_decision_task} method.
+      #
+      # @param [Array] task_list
+      #   Specifies the task list to poll for decision tasks.
+      #
+      # @param [Object] options
+      #   Options to use for the logger.
+      #
+      def initialize(service, domain, handler, task_list, options=nil)
+        @service = service
+        @handler = handler
+        @domain = domain
+        @task_list = task_list
+        @logger = options.logger if options
+        @logger ||= Utilities::LogFactory.make_logger(self, "debug")
+      end
+
+
+
+      # Retrieves any decision tasks that are ready.
+      def get_decision_tasks
+        @domain.decision_tasks.poll_for_single_task(@task_list)
+      end
+
+      def poll_and_process_single_task
+        # TODO waitIfSuspended
+        begin
+          @logger.debug "Starting a new task...\n\n\n"
+          tasks = get_decision_tasks
+          return false if tasks.nil?
+          @logger.debug "We have this many tasks #{tasks}"
+          @logger.debug "debugging on #{tasks}\n"
+          task_completed_request = @handler.handle_decision_task(tasks)
+          @logger.debug "task to be responded to with #{task_completed_request}\n"
+          if !task_completed_request[:decisions].empty? && (task_completed_request[:decisions].first.keys.include?(:fail_workflow_execution_decision_attributes))
+            fail_hash = task_completed_request[:decisions].first[:fail_workflow_execution_decision_attributes]
+            reason = fail_hash[:reason]
+            details = fail_hash[:details]
+            @logger.debug "#{reason}, #{details}"
+          end
+          @service.respond_decision_task_completed(task_completed_request)
+        rescue AWS::SimpleWorkflow::Errors::UnknownResourceFault => e
+          # Log stuff
+          @logger.debug "Error in the poller, #{e}"
+          @logger.debug "The error class in #{e.class}"
+        end
+      end
+    end
+
+    class ActivityTaskPoller
+      def initialize(service, domain, task_list, activity_definition_map, options=nil)
+        @service = service
+        @domain = domain
+        @task_list = task_list
+        @activity_definition_map = activity_definition_map
+        @logger = options.logger if options
+        @logger ||= Utilities::LogFactory.make_logger(self, "debug")
+        max_workers = options.execution_workers if options
+        max_workers = 20 if (max_workers.nil? || max_workers.zero?)
+        @executor = ForkingExecutor.new(:max_workers => max_workers, :logger => @logger)
+
+      end
+
+      def execute(task)
+        activity_type = task.activity_type
+        begin
+          context = ActivityExecutionContext.new(@service, @domain, task)
+          activity_implementation = @activity_definition_map[activity_type]
+          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
+            @service.respond_activity_task_completed(:task_token => task.task_token, :result => output)
+          end
+        rescue ActivityFailureException => e
+          respond_activity_task_failed_with_retry(task.task_token, e.message, e.details)
+        end
+        #TODO all the completion stuffs
+      end
+
+      def respond_activity_task_failed_with_retry(task_token, reason, details)
+        #TODO Set up this variable
+        if @failure_retrier.nil?
+          respond_activity_task_failed(task_token, reason, details)
+          #TODO Set up other stuff to do if we have it
+        end
+      end
+
+      def respond_activity_task_canceled_with_retry(task_token, message)
+        if @failure_retrier.nil?
+          respond_activity_task_canceled(task_token, message)
+        end
+        #TODO Set up other stuff to do if we have it
+      end
+
+      def respond_activity_task_canceled(task_token, message)
+        @service.respond_activity_task_canceled({:task_token => task_token, :details => message})
+      end
+
+      def respond_activity_task_failed(task_token, reason, details)
+        @logger.debug "The task token to be reported on is #{task_token}"
+        @service.respond_activity_task_failed(:task_token => task_token, :reason => reason.to_s, :details => details.to_s)
+      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))
+        begin
+          begin
+            execute(task)
+          rescue CancellationException => e
+            respond_activity_task_canceled_with_retry(task.task_token, e.message)
+          rescue Exception => e
+            @logger.error "Got an error, #{e.message}, while executing #{task.activity_type.name}"
+            @logger.error "Full stack trace: #{e.backtrace}"
+            respond_activity_task_failed_with_retry(task.task_token, e.message, e.backtrace)
+            #Do rescue stuff
+          ensure
+            @poll_semaphore.release
+          end
+        rescue Exception => e
+          semaphore_needs_release = true
+          @logger.debug "Got into the other error mode"
+          raise e
+        ensure
+          @poll_semaphore.release if semaphore_needs_release
+        end
+      end
+
+      def poll_and_process_single_task(use_forking = true)
+
+        @poll_semaphore ||= SuspendableSemaphore.new
+        @poll_semaphore.acquire
+        semaphore_needs_release = true
+        @logger.debug "before the poll\n\n"
+        begin
+          task = @domain.activity_tasks.poll_for_single_task(@task_list)
+          @logger.error "got a task, #{task.activity_type.name}"
+          @logger.error "The task token I got was: #{task.task_token}"
+        rescue Exception => e
+          @logger.debug "I have not been able to poll successfully, and am now bailing out, with error #{e}"
+          @poll_semaphore.release
+          return false
+        end
+        if task.nil?
+          "Still polling at #{Time.now}, but didn't get anything"
+          @logger.debug "Still polling at #{Time.now}, but didn't get anything"
+          @poll_semaphore.release
+          return false
+        end
+        semaphore_needs_release = false
+        if use_forking
+          @executor.execute { process_single_task(task) }
+        else
+          process_single_task(task)
+        end
+        # process_single_task(task)
+        @logger.debug "finished executing the task"
+        return true
+      end
+    end
+
+    class SuspendableSemaphore
+
+      def initialize
+
+      end
+
+      def acquire
+      end
+
+      def release
+      end
+    end
+  end
+end