temporal-ruby 0.0.0 → 0.0.1.pre.pre1

data/lib/temporal/workflow/history/window.rb

@@ -0,0 +1,40 @@
+module Temporal
+  class Workflow
+    class History
+      class Window
+        attr_reader :local_time, :last_event_id, :events, :markers
+
+        def initialize
+          @local_time = nil
+          @last_event_id = nil
+          @events = []
+          @markers = []
+          @replay = false
+        end
+
+        def replay?
+          @replay
+        end
+
+        def add(event)
+          case event.type
+          when 'MARKER_RECORDED'
+            markers << event
+          when 'WORKFLOW_TASK_STARTED'
+            @last_event_id = event.id + 1 # one for completed
+            @local_time = event.timestamp
+          when 'WORKFLOW_TASK_FAILED', 'WORKFLOW_TASK_TIMED_OUT'
+            @last_event_id = nil
+            @local_time = nil
+          when 'WORKFLOW_TASK_COMPLETED'
+            @replay = true
+          when 'WORKFLOW_TASK_SCHEDULED', 'WORKFLOW_TASK_FAILED'
+            # no-op
+          else
+            events << event
+          end
+        end
+      end
+    end
+  end
+end

data/lib/temporal/workflow/poller.rb

@@ -0,0 +1,67 @@
+require 'temporal/client'
+require 'temporal/middleware/chain'
+require 'temporal/workflow/task_processor'
+
+module Temporal
+  class Workflow
+    class Poller
+      def initialize(namespace, task_queue, workflow_lookup, middleware = [])
+        @namespace = namespace
+        @task_queue = task_queue
+        @workflow_lookup = workflow_lookup
+        @middleware = middleware
+        @shutting_down = false
+      end
+
+      def start
+        @shutting_down = false
+        @thread = Thread.new(&method(:poll_loop))
+      end
+
+      def stop
+        @shutting_down = true
+        Thread.new { Temporal.logger.info('Shutting down a workflow poller') }.join
+      end
+
+      def wait
+        @thread.join
+      end
+
+      private
+
+      attr_reader :namespace, :task_queue, :client, :workflow_lookup, :middleware
+
+      def client
+        @client ||= Temporal::Client.generate
+      end
+
+      def middleware_chain
+        @middleware_chain ||= Middleware::Chain.new(middleware)
+      end
+
+      def shutting_down?
+        @shutting_down
+      end
+
+      def poll_loop
+        while !shutting_down? do
+          Temporal.logger.debug("Polling worklow task queue (#{namespace} / #{task_queue})")
+
+          task = poll_for_task
+          process(task) if task&.workflow_type
+        end
+      end
+
+      def poll_for_task
+        client.poll_workflow_task_queue(namespace: namespace, task_queue: task_queue)
+      rescue StandardError => error
+        Temporal.logger.error("Unable to poll workflow task queue: #{error.inspect}")
+        nil
+      end
+
+      def process(task)
+        TaskProcessor.new(task, namespace, workflow_lookup, client, middleware_chain).process
+      end
+    end
+  end
+end

data/lib/temporal/workflow/replay_aware_logger.rb

@@ -0,0 +1,36 @@
+module Temporal
+  class Workflow
+    class ReplayAwareLogger
+      SEVERITIES = %i[debug info warn error fatal unknown].freeze
+
+      attr_writer :replay
+
+      def initialize(main_logger, replay = true)
+        @main_logger = main_logger
+        @replay = replay
+      end
+
+      SEVERITIES.each do |severity|
+        define_method severity do |message|
+          return if replay?
+
+          main_logger.public_send(severity, message)
+        end
+      end
+
+      def log(severity, message)
+        return if replay?
+
+        main_logger.log(severity, message)
+      end
+
+      private
+
+      attr_reader :main_logger
+
+      def replay?
+        @replay
+      end
+    end
+  end
+end

data/lib/temporal/workflow/state_manager.rb

