temporalio 0.3.0-aarch64-linux → 0.5.0-aarch64-linux

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'temporalio/worker/illegal_workflow_call_validator'
 require 'temporalio/workflow'
 
 module Temporalio
@@ -12,16 +13,32 @@ module Temporalio
             illegal_calls.to_h do |key, val|
               raise TypeError, 'Invalid illegal call map, top-level key must be a String' unless key.is_a?(String)
 
-              # @type var fixed_val: :all | Hash[Symbol, bool]
+              # @type var fixed_val: :all | Worker::IllegalWorkflowCallValidator | Hash[Symbol, TrueClass | Worker::IllegalWorkflowCallValidator] # rubocop:disable Layout/LineLength
               fixed_val = case val
+                          when Temporalio::Worker::IllegalWorkflowCallValidator
+                            if sub_val.method_name
+                              raise ArgumentError,
+                                    'Top level IllegalWorkflowCallValidator instances cannot have method name'
+                            end
+                            val
                           when Array
                             val.to_h do |sub_val|
-                              unless sub_val.is_a?(Symbol)
+                              case sub_val
+                              when Symbol
+                                [sub_val, true]
+                              when Temporalio::Worker::IllegalWorkflowCallValidator
+                                unless sub_val.method_name
+                                  raise ArgumentError,
+                                        'IllegalWorkflowCallValidator instances in array for ' \
+                                        "#{key} must have a method name"
+                                end
+
+                                [sub_val.method_name, sub_val]
+                              else
                                 raise TypeError,
-                                      'Invalid illegal call map, each value must be a Symbol'
+                                      'Invalid illegal call array entry for ' \
+                                      "#{key}, each value must be a Symbol or an IllegalWorkflowCallValidator"
                               end
-
-                              [sub_val, true]
                             end.freeze
                           when :all
                             :all
@@ -47,25 +64,54 @@ module Temporalio
               # class of things like `Date` does not have `attached_object` so you have to fall back in these rare cases
               # to parsing the string output. Reaching the string parsing component is rare, so this should not have
               # significant performance impact.
-              cls_name = if cls.singleton_class?
-                           if cls.respond_to?(:attached_object)
-                             cls = cls.attached_object # steep:ignore
-                             next unless cls.is_a?(Module)
+              class_name = if cls.singleton_class?
+                             if cls.respond_to?(:attached_object)
+                               cls = cls.attached_object # steep:ignore
+                               next unless cls.is_a?(Module)
 
-                             cls.name.to_s
+                               cls.name.to_s
+                             else
+                               cls.to_s.delete_prefix('#<Class:').delete_suffix('>')
+                             end
                            else
-                             cls.to_s.delete_prefix('#<Class:').delete_suffix('>')
+                             cls.name.to_s
                            end
-                         else
-                           cls.name.to_s
-                         end
 
               # Check if the call is considered illegal
-              vals = illegal_calls[cls_name]
-              if vals == :all || vals&.[](tp.callee_id) # steep:ignore
+              vals = illegal_calls[class_name]
+              invalid_suffix =
+                case vals
+                when :all
+                  ''
+                when Temporalio::Worker::IllegalWorkflowCallValidator
+                  disable do
+                    vals.block.call(Temporalio::Worker::IllegalWorkflowCallValidator::CallInfo.new(
+                                      class_name:, method_name: tp.callee_id, trace_point: tp
+                                    ))
+                    nil
+                  rescue Exception => e # rubocop:disable Lint/RescueException
+                    ", reason: #{e}"
+                  end
+                else
+                  per_method = vals&.[](tp.callee_id)
+                  case per_method
+                  when true
+                    ''
+                  when Temporalio::Worker::IllegalWorkflowCallValidator
+                    disable do
+                      per_method.block.call(Temporalio::Worker::IllegalWorkflowCallValidator::CallInfo.new(
+                                              class_name:, method_name: tp.callee_id, trace_point: tp
+                                            ))
+                      nil
+                    rescue Exception => e # rubocop:disable Lint/RescueException
+                      ", reason: #{e}"
+                    end
+                  end
+                end
+              if invalid_suffix
                 raise Workflow::NondeterminismError,
-                      "Cannot access #{cls_name} #{tp.callee_id} from inside a " \
-                      'workflow. If this is known to be safe, the code can be run in ' \
+                      "Cannot access #{class_name} #{tp.callee_id} from inside a " \
+                      "workflow#{invalid_suffix}. If this is known to be safe, the code can be run in " \
                       'a Temporalio::Workflow::Unsafe.illegal_call_tracing_disabled block.'
               end
             end

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

@@ -56,35 +56,30 @@ 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
+            execute_activity_with_local_backoffs(local: false, cancellation: input.cancellation,
+                                                 result_hint: input.result_hint) do
               seq = (@activity_counter += 1)
               @instance.add_command(
                 Bridge::Api::WorkflowCommands::WorkflowCommand.new(
                   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),
+                    arguments: ProtoUtils.convert_to_payload_array(
+                      @instance.payload_converter, input.args, hints: input.arg_hints
+                    ),
                     schedule_to_close_timeout: ProtoUtils.seconds_to_duration(input.schedule_to_close_timeout),
                     schedule_to_start_timeout: ProtoUtils.seconds_to_duration(input.schedule_to_start_timeout),
                     start_to_close_timeout: ProtoUtils.seconds_to_duration(input.start_to_close_timeout),
                     heartbeat_timeout: ProtoUtils.seconds_to_duration(input.heartbeat_timeout),
                     retry_policy: input.retry_policy&._to_proto,
                     cancellation_type: input.cancellation_type,
-                    do_not_eagerly_execute: input.disable_eager_execution
-                  )
+                    do_not_eagerly_execute: input.disable_eager_execution,
+                    priority: input.priority._to_proto
+                  ),
+                  user_metadata: ProtoUtils.to_user_metadata(input.summary, nil, @instance.payload_converter)
                 )
               )
               seq
