temporal-ruby 0.0.0 → 0.0.1.pre.pre1

data/lib/temporal/workflow/convenience_methods.rb

@@ -0,0 +1,34 @@
+# This module provides a set of methods for imitating direct Child Workflow calls
+# from within Workflows:
+#
+# class TestWorkflow < Temporal::Workflow
+#   def execute
+#     ChildWorkflow.execute!('foo', 'bar')
+#   end
+# end
+#
+# This is analogous to calling:
+#
+# workflow.execute_workflow(ChildWorkflow, 'foo', 'bar')
+#
+require 'temporal/thread_local_context'
+
+module Temporal
+  class Workflow
+    module ConvenienceMethods
+      def execute(*input, **args)
+        context = Temporal::ThreadLocalContext.get
+        raise 'Called Workflow#execute outside of a Workflow context' unless context
+
+        context.execute_workflow(self, *input, **args)
+      end
+
+      def execute!(*input, **args)
+        context = Temporal::ThreadLocalContext.get
+        raise 'Called Workflow#execute! outside of a Workflow context' unless context
+
+        context.execute_workflow!(self, *input, **args)
+      end
+    end
+  end
+end

data/lib/temporal/workflow/dispatcher.rb

@@ -0,0 +1,31 @@
+module Temporal
+  class Workflow
+    class Dispatcher
+      WILDCARD = '*'.freeze
+
+      def initialize
+        @handlers = Hash.new { |hash, key| hash[key] = [] }
+      end
+
+      def register_handler(target, event_name, &handler)
+        handlers[target] << [event_name, handler]
+      end
+
+      def dispatch(target, event_name, args = nil)
+        handlers_for(target, event_name).each do |handler|
+          handler.call(*args)
+        end
+      end
+
+      private
+
+      attr_reader :handlers
+
+      def handlers_for(target, event_name)
+        handlers[target]
+          .select { |(name, _)| name == event_name || name == WILDCARD }
+          .map(&:last)
+      end
+    end
+  end
+end

data/lib/temporal/workflow/execution_info.rb

@@ -0,0 +1,51 @@
+module Temporal
+  class Workflow
+    class ExecutionInfo < Struct.new(:workflow, :workflow_id, :run_id, :start_time, :close_time, :status, :history_length, keyword_init: true)
+      RUNNING_STATUS = :RUNNING
+      COMPLETED_STATUS = :COMPLETED
+      FAILED_STATUS = :FAILED
+      CANCELED_STATUS = :CANCELED
+      TERMINATED_STATUS = :TERMINATED
+      CONTINUED_AS_NEW_STATUS = :CONTINUED_AS_NEW
+      TIMED_OUT_STATUS = :TIMED_OUT
+
+      API_STATUS_MAP = {
+        WORKFLOW_EXECUTION_STATUS_RUNNING: RUNNING_STATUS,
+        WORKFLOW_EXECUTION_STATUS_COMPLETED: COMPLETED_STATUS,
+        WORKFLOW_EXECUTION_STATUS_FAILED: FAILED_STATUS,
+        WORKFLOW_EXECUTION_STATUS_CANCELED: CANCELED_STATUS,
+        WORKFLOW_EXECUTION_STATUS_TERMINATED: TERMINATED_STATUS,
+        WORKFLOW_EXECUTION_STATUS_CONTINUED_AS_NEW: CONTINUED_AS_NEW_STATUS,
+        WORKFLOW_EXECUTION_STATUS_TIMED_OUT: TIMED_OUT_STATUS
+      }.freeze
+
+      VALID_STATUSES = [
+        RUNNING_STATUS,
+        COMPLETED_STATUS,
+        FAILED_STATUS,
+        CANCELED_STATUS,
+        TERMINATED_STATUS,
+        CONTINUED_AS_NEW_STATUS,
+        TIMED_OUT_STATUS
+      ].freeze
+
+      def self.generate_from(response)
+        new(
+          workflow: response.type.name,
+          workflow_id: response.execution.workflow_id,
+          run_id: response.execution.run_id,
+          start_time: response.start_time&.to_time,
+          close_time: response.close_time&.to_time,
+          status: API_STATUS_MAP.fetch(response.status),
+          history_length: response.history_length,
+        ).freeze
+      end
+
+      VALID_STATUSES.each do |status|
+        define_method("#{status.downcase}?") do
+          self.status == status
+        end
+      end
+    end
+  end
+end

data/lib/temporal/workflow/executor.rb

@@ -0,0 +1,45 @@
+require 'fiber'
+
+require 'temporal/workflow/dispatcher'
+require 'temporal/workflow/state_manager'
+require 'temporal/workflow/context'
+require 'temporal/workflow/history/event_target'
+
+module Temporal
+  class Workflow
+    class Executor
+      def initialize(workflow_class, history)
+        @workflow_class = workflow_class
+        @dispatcher = Dispatcher.new
+        @state_manager = StateManager.new(dispatcher)
+        @history = history
+      end
+
+      def run
+        dispatcher.register_handler(
+          History::EventTarget.workflow,
+          'started',
+          &method(:execute_workflow)
+        )
+
+        while window = history.next_window
+          state_manager.apply(window)
+        end
+
+        return state_manager.commands
+      end
+
+      private
+
+      attr_reader :workflow_class, :dispatcher, :state_manager, :history
+
+      def execute_workflow(input, metadata)
+        context = Workflow::Context.new(state_manager, dispatcher, metadata)
+
+        Fiber.new do
+          workflow_class.execute_in_context(context, input)
+        end.resume
+      end
+    end
+  end
+end