@@ -0,0 +1,342 @@
+require 'temporal/json'
+require 'temporal/errors'
+require 'temporal/workflow/command'
+require 'temporal/workflow/command_state_machine'
+require 'temporal/workflow/history/event_target'
+require 'temporal/metadata'
+
+module Temporal
+  class Workflow
+    class StateManager
+      SIDE_EFFECT_MARKER = 'SIDE_EFFECT'.freeze
+      RELEASE_MARKER = 'RELEASE'.freeze
+
+      class UnsupportedEvent < Temporal::InternalError; end
+      class UnsupportedMarkerType < Temporal::InternalError; end
+
+      attr_reader :commands, :local_time
+
+      def initialize(dispatcher)
+        @dispatcher = dispatcher
+        @commands = []
+        @marker_ids = Set.new
+        @releases = {}
+        @side_effects = []
+        @command_tracker = Hash.new { |hash, key| hash[key] = CommandStateMachine.new }
+        @last_event_id = 0
+        @local_time = nil
+        @replay = false
+      end
+
+      def replay?
+        @replay
+      end
+
+      def schedule(command)
+        # Fast-forward event IDs to skip all the markers (version markers can
+        # be removed, so we can't rely on them being scheduled during a replay)
+        command_id = next_event_id
+        while marker_ids.include?(command_id) do
+          command_id = next_event_id
+        end
+
+        cancelation_id =
+          case command
+          when Command::ScheduleActivity
+            command.activity_id ||= command_id
+          when Command::StartChildWorkflow
+            command.workflow_id ||= command_id
+          when Command::StartTimer
+            command.timer_id ||= command_id
+          end
+
+        state_machine = command_tracker[command_id]
+        state_machine.requested if state_machine.state == CommandStateMachine::NEW_STATE
+
+        commands << [command_id, command]
+
+        return [event_target_from(command_id, command), cancelation_id]
+      end
+
+      def release?(release_name)
+        track_release(release_name) unless releases.key?(release_name)
+
+        releases[release_name]
+      end
+
+      def next_side_effect
+        side_effects.shift
+      end
+
+      def apply(history_window)
+        @replay = history_window.replay?
+        @local_time = history_window.local_time
+        @last_event_id = history_window.last_event_id
+
+        # handle markers first since their data is needed for processing events
+        history_window.markers.each do |event|
+          apply_event(event)
+        end
+
+        history_window.events.each do |event|
+          apply_event(event)
+        end
+      end
+
+      private
+
+      attr_reader :dispatcher, :command_tracker, :marker_ids, :side_effects, :releases
+
+      def next_event_id
+        @last_event_id += 1
+      end
+
+      def apply_event(event)
+        state_machine = command_tracker[event.originating_event_id]
+        target = History::EventTarget.from_event(event)
+
+        case event.type
+        when 'WORKFLOW_EXECUTION_STARTED'
+          state_machine.start
+          dispatch(
+            History::EventTarget.workflow,
+            'started',
+            parse_payload(event.attributes.input),
+            Metadata.generate(Metadata::WORKFLOW_TYPE, event.attributes)
+          )
+
+        when 'WORKFLOW_EXECUTION_COMPLETED'
+          # todo
+
+        when 'WORKFLOW_EXECUTION_FAILED'
+          # todo
+
+        when 'WORKFLOW_EXECUTION_TIMED_OUT'
+          # todo
+
+        when 'WORKFLOW_TASK_SCHEDULED'
+          # todo
+
+        when 'WORKFLOW_TASK_STARTED'
+          # todo
+
+        when 'WORKFLOW_TASK_COMPLETED'
+          # todo
+
+        when 'WORKFLOW_TASK_TIMED_OUT'
+          # todo
+
+        when 'WORKFLOW_TASK_FAILED'
+          # todo
+
+        when 'ACTIVITY_TASK_SCHEDULED'
+          state_machine.schedule
+          discard_command(event.originating_event_id)
+
+        when 'ACTIVITY_TASK_STARTED'
+          state_machine.start
+
+        when 'ACTIVITY_TASK_COMPLETED'
+          state_machine.complete
+          dispatch(target, 'completed', parse_payload(event.attributes.result))
+
+        when 'ACTIVITY_TASK_FAILED'
+          state_machine.fail
+          dispatch(target, 'failed', parse_failure(event.attributes.failure, ActivityException))
+
+        when 'ACTIVITY_TASK_TIMED_OUT'
+          state_machine.time_out
+          dispatch(target, 'failed', parse_failure(event.attributes.failure))
+
+        when 'ACTIVITY_TASK_CANCEL_REQUESTED'
+          state_machine.requested
+          discard_command(event.originating_event_id)
+
+        when 'REQUEST_CANCEL_ACTIVITY_TASK_FAILED'
+          state_machine.fail
+          dispatch(target, 'failed', event.attributes.cause, nil)
+
+        when 'ACTIVITY_TASK_CANCELED'
+          state_machine.cancel
+          dispatch(target, 'failed', parse_failure(event.attributes.failure))
+
+        when 'TIMER_STARTED'
+          state_machine.start
+          discard_command(event.originating_event_id)
+
+        when 'TIMER_FIRED'
+          state_machine.complete
+          dispatch(target, 'fired')
+
+        when 'CANCEL_TIMER_FAILED'
+          state_machine.failed
+          dispatch(target, 'failed', event.attributes.cause, nil)
+
+        when 'TIMER_CANCELED'
+          state_machine.cancel
+          dispatch(target, 'canceled')
+
+        when 'WORKFLOW_EXECUTION_CANCEL_REQUESTED'
+          # todo
+
+        when 'WORKFLOW_EXECUTION_CANCELED'
+          # todo
+
+        when 'REQUEST_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_INITIATED'
+          # todo
+
+        when 'REQUEST_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_FAILED'
+          # todo
+
+        when 'EXTERNAL_WORKFLOW_EXECUTION_CANCEL_REQUESTED'
+          # todo
+
+        when 'MARKER_RECORDED'
+          state_machine.complete
+          handle_marker(event.id, event.attributes.marker_name, parse_payload(event.attributes.details['data']))
+
+        when 'WORKFLOW_EXECUTION_SIGNALED'
+          dispatch(target, 'signaled', event.attributes.signal_name, parse_payload(event.attributes.input))
+
+        when 'WORKFLOW_EXECUTION_TERMINATED'
+          # todo
+
+        when 'WORKFLOW_EXECUTION_CONTINUED_AS_NEW'
+          # todo
+
+        when 'START_CHILD_WORKFLOW_EXECUTION_INITIATED'
+          state_machine.schedule
+          discard_command(event.originating_event_id)
+
+        when 'START_CHILD_WORKFLOW_EXECUTION_FAILED'
+          state_machine.fail
+          dispatch(target, 'failed', 'StandardError', parse_payload(event.attributes.cause))
+
+        when 'CHILD_WORKFLOW_EXECUTION_STARTED'
+          state_machine.start
+
+        when 'CHILD_WORKFLOW_EXECUTION_COMPLETED'
+          state_machine.complete
+          dispatch(target, 'completed', parse_payload(event.attributes.result))
+
+        when 'CHILD_WORKFLOW_EXECUTION_FAILED'
+          state_machine.fail
+          dispatch(target, 'failed', parse_failure(event.attributes.failure))
+
+        when 'CHILD_WORKFLOW_EXECUTION_CANCELED'
+          state_machine.cancel
+          dispatch(target, 'failed', parse_failure(event.attributes.failure))
+
+        when 'CHILD_WORKFLOW_EXECUTION_TIMED_OUT'
+          state_machine.time_out
+          dispatch(target, 'failed', parse_failure(event.attributes.failure))
+
+        when 'CHILD_WORKFLOW_EXECUTION_TERMINATED'
+          # todo
+
+        when 'SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_INITIATED'
+          # todo
+
+        when 'SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_FAILED'
+          # todo
+
+        when 'EXTERNAL_WORKFLOW_EXECUTION_SIGNALED'
+          # todo
+
+        when 'UPSERT_WORKFLOW_SEARCH_ATTRIBUTES'
+          # todo
+
+        else
+          raise UnsupportedEvent, event.type
+        end
+      end
+
+      def event_target_from(command_id, command)
+        target_type =
+          case command
+          when Command::ScheduleActivity
+            History::EventTarget::ACTIVITY_TYPE
+          when Command::RequestActivityCancellation
+            History::EventTarget::CANCEL_ACTIVITY_REQUEST_TYPE
+          when Command::RecordMarker
+            History::EventTarget::MARKER_TYPE
+          when Command::StartTimer
+            History::EventTarget::TIMER_TYPE
+          when Command::CancelTimer
+            History::EventTarget::CANCEL_TIMER_REQUEST_TYPE
+          when Command::CompleteWorkflow, Command::FailWorkflow
+            History::EventTarget::WORKFLOW_TYPE
+          when Command::StartChildWorkflow
+            History::EventTarget::CHILD_WORKFLOW_TYPE
+          end
+
+        History::EventTarget.new(command_id, target_type)
+      end
+
+      def dispatch(target, name, *attributes)
+        dispatcher.dispatch(target, name, attributes)
+      end
+
+      def discard_command(command_id)
+        commands.delete_if { |(id, _)| id == command_id }
+      end
+
+      def handle_marker(id, type, details)
+        marker_ids << id
+
+        case type
+        when SIDE_EFFECT_MARKER
+          side_effects << [id, details]
+        when RELEASE_MARKER
+          releases[details] = true
+        else
+          raise UnsupportedMarkerType, event.type
+        end
+      end
+
+      def track_release(release_name)
+        # replay does not allow untracked (via marker) releases
+        if replay?
+          releases[release_name] = false
+        else
+          releases[release_name] = true
+          schedule(Command::RecordMarker.new(name: RELEASE_MARKER, details: release_name))
+        end
+      end
+
+      def parse_payload(payload)
+        return if payload.nil? || payload.payloads.empty?
+
+        binary = payload.payloads.first.data
+        JSON.deserialize(binary)
+      end
+
+      def parse_failure(failure, default_exception_class = StandardError)
+        case failure.failure_info
+        when :application_failure_info
+          exception_class = safe_constantize(failure.application_failure_info.type)
+          exception_class ||= default_exception_class
+          details = parse_payload(failure.application_failure_info.details)
+          backtrace = failure.stack_trace.split("\n")
+
+          exception_class.new(details).tap do |exception|
+            exception.set_backtrace(backtrace) if !backtrace.empty?
+          end
+        when :timeout_failure_info
+          TimeoutError.new("Timeout type: #{failure.timeout_failure_info.timeout_type.to_s}")
+        when :canceled_failure_info
+          # TODO: Distinguish between different entity cancellations
+          StandardError.new(parse_payload(failure.canceled_failure_info.details))
+        else
+          StandardError.new(failure.message)
+        end
+      end
+
+      def safe_constantize(const)
+        Object.const_get(const) if Object.const_defined?(const)
+      rescue NameError
+        nil
+      end
+    end
+  end
+end