github.com/go/docker@v1.12.0-rc2/integration-cli/docker_cli_inspect_test.go (about) 1 package main 2 3 import ( 4 "encoding/json" 5 "fmt" 6 "os" 7 "os/exec" 8 "strconv" 9 "strings" 10 "time" 11 12 "github.com/docker/docker/pkg/integration/checker" 13 "github.com/docker/engine-api/types" 14 "github.com/docker/engine-api/types/container" 15 "github.com/go-check/check" 16 ) 17 18 func checkValidGraphDriver(c *check.C, name string) { 19 if name != "devicemapper" && name != "overlay" && name != "vfs" && name != "zfs" && name != "btrfs" && name != "aufs" { 20 c.Fatalf("%v is not a valid graph driver name", name) 21 } 22 } 23 24 func (s *DockerSuite) TestInspectImage(c *check.C) { 25 testRequires(c, DaemonIsLinux) 26 imageTest := "emptyfs" 27 // It is important that this ID remain stable. If a code change causes 28 // it to be different, this is equivalent to a cache bust when pulling 29 // a legacy-format manifest. If the check at the end of this function 30 // fails, fix the difference in the image serialization instead of 31 // updating this hash. 32 imageTestID := "sha256:11f64303f0f7ffdc71f001788132bca5346831939a956e3e975c93267d89a16d" 33 id := inspectField(c, imageTest, "Id") 34 35 c.Assert(id, checker.Equals, imageTestID) 36 } 37 38 func (s *DockerSuite) TestInspectInt64(c *check.C) { 39 testRequires(c, DaemonIsLinux) 40 41 dockerCmd(c, "run", "-d", "-m=300M", "--name", "inspectTest", "busybox", "true") 42 inspectOut := inspectField(c, "inspectTest", "HostConfig.Memory") 43 c.Assert(inspectOut, checker.Equals, "314572800") 44 } 45 46 func (s *DockerSuite) TestInspectDefault(c *check.C) { 47 testRequires(c, DaemonIsLinux) 48 //Both the container and image are named busybox. docker inspect will fetch the container JSON. 49 //If the container JSON is not available, it will go for the image JSON. 50 51 out, _ := dockerCmd(c, "run", "--name=busybox", "-d", "busybox", "true") 52 containerID := strings.TrimSpace(out) 53 54 inspectOut := inspectField(c, "busybox", "Id") 55 c.Assert(strings.TrimSpace(inspectOut), checker.Equals, containerID) 56 } 57 58 func (s *DockerSuite) TestInspectStatus(c *check.C) { 59 defer unpauseAllContainers() 60 testRequires(c, DaemonIsLinux) 61 out, _ := dockerCmd(c, "run", "-d", "busybox", "top") 62 out = strings.TrimSpace(out) 63 64 inspectOut := inspectField(c, out, "State.Status") 65 c.Assert(inspectOut, checker.Equals, "running") 66 67 dockerCmd(c, "pause", out) 68 inspectOut = inspectField(c, out, "State.Status") 69 c.Assert(inspectOut, checker.Equals, "paused") 70 71 dockerCmd(c, "unpause", out) 72 inspectOut = inspectField(c, out, "State.Status") 73 c.Assert(inspectOut, checker.Equals, "running") 74 75 dockerCmd(c, "stop", out) 76 inspectOut = inspectField(c, out, "State.Status") 77 c.Assert(inspectOut, checker.Equals, "exited") 78 79 } 80 81 func (s *DockerSuite) TestInspectTypeFlagContainer(c *check.C) { 82 testRequires(c, DaemonIsLinux) 83 //Both the container and image are named busybox. docker inspect will fetch container 84 //JSON State.Running field. If the field is true, it's a container. 85 86 dockerCmd(c, "run", "--name=busybox", "-d", "busybox", "top") 87 88 formatStr := "--format='{{.State.Running}}'" 89 out, _ := dockerCmd(c, "inspect", "--type=container", formatStr, "busybox") 90 c.Assert(out, checker.Equals, "true\n") // not a container JSON 91 } 92 93 func (s *DockerSuite) TestInspectTypeFlagWithNoContainer(c *check.C) { 94 testRequires(c, DaemonIsLinux) 95 //Run this test on an image named busybox. docker inspect will try to fetch container 96 //JSON. Since there is no container named busybox and --type=container, docker inspect will 97 //not try to get the image JSON. It will throw an error. 98 99 dockerCmd(c, "run", "-d", "busybox", "true") 100 101 _, _, err := dockerCmdWithError("inspect", "--type=container", "busybox") 102 // docker inspect should fail, as there is no container named busybox 103 c.Assert(err, checker.NotNil) 104 } 105 106 func (s *DockerSuite) TestInspectTypeFlagWithImage(c *check.C) { 107 testRequires(c, DaemonIsLinux) 108 //Both the container and image are named busybox. docker inspect will fetch image 109 //JSON as --type=image. if there is no image with name busybox, docker inspect 110 //will throw an error. 111 112 dockerCmd(c, "run", "--name=busybox", "-d", "busybox", "true") 113 114 out, _ := dockerCmd(c, "inspect", "--type=image", "busybox") 115 c.Assert(out, checker.Not(checker.Contains), "State") // not an image JSON 116 } 117 118 func (s *DockerSuite) TestInspectTypeFlagWithInvalidValue(c *check.C) { 119 testRequires(c, DaemonIsLinux) 120 //Both the container and image are named busybox. docker inspect will fail 121 //as --type=foobar is not a valid value for the flag. 122 123 dockerCmd(c, "run", "--name=busybox", "-d", "busybox", "true") 124 125 out, exitCode, err := dockerCmdWithError("inspect", "--type=foobar", "busybox") 126 c.Assert(err, checker.NotNil, check.Commentf("%s", exitCode)) 127 c.Assert(exitCode, checker.Equals, 1, check.Commentf("%s", err)) 128 c.Assert(out, checker.Contains, "not a valid value for --type") 129 } 130 131 func (s *DockerSuite) TestInspectImageFilterInt(c *check.C) { 132 testRequires(c, DaemonIsLinux) 133 imageTest := "emptyfs" 134 out := inspectField(c, imageTest, "Size") 135 136 size, err := strconv.Atoi(out) 137 c.Assert(err, checker.IsNil, check.Commentf("failed to inspect size of the image: %s, %v", out, err)) 138 139 //now see if the size turns out to be the same 140 formatStr := fmt.Sprintf("--format='{{eq .Size %d}}'", size) 141 out, _ = dockerCmd(c, "inspect", formatStr, imageTest) 142 result, err := strconv.ParseBool(strings.TrimSuffix(out, "\n")) 143 c.Assert(err, checker.IsNil) 144 c.Assert(result, checker.Equals, true) 145 } 146 147 func (s *DockerSuite) TestInspectContainerFilterInt(c *check.C) { 148 testRequires(c, DaemonIsLinux) 149 runCmd := exec.Command(dockerBinary, "run", "-i", "-a", "stdin", "busybox", "cat") 150 runCmd.Stdin = strings.NewReader("blahblah") 151 out, _, _, err := runCommandWithStdoutStderr(runCmd) 152 c.Assert(err, checker.IsNil, check.Commentf("failed to run container: %v, output: %q", err, out)) 153 154 id := strings.TrimSpace(out) 155 156 out = inspectField(c, id, "State.ExitCode") 157 158 exitCode, err := strconv.Atoi(out) 159 c.Assert(err, checker.IsNil, check.Commentf("failed to inspect exitcode of the container: %s, %v", out, err)) 160 161 //now get the exit code to verify 162 formatStr := fmt.Sprintf("--format='{{eq .State.ExitCode %d}}'", exitCode) 163 out, _ = dockerCmd(c, "inspect", formatStr, id) 164 result, err := strconv.ParseBool(strings.TrimSuffix(out, "\n")) 165 c.Assert(err, checker.IsNil) 166 c.Assert(result, checker.Equals, true) 167 } 168 169 func (s *DockerSuite) TestInspectImageGraphDriver(c *check.C) { 170 testRequires(c, DaemonIsLinux, Devicemapper) 171 imageTest := "emptyfs" 172 name := inspectField(c, imageTest, "GraphDriver.Name") 173 174 checkValidGraphDriver(c, name) 175 176 deviceID := inspectField(c, imageTest, "GraphDriver.Data.DeviceId") 177 178 _, err := strconv.Atoi(deviceID) 179 c.Assert(err, checker.IsNil, check.Commentf("failed to inspect DeviceId of the image: %s, %v", deviceID, err)) 180 181 deviceSize := inspectField(c, imageTest, "GraphDriver.Data.DeviceSize") 182 183 _, err = strconv.ParseUint(deviceSize, 10, 64) 184 c.Assert(err, checker.IsNil, check.Commentf("failed to inspect DeviceSize of the image: %s, %v", deviceSize, err)) 185 } 186 187 func (s *DockerSuite) TestInspectContainerGraphDriver(c *check.C) { 188 testRequires(c, DaemonIsLinux, Devicemapper) 189 190 out, _ := dockerCmd(c, "run", "-d", "busybox", "true") 191 out = strings.TrimSpace(out) 192 193 name := inspectField(c, out, "GraphDriver.Name") 194 195 checkValidGraphDriver(c, name) 196 197 imageDeviceID := inspectField(c, "busybox", "GraphDriver.Data.DeviceId") 198 199 deviceID := inspectField(c, out, "GraphDriver.Data.DeviceId") 200 201 c.Assert(imageDeviceID, checker.Not(checker.Equals), deviceID) 202 203 _, err := strconv.Atoi(deviceID) 204 c.Assert(err, checker.IsNil, check.Commentf("failed to inspect DeviceId of the image: %s, %v", deviceID, err)) 205 206 deviceSize := inspectField(c, out, "GraphDriver.Data.DeviceSize") 207 208 _, err = strconv.ParseUint(deviceSize, 10, 64) 209 c.Assert(err, checker.IsNil, check.Commentf("failed to inspect DeviceSize of the image: %s, %v", deviceSize, err)) 210 } 211 212 func (s *DockerSuite) TestInspectBindMountPoint(c *check.C) { 213 modifier := ",z" 214 prefix, slash := getPrefixAndSlashFromDaemonPlatform() 215 if daemonPlatform == "windows" { 216 modifier = "" 217 // TODO Windows: Temporary check - remove once TP5 support is dropped 218 if windowsDaemonKV < 14350 { 219 c.Skip("Needs later Windows build for RO volumes") 220 } 221 // Linux creates the host directory if it doesn't exist. Windows does not. 222 os.Mkdir(`c:\data`, os.ModeDir) 223 } 224 225 dockerCmd(c, "run", "-d", "--name", "test", "-v", prefix+slash+"data:"+prefix+slash+"data:ro"+modifier, "busybox", "cat") 226 227 vol := inspectFieldJSON(c, "test", "Mounts") 228 229 var mp []types.MountPoint 230 err := unmarshalJSON([]byte(vol), &mp) 231 c.Assert(err, checker.IsNil) 232 233 // check that there is only one mountpoint 234 c.Assert(mp, check.HasLen, 1) 235 236 m := mp[0] 237 238 c.Assert(m.Name, checker.Equals, "") 239 c.Assert(m.Driver, checker.Equals, "") 240 c.Assert(m.Source, checker.Equals, prefix+slash+"data") 241 c.Assert(m.Destination, checker.Equals, prefix+slash+"data") 242 c.Assert(m.Mode, checker.Equals, "ro"+modifier) 243 c.Assert(m.RW, checker.Equals, false) 244 } 245 246 // #14947 247 func (s *DockerSuite) TestInspectTimesAsRFC3339Nano(c *check.C) { 248 testRequires(c, DaemonIsLinux) 249 out, _ := dockerCmd(c, "run", "-d", "busybox", "true") 250 id := strings.TrimSpace(out) 251 startedAt := inspectField(c, id, "State.StartedAt") 252 finishedAt := inspectField(c, id, "State.FinishedAt") 253 created := inspectField(c, id, "Created") 254 255 _, err := time.Parse(time.RFC3339Nano, startedAt) 256 c.Assert(err, checker.IsNil) 257 _, err = time.Parse(time.RFC3339Nano, finishedAt) 258 c.Assert(err, checker.IsNil) 259 _, err = time.Parse(time.RFC3339Nano, created) 260 c.Assert(err, checker.IsNil) 261 262 created = inspectField(c, "busybox", "Created") 263 264 _, err = time.Parse(time.RFC3339Nano, created) 265 c.Assert(err, checker.IsNil) 266 } 267 268 // #15633 269 func (s *DockerSuite) TestInspectLogConfigNoType(c *check.C) { 270 testRequires(c, DaemonIsLinux) 271 dockerCmd(c, "create", "--name=test", "--log-opt", "max-file=42", "busybox") 272 var logConfig container.LogConfig 273 274 out := inspectFieldJSON(c, "test", "HostConfig.LogConfig") 275 276 err := json.NewDecoder(strings.NewReader(out)).Decode(&logConfig) 277 c.Assert(err, checker.IsNil, check.Commentf("%v", out)) 278 279 c.Assert(logConfig.Type, checker.Equals, "json-file") 280 c.Assert(logConfig.Config["max-file"], checker.Equals, "42", check.Commentf("%v", logConfig)) 281 } 282 283 func (s *DockerSuite) TestInspectNoSizeFlagContainer(c *check.C) { 284 285 //Both the container and image are named busybox. docker inspect will fetch container 286 //JSON SizeRw and SizeRootFs field. If there is no flag --size/-s, there are no size fields. 287 288 runSleepingContainer(c, "--name=busybox", "-d") 289 290 formatStr := "--format='{{.SizeRw}},{{.SizeRootFs}}'" 291 out, _ := dockerCmd(c, "inspect", "--type=container", formatStr, "busybox") 292 c.Assert(strings.TrimSpace(out), check.Equals, "<nil>,<nil>", check.Commentf("Exepcted not to display size info: %s", out)) 293 } 294 295 func (s *DockerSuite) TestInspectSizeFlagContainer(c *check.C) { 296 runSleepingContainer(c, "--name=busybox", "-d") 297 298 formatStr := "--format='{{.SizeRw}},{{.SizeRootFs}}'" 299 out, _ := dockerCmd(c, "inspect", "-s", "--type=container", formatStr, "busybox") 300 sz := strings.Split(out, ",") 301 302 c.Assert(strings.TrimSpace(sz[0]), check.Not(check.Equals), "<nil>") 303 c.Assert(strings.TrimSpace(sz[1]), check.Not(check.Equals), "<nil>") 304 } 305 306 func (s *DockerSuite) TestInspectSizeFlagImage(c *check.C) { 307 runSleepingContainer(c, "-d") 308 309 formatStr := "--format='{{.SizeRw}},{{.SizeRootFs}}'" 310 out, _, err := dockerCmdWithError("inspect", "-s", "--type=image", formatStr, "busybox") 311 312 // Template error rather than <no value> 313 // This is a more correct behavior because images don't have sizes associated. 314 c.Assert(err, check.Not(check.IsNil)) 315 c.Assert(out, checker.Contains, "Template parsing error") 316 } 317 318 func (s *DockerSuite) TestInspectTemplateError(c *check.C) { 319 // Template parsing error for both the container and image. 320 321 runSleepingContainer(c, "--name=container1", "-d") 322 323 out, _, err := dockerCmdWithError("inspect", "--type=container", "--format='Format container: {{.ThisDoesNotExist}}'", "container1") 324 c.Assert(err, check.Not(check.IsNil)) 325 c.Assert(out, checker.Contains, "Template parsing error") 326 327 out, _, err = dockerCmdWithError("inspect", "--type=image", "--format='Format container: {{.ThisDoesNotExist}}'", "busybox") 328 c.Assert(err, check.Not(check.IsNil)) 329 c.Assert(out, checker.Contains, "Template parsing error") 330 } 331 332 func (s *DockerSuite) TestInspectJSONFields(c *check.C) { 333 runSleepingContainer(c, "--name=busybox", "-d") 334 out, _, err := dockerCmdWithError("inspect", "--type=container", "--format='{{.HostConfig.Dns}}'", "busybox") 335 336 c.Assert(err, check.IsNil) 337 c.Assert(out, checker.Equals, "[]\n") 338 } 339 340 func (s *DockerSuite) TestInspectByPrefix(c *check.C) { 341 id := inspectField(c, "busybox", "Id") 342 c.Assert(id, checker.HasPrefix, "sha256:") 343 344 id2 := inspectField(c, id[:12], "Id") 345 c.Assert(id, checker.Equals, id2) 346 347 id3 := inspectField(c, strings.TrimPrefix(id, "sha256:")[:12], "Id") 348 c.Assert(id, checker.Equals, id3) 349 } 350 351 func (s *DockerSuite) TestInspectStopWhenNotFound(c *check.C) { 352 runSleepingContainer(c, "--name=busybox", "-d") 353 runSleepingContainer(c, "--name=not-shown", "-d") 354 out, _, err := dockerCmdWithError("inspect", "--type=container", "--format='{{.Name}}'", "busybox", "missing", "not-shown") 355 356 c.Assert(err, checker.Not(check.IsNil)) 357 c.Assert(out, checker.Contains, "busybox") 358 c.Assert(out, checker.Not(checker.Contains), "not-shown") 359 c.Assert(out, checker.Contains, "Error: No such container: missing") 360 } 361 362 func (s *DockerSuite) TestInspectHistory(c *check.C) { 363 testRequires(c, DaemonIsLinux) 364 dockerCmd(c, "run", "--name=testcont", "-d", "busybox", "top") 365 dockerCmd(c, "commit", "-m", "test comment", "testcont", "testimg") 366 out, _, err := dockerCmdWithError("inspect", "--format='{{.Comment}}'", "testimg") 367 368 c.Assert(err, check.IsNil) 369 c.Assert(out, checker.Contains, "test comment") 370 } 371 372 func (s *DockerSuite) TestInspectContainerNetworkDefault(c *check.C) { 373 testRequires(c, DaemonIsLinux) 374 375 contName := "test1" 376 dockerCmd(c, "run", "--name", contName, "-d", "busybox", "top") 377 netOut, _ := dockerCmd(c, "network", "inspect", "--format={{.ID}}", "bridge") 378 out := inspectField(c, contName, "NetworkSettings.Networks") 379 c.Assert(out, checker.Contains, "bridge") 380 out = inspectField(c, contName, "NetworkSettings.Networks.bridge.NetworkID") 381 c.Assert(strings.TrimSpace(out), checker.Equals, strings.TrimSpace(netOut)) 382 } 383 384 func (s *DockerSuite) TestInspectContainerNetworkCustom(c *check.C) { 385 testRequires(c, DaemonIsLinux) 386 387 netOut, _ := dockerCmd(c, "network", "create", "net1") 388 dockerCmd(c, "run", "--name=container1", "--net=net1", "-d", "busybox", "top") 389 out := inspectField(c, "container1", "NetworkSettings.Networks") 390 c.Assert(out, checker.Contains, "net1") 391 out = inspectField(c, "container1", "NetworkSettings.Networks.net1.NetworkID") 392 c.Assert(strings.TrimSpace(out), checker.Equals, strings.TrimSpace(netOut)) 393 } 394 395 func (s *DockerSuite) TestInspectRootFS(c *check.C) { 396 testRequires(c, DaemonIsLinux) 397 out, _, err := dockerCmdWithError("inspect", "busybox") 398 c.Assert(err, check.IsNil) 399 400 var imageJSON []types.ImageInspect 401 err = json.Unmarshal([]byte(out), &imageJSON) 402 c.Assert(err, checker.IsNil) 403 404 c.Assert(len(imageJSON[0].RootFS.Layers), checker.GreaterOrEqualThan, 1) 405 }