cadence-ruby 0.0.0 → 0.1.0

data/lib/cadence/testing/workflow_execution.rb

@@ -0,0 +1,44 @@
+require 'cadence/testing/future_registry'
+
+module Cadence
+  module Testing
+    class WorkflowExecution
+      attr_reader :status
+
+      def initialize
+        @status = Workflow::ExecutionInfo::RUNNING_STATUS
+        @futures = FutureRegistry.new
+      end
+
+      def run(&block)
+        @fiber = Fiber.new(&block)
+        resume
+      end
+
+      def resume
+        fiber.resume
+        @status = Workflow::ExecutionInfo::COMPLETED_STATUS unless fiber.alive?
+      rescue StandardError
+        @status = Workflow::ExecutionInfo::FAILED_STATUS
+      end
+
+      def register_future(token, future)
+        futures.register(token, future)
+      end
+
+      def complete_activity(token, result)
+        futures.complete(token, result)
+        resume
+      end
+
+      def fail_activity(token, error)
+        futures.fail(token, error)
+        resume
+      end
+
+      private
+
+      attr_reader :fiber, :futures
+    end
+  end
+end

data/lib/cadence/testing/workflow_override.rb

@@ -0,0 +1,36 @@
+require 'securerandom'
+require 'cadence/testing/local_workflow_context'
+require 'cadence/testing/workflow_execution'
+
+module Cadence
+  module Testing
+    module WorkflowOverride
+      def disabled_releases
+        @disabled_releases ||= Set.new
+      end
+
+      def allow_all_releases
+        disabled_releases.clear
+      end
+
+      def allow_release(release_name)
+        disabled_releases.delete(release_name.to_s)
+      end
+
+      def disable_release(release_name)
+        disabled_releases << release_name.to_s
+      end
+
+      def execute_locally(*input)
+        workflow_id = SecureRandom.uuid
+        run_id = SecureRandom.uuid
+        execution = WorkflowExecution.new
+        context = Cadence::Testing::LocalWorkflowContext.new(
+          execution, workflow_id, run_id, disabled_releases
+        )
+
+        execute_in_context(context, input)
+      end
+    end
+  end
+end

data/lib/cadence/thread_local_context.rb

@@ -0,0 +1,14 @@
+# Provides context for Cadence::Activity::WorkflowConvenienceMethods
+module Cadence
+  module ThreadLocalContext
+    WORKFLOW_CONTEXT_KEY = :cadence_workflow_context
+
+    def self.get
+      Thread.current[WORKFLOW_CONTEXT_KEY]
+    end
+
+    def self.set(context)
+      Thread.current[WORKFLOW_CONTEXT_KEY] = context
+    end
+  end
+end

data/lib/cadence/thread_pool.rb

@@ -0,0 +1,68 @@
+# This class implements a very simple ThreadPool with the ability to
+# block until at least one thread becomes available. This allows Pollers
+# to only poll when there's an available thread in the pool.
+#
+# NOTE: There's a minor race condition that can occur between calling
+#       #wait_for_available_threads and #schedule, but should be rare
+#
+module Cadence
+  class ThreadPool
+    attr_reader :size
+
+    def initialize(size)
+      @size = size
+      @queue = Queue.new
+      @mutex = Mutex.new
+      @availability = ConditionVariable.new
+      @available_threads = size
+      @pool = Array.new(size) do |i|
+        Thread.new { poll }
+      end
+    end
+
+    def wait_for_available_threads
+      @mutex.synchronize do
+        while @available_threads <= 0
+          @availability.wait(@mutex)
+        end
+      end
+    end
+
+    def schedule(&block)
+      @mutex.synchronize do
+        @available_threads -= 1
+        @queue << block
+      end
+    end
+
+    def shutdown
+      size.times do
+        schedule { throw EXIT_SYMBOL }
+      end
+
+      @pool.each(&:join)
+    end
+
+    private
+
+    EXIT_SYMBOL = :exit
+
+    def poll
+      catch(EXIT_SYMBOL) do
+        loop do
+          run(@queue.pop)
+          @mutex.synchronize do
+            @available_threads += 1
+            @availability.signal
+          end
+        end
+      end
+    end
+
+    def run(job)
+      job.call if job
+    rescue Exception
+      # Make sure we don't loose a thread
+    end
+  end
+end