@@ -96,26 +91,21 @@ 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|
+            @instance.assert_valid_local_activity.call(input.activity)
+
+            execute_activity_with_local_backoffs(local: true, cancellation: input.cancellation,
+                                                 result_hint: input.result_hint) do |do_backoff|
               seq = (@activity_counter += 1)
               @instance.add_command(
                 Bridge::Api::WorkflowCommands::WorkflowCommand.new(
                   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),
+                    arguments: ProtoUtils.convert_to_payload_array(
+                      @instance.payload_converter, input.args, hints: input.arg_hints
+                    ),
                     schedule_to_close_timeout: ProtoUtils.seconds_to_duration(input.schedule_to_close_timeout),
                     schedule_to_start_timeout: ProtoUtils.seconds_to_duration(input.schedule_to_start_timeout),
                     start_to_close_timeout: ProtoUtils.seconds_to_duration(input.start_to_close_timeout),
@@ -131,7 +121,7 @@ module Temporalio
             end
           end
 
-          def execute_activity_with_local_backoffs(local:, cancellation:, &)
+          def execute_activity_with_local_backoffs(local:, cancellation:, result_hint:, &)
             # We do not even want to schedule if the cancellation is already cancelled. We choose to use canceled
             # failure instead of wrapping in activity failure which is similar to what other SDKs do, with the accepted
             # tradeoff that it makes rescue more difficult (hence the presence of Error.canceled? helper).
@@ -140,7 +130,7 @@ module Temporalio
             # This has to be done in a loop for local activity backoff
             last_local_backoff = nil
             loop do
-              result = execute_activity_once(local:, cancellation:, last_local_backoff:, &)
+              result = execute_activity_once(local:, cancellation:, last_local_backoff:, result_hint:, &)
               return result unless result.is_a?(Bridge::Api::ActivityResult::DoBackoff)
 
               # @type var result: untyped
@@ -152,7 +142,7 @@ module Temporalio
           end
 
           # If this doesn't raise, it returns success | DoBackoff
-          def execute_activity_once(local:, cancellation:, last_local_backoff:, &)
+          def execute_activity_once(local:, cancellation:, last_local_backoff:, result_hint:, &)
             # Add to pending activities (removed by the resolver)
             seq = yield last_local_backoff
             @instance.pending_activities[seq] = Fiber.current
@@ -185,7 +175,7 @@ module Temporalio
 
             case resolution.status
             when :completed
-              @instance.payload_converter.from_payload(resolution.completed.result)
+              @instance.payload_converter.from_payload(resolution.completed.result, hint: result_hint)
             when :failed
               raise @instance.failure_converter.from_failure(resolution.failed.failure, @instance.payload_converter)
             when :cancelled
@@ -209,6 +199,7 @@ module Temporalio
               signal: input.signal,
               args: input.args,
               cancellation: input.cancellation,
+              arg_hints: input.arg_hints,
               headers: input.headers
             )
           end
@@ -221,19 +212,20 @@ module Temporalio
               signal: input.signal,
               args: input.args,
               cancellation: input.cancellation,
+              arg_hints: input.arg_hints,
               headers: input.headers
             )
           end
 
-          def _signal_external_workflow(id:, run_id:, child:, signal:, args:, cancellation:, headers:)
+          def _signal_external_workflow(id:, run_id:, child:, signal:, args:, cancellation:, arg_hints:, headers:)
             raise Error::CanceledError, 'Signal canceled before scheduled' if cancellation.canceled?
 
             # Add command
             seq = (@external_signal_counter += 1)
             cmd = Bridge::Api::WorkflowCommands::SignalExternalWorkflowExecution.new(
               seq:,
-              signal_name: Workflow::Definition::Signal._name_from_parameter(signal),
-              args: ProtoUtils.convert_to_payload_array(@instance.payload_converter, args),
+              signal_name: signal,
+              args: ProtoUtils.convert_to_payload_array(@instance.payload_converter, args, hints: arg_hints),
               headers: ProtoUtils.headers_to_proto_hash(headers, @instance.payload_converter)
             )
             if child
@@ -300,7 +292,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,9 +333,10 @@ 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),
+                  input: ProtoUtils.convert_to_payload_array(@instance.payload_converter, input.args,
+                                                             hints: input.arg_hints),
                   workflow_execution_timeout: ProtoUtils.seconds_to_duration(input.execution_timeout),
                   workflow_run_timeout: ProtoUtils.seconds_to_duration(input.run_timeout),
                   workflow_task_timeout: ProtoUtils.seconds_to_duration(input.task_timeout),
@@ -353,7 +347,11 @@ module Temporalio
                   headers: ProtoUtils.headers_to_proto_hash(input.headers, @instance.payload_converter),
                   memo: ProtoUtils.memo_to_proto_hash(input.memo, @instance.payload_converter),
                   search_attributes: input.search_attributes&._to_proto_hash,
-                  cancellation_type: input.cancellation_type
+                  cancellation_type: input.cancellation_type,
+                  priority: input.priority._to_proto
+                ),
+                user_metadata: ProtoUtils.to_user_metadata(
+                  input.static_summary, input.static_details, @instance.payload_converter
                 )
               )
             )
@@ -385,7 +383,8 @@ module Temporalio
                 first_execution_run_id: resolution.succeeded.run_id,
                 instance: @instance,
                 cancellation: input.cancellation,
-                cancel_callback_key:
+                cancel_callback_key:,
+                result_hint: input.result_hint
               )
               @instance.pending_child_workflows[seq] = handle
               handle

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)