hanzoai/tasks
2
0
Fork 0
mirror of https://github.com/hanzoai/tasks.git synced 2026-10-04 02:04:03 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
release/v1.30.x
tasks/client/matching/retryable_client_gen.go
T
Jacob MoodyandGitHub 7d1a144404 auto enabling priority and fairness (#8650) 
## What changed?
Add a new dynamic config for Auto Enabling fairness and priority if we
see the relevant tasks coming in.

## Why?
Seamlessly start to transition users who start using the fields over to
the new code path.

## How did you test it?
- [X] built
- [x] run locally and tested manually 
- [x] covered by existing tests
- [x] added new unit test(s)
- [x] added new functional test(s)

## Potential risks
Due to storing this in the userdata we are using that interface a bit
more, we also need to change the initialization such that we start it
before being able to substantiate the defaultQ, this change in
initialization might have unintended side effects that I'm not currently
seeing.
2026-01-06 14:40:23 -06:00

598 lines
20 KiB
Go
Raw Permalink Blame History

// Code generated by cmd/tools/genrpcwrappers. DO NOT EDIT.
package matching
import (
"context"
"go.temporal.io/server/api/matchingservice/v1"
"google.golang.org/grpc"
"go.temporal.io/server/common/backoff"
)
func (c *retryableClient) AddActivityTask(
ctx context.Context,
request *matchingservice.AddActivityTaskRequest,
opts ...grpc.CallOption,
) (*matchingservice.AddActivityTaskResponse, error) {
var resp *matchingservice.AddActivityTaskResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.AddActivityTask(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) AddWorkflowTask(
ctx context.Context,
request *matchingservice.AddWorkflowTaskRequest,
opts ...grpc.CallOption,
) (*matchingservice.AddWorkflowTaskResponse, error) {
var resp *matchingservice.AddWorkflowTaskResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.AddWorkflowTask(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) ApplyTaskQueueUserDataReplicationEvent(
ctx context.Context,
request *matchingservice.ApplyTaskQueueUserDataReplicationEventRequest,
opts ...grpc.CallOption,
) (*matchingservice.ApplyTaskQueueUserDataReplicationEventResponse, error) {
var resp *matchingservice.ApplyTaskQueueUserDataReplicationEventResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.ApplyTaskQueueUserDataReplicationEvent(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) CancelOutstandingPoll(
ctx context.Context,
request *matchingservice.CancelOutstandingPollRequest,
opts ...grpc.CallOption,
) (*matchingservice.CancelOutstandingPollResponse, error) {
var resp *matchingservice.CancelOutstandingPollResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.CancelOutstandingPoll(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) CheckTaskQueueUserDataPropagation(
ctx context.Context,
request *matchingservice.CheckTaskQueueUserDataPropagationRequest,
opts ...grpc.CallOption,
) (*matchingservice.CheckTaskQueueUserDataPropagationResponse, error) {
var resp *matchingservice.CheckTaskQueueUserDataPropagationResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.CheckTaskQueueUserDataPropagation(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) CheckTaskQueueVersionMembership(
ctx context.Context,
request *matchingservice.CheckTaskQueueVersionMembershipRequest,
opts ...grpc.CallOption,
) (*matchingservice.CheckTaskQueueVersionMembershipResponse, error) {
var resp *matchingservice.CheckTaskQueueVersionMembershipResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.CheckTaskQueueVersionMembership(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) CreateNexusEndpoint(
ctx context.Context,
request *matchingservice.CreateNexusEndpointRequest,
opts ...grpc.CallOption,
) (*matchingservice.CreateNexusEndpointResponse, error) {
var resp *matchingservice.CreateNexusEndpointResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.CreateNexusEndpoint(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) DeleteNexusEndpoint(
ctx context.Context,
request *matchingservice.DeleteNexusEndpointRequest,
opts ...grpc.CallOption,
) (*matchingservice.DeleteNexusEndpointResponse, error) {
var resp *matchingservice.DeleteNexusEndpointResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.DeleteNexusEndpoint(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) DescribeTaskQueue(
ctx context.Context,
request *matchingservice.DescribeTaskQueueRequest,
opts ...grpc.CallOption,
) (*matchingservice.DescribeTaskQueueResponse, error) {
var resp *matchingservice.DescribeTaskQueueResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.DescribeTaskQueue(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) DescribeTaskQueuePartition(
ctx context.Context,
request *matchingservice.DescribeTaskQueuePartitionRequest,
opts ...grpc.CallOption,
) (*matchingservice.DescribeTaskQueuePartitionResponse, error) {
var resp *matchingservice.DescribeTaskQueuePartitionResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.DescribeTaskQueuePartition(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) DescribeVersionedTaskQueues(
ctx context.Context,
request *matchingservice.DescribeVersionedTaskQueuesRequest,
opts ...grpc.CallOption,
) (*matchingservice.DescribeVersionedTaskQueuesResponse, error) {
var resp *matchingservice.DescribeVersionedTaskQueuesResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.DescribeVersionedTaskQueues(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) DescribeWorker(
ctx context.Context,
request *matchingservice.DescribeWorkerRequest,
opts ...grpc.CallOption,
) (*matchingservice.DescribeWorkerResponse, error) {
var resp *matchingservice.DescribeWorkerResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.DescribeWorker(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) DispatchNexusTask(
ctx context.Context,
request *matchingservice.DispatchNexusTaskRequest,
opts ...grpc.CallOption,
) (*matchingservice.DispatchNexusTaskResponse, error) {
var resp *matchingservice.DispatchNexusTaskResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.DispatchNexusTask(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) ForceLoadTaskQueuePartition(
ctx context.Context,
request *matchingservice.ForceLoadTaskQueuePartitionRequest,
opts ...grpc.CallOption,
) (*matchingservice.ForceLoadTaskQueuePartitionResponse, error) {
var resp *matchingservice.ForceLoadTaskQueuePartitionResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.ForceLoadTaskQueuePartition(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) ForceUnloadTaskQueue(
ctx context.Context,
request *matchingservice.ForceUnloadTaskQueueRequest,
opts ...grpc.CallOption,
) (*matchingservice.ForceUnloadTaskQueueResponse, error) {
var resp *matchingservice.ForceUnloadTaskQueueResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.ForceUnloadTaskQueue(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) ForceUnloadTaskQueuePartition(
ctx context.Context,
request *matchingservice.ForceUnloadTaskQueuePartitionRequest,
opts ...grpc.CallOption,
) (*matchingservice.ForceUnloadTaskQueuePartitionResponse, error) {
var resp *matchingservice.ForceUnloadTaskQueuePartitionResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.ForceUnloadTaskQueuePartition(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) GetBuildIdTaskQueueMapping(
ctx context.Context,
request *matchingservice.GetBuildIdTaskQueueMappingRequest,
opts ...grpc.CallOption,
) (*matchingservice.GetBuildIdTaskQueueMappingResponse, error) {
var resp *matchingservice.GetBuildIdTaskQueueMappingResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.GetBuildIdTaskQueueMapping(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) GetTaskQueueUserData(
ctx context.Context,
request *matchingservice.GetTaskQueueUserDataRequest,
opts ...grpc.CallOption,
) (*matchingservice.GetTaskQueueUserDataResponse, error) {
var resp *matchingservice.GetTaskQueueUserDataResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.GetTaskQueueUserData(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) GetWorkerBuildIdCompatibility(
ctx context.Context,
request *matchingservice.GetWorkerBuildIdCompatibilityRequest,
opts ...grpc.CallOption,
) (*matchingservice.GetWorkerBuildIdCompatibilityResponse, error) {
var resp *matchingservice.GetWorkerBuildIdCompatibilityResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.GetWorkerBuildIdCompatibility(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) GetWorkerVersioningRules(
ctx context.Context,
request *matchingservice.GetWorkerVersioningRulesRequest,
opts ...grpc.CallOption,
) (*matchingservice.GetWorkerVersioningRulesResponse, error) {
var resp *matchingservice.GetWorkerVersioningRulesResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.GetWorkerVersioningRules(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) ListNexusEndpoints(
ctx context.Context,
request *matchingservice.ListNexusEndpointsRequest,
opts ...grpc.CallOption,
) (*matchingservice.ListNexusEndpointsResponse, error) {
var resp *matchingservice.ListNexusEndpointsResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.ListNexusEndpoints(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) ListTaskQueuePartitions(
ctx context.Context,
request *matchingservice.ListTaskQueuePartitionsRequest,
opts ...grpc.CallOption,
) (*matchingservice.ListTaskQueuePartitionsResponse, error) {
var resp *matchingservice.ListTaskQueuePartitionsResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.ListTaskQueuePartitions(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) ListWorkers(
ctx context.Context,
request *matchingservice.ListWorkersRequest,
opts ...grpc.CallOption,
) (*matchingservice.ListWorkersResponse, error) {
var resp *matchingservice.ListWorkersResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.ListWorkers(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) PollActivityTaskQueue(
ctx context.Context,
request *matchingservice.PollActivityTaskQueueRequest,
opts ...grpc.CallOption,
) (*matchingservice.PollActivityTaskQueueResponse, error) {
var resp *matchingservice.PollActivityTaskQueueResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.PollActivityTaskQueue(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.pollPolicy, c.isRetryable)
return resp, err
}
func (c *retryableClient) PollNexusTaskQueue(
ctx context.Context,
request *matchingservice.PollNexusTaskQueueRequest,
opts ...grpc.CallOption,
) (*matchingservice.PollNexusTaskQueueResponse, error) {
var resp *matchingservice.PollNexusTaskQueueResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.PollNexusTaskQueue(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.pollPolicy, c.isRetryable)
return resp, err
}
func (c *retryableClient) PollWorkflowTaskQueue(
ctx context.Context,
request *matchingservice.PollWorkflowTaskQueueRequest,
opts ...grpc.CallOption,
) (*matchingservice.PollWorkflowTaskQueueResponse, error) {
var resp *matchingservice.PollWorkflowTaskQueueResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.PollWorkflowTaskQueue(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.pollPolicy, c.isRetryable)
return resp, err
}
func (c *retryableClient) QueryWorkflow(
ctx context.Context,
request *matchingservice.QueryWorkflowRequest,
opts ...grpc.CallOption,
) (*matchingservice.QueryWorkflowResponse, error) {
var resp *matchingservice.QueryWorkflowResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.QueryWorkflow(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) RecordWorkerHeartbeat(
ctx context.Context,
request *matchingservice.RecordWorkerHeartbeatRequest,
opts ...grpc.CallOption,
) (*matchingservice.RecordWorkerHeartbeatResponse, error) {
var resp *matchingservice.RecordWorkerHeartbeatResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.RecordWorkerHeartbeat(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) ReplicateTaskQueueUserData(
ctx context.Context,
request *matchingservice.ReplicateTaskQueueUserDataRequest,
opts ...grpc.CallOption,
) (*matchingservice.ReplicateTaskQueueUserDataResponse, error) {
var resp *matchingservice.ReplicateTaskQueueUserDataResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.ReplicateTaskQueueUserData(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) RespondNexusTaskCompleted(
ctx context.Context,
request *matchingservice.RespondNexusTaskCompletedRequest,
opts ...grpc.CallOption,
) (*matchingservice.RespondNexusTaskCompletedResponse, error) {
var resp *matchingservice.RespondNexusTaskCompletedResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.RespondNexusTaskCompleted(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) RespondNexusTaskFailed(
ctx context.Context,
request *matchingservice.RespondNexusTaskFailedRequest,
opts ...grpc.CallOption,
) (*matchingservice.RespondNexusTaskFailedResponse, error) {
var resp *matchingservice.RespondNexusTaskFailedResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.RespondNexusTaskFailed(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) RespondQueryTaskCompleted(
ctx context.Context,
request *matchingservice.RespondQueryTaskCompletedRequest,
opts ...grpc.CallOption,
) (*matchingservice.RespondQueryTaskCompletedResponse, error) {
var resp *matchingservice.RespondQueryTaskCompletedResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.RespondQueryTaskCompleted(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) SyncDeploymentUserData(
ctx context.Context,
request *matchingservice.SyncDeploymentUserDataRequest,
opts ...grpc.CallOption,
) (*matchingservice.SyncDeploymentUserDataResponse, error) {
var resp *matchingservice.SyncDeploymentUserDataResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.SyncDeploymentUserData(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) UpdateFairnessState(
ctx context.Context,
request *matchingservice.UpdateFairnessStateRequest,
opts ...grpc.CallOption,
) (*matchingservice.UpdateFairnessStateResponse, error) {
var resp *matchingservice.UpdateFairnessStateResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.UpdateFairnessState(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) UpdateNexusEndpoint(
ctx context.Context,
request *matchingservice.UpdateNexusEndpointRequest,
opts ...grpc.CallOption,
) (*matchingservice.UpdateNexusEndpointResponse, error) {
var resp *matchingservice.UpdateNexusEndpointResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.UpdateNexusEndpoint(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) UpdateTaskQueueConfig(
ctx context.Context,
request *matchingservice.UpdateTaskQueueConfigRequest,
opts ...grpc.CallOption,
) (*matchingservice.UpdateTaskQueueConfigResponse, error) {
var resp *matchingservice.UpdateTaskQueueConfigResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.UpdateTaskQueueConfig(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) UpdateTaskQueueUserData(
ctx context.Context,
request *matchingservice.UpdateTaskQueueUserDataRequest,
opts ...grpc.CallOption,
) (*matchingservice.UpdateTaskQueueUserDataResponse, error) {
var resp *matchingservice.UpdateTaskQueueUserDataResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.UpdateTaskQueueUserData(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) UpdateWorkerBuildIdCompatibility(
ctx context.Context,
request *matchingservice.UpdateWorkerBuildIdCompatibilityRequest,
opts ...grpc.CallOption,
) (*matchingservice.UpdateWorkerBuildIdCompatibilityResponse, error) {
var resp *matchingservice.UpdateWorkerBuildIdCompatibilityResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.UpdateWorkerBuildIdCompatibility(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
func (c *retryableClient) UpdateWorkerVersioningRules(
ctx context.Context,
request *matchingservice.UpdateWorkerVersioningRulesRequest,
opts ...grpc.CallOption,
) (*matchingservice.UpdateWorkerVersioningRulesResponse, error) {
var resp *matchingservice.UpdateWorkerVersioningRulesResponse
op := func(ctx context.Context) error {
var err error
resp, err = c.client.UpdateWorkerVersioningRules(ctx, request, opts...)
return err
}
err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
return resp, err
}
Reference in New Issue View Git Blame Copy Permalink