Skip to content

Commit 8cfefc6

Browse files
thaJeztahthaJeztah
committed
cli/command/system: prettyPrintServerInfo: accept Streams
No need to pass whole of DockerCLI, as all it needs is the outputs. Signed-off-by: Sebastiaan van Stijn <github@gone.nl>
1 parent ba7a200 commit 8cfefc6

1 file changed

Lines changed: 65 additions & 64 deletions

File tree

‎cli/command/system/info.go‎

Lines changed: 65 additions & 64 deletions
Original file line numberDiff line numberDiff line change
@@ -216,54 +216,55 @@ func prettyPrintClientInfo(streams command.Streams, info clientInfo) {
216216
}
217217

218218
//nolint:gocyclo
219-
func prettyPrintServerInfo(dockerCli command.Cli, info *info) []error {
219+
func prettyPrintServerInfo(streams command.Streams, info *info) []error {
220220
var errs []error
221+
output := streams.Out()
221222

222-
fmt.Fprintln(dockerCli.Out(), " Containers:", info.Containers)
223-
fmt.Fprintln(dockerCli.Out(), " Running:", info.ContainersRunning)
224-
fmt.Fprintln(dockerCli.Out(), " Paused:", info.ContainersPaused)
225-
fmt.Fprintln(dockerCli.Out(), " Stopped:", info.ContainersStopped)
226-
fmt.Fprintln(dockerCli.Out(), " Images:", info.Images)
227-
fprintlnNonEmpty(dockerCli.Out(), " Server Version:", info.ServerVersion)
228-
fprintlnNonEmpty(dockerCli.Out(), " Storage Driver:", info.Driver)
223+
fmt.Fprintln(output, " Containers:", info.Containers)
224+
fmt.Fprintln(output, " Running:", info.ContainersRunning)
225+
fmt.Fprintln(output, " Paused:", info.ContainersPaused)
226+
fmt.Fprintln(output, " Stopped:", info.ContainersStopped)
227+
fmt.Fprintln(output, " Images:", info.Images)
228+
fprintlnNonEmpty(output, " Server Version:", info.ServerVersion)
229+
fprintlnNonEmpty(output, " Storage Driver:", info.Driver)
229230
if info.DriverStatus != nil {
230231
for _, pair := range info.DriverStatus {
231-
fmt.Fprintf(dockerCli.Out(), " %s: %s\n", pair[0], pair[1])
232+
fmt.Fprintf(output, " %s: %s\n", pair[0], pair[1])
232233
}
233234
}
234235
if info.SystemStatus != nil {
235236
for _, pair := range info.SystemStatus {
236-
fmt.Fprintf(dockerCli.Out(), " %s: %s\n", pair[0], pair[1])
237+
fmt.Fprintf(output, " %s: %s\n", pair[0], pair[1])
237238
}
238239
}
239-
fprintlnNonEmpty(dockerCli.Out(), " Logging Driver:", info.LoggingDriver)
240-
fprintlnNonEmpty(dockerCli.Out(), " Cgroup Driver:", info.CgroupDriver)
241-
fprintlnNonEmpty(dockerCli.Out(), " Cgroup Version:", info.CgroupVersion)
240+
fprintlnNonEmpty(output, " Logging Driver:", info.LoggingDriver)
241+
fprintlnNonEmpty(output, " Cgroup Driver:", info.CgroupDriver)
242+
fprintlnNonEmpty(output, " Cgroup Version:", info.CgroupVersion)
242243

243-
fmt.Fprintln(dockerCli.Out(), " Plugins:")
244-
fmt.Fprintln(dockerCli.Out(), " Volume:", strings.Join(info.Plugins.Volume, " "))
245-
fmt.Fprintln(dockerCli.Out(), " Network:", strings.Join(info.Plugins.Network, " "))
244+
fmt.Fprintln(output, " Plugins:")
245+
fmt.Fprintln(output, " Volume:", strings.Join(info.Plugins.Volume, " "))
246+
fmt.Fprintln(output, " Network:", strings.Join(info.Plugins.Network, " "))
246247

247248
if len(info.Plugins.Authorization) != 0 {
248-
fmt.Fprintln(dockerCli.Out(), " Authorization:", strings.Join(info.Plugins.Authorization, " "))
249+
fmt.Fprintln(output, " Authorization:", strings.Join(info.Plugins.Authorization, " "))
249250
}
250251

251-
fmt.Fprintln(dockerCli.Out(), " Log:", strings.Join(info.Plugins.Log, " "))
252+
fmt.Fprintln(output, " Log:", strings.Join(info.Plugins.Log, " "))
252253

253-
fmt.Fprintln(dockerCli.Out(), " Swarm:", info.Swarm.LocalNodeState)
254-
printSwarmInfo(dockerCli.Out(), *info.Info)
254+
fmt.Fprintln(output, " Swarm:", info.Swarm.LocalNodeState)
255+
printSwarmInfo(output, *info.Info)
255256

256257
if len(info.Runtimes) > 0 {
257258
names := make([]string, 0, len(info.Runtimes))
258259
for name := range info.Runtimes {
259260
names = append(names, name)
260261
}
261-
fmt.Fprintln(dockerCli.Out(), " Runtimes:", strings.Join(names, " "))
262-
fmt.Fprintln(dockerCli.Out(), " Default Runtime:", info.DefaultRuntime)
262+
fmt.Fprintln(output, " Runtimes:", strings.Join(names, " "))
263+
fmt.Fprintln(output, " Default Runtime:", info.DefaultRuntime)
263264
}
264265

265266
if info.OSType == "linux" {
266-
fmt.Fprintln(dockerCli.Out(), " Init Binary:", info.InitBinary)
267+
fmt.Fprintln(output, " Init Binary:", info.InitBinary)
267268

268269
for _, ci := range []struct {
269270
Name string
@@ -273,23 +274,23 @@ func prettyPrintServerInfo(dockerCli command.Cli, info *info) []error {
273274
{"runc", info.RuncCommit},
274275
{"init", info.InitCommit},
275276
} {
276-
fmt.Fprintf(dockerCli.Out(), " %s version: %s", ci.Name, ci.Commit.ID)
277+
fmt.Fprintf(output, " %s version: %s", ci.Name, ci.Commit.ID)
277278
if ci.Commit.ID != ci.Commit.Expected {
278-
fmt.Fprintf(dockerCli.Out(), " (expected: %s)", ci.Commit.Expected)
279+
fmt.Fprintf(output, " (expected: %s)", ci.Commit.Expected)
279280
}
280-
fmt.Fprint(dockerCli.Out(), "\n")
281+
fmt.Fprint(output, "\n")
281282
}
282283
if len(info.SecurityOptions) != 0 {
283284
if kvs, err := types.DecodeSecurityOptions(info.SecurityOptions); err != nil {
284285
errs = append(errs, err)
285286
} else {
286-
fmt.Fprintln(dockerCli.Out(), " Security Options:")
287+
fmt.Fprintln(output, " Security Options:")
287288
for _, so := range kvs {
288-
fmt.Fprintln(dockerCli.Out(), " "+so.Name)
289+
fmt.Fprintln(output, " "+so.Name)
289290
for _, o := range so.Options {
290291
switch o.Key {
291292
case "profile":
292-
fmt.Fprintln(dockerCli.Out(), " Profile:", o.Value)
293+
fmt.Fprintln(output, " Profile:", o.Value)
293294
}
294295
}
295296
}
@@ -299,75 +300,75 @@ func prettyPrintServerInfo(dockerCli command.Cli, info *info) []error {
299300

300301
// Isolation only has meaning on a Windows daemon.
301302
if info.OSType == "windows" {
302-
fmt.Fprintln(dockerCli.Out(), " Default Isolation:", info.Isolation)
303-
}
304-
305-
fprintlnNonEmpty(dockerCli.Out(), " Kernel Version:", info.KernelVersion)
306-
fprintlnNonEmpty(dockerCli.Out(), " Operating System:", info.OperatingSystem)
307-
fprintlnNonEmpty(dockerCli.Out(), " OSType:", info.OSType)
308-
fprintlnNonEmpty(dockerCli.Out(), " Architecture:", info.Architecture)
309-
fmt.Fprintln(dockerCli.Out(), " CPUs:", info.NCPU)
310-
fmt.Fprintln(dockerCli.Out(), " Total Memory:", units.BytesSize(float64(info.MemTotal)))
311-
fprintlnNonEmpty(dockerCli.Out(), " Name:", info.Name)
312-
fprintlnNonEmpty(dockerCli.Out(), " ID:", info.ID)
313-
fmt.Fprintln(dockerCli.Out(), " Docker Root Dir:", info.DockerRootDir)
314-
fmt.Fprintln(dockerCli.Out(), " Debug Mode:", info.Debug)
303+
fmt.Fprintln(output, " Default Isolation:", info.Isolation)
304+
}
305+
306+
fprintlnNonEmpty(output, " Kernel Version:", info.KernelVersion)
307+
fprintlnNonEmpty(output, " Operating System:", info.OperatingSystem)
308+
fprintlnNonEmpty(output, " OSType:", info.OSType)
309+
fprintlnNonEmpty(output, " Architecture:", info.Architecture)
310+
fmt.Fprintln(output, " CPUs:", info.NCPU)
311+
fmt.Fprintln(output, " Total Memory:", units.BytesSize(float64(info.MemTotal)))
312+
fprintlnNonEmpty(output, " Name:", info.Name)
313+
fprintlnNonEmpty(output, " ID:", info.ID)
314+
fmt.Fprintln(output, " Docker Root Dir:", info.DockerRootDir)
315+
fmt.Fprintln(output, " Debug Mode:", info.Debug)
315316

316317
if info.Debug {
317-
fmt.Fprintln(dockerCli.Out(), " File Descriptors:", info.NFd)
318-
fmt.Fprintln(dockerCli.Out(), " Goroutines:", info.NGoroutines)
319-
fmt.Fprintln(dockerCli.Out(), " System Time:", info.SystemTime)
320-
fmt.Fprintln(dockerCli.Out(), " EventsListeners:", info.NEventsListener)
318+
fmt.Fprintln(output, " File Descriptors:", info.NFd)
319+
fmt.Fprintln(output, " Goroutines:", info.NGoroutines)
320+
fmt.Fprintln(output, " System Time:", info.SystemTime)
321+
fmt.Fprintln(output, " EventsListeners:", info.NEventsListener)
321322
}
322323

323-
fprintlnNonEmpty(dockerCli.Out(), " HTTP Proxy:", info.HTTPProxy)
324-
fprintlnNonEmpty(dockerCli.Out(), " HTTPS Proxy:", info.HTTPSProxy)
325-
fprintlnNonEmpty(dockerCli.Out(), " No Proxy:", info.NoProxy)
326-
fprintlnNonEmpty(dockerCli.Out(), " Username:", info.UserName)
324+
fprintlnNonEmpty(output, " HTTP Proxy:", info.HTTPProxy)
325+
fprintlnNonEmpty(output, " HTTPS Proxy:", info.HTTPSProxy)
326+
fprintlnNonEmpty(output, " No Proxy:", info.NoProxy)
327+
fprintlnNonEmpty(output, " Username:", info.UserName)
327328
if len(info.Labels) > 0 {
328-
fmt.Fprintln(dockerCli.Out(), " Labels:")
329+
fmt.Fprintln(output, " Labels:")
329330
for _, lbl := range info.Labels {
330-
fmt.Fprintln(dockerCli.Out(), " "+lbl)
331+
fmt.Fprintln(output, " "+lbl)
331332
}
332333
}
333334

334-
fmt.Fprintln(dockerCli.Out(), " Experimental:", info.ExperimentalBuild)
335+
fmt.Fprintln(output, " Experimental:", info.ExperimentalBuild)
335336

336337
if info.RegistryConfig != nil && (len(info.RegistryConfig.InsecureRegistryCIDRs) > 0 || len(info.RegistryConfig.IndexConfigs) > 0) {
337-
fmt.Fprintln(dockerCli.Out(), " Insecure Registries:")
338+
fmt.Fprintln(output, " Insecure Registries:")
338339
for _, reg := range info.RegistryConfig.IndexConfigs {
339340
if !reg.Secure {
340-
fmt.Fprintln(dockerCli.Out(), " "+reg.Name)
341+
fmt.Fprintln(output, " "+reg.Name)
341342
}
342343
}
343344

344345
for _, reg := range info.RegistryConfig.InsecureRegistryCIDRs {
345346
mask, _ := reg.Mask.Size()
346-
fmt.Fprintf(dockerCli.Out(), " %s/%d\n", reg.IP.String(), mask)
347+
fmt.Fprintf(output, " %s/%d\n", reg.IP.String(), mask)
347348
}
348349
}
349350

350351
if info.RegistryConfig != nil && len(info.RegistryConfig.Mirrors) > 0 {
351-
fmt.Fprintln(dockerCli.Out(), " Registry Mirrors:")
352+
fmt.Fprintln(output, " Registry Mirrors:")
352353
for _, mirror := range info.RegistryConfig.Mirrors {
353-
fmt.Fprintln(dockerCli.Out(), " "+mirror)
354+
fmt.Fprintln(output, " "+mirror)
354355
}
355356
}
356357

357-
fmt.Fprintln(dockerCli.Out(), " Live Restore Enabled:", info.LiveRestoreEnabled)
358+
fmt.Fprintln(output, " Live Restore Enabled:", info.LiveRestoreEnabled)
358359
if info.ProductLicense != "" {
359-
fmt.Fprintln(dockerCli.Out(), " Product License:", info.ProductLicense)
360+
fmt.Fprintln(output, " Product License:", info.ProductLicense)
360361
}
361362

362363
if info.DefaultAddressPools != nil && len(info.DefaultAddressPools) > 0 {
363-
fmt.Fprintln(dockerCli.Out(), " Default Address Pools:")
364+
fmt.Fprintln(output, " Default Address Pools:")
364365
for _, pool := range info.DefaultAddressPools {
365-
fmt.Fprintf(dockerCli.Out(), " Base: %s, Size: %d\n", pool.Base, pool.Size)
366+
fmt.Fprintf(output, " Base: %s, Size: %d\n", pool.Base, pool.Size)
366367
}
367368
}
368369

369-
fmt.Fprint(dockerCli.Out(), "\n")
370-
printServerWarnings(dockerCli.Err(), info)
370+
fmt.Fprint(output, "\n")
371+
printServerWarnings(streams.Err(), info)
371372
return errs
372373
}
373374

0 commit comments

Comments
 (0)