github.com/hernad/nomad@v1.6.112/drivers/docker/docklog/plugin.go (about)

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