Make dockerd debuggable

Signed-off-by: John Howard <jhoward@microsoft.com>

client.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"path/filepath"
+
+	"github.com/docker/docker/cli"
+	cliflags "github.com/docker/docker/cli/flags"
+	"github.com/docker/docker/cliconfig"
+	flag "github.com/docker/docker/pkg/mflag"
+	"github.com/docker/docker/utils"
+)
+
+var (
+	commonFlags = cliflags.InitCommonFlags()
+	clientFlags = &cli.ClientFlags{FlagSet: new(flag.FlagSet), Common: commonFlags}
+)
+
+func init() {
+
+	client := clientFlags.FlagSet
+	client.StringVar(&clientFlags.ConfigDir, []string{"-config"}, cliconfig.ConfigDir(), "Location of client config files")
+
+	clientFlags.PostParse = func() {
+		clientFlags.Common.PostParse()
+
+		if clientFlags.ConfigDir != "" {
+			cliconfig.SetConfigDir(clientFlags.ConfigDir)
+		}
+
+		if clientFlags.Common.TrustKey == "" {
+			clientFlags.Common.TrustKey = filepath.Join(cliconfig.ConfigDir(), cliflags.DefaultTrustKeyFile)
+		}
+
+		if clientFlags.Common.Debug {
+			utils.EnableDebug()
+		}
+	}
+}

client_test.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"os"
+	"testing"
+
+	"github.com/Sirupsen/logrus"
+	"github.com/docker/docker/utils"
+)
+
+func TestClientDebugEnabled(t *testing.T) {
+	defer utils.DisableDebug()
+
+	clientFlags.Common.FlagSet.Parse([]string{"-D"})
+	clientFlags.PostParse()
+
+	if os.Getenv("DEBUG") != "1" {
+		t.Fatal("expected debug enabled, got false")
+	}
+	if logrus.GetLevel() != logrus.DebugLevel {
+		t.Fatalf("expected logrus debug level, got %v", logrus.GetLevel())
+	}
+}

daemon.go

@@ -0,0 +1,11 @@
+package main
+
+const daemonBinary = "dockerd"
+
+// DaemonProxy acts as a cli.Handler to proxy calls to the daemon binary
+type DaemonProxy struct{}
+
+// NewDaemonProxy returns a new handler
+func NewDaemonProxy() DaemonProxy {
+	return DaemonProxy{}
+}

daemon_unix.go

@@ -0,0 +1,37 @@
+// +build !windows
+
+package main
+
+import (
+	"os"
+	"os/exec"
+	"syscall"
+)
+
+// CmdDaemon execs dockerd with the same flags
+// TODO: add a deprecation warning?
+func (p DaemonProxy) CmdDaemon(args ...string) error {
+	// Use os.Args[1:] so that "global" args are passed to dockerd
+	args = stripDaemonArg(os.Args[1:])
+
+	// TODO: check dirname args[0] first
+	binaryAbsPath, err := exec.LookPath(daemonBinary)
+	if err != nil {
+		return err
+	}
+
+	return syscall.Exec(
+		binaryAbsPath,
+		append([]string{daemonBinary}, args...),
+		os.Environ())
+}
+
+// stripDaemonArg removes the `daemon` argument from the list
+func stripDaemonArg(args []string) []string {
+	for i, arg := range args {
+		if arg == "daemon" {
+			return append(args[:i], args[i+1:]...)
+		}
+	}
+	return args
+}

daemon_windows.go

@@ -0,0 +1,11 @@
+package main
+
+import (
+	"fmt"
+)
+
+// CmdDaemon reports on an error on windows, because there is no exec
+func (p DaemonProxy) CmdDaemon(args ...string) error {
+	return fmt.Errorf(
+		"`docker daemon` does not exist on windows. Please run `dockerd` directly")
+}

daemon_windows_test.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestCmdDaemon(t *testing.T) {
+	proxy := NewDaemonProxy()
+	err := proxy.CmdDaemon("--help")
+	if err == nil {
+		t.Fatal("Expected CmdDaemon to fail in Windows.")
+	}
+
+	if !strings.Contains(err.Error(), "Please run `dockerd`") {
+		t.Fatalf("Expected an error about running dockerd, got %s", err)
+	}
+}

