docker_cli_info_test.go 8.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239
  1. package main
  2. import (
  3. "encoding/json"
  4. "fmt"
  5. "net"
  6. "strings"
  7. "testing"
  8. "github.com/docker/docker/integration-cli/checker"
  9. "github.com/docker/docker/integration-cli/daemon"
  10. testdaemon "github.com/docker/docker/internal/test/daemon"
  11. "github.com/go-check/check"
  12. "gotest.tools/assert"
  13. )
  14. // ensure docker info succeeds
  15. func (s *DockerSuite) TestInfoEnsureSucceeds(c *testing.T) {
  16. out, _ := dockerCmd(c, "info")
  17. // always shown fields
  18. stringsToCheck := []string{
  19. "ID:",
  20. "Containers:",
  21. " Running:",
  22. " Paused:",
  23. " Stopped:",
  24. "Images:",
  25. "OSType:",
  26. "Architecture:",
  27. "Logging Driver:",
  28. "Operating System:",
  29. "CPUs:",
  30. "Total Memory:",
  31. "Kernel Version:",
  32. "Storage Driver:",
  33. "Volume:",
  34. "Network:",
  35. "Live Restore Enabled:",
  36. }
  37. if testEnv.OSType == "linux" {
  38. stringsToCheck = append(stringsToCheck, "Init Binary:", "Security Options:", "containerd version:", "runc version:", "init version:")
  39. }
  40. if DaemonIsLinux() {
  41. stringsToCheck = append(stringsToCheck, "Runtimes:", "Default Runtime: runc")
  42. }
  43. if testEnv.DaemonInfo.ExperimentalBuild {
  44. stringsToCheck = append(stringsToCheck, "Experimental: true")
  45. } else {
  46. stringsToCheck = append(stringsToCheck, "Experimental: false")
  47. }
  48. for _, linePrefix := range stringsToCheck {
  49. assert.Assert(c, out, checker.Contains, linePrefix, check.Commentf("couldn't find string %v in output", linePrefix))
  50. }
  51. }
  52. // TestInfoFormat tests `docker info --format`
  53. func (s *DockerSuite) TestInfoFormat(c *testing.T) {
  54. out, status := dockerCmd(c, "info", "--format", "{{json .}}")
  55. assert.Equal(c, status, 0)
  56. var m map[string]interface{}
  57. err := json.Unmarshal([]byte(out), &m)
  58. assert.NilError(c, err)
  59. _, _, err = dockerCmdWithError("info", "--format", "{{.badString}}")
  60. assert.ErrorContains(c, err, "")
  61. }
  62. // TestInfoDiscoveryBackend verifies that a daemon run with `--cluster-advertise` and
  63. // `--cluster-store` properly show the backend's endpoint in info output.
  64. func (s *DockerSuite) TestInfoDiscoveryBackend(c *testing.T) {
  65. testRequires(c, testEnv.IsLocalDaemon, DaemonIsLinux)
  66. d := daemon.New(c, dockerBinary, dockerdBinary, testdaemon.WithEnvironment(testEnv.Execution))
  67. discoveryBackend := "consul://consuladdr:consulport/some/path"
  68. discoveryAdvertise := "1.1.1.1:2375"
  69. d.Start(c, fmt.Sprintf("--cluster-store=%s", discoveryBackend), fmt.Sprintf("--cluster-advertise=%s", discoveryAdvertise))
  70. defer d.Stop(c)
  71. out, err := d.Cmd("info")
  72. assert.NilError(c, err)
  73. assert.Assert(c, out, checker.Contains, fmt.Sprintf("Cluster Store: %s\n", discoveryBackend))
  74. assert.Assert(c, out, checker.Contains, fmt.Sprintf("Cluster Advertise: %s\n", discoveryAdvertise))
  75. }
  76. // TestInfoDiscoveryInvalidAdvertise verifies that a daemon run with
  77. // an invalid `--cluster-advertise` configuration
  78. func (s *DockerSuite) TestInfoDiscoveryInvalidAdvertise(c *testing.T) {
  79. testRequires(c, testEnv.IsLocalDaemon, DaemonIsLinux)
  80. d := daemon.New(c, dockerBinary, dockerdBinary, testdaemon.WithEnvironment(testEnv.Execution))
  81. discoveryBackend := "consul://consuladdr:consulport/some/path"
  82. // --cluster-advertise with an invalid string is an error
  83. err := d.StartWithError(fmt.Sprintf("--cluster-store=%s", discoveryBackend), "--cluster-advertise=invalid")
  84. assert.ErrorContains(c, err, "")
  85. // --cluster-advertise without --cluster-store is also an error
  86. err = d.StartWithError("--cluster-advertise=1.1.1.1:2375")
  87. assert.ErrorContains(c, err, "")
  88. }
  89. // TestInfoDiscoveryAdvertiseInterfaceName verifies that a daemon run with `--cluster-advertise`
  90. // configured with interface name properly show the advertise ip-address in info output.
  91. func (s *DockerSuite) TestInfoDiscoveryAdvertiseInterfaceName(c *testing.T) {
  92. testRequires(c, testEnv.IsLocalDaemon, Network, DaemonIsLinux)
  93. d := daemon.New(c, dockerBinary, dockerdBinary, testdaemon.WithEnvironment(testEnv.Execution))
  94. discoveryBackend := "consul://consuladdr:consulport/some/path"
  95. discoveryAdvertise := "eth0"
  96. d.Start(c, fmt.Sprintf("--cluster-store=%s", discoveryBackend), fmt.Sprintf("--cluster-advertise=%s:2375", discoveryAdvertise))
  97. defer d.Stop(c)
  98. iface, err := net.InterfaceByName(discoveryAdvertise)
  99. assert.NilError(c, err)
  100. addrs, err := iface.Addrs()
  101. assert.NilError(c, err)
  102. assert.Assert(c, len(addrs) > 0)
  103. ip, _, err := net.ParseCIDR(addrs[0].String())
  104. assert.NilError(c, err)
  105. out, err := d.Cmd("info")
  106. assert.NilError(c, err)
  107. assert.Assert(c, out, checker.Contains, fmt.Sprintf("Cluster Store: %s\n", discoveryBackend))
  108. assert.Assert(c, out, checker.Contains, fmt.Sprintf("Cluster Advertise: %s:2375\n", ip.String()))
  109. }
  110. func (s *DockerSuite) TestInfoDisplaysRunningContainers(c *testing.T) {
  111. testRequires(c, DaemonIsLinux)
  112. existing := existingContainerStates(c)
  113. dockerCmd(c, "run", "-d", "busybox", "top")
  114. out, _ := dockerCmd(c, "info")
  115. assert.Assert(c, out, checker.Contains, fmt.Sprintf("Containers: %d\n", existing["Containers"]+1))
  116. assert.Assert(c, out, checker.Contains, fmt.Sprintf(" Running: %d\n", existing["ContainersRunning"]+1))
  117. assert.Assert(c, out, checker.Contains, fmt.Sprintf(" Paused: %d\n", existing["ContainersPaused"]))
  118. assert.Assert(c, out, checker.Contains, fmt.Sprintf(" Stopped: %d\n", existing["ContainersStopped"]))
  119. }
  120. func (s *DockerSuite) TestInfoDisplaysPausedContainers(c *testing.T) {
  121. testRequires(c, IsPausable)
  122. existing := existingContainerStates(c)
  123. out := runSleepingContainer(c, "-d")
  124. cleanedContainerID := strings.TrimSpace(out)
  125. dockerCmd(c, "pause", cleanedContainerID)
  126. out, _ = dockerCmd(c, "info")
  127. assert.Assert(c, out, checker.Contains, fmt.Sprintf("Containers: %d\n", existing["Containers"]+1))
  128. assert.Assert(c, out, checker.Contains, fmt.Sprintf(" Running: %d\n", existing["ContainersRunning"]))
  129. assert.Assert(c, out, checker.Contains, fmt.Sprintf(" Paused: %d\n", existing["ContainersPaused"]+1))
  130. assert.Assert(c, out, checker.Contains, fmt.Sprintf(" Stopped: %d\n", existing["ContainersStopped"]))
  131. }
  132. func (s *DockerSuite) TestInfoDisplaysStoppedContainers(c *testing.T) {
  133. testRequires(c, DaemonIsLinux)
  134. existing := existingContainerStates(c)
  135. out, _ := dockerCmd(c, "run", "-d", "busybox", "top")
  136. cleanedContainerID := strings.TrimSpace(out)
  137. dockerCmd(c, "stop", cleanedContainerID)
  138. out, _ = dockerCmd(c, "info")
  139. assert.Assert(c, out, checker.Contains, fmt.Sprintf("Containers: %d\n", existing["Containers"]+1))
  140. assert.Assert(c, out, checker.Contains, fmt.Sprintf(" Running: %d\n", existing["ContainersRunning"]))
  141. assert.Assert(c, out, checker.Contains, fmt.Sprintf(" Paused: %d\n", existing["ContainersPaused"]))
  142. assert.Assert(c, out, checker.Contains, fmt.Sprintf(" Stopped: %d\n", existing["ContainersStopped"]+1))
  143. }
  144. func (s *DockerSuite) TestInfoDebug(c *testing.T) {
  145. testRequires(c, testEnv.IsLocalDaemon, DaemonIsLinux)
  146. d := daemon.New(c, dockerBinary, dockerdBinary, testdaemon.WithEnvironment(testEnv.Execution))
  147. d.Start(c, "--debug")
  148. defer d.Stop(c)
  149. out, err := d.Cmd("--debug", "info")
  150. assert.NilError(c, err)
  151. assert.Assert(c, out, checker.Contains, "Debug Mode (client): true\n")
  152. assert.Assert(c, out, checker.Contains, "Debug Mode (server): true\n")
  153. assert.Assert(c, out, checker.Contains, "File Descriptors")
  154. assert.Assert(c, out, checker.Contains, "Goroutines")
  155. assert.Assert(c, out, checker.Contains, "System Time")
  156. assert.Assert(c, out, checker.Contains, "EventsListeners")
  157. assert.Assert(c, out, checker.Contains, "Docker Root Dir")
  158. }
  159. func (s *DockerSuite) TestInsecureRegistries(c *testing.T) {
  160. testRequires(c, testEnv.IsLocalDaemon, DaemonIsLinux)
  161. registryCIDR := "192.168.1.0/24"
  162. registryHost := "insecurehost.com:5000"
  163. d := daemon.New(c, dockerBinary, dockerdBinary, testdaemon.WithEnvironment(testEnv.Execution))
  164. d.Start(c, "--insecure-registry="+registryCIDR, "--insecure-registry="+registryHost)
  165. defer d.Stop(c)
  166. out, err := d.Cmd("info")
  167. assert.NilError(c, err)
  168. assert.Assert(c, out, checker.Contains, "Insecure Registries:\n")
  169. assert.Assert(c, out, checker.Contains, fmt.Sprintf(" %s\n", registryHost))
  170. assert.Assert(c, out, checker.Contains, fmt.Sprintf(" %s\n", registryCIDR))
  171. }
  172. func (s *DockerDaemonSuite) TestRegistryMirrors(c *testing.T) {
  173. registryMirror1 := "https://192.168.1.2"
  174. registryMirror2 := "http://registry.mirror.com:5000"
  175. s.d.Start(c, "--registry-mirror="+registryMirror1, "--registry-mirror="+registryMirror2)
  176. out, err := s.d.Cmd("info")
  177. assert.NilError(c, err)
  178. assert.Assert(c, out, checker.Contains, "Registry Mirrors:\n")
  179. assert.Assert(c, out, checker.Contains, fmt.Sprintf(" %s", registryMirror1))
  180. assert.Assert(c, out, checker.Contains, fmt.Sprintf(" %s", registryMirror2))
  181. }
  182. func existingContainerStates(c *testing.T) map[string]int {
  183. out, _ := dockerCmd(c, "info", "--format", "{{json .}}")
  184. var m map[string]interface{}
  185. err := json.Unmarshal([]byte(out), &m)
  186. assert.NilError(c, err)
  187. res := map[string]int{}
  188. res["Containers"] = int(m["Containers"].(float64))
  189. res["ContainersRunning"] = int(m["ContainersRunning"].(float64))
  190. res["ContainersPaused"] = int(m["ContainersPaused"].(float64))
  191. res["ContainersStopped"] = int(m["ContainersStopped"].(float64))
  192. return res
  193. }