mirror of
https://github.com/moby/moby.git
synced 2022-11-09 12:21:53 -05:00
238 lines
8.7 KiB
Go
238 lines
8.7 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"net"
|
|
"strings"
|
|
|
|
"github.com/docker/docker/integration-cli/checker"
|
|
"github.com/docker/docker/integration-cli/daemon"
|
|
testdaemon "github.com/docker/docker/internal/test/daemon"
|
|
"github.com/go-check/check"
|
|
)
|
|
|
|
// ensure docker info succeeds
|
|
func (s *DockerSuite) TestInfoEnsureSucceeds(c *check.C) {
|
|
out, _ := dockerCmd(c, "info")
|
|
|
|
// always shown fields
|
|
stringsToCheck := []string{
|
|
"ID:",
|
|
"Containers:",
|
|
" Running:",
|
|
" Paused:",
|
|
" Stopped:",
|
|
"Images:",
|
|
"OSType:",
|
|
"Architecture:",
|
|
"Logging Driver:",
|
|
"Operating System:",
|
|
"CPUs:",
|
|
"Total Memory:",
|
|
"Kernel Version:",
|
|
"Storage Driver:",
|
|
"Volume:",
|
|
"Network:",
|
|
"Live Restore Enabled:",
|
|
}
|
|
|
|
if testEnv.OSType == "linux" {
|
|
stringsToCheck = append(stringsToCheck, "Init Binary:", "Security Options:", "containerd version:", "runc version:", "init version:")
|
|
}
|
|
|
|
if DaemonIsLinux() {
|
|
stringsToCheck = append(stringsToCheck, "Runtimes:", "Default Runtime: runc")
|
|
}
|
|
|
|
if testEnv.DaemonInfo.ExperimentalBuild {
|
|
stringsToCheck = append(stringsToCheck, "Experimental: true")
|
|
} else {
|
|
stringsToCheck = append(stringsToCheck, "Experimental: false")
|
|
}
|
|
|
|
for _, linePrefix := range stringsToCheck {
|
|
c.Assert(out, checker.Contains, linePrefix, check.Commentf("couldn't find string %v in output", linePrefix))
|
|
}
|
|
}
|
|
|
|
// TestInfoFormat tests `docker info --format`
|
|
func (s *DockerSuite) TestInfoFormat(c *check.C) {
|
|
out, status := dockerCmd(c, "info", "--format", "{{json .}}")
|
|
c.Assert(status, checker.Equals, 0)
|
|
var m map[string]interface{}
|
|
err := json.Unmarshal([]byte(out), &m)
|
|
c.Assert(err, checker.IsNil)
|
|
_, _, err = dockerCmdWithError("info", "--format", "{{.badString}}")
|
|
c.Assert(err, checker.NotNil)
|
|
}
|
|
|
|
// TestInfoDiscoveryBackend verifies that a daemon run with `--cluster-advertise` and
|
|
// `--cluster-store` properly show the backend's endpoint in info output.
|
|
func (s *DockerSuite) TestInfoDiscoveryBackend(c *check.C) {
|
|
testRequires(c, SameHostDaemon, DaemonIsLinux)
|
|
|
|
d := daemon.New(c, dockerBinary, dockerdBinary, testdaemon.WithEnvironment(testEnv.Execution))
|
|
discoveryBackend := "consul://consuladdr:consulport/some/path"
|
|
discoveryAdvertise := "1.1.1.1:2375"
|
|
d.Start(c, fmt.Sprintf("--cluster-store=%s", discoveryBackend), fmt.Sprintf("--cluster-advertise=%s", discoveryAdvertise))
|
|
defer d.Stop(c)
|
|
|
|
out, err := d.Cmd("info")
|
|
c.Assert(err, checker.IsNil)
|
|
c.Assert(out, checker.Contains, fmt.Sprintf("Cluster Store: %s\n", discoveryBackend))
|
|
c.Assert(out, checker.Contains, fmt.Sprintf("Cluster Advertise: %s\n", discoveryAdvertise))
|
|
}
|
|
|
|
// TestInfoDiscoveryInvalidAdvertise verifies that a daemon run with
|
|
// an invalid `--cluster-advertise` configuration
|
|
func (s *DockerSuite) TestInfoDiscoveryInvalidAdvertise(c *check.C) {
|
|
testRequires(c, SameHostDaemon, DaemonIsLinux)
|
|
|
|
d := daemon.New(c, dockerBinary, dockerdBinary, testdaemon.WithEnvironment(testEnv.Execution))
|
|
discoveryBackend := "consul://consuladdr:consulport/some/path"
|
|
|
|
// --cluster-advertise with an invalid string is an error
|
|
err := d.StartWithError(fmt.Sprintf("--cluster-store=%s", discoveryBackend), "--cluster-advertise=invalid")
|
|
c.Assert(err, checker.NotNil)
|
|
|
|
// --cluster-advertise without --cluster-store is also an error
|
|
err = d.StartWithError("--cluster-advertise=1.1.1.1:2375")
|
|
c.Assert(err, checker.NotNil)
|
|
}
|
|
|
|
// TestInfoDiscoveryAdvertiseInterfaceName verifies that a daemon run with `--cluster-advertise`
|
|
// configured with interface name properly show the advertise ip-address in info output.
|
|
func (s *DockerSuite) TestInfoDiscoveryAdvertiseInterfaceName(c *check.C) {
|
|
testRequires(c, SameHostDaemon, Network, DaemonIsLinux)
|
|
|
|
d := daemon.New(c, dockerBinary, dockerdBinary, testdaemon.WithEnvironment(testEnv.Execution))
|
|
discoveryBackend := "consul://consuladdr:consulport/some/path"
|
|
discoveryAdvertise := "eth0"
|
|
|
|
d.Start(c, fmt.Sprintf("--cluster-store=%s", discoveryBackend), fmt.Sprintf("--cluster-advertise=%s:2375", discoveryAdvertise))
|
|
defer d.Stop(c)
|
|
|
|
iface, err := net.InterfaceByName(discoveryAdvertise)
|
|
c.Assert(err, checker.IsNil)
|
|
addrs, err := iface.Addrs()
|
|
c.Assert(err, checker.IsNil)
|
|
c.Assert(len(addrs), checker.GreaterThan, 0)
|
|
ip, _, err := net.ParseCIDR(addrs[0].String())
|
|
c.Assert(err, checker.IsNil)
|
|
|
|
out, err := d.Cmd("info")
|
|
c.Assert(err, checker.IsNil)
|
|
c.Assert(out, checker.Contains, fmt.Sprintf("Cluster Store: %s\n", discoveryBackend))
|
|
c.Assert(out, checker.Contains, fmt.Sprintf("Cluster Advertise: %s:2375\n", ip.String()))
|
|
}
|
|
|
|
func (s *DockerSuite) TestInfoDisplaysRunningContainers(c *check.C) {
|
|
testRequires(c, DaemonIsLinux)
|
|
|
|
existing := existingContainerStates(c)
|
|
|
|
dockerCmd(c, "run", "-d", "busybox", "top")
|
|
out, _ := dockerCmd(c, "info")
|
|
c.Assert(out, checker.Contains, fmt.Sprintf("Containers: %d\n", existing["Containers"]+1))
|
|
c.Assert(out, checker.Contains, fmt.Sprintf(" Running: %d\n", existing["ContainersRunning"]+1))
|
|
c.Assert(out, checker.Contains, fmt.Sprintf(" Paused: %d\n", existing["ContainersPaused"]))
|
|
c.Assert(out, checker.Contains, fmt.Sprintf(" Stopped: %d\n", existing["ContainersStopped"]))
|
|
}
|
|
|
|
func (s *DockerSuite) TestInfoDisplaysPausedContainers(c *check.C) {
|
|
testRequires(c, IsPausable)
|
|
|
|
existing := existingContainerStates(c)
|
|
|
|
out := runSleepingContainer(c, "-d")
|
|
cleanedContainerID := strings.TrimSpace(out)
|
|
|
|
dockerCmd(c, "pause", cleanedContainerID)
|
|
|
|
out, _ = dockerCmd(c, "info")
|
|
c.Assert(out, checker.Contains, fmt.Sprintf("Containers: %d\n", existing["Containers"]+1))
|
|
c.Assert(out, checker.Contains, fmt.Sprintf(" Running: %d\n", existing["ContainersRunning"]))
|
|
c.Assert(out, checker.Contains, fmt.Sprintf(" Paused: %d\n", existing["ContainersPaused"]+1))
|
|
c.Assert(out, checker.Contains, fmt.Sprintf(" Stopped: %d\n", existing["ContainersStopped"]))
|
|
}
|
|
|
|
func (s *DockerSuite) TestInfoDisplaysStoppedContainers(c *check.C) {
|
|
testRequires(c, DaemonIsLinux)
|
|
|
|
existing := existingContainerStates(c)
|
|
|
|
out, _ := dockerCmd(c, "run", "-d", "busybox", "top")
|
|
cleanedContainerID := strings.TrimSpace(out)
|
|
|
|
dockerCmd(c, "stop", cleanedContainerID)
|
|
|
|
out, _ = dockerCmd(c, "info")
|
|
c.Assert(out, checker.Contains, fmt.Sprintf("Containers: %d\n", existing["Containers"]+1))
|
|
c.Assert(out, checker.Contains, fmt.Sprintf(" Running: %d\n", existing["ContainersRunning"]))
|
|
c.Assert(out, checker.Contains, fmt.Sprintf(" Paused: %d\n", existing["ContainersPaused"]))
|
|
c.Assert(out, checker.Contains, fmt.Sprintf(" Stopped: %d\n", existing["ContainersStopped"]+1))
|
|
}
|
|
|
|
func (s *DockerSuite) TestInfoDebug(c *check.C) {
|
|
testRequires(c, SameHostDaemon, DaemonIsLinux)
|
|
|
|
d := daemon.New(c, dockerBinary, dockerdBinary, testdaemon.WithEnvironment(testEnv.Execution))
|
|
d.Start(c, "--debug")
|
|
defer d.Stop(c)
|
|
|
|
out, err := d.Cmd("--debug", "info")
|
|
c.Assert(err, checker.IsNil)
|
|
c.Assert(out, checker.Contains, "Debug Mode (client): true\n")
|
|
c.Assert(out, checker.Contains, "Debug Mode (server): true\n")
|
|
c.Assert(out, checker.Contains, "File Descriptors")
|
|
c.Assert(out, checker.Contains, "Goroutines")
|
|
c.Assert(out, checker.Contains, "System Time")
|
|
c.Assert(out, checker.Contains, "EventsListeners")
|
|
c.Assert(out, checker.Contains, "Docker Root Dir")
|
|
}
|
|
|
|
func (s *DockerSuite) TestInsecureRegistries(c *check.C) {
|
|
testRequires(c, SameHostDaemon, DaemonIsLinux)
|
|
|
|
registryCIDR := "192.168.1.0/24"
|
|
registryHost := "insecurehost.com:5000"
|
|
|
|
d := daemon.New(c, dockerBinary, dockerdBinary, testdaemon.WithEnvironment(testEnv.Execution))
|
|
d.Start(c, "--insecure-registry="+registryCIDR, "--insecure-registry="+registryHost)
|
|
defer d.Stop(c)
|
|
|
|
out, err := d.Cmd("info")
|
|
c.Assert(err, checker.IsNil)
|
|
c.Assert(out, checker.Contains, "Insecure Registries:\n")
|
|
c.Assert(out, checker.Contains, fmt.Sprintf(" %s\n", registryHost))
|
|
c.Assert(out, checker.Contains, fmt.Sprintf(" %s\n", registryCIDR))
|
|
}
|
|
|
|
func (s *DockerDaemonSuite) TestRegistryMirrors(c *check.C) {
|
|
testRequires(c, SameHostDaemon, DaemonIsLinux)
|
|
|
|
registryMirror1 := "https://192.168.1.2"
|
|
registryMirror2 := "http://registry.mirror.com:5000"
|
|
|
|
s.d.Start(c, "--registry-mirror="+registryMirror1, "--registry-mirror="+registryMirror2)
|
|
|
|
out, err := s.d.Cmd("info")
|
|
c.Assert(err, checker.IsNil)
|
|
c.Assert(out, checker.Contains, "Registry Mirrors:\n")
|
|
c.Assert(out, checker.Contains, fmt.Sprintf(" %s", registryMirror1))
|
|
c.Assert(out, checker.Contains, fmt.Sprintf(" %s", registryMirror2))
|
|
}
|
|
|
|
func existingContainerStates(c *check.C) map[string]int {
|
|
out, _ := dockerCmd(c, "info", "--format", "{{json .}}")
|
|
var m map[string]interface{}
|
|
err := json.Unmarshal([]byte(out), &m)
|
|
c.Assert(err, checker.IsNil)
|
|
res := map[string]int{}
|
|
res["Containers"] = int(m["Containers"].(float64))
|
|
res["ContainersRunning"] = int(m["ContainersRunning"].(float64))
|
|
res["ContainersPaused"] = int(m["ContainersPaused"].(float64))
|
|
res["ContainersStopped"] = int(m["ContainersStopped"].(float64))
|
|
return res
|
|
}
|