temporalio 0.1.1 → 0.3.0

data/lib/temporalio/worker/activity_executor/fiber.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'temporalio/error'
+require 'temporalio/worker/activity_executor'
+
+module Temporalio
+  class Worker
+    class ActivityExecutor
+      # Activity executor for scheduling activites as fibers.
+      class Fiber
+        # @return [Fiber] Default/shared Fiber executor instance.
+        def self.default
+          @default ||= new
+        end
+
+        # @see ActivityExecutor.initialize_activity
+        def initialize_activity(defn)
+          # If there is not a current scheduler, we're going to preemptively
+          # fail the registration
+          return unless ::Fiber.current_scheduler.nil?
+
+          raise ArgumentError, "Activity '#{defn.name}' wants a fiber executor but no current fiber scheduler"
+        end
+
+        # @see ActivityExecutor.initialize_activity
+        def execute_activity(_defn, &)
+          ::Fiber.schedule(&)
+        end
+
+        # @see ActivityExecutor.activity_context
+        def activity_context
+          ::Fiber[:temporal_activity_context]
+        end
+
+        # @see ActivityExecutor.set_activity_context
+        def set_activity_context(defn, context)
+          ::Fiber[:temporal_activity_context] = context
+          # If they have opted in to raising on cancel, wire that up
+          return unless defn.cancel_raise
+
+          fiber = ::Fiber.current
+          context&.cancellation&.add_cancel_callback do
+            fiber.raise(Error::CanceledError.new('Activity canceled'))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/temporalio/worker/activity_executor/thread_pool.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'temporalio/worker/thread_pool'
+
+module Temporalio
+  class Worker
+    class ActivityExecutor
+      # Activity executor for scheduling activities in their own thread using {Worker::ThreadPool}.
+      class ThreadPool < ActivityExecutor
+        # @return [ThreadPool] Default/shared thread pool executor using default thread pool.
+        def self.default
+          @default ||= new
+        end
+
+        # Create a new thread pool executor.
+        #
+        # @param thread_pool [Worker::ThreadPool] Thread pool to use.
+        def initialize(thread_pool = Worker::ThreadPool.default) # rubocop:disable Lint/MissingSuper
+          @thread_pool = thread_pool
+        end
+
+        # @see ActivityExecutor.execute_activity
+        def execute_activity(_defn, &)
+          @thread_pool.execute(&)
+        end
+
+        # @see ActivityExecutor.activity_context
+        def activity_context
+          Thread.current[:temporal_activity_context]
+        end
+
+        # @see ActivityExecutor.set_activity_context
+        def set_activity_context(defn, context)
+          Thread.current[:temporal_activity_context] = context
+          # If they have opted in to raising on cancel, wire that up
+          return unless defn.cancel_raise
+
+          thread = Thread.current
+          context&.cancellation&.add_cancel_callback do
+            thread.raise(Error::CanceledError.new('Activity canceled')) if thread[:temporal_activity_context] == context
+          end
+        end
+      end
+    end
+  end
+end

data/lib/temporalio/worker/activity_executor.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'temporalio/worker/activity_executor/fiber'
+require 'temporalio/worker/activity_executor/thread_pool'
+
+module Temporalio
+  class Worker
+    # Base class to be extended by activity executor implementations. Most users will not use this, but rather keep with
+    # the two defaults of thread pool and fiber executors.
+    class ActivityExecutor
+      # @return [Hash<Symbol, ActivityExecutor>] Default set of executors (immutable).
+      def self.defaults
+        @defaults ||= {
+          default: ThreadPool.default,
+          thread_pool: ThreadPool.default,
+          fiber: Fiber.default
+        }.freeze
+      end
+
+      # Initialize an activity. This is called on worker initialize for every activity that will use this executor. This
+      # allows executor implementations to do eager validation based on the definition. This does not have to be
+      # implemented and the default is a no-op.
+      #
+      # @param defn [Activity::Definition::Info] Activity definition info.
+      def initialize_activity(defn)
+        # Default no-op
+      end
+
+      # Execute the given block in the executor. The block is built to never raise and need no arguments. Implementers
+      # must implement this.
+      #
+      # @param defn [Activity::Definition::Info] Activity definition info.
+      # @yield Block to execute.
+      def execute_activity(defn, &)
+        raise NotImplementedError
+      end
+
+      # @return [Activity::Context, nil] Get the current activity context. This is called by users from inside the
+      #   activity. Implementers must implement this.
+      def activity_context
+        raise NotImplementedError
+      end
+
+      # Set the current activity context (or unset if nil). This is called by the system from within the block given to
+      # {execute_activity} with a context before user code is executed and with nil after user code is complete.
+      # Implementers must implement this.
+      #
+      # @param defn [Activity::Definition::Info] Activity definition info.
+      # @param context [Activity::Context, nil] The value to set.
+      def set_activity_context(defn, context)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/temporalio/worker/interceptor.rb

