github.com/sijibomii/docker@v0.0.0-20231230191044-5cf6ca554647/integration-cli/docker_cli_network_unix_test.go (about) 1 // +build !windows 2 3 package main 4 5 import ( 6 "encoding/json" 7 "fmt" 8 "io/ioutil" 9 "net" 10 "net/http" 11 "net/http/httptest" 12 "os" 13 "strings" 14 "time" 15 16 "github.com/docker/docker/pkg/integration/checker" 17 "github.com/docker/docker/runconfig" 18 "github.com/docker/engine-api/types" 19 "github.com/docker/engine-api/types/versions/v1p20" 20 "github.com/docker/libnetwork/driverapi" 21 remoteapi "github.com/docker/libnetwork/drivers/remote/api" 22 "github.com/docker/libnetwork/ipamapi" 23 remoteipam "github.com/docker/libnetwork/ipams/remote/api" 24 "github.com/docker/libnetwork/netlabel" 25 "github.com/go-check/check" 26 "github.com/vishvananda/netlink" 27 ) 28 29 const dummyNetworkDriver = "dummy-network-driver" 30 const dummyIpamDriver = "dummy-ipam-driver" 31 32 var remoteDriverNetworkRequest remoteapi.CreateNetworkRequest 33 34 func init() { 35 check.Suite(&DockerNetworkSuite{ 36 ds: &DockerSuite{}, 37 }) 38 } 39 40 type DockerNetworkSuite struct { 41 server *httptest.Server 42 ds *DockerSuite 43 d *Daemon 44 } 45 46 func (s *DockerNetworkSuite) SetUpTest(c *check.C) { 47 s.d = NewDaemon(c) 48 } 49 50 func (s *DockerNetworkSuite) TearDownTest(c *check.C) { 51 s.d.Stop() 52 s.ds.TearDownTest(c) 53 } 54 55 func (s *DockerNetworkSuite) SetUpSuite(c *check.C) { 56 mux := http.NewServeMux() 57 s.server = httptest.NewServer(mux) 58 c.Assert(s.server, check.NotNil, check.Commentf("Failed to start a HTTP Server")) 59 setupRemoteNetworkDrivers(c, mux, s.server.URL, dummyNetworkDriver, dummyIpamDriver) 60 } 61 62 func setupRemoteNetworkDrivers(c *check.C, mux *http.ServeMux, url, netDrv, ipamDrv string) { 63 64 mux.HandleFunc("/Plugin.Activate", func(w http.ResponseWriter, r *http.Request) { 65 w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json") 66 fmt.Fprintf(w, `{"Implements": ["%s", "%s"]}`, driverapi.NetworkPluginEndpointType, ipamapi.PluginEndpointType) 67 }) 68 69 // Network driver implementation 70 mux.HandleFunc(fmt.Sprintf("/%s.GetCapabilities", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) { 71 w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json") 72 fmt.Fprintf(w, `{"Scope":"local"}`) 73 }) 74 75 mux.HandleFunc(fmt.Sprintf("/%s.CreateNetwork", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) { 76 err := json.NewDecoder(r.Body).Decode(&remoteDriverNetworkRequest) 77 if err != nil { 78 http.Error(w, "Unable to decode JSON payload: "+err.Error(), http.StatusBadRequest) 79 return 80 } 81 w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json") 82 fmt.Fprintf(w, "null") 83 }) 84 85 mux.HandleFunc(fmt.Sprintf("/%s.DeleteNetwork", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) { 86 w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json") 87 fmt.Fprintf(w, "null") 88 }) 89 90 mux.HandleFunc(fmt.Sprintf("/%s.CreateEndpoint", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) { 91 w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json") 92 fmt.Fprintf(w, `{"Interface":{"MacAddress":"a0:b1:c2:d3:e4:f5"}}`) 93 }) 94 95 mux.HandleFunc(fmt.Sprintf("/%s.Join", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) { 96 w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json") 97 98 veth := &netlink.Veth{ 99 LinkAttrs: netlink.LinkAttrs{Name: "randomIfName", TxQLen: 0}, PeerName: "cnt0"} 100 if err := netlink.LinkAdd(veth); err != nil { 101 fmt.Fprintf(w, `{"Error":"failed to add veth pair: `+err.Error()+`"}`) 102 } else { 103 fmt.Fprintf(w, `{"InterfaceName":{ "SrcName":"cnt0", "DstPrefix":"veth"}}`) 104 } 105 }) 106 107 mux.HandleFunc(fmt.Sprintf("/%s.Leave", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) { 108 w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json") 109 fmt.Fprintf(w, "null") 110 }) 111 112 mux.HandleFunc(fmt.Sprintf("/%s.DeleteEndpoint", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) { 113 w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json") 114 if link, err := netlink.LinkByName("cnt0"); err == nil { 115 netlink.LinkDel(link) 116 } 117 fmt.Fprintf(w, "null") 118 }) 119 120 // Ipam Driver implementation 121 var ( 122 poolRequest remoteipam.RequestPoolRequest 123 poolReleaseReq remoteipam.ReleasePoolRequest 124 addressRequest remoteipam.RequestAddressRequest 125 addressReleaseReq remoteipam.ReleaseAddressRequest 126 lAS = "localAS" 127 gAS = "globalAS" 128 pool = "172.28.0.0/16" 129 poolID = lAS + "/" + pool 130 gw = "172.28.255.254/16" 131 ) 132 133 mux.HandleFunc(fmt.Sprintf("/%s.GetDefaultAddressSpaces", ipamapi.PluginEndpointType), func(w http.ResponseWriter, r *http.Request) { 134 w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json") 135 fmt.Fprintf(w, `{"LocalDefaultAddressSpace":"`+lAS+`", "GlobalDefaultAddressSpace": "`+gAS+`"}`) 136 }) 137 138 mux.HandleFunc(fmt.Sprintf("/%s.RequestPool", ipamapi.PluginEndpointType), func(w http.ResponseWriter, r *http.Request) { 139 err := json.NewDecoder(r.Body).Decode(&poolRequest) 140 if err != nil { 141 http.Error(w, "Unable to decode JSON payload: "+err.Error(), http.StatusBadRequest) 142 return 143 } 144 w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json") 145 if poolRequest.AddressSpace != lAS && poolRequest.AddressSpace != gAS { 146 fmt.Fprintf(w, `{"Error":"Unknown address space in pool request: `+poolRequest.AddressSpace+`"}`) 147 } else if poolRequest.Pool != "" && poolRequest.Pool != pool { 148 fmt.Fprintf(w, `{"Error":"Cannot handle explicit pool requests yet"}`) 149 } else { 150 fmt.Fprintf(w, `{"PoolID":"`+poolID+`", "Pool":"`+pool+`"}`) 151 } 152 }) 153 154 mux.HandleFunc(fmt.Sprintf("/%s.RequestAddress", ipamapi.PluginEndpointType), func(w http.ResponseWriter, r *http.Request) { 155 err := json.NewDecoder(r.Body).Decode(&addressRequest) 156 if err != nil { 157 http.Error(w, "Unable to decode JSON payload: "+err.Error(), http.StatusBadRequest) 158 return 159 } 160 w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json") 161 // make sure libnetwork is now querying on the expected pool id 162 if addressRequest.PoolID != poolID { 163 fmt.Fprintf(w, `{"Error":"unknown pool id"}`) 164 } else if addressRequest.Address != "" { 165 fmt.Fprintf(w, `{"Error":"Cannot handle explicit address requests yet"}`) 166 } else { 167 fmt.Fprintf(w, `{"Address":"`+gw+`"}`) 168 } 169 }) 170 171 mux.HandleFunc(fmt.Sprintf("/%s.ReleaseAddress", ipamapi.PluginEndpointType), func(w http.ResponseWriter, r *http.Request) { 172 err := json.NewDecoder(r.Body).Decode(&addressReleaseReq) 173 if err != nil { 174 http.Error(w, "Unable to decode JSON payload: "+err.Error(), http.StatusBadRequest) 175 return 176 } 177 w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json") 178 // make sure libnetwork is now asking to release the expected address from the expected poolid 179 if addressRequest.PoolID != poolID { 180 fmt.Fprintf(w, `{"Error":"unknown pool id"}`) 181 } else if addressReleaseReq.Address != gw { 182 fmt.Fprintf(w, `{"Error":"unknown address"}`) 183 } else { 184 fmt.Fprintf(w, "null") 185 } 186 }) 187 188 mux.HandleFunc(fmt.Sprintf("/%s.ReleasePool", ipamapi.PluginEndpointType), func(w http.ResponseWriter, r *http.Request) { 189 err := json.NewDecoder(r.Body).Decode(&poolReleaseReq) 190 if err != nil { 191 http.Error(w, "Unable to decode JSON payload: "+err.Error(), http.StatusBadRequest) 192 return 193 } 194 w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json") 195 // make sure libnetwork is now asking to release the expected poolid 196 if addressRequest.PoolID != poolID { 197 fmt.Fprintf(w, `{"Error":"unknown pool id"}`) 198 } else { 199 fmt.Fprintf(w, "null") 200 } 201 }) 202 203 err := os.MkdirAll("/etc/docker/plugins", 0755) 204 c.Assert(err, checker.IsNil) 205 206 fileName := fmt.Sprintf("/etc/docker/plugins/%s.spec", netDrv) 207 err = ioutil.WriteFile(fileName, []byte(url), 0644) 208 c.Assert(err, checker.IsNil) 209 210 ipamFileName := fmt.Sprintf("/etc/docker/plugins/%s.spec", ipamDrv) 211 err = ioutil.WriteFile(ipamFileName, []byte(url), 0644) 212 c.Assert(err, checker.IsNil) 213 } 214 215 func (s *DockerNetworkSuite) TearDownSuite(c *check.C) { 216 if s.server == nil { 217 return 218 } 219 220 s.server.Close() 221 222 err := os.RemoveAll("/etc/docker/plugins") 223 c.Assert(err, checker.IsNil) 224 } 225 226 func assertNwIsAvailable(c *check.C, name string) { 227 if !isNwPresent(c, name) { 228 c.Fatalf("Network %s not found in network ls o/p", name) 229 } 230 } 231 232 func assertNwNotAvailable(c *check.C, name string) { 233 if isNwPresent(c, name) { 234 c.Fatalf("Found network %s in network ls o/p", name) 235 } 236 } 237 238 func isNwPresent(c *check.C, name string) bool { 239 out, _ := dockerCmd(c, "network", "ls") 240 lines := strings.Split(out, "\n") 241 for i := 1; i < len(lines)-1; i++ { 242 netFields := strings.Fields(lines[i]) 243 if netFields[1] == name { 244 return true 245 } 246 } 247 return false 248 } 249 250 // assertNwList checks network list retrieved with ls command 251 // equals to expected network list 252 // note: out should be `network ls [option]` result 253 func assertNwList(c *check.C, out string, expectNws []string) { 254 lines := strings.Split(out, "\n") 255 var nwList []string 256 for _, line := range lines[1 : len(lines)-1] { 257 netFields := strings.Fields(line) 258 // wrap all network name in nwList 259 nwList = append(nwList, netFields[1]) 260 } 261 262 // network ls should contains all expected networks 263 c.Assert(nwList, checker.DeepEquals, expectNws) 264 } 265 266 func getNwResource(c *check.C, name string) *types.NetworkResource { 267 out, _ := dockerCmd(c, "network", "inspect", name) 268 nr := []types.NetworkResource{} 269 err := json.Unmarshal([]byte(out), &nr) 270 c.Assert(err, check.IsNil) 271 return &nr[0] 272 } 273 274 func (s *DockerNetworkSuite) TestDockerNetworkLsDefault(c *check.C) { 275 defaults := []string{"bridge", "host", "none"} 276 for _, nn := range defaults { 277 assertNwIsAvailable(c, nn) 278 } 279 } 280 281 func (s *DockerNetworkSuite) TestDockerNetworkCreatePredefined(c *check.C) { 282 predefined := []string{"bridge", "host", "none", "default"} 283 for _, net := range predefined { 284 // predefined networks can't be created again 285 out, _, err := dockerCmdWithError("network", "create", net) 286 c.Assert(err, checker.NotNil, check.Commentf("%v", out)) 287 } 288 } 289 290 func (s *DockerNetworkSuite) TestDockerNetworkCreateHostBind(c *check.C) { 291 dockerCmd(c, "network", "create", "--subnet=192.168.10.0/24", "--gateway=192.168.10.1", "-o", "com.docker.network.bridge.host_binding_ipv4=192.168.10.1", "testbind") 292 assertNwIsAvailable(c, "testbind") 293 294 out, _ := runSleepingContainer(c, "--net=testbind", "-p", "5000:5000") 295 id := strings.TrimSpace(out) 296 c.Assert(waitRun(id), checker.IsNil) 297 out, _ = dockerCmd(c, "ps") 298 c.Assert(out, checker.Contains, "192.168.10.1:5000->5000/tcp") 299 } 300 301 func (s *DockerNetworkSuite) TestDockerNetworkRmPredefined(c *check.C) { 302 predefined := []string{"bridge", "host", "none", "default"} 303 for _, net := range predefined { 304 // predefined networks can't be removed 305 out, _, err := dockerCmdWithError("network", "rm", net) 306 c.Assert(err, checker.NotNil, check.Commentf("%v", out)) 307 } 308 } 309 310 func (s *DockerNetworkSuite) TestDockerNetworkLsFilter(c *check.C) { 311 out, _ := dockerCmd(c, "network", "create", "dev") 312 defer func() { 313 dockerCmd(c, "network", "rm", "dev") 314 }() 315 networkID := strings.TrimSpace(out) 316 317 // filter with partial ID and partial name 318 // only show 'bridge' and 'dev' network 319 out, _ = dockerCmd(c, "network", "ls", "-f", "id="+networkID[0:5], "-f", "name=dge") 320 assertNwList(c, out, []string{"bridge", "dev"}) 321 322 // only show built-in network (bridge, none, host) 323 out, _ = dockerCmd(c, "network", "ls", "-f", "type=builtin") 324 assertNwList(c, out, []string{"bridge", "host", "none"}) 325 326 // only show custom networks (dev) 327 out, _ = dockerCmd(c, "network", "ls", "-f", "type=custom") 328 assertNwList(c, out, []string{"dev"}) 329 330 // show all networks with filter 331 // it should be equivalent of ls without option 332 out, _ = dockerCmd(c, "network", "ls", "-f", "type=custom", "-f", "type=builtin") 333 assertNwList(c, out, []string{"bridge", "dev", "host", "none"}) 334 } 335 336 func (s *DockerNetworkSuite) TestDockerNetworkCreateDelete(c *check.C) { 337 dockerCmd(c, "network", "create", "test") 338 assertNwIsAvailable(c, "test") 339 340 dockerCmd(c, "network", "rm", "test") 341 assertNwNotAvailable(c, "test") 342 } 343 344 func (s *DockerNetworkSuite) TestDockerNetworkCreateLabel(c *check.C) { 345 testNet := "testnetcreatelabel" 346 testLabel := "foo" 347 testValue := "bar" 348 349 dockerCmd(c, "network", "create", "--label", testLabel+"="+testValue, testNet) 350 assertNwIsAvailable(c, testNet) 351 352 out, _, err := dockerCmdWithError("network", "inspect", "--format='{{ .Labels."+testLabel+" }}'", testNet) 353 c.Assert(err, check.IsNil) 354 c.Assert(strings.TrimSpace(out), check.Equals, testValue) 355 356 dockerCmd(c, "network", "rm", testNet) 357 assertNwNotAvailable(c, testNet) 358 } 359 360 func (s *DockerSuite) TestDockerNetworkDeleteNotExists(c *check.C) { 361 out, _, err := dockerCmdWithError("network", "rm", "test") 362 c.Assert(err, checker.NotNil, check.Commentf("%v", out)) 363 } 364 365 func (s *DockerSuite) TestDockerNetworkDeleteMultiple(c *check.C) { 366 dockerCmd(c, "network", "create", "testDelMulti0") 367 assertNwIsAvailable(c, "testDelMulti0") 368 dockerCmd(c, "network", "create", "testDelMulti1") 369 assertNwIsAvailable(c, "testDelMulti1") 370 dockerCmd(c, "network", "create", "testDelMulti2") 371 assertNwIsAvailable(c, "testDelMulti2") 372 out, _ := dockerCmd(c, "run", "-d", "--net", "testDelMulti2", "busybox", "top") 373 containerID := strings.TrimSpace(out) 374 waitRun(containerID) 375 376 // delete three networks at the same time, since testDelMulti2 377 // contains active container, its deletion should fail. 378 out, _, err := dockerCmdWithError("network", "rm", "testDelMulti0", "testDelMulti1", "testDelMulti2") 379 // err should not be nil due to deleting testDelMulti2 failed. 380 c.Assert(err, checker.NotNil, check.Commentf("out: %s", out)) 381 // testDelMulti2 should fail due to network has active endpoints 382 c.Assert(out, checker.Contains, "has active endpoints") 383 assertNwNotAvailable(c, "testDelMulti0") 384 assertNwNotAvailable(c, "testDelMulti1") 385 // testDelMulti2 can't be deleted, so it should exist 386 assertNwIsAvailable(c, "testDelMulti2") 387 } 388 389 func (s *DockerSuite) TestDockerNetworkInspect(c *check.C) { 390 out, _ := dockerCmd(c, "network", "inspect", "host") 391 networkResources := []types.NetworkResource{} 392 err := json.Unmarshal([]byte(out), &networkResources) 393 c.Assert(err, check.IsNil) 394 c.Assert(networkResources, checker.HasLen, 1) 395 396 out, _ = dockerCmd(c, "network", "inspect", "--format='{{ .Name }}'", "host") 397 c.Assert(strings.TrimSpace(out), check.Equals, "host") 398 } 399 400 func (s *DockerSuite) TestDockerInspectMultipleNetwork(c *check.C) { 401 out, _ := dockerCmd(c, "network", "inspect", "host", "none") 402 networkResources := []types.NetworkResource{} 403 err := json.Unmarshal([]byte(out), &networkResources) 404 c.Assert(err, check.IsNil) 405 c.Assert(networkResources, checker.HasLen, 2) 406 407 // Should print an error, return an exitCode 1 *but* should print the host network 408 out, exitCode, err := dockerCmdWithError("network", "inspect", "host", "nonexistent") 409 c.Assert(err, checker.NotNil) 410 c.Assert(exitCode, checker.Equals, 1) 411 c.Assert(out, checker.Contains, "Error: No such network: nonexistent") 412 networkResources = []types.NetworkResource{} 413 inspectOut := strings.SplitN(out, "\nError: No such network: nonexistent\n", 2)[0] 414 err = json.Unmarshal([]byte(inspectOut), &networkResources) 415 c.Assert(networkResources, checker.HasLen, 1) 416 417 // Should print an error and return an exitCode, nothing else 418 out, exitCode, err = dockerCmdWithError("network", "inspect", "nonexistent") 419 c.Assert(err, checker.NotNil) 420 c.Assert(exitCode, checker.Equals, 1) 421 c.Assert(out, checker.Contains, "Error: No such network: nonexistent") 422 } 423 424 func (s *DockerSuite) TestDockerInspectNetworkWithContainerName(c *check.C) { 425 dockerCmd(c, "network", "create", "brNetForInspect") 426 assertNwIsAvailable(c, "brNetForInspect") 427 defer func() { 428 dockerCmd(c, "network", "rm", "brNetForInspect") 429 assertNwNotAvailable(c, "brNetForInspect") 430 }() 431 432 out, _ := dockerCmd(c, "run", "-d", "--name", "testNetInspect1", "--net", "brNetForInspect", "busybox", "top") 433 c.Assert(waitRun("testNetInspect1"), check.IsNil) 434 containerID := strings.TrimSpace(out) 435 defer func() { 436 // we don't stop container by name, because we'll rename it later 437 dockerCmd(c, "stop", containerID) 438 }() 439 440 out, _ = dockerCmd(c, "network", "inspect", "brNetForInspect") 441 networkResources := []types.NetworkResource{} 442 err := json.Unmarshal([]byte(out), &networkResources) 443 c.Assert(err, check.IsNil) 444 c.Assert(networkResources, checker.HasLen, 1) 445 container, ok := networkResources[0].Containers[containerID] 446 c.Assert(ok, checker.True) 447 c.Assert(container.Name, checker.Equals, "testNetInspect1") 448 449 // rename container and check docker inspect output update 450 newName := "HappyNewName" 451 dockerCmd(c, "rename", "testNetInspect1", newName) 452 453 // check whether network inspect works properly 454 out, _ = dockerCmd(c, "network", "inspect", "brNetForInspect") 455 newNetRes := []types.NetworkResource{} 456 err = json.Unmarshal([]byte(out), &newNetRes) 457 c.Assert(err, check.IsNil) 458 c.Assert(newNetRes, checker.HasLen, 1) 459 container1, ok := newNetRes[0].Containers[containerID] 460 c.Assert(ok, checker.True) 461 c.Assert(container1.Name, checker.Equals, newName) 462 463 } 464 465 func (s *DockerNetworkSuite) TestDockerNetworkConnectDisconnect(c *check.C) { 466 dockerCmd(c, "network", "create", "test") 467 assertNwIsAvailable(c, "test") 468 nr := getNwResource(c, "test") 469 470 c.Assert(nr.Name, checker.Equals, "test") 471 c.Assert(len(nr.Containers), checker.Equals, 0) 472 473 // run a container 474 out, _ := dockerCmd(c, "run", "-d", "--name", "test", "busybox", "top") 475 c.Assert(waitRun("test"), check.IsNil) 476 containerID := strings.TrimSpace(out) 477 478 // connect the container to the test network 479 dockerCmd(c, "network", "connect", "test", containerID) 480 481 // inspect the network to make sure container is connected 482 nr = getNetworkResource(c, nr.ID) 483 c.Assert(len(nr.Containers), checker.Equals, 1) 484 c.Assert(nr.Containers[containerID], check.NotNil) 485 486 // check if container IP matches network inspect 487 ip, _, err := net.ParseCIDR(nr.Containers[containerID].IPv4Address) 488 c.Assert(err, check.IsNil) 489 containerIP := findContainerIP(c, "test", "test") 490 c.Assert(ip.String(), checker.Equals, containerIP) 491 492 // disconnect container from the network 493 dockerCmd(c, "network", "disconnect", "test", containerID) 494 nr = getNwResource(c, "test") 495 c.Assert(nr.Name, checker.Equals, "test") 496 c.Assert(len(nr.Containers), checker.Equals, 0) 497 498 // run another container 499 out, _ = dockerCmd(c, "run", "-d", "--net", "test", "--name", "test2", "busybox", "top") 500 c.Assert(waitRun("test2"), check.IsNil) 501 containerID = strings.TrimSpace(out) 502 503 nr = getNwResource(c, "test") 504 c.Assert(nr.Name, checker.Equals, "test") 505 c.Assert(len(nr.Containers), checker.Equals, 1) 506 507 // force disconnect the container to the test network 508 dockerCmd(c, "network", "disconnect", "-f", "test", containerID) 509 510 nr = getNwResource(c, "test") 511 c.Assert(nr.Name, checker.Equals, "test") 512 c.Assert(len(nr.Containers), checker.Equals, 0) 513 514 dockerCmd(c, "network", "rm", "test") 515 assertNwNotAvailable(c, "test") 516 } 517 518 func (s *DockerNetworkSuite) TestDockerNetworkIpamMultipleNetworks(c *check.C) { 519 // test0 bridge network 520 dockerCmd(c, "network", "create", "--subnet=192.168.0.0/16", "test1") 521 assertNwIsAvailable(c, "test1") 522 523 // test2 bridge network does not overlap 524 dockerCmd(c, "network", "create", "--subnet=192.169.0.0/16", "test2") 525 assertNwIsAvailable(c, "test2") 526 527 // for networks w/o ipam specified, docker will choose proper non-overlapping subnets 528 dockerCmd(c, "network", "create", "test3") 529 assertNwIsAvailable(c, "test3") 530 dockerCmd(c, "network", "create", "test4") 531 assertNwIsAvailable(c, "test4") 532 dockerCmd(c, "network", "create", "test5") 533 assertNwIsAvailable(c, "test5") 534 535 // test network with multiple subnets 536 // bridge network doesn't support multiple subnets. hence, use a dummy driver that supports 537 538 dockerCmd(c, "network", "create", "-d", dummyNetworkDriver, "--subnet=192.168.0.0/16", "--subnet=192.170.0.0/16", "test6") 539 assertNwIsAvailable(c, "test6") 540 541 // test network with multiple subnets with valid ipam combinations 542 // also check same subnet across networks when the driver supports it. 543 dockerCmd(c, "network", "create", "-d", dummyNetworkDriver, 544 "--subnet=192.168.0.0/16", "--subnet=192.170.0.0/16", 545 "--gateway=192.168.0.100", "--gateway=192.170.0.100", 546 "--ip-range=192.168.1.0/24", 547 "--aux-address", "a=192.168.1.5", "--aux-address", "b=192.168.1.6", 548 "--aux-address", "a=192.170.1.5", "--aux-address", "b=192.170.1.6", 549 "test7") 550 assertNwIsAvailable(c, "test7") 551 552 // cleanup 553 for i := 1; i < 8; i++ { 554 dockerCmd(c, "network", "rm", fmt.Sprintf("test%d", i)) 555 } 556 } 557 558 func (s *DockerNetworkSuite) TestDockerNetworkCustomIpam(c *check.C) { 559 // Create a bridge network using custom ipam driver 560 dockerCmd(c, "network", "create", "--ipam-driver", dummyIpamDriver, "br0") 561 assertNwIsAvailable(c, "br0") 562 563 // Verify expected network ipam fields are there 564 nr := getNetworkResource(c, "br0") 565 c.Assert(nr.Driver, checker.Equals, "bridge") 566 c.Assert(nr.IPAM.Driver, checker.Equals, dummyIpamDriver) 567 568 // remove network and exercise remote ipam driver 569 dockerCmd(c, "network", "rm", "br0") 570 assertNwNotAvailable(c, "br0") 571 } 572 573 func (s *DockerNetworkSuite) TestDockerNetworkIpamOptions(c *check.C) { 574 // Create a bridge network using custom ipam driver and options 575 dockerCmd(c, "network", "create", "--ipam-driver", dummyIpamDriver, "--ipam-opt", "opt1=drv1", "--ipam-opt", "opt2=drv2", "br0") 576 assertNwIsAvailable(c, "br0") 577 578 // Verify expected network ipam options 579 nr := getNetworkResource(c, "br0") 580 opts := nr.IPAM.Options 581 c.Assert(opts["opt1"], checker.Equals, "drv1") 582 c.Assert(opts["opt2"], checker.Equals, "drv2") 583 } 584 585 func (s *DockerNetworkSuite) TestDockerNetworkInspectDefault(c *check.C) { 586 nr := getNetworkResource(c, "none") 587 c.Assert(nr.Driver, checker.Equals, "null") 588 c.Assert(nr.Scope, checker.Equals, "local") 589 c.Assert(nr.Internal, checker.Equals, false) 590 c.Assert(nr.EnableIPv6, checker.Equals, false) 591 c.Assert(nr.IPAM.Driver, checker.Equals, "default") 592 c.Assert(len(nr.IPAM.Config), checker.Equals, 0) 593 594 nr = getNetworkResource(c, "host") 595 c.Assert(nr.Driver, checker.Equals, "host") 596 c.Assert(nr.Scope, checker.Equals, "local") 597 c.Assert(nr.Internal, checker.Equals, false) 598 c.Assert(nr.EnableIPv6, checker.Equals, false) 599 c.Assert(nr.IPAM.Driver, checker.Equals, "default") 600 c.Assert(len(nr.IPAM.Config), checker.Equals, 0) 601 602 nr = getNetworkResource(c, "bridge") 603 c.Assert(nr.Driver, checker.Equals, "bridge") 604 c.Assert(nr.Scope, checker.Equals, "local") 605 c.Assert(nr.Internal, checker.Equals, false) 606 c.Assert(nr.EnableIPv6, checker.Equals, false) 607 c.Assert(nr.IPAM.Driver, checker.Equals, "default") 608 c.Assert(len(nr.IPAM.Config), checker.Equals, 1) 609 c.Assert(nr.IPAM.Config[0].Subnet, checker.NotNil) 610 c.Assert(nr.IPAM.Config[0].Gateway, checker.NotNil) 611 } 612 613 func (s *DockerNetworkSuite) TestDockerNetworkInspectCustomUnspecified(c *check.C) { 614 // if unspecified, network subnet will be selected from inside preferred pool 615 dockerCmd(c, "network", "create", "test01") 616 assertNwIsAvailable(c, "test01") 617 618 nr := getNetworkResource(c, "test01") 619 c.Assert(nr.Driver, checker.Equals, "bridge") 620 c.Assert(nr.Scope, checker.Equals, "local") 621 c.Assert(nr.Internal, checker.Equals, false) 622 c.Assert(nr.EnableIPv6, checker.Equals, false) 623 c.Assert(nr.IPAM.Driver, checker.Equals, "default") 624 c.Assert(len(nr.IPAM.Config), checker.Equals, 1) 625 c.Assert(nr.IPAM.Config[0].Subnet, checker.NotNil) 626 c.Assert(nr.IPAM.Config[0].Gateway, checker.NotNil) 627 628 dockerCmd(c, "network", "rm", "test01") 629 assertNwNotAvailable(c, "test01") 630 } 631 632 func (s *DockerNetworkSuite) TestDockerNetworkInspectCustomSpecified(c *check.C) { 633 dockerCmd(c, "network", "create", "--driver=bridge", "--ipv6", "--subnet=172.28.0.0/16", "--ip-range=172.28.5.0/24", "--gateway=172.28.5.254", "br0") 634 assertNwIsAvailable(c, "br0") 635 636 nr := getNetworkResource(c, "br0") 637 c.Assert(nr.Driver, checker.Equals, "bridge") 638 c.Assert(nr.Scope, checker.Equals, "local") 639 c.Assert(nr.Internal, checker.Equals, false) 640 c.Assert(nr.EnableIPv6, checker.Equals, true) 641 c.Assert(nr.IPAM.Driver, checker.Equals, "default") 642 c.Assert(len(nr.IPAM.Config), checker.Equals, 1) 643 c.Assert(nr.IPAM.Config[0].Subnet, checker.Equals, "172.28.0.0/16") 644 c.Assert(nr.IPAM.Config[0].IPRange, checker.Equals, "172.28.5.0/24") 645 c.Assert(nr.IPAM.Config[0].Gateway, checker.Equals, "172.28.5.254") 646 c.Assert(nr.Internal, checker.False) 647 dockerCmd(c, "network", "rm", "br0") 648 assertNwNotAvailable(c, "test01") 649 } 650 651 func (s *DockerNetworkSuite) TestDockerNetworkIpamInvalidCombinations(c *check.C) { 652 // network with ip-range out of subnet range 653 _, _, err := dockerCmdWithError("network", "create", "--subnet=192.168.0.0/16", "--ip-range=192.170.0.0/16", "test") 654 c.Assert(err, check.NotNil) 655 656 // network with multiple gateways for a single subnet 657 _, _, err = dockerCmdWithError("network", "create", "--subnet=192.168.0.0/16", "--gateway=192.168.0.1", "--gateway=192.168.0.2", "test") 658 c.Assert(err, check.NotNil) 659 660 // Multiple overlapping subnets in the same network must fail 661 _, _, err = dockerCmdWithError("network", "create", "--subnet=192.168.0.0/16", "--subnet=192.168.1.0/16", "test") 662 c.Assert(err, check.NotNil) 663 664 // overlapping subnets across networks must fail 665 // create a valid test0 network 666 dockerCmd(c, "network", "create", "--subnet=192.168.0.0/16", "test0") 667 assertNwIsAvailable(c, "test0") 668 // create an overlapping test1 network 669 _, _, err = dockerCmdWithError("network", "create", "--subnet=192.168.128.0/17", "test1") 670 c.Assert(err, check.NotNil) 671 dockerCmd(c, "network", "rm", "test0") 672 assertNwNotAvailable(c, "test0") 673 } 674 675 func (s *DockerNetworkSuite) TestDockerNetworkDriverOptions(c *check.C) { 676 dockerCmd(c, "network", "create", "-d", dummyNetworkDriver, "-o", "opt1=drv1", "-o", "opt2=drv2", "testopt") 677 assertNwIsAvailable(c, "testopt") 678 gopts := remoteDriverNetworkRequest.Options[netlabel.GenericData] 679 c.Assert(gopts, checker.NotNil) 680 opts, ok := gopts.(map[string]interface{}) 681 c.Assert(ok, checker.Equals, true) 682 c.Assert(opts["opt1"], checker.Equals, "drv1") 683 c.Assert(opts["opt2"], checker.Equals, "drv2") 684 dockerCmd(c, "network", "rm", "testopt") 685 assertNwNotAvailable(c, "testopt") 686 687 } 688 689 func (s *DockerDaemonSuite) TestDockerNetworkNoDiscoveryDefaultBridgeNetwork(c *check.C) { 690 testRequires(c, ExecSupport) 691 // On default bridge network built-in service discovery should not happen 692 hostsFile := "/etc/hosts" 693 bridgeName := "external-bridge" 694 bridgeIP := "192.169.255.254/24" 695 out, err := createInterface(c, "bridge", bridgeName, bridgeIP) 696 c.Assert(err, check.IsNil, check.Commentf(out)) 697 defer deleteInterface(c, bridgeName) 698 699 err = s.d.StartWithBusybox("--bridge", bridgeName) 700 c.Assert(err, check.IsNil) 701 defer s.d.Restart() 702 703 // run two containers and store first container's etc/hosts content 704 out, err = s.d.Cmd("run", "-d", "busybox", "top") 705 c.Assert(err, check.IsNil) 706 cid1 := strings.TrimSpace(out) 707 defer s.d.Cmd("stop", cid1) 708 709 hosts, err := s.d.Cmd("exec", cid1, "cat", hostsFile) 710 c.Assert(err, checker.IsNil) 711 712 out, err = s.d.Cmd("run", "-d", "--name", "container2", "busybox", "top") 713 c.Assert(err, check.IsNil) 714 cid2 := strings.TrimSpace(out) 715 716 // verify first container's etc/hosts file has not changed after spawning the second named container 717 hostsPost, err := s.d.Cmd("exec", cid1, "cat", hostsFile) 718 c.Assert(err, checker.IsNil) 719 c.Assert(string(hosts), checker.Equals, string(hostsPost), 720 check.Commentf("Unexpected %s change on second container creation", hostsFile)) 721 722 // stop container 2 and verify first container's etc/hosts has not changed 723 _, err = s.d.Cmd("stop", cid2) 724 c.Assert(err, check.IsNil) 725 726 hostsPost, err = s.d.Cmd("exec", cid1, "cat", hostsFile) 727 c.Assert(err, checker.IsNil) 728 c.Assert(string(hosts), checker.Equals, string(hostsPost), 729 check.Commentf("Unexpected %s change on second container creation", hostsFile)) 730 731 // but discovery is on when connecting to non default bridge network 732 network := "anotherbridge" 733 out, err = s.d.Cmd("network", "create", network) 734 c.Assert(err, check.IsNil, check.Commentf(out)) 735 defer s.d.Cmd("network", "rm", network) 736 737 out, err = s.d.Cmd("network", "connect", network, cid1) 738 c.Assert(err, check.IsNil, check.Commentf(out)) 739 740 hosts, err = s.d.Cmd("exec", cid1, "cat", hostsFile) 741 c.Assert(err, checker.IsNil) 742 743 hostsPost, err = s.d.Cmd("exec", cid1, "cat", hostsFile) 744 c.Assert(err, checker.IsNil) 745 c.Assert(string(hosts), checker.Equals, string(hostsPost), 746 check.Commentf("Unexpected %s change on second network connection", hostsFile)) 747 } 748 749 func (s *DockerNetworkSuite) TestDockerNetworkAnonymousEndpoint(c *check.C) { 750 testRequires(c, ExecSupport, NotArm) 751 hostsFile := "/etc/hosts" 752 cstmBridgeNw := "custom-bridge-nw" 753 cstmBridgeNw1 := "custom-bridge-nw1" 754 755 dockerCmd(c, "network", "create", "-d", "bridge", cstmBridgeNw) 756 assertNwIsAvailable(c, cstmBridgeNw) 757 758 // run two anonymous containers and store their etc/hosts content 759 out, _ := dockerCmd(c, "run", "-d", "--net", cstmBridgeNw, "busybox", "top") 760 cid1 := strings.TrimSpace(out) 761 762 hosts1, err := readContainerFileWithExec(cid1, hostsFile) 763 c.Assert(err, checker.IsNil) 764 765 out, _ = dockerCmd(c, "run", "-d", "--net", cstmBridgeNw, "busybox", "top") 766 cid2 := strings.TrimSpace(out) 767 768 hosts2, err := readContainerFileWithExec(cid2, hostsFile) 769 c.Assert(err, checker.IsNil) 770 771 // verify first container etc/hosts file has not changed 772 hosts1post, err := readContainerFileWithExec(cid1, hostsFile) 773 c.Assert(err, checker.IsNil) 774 c.Assert(string(hosts1), checker.Equals, string(hosts1post), 775 check.Commentf("Unexpected %s change on anonymous container creation", hostsFile)) 776 777 // Connect the 2nd container to a new network and verify the 778 // first container /etc/hosts file still hasn't changed. 779 dockerCmd(c, "network", "create", "-d", "bridge", cstmBridgeNw1) 780 assertNwIsAvailable(c, cstmBridgeNw1) 781 782 dockerCmd(c, "network", "connect", cstmBridgeNw1, cid2) 783 784 hosts2, err = readContainerFileWithExec(cid2, hostsFile) 785 c.Assert(err, checker.IsNil) 786 787 hosts1post, err = readContainerFileWithExec(cid1, hostsFile) 788 c.Assert(err, checker.IsNil) 789 c.Assert(string(hosts1), checker.Equals, string(hosts1post), 790 check.Commentf("Unexpected %s change on container connect", hostsFile)) 791 792 // start a named container 793 cName := "AnyName" 794 out, _ = dockerCmd(c, "run", "-d", "--net", cstmBridgeNw, "--name", cName, "busybox", "top") 795 cid3 := strings.TrimSpace(out) 796 797 // verify that container 1 and 2 can ping the named container 798 dockerCmd(c, "exec", cid1, "ping", "-c", "1", cName) 799 dockerCmd(c, "exec", cid2, "ping", "-c", "1", cName) 800 801 // Stop named container and verify first two containers' etc/hosts file hasn't changed 802 dockerCmd(c, "stop", cid3) 803 hosts1post, err = readContainerFileWithExec(cid1, hostsFile) 804 c.Assert(err, checker.IsNil) 805 c.Assert(string(hosts1), checker.Equals, string(hosts1post), 806 check.Commentf("Unexpected %s change on name container creation", hostsFile)) 807 808 hosts2post, err := readContainerFileWithExec(cid2, hostsFile) 809 c.Assert(err, checker.IsNil) 810 c.Assert(string(hosts2), checker.Equals, string(hosts2post), 811 check.Commentf("Unexpected %s change on name container creation", hostsFile)) 812 813 // verify that container 1 and 2 can't ping the named container now 814 _, _, err = dockerCmdWithError("exec", cid1, "ping", "-c", "1", cName) 815 c.Assert(err, check.NotNil) 816 _, _, err = dockerCmdWithError("exec", cid2, "ping", "-c", "1", cName) 817 c.Assert(err, check.NotNil) 818 } 819 820 func (s *DockerNetworkSuite) TestDockerNetworkLinkOnDefaultNetworkOnly(c *check.C) { 821 // Legacy Link feature must work only on default network, and not across networks 822 cnt1 := "container1" 823 cnt2 := "container2" 824 network := "anotherbridge" 825 826 // Run first container on default network 827 dockerCmd(c, "run", "-d", "--name", cnt1, "busybox", "top") 828 829 // Create another network and run the second container on it 830 dockerCmd(c, "network", "create", network) 831 assertNwIsAvailable(c, network) 832 dockerCmd(c, "run", "-d", "--net", network, "--name", cnt2, "busybox", "top") 833 834 // Try launching a container on default network, linking to the first container. Must succeed 835 dockerCmd(c, "run", "-d", "--link", fmt.Sprintf("%s:%s", cnt1, cnt1), "busybox", "top") 836 837 // Try launching a container on default network, linking to the second container. Must fail 838 _, _, err := dockerCmdWithError("run", "-d", "--link", fmt.Sprintf("%s:%s", cnt2, cnt2), "busybox", "top") 839 c.Assert(err, checker.NotNil) 840 841 // Connect second container to default network. Now a container on default network can link to it 842 dockerCmd(c, "network", "connect", "bridge", cnt2) 843 dockerCmd(c, "run", "-d", "--link", fmt.Sprintf("%s:%s", cnt2, cnt2), "busybox", "top") 844 } 845 846 func (s *DockerNetworkSuite) TestDockerNetworkOverlayPortMapping(c *check.C) { 847 // Verify exposed ports are present in ps output when running a container on 848 // a network managed by a driver which does not provide the default gateway 849 // for the container 850 nwn := "ov" 851 ctn := "bb" 852 port1 := 80 853 port2 := 443 854 expose1 := fmt.Sprintf("--expose=%d", port1) 855 expose2 := fmt.Sprintf("--expose=%d", port2) 856 857 dockerCmd(c, "network", "create", "-d", dummyNetworkDriver, nwn) 858 assertNwIsAvailable(c, nwn) 859 860 dockerCmd(c, "run", "-d", "--net", nwn, "--name", ctn, expose1, expose2, "busybox", "top") 861 862 // Check docker ps o/p for last created container reports the unpublished ports 863 unpPort1 := fmt.Sprintf("%d/tcp", port1) 864 unpPort2 := fmt.Sprintf("%d/tcp", port2) 865 out, _ := dockerCmd(c, "ps", "-n=1") 866 // Missing unpublished ports in docker ps output 867 c.Assert(out, checker.Contains, unpPort1) 868 // Missing unpublished ports in docker ps output 869 c.Assert(out, checker.Contains, unpPort2) 870 } 871 872 func (s *DockerNetworkSuite) TestDockerNetworkDriverUngracefulRestart(c *check.C) { 873 testRequires(c, DaemonIsLinux, NotUserNamespace) 874 dnd := "dnd" 875 did := "did" 876 877 mux := http.NewServeMux() 878 server := httptest.NewServer(mux) 879 setupRemoteNetworkDrivers(c, mux, server.URL, dnd, did) 880 881 s.d.StartWithBusybox() 882 _, err := s.d.Cmd("network", "create", "-d", dnd, "--subnet", "1.1.1.0/24", "net1") 883 c.Assert(err, checker.IsNil) 884 885 _, err = s.d.Cmd("run", "-itd", "--net", "net1", "--name", "foo", "--ip", "1.1.1.10", "busybox", "sh") 886 c.Assert(err, checker.IsNil) 887 888 // Kill daemon and restart 889 if err = s.d.cmd.Process.Kill(); err != nil { 890 c.Fatal(err) 891 } 892 893 server.Close() 894 895 startTime := time.Now().Unix() 896 if err = s.d.Restart(); err != nil { 897 c.Fatal(err) 898 } 899 lapse := time.Now().Unix() - startTime 900 if lapse > 60 { 901 // In normal scenarios, daemon restart takes ~1 second. 902 // Plugin retry mechanism can delay the daemon start. systemd may not like it. 903 // Avoid accessing plugins during daemon bootup 904 c.Logf("daemon restart took too long : %d seconds", lapse) 905 } 906 907 // Restart the custom dummy plugin 908 mux = http.NewServeMux() 909 server = httptest.NewServer(mux) 910 setupRemoteNetworkDrivers(c, mux, server.URL, dnd, did) 911 912 // trying to reuse the same ip must succeed 913 _, err = s.d.Cmd("run", "-itd", "--net", "net1", "--name", "bar", "--ip", "1.1.1.10", "busybox", "sh") 914 c.Assert(err, checker.IsNil) 915 } 916 917 func (s *DockerNetworkSuite) TestDockerNetworkMacInspect(c *check.C) { 918 // Verify endpoint MAC address is correctly populated in container's network settings 919 nwn := "ov" 920 ctn := "bb" 921 922 dockerCmd(c, "network", "create", "-d", dummyNetworkDriver, nwn) 923 assertNwIsAvailable(c, nwn) 924 925 dockerCmd(c, "run", "-d", "--net", nwn, "--name", ctn, "busybox", "top") 926 927 mac := inspectField(c, ctn, "NetworkSettings.Networks."+nwn+".MacAddress") 928 c.Assert(mac, checker.Equals, "a0:b1:c2:d3:e4:f5") 929 } 930 931 func (s *DockerSuite) TestInspectApiMultipleNetworks(c *check.C) { 932 dockerCmd(c, "network", "create", "mybridge1") 933 dockerCmd(c, "network", "create", "mybridge2") 934 out, _ := dockerCmd(c, "run", "-d", "busybox", "top") 935 id := strings.TrimSpace(out) 936 c.Assert(waitRun(id), check.IsNil) 937 938 dockerCmd(c, "network", "connect", "mybridge1", id) 939 dockerCmd(c, "network", "connect", "mybridge2", id) 940 941 body := getInspectBody(c, "v1.20", id) 942 var inspect120 v1p20.ContainerJSON 943 err := json.Unmarshal(body, &inspect120) 944 c.Assert(err, checker.IsNil) 945 946 versionedIP := inspect120.NetworkSettings.IPAddress 947 948 body = getInspectBody(c, "v1.21", id) 949 var inspect121 types.ContainerJSON 950 err = json.Unmarshal(body, &inspect121) 951 c.Assert(err, checker.IsNil) 952 c.Assert(inspect121.NetworkSettings.Networks, checker.HasLen, 3) 953 954 bridge := inspect121.NetworkSettings.Networks["bridge"] 955 c.Assert(bridge.IPAddress, checker.Equals, versionedIP) 956 c.Assert(bridge.IPAddress, checker.Equals, inspect121.NetworkSettings.IPAddress) 957 } 958 959 func connectContainerToNetworks(c *check.C, d *Daemon, cName string, nws []string) { 960 // Run a container on the default network 961 out, err := d.Cmd("run", "-d", "--name", cName, "busybox", "top") 962 c.Assert(err, checker.IsNil, check.Commentf(out)) 963 964 // Attach the container to other networks 965 for _, nw := range nws { 966 out, err = d.Cmd("network", "create", nw) 967 c.Assert(err, checker.IsNil, check.Commentf(out)) 968 out, err = d.Cmd("network", "connect", nw, cName) 969 c.Assert(err, checker.IsNil, check.Commentf(out)) 970 } 971 } 972 973 func verifyContainerIsConnectedToNetworks(c *check.C, d *Daemon, cName string, nws []string) { 974 // Verify container is connected to all the networks 975 for _, nw := range nws { 976 out, err := d.Cmd("inspect", "-f", fmt.Sprintf("{{.NetworkSettings.Networks.%s}}", nw), cName) 977 c.Assert(err, checker.IsNil, check.Commentf(out)) 978 c.Assert(out, checker.Not(checker.Equals), "<no value>\n") 979 } 980 } 981 982 func (s *DockerNetworkSuite) TestDockerNetworkMultipleNetworksGracefulDaemonRestart(c *check.C) { 983 cName := "bb" 984 nwList := []string{"nw1", "nw2", "nw3"} 985 986 s.d.StartWithBusybox() 987 988 connectContainerToNetworks(c, s.d, cName, nwList) 989 verifyContainerIsConnectedToNetworks(c, s.d, cName, nwList) 990 991 // Reload daemon 992 s.d.Restart() 993 994 _, err := s.d.Cmd("start", cName) 995 c.Assert(err, checker.IsNil) 996 997 verifyContainerIsConnectedToNetworks(c, s.d, cName, nwList) 998 } 999 1000 func (s *DockerNetworkSuite) TestDockerNetworkMultipleNetworksUngracefulDaemonRestart(c *check.C) { 1001 cName := "cc" 1002 nwList := []string{"nw1", "nw2", "nw3"} 1003 1004 s.d.StartWithBusybox() 1005 1006 connectContainerToNetworks(c, s.d, cName, nwList) 1007 verifyContainerIsConnectedToNetworks(c, s.d, cName, nwList) 1008 1009 // Kill daemon and restart 1010 if err := s.d.cmd.Process.Kill(); err != nil { 1011 c.Fatal(err) 1012 } 1013 s.d.Restart() 1014 1015 // Restart container 1016 _, err := s.d.Cmd("start", cName) 1017 c.Assert(err, checker.IsNil) 1018 1019 verifyContainerIsConnectedToNetworks(c, s.d, cName, nwList) 1020 } 1021 1022 func (s *DockerNetworkSuite) TestDockerNetworkRunNetByID(c *check.C) { 1023 out, _ := dockerCmd(c, "network", "create", "one") 1024 containerOut, _, err := dockerCmdWithError("run", "-d", "--net", strings.TrimSpace(out), "busybox", "top") 1025 c.Assert(err, checker.IsNil, check.Commentf(containerOut)) 1026 } 1027 1028 func (s *DockerNetworkSuite) TestDockerNetworkHostModeUngracefulDaemonRestart(c *check.C) { 1029 testRequires(c, DaemonIsLinux, NotUserNamespace) 1030 s.d.StartWithBusybox() 1031 1032 // Run a few containers on host network 1033 for i := 0; i < 10; i++ { 1034 cName := fmt.Sprintf("hostc-%d", i) 1035 out, err := s.d.Cmd("run", "-d", "--name", cName, "--net=host", "--restart=always", "busybox", "top") 1036 c.Assert(err, checker.IsNil, check.Commentf(out)) 1037 1038 // verfiy container has finished starting before killing daemon 1039 err = s.d.waitRun(cName) 1040 c.Assert(err, checker.IsNil) 1041 } 1042 1043 // Kill daemon ungracefully and restart 1044 if err := s.d.cmd.Process.Kill(); err != nil { 1045 c.Fatal(err) 1046 } 1047 if err := s.d.Restart(); err != nil { 1048 c.Fatal(err) 1049 } 1050 1051 // make sure all the containers are up and running 1052 for i := 0; i < 10; i++ { 1053 err := s.d.waitRun(fmt.Sprintf("hostc-%d", i)) 1054 c.Assert(err, checker.IsNil) 1055 } 1056 } 1057 1058 func (s *DockerNetworkSuite) TestDockerNetworkConnectToHostFromOtherNetwork(c *check.C) { 1059 dockerCmd(c, "run", "-d", "--name", "container1", "busybox", "top") 1060 c.Assert(waitRun("container1"), check.IsNil) 1061 dockerCmd(c, "network", "disconnect", "bridge", "container1") 1062 out, _, err := dockerCmdWithError("network", "connect", "host", "container1") 1063 c.Assert(err, checker.NotNil, check.Commentf(out)) 1064 c.Assert(out, checker.Contains, runconfig.ErrConflictHostNetwork.Error()) 1065 } 1066 1067 func (s *DockerNetworkSuite) TestDockerNetworkDisconnectFromHost(c *check.C) { 1068 dockerCmd(c, "run", "-d", "--name", "container1", "--net=host", "busybox", "top") 1069 c.Assert(waitRun("container1"), check.IsNil) 1070 out, _, err := dockerCmdWithError("network", "disconnect", "host", "container1") 1071 c.Assert(err, checker.NotNil, check.Commentf("Should err out disconnect from host")) 1072 c.Assert(out, checker.Contains, runconfig.ErrConflictHostNetwork.Error()) 1073 } 1074 1075 func (s *DockerNetworkSuite) TestDockerNetworkConnectWithPortMapping(c *check.C) { 1076 testRequires(c, NotArm) 1077 dockerCmd(c, "network", "create", "test1") 1078 dockerCmd(c, "run", "-d", "--name", "c1", "-p", "5000:5000", "busybox", "top") 1079 c.Assert(waitRun("c1"), check.IsNil) 1080 dockerCmd(c, "network", "connect", "test1", "c1") 1081 } 1082 1083 func (s *DockerNetworkSuite) TestDockerNetworkConnectWithMac(c *check.C) { 1084 macAddress := "02:42:ac:11:00:02" 1085 dockerCmd(c, "network", "create", "mynetwork") 1086 dockerCmd(c, "run", "--name=test", "-d", "--mac-address", macAddress, "busybox", "top") 1087 c.Assert(waitRun("test"), check.IsNil) 1088 mac1 := inspectField(c, "test", "NetworkSettings.Networks.bridge.MacAddress") 1089 c.Assert(strings.TrimSpace(mac1), checker.Equals, macAddress) 1090 dockerCmd(c, "network", "connect", "mynetwork", "test") 1091 mac2 := inspectField(c, "test", "NetworkSettings.Networks.mynetwork.MacAddress") 1092 c.Assert(strings.TrimSpace(mac2), checker.Not(checker.Equals), strings.TrimSpace(mac1)) 1093 } 1094 1095 func (s *DockerNetworkSuite) TestDockerNetworkInspectCreatedContainer(c *check.C) { 1096 dockerCmd(c, "create", "--name", "test", "busybox") 1097 networks := inspectField(c, "test", "NetworkSettings.Networks") 1098 c.Assert(networks, checker.Contains, "bridge", check.Commentf("Should return 'bridge' network")) 1099 } 1100 1101 func (s *DockerNetworkSuite) TestDockerNetworkRestartWithMultipleNetworks(c *check.C) { 1102 dockerCmd(c, "network", "create", "test") 1103 dockerCmd(c, "run", "--name=foo", "-d", "busybox", "top") 1104 c.Assert(waitRun("foo"), checker.IsNil) 1105 dockerCmd(c, "network", "connect", "test", "foo") 1106 dockerCmd(c, "restart", "foo") 1107 networks := inspectField(c, "foo", "NetworkSettings.Networks") 1108 c.Assert(networks, checker.Contains, "bridge", check.Commentf("Should contain 'bridge' network")) 1109 c.Assert(networks, checker.Contains, "test", check.Commentf("Should contain 'test' network")) 1110 } 1111 1112 func (s *DockerNetworkSuite) TestDockerNetworkConnectDisconnectToStoppedContainer(c *check.C) { 1113 dockerCmd(c, "network", "create", "test") 1114 dockerCmd(c, "create", "--name=foo", "busybox", "top") 1115 dockerCmd(c, "network", "connect", "test", "foo") 1116 networks := inspectField(c, "foo", "NetworkSettings.Networks") 1117 c.Assert(networks, checker.Contains, "test", check.Commentf("Should contain 'test' network")) 1118 1119 // Restart docker daemon to test the config has persisted to disk 1120 s.d.Restart() 1121 networks = inspectField(c, "foo", "NetworkSettings.Networks") 1122 c.Assert(networks, checker.Contains, "test", check.Commentf("Should contain 'test' network")) 1123 1124 // start the container and test if we can ping it from another container in the same network 1125 dockerCmd(c, "start", "foo") 1126 c.Assert(waitRun("foo"), checker.IsNil) 1127 ip := inspectField(c, "foo", "NetworkSettings.Networks.test.IPAddress") 1128 ip = strings.TrimSpace(ip) 1129 dockerCmd(c, "run", "--net=test", "busybox", "sh", "-c", fmt.Sprintf("ping -c 1 %s", ip)) 1130 1131 dockerCmd(c, "stop", "foo") 1132 1133 // Test disconnect 1134 dockerCmd(c, "network", "disconnect", "test", "foo") 1135 networks = inspectField(c, "foo", "NetworkSettings.Networks") 1136 c.Assert(networks, checker.Not(checker.Contains), "test", check.Commentf("Should not contain 'test' network")) 1137 1138 // Restart docker daemon to test the config has persisted to disk 1139 s.d.Restart() 1140 networks = inspectField(c, "foo", "NetworkSettings.Networks") 1141 c.Assert(networks, checker.Not(checker.Contains), "test", check.Commentf("Should not contain 'test' network")) 1142 1143 } 1144 1145 func (s *DockerNetworkSuite) TestDockerNetworkConnectPreferredIP(c *check.C) { 1146 // create two networks 1147 dockerCmd(c, "network", "create", "--ipv6", "--subnet=172.28.0.0/16", "--subnet=2001:db8:1234::/64", "n0") 1148 assertNwIsAvailable(c, "n0") 1149 1150 dockerCmd(c, "network", "create", "--ipv6", "--subnet=172.30.0.0/16", "--ip-range=172.30.5.0/24", "--subnet=2001:db8:abcd::/64", "--ip-range=2001:db8:abcd::/80", "n1") 1151 assertNwIsAvailable(c, "n1") 1152 1153 // run a container on first network specifying the ip addresses 1154 dockerCmd(c, "run", "-d", "--name", "c0", "--net=n0", "--ip", "172.28.99.88", "--ip6", "2001:db8:1234::9988", "busybox", "top") 1155 c.Assert(waitRun("c0"), check.IsNil) 1156 verifyIPAddressConfig(c, "c0", "n0", "172.28.99.88", "2001:db8:1234::9988") 1157 verifyIPAddresses(c, "c0", "n0", "172.28.99.88", "2001:db8:1234::9988") 1158 1159 // connect the container to the second network specifying an ip addresses 1160 dockerCmd(c, "network", "connect", "--ip", "172.30.55.44", "--ip6", "2001:db8:abcd::5544", "n1", "c0") 1161 verifyIPAddressConfig(c, "c0", "n1", "172.30.55.44", "2001:db8:abcd::5544") 1162 verifyIPAddresses(c, "c0", "n1", "172.30.55.44", "2001:db8:abcd::5544") 1163 1164 // Stop and restart the container 1165 dockerCmd(c, "stop", "c0") 1166 dockerCmd(c, "start", "c0") 1167 1168 // verify requested addresses are applied and configs are still there 1169 verifyIPAddressConfig(c, "c0", "n0", "172.28.99.88", "2001:db8:1234::9988") 1170 verifyIPAddresses(c, "c0", "n0", "172.28.99.88", "2001:db8:1234::9988") 1171 verifyIPAddressConfig(c, "c0", "n1", "172.30.55.44", "2001:db8:abcd::5544") 1172 verifyIPAddresses(c, "c0", "n1", "172.30.55.44", "2001:db8:abcd::5544") 1173 1174 // Still it should fail to connect to the default network with a specified IP (whatever ip) 1175 out, _, err := dockerCmdWithError("network", "connect", "--ip", "172.21.55.44", "bridge", "c0") 1176 c.Assert(err, checker.NotNil, check.Commentf("out: %s", out)) 1177 c.Assert(out, checker.Contains, runconfig.ErrUnsupportedNetworkAndIP.Error()) 1178 1179 } 1180 1181 func (s *DockerNetworkSuite) TestDockerNetworkConnectPreferredIPStoppedContainer(c *check.C) { 1182 // create a container 1183 dockerCmd(c, "create", "--name", "c0", "busybox", "top") 1184 1185 // create a network 1186 dockerCmd(c, "network", "create", "--ipv6", "--subnet=172.30.0.0/16", "--subnet=2001:db8:abcd::/64", "n0") 1187 assertNwIsAvailable(c, "n0") 1188 1189 // connect the container to the network specifying an ip addresses 1190 dockerCmd(c, "network", "connect", "--ip", "172.30.55.44", "--ip6", "2001:db8:abcd::5544", "n0", "c0") 1191 verifyIPAddressConfig(c, "c0", "n0", "172.30.55.44", "2001:db8:abcd::5544") 1192 1193 // start the container, verify config has not changed and ip addresses are assigned 1194 dockerCmd(c, "start", "c0") 1195 c.Assert(waitRun("c0"), check.IsNil) 1196 verifyIPAddressConfig(c, "c0", "n0", "172.30.55.44", "2001:db8:abcd::5544") 1197 verifyIPAddresses(c, "c0", "n0", "172.30.55.44", "2001:db8:abcd::5544") 1198 1199 // stop the container and check ip config has not changed 1200 dockerCmd(c, "stop", "c0") 1201 verifyIPAddressConfig(c, "c0", "n0", "172.30.55.44", "2001:db8:abcd::5544") 1202 } 1203 1204 func (s *DockerNetworkSuite) TestDockerNetworkUnsupportedRequiredIP(c *check.C) { 1205 // requested IP is not supported on predefined networks 1206 for _, mode := range []string{"none", "host", "bridge", "default"} { 1207 checkUnsupportedNetworkAndIP(c, mode) 1208 } 1209 1210 // requested IP is not supported on networks with no user defined subnets 1211 dockerCmd(c, "network", "create", "n0") 1212 assertNwIsAvailable(c, "n0") 1213 1214 out, _, err := dockerCmdWithError("run", "-d", "--ip", "172.28.99.88", "--net", "n0", "busybox", "top") 1215 c.Assert(err, checker.NotNil, check.Commentf("out: %s", out)) 1216 c.Assert(out, checker.Contains, runconfig.ErrUnsupportedNetworkNoSubnetAndIP.Error()) 1217 1218 out, _, err = dockerCmdWithError("run", "-d", "--ip6", "2001:db8:1234::9988", "--net", "n0", "busybox", "top") 1219 c.Assert(err, checker.NotNil, check.Commentf("out: %s", out)) 1220 c.Assert(out, checker.Contains, runconfig.ErrUnsupportedNetworkNoSubnetAndIP.Error()) 1221 1222 dockerCmd(c, "network", "rm", "n0") 1223 assertNwNotAvailable(c, "n0") 1224 } 1225 1226 func checkUnsupportedNetworkAndIP(c *check.C, nwMode string) { 1227 out, _, err := dockerCmdWithError("run", "-d", "--net", nwMode, "--ip", "172.28.99.88", "--ip6", "2001:db8:1234::9988", "busybox", "top") 1228 c.Assert(err, checker.NotNil, check.Commentf("out: %s", out)) 1229 c.Assert(out, checker.Contains, runconfig.ErrUnsupportedNetworkAndIP.Error()) 1230 } 1231 1232 func verifyIPAddressConfig(c *check.C, cName, nwname, ipv4, ipv6 string) { 1233 if ipv4 != "" { 1234 out := inspectField(c, cName, fmt.Sprintf("NetworkSettings.Networks.%s.IPAMConfig.IPv4Address", nwname)) 1235 c.Assert(strings.TrimSpace(out), check.Equals, ipv4) 1236 } 1237 1238 if ipv6 != "" { 1239 out := inspectField(c, cName, fmt.Sprintf("NetworkSettings.Networks.%s.IPAMConfig.IPv6Address", nwname)) 1240 c.Assert(strings.TrimSpace(out), check.Equals, ipv6) 1241 } 1242 } 1243 1244 func verifyIPAddresses(c *check.C, cName, nwname, ipv4, ipv6 string) { 1245 out := inspectField(c, cName, fmt.Sprintf("NetworkSettings.Networks.%s.IPAddress", nwname)) 1246 c.Assert(strings.TrimSpace(out), check.Equals, ipv4) 1247 1248 out = inspectField(c, cName, fmt.Sprintf("NetworkSettings.Networks.%s.GlobalIPv6Address", nwname)) 1249 c.Assert(strings.TrimSpace(out), check.Equals, ipv6) 1250 } 1251 1252 func (s *DockerSuite) TestUserDefinedNetworkConnectDisconnectLink(c *check.C) { 1253 testRequires(c, DaemonIsLinux, NotUserNamespace, NotArm) 1254 dockerCmd(c, "network", "create", "-d", "bridge", "foo1") 1255 dockerCmd(c, "network", "create", "-d", "bridge", "foo2") 1256 1257 dockerCmd(c, "run", "-d", "--net=foo1", "--name=first", "busybox", "top") 1258 c.Assert(waitRun("first"), check.IsNil) 1259 1260 // run a container in a user-defined network with a link for an existing container 1261 // and a link for a container that doesn't exist 1262 dockerCmd(c, "run", "-d", "--net=foo1", "--name=second", "--link=first:FirstInFoo1", 1263 "--link=third:bar", "busybox", "top") 1264 c.Assert(waitRun("second"), check.IsNil) 1265 1266 // ping to first and its alias FirstInFoo1 must succeed 1267 _, _, err := dockerCmdWithError("exec", "second", "ping", "-c", "1", "first") 1268 c.Assert(err, check.IsNil) 1269 _, _, err = dockerCmdWithError("exec", "second", "ping", "-c", "1", "FirstInFoo1") 1270 c.Assert(err, check.IsNil) 1271 1272 // connect first container to foo2 network 1273 dockerCmd(c, "network", "connect", "foo2", "first") 1274 // connect second container to foo2 network with a different alias for first container 1275 dockerCmd(c, "network", "connect", "--link=first:FirstInFoo2", "foo2", "second") 1276 1277 // ping the new alias in network foo2 1278 _, _, err = dockerCmdWithError("exec", "second", "ping", "-c", "1", "FirstInFoo2") 1279 c.Assert(err, check.IsNil) 1280 1281 // disconnect first container from foo1 network 1282 dockerCmd(c, "network", "disconnect", "foo1", "first") 1283 1284 // link in foo1 network must fail 1285 _, _, err = dockerCmdWithError("exec", "second", "ping", "-c", "1", "FirstInFoo1") 1286 c.Assert(err, check.NotNil) 1287 1288 // link in foo2 network must succeed 1289 _, _, err = dockerCmdWithError("exec", "second", "ping", "-c", "1", "FirstInFoo2") 1290 c.Assert(err, check.IsNil) 1291 } 1292 1293 // #19100 This is a deprecated feature test, it should be removed in Docker 1.12 1294 func (s *DockerNetworkSuite) TestDockerNetworkStartAPIWithHostconfig(c *check.C) { 1295 netName := "test" 1296 conName := "foo" 1297 dockerCmd(c, "network", "create", netName) 1298 dockerCmd(c, "create", "--name", conName, "busybox", "top") 1299 1300 config := map[string]interface{}{ 1301 "HostConfig": map[string]interface{}{ 1302 "NetworkMode": netName, 1303 }, 1304 } 1305 _, _, err := sockRequest("POST", "/containers/"+conName+"/start", config) 1306 c.Assert(err, checker.IsNil) 1307 c.Assert(waitRun(conName), checker.IsNil) 1308 networks := inspectField(c, conName, "NetworkSettings.Networks") 1309 c.Assert(networks, checker.Contains, netName, check.Commentf(fmt.Sprintf("Should contain '%s' network", netName))) 1310 c.Assert(networks, checker.Not(checker.Contains), "bridge", check.Commentf("Should not contain 'bridge' network")) 1311 } 1312 1313 func (s *DockerNetworkSuite) TestDockerNetworkDisconnectDefault(c *check.C) { 1314 netWorkName1 := "test1" 1315 netWorkName2 := "test2" 1316 containerName := "foo" 1317 1318 dockerCmd(c, "network", "create", netWorkName1) 1319 dockerCmd(c, "network", "create", netWorkName2) 1320 dockerCmd(c, "create", "--name", containerName, "busybox", "top") 1321 dockerCmd(c, "network", "connect", netWorkName1, containerName) 1322 dockerCmd(c, "network", "connect", netWorkName2, containerName) 1323 dockerCmd(c, "network", "disconnect", "bridge", containerName) 1324 1325 dockerCmd(c, "start", containerName) 1326 c.Assert(waitRun(containerName), checker.IsNil) 1327 networks := inspectField(c, containerName, "NetworkSettings.Networks") 1328 c.Assert(networks, checker.Contains, netWorkName1, check.Commentf(fmt.Sprintf("Should contain '%s' network", netWorkName1))) 1329 c.Assert(networks, checker.Contains, netWorkName2, check.Commentf(fmt.Sprintf("Should contain '%s' network", netWorkName2))) 1330 c.Assert(networks, checker.Not(checker.Contains), "bridge", check.Commentf("Should not contain 'bridge' network")) 1331 } 1332 1333 func (s *DockerNetworkSuite) TestDockerNetworkConnectWithAliasOnDefaultNetworks(c *check.C) { 1334 testRequires(c, DaemonIsLinux, NotUserNamespace, NotArm) 1335 1336 defaults := []string{"bridge", "host", "none"} 1337 out, _ := dockerCmd(c, "run", "-d", "--net=none", "busybox", "top") 1338 containerID := strings.TrimSpace(out) 1339 for _, net := range defaults { 1340 res, _, err := dockerCmdWithError("network", "connect", "--alias", "alias"+net, net, containerID) 1341 c.Assert(err, checker.NotNil) 1342 c.Assert(res, checker.Contains, runconfig.ErrUnsupportedNetworkAndAlias.Error()) 1343 } 1344 } 1345 1346 func (s *DockerSuite) TestUserDefinedNetworkConnectDisconnectAlias(c *check.C) { 1347 testRequires(c, DaemonIsLinux, NotUserNamespace, NotArm) 1348 dockerCmd(c, "network", "create", "-d", "bridge", "net1") 1349 dockerCmd(c, "network", "create", "-d", "bridge", "net2") 1350 1351 dockerCmd(c, "run", "-d", "--net=net1", "--name=first", "--net-alias=foo", "busybox", "top") 1352 c.Assert(waitRun("first"), check.IsNil) 1353 1354 dockerCmd(c, "run", "-d", "--net=net1", "--name=second", "busybox", "top") 1355 c.Assert(waitRun("second"), check.IsNil) 1356 1357 // ping first container and its alias 1358 _, _, err := dockerCmdWithError("exec", "second", "ping", "-c", "1", "first") 1359 c.Assert(err, check.IsNil) 1360 _, _, err = dockerCmdWithError("exec", "second", "ping", "-c", "1", "foo") 1361 c.Assert(err, check.IsNil) 1362 1363 // connect first container to net2 network 1364 dockerCmd(c, "network", "connect", "--alias=bar", "net2", "first") 1365 // connect second container to foo2 network with a different alias for first container 1366 dockerCmd(c, "network", "connect", "net2", "second") 1367 1368 // ping the new alias in network foo2 1369 _, _, err = dockerCmdWithError("exec", "second", "ping", "-c", "1", "bar") 1370 c.Assert(err, check.IsNil) 1371 1372 // disconnect first container from net1 network 1373 dockerCmd(c, "network", "disconnect", "net1", "first") 1374 1375 // ping to net1 scoped alias "foo" must fail 1376 _, _, err = dockerCmdWithError("exec", "second", "ping", "-c", "1", "foo") 1377 c.Assert(err, check.NotNil) 1378 1379 // ping to net2 scoped alias "bar" must still succeed 1380 _, _, err = dockerCmdWithError("exec", "second", "ping", "-c", "1", "bar") 1381 c.Assert(err, check.IsNil) 1382 1383 // verify the alias option is rejected when running on predefined network 1384 out, _, err := dockerCmdWithError("run", "--rm", "--name=any", "--net-alias=any", "busybox", "top") 1385 c.Assert(err, checker.NotNil, check.Commentf("out: %s", out)) 1386 c.Assert(out, checker.Contains, runconfig.ErrUnsupportedNetworkAndAlias.Error()) 1387 1388 // verify the alias option is rejected when connecting to predefined network 1389 out, _, err = dockerCmdWithError("network", "connect", "--alias=any", "bridge", "first") 1390 c.Assert(err, checker.NotNil, check.Commentf("out: %s", out)) 1391 c.Assert(out, checker.Contains, runconfig.ErrUnsupportedNetworkAndAlias.Error()) 1392 } 1393 1394 func (s *DockerSuite) TestUserDefinedNetworkConnectivity(c *check.C) { 1395 testRequires(c, DaemonIsLinux, NotUserNamespace) 1396 dockerCmd(c, "network", "create", "-d", "bridge", "br.net1") 1397 1398 dockerCmd(c, "run", "-d", "--net=br.net1", "--name=c1.net1", "busybox", "top") 1399 c.Assert(waitRun("c1.net1"), check.IsNil) 1400 1401 dockerCmd(c, "run", "-d", "--net=br.net1", "--name=c2.net1", "busybox", "top") 1402 c.Assert(waitRun("c2.net1"), check.IsNil) 1403 1404 // ping first container by its unqualified name 1405 _, _, err := dockerCmdWithError("exec", "c2.net1", "ping", "-c", "1", "c1.net1") 1406 c.Assert(err, check.IsNil) 1407 1408 // ping first container by its qualified name 1409 _, _, err = dockerCmdWithError("exec", "c2.net1", "ping", "-c", "1", "c1.net1.br.net1") 1410 c.Assert(err, check.IsNil) 1411 1412 // ping with first qualified name masked by an additional domain. should fail 1413 _, _, err = dockerCmdWithError("exec", "c2.net1", "ping", "-c", "1", "c1.net1.br.net1.google.com") 1414 c.Assert(err, check.NotNil) 1415 } 1416 1417 func (s *DockerSuite) TestEmbeddedDNSInvalidInput(c *check.C) { 1418 testRequires(c, DaemonIsLinux, NotUserNamespace) 1419 dockerCmd(c, "network", "create", "-d", "bridge", "nw1") 1420 1421 // Sending garbage to embedded DNS shouldn't crash the daemon 1422 dockerCmd(c, "run", "-i", "--net=nw1", "--name=c1", "debian:jessie", "bash", "-c", "echo InvalidQuery > /dev/udp/127.0.0.11/53") 1423 } 1424 1425 func (s *DockerSuite) TestDockerNetworkConnectFailsNoInspectChange(c *check.C) { 1426 dockerCmd(c, "run", "-d", "--name=bb", "busybox", "top") 1427 c.Assert(waitRun("bb"), check.IsNil) 1428 1429 ns0 := inspectField(c, "bb", "NetworkSettings.Networks.bridge") 1430 1431 // A failing redundant network connect should not alter current container's endpoint settings 1432 _, _, err := dockerCmdWithError("network", "connect", "bridge", "bb") 1433 c.Assert(err, check.NotNil) 1434 1435 ns1 := inspectField(c, "bb", "NetworkSettings.Networks.bridge") 1436 c.Assert(ns1, check.Equals, ns0) 1437 } 1438 1439 func (s *DockerSuite) TestDockerNetworkInternalMode(c *check.C) { 1440 dockerCmd(c, "network", "create", "--driver=bridge", "--internal", "internal") 1441 assertNwIsAvailable(c, "internal") 1442 nr := getNetworkResource(c, "internal") 1443 c.Assert(nr.Internal, checker.True) 1444 1445 dockerCmd(c, "run", "-d", "--net=internal", "--name=first", "busybox", "top") 1446 c.Assert(waitRun("first"), check.IsNil) 1447 dockerCmd(c, "run", "-d", "--net=internal", "--name=second", "busybox", "top") 1448 c.Assert(waitRun("second"), check.IsNil) 1449 out, _, err := dockerCmdWithError("exec", "first", "ping", "-W", "4", "-c", "1", "www.google.com") 1450 c.Assert(err, check.NotNil) 1451 c.Assert(out, checker.Contains, "ping: bad address") 1452 _, _, err = dockerCmdWithError("exec", "second", "ping", "-c", "1", "first") 1453 c.Assert(err, check.IsNil) 1454 } 1455 1456 // Test for #21401 1457 func (s *DockerNetworkSuite) TestDockerNetworkCreateDeleteSpecialCharacters(c *check.C) { 1458 dockerCmd(c, "network", "create", "test@#$") 1459 assertNwIsAvailable(c, "test@#$") 1460 dockerCmd(c, "network", "rm", "test@#$") 1461 assertNwNotAvailable(c, "test@#$") 1462 1463 dockerCmd(c, "network", "create", "kiwl$%^") 1464 assertNwIsAvailable(c, "kiwl$%^") 1465 dockerCmd(c, "network", "rm", "kiwl$%^") 1466 assertNwNotAvailable(c, "kiwl$%^") 1467 }