temporal-ruby 0.0.0 → 0.0.1.pre.pre1

data/lib/temporal/errors.rb

@@ -0,0 +1,38 @@
+module Temporal
+  # Superclass for all Temporal errors
+  class Error < StandardError; end
+
+  # Superclass for errors specific to Temporal worker itself
+  class InternalError < Error; end
+
+  # Superclass for misconfiguration/misuse on the client (user) side
+  class ClientError < Error; end
+
+  # Represents any timeout
+  class TimeoutError < ClientError; end
+
+  # A superclass for activity exceptions raised explicitly
+  # with the intent to propagate to a workflow
+  class ActivityException < ClientError; end
+
+  class ActivityNotRegistered < ClientError; end
+  class WorkflowNotRegistered < ClientError; end
+
+  class ApiError < Error; end
+
+  class NotFoundFailure < ApiError; end
+  class WorkflowExecutionAlreadyStartedFailure < ApiError
+    attr_reader :run_id
+
+    def initialize(message, run_id)
+      super(message)
+      @run_id = run_id
+    end
+  end
+  class NamespaceNotActiveFailure < ApiError; end
+  class ClientVersionNotSupportedFailure < ApiError; end
+  class FeatureVersionNotSupportedFailure < ApiError; end
+  class NamespaceAlreadyExistsFailure < ApiError; end
+  class CancellationAlreadyRequestedFailure < ApiError; end
+  class QueryFailedFailure < ApiError; end
+end

data/lib/temporal/executable_lookup.rb

@@ -0,0 +1,25 @@
+# This class is responsible for matching an executable (activity or workflow) name
+# to a class implementing it.
+#
+# TODO: This class should be responsible for handling executable versions
+#       when these are implemented
+#
+module Temporal
+  class ExecutableLookup
+    def initialize
+      @executables = {}
+    end
+
+    def add(name, executable)
+      executables[name] = executable
+    end
+
+    def find(name)
+      executables[name]
+    end
+
+    private
+
+    attr_reader :executables
+  end
+end

data/lib/temporal/execution_options.rb

@@ -0,0 +1,35 @@
+require 'temporal/concerns/executable'
+
+module Temporal
+  class ExecutionOptions
+    attr_reader :name, :namespace, :task_queue, :retry_policy, :timeouts, :headers
+
+    def initialize(object, options = {})
+      @name = options[:name] || object.to_s
+      @namespace = options[:namespace]
+      @task_queue = options[:task_queue] || options[:task_list]
+      @retry_policy = options[:retry_policy]
+      @timeouts = options[:timeouts] || {}
+      @headers = options[:headers] || {}
+
+      if object.singleton_class.included_modules.include?(Concerns::Executable)
+        @namespace ||= object.namespace
+        @task_queue ||= object.task_queue
+        @retry_policy ||= object.retry_policy
+        @timeouts = object.timeouts.merge(@timeouts) if object.timeouts
+        @headers = object.headers.merge(@headers) if object.headers
+      end
+
+      @namespace ||= Temporal.configuration.namespace
+      @task_queue ||= Temporal.configuration.task_queue
+      @timeouts = Temporal.configuration.timeouts.merge(@timeouts)
+      @headers = Temporal.configuration.headers.merge(@headers)
+
+      freeze
+    end
+
+    def task_list
+      @task_queue
+    end
+  end
+end

data/lib/temporal/json.rb

@@ -0,0 +1,18 @@
+# Helper class for serializing/deserializing JSON
+require 'oj'
+
+module Temporal
+  module JSON
+    OJ_OPTIONS = {
+      mode: :object
+    }.freeze
+
+    def self.serialize(value)
+      Oj.dump(value, OJ_OPTIONS)
+    end
+
+    def self.deserialize(value)
+      Oj.load(value.to_s, OJ_OPTIONS)
+    end
+  end
+end

data/lib/temporal/metadata.rb

