kemko/nomad
1
0
Fork 0
mirror of https://github.com/kemko/nomad.git synced 2026-01-04 09:25:46 +03:00
Code Issues Packages Projects Releases Wiki Activity

driver/docker: rename container logger

Browse Source
This commit is contained in:
Nick Ethier
2018-10-16 13:49:50 -04:00
committed by Michael Schurter
parent e026d6e80a
commit 3a9ed23d71
7 changed files with 100 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
drivers/docker/docklog/client.go
View File

@@ -6,13 +6,13 @@ import (
"github.com/hashicorp/nomad/drivers/docker/docklog/proto"
)
// docklogClient implements the Docklog interface for client side requests
type docklogClient struct {
client proto.DocklogClient
// dockerLoggerClient implements the dockerLogger interface for client side requests
type dockerLoggerClient struct {
client proto.DockerLoggerClient
}
// Start proxies the Start client side func to the protobuf interface
func (c *docklogClient) Start(opts *StartOpts) error {
func (c *dockerLoggerClient) Start(opts *StartOpts) error {
req := &proto.StartRequest{
Endpoint: opts.Endpoint,
ContainerId: opts.ContainerID,
@@ -28,7 +28,7 @@ func (c *docklogClient) Start(opts *StartOpts) error {
}
// Stop proxies the Stop client side func to the protobuf interface
func (c *docklogClient) Stop() error {
func (c *dockerLoggerClient) Stop() error {
req := &proto.StopRequest{}
_, err := c.client.Stop(context.Background(), req)
return err

10
drivers/docker/docklog/docklog.go → drivers/docker/docklog/docker_logger.go
View File

@@ -11,9 +11,9 @@ import (
"golang.org/x/net/context"
)
// Docklog is a small utility to forward logs from a docker container to a target
// DockerLogger is a small utility to forward logs from a docker container to a target
// destination
type Docklog interface {
type DockerLogger interface {
Start(*StartOpts) error
Stop() error
}
@@ -37,12 +37,12 @@ type StartOpts struct {
TLSCA string
}
// NewDocklog returns an implementation of the Docklog interface
func NewDocklog(logger hclog.Logger) Docklog {
// NewDockerLogger returns an implementation of the DockerLogger interface
func NewDockerLogger(logger hclog.Logger) DockerLogger {
return &dockerLogger{logger: logger}
}
// dockerLogger implements the Docklog interface
// dockerLogger implements the DockerLogger interface
type dockerLogger struct {
logger hclog.Logger

29
drivers/docker/docklog/docklog_test.go → drivers/docker/docklog/docker_logger_test.go
View File

@@ -4,7 +4,6 @@ import (
"bytes"
"fmt"
"testing"
"time"
docker "github.com/fsouza/go-dockerclient"
"github.com/hashicorp/nomad/helper/testlog"
@@ -13,7 +12,7 @@ import (
"golang.org/x/net/context"
)
func TestDocklog(t *testing.T) {
func TestDockerLogger(t *testing.T) {
t.Parallel()
require := require.New(t)
@@ -43,20 +42,23 @@ func TestDocklog(t *testing.T) {
err = client.StartContainer(container.ID, nil)
require.NoError(err)
var count int
for !container.State.Running {
if count > 10 {
t.Fatal("timeout waiting for container to start")
}
time.Sleep(100 * time.Millisecond)
testutil.WaitForResult(func() (bool, error) {
container, err = client.InspectContainer(container.ID)
count++
}
if err != nil {
return false, err
}
if !container.State.Running {
return false, fmt.Errorf("container not running")
}
return true, nil
}, func(err error) {
require.NoError(err)
})
stdout := &noopCloser{bytes.NewBufferString("")}
stderr := &noopCloser{bytes.NewBufferString("")}
stdout := &noopCloser{bytes.NewBuffer(nil)}
stderr := &noopCloser{bytes.NewBuffer(nil)}
dl := NewDocklog(testlog.HCLogger(t)).(*dockerLogger)
dl := NewDockerLogger(testlog.HCLogger(t)).(*dockerLogger)
dl.stdout = stdout
dl.stderr = stderr
require.NoError(dl.Start(&StartOpts{
@@ -66,7 +68,6 @@ func TestDocklog(t *testing.T) {
echoToContainer(t, client, container.ID, "abc")
echoToContainer(t, client, container.ID, "123")
time.Sleep(2000 * time.Millisecond)
testutil.WaitForResult(func() (bool, error) {
act := stdout.String()
if "abc\n123\n" != act {

22
drivers/docker/docklog/plugin.go
View File

@@ -12,10 +12,12 @@ import (
"google.golang.org/grpc"
)
// LaunchDocklog launches an instance of docklog
const pluginName = "docker_logger"
// LaunchDockerLogger launches an instance of DockerLogger
// TODO: Integrate with base plugin loader
func LaunchDocklog(logger hclog.Logger) (Docklog, *plugin.Client, error) {
logger = logger.Named("docklog-launcher")
func LaunchDockerLogger(logger hclog.Logger) (DockerLogger, *plugin.Client, error) {
logger = logger.Named(pluginName)
bin, err := discover.NomadExecutable()
if err != nil {
return nil, nil, err
@@ -24,9 +26,9 @@ func LaunchDocklog(logger hclog.Logger) (Docklog, *plugin.Client, error) {
client := plugin.NewClient(&plugin.ClientConfig{
HandshakeConfig: base.Handshake,
Plugins: map[string]plugin.Plugin{
"docklog": &Plugin{impl: NewDocklog(hclog.L().Named("docklog"))},
pluginName: &Plugin{impl: NewDockerLogger(hclog.L().Named(pluginName))},
},
Cmd: exec.Command(bin, "docklog"),
Cmd: exec.Command(bin, pluginName),
AllowedProtocols: []plugin.Protocol{
plugin.ProtocolGRPC,
},
@@ -37,12 +39,12 @@ func LaunchDocklog(logger hclog.Logger) (Docklog, *plugin.Client, error) {
return nil, nil, err
}
raw, err := rpcClient.Dispense("docklog")
raw, err := rpcClient.Dispense(pluginName)
if err != nil {
return nil, nil, err
}
l := raw.(Docklog)
l := raw.(DockerLogger)
return l, client, nil
}
@@ -50,12 +52,12 @@ func LaunchDocklog(logger hclog.Logger) (Docklog, *plugin.Client, error) {
// Plugin is the go-plugin implementation
type Plugin struct {
plugin.NetRPCUnsupportedPlugin
impl Docklog
impl DockerLogger
}
// GRPCServer registered the server side implementation with the grpc server
func (p *Plugin) GRPCServer(broker *plugin.GRPCBroker, s *grpc.Server) error {
proto.RegisterDocklogServer(s, &docklogServer{
proto.RegisterDockerLoggerServer(s, &dockerLoggerServer{
impl: p.impl,
broker: broker,
})
@@ -64,5 +66,5 @@ func (p *Plugin) GRPCServer(broker *plugin.GRPCBroker, s *grpc.Server) error {
// 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 &docklogClient{client: proto.NewDocklogClient(c)}, nil
return &dockerLoggerClient{client: proto.NewDockerLoggerClient(c)}, nil
}

110
drivers/docker/docklog/proto/docklog.pb.go → drivers/docker/docklog/proto/docker_logger.pb.go
View File

@@ -1,5 +1,5 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: docklog.proto
// source: docker_logger.proto
package proto
@@ -40,7 +40,7 @@ func (m *StartRequest) Reset() { *m = StartRequest{} }
func (m *StartRequest) String() string { return proto.CompactTextString(m) }
func (*StartRequest) ProtoMessage() {}
func (*StartRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_docklog_6cb3edde8d295224, []int{0}
return fileDescriptor_docker_logger_54dce3369d4ecf54, []int{0}
}
func (m *StartRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_StartRequest.Unmarshal(m, b)
@@ -119,7 +119,7 @@ func (m *StartResponse) Reset() { *m = StartResponse{} }
func (m *StartResponse) String() string { return proto.CompactTextString(m) }
func (*StartResponse) ProtoMessage() {}
func (*StartResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_docklog_6cb3edde8d295224, []int{1}
return fileDescriptor_docker_logger_54dce3369d4ecf54, []int{1}
}
func (m *StartResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_StartResponse.Unmarshal(m, b)
@@ -149,7 +149,7 @@ func (m *StopRequest) Reset() { *m = StopRequest{} }
func (m *StopRequest) String() string { return proto.CompactTextString(m) }
func (*StopRequest) ProtoMessage() {}
func (*StopRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_docklog_6cb3edde8d295224, []int{2}
return fileDescriptor_docker_logger_54dce3369d4ecf54, []int{2}
}
func (m *StopRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_StopRequest.Unmarshal(m, b)
@@ -179,7 +179,7 @@ func (m *StopResponse) Reset() { *m = StopResponse{} }
func (m *StopResponse) String() string { return proto.CompactTextString(m) }
func (*StopResponse) ProtoMessage() {}
func (*StopResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_docklog_6cb3edde8d295224, []int{3}
return fileDescriptor_docker_logger_54dce3369d4ecf54, []int{3}
}
func (m *StopResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_StopResponse.Unmarshal(m, b)
@@ -214,125 +214,125 @@ var _ grpc.ClientConn
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// DocklogClient is the client API for Docklog service.
// DockerLoggerClient is the client API for DockerLogger service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type DocklogClient interface {
type DockerLoggerClient interface {
Start(ctx context.Context, in *StartRequest, opts ...grpc.CallOption) (*StartResponse, error)
Stop(ctx context.Context, in *StopRequest, opts ...grpc.CallOption) (*StopResponse, error)
}
type docklogClient struct {
type dockerLoggerClient struct {
cc *grpc.ClientConn
}
func NewDocklogClient(cc *grpc.ClientConn) DocklogClient {
return &docklogClient{cc}
func NewDockerLoggerClient(cc *grpc.ClientConn) DockerLoggerClient {
return &dockerLoggerClient{cc}
}
func (c *docklogClient) Start(ctx context.Context, in *StartRequest, opts ...grpc.CallOption) (*StartResponse, error) {
func (c *dockerLoggerClient) Start(ctx context.Context, in *StartRequest, opts ...grpc.CallOption) (*StartResponse, error) {
out := new(StartResponse)
err := c.cc.Invoke(ctx, "/hashicorp.nomad.drivers.docker.docklog.proto.Docklog/Start", in, out, opts...)
err := c.cc.Invoke(ctx, "/hashicorp.nomad.drivers.docker.docklog.proto.DockerLogger/Start", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *docklogClient) Stop(ctx context.Context, in *StopRequest, opts ...grpc.CallOption) (*StopResponse, error) {
func (c *dockerLoggerClient) Stop(ctx context.Context, in *StopRequest, opts ...grpc.CallOption) (*StopResponse, error) {
out := new(StopResponse)
err := c.cc.Invoke(ctx, "/hashicorp.nomad.drivers.docker.docklog.proto.Docklog/Stop", in, out, opts...)
err := c.cc.Invoke(ctx, "/hashicorp.nomad.drivers.docker.docklog.proto.DockerLogger/Stop", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// DocklogServer is the server API for Docklog service.
type DocklogServer interface {
// DockerLoggerServer is the server API for DockerLogger service.
type DockerLoggerServer interface {
Start(context.Context, *StartRequest) (*StartResponse, error)
Stop(context.Context, *StopRequest) (*StopResponse, error)
}
func RegisterDocklogServer(s *grpc.Server, srv DocklogServer) {
s.RegisterService(&_Docklog_serviceDesc, srv)
func RegisterDockerLoggerServer(s *grpc.Server, srv DockerLoggerServer) {
s.RegisterService(&_DockerLogger_serviceDesc, srv)
}
func _Docklog_Start_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
func _DockerLogger_Start_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(StartRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DocklogServer).Start(ctx, in)
return srv.(DockerLoggerServer).Start(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/hashicorp.nomad.drivers.docker.docklog.proto.Docklog/Start",
FullMethod: "/hashicorp.nomad.drivers.docker.docklog.proto.DockerLogger/Start",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DocklogServer).Start(ctx, req.(*StartRequest))
return srv.(DockerLoggerServer).Start(ctx, req.(*StartRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Docklog_Stop_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
func _DockerLogger_Stop_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(StopRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DocklogServer).Stop(ctx, in)
return srv.(DockerLoggerServer).Stop(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/hashicorp.nomad.drivers.docker.docklog.proto.Docklog/Stop",
FullMethod: "/hashicorp.nomad.drivers.docker.docklog.proto.DockerLogger/Stop",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DocklogServer).Stop(ctx, req.(*StopRequest))
return srv.(DockerLoggerServer).Stop(ctx, req.(*StopRequest))
}
return interceptor(ctx, in, info, handler)
}
var _Docklog_serviceDesc = grpc.ServiceDesc{
ServiceName: "hashicorp.nomad.drivers.docker.docklog.proto.Docklog",
HandlerType: (*DocklogServer)(nil),
var _DockerLogger_serviceDesc = grpc.ServiceDesc{
ServiceName: "hashicorp.nomad.drivers.docker.docklog.proto.DockerLogger",
HandlerType: (*DockerLoggerServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Start",
Handler: _Docklog_Start_Handler,
Handler: _DockerLogger_Start_Handler,
},
{
MethodName: "Stop",
Handler: _Docklog_Stop_Handler,
Handler: _DockerLogger_Stop_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "docklog.proto",
Metadata: "docker_logger.proto",
}
func init() { proto.RegisterFile("docklog.proto", fileDescriptor_docklog_6cb3edde8d295224) }
func init() { proto.RegisterFile("docker_logger.proto", fileDescriptor_docker_logger_54dce3369d4ecf54) }
var fileDescriptor_docklog_6cb3edde8d295224 = []byte{
// 311 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x90, 0xb1, 0x4e, 0xf3, 0x40,
0x10, 0x84, 0x7f, 0xe7, 0x8f, 0xed, 0xb0, 0x49, 0x40, 0x3a, 0x09, 0x61, 0xd2, 0x00, 0xae, 0x28,
0xd0, 0x15, 0x50, 0x11, 0x3a, 0x40, 0x48, 0x88, 0x2e, 0xe9, 0x68, 0x2c, 0xe3, 0x3b, 0x93, 0x53,
0x8c, 0xd7, 0xec, 0x6d, 0x90, 0x52, 0x21, 0xf1, 0x02, 0xbc, 0x1f, 0x4f, 0x83, 0x7c, 0x36, 0x16,
0x94, 0x49, 0x65, 0xef, 0xcc, 0x37, 0xa7, 0x9d, 0x85, 0xb1, 0xc2, 0x6c, 0x59, 0xe0, 0xb3, 0xac,
0x08, 0x19, 0xc5, 0xd9, 0x22, 0xb5, 0x0b, 0x93, 0x21, 0x55, 0xb2, 0xc4, 0x97, 0x54, 0x49, 0x45,
0xe6, 0x4d, 0x93, 0x95, 0x35, 0xa6, 0x49, 0xfe, 0xa1, 0xe3, 0x2f, 0x0f, 0x46, 0x73, 0x4e, 0x89,
0x67, 0xfa, 0x75, 0xa5, 0x2d, 0x8b, 0x09, 0x0c, 0x74, 0xa9, 0x2a, 0x34, 0x25, 0x47, 0xde, 0xb1,
0x77, 0xba, 0x33, 0xeb, 0x66, 0x71, 0x02, 0xa3, 0x0c, 0x4b, 0x4e, 0x4d, 0xa9, 0x29, 0x31, 0x2a,
0xea, 0x39, 0x7f, 0xd8, 0x69, 0xf7, 0x4a, 0x1c, 0xc1, 0xd0, 0xb2, 0xc2, 0x15, 0x27, 0xb9, 0xc9,
0x31, 0xfa, 0xef, 0x08, 0x68, 0xa4, 0x3b, 0x93, 0x63, 0x0b, 0x68, 0xa2, 0x06, 0xe8, 0x77, 0x80,
0x26, 0x72, 0xc0, 0x21, 0x0c, 0xb8, 0xb0, 0x49, 0xa6, 0x89, 0x23, 0xdf, 0xb9, 0x21, 0x17, 0xf6,
0x46, 0x13, 0x8b, 0x03, 0xa8, 0x7f, 0x93, 0xa5, 0x5e, 0x47, 0x81, 0x73, 0x02, 0x2e, 0xec, 0x83,
0x5e, 0x8b, 0x7d, 0x08, 0x5c, 0x26, 0x8d, 0x42, 0xa7, 0xfb, 0x75, 0x22, 0x8d, 0xf7, 0x60, 0xdc,
0x76, 0xb3, 0x15, 0x96, 0x56, 0xc7, 0x63, 0x18, 0xce, 0x19, 0xab, 0xb6, 0x6b, 0xbc, 0x5b, 0x77,
0xaf, 0xc7, 0xc6, 0x3e, 0xff, 0xec, 0x41, 0x78, 0xdb, 0x9c, 0x47, 0x7c, 0x78, 0xe0, 0xbb, 0xb0,
0x98, 0xca, 0x4d, 0x2e, 0x2a, 0x7f, 0x5f, 0x73, 0x72, 0xb5, 0x55, 0xb6, 0xdd, 0xf6, 0x9f, 0x78,
0x87, 0x7e, 0xbd, 0xa0, 0xb8, 0xdc, 0xf4, 0x99, 0xae, 0xe3, 0x64, 0xba, 0x4d, 0xf4, 0x67, 0x81,
0xeb, 0xf0, 0xd1, 0x77, 0xfa, 0x53, 0xe0, 0x3e, 0x17, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xd7,
0xfa, 0x4e, 0xd3, 0x6d, 0x02, 0x00, 0x00,
var fileDescriptor_docker_logger_54dce3369d4ecf54 = []byte{
// 319 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x50, 0xbd, 0x4e, 0xe3, 0x40,
0x10, 0x3e, 0xe7, 0x62, 0x27, 0x37, 0x49, 0xee, 0xa4, 0x3d, 0x21, 0x4c, 0x1a, 0xc0, 0x15, 0x05,
0x72, 0x01, 0x15, 0xa1, 0x03, 0x84, 0x84, 0xa0, 0x4a, 0x3a, 0x1a, 0xcb, 0x78, 0x27, 0xc9, 0x2a,
0xc6, 0x63, 0x66, 0x27, 0x48, 0xa9, 0x90, 0x78, 0x06, 0x9e, 0x8e, 0xa7, 0x41, 0x5e, 0x1b, 0x8b,
0x36, 0xa9, 0x76, 0xe7, 0xfb, 0x19, 0xcd, 0xf7, 0xc1, 0x7f, 0x4d, 0xd9, 0x0a, 0x39, 0xc9, 0x69,
0xb1, 0x40, 0x8e, 0x4b, 0x26, 0x21, 0x75, 0xba, 0x4c, 0xed, 0xd2, 0x64, 0xc4, 0x65, 0x5c, 0xd0,
0x73, 0xaa, 0x63, 0xcd, 0xe6, 0x15, 0xd9, 0xc6, 0xb5, 0xd8, 0x3d, 0x39, 0x2d, 0x6a, 0x75, 0xf4,
0xe9, 0xc1, 0x70, 0x26, 0x29, 0xcb, 0x14, 0x5f, 0xd6, 0x68, 0x45, 0x8d, 0xa1, 0x8f, 0x85, 0x2e,
0xc9, 0x14, 0x12, 0x7a, 0x47, 0xde, 0xc9, 0x9f, 0x69, 0x3b, 0xab, 0x63, 0x18, 0x66, 0x54, 0x48,
0x6a, 0x0a, 0xe4, 0xc4, 0xe8, 0xb0, 0xe3, 0xf8, 0x41, 0x8b, 0xdd, 0x69, 0x75, 0x08, 0x03, 0x2b,
0x9a, 0xd6, 0x92, 0xcc, 0xcd, 0x9c, 0xc2, 0xdf, 0x4e, 0x01, 0x35, 0x74, 0x6b, 0xe6, 0xd4, 0x08,
0x90, 0xb9, 0x16, 0x74, 0x5b, 0x01, 0x32, 0x3b, 0xc1, 0x01, 0xf4, 0x25, 0xb7, 0x49, 0x86, 0x2c,
0xa1, 0xef, 0xd8, 0x9e, 0xe4, 0xf6, 0x1a, 0x59, 0xd4, 0x3e, 0x54, 0xdf, 0x64, 0x85, 0x9b, 0x30,
0x70, 0x4c, 0x20, 0xb9, 0xbd, 0xc7, 0x8d, 0xda, 0x83, 0xc0, 0x79, 0xd2, 0xb0, 0xe7, 0x70, 0xbf,
0x72, 0xa4, 0xd1, 0x3f, 0x18, 0x35, 0xd9, 0x6c, 0x49, 0x85, 0xc5, 0x68, 0x04, 0x83, 0x99, 0x50,
0xd9, 0x64, 0x8d, 0xfe, 0x56, 0xd9, 0xab, 0xb1, 0xa6, 0xcf, 0x3e, 0x3a, 0x30, 0xbc, 0x71, 0x2d,
0x3d, 0xb8, 0x46, 0xd5, 0xbb, 0x07, 0xbe, 0xdb, 0xa0, 0x26, 0xf1, 0x36, 0xb5, 0xc6, 0x3f, 0x2b,
0x1d, 0x5f, 0xee, 0xe4, 0x6d, 0x4e, 0xfe, 0xa5, 0xde, 0xa0, 0x5b, 0x5d, 0xa9, 0x2e, 0xb6, 0x5d,
0xd3, 0x06, 0x1d, 0x4f, 0x76, 0xb1, 0x7e, 0x1f, 0x70, 0xd5, 0x7b, 0xf4, 0x1d, 0xfe, 0x14, 0xb8,
0xe7, 0xfc, 0x2b, 0x00, 0x00, 0xff, 0xff, 0x2e, 0xe1, 0xdf, 0xc9, 0x78, 0x02, 0x00, 0x00,
}

2
drivers/docker/docklog/proto/docklog.proto → drivers/docker/docklog/proto/docker_logger.proto
View File

@@ -2,7 +2,7 @@ syntax = "proto3";
package hashicorp.nomad.drivers.docker.docklog.proto;
option go_package = "proto";
service Docklog {
service DockerLogger {
rpc Start(StartRequest) returns (StartResponse) {}
rpc Stop(StopRequest) returns (StopResponse) {}
}

14
drivers/docker/docklog/server.go
View File

@@ -7,14 +7,14 @@ import (
"github.com/hashicorp/nomad/drivers/docker/docklog/proto"
)
// docklogServer is the server side translation between the protobuf and native interfaces
type docklogServer struct {
// dockerLoggerServer is the server side translation between the protobuf and native interfaces
type dockerLoggerServer struct {
broker *plugin.GRPCBroker
impl Docklog
impl DockerLogger
}
// Start proxies the protobuf Start RPC to the Start fun of the Docklog interface
func (s *docklogServer) Start(ctx context.Context, req *proto.StartRequest) (*proto.StartResponse, error) {
// Start proxies the protobuf Start RPC to the Start fun of the DockerLogger interface
func (s *dockerLoggerServer) Start(ctx context.Context, req *proto.StartRequest) (*proto.StartResponse, error) {
opts := &StartOpts{
Endpoint: req.Endpoint,
ContainerID: req.ContainerId,
@@ -33,7 +33,7 @@ func (s *docklogServer) Start(ctx context.Context, req *proto.StartRequest) (*pr
return resp, nil
}
// Stop proxies the protobuf Stop RPC to the Stop fun of the Docklog interface
func (s *docklogServer) Stop(ctx context.Context, req *proto.StopRequest) (*proto.StopResponse, error) {
// Stop proxies the protobuf Stop RPC to the Stop fun of the DockerLogger interface
func (s *dockerLoggerServer) Stop(ctx context.Context, req *proto.StopRequest) (*proto.StopResponse, error) {
return &proto.StopResponse{}, s.impl.Stop()
}