temporalio 0.4.0-aarch64-linux-musl

data/lib/temporalio/client/schedule_handle.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'temporalio/client/interceptor'
+require 'temporalio/client/schedule'
+
+module Temporalio
+  class Client
+    # Handle for interacting with a schedule. This is usually created via {Client.create_schedule} or
+    # {Client.schedule_handle}.
+    class ScheduleHandle
+      # @return [String] ID of the schedule.
+      attr_reader :id
+
+      # @!visibility private
+      def initialize(client:, id:)
+        @client = client
+        @id = id
+      end
+
+      # Backfill the schedule by going through the specified time periods as if they passed right now.
+      #
+      # @param backfills [Array<Schedule::Backfill>] Backfill periods.
+      # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+      #
+      # @raise [Error::RPCError] RPC error from call.
+      def backfill(
+        *backfills,
+        rpc_options: nil
+      )
+        raise ArgumentError, 'At least one backfill required' if backfills.empty?
+
+        @client._impl.backfill_schedule(Interceptor::BackfillScheduleInput.new(
+                                          id:,
+                                          backfills:,
+                                          rpc_options:
+                                        ))
+      end
+
+      # Delete this schedule.
+      #
+      # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+      #
+      # @raise [Error::RPCError] RPC error from call.
+      def delete(rpc_options: nil)
+        @client._impl.delete_schedule(Interceptor::DeleteScheduleInput.new(
+                                        id:,
+                                        rpc_options:
+                                      ))
+      end
+
+      # Fetch this schedule's description.
+      #
+      # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+      #
+      # @return [Schedule::Description] Schedule description.
+      # @raise [Error::RPCError] RPC error from call.
+      def describe(rpc_options: nil)
+        @client._impl.describe_schedule(Interceptor::DescribeScheduleInput.new(
+                                          id:,
+                                          rpc_options:
+                                        ))
+      end
+
+      # Pause the schedule and set a note.
+      #
+      # @param note [String] Note to set on the schedule.
+      # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+      #
+      # @raise [Error::RPCError] RPC error from call.
+      def pause(note: 'Paused via Ruby SDK', rpc_options: nil)
+        @client._impl.pause_schedule(Interceptor::PauseScheduleInput.new(
+                                       id:,
+                                       note:,
+                                       rpc_options:
+                                     ))
+      end
+
+      # Trigger an action on this schedule to happen immediately.
+      #
+      # @param overlap [Schedule::OverlapPolicy, nil] If set, overrides the schedule's overlap policy.
+      # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+      #
+      # @raise [Error::RPCError] RPC error from call.
+      def trigger(overlap: nil, rpc_options: nil)
+        @client._impl.trigger_schedule(Interceptor::TriggerScheduleInput.new(
+                                         id:,
+                                         overlap:,
+                                         rpc_options:
+                                       ))
+      end
+
+      # Unpause the schedule and set a note.
+      #
+      # @param note [String] Note to set on the schedule.
+      # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+      #
+      # @raise [Error::RPCError] RPC error from call.
+      def unpause(note: 'Unpaused via Ruby SDK', rpc_options: nil)
+        @client._impl.unpause_schedule(Interceptor::UnpauseScheduleInput.new(
+                                         id:,
+                                         note:,
+                                         rpc_options:
+                                       ))
+      end
+
+      # Update a schedule using a callback to build the update from the description.
+      #
+      # NOTE: In future versions, the callback may be invoked multiple times in a conflict-resolution loop.
+      #
+      # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+      # @yield Block called to obtain the update.
+      # @yieldparam [Schedule::Update::Input] Parameter to the block that contains a description with the schedule to be
+      #   updated.
+      # @yieldreturn [Schedule::Update, nil] The update to apply, or `nil` to not perform an update.
+      #
+      # @raise [Error::RPCError] RPC error from call.
+      def update(rpc_options: nil, &updater)
+        @client._impl.update_schedule(Interceptor::UpdateScheduleInput.new(
+                                        id:,
+                                        updater:,
+                                        rpc_options:
+                                      ))
+      end
+    end
+  end
+end

