Merge pull request #3173 from vieux/docker_info_job

Move info to job

api.go

@@ -216,7 +216,8 @@ func getImagesViz(srv *Server, version float64, w http.ResponseWriter, r *http.R
 }
 
 func getInfo(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	return writeJSON(w, http.StatusOK, srv.DockerInfo())
+	srv.Eng.ServeHTTP(w, r)
+	return nil
 }
 
 func getEvents(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

api_params.go

@@ -29,23 +29,6 @@ type (
 		VirtualSize int64
 	}
 
-	APIInfo struct {
-		Debug              bool
-		Containers         int
-		Images             int
-		Driver             string      `json:",omitempty"`
-		DriverStatus       [][2]string `json:",omitempty"`
-		NFd                int         `json:",omitempty"`
-		NGoroutines        int         `json:",omitempty"`
-		MemoryLimit        bool        `json:",omitempty"`
-		SwapLimit          bool        `json:",omitempty"`
-		IPv4Forwarding     bool        `json:",omitempty"`
-		LXCVersion         string      `json:",omitempty"`
-		NEventsListener    int         `json:",omitempty"`
-		KernelVersion      string      `json:",omitempty"`
-		IndexServerAddress string      `json:",omitempty"`
-	}
-
 	APITop struct {
 		Titles    []string
 		Processes [][]string

commands.go

@@ -433,42 +433,53 @@ func (cli *DockerCli) CmdInfo(args ...string) error {
 		return err
 	}
 
-	var out APIInfo
+	out := engine.NewOutput()
-	if err := json.Unmarshal(body, &out); err != nil {
+	remoteInfo, err := out.AddEnv()
+	if err != nil {
 		return err
 	}
 
-	fmt.Fprintf(cli.out, "Containers: %d\n", out.Containers)
+	if _, err := out.Write(body); err != nil {
-	fmt.Fprintf(cli.out, "Images: %d\n", out.Images)
+		utils.Errorf("Error reading remote info: %s\n", err)
-	fmt.Fprintf(cli.out, "Driver: %s\n", out.Driver)
+		return err
-	for _, pair := range out.DriverStatus {
+	}
+	out.Close()
+
+	fmt.Fprintf(cli.out, "Containers: %d\n", remoteInfo.GetInt("Containers"))
+	fmt.Fprintf(cli.out, "Images: %d\n", remoteInfo.GetInt("Images"))
+	fmt.Fprintf(cli.out, "Driver: %s\n", remoteInfo.Get("Driver"))
+	var driverStatus [][2]string
+	if err := remoteInfo.GetJson("DriverStatus", &driverStatus); err != nil {
+		return err
+	}
+	for _, pair := range driverStatus {
 		fmt.Fprintf(cli.out, " %s: %s\n", pair[0], pair[1])
 	}
-	if out.Debug || os.Getenv("DEBUG") != "" {
+	if remoteInfo.GetBool("Debug") || os.Getenv("DEBUG") != "" {
-		fmt.Fprintf(cli.out, "Debug mode (server): %v\n", out.Debug)
+		fmt.Fprintf(cli.out, "Debug mode (server): %v\n", remoteInfo.GetBool("Debug"))
 		fmt.Fprintf(cli.out, "Debug mode (client): %v\n", os.Getenv("DEBUG") != "")
-		fmt.Fprintf(cli.out, "Fds: %d\n", out.NFd)
+		fmt.Fprintf(cli.out, "Fds: %d\n", remoteInfo.GetInt("NFd"))
-		fmt.Fprintf(cli.out, "Goroutines: %d\n", out.NGoroutines)
+		fmt.Fprintf(cli.out, "Goroutines: %d\n", remoteInfo.GetInt("NGoroutines"))
-		fmt.Fprintf(cli.out, "LXC Version: %s\n", out.LXCVersion)
+		fmt.Fprintf(cli.out, "LXC Version: %s\n", remoteInfo.Get("LXCVersion"))
-		fmt.Fprintf(cli.out, "EventsListeners: %d\n", out.NEventsListener)
+		fmt.Fprintf(cli.out, "EventsListeners: %d\n", remoteInfo.GetInt("NEventsListener"))
-		fmt.Fprintf(cli.out, "Kernel Version: %s\n", out.KernelVersion)
+		fmt.Fprintf(cli.out, "Kernel Version: %s\n", remoteInfo.Get("KernelVersion"))
 	}
 
-	if len(out.IndexServerAddress) != 0 {
+	if len(remoteInfo.GetList("IndexServerAddress")) != 0 {
 		cli.LoadConfigFile()
-		u := cli.configFile.Configs[out.IndexServerAddress].Username
+		u := cli.configFile.Configs[remoteInfo.Get("IndexServerAddress")].Username
 		if len(u) > 0 {
 			fmt.Fprintf(cli.out, "Username: %v\n", u)
-			fmt.Fprintf(cli.out, "Registry: %v\n", out.IndexServerAddress)
+			fmt.Fprintf(cli.out, "Registry: %v\n", remoteInfo.GetList("IndexServerAddress"))
 		}
 	}
-	if !out.MemoryLimit {
+	if !remoteInfo.GetBool("MemoryLimit") {
 		fmt.Fprintf(cli.err, "WARNING: No memory limit support\n")
 	}
-	if !out.SwapLimit {
+	if !remoteInfo.GetBool("SwapLimit") {
 		fmt.Fprintf(cli.err, "WARNING: No swap limit support\n")
 	}
-	if !out.IPv4Forwarding {
+	if !remoteInfo.GetBool("IPv4Forwarding") {
 		fmt.Fprintf(cli.err, "WARNING: IPv4 forwarding is disabled.\n")
 	}
 	return nil

engine/env.go

@@ -51,7 +51,11 @@ func (env *Env) SetBool(key string, value bool) {
 	}
 }
 
-func (env *Env) GetInt(key string) int64 {
+func (env *Env) GetInt(key string) int {
+	return int(env.GetInt64(key))
+}
+
+func (env *Env) GetInt64(key string) int64 {
 	s := strings.Trim(env.Get(key), " \t")
 	val, err := strconv.ParseInt(s, 10, 64)
 	if err != nil {
@@ -60,7 +64,11 @@ func (env *Env) GetInt(key string) int64 {
 	return val
 }
 
-func (env *Env) SetInt(key string, value int64) {
+func (env *Env) SetInt(key string, value int) {
+	env.Set(key, fmt.Sprintf("%d", value))
+}
+
+func (env *Env) SetInt64(key string, value int64) {
 	env.Set(key, fmt.Sprintf("%d", value))
 }
 
@@ -145,7 +153,7 @@ func (env *Env) SetAuto(k string, v interface{}) {
 	// encoding/json decodes integers to float64, but cannot encode them back.
 	// (See http://golang.org/src/pkg/encoding/json/decode.go#L46)
 	if fval, ok := v.(float64); ok {
-		env.SetInt(k, int64(fval))
+		env.SetInt64(k, int64(fval))
 	} else if sval, ok := v.(string); ok {
 		env.Set(k, sval)
 	} else if val, err := json.Marshal(v); err == nil {

engine/job.go

@@ -113,11 +113,19 @@ func (job *Job) SetenvBool(key string, value bool) {
 	job.env.SetBool(key, value)
 }
 
-func (job *Job) GetenvInt(key string) int64 {
+func (job *Job) GetenvInt64(key string) int64 {
+	return job.env.GetInt64(key)
+}
+
+func (job *Job) GetenvInt(key string) int {
 	return job.env.GetInt(key)
 }
 
-func (job *Job) SetenvInt(key string, value int64) {
+func (job *Job) SetenvInt64(key string, value int64) {
+	job.env.SetInt64(key, value)
+}
+
+func (job *Job) SetenvInt(key string, value int) {
 	job.env.SetInt(key, value)
 }
 

integration/api_test.go

@@ -72,13 +72,17 @@ func TestGetInfo(t *testing.T) {
 	}
 	assertHttpNotError(r, t)
 
-	infos := &docker.APIInfo{}
+	out := engine.NewOutput()
-	err = json.Unmarshal(r.Body.Bytes(), infos)
+	i, err := out.AddEnv()
 	if err != nil {
 		t.Fatal(err)
 	}
-	if infos.Images != len(initialImages) {
+	if _, err := io.Copy(out, r.Body); err != nil {
-		t.Errorf("Expected images: %d, %d found", len(initialImages), infos.Images)
+		t.Fatal(err)
+	}
+	out.Close()
+	if images := i.GetInt("Images"); images != len(initialImages) {
+		t.Errorf("Expected images: %d, %d found", len(initialImages), images)
 	}
 }
 

server.go

@@ -111,6 +111,10 @@ func jobInitApi(job *engine.Job) engine.Status {
 		job.Error(err)
 		return engine.StatusErr
 	}
+	if err := job.Eng.Register("info", srv.DockerInfo); err != nil {
+		job.Error(err)
+		return engine.StatusErr
+	}
 	return engine.StatusOK
 }
 
@@ -610,7 +614,7 @@ func (srv *Server) Images(all bool, filter string) ([]APIImages, error) {
 	return outs, nil
 }
 
-func (srv *Server) DockerInfo() *APIInfo {
+func (srv *Server) DockerInfo(job *engine.Job) engine.Status {
 	images, _ := srv.runtime.graph.Map()
 	var imgcount int
 	if images == nil {
@@ -630,22 +634,26 @@ func (srv *Server) DockerInfo() *APIInfo {
 		kernelVersion = kv.String()
 	}
 
-	return &APIInfo{
+	v := &engine.Env{}
-		Containers:         len(srv.runtime.List()),
+	v.SetInt("Containers", len(srv.runtime.List()))
-		Images:             imgcount,
+	v.SetInt("Images", imgcount)
-		Driver:             srv.runtime.driver.String(),
+	v.Set("Driver", srv.runtime.driver.String())
-		DriverStatus:       srv.runtime.driver.Status(),
+	v.SetJson("DriverStatus", srv.runtime.driver.Status())
-		MemoryLimit:        srv.runtime.capabilities.MemoryLimit,
+	v.SetBool("MemoryLimit", srv.runtime.capabilities.MemoryLimit)
-		SwapLimit:          srv.runtime.capabilities.SwapLimit,
+	v.SetBool("SwapLimit", srv.runtime.capabilities.SwapLimit)
-		IPv4Forwarding:     !srv.runtime.capabilities.IPv4ForwardingDisabled,
+	v.SetBool("IPv4Forwarding", !srv.runtime.capabilities.IPv4ForwardingDisabled)
-		Debug:              os.Getenv("DEBUG") != "",
+	v.SetBool("Debug", os.Getenv("DEBUG") != "")
-		NFd:                utils.GetTotalUsedFds(),
+	v.SetInt("NFd", utils.GetTotalUsedFds())
-		NGoroutines:        runtime.NumGoroutine(),
+	v.SetInt("NGoroutines", runtime.NumGoroutine())
-		LXCVersion:         lxcVersion,
+	v.Set("LXCVersion", lxcVersion)
-		NEventsListener:    len(srv.events),
+	v.SetInt("NEventsListener", len(srv.events))
-		KernelVersion:      kernelVersion,
+	v.Set("KernelVersion", kernelVersion)
-		IndexServerAddress: auth.IndexServerAddress(),
+	v.Set("IndexServerAddress", auth.IndexServerAddress())
+	if _, err := v.WriteTo(job.Stdout); err != nil {
+		job.Error(err)
+		return engine.StatusErr
 	}
+	return engine.StatusOK
 }
 
 func (srv *Server) ImageHistory(name string) ([]APIHistory, error) {