temporal-ruby 0.0.1.pre.pre1 → 0.0.1

data/lib/temporal/client/retryer.rb

@@ -0,0 +1,49 @@
+module Temporal
+  module Client
+    module Retryer
+      INITIAL_INTERVAL_S = 0.2
+      MAX_INTERVAL_S = 6.0
+      BACKOFF_COEFFICIENT = 1.2
+      DEFAULT_RETRIES = 24 # gets us to about 60s given the other parameters, assuming 0 latency
+
+      # List pulled from RpcRetryOptions in the Java SDK
+      # https://github.com/temporalio/sdk-java/blob/ad8831d4a4d9d257baf3482ab49f1aa681895c0e/temporal-serviceclient/src/main/java/io/temporal/serviceclient/RpcRetryOptions.java#L32
+      # No amount of retrying will help in these cases.
+      def self.do_not_retry_errors
+        [
+          GRPC::AlreadyExists,
+          GRPC::Cancelled,
+          GRPC::FailedPrecondition,
+          GRPC::InvalidArgument,
+          # If the activity has timed out, the server will return this and will never accept a retry
+          GRPC::NotFound,
+          GRPC::PermissionDenied,
+          GRPC::Unauthenticated,
+          GRPC::Unimplemented,
+        ]
+      end
+
+      # Used for backoff retries in certain cases when calling temporal server.
+      # on_retry - a proc that's executed each time you need to retry
+      def self.with_retries(times: DEFAULT_RETRIES, on_retry: nil, &block)
+        # Values taken from the Java SDK
+        # https://github.com/temporalio/sdk-java/blob/ad8831d4a4d9d257baf3482ab49f1aa681895c0e/temporal-serviceclient/src/main/java/io/temporal/serviceclient/RpcRetryOptions.java#L32
+        current_interval_s = INITIAL_INTERVAL_S
+        retry_i = 0
+        loop do
+          begin
+            return yield
+          rescue *do_not_retry_errors
+            raise
+          rescue => e
+            raise e if retry_i >= times
+            retry_i += 1
+            on_retry.call if on_retry
+            sleep(current_interval_s)
+            current_interval_s = [current_interval_s * BACKOFF_COEFFICIENT, MAX_INTERVAL_S].min
+          end
+        end
+      end
+    end
+  end
+end

data/lib/temporal/client/serializer.rb

@@ -6,6 +6,7 @@ require 'temporal/client/serializer/record_marker'
 require 'temporal/client/serializer/start_timer'
 require 'temporal/client/serializer/cancel_timer'
 require 'temporal/client/serializer/complete_workflow'
+require 'temporal/client/serializer/continue_as_new'
 require 'temporal/client/serializer/fail_workflow'
 
 module Temporal
@@ -19,6 +20,7 @@ module Temporal
         Workflow::Command::StartTimer => Serializer::StartTimer,
         Workflow::Command::CancelTimer => Serializer::CancelTimer,
         Workflow::Command::CompleteWorkflow => Serializer::CompleteWorkflow,
+        Workflow::Command::ContinueAsNew => Serializer::ContinueAsNew,
         Workflow::Command::FailWorkflow => Serializer::FailWorkflow
       }.freeze
 

data/lib/temporal/client/serializer/cancel_timer.rb

@@ -5,10 +5,10 @@ module Temporal
     module Serializer
       class CancelTimer < Base
         def to_proto
