temporalio 0.1.1 → 0.3.0

data/lib/temporalio/internal/worker/workflow_worker.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require 'temporalio/api/payload_visitor'
+require 'temporalio/error'
+require 'temporalio/internal/worker/workflow_instance'
+require 'temporalio/scoped_logger'
+require 'temporalio/workflow'
+require 'temporalio/workflow/definition'
+require 'timeout'
+
+module Temporalio
+  module Internal
+    module Worker
+      # Worker for handling workflow activations. Most activation work is delegated to the workflow executor.
+      class WorkflowWorker
+        def self.workflow_definitions(workflows)
+          workflows.each_with_object({}) do |workflow, hash|
+            # Load definition
+            defn = begin
+              if workflow.is_a?(Workflow::Definition::Info)
+                workflow
+              else
+                Workflow::Definition::Info.from_class(workflow)
+              end
+            rescue StandardError
+              raise ArgumentError, "Failed loading workflow #{workflow}"
+            end
+
+            # Confirm name not in use
+            raise ArgumentError, "Multiple workflows named #{defn.name || '<dynamic>'}" if hash.key?(defn.name)
+
+            hash[defn.name] = defn
+          end
+        end
+
+        def initialize(worker:, bridge_worker:, workflow_definitions:)
+          @executor = worker.options.workflow_executor
+
+          payload_codec = worker.options.client.data_converter.payload_codec
+          @workflow_payload_codec_thread_pool = worker.options.workflow_payload_codec_thread_pool
+          if !Fiber.current_scheduler && payload_codec && !@workflow_payload_codec_thread_pool
+            raise ArgumentError, 'Must have workflow payload codec thread pool if providing codec and not using fibers'
+          end
+
+          # If there is a payload codec, we need to build encoding and decoding visitors
+          if payload_codec
+            @payload_encoding_visitor = Api::PayloadVisitor.new(skip_search_attributes: true) do |payload_or_payloads|
+              apply_codec_on_payload_visit(payload_or_payloads) { |payloads| payload_codec.encode(payloads) }
+            end
+            @payload_decoding_visitor = Api::PayloadVisitor.new(skip_search_attributes: true) do |payload_or_payloads|
+              apply_codec_on_payload_visit(payload_or_payloads) { |payloads| payload_codec.decode(payloads) }
+            end
+          end
+
+          @state = State.new(
+            workflow_definitions:,
+            bridge_worker:,
+            logger: worker.options.logger,
+            metric_meter: worker.options.client.connection.options.runtime.metric_meter,
+            data_converter: worker.options.client.data_converter,
+            deadlock_timeout: worker.options.debug_mode ? nil : 2.0,
+            # TODO(cretz): Make this more performant for the default set?
+            illegal_calls: WorkflowInstance::IllegalCallTracer.frozen_validated_illegal_calls(
+              worker.options.illegal_workflow_calls || {}
+            ),
+            namespace: worker.options.client.namespace,
+            task_queue: worker.options.task_queue,
+            disable_eager_activity_execution: worker.options.disable_eager_activity_execution,
+            workflow_interceptors: worker._workflow_interceptors,
+            workflow_failure_exception_types: worker.options.workflow_failure_exception_types.map do |t|
+              unless t.is_a?(Class) && t < Exception
+                raise ArgumentError, 'All failure types must classes inheriting Exception'
+              end
+
+              t
+            end.freeze
+          )
+
+          # Validate worker
+          @executor._validate_worker(worker, @state)
+        end
+
+        def handle_activation(runner:, activation:, decoded:)
+          # Encode in background if not encoded but it needs to be
+          if @payload_encoding_visitor && !decoded
+            if Fiber.current_scheduler
+              Fiber.schedule { decode_activation(runner, activation) }
+            else
+              @workflow_payload_codec_thread_pool.execute { decode_activation(runner, activation) }
+            end
+          else
+            @executor._activate(activation, @state) do |activation_completion|
+              runner.apply_workflow_activation_complete(workflow_worker: self, activation_completion:, encoded: false)
+            end
+          end
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          # Should never happen, executors are expected to trap things
+          @state.logger.error("Failed issuing activation on workflow run ID: #{activation.run_id}")
+          @state.logger.error(e)
+        end
+
+        def handle_activation_complete(runner:, activation_completion:, encoded:, completion_complete_queue:)
+          if @payload_encoding_visitor && !encoded
+            if Fiber.current_scheduler
+              Fiber.schedule { encode_activation_completion(runner, activation_completion) }
+            else
+              @workflow_payload_codec_thread_pool.execute do
+                encode_activation_completion(runner, activation_completion)
+              end
+            end
+          else
+            @state.bridge_worker.async_complete_workflow_activation(
+              activation_completion.run_id, activation_completion.to_proto, completion_complete_queue
+            )
+          end
+        end
+
+        def on_shutdown_complete
+          @state.evict_all
+        end
+
+        private
+
+        def decode_activation(runner, activation)
+          @payload_decoding_visitor.run(activation)
+          runner.apply_workflow_activation_decoded(workflow_worker: self, activation:)
+        end
+
+        def encode_activation_completion(runner, activation_completion)
+          @payload_encoding_visitor.run(activation_completion)
+          runner.apply_workflow_activation_complete(workflow_worker: self, activation_completion:, encoded: true)
+        end
+
+        def apply_codec_on_payload_visit(payload_or_payloads, &)
+          case payload_or_payloads
+          when Temporalio::Api::Common::V1::Payload
+            new_payloads = yield [payload_or_payloads]
+            payload_or_payloads.metadata = new_payloads.first.metadata
+            payload_or_payloads.data = new_payloads.first.data
+          when Enumerable
+            payload_or_payloads.replace(yield payload_or_payloads) # steep:ignore
+          else
+            raise 'Unrecognized visitor type'
+          end
+        end
+
+        class State
+          attr_reader :workflow_definitions, :bridge_worker, :logger, :metric_meter, :data_converter, :deadlock_timeout,
+                      :illegal_calls, :namespace, :task_queue, :disable_eager_activity_execution,
+                      :workflow_interceptors, :workflow_failure_exception_types
+
+          def initialize(
+            workflow_definitions:, bridge_worker:, logger:, metric_meter:, data_converter:, deadlock_timeout:,
+            illegal_calls:, namespace:, task_queue:, disable_eager_activity_execution:,
+            workflow_interceptors:, workflow_failure_exception_types:
+          )
+            @workflow_definitions = workflow_definitions
+            @bridge_worker = bridge_worker
+            @logger = logger
+            @metric_meter = metric_meter
+            @data_converter = data_converter
+            @deadlock_timeout = deadlock_timeout
+            @illegal_calls = illegal_calls
+            @namespace = namespace
+            @task_queue = task_queue
+            @disable_eager_activity_execution = disable_eager_activity_execution
+            @workflow_interceptors = workflow_interceptors
+            @workflow_failure_exception_types = workflow_failure_exception_types
+
+            @running_workflows = {}
+            @running_workflows_mutex = Mutex.new
+          end
+
+          # This can never be called at the same time for the same run ID on the same state object
+          def get_or_create_running_workflow(run_id, &)
+            instance = @running_workflows_mutex.synchronize { @running_workflows[run_id] }
+            # If instance is not there, we create it out of lock then store it under lock
+            unless instance
+              instance = yield
+              @running_workflows_mutex.synchronize { @running_workflows[run_id] = instance }
+            end
+            instance
+          end
+
+          def evict_running_workflow(run_id)
+            @running_workflows_mutex.synchronize { @running_workflows.delete(run_id) }
+          end
+
+          def evict_all
+            @running_workflows_mutex.synchronize { @running_workflows.clear }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/temporalio/internal.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Temporalio
+  # @!visibility private
+  module Internal
+  end
+end

