Files

105 lines
3.6 KiB
Go

package connectors
import (
"context"
"errors"
"fmt"
"time"
goplugin "github.com/hashicorp/go-plugin"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
sepb "github.com/samcharles93/archie-core/internal/contracts/secretengine/v1"
"github.com/samcharles93/archie-core/modules/connectors/internal/host"
)
// engineSurface names the secret engine contract in the plugin handshake.
const engineSurface = "secretengine"
// resolveTimeout bounds one secret lookup, so a hung engine can't hold a
// connector's start for ever.
const resolveTimeout = 30 * time.Second
// ErrSecretNotFound means a secret engine holds nothing under the key.
var ErrSecretNotFound = errors.New("secret engine holds no such key")
// Engine is a running secret engine: an extension that resolves the keys
// credentials name, such as entries in a sops file.
type Engine struct {
name string
version string
settings []Setting
client sepb.SecretEngineServiceClient
}
// Version is the engine's own release, as it described itself.
func (e *Engine) Version() string { return e.version }
// SettingsSchema is what the engine declared an operator enters.
func (e *Engine) SettingsSchema() []Setting { return e.settings }
// Resolve returns the secret the engine holds under key.
func (e *Engine) Resolve(ctx context.Context, key string) (string, error) {
ctx, cancel := context.WithTimeout(ctx, resolveTimeout)
defer cancel()
resp, err := e.client.Resolve(ctx, &sepb.ResolveRequest{Key: key})
if status.Code(err) == codes.NotFound {
return "", fmt.Errorf("secret engine %q: key %q: %w", e.name, key, ErrSecretNotFound)
}
if err != nil {
return "", fmt.Errorf("secret engine %q: %w", e.name, err)
}
return resp.GetValue(), nil
}
// StartEngine launches a secret engine and configures it with its settings
// and its own secrets.
func (h *Host) StartEngine(ctx context.Context, spec Spec) (*Engine, error) {
raw, err := h.procs.Start(ctx, host.Spec{
Name: spec.Name, Path: spec.Path, SHA256: spec.SHA256, Env: spec.Env, Egress: spec.Egress,
}, engineSurface, &enginePlugin{})
if err != nil {
return nil, err
}
client, ok := raw.(sepb.SecretEngineServiceClient)
if !ok {
h.procs.Stop(spec.Name)
return nil, fmt.Errorf("secret engine %q: plugin is not a secret engine", spec.Name)
}
if _, err := client.Configure(ctx, &sepb.ConfigureRequest{Settings: spec.Settings, Secrets: spec.Secrets}); err != nil {
h.procs.Stop(spec.Name)
return nil, fmt.Errorf("secret engine %q: configure: %w", spec.Name, err)
}
e := &Engine{name: spec.Name, client: client}
desc, err := client.Describe(ctx, &sepb.DescribeRequest{})
if status.Code(err) == codes.Unimplemented {
// An engine built before settings were declarable still runs.
return e, nil
}
if err != nil {
h.procs.Stop(spec.Name)
return nil, fmt.Errorf("secret engine %q: describe: %w", spec.Name, err)
}
e.version, e.settings = desc.GetVersion(), engineSettings(desc.GetSettings())
if err := validateSettingsSchema(e.settings); err != nil {
h.procs.Stop(spec.Name)
return nil, fmt.Errorf("secret engine %q: %w", spec.Name, err)
}
return e, nil
}
// enginePlugin is the host side of the go-plugin handshake for secret engines.
type enginePlugin struct {
goplugin.NetRPCUnsupportedPlugin
}
func (*enginePlugin) GRPCServer(*goplugin.GRPCBroker, *grpc.Server) error {
return errors.New("secret engines are served by extensions, not by the host")
}
func (*enginePlugin) GRPCClient(_ context.Context, _ *goplugin.GRPCBroker, conn *grpc.ClientConn) (any, error) {
return sepb.NewSecretEngineServiceClient(conn), nil
}