driver/docker: rename container logger

Author: nickethier

drivers/docker/docklog/client.go

@@ -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

drivers/docker/docklog/docklog.go drivers/docker/docklog/docker_logger.go

@@ -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
 

drivers/docker/docklog/docklog_test.go drivers/docker/docklog/docker_logger_test.go

@@ -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 {

drivers/docker/docklog/plugin.go

@@ -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,25 +39,25 @@ 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
 
 }
 
 // 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
 }