data/lib/temporalio/metric.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'temporalio/internal/metric'
+
+module Temporalio
+  # Metric that can be recorded from a metric meter. This is obtained via {Meter.create_metric}. The metric meter is
+  # obtained via workflow environment, activity context, or from the {Runtime} if in neither of those. This class is
+  # effectively abstract and will fail if `initialize` is attempted.
+  class Metric
+    # @!visibility private
+    def initialize
+      raise NotImplementedError, 'Metric is abstract, implementations override initialize'
+    end
+
+    # Record a value for the metric. For counters, this adds to any existing. For histograms, this records into proper
+    # buckets. For gauges, this sets the value. The value type must match the expectation.
+    #
+    # @param value [Numeric] Value to record. For counters and duration-based histograms, this value cannot be negative.
+    # @param additional_attributes [Hash{String, Symbol => String, Integer, Float, Boolean}, nil] Additional attributes
+    #   on this specific record. For better performance for attribute reuse, users are encouraged to use
+    #   {with_additional_attributes} to make a copy of this metric with those attributes.
+    def record(value, additional_attributes: nil)
+      raise NotImplementedError
+    end
+
+    # Create a copy of this metric but with the given additional attributes. This is more performant than providing
+    # attributes on each {record} call.
+    #
+    # @param additional_attributes [Hash{String, Symbol => String, Integer, Float, Boolean}] Attributes to set on the
+    #   resulting metric.
+    # @return [Metric] Copy of this metric with the additional attributes.
+    def with_additional_attributes(additional_attributes)
+      raise NotImplementedError
+    end
+
+    # @return [:counter, :histogram, :gauge] Metric type.
+    def metric_type
+      raise NotImplementedError
+    end
+
+    # @return [String] Metric name.
+    def name
+      raise NotImplementedError
+    end
+
+    # @return [String, nil] Metric description.
+    def description
+      raise NotImplementedError
+    end
+
+    # @return [String, nil] Metric unit.
+    def unit
+      raise NotImplementedError
+    end
+
+    # @return [:integer, :float, :duration] Metric value type.
+    def value_type
+      raise NotImplementedError
+    end
+
+    # Meter for creating metrics to record values on. This is obtained via workflow environment, activity context, or
+    # from the {Runtime} if in neither of those. This class is effectively abstract and will fail if `initialize` is
+    # attempted.
+    class Meter
+      # @return [Meter] A no-op instance of {Meter}.
+      def self.null
+        Internal::Metric::NullMeter.instance
+      end
+
+      # @!visibility private
+      def initialize
+        raise NotImplementedError, 'Meter is abstract, implementations override initialize'
+      end
+
+      # Create a new metric. Only certain metric types are accepted and only value types can work with certain metric
+      # types.
+      #
+      # @param metric_type [:counter, :histogram, :gauge] Metric type. Counters can only have `:integer` value types,
+      #   histograms can have `:integer`, `:float`, or :duration` value types, and gauges can have `:integer` or
+      #   `:float` value types.
+      # @param name [String] Metric name.
+      # @param description [String, nil] Metric description.
+      # @param unit [String, nil] Metric unit.
+      # @param value_type [:integer, :float, :duration] Metric value type. `:integer` works for all metric types,
+      #   `:float` works for `:histogram` and `:gauge` metric types, and `:duration` only works for `:histogram` metric
+      #   types.
+      # @return [Metric] Created metric.
+      def create_metric(
+        metric_type,
+        name,
+        description: nil,
+        unit: nil,
+        value_type: :integer
+      )
+        raise NotImplementedError
+      end
+
+      # Create a copy of this meter but with the given additional attributes. This is more performant than providing
+      # attributes on each {record} call.
+      #
+      # @param additional_attributes [Hash{String, Symbol => String, Integer, Float, Boolean}] Attributes to set on the
+      #   resulting meter.
+      # @return [Meter] Copy of this meter with the additional attributes.
+      def with_additional_attributes(additional_attributes)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/temporalio/retry_policy.rb

