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