mirror of
https://github.com/optim-enterprises-bv/vault.git
synced 2025-10-30 18:17:55 +00:00
07927e036c
* enable registering backend muxed plugins in plugin catalog * set the sysview on the pluginconfig to allow enabling secrets/auth plugins * store backend instances in map * store single implementations in the instances map cleanup instance map and ensure we don't deadlock * fix system backend unit tests move GetMultiplexIDFromContext to pluginutil package fix pluginutil test fix dbplugin ut * return error(s) if we can't get the plugin client update comments * refactor/move GetMultiplexIDFromContext test * add changelog * remove unnecessary field on pluginClient * add unit tests to PluginCatalog for secrets/auth plugins * fix comment * return pluginClient from TestRunTestPlugin * add multiplexed backend test * honor metadatamode value in newbackend pluginconfig * check that connection exists on cleanup * add automtls to secrets/auth plugins * don't remove apiclientmeta parsing * use formatting directive for fmt.Errorf * fix ut: remove tls provider func * remove tlsproviderfunc from backend plugin tests * use env var to prevent test plugin from running as a unit test * WIP: remove lazy loading * move non lazy loaded backend to new package * use version wrapper for backend plugin factory * remove backendVersionWrapper type * implement getBackendPluginType for plugin catalog * handle backend plugin v4 registration * add plugin automtls env guard * modify plugin factory to determine the backend to use * remove old pluginsets from v5 and log pid in plugin catalog * add reload mechanism via context * readd v3 and v4 to pluginset * call cleanup from reload if non-muxed * move v5 backend code to new package * use context reload for for ErrPluginShutdown case * add wrapper on v5 backend * fix run config UTs * fix unit tests - use v4/v5 mapping for plugin versions - fix test build err - add reload method on fakePluginClient - add multiplexed cases for integration tests * remove comment and update AutoMTLS field in test * remove comment * remove errwrap and unused context * only support metadatamode false for v5 backend plugins * update plugin catalog errors * use const for env variables * rename locks and remove unused * remove unneeded nil check * improvements based on staticcheck recommendations * use const for single implementation string * use const for context key * use info default log level * move pid to pluginClient struct * remove v3 and v4 from multiplexed plugin set * return from reload when non-multiplexed * update automtls env string * combine getBackend and getBrokeredClient * update comments for plugin reload, Backend return val and log * revert Backend return type * allow non-muxed plugins to serve v5 * move v5 code to existing sdk plugin package * do next export sdk fields now that we have removed extra plugin pkg * set TLSProvider in ServeMultiplex for backwards compat * use bool to flag multiplexing support on grpc backend server * revert userpass main.go * refactor plugin sdk - update comments - make use of multiplexing boolean and single implementation ID const * update comment and use multierr * attempt v4 if dispense fails on getPluginTypeForUnknown * update comments on sdk plugin backend
101 lines
3.1 KiB
Go
101 lines
3.1 KiB
Go
package plugin
|
|
|
|
import (
|
|
"context"
|
|
"time"
|
|
|
|
log "github.com/hashicorp/go-hclog"
|
|
"github.com/hashicorp/vault/sdk/logical"
|
|
)
|
|
|
|
// backendPluginClient implements logical.Backend and is the
|
|
// go-plugin client.
|
|
type BackendTracingMiddleware struct {
|
|
logger log.Logger
|
|
|
|
next logical.Backend
|
|
}
|
|
|
|
// Validate the backendTracingMiddle object satisfies the backend interface
|
|
var _ logical.Backend = &BackendTracingMiddleware{}
|
|
|
|
func (b *BackendTracingMiddleware) Initialize(ctx context.Context, req *logical.InitializationRequest) (err error) {
|
|
defer func(then time.Time) {
|
|
b.logger.Trace("initialize", "status", "finished", "err", err, "took", time.Since(then))
|
|
}(time.Now())
|
|
|
|
b.logger.Trace("initialize", "status", "started")
|
|
return b.next.Initialize(ctx, req)
|
|
}
|
|
|
|
func (b *BackendTracingMiddleware) HandleRequest(ctx context.Context, req *logical.Request) (resp *logical.Response, err error) {
|
|
defer func(then time.Time) {
|
|
b.logger.Trace("handle request", "path", req.Path, "status", "finished", "err", err, "took", time.Since(then))
|
|
}(time.Now())
|
|
|
|
b.logger.Trace("handle request", "path", req.Path, "status", "started")
|
|
return b.next.HandleRequest(ctx, req)
|
|
}
|
|
|
|
func (b *BackendTracingMiddleware) SpecialPaths() *logical.Paths {
|
|
defer func(then time.Time) {
|
|
b.logger.Trace("special paths", "status", "finished", "took", time.Since(then))
|
|
}(time.Now())
|
|
|
|
b.logger.Trace("special paths", "status", "started")
|
|
return b.next.SpecialPaths()
|
|
}
|
|
|
|
func (b *BackendTracingMiddleware) System() logical.SystemView {
|
|
return b.next.System()
|
|
}
|
|
|
|
func (b *BackendTracingMiddleware) Logger() log.Logger {
|
|
return b.next.Logger()
|
|
}
|
|
|
|
func (b *BackendTracingMiddleware) HandleExistenceCheck(ctx context.Context, req *logical.Request) (found bool, exists bool, err error) {
|
|
defer func(then time.Time) {
|
|
b.logger.Trace("handle existence check", "path", req.Path, "status", "finished", "err", err, "took", time.Since(then))
|
|
}(time.Now())
|
|
|
|
b.logger.Trace("handle existence check", "path", req.Path, "status", "started")
|
|
return b.next.HandleExistenceCheck(ctx, req)
|
|
}
|
|
|
|
func (b *BackendTracingMiddleware) Cleanup(ctx context.Context) {
|
|
defer func(then time.Time) {
|
|
b.logger.Trace("cleanup", "status", "finished", "took", time.Since(then))
|
|
}(time.Now())
|
|
|
|
b.logger.Trace("cleanup", "status", "started")
|
|
b.next.Cleanup(ctx)
|
|
}
|
|
|
|
func (b *BackendTracingMiddleware) InvalidateKey(ctx context.Context, key string) {
|
|
defer func(then time.Time) {
|
|
b.logger.Trace("invalidate key", "key", key, "status", "finished", "took", time.Since(then))
|
|
}(time.Now())
|
|
|
|
b.logger.Trace("invalidate key", "key", key, "status", "started")
|
|
b.next.InvalidateKey(ctx, key)
|
|
}
|
|
|
|
func (b *BackendTracingMiddleware) Setup(ctx context.Context, config *logical.BackendConfig) (err error) {
|
|
defer func(then time.Time) {
|
|
b.logger.Trace("setup", "status", "finished", "err", err, "took", time.Since(then))
|
|
}(time.Now())
|
|
|
|
b.logger.Trace("setup", "status", "started")
|
|
return b.next.Setup(ctx, config)
|
|
}
|
|
|
|
func (b *BackendTracingMiddleware) Type() logical.BackendType {
|
|
defer func(then time.Time) {
|
|
b.logger.Trace("type", "status", "finished", "took", time.Since(then))
|
|
}(time.Now())
|
|
|
|
b.logger.Trace("type", "status", "started")
|
|
return b.next.Type()
|
|
}
|