@@ -1,91 +1,73 @@
-require 'temporal/api/common/v1/message_pb'
-require 'temporalio/errors'
+# frozen_string_literal: true
+
+require 'temporalio/internal/proto_utils'
 
 module Temporalio
+  RetryPolicy = Data.define(
+    :initial_interval,
+    :backoff_coefficient,
+    :max_interval,
+    :max_attempts,
+    :non_retryable_error_types
+  )
+
   # Options for retrying workflows and activities.
   #
-  # @see https://docs.temporal.io/application-development/features/#workflow-retry-policy
+  # @!attribute initial_interval
+  #   @return [Float] Backoff interval in seconds for the first retry. Default 1.0.
+  # @!attribute backoff_coefficient
+  #   @return [Float] Coefficient to multiply previous backoff interval by to get new interval. Default 2.0.
+  # @!attribute max_interval
+  #   @return [Float, nil] Maximum backoff interval in seconds between retries. Default 100x `initial_interval`.
+  # @!attribute max_attempts
+  #   @return [Integer] Maximum number of attempts. If `0`, the default, there is no maximum.
+  # @!attribute non_retryable_error_types
+  #   @return [Array<String>, nil] List of error types that are not retryable.
   class RetryPolicy
-    class Invalid < Temporalio::Error; end
-
-    # @return [Integer] Backoff interval for the first retry.
-    attr_reader :initial_interval
-
-    # @return [Float] Coefficient to multiply previous backoff interval by to get new interval.
-    attr_reader :backoff
-
-    # @return [Integer, nil] Maximum backoff interval between retries. Default 100x
-    #   {#initial_interval}.
-    attr_reader :max_interval
-
-    # @return [Integer] Maximum number of attempts. If 0, the default, there is no maximum.
-    attr_reader :max_attempts
-
-    # @return [Array<String>] List of error types that are not retryable.
-    attr_reader :non_retriable_errors
-
-    def self.from_proto(proto)
-      new(
-        initial_interval: proto.initial_interval&.to_f&.round || 0,
-        backoff: proto.backoff_coefficient&.to_f || 0.0,
-        max_interval: proto.maximum_interval&.to_f&.round || 0,
-        max_attempts: proto.maximum_attempts || 1,
-        non_retriable_errors: proto.non_retryable_error_types || [],
-      ).freeze
+    # @!visibility private
+    def self._from_proto(raw_policy)
+      RetryPolicy.new(
+        initial_interval: Internal::ProtoUtils.duration_to_seconds(raw_policy.initial_interval) || raise, # Never nil
+        backoff_coefficient: raw_policy.backoff_coefficient,
+        max_interval: Internal::ProtoUtils.duration_to_seconds(raw_policy.maximum_interval),
+        max_attempts: raw_policy.maximum_attempts,
+        non_retryable_error_types: raw_policy.non_retryable_error_types&.to_a
+      )
     end
 
