temporalio 0.3.0-x86_64-linux → 0.4.0-x86_64-linux

data/lib/temporalio/internal/worker/activity_worker.rb

@@ -93,8 +93,10 @@ module Temporalio
         def handle_start_task(task_token, start)
           set_running_activity(task_token, nil)
 
-          # Find activity definition, falling back to dynamic if present
-          defn = @activities[start.activity_type] || @activities[nil]
+          # Find activity definition, falling back to dynamic if not found and not reserved name
+          defn = @activities[start.activity_type]
+          defn = @activities[nil] if !defn && !Internal::ProtoUtils.reserved_name?(start.activity_type)
+
           if defn.nil?
             raise Error::ApplicationError.new(
               "Activity #{start.activity_type} for workflow #{start.workflow_execution.workflow_id} " \
@@ -114,7 +116,7 @@ module Temporalio
             # Unset at the end
             Activity::Context._current_executor = nil
           end
-        rescue Exception => e # rubocop:disable Lint/RescueException We are intending to catch everything here
+        rescue Exception => e # rubocop:disable Lint/RescueException -- We are intending to catch everything here
           remove_running_activity(task_token)
           @scoped_logger.warn("Failed starting activity #{start.activity_type}")
           @scoped_logger.warn(e)
@@ -201,6 +203,7 @@ module Temporalio
 
           # Run
           activity = RunningActivity.new(
+            worker: @worker,
             info:,
             cancellation: Cancellation.new,
             worker_shutdown_cancellation: @worker._worker_shutdown_cancellation,
@@ -210,8 +213,8 @@ module Temporalio
           )
           Activity::Context._current_executor&.set_activity_context(defn, activity)
           set_running_activity(task_token, activity)
-          run_activity(activity, input)
-        rescue Exception => e # rubocop:disable Lint/RescueException We are intending to catch everything here
+          run_activity(defn, activity, input)
+        rescue Exception => e # rubocop:disable Lint/RescueException -- We are intending to catch everything here
           @scoped_logger.warn("Failed starting or sending completion for activity #{start.activity_type}")
           @scoped_logger.warn(e)
           # This means that the activity couldn't start or send completion (run
@@ -236,8 +239,11 @@ module Temporalio
           remove_running_activity(task_token)
         end
 
-        def run_activity(activity, input)
+        def run_activity(defn, activity, input)
           result = begin
+            # Create the instance. We choose to do this before interceptors so that it is available in the interceptor.
+            activity.instance = defn.instance.is_a?(Proc) ? defn.instance.call : defn.instance # steep:ignore
+
             # Build impl with interceptors
             # @type var impl: Temporalio::Worker::Interceptor::Activity::Inbound
             impl = InboundImplementation.new(self)
@@ -255,7 +261,7 @@ module Temporalio
                 result: @worker.options.client.data_converter.to_payload(result)
               )
             )
-          rescue Exception => e # rubocop:disable Lint/RescueException We are intending to catch everything here
+          rescue Exception => e # rubocop:disable Lint/RescueException -- We are intending to catch everything here
             if e.is_a?(Activity::CompleteAsyncError)
               # Wanting to complete async
               @scoped_logger.debug('Completing activity asynchronously')
@@ -293,9 +299,10 @@ module Temporalio
 
         class RunningActivity < Activity::Context
           attr_reader :info, :cancellation, :worker_shutdown_cancellation, :payload_converter, :logger
-          attr_accessor :_outbound_impl, :_server_requested_cancel
+          attr_accessor :instance, :_outbound_impl, :_server_requested_cancel
 
           def initialize( # rubocop:disable Lint/MissingSuper
+            worker:,
             info:,
             cancellation:,
             worker_shutdown_cancellation:,
@@ -303,6 +310,7 @@ module Temporalio
             logger:,
             runtime_metric_meter:
           )
+            @worker = worker
             @info = info
             @cancellation = cancellation
             @worker_shutdown_cancellation = worker_shutdown_cancellation
@@ -331,6 +339,10 @@ module Temporalio
               }
             )
           end
+
+          def client
+            @worker.client
+          end
         end
 
         class InboundImplementation < Temporalio::Worker::Interceptor::Activity::Inbound

