cadence-ruby 0.0.0 → 0.1.0

data/lib/cadence/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 < Cadence::Workflow
+#   def execute
+#     ChildWorkflow.execute!('foo', 'bar')
+#   end
+# end
+#
+# This is analogous to calling:
+#
+# workflow.execute_workflow(ChildWorkflow, 'foo', 'bar')
+#
+require 'cadence/thread_local_context'
+
+module Cadence
+  class Workflow
+    module ConvenienceMethods
+      def execute(*input, **args)
+        context = Cadence::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 = Cadence::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/cadence/workflow/decision.rb

@@ -0,0 +1,39 @@
+module Cadence
+  class Workflow
+    module Decision
+      # TODO: Move these classes into their own directories under workflow/decision/*
+      ScheduleActivity = Struct.new(:activity_type, :activity_id, :input, :domain, :task_list, :retry_policy, :timeouts, :headers, keyword_init: true)
+      StartChildWorkflow = Struct.new(:workflow_type, :workflow_id, :input, :domain, :task_list, :retry_policy, :timeouts, :headers, keyword_init: true)
+      RequestActivityCancellation = Struct.new(:activity_id, keyword_init: true)
+      RecordMarker = Struct.new(:name, :details, keyword_init: true)
+      StartTimer = Struct.new(:timeout, :timer_id, keyword_init: true)
+      CancelTimer = Struct.new(:timer_id, keyword_init: true)
+      CompleteWorkflow = Struct.new(:result, keyword_init: true)
+      FailWorkflow = Struct.new(:reason, :details, keyword_init: true)
+
+      # only these decisions are supported right now
+      SCHEDULE_ACTIVITY_TYPE = :schedule_activity
+      START_CHILD_WORKFLOW_TYPE = :start_child_workflow
+      RECORD_MARKER_TYPE = :record_marker
+      START_TIMER_TYPE = :start_timer
+      CANCEL_TIMER_TYPE = :cancel_timer
+      COMPLETE_WORKFLOW_TYPE = :complete_workflow
+      FAIL_WORKFLOW_TYPE = :fail_workflow
+
+      DECISION_CLASS_MAP = {
+        SCHEDULE_ACTIVITY_TYPE => ScheduleActivity,
+        START_CHILD_WORKFLOW_TYPE => StartChildWorkflow,
+        RECORD_MARKER_TYPE => RecordMarker,
+        START_TIMER_TYPE => StartTimer,
+        CANCEL_TIMER_TYPE => CancelTimer,
+        COMPLETE_WORKFLOW_TYPE => CompleteWorkflow,
+        FAIL_WORKFLOW_TYPE => FailWorkflow
+      }.freeze
+
+      def self.generate(type, **args)
+        decision_class = DECISION_CLASS_MAP[type]
+        decision_class.new(**args)
+      end
+    end
+  end
+end

data/lib/cadence/workflow/decision_state_machine.rb

@@ -0,0 +1,48 @@
+module Cadence
+  class Workflow
+    class DecisionStateMachine
+      NEW_STATE = :new
+      REQUESTED_STATE = :requested
+      SCHEDULED_STATE = :scheduled
+      STARTED_STATE = :started
+      COMPLETED_STATE = :completed
+      CANCELED_STATE = :canceled
+      FAILED_STATE = :failed
+      TIMED_OUT_STATE = :timed_out
+
+      attr_reader :state
+
+      def initialize
+        @state = NEW_STATE
+      end
+
+      def requested
+        @state = REQUESTED_STATE
+      end
+
+      def schedule
+        @state = SCHEDULED_STATE
+      end
+
+      def start
+        @state = STARTED_STATE
+      end
+
+      def complete
+        @state = COMPLETED_STATE
+      end
+
+      def cancel
+        @state = CANCELED_STATE
+      end
+
+      def fail
+        @state = FAILED_STATE
+      end
+
+      def time_out
+        @state = TIMED_OUT_STATE
+      end
+    end
+  end
+end

data/lib/cadence/workflow/decision_task_processor.rb

