docker_cli_network_unix_test.go 49 KB

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