data/lib/temporalio/internal/worker/multi_runner.rb

@@ -34,7 +34,7 @@ module Temporalio
                                rescue InjectEventForTesting => e
                                  @queue.push(e.event)
                                  @queue.push(Event::BlockSuccess.new(result: e))
-                               rescue Exception => e # rubocop:disable Lint/RescueException Intentionally catch all
+                               rescue Exception => e # rubocop:disable Lint/RescueException -- Intentionally catch all
                                  @queue.push(Event::BlockFailure.new(error: e))
                                end
                              else
@@ -43,7 +43,7 @@ module Temporalio
                                rescue InjectEventForTesting => e
                                  @queue.push(e.event)
                                  @queue.push(Event::BlockSuccess.new(result: e))
-                               rescue Exception => e # rubocop:disable Lint/RescueException Intentionally catch all
+                               rescue Exception => e # rubocop:disable Lint/RescueException -- Intentionally catch all
                                  @queue.push(Event::BlockFailure.new(error: e))
                                end
                              end

data/lib/temporalio/internal/worker/workflow_instance/context.rb

@@ -32,6 +32,16 @@ module Temporalio
             @instance.continue_as_new_suggested
           end
 
+          def current_details
+            @instance.current_details || ''
+          end
+
+          def current_details=(details)
+            raise 'Details must be a String' unless details.nil? || details.is_a?(String)
+
+            @instance.current_details = (details || '')
+          end
+
           def current_history_length
             @instance.current_history_length
           end
@@ -52,6 +62,7 @@ module Temporalio
             activity,
             *args,
             task_queue:,
+            summary:,
             schedule_to_close_timeout:,
             schedule_to_start_timeout:,
             start_to_close_timeout:,
@@ -62,11 +73,22 @@ module Temporalio
             activity_id:,
             disable_eager_execution:
           )