@@ -0,0 +1,362 @@
+# frozen_string_literal: true
+
+module Temporalio
+  class Worker
+    module Interceptor
+      # Mixin for intercepting activity worker work. Clases that `include` may implement their own {intercept_activity}
+      # that returns their own instance of {Inbound}.
+      #
+      # @note Input classes herein may get new required fields added and therefore the constructors of the Input classes
+      #   may change in backwards incompatible ways. Users should not try to construct Input classes themselves.
+      module Activity
+        # Method called when intercepting an activity. This is called when starting an activity attempt.
+        #
+        # @param next_interceptor [Inbound] Next interceptor in the chain that should be called. This is usually passed
+        #   to {Inbound} constructor.
+        # @return [Inbound] Interceptor to be called for activity calls.
+        def intercept_activity(next_interceptor)
+          next_interceptor
+        end
+
+        # Input for {Inbound.execute}.
+        ExecuteInput = Data.define(
+          :proc,
+          :args,
+          :headers
+        )
+
+        # Inbound interceptor for intercepting inbound activity calls. This should be extended by users needing to
+        # intercept activities.
+        class Inbound
+          # @return [Inbound] Next interceptor in the chain.
+          attr_reader :next_interceptor
+
+          # Initialize inbound with the next interceptor in the chain.
+          #
+          # @param next_interceptor [Inbound] Next interceptor in the chain.
+          def initialize(next_interceptor)
+            @next_interceptor = next_interceptor
+          end
+
+          # Initialize the outbound interceptor. This should be extended by users to return their own {Outbound}
+          # implementation that wraps the parameter here.
+          #
+          # @param outbound [Outbound] Next outbound interceptor in the chain.
+          # @return [Outbound] Outbound activity interceptor.
+          def init(outbound)
+            @next_interceptor.init(outbound)
+          end
+
+          # Execute an activity and return result or raise exception. Next interceptor in chain (i.e. `super`) will
+          # perform the execution.
+          #
+          # @param input [ExecuteInput] Input information.
+          # @return [Object] Activity result.
+          def execute(input)
+            @next_interceptor.execute(input)
+          end
+        end
+
+        # Input for {Outbound.heartbeat}.
+        HeartbeatInput = Data.define(
+          :details
+        )
+
+        # Outbound interceptor for intercepting outbound activity calls. This should be extended by users needing to
+        # intercept activity calls.
+        class Outbound
+          # @return [Outbound] Next interceptor in the chain.
+          attr_reader :next_interceptor
+
+          # Initialize outbound with the next interceptor in the chain.
+          #
+          # @param next_interceptor [Outbound] Next interceptor in the chain.
+          def initialize(next_interceptor)
+            @next_interceptor = next_interceptor
+          end
+
+          # Issue a heartbeat.
+          #
+          # @param input [HeartbeatInput] Input information.
+          def heartbeat(input)
+            @next_interceptor.heartbeat(input)
+          end
+        end
+      end
+
+      # Mixin for intercepting workflow worker work. Classes that `include` may implement their own {intercept_workflow}
+      # that returns their own instance of {Inbound}.
+      #
+      # @note Input classes herein may get new required fields added and therefore the constructors of the Input classes
+      #   may change in backwards incompatible ways. Users should not try to construct Input classes themselves.
+      module Workflow
+        # Method called when intercepting a workflow. This is called when creating a workflow instance.
+        #
+        # @param next_interceptor [Inbound] Next interceptor in the chain that should be called. This is usually passed
+        #   to {Inbound} constructor.
+        # @return [Inbound] Interceptor to be called for workflow calls.
+        def intercept_workflow(next_interceptor)
+          next_interceptor
+        end
+
+        # Input for {Inbound.execute}.
+        ExecuteInput = Data.define(
+          :args,
+          :headers
+        )
+
+        # Input for {Inbound.handle_signal}.
+        HandleSignalInput = Data.define(
+          :signal,
+          :args,
+          :definition,
+          :headers
+        )
+
+        # Input for {Inbound.handle_query}.
+        HandleQueryInput = Data.define(
+          :id,
+          :query,
+          :args,
+          :definition,
+          :headers
+        )
+
+        # Input for {Inbound.validate_update} and {Inbound.handle_update}.
+        HandleUpdateInput = Data.define(
+          :id,
+          :update,
+          :args,
+          :definition,
+          :headers
+        )
+
+        # Inbound interceptor for intercepting inbound workflow calls. This should be extended by users needing to
+        # intercept workflows.
+        class Inbound
+          # @return [Inbound] Next interceptor in the chain.
+          attr_reader :next_interceptor
+
+          # Initialize inbound with the next interceptor in the chain.
+          #
+          # @param next_interceptor [Inbound] Next interceptor in the chain.
+          def initialize(next_interceptor)
+            @next_interceptor = next_interceptor
+          end
+
+          # Initialize the outbound interceptor. This should be extended by users to return their own {Outbound}
+          # implementation that wraps the parameter here.
+          #
+          # @param outbound [Outbound] Next outbound interceptor in the chain.
+          # @return [Outbound] Outbound workflow interceptor.
+          def init(outbound)
+            @next_interceptor.init(outbound)
+          end
+
+          # Execute a workflow and return result or raise exception. Next interceptor in chain (i.e. `super`) will
+          # perform the execution.
+          #
+          # @param input [ExecuteInput] Input information.
+          # @return [Object] Workflow result.
+          def execute(input)
+            @next_interceptor.execute(input)
+          end
+
+          # Handle a workflow signal. Next interceptor in chain (i.e. `super`) will perform the handling.
+          #
+          # @param input [HandleSignalInput] Input information.
+          def handle_signal(input)
+            @next_interceptor.handle_signal(input)
+          end
+
+          # Handle a workflow query and return result or raise exception. Next interceptor in chain (i.e. `super`) will
+          # perform the handling.
+          #
+          # @param input [HandleQueryInput] Input information.
+          # @return [Object] Query result.
+          def handle_query(input)
+            @next_interceptor.handle_query(input)
+          end
+
+          # Validate a workflow update. Next interceptor in chain (i.e. `super`) will perform the validation.
+          #
+          # @param input [HandleUpdateInput] Input information.
+          def validate_update(input)
+            @next_interceptor.validate_update(input)
+          end
+
+          # Handle a workflow update and return result or raise exception. Next interceptor in chain (i.e. `super`) will
+          # perform the handling.
+          #
+          # @param input [HandleUpdateInput] Input information.
+          # @return [Object] Update result.
+          def handle_update(input)
+            @next_interceptor.handle_update(input)
+          end
+        end
+
+        # Input for {Outbound.cancel_external_workflow}.
+        CancelExternalWorkflowInput = Data.define(
+          :id,
+          :run_id
+        )
+
+        # Input for {Outbound.execute_activity}.
+        ExecuteActivityInput = Data.define(
+          :activity,
+          :args,
+          :task_queue,
+          :schedule_to_close_timeout,
+          :schedule_to_start_timeout,
+          :start_to_close_timeout,
+          :heartbeat_timeout,
+          :retry_policy,
+          :cancellation,
+          :cancellation_type,
+          :activity_id,
+          :disable_eager_execution,
+          :headers
+        )
+
+        # Input for {Outbound.execute_local_activity}.
+        ExecuteLocalActivityInput = Data.define(
+          :activity,
+          :args,
+          :schedule_to_close_timeout,
+          :schedule_to_start_timeout,
+          :start_to_close_timeout,
+          :retry_policy,
+          :local_retry_threshold,
+          :cancellation,
+          :cancellation_type,
+          :activity_id,
+          :headers
+        )
+
+        # Input for {Outbound.initialize_continue_as_new_error}.
+        InitializeContinueAsNewErrorInput = Data.define(
+          :error
+        )
+
+        # Input for {Outbound.signal_child_workflow}.
+        SignalChildWorkflowInput = Data.define(
+          :id,
+          :signal,
+          :args,
+          :cancellation,
+          :headers
+        )
+
+        # Input for {Outbound.signal_external_workflow}.
+        SignalExternalWorkflowInput = Data.define(
+          :id,
+          :run_id,
+          :signal,
+          :args,
+          :cancellation,
+          :headers
+        )
+
+        # Input for {Outbound.sleep}.
+        SleepInput = Data.define(
+          :duration,
+          :summary,
+          :cancellation
+        )
+
+        # Input for {Outbound.start_child_workflow}.
+        StartChildWorkflowInput = Data.define(
+          :workflow,
+          :args,
+          :id,
+          :task_queue,
+          :cancellation,
+          :cancellation_type,
+          :parent_close_policy,
+          :execution_timeout,
+          :run_timeout,
+          :task_timeout,
+          :id_reuse_policy,
+          :retry_policy,
+          :cron_schedule,
+          :memo,
+          :search_attributes,
+          :headers
+        )
+
+        # Outbound interceptor for intercepting outbound workflow calls. This should be extended by users needing to
+        # intercept workflow calls.
+        class Outbound
+          # @return [Outbound] Next interceptor in the chain.
+          attr_reader :next_interceptor
+
+          # Initialize outbound with the next interceptor in the chain.
+          #
+          # @param next_interceptor [Outbound] Next interceptor in the chain.
+          def initialize(next_interceptor)
+            @next_interceptor = next_interceptor
+          end
+
+          # Cancel external workflow.
+          #
+          # @param input [CancelExternalWorkflowInput] Input.
+          def cancel_external_workflow(input)
+            @next_interceptor.cancel_external_workflow(input)
+          end
+
+          # Execute activity.
+          #
+          # @param input [ExecuteActivityInput] Input.
+          # @return [Object] Activity result.
+          def execute_activity(input)
+            @next_interceptor.execute_activity(input)
+          end
+
+          # Execute local activity.
+          #
+          # @param input [ExecuteLocalActivityInput] Input.
+          # @return [Object] Activity result.
+          def execute_local_activity(input)
+            @next_interceptor.execute_local_activity(input)
+          end
+
+          # Initialize continue as new error.
+          #
+          # @param input [InitializeContinueAsNewErrorInput] Input.
+          def initialize_continue_as_new_error(input)
+            @next_interceptor.initialize_continue_as_new_error(input)
+          end
+
+          # Signal child workflow.
+          #
+          # @param input [SignalChildWorkflowInput] Input.
+          def signal_child_workflow(input)
+            @next_interceptor.signal_child_workflow(input)
+          end
+
+          # Signal external workflow.
+          #
+          # @param input [SignalExternalWorkflowInput] Input.
+          def signal_external_workflow(input)
+            @next_interceptor.signal_external_workflow(input)
+          end
+
+          # Sleep.
+          #
+          # @param input [SleepInput] Input.
+          def sleep(input)
+            @next_interceptor.sleep(input)
+          end
+
+          # Start child workflow.
+          #
+          # @param input [StartChildWorkflowInput] Input.
+          # @return [Workflow::ChildWorkflowHandle] Child workflow handle.
+          def start_child_workflow(input)
+            @next_interceptor.start_child_workflow(input)
+          end
+        end
+      end
+    end
+  end
+end