data/lib/temporal/workflow/future.rb

@@ -0,0 +1,77 @@
+require 'fiber'
+
+module Temporal
+  class Workflow
+    class Future
+      attr_reader :target, :callbacks
+
+      def initialize(target, context, cancelation_id: nil)
+        @target = target
+        @context = context
+        @cancelation_id = cancelation_id
+        @callbacks = []
+        @ready = false
+        @failed = false
+        @result = nil
+        @exception = nil
+      end
+
+      def finished?
+        ready? || failed?
+      end
+
+      def ready?
+        @ready
+      end
+
+      def failed?
+        @failed
+      end
+
+      def wait
+        return if finished?
+        context.wait_for(self)
+      end
+
+      def get
+        wait
+        exception || result
+      end
+
+      def set(result)
+        raise 'can not fulfil a failed future' if failed?
+
+        @result = result
+        @ready = true
+      end
+
+      def fail(exception)
+        raise 'can not fail a fulfilled future' if ready?
+
+        @exception = exception
+        @failed = true
+      end
+
+      def done(&block)
+        # do nothing
+        return if failed?
+
+        if ready?
+          block.call(result)
+        else
+          callbacks << block
+        end
+      end
+
+      def cancel
+        return false if finished?
+
+        context.cancel(target, cancelation_id)
+      end
+
+      private
+
+      attr_reader :context, :cancelation_id, :result, :exception
+    end
+  end
+end

data/lib/temporal/workflow/history.rb