@@ -0,0 +1,68 @@
+require 'temporal/errors'
+require 'temporal/metadata/activity'
+require 'temporal/metadata/workflow'
+require 'temporal/metadata/workflow_task'
+
+module Temporal
+  module Metadata
+    ACTIVITY_TYPE = :activity
+    WORKFLOW_TASK_TYPE = :workflow_task
+    WORKFLOW_TYPE = :workflow
+
+    class << self
+      def generate(type, data, namespace = nil)
+        case type
+        when ACTIVITY_TYPE
+          activity_metadata_from(data, namespace)
+        when WORKFLOW_TASK_TYPE
+          workflow_task_metadata_from(data, namespace)
+        when WORKFLOW_TYPE
+          workflow_metadata_from(data)
+        else
+          raise InternalError, 'Unsupported metadata type'
+        end
+      end
+
+      private
+
+      def headers(fields)
+        fields.transform_values { |v| v[:data] }
+      end
+
+      def activity_metadata_from(task, namespace)
+        Metadata::Activity.new(
+          namespace: namespace,
+          id: task.activity_id,
+          name: task.activity_type.name,
+          task_token: task.task_token,
+          attempt: task.attempt,
+          workflow_run_id: task.workflow_execution.run_id,
+          workflow_id: task.workflow_execution.workflow_id,
+          workflow_name: task.workflow_type.name,
+          headers: headers(task.header&.fields.to_h)
+        )
+      end
+
+      def workflow_task_metadata_from(task, namespace)
+        Metadata::WorkflowTask.new(
+          namespace: namespace,
+          id: task.started_event_id,
+          task_token: task.task_token,
+          attempt: task.attempt,
+          workflow_run_id: task.workflow_execution.run_id,
+          workflow_id: task.workflow_execution.workflow_id,
+          workflow_name: task.workflow_type.name
+        )
+      end
+
+      def workflow_metadata_from(event)
+        Metadata::Workflow.new(
+          name: event.workflow_type.name,
+          run_id: event.original_execution_run_id,
+          attempt: event.attempt,
+          headers: headers(event.header&.fields.to_h)
+        )
+      end
+    end
+  end
+end

data/lib/temporal/metadata/activity.rb

@@ -0,0 +1,27 @@
+require 'temporal/metadata/base'
+
+module Temporal
+  module Metadata
+    class Activity < Base
+      attr_reader :namespace, :id, :name, :task_token, :attempt, :workflow_run_id, :workflow_id, :workflow_name, :headers
+
+      def initialize(namespace:, id:, name:, task_token:, attempt:, workflow_run_id:, workflow_id:, workflow_name:, headers: {})
+        @namespace = namespace
+        @id = id
+        @name = name
+        @task_token = task_token
+        @attempt = attempt
+        @workflow_run_id = workflow_run_id
+        @workflow_id = workflow_id
+        @workflow_name = workflow_name
+        @headers = headers
+
+        freeze
+      end
+
+      def activity?
+        true
+      end
+    end
+  end
+end

data/lib/temporal/metadata/base.rb

@@ -0,0 +1,17 @@
+module Temporal
+  module Metadata
+    class Base
+      def activity?
+        false
+      end
+
+      def workflow_task?
+        false
+      end
+
+      def workflow?
+        false
+      end
+    end
+  end
+end

data/lib/temporal/metadata/workflow.rb

@@ -0,0 +1,22 @@
+require 'temporal/metadata/base'
+
+module Temporal
+  module Metadata
+    class Workflow < Base
+      attr_reader :name, :run_id, :attempt, :headers
+
+      def initialize(name:, run_id:, attempt:, headers: {})
+        @name = name
+        @run_id = run_id
+        @attempt = attempt
+        @headers = headers
+
+        freeze
+      end
+
+      def workflow?
+        true
+      end
+    end
+  end
+end

data/lib/temporal/metadata/workflow_task.rb

@@ -0,0 +1,25 @@
+require 'temporal/metadata/base'
+
+module Temporal
+  module Metadata
+    class WorkflowTask < Base
+      attr_reader :namespace, :id, :task_token, :attempt, :workflow_run_id, :workflow_id, :workflow_name
+
+      def initialize(namespace:, id:, task_token:, attempt:, workflow_run_id:, workflow_id:, workflow_name:)
+        @namespace = namespace
+        @id = id
+        @task_token = task_token
+        @attempt = attempt
+        @workflow_run_id = workflow_run_id
+        @workflow_id = workflow_id
+        @workflow_name = workflow_name
+
+        freeze
+      end
+
+      def workflow_task?
+        true
+      end
+    end
+  end
+end

data/lib/temporal/metrics.rb

