temporal-ruby 0.0.0 → 0.0.1.pre.pre1

data/lib/temporal/client/serializer.rb

@@ -0,0 +1,31 @@
+require 'temporal/workflow/command'
+require 'temporal/client/serializer/schedule_activity'
+require 'temporal/client/serializer/start_child_workflow'
+require 'temporal/client/serializer/request_activity_cancellation'
+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/fail_workflow'
+
+module Temporal
+  module Client
+    module Serializer
+      SERIALIZERS_MAP = {
+        Workflow::Command::ScheduleActivity => Serializer::ScheduleActivity,
+        Workflow::Command::StartChildWorkflow => Serializer::StartChildWorkflow,
+        Workflow::Command::RequestActivityCancellation => Serializer::RequestActivityCancellation,
+        Workflow::Command::RecordMarker => Serializer::RecordMarker,
+        Workflow::Command::StartTimer => Serializer::StartTimer,
+        Workflow::Command::CancelTimer => Serializer::CancelTimer,
+        Workflow::Command::CompleteWorkflow => Serializer::CompleteWorkflow,
+        Workflow::Command::FailWorkflow => Serializer::FailWorkflow
+      }.freeze
+
+      def self.serialize(object)
+        serializer = SERIALIZERS_MAP[object.class]
+        serializer.new(object).to_proto
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require 'oj'
+require 'gen/temporal/api/common/v1/message_pb'
+require 'gen/temporal/api/command/v1/message_pb'
+
+module Temporal
+  module Client
+    module Serializer
+      class Base
+        def initialize(object)
+          @object = object
+        end
+
+        def to_proto
+          raise NotImplementedError, 'serializer needs to implement #to_proto'
+        end
+
+        private
+
+        attr_reader :object
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require 'temporal/client/serializer/base'
+
+module Temporal
+  module Client
+    module Serializer
+      class CancelTimer < Base
+        def to_proto
+          Temporal::Api::Decision::V1::Command.new(
+            command_type: Temporal::Api::Enums::V1::CommandType::COMMAND_TYPE_CANCEL_TIMER,
+            cancel_timer_command_attributes:
+              Temporal::Api::Decision::V1::CancelTimerCommandAttributes.new(
+                timer_id: object.timer_id.to_s
+              )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'temporal/client/serializer/base'
+require 'temporal/client/serializer/payload'
+
+module Temporal
+  module Client
+    module Serializer
+      class CompleteWorkflow < Base
+        def to_proto
+          Temporal::Api::Decision::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
+              )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'temporal/client/serializer/base'
+require 'temporal/json'
+
+module Temporal
+  module Client
+    module Serializer
+      class FailWorkflow < Base
+        def to_proto
+          Temporal::Api::Decision::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(
+                failure: Failure.new(object.exception).to_proto
+              )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'temporal/client/serializer/base'
+require 'temporal/json'
+
+module Temporal
+  module Client
+    module Serializer
+      class Failure < Base
+        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
+            )
+          )
+        end
+
+        private
+
+        def stack_trace_from(backtrace)
+          return unless backtrace
+
+          backtrace.join("\n")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'temporal/client/serializer/base'
+require 'temporal/json'
+
+module Temporal
+  module Client
+    module Serializer
+      class Payload < Base
+        JSON_ENCODING = 'json/plain'.freeze
+
+        def to_proto
+          return if object.nil?
+
+          Temporal::Api::Common::V1::Payloads.new(
+            payloads: [
+              Temporal::Api::Common::V1::Payload.new(
+                metadata: { 'encoding' => JSON_ENCODING },
+                data: JSON.serialize(object)
+              )
+            ]
+          )
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,19 @@
+require 'temporal/client/serializer/base'
+
+module Temporal
+  module Client
+    module Serializer
+      class RequestActivityCancellation < Base
+        def to_proto
+          Temporal::Api::Decision::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(
+                scheduled_event_id: object.activity_id.to_i
+              )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+require 'temporal/client/serializer/base'
+require 'temporal/client/serializer/payload'
+
+module Temporal
+  module Client
+    module Serializer
+      class ScheduleActivity < Base
+        def to_proto
+          Temporal::Api::Decision::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(
+                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,
+                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),
+                header: serialize_headers(object.headers)
+              )
+          )
+        end
+
+        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
+
+          Temporal::Api::Common::V1::Header.new(fields: object.headers)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require 'temporal/client/serializer/base'
+require 'temporal/client/serializer/payload'
+
+module Temporal
+  module Client
+    module Serializer
+      class StartChildWorkflow < Base
+        def to_proto
+          Temporal::Api::Decision::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(
+                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,
+                workflow_execution_timeout: object.timeouts[:execution],
+                workflow_task_timeout: object.timeouts[:task],
+                retry_policy: serialize_retry_policy(object.retry_policy),
+                header: serialize_headers(object.headers)
+              )
+          )
+        end
+
+        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
+
+          Temporal::Api::Common::V1::Header.new(fields: object.headers)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'temporal/client/serializer/base'
+
+module Temporal
+  module Client
+    module Serializer
+      class StartTimer < Base
+        def to_proto
+          Temporal::Api::Decision::V1::Command.new(
+            command_type: Temporal::Api::Enums::V1::CommandType::COMMAND_TYPE_START_TIMER,
+            start_timer_command_attributes:
+              Temporal::Api::Decision::V1::StartTimerCommandAttributes.new(
+                timer_id: object.timer_id.to_s,
+                start_to_fire_timeout: object.timeout
+              )
+          )
+        end
+      end
+    end
+  end
+end

