temporal-ruby 0.0.0 → 0.0.1.pre.pre1

data/lib/temporal/testing/workflow_override.rb

@@ -0,0 +1,36 @@
+require 'securerandom'
+require 'temporal/testing/local_workflow_context'
+require 'temporal/testing/workflow_execution'
+
+module Temporal
+  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 = Temporal::Testing::LocalWorkflowContext.new(
+          execution, workflow_id, run_id, disabled_releases
+        )
+
+        execute_in_context(context, input)
+      end
+    end
+  end
+end

data/lib/temporal/thread_local_context.rb

@@ -0,0 +1,14 @@
+# Provides context for Temporal::Activity::WorkflowConvenienceMethods
+module Temporal
+  module ThreadLocalContext
+    WORKFLOW_CONTEXT_KEY = :temporal_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/temporal/thread_pool.rb

@@ -0,0 +1,63 @@
+# 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 Temporal
+  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
+          job = @queue.pop
+          job.call
+          @mutex.synchronize do
+            @available_threads += 1
+            @availability.signal
+          end
+        end
+      end
+    end
+  end
+end

data/lib/temporal/types.rb

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

data/lib/temporal/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 Temporal
+  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/temporal/version.rb

@@ -1,3 +1,3 @@
 module Temporal
-  VERSION = '0.0.0'.freeze
+  VERSION = '0.0.1-pre1'.freeze
 end

data/lib/temporal/worker.rb

@@ -0,0 +1,88 @@
+require 'temporal/client'
+require 'temporal/workflow/poller'
+require 'temporal/activity/poller'
+require 'temporal/execution_options'
+require 'temporal/executable_lookup'
+require 'temporal/middleware/entry'
+
+module Temporal
+  class Worker
+    def initialize
+      @workflows = Hash.new { |hash, key| hash[key] = ExecutableLookup.new }
+      @activities = Hash.new { |hash, key| hash[key] = ExecutableLookup.new }
+      @pollers = []
+      @workflow_task_middleware = []
+      @activity_middleware = []
+      @shutting_down = false
+    end
+
+    def register_workflow(workflow_class, options = {})
+      execution_options = ExecutionOptions.new(workflow_class, options)
+      key = [execution_options.namespace, execution_options.task_queue]
+
+      @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.namespace, execution_options.task_queue]
+
+      @activities[key].add(execution_options.name, activity_class)
+    end
+
+    def add_workflow_task_middleware(middleware_class, *args)
+      @workflow_task_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 |(namespace, task_queue), lookup|
+        pollers << workflow_poller_for(namespace, task_queue, lookup)
+      end
+
+      activities.each_pair do |(namespace, task_queue), lookup|
+        pollers << activity_poller_for(namespace, task_queue, lookup)
+      end
+
+      trap_signals
+
+      pollers.each(&:start)
+
+      # wait until instructed to shut down
+      while !shutting_down? do
+        sleep 1
+      end
+    end
+
+    def stop
+      @shutting_down = true
+      pollers.each(&:stop)
+      pollers.each(&:wait)
+    end
+
+    private
+
+    attr_reader :activities, :workflows, :pollers, :workflow_task_middleware, :activity_middleware
+
+    def shutting_down?
+      @shutting_down
+    end
+
+    def workflow_poller_for(namespace, task_queue, lookup)
+      Workflow::Poller.new(namespace, task_queue, lookup.freeze, workflow_task_middleware)
+    end
+
+    def activity_poller_for(namespace, task_queue, lookup)
+      Activity::Poller.new(namespace, task_queue, lookup.freeze, activity_middleware)
+    end
+
+    def trap_signals
+      %w[TERM INT].each do |signal|
+        Signal.trap(signal) { stop }
+      end
+    end
+  end
+end

data/lib/temporal/workflow.rb

