mirror of
https://github.com/hanzoai/tasks.git
synced 2026-11-02 12:22:18 +00:00
d8af9436cc
## What changed? This PR adds a new `GetTaskQueueUserData` RPC to the admin service. Given a namespace, task queue name, task queue type, and optional partition ID (default is 0, which is `root`), it returns the user data currently loaded by that partition. This PR wraps the existing `GetTaskQueueUserData` RPC in Matching Service. We will also create a `tdbg` command which calls this Admin Service RPC, in a separate PR. ## Why? Each task queue family has associated metadata, stored in [TaskQueueUserData](https://github.com/temporalio/temporal/blob/main/proto/internal/temporal/server/api/persistence/v1/task_queues.proto). Metadata related to worker versioning, queue rate limiting, fairness are all stored in `TaskQueueUserData`. TaskQueueUserData is replicated from the root partition to all other partitions. However, there is no admin-accessible way to read the user data loaded by a specific partition or compare versions across partitions to diagnose replication lag. ## Files changed | File | Change | |---|---| | `proto/internal/.../adminservice/v1/request_response.proto` | Added `GetTaskQueueUserDataRequest` and `GetTaskQueueUserDataResponse` messages | | `proto/internal/.../adminservice/v1/service.proto` | Added `GetTaskQueueUserData` RPC to `AdminService` | | `service/frontend/admin_handler.go` | Implemented `AdminHandler.GetTaskQueueUserData`: validates request, resolves namespace → ID, builds partition RPC name via `tqid`, calls matching service, returns per-type entry + version | | `service/frontend/admin_handler_test.go` | Added unit tests | ## How did you test it? - [x] built - [x] run locally and tested manually - [x] added new unit test(s) - [x] added new integration test(s) - not applicable, not touching persistence layer - [x] added new functional test(s) ### Unit tests 100% unit test coverage | Test case | Input | Expected | |---|---|---| | Nil request | `request == nil` | `errRequestNotSet` | | Empty namespace | `namespace == ""` | `errNamespaceNotSet` | | Namespace not found | Namespace registry returns not-found | Error propagated; matching never called | | Invalid task queue name | `task_queue` starts with `/_sys/` | `INVALID_ARGUMENT` from `tqid.NewTaskQueueFamily`; matching never called | | Root partition | `partition_id=0`, workflow type | Sends bare name `my-queue` to matching; returns correct `user_data` and `version` | | Non-root partition | `partition_id=1`, workflow type | Sends mangled name `/_sys/my-queue/1` to matching | | No per-type data | Matching returns response with empty `per_type` map | `user_data` is nil; `version` still populated | | Matching error | Matching client returns error | Error propagated to caller | ### Functional tests | Test | Setup | What it verifies | |------------------------------------------------|--------------------------------|----------------------------------------------------------------------------------| | TestAdminGetTaskQueueUserData_RootPartition | Write fairness weight config to a workflow task queue | Admin RPC resolves namespace by name, routes to root partition (partition_id=0), returns version > 0 and non-nil per-type data | | TestAdminGetTaskQueueUserData_NonRootPartition | Same write, then poll until non-root partition replicates | Admin RPC routes to a non-root partition (partition_id=1) via mangled name, returns the same version as root after replication | ### Manual tests <details> <summary>Setup</summary> 1. Build and start the server: `make temporal-server && make start-sqlite` 2. Create namespace: `temporal operator namespace create default` 3. Insert assignment rule: `temporal task-queue versioning insert-assignment-rule` </details> <details> <summary>Case 1 — Root partition, workflow type</summary> ``` grpcurl -plaintext \ -d '{"namespace":"default","task_queue":"my-queue","task_queue_type":"TASK_QUEUE_TYPE_WORKFLOW"}' \ localhost:7233 \ temporal.server.api.adminservice.v1.AdminService/GetTaskQueueUserData ``` ```json { "version": "1" } ``` </details> <details> <summary>Case 2 — Root partition, activity type</summary> ``` grpcurl -plaintext \ -d '{"namespace":"default","task_queue":"my-queue","task_queue_type":"TASK_QUEUE_TYPE_ACTIVITY"}' \ localhost:7233 \ temporal.server.api.adminservice.v1.AdminService/GetTaskQueueUserData ``` ```json { "version": "1" } ``` </details> <details> <summary>Case 3 — Non-root partition, workflow type</summary> ``` grpcurl -plaintext \ -d '{"namespace":"default","task_queue":"my-queue","task_queue_type":"TASK_QUEUE_TYPE_WORKFLOW","partition_id":1}' \ localhost:7233 \ temporal.server.api.adminservice.v1.AdminService/GetTaskQueueUserData ``` ```json { "version": "1" } ``` </details> <details> <summary>Case 4 — Non-root partition, activity type</summary> ``` grpcurl -plaintext \ -d '{"namespace":"default","task_queue":"my-queue","task_queue_type":"TASK_QUEUE_TYPE_ACTIVITY","partition_id":1}' \ localhost:7233 \ temporal.server.api.adminservice.v1.AdminService/GetTaskQueueUserData ``` ```json { "version": "1" } ``` </details> <details> <summary>Case 5 — Non-root partition, activity type, with user data</summary> Setup: Add rate limit config ``` grpcurl -plaintext \ -d '{ "namespace": "default", "task_queue": "my-queue", "task_queue_type": "TASK_QUEUE_TYPE_ACTIVITY", "update_queue_rate_limit": { "rate_limit": { "requests_per_second": 50.0 }, "reason": "manual test" } }' \ localhost:7233 \ temporal.api.workflowservice.v1.WorkflowService/UpdateTaskQueueConfig ``` ``` grpcurl -plaintext \ -d '{ "namespace": "default", "task_queue": "my-queue", "task_queue_type": "TASK_QUEUE_TYPE_ACTIVITY" }' \ localhost:7233 \ temporal.server.api.adminservice.v1.AdminService/GetTaskQueueUserData ``` ```json { "userData": { "config": { "queueRateLimit": { "rateLimit": { "requestsPerSecond": 50 }, "metadata": { "reason": "manual test", "updateTime": "2026-04-13T21:40:39.888Z" } } } }, "version": "2" } ``` </details> <details> <summary>Case 6 — Namespace not found</summary> ``` grpcurl -plaintext \ -d '{"namespace":"nonexistent","task_queue":"my-queue","task_queue_type":"TASK_QUEUE_TYPE_WORKFLOW"}' \ localhost:7233 \ temporal.server.api.adminservice.v1.AdminService/GetTaskQueueUserData ``` ``` ERROR: Code: NotFound Message: Namespace nonexistent is not found. ``` `NOT_FOUND` from namespace registry; matching never called. </details> --------- Co-authored-by: Hanzo Dev <[email protected]>
641 lines
20 KiB
Go
641 lines
20 KiB
Go
// Code generated by cmd/tools/genrpcwrappers. DO NOT EDIT.
|
|
|
|
package admin
|
|
|
|
import (
|
|
"context"
|
|
|
|
"go.temporal.io/server/api/adminservice/v1"
|
|
"google.golang.org/grpc"
|
|
)
|
|
|
|
func (c *metricClient) AddOrUpdateRemoteCluster(
|
|
ctx context.Context,
|
|
request *adminservice.AddOrUpdateRemoteClusterRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.AddOrUpdateRemoteClusterResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientAddOrUpdateRemoteCluster")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.AddOrUpdateRemoteCluster(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) AddSearchAttributes(
|
|
ctx context.Context,
|
|
request *adminservice.AddSearchAttributesRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.AddSearchAttributesResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientAddSearchAttributes")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.AddSearchAttributes(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) AddTasks(
|
|
ctx context.Context,
|
|
request *adminservice.AddTasksRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.AddTasksResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientAddTasks")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.AddTasks(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) CancelDLQJob(
|
|
ctx context.Context,
|
|
request *adminservice.CancelDLQJobRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.CancelDLQJobResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientCancelDLQJob")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.CancelDLQJob(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) CloseShard(
|
|
ctx context.Context,
|
|
request *adminservice.CloseShardRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.CloseShardResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientCloseShard")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.CloseShard(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) DeepHealthCheck(
|
|
ctx context.Context,
|
|
request *adminservice.DeepHealthCheckRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.DeepHealthCheckResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientDeepHealthCheck")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.DeepHealthCheck(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) DeleteWorkflowExecution(
|
|
ctx context.Context,
|
|
request *adminservice.DeleteWorkflowExecutionRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.DeleteWorkflowExecutionResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientDeleteWorkflowExecution")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.DeleteWorkflowExecution(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) DescribeCluster(
|
|
ctx context.Context,
|
|
request *adminservice.DescribeClusterRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.DescribeClusterResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientDescribeCluster")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.DescribeCluster(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) DescribeDLQJob(
|
|
ctx context.Context,
|
|
request *adminservice.DescribeDLQJobRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.DescribeDLQJobResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientDescribeDLQJob")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.DescribeDLQJob(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) DescribeHistoryHost(
|
|
ctx context.Context,
|
|
request *adminservice.DescribeHistoryHostRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.DescribeHistoryHostResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientDescribeHistoryHost")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.DescribeHistoryHost(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) DescribeMutableState(
|
|
ctx context.Context,
|
|
request *adminservice.DescribeMutableStateRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.DescribeMutableStateResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientDescribeMutableState")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.DescribeMutableState(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) DescribeTaskQueuePartition(
|
|
ctx context.Context,
|
|
request *adminservice.DescribeTaskQueuePartitionRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.DescribeTaskQueuePartitionResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientDescribeTaskQueuePartition")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.DescribeTaskQueuePartition(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) ForceUnloadTaskQueuePartition(
|
|
ctx context.Context,
|
|
request *adminservice.ForceUnloadTaskQueuePartitionRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.ForceUnloadTaskQueuePartitionResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientForceUnloadTaskQueuePartition")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.ForceUnloadTaskQueuePartition(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) GenerateLastHistoryReplicationTasks(
|
|
ctx context.Context,
|
|
request *adminservice.GenerateLastHistoryReplicationTasksRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.GenerateLastHistoryReplicationTasksResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientGenerateLastHistoryReplicationTasks")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.GenerateLastHistoryReplicationTasks(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) GetDLQMessages(
|
|
ctx context.Context,
|
|
request *adminservice.GetDLQMessagesRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.GetDLQMessagesResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientGetDLQMessages")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.GetDLQMessages(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) GetDLQReplicationMessages(
|
|
ctx context.Context,
|
|
request *adminservice.GetDLQReplicationMessagesRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.GetDLQReplicationMessagesResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientGetDLQReplicationMessages")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.GetDLQReplicationMessages(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) GetDLQTasks(
|
|
ctx context.Context,
|
|
request *adminservice.GetDLQTasksRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.GetDLQTasksResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientGetDLQTasks")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.GetDLQTasks(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) GetNamespace(
|
|
ctx context.Context,
|
|
request *adminservice.GetNamespaceRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.GetNamespaceResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientGetNamespace")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.GetNamespace(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) GetNamespaceReplicationMessages(
|
|
ctx context.Context,
|
|
request *adminservice.GetNamespaceReplicationMessagesRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.GetNamespaceReplicationMessagesResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientGetNamespaceReplicationMessages")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.GetNamespaceReplicationMessages(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) GetReplicationMessages(
|
|
ctx context.Context,
|
|
request *adminservice.GetReplicationMessagesRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.GetReplicationMessagesResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientGetReplicationMessages")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.GetReplicationMessages(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) GetSearchAttributes(
|
|
ctx context.Context,
|
|
request *adminservice.GetSearchAttributesRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.GetSearchAttributesResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientGetSearchAttributes")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.GetSearchAttributes(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) GetShard(
|
|
ctx context.Context,
|
|
request *adminservice.GetShardRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.GetShardResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientGetShard")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.GetShard(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) GetTaskQueueTasks(
|
|
ctx context.Context,
|
|
request *adminservice.GetTaskQueueTasksRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.GetTaskQueueTasksResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientGetTaskQueueTasks")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.GetTaskQueueTasks(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) GetTaskQueueUserData(
|
|
ctx context.Context,
|
|
request *adminservice.GetTaskQueueUserDataRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.GetTaskQueueUserDataResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientGetTaskQueueUserData")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.GetTaskQueueUserData(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) GetWorkflowExecutionRawHistory(
|
|
ctx context.Context,
|
|
request *adminservice.GetWorkflowExecutionRawHistoryRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.GetWorkflowExecutionRawHistoryResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientGetWorkflowExecutionRawHistory")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.GetWorkflowExecutionRawHistory(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) GetWorkflowExecutionRawHistoryV2(
|
|
ctx context.Context,
|
|
request *adminservice.GetWorkflowExecutionRawHistoryV2Request,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.GetWorkflowExecutionRawHistoryV2Response, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientGetWorkflowExecutionRawHistoryV2")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.GetWorkflowExecutionRawHistoryV2(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) ImportWorkflowExecution(
|
|
ctx context.Context,
|
|
request *adminservice.ImportWorkflowExecutionRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.ImportWorkflowExecutionResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientImportWorkflowExecution")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.ImportWorkflowExecution(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) ListClusterMembers(
|
|
ctx context.Context,
|
|
request *adminservice.ListClusterMembersRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.ListClusterMembersResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientListClusterMembers")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.ListClusterMembers(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) ListClusters(
|
|
ctx context.Context,
|
|
request *adminservice.ListClustersRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.ListClustersResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientListClusters")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.ListClusters(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) ListHistoryTasks(
|
|
ctx context.Context,
|
|
request *adminservice.ListHistoryTasksRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.ListHistoryTasksResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientListHistoryTasks")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.ListHistoryTasks(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) ListQueues(
|
|
ctx context.Context,
|
|
request *adminservice.ListQueuesRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.ListQueuesResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientListQueues")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.ListQueues(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) MergeDLQMessages(
|
|
ctx context.Context,
|
|
request *adminservice.MergeDLQMessagesRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.MergeDLQMessagesResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientMergeDLQMessages")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.MergeDLQMessages(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) MergeDLQTasks(
|
|
ctx context.Context,
|
|
request *adminservice.MergeDLQTasksRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.MergeDLQTasksResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientMergeDLQTasks")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.MergeDLQTasks(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) MigrateSchedule(
|
|
ctx context.Context,
|
|
request *adminservice.MigrateScheduleRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.MigrateScheduleResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientMigrateSchedule")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.MigrateSchedule(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) PurgeDLQMessages(
|
|
ctx context.Context,
|
|
request *adminservice.PurgeDLQMessagesRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.PurgeDLQMessagesResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientPurgeDLQMessages")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.PurgeDLQMessages(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) PurgeDLQTasks(
|
|
ctx context.Context,
|
|
request *adminservice.PurgeDLQTasksRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.PurgeDLQTasksResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientPurgeDLQTasks")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.PurgeDLQTasks(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) ReapplyEvents(
|
|
ctx context.Context,
|
|
request *adminservice.ReapplyEventsRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.ReapplyEventsResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientReapplyEvents")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.ReapplyEvents(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) RebuildMutableState(
|
|
ctx context.Context,
|
|
request *adminservice.RebuildMutableStateRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.RebuildMutableStateResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientRebuildMutableState")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.RebuildMutableState(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) RefreshWorkflowTasks(
|
|
ctx context.Context,
|
|
request *adminservice.RefreshWorkflowTasksRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.RefreshWorkflowTasksResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientRefreshWorkflowTasks")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.RefreshWorkflowTasks(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) RemoveRemoteCluster(
|
|
ctx context.Context,
|
|
request *adminservice.RemoveRemoteClusterRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.RemoveRemoteClusterResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientRemoveRemoteCluster")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.RemoveRemoteCluster(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) RemoveSearchAttributes(
|
|
ctx context.Context,
|
|
request *adminservice.RemoveSearchAttributesRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.RemoveSearchAttributesResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientRemoveSearchAttributes")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.RemoveSearchAttributes(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) RemoveTask(
|
|
ctx context.Context,
|
|
request *adminservice.RemoveTaskRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.RemoveTaskResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientRemoveTask")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.RemoveTask(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) ResendReplicationTasks(
|
|
ctx context.Context,
|
|
request *adminservice.ResendReplicationTasksRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.ResendReplicationTasksResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientResendReplicationTasks")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.ResendReplicationTasks(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) StartAdminBatchOperation(
|
|
ctx context.Context,
|
|
request *adminservice.StartAdminBatchOperationRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.StartAdminBatchOperationResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientStartAdminBatchOperation")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.StartAdminBatchOperation(ctx, request, opts...)
|
|
}
|
|
|
|
func (c *metricClient) SyncWorkflowState(
|
|
ctx context.Context,
|
|
request *adminservice.SyncWorkflowStateRequest,
|
|
opts ...grpc.CallOption,
|
|
) (_ *adminservice.SyncWorkflowStateResponse, retError error) {
|
|
|
|
metricsHandler, startTime := c.startMetricsRecording(ctx, "AdminClientSyncWorkflowState")
|
|
defer func() {
|
|
c.finishMetricsRecording(metricsHandler, startTime, retError)
|
|
}()
|
|
|
|
return c.client.SyncWorkflowState(ctx, request, opts...)
|
|
}
|