| package main |
| |
| import ( |
| "encoding/json" |
| "fmt" |
| "net" |
| "net/http" |
| "net/url" |
| "strings" |
| |
| "github.com/docker/docker/api/types" |
| "github.com/docker/docker/api/types/filters" |
| "github.com/docker/docker/api/types/network" |
| "github.com/docker/docker/integration-cli/checker" |
| "github.com/docker/docker/integration-cli/request" |
| "github.com/go-check/check" |
| ) |
| |
| func (s *DockerSuite) TestAPINetworkGetDefaults(c *check.C) { |
| testRequires(c, DaemonIsLinux) |
| // By default docker daemon creates 3 networks. check if they are present |
| defaults := []string{"bridge", "host", "none"} |
| for _, nn := range defaults { |
| c.Assert(isNetworkAvailable(c, nn), checker.Equals, true) |
| } |
| } |
| |
| func (s *DockerSuite) TestAPINetworkCreateDelete(c *check.C) { |
| testRequires(c, DaemonIsLinux) |
| // Create a network |
| name := "testnetwork" |
| config := types.NetworkCreateRequest{ |
| Name: name, |
| NetworkCreate: types.NetworkCreate{ |
| CheckDuplicate: true, |
| }, |
| } |
| id := createNetwork(c, config, http.StatusCreated) |
| c.Assert(isNetworkAvailable(c, name), checker.Equals, true) |
| |
| // delete the network and make sure it is deleted |
| deleteNetwork(c, id, true) |
| c.Assert(isNetworkAvailable(c, name), checker.Equals, false) |
| } |
| |
| func (s *DockerSuite) TestAPINetworkCreateCheckDuplicate(c *check.C) { |
| testRequires(c, DaemonIsLinux) |
| name := "testcheckduplicate" |
| configOnCheck := types.NetworkCreateRequest{ |
| Name: name, |
| NetworkCreate: types.NetworkCreate{ |
| CheckDuplicate: true, |
| }, |
| } |
| configNotCheck := types.NetworkCreateRequest{ |
| Name: name, |
| NetworkCreate: types.NetworkCreate{ |
| CheckDuplicate: false, |
| }, |
| } |
| |
| // Creating a new network first |
| createNetwork(c, configOnCheck, http.StatusCreated) |
| c.Assert(isNetworkAvailable(c, name), checker.Equals, true) |
| |
| // Creating another network with same name and CheckDuplicate must fail |
| createNetwork(c, configOnCheck, http.StatusConflict) |
| |
| // Creating another network with same name and not CheckDuplicate must succeed |
| createNetwork(c, configNotCheck, http.StatusCreated) |
| } |
| |
| func (s *DockerSuite) TestAPINetworkFilter(c *check.C) { |
| testRequires(c, DaemonIsLinux) |
| nr := getNetworkResource(c, getNetworkIDByName(c, "bridge")) |
| c.Assert(nr.Name, checker.Equals, "bridge") |
| } |
| |
| func (s *DockerSuite) TestAPINetworkInspectBridge(c *check.C) { |
| testRequires(c, DaemonIsLinux) |
| // Inspect default bridge network |
| nr := getNetworkResource(c, "bridge") |
| c.Assert(nr.Name, checker.Equals, "bridge") |
| |
| // run a container and attach it to the default bridge network |
| out, _ := dockerCmd(c, "run", "-d", "--name", "test", "busybox", "top") |
| containerID := strings.TrimSpace(out) |
| containerIP := findContainerIP(c, "test", "bridge") |
| |
| // inspect default bridge network again and make sure the container is connected |
| nr = getNetworkResource(c, nr.ID) |
| c.Assert(nr.Driver, checker.Equals, "bridge") |
| c.Assert(nr.Scope, checker.Equals, "local") |
| c.Assert(nr.Internal, checker.Equals, false) |
| c.Assert(nr.EnableIPv6, checker.Equals, false) |
| c.Assert(nr.IPAM.Driver, checker.Equals, "default") |
| c.Assert(nr.Containers[containerID], checker.NotNil) |
| |
| ip, _, err := net.ParseCIDR(nr.Containers[containerID].IPv4Address) |
| c.Assert(err, checker.IsNil) |
| c.Assert(ip.String(), checker.Equals, containerIP) |
| } |
| |
| func (s *DockerSuite) TestAPINetworkInspectUserDefinedNetwork(c *check.C) { |
| testRequires(c, DaemonIsLinux) |
| // IPAM configuration inspect |
| ipam := &network.IPAM{ |
| Driver: "default", |
| Config: []network.IPAMConfig{{Subnet: "172.28.0.0/16", IPRange: "172.28.5.0/24", Gateway: "172.28.5.254"}}, |
| } |
| config := types.NetworkCreateRequest{ |
| Name: "br0", |
| NetworkCreate: types.NetworkCreate{ |
| Driver: "bridge", |
| IPAM: ipam, |
| Options: map[string]string{"foo": "bar", "opts": "dopts"}, |
| }, |
| } |
| id0 := createNetwork(c, config, http.StatusCreated) |
| c.Assert(isNetworkAvailable(c, "br0"), checker.Equals, true) |
| |
| nr := getNetworkResource(c, id0) |
| c.Assert(len(nr.IPAM.Config), checker.Equals, 1) |
| c.Assert(nr.IPAM.Config[0].Subnet, checker.Equals, "172.28.0.0/16") |
| c.Assert(nr.IPAM.Config[0].IPRange, checker.Equals, "172.28.5.0/24") |
| c.Assert(nr.IPAM.Config[0].Gateway, checker.Equals, "172.28.5.254") |
| c.Assert(nr.Options["foo"], checker.Equals, "bar") |
| c.Assert(nr.Options["opts"], checker.Equals, "dopts") |
| |
| // delete the network and make sure it is deleted |
| deleteNetwork(c, id0, true) |
| c.Assert(isNetworkAvailable(c, "br0"), checker.Equals, false) |
| } |
| |
| func (s *DockerSuite) TestAPINetworkConnectDisconnect(c *check.C) { |
| testRequires(c, DaemonIsLinux) |
| // Create test network |
| name := "testnetwork" |
| config := types.NetworkCreateRequest{ |
| Name: name, |
| } |
| id := createNetwork(c, config, http.StatusCreated) |
| nr := getNetworkResource(c, id) |
| c.Assert(nr.Name, checker.Equals, name) |
| c.Assert(nr.ID, checker.Equals, id) |
| c.Assert(len(nr.Containers), checker.Equals, 0) |
| |
| // run a container |
| out, _ := dockerCmd(c, "run", "-d", "--name", "test", "busybox", "top") |
| containerID := strings.TrimSpace(out) |
| |
| // connect the container to the test network |
| connectNetwork(c, nr.ID, containerID) |
| |
| // inspect the network to make sure container is connected |
| nr = getNetworkResource(c, nr.ID) |
| c.Assert(len(nr.Containers), checker.Equals, 1) |
| c.Assert(nr.Containers[containerID], checker.NotNil) |
| |
| // check if container IP matches network inspect |
| ip, _, err := net.ParseCIDR(nr.Containers[containerID].IPv4Address) |
| c.Assert(err, checker.IsNil) |
| containerIP := findContainerIP(c, "test", "testnetwork") |
| c.Assert(ip.String(), checker.Equals, containerIP) |
| |
| // disconnect container from the network |
| disconnectNetwork(c, nr.ID, containerID) |
| nr = getNetworkResource(c, nr.ID) |
| c.Assert(nr.Name, checker.Equals, name) |
| c.Assert(len(nr.Containers), checker.Equals, 0) |
| |
| // delete the network |
| deleteNetwork(c, nr.ID, true) |
| } |
| |
| func (s *DockerSuite) TestAPINetworkIPAMMultipleBridgeNetworks(c *check.C) { |
| testRequires(c, DaemonIsLinux) |
| // test0 bridge network |
| ipam0 := &network.IPAM{ |
| Driver: "default", |
| Config: []network.IPAMConfig{{Subnet: "192.178.0.0/16", IPRange: "192.178.128.0/17", Gateway: "192.178.138.100"}}, |
| } |
| config0 := types.NetworkCreateRequest{ |
| Name: "test0", |
| NetworkCreate: types.NetworkCreate{ |
| Driver: "bridge", |
| IPAM: ipam0, |
| }, |
| } |
| id0 := createNetwork(c, config0, http.StatusCreated) |
| c.Assert(isNetworkAvailable(c, "test0"), checker.Equals, true) |
| |
| ipam1 := &network.IPAM{ |
| Driver: "default", |
| Config: []network.IPAMConfig{{Subnet: "192.178.128.0/17", Gateway: "192.178.128.1"}}, |
| } |
| // test1 bridge network overlaps with test0 |
| config1 := types.NetworkCreateRequest{ |
| Name: "test1", |
| NetworkCreate: types.NetworkCreate{ |
| Driver: "bridge", |
| IPAM: ipam1, |
| }, |
| } |
| createNetwork(c, config1, http.StatusForbidden) |
| c.Assert(isNetworkAvailable(c, "test1"), checker.Equals, false) |
| |
| ipam2 := &network.IPAM{ |
| Driver: "default", |
| Config: []network.IPAMConfig{{Subnet: "192.169.0.0/16", Gateway: "192.169.100.100"}}, |
| } |
| // test2 bridge network does not overlap |
| config2 := types.NetworkCreateRequest{ |
| Name: "test2", |
| NetworkCreate: types.NetworkCreate{ |
| Driver: "bridge", |
| IPAM: ipam2, |
| }, |
| } |
| createNetwork(c, config2, http.StatusCreated) |
| c.Assert(isNetworkAvailable(c, "test2"), checker.Equals, true) |
| |
| // remove test0 and retry to create test1 |
| deleteNetwork(c, id0, true) |
| createNetwork(c, config1, http.StatusCreated) |
| c.Assert(isNetworkAvailable(c, "test1"), checker.Equals, true) |
| |
| // for networks w/o ipam specified, docker will choose proper non-overlapping subnets |
| createNetwork(c, types.NetworkCreateRequest{Name: "test3"}, http.StatusCreated) |
| c.Assert(isNetworkAvailable(c, "test3"), checker.Equals, true) |
| createNetwork(c, types.NetworkCreateRequest{Name: "test4"}, http.StatusCreated) |
| c.Assert(isNetworkAvailable(c, "test4"), checker.Equals, true) |
| createNetwork(c, types.NetworkCreateRequest{Name: "test5"}, http.StatusCreated) |
| c.Assert(isNetworkAvailable(c, "test5"), checker.Equals, true) |
| |
| for i := 1; i < 6; i++ { |
| deleteNetwork(c, fmt.Sprintf("test%d", i), true) |
| } |
| } |
| |
| func (s *DockerSuite) TestAPICreateDeletePredefinedNetworks(c *check.C) { |
| testRequires(c, DaemonIsLinux) |
| createDeletePredefinedNetwork(c, "bridge") |
| createDeletePredefinedNetwork(c, "none") |
| createDeletePredefinedNetwork(c, "host") |
| } |
| |
| func createDeletePredefinedNetwork(c *check.C, name string) { |
| // Create pre-defined network |
| config := types.NetworkCreateRequest{ |
| Name: name, |
| NetworkCreate: types.NetworkCreate{ |
| CheckDuplicate: true, |
| }, |
| } |
| createNetwork(c, config, http.StatusForbidden) |
| deleteNetwork(c, name, false) |
| } |
| |
| func isNetworkAvailable(c *check.C, name string) bool { |
| resp, body, err := request.Get("/networks") |
| c.Assert(err, checker.IsNil) |
| defer resp.Body.Close() |
| c.Assert(resp.StatusCode, checker.Equals, http.StatusOK) |
| |
| nJSON := []types.NetworkResource{} |
| err = json.NewDecoder(body).Decode(&nJSON) |
| c.Assert(err, checker.IsNil) |
| |
| for _, n := range nJSON { |
| if n.Name == name { |
| return true |
| } |
| } |
| return false |
| } |
| |
| func getNetworkIDByName(c *check.C, name string) string { |
| var ( |
| v = url.Values{} |
| filterArgs = filters.NewArgs() |
| ) |
| filterArgs.Add("name", name) |
| filterJSON, err := filters.ToJSON(filterArgs) |
| c.Assert(err, checker.IsNil) |
| v.Set("filters", filterJSON) |
| |
| resp, body, err := request.Get("/networks?" + v.Encode()) |
| c.Assert(resp.StatusCode, checker.Equals, http.StatusOK) |
| c.Assert(err, checker.IsNil) |
| |
| nJSON := []types.NetworkResource{} |
| err = json.NewDecoder(body).Decode(&nJSON) |
| c.Assert(err, checker.IsNil) |
| var res string |
| for _, n := range nJSON { |
| // Find exact match |
| if n.Name == name { |
| res = n.ID |
| } |
| } |
| c.Assert(res, checker.Not(checker.Equals), "") |
| |
| return res |
| } |
| |
| func getNetworkResource(c *check.C, id string) *types.NetworkResource { |
| _, obj, err := request.Get("/networks/" + id) |
| c.Assert(err, checker.IsNil) |
| |
| nr := types.NetworkResource{} |
| err = json.NewDecoder(obj).Decode(&nr) |
| c.Assert(err, checker.IsNil) |
| |
| return &nr |
| } |
| |
| func createNetwork(c *check.C, config types.NetworkCreateRequest, expectedStatusCode int) string { |
| resp, body, err := request.Post("/networks/create", request.JSONBody(config)) |
| c.Assert(err, checker.IsNil) |
| defer resp.Body.Close() |
| |
| c.Assert(resp.StatusCode, checker.Equals, expectedStatusCode) |
| |
| if expectedStatusCode == http.StatusCreated { |
| var nr types.NetworkCreateResponse |
| err = json.NewDecoder(body).Decode(&nr) |
| c.Assert(err, checker.IsNil) |
| |
| return nr.ID |
| } |
| return "" |
| } |
| |
| func connectNetwork(c *check.C, nid, cid string) { |
| config := types.NetworkConnect{ |
| Container: cid, |
| } |
| |
| resp, _, err := request.Post("/networks/"+nid+"/connect", request.JSONBody(config)) |
| c.Assert(resp.StatusCode, checker.Equals, http.StatusOK) |
| c.Assert(err, checker.IsNil) |
| } |
| |
| func disconnectNetwork(c *check.C, nid, cid string) { |
| config := types.NetworkConnect{ |
| Container: cid, |
| } |
| |
| resp, _, err := request.Post("/networks/"+nid+"/disconnect", request.JSONBody(config)) |
| c.Assert(resp.StatusCode, checker.Equals, http.StatusOK) |
| c.Assert(err, checker.IsNil) |
| } |
| |
| func deleteNetwork(c *check.C, id string, shouldSucceed bool) { |
| resp, _, err := request.Delete("/networks/" + id) |
| c.Assert(err, checker.IsNil) |
| defer resp.Body.Close() |
| if !shouldSucceed { |
| c.Assert(resp.StatusCode, checker.Not(checker.Equals), http.StatusOK) |
| return |
| } |
| c.Assert(resp.StatusCode, checker.Equals, http.StatusNoContent) |
| } |
