One gRPC service per domain in state.v1 (tasks, executions, accounts, identities, packages, captures, bindings, access, orgs, alerts and so on), each with its own server type in staterpc. RPC and message names and numbers are unchanged.
1020 lines
43 KiB
Go
1020 lines
43 KiB
Go
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
|
|
// versions:
|
|
// - protoc-gen-go-grpc v1.6.2
|
|
// - protoc (unknown)
|
|
// source: state/v1/task.proto
|
|
|
|
package statev1
|
|
|
|
import (
|
|
context "context"
|
|
grpc "google.golang.org/grpc"
|
|
codes "google.golang.org/grpc/codes"
|
|
status "google.golang.org/grpc/status"
|
|
)
|
|
|
|
// This is a compile-time assertion to ensure that this generated file
|
|
// is compatible with the grpc package it is being compiled against.
|
|
// Requires gRPC-Go v1.64.0 or later.
|
|
const _ = grpc.SupportPackageIsVersion9
|
|
|
|
const (
|
|
TaskService_EnqueueIssue_FullMethodName = "/state.v1.TaskService/EnqueueIssue"
|
|
TaskService_EnqueueChatTask_FullMethodName = "/state.v1.TaskService/EnqueueChatTask"
|
|
TaskService_ActiveTasksByOrigin_FullMethodName = "/state.v1.TaskService/ActiveTasksByOrigin"
|
|
TaskService_UnpostedOutcomes_FullMethodName = "/state.v1.TaskService/UnpostedOutcomes"
|
|
TaskService_MarkOutcomePosted_FullMethodName = "/state.v1.TaskService/MarkOutcomePosted"
|
|
TaskService_ClaimNext_FullMethodName = "/state.v1.TaskService/ClaimNext"
|
|
TaskService_ClaimByIssue_FullMethodName = "/state.v1.TaskService/ClaimByIssue"
|
|
TaskService_Transition_FullMethodName = "/state.v1.TaskService/Transition"
|
|
TaskService_Update_FullMethodName = "/state.v1.TaskService/Update"
|
|
TaskService_TaskModels_FullMethodName = "/state.v1.TaskService/TaskModels"
|
|
TaskService_TaskInstructions_FullMethodName = "/state.v1.TaskService/TaskInstructions"
|
|
TaskService_Requeue_FullMethodName = "/state.v1.TaskService/Requeue"
|
|
TaskService_ParkTask_FullMethodName = "/state.v1.TaskService/ParkTask"
|
|
TaskService_RecoverStale_FullMethodName = "/state.v1.TaskService/RecoverStale"
|
|
TaskService_ArchiveTask_FullMethodName = "/state.v1.TaskService/ArchiveTask"
|
|
TaskService_RetryTask_FullMethodName = "/state.v1.TaskService/RetryTask"
|
|
TaskService_TaskByIssue_FullMethodName = "/state.v1.TaskService/TaskByIssue"
|
|
TaskService_OpenTaskByPR_FullMethodName = "/state.v1.TaskService/OpenTaskByPR"
|
|
TaskService_TaskByID_FullMethodName = "/state.v1.TaskService/TaskByID"
|
|
TaskService_OpenPRs_FullMethodName = "/state.v1.TaskService/OpenPRs"
|
|
TaskService_ClearTerminalTasks_FullMethodName = "/state.v1.TaskService/ClearTerminalTasks"
|
|
TaskService_Tasks_FullMethodName = "/state.v1.TaskService/Tasks"
|
|
TaskService_EnqueueCallTask_FullMethodName = "/state.v1.TaskService/EnqueueCallTask"
|
|
TaskService_WorkflowCallStatus_FullMethodName = "/state.v1.TaskService/WorkflowCallStatus"
|
|
)
|
|
|
|
// TaskServiceClient is the client API for TaskService service.
|
|
//
|
|
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
|
|
type TaskServiceClient interface {
|
|
EnqueueIssue(ctx context.Context, in *EnqueueIssueRequest, opts ...grpc.CallOption) (*EnqueueIssueResponse, error)
|
|
EnqueueChatTask(ctx context.Context, in *EnqueueChatTaskRequest, opts ...grpc.CallOption) (*EnqueueChatTaskResponse, error)
|
|
ActiveTasksByOrigin(ctx context.Context, in *ActiveTasksByOriginRequest, opts ...grpc.CallOption) (*ActiveTasksByOriginResponse, error)
|
|
// UnpostedOutcomes lists finished chat tasks whose outcome has not yet been
|
|
// posted to their conversation; MarkOutcomePosted records that it was.
|
|
UnpostedOutcomes(ctx context.Context, in *UnpostedOutcomesRequest, opts ...grpc.CallOption) (*UnpostedOutcomesResponse, error)
|
|
MarkOutcomePosted(ctx context.Context, in *MarkOutcomePostedRequest, opts ...grpc.CallOption) (*MarkOutcomePostedResponse, error)
|
|
ClaimNext(ctx context.Context, in *ClaimNextRequest, opts ...grpc.CallOption) (*ClaimNextResponse, error)
|
|
ClaimByIssue(ctx context.Context, in *ClaimByIssueRequest, opts ...grpc.CallOption) (*ClaimByIssueResponse, error)
|
|
Transition(ctx context.Context, in *TransitionRequest, opts ...grpc.CallOption) (*TransitionResponse, error)
|
|
Update(ctx context.Context, in *UpdateRequest, opts ...grpc.CallOption) (*UpdateResponse, error)
|
|
// TaskModels answers what a task's models resolve against: the aliases its
|
|
// org may use and the org's own providers. The org is the task's, never
|
|
// the caller's.
|
|
TaskModels(ctx context.Context, in *TaskModelsRequest, opts ...grpc.CallOption) (*TaskModelsResponse, error)
|
|
// TaskInstructions answers the instance and organisation instructions a
|
|
// task's agent runs follow. Organisation is empty for a system-org task.
|
|
TaskInstructions(ctx context.Context, in *TaskInstructionsRequest, opts ...grpc.CallOption) (*TaskInstructionsResponse, error)
|
|
Requeue(ctx context.Context, in *RequeueRequest, opts ...grpc.CallOption) (*RequeueResponse, error)
|
|
ParkTask(ctx context.Context, in *ParkTaskRequest, opts ...grpc.CallOption) (*ParkTaskResponse, error)
|
|
RecoverStale(ctx context.Context, in *RecoverStaleRequest, opts ...grpc.CallOption) (*RecoverStaleResponse, error)
|
|
ArchiveTask(ctx context.Context, in *ArchiveTaskRequest, opts ...grpc.CallOption) (*ArchiveTaskResponse, error)
|
|
RetryTask(ctx context.Context, in *RetryTaskRequest, opts ...grpc.CallOption) (*RetryTaskResponse, error)
|
|
TaskByIssue(ctx context.Context, in *TaskByIssueRequest, opts ...grpc.CallOption) (*TaskByIssueResponse, error)
|
|
OpenTaskByPR(ctx context.Context, in *OpenTaskByPRRequest, opts ...grpc.CallOption) (*OpenTaskByPRResponse, error)
|
|
TaskByID(ctx context.Context, in *TaskByIDRequest, opts ...grpc.CallOption) (*TaskByIDResponse, error)
|
|
OpenPRs(ctx context.Context, in *OpenPRsRequest, opts ...grpc.CallOption) (*OpenPRsResponse, error)
|
|
ClearTerminalTasks(ctx context.Context, in *ClearTerminalTasksRequest, opts ...grpc.CallOption) (*ClearTerminalTasksResponse, error)
|
|
Tasks(ctx context.Context, in *TasksRequest, opts ...grpc.CallOption) (*TasksResponse, error)
|
|
// WorkflowCaller: a workflow.call step starts its callee and, with
|
|
// wait:true, reads it back while waiting. Both are the one sanctioned
|
|
// widening of a task-scoped grant -- the callee is the caller's child
|
|
// (docs/prds/workflow-calls.md). CallStatus re-checks the parent-child
|
|
// relation server-side, so the grant only names the caller.
|
|
EnqueueCallTask(ctx context.Context, in *EnqueueCallTaskRequest, opts ...grpc.CallOption) (*EnqueueCallTaskResponse, error)
|
|
WorkflowCallStatus(ctx context.Context, in *WorkflowCallStatusRequest, opts ...grpc.CallOption) (*WorkflowCallStatusResponse, error)
|
|
}
|
|
|
|
type taskServiceClient struct {
|
|
cc grpc.ClientConnInterface
|
|
}
|
|
|
|
func NewTaskServiceClient(cc grpc.ClientConnInterface) TaskServiceClient {
|
|
return &taskServiceClient{cc}
|
|
}
|
|
|
|
func (c *taskServiceClient) EnqueueIssue(ctx context.Context, in *EnqueueIssueRequest, opts ...grpc.CallOption) (*EnqueueIssueResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(EnqueueIssueResponse)
|
|
err := c.cc.Invoke(ctx, TaskService_EnqueueIssue_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *taskServiceClient) EnqueueChatTask(ctx context.Context, in *EnqueueChatTaskRequest, opts ...grpc.CallOption) (*EnqueueChatTaskResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(EnqueueChatTaskResponse)
|
|
err := c.cc.Invoke(ctx, TaskService_EnqueueChatTask_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *taskServiceClient) ActiveTasksByOrigin(ctx context.Context, in *ActiveTasksByOriginRequest, opts ...grpc.CallOption) (*ActiveTasksByOriginResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(ActiveTasksByOriginResponse)
|
|
err := c.cc.Invoke(ctx, TaskService_ActiveTasksByOrigin_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *taskServiceClient) UnpostedOutcomes(ctx context.Context, in *UnpostedOutcomesRequest, opts ...grpc.CallOption) (*UnpostedOutcomesResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(UnpostedOutcomesResponse)
|
|
err := c.cc.Invoke(ctx, TaskService_UnpostedOutcomes_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *taskServiceClient) MarkOutcomePosted(ctx context.Context, in *MarkOutcomePostedRequest, opts ...grpc.CallOption) (*MarkOutcomePostedResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(MarkOutcomePostedResponse)
|
|
err := c.cc.Invoke(ctx, TaskService_MarkOutcomePosted_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *taskServiceClient) ClaimNext(ctx context.Context, in *ClaimNextRequest, opts ...grpc.CallOption) (*ClaimNextResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(ClaimNextResponse)
|
|
err := c.cc.Invoke(ctx, TaskService_ClaimNext_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *taskServiceClient) ClaimByIssue(ctx context.Context, in *ClaimByIssueRequest, opts ...grpc.CallOption) (*ClaimByIssueResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(ClaimByIssueResponse)
|
|
err := c.cc.Invoke(ctx, TaskService_ClaimByIssue_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *taskServiceClient) Transition(ctx context.Context, in *TransitionRequest, opts ...grpc.CallOption) (*TransitionResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(TransitionResponse)
|
|
err := c.cc.Invoke(ctx, TaskService_Transition_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *taskServiceClient) Update(ctx context.Context, in *UpdateRequest, opts ...grpc.CallOption) (*UpdateResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(UpdateResponse)
|
|
err := c.cc.Invoke(ctx, TaskService_Update_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *taskServiceClient) TaskModels(ctx context.Context, in *TaskModelsRequest, opts ...grpc.CallOption) (*TaskModelsResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(TaskModelsResponse)
|
|
err := c.cc.Invoke(ctx, TaskService_TaskModels_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *taskServiceClient) TaskInstructions(ctx context.Context, in *TaskInstructionsRequest, opts ...grpc.CallOption) (*TaskInstructionsResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(TaskInstructionsResponse)
|
|
err := c.cc.Invoke(ctx, TaskService_TaskInstructions_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *taskServiceClient) Requeue(ctx context.Context, in *RequeueRequest, opts ...grpc.CallOption) (*RequeueResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(RequeueResponse)
|
|
err := c.cc.Invoke(ctx, TaskService_Requeue_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *taskServiceClient) ParkTask(ctx context.Context, in *ParkTaskRequest, opts ...grpc.CallOption) (*ParkTaskResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(ParkTaskResponse)
|
|
err := c.cc.Invoke(ctx, TaskService_ParkTask_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *taskServiceClient) RecoverStale(ctx context.Context, in *RecoverStaleRequest, opts ...grpc.CallOption) (*RecoverStaleResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(RecoverStaleResponse)
|
|
err := c.cc.Invoke(ctx, TaskService_RecoverStale_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *taskServiceClient) ArchiveTask(ctx context.Context, in *ArchiveTaskRequest, opts ...grpc.CallOption) (*ArchiveTaskResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(ArchiveTaskResponse)
|
|
err := c.cc.Invoke(ctx, TaskService_ArchiveTask_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *taskServiceClient) RetryTask(ctx context.Context, in *RetryTaskRequest, opts ...grpc.CallOption) (*RetryTaskResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(RetryTaskResponse)
|
|
err := c.cc.Invoke(ctx, TaskService_RetryTask_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *taskServiceClient) TaskByIssue(ctx context.Context, in *TaskByIssueRequest, opts ...grpc.CallOption) (*TaskByIssueResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(TaskByIssueResponse)
|
|
err := c.cc.Invoke(ctx, TaskService_TaskByIssue_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *taskServiceClient) OpenTaskByPR(ctx context.Context, in *OpenTaskByPRRequest, opts ...grpc.CallOption) (*OpenTaskByPRResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(OpenTaskByPRResponse)
|
|
err := c.cc.Invoke(ctx, TaskService_OpenTaskByPR_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *taskServiceClient) TaskByID(ctx context.Context, in *TaskByIDRequest, opts ...grpc.CallOption) (*TaskByIDResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(TaskByIDResponse)
|
|
err := c.cc.Invoke(ctx, TaskService_TaskByID_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *taskServiceClient) OpenPRs(ctx context.Context, in *OpenPRsRequest, opts ...grpc.CallOption) (*OpenPRsResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(OpenPRsResponse)
|
|
err := c.cc.Invoke(ctx, TaskService_OpenPRs_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *taskServiceClient) ClearTerminalTasks(ctx context.Context, in *ClearTerminalTasksRequest, opts ...grpc.CallOption) (*ClearTerminalTasksResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(ClearTerminalTasksResponse)
|
|
err := c.cc.Invoke(ctx, TaskService_ClearTerminalTasks_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *taskServiceClient) Tasks(ctx context.Context, in *TasksRequest, opts ...grpc.CallOption) (*TasksResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(TasksResponse)
|
|
err := c.cc.Invoke(ctx, TaskService_Tasks_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *taskServiceClient) EnqueueCallTask(ctx context.Context, in *EnqueueCallTaskRequest, opts ...grpc.CallOption) (*EnqueueCallTaskResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(EnqueueCallTaskResponse)
|
|
err := c.cc.Invoke(ctx, TaskService_EnqueueCallTask_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *taskServiceClient) WorkflowCallStatus(ctx context.Context, in *WorkflowCallStatusRequest, opts ...grpc.CallOption) (*WorkflowCallStatusResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(WorkflowCallStatusResponse)
|
|
err := c.cc.Invoke(ctx, TaskService_WorkflowCallStatus_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// TaskServiceServer is the server API for TaskService service.
|
|
// All implementations must embed UnimplementedTaskServiceServer
|
|
// for forward compatibility.
|
|
type TaskServiceServer interface {
|
|
EnqueueIssue(context.Context, *EnqueueIssueRequest) (*EnqueueIssueResponse, error)
|
|
EnqueueChatTask(context.Context, *EnqueueChatTaskRequest) (*EnqueueChatTaskResponse, error)
|
|
ActiveTasksByOrigin(context.Context, *ActiveTasksByOriginRequest) (*ActiveTasksByOriginResponse, error)
|
|
// UnpostedOutcomes lists finished chat tasks whose outcome has not yet been
|
|
// posted to their conversation; MarkOutcomePosted records that it was.
|
|
UnpostedOutcomes(context.Context, *UnpostedOutcomesRequest) (*UnpostedOutcomesResponse, error)
|
|
MarkOutcomePosted(context.Context, *MarkOutcomePostedRequest) (*MarkOutcomePostedResponse, error)
|
|
ClaimNext(context.Context, *ClaimNextRequest) (*ClaimNextResponse, error)
|
|
ClaimByIssue(context.Context, *ClaimByIssueRequest) (*ClaimByIssueResponse, error)
|
|
Transition(context.Context, *TransitionRequest) (*TransitionResponse, error)
|
|
Update(context.Context, *UpdateRequest) (*UpdateResponse, error)
|
|
// TaskModels answers what a task's models resolve against: the aliases its
|
|
// org may use and the org's own providers. The org is the task's, never
|
|
// the caller's.
|
|
TaskModels(context.Context, *TaskModelsRequest) (*TaskModelsResponse, error)
|
|
// TaskInstructions answers the instance and organisation instructions a
|
|
// task's agent runs follow. Organisation is empty for a system-org task.
|
|
TaskInstructions(context.Context, *TaskInstructionsRequest) (*TaskInstructionsResponse, error)
|
|
Requeue(context.Context, *RequeueRequest) (*RequeueResponse, error)
|
|
ParkTask(context.Context, *ParkTaskRequest) (*ParkTaskResponse, error)
|
|
RecoverStale(context.Context, *RecoverStaleRequest) (*RecoverStaleResponse, error)
|
|
ArchiveTask(context.Context, *ArchiveTaskRequest) (*ArchiveTaskResponse, error)
|
|
RetryTask(context.Context, *RetryTaskRequest) (*RetryTaskResponse, error)
|
|
TaskByIssue(context.Context, *TaskByIssueRequest) (*TaskByIssueResponse, error)
|
|
OpenTaskByPR(context.Context, *OpenTaskByPRRequest) (*OpenTaskByPRResponse, error)
|
|
TaskByID(context.Context, *TaskByIDRequest) (*TaskByIDResponse, error)
|
|
OpenPRs(context.Context, *OpenPRsRequest) (*OpenPRsResponse, error)
|
|
ClearTerminalTasks(context.Context, *ClearTerminalTasksRequest) (*ClearTerminalTasksResponse, error)
|
|
Tasks(context.Context, *TasksRequest) (*TasksResponse, error)
|
|
// WorkflowCaller: a workflow.call step starts its callee and, with
|
|
// wait:true, reads it back while waiting. Both are the one sanctioned
|
|
// widening of a task-scoped grant -- the callee is the caller's child
|
|
// (docs/prds/workflow-calls.md). CallStatus re-checks the parent-child
|
|
// relation server-side, so the grant only names the caller.
|
|
EnqueueCallTask(context.Context, *EnqueueCallTaskRequest) (*EnqueueCallTaskResponse, error)
|
|
WorkflowCallStatus(context.Context, *WorkflowCallStatusRequest) (*WorkflowCallStatusResponse, error)
|
|
mustEmbedUnimplementedTaskServiceServer()
|
|
}
|
|
|
|
// UnimplementedTaskServiceServer must be embedded to have
|
|
// forward compatible implementations.
|
|
//
|
|
// NOTE: this should be embedded by value instead of pointer to avoid a nil
|
|
// pointer dereference when methods are called.
|
|
type UnimplementedTaskServiceServer struct{}
|
|
|
|
func (UnimplementedTaskServiceServer) EnqueueIssue(context.Context, *EnqueueIssueRequest) (*EnqueueIssueResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method EnqueueIssue not implemented")
|
|
}
|
|
func (UnimplementedTaskServiceServer) EnqueueChatTask(context.Context, *EnqueueChatTaskRequest) (*EnqueueChatTaskResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method EnqueueChatTask not implemented")
|
|
}
|
|
func (UnimplementedTaskServiceServer) ActiveTasksByOrigin(context.Context, *ActiveTasksByOriginRequest) (*ActiveTasksByOriginResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method ActiveTasksByOrigin not implemented")
|
|
}
|
|
func (UnimplementedTaskServiceServer) UnpostedOutcomes(context.Context, *UnpostedOutcomesRequest) (*UnpostedOutcomesResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method UnpostedOutcomes not implemented")
|
|
}
|
|
func (UnimplementedTaskServiceServer) MarkOutcomePosted(context.Context, *MarkOutcomePostedRequest) (*MarkOutcomePostedResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method MarkOutcomePosted not implemented")
|
|
}
|
|
func (UnimplementedTaskServiceServer) ClaimNext(context.Context, *ClaimNextRequest) (*ClaimNextResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method ClaimNext not implemented")
|
|
}
|
|
func (UnimplementedTaskServiceServer) ClaimByIssue(context.Context, *ClaimByIssueRequest) (*ClaimByIssueResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method ClaimByIssue not implemented")
|
|
}
|
|
func (UnimplementedTaskServiceServer) Transition(context.Context, *TransitionRequest) (*TransitionResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method Transition not implemented")
|
|
}
|
|
func (UnimplementedTaskServiceServer) Update(context.Context, *UpdateRequest) (*UpdateResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method Update not implemented")
|
|
}
|
|
func (UnimplementedTaskServiceServer) TaskModels(context.Context, *TaskModelsRequest) (*TaskModelsResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method TaskModels not implemented")
|
|
}
|
|
func (UnimplementedTaskServiceServer) TaskInstructions(context.Context, *TaskInstructionsRequest) (*TaskInstructionsResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method TaskInstructions not implemented")
|
|
}
|
|
func (UnimplementedTaskServiceServer) Requeue(context.Context, *RequeueRequest) (*RequeueResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method Requeue not implemented")
|
|
}
|
|
func (UnimplementedTaskServiceServer) ParkTask(context.Context, *ParkTaskRequest) (*ParkTaskResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method ParkTask not implemented")
|
|
}
|
|
func (UnimplementedTaskServiceServer) RecoverStale(context.Context, *RecoverStaleRequest) (*RecoverStaleResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method RecoverStale not implemented")
|
|
}
|
|
func (UnimplementedTaskServiceServer) ArchiveTask(context.Context, *ArchiveTaskRequest) (*ArchiveTaskResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method ArchiveTask not implemented")
|
|
}
|
|
func (UnimplementedTaskServiceServer) RetryTask(context.Context, *RetryTaskRequest) (*RetryTaskResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method RetryTask not implemented")
|
|
}
|
|
func (UnimplementedTaskServiceServer) TaskByIssue(context.Context, *TaskByIssueRequest) (*TaskByIssueResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method TaskByIssue not implemented")
|
|
}
|
|
func (UnimplementedTaskServiceServer) OpenTaskByPR(context.Context, *OpenTaskByPRRequest) (*OpenTaskByPRResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method OpenTaskByPR not implemented")
|
|
}
|
|
func (UnimplementedTaskServiceServer) TaskByID(context.Context, *TaskByIDRequest) (*TaskByIDResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method TaskByID not implemented")
|
|
}
|
|
func (UnimplementedTaskServiceServer) OpenPRs(context.Context, *OpenPRsRequest) (*OpenPRsResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method OpenPRs not implemented")
|
|
}
|
|
func (UnimplementedTaskServiceServer) ClearTerminalTasks(context.Context, *ClearTerminalTasksRequest) (*ClearTerminalTasksResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method ClearTerminalTasks not implemented")
|
|
}
|
|
func (UnimplementedTaskServiceServer) Tasks(context.Context, *TasksRequest) (*TasksResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method Tasks not implemented")
|
|
}
|
|
func (UnimplementedTaskServiceServer) EnqueueCallTask(context.Context, *EnqueueCallTaskRequest) (*EnqueueCallTaskResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method EnqueueCallTask not implemented")
|
|
}
|
|
func (UnimplementedTaskServiceServer) WorkflowCallStatus(context.Context, *WorkflowCallStatusRequest) (*WorkflowCallStatusResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method WorkflowCallStatus not implemented")
|
|
}
|
|
func (UnimplementedTaskServiceServer) mustEmbedUnimplementedTaskServiceServer() {}
|
|
func (UnimplementedTaskServiceServer) testEmbeddedByValue() {}
|
|
|
|
// UnsafeTaskServiceServer may be embedded to opt out of forward compatibility for this service.
|
|
// Use of this interface is not recommended, as added methods to TaskServiceServer will
|
|
// result in compilation errors.
|
|
type UnsafeTaskServiceServer interface {
|
|
mustEmbedUnimplementedTaskServiceServer()
|
|
}
|
|
|
|
func RegisterTaskServiceServer(s grpc.ServiceRegistrar, srv TaskServiceServer) {
|
|
// If the following call panics, it indicates UnimplementedTaskServiceServer was
|
|
// embedded by pointer and is nil. This will cause panics if an
|
|
// unimplemented method is ever invoked, so we test this at initialization
|
|
// time to prevent it from happening at runtime later due to I/O.
|
|
if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
|
|
t.testEmbeddedByValue()
|
|
}
|
|
s.RegisterService(&TaskService_ServiceDesc, srv)
|
|
}
|
|
|
|
func _TaskService_EnqueueIssue_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(EnqueueIssueRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(TaskServiceServer).EnqueueIssue(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: TaskService_EnqueueIssue_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(TaskServiceServer).EnqueueIssue(ctx, req.(*EnqueueIssueRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _TaskService_EnqueueChatTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(EnqueueChatTaskRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(TaskServiceServer).EnqueueChatTask(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: TaskService_EnqueueChatTask_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(TaskServiceServer).EnqueueChatTask(ctx, req.(*EnqueueChatTaskRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _TaskService_ActiveTasksByOrigin_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(ActiveTasksByOriginRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(TaskServiceServer).ActiveTasksByOrigin(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: TaskService_ActiveTasksByOrigin_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(TaskServiceServer).ActiveTasksByOrigin(ctx, req.(*ActiveTasksByOriginRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _TaskService_UnpostedOutcomes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(UnpostedOutcomesRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(TaskServiceServer).UnpostedOutcomes(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: TaskService_UnpostedOutcomes_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(TaskServiceServer).UnpostedOutcomes(ctx, req.(*UnpostedOutcomesRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _TaskService_MarkOutcomePosted_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(MarkOutcomePostedRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(TaskServiceServer).MarkOutcomePosted(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: TaskService_MarkOutcomePosted_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(TaskServiceServer).MarkOutcomePosted(ctx, req.(*MarkOutcomePostedRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _TaskService_ClaimNext_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(ClaimNextRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(TaskServiceServer).ClaimNext(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: TaskService_ClaimNext_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(TaskServiceServer).ClaimNext(ctx, req.(*ClaimNextRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _TaskService_ClaimByIssue_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(ClaimByIssueRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(TaskServiceServer).ClaimByIssue(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: TaskService_ClaimByIssue_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(TaskServiceServer).ClaimByIssue(ctx, req.(*ClaimByIssueRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _TaskService_Transition_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(TransitionRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(TaskServiceServer).Transition(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: TaskService_Transition_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(TaskServiceServer).Transition(ctx, req.(*TransitionRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _TaskService_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(UpdateRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(TaskServiceServer).Update(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: TaskService_Update_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(TaskServiceServer).Update(ctx, req.(*UpdateRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _TaskService_TaskModels_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(TaskModelsRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(TaskServiceServer).TaskModels(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: TaskService_TaskModels_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(TaskServiceServer).TaskModels(ctx, req.(*TaskModelsRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _TaskService_TaskInstructions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(TaskInstructionsRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(TaskServiceServer).TaskInstructions(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: TaskService_TaskInstructions_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(TaskServiceServer).TaskInstructions(ctx, req.(*TaskInstructionsRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _TaskService_Requeue_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(RequeueRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(TaskServiceServer).Requeue(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: TaskService_Requeue_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(TaskServiceServer).Requeue(ctx, req.(*RequeueRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _TaskService_ParkTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(ParkTaskRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(TaskServiceServer).ParkTask(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: TaskService_ParkTask_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(TaskServiceServer).ParkTask(ctx, req.(*ParkTaskRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _TaskService_RecoverStale_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(RecoverStaleRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(TaskServiceServer).RecoverStale(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: TaskService_RecoverStale_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(TaskServiceServer).RecoverStale(ctx, req.(*RecoverStaleRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _TaskService_ArchiveTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(ArchiveTaskRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(TaskServiceServer).ArchiveTask(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: TaskService_ArchiveTask_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(TaskServiceServer).ArchiveTask(ctx, req.(*ArchiveTaskRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _TaskService_RetryTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(RetryTaskRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(TaskServiceServer).RetryTask(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: TaskService_RetryTask_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(TaskServiceServer).RetryTask(ctx, req.(*RetryTaskRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _TaskService_TaskByIssue_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(TaskByIssueRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(TaskServiceServer).TaskByIssue(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: TaskService_TaskByIssue_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(TaskServiceServer).TaskByIssue(ctx, req.(*TaskByIssueRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _TaskService_OpenTaskByPR_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(OpenTaskByPRRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(TaskServiceServer).OpenTaskByPR(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: TaskService_OpenTaskByPR_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(TaskServiceServer).OpenTaskByPR(ctx, req.(*OpenTaskByPRRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _TaskService_TaskByID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(TaskByIDRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(TaskServiceServer).TaskByID(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: TaskService_TaskByID_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(TaskServiceServer).TaskByID(ctx, req.(*TaskByIDRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _TaskService_OpenPRs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(OpenPRsRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(TaskServiceServer).OpenPRs(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: TaskService_OpenPRs_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(TaskServiceServer).OpenPRs(ctx, req.(*OpenPRsRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _TaskService_ClearTerminalTasks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(ClearTerminalTasksRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(TaskServiceServer).ClearTerminalTasks(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: TaskService_ClearTerminalTasks_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(TaskServiceServer).ClearTerminalTasks(ctx, req.(*ClearTerminalTasksRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _TaskService_Tasks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(TasksRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(TaskServiceServer).Tasks(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: TaskService_Tasks_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(TaskServiceServer).Tasks(ctx, req.(*TasksRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _TaskService_EnqueueCallTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(EnqueueCallTaskRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(TaskServiceServer).EnqueueCallTask(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: TaskService_EnqueueCallTask_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(TaskServiceServer).EnqueueCallTask(ctx, req.(*EnqueueCallTaskRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _TaskService_WorkflowCallStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(WorkflowCallStatusRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(TaskServiceServer).WorkflowCallStatus(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: TaskService_WorkflowCallStatus_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(TaskServiceServer).WorkflowCallStatus(ctx, req.(*WorkflowCallStatusRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
// TaskService_ServiceDesc is the grpc.ServiceDesc for TaskService service.
|
|
// It's only intended for direct use with grpc.RegisterService,
|
|
// and not to be introspected or modified (even as a copy)
|
|
var TaskService_ServiceDesc = grpc.ServiceDesc{
|
|
ServiceName: "state.v1.TaskService",
|
|
HandlerType: (*TaskServiceServer)(nil),
|
|
Methods: []grpc.MethodDesc{
|
|
{
|
|
MethodName: "EnqueueIssue",
|
|
Handler: _TaskService_EnqueueIssue_Handler,
|
|
},
|
|
{
|
|
MethodName: "EnqueueChatTask",
|
|
Handler: _TaskService_EnqueueChatTask_Handler,
|
|
},
|
|
{
|
|
MethodName: "ActiveTasksByOrigin",
|
|
Handler: _TaskService_ActiveTasksByOrigin_Handler,
|
|
},
|
|
{
|
|
MethodName: "UnpostedOutcomes",
|
|
Handler: _TaskService_UnpostedOutcomes_Handler,
|
|
},
|
|
{
|
|
MethodName: "MarkOutcomePosted",
|
|
Handler: _TaskService_MarkOutcomePosted_Handler,
|
|
},
|
|
{
|
|
MethodName: "ClaimNext",
|
|
Handler: _TaskService_ClaimNext_Handler,
|
|
},
|
|
{
|
|
MethodName: "ClaimByIssue",
|
|
Handler: _TaskService_ClaimByIssue_Handler,
|
|
},
|
|
{
|
|
MethodName: "Transition",
|
|
Handler: _TaskService_Transition_Handler,
|
|
},
|
|
{
|
|
MethodName: "Update",
|
|
Handler: _TaskService_Update_Handler,
|
|
},
|
|
{
|
|
MethodName: "TaskModels",
|
|
Handler: _TaskService_TaskModels_Handler,
|
|
},
|
|
{
|
|
MethodName: "TaskInstructions",
|
|
Handler: _TaskService_TaskInstructions_Handler,
|
|
},
|
|
{
|
|
MethodName: "Requeue",
|
|
Handler: _TaskService_Requeue_Handler,
|
|
},
|
|
{
|
|
MethodName: "ParkTask",
|
|
Handler: _TaskService_ParkTask_Handler,
|
|
},
|
|
{
|
|
MethodName: "RecoverStale",
|
|
Handler: _TaskService_RecoverStale_Handler,
|
|
},
|
|
{
|
|
MethodName: "ArchiveTask",
|
|
Handler: _TaskService_ArchiveTask_Handler,
|
|
},
|
|
{
|
|
MethodName: "RetryTask",
|
|
Handler: _TaskService_RetryTask_Handler,
|
|
},
|
|
{
|
|
MethodName: "TaskByIssue",
|
|
Handler: _TaskService_TaskByIssue_Handler,
|
|
},
|
|
{
|
|
MethodName: "OpenTaskByPR",
|
|
Handler: _TaskService_OpenTaskByPR_Handler,
|
|
},
|
|
{
|
|
MethodName: "TaskByID",
|
|
Handler: _TaskService_TaskByID_Handler,
|
|
},
|
|
{
|
|
MethodName: "OpenPRs",
|
|
Handler: _TaskService_OpenPRs_Handler,
|
|
},
|
|
{
|
|
MethodName: "ClearTerminalTasks",
|
|
Handler: _TaskService_ClearTerminalTasks_Handler,
|
|
},
|
|
{
|
|
MethodName: "Tasks",
|
|
Handler: _TaskService_Tasks_Handler,
|
|
},
|
|
{
|
|
MethodName: "EnqueueCallTask",
|
|
Handler: _TaskService_EnqueueCallTask_Handler,
|
|
},
|
|
{
|
|
MethodName: "WorkflowCallStatus",
|
|
Handler: _TaskService_WorkflowCallStatus_Handler,
|
|
},
|
|
},
|
|
Streams: []grpc.StreamDesc{},
|
|
Metadata: "state/v1/task.proto",
|
|
}
|