libnetwork_test.go 15 KB

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