data/lib/temporalio/client/with_start_workflow_operation.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'temporalio/common_enums'
+
+module Temporalio
+  class Client
+    # Start operation used by {Client.start_update_with_start_workflow}, {Client.execute_update_with_start_workflow},
+    # and {Client.signal_with_start_workflow}.
+    class WithStartWorkflowOperation
+      Options = Data.define(
+        :workflow,
+        :args,
+        :id,
+        :task_queue,
+        :static_summary,
+        :static_details,
+        :execution_timeout,
+        :run_timeout,
+        :task_timeout,
+        :id_reuse_policy,
+        :id_conflict_policy,
+        :retry_policy,
+        :cron_schedule,
+        :memo,
+        :search_attributes,
+        :start_delay,
+        :headers
+      )
+
+      # Options the operation was created with.
+      class Options; end # rubocop:disable Lint/EmptyClass
+
+      # @return [Options] Options the operation was created with.
+      attr_accessor :options
+
+      # Create a with-start workflow operation. These are mostly the same options as {Client.start_workflow}, see that
+      # documentation for more details.
+      #
+      # Note, for {Client.start_update_with_start_workflow} and {Client.execute_update_with_start_workflow},
+      # `id_conflict_policy` is required.
+      def initialize(
+        workflow,
+        *args,
+        id:,
+        task_queue:,
+        static_summary: nil,
+        static_details: nil,
+        execution_timeout: nil,
+        run_timeout: nil,
+        task_timeout: nil,
+        id_reuse_policy: WorkflowIDReusePolicy::ALLOW_DUPLICATE,
+        id_conflict_policy: WorkflowIDConflictPolicy::UNSPECIFIED,
+        retry_policy: nil,
+        cron_schedule: nil,
+        memo: nil,
+        search_attributes: nil,
+        start_delay: nil,
+        headers: {}
+      )
+        @options = Options.new(
+          workflow: Workflow::Definition._workflow_type_from_workflow_parameter(workflow),
+          args:,
+          id:,
+          task_queue:,
+          static_summary:,
+          static_details:,
+          execution_timeout:,
+          run_timeout:,
+          task_timeout:,
+          id_reuse_policy:,
+          id_conflict_policy:,
+          retry_policy:,
+          cron_schedule:,
+          memo:,
+          search_attributes:,
+          start_delay:,
+          headers:
+        )
+        @workflow_handle_mutex = Mutex.new
+        @workflow_handle_cond_var = ConditionVariable.new
+      end
+
+      # Get the workflow handle, possibly waiting until set, or raise an error if the workflow start was unsuccessful.
+      #
+      # @param wait [Boolean] True to wait until it is set, false to return immediately.
+      #
+      # @return [WorkflowHandle, nil] The workflow handle when available or `nil` if `wait` is false and it is not set
+      #   yet.
+      # @raise [Error] Any error that occurred during the call before the workflow start returned.
+      def workflow_handle(wait: true)
+        @workflow_handle_mutex.synchronize do
+          @workflow_handle_cond_var.wait(@workflow_handle_mutex) unless @workflow_handle || !wait
+          raise @workflow_handle if @workflow_handle.is_a?(Exception)
+
+          @workflow_handle
+        end
+      end
+
+      # @!visibility private
+      def _set_workflow_handle(value)
+        @workflow_handle_mutex.synchronize do
+          @workflow_handle ||= value
+          @workflow_handle_cond_var.broadcast
+        end
+      end
+
+      # @!visibility private
+      def _mark_used
+        raise 'Start operation already used' if @in_use
+
+        @in_use = true
+      end
+    end
+  end
+end

