105 lines
3.6 KiB
Go
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
|
|
}
|