temporalio 0.2.0 → 0.3.0

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

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+require 'etc'
+require 'temporalio/internal/bridge/api'
+require 'temporalio/internal/proto_utils'
+require 'temporalio/internal/worker/workflow_instance'
+require 'temporalio/scoped_logger'
+require 'temporalio/worker/thread_pool'
+require 'temporalio/worker/workflow_executor'
+require 'temporalio/workflow'
+require 'temporalio/workflow/definition'
+require 'timeout'
+
+module Temporalio
+  class Worker
+    class WorkflowExecutor
+      # Thread pool implementation of {WorkflowExecutor}.
+      #
+      # Users should use {default} unless they have specific needs to change the thread pool or max threads.
+      class ThreadPool < WorkflowExecutor
+        # @return [ThreadPool] Default executor that lazily constructs an instance with default values.
+        def self.default
+          @default ||= ThreadPool.new
+        end
+
+        # Create a thread pool executor. Most users may prefer {default}.
+        #
+        # @param max_threads [Integer] Maximum number of threads to use concurrently.
+        # @param thread_pool [Worker::ThreadPool] Thread pool to use.
+        def initialize(max_threads: [4, Etc.nprocessors].max, thread_pool: Temporalio::Worker::ThreadPool.default) # rubocop:disable Lint/MissingSuper
+          @max_threads = max_threads
+          @thread_pool = thread_pool
+          @workers_mutex = Mutex.new
+          @workers = []
+          @workers_by_worker_state_and_run_id = {}
+        end
+
+        # @!visibility private
+        def _validate_worker(worker, worker_state)
+          # Do nothing
+        end
+
+        # @!visibility private
+        def _activate(activation, worker_state, &)
+          # Get applicable worker
+          worker = @workers_mutex.synchronize do
+            run_key = [worker_state, activation.run_id]
+            @workers_by_worker_state_and_run_id.fetch(run_key) do
+              # If not found, get a new one either by creating if not enough or find the one with the fewest.
+              new_worker = if @workers.size < @max_threads
+                             created_worker = Worker.new(self)
+                             @workers << Worker.new(self)
+                             created_worker
+                           else
+                             @workers.min_by(&:workflow_count)
+                           end
+              @workers_by_worker_state_and_run_id[run_key] = new_worker
+              new_worker.workflow_count += 1
+              new_worker
+            end
+          end
+          raise "No worker for run ID #{activation.run_id}" unless worker
+
+          # Enqueue activation
+          worker.enqueue_activation(activation, worker_state, &)
+        end
+
+        # @!visibility private
+        def _thread_pool
+          @thread_pool
+        end
+
+        # @!visibility private
+        def _remove_workflow(worker_state, run_id)
+          @workers_mutex.synchronize do
+            worker = @workers_by_worker_state_and_run_id.delete([worker_state, run_id])
+            if worker
+              worker.workflow_count -= 1
+              # Remove worker from array if done. The array should be small enough that the delete being O(N) is not
+              # worth using a set or a map.
+              if worker.workflow_count.zero?
+                @workers.delete(worker)
+                worker.shutdown
+              end
+            end
+          end
+        end
+
+        # @!visibility private
+        class Worker
+          LOG_ACTIVATIONS = false
+
+          attr_accessor :workflow_count
+
+          def initialize(executor)
+            @executor = executor
+            @workflow_count = 0
+            @queue = Queue.new
+            executor._thread_pool.execute { run }
+          end
+
+          # @!visibility private
+          def enqueue_activation(activation, worker_state, &completion_block)
+            @queue << [:activate, activation, worker_state, completion_block]
+          end
+
+          # @!visibility private
+          def shutdown
+            @queue << [:shutdown]
+          end
+
+          private
+
+          def run
+            loop do
+              work = @queue.pop
+              if work.is_a?(Exception)
+                Warning.warn("Failed activation: #{work}")
+              elsif work.is_a?(Array)
+                case work.first
+                when :shutdown
+                  return
+                when :activate
+                  activate(work[1], work[2], &work[3])
+                end
+              end
+            rescue Exception => e # rubocop:disable Lint/RescueException
+              Warning.warn("Unexpected failure during run: #{e.full_message}")
+            end
+          end
+
+          def activate(activation, worker_state, &)
+            worker_state.logger.debug("Received workflow activation: #{activation}") if LOG_ACTIVATIONS
+
+            # Check whether it has eviction
+            cache_remove_job = activation.jobs.find { |j| !j.remove_from_cache.nil? }&.remove_from_cache
+
+            # If it's eviction only, just evict inline and do nothing else
+            if cache_remove_job && activation.jobs.size == 1
+              evict(worker_state, activation.run_id)
+              worker_state.logger.debug('Sending empty workflow completion') if LOG_ACTIVATIONS
+              yield Internal::Bridge::Api::WorkflowCompletion::WorkflowActivationCompletion.new(
+                run_id: activation.run_id,
+                successful: Internal::Bridge::Api::WorkflowCompletion::Success.new
+              )
+              return
+            end
+
+            completion = Timeout.timeout(
+              worker_state.deadlock_timeout,
+              DeadlockError,
+              # TODO(cretz): Document that this affects all running workflows on this worker
+              # and maybe test to see how that is mitigated
+              "[TMPRL1101] Potential deadlock detected: workflow didn't yield " \
+              "within #{worker_state.deadlock_timeout} second(s)."
+            ) do
+              # Get or create workflow
+              instance = worker_state.get_or_create_running_workflow(activation.run_id) do
+                create_instance(activation, worker_state)
+              end
+
+              # Activate. We expect most errors in here to have been captured inside.
+              instance.activate(activation)
+            rescue Exception => e # rubocop:disable Lint/RescueException
+              worker_state.logger.error("Failed activation on workflow run ID: #{activation.run_id}")
+              worker_state.logger.error(e)
+              Internal::Worker::WorkflowInstance.new_completion_with_failure(
+                run_id: activation.run_id,
+                error: e,
+                failure_converter: worker_state.data_converter.failure_converter,
+                payload_converter: worker_state.data_converter.payload_converter
+              )
+            end
+
+            # Go ahead and evict if there is an eviction job
+            evict(worker_state, activation.run_id) if cache_remove_job
+
+            # Complete the activation
+            worker_state.logger.debug("Sending workflow completion: #{completion}") if LOG_ACTIVATIONS
+            yield completion
+          end
+
+          def create_instance(initial_activation, worker_state)
+            # Extract start job
+            init_job = initial_activation.jobs.find { |j| !j.initialize_workflow.nil? }&.initialize_workflow
+            raise 'Missing initialize job in initial activation' unless init_job
+
+            # Obtain definition
+            definition = worker_state.workflow_definitions[init_job.workflow_type] ||
+                         worker_state.workflow_definitions[nil]
+            unless definition
+              raise Error::ApplicationError.new(
+                "Workflow type #{init_job.workflow_type} is not registered on this worker, available workflows: " +
+                  worker_state.workflow_definitions.keys.compact.sort.join(', '),
+                type: 'NotFoundError'
+              )
+            end
+
+            Internal::Worker::WorkflowInstance.new(
+              Internal::Worker::WorkflowInstance::Details.new(
+                namespace: worker_state.namespace,
+                task_queue: worker_state.task_queue,
+                definition:,
+                initial_activation:,
+                logger: worker_state.logger,
+                metric_meter: worker_state.metric_meter,
+                payload_converter: worker_state.data_converter.payload_converter,
+                failure_converter: worker_state.data_converter.failure_converter,
+                interceptors: worker_state.workflow_interceptors,
+                disable_eager_activity_execution: worker_state.disable_eager_activity_execution,
+                illegal_calls: worker_state.illegal_calls,
+                workflow_failure_exception_types: worker_state.workflow_failure_exception_types
+              )
+            )
+          end
+
+          def evict(worker_state, run_id)
+            worker_state.evict_running_workflow(run_id)
+            @executor._remove_workflow(worker_state, run_id)
+          end
+        end
+
+        private_constant :Worker
+
+        # Error raised when a processing a workflow task takes more than the expected amount of time.
+        class DeadlockError < Exception; end # rubocop:disable Lint/InheritException
+      end
+    end
+  end
+end