data/lib/temporalio/client/workflow_execution.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'temporalio/api'
+require 'temporalio/client/workflow_execution_status'
+require 'temporalio/internal/proto_utils'
+require 'temporalio/search_attributes'
+
+module Temporalio
+  class Client
+    # Info for a single workflow execution run.
+    class WorkflowExecution
+      # @return [Api::Workflow::V1::WorkflowExecutionInfo] Underlying protobuf info.
+      attr_reader :raw_info
+
+      # @!visibility private
+      def initialize(raw_info, data_converter)
+        @raw_info = raw_info
+        @memo = Internal::ProtoUtils::LazyMemo.new(raw_info.memo, data_converter)
+        @search_attributes = Internal::ProtoUtils::LazySearchAttributes.new(raw_info.search_attributes)
+      end
+
+      # @return [Time, nil] When the workflow was closed if closed.
+      def close_time
+        Internal::ProtoUtils.timestamp_to_time(@raw_info.close_time)
+      end
+
+      # @return [Time, nil] When this workflow run started or should start.
+      def execution_time
+        Internal::ProtoUtils.timestamp_to_time(@raw_info.execution_time)
+      end
+
+      # @return [Integer] Number of events in the history.
+      def history_length
+        @raw_info.history_length
+      end
+
+      # @return [String] ID for the workflow.
+      def id
+        @raw_info.execution.workflow_id
+      end
+
+      # @return [Hash<String, Object>, nil] Memo for the workflow.
+      def memo
+        @memo.get
+      end
+
+      # @return [String, nil] ID for the parent workflow if this was started as a child.
+      def parent_id
+        @raw_info.parent_execution&.workflow_id
+      end
+
+      # @return [String, nil] Run ID for the parent workflow if this was started as a child.
+      def parent_run_id
+        @raw_info.parent_execution&.run_id
+      end
+
+      # @return [String] Run ID for this workflow run.
+      def run_id
+        @raw_info.execution.run_id
+      end
+
+      # @return [SearchAttributes, nil] Current set of search attributes if any.
+      def search_attributes
+        @search_attributes.get
+      end
+
+      # @return [Time] When the workflow was created.
+      def start_time
+        Internal::ProtoUtils.timestamp_to_time(@raw_info.start_time) || raise # Never nil
+      end
+
+      # @return [WorkflowExecutionStatus] Status for the workflow.
+      def status
+        Internal::ProtoUtils.enum_to_int(Api::Enums::V1::WorkflowExecutionStatus, @raw_info.status)
+      end
+
+      # @return [String] Task queue for the workflow.
+      def task_queue
+        @raw_info.task_queue
+      end
+
+      # @return [String] Type name for the workflow.
+      def workflow_type
+        @raw_info.type.name
+      end
+
+      # Description for a single workflow execution run.
+      class Description < WorkflowExecution
+        # @return [Api::WorkflowService::V1::DescribeWorkflowExecutionResponse] Underlying protobuf description.
+        attr_reader :raw_description
+
+        # @!visibility private
+        def initialize(raw_description, data_converter)
+          super(raw_description.workflow_execution_info, data_converter)
+          @raw_description = raw_description
+          @data_converter = data_converter
+        end
+
+        # @return [String, nil] Static summary configured on the workflow. This is currently experimental.
+        def static_summary
+          user_metadata.first
+        end
+
+        # @return [String, nil] Static details configured on the workflow. This is currently experimental.
+        def static_details
+          user_metadata.last
+        end
+
+        private
+
+        def user_metadata
+          @user_metadata ||= Internal::ProtoUtils.from_user_metadata(
+            @raw_description.execution_config&.user_metadata, @data_converter
+          )
+        end
+      end
+    end
+  end
+end

data/lib/temporalio/client/workflow_execution_count.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Temporalio
+  class Client
+    # Representation of a count from a count workflows call.
+    class WorkflowExecutionCount
+      # @return [Integer] Approximate number of workflows matching the original query. If the query had a group-by
+      # clause, this is simply the sum of all the counts in {groups}.
+      attr_reader :count
+
+      # @return [Array<AggregationGroup>] Groups if the query had a group-by clause, or empty if not.
+      attr_reader :groups
+
+      # @!visibility private
+      def initialize(count, groups)
+        @count = count
+        @groups = groups
+      end
+
+      # Aggregation group if the workflow count query had a group-by clause.
+      class AggregationGroup
+        # @return [Integer] Approximate number of workflows matching the original query for this group.
+        attr_reader :count
+
+        # @return [Array<Object>] Search attribute values for this group.
+        attr_reader :group_values
+
+        # @!visibility private
+        def initialize(count, group_values)
+          @count = count
+          @group_values = group_values
+        end
+      end
+    end
+  end
+end

data/lib/temporalio/client/workflow_execution_status.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'temporalio/api'
+
+module Temporalio
+  class Client
+    # Status of a workflow execution.
+    module WorkflowExecutionStatus
+      RUNNING = Api::Enums::V1::WorkflowExecutionStatus::WORKFLOW_EXECUTION_STATUS_RUNNING
+      COMPLETED = Api::Enums::V1::WorkflowExecutionStatus::WORKFLOW_EXECUTION_STATUS_COMPLETED
+      FAILED = Api::Enums::V1::WorkflowExecutionStatus::WORKFLOW_EXECUTION_STATUS_FAILED
+      CANCELED = Api::Enums::V1::WorkflowExecutionStatus::WORKFLOW_EXECUTION_STATUS_CANCELED
+      TERMINATED = Api::Enums::V1::WorkflowExecutionStatus::WORKFLOW_EXECUTION_STATUS_TERMINATED
+      CONTINUED_AS_NEW = Api::Enums::V1::WorkflowExecutionStatus::WORKFLOW_EXECUTION_STATUS_CONTINUED_AS_NEW
+      TIMED_OUT = Api::Enums::V1::WorkflowExecutionStatus::WORKFLOW_EXECUTION_STATUS_TIMED_OUT
+    end
+  end
+end