+            activity = case activity
+                       when Class
+                         Activity::Definition::Info.from_activity(activity).name&.to_s
+                       when Symbol, String
+                         activity.to_s
+                       else
+                         raise ArgumentError, 'Activity must be a definition class, or a symbol/string'
+                       end
+            raise 'Cannot invoke dynamic activities' unless activity
+
             @outbound.execute_activity(
               Temporalio::Worker::Interceptor::Workflow::ExecuteActivityInput.new(
                 activity:,
                 args:,
                 task_queue: task_queue || info.task_queue,
+                summary:,
                 schedule_to_close_timeout:,
                 schedule_to_start_timeout:,
                 start_to_close_timeout:,
@@ -93,6 +115,16 @@ module Temporalio
             cancellation_type:,
             activity_id:
           )
+            activity = case activity
+                       when Class
+                         Activity::Definition::Info.from_activity(activity).name&.to_s
+                       when Symbol, String
+                         activity.to_s
+                       else
+                         raise ArgumentError, 'Activity must be a definition class, or a symbol/string'
+                       end
+            raise 'Cannot invoke dynamic activities' unless activity
+
             @outbound.execute_local_activity(
               Temporalio::Worker::Interceptor::Workflow::ExecuteLocalActivityInput.new(
                 activity:,
@@ -122,12 +154,26 @@ module Temporalio
             @instance.info
           end
 
+          def instance
+            @instance.instance
+          end
+
           def initialize_continue_as_new_error(error)
             @outbound.initialize_continue_as_new_error(
               Temporalio::Worker::Interceptor::Workflow::InitializeContinueAsNewErrorInput.new(error:)
             )
           end
 
+          def io_enabled(&)
+            prev = @instance.io_enabled
+            @instance.io_enabled = true
+            begin
+              yield
+            ensure
+              @instance.io_enabled = prev
+            end
+          end
+
           def logger
             @instance.logger
           end
@@ -187,6 +233,8 @@ module Temporalio
             *args,
             id:,
             task_queue:,
+            static_summary:,
+            static_details:,
             cancellation:,
             cancellation_type:,
             parent_close_policy:,
@@ -201,10 +249,12 @@ module Temporalio
           )
             @outbound.start_child_workflow(
               Temporalio::Worker::Interceptor::Workflow::StartChildWorkflowInput.new(
-                workflow:,
+                workflow: Workflow::Definition._workflow_type_from_workflow_parameter(workflow),
                 args:,
                 id:,
                 task_queue:,
+                static_summary:,
+                static_details:,
                 cancellation:,
                 cancellation_type:,
                 parent_close_policy:,
@@ -221,6 +271,10 @@ module Temporalio
             )
           end
 
+          def storage
+            @storage ||= {}
+          end
+
           def timeout(duration, exception_class, *exception_args, summary:, &)
             raise 'Block required for timeout' unless block_given?
 
@@ -302,7 +356,7 @@ module Temporalio
             @outbound.signal_child_workflow(
               Temporalio::Worker::Interceptor::Workflow::SignalChildWorkflowInput.new(
                 id:,
-                signal:,
+                signal: Workflow::Definition::Signal._name_from_parameter(signal),
                 args:,
                 cancellation:,
                 headers: {}
@@ -315,7 +369,7 @@ module Temporalio
               Temporalio::Worker::Interceptor::Workflow::SignalExternalWorkflowInput.new(
                 id:,
                 run_id:,
-                signal:,
+                signal: Workflow::Definition::Signal._name_from_parameter(signal),
                 args:,
                 cancellation:,
                 headers: {}

data/lib/temporalio/internal/worker/workflow_instance/details.rb

@@ -8,7 +8,7 @@ module Temporalio
         class Details
           attr_reader :namespace, :task_queue, :definition, :initial_activation, :logger, :metric_meter,
                       :payload_converter, :failure_converter, :interceptors, :disable_eager_activity_execution,
-                      :illegal_calls, :workflow_failure_exception_types
+                      :illegal_calls, :workflow_failure_exception_types, :unsafe_workflow_io_enabled
 
           def initialize(
             namespace:,
@@ -22,7 +22,8 @@ module Temporalio
             interceptors:,
             disable_eager_activity_execution:,
             illegal_calls:,
-            workflow_failure_exception_types:
+            workflow_failure_exception_types:,
+            unsafe_workflow_io_enabled:
           )
             @namespace = namespace
             @task_queue = task_queue
@@ -36,6 +37,7 @@ module Temporalio
             @disable_eager_activity_execution = disable_eager_activity_execution
             @illegal_calls = illegal_calls
             @workflow_failure_exception_types = workflow_failure_exception_types
+            @unsafe_workflow_io_enabled = unsafe_workflow_io_enabled
           end
         end
       end

data/lib/temporalio/internal/worker/workflow_instance/outbound_implementation.rb

@@ -56,16 +56,6 @@ module Temporalio
               raise ArgumentError, 'Activity must have schedule_to_close_timeout or start_to_close_timeout'
             end
 
-            activity_type = case input.activity
-                            when Class
-                              Activity::Definition::Info.from_activity(input.activity).name
-                            when Symbol, String
-                              input.activity.to_s
-                            else
-                              raise ArgumentError, 'Activity must be a definition class, or a symbol/string'
-                            end
-            raise 'Cannot invoke dynamic activities' unless activity_type
-
             execute_activity_with_local_backoffs(local: false, cancellation: input.cancellation) do
               seq = (@activity_counter += 1)
               @instance.add_command(
@@ -73,7 +63,7 @@ module Temporalio
                   schedule_activity: Bridge::Api::WorkflowCommands::ScheduleActivity.new(
                     seq:,
                     activity_id: input.activity_id || seq.to_s,
-                    activity_type:,
+                    activity_type: input.activity,
                     task_queue: input.task_queue,
                     headers: ProtoUtils.headers_to_proto_hash(input.headers, @instance.payload_converter),
                     arguments: ProtoUtils.convert_to_payload_array(@instance.payload_converter, input.args),
@@ -84,7 +74,8 @@ module Temporalio
                     retry_policy: input.retry_policy&._to_proto,
                     cancellation_type: input.cancellation_type,
                     do_not_eagerly_execute: input.disable_eager_execution
-                  )
+                  ),
+                  user_metadata: ProtoUtils.to_user_metadata(input.summary, nil, @instance.payload_converter)
                 )
               )
               seq
@@ -96,16 +87,6 @@ module Temporalio
               raise ArgumentError, 'Activity must have schedule_to_close_timeout or start_to_close_timeout'
             end
 
-            activity_type = case input.activity
-                            when Class
-                              Activity::Definition::Info.from_activity(input.activity).name
-                            when Symbol, String
-                              input.activity.to_s
-                            else
-                              raise ArgumentError, 'Activity must be a definition class, or a symbol/string'
-                            end
-            raise 'Cannot invoke dynamic activities' unless activity_type
-
             execute_activity_with_local_backoffs(local: true, cancellation: input.cancellation) do |do_backoff|
               seq = (@activity_counter += 1)
               @instance.add_command(
@@ -113,7 +94,7 @@ module Temporalio
                   schedule_local_activity: Bridge::Api::WorkflowCommands::ScheduleLocalActivity.new(
                     seq:,
                     activity_id: input.activity_id || seq.to_s,
-                    activity_type:,
+                    activity_type: input.activity,
                     headers: ProtoUtils.headers_to_proto_hash(input.headers, @instance.payload_converter),
                     arguments: ProtoUtils.convert_to_payload_array(@instance.payload_converter, input.args),
                     schedule_to_close_timeout: ProtoUtils.seconds_to_duration(input.schedule_to_close_timeout),
@@ -232,7 +213,7 @@ module Temporalio
             seq = (@external_signal_counter += 1)
             cmd = Bridge::Api::WorkflowCommands::SignalExternalWorkflowExecution.new(
               seq:,
-              signal_name: Workflow::Definition::Signal._name_from_parameter(signal),
+              signal_name: signal,
               args: ProtoUtils.convert_to_payload_array(@instance.payload_converter, args),
               headers: ProtoUtils.headers_to_proto_hash(headers, @instance.payload_converter)
             )
@@ -300,7 +281,8 @@ module Temporalio
                 start_timer: Bridge::Api::WorkflowCommands::StartTimer.new(
                   seq:,
                   start_to_fire_timeout: ProtoUtils.seconds_to_duration(duration)
-                )
+                ),
+                user_metadata: ProtoUtils.to_user_metadata(input.summary, nil, @instance.payload_converter)
               )
             )
             @instance.pending_timers[seq] = Fiber.current
@@ -340,7 +322,7 @@ module Temporalio
                   seq:,
                   namespace: @instance.info.namespace,
                   workflow_id: input.id,
-                  workflow_type: Workflow::Definition._workflow_type_from_workflow_parameter(input.workflow),
+                  workflow_type: input.workflow,
                   task_queue: input.task_queue,
                   input: ProtoUtils.convert_to_payload_array(@instance.payload_converter, input.args),
                   workflow_execution_timeout: ProtoUtils.seconds_to_duration(input.execution_timeout),
@@ -354,6 +336,9 @@ module Temporalio
                   memo: ProtoUtils.memo_to_proto_hash(input.memo, @instance.payload_converter),
                   search_attributes: input.search_attributes&._to_proto_hash,
                   cancellation_type: input.cancellation_type
+                ),
+                user_metadata: ProtoUtils.to_user_metadata(
+                  input.static_summary, input.static_details, @instance.payload_converter
                 )
               )
             )

