/
plugin.go
100 lines (83 loc) · 2.37 KB
/
plugin.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
package docklog
import (
"context"
"os"
"os/exec"
hclog "github.com/hashicorp/go-hclog"
plugin "github.com/hashicorp/go-plugin"
"github.com/hashicorp/nomad/drivers/docker/docklog/proto"
"github.com/hashicorp/nomad/plugins/base"
"google.golang.org/grpc"
)
const PluginName = "docker_logger"
// LaunchDockerLogger launches an instance of DockerLogger
func LaunchDockerLogger(logger hclog.Logger) (DockerLogger, *plugin.Client, error) {
logger = logger.Named(PluginName)
bin, err := os.Executable()
if err != nil {
return nil, nil, err
}
client := plugin.NewClient(&plugin.ClientConfig{
HandshakeConfig: base.Handshake,
Plugins: map[string]plugin.Plugin{
PluginName: &Plugin{impl: NewDockerLogger(logger)},
},
Cmd: exec.Command(bin, PluginName),
AllowedProtocols: []plugin.Protocol{
plugin.ProtocolGRPC,
},
Logger: logger,
})
rpcClient, err := client.Client()
if err != nil {
return nil, nil, err
}
raw, err := rpcClient.Dispense(PluginName)
if err != nil {
return nil, nil, err
}
l := raw.(DockerLogger)
return l, client, nil
}
func ReattachDockerLogger(reattachCfg *plugin.ReattachConfig) (DockerLogger, *plugin.Client, error) {
client := plugin.NewClient(&plugin.ClientConfig{
HandshakeConfig: base.Handshake,
Plugins: map[string]plugin.Plugin{
PluginName: &Plugin{impl: NewDockerLogger(hclog.L().Named(PluginName))},
},
Reattach: reattachCfg,
AllowedProtocols: []plugin.Protocol{
plugin.ProtocolGRPC,
},
})
rpcClient, err := client.Client()
if err != nil {
return nil, nil, err
}
raw, err := rpcClient.Dispense(PluginName)
if err != nil {
return nil, nil, err
}
l := raw.(DockerLogger)
return l, client, nil
}
// Plugin is the go-plugin implementation
type Plugin struct {
plugin.NetRPCUnsupportedPlugin
impl DockerLogger
}
func NewPlugin(impl DockerLogger) *Plugin {
return &Plugin{impl: impl}
}
// GRPCServer registered the server side implementation with the grpc server
func (p *Plugin) GRPCServer(broker *plugin.GRPCBroker, s *grpc.Server) error {
proto.RegisterDockerLoggerServer(s, &dockerLoggerServer{
impl: p.impl,
broker: broker,
})
return nil
}
// GRPCClient returns a client side implementation of the plugin
func (p *Plugin) GRPCClient(ctx context.Context, broker *plugin.GRPCBroker, c *grpc.ClientConn) (interface{}, error) {
return &dockerLoggerClient{client: proto.NewDockerLoggerClient(c)}, nil
}