data/lib/temporalio/worker/workflow_executor.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'temporalio/worker/workflow_executor/thread_pool'
+
+module Temporalio
+  class Worker
+    # Workflow executor that executes workflow tasks. Unlike {ActivityExecutor}, this class is not meant for user
+    # implementation. The only implementation that is currently accepted is {WorkflowExecutor::ThreadPool}.
+    class WorkflowExecutor
+      # @!visibility private
+      def initialize
+        raise 'Cannot create custom executors'
+      end
+
+      # @!visibility private
+      def _validate_worker(worker, worker_state)
+        raise NotImplementedError
+      end
+
+      # @!visibility private
+      def _activate(activation, worker_state, &)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/temporalio/worker.rb

@@ -8,9 +8,13 @@ require 'temporalio/internal/bridge'
 require 'temporalio/internal/bridge/worker'
 require 'temporalio/internal/worker/activity_worker'
 require 'temporalio/internal/worker/multi_runner'
+require 'temporalio/internal/worker/workflow_instance'
+require 'temporalio/internal/worker/workflow_worker'
 require 'temporalio/worker/activity_executor'
 require 'temporalio/worker/interceptor'
+require 'temporalio/worker/thread_pool'
 require 'temporalio/worker/tuner'
+require 'temporalio/worker/workflow_executor'
 
 module Temporalio
   # Worker for processing activities and workflows on a task queue.
