libnetwork_linux_test.go 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005
  1. package libnetwork_test
  2. import (
  3. "bytes"
  4. "encoding/json"
  5. "flag"
  6. "fmt"
  7. "io/ioutil"
  8. "net"
  9. "os"
  10. "os/exec"
  11. "runtime"
  12. "strconv"
  13. "strings"
  14. "testing"
  15. "github.com/Sirupsen/logrus"
  16. "github.com/docker/docker/pkg/reexec"
  17. "github.com/docker/libnetwork"
  18. "github.com/docker/libnetwork/ipamapi"
  19. "github.com/docker/libnetwork/netlabel"
  20. "github.com/docker/libnetwork/options"
  21. "github.com/docker/libnetwork/osl"
  22. "github.com/docker/libnetwork/testutils"
  23. "github.com/docker/libnetwork/types"
  24. "github.com/opencontainers/runc/libcontainer"
  25. "github.com/opencontainers/runc/libcontainer/configs"
  26. "github.com/vishvananda/netlink"
  27. "github.com/vishvananda/netns"
  28. )
  29. func TestHost(t *testing.T) {
  30. sbx1, err := controller.NewSandbox("host_c1",
  31. libnetwork.OptionHostname("test1"),
  32. libnetwork.OptionDomainname("docker.io"),
  33. libnetwork.OptionExtraHost("web", "192.168.0.1"),
  34. libnetwork.OptionUseDefaultSandbox())
  35. if err != nil {
  36. t.Fatal(err)
  37. }
  38. defer func() {
  39. if err := sbx1.Delete(); err != nil {
  40. t.Fatal(err)
  41. }
  42. }()
  43. sbx2, err := controller.NewSandbox("host_c2",
  44. libnetwork.OptionHostname("test2"),
  45. libnetwork.OptionDomainname("docker.io"),
  46. libnetwork.OptionExtraHost("web", "192.168.0.1"),
  47. libnetwork.OptionUseDefaultSandbox())
  48. if err != nil {
  49. t.Fatal(err)
  50. }
  51. defer func() {
  52. if err := sbx2.Delete(); err != nil {
  53. t.Fatal(err)
  54. }
  55. }()
  56. network, err := createTestNetwork("host", "testhost", options.Generic{}, nil, nil)
  57. if err != nil {
  58. t.Fatal(err)
  59. }
  60. ep1, err := network.CreateEndpoint("testep1")
  61. if err != nil {
  62. t.Fatal(err)
  63. }
  64. if err := ep1.Join(sbx1); err != nil {
  65. t.Fatal(err)
  66. }
  67. ep2, err := network.CreateEndpoint("testep2")
  68. if err != nil {
  69. t.Fatal(err)
  70. }
  71. if err := ep2.Join(sbx2); err != nil {
  72. t.Fatal(err)
  73. }
  74. if err := ep1.Leave(sbx1); err != nil {
  75. t.Fatal(err)
  76. }
  77. if err := ep2.Leave(sbx2); err != nil {
  78. t.Fatal(err)
  79. }
  80. if err := ep1.Delete(false); err != nil {
  81. t.Fatal(err)
  82. }
  83. if err := ep2.Delete(false); err != nil {
  84. t.Fatal(err)
  85. }
  86. // Try to create another host endpoint and join/leave that.
  87. cnt3, err := controller.NewSandbox("host_c3",
  88. libnetwork.OptionHostname("test3"),
  89. libnetwork.OptionDomainname("docker.io"),
  90. libnetwork.OptionExtraHost("web", "192.168.0.1"),
  91. libnetwork.OptionUseDefaultSandbox())
  92. if err != nil {
  93. t.Fatal(err)
  94. }
  95. defer func() {
  96. if err := cnt3.Delete(); err != nil {
  97. t.Fatal(err)
  98. }
  99. }()
  100. ep3, err := network.CreateEndpoint("testep3")
  101. if err != nil {
  102. t.Fatal(err)
  103. }
  104. if err := ep3.Join(sbx2); err != nil {
  105. t.Fatal(err)
  106. }
  107. if err := ep3.Leave(sbx2); err != nil {
  108. t.Fatal(err)
  109. }
  110. if err := ep3.Delete(false); err != nil {
  111. t.Fatal(err)
  112. }
  113. }
  114. // Testing IPV6 from MAC address
  115. func TestBridgeIpv6FromMac(t *testing.T) {
  116. if !testutils.IsRunningInContainer() {
  117. defer testutils.SetupTestOSContext(t)()
  118. }
  119. netOption := options.Generic{
  120. netlabel.GenericData: options.Generic{
  121. "BridgeName": "testipv6mac",
  122. "EnableICC": true,
  123. "EnableIPMasquerade": true,
  124. },
  125. }
  126. ipamV4ConfList := []*libnetwork.IpamConf{{PreferredPool: "192.168.100.0/24", Gateway: "192.168.100.1"}}
  127. ipamV6ConfList := []*libnetwork.IpamConf{{PreferredPool: "fe90::/64", Gateway: "fe90::22"}}
  128. network, err := controller.NewNetwork(bridgeNetType, "testipv6mac", "",
  129. libnetwork.NetworkOptionGeneric(netOption),
  130. libnetwork.NetworkOptionEnableIPv6(true),
  131. libnetwork.NetworkOptionIpam(ipamapi.DefaultIPAM, "", ipamV4ConfList, ipamV6ConfList, nil),
  132. libnetwork.NetworkOptionDeferIPv6Alloc(true))
  133. if err != nil {
  134. t.Fatal(err)
  135. }
  136. mac := net.HardwareAddr{0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff}
  137. epOption := options.Generic{netlabel.MacAddress: mac}
  138. ep, err := network.CreateEndpoint("testep", libnetwork.EndpointOptionGeneric(epOption))
  139. if err != nil {
  140. t.Fatal(err)
  141. }
  142. iface := ep.Info().Iface()
  143. if !bytes.Equal(iface.MacAddress(), mac) {
  144. t.Fatalf("Unexpected mac address: %v", iface.MacAddress())
  145. }
  146. ip, expIP, _ := net.ParseCIDR("fe90::aabb:ccdd:eeff/64")
  147. expIP.IP = ip
  148. if !types.CompareIPNet(expIP, iface.AddressIPv6()) {
  149. t.Fatalf("Expected %v. Got: %v", expIP, iface.AddressIPv6())
  150. }
  151. if err := ep.Delete(false); err != nil {
  152. t.Fatal(err)
  153. }
  154. if err := network.Delete(); err != nil {
  155. t.Fatal(err)
  156. }
  157. }
  158. func checkSandbox(t *testing.T, info libnetwork.EndpointInfo) {
  159. key := info.Sandbox().Key()
  160. sbNs, err := netns.GetFromPath(key)
  161. if err != nil {
  162. t.Fatalf("Failed to get network namespace path %q: %v", key, err)
  163. }
  164. defer sbNs.Close()
  165. nh, err := netlink.NewHandleAt(sbNs)
  166. if err != nil {
  167. t.Fatal(err)
  168. }
  169. _, err = nh.LinkByName("eth0")
  170. if err != nil {
  171. t.Fatalf("Could not find the interface eth0 inside the sandbox: %v", err)
  172. }
  173. _, err = nh.LinkByName("eth1")
  174. if err != nil {
  175. t.Fatalf("Could not find the interface eth1 inside the sandbox: %v", err)
  176. }
  177. }
  178. func TestEndpointJoin(t *testing.T) {
  179. if !testutils.IsRunningInContainer() {
  180. defer testutils.SetupTestOSContext(t)()
  181. }
  182. // Create network 1 and add 2 endpoint: ep11, ep12
  183. netOption := options.Generic{
  184. netlabel.GenericData: options.Generic{
  185. "BridgeName": "testnetwork1",
  186. "EnableICC": true,
  187. "EnableIPMasquerade": true,
  188. },
  189. }
  190. ipamV6ConfList := []*libnetwork.IpamConf{{PreferredPool: "fe90::/64", Gateway: "fe90::22"}}
  191. n1, err := controller.NewNetwork(bridgeNetType, "testnetwork1", "",
  192. libnetwork.NetworkOptionGeneric(netOption),
  193. libnetwork.NetworkOptionEnableIPv6(true),
  194. libnetwork.NetworkOptionIpam(ipamapi.DefaultIPAM, "", nil, ipamV6ConfList, nil),
  195. libnetwork.NetworkOptionDeferIPv6Alloc(true))
  196. if err != nil {
  197. t.Fatal(err)
  198. }
  199. defer func() {
  200. if err := n1.Delete(); err != nil {
  201. t.Fatal(err)
  202. }
  203. }()
  204. ep1, err := n1.CreateEndpoint("ep1")
  205. if err != nil {
  206. t.Fatal(err)
  207. }
  208. defer func() {
  209. if err := ep1.Delete(false); err != nil {
  210. t.Fatal(err)
  211. }
  212. }()
  213. // Validate if ep.Info() only gives me IP address info and not names and gateway during CreateEndpoint()
  214. info := ep1.Info()
  215. iface := info.Iface()
  216. if iface.Address() != nil && iface.Address().IP.To4() == nil {
  217. t.Fatalf("Invalid IP address returned: %v", iface.Address())
  218. }
  219. if iface.AddressIPv6() != nil && iface.AddressIPv6().IP == nil {
  220. t.Fatalf("Invalid IPv6 address returned: %v", iface.Address())
  221. }
  222. if len(info.Gateway()) != 0 {
  223. t.Fatalf("Expected empty gateway for an empty endpoint. Instead found a gateway: %v", info.Gateway())
  224. }
  225. if len(info.GatewayIPv6()) != 0 {
  226. t.Fatalf("Expected empty gateway for an empty ipv6 endpoint. Instead found a gateway: %v", info.GatewayIPv6())
  227. }
  228. if info.Sandbox() != nil {
  229. t.Fatalf("Expected an empty sandbox key for an empty endpoint. Instead found a non-empty sandbox key: %s", info.Sandbox().Key())
  230. }
  231. // test invalid joins
  232. err = ep1.Join(nil)
  233. if err == nil {
  234. t.Fatalf("Expected to fail join with nil Sandbox")
  235. }
  236. if _, ok := err.(types.BadRequestError); !ok {
  237. t.Fatalf("Unexpected error type returned: %T", err)
  238. }
  239. fsbx := &fakeSandbox{}
  240. if err = ep1.Join(fsbx); err == nil {
  241. t.Fatalf("Expected to fail join with invalid Sandbox")
  242. }
  243. if _, ok := err.(types.BadRequestError); !ok {
  244. t.Fatalf("Unexpected error type returned: %T", err)
  245. }
  246. sb, err := controller.NewSandbox(containerID,
  247. libnetwork.OptionHostname("test"),
  248. libnetwork.OptionDomainname("docker.io"),
  249. libnetwork.OptionExtraHost("web", "192.168.0.1"))
  250. if err != nil {
  251. t.Fatal(err)
  252. }
  253. defer func() {
  254. if err := sb.Delete(); err != nil {
  255. t.Fatal(err)
  256. }
  257. }()
  258. err = ep1.Join(sb)
  259. if err != nil {
  260. t.Fatal(err)
  261. }
  262. defer func() {
  263. err = ep1.Leave(sb)
  264. if err != nil {
  265. t.Fatal(err)
  266. }
  267. }()
  268. // Validate if ep.Info() only gives valid gateway and sandbox key after has container has joined.
  269. info = ep1.Info()
  270. if len(info.Gateway()) == 0 {
  271. t.Fatalf("Expected a valid gateway for a joined endpoint. Instead found an invalid gateway: %v", info.Gateway())
  272. }
  273. if len(info.GatewayIPv6()) == 0 {
  274. t.Fatalf("Expected a valid ipv6 gateway for a joined endpoint. Instead found an invalid gateway: %v", info.GatewayIPv6())
  275. }
  276. if info.Sandbox() == nil {
  277. t.Fatalf("Expected an non-empty sandbox key for a joined endpoint. Instead found an empty sandbox key")
  278. }
  279. // Check endpoint provided container information
  280. if ep1.Info().Sandbox().Key() != sb.Key() {
  281. t.Fatalf("Endpoint Info returned unexpected sandbox key: %s", sb.Key())
  282. }
  283. // Attempt retrieval of endpoint interfaces statistics
  284. stats, err := sb.Statistics()
  285. if err != nil {
  286. t.Fatal(err)
  287. }
  288. if _, ok := stats["eth0"]; !ok {
  289. t.Fatalf("Did not find eth0 statistics")
  290. }
  291. // Now test the container joining another network
  292. n2, err := createTestNetwork(bridgeNetType, "testnetwork2",
  293. options.Generic{
  294. netlabel.GenericData: options.Generic{
  295. "BridgeName": "testnetwork2",
  296. },
  297. }, nil, nil)
  298. if err != nil {
  299. t.Fatal(err)
  300. }
  301. defer func() {
  302. if err := n2.Delete(); err != nil {
  303. t.Fatal(err)
  304. }
  305. }()
  306. ep2, err := n2.CreateEndpoint("ep2")
  307. if err != nil {
  308. t.Fatal(err)
  309. }
  310. defer func() {
  311. if err := ep2.Delete(false); err != nil {
  312. t.Fatal(err)
  313. }
  314. }()
  315. err = ep2.Join(sb)
  316. if err != nil {
  317. t.Fatal(err)
  318. }
  319. defer func() {
  320. err = ep2.Leave(sb)
  321. if err != nil {
  322. t.Fatal(err)
  323. }
  324. }()
  325. if ep1.Info().Sandbox().Key() != ep2.Info().Sandbox().Key() {
  326. t.Fatalf("ep1 and ep2 returned different container sandbox key")
  327. }
  328. checkSandbox(t, info)
  329. }
  330. func TestExternalKey(t *testing.T) {
  331. externalKeyTest(t, false)
  332. }
  333. func externalKeyTest(t *testing.T, reexec bool) {
  334. if !testutils.IsRunningInContainer() {
  335. defer testutils.SetupTestOSContext(t)()
  336. }
  337. n, err := createTestNetwork(bridgeNetType, "testnetwork", options.Generic{
  338. netlabel.GenericData: options.Generic{
  339. "BridgeName": "testnetwork",
  340. },
  341. }, nil, nil)
  342. if err != nil {
  343. t.Fatal(err)
  344. }
  345. defer func() {
  346. if err := n.Delete(); err != nil {
  347. t.Fatal(err)
  348. }
  349. }()
  350. n2, err := createTestNetwork(bridgeNetType, "testnetwork2", options.Generic{
  351. netlabel.GenericData: options.Generic{
  352. "BridgeName": "testnetwork2",
  353. },
  354. }, nil, nil)
  355. if err != nil {
  356. t.Fatal(err)
  357. }
  358. defer func() {
  359. if err := n2.Delete(); err != nil {
  360. t.Fatal(err)
  361. }
  362. }()
  363. ep, err := n.CreateEndpoint("ep1")
  364. if err != nil {
  365. t.Fatal(err)
  366. }
  367. defer func() {
  368. err = ep.Delete(false)
  369. if err != nil {
  370. t.Fatal(err)
  371. }
  372. }()
  373. ep2, err := n2.CreateEndpoint("ep2")
  374. if err != nil {
  375. t.Fatal(err)
  376. }
  377. defer func() {
  378. err = ep2.Delete(false)
  379. if err != nil {
  380. t.Fatal(err)
  381. }
  382. }()
  383. cnt, err := controller.NewSandbox(containerID,
  384. libnetwork.OptionHostname("test"),
  385. libnetwork.OptionDomainname("docker.io"),
  386. libnetwork.OptionUseExternalKey(),
  387. libnetwork.OptionExtraHost("web", "192.168.0.1"))
  388. defer func() {
  389. if err := cnt.Delete(); err != nil {
  390. t.Fatal(err)
  391. }
  392. osl.GC()
  393. }()
  394. // Join endpoint to sandbox before SetKey
  395. err = ep.Join(cnt)
  396. if err != nil {
  397. t.Fatal(err)
  398. }
  399. defer func() {
  400. err = ep.Leave(cnt)
  401. if err != nil {
  402. t.Fatal(err)
  403. }
  404. }()
  405. sbox := ep.Info().Sandbox()
  406. if sbox == nil {
  407. t.Fatalf("Expected to have a valid Sandbox")
  408. }
  409. if reexec {
  410. err := reexecSetKey("this-must-fail", containerID, controller.ID())
  411. if err == nil {
  412. t.Fatalf("SetExternalKey must fail if the corresponding namespace is not created")
  413. }
  414. } else {
  415. // Setting an non-existing key (namespace) must fail
  416. if err := sbox.SetKey("this-must-fail"); err == nil {
  417. t.Fatalf("Setkey must fail if the corresponding namespace is not created")
  418. }
  419. }
  420. // Create a new OS sandbox using the osl API before using it in SetKey
  421. if extOsBox, err := osl.NewSandbox("ValidKey", true, false); err != nil {
  422. t.Fatalf("Failed to create new osl sandbox")
  423. } else {
  424. defer func() {
  425. if err := extOsBox.Destroy(); err != nil {
  426. logrus.Warnf("Failed to remove os sandbox: %v", err)
  427. }
  428. }()
  429. }
  430. if reexec {
  431. err := reexecSetKey("ValidKey", containerID, controller.ID())
  432. if err != nil {
  433. t.Fatalf("SetExternalKey failed with %v", err)
  434. }
  435. } else {
  436. if err := sbox.SetKey("ValidKey"); err != nil {
  437. t.Fatalf("Setkey failed with %v", err)
  438. }
  439. }
  440. // Join endpoint to sandbox after SetKey
  441. err = ep2.Join(sbox)
  442. if err != nil {
  443. t.Fatal(err)
  444. }
  445. defer func() {
  446. err = ep2.Leave(sbox)
  447. if err != nil {
  448. t.Fatal(err)
  449. }
  450. }()
  451. if ep.Info().Sandbox().Key() != ep2.Info().Sandbox().Key() {
  452. t.Fatalf("ep1 and ep2 returned different container sandbox key")
  453. }
  454. checkSandbox(t, ep.Info())
  455. }
  456. func reexecSetKey(key string, containerID string, controllerID string) error {
  457. var (
  458. state libcontainer.State
  459. b []byte
  460. err error
  461. )
  462. state.NamespacePaths = make(map[configs.NamespaceType]string)
  463. state.NamespacePaths[configs.NamespaceType("NEWNET")] = key
  464. if b, err = json.Marshal(state); err != nil {
  465. return err
  466. }
  467. cmd := &exec.Cmd{
  468. Path: reexec.Self(),
  469. Args: append([]string{"libnetwork-setkey"}, containerID, controllerID),
  470. Stdin: strings.NewReader(string(b)),
  471. Stdout: os.Stdout,
  472. Stderr: os.Stderr,
  473. }
  474. return cmd.Run()
  475. }
  476. func TestEnableIPv6(t *testing.T) {
  477. if !testutils.IsRunningInContainer() {
  478. defer testutils.SetupTestOSContext(t)()
  479. }
  480. tmpResolvConf := []byte("search pommesfrites.fr\nnameserver 12.34.56.78\nnameserver 2001:4860:4860::8888\n")
  481. expectedResolvConf := []byte("search pommesfrites.fr\nnameserver 127.0.0.11\nnameserver 2001:4860:4860::8888\noptions ndots:0\n")
  482. //take a copy of resolv.conf for restoring after test completes
  483. resolvConfSystem, err := ioutil.ReadFile("/etc/resolv.conf")
  484. if err != nil {
  485. t.Fatal(err)
  486. }
  487. //cleanup
  488. defer func() {
  489. if err := ioutil.WriteFile("/etc/resolv.conf", resolvConfSystem, 0644); err != nil {
  490. t.Fatal(err)
  491. }
  492. }()
  493. netOption := options.Generic{
  494. netlabel.EnableIPv6: true,
  495. netlabel.GenericData: options.Generic{
  496. "BridgeName": "testnetwork",
  497. },
  498. }
  499. ipamV6ConfList := []*libnetwork.IpamConf{{PreferredPool: "fe99::/64", Gateway: "fe99::9"}}
  500. n, err := createTestNetwork("bridge", "testnetwork", netOption, nil, ipamV6ConfList)
  501. if err != nil {
  502. t.Fatal(err)
  503. }
  504. defer func() {
  505. if err := n.Delete(); err != nil {
  506. t.Fatal(err)
  507. }
  508. }()
  509. ep1, err := n.CreateEndpoint("ep1")
  510. if err != nil {
  511. t.Fatal(err)
  512. }
  513. if err := ioutil.WriteFile("/etc/resolv.conf", tmpResolvConf, 0644); err != nil {
  514. t.Fatal(err)
  515. }
  516. resolvConfPath := "/tmp/libnetwork_test/resolv.conf"
  517. defer os.Remove(resolvConfPath)
  518. sb, err := controller.NewSandbox(containerID, libnetwork.OptionResolvConfPath(resolvConfPath))
  519. if err != nil {
  520. t.Fatal(err)
  521. }
  522. defer func() {
  523. if err := sb.Delete(); err != nil {
  524. t.Fatal(err)
  525. }
  526. }()
  527. err = ep1.Join(sb)
  528. if err != nil {
  529. t.Fatal(err)
  530. }
  531. content, err := ioutil.ReadFile(resolvConfPath)
  532. if err != nil {
  533. t.Fatal(err)
  534. }
  535. if !bytes.Equal(content, expectedResolvConf) {
  536. t.Fatalf("Expected:\n%s\nGot:\n%s", string(expectedResolvConf), string(content))
  537. }
  538. if err != nil {
  539. t.Fatal(err)
  540. }
  541. }
  542. func TestResolvConfHost(t *testing.T) {
  543. if !testutils.IsRunningInContainer() {
  544. defer testutils.SetupTestOSContext(t)()
  545. }
  546. tmpResolvConf := []byte("search localhost.net\nnameserver 127.0.0.1\nnameserver 2001:4860:4860::8888\n")
  547. //take a copy of resolv.conf for restoring after test completes
  548. resolvConfSystem, err := ioutil.ReadFile("/etc/resolv.conf")
  549. if err != nil {
  550. t.Fatal(err)
  551. }
  552. //cleanup
  553. defer func() {
  554. if err := ioutil.WriteFile("/etc/resolv.conf", resolvConfSystem, 0644); err != nil {
  555. t.Fatal(err)
  556. }
  557. }()
  558. n, err := controller.NetworkByName("testhost")
  559. if err != nil {
  560. t.Fatal(err)
  561. }
  562. ep1, err := n.CreateEndpoint("ep1", libnetwork.CreateOptionDisableResolution())
  563. if err != nil {
  564. t.Fatal(err)
  565. }
  566. if err := ioutil.WriteFile("/etc/resolv.conf", tmpResolvConf, 0644); err != nil {
  567. t.Fatal(err)
  568. }
  569. resolvConfPath := "/tmp/libnetwork_test/resolv.conf"
  570. defer os.Remove(resolvConfPath)
  571. sb, err := controller.NewSandbox(containerID,
  572. libnetwork.OptionResolvConfPath(resolvConfPath),
  573. libnetwork.OptionOriginResolvConfPath("/etc/resolv.conf"))
  574. if err != nil {
  575. t.Fatal(err)
  576. }
  577. defer func() {
  578. if err := sb.Delete(); err != nil {
  579. t.Fatal(err)
  580. }
  581. }()
  582. err = ep1.Join(sb)
  583. if err != nil {
  584. t.Fatal(err)
  585. }
  586. defer func() {
  587. err = ep1.Leave(sb)
  588. if err != nil {
  589. t.Fatal(err)
  590. }
  591. }()
  592. finfo, err := os.Stat(resolvConfPath)
  593. if err != nil {
  594. t.Fatal(err)
  595. }
  596. fmode := (os.FileMode)(0644)
  597. if finfo.Mode() != fmode {
  598. t.Fatalf("Expected file mode %s, got %s", fmode.String(), finfo.Mode().String())
  599. }
  600. content, err := ioutil.ReadFile(resolvConfPath)
  601. if err != nil {
  602. t.Fatal(err)
  603. }
  604. if !bytes.Equal(content, tmpResolvConf) {
  605. t.Fatalf("Expected:\n%s\nGot:\n%s", string(tmpResolvConf), string(content))
  606. }
  607. }
  608. func TestResolvConf(t *testing.T) {
  609. if !testutils.IsRunningInContainer() {
  610. defer testutils.SetupTestOSContext(t)()
  611. }
  612. tmpResolvConf1 := []byte("search pommesfrites.fr\nnameserver 12.34.56.78\nnameserver 2001:4860:4860::8888\n")
  613. tmpResolvConf2 := []byte("search pommesfrites.fr\nnameserver 112.34.56.78\nnameserver 2001:4860:4860::8888\n")
  614. expectedResolvConf1 := []byte("search pommesfrites.fr\nnameserver 127.0.0.11\noptions ndots:0\n")
  615. tmpResolvConf3 := []byte("search pommesfrites.fr\nnameserver 113.34.56.78\n")
  616. //take a copy of resolv.conf for restoring after test completes
  617. resolvConfSystem, err := ioutil.ReadFile("/etc/resolv.conf")
  618. if err != nil {
  619. t.Fatal(err)
  620. }
  621. //cleanup
  622. defer func() {
  623. if err := ioutil.WriteFile("/etc/resolv.conf", resolvConfSystem, 0644); err != nil {
  624. t.Fatal(err)
  625. }
  626. }()
  627. netOption := options.Generic{
  628. netlabel.GenericData: options.Generic{
  629. "BridgeName": "testnetwork",
  630. },
  631. }
  632. n, err := createTestNetwork("bridge", "testnetwork", netOption, nil, nil)
  633. if err != nil {
  634. t.Fatal(err)
  635. }
  636. defer func() {
  637. if err := n.Delete(); err != nil {
  638. t.Fatal(err)
  639. }
  640. }()
  641. ep, err := n.CreateEndpoint("ep")
  642. if err != nil {
  643. t.Fatal(err)
  644. }
  645. if err := ioutil.WriteFile("/etc/resolv.conf", tmpResolvConf1, 0644); err != nil {
  646. t.Fatal(err)
  647. }
  648. resolvConfPath := "/tmp/libnetwork_test/resolv.conf"
  649. defer os.Remove(resolvConfPath)
  650. sb1, err := controller.NewSandbox(containerID, libnetwork.OptionResolvConfPath(resolvConfPath))
  651. if err != nil {
  652. t.Fatal(err)
  653. }
  654. defer func() {
  655. if err := sb1.Delete(); err != nil {
  656. t.Fatal(err)
  657. }
  658. }()
  659. err = ep.Join(sb1)
  660. if err != nil {
  661. t.Fatal(err)
  662. }
  663. finfo, err := os.Stat(resolvConfPath)
  664. if err != nil {
  665. t.Fatal(err)
  666. }
  667. fmode := (os.FileMode)(0644)
  668. if finfo.Mode() != fmode {
  669. t.Fatalf("Expected file mode %s, got %s", fmode.String(), finfo.Mode().String())
  670. }
  671. content, err := ioutil.ReadFile(resolvConfPath)
  672. if err != nil {
  673. t.Fatal(err)
  674. }
  675. if !bytes.Equal(content, expectedResolvConf1) {
  676. fmt.Printf("\n%v\n%v\n", expectedResolvConf1, content)
  677. t.Fatalf("Expected:\n%s\nGot:\n%s", string(expectedResolvConf1), string(content))
  678. }
  679. err = ep.Leave(sb1)
  680. if err != nil {
  681. t.Fatal(err)
  682. }
  683. if err := ioutil.WriteFile("/etc/resolv.conf", tmpResolvConf2, 0644); err != nil {
  684. t.Fatal(err)
  685. }
  686. sb2, err := controller.NewSandbox(containerID+"_2", libnetwork.OptionResolvConfPath(resolvConfPath))
  687. if err != nil {
  688. t.Fatal(err)
  689. }
  690. defer func() {
  691. if err := sb2.Delete(); err != nil {
  692. t.Fatal(err)
  693. }
  694. }()
  695. err = ep.Join(sb2)
  696. if err != nil {
  697. t.Fatal(err)
  698. }
  699. content, err = ioutil.ReadFile(resolvConfPath)
  700. if err != nil {
  701. t.Fatal(err)
  702. }
  703. if !bytes.Equal(content, expectedResolvConf1) {
  704. t.Fatalf("Expected:\n%s\nGot:\n%s", string(expectedResolvConf1), string(content))
  705. }
  706. if err := ioutil.WriteFile(resolvConfPath, tmpResolvConf3, 0644); err != nil {
  707. t.Fatal(err)
  708. }
  709. err = ep.Leave(sb2)
  710. if err != nil {
  711. t.Fatal(err)
  712. }
  713. err = ep.Join(sb2)
  714. if err != nil {
  715. t.Fatal(err)
  716. }
  717. content, err = ioutil.ReadFile(resolvConfPath)
  718. if err != nil {
  719. t.Fatal(err)
  720. }
  721. if !bytes.Equal(content, tmpResolvConf3) {
  722. t.Fatalf("Expected:\n%s\nGot:\n%s", string(tmpResolvConf3), string(content))
  723. }
  724. }
  725. func parallelJoin(t *testing.T, rc libnetwork.Sandbox, ep libnetwork.Endpoint, thrNumber int) {
  726. debugf("J%d.", thrNumber)
  727. var err error
  728. sb := sboxes[thrNumber-1]
  729. err = ep.Join(sb)
  730. runtime.LockOSThread()
  731. if err != nil {
  732. if _, ok := err.(types.ForbiddenError); !ok {
  733. t.Fatalf("thread %d: %v", thrNumber, err)
  734. }
  735. debugf("JE%d(%v).", thrNumber, err)
  736. }
  737. debugf("JD%d.", thrNumber)
  738. }
  739. func parallelLeave(t *testing.T, rc libnetwork.Sandbox, ep libnetwork.Endpoint, thrNumber int) {
  740. debugf("L%d.", thrNumber)
  741. var err error
  742. sb := sboxes[thrNumber-1]
  743. err = ep.Leave(sb)
  744. runtime.LockOSThread()
  745. if err != nil {
  746. if _, ok := err.(types.ForbiddenError); !ok {
  747. t.Fatalf("thread %d: %v", thrNumber, err)
  748. }
  749. debugf("LE%d(%v).", thrNumber, err)
  750. }
  751. debugf("LD%d.", thrNumber)
  752. }
  753. func runParallelTests(t *testing.T, thrNumber int) {
  754. var (
  755. ep libnetwork.Endpoint
  756. sb libnetwork.Sandbox
  757. err error
  758. )
  759. t.Parallel()
  760. pTest := flag.Lookup("test.parallel")
  761. if pTest == nil {
  762. t.Skip("Skipped because test.parallel flag not set;")
  763. }
  764. numParallel, err := strconv.Atoi(pTest.Value.String())
  765. if err != nil {
  766. t.Fatal(err)
  767. }
  768. if numParallel < numThreads {
  769. t.Skip("Skipped because t.parallel was less than ", numThreads)
  770. }
  771. runtime.LockOSThread()
  772. defer runtime.UnlockOSThread()
  773. if thrNumber == first {
  774. createGlobalInstance(t)
  775. }
  776. if thrNumber != first {
  777. <-start
  778. thrdone := make(chan struct{})
  779. done <- thrdone
  780. defer close(thrdone)
  781. if thrNumber == last {
  782. defer close(done)
  783. }
  784. err = netns.Set(testns)
  785. if err != nil {
  786. t.Fatal(err)
  787. }
  788. }
  789. defer netns.Set(origns)
  790. net1, err := controller.NetworkByName("testhost")
  791. if err != nil {
  792. t.Fatal(err)
  793. }
  794. if net1 == nil {
  795. t.Fatal("Could not find testhost")
  796. }
  797. net2, err := controller.NetworkByName("network2")
  798. if err != nil {
  799. t.Fatal(err)
  800. }
  801. if net2 == nil {
  802. t.Fatal("Could not find network2")
  803. }
  804. epName := fmt.Sprintf("pep%d", thrNumber)
  805. if thrNumber == first {
  806. ep, err = net1.EndpointByName(epName)
  807. } else {
  808. ep, err = net2.EndpointByName(epName)
  809. }
  810. if err != nil {
  811. t.Fatal(err)
  812. }
  813. if ep == nil {
  814. t.Fatal("Got nil ep with no error")
  815. }
  816. cid := fmt.Sprintf("%drace", thrNumber)
  817. controller.WalkSandboxes(libnetwork.SandboxContainerWalker(&sb, cid))
  818. if sb == nil {
  819. t.Fatalf("Got nil sandbox for container: %s", cid)
  820. }
  821. for i := 0; i < iterCnt; i++ {
  822. parallelJoin(t, sb, ep, thrNumber)
  823. parallelLeave(t, sb, ep, thrNumber)
  824. }
  825. debugf("\n")
  826. err = sb.Delete()
  827. if err != nil {
  828. t.Fatal(err)
  829. }
  830. if thrNumber == first {
  831. for thrdone := range done {
  832. <-thrdone
  833. }
  834. testns.Close()
  835. if err := net2.Delete(); err != nil {
  836. t.Fatal(err)
  837. }
  838. } else {
  839. err = ep.Delete(false)
  840. if err != nil {
  841. t.Fatal(err)
  842. }
  843. }
  844. }
  845. func TestParallel1(t *testing.T) {
  846. runParallelTests(t, 1)
  847. }
  848. func TestParallel2(t *testing.T) {
  849. runParallelTests(t, 2)
  850. }
  851. func TestParallel3(t *testing.T) {
  852. runParallelTests(t, 3)
  853. }
  854. func TestNullIpam(t *testing.T) {
  855. _, err := controller.NewNetwork(bridgeNetType, "testnetworkinternal", "", libnetwork.NetworkOptionIpam(ipamapi.NullIPAM, "", nil, nil, nil))
  856. if err == nil || err.Error() != "ipv4 pool is empty" {
  857. t.Fatal("bridge network should complain empty pool")
  858. }
  859. }