data/lib/temporalio/internal/worker/workflow_instance/scheduler.rb

@@ -137,8 +137,28 @@ module Temporalio
           end
 
           def io_wait(io, events, timeout)
-            # TODO(cretz): This in a blocking fashion?
-            raise NotImplementedError, 'TODO'
+            # Do not allow if IO disabled
+            unless @instance.io_enabled
+              raise Workflow::NondeterminismError,
+                    'Cannot perform IO from inside a workflow. If this is known to be safe, ' \
+                    'the code can be run in a Temporalio::Workflow::Unsafe.io_enabled block.'
+            end
+
+            # Use regular Ruby behavior of blocking this thread. There is no Ruby implementation of io_wait we can just
+            # delegate to at this time (or default scheduler or anything like that), so we had to implement this
+            # ourselves.
+            readers = events.nobits?(IO::READABLE) ? nil : [io]
+            writers = events.nobits?(IO::WRITABLE) ? nil : [io]
+            priority = events.nobits?(IO::PRIORITY) ? nil : [io]
+            ready = IO.select(readers, writers, priority, timeout) # steep:ignore
+
+            result = 0
+            unless ready.nil?
+              result |= IO::READABLE if ready[0]&.include?(io)
+              result |= IO::WRITABLE if ready[1]&.include?(io)
+              result |= IO::PRIORITY if ready[2]&.include?(io)
+            end
+            result
           end
 
           def kernel_sleep(duration = nil)

