docker_cli_swarm_test.go 40 KB

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