mirror of
https://github.com/hashicorp/vault.git
synced 2025-08-10 16:47:01 +02:00
792d219aa9
* logbridge with hclog and identical output * Initial search & replace This compiles, but there is a fair amount of TODO and commented out code, especially around the plugin logclient/logserver code. * strip logbridge * fix majority of tests * update logxi aliases * WIP fixing tests * more test fixes * Update test to hclog * Fix format * Rename hclog -> log * WIP making hclog and logxi love each other * update logger_test.go * clean up merged comments * Replace RawLogger interface with a Logger * Add some logger names * Replace Trace with Debug * update builtin logical logging patterns * Fix build errors * More log updates * update log approach in command and builtin * More log updates * update helper, http, and logical directories * Update loggers * Log updates * Update logging * Update logging * Update logging * Update logging * update logging in physical * prefixing and lowercase * Update logging * Move phyisical logging name to server command * Fix som tests * address jims feedback so far * incorporate brians feedback so far * strip comments * move vault.go to logging package * update Debug to Trace * Update go-plugin deps * Update logging based on review comments * Updates from review * Unvendor logxi * Remove null_logger.go
76 lines
2.0 KiB
Go
76 lines
2.0 KiB
Go
package dbplugin
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"sync"
|
|
|
|
log "github.com/hashicorp/go-hclog"
|
|
"github.com/hashicorp/go-plugin"
|
|
"github.com/hashicorp/vault/helper/pluginutil"
|
|
)
|
|
|
|
// DatabasePluginClient embeds a databasePluginRPCClient and wraps it's Close
|
|
// method to also call Kill() on the plugin.Client.
|
|
type DatabasePluginClient struct {
|
|
client *plugin.Client
|
|
sync.Mutex
|
|
|
|
Database
|
|
}
|
|
|
|
// This wraps the Close call and ensures we both close the database connection
|
|
// and kill the plugin.
|
|
func (dc *DatabasePluginClient) Close() error {
|
|
err := dc.Database.Close()
|
|
dc.client.Kill()
|
|
|
|
return err
|
|
}
|
|
|
|
// newPluginClient returns a databaseRPCClient with a connection to a running
|
|
// plugin. The client is wrapped in a DatabasePluginClient object to ensure the
|
|
// plugin is killed on call of Close().
|
|
func newPluginClient(ctx context.Context, sys pluginutil.RunnerUtil, pluginRunner *pluginutil.PluginRunner, logger log.Logger) (Database, error) {
|
|
// pluginMap is the map of plugins we can dispense.
|
|
var pluginMap = map[string]plugin.Plugin{
|
|
"database": new(DatabasePlugin),
|
|
}
|
|
|
|
client, err := pluginRunner.Run(ctx, sys, pluginMap, handshakeConfig, []string{}, logger)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Connect via RPC
|
|
rpcClient, err := client.Client()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Request the plugin
|
|
raw, err := rpcClient.Dispense("database")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// We should have a database type now. This feels like a normal interface
|
|
// implementation but is in fact over an RPC connection.
|
|
var db Database
|
|
switch raw.(type) {
|
|
case *gRPCClient:
|
|
db = raw.(*gRPCClient)
|
|
case *databasePluginRPCClient:
|
|
logger.Warn("plugin is using deprecated net RPC transport, recompile plugin to upgrade to gRPC", "plugin", pluginRunner.Name)
|
|
db = raw.(*databasePluginRPCClient)
|
|
default:
|
|
return nil, errors.New("unsupported client type")
|
|
}
|
|
|
|
// Wrap RPC implementation in DatabasePluginClient
|
|
return &DatabasePluginClient{
|
|
client: client,
|
|
Database: db,
|
|
}, nil
|
|
}
|