cadence-ruby 0.0.0 → 0.1.0

data/lib/cadence/metrics_adapters/null.rb

@@ -0,0 +1,9 @@
+module Cadence
+  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/cadence/middleware/chain.rb

@@ -0,0 +1,30 @@
+module Cadence
+  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/cadence/middleware/entry.rb

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

data/lib/cadence/retry_policy.rb

@@ -0,0 +1,27 @@
+require 'cadence/errors'
+
+module Cadence
+  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/cadence/saga/concern.rb

@@ -0,0 +1,37 @@
+require 'cadence/saga/saga'
+require 'cadence/saga/result'
+
+module Cadence
+  module Saga
+    module Concern
+      def run_saga(configuration = {}, &block)
+        saga = Cadence::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"))
+
+        if compensate?(error, **configuration)
+          logger.error('Saga compensating')
+          saga.compensate
+          Result.new(false, error)
+        else
+          logger.error('Saga not compensating')
+          raise error
+        end
+      end
+
+      def compensate?(error, compensate_on: [], do_not_compensate_on: [])
+        error_class = error.class
+        if compensate_on.any?
+          compensate_on.include?(error_class)
+        else
+          !do_not_compensate_on.include?(error_class)
+        end
+      end
+    end
+  end
+end

data/lib/cadence/saga/result.rb

@@ -0,0 +1,22 @@
+module Cadence
+  module Saga
+    class Result
+      attr_reader :rollback_reason
+
+      def initialize(completed, rollback_reason = nil)
+        @completed = completed
+        @rollback_reason = rollback_reason
+
+        freeze
+      end
+
+      def completed?
+        @completed
+      end
+
+      def compensated?
+        !completed?
+      end
+    end
+  end
+end

data/lib/cadence/saga/saga.rb

@@ -0,0 +1,24 @@
+module Cadence
+  module Saga
+    class Saga
+      def initialize(context)
+        @context = context
+        @compensations = []
+      end
+
+      def add_compensation(activity, *args)
+        compensations << [activity, args]
+      end
+
+      def compensate
+        compensations.reverse_each do |(activity, args)|
+          context.execute_activity!(activity, *args)
+        end
+      end
+
+      private
+
+      attr_reader :context, :compensations
+    end
+  end
+end

data/lib/cadence/testing.rb

@@ -0,0 +1,50 @@
+require 'cadence/testing/cadence_override'
+require 'cadence/testing/workflow_override'
+
+module Cadence
+  module Testing
+    DISABLED_MODE = nil
+    LOCAL_MODE = :local
+
+    class << self
+      def local!(&block)
+        set_mode(LOCAL_MODE, &block)
+      end
+
+      def disabled!(&block)
+        set_mode(DISABLED_MODE, &block)
+      end
+
+      def disabled?
+        mode == DISABLED_MODE
+      end
+
+      def local?
+        mode == LOCAL_MODE
+      end
+
+      private
+
+      attr_reader :mode
+
+      def set_mode(new_mode, &block)
+        if block_given?
+          with_mode(new_mode, &block)
+        else
+          @mode = new_mode
+        end
+      end
+
+      def with_mode(new_mode, &block)
+        previous_mode = mode
+        @mode = new_mode
+        yield
+      ensure
+        @mode = previous_mode
+      end
+    end
+  end
+end
+
+Cadence.singleton_class.prepend Cadence::Testing::CadenceOverride
+Cadence::Workflow.extend Cadence::Testing::WorkflowOverride

data/lib/cadence/testing/cadence_override.rb

