feat(forgeext): forge surface served by extensions; forge.type names the installed package

This commit is contained in:
sam committed 2026-10-04 13:56:32 +11:00
1 parent 37c6a71343
commit 153dfc094c
12 files changed
+4303 -98

No files matched your search

+9 -3
View File
@@ -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,
+96
View File
@@ -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()
}
}
+5 -2
View File
@@ -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",
}
+7 -2
View File
@@ -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.
+1 -1
View File
@@ -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
}
+5 -85
View File
@@ -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() }
+209
View File
@@ -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; }