data/lib/temporalio/internal/worker/workflow_instance.rb

@@ -4,6 +4,7 @@ require 'json'
 require 'temporalio'
 require 'temporalio/activity/definition'
 require 'temporalio/api'
+require 'temporalio/converters/payload_converter'
 require 'temporalio/converters/raw_value'
 require 'temporalio/error'
 require 'temporalio/internal/bridge/api'
@@ -56,6 +57,7 @@ module Temporalio
                     :failure_converter, :cancellation, :continue_as_new_suggested, :current_history_length,
                     :current_history_size, :replaying, :random, :signal_handlers, :query_handlers, :update_handlers,
                     :context_frozen
+        attr_accessor :io_enabled, :current_details
 
         def initialize(details)
           # Initialize general state
@@ -66,6 +68,7 @@ module Temporalio
           @logger = ReplaySafeLogger.new(logger: details.logger, instance: self)
           @logger.scoped_values_getter = proc { scoped_logger_info }
           @runtime_metric_meter = details.metric_meter
+          @io_enabled = details.unsafe_workflow_io_enabled
           @scheduler = Scheduler.new(self)
           @payload_converter = details.payload_converter
           @failure_converter = details.failure_converter
@@ -115,6 +118,7 @@ module Temporalio
               continued_run_id: ProtoUtils.string_or(@init_job.continued_from_execution_run_id),
               cron_schedule: ProtoUtils.string_or(@init_job.cron_schedule),
               execution_timeout: ProtoUtils.duration_to_seconds(@init_job.workflow_execution_timeout),
+              headers: ProtoUtils.headers_from_proto_map(@init_job.headers, @payload_converter) || {},
               last_failure: if @init_job.continued_failure
                               @failure_converter.from_failure(@init_job.continued_failure, @payload_converter)
                             end,
@@ -130,6 +134,12 @@ module Temporalio
                         )
                       end,
               retry_policy: (RetryPolicy._from_proto(@init_job.retry_policy) if @init_job.retry_policy),
+              root: if @init_job.root_workflow
+                      Workflow::Info::RootInfo.new(
+                        run_id: @init_job.root_workflow.run_id,
+                        workflow_id: @init_job.root_workflow.workflow_id
+                      )
+                    end,
               run_id: details.initial_activation.run_id,
               run_timeout: ProtoUtils.duration_to_seconds(@init_job.workflow_run_timeout),
               start_time: ProtoUtils.timestamp_to_time(details.initial_activation.timestamp) || raise,
@@ -348,7 +358,10 @@ module Temporalio
         end
 
         def apply_signal(job)
-          defn = signal_handlers[job.signal_name] || signal_handlers[nil]
+          # Get signal definition, falling back to dynamic if not present and not reserved
+          defn = signal_handlers[job.signal_name]
+          defn = signal_handlers[nil] if !defn && !Internal::ProtoUtils.reserved_name?(job.signal_name)
+
           handler_exec =
             if defn
               HandlerExecution.new(name: job.signal_name, update_id: nil, unfinished_policy: defn.unfinished_policy)
@@ -381,37 +394,41 @@ module Temporalio
         end
 
         def apply_query(job)
-          # TODO(cretz): __temporal_workflow_metadata
-          defn = case job.query_type
-                 when '__stack_trace'
-                   Workflow::Definition::Query.new(
-                     name: '__stack_trace',
-                     to_invoke: proc { scheduler.stack_trace }
-                   )
-                 else
-                   query_handlers[job.query_type] || query_handlers[nil]
-                 end
           schedule do