@@ -0,0 +1,76 @@
+require 'temporal/workflow/history/event'
+require 'temporal/workflow/history/window'
+
+module Temporal
+  class Workflow
+    class History
+      attr_reader :events
+
+      def initialize(events)
+        @events = events.map { |event| History::Event.new(event) }
+        @iterator = @events.each
+      end
+
+      def last_completed_workflow_task
+        events.select { |event| event.type == 'WORKFLOW_TASK_COMPLETED' }.last
+      end
+
+      # It is very important to replay the History window by window in order to
+      # simulate the exact same state the workflow was in when it processed the
+      # workflow task for the first time.
+      #
+      # A history window consists of 3 parts:
+      #
+      # 1. Events that happened since the last window (timer fired, activity completed, etc)
+      # 2. A workflow task related events (workflow task started, completed, failed, etc)
+      # 3. Commands issued by the last workflow task (^) (schedule activity, start timer, etc)
+      #
+      def next_window
+        return unless peek_event
+
+        window = History::Window.new
+
+        while event = next_event
+          window.add(event)
+
+          break if event.type == 'WORKFLOW_TASK_COMPLETED'
+        end
+
+        # Find the end of the window by exhausting all the commands
+        window.add(next_event) while command?(peek_event)
+
+        window.freeze
+      end
+
+      private
+
+      COMMAND_EVENT_TYPES = %w[
+        ACTIVITY_TASK_SCHEDULED
+        ACTIVITY_TASK_CANCEL_REQUESTED
+        TIMER_STARTED
+        CANCEL_TIMER_FAILED
+        TIMER_CANCELED
+        WORKFLOW_EXECUTION_CANCEL_REQUESTED
+        START_CHILD_WORKFLOW_EXECUTION_INITIATED
+        SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_INITIATED
+        REQUEST_CANCEL_ACTIVITY_TASK_FAILED
+        REQUEST_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_INITIATED
+        MARKER_RECORDED
+      ].freeze
+
+      attr_reader :iterator
+
+      def next_event
+        iterator.next rescue nil
+      end
+
+      def peek_event
+        iterator.peek rescue nil
+      end
+
+      def command?(event)
+        COMMAND_EVENT_TYPES.include?(event&.type)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+module Temporal
+  class Workflow
+    class History
+      class Event
+        EVENT_TYPES = %w[
+          ACTIVITY_TASK_STARTED
+          ACTIVITY_TASK_COMPLETED
+          ACTIVITY_TASK_FAILED
+          ACTIVITY_TASK_TIMED_OUT
+          ACTIVITY_TASK_CANCELED
+          TIMER_FIRED
+          REQUEST_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_FAILED
+          WORKFLOW_EXECUTION_SIGNALED
+          WORKFLOW_EXECUTION_TERMINATED
+          SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_FAILED
+          EXTERNAL_WORKFLOW_EXECUTION_CANCEL_REQUESTED
+          EXTERNAL_WORKFLOW_EXECUTION_SIGNALED
+          UPSERT_WORKFLOW_SEARCH_ATTRIBUTES
+        ].freeze
+
+        CHILD_WORKFLOW_EVENTS = %w[
+          START_CHILD_WORKFLOW_EXECUTION_FAILED
+          CHILD_WORKFLOW_EXECUTION_STARTED
+          CHILD_WORKFLOW_EXECUTION_COMPLETED
+          CHILD_WORKFLOW_EXECUTION_FAILED
+          CHILD_WORKFLOW_EXECUTION_CANCELED
+          CHILD_WORKFLOW_EXECUTION_TIMED_OUT
+          CHILD_WORKFLOW_EXECUTION_TERMINATED
+        ].freeze
+
+        PREFIX = 'EVENT_TYPE_'.freeze
+
+        attr_reader :id, :timestamp, :type, :attributes
+
+        def initialize(raw_event)
+          @id = raw_event.event_id
+          @timestamp = raw_event.event_time.to_time
+          @type = raw_event.event_type.to_s.gsub(PREFIX, '')
+          @attributes = extract_attributes(raw_event)
+
+          freeze
+        end
+
+        # Returns the ID of the first event associated with the current event.
+        def originating_event_id
+          case type
+          when 'TIMER_FIRED'
+            attributes.started_event_id
+          when 'WORKFLOW_EXECUTION_SIGNALED'
+            1 # fixed id for everything related to current workflow
+          when *EVENT_TYPES
+            attributes.scheduled_event_id
+          when *CHILD_WORKFLOW_EVENTS
+            attributes.initiated_event_id
+          else
+            id
+          end
+        end
+
+        private
+
+        def extract_attributes(raw_event)
+          attributes_name = raw_event.attributes
+          raw_event.public_send(attributes_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+require 'temporal/errors'
+
+module Temporal
+  class Workflow
+    class History
+      class EventTarget
+        class UnexpectedEventType < InternalError; end
+
+        ACTIVITY_TYPE                         = :activity
+        CANCEL_ACTIVITY_REQUEST_TYPE          = :cancel_activity_request
+        TIMER_TYPE                            = :timer
+        CANCEL_TIMER_REQUEST_TYPE             = :cancel_timer_request
+        CHILD_WORKFLOW_TYPE                   = :child_workflow
+        MARKER_TYPE                           = :marker
+        EXTERNAL_WORKFLOW_TYPE                = :external_workflow
+        CANCEL_EXTERNAL_WORKFLOW_REQUEST_TYPE = :cancel_external_workflow_request
+        WORKFLOW_TYPE                         = :workflow
+        CANCEL_WORKFLOW_REQUEST_TYPE          = :cancel_workflow_request
+
+        TARGET_TYPES = {
+          'ACTIVITY_TASK'                              => ACTIVITY_TYPE,
+          'ACTIVITY_TASK_CANCEL'                       => CANCEL_ACTIVITY_REQUEST_TYPE,
+          'REQUEST_CANCEL_ACTIVITY_TASK'               => CANCEL_ACTIVITY_REQUEST_TYPE,
+          'TIMER'                                      => TIMER_TYPE,
+          'CANCEL_TIMER'                               => CANCEL_TIMER_REQUEST_TYPE,
+          'CHILD_WORKFLOW_EXECUTION'                   => CHILD_WORKFLOW_TYPE,
+          'START_CHILD_WORKFLOW_EXECUTION'             => CHILD_WORKFLOW_TYPE,
+          'MARKER'                                     => MARKER_TYPE,
+          'EXTERNAL_WORKFLOW_EXECUTION'                => EXTERNAL_WORKFLOW_TYPE,
+          'SIGNAL_EXTERNAL_WORKFLOW_EXECUTION'         => EXTERNAL_WORKFLOW_TYPE,
+          'EXTERNAL_WORKFLOW_EXECUTION_CANCEL'         => CANCEL_EXTERNAL_WORKFLOW_REQUEST_TYPE,
+          'REQUEST_CANCEL_EXTERNAL_WORKFLOW_EXECUTION' => CANCEL_EXTERNAL_WORKFLOW_REQUEST_TYPE,
+          'UPSERT_WORKFLOW_SEARCH_ATTRIBUTES'          => WORKFLOW_TYPE,
+          'WORKFLOW_EXECUTION'                         => WORKFLOW_TYPE,
+          'WORKFLOW_EXECUTION_CANCEL'                  => CANCEL_WORKFLOW_REQUEST_TYPE,
+        }.freeze
+
+        attr_reader :id, :type
+
+        def self.workflow
+          @workflow ||= new(1, WORKFLOW_TYPE)
+        end
+
+        def self.from_event(event)
+          _, target_type = TARGET_TYPES.find { |type, _| event.type.start_with?(type) }
+
+          unless target_type
+            raise UnexpectedEventType, "Unexpected event #{event.type}"
+          end
+
+          new(event.originating_event_id, target_type)
+        end
+
+        def initialize(id, type)
+          @id = id
+          @type = type
+
+          freeze
+        end
+
+        def ==(other)
+          id == other.id && type == other.type
+        end
+
+        def eql?(other)
+          self == other
+        end
+
+        def hash
+          [id, type].hash
+        end
+      end
+    end
+  end
+end