@@ -0,0 +1,42 @@
+require 'temporal/concerns/executable'
+require 'temporal/workflow/convenience_methods'
+require 'temporal/thread_local_context'
+
+module Temporal
+  class Workflow
+    extend Concerns::Executable
+    extend ConvenienceMethods
+
+    def self.execute_in_context(context, input)
+      Temporal::ThreadLocalContext.set(context)
+
+      workflow = new(context)
+      result = workflow.execute(*input)
+
+      context.complete(result)
+    rescue StandardError, ScriptError => error
+      Temporal.logger.error("Workflow execution failed with: #{error.inspect}")
+      Temporal.logger.debug(error.backtrace.join("\n"))
+
+      context.fail(error)
+    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/temporal/workflow/command.rb

@@ -0,0 +1,39 @@
+module Temporal
+  class Workflow
+    module Command
+      # TODO: Move these classes into their own directories under workflow/command/*
+      ScheduleActivity = Struct.new(:activity_type, :activity_id, :input, :namespace, :task_queue, :retry_policy, :timeouts, :headers, keyword_init: true)
+      StartChildWorkflow = Struct.new(:workflow_type, :workflow_id, :input, :namespace, :task_queue, :retry_policy, :timeouts, :headers, keyword_init: true)
+      RequestActivityCancellation = Struct.new(:activity_id, keyword_init: true)
+      RecordMarker = Struct.new(:name, :details, keyword_init: true)
+      StartTimer = Struct.new(:timeout, :timer_id, keyword_init: true)
+      CancelTimer = Struct.new(:timer_id, keyword_init: true)
+      CompleteWorkflow = Struct.new(:result, keyword_init: true)
+      FailWorkflow = Struct.new(:exception, keyword_init: true)
+
+      # only these commands are supported right now
+      SCHEDULE_ACTIVITY_TYPE = :schedule_activity
+      START_CHILD_WORKFLOW_TYPE = :start_child_workflow
+      RECORD_MARKER_TYPE = :record_marker
+      START_TIMER_TYPE = :start_timer
+      CANCEL_TIMER_TYPE = :cancel_timer
+      COMPLETE_WORKFLOW_TYPE = :complete_workflow
+      FAIL_WORKFLOW_TYPE = :fail_workflow
+
+      COMMAND_CLASS_MAP = {
+        SCHEDULE_ACTIVITY_TYPE => ScheduleActivity,
+        START_CHILD_WORKFLOW_TYPE => StartChildWorkflow,
+        RECORD_MARKER_TYPE => RecordMarker,
+        START_TIMER_TYPE => StartTimer,
+        CANCEL_TIMER_TYPE => CancelTimer,
+        COMPLETE_WORKFLOW_TYPE => CompleteWorkflow,
+        FAIL_WORKFLOW_TYPE => FailWorkflow
+      }.freeze
+
+      def self.generate(type, **args)
+        command_class = COMMAND_CLASS_MAP[type]
+        command_class.new(**args)
+      end
+    end
+  end
+end

data/lib/temporal/workflow/command_state_machine.rb

@@ -0,0 +1,48 @@
+module Temporal
+  class Workflow
+    class CommandStateMachine
+      NEW_STATE = :new
+      REQUESTED_STATE = :requested
+      SCHEDULED_STATE = :scheduled
+      STARTED_STATE = :started
+      COMPLETED_STATE = :completed
+      CANCELED_STATE = :canceled
+      FAILED_STATE = :failed
+      TIMED_OUT_STATE = :timed_out
+
+      attr_reader :state
+
+      def initialize
+        @state = NEW_STATE
+      end
+
+      def requested
+        @state = REQUESTED_STATE
+      end
+
+      def schedule
+        @state = SCHEDULED_STATE
+      end
+
+      def start
+        @state = STARTED_STATE
+      end
+
+      def complete
+        @state = COMPLETED_STATE
+      end
+
+      def cancel
+        @state = CANCELED_STATE
+      end
+
+      def fail
+        @state = FAILED_STATE
+      end
+
+      def time_out
+        @state = TIMED_OUT_STATE
+      end
+    end
+  end
+end