@@ -19,13 +23,14 @@ module Temporalio
   # {run_all} is used for a collection of workers. These can wait until a block is complete or a {Cancellation} is
   # canceled.
   class Worker
-    # Options as returned from {options} for `**to_h`` splat use in {initialize}. See {initialize} for details.
-    Options = Struct.new(
+    Options = Data.define(
       :client,
       :task_queue,
       :activities,
-      :activity_executors,
+      :workflows,
       :tuner,
+      :activity_executors,
+      :workflow_executor,
       :interceptors,
       :build_id,
       :identity,
@@ -42,9 +47,16 @@ module Temporalio
       :max_task_queue_activities_per_second,
       :graceful_shutdown_period,
       :use_worker_versioning,
-      keyword_init: true
+      :disable_eager_activity_execution,
+      :illegal_workflow_calls,
+      :workflow_failure_exception_types,
+      :workflow_payload_codec_thread_pool,
+      :debug_mode
     )
 
+    # Options as returned from {options} for `**to_h` splat use in {initialize}. See {initialize} for details.
+    class Options; end # rubocop:disable Lint/EmptyClass
+
     # @return [String] Memoized default build ID. This default value is built as a checksum of all of the loaded Ruby
     #   source files in `$LOADED_FEATURES`. Users may prefer to set the build ID to a better representation of the
     #   source.
@@ -108,7 +120,7 @@ module Temporalio
       runner.apply_thread_or_fiber_block(&block)
 
       # Reuse first worker logger
-      logger = workers.first&.options&.logger or raise # Help steep
+      logger = workers.first&.options&.logger or raise # Never nil
 
       # On cancel, initiate shutdown
       cancellation.add_cancel_callback do
@@ -121,16 +133,34 @@ module Temporalio
       block_result = nil
       loop do
         event = runner.next_event
+        # TODO(cretz): Consider improving performance instead of this case statement
         case event
         when Internal::Worker::MultiRunner::Event::PollSuccess
           # Successful poll
-          event.worker._on_poll_bytes(event.worker_type, event.bytes)
+          event.worker._on_poll_bytes(runner, event.worker_type, event.bytes)
         when Internal::Worker::MultiRunner::Event::PollFailure
           # Poll failure, this causes shutdown of all workers
-          logger.error('Poll failure (beginning worker shutdown if not alaredy occurring)')
+          logger.error('Poll failure (beginning worker shutdown if not already occurring)')
           logger.error(event.error)
           first_error ||= event.error
           runner.initiate_shutdown
+        when Internal::Worker::MultiRunner::Event::WorkflowActivationDecoded
+          # Came back from a codec as decoded
+          event.workflow_worker.handle_activation(runner:, activation: event.activation, decoded: true)
+        when Internal::Worker::MultiRunner::Event::WorkflowActivationComplete
+          # An activation is complete
+          event.workflow_worker.handle_activation_complete(
+            runner:,
+            activation_completion: event.activation_completion,
+            encoded: event.encoded,
+            completion_complete_queue: event.completion_complete_queue
+          )
+        when Internal::Worker::MultiRunner::Event::WorkflowActivationCompletionComplete
+          # Completion complete, only need to log error if it occurs here
+          if event.error
+            logger.error("Activation completion failed to record on run ID #{event.run_id}")
+            logger.error(event.error)
+          end
         when Internal::Worker::MultiRunner::Event::PollerShutDown
           # Individual poller shut down. Nothing to do here until we support
           # worker status or something.
@@ -186,6 +216,9 @@ module Temporalio
         end
       end
 
+      # Notify each worker we're done with it
+      workers.each(&:_on_shutdown_complete)
+
       # If there was an shutdown-causing error, we raise that
       if !first_error.nil?
         raise first_error
@@ -194,6 +227,53 @@ module Temporalio
       end
     end
 
+    # @return [Hash<String, [:all, Array<Symbol>]>] Default, immutable set illegal calls used for the
+    #   `illegal_workflow_calls` worker option. See the documentation of that option for more details.
+    def self.default_illegal_workflow_calls
+      @default_illegal_workflow_calls ||= begin
+        hash = {
+          'BasicSocket' => :all,
+          'Date' => %i[initialize today],
+          'DateTime' => %i[initialize now],
+          'Dir' => :all,
+          'Fiber' => [:set_scheduler],
+          'File' => :all,
+          'FileTest' => :all,
+          'FileUtils' => :all,
+          'Find' => :all,
+          'GC' => :all,
+          'IO' => [
+            :read
+            # Intentionally leaving out write so puts will work. We don't want to add heavy logic replacing stdout or
+            # trying to derive whether it's file vs stdout write.
+            #:write
+          ],
+          'Kernel' => %i[abort at_exit autoload autoload? eval exec exit fork gets load open rand readline readlines
+                         spawn srand system test trap],
+          'Net::HTTP' => :all,
+          'Pathname' => :all,
+          # TODO(cretz): Investigate why clock_gettime called from Timeout thread affects this code at all. Stack trace
+          # test executing activities inside a timeout will fail if clock_gettime is blocked.
+          'Process' => %i[abort argv0 daemon detach exec exit exit! fork kill setpriority setproctitle setrlimit setsid
+                          spawn times wait wait2 waitall warmup],
+          # TODO(cretz): Allow Ractor.current since exception formatting in error_highlight references it
+          # 'Ractor' => :all,
+          'Random::Base' => [:initialize],
+          'Resolv' => :all,
+          'SecureRandom' => :all,
+          'Signal' => :all,
+          'Socket' => :all,
+          'Tempfile' => :all,
+          'Thread' => %i[abort_on_exception= exit fork handle_interrupt ignore_deadlock= kill new pass
+                         pending_interrupt? report_on_exception= start stop initialize join name= priority= raise run
+                         terminate thread_variable_set wakeup],
+          'Time' => %i[initialize now]
+        } #: Hash[String, :all | Array[Symbol]]
+        hash.each_value(&:freeze)
+        hash.freeze
+      end
+    end
+
     # @return [Options] Frozen options for this client which has the same attributes as {initialize}.
     attr_reader :options
 
@@ -201,20 +281,26 @@ module Temporalio
     #
     # @param client [Client] Client for this worker.
     # @param task_queue [String] Task queue for this worker.
-    # @param activities [Array<Activity, Class<Activity>, Activity::Definition>] Activities for this worker.
-    # @param activity_executors [Hash<Symbol, Worker::ActivityExecutor>] Executors that activities can run within.
+    # @param activities [Array<Activity::Definition, Class<Activity::Definition>, Activity::Definition::Info>]
+    #   Activities for this worker.
+    # @param workflows [Array<Class<Workflow::Definition>>] Workflows for this worker.
     # @param tuner [Tuner] Tuner that controls the amount of concurrent activities/workflows that run at a time.
-    # @param interceptors [Array<Interceptor>] Interceptors specific to this worker. Note, interceptors set on the
-    #   client that include the {Interceptor} module are automatically included here, so no need to specify them again.
+    # @param activity_executors [Hash<Symbol, Worker::ActivityExecutor>] Executors that activities can run within.
+    # @param workflow_executor [WorkflowExecutor] Workflow executor that workflow tasks run within. This must be a
+    #   {WorkflowExecutor::ThreadPool} currently.
+    # @param interceptors [Array<Interceptor::Activity, Interceptor::Workflow>] Interceptors specific to this worker.
+    #   Note, interceptors set on the client that include the {Interceptor::Activity} or {Interceptor::Workflow} module
+    #   are automatically included here, so no need to specify them again.
     # @param build_id [String] Unique identifier for the current runtime. This is best set as a unique value
     #   representing all code and should change only when code does. This can be something like a git commit hash. If
     #   unset, default is hash of known Ruby code.
     # @param identity [String, nil] Override the identity for this worker. If unset, client identity is used.
+    # @param logger [Logger] Logger to override client logger with. Default is the client logger.
     # @param max_cached_workflows [Integer] Number of workflows held in cache for use by sticky task queue. If set to 0,
     #   workflow caching and sticky queuing are disabled.
     # @param max_concurrent_workflow_task_polls [Integer] Maximum number of concurrent poll workflow task requests we
     #   will perform at a time on this worker's task queue.
-    # @param nonsticky_to_sticky_poll_ratio [Float] `max_concurrent_workflow_task_polls`` * this number = the number of
+    # @param nonsticky_to_sticky_poll_ratio [Float] `max_concurrent_workflow_task_polls` * this number = the number of
     #   max pollers that will be allowed for the nonsticky queue when sticky tasks are enabled. If both defaults are
     #   used, the sticky queue will allow 4 max pollers while the nonsticky queue will allow one. The minimum for either
     #   poller is 1, so if `max_concurrent_workflow_task_polls` is 1 and sticky queues are enabled, there will be 2
@@ -239,12 +325,35 @@ module Temporalio
     # @param use_worker_versioning [Boolean] If true, the `build_id` argument must be specified, and this worker opts
     #   into the worker versioning feature. This ensures it only receives workflow tasks for workflows which it claims
     #   to be compatible with. For more information, see https://docs.temporal.io/workers#worker-versioning.
+    # @param disable_eager_activity_execution [Boolean] If true, disables eager activity execution. Eager activity
+    #   execution is an optimization on some servers that sends activities back to the same worker as the calling
+    #   workflow if they can run there. This should be set to true for `max_task_queue_activities_per_second` to work
+    #   and in a future version of this API may be implied as such (i.e. this setting will be ignored if that setting is
+    #   set).
+    # @param illegal_workflow_calls [Hash<String, [:all, Array<Symbol>]>] Set of illegal workflow calls that are
+    #   considered unsafe/non-deterministic and will raise if seen. The key of the hash is the fully qualified string
+    #   class name (no leading `::`). The value is either `:all` which means any use of the class, or an array of
+    #   symbols for methods on the class that cannot be used. The methods refer to either instance or class methods,
+    #   there is no way to differentiate at this time.
+    # @param workflow_failure_exception_types [Array<Class<Exception>>] Workflow failure exception types. This is the
+    #   set of exception types that, if a workflow-thrown exception extends, will cause the workflow/update to fail
+    #   instead of suspending the workflow via task failure. These are applied in addition to the
+    #   `workflow_failure_exception_type` on the workflow definition class itself. If {::Exception} is set, it
+    #   effectively will fail a workflow/update in all user exception cases.
+    # @param workflow_payload_codec_thread_pool [ThreadPool, nil] Thread pool to run payload codec encode/decode within.
+    #   This is required if a payload codec exists and the worker is not fiber based. Codecs can potentially block
+    #   execution which is why they need to be run in the background.
+    # @param debug_mode [Boolean] If true, deadlock detection is disabled. Deadlock detection will fail workflow tasks
+    #   if they block the thread for too long. This defaults to true if the `TEMPORAL_DEBUG` environment variable is
+    #   `true` or `1`.
     def initialize(
       client:,
       task_queue:,
       activities: [],
-      activity_executors: ActivityExecutor.defaults,
+      workflows: [],
       tuner: Tuner.create_fixed,
+      activity_executors: ActivityExecutor.defaults,
+      workflow_executor: WorkflowExecutor::ThreadPool.default,
       interceptors: [],
       build_id: Worker.default_build_id,
       identity: nil,
@@ -260,17 +369,23 @@ module Temporalio
       max_activities_per_second: nil,
       max_task_queue_activities_per_second: nil,
       graceful_shutdown_period: 0,
-      use_worker_versioning: false
+      use_worker_versioning: false,
+      disable_eager_activity_execution: false,
+      illegal_workflow_calls: Worker.default_illegal_workflow_calls,
+      workflow_failure_exception_types: [],
+      workflow_payload_codec_thread_pool: nil,
+      debug_mode: %w[true 1].include?(ENV['TEMPORAL_DEBUG'].to_s.downcase)
     )
-      # TODO(cretz): Remove when workflows come about
-      raise ArgumentError, 'Must have at least one activity' if activities.empty?
+      raise ArgumentError, 'Must have at least one activity or workflow' if activities.empty? && workflows.empty?
 
       @options = Options.new(
         client:,
         task_queue:,
         activities:,
-        activity_executors:,
+        workflows:,
         tuner:,
+        activity_executors:,
+        workflow_executor:,
         interceptors:,
         build_id:,
         identity:,
@@ -286,15 +401,36 @@ module Temporalio
         max_activities_per_second:,
         max_task_queue_activities_per_second:,
         graceful_shutdown_period:,
-        use_worker_versioning:
+        use_worker_versioning:,
+        disable_eager_activity_execution:,
+        illegal_workflow_calls:,
+        workflow_failure_exception_types:,
+        workflow_payload_codec_thread_pool:,
+        debug_mode:
       ).freeze
 
+      # Preload workflow definitions and some workflow settings for the bridge
+      workflow_definitions = Internal::Worker::WorkflowWorker.workflow_definitions(workflows)
+      nondeterminism_as_workflow_fail = workflow_failure_exception_types.any? do |t|
+        t.is_a?(Class) && t >= Workflow::NondeterminismError
+      end
+      nondeterminism_as_workflow_fail_for_types = workflow_definitions.values.map do |defn|
+        next unless defn.failure_exception_types.any? { |t| t.is_a?(Class) && t >= Workflow::NondeterminismError }
+
+        # If they tried to do this on a dynamic workflow and haven't already set worker-level option, warn
+        unless defn.name || nondeterminism_as_workflow_fail
+          warn('Note, dynamic workflows cannot trap non-determinism errors, so worker-level ' \
+               'workflow_failure_exception_types should be set to capture that if that is the intention')
+        end
+        defn.name
+      end.compact
+
       # Create the bridge worker
       @bridge_worker = Internal::Bridge::Worker.new(
         client.connection._core_client,
         Internal::Bridge::Worker::Options.new(
           activity: !activities.empty?,
-          workflow: false,
+          workflow: !workflows.empty?,
           namespace: client.namespace,
           task_queue:,
           tuner: Internal::Bridge::Worker::TunerOptions.new(
@@ -308,26 +444,42 @@ module Temporalio
           max_concurrent_workflow_task_polls:,
           nonsticky_to_sticky_poll_ratio:,
           max_concurrent_activity_task_polls:,
-          no_remote_activities:,
+          # For shutdown to work properly, we must disable remote activities
+          # ourselves if there are no activities
+          no_remote_activities: no_remote_activities || activities.empty?,
           sticky_queue_schedule_to_start_timeout:,
           max_heartbeat_throttle_interval:,
           default_heartbeat_throttle_interval:,
           max_worker_activities_per_second: max_activities_per_second,
           max_task_queue_activities_per_second:,
           graceful_shutdown_period:,
-          use_worker_versioning:
+          use_worker_versioning:,
+          nondeterminism_as_workflow_fail:,
+          nondeterminism_as_workflow_fail_for_types:
         )
       )
 
       # Collect interceptors from client and params
-      @all_interceptors = client.options.interceptors.select { |i| i.is_a?(Interceptor) } + interceptors
+      @activity_interceptors = (client.options.interceptors + interceptors).select do |i|
+        i.is_a?(Interceptor::Activity)
+      end
+      @workflow_interceptors = (client.options.interceptors + interceptors).select do |i|
+        i.is_a?(Interceptor::Workflow)
+      end
 
       # Cancellation for the whole worker
       @worker_shutdown_cancellation = Cancellation.new
 
       # Create workers
-      # TODO(cretz): Make conditional when workflows appear
-      @activity_worker = Internal::Worker::ActivityWorker.new(self, @bridge_worker)
+      unless activities.empty?
+        @activity_worker = Internal::Worker::ActivityWorker.new(worker: self,
+                                                                bridge_worker: @bridge_worker)
+      end
+      unless workflows.empty?
+        @workflow_worker = Internal::Worker::WorkflowWorker.new(worker: self,
+                                                                bridge_worker: @bridge_worker,
+                                                                workflow_definitions:)
+      end
 
       # Validate worker
       @bridge_worker.validate
@@ -387,16 +539,35 @@ module Temporalio
     end
 
     # @!visibility private
-    def _all_interceptors
-      @all_interceptors
+    def _activity_interceptors
+      @activity_interceptors
     end
 
     # @!visibility private
-    def _on_poll_bytes(worker_type, bytes)
-      # TODO(cretz): Workflow workers
-      raise "Unrecognized worker type #{worker_type}" unless worker_type == :activity
+    def _workflow_interceptors
+      @workflow_interceptors
+    end
+
+    # @!visibility private
+    def _on_poll_bytes(runner, worker_type, bytes)
+      case worker_type
+      when :activity
+        @activity_worker.handle_task(Internal::Bridge::Api::ActivityTask::ActivityTask.decode(bytes))
+      when :workflow
+        @workflow_worker.handle_activation(
+          runner:,
+          activation: Internal::Bridge::Api::WorkflowActivation::WorkflowActivation.decode(bytes),
+          decoded: false
+        )
+      else
+        raise "Unrecognized worker type #{worker_type}"
+      end
+    end
 
-      @activity_worker.handle_task(Internal::Bridge::Api::ActivityTask::ActivityTask.decode(bytes))
+    # @!visibility private
+    def _on_shutdown_complete
+      @workflow_worker&.on_shutdown_complete
+      @workflow_worker = nil
     end
 
     private

data/lib/temporalio/workflow/activity_cancellation_type.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'temporalio/internal/bridge/api'
+
+module Temporalio
+  module Workflow
+    # Cancellation types for activities.
+    module ActivityCancellationType
+      # Initiate a cancellation request and immediately report cancellation to the workflow.
+      TRY_CANCEL = Internal::Bridge::Api::WorkflowCommands::ActivityCancellationType::TRY_CANCEL
+      # Wait for activity cancellation completion. Note that activity must heartbeat to receive a cancellation
+      # notification. This can block the cancellation for a long time if activity doesn't heartbeat or chooses to ignore
+      # the cancellation request.
+      WAIT_CANCELLATION_COMPLETED =
+        Internal::Bridge::Api::WorkflowCommands::ActivityCancellationType::WAIT_CANCELLATION_COMPLETED
+      # Do not request cancellation of the activity and immediately report cancellation to the workflow.
+      ABANDON = Internal::Bridge::Api::WorkflowCommands::ActivityCancellationType::ABANDON
+    end
+  end
+end