docker.go

@@ -0,0 +1,77 @@
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/Sirupsen/logrus"
+	"github.com/docker/docker/api/client"
+	"github.com/docker/docker/cli"
+	"github.com/docker/docker/dockerversion"
+	flag "github.com/docker/docker/pkg/mflag"
+	"github.com/docker/docker/pkg/term"
+	"github.com/docker/docker/utils"
+)
+
+func main() {
+	// Set terminal emulation based on platform as required.
+	stdin, stdout, stderr := term.StdStreams()
+
+	logrus.SetOutput(stderr)
+
+	flag.Merge(flag.CommandLine, clientFlags.FlagSet, commonFlags.FlagSet)
+
+	flag.Usage = func() {
+		fmt.Fprint(stdout, "Usage: docker [OPTIONS] COMMAND [arg...]\n       docker [ --help | -v | --version ]\n\n")
+		fmt.Fprint(stdout, "A self-sufficient runtime for containers.\n\nOptions:\n")
+
+		flag.CommandLine.SetOutput(stdout)
+		flag.PrintDefaults()
+
+		help := "\nCommands:\n"
+
+		for _, cmd := range dockerCommands {
+			help += fmt.Sprintf("    %-10.10s%s\n", cmd.Name, cmd.Description)
+		}
+
+		help += "\nRun 'docker COMMAND --help' for more information on a command."
+		fmt.Fprintf(stdout, "%s\n", help)
+	}
+
+	flag.Parse()
+
+	if *flVersion {
+		showVersion()
+		return
+	}
+
+	if *flHelp {
+		// if global flag --help is present, regardless of what other options and commands there are,
+		// just print the usage.
+		flag.Usage()
+		return
+	}
+
+	clientCli := client.NewDockerCli(stdin, stdout, stderr, clientFlags)
+
+	c := cli.New(clientCli, NewDaemonProxy())
+	if err := c.Run(flag.Args()...); err != nil {
+		if sterr, ok := err.(cli.StatusError); ok {
+			if sterr.Status != "" {
+				fmt.Fprintln(stderr, sterr.Status)
+				os.Exit(1)
+			}
+			os.Exit(sterr.StatusCode)
+		}
+		fmt.Fprintln(stderr, err)
+		os.Exit(1)
+	}
+}
+
+func showVersion() {
+	if utils.ExperimentalBuild() {
+		fmt.Printf("Docker version %s, build %s, experimental\n", dockerversion.Version, dockerversion.GitCommit)
+	} else {
+		fmt.Printf("Docker version %s, build %s\n", dockerversion.Version, dockerversion.GitCommit)
+	}
+}

docker_windows.go

@@ -0,0 +1,5 @@
+package main
+
+import (
+	_ "github.com/docker/docker/autogen/winresources/dockerd"
+)

flags.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"sort"
+
+	"github.com/docker/docker/cli"
+	flag "github.com/docker/docker/pkg/mflag"
+)
+
+var (
+	flHelp    = flag.Bool([]string{"h", "-help"}, false, "Print usage")
+	flVersion = flag.Bool([]string{"v", "-version"}, false, "Print version information and quit")
+)
+
+type byName []cli.Command
+
+func (a byName) Len() int           { return len(a) }
+func (a byName) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+func (a byName) Less(i, j int) bool { return a[i].Name < a[j].Name }
+
+var dockerCommands []cli.Command
+
+// TODO(tiborvass): do not show 'daemon' on client-only binaries
+
+func init() {
+	for _, cmd := range cli.DockerCommands {
+		dockerCommands = append(dockerCommands, cmd)
+	}
+	sort.Sort(byName(dockerCommands))
+}

flags_test.go

@@ -0,0 +1,13 @@
+package main
+
+import (
+	"sort"
+	"testing"
+)
+
+// Tests if the subcommands of docker are sorted
+func TestDockerSubcommandsAreSorted(t *testing.T) {
+	if !sort.IsSorted(byName(dockerCommands)) {
+		t.Fatal("Docker subcommands are not in sorted order")
+	}
+}