aws-flow 1.0.0

data/lib/aws/decider/decision_context.rb

@@ -0,0 +1,60 @@
+#--
+# 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
+     class DecisionContext
+       attr_accessor :activity_client, :workflow_client, :workflow_clock, :workflow_context, :decision_helper
+       def initialize(activity_client, workflow_client, workflow_clock, workflow_context, decision_helper)
+         @activity_client = activity_client
+         @workflow_client = workflow_client
+         @workflow_clock = workflow_clock
+         @workflow_context = workflow_context
+         @decision_helper = decision_helper
+       end
+     end
+
+
+     # The context for a workflow
+     class WorkflowContext
+
+       attr_accessor :continue_as_new_options
+       # The decision task method for this workflow.
+       attr_accessor :decision_task
+
+       # The {WorkflowClock} for this workflow.
+       attr_accessor :workflow_clock
+
+       # Creates a new `WorkflowContext`
+       #
+       # @param decision_task
+       #   The decision task method for this workflow. This is accessible after instance creation by using the
+       #   {#decision_task} attribute.
+       #
+       # @param workflow_clock
+       #   The {WorkflowClock} to use to schedule timers for this workflow. This is accessible after instance
+       #   creation by using the {#workflow_clock} attribute.
+       #
+       def initialize(decision_task, workflow_clock)
+         @decision_task = decision_task
+         @workflow_clock = workflow_clock
+       end
+       def workflow_execution
+         @decision_task.workflow_execution
+       end
+     end
+
+   end
+ end

data/lib/aws/decider/exceptions.rb

@@ -0,0 +1,178 @@
+#--
+# 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
+
+
+        # Exception used to communicate failure during fulfillment of a decision sent to SWF. This exception and all its
+    # subclasses are expected to be thrown by the framework.
+    class DecisionException < Exception
+      attr_accessor :event_id
+    end
+
+
+    # An exception that serves as the base for {ChildWorkflowFailedException}, {FailWorkflowExecutionException}, and
+    # {ActivityFailureException}.
+    class FlowException < Exception
+      # A string containing the reason for the exception.
+      attr_accessor :reason
+
+      # A string containing details for the exception.
+      attr_accessor :details
+
+      # Creates a new FlowException.
+      #
+      # @param reason [String]
+      #   The reason for the exception. This is made available to the exception receiver through the {#reason}
+      #   attribute.
+      #
+      # @param details [String]
+      #   The details of the exception. This is made available to the exception receiver through the {#details}
+      #   attribute.
+      #
+      def initialize(reason = "Something went wrong in Flow",
+                     details = "But this indicates that it got corrupted getting out")
+        @reason = reason
+        @details = details
+        details = details.message if details.is_a? Exception
+        self.set_backtrace(details)
+      end
+    end
+
+
+
+    class ChildWorkflowException < FlowException
+      def detail_termination(message, event_id, workflow_execution, workflow_type)
+        "#{message} for workflow_execution #{workflow_execution.to_s} with event_id #{event_id}"
+      end
+    end
+
+    class ChildWorkflowTerminatedException < ChildWorkflowException
+      def initialize(event_id, workflow_execution, workflow_type)
+        @reason = "WF exception terminated"
+        @detail = detail_termination("Terminated", event_id, workflow_execution, workflow_type)
+        # TODO: we'll likely want to provide more info later, but it'll take a bit to plumb it
+        # @detail = "Terminate for workflow_execution #{workflow_execution.to_s} of workflow_type #{workflow_type.to_s} with event_id #{event_id}"
+      end
+    end
+    class ChildWorkflowTimedOutException < ChildWorkflowException
+      def initialize(event_id, workflow_execution, workflow_type)
+        @reason = "WF exception timed out"
+        @detail = detail_termination("Timed out", event_id, workflow_execution, workflow_type)
+
+      end
+    end
+    # Unhandled exceptions in child workflows are reported back to the parent workflow implementation by throwing a
+    # `ChildWorkflowFailedException`. The original exception can be retrieved from the {#reason} attribute of this
+    # exception. The exception also provides information in the {#details} attribute that is useful for debugging
+    # purposes, such as the unique identifiers of the child execution.
+    #
+    # @abstract An exception raised when the child workflow execution has failed.
+    #
+    class ChildWorkflowFailedException < FlowException
+
+      attr_accessor :cause, :details
+      # Creates a new `ChildWorkflowFailedException`
+      #
+      # @param event_id
+      #   The event id for the exception.
+      #
+      # @param execution
+      #   The child workflow execution that raised the exception.
+      #
+      # @param workflow_type
+      #   The workflow type of the child workflow that raised the exception.
+      #
+      # @param (see FlowException#initialize)
+      #
+      def initialize(event_id, execution, workflow_type, reason, details)
+        @cause = details
+        # TODO This should probably do more with the event_id, execution, workflow_type
+        super(reason, details)
+      end
+    end
+
+
+    # @abstract An exception raised when the workflow execution has failed.
+    class FailWorkflowExecutionException < FlowException
+    end
+
+
+    # This exception is used by the framework internally to communicate activity failure. When an activity fails due to
+    # an unhandled exception, it is wrapped in ActivityFailureException and reported to Amazon SWF. You need to deal
+    # with this exception only if you use the activity worker extensibility points. Your application code will never
+    # need to deal with this exception.
+    #
+    # @abstract An exception raised when the activity has failed.
+    class ActivityFailureException < FlowException
+    end
+    class WorkflowException < FlowException; end
+    class SignalExternalWorkflowException < FlowException
+      def initialize(event_id, workflow_execution, cause)
+        super("Signalling the external workflow failed", cause)
+      end
+    end
+
+    class StartChildWorkflowFailedException < FlowException
+      def initialize(event_id, workflow_execution, workflow_type, cause)
+        super("failed to start child workflow", cause)
+      end
+    end
+    class StartTimerFailedException < FlowException
+      def initialize(event_id, timer_id, user_context, cause)
+        super("Timerid #{timer_id} got messed up", cause)
+      end
+    end
+    # This exception is thrown if an activity was timed out by Amazon SWF. This could happen if the activity task could
+    # not be assigned to the worker within the require time period or could not be completed by the worker in the
+    # required time. You can set these timeouts on the activity using the @ActivityRegistrationOptions annotation or
+    # using the ActivitySchedulingOptions parameter when calling the activity method.
+    #
+    # @abstract An exception raised when the activity task has timed out.
+    class ActivityTaskTimedOutException < ActivityFailureException
+
+      # Creates a new ActivityTaskTimeoutException
+      def initialize(id, activity_id, reason, details)
+        @id = id
+        @activity_id = activity_id
+        super(reason, details)
+      end
+    end
+
+    class ScheduleActivityTaskFailedException < FlowException
+      def initialize(event_id, activity_type, activity_id, cause)
+        super("Schedule activity task failed", cause)
+      end
+    end
+
+    # Unhandled exceptions in activities are reported back to the workflow implementation by throwing an
+    # `ActivityTaskFailedException`. The original exception can be retrieved from the reason attribute of this
+    # exception. The exception also provides information in the `details` attribute that is useful for debugging
+    # purposes, such as the unique activity identifier in the history.
+    #
+    # @abstract An exception raised when the activity task has failed.
+    class ActivityTaskFailedException < ActivityFailureException
+      attr_accessor :cause, :details
+      # Creates a new ActivityTaskFailedException
+      def initialize(id, activity_id, reason, details)
+        @id = id
+        @activity_id = activity_id
+        @cause = details
+        super(reason, details)
+      end
+    end
+  end
+end

