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