data/lib/temporal/concerns/executable.rb

@@ -0,0 +1,37 @@
+require 'temporal/retry_policy'
+
+module Temporal
+  module Concerns
+    module Executable
+      def namespace(*args)
+        return @namespace if args.empty?
+        @namespace = args.first
+      end
+
+      def task_queue(*args)
+        return @task_queue if args.empty?
+        @task_queue = args.first
+      end
+
+      def task_list(*args)
+        task_queue(*args)
+      end
+
+      def retry_policy(*args)
+        return @retry_policy if args.empty?
+        @retry_policy = Temporal::RetryPolicy.new(args.first)
+        @retry_policy.validate!
+      end
+
+      def timeouts(*args)
+        return @timeouts if args.empty?
+        @timeouts = args.first
+      end
+
+      def headers(*args)
+        return @headers if args.empty?
+        @headers = args.first
+      end
+    end
+  end
+end

data/lib/temporal/concerns/typed.rb

@@ -0,0 +1,40 @@
+require 'dry-struct'
+require 'temporal/types'
+
+module Temporal
+  module Concerns
+    module Typed
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        attr_reader :input_class
+
+        def execute_in_context(context, input)
+          input = input_class[*input] if input_class
+
+          super(context, input)
+        end
+
+        def input(klass = nil, &block)
+          if klass
+            unless klass.is_a?(Dry::Types::Type)
+              raise 'Unsupported input class. Use one of the provided Temporal::Types'
+            end
+            @input_class = klass
+          else
+            @input_class = generate_struct
+            @input_class.instance_eval(&block)
+          end
+        end
+
+        private
+
+        def generate_struct
+          Class.new(Dry::Struct::Value) { transform_keys(&:to_sym) }
+        end
+      end
+    end
+  end
+end

data/lib/temporal/configuration.rb

@@ -0,0 +1,44 @@
+require 'logger'
+require 'temporal/metrics_adapters/null'
+
+module Temporal
+  class Configuration
+    attr_reader :timeouts
+    attr_accessor :client_type, :host, :port, :logger, :metrics_adapter, :namespace, :task_queue, :headers
+
+    DEFAULT_TIMEOUTS = {
+      execution: 60,          # End-to-end workflow time
+      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
+      start_to_close: 30,     # Time spent processing an activity
+      heartbeat: nil          # Max time between heartbeats (off by default)
+    }.freeze
+
+    DEFAULT_HEADERS = {}.freeze
+    DEFAULT_NAMESPACE = 'default-namespace'.freeze
+    DEFAULT_TASK_QUEUE = 'default-task-queue'.freeze
+
+    def initialize
+      @client_type = :grpc
+      @logger = 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
+    end
+
+    def task_list
+      @task_queue
+    end
+
+    def task_list=(name)
+      self.task_queue = name
+    end
+
+    def timeouts=(new_timeouts)
+      @timeouts = DEFAULT_TIMEOUTS.merge(new_timeouts)
+    end
+  end
+end