libnetwork_test.go 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767
  1. package libnetwork_test
  2. import (
  3. "net"
  4. "os"
  5. "testing"
  6. log "github.com/Sirupsen/logrus"
  7. "github.com/docker/docker/pkg/reexec"
  8. "github.com/docker/libnetwork"
  9. "github.com/docker/libnetwork/netutils"
  10. "github.com/docker/libnetwork/pkg/options"
  11. )
  12. const (
  13. bridgeNetType = "bridge"
  14. bridgeName = "docker0"
  15. )
  16. func TestMain(m *testing.M) {
  17. if reexec.Init() {
  18. return
  19. }
  20. os.Exit(m.Run())
  21. }
  22. func createTestNetwork(networkType, networkName string, option options.Generic) (libnetwork.Network, error) {
  23. controller := libnetwork.New()
  24. genericOption := make(map[string]interface{})
  25. genericOption[options.GenericData] = option
  26. err := controller.ConfigureNetworkDriver(networkType, genericOption)
  27. if err != nil {
  28. return nil, err
  29. }
  30. network, err := controller.NewNetwork(networkType, networkName)
  31. if err != nil {
  32. return nil, err
  33. }
  34. return network, nil
  35. }
  36. func getEmptyGenericOption() map[string]interface{} {
  37. genericOption := make(map[string]interface{})
  38. genericOption[options.GenericData] = options.Generic{}
  39. return genericOption
  40. }
  41. func getPortMapping() []netutils.PortBinding {
  42. return []netutils.PortBinding{
  43. netutils.PortBinding{Proto: netutils.TCP, Port: uint16(230), HostPort: uint16(23000)},
  44. netutils.PortBinding{Proto: netutils.UDP, Port: uint16(200), HostPort: uint16(22000)},
  45. netutils.PortBinding{Proto: netutils.TCP, Port: uint16(120), HostPort: uint16(12000)},
  46. }
  47. }
  48. func TestNull(t *testing.T) {
  49. network, err := createTestNetwork("null", "testnetwork", options.Generic{})
  50. if err != nil {
  51. t.Fatal(err)
  52. }
  53. ep, err := network.CreateEndpoint("testep")
  54. if err != nil {
  55. t.Fatal(err)
  56. }
  57. _, err = ep.Join("null_container",
  58. libnetwork.JoinOptionHostname("test"),
  59. libnetwork.JoinOptionDomainname("docker.io"),
  60. libnetwork.JoinOptionExtraHost("web", "192.168.0.1"))
  61. if err != nil {
  62. t.Fatal(err)
  63. }
  64. err = ep.Leave("null_container")
  65. if err != nil {
  66. t.Fatal(err)
  67. }
  68. if err := ep.Delete(); err != nil {
  69. t.Fatal(err)
  70. }
  71. if err := network.Delete(); err != nil {
  72. t.Fatal(err)
  73. }
  74. }
  75. func TestHost(t *testing.T) {
  76. network, err := createTestNetwork("host", "testnetwork", options.Generic{})
  77. if err != nil {
  78. t.Fatal(err)
  79. }
  80. ep, err := network.CreateEndpoint("testep")
  81. if err != nil {
  82. t.Fatal(err)
  83. }
  84. _, err = ep.Join("host_container",
  85. libnetwork.JoinOptionHostname("test"),
  86. libnetwork.JoinOptionDomainname("docker.io"),
  87. libnetwork.JoinOptionExtraHost("web", "192.168.0.1"),
  88. libnetwork.JoinOptionUseDefaultSandbox())
  89. if err != nil {
  90. t.Fatal(err)
  91. }
  92. err = ep.Leave("host_container")
  93. if err != nil {
  94. t.Fatal(err)
  95. }
  96. if err := ep.Delete(); err != nil {
  97. t.Fatal(err)
  98. }
  99. if err := network.Delete(); err != nil {
  100. t.Fatal(err)
  101. }
  102. }
  103. func TestBridge(t *testing.T) {
  104. defer netutils.SetupTestNetNS(t)()
  105. ip, subnet, err := net.ParseCIDR("192.168.100.1/24")
  106. if err != nil {
  107. t.Fatal(err)
  108. }
  109. subnet.IP = ip
  110. ip, cidr, err := net.ParseCIDR("192.168.100.2/28")
  111. if err != nil {
  112. t.Fatal(err)
  113. }
  114. cidr.IP = ip
  115. ip, cidrv6, err := net.ParseCIDR("fe90::1/96")
  116. if err != nil {
  117. t.Fatal(err)
  118. }
  119. cidrv6.IP = ip
  120. log.Debug("Adding a bridge")
  121. option := options.Generic{
  122. "BridgeName": bridgeName,
  123. "AddressIPv4": subnet,
  124. "FixedCIDR": cidr,
  125. "FixedCIDRv6": cidrv6,
  126. "EnableIPv6": true,
  127. "EnableIPTables": true,
  128. "EnableIPMasquerade": true,
  129. "EnableICC": true,
  130. "EnableIPForwarding": true,
  131. "AllowNonDefaultBridge": true}
  132. network, err := createTestNetwork(bridgeNetType, "testnetwork", option)
  133. if err != nil {
  134. t.Fatal(err)
  135. }
  136. ep, err := network.CreateEndpoint("testep", libnetwork.CreateOptionPortMapping(getPortMapping()))
  137. if err != nil {
  138. t.Fatal(err)
  139. }
  140. epInfo, err := ep.Info()
  141. if err != nil {
  142. t.Fatal(err)
  143. }
  144. pmd, ok := epInfo[options.PortMap]
  145. if !ok {
  146. t.Fatalf("Could not find expected info in endpoint data")
  147. }
  148. pm, ok := pmd.([]netutils.PortBinding)
  149. if !ok {
  150. t.Fatalf("Unexpected format for port mapping in endpoint operational data")
  151. }
  152. if len(pm) != 3 {
  153. t.Fatalf("Incomplete data for port mapping in endpoint operational data: %d", len(pm))
  154. }
  155. if err := ep.Delete(); err != nil {
  156. t.Fatal(err)
  157. }
  158. if err := network.Delete(); err != nil {
  159. t.Fatal(err)
  160. }
  161. }
  162. func TestUnknownDriver(t *testing.T) {
  163. defer netutils.SetupTestNetNS(t)()
  164. _, err := createTestNetwork("unknowndriver", "testnetwork", options.Generic{})
  165. if err == nil {
  166. t.Fatal("Expected to fail. But instead succeeded")
  167. }
  168. if _, ok := err.(libnetwork.NetworkTypeError); !ok {
  169. t.Fatalf("Did not fail with expected error. Actual error: %v", err)
  170. }
  171. }
  172. func TestNilDriver(t *testing.T) {
  173. controller := libnetwork.New()
  174. _, err := controller.NewNetwork("framerelay", "dummy",
  175. libnetwork.NetworkOptionGeneric(getEmptyGenericOption()))
  176. if err == nil {
  177. t.Fatal("Expected to fail. But instead succeeded")
  178. }
  179. if err != libnetwork.ErrInvalidNetworkDriver {
  180. t.Fatalf("Did not fail with expected error. Actual error: %v", err)
  181. }
  182. }
  183. func TestNoInitDriver(t *testing.T) {
  184. controller := libnetwork.New()
  185. _, err := controller.NewNetwork("ppp", "dummy",
  186. libnetwork.NetworkOptionGeneric(getEmptyGenericOption()))
  187. if err == nil {
  188. t.Fatal("Expected to fail. But instead succeeded")
  189. }
  190. if err != libnetwork.ErrInvalidNetworkDriver {
  191. t.Fatalf("Did not fail with expected error. Actual error: %v", err)
  192. }
  193. }
  194. func TestDuplicateNetwork(t *testing.T) {
  195. defer netutils.SetupTestNetNS(t)()
  196. controller := libnetwork.New()
  197. genericOption := make(map[string]interface{})
  198. genericOption[options.GenericData] = options.Generic{}
  199. err := controller.ConfigureNetworkDriver(bridgeNetType, genericOption)
  200. if err != nil {
  201. t.Fatal(err)
  202. }
  203. _, err = controller.NewNetwork(bridgeNetType, "testnetwork", nil)
  204. if err != nil {
  205. t.Fatal(err)
  206. }
  207. _, err = controller.NewNetwork(bridgeNetType, "testnetwork")
  208. if err == nil {
  209. t.Fatal("Expected to fail. But instead succeeded")
  210. }
  211. if _, ok := err.(libnetwork.NetworkNameError); !ok {
  212. t.Fatalf("Did not fail with expected error. Actual error: %v", err)
  213. }
  214. }
  215. func TestNetworkName(t *testing.T) {
  216. defer netutils.SetupTestNetNS(t)()
  217. networkName := "testnetwork"
  218. n, err := createTestNetwork(bridgeNetType, networkName, options.Generic{})
  219. if err != nil {
  220. t.Fatal(err)
  221. }
  222. if n.Name() != networkName {
  223. t.Fatalf("Expected network name %s, got %s", networkName, n.Name())
  224. }
  225. }
  226. func TestNetworkType(t *testing.T) {
  227. defer netutils.SetupTestNetNS(t)()
  228. n, err := createTestNetwork(bridgeNetType, "testnetwork", options.Generic{})
  229. if err != nil {
  230. t.Fatal(err)
  231. }
  232. if n.Type() != bridgeNetType {
  233. t.Fatalf("Expected network type %s, got %s", bridgeNetType, n.Type())
  234. }
  235. }
  236. func TestNetworkID(t *testing.T) {
  237. defer netutils.SetupTestNetNS(t)()
  238. n, err := createTestNetwork(bridgeNetType, "testnetwork", options.Generic{})
  239. if err != nil {
  240. t.Fatal(err)
  241. }
  242. if n.ID() == "" {
  243. t.Fatal("Expected non-empty network id")
  244. }
  245. }
  246. func TestDeleteNetworkWithActiveEndpoints(t *testing.T) {
  247. defer netutils.SetupTestNetNS(t)()
  248. option := options.Generic{
  249. "BridgeName": bridgeName,
  250. "AllowNonDefaultBridge": true}
  251. network, err := createTestNetwork(bridgeNetType, "testnetwork", option)
  252. if err != nil {
  253. t.Fatal(err)
  254. }
  255. ep, err := network.CreateEndpoint("testep")
  256. if err != nil {
  257. t.Fatal(err)
  258. }
  259. err = network.Delete()
  260. if err == nil {
  261. t.Fatal("Expected to fail. But instead succeeded")
  262. }
  263. if _, ok := err.(*libnetwork.ActiveEndpointsError); !ok {
  264. t.Fatalf("Did not fail with expected error. Actual error: %v", err)
  265. }
  266. // Done testing. Now cleanup.
  267. if err := ep.Delete(); err != nil {
  268. t.Fatal(err)
  269. }
  270. if err := network.Delete(); err != nil {
  271. t.Fatal(err)
  272. }
  273. }
  274. func TestUnknownNetwork(t *testing.T) {
  275. defer netutils.SetupTestNetNS(t)()
  276. option := options.Generic{
  277. "BridgeName": bridgeName,
  278. "AllowNonDefaultBridge": true}
  279. network, err := createTestNetwork(bridgeNetType, "testnetwork", option)
  280. if err != nil {
  281. t.Fatal(err)
  282. }
  283. err = network.Delete()
  284. if err != nil {
  285. t.Fatal(err)
  286. }
  287. err = network.Delete()
  288. if err == nil {
  289. t.Fatal("Expected to fail. But instead succeeded")
  290. }
  291. if _, ok := err.(*libnetwork.UnknownNetworkError); !ok {
  292. t.Fatalf("Did not fail with expected error. Actual error: %v", err)
  293. }
  294. }
  295. func TestUnknownEndpoint(t *testing.T) {
  296. defer netutils.SetupTestNetNS(t)()
  297. ip, subnet, err := net.ParseCIDR("192.168.100.1/24")
  298. if err != nil {
  299. t.Fatal(err)
  300. }
  301. subnet.IP = ip
  302. option := options.Generic{
  303. "BridgeName": bridgeName,
  304. "AddressIPv4": subnet,
  305. "AllowNonDefaultBridge": true}
  306. network, err := createTestNetwork(bridgeNetType, "testnetwork", option)
  307. if err != nil {
  308. t.Fatal(err)
  309. }
  310. ep, err := network.CreateEndpoint("testep")
  311. if err != nil {
  312. t.Fatal(err)
  313. }
  314. err = ep.Delete()
  315. if err != nil {
  316. t.Fatal(err)
  317. }
  318. err = ep.Delete()
  319. if err == nil {
  320. t.Fatal("Expected to fail. But instead succeeded")
  321. }
  322. if _, ok := err.(*libnetwork.UnknownEndpointError); !ok {
  323. t.Fatalf("Did not fail with expected error. Actual error: %v", err)
  324. }
  325. // Done testing. Now cleanup
  326. if err := network.Delete(); err != nil {
  327. t.Fatal(err)
  328. }
  329. }
  330. func TestNetworkEndpointsWalkers(t *testing.T) {
  331. defer netutils.SetupTestNetNS(t)()
  332. controller := libnetwork.New()
  333. err := controller.ConfigureNetworkDriver(bridgeNetType, getEmptyGenericOption())
  334. if err != nil {
  335. t.Fatal(err)
  336. }
  337. // Create network 1 and add 2 endpoint: ep11, ep12
  338. net1, err := controller.NewNetwork(bridgeNetType, "network1")
  339. if err != nil {
  340. t.Fatal(err)
  341. }
  342. ep11, err := net1.CreateEndpoint("ep11")
  343. if err != nil {
  344. t.Fatal(err)
  345. }
  346. ep12, err := net1.CreateEndpoint("ep12")
  347. if err != nil {
  348. t.Fatal(err)
  349. }
  350. // Test list methods on net1
  351. epList1 := net1.Endpoints()
  352. if len(epList1) != 2 {
  353. t.Fatalf("Endpoints() returned wrong number of elements: %d instead of 2", len(epList1))
  354. }
  355. // endpoint order is not guaranteed
  356. for _, e := range epList1 {
  357. if e != ep11 && e != ep12 {
  358. t.Fatal("Endpoints() did not return all the expected elements")
  359. }
  360. }
  361. // Test Endpoint Walk method
  362. var epName string
  363. var epWanted libnetwork.Endpoint
  364. wlk := func(ep libnetwork.Endpoint) bool {
  365. if ep.Name() == epName {
  366. epWanted = ep
  367. return true
  368. }
  369. return false
  370. }
  371. // Look for ep1 on network1
  372. epName = "ep11"
  373. net1.WalkEndpoints(wlk)
  374. if epWanted == nil {
  375. t.Fatal(err)
  376. }
  377. if ep11 != epWanted {
  378. t.Fatal(err)
  379. }
  380. // Test Network Walk method
  381. var netName string
  382. var netWanted libnetwork.Network
  383. nwWlk := func(nw libnetwork.Network) bool {
  384. if nw.Name() == netName {
  385. netWanted = nw
  386. return true
  387. }
  388. return false
  389. }
  390. // Look for network named "network1"
  391. netName = "network1"
  392. controller.WalkNetworks(nwWlk)
  393. if netWanted == nil {
  394. t.Fatal(err)
  395. }
  396. if net1 != netWanted {
  397. t.Fatal(err)
  398. }
  399. }
  400. func TestControllerQuery(t *testing.T) {
  401. defer netutils.SetupTestNetNS(t)()
  402. controller := libnetwork.New()
  403. err := controller.ConfigureNetworkDriver(bridgeNetType, getEmptyGenericOption())
  404. if err != nil {
  405. t.Fatal(err)
  406. }
  407. // Create network 1
  408. net1, err := controller.NewNetwork(bridgeNetType, "network1")
  409. if err != nil {
  410. t.Fatal(err)
  411. }
  412. g := controller.NetworkByName("")
  413. if g != nil {
  414. t.Fatalf("NetworkByName() succeeded with invalid target name")
  415. }
  416. g = controller.NetworkByID("")
  417. if g != nil {
  418. t.Fatalf("NetworkByID() succeeded with invalid target id: %v", g)
  419. }
  420. g = controller.NetworkByID("network1")
  421. if g != nil {
  422. t.Fatalf("NetworkByID() succeeded with invalid target name")
  423. }
  424. g = controller.NetworkByName("network1")
  425. if g == nil {
  426. t.Fatalf("NetworkByName() did not find the network")
  427. }
  428. if g != net1 {
  429. t.Fatalf("NetworkByName() returned the wrong network")
  430. }
  431. g = controller.NetworkByID(net1.ID())
  432. if net1 != g {
  433. t.Fatalf("NetworkByID() returned unexpected element: %v", g)
  434. }
  435. }
  436. func TestNetworkQuery(t *testing.T) {
  437. defer netutils.SetupTestNetNS(t)()
  438. controller := libnetwork.New()
  439. err := controller.ConfigureNetworkDriver(bridgeNetType, getEmptyGenericOption())
  440. if err != nil {
  441. t.Fatal(err)
  442. }
  443. // Create network 1 and add 2 endpoint: ep11, ep12
  444. net1, err := controller.NewNetwork(bridgeNetType, "network1")
  445. if err != nil {
  446. t.Fatal(err)
  447. }
  448. ep11, err := net1.CreateEndpoint("ep11")
  449. if err != nil {
  450. t.Fatal(err)
  451. }
  452. ep12, err := net1.CreateEndpoint("ep12")
  453. if err != nil {
  454. t.Fatal(err)
  455. }
  456. e := net1.EndpointByName("ep11")
  457. if ep11 != e {
  458. t.Fatalf("EndpointByName() returned %v instead of %v", e, ep11)
  459. }
  460. e = net1.EndpointByName("")
  461. if e != nil {
  462. t.Fatalf("EndpointByName(): expected nil, got %v", e)
  463. }
  464. e = net1.EndpointByName("IamNotAnEndpoint")
  465. if e != nil {
  466. t.Fatalf("EndpointByName(): expected nil, got %v", e)
  467. }
  468. e = net1.EndpointByID(ep12.ID())
  469. if ep12 != e {
  470. t.Fatalf("EndpointByID() returned %v instead of %v", e, ep12)
  471. }
  472. e = net1.EndpointByID("")
  473. if e != nil {
  474. t.Fatalf("EndpointByID(): expected nil, got %v", e)
  475. }
  476. }
  477. const containerID = "valid_container"
  478. func TestEndpointJoin(t *testing.T) {
  479. defer netutils.SetupTestNetNS(t)()
  480. n, err := createTestNetwork(bridgeNetType, "testnetwork", options.Generic{})
  481. if err != nil {
  482. t.Fatal(err)
  483. }
  484. ep, err := n.CreateEndpoint("ep1")
  485. if err != nil {
  486. t.Fatal(err)
  487. }
  488. _, err = ep.Join(containerID,
  489. libnetwork.JoinOptionHostname("test"),
  490. libnetwork.JoinOptionDomainname("docker.io"),
  491. libnetwork.JoinOptionExtraHost("web", "192.168.0.1"))
  492. if err != nil {
  493. t.Fatal(err)
  494. }
  495. err = ep.Leave(containerID)
  496. if err != nil {
  497. t.Fatal(err)
  498. }
  499. }
  500. func TestEndpointJoinInvalidContainerId(t *testing.T) {
  501. defer netutils.SetupTestNetNS(t)()
  502. n, err := createTestNetwork(bridgeNetType, "testnetwork", options.Generic{})
  503. if err != nil {
  504. t.Fatal(err)
  505. }
  506. ep, err := n.CreateEndpoint("ep1")
  507. if err != nil {
  508. t.Fatal(err)
  509. }
  510. _, err = ep.Join("")
  511. if err == nil {
  512. t.Fatal("Expected to fail join with empty container id string")
  513. }
  514. if _, ok := err.(libnetwork.InvalidContainerIDError); !ok {
  515. t.Fatalf("Failed for unexpected reason: %v", err)
  516. }
  517. }
  518. func TestEndpointMultipleJoins(t *testing.T) {
  519. defer netutils.SetupTestNetNS(t)()
  520. n, err := createTestNetwork(bridgeNetType, "testnetwork", options.Generic{})
  521. if err != nil {
  522. t.Fatal(err)
  523. }
  524. ep, err := n.CreateEndpoint("ep1")
  525. if err != nil {
  526. t.Fatal(err)
  527. }
  528. _, err = ep.Join(containerID,
  529. libnetwork.JoinOptionHostname("test"),
  530. libnetwork.JoinOptionDomainname("docker.io"),
  531. libnetwork.JoinOptionExtraHost("web", "192.168.0.1"))
  532. if err != nil {
  533. t.Fatal(err)
  534. }
  535. _, err = ep.Join("container2")
  536. if err == nil {
  537. t.Fatal("Expected to fail multiple joins for the same endpoint")
  538. }
  539. if err != libnetwork.ErrInvalidJoin {
  540. t.Fatalf("Failed for unexpected reason: %v", err)
  541. }
  542. err = ep.Leave(containerID)
  543. if err != nil {
  544. t.Fatal(err)
  545. }
  546. }
  547. func TestEndpointInvalidLeave(t *testing.T) {
  548. defer netutils.SetupTestNetNS(t)()
  549. n, err := createTestNetwork(bridgeNetType, "testnetwork", options.Generic{})
  550. if err != nil {
  551. t.Fatal(err)
  552. }
  553. ep, err := n.CreateEndpoint("ep1")
  554. if err != nil {
  555. t.Fatal(err)
  556. }
  557. err = ep.Leave(containerID)
  558. if err == nil {
  559. t.Fatal("Expected to fail leave from an endpoint which has no active join")
  560. }
  561. if _, ok := err.(libnetwork.InvalidContainerIDError); !ok {
  562. t.Fatalf("Failed for unexpected reason: %v", err)
  563. }
  564. _, err = ep.Join(containerID,
  565. libnetwork.JoinOptionHostname("test"),
  566. libnetwork.JoinOptionDomainname("docker.io"),
  567. libnetwork.JoinOptionExtraHost("web", "192.168.0.1"))
  568. if err != nil {
  569. t.Fatal(err)
  570. }
  571. err = ep.Leave("")
  572. if err == nil {
  573. t.Fatal("Expected to fail leave with empty container id")
  574. }
  575. if _, ok := err.(libnetwork.InvalidContainerIDError); !ok {
  576. t.Fatalf("Failed for unexpected reason: %v", err)
  577. }
  578. err = ep.Leave("container2")
  579. if err == nil {
  580. t.Fatal("Expected to fail leave with wrong container id")
  581. }
  582. if _, ok := err.(libnetwork.InvalidContainerIDError); !ok {
  583. t.Fatalf("Failed for unexpected reason: %v", err)
  584. }
  585. err = ep.Leave(containerID)
  586. if err != nil {
  587. t.Fatal(err)
  588. }
  589. }
  590. func TestEndpointUpdateParent(t *testing.T) {
  591. defer netutils.SetupTestNetNS(t)()
  592. n, err := createTestNetwork("bridge", "testnetwork", options.Generic{})
  593. if err != nil {
  594. t.Fatal(err)
  595. }
  596. ep1, err := n.CreateEndpoint("ep1", nil)
  597. if err != nil {
  598. t.Fatal(err)
  599. }
  600. _, err = ep1.Join(containerID,
  601. libnetwork.JoinOptionHostname("test1"),
  602. libnetwork.JoinOptionDomainname("docker.io"),
  603. libnetwork.JoinOptionExtraHost("web", "192.168.0.1"))
  604. if err != nil {
  605. t.Fatal(err)
  606. }
  607. ep2, err := n.CreateEndpoint("ep2", nil)
  608. if err != nil {
  609. t.Fatal(err)
  610. }
  611. _, err = ep2.Join("container2",
  612. libnetwork.JoinOptionHostname("test2"),
  613. libnetwork.JoinOptionDomainname("docker.io"),
  614. libnetwork.JoinOptionHostsPath("/var/lib/docker/test_network/container2/hosts"),
  615. libnetwork.JoinOptionParentUpdate(ep1.ID(), "web", "192.168.0.2"))
  616. if err != nil {
  617. t.Fatal(err)
  618. }
  619. err = ep2.Leave("container2")
  620. if err != nil {
  621. t.Fatal(err)
  622. }
  623. err = ep1.Leave(containerID)
  624. if err != nil {
  625. t.Fatal(err)
  626. }
  627. }