runtime_test.go 24 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891
  1. package docker
  2. import (
  3. "bytes"
  4. "fmt"
  5. "io"
  6. std_log "log"
  7. "net"
  8. "net/url"
  9. "os"
  10. "path/filepath"
  11. "runtime"
  12. "strconv"
  13. "strings"
  14. "syscall"
  15. "testing"
  16. "time"
  17. "github.com/docker/docker/daemon"
  18. "github.com/docker/docker/engine"
  19. "github.com/docker/docker/image"
  20. "github.com/docker/docker/nat"
  21. "github.com/docker/docker/pkg/ioutils"
  22. "github.com/docker/docker/pkg/log"
  23. "github.com/docker/docker/reexec"
  24. "github.com/docker/docker/runconfig"
  25. "github.com/docker/docker/utils"
  26. )
  27. const (
  28. unitTestImageName = "docker-test-image"
  29. unitTestImageID = "83599e29c455eb719f77d799bc7c51521b9551972f5a850d7ad265bc1b5292f6" // 1.0
  30. unitTestImageIDShort = "83599e29c455"
  31. unitTestNetworkBridge = "testdockbr0"
  32. unitTestStoreBase = "/var/lib/docker/unit-tests"
  33. unitTestDockerTmpdir = "/var/lib/docker/tmp"
  34. testDaemonAddr = "127.0.0.1:4270"
  35. testDaemonProto = "tcp"
  36. testDaemonHttpsProto = "tcp"
  37. testDaemonHttpsAddr = "localhost:4271"
  38. testDaemonRogueHttpsAddr = "localhost:4272"
  39. )
  40. var (
  41. // FIXME: globalDaemon is deprecated by globalEngine. All tests should be converted.
  42. globalDaemon *daemon.Daemon
  43. globalEngine *engine.Engine
  44. globalHttpsEngine *engine.Engine
  45. globalRogueHttpsEngine *engine.Engine
  46. startFds int
  47. startGoroutines int
  48. )
  49. // FIXME: nuke() is deprecated by Daemon.Nuke()
  50. func nuke(daemon *daemon.Daemon) error {
  51. return daemon.Nuke()
  52. }
  53. // FIXME: cleanup and nuke are redundant.
  54. func cleanup(eng *engine.Engine, t *testing.T) error {
  55. daemon := mkDaemonFromEngine(eng, t)
  56. for _, container := range daemon.List() {
  57. container.Kill()
  58. daemon.Destroy(container)
  59. }
  60. job := eng.Job("images")
  61. images, err := job.Stdout.AddTable()
  62. if err != nil {
  63. t.Fatal(err)
  64. }
  65. if err := job.Run(); err != nil {
  66. t.Fatal(err)
  67. }
  68. for _, image := range images.Data {
  69. if image.Get("Id") != unitTestImageID {
  70. eng.Job("image_delete", image.Get("Id")).Run()
  71. }
  72. }
  73. return nil
  74. }
  75. func layerArchive(tarfile string) (io.Reader, error) {
  76. // FIXME: need to close f somewhere
  77. f, err := os.Open(tarfile)
  78. if err != nil {
  79. return nil, err
  80. }
  81. return f, nil
  82. }
  83. func init() {
  84. // Always use the same driver (vfs) for all integration tests.
  85. // To test other drivers, we need a dedicated driver validation suite.
  86. os.Setenv("DOCKER_DRIVER", "vfs")
  87. os.Setenv("TEST", "1")
  88. os.Setenv("DOCKER_TMPDIR", unitTestDockerTmpdir)
  89. // Hack to run sys init during unit testing
  90. if reexec.Init() {
  91. return
  92. }
  93. if uid := syscall.Geteuid(); uid != 0 {
  94. log.Fatalf("docker tests need to be run as root")
  95. }
  96. // Copy dockerinit into our current testing directory, if provided (so we can test a separate dockerinit binary)
  97. if dockerinit := os.Getenv("TEST_DOCKERINIT_PATH"); dockerinit != "" {
  98. src, err := os.Open(dockerinit)
  99. if err != nil {
  100. log.Fatalf("Unable to open TEST_DOCKERINIT_PATH: %s", err)
  101. }
  102. defer src.Close()
  103. dst, err := os.OpenFile(filepath.Join(filepath.Dir(utils.SelfPath()), "dockerinit"), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0555)
  104. if err != nil {
  105. log.Fatalf("Unable to create dockerinit in test directory: %s", err)
  106. }
  107. defer dst.Close()
  108. if _, err := io.Copy(dst, src); err != nil {
  109. log.Fatalf("Unable to copy dockerinit to TEST_DOCKERINIT_PATH: %s", err)
  110. }
  111. dst.Close()
  112. src.Close()
  113. }
  114. // Setup the base daemon, which will be duplicated for each test.
  115. // (no tests are run directly in the base)
  116. setupBaseImage()
  117. // Create the "global daemon" with a long-running daemons for integration tests
  118. spawnGlobalDaemon()
  119. spawnLegitHttpsDaemon()
  120. spawnRogueHttpsDaemon()
  121. startFds, startGoroutines = utils.GetTotalUsedFds(), runtime.NumGoroutine()
  122. }
  123. func setupBaseImage() {
  124. eng := newTestEngine(std_log.New(os.Stderr, "", 0), false, unitTestStoreBase)
  125. job := eng.Job("image_inspect", unitTestImageName)
  126. img, _ := job.Stdout.AddEnv()
  127. // If the unit test is not found, try to download it.
  128. if err := job.Run(); err != nil || img.Get("Id") != unitTestImageID {
  129. // Retrieve the Image
  130. job = eng.Job("pull", unitTestImageName)
  131. job.Stdout.Add(ioutils.NopWriteCloser(os.Stdout))
  132. if err := job.Run(); err != nil {
  133. log.Fatalf("Unable to pull the test image: %s", err)
  134. }
  135. }
  136. }
  137. func spawnGlobalDaemon() {
  138. if globalDaemon != nil {
  139. log.Debugf("Global daemon already exists. Skipping.")
  140. return
  141. }
  142. t := std_log.New(os.Stderr, "", 0)
  143. eng := NewTestEngine(t)
  144. globalEngine = eng
  145. globalDaemon = mkDaemonFromEngine(eng, t)
  146. // Spawn a Daemon
  147. go func() {
  148. log.Debugf("Spawning global daemon for integration tests")
  149. listenURL := &url.URL{
  150. Scheme: testDaemonProto,
  151. Host: testDaemonAddr,
  152. }
  153. job := eng.Job("serveapi", listenURL.String())
  154. job.SetenvBool("Logging", true)
  155. if err := job.Run(); err != nil {
  156. log.Fatalf("Unable to spawn the test daemon: %s", err)
  157. }
  158. }()
  159. // Give some time to ListenAndServer to actually start
  160. // FIXME: use inmem transports instead of tcp
  161. time.Sleep(time.Second)
  162. if err := eng.Job("acceptconnections").Run(); err != nil {
  163. log.Fatalf("Unable to accept connections for test api: %s", err)
  164. }
  165. }
  166. func spawnLegitHttpsDaemon() {
  167. if globalHttpsEngine != nil {
  168. return
  169. }
  170. globalHttpsEngine = spawnHttpsDaemon(testDaemonHttpsAddr, "fixtures/https/ca.pem",
  171. "fixtures/https/server-cert.pem", "fixtures/https/server-key.pem")
  172. }
  173. func spawnRogueHttpsDaemon() {
  174. if globalRogueHttpsEngine != nil {
  175. return
  176. }
  177. globalRogueHttpsEngine = spawnHttpsDaemon(testDaemonRogueHttpsAddr, "fixtures/https/ca.pem",
  178. "fixtures/https/server-rogue-cert.pem", "fixtures/https/server-rogue-key.pem")
  179. }
  180. func spawnHttpsDaemon(addr, cacert, cert, key string) *engine.Engine {
  181. t := std_log.New(os.Stderr, "", 0)
  182. root, err := newTestDirectory(unitTestStoreBase)
  183. if err != nil {
  184. t.Fatal(err)
  185. }
  186. // FIXME: here we don't use NewTestEngine because it configures the daemon with Autorestart=false,
  187. // and we want to set it to true.
  188. eng := newTestEngine(t, true, root)
  189. // Spawn a Daemon
  190. go func() {
  191. log.Debugf("Spawning https daemon for integration tests")
  192. listenURL := &url.URL{
  193. Scheme: testDaemonHttpsProto,
  194. Host: addr,
  195. }
  196. job := eng.Job("serveapi", listenURL.String())
  197. job.SetenvBool("Logging", true)
  198. job.SetenvBool("Tls", true)
  199. job.SetenvBool("TlsVerify", true)
  200. job.Setenv("TlsCa", cacert)
  201. job.Setenv("TlsCert", cert)
  202. job.Setenv("TlsKey", key)
  203. if err := job.Run(); err != nil {
  204. log.Fatalf("Unable to spawn the test daemon: %s", err)
  205. }
  206. }()
  207. // Give some time to ListenAndServer to actually start
  208. time.Sleep(time.Second)
  209. if err := eng.Job("acceptconnections").Run(); err != nil {
  210. log.Fatalf("Unable to accept connections for test api: %s", err)
  211. }
  212. return eng
  213. }
  214. // FIXME: test that ImagePull(json=true) send correct json output
  215. func GetTestImage(daemon *daemon.Daemon) *image.Image {
  216. imgs, err := daemon.Graph().Map()
  217. if err != nil {
  218. log.Fatalf("Unable to get the test image: %s", err)
  219. }
  220. for _, image := range imgs {
  221. if image.ID == unitTestImageID {
  222. return image
  223. }
  224. }
  225. log.Fatalf("Test image %v not found in %s: %s", unitTestImageID, daemon.Graph().Root, imgs)
  226. return nil
  227. }
  228. func TestDaemonCreate(t *testing.T) {
  229. daemon := mkDaemon(t)
  230. defer nuke(daemon)
  231. // Make sure we start we 0 containers
  232. if len(daemon.List()) != 0 {
  233. t.Errorf("Expected 0 containers, %v found", len(daemon.List()))
  234. }
  235. container, _, err := daemon.Create(&runconfig.Config{
  236. Image: GetTestImage(daemon).ID,
  237. Cmd: []string{"ls", "-al"},
  238. },
  239. "",
  240. )
  241. if err != nil {
  242. t.Fatal(err)
  243. }
  244. defer func() {
  245. if err := daemon.Destroy(container); err != nil {
  246. t.Error(err)
  247. }
  248. }()
  249. // Make sure we can find the newly created container with List()
  250. if len(daemon.List()) != 1 {
  251. t.Errorf("Expected 1 container, %v found", len(daemon.List()))
  252. }
  253. // Make sure the container List() returns is the right one
  254. if daemon.List()[0].ID != container.ID {
  255. t.Errorf("Unexpected container %v returned by List", daemon.List()[0])
  256. }
  257. // Make sure we can get the container with Get()
  258. if daemon.Get(container.ID) == nil {
  259. t.Errorf("Unable to get newly created container")
  260. }
  261. // Make sure it is the right container
  262. if daemon.Get(container.ID) != container {
  263. t.Errorf("Get() returned the wrong container")
  264. }
  265. // Make sure Exists returns it as existing
  266. if !daemon.Exists(container.ID) {
  267. t.Errorf("Exists() returned false for a newly created container")
  268. }
  269. // Test that conflict error displays correct details
  270. testContainer, _, _ := daemon.Create(
  271. &runconfig.Config{
  272. Image: GetTestImage(daemon).ID,
  273. Cmd: []string{"ls", "-al"},
  274. },
  275. "conflictname",
  276. )
  277. if _, _, err := daemon.Create(&runconfig.Config{Image: GetTestImage(daemon).ID, Cmd: []string{"ls", "-al"}}, testContainer.Name); err == nil || !strings.Contains(err.Error(), utils.TruncateID(testContainer.ID)) {
  278. t.Fatalf("Name conflict error doesn't include the correct short id. Message was: %s", err.Error())
  279. }
  280. // Make sure create with bad parameters returns an error
  281. if _, _, err = daemon.Create(&runconfig.Config{Image: GetTestImage(daemon).ID}, ""); err == nil {
  282. t.Fatal("Builder.Create should throw an error when Cmd is missing")
  283. }
  284. if _, _, err := daemon.Create(
  285. &runconfig.Config{
  286. Image: GetTestImage(daemon).ID,
  287. Cmd: []string{},
  288. },
  289. "",
  290. ); err == nil {
  291. t.Fatal("Builder.Create should throw an error when Cmd is empty")
  292. }
  293. config := &runconfig.Config{
  294. Image: GetTestImage(daemon).ID,
  295. Cmd: []string{"/bin/ls"},
  296. PortSpecs: []string{"80"},
  297. }
  298. container, _, err = daemon.Create(config, "")
  299. _, err = daemon.Commit(container, "testrepo", "testtag", "", "", true, config)
  300. if err != nil {
  301. t.Error(err)
  302. }
  303. // test expose 80:8000
  304. container, warnings, err := daemon.Create(&runconfig.Config{
  305. Image: GetTestImage(daemon).ID,
  306. Cmd: []string{"ls", "-al"},
  307. PortSpecs: []string{"80:8000"},
  308. },
  309. "",
  310. )
  311. if err != nil {
  312. t.Fatal(err)
  313. }
  314. if warnings == nil || len(warnings) != 1 {
  315. t.Error("Expected a warning, got none")
  316. }
  317. }
  318. func TestDestroy(t *testing.T) {
  319. daemon := mkDaemon(t)
  320. defer nuke(daemon)
  321. container, _, err := daemon.Create(&runconfig.Config{
  322. Image: GetTestImage(daemon).ID,
  323. Cmd: []string{"ls", "-al"},
  324. }, "")
  325. if err != nil {
  326. t.Fatal(err)
  327. }
  328. // Destroy
  329. if err := daemon.Destroy(container); err != nil {
  330. t.Error(err)
  331. }
  332. // Make sure daemon.Exists() behaves correctly
  333. if daemon.Exists("test_destroy") {
  334. t.Errorf("Exists() returned true")
  335. }
  336. // Make sure daemon.List() doesn't list the destroyed container
  337. if len(daemon.List()) != 0 {
  338. t.Errorf("Expected 0 container, %v found", len(daemon.List()))
  339. }
  340. // Make sure daemon.Get() refuses to return the unexisting container
  341. if daemon.Get(container.ID) != nil {
  342. t.Errorf("Unable to get newly created container")
  343. }
  344. // Test double destroy
  345. if err := daemon.Destroy(container); err == nil {
  346. // It should have failed
  347. t.Errorf("Double destroy did not fail")
  348. }
  349. }
  350. func TestGet(t *testing.T) {
  351. daemon := mkDaemon(t)
  352. defer nuke(daemon)
  353. container1, _, _ := mkContainer(daemon, []string{"_", "ls", "-al"}, t)
  354. defer daemon.Destroy(container1)
  355. container2, _, _ := mkContainer(daemon, []string{"_", "ls", "-al"}, t)
  356. defer daemon.Destroy(container2)
  357. container3, _, _ := mkContainer(daemon, []string{"_", "ls", "-al"}, t)
  358. defer daemon.Destroy(container3)
  359. if daemon.Get(container1.ID) != container1 {
  360. t.Errorf("Get(test1) returned %v while expecting %v", daemon.Get(container1.ID), container1)
  361. }
  362. if daemon.Get(container2.ID) != container2 {
  363. t.Errorf("Get(test2) returned %v while expecting %v", daemon.Get(container2.ID), container2)
  364. }
  365. if daemon.Get(container3.ID) != container3 {
  366. t.Errorf("Get(test3) returned %v while expecting %v", daemon.Get(container3.ID), container3)
  367. }
  368. }
  369. func startEchoServerContainer(t *testing.T, proto string) (*daemon.Daemon, *daemon.Container, string) {
  370. var (
  371. err error
  372. id string
  373. outputBuffer = bytes.NewBuffer(nil)
  374. strPort string
  375. eng = NewTestEngine(t)
  376. daemon = mkDaemonFromEngine(eng, t)
  377. port = 5554
  378. p nat.Port
  379. )
  380. defer func() {
  381. if err != nil {
  382. daemon.Nuke()
  383. }
  384. }()
  385. for {
  386. port += 1
  387. strPort = strconv.Itoa(port)
  388. var cmd string
  389. if proto == "tcp" {
  390. cmd = "socat TCP-LISTEN:" + strPort + ",reuseaddr,fork EXEC:/bin/cat"
  391. } else if proto == "udp" {
  392. cmd = "socat UDP-RECVFROM:" + strPort + ",fork EXEC:/bin/cat"
  393. } else {
  394. t.Fatal(fmt.Errorf("Unknown protocol %v", proto))
  395. }
  396. ep := make(map[nat.Port]struct{}, 1)
  397. p = nat.Port(fmt.Sprintf("%s/%s", strPort, proto))
  398. ep[p] = struct{}{}
  399. jobCreate := eng.Job("create")
  400. jobCreate.Setenv("Image", unitTestImageID)
  401. jobCreate.SetenvList("Cmd", []string{"sh", "-c", cmd})
  402. jobCreate.SetenvList("PortSpecs", []string{fmt.Sprintf("%s/%s", strPort, proto)})
  403. jobCreate.SetenvJson("ExposedPorts", ep)
  404. jobCreate.Stdout.Add(outputBuffer)
  405. if err := jobCreate.Run(); err != nil {
  406. t.Fatal(err)
  407. }
  408. id = engine.Tail(outputBuffer, 1)
  409. // FIXME: this relies on the undocumented behavior of daemon.Create
  410. // which will return a nil error AND container if the exposed ports
  411. // are invalid. That behavior should be fixed!
  412. if id != "" {
  413. break
  414. }
  415. t.Logf("Port %v already in use, trying another one", strPort)
  416. }
  417. jobStart := eng.Job("start", id)
  418. portBindings := make(map[nat.Port][]nat.PortBinding)
  419. portBindings[p] = []nat.PortBinding{
  420. {},
  421. }
  422. if err := jobStart.SetenvJson("PortsBindings", portBindings); err != nil {
  423. t.Fatal(err)
  424. }
  425. if err := jobStart.Run(); err != nil {
  426. t.Fatal(err)
  427. }
  428. container := daemon.Get(id)
  429. if container == nil {
  430. t.Fatalf("Couldn't fetch test container %s", id)
  431. }
  432. setTimeout(t, "Waiting for the container to be started timed out", 2*time.Second, func() {
  433. for !container.IsRunning() {
  434. time.Sleep(10 * time.Millisecond)
  435. }
  436. })
  437. // Even if the state is running, lets give some time to lxc to spawn the process
  438. container.WaitStop(500 * time.Millisecond)
  439. strPort = container.NetworkSettings.Ports[p][0].HostPort
  440. return daemon, container, strPort
  441. }
  442. // Run a container with a TCP port allocated, and test that it can receive connections on localhost
  443. func TestAllocateTCPPortLocalhost(t *testing.T) {
  444. daemon, container, port := startEchoServerContainer(t, "tcp")
  445. defer nuke(daemon)
  446. defer container.Kill()
  447. for i := 0; i != 10; i++ {
  448. conn, err := net.Dial("tcp", fmt.Sprintf("localhost:%v", port))
  449. if err != nil {
  450. t.Fatal(err)
  451. }
  452. defer conn.Close()
  453. input := bytes.NewBufferString("well hello there\n")
  454. _, err = conn.Write(input.Bytes())
  455. if err != nil {
  456. t.Fatal(err)
  457. }
  458. buf := make([]byte, 16)
  459. read := 0
  460. conn.SetReadDeadline(time.Now().Add(3 * time.Second))
  461. read, err = conn.Read(buf)
  462. if err != nil {
  463. if err, ok := err.(*net.OpError); ok {
  464. if err.Err == syscall.ECONNRESET {
  465. t.Logf("Connection reset by the proxy, socat is probably not listening yet, trying again in a sec")
  466. conn.Close()
  467. time.Sleep(time.Second)
  468. continue
  469. }
  470. if err.Timeout() {
  471. t.Log("Timeout, trying again")
  472. conn.Close()
  473. continue
  474. }
  475. }
  476. t.Fatal(err)
  477. }
  478. output := string(buf[:read])
  479. if !strings.Contains(output, "well hello there") {
  480. t.Fatal(fmt.Errorf("[%v] doesn't contain [well hello there]", output))
  481. } else {
  482. return
  483. }
  484. }
  485. t.Fatal("No reply from the container")
  486. }
  487. // Run a container with an UDP port allocated, and test that it can receive connections on localhost
  488. func TestAllocateUDPPortLocalhost(t *testing.T) {
  489. daemon, container, port := startEchoServerContainer(t, "udp")
  490. defer nuke(daemon)
  491. defer container.Kill()
  492. conn, err := net.Dial("udp", fmt.Sprintf("localhost:%v", port))
  493. if err != nil {
  494. t.Fatal(err)
  495. }
  496. defer conn.Close()
  497. input := bytes.NewBufferString("well hello there\n")
  498. buf := make([]byte, 16)
  499. // Try for a minute, for some reason the select in socat may take ages
  500. // to return even though everything on the path seems fine (i.e: the
  501. // UDPProxy forwards the traffic correctly and you can see the packets
  502. // on the interface from within the container).
  503. for i := 0; i != 120; i++ {
  504. _, err := conn.Write(input.Bytes())
  505. if err != nil {
  506. t.Fatal(err)
  507. }
  508. conn.SetReadDeadline(time.Now().Add(500 * time.Millisecond))
  509. read, err := conn.Read(buf)
  510. if err == nil {
  511. output := string(buf[:read])
  512. if strings.Contains(output, "well hello there") {
  513. return
  514. }
  515. }
  516. }
  517. t.Fatal("No reply from the container")
  518. }
  519. func TestRestore(t *testing.T) {
  520. eng := NewTestEngine(t)
  521. daemon1 := mkDaemonFromEngine(eng, t)
  522. defer daemon1.Nuke()
  523. // Create a container with one instance of docker
  524. container1, _, _ := mkContainer(daemon1, []string{"_", "ls", "-al"}, t)
  525. defer daemon1.Destroy(container1)
  526. // Create a second container meant to be killed
  527. container2, _, _ := mkContainer(daemon1, []string{"-i", "_", "/bin/cat"}, t)
  528. defer daemon1.Destroy(container2)
  529. // Start the container non blocking
  530. if err := container2.Start(); err != nil {
  531. t.Fatal(err)
  532. }
  533. if !container2.IsRunning() {
  534. t.Fatalf("Container %v should appear as running but isn't", container2.ID)
  535. }
  536. // Simulate a crash/manual quit of dockerd: process dies, states stays 'Running'
  537. cStdin, _ := container2.StdinPipe()
  538. cStdin.Close()
  539. if _, err := container2.WaitStop(2 * time.Second); err != nil {
  540. t.Fatal(err)
  541. }
  542. container2.SetRunning(42)
  543. container2.ToDisk()
  544. if len(daemon1.List()) != 2 {
  545. t.Errorf("Expected 2 container, %v found", len(daemon1.List()))
  546. }
  547. if err := container1.Run(); err != nil {
  548. t.Fatal(err)
  549. }
  550. if !container2.IsRunning() {
  551. t.Fatalf("Container %v should appear as running but isn't", container2.ID)
  552. }
  553. // Here are are simulating a docker restart - that is, reloading all containers
  554. // from scratch
  555. eng = newTestEngine(t, false, daemon1.Config().Root)
  556. daemon2 := mkDaemonFromEngine(eng, t)
  557. if len(daemon2.List()) != 2 {
  558. t.Errorf("Expected 2 container, %v found", len(daemon2.List()))
  559. }
  560. runningCount := 0
  561. for _, c := range daemon2.List() {
  562. if c.IsRunning() {
  563. t.Errorf("Running container found: %v (%v)", c.ID, c.Path)
  564. runningCount++
  565. }
  566. }
  567. if runningCount != 0 {
  568. t.Fatalf("Expected 0 container alive, %d found", runningCount)
  569. }
  570. container3 := daemon2.Get(container1.ID)
  571. if container3 == nil {
  572. t.Fatal("Unable to Get container")
  573. }
  574. if err := container3.Run(); err != nil {
  575. t.Fatal(err)
  576. }
  577. container2.SetStopped(0)
  578. }
  579. func TestDefaultContainerName(t *testing.T) {
  580. eng := NewTestEngine(t)
  581. daemon := mkDaemonFromEngine(eng, t)
  582. defer nuke(daemon)
  583. config, _, _, err := parseRun([]string{unitTestImageID, "echo test"}, nil)
  584. if err != nil {
  585. t.Fatal(err)
  586. }
  587. container := daemon.Get(createNamedTestContainer(eng, config, t, "some_name"))
  588. containerID := container.ID
  589. if container.Name != "/some_name" {
  590. t.Fatalf("Expect /some_name got %s", container.Name)
  591. }
  592. if c := daemon.Get("/some_name"); c == nil {
  593. t.Fatalf("Couldn't retrieve test container as /some_name")
  594. } else if c.ID != containerID {
  595. t.Fatalf("Container /some_name has ID %s instead of %s", c.ID, containerID)
  596. }
  597. }
  598. func TestRandomContainerName(t *testing.T) {
  599. eng := NewTestEngine(t)
  600. daemon := mkDaemonFromEngine(eng, t)
  601. defer nuke(daemon)
  602. config, _, _, err := parseRun([]string{GetTestImage(daemon).ID, "echo test"}, nil)
  603. if err != nil {
  604. t.Fatal(err)
  605. }
  606. container := daemon.Get(createTestContainer(eng, config, t))
  607. containerID := container.ID
  608. if container.Name == "" {
  609. t.Fatalf("Expected not empty container name")
  610. }
  611. if c := daemon.Get(container.Name); c == nil {
  612. log.Fatalf("Could not lookup container %s by its name", container.Name)
  613. } else if c.ID != containerID {
  614. log.Fatalf("Looking up container name %s returned id %s instead of %s", container.Name, c.ID, containerID)
  615. }
  616. }
  617. func TestContainerNameValidation(t *testing.T) {
  618. eng := NewTestEngine(t)
  619. daemon := mkDaemonFromEngine(eng, t)
  620. defer nuke(daemon)
  621. for _, test := range []struct {
  622. Name string
  623. Valid bool
  624. }{
  625. {"abc-123_AAA.1", true},
  626. {"\000asdf", false},
  627. } {
  628. config, _, _, err := parseRun([]string{unitTestImageID, "echo test"}, nil)
  629. if err != nil {
  630. if !test.Valid {
  631. continue
  632. }
  633. t.Fatal(err)
  634. }
  635. var outputBuffer = bytes.NewBuffer(nil)
  636. job := eng.Job("create", test.Name)
  637. if err := job.ImportEnv(config); err != nil {
  638. t.Fatal(err)
  639. }
  640. job.Stdout.Add(outputBuffer)
  641. if err := job.Run(); err != nil {
  642. if !test.Valid {
  643. continue
  644. }
  645. t.Fatal(err)
  646. }
  647. container := daemon.Get(engine.Tail(outputBuffer, 1))
  648. if container.Name != "/"+test.Name {
  649. t.Fatalf("Expect /%s got %s", test.Name, container.Name)
  650. }
  651. if c := daemon.Get("/" + test.Name); c == nil {
  652. t.Fatalf("Couldn't retrieve test container as /%s", test.Name)
  653. } else if c.ID != container.ID {
  654. t.Fatalf("Container /%s has ID %s instead of %s", test.Name, c.ID, container.ID)
  655. }
  656. }
  657. }
  658. func TestLinkChildContainer(t *testing.T) {
  659. eng := NewTestEngine(t)
  660. daemon := mkDaemonFromEngine(eng, t)
  661. defer nuke(daemon)
  662. config, _, _, err := parseRun([]string{unitTestImageID, "echo test"}, nil)
  663. if err != nil {
  664. t.Fatal(err)
  665. }
  666. container := daemon.Get(createNamedTestContainer(eng, config, t, "/webapp"))
  667. webapp, err := daemon.GetByName("/webapp")
  668. if err != nil {
  669. t.Fatal(err)
  670. }
  671. if webapp.ID != container.ID {
  672. t.Fatalf("Expect webapp id to match container id: %s != %s", webapp.ID, container.ID)
  673. }
  674. config, _, _, err = parseRun([]string{GetTestImage(daemon).ID, "echo test"}, nil)
  675. if err != nil {
  676. t.Fatal(err)
  677. }
  678. childContainer := daemon.Get(createTestContainer(eng, config, t))
  679. if err := daemon.RegisterLink(webapp, childContainer, "db"); err != nil {
  680. t.Fatal(err)
  681. }
  682. // Get the child by it's new name
  683. db, err := daemon.GetByName("/webapp/db")
  684. if err != nil {
  685. t.Fatal(err)
  686. }
  687. if db.ID != childContainer.ID {
  688. t.Fatalf("Expect db id to match container id: %s != %s", db.ID, childContainer.ID)
  689. }
  690. }
  691. func TestGetAllChildren(t *testing.T) {
  692. eng := NewTestEngine(t)
  693. daemon := mkDaemonFromEngine(eng, t)
  694. defer nuke(daemon)
  695. config, _, _, err := parseRun([]string{unitTestImageID, "echo test"}, nil)
  696. if err != nil {
  697. t.Fatal(err)
  698. }
  699. container := daemon.Get(createNamedTestContainer(eng, config, t, "/webapp"))
  700. webapp, err := daemon.GetByName("/webapp")
  701. if err != nil {
  702. t.Fatal(err)
  703. }
  704. if webapp.ID != container.ID {
  705. t.Fatalf("Expect webapp id to match container id: %s != %s", webapp.ID, container.ID)
  706. }
  707. config, _, _, err = parseRun([]string{unitTestImageID, "echo test"}, nil)
  708. if err != nil {
  709. t.Fatal(err)
  710. }
  711. childContainer := daemon.Get(createTestContainer(eng, config, t))
  712. if err := daemon.RegisterLink(webapp, childContainer, "db"); err != nil {
  713. t.Fatal(err)
  714. }
  715. children, err := daemon.Children("/webapp")
  716. if err != nil {
  717. t.Fatal(err)
  718. }
  719. if children == nil {
  720. t.Fatal("Children should not be nil")
  721. }
  722. if len(children) == 0 {
  723. t.Fatal("Children should not be empty")
  724. }
  725. for key, value := range children {
  726. if key != "/webapp/db" {
  727. t.Fatalf("Expected /webapp/db got %s", key)
  728. }
  729. if value.ID != childContainer.ID {
  730. t.Fatalf("Expected id %s got %s", childContainer.ID, value.ID)
  731. }
  732. }
  733. }
  734. func TestDestroyWithInitLayer(t *testing.T) {
  735. daemon := mkDaemon(t)
  736. defer nuke(daemon)
  737. container, _, err := daemon.Create(&runconfig.Config{
  738. Image: GetTestImage(daemon).ID,
  739. Cmd: []string{"ls", "-al"},
  740. }, "")
  741. if err != nil {
  742. t.Fatal(err)
  743. }
  744. // Destroy
  745. if err := daemon.Destroy(container); err != nil {
  746. t.Fatal(err)
  747. }
  748. // Make sure daemon.Exists() behaves correctly
  749. if daemon.Exists("test_destroy") {
  750. t.Fatalf("Exists() returned true")
  751. }
  752. // Make sure daemon.List() doesn't list the destroyed container
  753. if len(daemon.List()) != 0 {
  754. t.Fatalf("Expected 0 container, %v found", len(daemon.List()))
  755. }
  756. driver := daemon.Graph().Driver()
  757. // Make sure that the container does not exist in the driver
  758. if _, err := driver.Get(container.ID, ""); err == nil {
  759. t.Fatal("Conttainer should not exist in the driver")
  760. }
  761. // Make sure that the init layer is removed from the driver
  762. if _, err := driver.Get(fmt.Sprintf("%s-init", container.ID), ""); err == nil {
  763. t.Fatal("Container's init layer should not exist in the driver")
  764. }
  765. }