-          Temporal::Api::Decision::V1::Command.new(
+          Temporal::Api::Command::V1::Command.new(
             command_type: Temporal::Api::Enums::V1::CommandType::COMMAND_TYPE_CANCEL_TIMER,
             cancel_timer_command_attributes:
-              Temporal::Api::Decision::V1::CancelTimerCommandAttributes.new(
+              Temporal::Api::Command::V1::CancelTimerCommandAttributes.new(
                 timer_id: object.timer_id.to_s
               )
           )

data/lib/temporal/client/serializer/complete_workflow.rb

@@ -1,16 +1,18 @@
 require 'temporal/client/serializer/base'
-require 'temporal/client/serializer/payload'
+require 'temporal/concerns/payloads'
 
 module Temporal
   module Client
     module Serializer
       class CompleteWorkflow < Base
+        include Concerns::Payloads
+
         def to_proto
-          Temporal::Api::Decision::V1::Command.new(
+          Temporal::Api::Command::V1::Command.new(
             command_type: Temporal::Api::Enums::V1::CommandType::COMMAND_TYPE_COMPLETE_WORKFLOW_EXECUTION,
             complete_workflow_execution_command_attributes:
-              Temporal::Api::Decision::V1::CompleteWorkflowExecutionCommandAttributes.new(
-                result: Payload.new(object.result).to_proto
+              Temporal::Api::Command::V1::CompleteWorkflowExecutionCommandAttributes.new(
+                result: to_result_payloads(object.result)
               )
           )
         end

data/lib/temporal/client/serializer/continue_as_new.rb

@@ -0,0 +1,37 @@
+require 'temporal/client/serializer/base'
+require 'temporal/client/serializer/retry_policy'
+require 'temporal/concerns/payloads'
+
+module Temporal
+  module Client
+    module Serializer
+      class ContinueAsNew < Base
+        include Concerns::Payloads
+
+        def to_proto
+          Temporal::Api::Command::V1::Command.new(
+            command_type: Temporal::Api::Enums::V1::CommandType::COMMAND_TYPE_CONTINUE_AS_NEW_WORKFLOW_EXECUTION,
+            continue_as_new_workflow_execution_command_attributes:
+              Temporal::Api::Command::V1::ContinueAsNewWorkflowExecutionCommandAttributes.new(
+                workflow_type: Temporal::Api::Common::V1::WorkflowType.new(name: object.workflow_type),
+                task_queue: Temporal::Api::TaskQueue::V1::TaskQueue.new(name: object.task_queue),
+                input: to_payloads(object.input),
+                workflow_run_timeout: object.timeouts[:execution],
+                workflow_task_timeout: object.timeouts[:task],
+                retry_policy: Temporal::Client::Serializer::RetryPolicy.new(object.retry_policy).to_proto,
+                header: serialize_headers(object.headers)
+              )
+          )
+        end
+
+        private
+
+        def serialize_headers(headers)
+          return unless headers
+
+          Temporal::Api::Common::V1::Header.new(fields: object.headers)
+        end
+      end
+    end
+  end
+end

data/lib/temporal/client/serializer/fail_workflow.rb

@@ -6,10 +6,10 @@ module Temporal
     module Serializer
       class FailWorkflow < Base
         def to_proto
-          Temporal::Api::Decision::V1::Command.new(
+          Temporal::Api::Command::V1::Command.new(
             command_type: Temporal::Api::Enums::V1::CommandType::COMMAND_TYPE_FAIL_WORKFLOW_EXECUTION,
             fail_workflow_execution_command_attributes:
-              Temporal::Api::Decision::V1::FailWorkflowExecutionCommandAttributes.new(
+              Temporal::Api::Command::V1::FailWorkflowExecutionCommandAttributes.new(
                 failure: Failure.new(object.exception).to_proto
               )
           )

data/lib/temporal/client/serializer/failure.rb

@@ -1,17 +1,19 @@
 require 'temporal/client/serializer/base'
-require 'temporal/json'
+require 'temporal/concerns/payloads'
 
 module Temporal
   module Client
     module Serializer
       class Failure < Base
+        include Concerns::Payloads
+
         def to_proto
           Temporal::Api::Failure::V1::Failure.new(
             message: object.message,
             stack_trace: stack_trace_from(object.backtrace),
             application_failure_info: Temporal::Api::Failure::V1::ApplicationFailureInfo.new(
               type: object.class.name,
-              details: Payload.new(object.message).to_proto
+              details: to_details_payloads(object.message)
             )
           )
         end

data/lib/temporal/client/serializer/record_marker.rb

@@ -1,18 +1,20 @@
 require 'temporal/client/serializer/base'
-require 'temporal/client/serializer/payload'
+require 'temporal/concerns/payloads'
 
 module Temporal
   module Client
     module Serializer
       class RecordMarker < Base
+        include Concerns::Payloads
+
         def to_proto
-          Temporal::Api::Decision::V1::Command.new(
+          Temporal::Api::Command::V1::Command.new(
             command_type: Temporal::Api::Enums::V1::CommandType::COMMAND_TYPE_RECORD_MARKER,
             record_marker_command_attributes:
-              Temporal::Api::Decision::V1::RecordMarkerCommandAttributes.new(
+              Temporal::Api::Command::V1::RecordMarkerCommandAttributes.new(
                 marker_name: object.name,
                 details: {
-                  'data' => Payload.new(object.details).to_proto
+                  'data' => to_details_payloads(object.details)
                 }
               )
           )

data/lib/temporal/client/serializer/request_activity_cancellation.rb

@@ -5,10 +5,10 @@ module Temporal
     module Serializer
       class RequestActivityCancellation < Base
         def to_proto
-          Temporal::Api::Decision::V1::Command.new(
+          Temporal::Api::Command::V1::Command.new(
             command_type: Temporal::Api::Enums::V1::CommandType::COMMAND_TYPE_REQUEST_CANCEL_ACTIVITY_TASK,
             request_cancel_activity_task_command_attributes:
-              Temporal::Api::Decision::V1::RequestCancelActivityTaskCommandAttributes.new(
+              Temporal::Api::Command::V1::RequestCancelActivityTaskCommandAttributes.new(
                 scheduled_event_id: object.activity_id.to_i
               )
           )

data/lib/temporal/client/serializer/retry_policy.rb

@@ -0,0 +1,24 @@
+require 'temporal/client/serializer/base'
+
+module Temporal
+  module Client
+    module Serializer
+      class RetryPolicy < Base
+        def to_proto
+          return unless object
+
+          non_retriable_errors = Array(object.non_retriable_errors).map(&:name)
+          options = {
+            initial_interval: object.interval,
+            backoff_coefficient: object.backoff,
+            maximum_interval: object.max_interval,
+            maximum_attempts: object.max_attempts,
+            non_retryable_error_types: non_retriable_errors,
+          }.compact
+
+          Temporal::Api::Common::V1::RetryPolicy.new(options)
+        end
+      end
+    end
+  end
+end

data/lib/temporal/client/serializer/schedule_activity.rb

@@ -1,25 +1,28 @@
 require 'temporal/client/serializer/base'
-require 'temporal/client/serializer/payload'
+require 'temporal/client/serializer/retry_policy'
+require 'temporal/concerns/payloads'
 
 module Temporal
   module Client
     module Serializer
       class ScheduleActivity < Base
+        include Concerns::Payloads
+
         def to_proto
-          Temporal::Api::Decision::V1::Command.new(
+          Temporal::Api::Command::V1::Command.new(
             command_type: Temporal::Api::Enums::V1::CommandType::COMMAND_TYPE_SCHEDULE_ACTIVITY_TASK,
             schedule_activity_task_command_attributes:
-              Temporal::Api::Decision::V1::ScheduleActivityTaskCommandAttributes.new(
+              Temporal::Api::Command::V1::ScheduleActivityTaskCommandAttributes.new(
                 activity_id: object.activity_id.to_s,
                 activity_type: Temporal::Api::Common::V1::ActivityType.new(name: object.activity_type),
-                input: Payload.new(object.input).to_proto,
+                input: to_payloads(object.input),
                 namespace: object.namespace,
                 task_queue: Temporal::Api::TaskQueue::V1::TaskQueue.new(name: object.task_queue),
                 schedule_to_close_timeout: object.timeouts[:schedule_to_close],
                 schedule_to_start_timeout: object.timeouts[:schedule_to_start],
                 start_to_close_timeout: object.timeouts[:start_to_close],
                 heartbeat_timeout: object.timeouts[:heartbeat],
-                retry_policy: serialize_retry_policy(object.retry_policy),
+                retry_policy: Temporal::Client::Serializer::RetryPolicy.new(object.retry_policy).to_proto,
                 header: serialize_headers(object.headers)
               )
           )
@@ -27,21 +30,6 @@ module Temporal
 
         private
 
-        def serialize_retry_policy(retry_policy)
-          return unless retry_policy
-
-          non_retriable_errors = Array(retry_policy.non_retriable_errors).map(&:name)
-          options = {
-            initial_interval: retry_policy.interval,
-            backoff_coefficient: retry_policy.backoff,
-            maximum_interval: retry_policy.max_interval,
-            maximum_attempts: retry_policy.max_attempts,
-            non_retryable_error_types: non_retriable_errors
-          }.compact
-
-          Temporal::Api::Common::V1::RetryPolicy.new(options)
-        end
-
         def serialize_headers(headers)
           return unless headers
 

data/lib/temporal/client/serializer/start_child_workflow.rb

@@ -1,23 +1,27 @@
 require 'temporal/client/serializer/base'
-require 'temporal/client/serializer/payload'
+require 'temporal/client/serializer/retry_policy'
+require 'temporal/concerns/payloads'
 
 module Temporal
   module Client
     module Serializer
       class StartChildWorkflow < Base
+        include Concerns::Payloads
+
         def to_proto
-          Temporal::Api::Decision::V1::Command.new(
+          Temporal::Api::Command::V1::Command.new(
             command_type: Temporal::Api::Enums::V1::CommandType::COMMAND_TYPE_START_CHILD_WORKFLOW_EXECUTION,
             start_child_workflow_execution_command_attributes:
-              Temporal::Api::Decision::V1::StartChildWorkflowExecutionCommandAttributes.new(
+              Temporal::Api::Command::V1::StartChildWorkflowExecutionCommandAttributes.new(
                 namespace: object.namespace,
                 workflow_id: object.workflow_id.to_s,
                 workflow_type: Temporal::Api::Common::V1::WorkflowType.new(name: object.workflow_type),
                 task_queue: Temporal::Api::TaskQueue::V1::TaskQueue.new(name: object.task_queue),
-                input: Payload.new(object.input).to_proto,
+                input: to_payloads(object.input),
                 workflow_execution_timeout: object.timeouts[:execution],
+                workflow_run_timeout: object.timeouts[:run],
                 workflow_task_timeout: object.timeouts[:task],
-                retry_policy: serialize_retry_policy(object.retry_policy),
+                retry_policy: Temporal::Client::Serializer::RetryPolicy.new(object.retry_policy).to_proto,
                 header: serialize_headers(object.headers)
               )
           )
@@ -25,21 +29,6 @@ module Temporal
 
         private
 
-        def serialize_retry_policy(retry_policy)
-          return unless retry_policy
-
-          non_retriable_errors = Array(retry_policy.non_retriable_errors).map(&:name)
-          options = {
-            initial_interval: retry_policy.interval,
-            backoff_coefficient: retry_policy.backoff,
-            maximum_interval: retry_policy.max_interval,
-            maximum_attempts: retry_policy.max_attempts,
-            non_retriable_error_reasons: non_retriable_errors,
-          }.compact
-
-          Temporal::Api::Common::V1::RetryPolicy.new(options)
-        end
-
         def serialize_headers(headers)
           return unless headers
 

data/lib/temporal/client/serializer/start_timer.rb

@@ -5,10 +5,10 @@ module Temporal
     module Serializer
       class StartTimer < Base
         def to_proto
-          Temporal::Api::Decision::V1::Command.new(
+          Temporal::Api::Command::V1::Command.new(
             command_type: Temporal::Api::Enums::V1::CommandType::COMMAND_TYPE_START_TIMER,
             start_timer_command_attributes:
-              Temporal::Api::Decision::V1::StartTimerCommandAttributes.new(
+              Temporal::Api::Command::V1::StartTimerCommandAttributes.new(
                 timer_id: object.timer_id.to_s,
                 start_to_fire_timeout: object.timeout
               )

data/lib/temporal/concerns/payloads.rb

@@ -0,0 +1,51 @@
+module Temporal
+  module Concerns
+    module Payloads
+      def from_payloads(payloads)
+        payload_converter.from_payloads(payloads)
+      end
+
+      def from_payload(payload)
+        payload_converter.from_payload(payload)
+      end
+
+      def from_result_payloads(payloads)
+        from_payloads(payloads)&.first
+      end
+
+      def from_details_payloads(payloads)
+        from_payloads(payloads)&.first
+      end
+
+      def from_signal_payloads(payloads)
+        from_payloads(payloads)&.first
+      end
+
+      def to_payloads(data)
+        payload_converter.to_payloads(data)
+      end
+
+      def to_payload(data)
+        payload_converter.to_payload(data)
+      end
+
+      def to_result_payloads(data)
+        to_payloads([data])
+      end
+
+      def to_details_payloads(data)
+        to_payloads([data])
+      end
+
+      def to_signal_payloads(data)
+        to_payloads([data])
+      end
+
+      private
+
+      def payload_converter
+        Temporal.configuration.converter
+      end
+    end
+  end
+end

data/lib/temporal/configuration.rb

@@ -1,13 +1,23 @@
-require 'logger'
+require 'temporal/logger'
 require 'temporal/metrics_adapters/null'
+require 'temporal/client/converter/payload/nil'
+require 'temporal/client/converter/payload/bytes'
+require 'temporal/client/converter/payload/json'
+require 'temporal/client/converter/composite'
 
 module Temporal
   class Configuration
-    attr_reader :timeouts
+    attr_reader :timeouts, :error_handlers
+    attr_writer :converter
     attr_accessor :client_type, :host, :port, :logger, :metrics_adapter, :namespace, :task_queue, :headers
 
+    # We want an infinite execution timeout for cron schedules and other perpetual workflows.
+    # We choose an 10-year execution timeout because that's the maximum the cassandra DB supports,
+    # matching the go SDK, see https://github.com/temporalio/sdk-go/blob/d96130dad3d2bc189bc7626543bd5911cc07ff6d/internal/internal_workflow_testsuite.go#L68
     DEFAULT_TIMEOUTS = {
-      execution: 60,          # End-to-end workflow time
+      execution: 86_400 * 365 * 10, # End-to-end workflow time, including all recurrences if it's scheduled.
+      # Time for a single run, excluding retries.  Server defaults to execution timeout; we default here as well to be explicit.
+      run: 86_400 * 365 * 10,
       task: 10,               # Workflow task processing time
       schedule_to_close: nil, # End-to-end activity time (default: schedule_to_start + start_to_close)
       schedule_to_start: 10,  # Queue time for an activity
@@ -18,15 +28,28 @@ module Temporal
     DEFAULT_HEADERS = {}.freeze
     DEFAULT_NAMESPACE = 'default-namespace'.freeze
     DEFAULT_TASK_QUEUE = 'default-task-queue'.freeze
+    DEFAULT_CONVERTER = Temporal::Client::Converter::Composite.new(
+      payload_converters: [
+        Temporal::Client::Converter::Payload::Nil.new,
+        Temporal::Client::Converter::Payload::Bytes.new,
+        Temporal::Client::Converter::Payload::JSON.new,
+      ]
+    ).freeze
 
     def initialize
       @client_type = :grpc
-      @logger = Logger.new(STDOUT, progname: 'temporal_client')
+      @logger = Temporal::Logger.new(STDOUT, progname: 'temporal_client')
       @metrics_adapter = MetricsAdapters::Null.new
       @timeouts = DEFAULT_TIMEOUTS
       @namespace = DEFAULT_NAMESPACE
       @task_queue = DEFAULT_TASK_QUEUE
       @headers = DEFAULT_HEADERS
+      @converter = DEFAULT_CONVERTER
+      @error_handlers = []
+    end
+
+    def on_error(&block)
+      @error_handlers << block
     end
 
     def task_list
@@ -40,5 +63,9 @@ module Temporal
     def timeouts=(new_timeouts)
       @timeouts = DEFAULT_TIMEOUTS.merge(new_timeouts)
     end
+
+    def converter
+      @converter
+    end
   end
 end