data/lib/cadence/types.rb

@@ -0,0 +1,7 @@
+require 'dry-types'
+
+module Cadence
+  module Types
+    include Dry.Types
+  end
+end

data/lib/cadence/utils.rb

@@ -0,0 +1,17 @@
+module Cadence
+  module Utils
+    NANO = 10**9
+    MILLI = 10**3
+
+    class << self
+      def time_from_nanos(timestamp)
+        seconds, nanoseconds = timestamp.divmod(NANO)
+        Time.at(seconds, nanoseconds, :nsec)
+      end
+
+      def time_to_nanos(time)
+        time.to_f * NANO
+      end
+    end
+  end
+end

data/lib/cadence/uuid.rb

@@ -0,0 +1,19 @@
+# This is a simple UUIDv5 (SHA1) implementation adopted from:
+# https://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/digest/uuid.rb#L18
+require 'digest'
+
+module Cadence
+  module UUID
+    def self.v5(uuid_namespace, name)
+      hash = Digest::SHA1.new
+      hash.update(uuid_namespace)
+      hash.update(name)
+
+      ary = hash.digest.unpack("NnnnnN")
+      ary[2] = (ary[2] & 0x0FFF) | (5 << 12)
+      ary[3] = (ary[3] & 0x3FFF) | 0x8000
+
+      "%08x-%04x-%04x-%04x-%04x%08x" % ary
+    end
+  end
+end

data/lib/cadence/version.rb

@@ -1,3 +1,3 @@
 module Cadence
-  VERSION = '0.0.0'.freeze
+  VERSION = '0.1.0'.freeze
 end

data/lib/cadence/worker.rb

@@ -0,0 +1,91 @@
+require 'cadence/client'
+require 'cadence/workflow/poller'
+require 'cadence/activity/poller'
+require 'cadence/execution_options'
+require 'cadence/executable_lookup'
+require 'cadence/middleware/entry'
+
+module Cadence
+  class Worker
+    def initialize(options = {})
+      @options = options
+      @workflows = Hash.new { |hash, key| hash[key] = ExecutableLookup.new }
+      @activities = Hash.new { |hash, key| hash[key] = ExecutableLookup.new }
+      @pollers = []
+      @decision_middleware = []
+      @activity_middleware = []
+      @shutting_down = false
+    end
+
+    def register_workflow(workflow_class, options = {})
+      execution_options = ExecutionOptions.new(workflow_class, options)
+      key = [execution_options.domain, execution_options.task_list]
+
+      @workflows[key].add(execution_options.name, workflow_class)
+    end
+
+    def register_activity(activity_class, options = {})
+      execution_options = ExecutionOptions.new(activity_class, options)
+      key = [execution_options.domain, execution_options.task_list]
+
+      @activities[key].add(execution_options.name, activity_class)
+    end
+
+    def add_decision_middleware(middleware_class, *args)
+      @decision_middleware << Middleware::Entry.new(middleware_class, args)
+    end
+
+    def add_activity_middleware(middleware_class, *args)
+      @activity_middleware << Middleware::Entry.new(middleware_class, args)
+    end
+
+    def start
+      workflows.each_pair do |(domain, task_list), lookup|
+        pollers << workflow_poller_for(domain, task_list, lookup)
+      end
+
+      activities.each_pair do |(domain, task_list), lookup|
+        pollers << activity_poller_for(domain, task_list, lookup)
+      end
+
+      trap_signals
+
+      pollers.each(&:start)
+
+      # keep the main worker thread alive
+      sleep(1) while !shutting_down?
+    end
+
+    def stop
+      @shutting_down = true
+
+      Thread.new do
+        pollers.each(&:stop)
+        pollers.each(&:wait)
+      end.join
+    end
+
+    private
+
+    attr_reader :options, :activities, :workflows, :pollers,
+                :decision_middleware, :activity_middleware
+
+    def shutting_down?
+      @shutting_down
+    end
+
+    def workflow_poller_for(domain, task_list, lookup)
+      Workflow::Poller.new(domain, task_list, lookup.freeze, decision_middleware, options)
+    end
+
+    def activity_poller_for(domain, task_list, lookup)
+      Activity::Poller.new(domain, task_list, lookup.freeze, activity_middleware, options)
+    end
+
+    def trap_signals
+      %w[TERM INT].each do |signal|
+        Signal.trap(signal) { stop }
+      end
+    end
+  end
+end