@@ -0,0 +1,105 @@
+require 'cadence/workflow/executor'
+require 'cadence/workflow/history'
+require 'cadence/workflow/serializer'
+require 'cadence/metadata'
+
+module Cadence
+  class Workflow
+    class DecisionTaskProcessor
+      MAX_FAILED_ATTEMPTS = 50
+
+      def initialize(task, domain, workflow_lookup, client, middleware_chain)
+        @task = task
+        @domain = domain
+        @task_token = task.taskToken
+        @workflow_name = task.workflowType.name
+        @workflow_class = workflow_lookup.find(workflow_name)
+        @client = client
+        @middleware_chain = middleware_chain
+      end
+
+      def process
+        start_time = Time.now
+
+        Cadence.logger.info("Processing a decision task for #{workflow_name}")
+        Cadence.metrics.timing('decision_task.queue_time', queue_time_ms, workflow: workflow_name)
+
+        unless workflow_class
+          fail_task('Workflow does not exist')
+          return
+        end
+
+        history = fetch_full_history
+        # TODO: For sticky workflows we need to cache the Executor instance
+        executor = Workflow::Executor.new(workflow_class, history)
+        metadata = Metadata.generate(Metadata::DECISION_TYPE, task, domain)
+
+        decisions = middleware_chain.invoke(metadata) do
+          executor.run
+        end
+
+        complete_task(decisions)
+      rescue StandardError => error
+        fail_task(error.inspect)
+        Cadence.logger.debug(error.backtrace.join("\n"))
+      ensure
+        time_diff_ms = ((Time.now - start_time) * 1000).round
+        Cadence.metrics.timing('decision_task.latency', time_diff_ms, workflow: workflow_name)
+        Cadence.logger.debug("Decision task processed in #{time_diff_ms}ms")
+      end
+
+      private
+
+      attr_reader :task, :domain, :task_token, :workflow_name, :workflow_class, :client, :middleware_chain
+
+      def queue_time_ms
+        ((task.startedTimestamp - task.scheduledTimestamp) / 1_000_000).round
+      end
+
+      def serialize_decisions(decisions)
+        decisions.map { |(_, decision)| Workflow::Serializer.serialize(decision) }
+      end
+
+      def fetch_full_history
+        events = task.history.events.to_a
+        next_page_token = task.nextPageToken
+
+        while next_page_token do
+          response = client.get_workflow_execution_history(
+            domain: domain,
+            workflow_id: task.workflowExecution.workflowId,
+            run_id: task.workflowExecution.runId,
+            next_page_token: next_page_token
+          )
+
+          events += response.history.events.to_a
+          next_page_token = response.nextPageToken
+        end
+
+        Workflow::History.new(events)
+      end
+
+      def complete_task(decisions)
+        Cadence.logger.info("Decision task for #{workflow_name} completed")
+
+        client.respond_decision_task_completed(
+          task_token: task_token,
+          decisions: serialize_decisions(decisions)
+        )
+      end
+
+      def fail_task(message)
+        Cadence.logger.error("Decision task for #{workflow_name} failed with: #{message}")
+
+        # Stop from getting into infinite loop if the error persists
+        return if task.attempt >= MAX_FAILED_ATTEMPTS
+
+        client.respond_decision_task_failed(
+          task_token: task_token,
+          cause: CadenceThrift::DecisionTaskFailedCause::UNHANDLED_DECISION,
+          details: message
+        )
+      end
+    end
+  end
+end

data/lib/cadence/workflow/dispatcher.rb

@@ -0,0 +1,31 @@
+module Cadence
+  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/cadence/workflow/execution_info.rb

@@ -0,0 +1,45 @@
+require 'cadence/utils'
+
+module Cadence
+  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
+
+      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)
+        status = ::CadenceThrift::WorkflowExecutionCloseStatus::VALUE_MAP[response.closeStatus]
+
+        new(
+          workflow: response.type.name,
+          workflow_id: response.execution.workflowId,
+          run_id: response.execution.runId,
+          start_time: Utils.time_from_nanos(response.startTime),
+          close_time: Utils.time_from_nanos(response.closeTime),
+          status: status&.to_sym || RUNNING_STATUS,
+          history_length: response.historyLength,
+        ).freeze
+      end
+
+      VALID_STATUSES.each do |status|
+        define_method("#{status.downcase}?") do
+          self.status == status
+        end
+      end
+    end
+  end
+end

data/lib/cadence/workflow/executor.rb

@@ -0,0 +1,45 @@
+require 'fiber'
+
+require 'cadence/workflow/dispatcher'
+require 'cadence/workflow/state_manager'
+require 'cadence/workflow/context'
+require 'cadence/workflow/history/event_target'
+
+module Cadence
+  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.decisions
+      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/cadence/workflow/future.rb

@@ -0,0 +1,75 @@
+require 'fiber'
+
+module Cadence
+  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
+        @result = nil
+        @failure = nil
+      end
+
+      def finished?
+        ready? || failed?
+      end
+
+      def ready?
+        @ready
+      end
+
+      def failed?
+        !!@failure
+      end
+
+      def wait
+        return if finished?
+        context.wait_for(self)
+      end
+
+      def get
+        wait
+        failure || result
+      end
+
+      def set(result)
+        raise 'can not fulfil a failed future' if failed?
+
+        @result = result
+        @ready = true
+      end
+
+      def fail(reason, details)
+        raise 'can not fail a fulfilled future' if ready?
+
+        @failure = [reason, details]
+      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, :failure
+    end
+  end
+end

data/lib/cadence/workflow/history.rb

@@ -0,0 +1,76 @@
+require 'cadence/workflow/history/event'
+require 'cadence/workflow/history/window'
+
+module Cadence
+  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_decision_task
+        events.select { |event| event.type == 'DecisionTaskCompleted' }.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
+      # decision 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 decision task related events (decision task started, completed, failed, etc)
+      # 3. Commands issued by the last decision 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 == 'DecisionTaskCompleted'
+        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[
+        ActivityTaskScheduled
+        ActivityTaskCancelRequested
+        TimerStarted
+        CancelTimerFailed
+        TimerCanceled
+        WorkflowExecutionCancelRequested
+        StartChildWorkflowExecutionInitiated
+        SignalExternalWorkflowExecutionInitiated
+        RequestCancelActivityTaskFailed
+        RequestCancelExternalWorkflowExecutionInitiated
+        MarkerRecorded
+      ].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