feat(forgeext): forge surface served by extensions; forge.type names the installed package
This commit is contained in:
1 parent
37c6a71343
commit
153dfc094c
12 files changed
+4303
-98
No files matched your search
@@ -47,6 +47,7 @@ import (
|
||||
infraaccess "github.com/samcharles93/archie-core/internal/infrastructure/access"
|
||||
"github.com/samcharles93/archie-core/internal/infrastructure/configuration"
|
||||
"github.com/samcharles93/archie-core/internal/infrastructure/eventbus/nats"
|
||||
"github.com/samcharles93/archie-core/internal/infrastructure/extension"
|
||||
"github.com/samcharles93/archie-core/internal/infrastructure/modelcatalog"
|
||||
"github.com/samcharles93/archie-core/internal/infrastructure/staterpc"
|
||||
"github.com/samcharles93/archie-core/internal/infrastructure/taskactions"
|
||||
@@ -84,6 +85,7 @@ type boot struct {
|
||||
|
||||
secrets *secret.Registry
|
||||
forgeClient forge.Forge
|
||||
forgeExt *forgeExtensions
|
||||
token string
|
||||
|
||||
// stateStore is the State Store contract adapter every daemon and gateway
|
||||
@@ -251,8 +253,12 @@ func (b *boot) openStores(ctx context.Context) error {
|
||||
|
||||
// openForge builds the forge client. It runs after the runtime settings are
|
||||
// layered, so a token held by an extension engine can resolve.
|
||||
func (b *boot) openForge() {
|
||||
b.forgeClient, b.token = resolveForge(b.cfg.Forge, b.secrets, b.log)
|
||||
func (b *boot) openForge(ctx context.Context) {
|
||||
if packages, ok := b.stateStore.(extension.Packages); ok {
|
||||
b.forgeExt = newForgeExtensions(extension.Source{Query: b.controlPlane, Packages: packages}, b.log)
|
||||
b.addCleanup(b.forgeExt.close)
|
||||
}
|
||||
b.forgeClient, b.token = resolveForge(ctx, b.cfg.Forge, "default", b.secrets, b.forgeExt, b.log)
|
||||
}
|
||||
|
||||
func (b *boot) openStateStoreAdapter(ctx context.Context) error {
|
||||
@@ -530,7 +536,7 @@ func (b *boot) buildTreesAndIdentities(ctx context.Context) error {
|
||||
b.buildWorktreeManager()
|
||||
|
||||
for _, idCfg := range cfg.Identities {
|
||||
idForge, idToken := resolveForge(idCfg.Forge, b.secrets, log.With("identity", idCfg.Name))
|
||||
idForge, idToken := resolveForge(ctx, idCfg.Forge, idCfg.Name, b.secrets, b.forgeExt, log.With("identity", idCfg.Name))
|
||||
idTrees := &worktree.Manager{
|
||||
WorkDir: filepath.Join(cfg.WorkDir, "identity-"+idCfg.Name),
|
||||
Token: idToken,
|
||||
|
||||
@@ -0,0 +1,96 @@
|
||||
package archied
|
||||
|
||||
import (
|
||||
"context"
|
||||
"log/slog"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"slices"
|
||||
|
||||
"github.com/hashicorp/go-hclog"
|
||||
|
||||
"github.com/samcharles93/archie-core/internal/domain/storepkg"
|
||||
"github.com/samcharles93/archie-core/internal/forge"
|
||||
"github.com/samcharles93/archie-core/internal/infrastructure/extension"
|
||||
"github.com/samcharles93/archie-core/internal/infrastructure/forgeext"
|
||||
)
|
||||
|
||||
// forgeExtensions opens forge instances served by installed forge extensions:
|
||||
// the package named by forge.type, with its authority accepted and enabled in
|
||||
// extension-settings. Changing which extension serves a forge takes a restart,
|
||||
// as every forge setting does.
|
||||
type forgeExtensions struct {
|
||||
host *extension.Host
|
||||
source extension.Source
|
||||
cacheDir string
|
||||
log *slog.Logger
|
||||
}
|
||||
|
||||
func newForgeExtensions(source extension.Source, log *slog.Logger) *forgeExtensions {
|
||||
cache, err := os.UserCacheDir()
|
||||
if err != nil {
|
||||
log.Warn("forge extensions unavailable: no cache directory", "err", err)
|
||||
return nil
|
||||
}
|
||||
return &forgeExtensions{
|
||||
host: extension.NewHost(hclog.New(&hclog.LoggerOptions{Name: "extension", Level: hclog.Warn})),
|
||||
source: source,
|
||||
cacheDir: filepath.Join(cache, "archie", "extensions", "forge"),
|
||||
log: log,
|
||||
}
|
||||
}
|
||||
|
||||
// open returns the instance's forge when an enabled extension named typ serves
|
||||
// it. handled is false when none does, so the caller falls back to the
|
||||
// compiled-in forge; an extension that is enabled but will not start is
|
||||
// handled, as a forge that fails rather than a different one.
|
||||
func (e *forgeExtensions) open(ctx context.Context, typ, instance, host, token string) (f forge.Forge, handled bool) {
|
||||
if e == nil {
|
||||
return nil, false
|
||||
}
|
||||
settings, _, err := e.source.Enabled(ctx)
|
||||
if err != nil {
|
||||
e.log.Warn("forge extensions: extension settings unavailable", "err", err)
|
||||
return nil, false
|
||||
}
|
||||
setting, ok := settings[typ]
|
||||
if !ok || !setting.Enabled {
|
||||
return nil, false
|
||||
}
|
||||
installed, err := e.source.Packages.ListInstalled(ctx, extension.OrgID)
|
||||
if err != nil {
|
||||
e.log.Warn("forge extensions: installed packages unavailable", "err", err)
|
||||
return nil, false
|
||||
}
|
||||
for _, pkg := range installed {
|
||||
if pkg.Name != typ || pkg.AcceptedAuthority == nil {
|
||||
continue
|
||||
}
|
||||
index := slices.IndexFunc(pkg.Descriptor.Contributes.Extensions, func(x storepkg.Extension) bool { return x.Surface == storepkg.SurfaceForge })
|
||||
if index < 0 {
|
||||
continue
|
||||
}
|
||||
forgeClient, err := e.start(ctx, pkg, pkg.Descriptor.Contributes.Extensions[index].Path, instance, host, token, setting.Settings)
|
||||
if err != nil {
|
||||
e.log.Warn("forge disabled: extension did not start", "forge_type", typ, "instance", instance, "err", err)
|
||||
return forge.NewNoop(e.log), true
|
||||
}
|
||||
return forgeClient, true
|
||||
}
|
||||
return nil, false
|
||||
}
|
||||
|
||||
func (e *forgeExtensions) start(ctx context.Context, pkg storepkg.Installed, file, instance, host, token string, settings map[string]string) (forge.Forge, error) {
|
||||
binary, sum, err := extension.Materialize(ctx, e.source.Packages, e.cacheDir, pkg, file)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
spec := extension.Spec{Name: "forge/" + instance, Path: binary, SHA256: sum, Env: slices.Clone(pkg.AcceptedAuthority.Env)}
|
||||
return forgeext.Open(ctx, e.host, forgeext.Instance{Spec: spec, Host: host, Token: token, Settings: settings}, e.log)
|
||||
}
|
||||
|
||||
func (e *forgeExtensions) close() {
|
||||
if e != nil {
|
||||
e.host.Close()
|
||||
}
|
||||
}
|
||||
@@ -53,7 +53,7 @@ import (
|
||||
// becomes a crash loop where the error scrolls past unread. A malformed
|
||||
// configuration is a different matter and still fails fast in validation, well
|
||||
// before this point.
|
||||
func resolveForge(cfg config.Forge, secrets *secret.Registry, log *slog.Logger) (forge.Forge, string) {
|
||||
func resolveForge(ctx context.Context, cfg config.Forge, instance string, secrets *secret.Registry, extensions *forgeExtensions, log *slog.Logger) (forge.Forge, string) {
|
||||
if configuration.ForgeDisabled(cfg.Type) {
|
||||
return forge.NewNoop(log), ""
|
||||
}
|
||||
@@ -66,6 +66,9 @@ func resolveForge(cfg config.Forge, secrets *secret.Registry, log *slog.Logger)
|
||||
"err", err)
|
||||
return forge.NewNoop(log), ""
|
||||
}
|
||||
if client, handled := extensions.open(ctx, cfg.Type, instance, cfg.Host, token); handled {
|
||||
return client, token
|
||||
}
|
||||
client, err := forge.New(cfg.Type, token, cfg.Host, log)
|
||||
if err != nil {
|
||||
log.Warn("forge disabled: client construction failed",
|
||||
@@ -157,7 +160,7 @@ func Run() int { //nolint:cyclop,funlen // the composition root's setup sequence
|
||||
b.log.Error("runtime settings unavailable", "err", err)
|
||||
return 1
|
||||
}
|
||||
b.openForge()
|
||||
b.openForge(ctx)
|
||||
if err := b.startLiveSettings(ctx); err != nil {
|
||||
b.log.Error("live settings unavailable", "err", err)
|
||||
return 1
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,829 @@
|
||||
// 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_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_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_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_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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
// 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) 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) 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) 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) 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)
|
||||
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)
|
||||
GetPullRequest(context.Context, *GetPullRequestRequest) (*GetPullRequestResponse, error)
|
||||
GetPullRequestDiff(context.Context, *GetPullRequestDiffRequest) (*GetPullRequestDiffResponse, error)
|
||||
ListReviews(context.Context, *ListReviewsRequest) (*ListReviewsResponse, error)
|
||||
ListReviewComments(context.Context, *ListReviewCommentsRequest) (*ListReviewCommentsResponse, 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)
|
||||
// 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) 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) 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) 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) 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_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_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_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_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: "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: "GetPullRequest",
|
||||
Handler: _ForgeService_GetPullRequest_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "GetPullRequestDiff",
|
||||
Handler: _ForgeService_GetPullRequestDiff_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "ListReviews",
|
||||
Handler: _ForgeService_ListReviews_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "ListReviewComments",
|
||||
Handler: _ForgeService_ListReviewComments_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,
|
||||
},
|
||||
},
|
||||
Streams: []grpc.StreamDesc{
|
||||
{
|
||||
StreamName: "GetRepoArchive",
|
||||
Handler: _ForgeService_GetRepoArchive_Handler,
|
||||
ServerStreams: true,
|
||||
},
|
||||
},
|
||||
Metadata: "forge/v1/forge.proto",
|
||||
}
|
||||
@@ -51,9 +51,14 @@ type Extension struct {
|
||||
}
|
||||
|
||||
// Surfaces are the extension surfaces the host defines a contract for.
|
||||
const SurfaceSecretEngine = "secretengine"
|
||||
const (
|
||||
SurfaceSecretEngine = "secretengine"
|
||||
SurfaceForge = "forge"
|
||||
)
|
||||
|
||||
func validSurface(surface string) bool { return surface == SurfaceSecretEngine }
|
||||
func validSurface(surface string) bool {
|
||||
return surface == SurfaceSecretEngine || surface == SurfaceForge
|
||||
}
|
||||
|
||||
// PackageRef identifies a required package or Kit. References are pinned to
|
||||
// immutable content digests so dependency resolution cannot drift by tag.
|
||||
|
||||
@@ -37,7 +37,7 @@ func TestDescriptorExecutableOnlyForExtensions(t *testing.T) {
|
||||
d.Contributes.Extensions[0].Path = "bin/other"
|
||||
}, wantErr: "not a declared package file"},
|
||||
{name: "an unknown surface is refused", mutate: func(d *Descriptor) {
|
||||
d.Contributes.Extensions[0].Surface = "forge"
|
||||
d.Contributes.Extensions[0].Surface = "issue-tracker"
|
||||
}, wantErr: "unknown surface"},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
|
||||
@@ -4,6 +4,7 @@ import (
|
||||
"fmt"
|
||||
"net/url"
|
||||
"path/filepath"
|
||||
"regexp"
|
||||
"slices"
|
||||
"strings"
|
||||
|
||||
@@ -30,8 +31,11 @@ const (
|
||||
memoryEngineBuiltin = "builtin"
|
||||
)
|
||||
|
||||
// forgeTypePattern is a package name: forge.type names the installed forge
|
||||
// package that serves the instance, or disables the forge.
|
||||
var forgeTypePattern = regexp.MustCompile(`^[a-z0-9][a-z0-9-]*$`)
|
||||
|
||||
var (
|
||||
forgeTypes = []string{forgeTypeGitHub, forgeTypeGitea, forgeTypeNone, forgeTypeOff, forgeTypeDisabled}
|
||||
dispatchTriggers = []string{dispatchTriggerAssignee, dispatchTriggerLabel, dispatchTriggerEither}
|
||||
natsModes = []string{config.NATSModeEmbedded, config.NATSModeExternal}
|
||||
forgeIntakes = []string{config.ForgeIntakePoll, config.ForgeIntakeWebhook, config.ForgeIntakeBoth}
|
||||
@@ -264,8 +268,8 @@ func validateIdentities(identities []config.IdentityConfig) error {
|
||||
if len(id.Repos) == 0 {
|
||||
return fmt.Errorf("%w: identities[%d] has no [[identities.repos]] entries -- at least one is required", ErrInvalidInput, i)
|
||||
}
|
||||
if !oneOf(id.Forge.Type, forgeTypes) {
|
||||
return fmt.Errorf("%w: identities[%d].forge.type %q (want %s)", ErrInvalidInput, i, id.Forge.Type, list(forgeTypes))
|
||||
if !forgeTypePattern.MatchString(id.Forge.Type) {
|
||||
return fmt.Errorf("%w: identities[%d].forge.type %q (want none or the name of an installed forge package)", ErrInvalidInput, i, id.Forge.Type)
|
||||
}
|
||||
if !ForgeDisabled(id.Forge.Type) && id.Forge.Token == (config.SecretRef{}) {
|
||||
return fmt.Errorf("%w: identities[%d].forge.token is required (each identity needs its own secret reference; unlike the top-level [forge], there is no default)", ErrInvalidInput, i)
|
||||
@@ -286,8 +290,8 @@ func validateSingleIdentity(cfg *config.Config) error {
|
||||
if !identity.ValidDisplayName(cfg.BotUser) {
|
||||
return fmt.Errorf("%w: bot_user is required (or define [[identities]])", ErrInvalidInput)
|
||||
}
|
||||
if !oneOf(cfg.Forge.Type, forgeTypes) {
|
||||
return fmt.Errorf("%w: forge.type %q (want %s)", ErrInvalidInput, cfg.Forge.Type, list(forgeTypes))
|
||||
if !forgeTypePattern.MatchString(cfg.Forge.Type) {
|
||||
return fmt.Errorf("%w: forge.type %q (want none or the name of an installed forge package)", ErrInvalidInput, cfg.Forge.Type)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -0,0 +1,99 @@
|
||||
package extension
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"os"
|
||||
"path"
|
||||
"path/filepath"
|
||||
|
||||
"github.com/samcharles93/archie-core/internal/domain/storepkg"
|
||||
"github.com/samcharles93/archie-core/internal/infrastructure/controlplanerpc"
|
||||
)
|
||||
|
||||
// OrgID is the single-operator install's org, the one packages are installed in.
|
||||
const OrgID = "default"
|
||||
|
||||
// Packages reads installed packages, as *staterpc.Client does.
|
||||
type Packages interface {
|
||||
ListInstalled(ctx context.Context, orgID string) ([]storepkg.Installed, error)
|
||||
GetInstalled(ctx context.Context, orgID, name string) (storepkg.Installed, error)
|
||||
}
|
||||
|
||||
// Source is what an extension supervisor reads: the extension-settings
|
||||
// resource and the installed packages.
|
||||
type Source struct {
|
||||
// Query reads a control-plane resource, as *controlplanerpc.Client does.
|
||||
Query controlplanerpc.ResourceReader
|
||||
Packages Packages
|
||||
}
|
||||
|
||||
// Enabled reads the extension-settings resource, keyed by extension name, and
|
||||
// its version.
|
||||
func (s Source) Enabled(ctx context.Context) (map[string]controlplanerpc.ExtensionSetting, int64, error) {
|
||||
byName := make(map[string]controlplanerpc.ExtensionSetting)
|
||||
version, _, err := s.Query.Query(ctx, controlplanerpc.ExtensionSettingsKind, func(value []byte) error {
|
||||
var doc controlplanerpc.ExtensionSettings
|
||||
if err := json.Unmarshal(value, &doc); err != nil {
|
||||
return err
|
||||
}
|
||||
for _, setting := range doc.Extensions {
|
||||
byName[setting.Name] = setting
|
||||
}
|
||||
return nil
|
||||
})
|
||||
if err != nil {
|
||||
return nil, 0, fmt.Errorf("read extension settings: %w", err)
|
||||
}
|
||||
return byName, version, nil
|
||||
}
|
||||
|
||||
// Materialize writes the package's extension binary under cacheDir, keyed by
|
||||
// package digest, and returns its path and sha256. A binary already there for
|
||||
// this digest is reused.
|
||||
func Materialize(ctx context.Context, packages Packages, cacheDir string, pkg storepkg.Installed, file string) (string, string, error) {
|
||||
full, err := packages.GetInstalled(ctx, OrgID, pkg.Name)
|
||||
if err != nil {
|
||||
return "", "", fmt.Errorf("get installed package: %w", err)
|
||||
}
|
||||
files, err := storepkg.FilesFromLayer(full.Layer)
|
||||
if err != nil {
|
||||
return "", "", err
|
||||
}
|
||||
content, ok := files[file]
|
||||
if !ok {
|
||||
return "", "", fmt.Errorf("package layer has no %q", file)
|
||||
}
|
||||
sum := sha256.Sum256(content)
|
||||
dir := filepath.Join(cacheDir, pkg.Name, hex.EncodeToString(sum[:8]))
|
||||
target := filepath.Join(dir, path.Base(file))
|
||||
if existing, err := os.ReadFile(target); err == nil && sha256.Sum256(existing) == sum {
|
||||
return target, hex.EncodeToString(sum[:]), nil
|
||||
}
|
||||
if err := os.MkdirAll(dir, 0o700); err != nil {
|
||||
return "", "", err
|
||||
}
|
||||
tmp, err := os.CreateTemp(dir, ".extract-*")
|
||||
if err != nil {
|
||||
return "", "", err
|
||||
}
|
||||
defer func() { _ = os.Remove(tmp.Name()) }()
|
||||
if _, err := tmp.Write(content); err != nil {
|
||||
_ = tmp.Close()
|
||||
return "", "", err
|
||||
}
|
||||
if err := tmp.Chmod(0o700); err != nil {
|
||||
_ = tmp.Close()
|
||||
return "", "", err
|
||||
}
|
||||
if err := tmp.Close(); err != nil {
|
||||
return "", "", err
|
||||
}
|
||||
if err := os.Rename(tmp.Name(), target); err != nil {
|
||||
return "", "", err
|
||||
}
|
||||
return target, hex.EncodeToString(sum[:]), nil
|
||||
}
|
||||
@@ -0,0 +1,350 @@
|
||||
// Package forgeext adapts a forge extension, served over the forge.v1 gRPC
|
||||
// surface, to the host's forge.Forge. One extension process serves one
|
||||
// configured forge instance.
|
||||
package forgeext
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"log/slog"
|
||||
"sync"
|
||||
|
||||
goplugin "github.com/hashicorp/go-plugin"
|
||||
"google.golang.org/grpc"
|
||||
"google.golang.org/grpc/codes"
|
||||
"google.golang.org/grpc/status"
|
||||
|
||||
forgev1 "github.com/samcharles93/archie-core/internal/contracts/forge/v1"
|
||||
"github.com/samcharles93/archie-core/internal/forge"
|
||||
"github.com/samcharles93/archie-core/internal/infrastructure/extension"
|
||||
)
|
||||
|
||||
// Surface is the go-plugin surface name a forge binary serves.
|
||||
const Surface = "forge"
|
||||
|
||||
// Plugin is the go-plugin shim for the surface. Impl is set only by a forge
|
||||
// binary serving it.
|
||||
type Plugin struct {
|
||||
goplugin.NetRPCUnsupportedPlugin
|
||||
Impl forgev1.ForgeServiceServer
|
||||
}
|
||||
|
||||
func (p *Plugin) GRPCServer(_ *goplugin.GRPCBroker, s *grpc.Server) error {
|
||||
forgev1.RegisterForgeServiceServer(s, p.Impl)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (*Plugin) GRPCClient(_ context.Context, _ *goplugin.GRPCBroker, c *grpc.ClientConn) (any, error) {
|
||||
return forgev1.NewForgeServiceClient(c), nil
|
||||
}
|
||||
|
||||
// Instance is one forge to run: the plugin binary and what Configure hands it.
|
||||
type Instance struct {
|
||||
Spec extension.Spec
|
||||
Host string
|
||||
Token string
|
||||
Settings map[string]string
|
||||
}
|
||||
|
||||
// Forge calls a forge extension. It owns its process: a call that finds the
|
||||
// process dead starts it again and retries once, and a process that cannot
|
||||
// start fails the call. Callers already retry and report a failing forge, so
|
||||
// nothing is dropped silently.
|
||||
type Forge struct {
|
||||
host *extension.Host
|
||||
inst Instance
|
||||
log *slog.Logger
|
||||
|
||||
mu sync.Mutex
|
||||
client forgev1.ForgeServiceClient
|
||||
}
|
||||
|
||||
var (
|
||||
_ forge.Forge = (*Forge)(nil)
|
||||
_ forge.PullRequestReader = (*Forge)(nil)
|
||||
_ forge.PullRequestDiffReader = (*Forge)(nil)
|
||||
_ forge.RepoArchiveReader = (*Forge)(nil)
|
||||
_ forge.PullRequestReviewReader = (*Forge)(nil)
|
||||
_ forge.ReviewCommentWriter = (*Forge)(nil)
|
||||
)
|
||||
|
||||
// Open starts the instance's extension process and configures it. The process
|
||||
// runs until Close is called, whatever happens to ctx.
|
||||
func Open(ctx context.Context, host *extension.Host, inst Instance, log *slog.Logger) (*Forge, error) {
|
||||
f := &Forge{host: host, inst: inst, log: log}
|
||||
if _, err := f.connect(ctx, nil); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return f, nil
|
||||
}
|
||||
|
||||
// Close stops the extension process.
|
||||
func (f *Forge) Close() { f.host.Stop(f.inst.Spec.Name) }
|
||||
|
||||
// connect returns the live client, starting the process when stale is nil or
|
||||
// is the client the caller just saw fail.
|
||||
func (f *Forge) connect(ctx context.Context, stale forgev1.ForgeServiceClient) (forgev1.ForgeServiceClient, error) {
|
||||
f.mu.Lock()
|
||||
defer f.mu.Unlock()
|
||||
if f.client != nil && f.client != stale && f.host.Alive(f.inst.Spec.Name) {
|
||||
return f.client, nil
|
||||
}
|
||||
raw, err := f.host.Start(context.WithoutCancel(ctx), f.inst.Spec, Surface, &Plugin{})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
client, ok := raw.(forgev1.ForgeServiceClient)
|
||||
if !ok {
|
||||
f.host.Stop(f.inst.Spec.Name)
|
||||
return nil, fmt.Errorf("extension %q: unexpected client type %T", f.inst.Spec.Name, raw)
|
||||
}
|
||||
if _, err := client.Configure(ctx, &forgev1.ConfigureRequest{Host: f.inst.Host, Token: f.inst.Token, Settings: f.inst.Settings}); err != nil {
|
||||
f.host.Stop(f.inst.Spec.Name)
|
||||
return nil, fmt.Errorf("extension %q: configure: %w", f.inst.Spec.Name, err)
|
||||
}
|
||||
f.client = client
|
||||
return client, nil
|
||||
}
|
||||
|
||||
// call runs fn on the live client, restarting the process once when the call
|
||||
// finds it gone.
|
||||
func call[T any](ctx context.Context, f *Forge, op string, fn func(forgev1.ForgeServiceClient) (T, error)) (T, error) {
|
||||
var zero T
|
||||
client, err := f.connect(ctx, nil)
|
||||
if err != nil {
|
||||
return zero, fmt.Errorf("forge %s: %w", op, err)
|
||||
}
|
||||
out, err := fn(client)
|
||||
if status.Code(err) == codes.Unavailable {
|
||||
if client, err = f.connect(ctx, client); err != nil {
|
||||
return zero, fmt.Errorf("forge %s: %w", op, err)
|
||||
}
|
||||
out, err = fn(client)
|
||||
}
|
||||
if status.Code(err) == codes.Unimplemented {
|
||||
return zero, fmt.Errorf("this forge does not support %s", op)
|
||||
}
|
||||
if err != nil {
|
||||
return zero, fmt.Errorf("forge %s: %w", op, err)
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func ref(owner, repo string) *forgev1.RepoRef { return &forgev1.RepoRef{Owner: owner, Repo: repo} }
|
||||
|
||||
func prRef(owner, repo string, number int) *forgev1.PullRequestRef {
|
||||
return &forgev1.PullRequestRef{Repo: ref(owner, repo), Number: int32(number)} //nolint:gosec // issue numbers fit int32
|
||||
}
|
||||
|
||||
func issues(in []*forgev1.Issue) []forge.Issue {
|
||||
out := make([]forge.Issue, 0, len(in))
|
||||
for _, i := range in {
|
||||
out = append(out, forge.Issue{Number: int(i.GetNumber()), Title: i.GetTitle(), Body: i.GetBody(), Labels: i.GetLabels()})
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func (f *Forge) AssignedIssues(ctx context.Context, owner, repo, assignee string) ([]forge.Issue, error) {
|
||||
resp, err := call(ctx, f, "assigned issues", func(c forgev1.ForgeServiceClient) (*forgev1.AssignedIssuesResponse, error) {
|
||||
return c.AssignedIssues(ctx, &forgev1.AssignedIssuesRequest{Repo: ref(owner, repo), Assignee: assignee})
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return issues(resp.GetIssues()), nil
|
||||
}
|
||||
|
||||
func (f *Forge) IssuesWithLabel(ctx context.Context, owner, repo, label string) ([]forge.Issue, error) {
|
||||
resp, err := call(ctx, f, "issues with label", func(c forgev1.ForgeServiceClient) (*forgev1.IssuesWithLabelResponse, error) {
|
||||
return c.IssuesWithLabel(ctx, &forgev1.IssuesWithLabelRequest{Repo: ref(owner, repo), Label: label})
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return issues(resp.GetIssues()), nil
|
||||
}
|
||||
|
||||
func (f *Forge) Comment(ctx context.Context, owner, repo string, number int, body string) (int64, error) {
|
||||
resp, err := call(ctx, f, "comment", func(c forgev1.ForgeServiceClient) (*forgev1.CommentResponse, error) {
|
||||
return c.Comment(ctx, &forgev1.CommentRequest{Repo: ref(owner, repo), Number: int32(number), Body: body}) //nolint:gosec // issue numbers fit int32
|
||||
})
|
||||
return resp.GetId(), err
|
||||
}
|
||||
|
||||
func (f *Forge) CloseIssue(ctx context.Context, owner, repo string, number int, comment string) error {
|
||||
_, err := call(ctx, f, "close issue", func(c forgev1.ForgeServiceClient) (*forgev1.CloseIssueResponse, error) {
|
||||
return c.CloseIssue(ctx, &forgev1.CloseIssueRequest{Repo: ref(owner, repo), Number: int32(number), Comment: comment}) //nolint:gosec // issue numbers fit int32
|
||||
})
|
||||
return err
|
||||
}
|
||||
|
||||
func (f *Forge) React(ctx context.Context, owner, repo string, number int, reaction string) error {
|
||||
_, err := call(ctx, f, "react", func(c forgev1.ForgeServiceClient) (*forgev1.ReactResponse, error) {
|
||||
return c.React(ctx, &forgev1.ReactRequest{Repo: ref(owner, repo), Number: int32(number), Reaction: reaction}) //nolint:gosec // issue numbers fit int32
|
||||
})
|
||||
return err
|
||||
}
|
||||
|
||||
// SetStateLabel has no error to return; a failure is logged and the next
|
||||
// state change corrects the label.
|
||||
func (f *Forge) SetStateLabel(ctx context.Context, owner, repo string, number int, label string, knownLabels []string) {
|
||||
_, err := call(ctx, f, "set state label", func(c forgev1.ForgeServiceClient) (*forgev1.SetStateLabelResponse, error) {
|
||||
return c.SetStateLabel(ctx, &forgev1.SetStateLabelRequest{Repo: ref(owner, repo), Number: int32(number), Label: label, KnownLabels: knownLabels}) //nolint:gosec // issue numbers fit int32
|
||||
})
|
||||
if err != nil {
|
||||
f.log.Warn("set state label", "owner", owner, "repo", repo, "number", number, "err", err)
|
||||
}
|
||||
}
|
||||
|
||||
func (f *Forge) CreatePR(ctx context.Context, owner, repo, title, head, base, body string) (int, error) {
|
||||
resp, err := call(ctx, f, "create pull request", func(c forgev1.ForgeServiceClient) (*forgev1.CreatePRResponse, error) {
|
||||
return c.CreatePR(ctx, &forgev1.CreatePRRequest{Repo: ref(owner, repo), Title: title, Head: head, Base: base, Body: body})
|
||||
})
|
||||
return int(resp.GetNumber()), err
|
||||
}
|
||||
|
||||
func (f *Forge) PRState(ctx context.Context, owner, repo string, number int) (string, error) {
|
||||
resp, err := call(ctx, f, "pull request state", func(c forgev1.ForgeServiceClient) (*forgev1.PRStateResponse, error) {
|
||||
return c.PRState(ctx, &forgev1.PRStateRequest{Repo: ref(owner, repo), Number: int32(number)}) //nolint:gosec // issue numbers fit int32
|
||||
})
|
||||
return resp.GetState(), err
|
||||
}
|
||||
|
||||
func (f *Forge) GetPullRequest(ctx context.Context, owner, repo string, number int) (forge.PullRequest, error) {
|
||||
resp, err := call(ctx, f, "get pull request", func(c forgev1.ForgeServiceClient) (*forgev1.GetPullRequestResponse, error) {
|
||||
return c.GetPullRequest(ctx, &forgev1.GetPullRequestRequest{Repo: ref(owner, repo), Number: int32(number)}) //nolint:gosec // issue numbers fit int32
|
||||
})
|
||||
if err != nil {
|
||||
return forge.PullRequest{}, err
|
||||
}
|
||||
pr := resp.GetPullRequest()
|
||||
return forge.PullRequest{
|
||||
Number: int(pr.GetNumber()), Title: pr.GetTitle(), Body: pr.GetBody(),
|
||||
HeadRef: pr.GetHeadRef(), BaseRef: pr.GetBaseRef(), HeadSHA: pr.GetHeadSha(), BaseSHA: pr.GetBaseSha(),
|
||||
State: pr.GetState(),
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (f *Forge) GetPullRequestDiff(ctx context.Context, owner, repo string, number int) (string, error) {
|
||||
resp, err := call(ctx, f, "get pull request diff", func(c forgev1.ForgeServiceClient) (*forgev1.GetPullRequestDiffResponse, error) {
|
||||
return c.GetPullRequestDiff(ctx, &forgev1.GetPullRequestDiffRequest{Repo: ref(owner, repo), Number: int32(number)}) //nolint:gosec // issue numbers fit int32
|
||||
})
|
||||
return resp.GetDiff(), err
|
||||
}
|
||||
|
||||
func (f *Forge) ListReviews(ctx context.Context, owner, repo string, number int, sinceID int64) ([]forge.Review, error) {
|
||||
resp, err := call(ctx, f, "list reviews", func(c forgev1.ForgeServiceClient) (*forgev1.ListReviewsResponse, error) {
|
||||
return c.ListReviews(ctx, &forgev1.ListReviewsRequest{PullRequest: prRef(owner, repo, number), SinceId: sinceID})
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out := make([]forge.Review, 0, len(resp.GetReviews()))
|
||||
for _, r := range resp.GetReviews() {
|
||||
out = append(out, forge.Review{ID: r.GetId(), Author: r.GetAuthor(), State: r.GetState(), Body: r.GetBody(), SubmittedAt: r.GetSubmittedAt().AsTime()})
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (f *Forge) ListReviewComments(ctx context.Context, owner, repo string, number int, sinceID int64) ([]forge.ReviewComment, error) {
|
||||
resp, err := call(ctx, f, "list review comments", func(c forgev1.ForgeServiceClient) (*forgev1.ListReviewCommentsResponse, error) {
|
||||
return c.ListReviewComments(ctx, &forgev1.ListReviewCommentsRequest{PullRequest: prRef(owner, repo, number), SinceId: sinceID})
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out := make([]forge.ReviewComment, 0, len(resp.GetComments()))
|
||||
for _, c := range resp.GetComments() {
|
||||
out = append(out, forge.ReviewComment{
|
||||
ID: c.GetId(), ReviewID: c.GetReviewId(), Author: c.GetAuthor(), Body: c.GetBody(), Path: c.GetPath(),
|
||||
Line: int(c.GetLine()), InReplyTo: c.GetInReplyTo(), CreatedAt: c.GetCreatedAt().AsTime(),
|
||||
})
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (f *Forge) ReplyToReview(ctx context.Context, owner, repo string, number int, commentID int64, body string) error {
|
||||
_, err := call(ctx, f, "reply to review", func(c forgev1.ForgeServiceClient) (*forgev1.ReplyToReviewResponse, error) {
|
||||
return c.ReplyToReview(ctx, &forgev1.ReplyToReviewRequest{PullRequest: prRef(owner, repo, number), CommentId: commentID, Body: body})
|
||||
})
|
||||
return err
|
||||
}
|
||||
|
||||
func (f *Forge) CreateReviewComments(ctx context.Context, owner, repo string, number int, reviewedHeadSHA string, comments []forge.InlineReviewComment) error {
|
||||
in := make([]*forgev1.InlineReviewComment, 0, len(comments))
|
||||
for _, c := range comments {
|
||||
in = append(in, &forgev1.InlineReviewComment{Path: c.Path, Line: int32(c.Line), Body: c.Body}) //nolint:gosec // line numbers fit int32
|
||||
}
|
||||
_, err := call(ctx, f, "create review comments", func(c forgev1.ForgeServiceClient) (*forgev1.CreateReviewCommentsResponse, error) {
|
||||
return c.CreateReviewComments(ctx, &forgev1.CreateReviewCommentsRequest{PullRequest: prRef(owner, repo, number), ReviewedHeadSha: reviewedHeadSHA, Comments: in})
|
||||
})
|
||||
return err
|
||||
}
|
||||
|
||||
func (f *Forge) AcceptInvitations(ctx context.Context) error {
|
||||
_, err := call(ctx, f, "accept invitations", func(c forgev1.ForgeServiceClient) (*forgev1.AcceptInvitationsResponse, error) {
|
||||
return c.AcceptInvitations(ctx, &forgev1.AcceptInvitationsRequest{})
|
||||
})
|
||||
return err
|
||||
}
|
||||
|
||||
func (f *Forge) VerifyPush(ctx context.Context, owner, repo string) error {
|
||||
_, err := call(ctx, f, "verify push", func(c forgev1.ForgeServiceClient) (*forgev1.VerifyPushResponse, error) {
|
||||
return c.VerifyPush(ctx, &forgev1.VerifyPushRequest{Repo: ref(owner, repo)})
|
||||
})
|
||||
return err
|
||||
}
|
||||
|
||||
func (f *Forge) LinkBranch(ctx context.Context, owner, repo string, issueNumber int, branch string) error {
|
||||
_, err := call(ctx, f, "link branch", func(c forgev1.ForgeServiceClient) (*forgev1.LinkBranchResponse, error) {
|
||||
return c.LinkBranch(ctx, &forgev1.LinkBranchRequest{Repo: ref(owner, repo), IssueNumber: int32(issueNumber), Branch: branch}) //nolint:gosec // issue numbers fit int32
|
||||
})
|
||||
return err
|
||||
}
|
||||
|
||||
// GetRepoArchive streams the archive. The first chunk is read before
|
||||
// returning so an unsupported or failing forge surfaces as the call's error.
|
||||
func (f *Forge) GetRepoArchive(ctx context.Context, owner, repo, ref string) (io.ReadCloser, error) {
|
||||
ctx, cancel := context.WithCancel(ctx)
|
||||
stream, err := call(ctx, f, "get repo archive", func(c forgev1.ForgeServiceClient) (grpc.ServerStreamingClient[forgev1.GetRepoArchiveResponse], error) {
|
||||
return c.GetRepoArchive(ctx, &forgev1.GetRepoArchiveRequest{Repo: &forgev1.RepoRef{Owner: owner, Repo: repo}, Ref: ref})
|
||||
})
|
||||
if err != nil {
|
||||
cancel()
|
||||
return nil, err
|
||||
}
|
||||
first, err := stream.Recv()
|
||||
if err != nil && !errors.Is(err, io.EOF) {
|
||||
cancel()
|
||||
if status.Code(err) == codes.Unimplemented {
|
||||
return nil, errors.New("this forge does not support get repo archive")
|
||||
}
|
||||
return nil, fmt.Errorf("forge get repo archive: %w", err)
|
||||
}
|
||||
pr, pw := io.Pipe()
|
||||
go func() {
|
||||
defer cancel()
|
||||
if err == nil {
|
||||
if _, werr := pw.Write(first.GetData()); werr != nil {
|
||||
return
|
||||
}
|
||||
for {
|
||||
chunk, rerr := stream.Recv()
|
||||
if errors.Is(rerr, io.EOF) {
|
||||
break
|
||||
}
|
||||
if rerr != nil {
|
||||
_ = pw.CloseWithError(rerr)
|
||||
return
|
||||
}
|
||||
if _, werr := pw.Write(chunk.GetData()); werr != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
_ = pw.Close()
|
||||
}()
|
||||
return pr, nil
|
||||
}
|
||||
@@ -2,14 +2,11 @@ package secretengine
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"os"
|
||||
"path"
|
||||
"path/filepath"
|
||||
"slices"
|
||||
"sync"
|
||||
@@ -24,20 +21,8 @@ import (
|
||||
"github.com/samcharles93/archie-core/internal/secret"
|
||||
)
|
||||
|
||||
// orgID is the single-operator install's org, the one packages are installed in.
|
||||
const orgID = "default"
|
||||
|
||||
// Source is what the runner reads: the extension-settings resource and the
|
||||
// installed packages.
|
||||
type Source struct {
|
||||
// Query reads a control-plane resource, as *controlplanerpc.Client does.
|
||||
Query controlplanerpc.ResourceReader
|
||||
// Packages reads installed packages, as *staterpc.Client does.
|
||||
Packages interface {
|
||||
ListInstalled(ctx context.Context, orgID string) ([]storepkg.Installed, error)
|
||||
GetInstalled(ctx context.Context, orgID, name string) (storepkg.Installed, error)
|
||||
}
|
||||
}
|
||||
// Source is what the runner reads.
|
||||
type Source = extension.Source
|
||||
|
||||
// Runner keeps the enabled secret-engine extensions running and registered.
|
||||
// An extension runs when its package is installed, its authority is accepted
|
||||
@@ -94,7 +79,7 @@ func (r *Runner) Run(ctx context.Context, interval time.Duration) {
|
||||
// package, settings or process changed, and stops the rest. It returns the
|
||||
// problems it met; a failed engine does not stop the others.
|
||||
func (r *Runner) Sync(ctx context.Context) error {
|
||||
settings, version, err := r.enabled(ctx)
|
||||
settings, version, err := r.source.Enabled(ctx)
|
||||
if err == nil {
|
||||
err = r.apply(ctx, settings)
|
||||
}
|
||||
@@ -105,7 +90,7 @@ func (r *Runner) Sync(ctx context.Context) error {
|
||||
}
|
||||
|
||||
func (r *Runner) apply(ctx context.Context, settings map[string]controlplanerpc.ExtensionSetting) error {
|
||||
installed, err := r.source.Packages.ListInstalled(ctx, orgID)
|
||||
installed, err := r.source.Packages.ListInstalled(ctx, extension.OrgID)
|
||||
if err != nil {
|
||||
return fmt.Errorf("list installed packages: %w", err)
|
||||
}
|
||||
@@ -136,24 +121,6 @@ func (r *Runner) apply(ctx context.Context, settings map[string]controlplanerpc.
|
||||
return errors.Join(problems...)
|
||||
}
|
||||
|
||||
func (r *Runner) enabled(ctx context.Context) (map[string]controlplanerpc.ExtensionSetting, int64, error) {
|
||||
byName := make(map[string]controlplanerpc.ExtensionSetting)
|
||||
version, _, err := r.source.Query.Query(ctx, controlplanerpc.ExtensionSettingsKind, func(value []byte) error {
|
||||
var doc controlplanerpc.ExtensionSettings
|
||||
if err := json.Unmarshal(value, &doc); err != nil {
|
||||
return err
|
||||
}
|
||||
for _, setting := range doc.Extensions {
|
||||
byName[setting.Name] = setting
|
||||
}
|
||||
return nil
|
||||
})
|
||||
if err != nil {
|
||||
return nil, 0, fmt.Errorf("read extension settings: %w", err)
|
||||
}
|
||||
return byName, version, nil
|
||||
}
|
||||
|
||||
func secretEngines(d storepkg.Descriptor) []storepkg.Extension {
|
||||
var out []storepkg.Extension
|
||||
for _, extension := range d.Contributes.Extensions {
|
||||
@@ -178,7 +145,7 @@ func (r *Runner) ensure(ctx context.Context, pkg storepkg.Installed, setting con
|
||||
if len(engines) != 1 {
|
||||
return fmt.Errorf("a package serves one secret engine, this one declares %d", len(engines))
|
||||
}
|
||||
binary, sum, err := r.materialize(ctx, pkg, engines[0].Path)
|
||||
binary, sum, err := extension.Materialize(ctx, r.source.Packages, r.cacheDir, pkg, engines[0].Path)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -192,53 +159,6 @@ func (r *Runner) ensure(ctx context.Context, pkg storepkg.Installed, setting con
|
||||
return nil
|
||||
}
|
||||
|
||||
// materialize writes the package's extension binary under the cache, keyed by
|
||||
// package digest, and returns its path and sha256. A binary already there for
|
||||
// this digest is reused.
|
||||
func (r *Runner) materialize(ctx context.Context, pkg storepkg.Installed, file string) (string, string, error) {
|
||||
full, err := r.source.Packages.GetInstalled(ctx, orgID, pkg.Name)
|
||||
if err != nil {
|
||||
return "", "", fmt.Errorf("get installed package: %w", err)
|
||||
}
|
||||
files, err := storepkg.FilesFromLayer(full.Layer)
|
||||
if err != nil {
|
||||
return "", "", err
|
||||
}
|
||||
content, ok := files[file]
|
||||
if !ok {
|
||||
return "", "", fmt.Errorf("package layer has no %q", file)
|
||||
}
|
||||
sum := sha256.Sum256(content)
|
||||
dir := filepath.Join(r.cacheDir, pkg.Name, hex.EncodeToString(sum[:8]))
|
||||
target := filepath.Join(dir, path.Base(file))
|
||||
if existing, err := os.ReadFile(target); err == nil && sha256.Sum256(existing) == sum {
|
||||
return target, hex.EncodeToString(sum[:]), nil
|
||||
}
|
||||
if err := os.MkdirAll(dir, 0o700); err != nil {
|
||||
return "", "", err
|
||||
}
|
||||
tmp, err := os.CreateTemp(dir, ".extract-*")
|
||||
if err != nil {
|
||||
return "", "", err
|
||||
}
|
||||
defer func() { _ = os.Remove(tmp.Name()) }()
|
||||
if _, err := tmp.Write(content); err != nil {
|
||||
_ = tmp.Close()
|
||||
return "", "", err
|
||||
}
|
||||
if err := tmp.Chmod(0o700); err != nil {
|
||||
_ = tmp.Close()
|
||||
return "", "", err
|
||||
}
|
||||
if err := tmp.Close(); err != nil {
|
||||
return "", "", err
|
||||
}
|
||||
if err := os.Rename(tmp.Name(), target); err != nil {
|
||||
return "", "", err
|
||||
}
|
||||
return target, hex.EncodeToString(sum[:]), nil
|
||||
}
|
||||
|
||||
// Close stops every running engine.
|
||||
func (r *Runner) Close() { r.host.Close() }
|
||||
|
||||
|
||||
@@ -0,0 +1,209 @@
|
||||
syntax = "proto3";
|
||||
|
||||
package forge.v1;
|
||||
|
||||
import "google/protobuf/timestamp.proto";
|
||||
|
||||
// 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.
|
||||
service ForgeService {
|
||||
// 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.
|
||||
rpc Configure(ConfigureRequest) returns (ConfigureResponse);
|
||||
|
||||
rpc AssignedIssues(AssignedIssuesRequest) returns (AssignedIssuesResponse);
|
||||
rpc IssuesWithLabel(IssuesWithLabelRequest) returns (IssuesWithLabelResponse);
|
||||
rpc Comment(CommentRequest) returns (CommentResponse);
|
||||
rpc CloseIssue(CloseIssueRequest) returns (CloseIssueResponse);
|
||||
rpc React(ReactRequest) returns (ReactResponse);
|
||||
rpc SetStateLabel(SetStateLabelRequest) returns (SetStateLabelResponse);
|
||||
|
||||
rpc CreatePR(CreatePRRequest) returns (CreatePRResponse);
|
||||
rpc PRState(PRStateRequest) returns (PRStateResponse);
|
||||
rpc GetPullRequest(GetPullRequestRequest) returns (GetPullRequestResponse);
|
||||
rpc GetPullRequestDiff(GetPullRequestDiffRequest) returns (GetPullRequestDiffResponse);
|
||||
rpc ListReviews(ListReviewsRequest) returns (ListReviewsResponse);
|
||||
rpc ListReviewComments(ListReviewCommentsRequest) returns (ListReviewCommentsResponse);
|
||||
rpc ReplyToReview(ReplyToReviewRequest) returns (ReplyToReviewResponse);
|
||||
rpc CreateReviewComments(CreateReviewCommentsRequest) returns (CreateReviewCommentsResponse);
|
||||
|
||||
rpc AcceptInvitations(AcceptInvitationsRequest) returns (AcceptInvitationsResponse);
|
||||
rpc VerifyPush(VerifyPushRequest) returns (VerifyPushResponse);
|
||||
rpc LinkBranch(LinkBranchRequest) returns (LinkBranchResponse);
|
||||
// GetRepoArchive streams a gzipped tar of the repository at a ref.
|
||||
rpc GetRepoArchive(GetRepoArchiveRequest) returns (stream GetRepoArchiveResponse);
|
||||
}
|
||||
|
||||
message ConfigureRequest {
|
||||
string host = 1;
|
||||
string token = 2;
|
||||
map<string, string> settings = 3;
|
||||
}
|
||||
message ConfigureResponse {}
|
||||
|
||||
message RepoRef {
|
||||
string owner = 1;
|
||||
string repo = 2;
|
||||
}
|
||||
|
||||
message PullRequestRef {
|
||||
RepoRef repo = 1;
|
||||
int32 number = 2;
|
||||
}
|
||||
|
||||
message Issue {
|
||||
int32 number = 1;
|
||||
string title = 2;
|
||||
string body = 3;
|
||||
repeated string labels = 4;
|
||||
}
|
||||
message AssignedIssuesResponse { repeated Issue issues = 1; }
|
||||
message IssuesWithLabelResponse { repeated Issue issues = 1; }
|
||||
|
||||
message AssignedIssuesRequest {
|
||||
RepoRef repo = 1;
|
||||
string assignee = 2;
|
||||
}
|
||||
message IssuesWithLabelRequest {
|
||||
RepoRef repo = 1;
|
||||
string label = 2;
|
||||
}
|
||||
|
||||
message CommentRequest {
|
||||
RepoRef repo = 1;
|
||||
int32 number = 2;
|
||||
string body = 3;
|
||||
}
|
||||
message CommentResponse { int64 id = 1; }
|
||||
|
||||
message CloseIssueRequest {
|
||||
RepoRef repo = 1;
|
||||
int32 number = 2;
|
||||
string comment = 3;
|
||||
}
|
||||
message CloseIssueResponse {}
|
||||
|
||||
message ReactRequest {
|
||||
RepoRef repo = 1;
|
||||
int32 number = 2;
|
||||
string reaction = 3;
|
||||
}
|
||||
message ReactResponse {}
|
||||
|
||||
message SetStateLabelRequest {
|
||||
RepoRef repo = 1;
|
||||
int32 number = 2;
|
||||
string label = 3;
|
||||
repeated string known_labels = 4;
|
||||
}
|
||||
message SetStateLabelResponse {}
|
||||
|
||||
message CreatePRRequest {
|
||||
RepoRef repo = 1;
|
||||
string title = 2;
|
||||
string head = 3;
|
||||
string base = 4;
|
||||
string body = 5;
|
||||
}
|
||||
message CreatePRResponse { int32 number = 1; }
|
||||
|
||||
message PRStateRequest {
|
||||
RepoRef repo = 1;
|
||||
int32 number = 2;
|
||||
}
|
||||
message PRStateResponse { string state = 1; }
|
||||
|
||||
message PullRequest {
|
||||
int32 number = 1;
|
||||
string title = 2;
|
||||
string body = 3;
|
||||
string head_ref = 4;
|
||||
string base_ref = 5;
|
||||
string head_sha = 6;
|
||||
string base_sha = 7;
|
||||
string state = 8;
|
||||
}
|
||||
|
||||
message GetPullRequestRequest {
|
||||
RepoRef repo = 1;
|
||||
int32 number = 2;
|
||||
}
|
||||
message GetPullRequestResponse { PullRequest pull_request = 1; }
|
||||
|
||||
message GetPullRequestDiffRequest {
|
||||
RepoRef repo = 1;
|
||||
int32 number = 2;
|
||||
}
|
||||
message GetPullRequestDiffResponse { string diff = 1; }
|
||||
|
||||
message ListReviewsRequest {
|
||||
PullRequestRef pull_request = 1;
|
||||
int64 since_id = 2;
|
||||
}
|
||||
|
||||
message Review {
|
||||
int64 id = 1;
|
||||
string author = 2;
|
||||
string state = 3;
|
||||
string body = 4;
|
||||
google.protobuf.Timestamp submitted_at = 5;
|
||||
}
|
||||
message ListReviewsResponse { repeated Review reviews = 1; }
|
||||
|
||||
message ReviewComment {
|
||||
int64 id = 1;
|
||||
int64 review_id = 2;
|
||||
string author = 3;
|
||||
string body = 4;
|
||||
string path = 5;
|
||||
int32 line = 6;
|
||||
int64 in_reply_to = 7;
|
||||
google.protobuf.Timestamp created_at = 8;
|
||||
}
|
||||
message ListReviewCommentsRequest {
|
||||
PullRequestRef pull_request = 1;
|
||||
int64 since_id = 2;
|
||||
}
|
||||
message ListReviewCommentsResponse { repeated ReviewComment comments = 1; }
|
||||
|
||||
message ReplyToReviewRequest {
|
||||
PullRequestRef pull_request = 1;
|
||||
int64 comment_id = 2;
|
||||
string body = 3;
|
||||
}
|
||||
message ReplyToReviewResponse {}
|
||||
|
||||
message InlineReviewComment {
|
||||
string path = 1;
|
||||
int32 line = 2;
|
||||
string body = 3;
|
||||
}
|
||||
message CreateReviewCommentsRequest {
|
||||
PullRequestRef pull_request = 1;
|
||||
string reviewed_head_sha = 2;
|
||||
repeated InlineReviewComment comments = 3;
|
||||
}
|
||||
message CreateReviewCommentsResponse {}
|
||||
|
||||
message LinkBranchRequest {
|
||||
RepoRef repo = 1;
|
||||
int32 issue_number = 2;
|
||||
string branch = 3;
|
||||
}
|
||||
message LinkBranchResponse {}
|
||||
|
||||
message AcceptInvitationsRequest {}
|
||||
message AcceptInvitationsResponse {}
|
||||
|
||||
message VerifyPushRequest { RepoRef repo = 1; }
|
||||
message VerifyPushResponse {}
|
||||
|
||||
message GetRepoArchiveRequest {
|
||||
RepoRef repo = 1;
|
||||
string ref = 2;
|
||||
}
|
||||
message GetRepoArchiveResponse { bytes data = 1; }
|
||||
Reference in new issue
Block a user