github.com/zhouyu0/docker-note@v0.0.0-20190722021225-b8d3825084db/integration-cli/docker_cli_info_test.go (about)

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