@@ -0,0 +1,37 @@
+module Temporal
+  class Metrics
+    def initialize(adapter)
+      @adapter = adapter
+    end
+
+    def increment(key, tags = {})
+      count(key, 1, tags)
+    end
+
+    def decrement(key, tags = {})
+      count(key, -1, tags)
+    end
+
+    def count(key, count, tags = {})
+      adapter.count(key, count, tags)
+    rescue StandardError => error
+      Temporal.logger.error("Adapter failed to send count metrics for #{key}: #{error.inspect}")
+    end
+
+    def gauge(key, value, tags = {})
+      adapter.gauge(key, value, tags)
+    rescue StandardError => error
+      Temporal.logger.error("Adapter failed to send gauge metrics for #{key}: #{error.inspect}")
+    end
+
+    def timing(key, time, tags = {})
+      adapter.timing(key, time, tags)
+    rescue StandardError => error
+      Temporal.logger.error("Adapter failed to send timing metrics for #{key}: #{error.inspect}")
+    end
+
+    private
+
+    attr_reader :adapter
+  end
+end

data/lib/temporal/metrics_adapters/log.rb

@@ -0,0 +1,33 @@
+module Temporal
+  module MetricsAdapters
+    class Log
+      def initialize(logger)
+        @logger = logger
+      end
+
+      def count(key, count, tags)
+        logger.debug(format_message(key, 'count', count, tags))
+      end
+
+      def gauge(key, value, tags)
+        logger.debug(format_message(key, 'gauge', value, tags))
+      end
+
+      def timing(key, time, tags)
+        logger.debug(format_message(key, 'timing', time, tags))
+      end
+
+      private
+
+      attr_reader :logger
+
+      def format_message(key, type, value, tags)
+        tags_str = tags.map { |k, v| "#{k}:#{v}" }.join(',')
+        parts = [key, type, value]
+        parts << tags_str if !tags_str.empty?
+
+        parts.join(' | ')
+      end
+    end
+  end
+end

data/lib/temporal/metrics_adapters/null.rb

@@ -0,0 +1,9 @@
+module Temporal
+  module MetricsAdapters
+    class Null
+      def count(_key, _count, _tags); end
+      def gauge(_key, _value, _tags); end
+      def timing(_key, _time, _tags); end
+    end
+  end
+end

data/lib/temporal/middleware/chain.rb

@@ -0,0 +1,30 @@
+module Temporal
+  module Middleware
+    class Chain
+      def initialize(entries = [])
+        @middleware = entries.map(&:init_middleware)
+      end
+
+      def invoke(metadata)
+        result = nil
+        chain = middleware.dup
+
+        traverse_chain = lambda do
+          if chain.empty?
+            result = yield
+          else
+            chain.shift.call(metadata, &traverse_chain)
+          end
+        end
+
+        traverse_chain.call
+
+        result
+      end
+
+      private
+
+      attr_reader :middleware
+    end
+  end
+end

data/lib/temporal/middleware/entry.rb

@@ -0,0 +1,9 @@
+module Temporal
+  module Middleware
+    class Entry < Struct.new(:klass, :args)
+      def init_middleware
+        klass.new(*args)
+      end
+    end
+  end
+end

data/lib/temporal/retry_policy.rb

@@ -0,0 +1,27 @@
+require 'temporal/errors'
+
+module Temporal
+  class RetryPolicy < Struct.new(:interval, :backoff, :max_interval, :max_attempts,
+    :expiration_interval, :non_retriable_errors, keyword_init: true)
+
+    class InvalidRetryPolicy < ClientError; end
+
+    def validate!
+      unless interval && backoff
+        raise InvalidRetryPolicy, 'interval and backoff must be set'
+      end
+
+      unless max_attempts || expiration_interval
+        raise InvalidRetryPolicy, 'max_attempts or expiration_interval must be set'
+      end
+
+      unless [interval, max_interval, expiration_interval].compact.all? { |arg| arg.is_a?(Integer) }
+        raise InvalidRetryPolicy, 'All intervals must be specified in whole seconds'
+      end
+
+      unless [interval, max_interval, expiration_interval].compact.all? { |arg| arg > 0 }
+        raise InvalidRetryPolicy, 'All intervals must be greater than 0'
+      end
+    end
+  end
+end

data/lib/temporal/saga/concern.rb

@@ -0,0 +1,23 @@
+require 'temporal/saga/saga'
+require 'temporal/saga/result'
+
+module Temporal
+  module Saga
+    module Concern
+      def run_saga(&block)
+        saga = Temporal::Saga::Saga.new(workflow)
+
+        block.call(saga)
+
+        Result.new(true)
+      rescue StandardError => error # TODO: is there a need for a specialized error here?
+        logger.error("Saga execution aborted: #{error.inspect}")
+        logger.debug(error.backtrace.join("\n"))
+
+        saga.compensate
+
+        Result.new(false, error)
+      end
+    end
+  end
+end