cadence-ruby 0.0.0 → 0.1.0

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

@@ -0,0 +1,71 @@
+require 'cadence/utils'
+
+module Cadence
+  class Workflow
+    class History
+      class Event
+        EVENT_TYPES = %w[
+          ActivityTaskStarted
+          ActivityTaskCompleted
+          ActivityTaskFailed
+          ActivityTaskTimedOut
+          ActivityTaskCanceled
+          TimerFired
+          RequestCancelExternalWorkflowExecutionFailed
+          WorkflowExecutionSignaled
+          WorkflowExecutionTerminated
+          SignalExternalWorkflowExecutionFailed
+          ExternalWorkflowExecutionCancelRequested
+          ExternalWorkflowExecutionSignaled
+          UpsertWorkflowSearchAttributes
+        ].freeze
+
+        CHILD_WORKFLOW_EVENTS = %w[
+          StartChildWorkflowExecutionFailed
+          ChildWorkflowExecutionStarted
+          ChildWorkflowExecutionCompleted
+          ChildWorkflowExecutionFailed
+          ChildWorkflowExecutionCanceled
+          ChildWorkflowExecutionTimedOut
+          ChildWorkflowExecutionTerminated
+        ].freeze
+
+        attr_reader :id, :timestamp, :type, :attributes
+
+        def initialize(raw_event)
+          @id = raw_event.eventId
+          @timestamp = Utils.time_from_nanos(raw_event.timestamp)
+          @type = CadenceThrift::EventType::VALUE_MAP[raw_event.eventType]
+          @attributes = extract_attributes(raw_event)
+
+          freeze
+        end
+
+        # Returns the ID of the first event associated with the current event,
+        # referred to as a "decision" event. Not related to DecisionTask.
+        def decision_id
+          case type
+          when 'TimerFired'
+            attributes.startedEventId
+          when 'WorkflowExecutionSignaled'
+            1 # fixed id for everything related to current workflow
+          when *EVENT_TYPES
+            attributes.scheduledEventId
+          when *CHILD_WORKFLOW_EVENTS
+            attributes.initiatedEventId
+          else
+            id
+          end
+        end
+
+        private
+
+        def extract_attributes(raw_event)
+          attributes_argument = "#{type}EventAttributes"
+          attributes_argument[0] = attributes_argument[0].downcase
+          raw_event.public_send(attributes_argument)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+require 'cadence/errors'
+
+module Cadence
+  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 = {
+          'ActivityTask'                           => ACTIVITY_TYPE,
+          'ActivityTaskCancel'                     => CANCEL_ACTIVITY_REQUEST_TYPE,
+          'RequestCancelActivityTask'              => CANCEL_ACTIVITY_REQUEST_TYPE,
+          'Timer'                                  => TIMER_TYPE,
+          'CancelTimer'                            => CANCEL_TIMER_REQUEST_TYPE,
+          'ChildWorkflowExecution'                 => CHILD_WORKFLOW_TYPE,
+          'StartChildWorkflowExecution'            => CHILD_WORKFLOW_TYPE,
+          'Marker'                                 => MARKER_TYPE,
+          'ExternalWorkflowExecution'              => EXTERNAL_WORKFLOW_TYPE,
+          'SignalExternalWorkflowExecution'        => EXTERNAL_WORKFLOW_TYPE,
+          'ExternalWorkflowExecutionCancel'        => CANCEL_EXTERNAL_WORKFLOW_REQUEST_TYPE,
+          'RequestCancelExternalWorkflowExecution' => CANCEL_EXTERNAL_WORKFLOW_REQUEST_TYPE,
+          'UpsertWorkflowSearchAttributes'         => WORKFLOW_TYPE,
+          'WorkflowExecution'                      => WORKFLOW_TYPE,
+          'WorkflowExecutionCancel'                => 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.decision_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
+
+        def to_s
+          "#{type} (#{id})"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Cadence
+  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 'MarkerRecorded'
+            markers << event
+          when 'DecisionTaskStarted'
+            @last_event_id = event.id + 1 # one for completed
+            @local_time = event.timestamp
+          when 'DecisionTaskFailed', 'DecisionTaskTimedOut'
+            @next_event_id = nil
+            @local_time = nil
+          when 'DecisionTaskCompleted'
+            @replay = true
+          when 'DecisionTaskScheduled', 'DecisionTaskFailed'
+            # no-op
+          else
+            events << event
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cadence/workflow/poller.rb

@@ -0,0 +1,74 @@
+require 'cadence/client'
+require 'cadence/middleware/chain'
+require 'cadence/workflow/decision_task_processor'
+
+module Cadence
+  class Workflow
+    class Poller
+      def initialize(domain, task_list, workflow_lookup, middleware = [], options = {})
+        @domain = domain
+        @task_list = task_list
+        @workflow_lookup = workflow_lookup
+        @middleware = middleware
+        @options = options
+        @shutting_down = false
+      end
+
+      def start
+        @shutting_down = false
+        @thread = Thread.new(&method(:poll_loop))
+      end
+
+      def stop
+        @shutting_down = true
+        Cadence.logger.info('Shutting down a workflow poller')
+      end
+
+      def wait
+        @thread.join
+      end
+
+      private
+
+      attr_reader :domain, :task_list, :client, :workflow_lookup, :middleware, :options
+
+      def client
+        @client ||= Cadence::Client.generate(options)
+      end
+
+      def middleware_chain
+        @middleware_chain ||= Middleware::Chain.new(middleware)
+      end
+
+      def shutting_down?
+        @shutting_down
+      end
+
+      def poll_loop
+        last_poll_time = Time.now
+        metrics_tags = { domain: domain, task_list: task_list }.freeze
+
+        while !shutting_down? do
+          time_diff_ms = ((Time.now - last_poll_time) * 1000).round
+          Cadence.metrics.timing('workflow_poller.time_since_last_poll', time_diff_ms, metrics_tags)
+          Cadence.logger.debug("Polling for decision tasks (#{domain} / #{task_list})")
+
+          task = poll_for_task
+          last_poll_time = Time.now
+          process(task) if task&.workflowType
+        end
+      end
+
+      def poll_for_task
+        client.poll_for_decision_task(domain: domain, task_list: task_list)
+      rescue StandardError => error
+        Cadence.logger.error("Unable to poll for a decision task: #{error.inspect}")
+        nil
+      end
+
+      def process(task)
+        DecisionTaskProcessor.new(task, domain, workflow_lookup, client, middleware_chain).process
+      end
+    end
+  end
+end

data/lib/cadence/workflow/replay_aware_logger.rb

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

@@ -0,0 +1,31 @@
+require 'cadence/workflow/decision'
+require 'cadence/workflow/serializer/schedule_activity'
+require 'cadence/workflow/serializer/start_child_workflow'
+require 'cadence/workflow/serializer/request_activity_cancellation'
+require 'cadence/workflow/serializer/record_marker'
+require 'cadence/workflow/serializer/start_timer'
+require 'cadence/workflow/serializer/cancel_timer'
+require 'cadence/workflow/serializer/complete_workflow'
+require 'cadence/workflow/serializer/fail_workflow'
+
+module Cadence
+  class Workflow
+    module Serializer
+      SERIALIZERS_MAP = {
+        Workflow::Decision::ScheduleActivity => Serializer::ScheduleActivity,
+        Workflow::Decision::StartChildWorkflow => Serializer::StartChildWorkflow,
+        Workflow::Decision::RequestActivityCancellation => Serializer::RequestActivityCancellation,
+        Workflow::Decision::RecordMarker => Serializer::RecordMarker,
+        Workflow::Decision::StartTimer => Serializer::StartTimer,
+        Workflow::Decision::CancelTimer => Serializer::CancelTimer,
+        Workflow::Decision::CompleteWorkflow => Serializer::CompleteWorkflow,
+        Workflow::Decision::FailWorkflow => Serializer::FailWorkflow
+      }.freeze
+
+      def self.serialize(object)
+        serializer = SERIALIZERS_MAP[object.class]
+        serializer.new(object).to_thrift
+      end
+    end
+  end
+end

data/lib/cadence/workflow/serializer/base.rb

@@ -0,0 +1,22 @@
+require 'oj'
+require 'gen/thrift/shared_types'
+
+module Cadence
+  class Workflow
+    module Serializer
+      class Base
+        def initialize(object)
+          @object = object
+        end
+
+        def to_thrift
+          raise NotImplementedError, 'serializer needs to implement #to_thrift'
+        end
+
+        private
+
+        attr_reader :object
+      end
+    end
+  end
+end

data/lib/cadence/workflow/serializer/cancel_timer.rb

@@ -0,0 +1,19 @@
+require 'cadence/workflow/serializer/base'
+
+module Cadence
+  class Workflow
+    module Serializer
+      class CancelTimer < Base
+        def to_thrift
+          CadenceThrift::Decision.new(
+            decisionType: CadenceThrift::DecisionType::CancelTimer,
+            cancelTimerDecisionAttributes:
+              CadenceThrift::CancelTimerDecisionAttributes.new(
+                timerId: object.timer_id.to_s
+              )
+          )
+        end
+      end
+    end
+  end
+end

data/lib/cadence/workflow/serializer/complete_workflow.rb

@@ -0,0 +1,20 @@
+require 'cadence/workflow/serializer/base'
+require 'cadence/json'
+
+module Cadence
+  class Workflow
+    module Serializer
+      class CompleteWorkflow < Base
+        def to_thrift
+          CadenceThrift::Decision.new(
+            decisionType: CadenceThrift::DecisionType::CompleteWorkflowExecution,
+            completeWorkflowExecutionDecisionAttributes:
+              CadenceThrift::CompleteWorkflowExecutionDecisionAttributes.new(
+                result: JSON.serialize(object.result)
+              )
+          )
+        end
+      end
+    end
+  end
+end

data/lib/cadence/workflow/serializer/fail_workflow.rb

@@ -0,0 +1,21 @@
+require 'cadence/workflow/serializer/base'
+require 'cadence/json'
+
+module Cadence
+  class Workflow
+    module Serializer
+      class FailWorkflow < Base
+        def to_thrift
+          CadenceThrift::Decision.new(
+            decisionType: CadenceThrift::DecisionType::FailWorkflowExecution,
+            failWorkflowExecutionDecisionAttributes:
+              CadenceThrift::FailWorkflowExecutionDecisionAttributes.new(
+                reason: object.reason,
+                details: JSON.serialize(object.details)
+              )
+          )
+        end
+      end
+    end
+  end
+end

data/lib/cadence/workflow/serializer/record_marker.rb

@@ -0,0 +1,21 @@
+require 'cadence/workflow/serializer/base'
+require 'cadence/json'
+
+module Cadence
+  class Workflow
+    module Serializer
+      class RecordMarker < Base
+        def to_thrift
+          CadenceThrift::Decision.new(
+            decisionType: CadenceThrift::DecisionType::RecordMarker,
+            recordMarkerDecisionAttributes:
+              CadenceThrift::RecordMarkerDecisionAttributes.new(
+                markerName: object.name,
+                details: JSON.serialize(object.details)
+              )
+          )
+        end
+      end
+    end
+  end
+end