temporalio 0.2.0 → 0.4.0

data/lib/temporalio/client/connection.rb

@@ -14,8 +14,7 @@ module Temporalio
     # Connection to Temporal server that is not namespace specific. Most users will use {Client.connect} instead of this
     # directly.
     class Connection
-      # Options as returned from {options} for +**to_h+ splat use in {initialize}. See {initialize} for details.
-      Options = Struct.new(
+      Options = Data.define(
         :target_host,
         :api_key,
         :tls,
@@ -25,8 +24,17 @@ module Temporalio
         :keep_alive,
         :http_connect_proxy,
         :runtime,
-        :lazy_connect,
-        keyword_init: true
+        :lazy_connect
+      )
+
+      # Options as returned from {options} for +**to_h+ splat use in {initialize}. See {initialize} for details.
+      class Options; end # rubocop:disable Lint/EmptyClass
+
+      TLSOptions = Data.define(
+        :client_cert,
+        :client_private_key,
+        :server_root_ca_cert,
+        :domain
       )
 
       # TLS options. All attributes are optional, and an empty options set just enables default TLS.
@@ -41,12 +49,24 @@ module Temporalio
       # @!attribute domain
       #   @return [String, nil] SNI override. This is only needed for self-hosted servers with certificates that do not
       #     match the hostname being connected to.
-      TLSOptions = Struct.new(
-        :client_cert,
-        :client_private_key,
-        :server_root_ca_cert,
-        :domain,
-        keyword_init: true
+      class TLSOptions
+        def initialize(
+          client_cert: nil,
+          client_private_key: nil,
+          server_root_ca_cert: nil,
+          domain: nil
+        )
+          super
+        end
+      end
+
+      RPCRetryOptions = Data.define(
+        :initial_interval,
+        :randomization_factor,
+        :multiplier,
+        :max_interval,
+        :max_elapsed_time,
+        :max_retries
       )
 
       # Retry options for server calls when retry is enabled (which it is by default on all high-level {Client} calls).
@@ -64,27 +84,24 @@ module Temporalio
       #   @return [Float] Maximum total time, default 10.0. Can use 0 for no max.
       # @!attribute max_retries
       #   @return [Integer] Maximum number of retries, default 10.
-      RPCRetryOptions = Struct.new(
-        :initial_interval,
-        :randomization_factor,
-        :multiplier,
-        :max_interval,
-        :max_elapsed_time,
-        :max_retries,
-        keyword_init: true
-      ) do
-        def initialize(**kwargs)
-          # @type var kwargs: untyped
-          kwargs[:initial_interval] = 0.1 unless kwargs.key?(:initial_interval)
-          kwargs[:randomization_factor] = 0.2 unless kwargs.key?(:randomization_factor)
-          kwargs[:multiplier] = 1.5 unless kwargs.key?(:multiplier)
-          kwargs[:max_interval] = 5.0 unless kwargs.key?(:max_interval)
-          kwargs[:max_elapsed_time] = 10.0 unless kwargs.key?(:max_elapsed_time)
-          kwargs[:max_retries] = 10 unless kwargs.key?(:max_retries)
+      class RPCRetryOptions
+        def initialize(
+          initial_interval: 0.1,
+          randomization_factor: 0.2,
+          multiplier: 1.5,
+          max_interval: 5.0,
+          max_elapsed_time: 10.0,
+          max_retries: 10
+        )
           super
         end
       end
 
+      KeepAliveOptions = Data.define(
+        :interval,
+        :timeout
+      )
+
       # Keep-alive options for client connections. For most users, the default is preferred.
       #
       # @!attribute interval
@@ -92,19 +109,18 @@ module Temporalio
       # @!attribute timeout
       #   @return [Float] Timeout that the keep alive must be responded to within or the connection will be closed,
       #     default 15.0.
-      KeepAliveOptions = Struct.new(
-        :interval,
-        :timeout,
-        keyword_init: true
-      ) do
-        def initialize(**kwargs)
-          # @type var kwargs: untyped
-          kwargs[:interval] = 30.0 unless kwargs.key?(:interval)
-          kwargs[:timeout] = 15.0 unless kwargs.key?(:timeout)
+      class KeepAliveOptions
+        def initialize(interval: 30.0, timeout: 15.0)
           super
         end
       end
 
+      HTTPConnectProxyOptions = Data.define(
+        :target_host,
+        :basic_auth_user,
+        :basic_auth_pass
+      )
+
       # Options for HTTP CONNECT proxy for client connections.
       #
       # @!attribute target_host
@@ -113,14 +129,11 @@ module Temporalio
       #   @return [String, nil] User for HTTP basic auth for the proxy, must be combined with {basic_auth_pass}.
       # @!attribute basic_auth_pass
       #   @return [String, nil] Pass for HTTP basic auth for the proxy, must be combined with {basic_auth_user}.
-      HTTPConnectProxyOptions = Struct.new(
-        :target_host,
-        :basic_auth_user, # Optional
-        :basic_auth_pass, # Optional,
-        keyword_init: true
-      )
+      class HTTPConnectProxyOptions; end # rubocop:disable Lint/EmptyClass
 
-      # @return [Options] Frozen options for this client which has the same attributes as {initialize}.
+      # @return [Options] Frozen options for this client which has the same attributes as {initialize}. Note that if
+      #   {api_key=} or {rpc_metadata=} are updated, the options object is replaced with those changes (it is not
+      #   mutated in place).
       attr_reader :options
 
       # @return [WorkflowService] Raw gRPC workflow service.
@@ -181,6 +194,7 @@ module Temporalio
           lazy_connect:
         ).freeze
         # Create core client now if not lazy
+        @core_client_mutex = Mutex.new
         _core_client unless lazy_connect
         # Create service instances
         @workflow_service = WorkflowService.new(self)
@@ -204,11 +218,43 @@ module Temporalio
         !@core_client.nil?
       end
 
+      # @return [String, nil] API key. This is a shortcut for `options.api_key`.
+      def api_key
+        @options.api_key
+      end
+
+      # Set the API key for all future calls. This also makes a new object for {options} with the changes.
+      #
+      # @param new_key [String, nil] New API key.
+      def api_key=(new_key)
+        # Mutate the client if connected then mutate options
+        @core_client_mutex.synchronize do
+          @core_client&.update_api_key(new_key)
+          @options = @options.with(api_key: new_key)
+        end
+      end
+
+      # @return [Hash<String, String>] RPC metadata (aka HTTP headers). This is a shortcut for `options.rpc_metadata`.
+      def rpc_metadata
+        @options.rpc_metadata
+      end
+
+      # Set the RPC metadata (aka HTTP headers) for all future calls. This also makes a new object for {options} with
+      # the changes.
+      #
+      # @param rpc_metadata [Hash<String, String>] New API key.
+      def rpc_metadata=(rpc_metadata)
+        # Mutate the client if connected then mutate options
+        @core_client_mutex.synchronize do
+          @core_client&.update_metadata(rpc_metadata)
+          @options = @options.with(rpc_metadata: rpc_metadata)
+        end
+      end
+
       # @!visibility private
       def _core_client
         # If lazy, this needs to be done under mutex
         if @options.lazy_connect
-          @core_client_mutex ||= Mutex.new
           @core_client_mutex.synchronize do
             @core_client ||= new_core_client
           end

data/lib/temporalio/client/interceptor.rb

@@ -18,11 +18,13 @@ module Temporalio
       end
 
       # Input for {Outbound.start_workflow}.
-      StartWorkflowInput = Struct.new(
+      StartWorkflowInput = Data.define(
         :workflow,
         :args,
         :workflow_id,
         :task_queue,
+        :static_summary,
+        :static_details,
         :execution_timeout,
         :run_timeout,
         :task_timeout,
@@ -35,75 +37,81 @@ module Temporalio
         :start_delay,
         :request_eager_start,
         :headers,
-        :rpc_metadata,
-        :rpc_timeout,
-        keyword_init: true
+        :rpc_options
+      )
+
+      # Input for {Outbound.start_update_with_start_workflow}.
+      StartUpdateWithStartWorkflowInput = Data.define(
+        :update_id,
+        :update,
+        :args,
+        :wait_for_stage,
+        :start_workflow_operation,
+        :headers,
+        :rpc_options
+      )
+
+      # Input for {Outbound.signal_with_start_workflow}.
+      SignalWithStartWorkflowInput = Data.define(
+        :signal,
+        :args,
+        :start_workflow_operation,
+        # Headers intentionally not defined here, because they are not separate from start_workflow_operation
+        :rpc_options
       )
 
       # Input for {Outbound.list_workflows}.
-      ListWorkflowsInput = Struct.new(
+      ListWorkflowsInput = Data.define(
         :query,
-        :rpc_metadata,
-        :rpc_timeout,
-        keyword_init: true
+        :rpc_options
       )
 
       # Input for {Outbound.count_workflows}.
-      CountWorkflowsInput = Struct.new(
+      CountWorkflowsInput = Data.define(
         :query,
-        :rpc_metadata,
-        :rpc_timeout,
-        keyword_init: true
+        :rpc_options
       )
 
       # Input for {Outbound.describe_workflow}.
-      DescribeWorkflowInput = Struct.new(
+      DescribeWorkflowInput = Data.define(
         :workflow_id,
         :run_id,
-        :rpc_metadata,
-        :rpc_timeout,
-        keyword_init: true
+        :rpc_options
       )
 
       # Input for {Outbound.fetch_workflow_history_events}.
-      FetchWorkflowHistoryEventsInput = Struct.new(
+      FetchWorkflowHistoryEventsInput = Data.define(
         :workflow_id,
         :run_id,
         :wait_new_event,
         :event_filter_type,
         :skip_archival,
-        :rpc_metadata,
-        :rpc_timeout,
-        keyword_init: true
+        :rpc_options
       )
 
       # Input for {Outbound.signal_workflow}.
-      SignalWorkflowInput = Struct.new(
+      SignalWorkflowInput = Data.define(
         :workflow_id,
         :run_id,
         :signal,
         :args,
         :headers,
-        :rpc_metadata,
-        :rpc_timeout,
-        keyword_init: true
+        :rpc_options
       )
 
       # Input for {Outbound.query_workflow}.
-      QueryWorkflowInput = Struct.new(
+      QueryWorkflowInput = Data.define(
         :workflow_id,
         :run_id,
         :query,
         :args,
         :reject_condition,
         :headers,
-        :rpc_metadata,
-        :rpc_timeout,
-        keyword_init: true
+        :rpc_options
       )
 
       # Input for {Outbound.start_workflow_update}.
-      StartWorkflowUpdateInput = Struct.new(
+      StartWorkflowUpdateInput = Data.define(
         :workflow_id,
         :run_id,
         :update_id,
@@ -111,78 +119,126 @@ module Temporalio
         :args,
         :wait_for_stage,
         :headers,
-        :rpc_metadata,
-        :rpc_timeout,
-        keyword_init: true
+        :rpc_options
       )
 
       # Input for {Outbound.poll_workflow_update}.
-      PollWorkflowUpdateInput = Struct.new(
+      PollWorkflowUpdateInput = Data.define(
         :workflow_id,
         :run_id,
         :update_id,
-        :rpc_metadata,
-        :rpc_timeout,
-        keyword_init: true
+        :rpc_options
       )
 
       # Input for {Outbound.cancel_workflow}.
-      CancelWorkflowInput = Struct.new(
+      CancelWorkflowInput = Data.define(
         :workflow_id,
         :run_id,
         :first_execution_run_id,
-        :rpc_metadata,
-        :rpc_timeout,
-        keyword_init: true
+        :rpc_options
       )
 
       # Input for {Outbound.terminate_workflow}.
-      TerminateWorkflowInput = Struct.new(
+      TerminateWorkflowInput = Data.define(
         :workflow_id,
         :run_id,
         :first_execution_run_id,
         :reason,
         :details,
-        :rpc_metadata,
-        :rpc_timeout,
-        keyword_init: true
+        :rpc_options
+      )
+
+      # Input for {Outbound.create_schedule}.
+      CreateScheduleInput = Data.define(
+        :id,
+        :schedule,
+        :trigger_immediately,
+        :backfills,
+        :memo,
+        :search_attributes,
+        :rpc_options
+      )
+
+      # Input for {Outbound.list_schedules}.
+      ListSchedulesInput = Data.define(
+        :query,
+        :rpc_options
+      )
+
+      # Input for {Outbound.backfill_schedule}.
+      BackfillScheduleInput = Data.define(
+        :id,
+        :backfills,
+        :rpc_options
+      )
+
+      # Input for {Outbound.delete_schedule}.
+      DeleteScheduleInput = Data.define(
+        :id,
+        :rpc_options
+      )
+
+      # Input for {Outbound.describe_schedule}.
+      DescribeScheduleInput = Data.define(
+        :id,
+        :rpc_options
+      )
+
+      # Input for {Outbound.pause_schedule}.
+      PauseScheduleInput = Data.define(
+        :id,
+        :note,
+        :rpc_options
+      )
+
+      # Input for {Outbound.trigger_schedule}.
+      TriggerScheduleInput = Data.define(
+        :id,
+        :overlap,
+        :rpc_options
+      )
+
+      # Input for {Outbound.unpause_schedule}.
+      UnpauseScheduleInput = Data.define(
+        :id,
+        :note,
+        :rpc_options
+      )
+
+      # Input for {Outbound.update_schedule}.
+      UpdateScheduleInput = Data.define(
+        :id,
+        :updater,
+        :rpc_options
       )
 
       # Input for {Outbound.heartbeat_async_activity}.
-      HeartbeatAsyncActivityInput = Struct.new(
+      HeartbeatAsyncActivityInput = Data.define(
         :task_token_or_id_reference,
         :details,
-        :rpc_metadata,
-        :rpc_timeout,
-        keyword_init: true
+        :rpc_options
       )
 
       # Input for {Outbound.complete_async_activity}.
-      CompleteAsyncActivityInput = Struct.new(
+      CompleteAsyncActivityInput = Data.define(
         :task_token_or_id_reference,
         :result,
-        :rpc_metadata,
-        :rpc_timeout,
-        keyword_init: true
+        :rpc_options
       )
 
       # Input for {Outbound.fail_async_activity}.
-      FailAsyncActivityInput = Struct.new(
+      FailAsyncActivityInput = Data.define(
         :task_token_or_id_reference,
         :error,
         :last_heartbeat_details,
-        :rpc_metadata,
-        :rpc_timeout,
-        keyword_init: true
+        :rpc_options
       )
 
       # Input for {Outbound.report_cancellation_async_activity}.
-      ReportCancellationAsyncActivityInput = Struct.new(
+      ReportCancellationAsyncActivityInput = Data.define(
         :task_token_or_id_reference,
         :details,
-        :rpc_metadata,
-        :rpc_timeout,
-        keyword_init: true
+        :rpc_options
       )
 
       # Outbound interceptor for intercepting client calls. This should be extended by users needing to intercept client
@@ -206,6 +262,23 @@ module Temporalio
           next_interceptor.start_workflow(input)
         end
 
+        # Called for every {Client.start_update_with_start_workflow} and {Client.execute_update_with_start_workflow}
+        # call.
+        #
+        # @param input [StartUpdateWithStartWorkflowInput] Input.
+        # @return [WorkflowUpdateHandle] Workflow update handle.
+        def start_update_with_start_workflow(input)
+          next_interceptor.start_update_with_start_workflow(input)
+        end
+
+        # Called for every {Client.signal_with_start_workflow}.
+        #
+        # @param input [SignalWithStartWorkflowInput] Input.
+        # @return [WorkflowHandle] Workflow handle.
+        def signal_with_start_workflow(input)
+          next_interceptor.signal_with_start_workflow(input)
+        end
+
         # Called for every {Client.list_workflows} call.
         #
         # @param input [ListWorkflowsInput] Input.
@@ -283,6 +356,72 @@ module Temporalio
           next_interceptor.terminate_workflow(input)
         end
 
+        # Called for every {Client.create_schedule} call.
+        #
+        # @param input [CreateScheduleInput] Input.
+        # @return [ScheduleHandle] Schedule handle.
+        def create_schedule(input)
+          next_interceptor.create_schedule(input)
+        end
+
+        # Called for every {Client.list_schedules} call.
+        #
+        # @param input [ListSchedulesInput] Input.
+        # @return [Enumerator<Schedule::List::Description>] Enumerable schedules.
+        def list_schedules(input)
+          next_interceptor.list_schedules(input)
+        end
+
+        # Called for every {ScheduleHandle.backfill} call.
+        #
+        # @param input [BackfillScheduleInput] Input.
+        def backfill_schedule(input)
+          next_interceptor.backfill_schedule(input)
+        end
+
+        # Called for every {ScheduleHandle.delete} call.
+        #
+        # @param input [DeleteScheduleInput] Input.
+        def delete_schedule(input)
+          next_interceptor.delete_schedule(input)
+        end
+
+        # Called for every {ScheduleHandle.describe} call.
+        #
+        # @param input [DescribeScheduleInput] Input.
+        # @return [Schedule::Description] Schedule description.
+        def describe_schedule(input)
+          next_interceptor.describe_schedule(input)
+        end
+
+        # Called for every {ScheduleHandle.pause} call.
+        #
+        # @param input [PauseScheduleInput] Input.
+        def pause_schedule(input)
+          next_interceptor.pause_schedule(input)
+        end
+
+        # Called for every {ScheduleHandle.trigger} call.
+        #
+        # @param input [TriggerScheduleInput] Input.
+        def trigger_schedule(input)
+          next_interceptor.trigger_schedule(input)
+        end
+
+        # Called for every {ScheduleHandle.unpause} call.
+        #
+        # @param input [UnpauseScheduleInput] Input.
+        def unpause_schedule(input)
+          next_interceptor.unpause_schedule(input)
+        end
+
+        # Called for every {ScheduleHandle.update} call.
+        #
+        # @param input [UpdateScheduleInput] Input.
+        def update_schedule(input)
+          next_interceptor.update_schedule(input)
+        end
+
         # Called for every {AsyncActivityHandle.heartbeat} call.
         #
         # @param input [HeartbeatAsyncActivityInput] Input.