docker_cli_swarm_test.go 39 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053
  1. // +build !windows
  2. package main
  3. import (
  4. "bytes"
  5. "encoding/json"
  6. "fmt"
  7. "io/ioutil"
  8. "net/http"
  9. "net/http/httptest"
  10. "os"
  11. "path/filepath"
  12. "strings"
  13. "time"
  14. "github.com/docker/docker/api/types/swarm"
  15. "github.com/docker/docker/pkg/integration/checker"
  16. "github.com/docker/libnetwork/driverapi"
  17. "github.com/docker/libnetwork/ipamapi"
  18. remoteipam "github.com/docker/libnetwork/ipams/remote/api"
  19. "github.com/go-check/check"
  20. "github.com/vishvananda/netlink"
  21. )
  22. func (s *DockerSwarmSuite) TestSwarmUpdate(c *check.C) {
  23. d := s.AddDaemon(c, true, true)
  24. getSpec := func() swarm.Spec {
  25. sw := d.getSwarm(c)
  26. return sw.Spec
  27. }
  28. out, err := d.Cmd("swarm", "update", "--cert-expiry", "30h", "--dispatcher-heartbeat", "11s")
  29. c.Assert(err, checker.IsNil, check.Commentf("out: %v", out))
  30. spec := getSpec()
  31. c.Assert(spec.CAConfig.NodeCertExpiry, checker.Equals, 30*time.Hour)
  32. c.Assert(spec.Dispatcher.HeartbeatPeriod, checker.Equals, 11*time.Second)
  33. // setting anything under 30m for cert-expiry is not allowed
  34. out, err = d.Cmd("swarm", "update", "--cert-expiry", "15m")
  35. c.Assert(err, checker.NotNil)
  36. c.Assert(out, checker.Contains, "minimum certificate expiry time")
  37. spec = getSpec()
  38. c.Assert(spec.CAConfig.NodeCertExpiry, checker.Equals, 30*time.Hour)
  39. }
  40. func (s *DockerSwarmSuite) TestSwarmInit(c *check.C) {
  41. d := s.AddDaemon(c, false, false)
  42. getSpec := func() swarm.Spec {
  43. sw := d.getSwarm(c)
  44. return sw.Spec
  45. }
  46. out, err := d.Cmd("swarm", "init", "--cert-expiry", "30h", "--dispatcher-heartbeat", "11s")
  47. c.Assert(err, checker.IsNil, check.Commentf("out: %v", out))
  48. spec := getSpec()
  49. c.Assert(spec.CAConfig.NodeCertExpiry, checker.Equals, 30*time.Hour)
  50. c.Assert(spec.Dispatcher.HeartbeatPeriod, checker.Equals, 11*time.Second)
  51. c.Assert(d.Leave(true), checker.IsNil)
  52. time.Sleep(500 * time.Millisecond) // https://github.com/docker/swarmkit/issues/1421
  53. out, err = d.Cmd("swarm", "init")
  54. c.Assert(err, checker.IsNil, check.Commentf("out: %v", out))
  55. spec = getSpec()
  56. c.Assert(spec.CAConfig.NodeCertExpiry, checker.Equals, 90*24*time.Hour)
  57. c.Assert(spec.Dispatcher.HeartbeatPeriod, checker.Equals, 5*time.Second)
  58. }
  59. func (s *DockerSwarmSuite) TestSwarmInitIPv6(c *check.C) {
  60. testRequires(c, IPv6)
  61. d1 := s.AddDaemon(c, false, false)
  62. out, err := d1.Cmd("swarm", "init", "--listen-addr", "::1")
  63. c.Assert(err, checker.IsNil, check.Commentf("out: %v", out))
  64. d2 := s.AddDaemon(c, false, false)
  65. out, err = d2.Cmd("swarm", "join", "::1")
  66. c.Assert(err, checker.IsNil, check.Commentf("out: %v", out))
  67. out, err = d2.Cmd("info")
  68. c.Assert(err, checker.IsNil, check.Commentf("out: %v", out))
  69. c.Assert(out, checker.Contains, "Swarm: active")
  70. }
  71. func (s *DockerSwarmSuite) TestSwarmIncompatibleDaemon(c *check.C) {
  72. // init swarm mode and stop a daemon
  73. d := s.AddDaemon(c, true, true)
  74. info, err := d.info()
  75. c.Assert(err, checker.IsNil)
  76. c.Assert(info.LocalNodeState, checker.Equals, swarm.LocalNodeStateActive)
  77. c.Assert(d.Stop(), checker.IsNil)
  78. // start a daemon with --cluster-store and --cluster-advertise
  79. err = d.Start("--cluster-store=consul://consuladdr:consulport/some/path", "--cluster-advertise=1.1.1.1:2375")
  80. c.Assert(err, checker.NotNil)
  81. content, _ := ioutil.ReadFile(d.logFile.Name())
  82. c.Assert(string(content), checker.Contains, "--cluster-store and --cluster-advertise daemon configurations are incompatible with swarm mode")
  83. // start a daemon with --live-restore
  84. err = d.Start("--live-restore")
  85. c.Assert(err, checker.NotNil)
  86. content, _ = ioutil.ReadFile(d.logFile.Name())
  87. c.Assert(string(content), checker.Contains, "--live-restore daemon configuration is incompatible with swarm mode")
  88. // restart for teardown
  89. c.Assert(d.Start(), checker.IsNil)
  90. }
  91. // Test case for #24090
  92. func (s *DockerSwarmSuite) TestSwarmNodeListHostname(c *check.C) {
  93. d := s.AddDaemon(c, true, true)
  94. // The first line should contain "HOSTNAME"
  95. out, err := d.Cmd("node", "ls")
  96. c.Assert(err, checker.IsNil)
  97. c.Assert(strings.Split(out, "\n")[0], checker.Contains, "HOSTNAME")
  98. }
  99. func (s *DockerSwarmSuite) TestSwarmServiceTemplatingHostname(c *check.C) {
  100. d := s.AddDaemon(c, true, true)
  101. out, err := d.Cmd("service", "create", "--name", "test", "--hostname", "{{.Service.Name}}-{{.Task.Slot}}", "busybox", "top")
  102. c.Assert(err, checker.IsNil, check.Commentf(out))
  103. // make sure task has been deployed.
  104. waitAndAssert(c, defaultReconciliationTimeout, d.checkActiveContainerCount, checker.Equals, 1)
  105. containers := d.activeContainers()
  106. out, err = d.Cmd("inspect", "--type", "container", "--format", "{{.Config.Hostname}}", containers[0])
  107. c.Assert(err, checker.IsNil, check.Commentf(out))
  108. c.Assert(strings.Split(out, "\n")[0], checker.Equals, "test-1", check.Commentf("hostname with templating invalid"))
  109. }
  110. // Test case for #24270
  111. func (s *DockerSwarmSuite) TestSwarmServiceListFilter(c *check.C) {
  112. d := s.AddDaemon(c, true, true)
  113. name1 := "redis-cluster-md5"
  114. name2 := "redis-cluster"
  115. name3 := "other-cluster"
  116. out, err := d.Cmd("service", "create", "--name", name1, "busybox", "top")
  117. c.Assert(err, checker.IsNil)
  118. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  119. out, err = d.Cmd("service", "create", "--name", name2, "busybox", "top")
  120. c.Assert(err, checker.IsNil)
  121. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  122. out, err = d.Cmd("service", "create", "--name", name3, "busybox", "top")
  123. c.Assert(err, checker.IsNil)
  124. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  125. filter1 := "name=redis-cluster-md5"
  126. filter2 := "name=redis-cluster"
  127. // We search checker.Contains with `name+" "` to prevent prefix only.
  128. out, err = d.Cmd("service", "ls", "--filter", filter1)
  129. c.Assert(err, checker.IsNil)
  130. c.Assert(out, checker.Contains, name1+" ")
  131. c.Assert(out, checker.Not(checker.Contains), name2+" ")
  132. c.Assert(out, checker.Not(checker.Contains), name3+" ")
  133. out, err = d.Cmd("service", "ls", "--filter", filter2)
  134. c.Assert(err, checker.IsNil)
  135. c.Assert(out, checker.Contains, name1+" ")
  136. c.Assert(out, checker.Contains, name2+" ")
  137. c.Assert(out, checker.Not(checker.Contains), name3+" ")
  138. out, err = d.Cmd("service", "ls")
  139. c.Assert(err, checker.IsNil)
  140. c.Assert(out, checker.Contains, name1+" ")
  141. c.Assert(out, checker.Contains, name2+" ")
  142. c.Assert(out, checker.Contains, name3+" ")
  143. }
  144. func (s *DockerSwarmSuite) TestSwarmNodeListFilter(c *check.C) {
  145. d := s.AddDaemon(c, true, true)
  146. out, err := d.Cmd("node", "inspect", "--format", "{{ .Description.Hostname }}", "self")
  147. c.Assert(err, checker.IsNil)
  148. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  149. name := strings.TrimSpace(out)
  150. filter := "name=" + name[:4]
  151. out, err = d.Cmd("node", "ls", "--filter", filter)
  152. c.Assert(err, checker.IsNil)
  153. c.Assert(out, checker.Contains, name)
  154. out, err = d.Cmd("node", "ls", "--filter", "name=none")
  155. c.Assert(err, checker.IsNil)
  156. c.Assert(out, checker.Not(checker.Contains), name)
  157. }
  158. func (s *DockerSwarmSuite) TestSwarmNodeTaskListFilter(c *check.C) {
  159. d := s.AddDaemon(c, true, true)
  160. name := "redis-cluster-md5"
  161. out, err := d.Cmd("service", "create", "--name", name, "--replicas=3", "busybox", "top")
  162. c.Assert(err, checker.IsNil)
  163. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  164. // make sure task has been deployed.
  165. waitAndAssert(c, defaultReconciliationTimeout, d.checkActiveContainerCount, checker.Equals, 3)
  166. filter := "name=redis-cluster"
  167. out, err = d.Cmd("node", "ps", "--filter", filter, "self")
  168. c.Assert(err, checker.IsNil)
  169. c.Assert(out, checker.Contains, name+".1")
  170. c.Assert(out, checker.Contains, name+".2")
  171. c.Assert(out, checker.Contains, name+".3")
  172. out, err = d.Cmd("node", "ps", "--filter", "name=none", "self")
  173. c.Assert(err, checker.IsNil)
  174. c.Assert(out, checker.Not(checker.Contains), name+".1")
  175. c.Assert(out, checker.Not(checker.Contains), name+".2")
  176. c.Assert(out, checker.Not(checker.Contains), name+".3")
  177. out, err = d.Cmd("node", "ps", "--filter", "desired-state=running", "self")
  178. c.Assert(err, checker.IsNil)
  179. c.Assert(out, checker.Contains, name+".1")
  180. c.Assert(out, checker.Contains, name+".2")
  181. c.Assert(out, checker.Contains, name+".3")
  182. out, err = d.Cmd("node", "ps", "--filter", "desired-state=shutdown", "self")
  183. c.Assert(err, checker.IsNil)
  184. c.Assert(out, checker.Not(checker.Contains), name+".1")
  185. c.Assert(out, checker.Not(checker.Contains), name+".2")
  186. c.Assert(out, checker.Not(checker.Contains), name+".3")
  187. }
  188. func (s *DockerSwarmSuite) TestSwarmServiceTaskListAll(c *check.C) {
  189. d := s.AddDaemon(c, true, true)
  190. name := "service-task-list-1"
  191. out, err := d.Cmd("service", "create", "--name", name, "--replicas=3", "busybox", "top")
  192. c.Assert(err, checker.IsNil)
  193. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  194. // make sure task has been deployed.
  195. waitAndAssert(c, defaultReconciliationTimeout, d.checkActiveContainerCount, checker.Equals, 3)
  196. out, err = d.Cmd("service", "ps", name)
  197. c.Assert(err, checker.IsNil)
  198. c.Assert(out, checker.Contains, name+".1")
  199. c.Assert(out, checker.Contains, name+".2")
  200. c.Assert(out, checker.Contains, name+".3")
  201. // Get the last container id so we can restart it to cause a task error in the history
  202. containerID, err := d.Cmd("ps", "-q", "-l")
  203. c.Assert(err, checker.IsNil)
  204. _, err = d.Cmd("stop", strings.TrimSpace(containerID))
  205. c.Assert(err, checker.IsNil)
  206. waitAndAssert(c, defaultReconciliationTimeout, d.checkActiveContainerCount, checker.Equals, 3)
  207. out, err = d.Cmd("service", "ps", name)
  208. c.Assert(err, checker.IsNil)
  209. c.Assert(out, checker.Count, name, 3)
  210. out, err = d.Cmd("service", "ps", name, "-a")
  211. c.Assert(err, checker.IsNil)
  212. c.Assert(out, checker.Count, name, 4)
  213. }
  214. func (s *DockerSwarmSuite) TestSwarmNodeTaskListAll(c *check.C) {
  215. d := s.AddDaemon(c, true, true)
  216. name := "node-task-list"
  217. out, err := d.Cmd("service", "create", "--name", name, "--replicas=3", "busybox", "top")
  218. c.Assert(err, checker.IsNil)
  219. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  220. // make sure task has been deployed.
  221. waitAndAssert(c, defaultReconciliationTimeout, d.checkActiveContainerCount, checker.Equals, 3)
  222. out, err = d.Cmd("service", "ps", name)
  223. c.Assert(err, checker.IsNil)
  224. c.Assert(out, checker.Contains, name+".1")
  225. c.Assert(out, checker.Contains, name+".2")
  226. c.Assert(out, checker.Contains, name+".3")
  227. // Get the last container id so we can restart it to cause a task error in the history
  228. containerID, err := d.Cmd("ps", "-q", "-l")
  229. c.Assert(err, checker.IsNil)
  230. _, err = d.Cmd("stop", strings.TrimSpace(containerID))
  231. c.Assert(err, checker.IsNil)
  232. waitAndAssert(c, defaultReconciliationTimeout, d.checkActiveContainerCount, checker.Equals, 3)
  233. out, err = d.Cmd("node", "ps", "self")
  234. c.Assert(err, checker.IsNil)
  235. c.Assert(out, checker.Count, name, 3)
  236. out, err = d.Cmd("node", "ps", "self", "-a")
  237. c.Assert(err, checker.IsNil)
  238. c.Assert(out, checker.Count, name, 4)
  239. }
  240. // Test case for #25375
  241. func (s *DockerSwarmSuite) TestSwarmPublishAdd(c *check.C) {
  242. d := s.AddDaemon(c, true, true)
  243. name := "top"
  244. out, err := d.Cmd("service", "create", "--name", name, "--label", "x=y", "busybox", "top")
  245. c.Assert(err, checker.IsNil)
  246. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  247. out, err = d.Cmd("service", "update", "--publish-add", "80:80", name)
  248. c.Assert(err, checker.IsNil)
  249. out, err = d.cmdRetryOutOfSequence("service", "update", "--publish-add", "80:80", name)
  250. c.Assert(err, checker.IsNil)
  251. out, err = d.cmdRetryOutOfSequence("service", "update", "--publish-add", "80:80", "--publish-add", "80:20", name)
  252. c.Assert(err, checker.NotNil)
  253. out, err = d.cmdRetryOutOfSequence("service", "update", "--publish-add", "80:20", name)
  254. c.Assert(err, checker.IsNil)
  255. out, err = d.Cmd("service", "inspect", "--format", "{{ .Spec.EndpointSpec.Ports }}", name)
  256. c.Assert(err, checker.IsNil)
  257. c.Assert(strings.TrimSpace(out), checker.Equals, "[{ tcp 20 80}]")
  258. }
  259. func (s *DockerSwarmSuite) TestSwarmServiceWithGroup(c *check.C) {
  260. d := s.AddDaemon(c, true, true)
  261. name := "top"
  262. out, err := d.Cmd("service", "create", "--name", name, "--user", "root:root", "--group", "wheel", "--group", "audio", "--group", "staff", "--group", "777", "busybox", "top")
  263. c.Assert(err, checker.IsNil)
  264. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  265. // make sure task has been deployed.
  266. waitAndAssert(c, defaultReconciliationTimeout, d.checkActiveContainerCount, checker.Equals, 1)
  267. out, err = d.Cmd("ps", "-q")
  268. c.Assert(err, checker.IsNil)
  269. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  270. container := strings.TrimSpace(out)
  271. out, err = d.Cmd("exec", container, "id")
  272. c.Assert(err, checker.IsNil)
  273. c.Assert(strings.TrimSpace(out), checker.Equals, "uid=0(root) gid=0(root) groups=10(wheel),29(audio),50(staff),777")
  274. }
  275. func (s *DockerSwarmSuite) TestSwarmContainerAutoStart(c *check.C) {
  276. d := s.AddDaemon(c, true, true)
  277. out, err := d.Cmd("network", "create", "--attachable", "-d", "overlay", "foo")
  278. c.Assert(err, checker.IsNil)
  279. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  280. out, err = d.Cmd("run", "-id", "--restart=always", "--net=foo", "--name=test", "busybox", "top")
  281. c.Assert(err, checker.IsNil, check.Commentf(out))
  282. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  283. out, err = d.Cmd("ps", "-q")
  284. c.Assert(err, checker.IsNil, check.Commentf(out))
  285. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  286. d.Restart()
  287. out, err = d.Cmd("ps", "-q")
  288. c.Assert(err, checker.IsNil, check.Commentf(out))
  289. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  290. }
  291. func (s *DockerSwarmSuite) TestSwarmContainerEndpointOptions(c *check.C) {
  292. d := s.AddDaemon(c, true, true)
  293. out, err := d.Cmd("network", "create", "--attachable", "-d", "overlay", "foo")
  294. c.Assert(err, checker.IsNil, check.Commentf(out))
  295. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  296. _, err = d.Cmd("run", "-d", "--net=foo", "--name=first", "--net-alias=first-alias", "busybox", "top")
  297. c.Assert(err, checker.IsNil, check.Commentf(out))
  298. _, err = d.Cmd("run", "-d", "--net=foo", "--name=second", "busybox", "top")
  299. c.Assert(err, checker.IsNil, check.Commentf(out))
  300. // ping first container and its alias
  301. _, err = d.Cmd("exec", "second", "ping", "-c", "1", "first")
  302. c.Assert(err, check.IsNil, check.Commentf(out))
  303. _, err = d.Cmd("exec", "second", "ping", "-c", "1", "first-alias")
  304. c.Assert(err, check.IsNil, check.Commentf(out))
  305. }
  306. func (s *DockerSwarmSuite) TestSwarmContainerAttachByNetworkId(c *check.C) {
  307. d := s.AddDaemon(c, true, true)
  308. out, err := d.Cmd("network", "create", "--attachable", "-d", "overlay", "testnet")
  309. c.Assert(err, checker.IsNil)
  310. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  311. networkID := strings.TrimSpace(out)
  312. out, err = d.Cmd("run", "-d", "--net", networkID, "busybox", "top")
  313. c.Assert(err, checker.IsNil)
  314. cID := strings.TrimSpace(out)
  315. d.waitRun(cID)
  316. _, err = d.Cmd("rm", "-f", cID)
  317. c.Assert(err, checker.IsNil)
  318. out, err = d.Cmd("network", "rm", "testnet")
  319. c.Assert(err, checker.IsNil)
  320. checkNetwork := func(*check.C) (interface{}, check.CommentInterface) {
  321. out, err := d.Cmd("network", "ls")
  322. c.Assert(err, checker.IsNil)
  323. return out, nil
  324. }
  325. waitAndAssert(c, 3*time.Second, checkNetwork, checker.Not(checker.Contains), "testnet")
  326. }
  327. func (s *DockerSwarmSuite) TestSwarmRemoveInternalNetwork(c *check.C) {
  328. d := s.AddDaemon(c, true, true)
  329. name := "ingress"
  330. out, err := d.Cmd("network", "rm", name)
  331. c.Assert(err, checker.NotNil)
  332. c.Assert(strings.TrimSpace(out), checker.Contains, name)
  333. c.Assert(strings.TrimSpace(out), checker.Contains, "is a pre-defined network and cannot be removed")
  334. }
  335. // Test case for #24108, also the case from:
  336. // https://github.com/docker/docker/pull/24620#issuecomment-233715656
  337. func (s *DockerSwarmSuite) TestSwarmTaskListFilter(c *check.C) {
  338. d := s.AddDaemon(c, true, true)
  339. name := "redis-cluster-md5"
  340. out, err := d.Cmd("service", "create", "--name", name, "--replicas=3", "busybox", "top")
  341. c.Assert(err, checker.IsNil)
  342. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  343. filter := "name=redis-cluster"
  344. checkNumTasks := func(*check.C) (interface{}, check.CommentInterface) {
  345. out, err := d.Cmd("service", "ps", "--filter", filter, name)
  346. c.Assert(err, checker.IsNil)
  347. return len(strings.Split(out, "\n")) - 2, nil // includes header and nl in last line
  348. }
  349. // wait until all tasks have been created
  350. waitAndAssert(c, defaultReconciliationTimeout, checkNumTasks, checker.Equals, 3)
  351. out, err = d.Cmd("service", "ps", "--filter", filter, name)
  352. c.Assert(err, checker.IsNil)
  353. c.Assert(out, checker.Contains, name+".1")
  354. c.Assert(out, checker.Contains, name+".2")
  355. c.Assert(out, checker.Contains, name+".3")
  356. out, err = d.Cmd("service", "ps", "--filter", "name="+name+".1", name)
  357. c.Assert(err, checker.IsNil)
  358. c.Assert(out, checker.Contains, name+".1")
  359. c.Assert(out, checker.Not(checker.Contains), name+".2")
  360. c.Assert(out, checker.Not(checker.Contains), name+".3")
  361. out, err = d.Cmd("service", "ps", "--filter", "name=none", name)
  362. c.Assert(err, checker.IsNil)
  363. c.Assert(out, checker.Not(checker.Contains), name+".1")
  364. c.Assert(out, checker.Not(checker.Contains), name+".2")
  365. c.Assert(out, checker.Not(checker.Contains), name+".3")
  366. name = "redis-cluster-sha1"
  367. out, err = d.Cmd("service", "create", "--name", name, "--mode=global", "busybox", "top")
  368. c.Assert(err, checker.IsNil)
  369. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  370. waitAndAssert(c, defaultReconciliationTimeout, checkNumTasks, checker.Equals, 1)
  371. filter = "name=redis-cluster"
  372. out, err = d.Cmd("service", "ps", "--filter", filter, name)
  373. c.Assert(err, checker.IsNil)
  374. c.Assert(out, checker.Contains, name)
  375. out, err = d.Cmd("service", "ps", "--filter", "name="+name, name)
  376. c.Assert(err, checker.IsNil)
  377. c.Assert(out, checker.Contains, name)
  378. out, err = d.Cmd("service", "ps", "--filter", "name=none", name)
  379. c.Assert(err, checker.IsNil)
  380. c.Assert(out, checker.Not(checker.Contains), name)
  381. }
  382. func (s *DockerSwarmSuite) TestPsListContainersFilterIsTask(c *check.C) {
  383. d := s.AddDaemon(c, true, true)
  384. // Create a bare container
  385. out, err := d.Cmd("run", "-d", "--name=bare-container", "busybox", "top")
  386. c.Assert(err, checker.IsNil)
  387. bareID := strings.TrimSpace(out)[:12]
  388. // Create a service
  389. name := "busybox-top"
  390. out, err = d.Cmd("service", "create", "--name", name, "busybox", "top")
  391. c.Assert(err, checker.IsNil)
  392. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  393. // make sure task has been deployed.
  394. waitAndAssert(c, defaultReconciliationTimeout, d.checkServiceRunningTasks(name), checker.Equals, 1)
  395. // Filter non-tasks
  396. out, err = d.Cmd("ps", "-a", "-q", "--filter=is-task=false")
  397. c.Assert(err, checker.IsNil)
  398. psOut := strings.TrimSpace(out)
  399. c.Assert(psOut, checker.Equals, bareID, check.Commentf("Expected id %s, got %s for is-task label, output %q", bareID, psOut, out))
  400. // Filter tasks
  401. out, err = d.Cmd("ps", "-a", "-q", "--filter=is-task=true")
  402. c.Assert(err, checker.IsNil)
  403. lines := strings.Split(strings.Trim(out, "\n "), "\n")
  404. c.Assert(lines, checker.HasLen, 1)
  405. c.Assert(lines[0], checker.Not(checker.Equals), bareID, check.Commentf("Expected not %s, but got it for is-task label, output %q", bareID, out))
  406. }
  407. const globalNetworkPlugin = "global-network-plugin"
  408. const globalIPAMPlugin = "global-ipam-plugin"
  409. func (s *DockerSwarmSuite) SetUpSuite(c *check.C) {
  410. mux := http.NewServeMux()
  411. s.server = httptest.NewServer(mux)
  412. c.Assert(s.server, check.NotNil, check.Commentf("Failed to start an HTTP Server"))
  413. setupRemoteGlobalNetworkPlugin(c, mux, s.server.URL, globalNetworkPlugin, globalIPAMPlugin)
  414. }
  415. func setupRemoteGlobalNetworkPlugin(c *check.C, mux *http.ServeMux, url, netDrv, ipamDrv string) {
  416. mux.HandleFunc("/Plugin.Activate", func(w http.ResponseWriter, r *http.Request) {
  417. w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")
  418. fmt.Fprintf(w, `{"Implements": ["%s", "%s"]}`, driverapi.NetworkPluginEndpointType, ipamapi.PluginEndpointType)
  419. })
  420. // Network driver implementation
  421. mux.HandleFunc(fmt.Sprintf("/%s.GetCapabilities", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
  422. w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")
  423. fmt.Fprintf(w, `{"Scope":"global"}`)
  424. })
  425. mux.HandleFunc(fmt.Sprintf("/%s.AllocateNetwork", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
  426. err := json.NewDecoder(r.Body).Decode(&remoteDriverNetworkRequest)
  427. if err != nil {
  428. http.Error(w, "Unable to decode JSON payload: "+err.Error(), http.StatusBadRequest)
  429. return
  430. }
  431. w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")
  432. fmt.Fprintf(w, "null")
  433. })
  434. mux.HandleFunc(fmt.Sprintf("/%s.FreeNetwork", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
  435. w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")
  436. fmt.Fprintf(w, "null")
  437. })
  438. mux.HandleFunc(fmt.Sprintf("/%s.CreateNetwork", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
  439. err := json.NewDecoder(r.Body).Decode(&remoteDriverNetworkRequest)
  440. if err != nil {
  441. http.Error(w, "Unable to decode JSON payload: "+err.Error(), http.StatusBadRequest)
  442. return
  443. }
  444. w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")
  445. fmt.Fprintf(w, "null")
  446. })
  447. mux.HandleFunc(fmt.Sprintf("/%s.DeleteNetwork", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
  448. w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")
  449. fmt.Fprintf(w, "null")
  450. })
  451. mux.HandleFunc(fmt.Sprintf("/%s.CreateEndpoint", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
  452. w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")
  453. fmt.Fprintf(w, `{"Interface":{"MacAddress":"a0:b1:c2:d3:e4:f5"}}`)
  454. })
  455. mux.HandleFunc(fmt.Sprintf("/%s.Join", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
  456. w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")
  457. veth := &netlink.Veth{
  458. LinkAttrs: netlink.LinkAttrs{Name: "randomIfName", TxQLen: 0}, PeerName: "cnt0"}
  459. if err := netlink.LinkAdd(veth); err != nil {
  460. fmt.Fprintf(w, `{"Error":"failed to add veth pair: `+err.Error()+`"}`)
  461. } else {
  462. fmt.Fprintf(w, `{"InterfaceName":{ "SrcName":"cnt0", "DstPrefix":"veth"}}`)
  463. }
  464. })
  465. mux.HandleFunc(fmt.Sprintf("/%s.Leave", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
  466. w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")
  467. fmt.Fprintf(w, "null")
  468. })
  469. mux.HandleFunc(fmt.Sprintf("/%s.DeleteEndpoint", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
  470. w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")
  471. if link, err := netlink.LinkByName("cnt0"); err == nil {
  472. netlink.LinkDel(link)
  473. }
  474. fmt.Fprintf(w, "null")
  475. })
  476. // IPAM Driver implementation
  477. var (
  478. poolRequest remoteipam.RequestPoolRequest
  479. poolReleaseReq remoteipam.ReleasePoolRequest
  480. addressRequest remoteipam.RequestAddressRequest
  481. addressReleaseReq remoteipam.ReleaseAddressRequest
  482. lAS = "localAS"
  483. gAS = "globalAS"
  484. pool = "172.28.0.0/16"
  485. poolID = lAS + "/" + pool
  486. gw = "172.28.255.254/16"
  487. )
  488. mux.HandleFunc(fmt.Sprintf("/%s.GetDefaultAddressSpaces", ipamapi.PluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
  489. w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")
  490. fmt.Fprintf(w, `{"LocalDefaultAddressSpace":"`+lAS+`", "GlobalDefaultAddressSpace": "`+gAS+`"}`)
  491. })
  492. mux.HandleFunc(fmt.Sprintf("/%s.RequestPool", ipamapi.PluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
  493. err := json.NewDecoder(r.Body).Decode(&poolRequest)
  494. if err != nil {
  495. http.Error(w, "Unable to decode JSON payload: "+err.Error(), http.StatusBadRequest)
  496. return
  497. }
  498. w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")
  499. if poolRequest.AddressSpace != lAS && poolRequest.AddressSpace != gAS {
  500. fmt.Fprintf(w, `{"Error":"Unknown address space in pool request: `+poolRequest.AddressSpace+`"}`)
  501. } else if poolRequest.Pool != "" && poolRequest.Pool != pool {
  502. fmt.Fprintf(w, `{"Error":"Cannot handle explicit pool requests yet"}`)
  503. } else {
  504. fmt.Fprintf(w, `{"PoolID":"`+poolID+`", "Pool":"`+pool+`"}`)
  505. }
  506. })
  507. mux.HandleFunc(fmt.Sprintf("/%s.RequestAddress", ipamapi.PluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
  508. err := json.NewDecoder(r.Body).Decode(&addressRequest)
  509. if err != nil {
  510. http.Error(w, "Unable to decode JSON payload: "+err.Error(), http.StatusBadRequest)
  511. return
  512. }
  513. w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")
  514. // make sure libnetwork is now querying on the expected pool id
  515. if addressRequest.PoolID != poolID {
  516. fmt.Fprintf(w, `{"Error":"unknown pool id"}`)
  517. } else if addressRequest.Address != "" {
  518. fmt.Fprintf(w, `{"Error":"Cannot handle explicit address requests yet"}`)
  519. } else {
  520. fmt.Fprintf(w, `{"Address":"`+gw+`"}`)
  521. }
  522. })
  523. mux.HandleFunc(fmt.Sprintf("/%s.ReleaseAddress", ipamapi.PluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
  524. err := json.NewDecoder(r.Body).Decode(&addressReleaseReq)
  525. if err != nil {
  526. http.Error(w, "Unable to decode JSON payload: "+err.Error(), http.StatusBadRequest)
  527. return
  528. }
  529. w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")
  530. // make sure libnetwork is now asking to release the expected address from the expected poolid
  531. if addressRequest.PoolID != poolID {
  532. fmt.Fprintf(w, `{"Error":"unknown pool id"}`)
  533. } else if addressReleaseReq.Address != gw {
  534. fmt.Fprintf(w, `{"Error":"unknown address"}`)
  535. } else {
  536. fmt.Fprintf(w, "null")
  537. }
  538. })
  539. mux.HandleFunc(fmt.Sprintf("/%s.ReleasePool", ipamapi.PluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
  540. err := json.NewDecoder(r.Body).Decode(&poolReleaseReq)
  541. if err != nil {
  542. http.Error(w, "Unable to decode JSON payload: "+err.Error(), http.StatusBadRequest)
  543. return
  544. }
  545. w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")
  546. // make sure libnetwork is now asking to release the expected poolid
  547. if addressRequest.PoolID != poolID {
  548. fmt.Fprintf(w, `{"Error":"unknown pool id"}`)
  549. } else {
  550. fmt.Fprintf(w, "null")
  551. }
  552. })
  553. err := os.MkdirAll("/etc/docker/plugins", 0755)
  554. c.Assert(err, checker.IsNil)
  555. fileName := fmt.Sprintf("/etc/docker/plugins/%s.spec", netDrv)
  556. err = ioutil.WriteFile(fileName, []byte(url), 0644)
  557. c.Assert(err, checker.IsNil)
  558. ipamFileName := fmt.Sprintf("/etc/docker/plugins/%s.spec", ipamDrv)
  559. err = ioutil.WriteFile(ipamFileName, []byte(url), 0644)
  560. c.Assert(err, checker.IsNil)
  561. }
  562. func (s *DockerSwarmSuite) TestSwarmNetworkPlugin(c *check.C) {
  563. d := s.AddDaemon(c, true, true)
  564. out, err := d.Cmd("network", "create", "-d", globalNetworkPlugin, "foo")
  565. c.Assert(err, checker.IsNil)
  566. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  567. name := "top"
  568. out, err = d.Cmd("service", "create", "--name", name, "--network", "foo", "busybox", "top")
  569. c.Assert(err, checker.IsNil)
  570. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  571. out, err = d.Cmd("service", "inspect", "--format", "{{range .Spec.Networks}}{{.Target}}{{end}}", name)
  572. c.Assert(err, checker.IsNil)
  573. c.Assert(strings.TrimSpace(out), checker.Equals, "foo")
  574. }
  575. // Test case for #24712
  576. func (s *DockerSwarmSuite) TestSwarmServiceEnvFile(c *check.C) {
  577. d := s.AddDaemon(c, true, true)
  578. path := filepath.Join(d.folder, "env.txt")
  579. err := ioutil.WriteFile(path, []byte("VAR1=A\nVAR2=A\n"), 0644)
  580. c.Assert(err, checker.IsNil)
  581. name := "worker"
  582. out, err := d.Cmd("service", "create", "--env-file", path, "--env", "VAR1=B", "--env", "VAR1=C", "--env", "VAR2=", "--env", "VAR2", "--name", name, "busybox", "top")
  583. c.Assert(err, checker.IsNil)
  584. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  585. // The complete env is [VAR1=A VAR2=A VAR1=B VAR1=C VAR2= VAR2] and duplicates will be removed => [VAR1=C VAR2]
  586. out, err = d.Cmd("inspect", "--format", "{{ .Spec.TaskTemplate.ContainerSpec.Env }}", name)
  587. c.Assert(err, checker.IsNil)
  588. c.Assert(out, checker.Contains, "[VAR1=C VAR2]")
  589. }
  590. func (s *DockerSwarmSuite) TestSwarmServiceTTY(c *check.C) {
  591. d := s.AddDaemon(c, true, true)
  592. name := "top"
  593. ttyCheck := "if [ -t 0 ]; then echo TTY > /status && top; else echo none > /status && top; fi"
  594. // Without --tty
  595. expectedOutput := "none"
  596. out, err := d.Cmd("service", "create", "--name", name, "busybox", "sh", "-c", ttyCheck)
  597. c.Assert(err, checker.IsNil)
  598. // Make sure task has been deployed.
  599. waitAndAssert(c, defaultReconciliationTimeout, d.checkActiveContainerCount, checker.Equals, 1)
  600. // We need to get the container id.
  601. out, err = d.Cmd("ps", "-a", "-q", "--no-trunc")
  602. c.Assert(err, checker.IsNil)
  603. id := strings.TrimSpace(out)
  604. out, err = d.Cmd("exec", id, "cat", "/status")
  605. c.Assert(err, checker.IsNil)
  606. c.Assert(out, checker.Contains, expectedOutput, check.Commentf("Expected '%s', but got %q", expectedOutput, out))
  607. // Remove service
  608. out, err = d.Cmd("service", "rm", name)
  609. c.Assert(err, checker.IsNil)
  610. // Make sure container has been destroyed.
  611. waitAndAssert(c, defaultReconciliationTimeout, d.checkActiveContainerCount, checker.Equals, 0)
  612. // With --tty
  613. expectedOutput = "TTY"
  614. out, err = d.Cmd("service", "create", "--name", name, "--tty", "busybox", "sh", "-c", ttyCheck)
  615. c.Assert(err, checker.IsNil)
  616. // Make sure task has been deployed.
  617. waitAndAssert(c, defaultReconciliationTimeout, d.checkActiveContainerCount, checker.Equals, 1)
  618. // We need to get the container id.
  619. out, err = d.Cmd("ps", "-a", "-q", "--no-trunc")
  620. c.Assert(err, checker.IsNil)
  621. id = strings.TrimSpace(out)
  622. out, err = d.Cmd("exec", id, "cat", "/status")
  623. c.Assert(err, checker.IsNil)
  624. c.Assert(out, checker.Contains, expectedOutput, check.Commentf("Expected '%s', but got %q", expectedOutput, out))
  625. }
  626. func (s *DockerSwarmSuite) TestSwarmServiceTTYUpdate(c *check.C) {
  627. d := s.AddDaemon(c, true, true)
  628. // Create a service
  629. name := "top"
  630. _, err := d.Cmd("service", "create", "--name", name, "busybox", "top")
  631. c.Assert(err, checker.IsNil)
  632. // Make sure task has been deployed.
  633. waitAndAssert(c, defaultReconciliationTimeout, d.checkActiveContainerCount, checker.Equals, 1)
  634. out, err := d.Cmd("service", "inspect", "--format", "{{ .Spec.TaskTemplate.ContainerSpec.TTY }}", name)
  635. c.Assert(err, checker.IsNil)
  636. c.Assert(strings.TrimSpace(out), checker.Equals, "false")
  637. _, err = d.Cmd("service", "update", "--tty", name)
  638. c.Assert(err, checker.IsNil)
  639. out, err = d.Cmd("service", "inspect", "--format", "{{ .Spec.TaskTemplate.ContainerSpec.TTY }}", name)
  640. c.Assert(err, checker.IsNil)
  641. c.Assert(strings.TrimSpace(out), checker.Equals, "true")
  642. }
  643. func (s *DockerSwarmSuite) TestDNSConfig(c *check.C) {
  644. d := s.AddDaemon(c, true, true)
  645. // Create a service
  646. name := "top"
  647. _, err := d.Cmd("service", "create", "--name", name, "--dns=1.2.3.4", "--dns-search=example.com", "--dns-option=timeout:3", "busybox", "top")
  648. c.Assert(err, checker.IsNil)
  649. // Make sure task has been deployed.
  650. waitAndAssert(c, defaultReconciliationTimeout, d.checkActiveContainerCount, checker.Equals, 1)
  651. // We need to get the container id.
  652. out, err := d.Cmd("ps", "-a", "-q", "--no-trunc")
  653. c.Assert(err, checker.IsNil)
  654. id := strings.TrimSpace(out)
  655. // Compare against expected output.
  656. expectedOutput1 := "nameserver 1.2.3.4"
  657. expectedOutput2 := "search example.com"
  658. expectedOutput3 := "options timeout:3"
  659. out, err = d.Cmd("exec", id, "cat", "/etc/resolv.conf")
  660. c.Assert(err, checker.IsNil)
  661. c.Assert(out, checker.Contains, expectedOutput1, check.Commentf("Expected '%s', but got %q", expectedOutput1, out))
  662. c.Assert(out, checker.Contains, expectedOutput2, check.Commentf("Expected '%s', but got %q", expectedOutput2, out))
  663. c.Assert(out, checker.Contains, expectedOutput3, check.Commentf("Expected '%s', but got %q", expectedOutput3, out))
  664. }
  665. func (s *DockerSwarmSuite) TestDNSConfigUpdate(c *check.C) {
  666. d := s.AddDaemon(c, true, true)
  667. // Create a service
  668. name := "top"
  669. _, err := d.Cmd("service", "create", "--name", name, "busybox", "top")
  670. c.Assert(err, checker.IsNil)
  671. // Make sure task has been deployed.
  672. waitAndAssert(c, defaultReconciliationTimeout, d.checkActiveContainerCount, checker.Equals, 1)
  673. _, err = d.Cmd("service", "update", "--dns-add=1.2.3.4", "--dns-search-add=example.com", "--dns-option-add=timeout:3", name)
  674. c.Assert(err, checker.IsNil)
  675. out, err := d.Cmd("service", "inspect", "--format", "{{ .Spec.TaskTemplate.ContainerSpec.DNSConfig }}", name)
  676. c.Assert(err, checker.IsNil)
  677. c.Assert(strings.TrimSpace(out), checker.Equals, "{[1.2.3.4] [example.com] [timeout:3]}")
  678. }
  679. func (s *DockerSwarmSuite) TestSwarmInitLocked(c *check.C) {
  680. d := s.AddDaemon(c, false, false)
  681. outs, err := d.Cmd("swarm", "init", "--autolock")
  682. c.Assert(err, checker.IsNil, check.Commentf("out: %v", outs))
  683. c.Assert(outs, checker.Contains, "docker swarm unlock")
  684. var unlockKey string
  685. for _, line := range strings.Split(outs, "\n") {
  686. if strings.Contains(line, "SWMKEY") {
  687. unlockKey = strings.TrimSpace(line)
  688. break
  689. }
  690. }
  691. c.Assert(unlockKey, checker.Not(checker.Equals), "")
  692. outs, err = d.Cmd("swarm", "unlock-key", "-q")
  693. c.Assert(outs, checker.Equals, unlockKey+"\n")
  694. info, err := d.info()
  695. c.Assert(err, checker.IsNil)
  696. c.Assert(info.LocalNodeState, checker.Equals, swarm.LocalNodeStateActive)
  697. c.Assert(d.Restart(), checker.IsNil)
  698. info, err = d.info()
  699. c.Assert(err, checker.IsNil)
  700. c.Assert(info.LocalNodeState, checker.Equals, swarm.LocalNodeStateLocked)
  701. cmd := d.command("swarm", "unlock")
  702. cmd.Stdin = bytes.NewBufferString("wrong-secret-key")
  703. out, err := cmd.CombinedOutput()
  704. c.Assert(err, checker.NotNil, check.Commentf("out: %v", string(out)))
  705. c.Assert(string(out), checker.Contains, "invalid key")
  706. cmd = d.command("swarm", "unlock")
  707. cmd.Stdin = bytes.NewBufferString(unlockKey)
  708. out, err = cmd.CombinedOutput()
  709. c.Assert(err, checker.IsNil, check.Commentf("out: %v", string(out)))
  710. info, err = d.info()
  711. c.Assert(err, checker.IsNil)
  712. c.Assert(info.LocalNodeState, checker.Equals, swarm.LocalNodeStateActive)
  713. outs, err = d.Cmd("node", "ls")
  714. c.Assert(err, checker.IsNil)
  715. c.Assert(outs, checker.Not(checker.Contains), "Swarm is encrypted and needs to be unlocked")
  716. outs, err = d.Cmd("swarm", "update", "--autolock=false")
  717. c.Assert(err, checker.IsNil, check.Commentf("out: %v", outs))
  718. // Wait for autolock to be turned off
  719. time.Sleep(time.Second)
  720. c.Assert(d.Restart(), checker.IsNil)
  721. info, err = d.info()
  722. c.Assert(err, checker.IsNil)
  723. c.Assert(info.LocalNodeState, checker.Equals, swarm.LocalNodeStateActive)
  724. outs, err = d.Cmd("node", "ls")
  725. c.Assert(err, checker.IsNil)
  726. c.Assert(outs, checker.Not(checker.Contains), "Swarm is encrypted and needs to be unlocked")
  727. }
  728. func (s *DockerSwarmSuite) TestSwarmLeaveLocked(c *check.C) {
  729. d := s.AddDaemon(c, false, false)
  730. outs, err := d.Cmd("swarm", "init", "--autolock")
  731. c.Assert(err, checker.IsNil, check.Commentf("out: %v", outs))
  732. c.Assert(d.Restart("--swarm-default-advertise-addr=lo"), checker.IsNil)
  733. info, err := d.info()
  734. c.Assert(err, checker.IsNil)
  735. c.Assert(info.LocalNodeState, checker.Equals, swarm.LocalNodeStateLocked)
  736. outs, _ = d.Cmd("node", "ls")
  737. c.Assert(outs, checker.Contains, "Swarm is encrypted and needs to be unlocked")
  738. outs, err = d.Cmd("swarm", "leave", "--force")
  739. c.Assert(err, checker.IsNil, check.Commentf("out: %v", outs))
  740. info, err = d.info()
  741. c.Assert(err, checker.IsNil)
  742. c.Assert(info.LocalNodeState, checker.Equals, swarm.LocalNodeStateInactive)
  743. outs, err = d.Cmd("swarm", "init")
  744. c.Assert(err, checker.IsNil, check.Commentf("out: %v", outs))
  745. info, err = d.info()
  746. c.Assert(err, checker.IsNil)
  747. c.Assert(info.LocalNodeState, checker.Equals, swarm.LocalNodeStateActive)
  748. }
  749. func (s *DockerSwarmSuite) TestSwarmRotateUnlockKey(c *check.C) {
  750. d := s.AddDaemon(c, true, true)
  751. outs, err := d.Cmd("swarm", "update", "--autolock")
  752. c.Assert(err, checker.IsNil, check.Commentf("out: %v", outs))
  753. c.Assert(outs, checker.Contains, "docker swarm unlock")
  754. var unlockKey string
  755. for _, line := range strings.Split(outs, "\n") {
  756. if strings.Contains(line, "SWMKEY") {
  757. unlockKey = strings.TrimSpace(line)
  758. break
  759. }
  760. }
  761. c.Assert(unlockKey, checker.Not(checker.Equals), "")
  762. outs, err = d.Cmd("swarm", "unlock-key", "-q")
  763. c.Assert(outs, checker.Equals, unlockKey+"\n")
  764. // Rotate multiple times
  765. for i := 0; i != 3; i++ {
  766. outs, err = d.Cmd("swarm", "unlock-key", "-q", "--rotate")
  767. c.Assert(err, checker.IsNil, check.Commentf("out: %v", outs))
  768. // Strip \n
  769. newUnlockKey := outs[:len(outs)-1]
  770. c.Assert(newUnlockKey, checker.Not(checker.Equals), "")
  771. c.Assert(d.Restart(), checker.IsNil)
  772. info, err := d.info()
  773. c.Assert(err, checker.IsNil)
  774. c.Assert(info.LocalNodeState, checker.Equals, swarm.LocalNodeStateLocked)
  775. outs, _ = d.Cmd("node", "ls")
  776. c.Assert(outs, checker.Contains, "Swarm is encrypted and needs to be unlocked")
  777. cmd := d.command("swarm", "unlock")
  778. cmd.Stdin = bytes.NewBufferString(unlockKey)
  779. out, err := cmd.CombinedOutput()
  780. if err == nil {
  781. // On occasion, the daemon may not have finished
  782. // rotating the KEK before restarting. The test is
  783. // intentionally written to explore this behavior.
  784. // When this happens, unlocking with the old key will
  785. // succeed. If we wait for the rotation to happen and
  786. // restart again, the new key should be required this
  787. // time.
  788. time.Sleep(3 * time.Second)
  789. c.Assert(d.Restart(), checker.IsNil)
  790. cmd = d.command("swarm", "unlock")
  791. cmd.Stdin = bytes.NewBufferString(unlockKey)
  792. out, err = cmd.CombinedOutput()
  793. }
  794. c.Assert(err, checker.NotNil, check.Commentf("out: %v", string(out)))
  795. c.Assert(string(out), checker.Contains, "invalid key")
  796. outs, _ = d.Cmd("node", "ls")
  797. c.Assert(outs, checker.Contains, "Swarm is encrypted and needs to be unlocked")
  798. cmd = d.command("swarm", "unlock")
  799. cmd.Stdin = bytes.NewBufferString(newUnlockKey)
  800. out, err = cmd.CombinedOutput()
  801. c.Assert(err, checker.IsNil, check.Commentf("out: %v", string(out)))
  802. info, err = d.info()
  803. c.Assert(err, checker.IsNil)
  804. c.Assert(info.LocalNodeState, checker.Equals, swarm.LocalNodeStateActive)
  805. outs, err = d.Cmd("node", "ls")
  806. c.Assert(err, checker.IsNil)
  807. c.Assert(outs, checker.Not(checker.Contains), "Swarm is encrypted and needs to be unlocked")
  808. }
  809. }
  810. func (s *DockerSwarmSuite) TestExtraHosts(c *check.C) {
  811. d := s.AddDaemon(c, true, true)
  812. // Create a service
  813. name := "top"
  814. _, err := d.Cmd("service", "create", "--name", name, "--host=example.com:1.2.3.4", "busybox", "top")
  815. c.Assert(err, checker.IsNil)
  816. // Make sure task has been deployed.
  817. waitAndAssert(c, defaultReconciliationTimeout, d.checkActiveContainerCount, checker.Equals, 1)
  818. // We need to get the container id.
  819. out, err := d.Cmd("ps", "-a", "-q", "--no-trunc")
  820. c.Assert(err, checker.IsNil)
  821. id := strings.TrimSpace(out)
  822. // Compare against expected output.
  823. expectedOutput := "1.2.3.4\texample.com"
  824. out, err = d.Cmd("exec", id, "cat", "/etc/hosts")
  825. c.Assert(err, checker.IsNil)
  826. c.Assert(out, checker.Contains, expectedOutput, check.Commentf("Expected '%s', but got %q", expectedOutput, out))
  827. }