-            unless defn
-              raise "Query handler for #{job.query_type} expected but not found, " \
-                    "known queries: [#{query_handlers.keys.compact.sort.join(', ')}]"
-            end
+            # If it's a built-in, run it without interceptors, otherwise do normal behavior
+            result = if job.query_type == '__stack_trace'
+                       # Use raw value built from default converter because we don't want to use user-conversion
+                       Converters::RawValue.new(Converters::PayloadConverter.default.to_payload(scheduler.stack_trace))
+                     elsif job.query_type == '__temporal_workflow_metadata'
+                       # Use raw value built from default converter because we don't want to use user-conversion
+                       Converters::RawValue.new(Converters::PayloadConverter.default.to_payload(workflow_metadata))
+                     else
+                       # Get query definition, falling back to dynamic if not present and not reserved
+                       defn = query_handlers[job.query_type]
+                       defn = query_handlers[nil] if !defn && !Internal::ProtoUtils.reserved_name?(job.query_type)
+
+                       unless defn
+                         raise "Query handler for #{job.query_type} expected but not found, " \
+                               "known queries: [#{query_handlers.keys.compact.sort.join(', ')}]"
+                       end
+
+                       with_context_frozen do
+                         @inbound.handle_query(
+                           Temporalio::Worker::Interceptor::Workflow::HandleQueryInput.new(
+                             id: job.query_id,
+                             query: job.query_type,
+                             args: begin
+                               convert_handler_args(payload_array: job.arguments, defn:)
+                             rescue StandardError => e
+                               raise "Failed converting query input arguments: #{e}"
+                             end,
+                             definition: defn,
+                             headers: ProtoUtils.headers_from_proto_map(job.headers, @payload_converter) || {}
+                           )
+                         )
+                       end
+                     end
 
-            result = with_context_frozen do
-              @inbound.handle_query(
-                Temporalio::Worker::Interceptor::Workflow::HandleQueryInput.new(
-                  id: job.query_id,
-                  query: job.query_type,
-                  args: begin
-                    convert_handler_args(payload_array: job.arguments, defn:)
-                  rescue StandardError => e
-                    raise "Failed converting query input arguments: #{e}"
-                  end,
-                  definition: defn,
-                  headers: ProtoUtils.headers_from_proto_map(job.headers, @payload_converter) || {}
-                )
-              )
-            end
             add_command(
               Bridge::Api::WorkflowCommands::WorkflowCommand.new(
                 respond_to_query: Bridge::Api::WorkflowCommands::QueryResult.new(
@@ -435,7 +452,10 @@ module Temporalio
         end
 
         def apply_update(job)
-          defn = update_handlers[job.name] || update_handlers[nil]
+          # Get update definition, falling back to dynamic if not present and not reserved
+          defn = update_handlers[job.name]
+          defn = update_handlers[nil] if !defn && !Internal::ProtoUtils.reserved_name?(job.name)
+
           handler_exec =
             (HandlerExecution.new(name: job.name, update_id: job.id, unfinished_policy: defn.unfinished_policy) if defn)
           schedule(handler_exec:) do
@@ -527,7 +547,7 @@ module Temporalio
           result = @inbound.execute(
             Temporalio::Worker::Interceptor::Workflow::ExecuteInput.new(
               args: @workflow_arguments,
-              headers: ProtoUtils.headers_from_proto_map(@init_job.headers, @payload_converter) || {}
+              headers: @info.headers
             )
           )
           add_command(
@@ -671,6 +691,30 @@ module Temporalio
           end
         end
 
+        def workflow_metadata
+          Temporalio::Api::Sdk::V1::WorkflowMetadata.new(
+            definition: Temporalio::Api::Sdk::V1::WorkflowDefinition.new(
+              type: info.workflow_type,
+              query_definitions: query_handlers.values.map do |defn|
+                Temporalio::Api::Sdk::V1::WorkflowInteractionDefinition.new(
+                  name: defn.name || '', description: defn.description || ''
+                )
+              end,
+              signal_definitions: signal_handlers.values.map do |defn|
+                Temporalio::Api::Sdk::V1::WorkflowInteractionDefinition.new(
+                  name: defn.name || '', description: defn.description || ''
+                )
+              end,
+              update_definitions: update_handlers.values.map do |defn|
+                Temporalio::Api::Sdk::V1::WorkflowInteractionDefinition.new(
+                  name: defn.name || '', description: defn.description || ''
+                )
+              end
+            ),
+            current_details: current_details || ''
+          )
+        end
+
         def scoped_logger_info
           @scoped_logger_info ||= {
             attempt: info.attempt,