data/lib/cadence/workflow.rb

@@ -0,0 +1,42 @@
+require 'cadence/concerns/executable'
+require 'cadence/workflow/convenience_methods'
+require 'cadence/thread_local_context'
+
+module Cadence
+  class Workflow
+    extend Concerns::Executable
+    extend ConvenienceMethods
+
+    def self.execute_in_context(context, input)
+      Cadence::ThreadLocalContext.set(context)
+
+      workflow = new(context)
+      result = workflow.execute(*input)
+
+      context.complete(result)
+    rescue StandardError, ScriptError => error
+      Cadence.logger.error("Workflow execution failed with: #{error.inspect}")
+      Cadence.logger.debug(error.backtrace.join("\n"))
+
+      context.fail(error.class.name, error.message)
+    end
+
+    def initialize(context)
+      @context = context
+    end
+
+    def execute
+      raise NotImplementedError, '#execute method must be implemented by a subclass'
+    end
+
+    private
+
+    def workflow
+      @context
+    end
+
+    def logger
+      workflow.logger
+    end
+  end
+end

data/lib/cadence/workflow/context.rb

@@ -0,0 +1,266 @@
+require 'securerandom'
+
+require 'cadence/execution_options'
+require 'cadence/errors'
+require 'cadence/thread_local_context'
+require 'cadence/workflow/history/event_target'
+require 'cadence/workflow/decision'
+require 'cadence/workflow/future'
+require 'cadence/workflow/replay_aware_logger'
+require 'cadence/workflow/state_manager'
+
+# This context class is available in the workflow implementation
+# and provides context and methods for interacting with Cadence
+#
+module Cadence
+  class Workflow
+    class Context
+      def initialize(state_manager, dispatcher, metadata)
+        @state_manager = state_manager
+        @dispatcher = dispatcher
+        @metadata = metadata
+      end
+
+      def logger
+        @logger ||= ReplayAwareLogger.new(Cadence.logger)
+        @logger.replay = state_manager.replay?
+        @logger
+      end
+
+      def headers
+        metadata.headers
+      end
+
+      def has_release?(release_name)
+        state_manager.release?(release_name.to_s)
+      end
+
+      def execute_activity(activity_class, *input, **args)
+        options = args.delete(:options) || {}
+        input << args unless args.empty?
+
+        execution_options = ExecutionOptions.new(activity_class, options)
+
+        decision = Decision::ScheduleActivity.new(
+          activity_id: options[:activity_id],
+          activity_type: execution_options.name,
+          input: input,
+          domain: execution_options.domain,
+          task_list: execution_options.task_list,
+          retry_policy: execution_options.retry_policy,
+          timeouts: execution_options.timeouts,
+          headers: execution_options.headers
+        )
+
+        target, cancelation_id = schedule_decision(decision)
+        future = Future.new(target, self, cancelation_id: cancelation_id)
+
+        dispatcher.register_handler(target, 'completed') do |result|
+          future.set(result)
+          future.callbacks.each { |callback| call_in_fiber(callback, result) }
+        end
+
+        dispatcher.register_handler(target, 'failed') do |reason, details|
+          future.fail(reason, details)
+        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
+
+      # TODO: how to handle failures?
+      def execute_local_activity(activity_class, *input, **args)
+        input << args unless args.empty?
+
+        side_effect do
+          # TODO: this probably requires a local context implementation
+          context = Activity::Context.new(nil, nil)
+          activity_class.execute_in_context(context, input)
+        end
+      end
+
+      def execute_workflow(workflow_class, *input, **args)
+        options = args.delete(:options) || {}
+        input << args unless args.empty?
+
+        execution_options = ExecutionOptions.new(workflow_class, options)
+
+        decision = Decision::StartChildWorkflow.new(
+          workflow_id: options[:workflow_id] || SecureRandom.uuid,
+          workflow_type: execution_options.name,
+          input: input,
+          domain: execution_options.domain,
+          task_list: execution_options.task_list,
+          retry_policy: execution_options.retry_policy,
+          timeouts: execution_options.timeouts,
+          headers: execution_options.headers
+        )
+
+        target, cancelation_id = schedule_decision(decision)
+        future = Future.new(target, self, cancelation_id: cancelation_id)
+
+        dispatcher.register_handler(target, 'completed') do |result|
+          future.set(result)
+          future.callbacks.each { |callback| call_in_fiber(callback, result) }
+        end
+
+        dispatcher.register_handler(target, 'failed') do |reason, details|
+          future.fail(reason, details)
+        end
+
+        future
+      end
+
+      def execute_workflow!(workflow_class, *input, **args)
+        future = execute_workflow(workflow_class, *input, **args)
+        result = future.get
+
+        if future.failed?
+          reason, details = result
+
+          error_class = safe_constantize(reason) || StandardError.new(details)
+
+          raise error_class, details
+        end
+
+        result
+      end
+
+      def side_effect(&block)
+        marker = state_manager.next_side_effect
+        return marker.last if marker
+
+        result = block.call
+        decision = Decision::RecordMarker.new(name: StateManager::SIDE_EFFECT_MARKER, details: result)
+        schedule_decision(decision)
+
+        result
+      end
+
+      def sleep(timeout)
+        start_timer(timeout).wait
+      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)
+        decision = Decision::StartTimer.new(timeout: timeout, timer_id: timer_id)
+        target, cancelation_id = schedule_decision(decision)
+        future = Future.new(target, self, cancelation_id: cancelation_id)
+
+        dispatcher.register_handler(target, 'fired') do |result|
+          future.set(result)
+          future.callbacks.each { |callback| call_in_fiber(callback, result) }
+        end
+
+        dispatcher.register_handler(target, 'canceled') do |reason, details|
+          future.fail(reason, details)
+        end
+
+        future
+      end
+
+      def cancel_timer(timer_id)
+        decision = Decision::CancelTimer.new(timer_id: timer_id)
+        schedule_decision(decision)
+      end
+
+      # TODO: check if workflow can be completed
+      def complete(result = nil)
+        decision = Decision::CompleteWorkflow.new(result: result)
+        schedule_decision(decision)
+      end
+
+      # TODO: check if workflow can be failed
+      def fail(reason, details = nil)
+        decision = Decision::FailWorkflow.new(reason: reason, details: details)
+        schedule_decision(decision)
+      end
+
+      def wait_for_all(*futures)
+        futures.each(&:wait)
+
+        return
+      end
+
+      def wait_for(future)
+        fiber = Fiber.current
+
+        dispatcher.register_handler(future.target, Dispatcher::WILDCARD) do
+          fiber.resume if future.finished?
+        end
+
+        Fiber.yield
+
+        return
+      end
+
+      def now
+        state_manager.local_time
+      end
+
+      def on_signal(&block)
+        target = History::EventTarget.workflow
+
+        dispatcher.register_handler(target, 'signaled') do |signal, input|
+          call_in_fiber(block, signal, input)
+        end
+      end
+
+      def cancel_activity(activity_id)
+        decision = Decision::RequestActivityCancellation.new(activity_id: activity_id)
+
+        schedule_decision(decision)
+      end
+
+      def cancel(target, cancelation_id)
+        case target.type
+        when History::EventTarget::ACTIVITY_TYPE
+          cancel_activity(cancelation_id)
+        when History::EventTarget::TIMER_TYPE
+          cancel_timer(cancelation_id)
+        else
+          raise "#{target} can not be canceled"
+        end
+      end
+
+      private
+
+      attr_reader :state_manager, :dispatcher, :metadata
+
+      def schedule_decision(decision)
+        state_manager.schedule(decision)
+      end
+
+      def call_in_fiber(block, *args)
+        Fiber.new do
+          Cadence::ThreadLocalContext.set(self)
+          block.call(*args)
+        end.resume
+      end
+
+      def safe_constantize(const)
+        Object.const_get(const) if Object.const_defined?(const)
+      rescue NameError
+        nil
+      end
+    end
+  end
+end