data/lib/temporal/workflow/context.rb

@@ -0,0 +1,243 @@
+require 'securerandom'
+
+require 'temporal/execution_options'
+require 'temporal/errors'
+require 'temporal/thread_local_context'
+require 'temporal/workflow/history/event_target'
+require 'temporal/workflow/command'
+require 'temporal/workflow/future'
+require 'temporal/workflow/replay_aware_logger'
+require 'temporal/workflow/state_manager'
+
+# This context class is available in the workflow implementation
+# and provides context and methods for interacting with Temporal
+#
+module Temporal
+  class Workflow
+    class Context
+      def initialize(state_manager, dispatcher, metadata)
+        @state_manager = state_manager
+        @dispatcher = dispatcher
+        @metadata = metadata
+      end
+
+      def logger
+        @logger ||= ReplayAwareLogger.new(Temporal.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)
+
+        command = Command::ScheduleActivity.new(
+          activity_id: options[:activity_id],
+          activity_type: execution_options.name,
+          input: input,
+          namespace: execution_options.namespace,
+          task_queue: execution_options.task_queue,
+          retry_policy: execution_options.retry_policy,
+          timeouts: execution_options.timeouts,
+          headers: execution_options.headers
+        )
+
+        target, cancelation_id = schedule_command(command)
+        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 |exception|
+          future.fail(exception)
+        end
+
+        future
+      end
+
+      def execute_activity!(activity_class, *input, **args)
+        future = execute_activity(activity_class, *input, **args)
+        result = future.get
+
+        raise result if future.failed?
+
+        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)
+
+        command = Command::StartChildWorkflow.new(
+          workflow_id: options[:workflow_id] || SecureRandom.uuid,
+          workflow_type: execution_options.name,
+          input: input,
+          namespace: execution_options.namespace,
+          task_queue: execution_options.task_queue,
+          retry_policy: execution_options.retry_policy,
+          timeouts: execution_options.timeouts,
+          headers: execution_options.headers
+        )
+
+        target, cancelation_id = schedule_command(command)
+        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 |exception|
+          future.fail(exception)
+        end
+
+        future
+      end
+
+      def execute_workflow!(workflow_class, *input, **args)
+        future = execute_workflow(workflow_class, *input, **args)
+        result = future.get
+
+        raise result if future.failed?
+
+        result
+      end
+
+      def side_effect(&block)
+        marker = state_manager.next_side_effect
+        return marker.last if marker
+
+        result = block.call
+        command = Command::RecordMarker.new(name: StateManager::SIDE_EFFECT_MARKER, details: result)
+        schedule_command(command)
+
+        result
+      end
+
+      def sleep(timeout)
+        start_timer(timeout).wait
+      end
+
+      def start_timer(timeout, timer_id = nil)
+        command = Command::StartTimer.new(timeout: timeout, timer_id: timer_id)
+        target, cancelation_id = schedule_command(command)
+        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 |exception|
+          future.fail(exception)
+        end
+
+        future
+      end
+
+      def cancel_timer(timer_id)
+        command = Command::CancelTimer.new(timer_id: timer_id)
+        schedule_command(command)
+      end
+
+      # TODO: check if workflow can be completed
+      def complete(result = nil)
+        command = Command::CompleteWorkflow.new(result: result)
+        schedule_command(command)
+      end
+
+      # TODO: check if workflow can be failed
+      def fail(exception)
+        command = Command::FailWorkflow.new(exception: exception)
+        schedule_command(command)
+      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)
+        command = Command::RequestActivityCancellation.new(activity_id: activity_id)
+
+        schedule_command(command)
+      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_command(command)
+        state_manager.schedule(command)
+      end
+
+      def call_in_fiber(block, *args)
+        Fiber.new do
+          Temporal::ThreadLocalContext.set(self)
+          block.call(*args)
+        end.resume
+      end
+    end
+  end
+end