| // +build !windows |
| |
| package main |
| |
| import ( |
| "encoding/json" |
| "fmt" |
| "io/ioutil" |
| "net" |
| "net/http" |
| "net/http/httptest" |
| "os" |
| "strings" |
| |
| "github.com/docker/docker/api/types" |
| "github.com/docker/libnetwork/driverapi" |
| "github.com/go-check/check" |
| ) |
| |
| const dummyNetworkDriver = "dummy-network-driver" |
| |
| func init() { |
| check.Suite(&DockerNetworkSuite{ |
| ds: &DockerSuite{}, |
| }) |
| } |
| |
| type DockerNetworkSuite struct { |
| server *httptest.Server |
| ds *DockerSuite |
| d *Daemon |
| } |
| |
| func (s *DockerNetworkSuite) SetUpTest(c *check.C) { |
| s.d = NewDaemon(c) |
| } |
| |
| func (s *DockerNetworkSuite) TearDownTest(c *check.C) { |
| s.d.Stop() |
| s.ds.TearDownTest(c) |
| } |
| |
| func (s *DockerNetworkSuite) SetUpSuite(c *check.C) { |
| mux := http.NewServeMux() |
| s.server = httptest.NewServer(mux) |
| if s.server == nil { |
| c.Fatal("Failed to start a HTTP Server") |
| } |
| |
| mux.HandleFunc("/Plugin.Activate", func(w http.ResponseWriter, r *http.Request) { |
| w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json") |
| fmt.Fprintf(w, `{"Implements": ["%s"]}`, driverapi.NetworkPluginEndpointType) |
| }) |
| |
| mux.HandleFunc(fmt.Sprintf("/%s.GetCapabilities", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) { |
| w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json") |
| fmt.Fprintf(w, `{"Scope":"local"}`) |
| }) |
| |
| mux.HandleFunc(fmt.Sprintf("/%s.CreateNetwork", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) { |
| w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json") |
| fmt.Fprintf(w, "null") |
| }) |
| |
| mux.HandleFunc(fmt.Sprintf("/%s.DeleteNetwork", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) { |
| w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json") |
| fmt.Fprintf(w, "null") |
| }) |
| |
| if err := os.MkdirAll("/etc/docker/plugins", 0755); err != nil { |
| c.Fatal(err) |
| } |
| |
| fileName := fmt.Sprintf("/etc/docker/plugins/%s.spec", dummyNetworkDriver) |
| if err := ioutil.WriteFile(fileName, []byte(s.server.URL), 0644); err != nil { |
| c.Fatal(err) |
| } |
| } |
| |
| func (s *DockerNetworkSuite) TearDownSuite(c *check.C) { |
| if s.server == nil { |
| return |
| } |
| |
| s.server.Close() |
| |
| if err := os.RemoveAll("/etc/docker/plugins"); err != nil { |
| c.Fatal(err) |
| } |
| } |
| |
| func assertNwIsAvailable(c *check.C, name string) { |
| if !isNwPresent(c, name) { |
| c.Fatalf("Network %s not found in network ls o/p", name) |
| } |
| } |
| |
| func assertNwNotAvailable(c *check.C, name string) { |
| if isNwPresent(c, name) { |
| c.Fatalf("Found network %s in network ls o/p", name) |
| } |
| } |
| |
| func isNwPresent(c *check.C, name string) bool { |
| out, _ := dockerCmd(c, "network", "ls") |
| lines := strings.Split(out, "\n") |
| for i := 1; i < len(lines)-1; i++ { |
| if strings.Contains(lines[i], name) { |
| return true |
| } |
| } |
| return false |
| } |
| |
| func getNwResource(c *check.C, name string) *types.NetworkResource { |
| out, _ := dockerCmd(c, "network", "inspect", name) |
| nr := types.NetworkResource{} |
| err := json.Unmarshal([]byte(out), &nr) |
| c.Assert(err, check.IsNil) |
| return &nr |
| } |
| |
| func (s *DockerNetworkSuite) TestDockerNetworkLsDefault(c *check.C) { |
| defaults := []string{"bridge", "host", "none"} |
| for _, nn := range defaults { |
| assertNwIsAvailable(c, nn) |
| } |
| } |
| |
| func (s *DockerNetworkSuite) TestDockerNetworkCreateDelete(c *check.C) { |
| dockerCmd(c, "network", "create", "test") |
| assertNwIsAvailable(c, "test") |
| |
| dockerCmd(c, "network", "rm", "test") |
| assertNwNotAvailable(c, "test") |
| } |
| |
| func (s *DockerNetworkSuite) TestDockerNetworkConnectDisconnect(c *check.C) { |
| dockerCmd(c, "network", "create", "test") |
| assertNwIsAvailable(c, "test") |
| nr := getNwResource(c, "test") |
| |
| c.Assert(nr.Name, check.Equals, "test") |
| c.Assert(len(nr.Containers), check.Equals, 0) |
| |
| // run a container |
| out, _ := dockerCmd(c, "run", "-d", "--name", "test", "busybox", "top") |
| c.Assert(waitRun("test"), check.IsNil) |
| containerID := strings.TrimSpace(out) |
| |
| // connect the container to the test network |
| dockerCmd(c, "network", "connect", "test", containerID) |
| |
| // inspect the network to make sure container is connected |
| nr = getNetworkResource(c, nr.ID) |
| c.Assert(len(nr.Containers), check.Equals, 1) |
| c.Assert(nr.Containers[containerID], check.NotNil) |
| |
| // check if container IP matches network inspect |
| ip, _, err := net.ParseCIDR(nr.Containers[containerID].IPv4Address) |
| c.Assert(err, check.IsNil) |
| containerIP := findContainerIP(c, "test") |
| c.Assert(ip.String(), check.Equals, containerIP) |
| |
| // disconnect container from the network |
| dockerCmd(c, "network", "disconnect", "test", containerID) |
| nr = getNwResource(c, "test") |
| c.Assert(nr.Name, check.Equals, "test") |
| c.Assert(len(nr.Containers), check.Equals, 0) |
| |
| // check if network connect fails for inactive containers |
| dockerCmd(c, "stop", containerID) |
| _, _, err = dockerCmdWithError("network", "connect", "test", containerID) |
| c.Assert(err, check.NotNil) |
| |
| dockerCmd(c, "network", "rm", "test") |
| assertNwNotAvailable(c, "test") |
| } |
| |
| func (s *DockerNetworkSuite) TestDockerNetworkIpamMultipleNetworks(c *check.C) { |
| // test0 bridge network |
| dockerCmd(c, "network", "create", "--subnet=192.168.0.0/16", "test1") |
| assertNwIsAvailable(c, "test1") |
| |
| // test2 bridge network does not overlap |
| dockerCmd(c, "network", "create", "--subnet=192.169.0.0/16", "test2") |
| assertNwIsAvailable(c, "test2") |
| |
| // for networks w/o ipam specified, docker will choose proper non-overlapping subnets |
| dockerCmd(c, "network", "create", "test3") |
| assertNwIsAvailable(c, "test3") |
| dockerCmd(c, "network", "create", "test4") |
| assertNwIsAvailable(c, "test4") |
| dockerCmd(c, "network", "create", "test5") |
| assertNwIsAvailable(c, "test5") |
| |
| // test network with multiple subnets |
| // bridge network doesnt support multiple subnets. hence, use a dummy driver that supports |
| |
| dockerCmd(c, "network", "create", "-d", dummyNetworkDriver, "--subnet=192.168.0.0/16", "--subnet=192.170.0.0/16", "test6") |
| assertNwIsAvailable(c, "test6") |
| |
| // test network with multiple subnets with valid ipam combinations |
| // also check same subnet across networks when the driver supports it. |
| dockerCmd(c, "network", "create", "-d", dummyNetworkDriver, |
| "--subnet=192.168.0.0/16", "--subnet=192.170.0.0/16", |
| "--gateway=192.168.0.100", "--gateway=192.170.0.100", |
| "--ip-range=192.168.1.0/24", |
| "--aux-address", "a=192.168.1.5", "--aux-address", "b=192.168.1.6", |
| "--aux-address", "a=192.170.1.5", "--aux-address", "b=192.170.1.6", |
| "test7") |
| assertNwIsAvailable(c, "test7") |
| |
| // cleanup |
| for i := 1; i < 8; i++ { |
| dockerCmd(c, "network", "rm", fmt.Sprintf("test%d", i)) |
| } |
| } |
| |
| func (s *DockerNetworkSuite) TestDockerNetworkInspect(c *check.C) { |
| // if unspecified, network gateway will be selected from inside preferred pool |
| 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") |
| assertNwIsAvailable(c, "br0") |
| |
| nr := getNetworkResource(c, "br0") |
| c.Assert(nr.Driver, check.Equals, "bridge") |
| c.Assert(nr.Scope, check.Equals, "local") |
| c.Assert(nr.IPAM.Driver, check.Equals, "default") |
| c.Assert(len(nr.IPAM.Config), check.Equals, 1) |
| c.Assert(nr.IPAM.Config[0].Subnet, check.Equals, "172.28.0.0/16") |
| c.Assert(nr.IPAM.Config[0].IPRange, check.Equals, "172.28.5.0/24") |
| c.Assert(nr.IPAM.Config[0].Gateway, check.Equals, "172.28.5.254") |
| dockerCmd(c, "network", "rm", "br0") |
| } |
| |
| func (s *DockerNetworkSuite) TestDockerNetworkIpamInvalidCombinations(c *check.C) { |
| // network with ip-range out of subnet range |
| _, _, err := dockerCmdWithError("network", "create", "--subnet=192.168.0.0/16", "--ip-range=192.170.0.0/16", "test") |
| c.Assert(err, check.NotNil) |
| |
| // network with multiple gateways for a single subnet |
| _, _, err = dockerCmdWithError("network", "create", "--subnet=192.168.0.0/16", "--gateway=192.168.0.1", "--gateway=192.168.0.2", "test") |
| c.Assert(err, check.NotNil) |
| |
| // Multiple overlaping subnets in the same network must fail |
| _, _, err = dockerCmdWithError("network", "create", "--subnet=192.168.0.0/16", "--subnet=192.168.1.0/16", "test") |
| c.Assert(err, check.NotNil) |
| |
| // overlapping subnets across networks must fail |
| // create a valid test0 network |
| dockerCmd(c, "network", "create", "--subnet=192.168.0.0/16", "test0") |
| assertNwIsAvailable(c, "test0") |
| // create an overlapping test1 network |
| _, _, err = dockerCmdWithError("network", "create", "--subnet=192.168.128.0/17", "test1") |
| c.Assert(err, check.NotNil) |
| dockerCmd(c, "network", "rm", "test0") |
| } |
