Move "info" to daemon/info.go

Signed-off-by: Solomon Hykes <solomon@docker.com>
Upstream-commit: 94715e8e643f0bc9aa57841b346f5196f75f0dc0
Component: engine

components/engine/daemon/daemon.go

@@ -118,6 +118,7 @@ func (daemon *Daemon) Install(eng *engine.Engine) error {
 		"create":            daemon.ContainerCreate,
 		"delete":            daemon.ContainerDestroy,
 		"export":            daemon.ContainerExport,
+		"info":              daemon.CmdInfo,
 		"kill":              daemon.ContainerKill,
 		"logs":              daemon.ContainerLogs,
 		"pause":             daemon.ContainerPause,

components/engine/daemon/info.go

@@ -0,0 +1,74 @@
+package daemon
+
+import (
+	"os"
+	"runtime"
+
+	"github.com/docker/docker/dockerversion"
+	"github.com/docker/docker/engine"
+	"github.com/docker/docker/pkg/parsers/kernel"
+	"github.com/docker/docker/pkg/parsers/operatingsystem"
+	"github.com/docker/docker/registry"
+	"github.com/docker/docker/utils"
+)
+
+func (daemon *Daemon) CmdInfo(job *engine.Job) engine.Status {
+	images, _ := daemon.Graph().Map()
+	var imgcount int
+	if images == nil {
+		imgcount = 0
+	} else {
+		imgcount = len(images)
+	}
+	kernelVersion := "<unknown>"
+	if kv, err := kernel.GetKernelVersion(); err == nil {
+		kernelVersion = kv.String()
+	}
+
+	operatingSystem := "<unknown>"
+	if s, err := operatingsystem.GetOperatingSystem(); err == nil {
+		operatingSystem = s
+	}
+	if inContainer, err := operatingsystem.IsContainerized(); err != nil {
+		utils.Errorf("Could not determine if daemon is containerized: %v", err)
+		operatingSystem += " (error determining if containerized)"
+	} else if inContainer {
+		operatingSystem += " (containerized)"
+	}
+
+	// if we still have the original dockerinit binary from before we copied it locally, let's return the path to that, since that's more intuitive (the copied path is trivial to derive by hand given VERSION)
+	initPath := utils.DockerInitPath("")
+	if initPath == "" {
+		// if that fails, we'll just return the path from the daemon
+		initPath = daemon.SystemInitPath()
+	}
+
+	cjob := job.Eng.Job("subscribers_count")
+	env, _ := cjob.Stdout.AddEnv()
+	if err := cjob.Run(); err != nil {
+		return job.Error(err)
+	}
+	v := &engine.Env{}
+	v.SetInt("Containers", len(daemon.List()))
+	v.SetInt("Images", imgcount)
+	v.Set("Driver", daemon.GraphDriver().String())
+	v.SetJson("DriverStatus", daemon.GraphDriver().Status())
+	v.SetBool("MemoryLimit", daemon.SystemConfig().MemoryLimit)
+	v.SetBool("SwapLimit", daemon.SystemConfig().SwapLimit)
+	v.SetBool("IPv4Forwarding", !daemon.SystemConfig().IPv4ForwardingDisabled)
+	v.SetBool("Debug", os.Getenv("DEBUG") != "")
+	v.SetInt("NFd", utils.GetTotalUsedFds())
+	v.SetInt("NGoroutines", runtime.NumGoroutine())
+	v.Set("ExecutionDriver", daemon.ExecutionDriver().Name())
+	v.SetInt("NEventsListener", env.GetInt("count"))
+	v.Set("KernelVersion", kernelVersion)
+	v.Set("OperatingSystem", operatingSystem)
+	v.Set("IndexServerAddress", registry.IndexServerAddress())
+	v.Set("InitSha1", dockerversion.INITSHA1)
+	v.Set("InitPath", initPath)
+	v.SetList("Sockets", daemon.Sockets)
+	if _, err := v.WriteTo(job.Stdout); err != nil {
+		return job.Error(err)
+	}
+	return engine.StatusOK
+}

components/engine/server/init.go

@@ -86,7 +86,6 @@ func InitServer(job *engine.Job) engine.Status {
 	job.Eng.Hack_SetGlobalVar("httpapi.daemon", srv.daemon)
 
 	for name, handler := range map[string]engine.Handler{
-		"info":  srv.DockerInfo,
 		"build": srv.Build,
 		"pull":  srv.ImagePull,
 		"push":  srv.ImagePush,

components/engine/server/server.go

@@ -22,81 +22,13 @@
 package server
 
 import (
-	"os"
-	"runtime"
 	"sync"
 	"time"
 
 	"github.com/docker/docker/daemon"
-	"github.com/docker/docker/dockerversion"
 	"github.com/docker/docker/engine"
-	"github.com/docker/docker/pkg/parsers/kernel"
-	"github.com/docker/docker/pkg/parsers/operatingsystem"
-	"github.com/docker/docker/registry"
-	"github.com/docker/docker/utils"
 )
 
-func (srv *Server) DockerInfo(job *engine.Job) engine.Status {
-	images, _ := srv.daemon.Graph().Map()
-	var imgcount int
-	if images == nil {
-		imgcount = 0
-	} else {
-		imgcount = len(images)
-	}
-	kernelVersion := "<unknown>"
-	if kv, err := kernel.GetKernelVersion(); err == nil {
-		kernelVersion = kv.String()
-	}
-
-	operatingSystem := "<unknown>"
-	if s, err := operatingsystem.GetOperatingSystem(); err == nil {
-		operatingSystem = s
-	}
-	if inContainer, err := operatingsystem.IsContainerized(); err != nil {
-		utils.Errorf("Could not determine if daemon is containerized: %v", err)
-		operatingSystem += " (error determining if containerized)"
-	} else if inContainer {
-		operatingSystem += " (containerized)"
-	}
-
-	// if we still have the original dockerinit binary from before we copied it locally, let's return the path to that, since that's more intuitive (the copied path is trivial to derive by hand given VERSION)
-	initPath := utils.DockerInitPath("")
-	if initPath == "" {
-		// if that fails, we'll just return the path from the daemon
-		initPath = srv.daemon.SystemInitPath()
-	}
-
-	cjob := job.Eng.Job("subscribers_count")
-	env, _ := cjob.Stdout.AddEnv()
-	if err := cjob.Run(); err != nil {
-		return job.Error(err)
-	}
-	v := &engine.Env{}
-	v.SetInt("Containers", len(srv.daemon.List()))
-	v.SetInt("Images", imgcount)
-	v.Set("Driver", srv.daemon.GraphDriver().String())
-	v.SetJson("DriverStatus", srv.daemon.GraphDriver().Status())
-	v.SetBool("MemoryLimit", srv.daemon.SystemConfig().MemoryLimit)
-	v.SetBool("SwapLimit", srv.daemon.SystemConfig().SwapLimit)
-	v.SetBool("IPv4Forwarding", !srv.daemon.SystemConfig().IPv4ForwardingDisabled)
-	v.SetBool("Debug", os.Getenv("DEBUG") != "")
-	v.SetInt("NFd", utils.GetTotalUsedFds())
-	v.SetInt("NGoroutines", runtime.NumGoroutine())
-	v.Set("ExecutionDriver", srv.daemon.ExecutionDriver().Name())
-	v.SetInt("NEventsListener", env.GetInt("count"))
-	v.Set("KernelVersion", kernelVersion)
-	v.Set("OperatingSystem", operatingSystem)
-	v.Set("IndexServerAddress", registry.IndexServerAddress())
-	v.Set("InitSha1", dockerversion.INITSHA1)
-	v.Set("InitPath", initPath)
-	v.SetList("Sockets", srv.daemon.Sockets)
-	if _, err := v.WriteTo(job.Stdout); err != nil {
-		return job.Error(err)
-	}
-	return engine.StatusOK
-}
-
 func (srv *Server) SetRunning(status bool) {
 	srv.Lock()
 	defer srv.Unlock()