data/lib/aws/decider/executor.rb

@@ -0,0 +1,149 @@
+#--
+# 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'
+require 'logger'
+
+module AWS
+  module Flow
+
+    class LogMock
+      attr_accessor :log_level
+      def initialize()
+      end
+      def info(s)
+        p "info: #{s}" if @log_level > 4
+      end
+      def debug(s)
+        p "debug: #{s}" if @log_level > 3
+      end
+      def warn(s)
+        p "warn: #{s}" if @log_level > 2
+      end
+      def error(s)
+        p "error: #{s}" if @log_level > 1
+        p s.backtrace if s.respond_to?(:backtrace)
+      end
+    end
+    class RejectedExecutionException < Exception; end
+
+    class ForkingExecutor
+
+      class << self
+        attr_accessor :executors
+      end
+      attr_accessor :max_workers, :pids, :is_shutdown
+
+      def initialize(options = {})
+        @log = options[:logger]
+        @log ||= Logger.new("#{Dir.tmpdir}/forking_log")
+        @semaphore = Mutex.new
+        log_level = options[:log_level] || 4
+        @log.level = Logger::DEBUG
+        @log.info("LOG INITIALIZED")
+        @max_workers = options[:max_workers] || 1
+        @pids = []
+        @is_shutdown = false
+        ForkingExecutor.executors ||= []
+        ForkingExecutor.executors << self
+      end
+
+      def execute(&block)
+        @log.error "Here are the pids that are currently running #{@pids}"
+        raise RejectedExecutionException if @is_shutdown
+        block_on_max_workers
+        @log.debug "PARENT BEFORE FORK #{Process.pid}"
+        child_pid = fork do
+          begin
+            @log.debug "CHILD #{Process.pid}"
+            # TODO: which signals to ignore?
+            # ignore signals in the child
+            %w{ TERM INT HUP SIGUSR2 }.each { |signal| Signal.trap(signal, 'SIG_IGN') }
+            block.call
+            @log.debug "CHILD #{Process.pid} AFTER block.call"
+            Process.exit!(0)
+          rescue => e
+            @log.error e
+            @log.error "Definitely dying off right here"
+            Process.exit!(1)
+          end
+        end
+        @log.debug "PARENT AFTER FORK #{Process.pid}, child_pid=#{child_pid}"
+        @pids << child_pid
+      end
+
+      def shutdown(timeout_seconds)
+        @is_shutdown = true
+        remove_completed_pids
+
+        unless @pids.empty?
+          @log.info "Exit requested, waiting up to #{timeout_seconds} seconds for child processes to finish"
+
+          # check every second for child processes to finish
+          timeout_seconds.times do
+            sleep 1
+            remove_completed_pids
+            break if @pids.empty?
+          end
+
+          # forcibly kill all remaining children
+          unless @pids.empty?
+            @log.warn "Child processes still running, sending KILL signal: #{@pids.join(',')}"
+            @pids.each { |pid| Process.kill('KILL', pid) }
+          end
+        end
+      end
+
+      private
+
+      # Remove all child processes from @pids list that have finished
+      # Block for at least one child to finish if block argument is set to true
+      def remove_completed_pids(block=false)
+        loop do
+          # waitpid2 throws an Errno::ECHILD if there are no child processes,
+          # so we don't even call it if there aren't any pids to wait on
+          break if @pids.empty?
+          # non-blocking wait - only returns a non-null pid
+          # if the child process has exited
+          pid, status = Process.waitpid2(-1, block ? 0 : Process::WNOHANG)
+          @log.debug "#{pid}"
+          # no more children have finished
+          break unless pid
+
+          if status.success?
+            @log.debug "Worker #{pid} exited successfully"
+          else
+            @log.error "Worker #{pid} exited with non-zero status code"
+          end
+          @pids.delete(pid)
+          break if pid
+        end
+      end
+
+      def block_on_max_workers
+        @log.debug "block_on_max_workers workers=#{@pids.size}, max_workers=#{@max_workers}"
+        start_time = Time.now
+        if @pids.size > @max_workers
+          @log.info "Reached maximum number of workers (#{@max_workers}), \
+                     waiting for some to finish before polling again"
+          begin
+            remove_completed_pids(true)
+          end while @pids.size > @max_workers
+        end
+      end
+    end
+
+  end
+end

