package plugin import ( "bytes" "context" "encoding/json" "errors" "fmt" "io" "log/slog" "sync" githubplugin "github.com/hashicorp/go-plugin" "google.golang.org/grpc" "google.golang.org/grpc/codes" "google.golang.org/grpc/status" protolib "google.golang.org/protobuf/proto" "github.com/certimate-go/certimate/pkg/plugin/proto" ) type frameSendFunc func(*proto.LogEntry) error func (f frameSendFunc) Send(e *proto.LogEntry) error { return f(e) } type GRPCPlugin struct { githubplugin.NetRPCUnsupportedPlugin Impl Plugin } func (p *GRPCPlugin) GRPCServer(_ *githubplugin.GRPCBroker, s *grpc.Server) error { proto.RegisterPluginServiceServer(s, &pluginServiceServer{impl: p.Impl, executions: newExecutionRegistry()}) return nil } func (p *GRPCPlugin) GRPCClient(_ context.Context, _ *githubplugin.GRPCBroker, c *grpc.ClientConn) (interface{}, error) { return &pluginServiceClient{raw: proto.NewPluginServiceClient(c)}, nil } type pluginExecution struct { postMu sync.Mutex request *proto.ProcessRequest done chan struct{} postDone bool postErr error } type executionRegistry struct { mu sync.Mutex executions map[string]*pluginExecution } func newExecutionRegistry() *executionRegistry { return &executionRegistry{executions: make(map[string]*pluginExecution)} } func (r *executionRegistry) begin(id string, req *proto.ProcessRequest) *pluginExecution { r.mu.Lock() defer r.mu.Unlock() ex := &pluginExecution{request: protolib.Clone(req).(*proto.ProcessRequest), done: make(chan struct{})} r.executions[id] = ex return ex } func (r *executionRegistry) lookup(id string) *pluginExecution { r.mu.Lock() defer r.mu.Unlock() return r.executions[id] } func encodeMetadata(m *Metadata, err error) (*proto.GetMetadataResponse, error) { if err != nil { return nil, err } return &proto.GetMetadataResponse{ ProviderType: m.ProviderType, AccessProviderType: m.AccessProviderType, Capability: m.Capability, ProtocolVersion: m.ProtocolVersion, Category: m.Category, DisplayNameKey: m.DisplayNameKey, AccessDisplayNameKey: m.AccessDisplayNameKey, }, nil } func decodeMetadata(resp *proto.GetMetadataResponse) *Metadata { return &Metadata{ ProviderType: resp.ProviderType, AccessProviderType: resp.AccessProviderType, Capability: resp.Capability, ProtocolVersion: resp.ProtocolVersion, Category: resp.Category, DisplayNameKey: resp.DisplayNameKey, AccessDisplayNameKey: resp.AccessDisplayNameKey, SupportsAccessCheck: resp.SupportsAccessCheck, RuntimeConfigJSON: resp.RuntimeConfigJson, } } func validateRuntimeConfig(raw []byte) error { if len(raw) == 0 { return nil } trimmed := bytes.TrimSpace(raw) if len(trimmed) == 0 || trimmed[0] != '{' || !json.Valid(trimmed) { return errors.New("plugin: runtime config must be a JSON object") } return nil } func implementsAccessChecker(impl Plugin) bool { _, ok := impl.(AccessChecker) return ok } func encodeConfigSchema(cs *ConfigSchema, err error) (*proto.GetConfigSchemaResponse, error) { if err != nil { return nil, err } i18n := make(map[string]*proto.StringMap, len(cs.I18n)) for locale, entries := range cs.I18n { i18n[locale] = &proto.StringMap{Entries: entries} } return &proto.GetConfigSchemaResponse{ AccessSchemaJson: cs.AccessSchemaJSON, ProviderSchemaJson: cs.ProviderSchemaJSON, I18NResources: i18n, }, nil } func decodeConfigSchema(resp *proto.GetConfigSchemaResponse) *ConfigSchema { i18n := make(map[string]map[string]string, len(resp.I18NResources)) for locale, sm := range resp.I18NResources { i18n[locale] = sm.GetEntries() } return &ConfigSchema{ AccessSchemaJSON: resp.AccessSchemaJson, ProviderSchemaJSON: resp.ProviderSchemaJson, I18n: i18n, } } func encodeRequest(req *Request) *proto.ProcessRequest { out := &proto.ProcessRequest{ ExecutionId: req.ExecutionID, Capability: req.Capability, LogLevel: req.LogLevel, AccessConfigJson: req.AccessConfigJSON, ExtendedConfigJson: req.ExtendedConfigJSON, } switch { case req.Deploy != nil: out.Payload = &proto.ProcessRequest_Deploy{Deploy: &proto.DeployPayload{ CertificatePem: req.Deploy.CertificatePEM, PrivateKeyPem: req.Deploy.PrivateKeyPEM, }} case req.Dns != nil: out.Payload = &proto.ProcessRequest_Dns{Dns: &proto.DnsPayload{ Domain: req.Dns.Domain, Token: req.Dns.Token, KeyAuth: req.Dns.KeyAuth, }} case req.Notify != nil: out.Payload = &proto.ProcessRequest_Notify{Notify: &proto.NotifyPayload{ Subject: req.Notify.Subject, Message: req.Notify.Message, }} case req.Purge != nil: out.Payload = &proto.ProcessRequest_Purge{Purge: &proto.PurgePayload{ ExpirySeconds: req.Purge.ExpirySeconds, }} } return out } func decodeRequest(req *proto.ProcessRequest) *Request { out := &Request{ ExecutionID: req.ExecutionId, Capability: req.Capability, LogLevel: req.LogLevel, AccessConfigJSON: req.AccessConfigJson, ExtendedConfigJSON: req.ExtendedConfigJson, } switch p := req.Payload.(type) { case *proto.ProcessRequest_Deploy: out.Deploy = &DeployPayload{CertificatePEM: p.Deploy.GetCertificatePem(), PrivateKeyPEM: p.Deploy.GetPrivateKeyPem()} case *proto.ProcessRequest_Dns: out.Dns = &DnsPayload{Domain: p.Dns.GetDomain(), Token: p.Dns.GetToken(), KeyAuth: p.Dns.GetKeyAuth()} case *proto.ProcessRequest_Notify: out.Notify = &NotifyPayload{Subject: p.Notify.GetSubject(), Message: p.Notify.GetMessage()} case *proto.ProcessRequest_Purge: out.Purge = &PurgePayload{ExpirySeconds: p.Purge.GetExpirySeconds()} } return out } func encodeResult(res *Result) *proto.ProcessResult { switch { case res.Deploy != nil: return &proto.ProcessResult{Result: &proto.ProcessResult_Deploy{Deploy: &proto.DeployResult{ExtendedDataJson: res.Deploy.ExtendedDataJSON}}} case res.Dns != nil: return &proto.ProcessResult{Result: &proto.ProcessResult_Dns{Dns: &proto.DnsResult{}}} case res.Notify != nil: return &proto.ProcessResult{Result: &proto.ProcessResult_Notify{Notify: &proto.NotifyResult{ExtendedDataJson: res.Notify.ExtendedDataJSON}}} case res.Purge != nil: return &proto.ProcessResult{Result: &proto.ProcessResult_Purge{Purge: &proto.PurgeResult{Count: int64(res.Purge.Count), ExtendedDataJson: res.Purge.ExtendedDataJSON}}} } return nil } func decodeResult(res *proto.ProcessResult, capability string) (*Result, error) { out := &Result{} switch r := res.GetResult().(type) { case *proto.ProcessResult_Deploy: out.Deploy = &DeployResult{ExtendedDataJSON: r.Deploy.GetExtendedDataJson()} case *proto.ProcessResult_Dns: out.Dns = &DnsResult{} case *proto.ProcessResult_Notify: out.Notify = &NotifyResult{ExtendedDataJSON: r.Notify.GetExtendedDataJson()} case *proto.ProcessResult_Purge: count := r.Purge.GetCount() if count < 0 { return nil, fmt.Errorf("illegal purge result count %d", count) } out.Purge = &PurgeResult{Count: int(count), ExtendedDataJSON: r.Purge.GetExtendedDataJson()} default: return nil, fmt.Errorf("process result carries no result") } if err := out.Validate(capability); err != nil { return nil, err } return out, nil } func encodeAccessCheckResult(res *AccessCheckResult) *proto.CheckAccessResponse { out := &proto.CheckAccessResponse{ Status: res.Status, ReasonCode: res.ReasonCode, Diagnostics: res.Diagnostics, Items: make([]*proto.CheckAccessItem, len(res.Items)), } for i, item := range res.Items { out.Items[i] = &proto.CheckAccessItem{Id: item.ID, Status: item.Status} } return out } func decodeAccessCheckResult(resp *proto.CheckAccessResponse) (*AccessCheckResult, error) { out := &AccessCheckResult{ Status: resp.Status, ReasonCode: resp.ReasonCode, Diagnostics: resp.Diagnostics, Items: make([]AccessCheckItem, len(resp.Items)), } for i, item := range resp.Items { out.Items[i] = AccessCheckItem{ID: item.GetId(), Status: item.GetStatus()} } if err := out.Validate(); err != nil { return nil, err } return out, nil } type pluginServiceServer struct { proto.UnimplementedPluginServiceServer impl Plugin executions *executionRegistry } func (s *pluginServiceServer) GetMetadata(ctx context.Context, _ *proto.GetMetadataRequest) (*proto.GetMetadataResponse, error) { resp, err := encodeMetadata(s.impl.GetMetadata(ctx)) if err != nil { return nil, err } resp.SupportsAccessCheck = implementsAccessChecker(s.impl) if provider, ok := s.impl.(RuntimeConfigProvider); ok { config, err := provider.RuntimeConfig(ctx) if err != nil { return nil, err } if err := validateRuntimeConfig(config); err != nil { return nil, err } resp.RuntimeConfigJson = config } return resp, nil } func (s *pluginServiceServer) GetConfigSchema(ctx context.Context, _ *proto.GetConfigSchemaRequest) (*proto.GetConfigSchemaResponse, error) { return encodeConfigSchema(s.impl.GetConfigSchema(ctx)) } func (s *pluginServiceServer) Process(req *proto.ProcessRequest, stream proto.PluginService_ProcessServer) error { decoded := decodeRequest(req) if err := decoded.Validate(); err != nil { return fmt.Errorf("plugin: reject process request: %w", err) } if s.impl == nil { return errors.New("plugin: no implementation configured") } ex := s.executions.begin(decoded.ExecutionID, req) defer close(ex.done) ctx := stream.Context() logger := NewStreamLogger(frameSendFunc(func(e *proto.LogEntry) error { return stream.Send(&proto.ProcessFrame{Frame: &proto.ProcessFrame_Log{Log: e}}) }), parseLogLevel(req.LogLevel)) res, err := s.impl.Process(ctx, decoded, logger) if err != nil { return err } if verr := res.Validate(decoded.Capability); verr != nil { return fmt.Errorf("plugin: reject process result: %w", verr) } return stream.Send(&proto.ProcessFrame{ Frame: &proto.ProcessFrame_Result{Result: encodeResult(res)}, }) } func (s *pluginServiceServer) PostProcess(req *proto.PostProcessRequest, stream proto.PluginService_PostProcessServer) error { ex := s.executions.lookup(req.GetExecutionId()) if ex == nil { return fmt.Errorf("plugin: unknown execution id %q", req.GetExecutionId()) } if !protolib.Equal(ex.request, req.GetRequest()) { return fmt.Errorf("plugin: post process request does not match original execution %q", req.GetExecutionId()) } ex.postMu.Lock() defer ex.postMu.Unlock() if ex.postDone { if ex.postErr != nil { return ex.postErr } return stream.Send(&proto.PostProcessFrame{Frame: &proto.PostProcessFrame_Result{Result: &proto.PostProcessResult{}}}) } ctx := stream.Context() select { case <-ex.done: case <-ctx.Done(): return fmt.Errorf("plugin: execution %q still running when the finalization budget expired: %w", req.GetExecutionId(), ctx.Err()) } logger := NewStreamLogger(frameSendFunc(func(e *proto.LogEntry) error { return stream.Send(&proto.PostProcessFrame{Frame: &proto.PostProcessFrame_Log{Log: e}}) }), parseLogLevel(req.GetRequest().GetLogLevel())) err := s.impl.PostProcess(ctx, decodeRequest(req.GetRequest()), logger) ex.postDone = true ex.postErr = err if err != nil { return err } return stream.Send(&proto.PostProcessFrame{ Frame: &proto.PostProcessFrame_Result{Result: &proto.PostProcessResult{}}, }) } func (s *pluginServiceServer) CheckAccess(ctx context.Context, req *proto.CheckAccessRequest) (*proto.CheckAccessResponse, error) { checker, ok := s.impl.(AccessChecker) if !ok { return nil, status.Error(codes.Unimplemented, "plugin does not implement access connectivity checks") } logger := slog.New(slog.NewTextHandler(io.Discard, nil)) res, err := checker.CheckAccess(ctx, &AccessCheckRequest{AccessConfigJSON: req.GetAccessConfigJson()}, logger) if err != nil { return nil, err } if verr := res.Validate(); verr != nil { return nil, fmt.Errorf("plugin: reject access check result: %w", verr) } return encodeAccessCheckResult(res), nil } type pluginServiceClient struct { raw proto.PluginServiceClient } func (c *pluginServiceClient) GetMetadata(ctx context.Context) (*Metadata, error) { resp, err := c.raw.GetMetadata(ctx, &proto.GetMetadataRequest{}) if err != nil { return nil, err } if err := validateRuntimeConfig(resp.GetRuntimeConfigJson()); err != nil { return nil, err } return decodeMetadata(resp), nil } func (c *pluginServiceClient) GetConfigSchema(ctx context.Context) (*ConfigSchema, error) { resp, err := c.raw.GetConfigSchema(ctx, &proto.GetConfigSchemaRequest{}) if err != nil { return nil, err } return decodeConfigSchema(resp), nil } func (c *pluginServiceClient) Process(ctx context.Context, req *Request, logger *slog.Logger) (*Result, error) { if err := req.Validate(); err != nil { return nil, fmt.Errorf("plugin: reject process request: %w", err) } stream, err := c.raw.Process(ctx, encodeRequest(req)) if err != nil { return nil, err } var result *Result for { frame, err := stream.Recv() if err != nil { if errors.Is(err, io.EOF) { if result == nil { return nil, &ErrPluginProtocol{Reason: "stream ended without a final result"} } return result, nil } if result != nil { return nil, &ErrPluginProtocol{Reason: fmt.Sprintf("stream failed after the final result: %v", err)} } return nil, err } if result != nil { return nil, &ErrPluginProtocol{Reason: "frame received after the final result"} } switch f := frame.Frame.(type) { case *proto.ProcessFrame_Log: forwardLog(ctx, logger, f.Log) case *proto.ProcessFrame_Result: parsed, err := decodeResult(f.Result, req.Capability) if err != nil { return nil, &ErrPluginProtocol{Reason: err.Error()} } result = parsed default: return nil, &ErrPluginProtocol{Reason: "unknown process frame"} } } } func (c *pluginServiceClient) PostProcess(ctx context.Context, req *Request, logger *slog.Logger) error { stream, err := c.raw.PostProcess(ctx, &proto.PostProcessRequest{ExecutionId: req.ExecutionID, Request: encodeRequest(req)}) if err != nil { return err } completed := false for { frame, err := stream.Recv() if err != nil { if errors.Is(err, io.EOF) { if !completed { return &ErrPluginProtocol{Reason: "stream ended without a finalization result"} } return nil } if completed { return &ErrPluginProtocol{Reason: fmt.Sprintf("stream failed after the finalization result: %v", err)} } return err } if completed { return &ErrPluginProtocol{Reason: "frame received after the finalization result"} } switch f := frame.Frame.(type) { case *proto.PostProcessFrame_Log: forwardLog(ctx, logger, f.Log) case *proto.PostProcessFrame_Result: completed = true default: return &ErrPluginProtocol{Reason: "unknown finalization frame"} } } } func (c *pluginServiceClient) CheckAccess(ctx context.Context, req *AccessCheckRequest) (*AccessCheckResult, error) { resp, err := c.raw.CheckAccess(ctx, &proto.CheckAccessRequest{AccessConfigJson: req.AccessConfigJSON}) if err != nil { return nil, err } return decodeAccessCheckResult(resp) } func forwardLog(ctx context.Context, logger *slog.Logger, e *proto.LogEntry) { if logger == nil || e == nil { return } attrs := make([]any, 0, len(e.Data)) for k, v := range e.Data { attrs = append(attrs, slog.String(k, v)) } logger.Log(ctx, slog.Level(e.Level), e.Message, attrs...) }