-    # @param initial_interval [Integer] Backoff interval (in seconds) for the first retry.
-    # @param backoff [Float] Coefficient to multiply previous backoff interval by to get new
-    #   interval.
-    # @param max_interval [Integer] Maximum backoff interval between retries. Default 100x
-    #   {#initial_interval}.
-    # @param max_attempts [Integer] Maximum number of attempts. If 0, there is no maximum.
-    # @param non_retriable_errors [Array<Class, String>] List of error types that are not retryable.
+    # Create retry policy.
+    #
+    # @param initial_interval [Float] Backoff interval in seconds for the first retry. Default 1.0.
+    # @param backoff_coefficient [Float] Coefficient to multiply previous backoff interval by to get new interval.
+    #   Default 2.0.
+    # @param max_interval [Float, nil] Maximum backoff interval in seconds between retries. Default 100x
+    #   `initial_interval`.
+    # @param max_attempts [Integer] Maximum number of attempts. If `0`, the default, there is no maximum.
+    # @param non_retryable_error_types [Array<String>, nil] List of error types that are not retryable.
     def initialize(
-      initial_interval: 1,
-      backoff: 2.0,
+      initial_interval: 1.0,
+      backoff_coefficient: 2.0,
       max_interval: nil,
       max_attempts: 0,
-      non_retriable_errors: []
+      non_retryable_error_types: nil
     )
-      @initial_interval = initial_interval
-      @backoff = backoff
-      @max_interval = max_interval
-      @max_attempts = max_attempts
-      @non_retriable_errors = non_retriable_errors.map(&:to_s).compact
+      super
     end
 
-    def validate!
-      # Retries disabled
-      return if max_attempts == 1
-
-      # Maximum attempts
-      raise Invalid, 'Maximum attempts must be specified' unless max_attempts
-      raise Invalid, 'Maximum attempts cannot be negative' if max_attempts.negative?
-
-      # Initial interval
-      raise Invalid, 'Initial interval must be specified' unless initial_interval
-      raise Invalid, 'Initial interval cannot be negative' if initial_interval.negative?
-      raise Invalid, 'Initial interval must be in whole seconds' unless initial_interval.is_a?(Integer)
-
-      # Backoff coefficient
-      raise Invalid, 'Backoff coefficient must be specified' unless backoff
-      raise Invalid, 'Backoff coefficient cannot be less than 1' if backoff < 1
-
-      # Maximum interval
-      if max_interval
-        raise Invalid, 'Maximum interval cannot be negative' if max_interval.negative?
-        raise Invalid, 'Maximum interval cannot be less than initial interval' if max_interval < initial_interval
-      end
-    end
+    # @!visibility private
+    def _to_proto
+      raise 'Initial interval cannot be negative' if initial_interval.negative?
+      raise 'Backoff coefficient cannot be less than 1' if backoff_coefficient < 1
+      raise 'Max interval cannot be negative' if max_interval&.negative?
+      raise 'Max interval cannot be less than initial interval' if max_interval && max_interval < initial_interval
+      raise 'Max attempts cannot be negative' if max_attempts.negative?
 
-    def to_proto
-      Temporalio::Api::Common::V1::RetryPolicy.new(
-        initial_interval: Google::Protobuf::Duration.new(seconds: initial_interval),
-        backoff_coefficient: backoff,
-        maximum_interval: max_interval ? Google::Protobuf::Duration.new(seconds: max_interval) : nil,
+      Api::Common::V1::RetryPolicy.new(
+        initial_interval: Internal::ProtoUtils.seconds_to_duration(initial_interval),
+        backoff_coefficient:,
+        maximum_interval: Internal::ProtoUtils.seconds_to_duration(max_interval),
         maximum_attempts: max_attempts,
-        non_retryable_error_types: non_retriable_errors,
+        non_retryable_error_types:
       )
     end
   end