data/lib/aws/decider/flow_defaults.rb

@@ -0,0 +1,70 @@
+#--
+# 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
+    class FlowConstants
+      class << self
+        attr_reader :exponential_retry_maximum_retry_interval_seconds, :exponential_retry_retry_expiration_seconds, :exponential_retry_backoff_coefficient, :exponential_retry_maximum_attempts, :exponential_retry_function, :default_data_converter, :exponential_retry_exceptions_to_include, :exponential_retry_exceptions_to_exclude, :jitter_function, :should_jitter
+        # # The maximum exponential retry interval, in seconds. Use the value -1 (the default) to set <i>no maximum</i>.
+        # attr_reader :exponential_retry_maximum_retry_interval_seconds
+
+        # # The maximum time that can pass, in seconds, before the exponential retry attempt is considered a failure. Use
+        # # the value -1 (the default) to set <i>no maximum</i>.
+        # attr_reader :exponential_retry_retry_expiration_seconds
+
+        # # The coefficient used to determine how much to back off the interval timing for an exponential retry scenario.
+        # # The default value, 2.0, causes each attempt to wait twice as long as the previous attempt.
+        # attr_reader :exponential_retry_backoff_coefficient
+
+        # # The maximum number of attempts to make for an exponential retry of a failed task. The default value is
+        # # Float::INFINITY.
+        # attr_reader :exponential_retry_maximum_attempts
+
+        # # The default exponential retry function.
+        # attr_reader :exponential_retry_function
+
+        # The DataConverter for instances of this class.
+        attr_reader :default_data_converter
+      end
+      INFINITY = -1
+      @exponential_retry_maximum_attempts = Float::INFINITY
+      @exponential_retry_maximum_retry_interval_seconds = -1
+      @exponential_retry_retry_expiration_seconds = -1
+      @exponential_retry_backoff_coefficient = 2.0
+      @exponential_retry_initial_retry_interval = 2
+      @should_jitter = true
+      @exponential_retry_exceptions_to_exclude = []
+      @exponential_retry_exceptions_to_include = [Exception]
+      @exponential_retry_function = lambda do |first, time_of_failure, attempts|
+        raise ArgumentError.new("first is not an instance of Time") unless first.instance_of?(Time)
+        raise ArgumentError.new("time_of_failure can't be negative") if time_of_failure < 0
+        raise ArgumentError.new("number of attempts can't be negative") if (attempts.values.find {|x| x < 0})
+        result = @exponential_retry_initial_retry_interval * (@exponential_retry_backoff_coefficient ** (attempts.values.reduce(0, :+) - 2))
+        result = @exponential_retry_maximum_retry_interval_seconds if @exponential_retry_maximum_retry_interval_seconds != INFINITY && result > @exponential_retry_maximum_retry_interval_seconds
+        seconds_since_first_attempt = time_of_failure.zero? ? 0 : -(first - time_of_failure).to_i
+        result = -1 if @exponential_retry_retry_expiration_seconds != INFINITY && (result + seconds_since_first_attempt) >= @exponential_retry_retry_expiration_seconds
+        return result.to_i
+      end
+
+      @jitter_function = lambda do |seed, max_value|
+         random = Random.new(seed.to_i)
+         random.rand(max_value)
+      end
+
+      @default_data_converter = YAMLDataConverter.new
+    end
+  end
+end