@@ -0,0 +1,112 @@
+require 'securerandom'
+require 'cadence/activity/async_token'
+require 'cadence/workflow/execution_info'
+require 'cadence/testing/workflow_execution'
+require 'cadence/testing/local_workflow_context'
+
+module Cadence
+  module Testing
+    module CadenceOverride
+      def start_workflow(workflow, *input, **args)
+        return super if Cadence::Testing.disabled?
+
+        if Cadence::Testing.local?
+          start_locally(workflow, *input, **args)
+        end
+      end
+
+      def fetch_workflow_execution_info(_domain, workflow_id, run_id)
+        return super if Cadence::Testing.disabled?
+
+        execution = executions[[workflow_id, run_id]]
+
+        Workflow::ExecutionInfo.new(
+          workflow: nil,
+          workflow_id: workflow_id,
+          run_id: run_id,
+          start_time: nil,
+          close_time: nil,
+          status: execution.status,
+          history_length: nil,
+        ).freeze
+      end
+
+      def complete_activity(async_token, result = nil)
+        return super if Cadence::Testing.disabled?
+
+        details = Activity::AsyncToken.decode(async_token)
+        execution = executions[[details.workflow_id, details.run_id]]
+
+        execution.complete_activity(async_token, result)
+      end
+
+      def fail_activity(async_token, error)
+        return super if Cadence::Testing.disabled?
+
+        details = Activity::AsyncToken.decode(async_token)
+        execution = executions[[details.workflow_id, details.run_id]]
+
+        execution.fail_activity(async_token, error)
+      end
+
+      private
+
+      def executions
+        @executions ||= {}
+      end
+
+      def start_locally(workflow, *input, **args)
+        options = args.delete(:options) || {}
+        input << args unless args.empty?
+
+        reuse_policy = options[:workflow_id_reuse_policy] || :allow_failed
+        workflow_id = options[:workflow_id] || SecureRandom.uuid
+        run_id = SecureRandom.uuid
+
+        if !allowed?(workflow_id, reuse_policy)
+          raise CadenceThrift::WorkflowExecutionAlreadyStartedError,
+            "Workflow execution already started for id #{workflow_id}, reuse policy #{reuse_policy}"
+        end
+
+        execution = WorkflowExecution.new
+        executions[[workflow_id, run_id]] = execution
+
+        execution_options = ExecutionOptions.new(workflow, options)
+        headers = execution_options.headers
+        context = Cadence::Testing::LocalWorkflowContext.new(
+          execution, workflow_id, run_id, workflow.disabled_releases, headers
+        )
+
+        execution.run do
+          workflow.execute_in_context(context, input)
+        end
+
+        run_id
+      end
+
+      def allowed?(workflow_id, reuse_policy)
+        disallowed_statuses = disallowed_statuses_for(reuse_policy)
+
+        # there isn't a single execution in a dissallowed status
+        executions.none? do |(w_id, _), execution|
+          w_id == workflow_id && disallowed_statuses.include?(execution.status)
+        end
+      end
+
+      def disallowed_statuses_for(reuse_policy)
+        case reuse_policy
+        when :allow_failed
+          [Workflow::ExecutionInfo::RUNNING_STATUS, Workflow::ExecutionInfo::COMPLETED_STATUS]
+        when :allow
+          [Workflow::ExecutionInfo::RUNNING_STATUS]
+        when :reject
+          [
+            Workflow::ExecutionInfo::RUNNING_STATUS,
+            Workflow::ExecutionInfo::FAILED_STATUS,
+            Workflow::ExecutionInfo::COMPLETED_STATUS
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/cadence/testing/future_registry.rb

@@ -0,0 +1,27 @@
+module Cadence
+  module Testing
+    class FutureRegistry
+      def initialize
+        @store = {}
+      end
+
+      def register(token, future)
+        raise 'already registered' if store.key?(token)
+
+        store[token] = future
+      end
+
+      def complete(token, result)
+        store[token].set(result)
+      end
+
+      def fail(token, error)
+        store[token].fail(error.class.name, error.message)
+      end
+
+      private
+
+      attr_reader :store
+    end
+  end
+end

data/lib/cadence/testing/local_activity_context.rb

@@ -0,0 +1,17 @@
+require 'securerandom'
+require 'cadence/uuid'
+require 'cadence/activity/context'
+
+module Cadence
+  module Testing
+    class LocalActivityContext < Activity::Context
+      def initialize(metadata)
+        super(nil, metadata)
+      end
+
+      def heartbeat(details = nil)
+        raise NotImplementedError, 'not yet available for testing'
+      end
+    end
+  end
+end

data/lib/cadence/testing/local_workflow_context.rb

@@ -0,0 +1,207 @@
+require 'securerandom'
+require 'cadence/testing/local_activity_context'
+require 'cadence/testing/workflow_execution'
+require 'cadence/execution_options'
+require 'cadence/metadata/activity'
+require 'cadence/workflow/future'
+require 'cadence/workflow/history/event_target'
+
+module Cadence
+  module Testing
+    class LocalWorkflowContext
+      attr_reader :headers
+
+      def initialize(execution, workflow_id, run_id, disabled_releases, headers = {})
+        @last_event_id = 0
+        @execution = execution
+        @run_id = run_id
+        @workflow_id = workflow_id
+        @disabled_releases = disabled_releases
+        @headers = headers
+      end
+
+      def logger
+        Cadence.logger
+      end
+
+      def has_release?(change_name)
+        !disabled_releases.include?(change_name.to_s)
+      end
+
+      def execute_activity(activity_class, *input, **args)
+        options = args.delete(:options) || {}
+        input << args unless args.empty?
+
+        event_id = next_event_id
+        activity_id = options[:activity_id] || event_id
+
+        target = Workflow::History::EventTarget.new(event_id, Workflow::History::EventTarget::ACTIVITY_TYPE)
+        future = Workflow::Future.new(target, self, cancelation_id: activity_id)
+
+        execution_options = ExecutionOptions.new(activity_class, options)
+        metadata = Metadata::Activity.new(
+          domain: execution_options.domain,
+          id: activity_id,
+          name: execution_options.name,
+          task_token: nil,
+          attempt: 1,
+          workflow_run_id: run_id,
+          workflow_id: workflow_id,
+          workflow_name: nil, # not yet used, but will be in the future
+          headers: execution_options.headers,
+          timeouts: {
+            start_to_close: 30,
+            schedule_to_close: 60,
+            heartbeat: 5
+          }
+        )
+        context = LocalActivityContext.new(metadata)
+
+        result = activity_class.execute_in_context(context, input)
+
+        if context.async?
+          execution.register_future(context.async_token, future)
+        else
+          # Fulfil the future straigt away for non-async activities
+          future.set(result)
+        end
+
+        future
+      end
+
+      def execute_activity!(activity_class, *input, **args)
+        future = execute_activity(activity_class, *input, **args)
+        result = future.get
+
+        if future.failed?
+          reason, details = result
+
+          error_class = safe_constantize(reason) || Cadence::ActivityException
+
+          raise error_class, details
+        end
+
+        result
+      end
+
+      def execute_local_activity(activity_class, *input, **args)
+        options = args.delete(:options) || {}
+        input << args unless args.empty?
+
+        execution_options = ExecutionOptions.new(activity_class, options)
+        activity_id = options[:activity_id] || SecureRandom.uuid
+        metadata = Metadata::Activity.new(
+          domain: execution_options.domain,
+          id: activity_id,
+          name: execution_options.name,
+          task_token: nil,
+          attempt: 1,
+          workflow_run_id: run_id,
+          workflow_id: workflow_id,
+          workflow_name: nil, # not yet used, but will be in the future
+          headers: execution_options.headers,
+          timeouts: {
+            schedule_to_close: 60,
+            start_to_close: 30,
+            heartbeat: 5
+          }
+        )
+        context = LocalActivityContext.new(metadata)
+
+        activity_class.execute_in_context(context, input)
+      end
+
+      def execute_workflow(workflow_class, *input, **args)
+        raise NotImplementedError, 'not yet available for testing'
+      end
+
+      def execute_workflow!(workflow_class, *input, **args)
+        options = args.delete(:options) || {}
+        input << args unless args.empty?
+
+        execution = WorkflowExecution.new
+        workflow_id = SecureRandom.uuid
+        run_id = SecureRandom.uuid
+        execution_options = ExecutionOptions.new(workflow_class, options)
+        context = Cadence::Testing::LocalWorkflowContext.new(
+          execution, workflow_id, run_id, workflow_class.disabled_releases, execution_options.headers
+        )
+
+        workflow_class.execute_in_context(context, input)
+      end
+
+      def side_effect(&block)
+        block.call
+      end
+
+      def sleep(timeout)
+        ::Kernel.sleep timeout
+      end
+
+      def sleep_until(end_time)
+        delay = (end_time.to_time - now).to_i
+        sleep(delay) if delay > 0
+      end
+
+      def start_timer(timeout, timer_id = nil)
+        raise NotImplementedError, 'not yet available for testing'
+      end
+
+      def cancel_timer(timer_id)
+        raise NotImplementedError, 'not yet available for testing'
+      end
+
+      def complete(result = nil)
+        result
+      end
+
+      def fail(reason, details = nil)
+        error_class = safe_constantize(reason) || StandardError
+
+        raise error_class, details
+      end
+
+      def wait_for_all(*futures)
+        futures.each(&:wait)
+
+        return
+      end
+
+      def wait_for(future)
+        # Point of communication
+        Fiber.yield while !future.finished?
+      end
+
+      def now
+        Time.now
+      end
+
+      def on_signal(&block)
+        raise NotImplementedError, 'not yet available for testing'
+      end
+
+      def cancel_activity(activity_id)
+        raise NotImplementedError, 'not yet available for testing'
+      end
+
+      def cancel(target, cancelation_id)
+        raise NotImplementedError, 'not yet available for testing'
+      end
+
+      private
+
+      attr_reader :execution, :run_id, :workflow_id, :disabled_releases
+
+      def next_event_id
+        @last_event_id += 1
+        @last_event_id
+      end
+
+      def safe_constantize(const)
+        Object.const_get(const) if Object.const_defined?(const)
+      rescue NameError
+        nil
+      end
+    end
+  end
+end