1062 lines
44 KiB
Go
1062 lines
44 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_HandoffTask_FullMethodName = "/state.v1.TaskService/HandoffTask"
|
|
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)
|
|
// HandoffTask completes a running run and starts its linked successor on
|
|
// the same work item under another workflow.
|
|
HandoffTask(ctx context.Context, in *HandoffTaskRequest, opts ...grpc.CallOption) (*HandoffTaskResponse, 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) HandoffTask(ctx context.Context, in *HandoffTaskRequest, opts ...grpc.CallOption) (*HandoffTaskResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(HandoffTaskResponse)
|
|
err := c.cc.Invoke(ctx, TaskService_HandoffTask_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)
|
|
// HandoffTask completes a running run and starts its linked successor on
|
|
// the same work item under another workflow.
|
|
HandoffTask(context.Context, *HandoffTaskRequest) (*HandoffTaskResponse, 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) HandoffTask(context.Context, *HandoffTaskRequest) (*HandoffTaskResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method HandoffTask 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_HandoffTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(HandoffTaskRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(TaskServiceServer).HandoffTask(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: TaskService_HandoffTask_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(TaskServiceServer).HandoffTask(ctx, req.(*HandoffTaskRequest))
|
|
}
|
|
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: "HandoffTask",
|
|
Handler: _TaskService_HandoffTask_Handler,
|
|
},
|
|
{
|
|
MethodName: "WorkflowCallStatus",
|
|
Handler: _TaskService_WorkflowCallStatus_Handler,
|
|
},
|
|
},
|
|
Streams: []grpc.StreamDesc{},
|
|
Metadata: "state/v1/task.proto",
|
|
}
|