1030 lines
44 KiB
Go
1030 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: forge/v1/forge.proto
|
|
|
|
package forgev1
|
|
|
|
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 (
|
|
ForgeService_Configure_FullMethodName = "/forge.v1.ForgeService/Configure"
|
|
ForgeService_AssignedIssues_FullMethodName = "/forge.v1.ForgeService/AssignedIssues"
|
|
ForgeService_IssuesWithLabel_FullMethodName = "/forge.v1.ForgeService/IssuesWithLabel"
|
|
ForgeService_Comment_FullMethodName = "/forge.v1.ForgeService/Comment"
|
|
ForgeService_CreateIssue_FullMethodName = "/forge.v1.ForgeService/CreateIssue"
|
|
ForgeService_CloseIssue_FullMethodName = "/forge.v1.ForgeService/CloseIssue"
|
|
ForgeService_React_FullMethodName = "/forge.v1.ForgeService/React"
|
|
ForgeService_SetStateLabel_FullMethodName = "/forge.v1.ForgeService/SetStateLabel"
|
|
ForgeService_CreatePR_FullMethodName = "/forge.v1.ForgeService/CreatePR"
|
|
ForgeService_PRState_FullMethodName = "/forge.v1.ForgeService/PRState"
|
|
ForgeService_ClosePR_FullMethodName = "/forge.v1.ForgeService/ClosePR"
|
|
ForgeService_MergePR_FullMethodName = "/forge.v1.ForgeService/MergePR"
|
|
ForgeService_GetPullRequest_FullMethodName = "/forge.v1.ForgeService/GetPullRequest"
|
|
ForgeService_GetPullRequestDiff_FullMethodName = "/forge.v1.ForgeService/GetPullRequestDiff"
|
|
ForgeService_ListReviews_FullMethodName = "/forge.v1.ForgeService/ListReviews"
|
|
ForgeService_ListReviewComments_FullMethodName = "/forge.v1.ForgeService/ListReviewComments"
|
|
ForgeService_HasWriteAccess_FullMethodName = "/forge.v1.ForgeService/HasWriteAccess"
|
|
ForgeService_ReplyToReview_FullMethodName = "/forge.v1.ForgeService/ReplyToReview"
|
|
ForgeService_CreateReviewComments_FullMethodName = "/forge.v1.ForgeService/CreateReviewComments"
|
|
ForgeService_AcceptInvitations_FullMethodName = "/forge.v1.ForgeService/AcceptInvitations"
|
|
ForgeService_VerifyPush_FullMethodName = "/forge.v1.ForgeService/VerifyPush"
|
|
ForgeService_LinkBranch_FullMethodName = "/forge.v1.ForgeService/LinkBranch"
|
|
ForgeService_GitCredential_FullMethodName = "/forge.v1.ForgeService/GitCredential"
|
|
ForgeService_GetRepoArchive_FullMethodName = "/forge.v1.ForgeService/GetRepoArchive"
|
|
)
|
|
|
|
// ForgeServiceClient is the client API for ForgeService 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.
|
|
//
|
|
// ForgeService is the surface a forge extension serves. The host launches one
|
|
// plugin process per configured forge instance and routes every issue, pull
|
|
// request and repository call of that instance through it. The calls follow
|
|
// the host's forge interfaces; a capability the forge lacks answers
|
|
// UNIMPLEMENTED.
|
|
type ForgeServiceClient interface {
|
|
// Configure hands the plugin its instance once, right after launch and
|
|
// before any other call. The token is the instance's resolved credential;
|
|
// the plugin process does not inherit the host environment.
|
|
Configure(ctx context.Context, in *ConfigureRequest, opts ...grpc.CallOption) (*ConfigureResponse, error)
|
|
AssignedIssues(ctx context.Context, in *AssignedIssuesRequest, opts ...grpc.CallOption) (*AssignedIssuesResponse, error)
|
|
IssuesWithLabel(ctx context.Context, in *IssuesWithLabelRequest, opts ...grpc.CallOption) (*IssuesWithLabelResponse, error)
|
|
Comment(ctx context.Context, in *CommentRequest, opts ...grpc.CallOption) (*CommentResponse, error)
|
|
CreateIssue(ctx context.Context, in *CreateIssueRequest, opts ...grpc.CallOption) (*CreateIssueResponse, error)
|
|
CloseIssue(ctx context.Context, in *CloseIssueRequest, opts ...grpc.CallOption) (*CloseIssueResponse, error)
|
|
React(ctx context.Context, in *ReactRequest, opts ...grpc.CallOption) (*ReactResponse, error)
|
|
SetStateLabel(ctx context.Context, in *SetStateLabelRequest, opts ...grpc.CallOption) (*SetStateLabelResponse, error)
|
|
CreatePR(ctx context.Context, in *CreatePRRequest, opts ...grpc.CallOption) (*CreatePRResponse, error)
|
|
PRState(ctx context.Context, in *PRStateRequest, opts ...grpc.CallOption) (*PRStateResponse, error)
|
|
ClosePR(ctx context.Context, in *ClosePRRequest, opts ...grpc.CallOption) (*ClosePRResponse, error)
|
|
MergePR(ctx context.Context, in *MergePRRequest, opts ...grpc.CallOption) (*MergePRResponse, error)
|
|
GetPullRequest(ctx context.Context, in *GetPullRequestRequest, opts ...grpc.CallOption) (*GetPullRequestResponse, error)
|
|
GetPullRequestDiff(ctx context.Context, in *GetPullRequestDiffRequest, opts ...grpc.CallOption) (*GetPullRequestDiffResponse, error)
|
|
ListReviews(ctx context.Context, in *ListReviewsRequest, opts ...grpc.CallOption) (*ListReviewsResponse, error)
|
|
ListReviewComments(ctx context.Context, in *ListReviewCommentsRequest, opts ...grpc.CallOption) (*ListReviewCommentsResponse, error)
|
|
// HasWriteAccess reports whether a user holds write (push) access to a
|
|
// repository. Text from users without it is untrusted.
|
|
HasWriteAccess(ctx context.Context, in *HasWriteAccessRequest, opts ...grpc.CallOption) (*HasWriteAccessResponse, error)
|
|
ReplyToReview(ctx context.Context, in *ReplyToReviewRequest, opts ...grpc.CallOption) (*ReplyToReviewResponse, error)
|
|
CreateReviewComments(ctx context.Context, in *CreateReviewCommentsRequest, opts ...grpc.CallOption) (*CreateReviewCommentsResponse, error)
|
|
AcceptInvitations(ctx context.Context, in *AcceptInvitationsRequest, opts ...grpc.CallOption) (*AcceptInvitationsResponse, error)
|
|
VerifyPush(ctx context.Context, in *VerifyPushRequest, opts ...grpc.CallOption) (*VerifyPushResponse, error)
|
|
LinkBranch(ctx context.Context, in *LinkBranchRequest, opts ...grpc.CallOption) (*LinkBranchResponse, error)
|
|
// GitCredential returns a short-lived credential for cloning and pushing one
|
|
// repository, and the identity commits through it should carry. A forge that
|
|
// authenticates git with its configured token answers UNIMPLEMENTED.
|
|
GitCredential(ctx context.Context, in *GitCredentialRequest, opts ...grpc.CallOption) (*GitCredentialResponse, error)
|
|
// GetRepoArchive streams a gzipped tar of the repository at a ref.
|
|
GetRepoArchive(ctx context.Context, in *GetRepoArchiveRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[GetRepoArchiveResponse], error)
|
|
}
|
|
|
|
type forgeServiceClient struct {
|
|
cc grpc.ClientConnInterface
|
|
}
|
|
|
|
func NewForgeServiceClient(cc grpc.ClientConnInterface) ForgeServiceClient {
|
|
return &forgeServiceClient{cc}
|
|
}
|
|
|
|
func (c *forgeServiceClient) Configure(ctx context.Context, in *ConfigureRequest, opts ...grpc.CallOption) (*ConfigureResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(ConfigureResponse)
|
|
err := c.cc.Invoke(ctx, ForgeService_Configure_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *forgeServiceClient) AssignedIssues(ctx context.Context, in *AssignedIssuesRequest, opts ...grpc.CallOption) (*AssignedIssuesResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(AssignedIssuesResponse)
|
|
err := c.cc.Invoke(ctx, ForgeService_AssignedIssues_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *forgeServiceClient) IssuesWithLabel(ctx context.Context, in *IssuesWithLabelRequest, opts ...grpc.CallOption) (*IssuesWithLabelResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(IssuesWithLabelResponse)
|
|
err := c.cc.Invoke(ctx, ForgeService_IssuesWithLabel_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *forgeServiceClient) Comment(ctx context.Context, in *CommentRequest, opts ...grpc.CallOption) (*CommentResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(CommentResponse)
|
|
err := c.cc.Invoke(ctx, ForgeService_Comment_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *forgeServiceClient) CreateIssue(ctx context.Context, in *CreateIssueRequest, opts ...grpc.CallOption) (*CreateIssueResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(CreateIssueResponse)
|
|
err := c.cc.Invoke(ctx, ForgeService_CreateIssue_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *forgeServiceClient) CloseIssue(ctx context.Context, in *CloseIssueRequest, opts ...grpc.CallOption) (*CloseIssueResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(CloseIssueResponse)
|
|
err := c.cc.Invoke(ctx, ForgeService_CloseIssue_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *forgeServiceClient) React(ctx context.Context, in *ReactRequest, opts ...grpc.CallOption) (*ReactResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(ReactResponse)
|
|
err := c.cc.Invoke(ctx, ForgeService_React_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *forgeServiceClient) SetStateLabel(ctx context.Context, in *SetStateLabelRequest, opts ...grpc.CallOption) (*SetStateLabelResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(SetStateLabelResponse)
|
|
err := c.cc.Invoke(ctx, ForgeService_SetStateLabel_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *forgeServiceClient) CreatePR(ctx context.Context, in *CreatePRRequest, opts ...grpc.CallOption) (*CreatePRResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(CreatePRResponse)
|
|
err := c.cc.Invoke(ctx, ForgeService_CreatePR_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *forgeServiceClient) PRState(ctx context.Context, in *PRStateRequest, opts ...grpc.CallOption) (*PRStateResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(PRStateResponse)
|
|
err := c.cc.Invoke(ctx, ForgeService_PRState_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *forgeServiceClient) ClosePR(ctx context.Context, in *ClosePRRequest, opts ...grpc.CallOption) (*ClosePRResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(ClosePRResponse)
|
|
err := c.cc.Invoke(ctx, ForgeService_ClosePR_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *forgeServiceClient) MergePR(ctx context.Context, in *MergePRRequest, opts ...grpc.CallOption) (*MergePRResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(MergePRResponse)
|
|
err := c.cc.Invoke(ctx, ForgeService_MergePR_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *forgeServiceClient) GetPullRequest(ctx context.Context, in *GetPullRequestRequest, opts ...grpc.CallOption) (*GetPullRequestResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(GetPullRequestResponse)
|
|
err := c.cc.Invoke(ctx, ForgeService_GetPullRequest_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *forgeServiceClient) GetPullRequestDiff(ctx context.Context, in *GetPullRequestDiffRequest, opts ...grpc.CallOption) (*GetPullRequestDiffResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(GetPullRequestDiffResponse)
|
|
err := c.cc.Invoke(ctx, ForgeService_GetPullRequestDiff_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *forgeServiceClient) ListReviews(ctx context.Context, in *ListReviewsRequest, opts ...grpc.CallOption) (*ListReviewsResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(ListReviewsResponse)
|
|
err := c.cc.Invoke(ctx, ForgeService_ListReviews_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *forgeServiceClient) ListReviewComments(ctx context.Context, in *ListReviewCommentsRequest, opts ...grpc.CallOption) (*ListReviewCommentsResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(ListReviewCommentsResponse)
|
|
err := c.cc.Invoke(ctx, ForgeService_ListReviewComments_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *forgeServiceClient) HasWriteAccess(ctx context.Context, in *HasWriteAccessRequest, opts ...grpc.CallOption) (*HasWriteAccessResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(HasWriteAccessResponse)
|
|
err := c.cc.Invoke(ctx, ForgeService_HasWriteAccess_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *forgeServiceClient) ReplyToReview(ctx context.Context, in *ReplyToReviewRequest, opts ...grpc.CallOption) (*ReplyToReviewResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(ReplyToReviewResponse)
|
|
err := c.cc.Invoke(ctx, ForgeService_ReplyToReview_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *forgeServiceClient) CreateReviewComments(ctx context.Context, in *CreateReviewCommentsRequest, opts ...grpc.CallOption) (*CreateReviewCommentsResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(CreateReviewCommentsResponse)
|
|
err := c.cc.Invoke(ctx, ForgeService_CreateReviewComments_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *forgeServiceClient) AcceptInvitations(ctx context.Context, in *AcceptInvitationsRequest, opts ...grpc.CallOption) (*AcceptInvitationsResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(AcceptInvitationsResponse)
|
|
err := c.cc.Invoke(ctx, ForgeService_AcceptInvitations_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *forgeServiceClient) VerifyPush(ctx context.Context, in *VerifyPushRequest, opts ...grpc.CallOption) (*VerifyPushResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(VerifyPushResponse)
|
|
err := c.cc.Invoke(ctx, ForgeService_VerifyPush_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *forgeServiceClient) LinkBranch(ctx context.Context, in *LinkBranchRequest, opts ...grpc.CallOption) (*LinkBranchResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(LinkBranchResponse)
|
|
err := c.cc.Invoke(ctx, ForgeService_LinkBranch_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *forgeServiceClient) GitCredential(ctx context.Context, in *GitCredentialRequest, opts ...grpc.CallOption) (*GitCredentialResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(GitCredentialResponse)
|
|
err := c.cc.Invoke(ctx, ForgeService_GitCredential_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *forgeServiceClient) GetRepoArchive(ctx context.Context, in *GetRepoArchiveRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[GetRepoArchiveResponse], error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
stream, err := c.cc.NewStream(ctx, &ForgeService_ServiceDesc.Streams[0], ForgeService_GetRepoArchive_FullMethodName, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
x := &grpc.GenericClientStream[GetRepoArchiveRequest, GetRepoArchiveResponse]{ClientStream: stream}
|
|
if err := x.ClientStream.SendMsg(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := x.ClientStream.CloseSend(); err != nil {
|
|
return nil, err
|
|
}
|
|
return x, nil
|
|
}
|
|
|
|
// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
|
|
type ForgeService_GetRepoArchiveClient = grpc.ServerStreamingClient[GetRepoArchiveResponse]
|
|
|
|
// ForgeServiceServer is the server API for ForgeService service.
|
|
// All implementations must embed UnimplementedForgeServiceServer
|
|
// for forward compatibility.
|
|
//
|
|
// ForgeService is the surface a forge extension serves. The host launches one
|
|
// plugin process per configured forge instance and routes every issue, pull
|
|
// request and repository call of that instance through it. The calls follow
|
|
// the host's forge interfaces; a capability the forge lacks answers
|
|
// UNIMPLEMENTED.
|
|
type ForgeServiceServer interface {
|
|
// Configure hands the plugin its instance once, right after launch and
|
|
// before any other call. The token is the instance's resolved credential;
|
|
// the plugin process does not inherit the host environment.
|
|
Configure(context.Context, *ConfigureRequest) (*ConfigureResponse, error)
|
|
AssignedIssues(context.Context, *AssignedIssuesRequest) (*AssignedIssuesResponse, error)
|
|
IssuesWithLabel(context.Context, *IssuesWithLabelRequest) (*IssuesWithLabelResponse, error)
|
|
Comment(context.Context, *CommentRequest) (*CommentResponse, error)
|
|
CreateIssue(context.Context, *CreateIssueRequest) (*CreateIssueResponse, error)
|
|
CloseIssue(context.Context, *CloseIssueRequest) (*CloseIssueResponse, error)
|
|
React(context.Context, *ReactRequest) (*ReactResponse, error)
|
|
SetStateLabel(context.Context, *SetStateLabelRequest) (*SetStateLabelResponse, error)
|
|
CreatePR(context.Context, *CreatePRRequest) (*CreatePRResponse, error)
|
|
PRState(context.Context, *PRStateRequest) (*PRStateResponse, error)
|
|
ClosePR(context.Context, *ClosePRRequest) (*ClosePRResponse, error)
|
|
MergePR(context.Context, *MergePRRequest) (*MergePRResponse, error)
|
|
GetPullRequest(context.Context, *GetPullRequestRequest) (*GetPullRequestResponse, error)
|
|
GetPullRequestDiff(context.Context, *GetPullRequestDiffRequest) (*GetPullRequestDiffResponse, error)
|
|
ListReviews(context.Context, *ListReviewsRequest) (*ListReviewsResponse, error)
|
|
ListReviewComments(context.Context, *ListReviewCommentsRequest) (*ListReviewCommentsResponse, error)
|
|
// HasWriteAccess reports whether a user holds write (push) access to a
|
|
// repository. Text from users without it is untrusted.
|
|
HasWriteAccess(context.Context, *HasWriteAccessRequest) (*HasWriteAccessResponse, error)
|
|
ReplyToReview(context.Context, *ReplyToReviewRequest) (*ReplyToReviewResponse, error)
|
|
CreateReviewComments(context.Context, *CreateReviewCommentsRequest) (*CreateReviewCommentsResponse, error)
|
|
AcceptInvitations(context.Context, *AcceptInvitationsRequest) (*AcceptInvitationsResponse, error)
|
|
VerifyPush(context.Context, *VerifyPushRequest) (*VerifyPushResponse, error)
|
|
LinkBranch(context.Context, *LinkBranchRequest) (*LinkBranchResponse, error)
|
|
// GitCredential returns a short-lived credential for cloning and pushing one
|
|
// repository, and the identity commits through it should carry. A forge that
|
|
// authenticates git with its configured token answers UNIMPLEMENTED.
|
|
GitCredential(context.Context, *GitCredentialRequest) (*GitCredentialResponse, error)
|
|
// GetRepoArchive streams a gzipped tar of the repository at a ref.
|
|
GetRepoArchive(*GetRepoArchiveRequest, grpc.ServerStreamingServer[GetRepoArchiveResponse]) error
|
|
mustEmbedUnimplementedForgeServiceServer()
|
|
}
|
|
|
|
// UnimplementedForgeServiceServer 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 UnimplementedForgeServiceServer struct{}
|
|
|
|
func (UnimplementedForgeServiceServer) Configure(context.Context, *ConfigureRequest) (*ConfigureResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method Configure not implemented")
|
|
}
|
|
func (UnimplementedForgeServiceServer) AssignedIssues(context.Context, *AssignedIssuesRequest) (*AssignedIssuesResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method AssignedIssues not implemented")
|
|
}
|
|
func (UnimplementedForgeServiceServer) IssuesWithLabel(context.Context, *IssuesWithLabelRequest) (*IssuesWithLabelResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method IssuesWithLabel not implemented")
|
|
}
|
|
func (UnimplementedForgeServiceServer) Comment(context.Context, *CommentRequest) (*CommentResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method Comment not implemented")
|
|
}
|
|
func (UnimplementedForgeServiceServer) CreateIssue(context.Context, *CreateIssueRequest) (*CreateIssueResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method CreateIssue not implemented")
|
|
}
|
|
func (UnimplementedForgeServiceServer) CloseIssue(context.Context, *CloseIssueRequest) (*CloseIssueResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method CloseIssue not implemented")
|
|
}
|
|
func (UnimplementedForgeServiceServer) React(context.Context, *ReactRequest) (*ReactResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method React not implemented")
|
|
}
|
|
func (UnimplementedForgeServiceServer) SetStateLabel(context.Context, *SetStateLabelRequest) (*SetStateLabelResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method SetStateLabel not implemented")
|
|
}
|
|
func (UnimplementedForgeServiceServer) CreatePR(context.Context, *CreatePRRequest) (*CreatePRResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method CreatePR not implemented")
|
|
}
|
|
func (UnimplementedForgeServiceServer) PRState(context.Context, *PRStateRequest) (*PRStateResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method PRState not implemented")
|
|
}
|
|
func (UnimplementedForgeServiceServer) ClosePR(context.Context, *ClosePRRequest) (*ClosePRResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method ClosePR not implemented")
|
|
}
|
|
func (UnimplementedForgeServiceServer) MergePR(context.Context, *MergePRRequest) (*MergePRResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method MergePR not implemented")
|
|
}
|
|
func (UnimplementedForgeServiceServer) GetPullRequest(context.Context, *GetPullRequestRequest) (*GetPullRequestResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method GetPullRequest not implemented")
|
|
}
|
|
func (UnimplementedForgeServiceServer) GetPullRequestDiff(context.Context, *GetPullRequestDiffRequest) (*GetPullRequestDiffResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method GetPullRequestDiff not implemented")
|
|
}
|
|
func (UnimplementedForgeServiceServer) ListReviews(context.Context, *ListReviewsRequest) (*ListReviewsResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method ListReviews not implemented")
|
|
}
|
|
func (UnimplementedForgeServiceServer) ListReviewComments(context.Context, *ListReviewCommentsRequest) (*ListReviewCommentsResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method ListReviewComments not implemented")
|
|
}
|
|
func (UnimplementedForgeServiceServer) HasWriteAccess(context.Context, *HasWriteAccessRequest) (*HasWriteAccessResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method HasWriteAccess not implemented")
|
|
}
|
|
func (UnimplementedForgeServiceServer) ReplyToReview(context.Context, *ReplyToReviewRequest) (*ReplyToReviewResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method ReplyToReview not implemented")
|
|
}
|
|
func (UnimplementedForgeServiceServer) CreateReviewComments(context.Context, *CreateReviewCommentsRequest) (*CreateReviewCommentsResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method CreateReviewComments not implemented")
|
|
}
|
|
func (UnimplementedForgeServiceServer) AcceptInvitations(context.Context, *AcceptInvitationsRequest) (*AcceptInvitationsResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method AcceptInvitations not implemented")
|
|
}
|
|
func (UnimplementedForgeServiceServer) VerifyPush(context.Context, *VerifyPushRequest) (*VerifyPushResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method VerifyPush not implemented")
|
|
}
|
|
func (UnimplementedForgeServiceServer) LinkBranch(context.Context, *LinkBranchRequest) (*LinkBranchResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method LinkBranch not implemented")
|
|
}
|
|
func (UnimplementedForgeServiceServer) GitCredential(context.Context, *GitCredentialRequest) (*GitCredentialResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method GitCredential not implemented")
|
|
}
|
|
func (UnimplementedForgeServiceServer) GetRepoArchive(*GetRepoArchiveRequest, grpc.ServerStreamingServer[GetRepoArchiveResponse]) error {
|
|
return status.Error(codes.Unimplemented, "method GetRepoArchive not implemented")
|
|
}
|
|
func (UnimplementedForgeServiceServer) mustEmbedUnimplementedForgeServiceServer() {}
|
|
func (UnimplementedForgeServiceServer) testEmbeddedByValue() {}
|
|
|
|
// UnsafeForgeServiceServer may be embedded to opt out of forward compatibility for this service.
|
|
// Use of this interface is not recommended, as added methods to ForgeServiceServer will
|
|
// result in compilation errors.
|
|
type UnsafeForgeServiceServer interface {
|
|
mustEmbedUnimplementedForgeServiceServer()
|
|
}
|
|
|
|
func RegisterForgeServiceServer(s grpc.ServiceRegistrar, srv ForgeServiceServer) {
|
|
// If the following call panics, it indicates UnimplementedForgeServiceServer 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(&ForgeService_ServiceDesc, srv)
|
|
}
|
|
|
|
func _ForgeService_Configure_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(ConfigureRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ForgeServiceServer).Configure(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ForgeService_Configure_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ForgeServiceServer).Configure(ctx, req.(*ConfigureRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ForgeService_AssignedIssues_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(AssignedIssuesRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ForgeServiceServer).AssignedIssues(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ForgeService_AssignedIssues_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ForgeServiceServer).AssignedIssues(ctx, req.(*AssignedIssuesRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ForgeService_IssuesWithLabel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(IssuesWithLabelRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ForgeServiceServer).IssuesWithLabel(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ForgeService_IssuesWithLabel_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ForgeServiceServer).IssuesWithLabel(ctx, req.(*IssuesWithLabelRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ForgeService_Comment_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(CommentRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ForgeServiceServer).Comment(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ForgeService_Comment_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ForgeServiceServer).Comment(ctx, req.(*CommentRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ForgeService_CreateIssue_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(CreateIssueRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ForgeServiceServer).CreateIssue(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ForgeService_CreateIssue_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ForgeServiceServer).CreateIssue(ctx, req.(*CreateIssueRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ForgeService_CloseIssue_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(CloseIssueRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ForgeServiceServer).CloseIssue(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ForgeService_CloseIssue_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ForgeServiceServer).CloseIssue(ctx, req.(*CloseIssueRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ForgeService_React_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(ReactRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ForgeServiceServer).React(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ForgeService_React_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ForgeServiceServer).React(ctx, req.(*ReactRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ForgeService_SetStateLabel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(SetStateLabelRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ForgeServiceServer).SetStateLabel(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ForgeService_SetStateLabel_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ForgeServiceServer).SetStateLabel(ctx, req.(*SetStateLabelRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ForgeService_CreatePR_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(CreatePRRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ForgeServiceServer).CreatePR(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ForgeService_CreatePR_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ForgeServiceServer).CreatePR(ctx, req.(*CreatePRRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ForgeService_PRState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(PRStateRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ForgeServiceServer).PRState(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ForgeService_PRState_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ForgeServiceServer).PRState(ctx, req.(*PRStateRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ForgeService_ClosePR_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(ClosePRRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ForgeServiceServer).ClosePR(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ForgeService_ClosePR_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ForgeServiceServer).ClosePR(ctx, req.(*ClosePRRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ForgeService_MergePR_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(MergePRRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ForgeServiceServer).MergePR(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ForgeService_MergePR_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ForgeServiceServer).MergePR(ctx, req.(*MergePRRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ForgeService_GetPullRequest_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(GetPullRequestRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ForgeServiceServer).GetPullRequest(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ForgeService_GetPullRequest_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ForgeServiceServer).GetPullRequest(ctx, req.(*GetPullRequestRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ForgeService_GetPullRequestDiff_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(GetPullRequestDiffRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ForgeServiceServer).GetPullRequestDiff(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ForgeService_GetPullRequestDiff_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ForgeServiceServer).GetPullRequestDiff(ctx, req.(*GetPullRequestDiffRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ForgeService_ListReviews_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(ListReviewsRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ForgeServiceServer).ListReviews(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ForgeService_ListReviews_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ForgeServiceServer).ListReviews(ctx, req.(*ListReviewsRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ForgeService_ListReviewComments_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(ListReviewCommentsRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ForgeServiceServer).ListReviewComments(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ForgeService_ListReviewComments_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ForgeServiceServer).ListReviewComments(ctx, req.(*ListReviewCommentsRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ForgeService_HasWriteAccess_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(HasWriteAccessRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ForgeServiceServer).HasWriteAccess(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ForgeService_HasWriteAccess_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ForgeServiceServer).HasWriteAccess(ctx, req.(*HasWriteAccessRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ForgeService_ReplyToReview_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(ReplyToReviewRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ForgeServiceServer).ReplyToReview(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ForgeService_ReplyToReview_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ForgeServiceServer).ReplyToReview(ctx, req.(*ReplyToReviewRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ForgeService_CreateReviewComments_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(CreateReviewCommentsRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ForgeServiceServer).CreateReviewComments(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ForgeService_CreateReviewComments_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ForgeServiceServer).CreateReviewComments(ctx, req.(*CreateReviewCommentsRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ForgeService_AcceptInvitations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(AcceptInvitationsRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ForgeServiceServer).AcceptInvitations(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ForgeService_AcceptInvitations_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ForgeServiceServer).AcceptInvitations(ctx, req.(*AcceptInvitationsRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ForgeService_VerifyPush_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(VerifyPushRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ForgeServiceServer).VerifyPush(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ForgeService_VerifyPush_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ForgeServiceServer).VerifyPush(ctx, req.(*VerifyPushRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ForgeService_LinkBranch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(LinkBranchRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ForgeServiceServer).LinkBranch(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ForgeService_LinkBranch_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ForgeServiceServer).LinkBranch(ctx, req.(*LinkBranchRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ForgeService_GitCredential_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(GitCredentialRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ForgeServiceServer).GitCredential(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ForgeService_GitCredential_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ForgeServiceServer).GitCredential(ctx, req.(*GitCredentialRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ForgeService_GetRepoArchive_Handler(srv interface{}, stream grpc.ServerStream) error {
|
|
m := new(GetRepoArchiveRequest)
|
|
if err := stream.RecvMsg(m); err != nil {
|
|
return err
|
|
}
|
|
return srv.(ForgeServiceServer).GetRepoArchive(m, &grpc.GenericServerStream[GetRepoArchiveRequest, GetRepoArchiveResponse]{ServerStream: stream})
|
|
}
|
|
|
|
// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
|
|
type ForgeService_GetRepoArchiveServer = grpc.ServerStreamingServer[GetRepoArchiveResponse]
|
|
|
|
// ForgeService_ServiceDesc is the grpc.ServiceDesc for ForgeService service.
|
|
// It's only intended for direct use with grpc.RegisterService,
|
|
// and not to be introspected or modified (even as a copy)
|
|
var ForgeService_ServiceDesc = grpc.ServiceDesc{
|
|
ServiceName: "forge.v1.ForgeService",
|
|
HandlerType: (*ForgeServiceServer)(nil),
|
|
Methods: []grpc.MethodDesc{
|
|
{
|
|
MethodName: "Configure",
|
|
Handler: _ForgeService_Configure_Handler,
|
|
},
|
|
{
|
|
MethodName: "AssignedIssues",
|
|
Handler: _ForgeService_AssignedIssues_Handler,
|
|
},
|
|
{
|
|
MethodName: "IssuesWithLabel",
|
|
Handler: _ForgeService_IssuesWithLabel_Handler,
|
|
},
|
|
{
|
|
MethodName: "Comment",
|
|
Handler: _ForgeService_Comment_Handler,
|
|
},
|
|
{
|
|
MethodName: "CreateIssue",
|
|
Handler: _ForgeService_CreateIssue_Handler,
|
|
},
|
|
{
|
|
MethodName: "CloseIssue",
|
|
Handler: _ForgeService_CloseIssue_Handler,
|
|
},
|
|
{
|
|
MethodName: "React",
|
|
Handler: _ForgeService_React_Handler,
|
|
},
|
|
{
|
|
MethodName: "SetStateLabel",
|
|
Handler: _ForgeService_SetStateLabel_Handler,
|
|
},
|
|
{
|
|
MethodName: "CreatePR",
|
|
Handler: _ForgeService_CreatePR_Handler,
|
|
},
|
|
{
|
|
MethodName: "PRState",
|
|
Handler: _ForgeService_PRState_Handler,
|
|
},
|
|
{
|
|
MethodName: "ClosePR",
|
|
Handler: _ForgeService_ClosePR_Handler,
|
|
},
|
|
{
|
|
MethodName: "MergePR",
|
|
Handler: _ForgeService_MergePR_Handler,
|
|
},
|
|
{
|
|
MethodName: "GetPullRequest",
|
|
Handler: _ForgeService_GetPullRequest_Handler,
|
|
},
|
|
{
|
|
MethodName: "GetPullRequestDiff",
|
|
Handler: _ForgeService_GetPullRequestDiff_Handler,
|
|
},
|
|
{
|
|
MethodName: "ListReviews",
|
|
Handler: _ForgeService_ListReviews_Handler,
|
|
},
|
|
{
|
|
MethodName: "ListReviewComments",
|
|
Handler: _ForgeService_ListReviewComments_Handler,
|
|
},
|
|
{
|
|
MethodName: "HasWriteAccess",
|
|
Handler: _ForgeService_HasWriteAccess_Handler,
|
|
},
|
|
{
|
|
MethodName: "ReplyToReview",
|
|
Handler: _ForgeService_ReplyToReview_Handler,
|
|
},
|
|
{
|
|
MethodName: "CreateReviewComments",
|
|
Handler: _ForgeService_CreateReviewComments_Handler,
|
|
},
|
|
{
|
|
MethodName: "AcceptInvitations",
|
|
Handler: _ForgeService_AcceptInvitations_Handler,
|
|
},
|
|
{
|
|
MethodName: "VerifyPush",
|
|
Handler: _ForgeService_VerifyPush_Handler,
|
|
},
|
|
{
|
|
MethodName: "LinkBranch",
|
|
Handler: _ForgeService_LinkBranch_Handler,
|
|
},
|
|
{
|
|
MethodName: "GitCredential",
|
|
Handler: _ForgeService_GitCredential_Handler,
|
|
},
|
|
},
|
|
Streams: []grpc.StreamDesc{
|
|
{
|
|
StreamName: "GetRepoArchive",
|
|
Handler: _ForgeService_GetRepoArchive_Handler,
|
|
ServerStreams: true,
|
|
},
|
|
},
|
|
Metadata: "forge/v1/forge.proto",
|
|
}
|