docker_cli_swarm_test.go 72 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929
  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. "os/exec"
  12. "path/filepath"
  13. "strings"
  14. "time"
  15. "github.com/docker/docker/api/types"
  16. "github.com/docker/docker/api/types/swarm"
  17. "github.com/docker/docker/integration-cli/checker"
  18. "github.com/docker/docker/integration-cli/cli"
  19. "github.com/docker/docker/integration-cli/daemon"
  20. "github.com/docker/docker/pkg/testutil"
  21. icmd "github.com/docker/docker/pkg/testutil/cmd"
  22. "github.com/docker/libnetwork/driverapi"
  23. "github.com/docker/libnetwork/ipamapi"
  24. remoteipam "github.com/docker/libnetwork/ipams/remote/api"
  25. "github.com/go-check/check"
  26. "github.com/vishvananda/netlink"
  27. )
  28. func (s *DockerSwarmSuite) TestSwarmUpdate(c *check.C) {
  29. d := s.AddDaemon(c, true, true)
  30. getSpec := func() swarm.Spec {
  31. sw := d.GetSwarm(c)
  32. return sw.Spec
  33. }
  34. out, err := d.Cmd("swarm", "update", "--cert-expiry", "30h", "--dispatcher-heartbeat", "11s")
  35. c.Assert(err, checker.IsNil, check.Commentf("out: %v", out))
  36. spec := getSpec()
  37. c.Assert(spec.CAConfig.NodeCertExpiry, checker.Equals, 30*time.Hour)
  38. c.Assert(spec.Dispatcher.HeartbeatPeriod, checker.Equals, 11*time.Second)
  39. // setting anything under 30m for cert-expiry is not allowed
  40. out, err = d.Cmd("swarm", "update", "--cert-expiry", "15m")
  41. c.Assert(err, checker.NotNil)
  42. c.Assert(out, checker.Contains, "minimum certificate expiry time")
  43. spec = getSpec()
  44. c.Assert(spec.CAConfig.NodeCertExpiry, checker.Equals, 30*time.Hour)
  45. }
  46. func (s *DockerSwarmSuite) TestSwarmInit(c *check.C) {
  47. d := s.AddDaemon(c, false, false)
  48. getSpec := func() swarm.Spec {
  49. sw := d.GetSwarm(c)
  50. return sw.Spec
  51. }
  52. cli.Docker(cli.Args("swarm", "init", "--cert-expiry", "30h", "--dispatcher-heartbeat", "11s"),
  53. cli.Daemon(d.Daemon)).Assert(c, icmd.Success)
  54. spec := getSpec()
  55. c.Assert(spec.CAConfig.NodeCertExpiry, checker.Equals, 30*time.Hour)
  56. c.Assert(spec.Dispatcher.HeartbeatPeriod, checker.Equals, 11*time.Second)
  57. c.Assert(d.Leave(true), checker.IsNil)
  58. time.Sleep(500 * time.Millisecond) // https://github.com/docker/swarmkit/issues/1421
  59. cli.Docker(cli.Args("swarm", "init"), cli.Daemon(d.Daemon)).Assert(c, icmd.Success)
  60. spec = getSpec()
  61. c.Assert(spec.CAConfig.NodeCertExpiry, checker.Equals, 90*24*time.Hour)
  62. c.Assert(spec.Dispatcher.HeartbeatPeriod, checker.Equals, 5*time.Second)
  63. }
  64. func (s *DockerSwarmSuite) TestSwarmInitIPv6(c *check.C) {
  65. testRequires(c, IPv6)
  66. d1 := s.AddDaemon(c, false, false)
  67. cli.Docker(cli.Args("swarm", "init", "--listen-add", "::1"), cli.Daemon(d1.Daemon)).Assert(c, icmd.Success)
  68. d2 := s.AddDaemon(c, false, false)
  69. cli.Docker(cli.Args("swarm", "join", "::1"), cli.Daemon(d2.Daemon)).Assert(c, icmd.Success)
  70. out := cli.Docker(cli.Args("info"), cli.Daemon(d2.Daemon)).Assert(c, icmd.Success).Combined()
  71. c.Assert(out, checker.Contains, "Swarm: active")
  72. }
  73. func (s *DockerSwarmSuite) TestSwarmInitUnspecifiedAdvertiseAddr(c *check.C) {
  74. d := s.AddDaemon(c, false, false)
  75. out, err := d.Cmd("swarm", "init", "--advertise-addr", "0.0.0.0")
  76. c.Assert(err, checker.NotNil)
  77. c.Assert(out, checker.Contains, "advertise address must be a non-zero IP address")
  78. }
  79. func (s *DockerSwarmSuite) TestSwarmIncompatibleDaemon(c *check.C) {
  80. // init swarm mode and stop a daemon
  81. d := s.AddDaemon(c, true, true)
  82. info, err := d.SwarmInfo()
  83. c.Assert(err, checker.IsNil)
  84. c.Assert(info.LocalNodeState, checker.Equals, swarm.LocalNodeStateActive)
  85. d.Stop(c)
  86. // start a daemon with --cluster-store and --cluster-advertise
  87. err = d.StartWithError("--cluster-store=consul://consuladdr:consulport/some/path", "--cluster-advertise=1.1.1.1:2375")
  88. c.Assert(err, checker.NotNil)
  89. content, err := d.ReadLogFile()
  90. c.Assert(err, checker.IsNil)
  91. c.Assert(string(content), checker.Contains, "--cluster-store and --cluster-advertise daemon configurations are incompatible with swarm mode")
  92. // start a daemon with --live-restore
  93. err = d.StartWithError("--live-restore")
  94. c.Assert(err, checker.NotNil)
  95. content, err = d.ReadLogFile()
  96. c.Assert(err, checker.IsNil)
  97. c.Assert(string(content), checker.Contains, "--live-restore daemon configuration is incompatible with swarm mode")
  98. // restart for teardown
  99. d.Start(c)
  100. }
  101. func (s *DockerSwarmSuite) TestSwarmServiceTemplatingHostname(c *check.C) {
  102. d := s.AddDaemon(c, true, true)
  103. out, err := d.Cmd("service", "create", "--name", "test", "--hostname", "{{.Service.Name}}-{{.Task.Slot}}", "busybox", "top")
  104. c.Assert(err, checker.IsNil, check.Commentf(out))
  105. // make sure task has been deployed.
  106. waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, 1)
  107. containers := d.ActiveContainers()
  108. out, err = d.Cmd("inspect", "--type", "container", "--format", "{{.Config.Hostname}}", containers[0])
  109. c.Assert(err, checker.IsNil, check.Commentf(out))
  110. c.Assert(strings.Split(out, "\n")[0], checker.Equals, "test-1", check.Commentf("hostname with templating invalid"))
  111. }
  112. // Test case for #24270
  113. func (s *DockerSwarmSuite) TestSwarmServiceListFilter(c *check.C) {
  114. d := s.AddDaemon(c, true, true)
  115. name1 := "redis-cluster-md5"
  116. name2 := "redis-cluster"
  117. name3 := "other-cluster"
  118. out, err := d.Cmd("service", "create", "--name", name1, "busybox", "top")
  119. c.Assert(err, checker.IsNil)
  120. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  121. out, err = d.Cmd("service", "create", "--name", name2, "busybox", "top")
  122. c.Assert(err, checker.IsNil)
  123. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  124. out, err = d.Cmd("service", "create", "--name", name3, "busybox", "top")
  125. c.Assert(err, checker.IsNil)
  126. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  127. filter1 := "name=redis-cluster-md5"
  128. filter2 := "name=redis-cluster"
  129. // We search checker.Contains with `name+" "` to prevent prefix only.
  130. out, err = d.Cmd("service", "ls", "--filter", filter1)
  131. c.Assert(err, checker.IsNil)
  132. c.Assert(out, checker.Contains, name1+" ")
  133. c.Assert(out, checker.Not(checker.Contains), name2+" ")
  134. c.Assert(out, checker.Not(checker.Contains), name3+" ")
  135. out, err = d.Cmd("service", "ls", "--filter", filter2)
  136. c.Assert(err, checker.IsNil)
  137. c.Assert(out, checker.Contains, name1+" ")
  138. c.Assert(out, checker.Contains, name2+" ")
  139. c.Assert(out, checker.Not(checker.Contains), name3+" ")
  140. out, err = d.Cmd("service", "ls")
  141. c.Assert(err, checker.IsNil)
  142. c.Assert(out, checker.Contains, name1+" ")
  143. c.Assert(out, checker.Contains, name2+" ")
  144. c.Assert(out, checker.Contains, name3+" ")
  145. }
  146. func (s *DockerSwarmSuite) TestSwarmNodeListFilter(c *check.C) {
  147. d := s.AddDaemon(c, true, true)
  148. out, err := d.Cmd("node", "inspect", "--format", "{{ .Description.Hostname }}", "self")
  149. c.Assert(err, checker.IsNil)
  150. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  151. name := strings.TrimSpace(out)
  152. filter := "name=" + name[:4]
  153. out, err = d.Cmd("node", "ls", "--filter", filter)
  154. c.Assert(err, checker.IsNil)
  155. c.Assert(out, checker.Contains, name)
  156. out, err = d.Cmd("node", "ls", "--filter", "name=none")
  157. c.Assert(err, checker.IsNil)
  158. c.Assert(out, checker.Not(checker.Contains), name)
  159. }
  160. func (s *DockerSwarmSuite) TestSwarmNodeTaskListFilter(c *check.C) {
  161. d := s.AddDaemon(c, true, true)
  162. name := "redis-cluster-md5"
  163. out, err := d.Cmd("service", "create", "--name", name, "--replicas=3", "busybox", "top")
  164. c.Assert(err, checker.IsNil)
  165. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  166. // make sure task has been deployed.
  167. waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, 3)
  168. filter := "name=redis-cluster"
  169. out, err = d.Cmd("node", "ps", "--filter", filter, "self")
  170. c.Assert(err, checker.IsNil)
  171. c.Assert(out, checker.Contains, name+".1")
  172. c.Assert(out, checker.Contains, name+".2")
  173. c.Assert(out, checker.Contains, name+".3")
  174. out, err = d.Cmd("node", "ps", "--filter", "name=none", "self")
  175. c.Assert(err, checker.IsNil)
  176. c.Assert(out, checker.Not(checker.Contains), name+".1")
  177. c.Assert(out, checker.Not(checker.Contains), name+".2")
  178. c.Assert(out, checker.Not(checker.Contains), name+".3")
  179. }
  180. // Test case for #25375
  181. func (s *DockerSwarmSuite) TestSwarmPublishAdd(c *check.C) {
  182. d := s.AddDaemon(c, true, true)
  183. name := "top"
  184. out, err := d.Cmd("service", "create", "--name", name, "--label", "x=y", "busybox", "top")
  185. c.Assert(err, checker.IsNil)
  186. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  187. out, err = d.Cmd("service", "update", "--publish-add", "80:80", name)
  188. c.Assert(err, checker.IsNil)
  189. out, err = d.CmdRetryOutOfSequence("service", "update", "--publish-add", "80:80", name)
  190. c.Assert(err, checker.IsNil)
  191. out, err = d.CmdRetryOutOfSequence("service", "update", "--publish-add", "80:80", "--publish-add", "80:20", name)
  192. c.Assert(err, checker.NotNil)
  193. out, err = d.Cmd("service", "inspect", "--format", "{{ .Spec.EndpointSpec.Ports }}", name)
  194. c.Assert(err, checker.IsNil)
  195. c.Assert(strings.TrimSpace(out), checker.Equals, "[{ tcp 80 80 ingress}]")
  196. }
  197. func (s *DockerSwarmSuite) TestSwarmServiceWithGroup(c *check.C) {
  198. d := s.AddDaemon(c, true, true)
  199. name := "top"
  200. out, err := d.Cmd("service", "create", "--name", name, "--user", "root:root", "--group", "wheel", "--group", "audio", "--group", "staff", "--group", "777", "busybox", "top")
  201. c.Assert(err, checker.IsNil)
  202. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  203. // make sure task has been deployed.
  204. waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, 1)
  205. out, err = d.Cmd("ps", "-q")
  206. c.Assert(err, checker.IsNil)
  207. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  208. container := strings.TrimSpace(out)
  209. out, err = d.Cmd("exec", container, "id")
  210. c.Assert(err, checker.IsNil)
  211. c.Assert(strings.TrimSpace(out), checker.Equals, "uid=0(root) gid=0(root) groups=10(wheel),29(audio),50(staff),777")
  212. }
  213. func (s *DockerSwarmSuite) TestSwarmContainerAutoStart(c *check.C) {
  214. d := s.AddDaemon(c, true, true)
  215. out, err := d.Cmd("network", "create", "--attachable", "-d", "overlay", "foo")
  216. c.Assert(err, checker.IsNil)
  217. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  218. out, err = d.Cmd("run", "-id", "--restart=always", "--net=foo", "--name=test", "busybox", "top")
  219. c.Assert(err, checker.IsNil, check.Commentf(out))
  220. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  221. out, err = d.Cmd("ps", "-q")
  222. c.Assert(err, checker.IsNil, check.Commentf(out))
  223. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  224. d.Restart(c)
  225. out, err = d.Cmd("ps", "-q")
  226. c.Assert(err, checker.IsNil, check.Commentf(out))
  227. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  228. }
  229. func (s *DockerSwarmSuite) TestSwarmContainerEndpointOptions(c *check.C) {
  230. d := s.AddDaemon(c, true, true)
  231. out, err := d.Cmd("network", "create", "--attachable", "-d", "overlay", "foo")
  232. c.Assert(err, checker.IsNil, check.Commentf(out))
  233. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  234. _, err = d.Cmd("run", "-d", "--net=foo", "--name=first", "--net-alias=first-alias", "busybox", "top")
  235. c.Assert(err, checker.IsNil, check.Commentf(out))
  236. _, err = d.Cmd("run", "-d", "--net=foo", "--name=second", "busybox", "top")
  237. c.Assert(err, checker.IsNil, check.Commentf(out))
  238. _, err = d.Cmd("run", "-d", "--net=foo", "--net-alias=third-alias", "busybox", "top")
  239. c.Assert(err, checker.IsNil, check.Commentf(out))
  240. // ping first container and its alias, also ping third and anonymous container by its alias
  241. _, err = d.Cmd("exec", "second", "ping", "-c", "1", "first")
  242. c.Assert(err, check.IsNil, check.Commentf(out))
  243. _, err = d.Cmd("exec", "second", "ping", "-c", "1", "first-alias")
  244. c.Assert(err, check.IsNil, check.Commentf(out))
  245. _, err = d.Cmd("exec", "second", "ping", "-c", "1", "third-alias")
  246. c.Assert(err, check.IsNil, check.Commentf(out))
  247. }
  248. func (s *DockerSwarmSuite) TestSwarmContainerAttachByNetworkId(c *check.C) {
  249. d := s.AddDaemon(c, true, true)
  250. out, err := d.Cmd("network", "create", "--attachable", "-d", "overlay", "testnet")
  251. c.Assert(err, checker.IsNil)
  252. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  253. networkID := strings.TrimSpace(out)
  254. out, err = d.Cmd("run", "-d", "--net", networkID, "busybox", "top")
  255. c.Assert(err, checker.IsNil)
  256. cID := strings.TrimSpace(out)
  257. d.WaitRun(cID)
  258. _, err = d.Cmd("rm", "-f", cID)
  259. c.Assert(err, checker.IsNil)
  260. _, err = d.Cmd("network", "rm", "testnet")
  261. c.Assert(err, checker.IsNil)
  262. checkNetwork := func(*check.C) (interface{}, check.CommentInterface) {
  263. out, err := d.Cmd("network", "ls")
  264. c.Assert(err, checker.IsNil)
  265. return out, nil
  266. }
  267. waitAndAssert(c, 3*time.Second, checkNetwork, checker.Not(checker.Contains), "testnet")
  268. }
  269. func (s *DockerSwarmSuite) TestOverlayAttachable(c *check.C) {
  270. d := s.AddDaemon(c, true, true)
  271. out, err := d.Cmd("network", "create", "-d", "overlay", "--attachable", "ovnet")
  272. c.Assert(err, checker.IsNil, check.Commentf(out))
  273. // validate attachable
  274. out, err = d.Cmd("network", "inspect", "--format", "{{json .Attachable}}", "ovnet")
  275. c.Assert(err, checker.IsNil, check.Commentf(out))
  276. c.Assert(strings.TrimSpace(out), checker.Equals, "true")
  277. // validate containers can attache to this overlay network
  278. out, err = d.Cmd("run", "-d", "--network", "ovnet", "--name", "c1", "busybox", "top")
  279. c.Assert(err, checker.IsNil, check.Commentf(out))
  280. // redo validation, there was a bug that the value of attachable changes after
  281. // containers attach to the network
  282. out, err = d.Cmd("network", "inspect", "--format", "{{json .Attachable}}", "ovnet")
  283. c.Assert(err, checker.IsNil, check.Commentf(out))
  284. c.Assert(strings.TrimSpace(out), checker.Equals, "true")
  285. }
  286. func (s *DockerSwarmSuite) TestOverlayAttachableOnSwarmLeave(c *check.C) {
  287. d := s.AddDaemon(c, true, true)
  288. // Create an attachable swarm network
  289. nwName := "attovl"
  290. out, err := d.Cmd("network", "create", "-d", "overlay", "--attachable", nwName)
  291. c.Assert(err, checker.IsNil, check.Commentf(out))
  292. // Connect a container to the network
  293. out, err = d.Cmd("run", "-d", "--network", nwName, "--name", "c1", "busybox", "top")
  294. c.Assert(err, checker.IsNil, check.Commentf(out))
  295. // Leave the swarm
  296. err = d.Leave(true)
  297. c.Assert(err, checker.IsNil)
  298. // Check the container is disconnected
  299. out, err = d.Cmd("inspect", "c1", "--format", "{{.NetworkSettings.Networks."+nwName+"}}")
  300. c.Assert(err, checker.IsNil)
  301. c.Assert(strings.TrimSpace(out), checker.Equals, "<no value>")
  302. // Check the network is gone
  303. out, err = d.Cmd("network", "ls", "--format", "{{.Name}}")
  304. c.Assert(err, checker.IsNil)
  305. c.Assert(out, checker.Not(checker.Contains), nwName)
  306. }
  307. func (s *DockerSwarmSuite) TestOverlayAttachableReleaseResourcesOnFailure(c *check.C) {
  308. d := s.AddDaemon(c, true, true)
  309. // Create attachable network
  310. out, err := d.Cmd("network", "create", "-d", "overlay", "--attachable", "--subnet", "10.10.9.0/24", "ovnet")
  311. c.Assert(err, checker.IsNil, check.Commentf(out))
  312. // Attach a container with specific IP
  313. out, err = d.Cmd("run", "-d", "--network", "ovnet", "--name", "c1", "--ip", "10.10.9.33", "busybox", "top")
  314. c.Assert(err, checker.IsNil, check.Commentf(out))
  315. // Attempt to attach another contianer with same IP, must fail
  316. _, err = d.Cmd("run", "-d", "--network", "ovnet", "--name", "c2", "--ip", "10.10.9.33", "busybox", "top")
  317. c.Assert(err, checker.NotNil)
  318. // Remove first container
  319. out, err = d.Cmd("rm", "-f", "c1")
  320. c.Assert(err, checker.IsNil, check.Commentf(out))
  321. // Verify the network can be removed, no phantom network attachment task left over
  322. out, err = d.Cmd("network", "rm", "ovnet")
  323. c.Assert(err, checker.IsNil, check.Commentf(out))
  324. }
  325. func (s *DockerSwarmSuite) TestSwarmIngressNetwork(c *check.C) {
  326. d := s.AddDaemon(c, true, true)
  327. // Ingress network can be removed
  328. out, _, err := testutil.RunCommandPipelineWithOutput(
  329. exec.Command("echo", "Y"),
  330. exec.Command("docker", "-H", d.Sock(), "network", "rm", "ingress"),
  331. )
  332. c.Assert(err, checker.IsNil, check.Commentf(out))
  333. // And recreated
  334. out, err = d.Cmd("network", "create", "-d", "overlay", "--ingress", "new-ingress")
  335. c.Assert(err, checker.IsNil, check.Commentf(out))
  336. // But only one is allowed
  337. out, err = d.Cmd("network", "create", "-d", "overlay", "--ingress", "another-ingress")
  338. c.Assert(err, checker.NotNil)
  339. c.Assert(strings.TrimSpace(out), checker.Contains, "is already present")
  340. // It cannot be removed if it is being used
  341. out, err = d.Cmd("service", "create", "--name", "srv1", "-p", "9000:8000", "busybox", "top")
  342. c.Assert(err, checker.IsNil, check.Commentf(out))
  343. out, _, err = testutil.RunCommandPipelineWithOutput(
  344. exec.Command("echo", "Y"),
  345. exec.Command("docker", "-H", d.Sock(), "network", "rm", "new-ingress"),
  346. )
  347. c.Assert(err, checker.NotNil)
  348. c.Assert(strings.TrimSpace(out), checker.Contains, "ingress network cannot be removed because service")
  349. // But it can be removed once no more services depend on it
  350. out, err = d.Cmd("service", "update", "--publish-rm", "9000:8000", "srv1")
  351. c.Assert(err, checker.IsNil, check.Commentf(out))
  352. out, _, err = testutil.RunCommandPipelineWithOutput(
  353. exec.Command("echo", "Y"),
  354. exec.Command("docker", "-H", d.Sock(), "network", "rm", "new-ingress"),
  355. )
  356. c.Assert(err, checker.IsNil, check.Commentf(out))
  357. // A service which needs the ingress network cannot be created if no ingress is present
  358. out, err = d.Cmd("service", "create", "--name", "srv2", "-p", "500:500", "busybox", "top")
  359. c.Assert(err, checker.NotNil)
  360. c.Assert(strings.TrimSpace(out), checker.Contains, "no ingress network is present")
  361. // An existing service cannot be updated to use the ingress nw if the nw is not present
  362. out, err = d.Cmd("service", "update", "--publish-add", "9000:8000", "srv1")
  363. c.Assert(err, checker.NotNil)
  364. c.Assert(strings.TrimSpace(out), checker.Contains, "no ingress network is present")
  365. // But services which do not need routing mesh can be created regardless
  366. out, err = d.Cmd("service", "create", "--name", "srv3", "--endpoint-mode", "dnsrr", "busybox", "top")
  367. c.Assert(err, checker.IsNil, check.Commentf(out))
  368. }
  369. func (s *DockerSwarmSuite) TestSwarmCreateServiceWithNoIngressNetwork(c *check.C) {
  370. d := s.AddDaemon(c, true, true)
  371. // Remove ingress network
  372. out, _, err := testutil.RunCommandPipelineWithOutput(
  373. exec.Command("echo", "Y"),
  374. exec.Command("docker", "-H", d.Sock(), "network", "rm", "ingress"),
  375. )
  376. c.Assert(err, checker.IsNil, check.Commentf(out))
  377. // Create a overlay network and launch a service on it
  378. // Make sure nothing panics because ingress network is missing
  379. out, err = d.Cmd("network", "create", "-d", "overlay", "another-network")
  380. c.Assert(err, checker.IsNil, check.Commentf(out))
  381. out, err = d.Cmd("service", "create", "--name", "srv4", "--network", "another-network", "busybox", "top")
  382. c.Assert(err, checker.IsNil, check.Commentf(out))
  383. }
  384. // Test case for #24108, also the case from:
  385. // https://github.com/docker/docker/pull/24620#issuecomment-233715656
  386. func (s *DockerSwarmSuite) TestSwarmTaskListFilter(c *check.C) {
  387. d := s.AddDaemon(c, true, true)
  388. name := "redis-cluster-md5"
  389. out, err := d.Cmd("service", "create", "--name", name, "--replicas=3", "busybox", "top")
  390. c.Assert(err, checker.IsNil)
  391. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  392. filter := "name=redis-cluster"
  393. checkNumTasks := func(*check.C) (interface{}, check.CommentInterface) {
  394. out, err := d.Cmd("service", "ps", "--filter", filter, name)
  395. c.Assert(err, checker.IsNil)
  396. return len(strings.Split(out, "\n")) - 2, nil // includes header and nl in last line
  397. }
  398. // wait until all tasks have been created
  399. waitAndAssert(c, defaultReconciliationTimeout, checkNumTasks, checker.Equals, 3)
  400. out, err = d.Cmd("service", "ps", "--filter", filter, name)
  401. c.Assert(err, checker.IsNil)
  402. c.Assert(out, checker.Contains, name+".1")
  403. c.Assert(out, checker.Contains, name+".2")
  404. c.Assert(out, checker.Contains, name+".3")
  405. out, err = d.Cmd("service", "ps", "--filter", "name="+name+".1", name)
  406. c.Assert(err, checker.IsNil)
  407. c.Assert(out, checker.Contains, name+".1")
  408. c.Assert(out, checker.Not(checker.Contains), name+".2")
  409. c.Assert(out, checker.Not(checker.Contains), name+".3")
  410. out, err = d.Cmd("service", "ps", "--filter", "name=none", name)
  411. c.Assert(err, checker.IsNil)
  412. c.Assert(out, checker.Not(checker.Contains), name+".1")
  413. c.Assert(out, checker.Not(checker.Contains), name+".2")
  414. c.Assert(out, checker.Not(checker.Contains), name+".3")
  415. name = "redis-cluster-sha1"
  416. out, err = d.Cmd("service", "create", "--name", name, "--mode=global", "busybox", "top")
  417. c.Assert(err, checker.IsNil)
  418. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  419. waitAndAssert(c, defaultReconciliationTimeout, checkNumTasks, checker.Equals, 1)
  420. filter = "name=redis-cluster"
  421. out, err = d.Cmd("service", "ps", "--filter", filter, name)
  422. c.Assert(err, checker.IsNil)
  423. c.Assert(out, checker.Contains, name)
  424. out, err = d.Cmd("service", "ps", "--filter", "name="+name, name)
  425. c.Assert(err, checker.IsNil)
  426. c.Assert(out, checker.Contains, name)
  427. out, err = d.Cmd("service", "ps", "--filter", "name=none", name)
  428. c.Assert(err, checker.IsNil)
  429. c.Assert(out, checker.Not(checker.Contains), name)
  430. }
  431. func (s *DockerSwarmSuite) TestPsListContainersFilterIsTask(c *check.C) {
  432. d := s.AddDaemon(c, true, true)
  433. // Create a bare container
  434. out, err := d.Cmd("run", "-d", "--name=bare-container", "busybox", "top")
  435. c.Assert(err, checker.IsNil)
  436. bareID := strings.TrimSpace(out)[:12]
  437. // Create a service
  438. name := "busybox-top"
  439. out, err = d.Cmd("service", "create", "--name", name, "busybox", "top")
  440. c.Assert(err, checker.IsNil)
  441. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  442. // make sure task has been deployed.
  443. waitAndAssert(c, defaultReconciliationTimeout, d.CheckServiceRunningTasks(name), checker.Equals, 1)
  444. // Filter non-tasks
  445. out, err = d.Cmd("ps", "-a", "-q", "--filter=is-task=false")
  446. c.Assert(err, checker.IsNil)
  447. psOut := strings.TrimSpace(out)
  448. c.Assert(psOut, checker.Equals, bareID, check.Commentf("Expected id %s, got %s for is-task label, output %q", bareID, psOut, out))
  449. // Filter tasks
  450. out, err = d.Cmd("ps", "-a", "-q", "--filter=is-task=true")
  451. c.Assert(err, checker.IsNil)
  452. lines := strings.Split(strings.Trim(out, "\n "), "\n")
  453. c.Assert(lines, checker.HasLen, 1)
  454. 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))
  455. }
  456. const globalNetworkPlugin = "global-network-plugin"
  457. const globalIPAMPlugin = "global-ipam-plugin"
  458. func setupRemoteGlobalNetworkPlugin(c *check.C, mux *http.ServeMux, url, netDrv, ipamDrv string) {
  459. mux.HandleFunc("/Plugin.Activate", func(w http.ResponseWriter, r *http.Request) {
  460. w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")
  461. fmt.Fprintf(w, `{"Implements": ["%s", "%s"]}`, driverapi.NetworkPluginEndpointType, ipamapi.PluginEndpointType)
  462. })
  463. // Network driver implementation
  464. mux.HandleFunc(fmt.Sprintf("/%s.GetCapabilities", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
  465. w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")
  466. fmt.Fprintf(w, `{"Scope":"global"}`)
  467. })
  468. mux.HandleFunc(fmt.Sprintf("/%s.AllocateNetwork", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
  469. err := json.NewDecoder(r.Body).Decode(&remoteDriverNetworkRequest)
  470. if err != nil {
  471. http.Error(w, "Unable to decode JSON payload: "+err.Error(), http.StatusBadRequest)
  472. return
  473. }
  474. w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")
  475. fmt.Fprintf(w, "null")
  476. })
  477. mux.HandleFunc(fmt.Sprintf("/%s.FreeNetwork", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
  478. w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")
  479. fmt.Fprintf(w, "null")
  480. })
  481. mux.HandleFunc(fmt.Sprintf("/%s.CreateNetwork", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
  482. err := json.NewDecoder(r.Body).Decode(&remoteDriverNetworkRequest)
  483. if err != nil {
  484. http.Error(w, "Unable to decode JSON payload: "+err.Error(), http.StatusBadRequest)
  485. return
  486. }
  487. w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")
  488. fmt.Fprintf(w, "null")
  489. })
  490. mux.HandleFunc(fmt.Sprintf("/%s.DeleteNetwork", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
  491. w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")
  492. fmt.Fprintf(w, "null")
  493. })
  494. mux.HandleFunc(fmt.Sprintf("/%s.CreateEndpoint", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
  495. w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")
  496. fmt.Fprintf(w, `{"Interface":{"MacAddress":"a0:b1:c2:d3:e4:f5"}}`)
  497. })
  498. mux.HandleFunc(fmt.Sprintf("/%s.Join", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
  499. w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")
  500. veth := &netlink.Veth{
  501. LinkAttrs: netlink.LinkAttrs{Name: "randomIfName", TxQLen: 0}, PeerName: "cnt0"}
  502. if err := netlink.LinkAdd(veth); err != nil {
  503. fmt.Fprintf(w, `{"Error":"failed to add veth pair: `+err.Error()+`"}`)
  504. } else {
  505. fmt.Fprintf(w, `{"InterfaceName":{ "SrcName":"cnt0", "DstPrefix":"veth"}}`)
  506. }
  507. })
  508. mux.HandleFunc(fmt.Sprintf("/%s.Leave", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
  509. w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")
  510. fmt.Fprintf(w, "null")
  511. })
  512. mux.HandleFunc(fmt.Sprintf("/%s.DeleteEndpoint", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
  513. w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")
  514. if link, err := netlink.LinkByName("cnt0"); err == nil {
  515. netlink.LinkDel(link)
  516. }
  517. fmt.Fprintf(w, "null")
  518. })
  519. // IPAM Driver implementation
  520. var (
  521. poolRequest remoteipam.RequestPoolRequest
  522. poolReleaseReq remoteipam.ReleasePoolRequest
  523. addressRequest remoteipam.RequestAddressRequest
  524. addressReleaseReq remoteipam.ReleaseAddressRequest
  525. lAS = "localAS"
  526. gAS = "globalAS"
  527. pool = "172.28.0.0/16"
  528. poolID = lAS + "/" + pool
  529. gw = "172.28.255.254/16"
  530. )
  531. mux.HandleFunc(fmt.Sprintf("/%s.GetDefaultAddressSpaces", ipamapi.PluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
  532. w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")
  533. fmt.Fprintf(w, `{"LocalDefaultAddressSpace":"`+lAS+`", "GlobalDefaultAddressSpace": "`+gAS+`"}`)
  534. })
  535. mux.HandleFunc(fmt.Sprintf("/%s.RequestPool", ipamapi.PluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
  536. err := json.NewDecoder(r.Body).Decode(&poolRequest)
  537. if err != nil {
  538. http.Error(w, "Unable to decode JSON payload: "+err.Error(), http.StatusBadRequest)
  539. return
  540. }
  541. w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")
  542. if poolRequest.AddressSpace != lAS && poolRequest.AddressSpace != gAS {
  543. fmt.Fprintf(w, `{"Error":"Unknown address space in pool request: `+poolRequest.AddressSpace+`"}`)
  544. } else if poolRequest.Pool != "" && poolRequest.Pool != pool {
  545. fmt.Fprintf(w, `{"Error":"Cannot handle explicit pool requests yet"}`)
  546. } else {
  547. fmt.Fprintf(w, `{"PoolID":"`+poolID+`", "Pool":"`+pool+`"}`)
  548. }
  549. })
  550. mux.HandleFunc(fmt.Sprintf("/%s.RequestAddress", ipamapi.PluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
  551. err := json.NewDecoder(r.Body).Decode(&addressRequest)
  552. if err != nil {
  553. http.Error(w, "Unable to decode JSON payload: "+err.Error(), http.StatusBadRequest)
  554. return
  555. }
  556. w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")
  557. // make sure libnetwork is now querying on the expected pool id
  558. if addressRequest.PoolID != poolID {
  559. fmt.Fprintf(w, `{"Error":"unknown pool id"}`)
  560. } else if addressRequest.Address != "" {
  561. fmt.Fprintf(w, `{"Error":"Cannot handle explicit address requests yet"}`)
  562. } else {
  563. fmt.Fprintf(w, `{"Address":"`+gw+`"}`)
  564. }
  565. })
  566. mux.HandleFunc(fmt.Sprintf("/%s.ReleaseAddress", ipamapi.PluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
  567. err := json.NewDecoder(r.Body).Decode(&addressReleaseReq)
  568. if err != nil {
  569. http.Error(w, "Unable to decode JSON payload: "+err.Error(), http.StatusBadRequest)
  570. return
  571. }
  572. w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")
  573. // make sure libnetwork is now asking to release the expected address from the expected poolid
  574. if addressRequest.PoolID != poolID {
  575. fmt.Fprintf(w, `{"Error":"unknown pool id"}`)
  576. } else if addressReleaseReq.Address != gw {
  577. fmt.Fprintf(w, `{"Error":"unknown address"}`)
  578. } else {
  579. fmt.Fprintf(w, "null")
  580. }
  581. })
  582. mux.HandleFunc(fmt.Sprintf("/%s.ReleasePool", ipamapi.PluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
  583. err := json.NewDecoder(r.Body).Decode(&poolReleaseReq)
  584. if err != nil {
  585. http.Error(w, "Unable to decode JSON payload: "+err.Error(), http.StatusBadRequest)
  586. return
  587. }
  588. w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")
  589. // make sure libnetwork is now asking to release the expected poolid
  590. if addressRequest.PoolID != poolID {
  591. fmt.Fprintf(w, `{"Error":"unknown pool id"}`)
  592. } else {
  593. fmt.Fprintf(w, "null")
  594. }
  595. })
  596. err := os.MkdirAll("/etc/docker/plugins", 0755)
  597. c.Assert(err, checker.IsNil)
  598. fileName := fmt.Sprintf("/etc/docker/plugins/%s.spec", netDrv)
  599. err = ioutil.WriteFile(fileName, []byte(url), 0644)
  600. c.Assert(err, checker.IsNil)
  601. ipamFileName := fmt.Sprintf("/etc/docker/plugins/%s.spec", ipamDrv)
  602. err = ioutil.WriteFile(ipamFileName, []byte(url), 0644)
  603. c.Assert(err, checker.IsNil)
  604. }
  605. func (s *DockerSwarmSuite) TestSwarmNetworkPlugin(c *check.C) {
  606. mux := http.NewServeMux()
  607. s.server = httptest.NewServer(mux)
  608. c.Assert(s.server, check.NotNil, check.Commentf("Failed to start an HTTP Server"))
  609. setupRemoteGlobalNetworkPlugin(c, mux, s.server.URL, globalNetworkPlugin, globalIPAMPlugin)
  610. defer func() {
  611. s.server.Close()
  612. err := os.RemoveAll("/etc/docker/plugins")
  613. c.Assert(err, checker.IsNil)
  614. }()
  615. d := s.AddDaemon(c, true, true)
  616. out, err := d.Cmd("network", "create", "-d", globalNetworkPlugin, "foo")
  617. c.Assert(err, checker.NotNil)
  618. c.Assert(out, checker.Contains, "not supported in swarm mode")
  619. }
  620. // Test case for #24712
  621. func (s *DockerSwarmSuite) TestSwarmServiceEnvFile(c *check.C) {
  622. d := s.AddDaemon(c, true, true)
  623. path := filepath.Join(d.Folder, "env.txt")
  624. err := ioutil.WriteFile(path, []byte("VAR1=A\nVAR2=A\n"), 0644)
  625. c.Assert(err, checker.IsNil)
  626. name := "worker"
  627. out, err := d.Cmd("service", "create", "--env-file", path, "--env", "VAR1=B", "--env", "VAR1=C", "--env", "VAR2=", "--env", "VAR2", "--name", name, "busybox", "top")
  628. c.Assert(err, checker.IsNil)
  629. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  630. // The complete env is [VAR1=A VAR2=A VAR1=B VAR1=C VAR2= VAR2] and duplicates will be removed => [VAR1=C VAR2]
  631. out, err = d.Cmd("inspect", "--format", "{{ .Spec.TaskTemplate.ContainerSpec.Env }}", name)
  632. c.Assert(err, checker.IsNil)
  633. c.Assert(out, checker.Contains, "[VAR1=C VAR2]")
  634. }
  635. func (s *DockerSwarmSuite) TestSwarmServiceTTY(c *check.C) {
  636. d := s.AddDaemon(c, true, true)
  637. name := "top"
  638. ttyCheck := "if [ -t 0 ]; then echo TTY > /status && top; else echo none > /status && top; fi"
  639. // Without --tty
  640. expectedOutput := "none"
  641. out, err := d.Cmd("service", "create", "--name", name, "busybox", "sh", "-c", ttyCheck)
  642. c.Assert(err, checker.IsNil)
  643. // Make sure task has been deployed.
  644. waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, 1)
  645. // We need to get the container id.
  646. out, err = d.Cmd("ps", "-a", "-q", "--no-trunc")
  647. c.Assert(err, checker.IsNil)
  648. id := strings.TrimSpace(out)
  649. out, err = d.Cmd("exec", id, "cat", "/status")
  650. c.Assert(err, checker.IsNil)
  651. c.Assert(out, checker.Contains, expectedOutput, check.Commentf("Expected '%s', but got %q", expectedOutput, out))
  652. // Remove service
  653. out, err = d.Cmd("service", "rm", name)
  654. c.Assert(err, checker.IsNil)
  655. // Make sure container has been destroyed.
  656. waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, 0)
  657. // With --tty
  658. expectedOutput = "TTY"
  659. out, err = d.Cmd("service", "create", "--name", name, "--tty", "busybox", "sh", "-c", ttyCheck)
  660. c.Assert(err, checker.IsNil)
  661. // Make sure task has been deployed.
  662. waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, 1)
  663. // We need to get the container id.
  664. out, err = d.Cmd("ps", "-a", "-q", "--no-trunc")
  665. c.Assert(err, checker.IsNil)
  666. id = strings.TrimSpace(out)
  667. out, err = d.Cmd("exec", id, "cat", "/status")
  668. c.Assert(err, checker.IsNil)
  669. c.Assert(out, checker.Contains, expectedOutput, check.Commentf("Expected '%s', but got %q", expectedOutput, out))
  670. }
  671. func (s *DockerSwarmSuite) TestSwarmServiceTTYUpdate(c *check.C) {
  672. d := s.AddDaemon(c, true, true)
  673. // Create a service
  674. name := "top"
  675. _, err := d.Cmd("service", "create", "--name", name, "busybox", "top")
  676. c.Assert(err, checker.IsNil)
  677. // Make sure task has been deployed.
  678. waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, 1)
  679. out, err := d.Cmd("service", "inspect", "--format", "{{ .Spec.TaskTemplate.ContainerSpec.TTY }}", name)
  680. c.Assert(err, checker.IsNil)
  681. c.Assert(strings.TrimSpace(out), checker.Equals, "false")
  682. _, err = d.Cmd("service", "update", "--tty", name)
  683. c.Assert(err, checker.IsNil)
  684. out, err = d.Cmd("service", "inspect", "--format", "{{ .Spec.TaskTemplate.ContainerSpec.TTY }}", name)
  685. c.Assert(err, checker.IsNil)
  686. c.Assert(strings.TrimSpace(out), checker.Equals, "true")
  687. }
  688. func (s *DockerSwarmSuite) TestSwarmServiceNetworkUpdate(c *check.C) {
  689. d := s.AddDaemon(c, true, true)
  690. result := icmd.RunCmd(d.Command("network", "create", "-d", "overlay", "foo"))
  691. result.Assert(c, icmd.Success)
  692. fooNetwork := strings.TrimSpace(string(result.Combined()))
  693. result = icmd.RunCmd(d.Command("network", "create", "-d", "overlay", "bar"))
  694. result.Assert(c, icmd.Success)
  695. barNetwork := strings.TrimSpace(string(result.Combined()))
  696. result = icmd.RunCmd(d.Command("network", "create", "-d", "overlay", "baz"))
  697. result.Assert(c, icmd.Success)
  698. bazNetwork := strings.TrimSpace(string(result.Combined()))
  699. // Create a service
  700. name := "top"
  701. result = icmd.RunCmd(d.Command("service", "create", "--network", "foo", "--network", "bar", "--name", name, "busybox", "top"))
  702. result.Assert(c, icmd.Success)
  703. // Make sure task has been deployed.
  704. waitAndAssert(c, defaultReconciliationTimeout, d.CheckRunningTaskNetworks, checker.DeepEquals,
  705. map[string]int{fooNetwork: 1, barNetwork: 1})
  706. // Remove a network
  707. result = icmd.RunCmd(d.Command("service", "update", "--network-rm", "foo", name))
  708. result.Assert(c, icmd.Success)
  709. waitAndAssert(c, defaultReconciliationTimeout, d.CheckRunningTaskNetworks, checker.DeepEquals,
  710. map[string]int{barNetwork: 1})
  711. // Add a network
  712. result = icmd.RunCmd(d.Command("service", "update", "--network-add", "baz", name))
  713. result.Assert(c, icmd.Success)
  714. waitAndAssert(c, defaultReconciliationTimeout, d.CheckRunningTaskNetworks, checker.DeepEquals,
  715. map[string]int{barNetwork: 1, bazNetwork: 1})
  716. }
  717. func (s *DockerSwarmSuite) TestDNSConfig(c *check.C) {
  718. d := s.AddDaemon(c, true, true)
  719. // Create a service
  720. name := "top"
  721. _, err := d.Cmd("service", "create", "--name", name, "--dns=1.2.3.4", "--dns-search=example.com", "--dns-option=timeout:3", "busybox", "top")
  722. c.Assert(err, checker.IsNil)
  723. // Make sure task has been deployed.
  724. waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, 1)
  725. // We need to get the container id.
  726. out, err := d.Cmd("ps", "-a", "-q", "--no-trunc")
  727. c.Assert(err, checker.IsNil)
  728. id := strings.TrimSpace(out)
  729. // Compare against expected output.
  730. expectedOutput1 := "nameserver 1.2.3.4"
  731. expectedOutput2 := "search example.com"
  732. expectedOutput3 := "options timeout:3"
  733. out, err = d.Cmd("exec", id, "cat", "/etc/resolv.conf")
  734. c.Assert(err, checker.IsNil)
  735. c.Assert(out, checker.Contains, expectedOutput1, check.Commentf("Expected '%s', but got %q", expectedOutput1, out))
  736. c.Assert(out, checker.Contains, expectedOutput2, check.Commentf("Expected '%s', but got %q", expectedOutput2, out))
  737. c.Assert(out, checker.Contains, expectedOutput3, check.Commentf("Expected '%s', but got %q", expectedOutput3, out))
  738. }
  739. func (s *DockerSwarmSuite) TestDNSConfigUpdate(c *check.C) {
  740. d := s.AddDaemon(c, true, true)
  741. // Create a service
  742. name := "top"
  743. _, err := d.Cmd("service", "create", "--name", name, "busybox", "top")
  744. c.Assert(err, checker.IsNil)
  745. // Make sure task has been deployed.
  746. waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, 1)
  747. _, err = d.Cmd("service", "update", "--dns-add=1.2.3.4", "--dns-search-add=example.com", "--dns-option-add=timeout:3", name)
  748. c.Assert(err, checker.IsNil)
  749. out, err := d.Cmd("service", "inspect", "--format", "{{ .Spec.TaskTemplate.ContainerSpec.DNSConfig }}", name)
  750. c.Assert(err, checker.IsNil)
  751. c.Assert(strings.TrimSpace(out), checker.Equals, "{[1.2.3.4] [example.com] [timeout:3]}")
  752. }
  753. func getNodeStatus(c *check.C, d *daemon.Swarm) swarm.LocalNodeState {
  754. info, err := d.SwarmInfo()
  755. c.Assert(err, checker.IsNil)
  756. return info.LocalNodeState
  757. }
  758. func checkSwarmLockedToUnlocked(c *check.C, d *daemon.Swarm, unlockKey string) {
  759. d.Restart(c)
  760. status := getNodeStatus(c, d)
  761. if status == swarm.LocalNodeStateLocked {
  762. // it must not have updated to be unlocked in time - unlock, wait 3 seconds, and try again
  763. cmd := d.Command("swarm", "unlock")
  764. cmd.Stdin = bytes.NewBufferString(unlockKey)
  765. icmd.RunCmd(cmd).Assert(c, icmd.Success)
  766. c.Assert(getNodeStatus(c, d), checker.Equals, swarm.LocalNodeStateActive)
  767. time.Sleep(3 * time.Second)
  768. d.Restart(c)
  769. }
  770. c.Assert(getNodeStatus(c, d), checker.Equals, swarm.LocalNodeStateActive)
  771. }
  772. func checkSwarmUnlockedToLocked(c *check.C, d *daemon.Swarm) {
  773. d.Restart(c)
  774. status := getNodeStatus(c, d)
  775. if status == swarm.LocalNodeStateActive {
  776. // it must not have updated to be unlocked in time - wait 3 seconds, and try again
  777. time.Sleep(3 * time.Second)
  778. d.Restart(c)
  779. }
  780. c.Assert(getNodeStatus(c, d), checker.Equals, swarm.LocalNodeStateLocked)
  781. }
  782. func (s *DockerSwarmSuite) TestUnlockEngineAndUnlockedSwarm(c *check.C) {
  783. d := s.AddDaemon(c, false, false)
  784. // unlocking a normal engine should return an error - it does not even ask for the key
  785. cmd := d.Command("swarm", "unlock")
  786. result := icmd.RunCmd(cmd)
  787. result.Assert(c, icmd.Expected{
  788. ExitCode: 1,
  789. })
  790. c.Assert(result.Combined(), checker.Contains, "Error: This node is not part of a swarm")
  791. c.Assert(result.Combined(), checker.Not(checker.Contains), "Please enter unlock key")
  792. _, err := d.Cmd("swarm", "init")
  793. c.Assert(err, checker.IsNil)
  794. // unlocking an unlocked swarm should return an error - it does not even ask for the key
  795. cmd = d.Command("swarm", "unlock")
  796. result = icmd.RunCmd(cmd)
  797. result.Assert(c, icmd.Expected{
  798. ExitCode: 1,
  799. })
  800. c.Assert(result.Combined(), checker.Contains, "Error: swarm is not locked")
  801. c.Assert(result.Combined(), checker.Not(checker.Contains), "Please enter unlock key")
  802. }
  803. func (s *DockerSwarmSuite) TestSwarmInitLocked(c *check.C) {
  804. d := s.AddDaemon(c, false, false)
  805. outs, err := d.Cmd("swarm", "init", "--autolock")
  806. c.Assert(err, checker.IsNil, check.Commentf("out: %v", outs))
  807. c.Assert(outs, checker.Contains, "docker swarm unlock")
  808. var unlockKey string
  809. for _, line := range strings.Split(outs, "\n") {
  810. if strings.Contains(line, "SWMKEY") {
  811. unlockKey = strings.TrimSpace(line)
  812. break
  813. }
  814. }
  815. c.Assert(unlockKey, checker.Not(checker.Equals), "")
  816. outs, err = d.Cmd("swarm", "unlock-key", "-q")
  817. c.Assert(outs, checker.Equals, unlockKey+"\n")
  818. c.Assert(getNodeStatus(c, d), checker.Equals, swarm.LocalNodeStateActive)
  819. // It starts off locked
  820. d.Restart(c)
  821. c.Assert(getNodeStatus(c, d), checker.Equals, swarm.LocalNodeStateLocked)
  822. cmd := d.Command("swarm", "unlock")
  823. cmd.Stdin = bytes.NewBufferString("wrong-secret-key")
  824. icmd.RunCmd(cmd).Assert(c, icmd.Expected{
  825. ExitCode: 1,
  826. Err: "invalid key",
  827. })
  828. c.Assert(getNodeStatus(c, d), checker.Equals, swarm.LocalNodeStateLocked)
  829. cmd = d.Command("swarm", "unlock")
  830. cmd.Stdin = bytes.NewBufferString(unlockKey)
  831. icmd.RunCmd(cmd).Assert(c, icmd.Success)
  832. c.Assert(getNodeStatus(c, d), checker.Equals, swarm.LocalNodeStateActive)
  833. outs, err = d.Cmd("node", "ls")
  834. c.Assert(err, checker.IsNil)
  835. c.Assert(outs, checker.Not(checker.Contains), "Swarm is encrypted and needs to be unlocked")
  836. outs, err = d.Cmd("swarm", "update", "--autolock=false")
  837. c.Assert(err, checker.IsNil, check.Commentf("out: %v", outs))
  838. checkSwarmLockedToUnlocked(c, d, unlockKey)
  839. outs, err = d.Cmd("node", "ls")
  840. c.Assert(err, checker.IsNil)
  841. c.Assert(outs, checker.Not(checker.Contains), "Swarm is encrypted and needs to be unlocked")
  842. }
  843. func (s *DockerSwarmSuite) TestSwarmLeaveLocked(c *check.C) {
  844. d := s.AddDaemon(c, false, false)
  845. outs, err := d.Cmd("swarm", "init", "--autolock")
  846. c.Assert(err, checker.IsNil, check.Commentf("out: %v", outs))
  847. // It starts off locked
  848. d.Restart(c, "--swarm-default-advertise-addr=lo")
  849. info, err := d.SwarmInfo()
  850. c.Assert(err, checker.IsNil)
  851. c.Assert(info.LocalNodeState, checker.Equals, swarm.LocalNodeStateLocked)
  852. outs, _ = d.Cmd("node", "ls")
  853. c.Assert(outs, checker.Contains, "Swarm is encrypted and needs to be unlocked")
  854. // `docker swarm leave` a locked swarm without --force will return an error
  855. outs, _ = d.Cmd("swarm", "leave")
  856. c.Assert(outs, checker.Contains, "Swarm is encrypted and locked.")
  857. // It is OK for user to leave a locked swarm with --force
  858. outs, err = d.Cmd("swarm", "leave", "--force")
  859. c.Assert(err, checker.IsNil, check.Commentf("out: %v", outs))
  860. info, err = d.SwarmInfo()
  861. c.Assert(err, checker.IsNil)
  862. c.Assert(info.LocalNodeState, checker.Equals, swarm.LocalNodeStateInactive)
  863. outs, err = d.Cmd("swarm", "init")
  864. c.Assert(err, checker.IsNil, check.Commentf("out: %v", outs))
  865. info, err = d.SwarmInfo()
  866. c.Assert(err, checker.IsNil)
  867. c.Assert(info.LocalNodeState, checker.Equals, swarm.LocalNodeStateActive)
  868. }
  869. func (s *DockerSwarmSuite) TestSwarmLockUnlockCluster(c *check.C) {
  870. d1 := s.AddDaemon(c, true, true)
  871. d2 := s.AddDaemon(c, true, true)
  872. d3 := s.AddDaemon(c, true, true)
  873. // they start off unlocked
  874. d2.Restart(c)
  875. c.Assert(getNodeStatus(c, d2), checker.Equals, swarm.LocalNodeStateActive)
  876. // stop this one so it does not get autolock info
  877. d2.Stop(c)
  878. // enable autolock
  879. outs, err := d1.Cmd("swarm", "update", "--autolock")
  880. c.Assert(err, checker.IsNil, check.Commentf("out: %v", outs))
  881. c.Assert(outs, checker.Contains, "docker swarm unlock")
  882. var unlockKey string
  883. for _, line := range strings.Split(outs, "\n") {
  884. if strings.Contains(line, "SWMKEY") {
  885. unlockKey = strings.TrimSpace(line)
  886. break
  887. }
  888. }
  889. c.Assert(unlockKey, checker.Not(checker.Equals), "")
  890. outs, err = d1.Cmd("swarm", "unlock-key", "-q")
  891. c.Assert(outs, checker.Equals, unlockKey+"\n")
  892. // The ones that got the cluster update should be set to locked
  893. for _, d := range []*daemon.Swarm{d1, d3} {
  894. checkSwarmUnlockedToLocked(c, d)
  895. cmd := d.Command("swarm", "unlock")
  896. cmd.Stdin = bytes.NewBufferString(unlockKey)
  897. icmd.RunCmd(cmd).Assert(c, icmd.Success)
  898. c.Assert(getNodeStatus(c, d), checker.Equals, swarm.LocalNodeStateActive)
  899. }
  900. // d2 never got the cluster update, so it is still set to unlocked
  901. d2.Start(c)
  902. c.Assert(getNodeStatus(c, d2), checker.Equals, swarm.LocalNodeStateActive)
  903. // d2 is now set to lock
  904. checkSwarmUnlockedToLocked(c, d2)
  905. // leave it locked, and set the cluster to no longer autolock
  906. outs, err = d1.Cmd("swarm", "update", "--autolock=false")
  907. c.Assert(err, checker.IsNil, check.Commentf("out: %v", outs))
  908. // the ones that got the update are now set to unlocked
  909. for _, d := range []*daemon.Swarm{d1, d3} {
  910. checkSwarmLockedToUnlocked(c, d, unlockKey)
  911. }
  912. // d2 still locked
  913. c.Assert(getNodeStatus(c, d2), checker.Equals, swarm.LocalNodeStateLocked)
  914. // unlock it
  915. cmd := d2.Command("swarm", "unlock")
  916. cmd.Stdin = bytes.NewBufferString(unlockKey)
  917. icmd.RunCmd(cmd).Assert(c, icmd.Success)
  918. c.Assert(getNodeStatus(c, d2), checker.Equals, swarm.LocalNodeStateActive)
  919. // once it's caught up, d2 is set to not be locked
  920. checkSwarmLockedToUnlocked(c, d2, unlockKey)
  921. // managers who join now are never set to locked in the first place
  922. d4 := s.AddDaemon(c, true, true)
  923. d4.Restart(c)
  924. c.Assert(getNodeStatus(c, d4), checker.Equals, swarm.LocalNodeStateActive)
  925. }
  926. func (s *DockerSwarmSuite) TestSwarmJoinPromoteLocked(c *check.C) {
  927. d1 := s.AddDaemon(c, true, true)
  928. // enable autolock
  929. outs, err := d1.Cmd("swarm", "update", "--autolock")
  930. c.Assert(err, checker.IsNil, check.Commentf("out: %v", outs))
  931. c.Assert(outs, checker.Contains, "docker swarm unlock")
  932. var unlockKey string
  933. for _, line := range strings.Split(outs, "\n") {
  934. if strings.Contains(line, "SWMKEY") {
  935. unlockKey = strings.TrimSpace(line)
  936. break
  937. }
  938. }
  939. c.Assert(unlockKey, checker.Not(checker.Equals), "")
  940. outs, err = d1.Cmd("swarm", "unlock-key", "-q")
  941. c.Assert(outs, checker.Equals, unlockKey+"\n")
  942. // joined workers start off unlocked
  943. d2 := s.AddDaemon(c, true, false)
  944. d2.Restart(c)
  945. c.Assert(getNodeStatus(c, d2), checker.Equals, swarm.LocalNodeStateActive)
  946. // promote worker
  947. outs, err = d1.Cmd("node", "promote", d2.Info.NodeID)
  948. c.Assert(err, checker.IsNil)
  949. c.Assert(outs, checker.Contains, "promoted to a manager in the swarm")
  950. // join new manager node
  951. d3 := s.AddDaemon(c, true, true)
  952. // both new nodes are locked
  953. for _, d := range []*daemon.Swarm{d2, d3} {
  954. checkSwarmUnlockedToLocked(c, d)
  955. cmd := d.Command("swarm", "unlock")
  956. cmd.Stdin = bytes.NewBufferString(unlockKey)
  957. icmd.RunCmd(cmd).Assert(c, icmd.Success)
  958. c.Assert(getNodeStatus(c, d), checker.Equals, swarm.LocalNodeStateActive)
  959. }
  960. // get d3's cert
  961. d3cert, err := ioutil.ReadFile(filepath.Join(d3.Folder, "root", "swarm", "certificates", "swarm-node.crt"))
  962. c.Assert(err, checker.IsNil)
  963. // demote manager back to worker - workers are not locked
  964. outs, err = d1.Cmd("node", "demote", d3.Info.NodeID)
  965. c.Assert(err, checker.IsNil)
  966. c.Assert(outs, checker.Contains, "demoted in the swarm")
  967. // Wait for it to actually be demoted, for the key and cert to be replaced.
  968. // Then restart and assert that the node is not locked. If we don't wait for the cert
  969. // to be replaced, then the node still has the manager TLS key which is still locked
  970. // (because we never want a manager TLS key to be on disk unencrypted if the cluster
  971. // is set to autolock)
  972. waitAndAssert(c, defaultReconciliationTimeout, d3.CheckControlAvailable, checker.False)
  973. waitAndAssert(c, defaultReconciliationTimeout, func(c *check.C) (interface{}, check.CommentInterface) {
  974. cert, err := ioutil.ReadFile(filepath.Join(d3.Folder, "root", "swarm", "certificates", "swarm-node.crt"))
  975. if err != nil {
  976. return "", check.Commentf("error: %v", err)
  977. }
  978. return string(cert), check.Commentf("cert: %v", string(cert))
  979. }, checker.Not(checker.Equals), string(d3cert))
  980. // by now, it should *never* be locked on restart
  981. d3.Restart(c)
  982. c.Assert(getNodeStatus(c, d3), checker.Equals, swarm.LocalNodeStateActive)
  983. }
  984. func (s *DockerSwarmSuite) TestSwarmRotateUnlockKey(c *check.C) {
  985. d := s.AddDaemon(c, true, true)
  986. outs, err := d.Cmd("swarm", "update", "--autolock")
  987. c.Assert(err, checker.IsNil, check.Commentf("out: %v", outs))
  988. c.Assert(outs, checker.Contains, "docker swarm unlock")
  989. var unlockKey string
  990. for _, line := range strings.Split(outs, "\n") {
  991. if strings.Contains(line, "SWMKEY") {
  992. unlockKey = strings.TrimSpace(line)
  993. break
  994. }
  995. }
  996. c.Assert(unlockKey, checker.Not(checker.Equals), "")
  997. outs, err = d.Cmd("swarm", "unlock-key", "-q")
  998. c.Assert(outs, checker.Equals, unlockKey+"\n")
  999. // Rotate multiple times
  1000. for i := 0; i != 3; i++ {
  1001. outs, err = d.Cmd("swarm", "unlock-key", "-q", "--rotate")
  1002. c.Assert(err, checker.IsNil, check.Commentf("out: %v", outs))
  1003. // Strip \n
  1004. newUnlockKey := outs[:len(outs)-1]
  1005. c.Assert(newUnlockKey, checker.Not(checker.Equals), "")
  1006. c.Assert(newUnlockKey, checker.Not(checker.Equals), unlockKey)
  1007. d.Restart(c)
  1008. c.Assert(getNodeStatus(c, d), checker.Equals, swarm.LocalNodeStateLocked)
  1009. outs, _ = d.Cmd("node", "ls")
  1010. c.Assert(outs, checker.Contains, "Swarm is encrypted and needs to be unlocked")
  1011. cmd := d.Command("swarm", "unlock")
  1012. cmd.Stdin = bytes.NewBufferString(unlockKey)
  1013. result := icmd.RunCmd(cmd)
  1014. if result.Error == nil {
  1015. // On occasion, the daemon may not have finished
  1016. // rotating the KEK before restarting. The test is
  1017. // intentionally written to explore this behavior.
  1018. // When this happens, unlocking with the old key will
  1019. // succeed. If we wait for the rotation to happen and
  1020. // restart again, the new key should be required this
  1021. // time.
  1022. time.Sleep(3 * time.Second)
  1023. d.Restart(c)
  1024. cmd = d.Command("swarm", "unlock")
  1025. cmd.Stdin = bytes.NewBufferString(unlockKey)
  1026. result = icmd.RunCmd(cmd)
  1027. }
  1028. result.Assert(c, icmd.Expected{
  1029. ExitCode: 1,
  1030. Err: "invalid key",
  1031. })
  1032. outs, _ = d.Cmd("node", "ls")
  1033. c.Assert(outs, checker.Contains, "Swarm is encrypted and needs to be unlocked")
  1034. cmd = d.Command("swarm", "unlock")
  1035. cmd.Stdin = bytes.NewBufferString(newUnlockKey)
  1036. icmd.RunCmd(cmd).Assert(c, icmd.Success)
  1037. c.Assert(getNodeStatus(c, d), checker.Equals, swarm.LocalNodeStateActive)
  1038. outs, err = d.Cmd("node", "ls")
  1039. c.Assert(err, checker.IsNil)
  1040. c.Assert(outs, checker.Not(checker.Contains), "Swarm is encrypted and needs to be unlocked")
  1041. unlockKey = newUnlockKey
  1042. }
  1043. }
  1044. // This differs from `TestSwarmRotateUnlockKey` because that one rotates a single node, which is the leader.
  1045. // This one keeps the leader up, and asserts that other manager nodes in the cluster also have their unlock
  1046. // key rotated.
  1047. func (s *DockerSwarmSuite) TestSwarmClusterRotateUnlockKey(c *check.C) {
  1048. d1 := s.AddDaemon(c, true, true) // leader - don't restart this one, we don't want leader election delays
  1049. d2 := s.AddDaemon(c, true, true)
  1050. d3 := s.AddDaemon(c, true, true)
  1051. outs, err := d1.Cmd("swarm", "update", "--autolock")
  1052. c.Assert(err, checker.IsNil, check.Commentf("out: %v", outs))
  1053. c.Assert(outs, checker.Contains, "docker swarm unlock")
  1054. var unlockKey string
  1055. for _, line := range strings.Split(outs, "\n") {
  1056. if strings.Contains(line, "SWMKEY") {
  1057. unlockKey = strings.TrimSpace(line)
  1058. break
  1059. }
  1060. }
  1061. c.Assert(unlockKey, checker.Not(checker.Equals), "")
  1062. outs, err = d1.Cmd("swarm", "unlock-key", "-q")
  1063. c.Assert(outs, checker.Equals, unlockKey+"\n")
  1064. // Rotate multiple times
  1065. for i := 0; i != 3; i++ {
  1066. outs, err = d1.Cmd("swarm", "unlock-key", "-q", "--rotate")
  1067. c.Assert(err, checker.IsNil, check.Commentf("out: %v", outs))
  1068. // Strip \n
  1069. newUnlockKey := outs[:len(outs)-1]
  1070. c.Assert(newUnlockKey, checker.Not(checker.Equals), "")
  1071. c.Assert(newUnlockKey, checker.Not(checker.Equals), unlockKey)
  1072. d2.Restart(c)
  1073. d3.Restart(c)
  1074. for _, d := range []*daemon.Swarm{d2, d3} {
  1075. c.Assert(getNodeStatus(c, d), checker.Equals, swarm.LocalNodeStateLocked)
  1076. outs, _ := d.Cmd("node", "ls")
  1077. c.Assert(outs, checker.Contains, "Swarm is encrypted and needs to be unlocked")
  1078. cmd := d.Command("swarm", "unlock")
  1079. cmd.Stdin = bytes.NewBufferString(unlockKey)
  1080. result := icmd.RunCmd(cmd)
  1081. if result.Error == nil {
  1082. // On occasion, the daemon may not have finished
  1083. // rotating the KEK before restarting. The test is
  1084. // intentionally written to explore this behavior.
  1085. // When this happens, unlocking with the old key will
  1086. // succeed. If we wait for the rotation to happen and
  1087. // restart again, the new key should be required this
  1088. // time.
  1089. time.Sleep(3 * time.Second)
  1090. d.Restart(c)
  1091. cmd = d.Command("swarm", "unlock")
  1092. cmd.Stdin = bytes.NewBufferString(unlockKey)
  1093. result = icmd.RunCmd(cmd)
  1094. }
  1095. result.Assert(c, icmd.Expected{
  1096. ExitCode: 1,
  1097. Err: "invalid key",
  1098. })
  1099. outs, _ = d.Cmd("node", "ls")
  1100. c.Assert(outs, checker.Contains, "Swarm is encrypted and needs to be unlocked")
  1101. cmd = d.Command("swarm", "unlock")
  1102. cmd.Stdin = bytes.NewBufferString(newUnlockKey)
  1103. icmd.RunCmd(cmd).Assert(c, icmd.Success)
  1104. c.Assert(getNodeStatus(c, d), checker.Equals, swarm.LocalNodeStateActive)
  1105. outs, err = d.Cmd("node", "ls")
  1106. c.Assert(err, checker.IsNil)
  1107. c.Assert(outs, checker.Not(checker.Contains), "Swarm is encrypted and needs to be unlocked")
  1108. }
  1109. unlockKey = newUnlockKey
  1110. }
  1111. }
  1112. func (s *DockerSwarmSuite) TestSwarmAlternateLockUnlock(c *check.C) {
  1113. d := s.AddDaemon(c, true, true)
  1114. var unlockKey string
  1115. for i := 0; i < 2; i++ {
  1116. // set to lock
  1117. outs, err := d.Cmd("swarm", "update", "--autolock")
  1118. c.Assert(err, checker.IsNil, check.Commentf("out: %v", outs))
  1119. c.Assert(outs, checker.Contains, "docker swarm unlock")
  1120. for _, line := range strings.Split(outs, "\n") {
  1121. if strings.Contains(line, "SWMKEY") {
  1122. unlockKey = strings.TrimSpace(line)
  1123. break
  1124. }
  1125. }
  1126. c.Assert(unlockKey, checker.Not(checker.Equals), "")
  1127. checkSwarmUnlockedToLocked(c, d)
  1128. cmd := d.Command("swarm", "unlock")
  1129. cmd.Stdin = bytes.NewBufferString(unlockKey)
  1130. icmd.RunCmd(cmd).Assert(c, icmd.Success)
  1131. c.Assert(getNodeStatus(c, d), checker.Equals, swarm.LocalNodeStateActive)
  1132. outs, err = d.Cmd("swarm", "update", "--autolock=false")
  1133. c.Assert(err, checker.IsNil, check.Commentf("out: %v", outs))
  1134. checkSwarmLockedToUnlocked(c, d, unlockKey)
  1135. }
  1136. }
  1137. func (s *DockerSwarmSuite) TestExtraHosts(c *check.C) {
  1138. d := s.AddDaemon(c, true, true)
  1139. // Create a service
  1140. name := "top"
  1141. _, err := d.Cmd("service", "create", "--name", name, "--host=example.com:1.2.3.4", "busybox", "top")
  1142. c.Assert(err, checker.IsNil)
  1143. // Make sure task has been deployed.
  1144. waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, 1)
  1145. // We need to get the container id.
  1146. out, err := d.Cmd("ps", "-a", "-q", "--no-trunc")
  1147. c.Assert(err, checker.IsNil)
  1148. id := strings.TrimSpace(out)
  1149. // Compare against expected output.
  1150. expectedOutput := "1.2.3.4\texample.com"
  1151. out, err = d.Cmd("exec", id, "cat", "/etc/hosts")
  1152. c.Assert(err, checker.IsNil)
  1153. c.Assert(out, checker.Contains, expectedOutput, check.Commentf("Expected '%s', but got %q", expectedOutput, out))
  1154. }
  1155. func (s *DockerSwarmSuite) TestSwarmManagerAddress(c *check.C) {
  1156. d1 := s.AddDaemon(c, true, true)
  1157. d2 := s.AddDaemon(c, true, false)
  1158. d3 := s.AddDaemon(c, true, false)
  1159. // Manager Addresses will always show Node 1's address
  1160. expectedOutput := fmt.Sprintf("Manager Addresses:\n 127.0.0.1:%d\n", d1.Port)
  1161. out, err := d1.Cmd("info")
  1162. c.Assert(err, checker.IsNil)
  1163. c.Assert(out, checker.Contains, expectedOutput)
  1164. out, err = d2.Cmd("info")
  1165. c.Assert(err, checker.IsNil)
  1166. c.Assert(out, checker.Contains, expectedOutput)
  1167. out, err = d3.Cmd("info")
  1168. c.Assert(err, checker.IsNil)
  1169. c.Assert(out, checker.Contains, expectedOutput)
  1170. }
  1171. func (s *DockerSwarmSuite) TestSwarmServiceInspectPretty(c *check.C) {
  1172. d := s.AddDaemon(c, true, true)
  1173. name := "top"
  1174. out, err := d.Cmd("service", "create", "--name", name, "--limit-cpu=0.5", "busybox", "top")
  1175. c.Assert(err, checker.IsNil, check.Commentf(out))
  1176. expectedOutput := `
  1177. Resources:
  1178. Limits:
  1179. CPU: 0.5`
  1180. out, err = d.Cmd("service", "inspect", "--pretty", name)
  1181. c.Assert(err, checker.IsNil, check.Commentf(out))
  1182. c.Assert(out, checker.Contains, expectedOutput, check.Commentf(out))
  1183. }
  1184. func (s *DockerSwarmSuite) TestSwarmNetworkIPAMOptions(c *check.C) {
  1185. d := s.AddDaemon(c, true, true)
  1186. out, err := d.Cmd("network", "create", "-d", "overlay", "--ipam-opt", "foo=bar", "foo")
  1187. c.Assert(err, checker.IsNil, check.Commentf(out))
  1188. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  1189. out, err = d.Cmd("network", "inspect", "--format", "{{.IPAM.Options}}", "foo")
  1190. c.Assert(err, checker.IsNil, check.Commentf(out))
  1191. c.Assert(strings.TrimSpace(out), checker.Equals, "map[foo:bar]")
  1192. out, err = d.Cmd("service", "create", "--network=foo", "--name", "top", "busybox", "top")
  1193. c.Assert(err, checker.IsNil, check.Commentf(out))
  1194. // make sure task has been deployed.
  1195. waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, 1)
  1196. out, err = d.Cmd("network", "inspect", "--format", "{{.IPAM.Options}}", "foo")
  1197. c.Assert(err, checker.IsNil, check.Commentf(out))
  1198. c.Assert(strings.TrimSpace(out), checker.Equals, "map[foo:bar]")
  1199. }
  1200. func (s *DockerTrustedSwarmSuite) TestTrustedServiceCreate(c *check.C) {
  1201. d := s.swarmSuite.AddDaemon(c, true, true)
  1202. // Attempt creating a service from an image that is known to notary.
  1203. repoName := s.trustSuite.setupTrustedImage(c, "trusted-pull")
  1204. name := "trusted"
  1205. serviceCmd := d.Command("-D", "service", "create", "--name", name, repoName, "top")
  1206. icmd.RunCmd(serviceCmd, trustedCmd).Assert(c, icmd.Expected{
  1207. Err: "resolved image tag to",
  1208. })
  1209. out, err := d.Cmd("service", "inspect", "--pretty", name)
  1210. c.Assert(err, checker.IsNil, check.Commentf(out))
  1211. c.Assert(out, checker.Contains, repoName+"@", check.Commentf(out))
  1212. // Try trusted service create on an untrusted tag.
  1213. repoName = fmt.Sprintf("%v/untrustedservicecreate/createtest:latest", privateRegistryURL)
  1214. // tag the image and upload it to the private registry
  1215. dockerCmd(c, "tag", "busybox", repoName)
  1216. dockerCmd(c, "push", repoName)
  1217. dockerCmd(c, "rmi", repoName)
  1218. name = "untrusted"
  1219. serviceCmd = d.Command("service", "create", "--name", name, repoName, "top")
  1220. icmd.RunCmd(serviceCmd, trustedCmd).Assert(c, icmd.Expected{
  1221. ExitCode: 1,
  1222. Err: "Error: remote trust data does not exist",
  1223. })
  1224. out, err = d.Cmd("service", "inspect", "--pretty", name)
  1225. c.Assert(err, checker.NotNil, check.Commentf(out))
  1226. }
  1227. func (s *DockerTrustedSwarmSuite) TestTrustedServiceUpdate(c *check.C) {
  1228. d := s.swarmSuite.AddDaemon(c, true, true)
  1229. // Attempt creating a service from an image that is known to notary.
  1230. repoName := s.trustSuite.setupTrustedImage(c, "trusted-pull")
  1231. name := "myservice"
  1232. // Create a service without content trust
  1233. _, err := d.Cmd("service", "create", "--name", name, repoName, "top")
  1234. c.Assert(err, checker.IsNil)
  1235. out, err := d.Cmd("service", "inspect", "--pretty", name)
  1236. c.Assert(err, checker.IsNil, check.Commentf(out))
  1237. // Daemon won't insert the digest because this is disabled by
  1238. // DOCKER_SERVICE_PREFER_OFFLINE_IMAGE.
  1239. c.Assert(out, check.Not(checker.Contains), repoName+"@", check.Commentf(out))
  1240. serviceCmd := d.Command("-D", "service", "update", "--image", repoName, name)
  1241. icmd.RunCmd(serviceCmd, trustedCmd).Assert(c, icmd.Expected{
  1242. Err: "resolved image tag to",
  1243. })
  1244. out, err = d.Cmd("service", "inspect", "--pretty", name)
  1245. c.Assert(err, checker.IsNil, check.Commentf(out))
  1246. c.Assert(out, checker.Contains, repoName+"@", check.Commentf(out))
  1247. // Try trusted service update on an untrusted tag.
  1248. repoName = fmt.Sprintf("%v/untrustedservicecreate/createtest:latest", privateRegistryURL)
  1249. // tag the image and upload it to the private registry
  1250. dockerCmd(c, "tag", "busybox", repoName)
  1251. dockerCmd(c, "push", repoName)
  1252. dockerCmd(c, "rmi", repoName)
  1253. serviceCmd = d.Command("service", "update", "--image", repoName, name)
  1254. icmd.RunCmd(serviceCmd, trustedCmd).Assert(c, icmd.Expected{
  1255. ExitCode: 1,
  1256. Err: "Error: remote trust data does not exist",
  1257. })
  1258. }
  1259. // Test case for issue #27866, which did not allow NW name that is the prefix of a swarm NW ID.
  1260. // e.g. if the ingress ID starts with "n1", it was impossible to create a NW named "n1".
  1261. func (s *DockerSwarmSuite) TestSwarmNetworkCreateIssue27866(c *check.C) {
  1262. d := s.AddDaemon(c, true, true)
  1263. out, err := d.Cmd("network", "inspect", "-f", "{{.Id}}", "ingress")
  1264. c.Assert(err, checker.IsNil, check.Commentf("out: %v", out))
  1265. ingressID := strings.TrimSpace(out)
  1266. c.Assert(ingressID, checker.Not(checker.Equals), "")
  1267. // create a network of which name is the prefix of the ID of an overlay network
  1268. // (ingressID in this case)
  1269. newNetName := ingressID[0:2]
  1270. out, err = d.Cmd("network", "create", "--driver", "overlay", newNetName)
  1271. // In #27866, it was failing because of "network with name %s already exists"
  1272. c.Assert(err, checker.IsNil, check.Commentf("out: %v", out))
  1273. out, err = d.Cmd("network", "rm", newNetName)
  1274. c.Assert(err, checker.IsNil, check.Commentf("out: %v", out))
  1275. }
  1276. // Test case for https://github.com/docker/docker/pull/27938#issuecomment-265768303
  1277. // This test creates two networks with the same name sequentially, with various drivers.
  1278. // Since the operations in this test are done sequentially, the 2nd call should fail with
  1279. // "network with name FOO already exists".
  1280. // Note that it is to ok have multiple networks with the same name if the operations are done
  1281. // in parallel. (#18864)
  1282. func (s *DockerSwarmSuite) TestSwarmNetworkCreateDup(c *check.C) {
  1283. d := s.AddDaemon(c, true, true)
  1284. drivers := []string{"bridge", "overlay"}
  1285. for i, driver1 := range drivers {
  1286. nwName := fmt.Sprintf("network-test-%d", i)
  1287. for _, driver2 := range drivers {
  1288. c.Logf("Creating a network named %q with %q, then %q",
  1289. nwName, driver1, driver2)
  1290. out, err := d.Cmd("network", "create", "--driver", driver1, nwName)
  1291. c.Assert(err, checker.IsNil, check.Commentf("out: %v", out))
  1292. out, err = d.Cmd("network", "create", "--driver", driver2, nwName)
  1293. c.Assert(out, checker.Contains,
  1294. fmt.Sprintf("network with name %s already exists", nwName))
  1295. c.Assert(err, checker.NotNil)
  1296. c.Logf("As expected, the attempt to network %q with %q failed: %s",
  1297. nwName, driver2, out)
  1298. out, err = d.Cmd("network", "rm", nwName)
  1299. c.Assert(err, checker.IsNil, check.Commentf("out: %v", out))
  1300. }
  1301. }
  1302. }
  1303. func (s *DockerSwarmSuite) TestSwarmServicePsMultipleServiceIDs(c *check.C) {
  1304. d := s.AddDaemon(c, true, true)
  1305. name1 := "top1"
  1306. out, err := d.Cmd("service", "create", "--detach=true", "--name", name1, "--replicas=3", "busybox", "top")
  1307. c.Assert(err, checker.IsNil)
  1308. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  1309. id1 := strings.TrimSpace(out)
  1310. name2 := "top2"
  1311. out, err = d.Cmd("service", "create", "--detach=true", "--name", name2, "--replicas=3", "busybox", "top")
  1312. c.Assert(err, checker.IsNil)
  1313. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  1314. id2 := strings.TrimSpace(out)
  1315. // make sure task has been deployed.
  1316. waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, 6)
  1317. out, err = d.Cmd("service", "ps", name1)
  1318. c.Assert(err, checker.IsNil)
  1319. c.Assert(out, checker.Contains, name1+".1")
  1320. c.Assert(out, checker.Contains, name1+".2")
  1321. c.Assert(out, checker.Contains, name1+".3")
  1322. c.Assert(out, checker.Not(checker.Contains), name2+".1")
  1323. c.Assert(out, checker.Not(checker.Contains), name2+".2")
  1324. c.Assert(out, checker.Not(checker.Contains), name2+".3")
  1325. out, err = d.Cmd("service", "ps", name1, name2)
  1326. c.Assert(err, checker.IsNil)
  1327. c.Assert(out, checker.Contains, name1+".1")
  1328. c.Assert(out, checker.Contains, name1+".2")
  1329. c.Assert(out, checker.Contains, name1+".3")
  1330. c.Assert(out, checker.Contains, name2+".1")
  1331. c.Assert(out, checker.Contains, name2+".2")
  1332. c.Assert(out, checker.Contains, name2+".3")
  1333. // Name Prefix
  1334. out, err = d.Cmd("service", "ps", "to")
  1335. c.Assert(err, checker.IsNil)
  1336. c.Assert(out, checker.Contains, name1+".1")
  1337. c.Assert(out, checker.Contains, name1+".2")
  1338. c.Assert(out, checker.Contains, name1+".3")
  1339. c.Assert(out, checker.Contains, name2+".1")
  1340. c.Assert(out, checker.Contains, name2+".2")
  1341. c.Assert(out, checker.Contains, name2+".3")
  1342. // Name Prefix (no hit)
  1343. out, err = d.Cmd("service", "ps", "noname")
  1344. c.Assert(err, checker.NotNil)
  1345. c.Assert(out, checker.Contains, "no such services: noname")
  1346. out, err = d.Cmd("service", "ps", id1)
  1347. c.Assert(err, checker.IsNil)
  1348. c.Assert(out, checker.Contains, name1+".1")
  1349. c.Assert(out, checker.Contains, name1+".2")
  1350. c.Assert(out, checker.Contains, name1+".3")
  1351. c.Assert(out, checker.Not(checker.Contains), name2+".1")
  1352. c.Assert(out, checker.Not(checker.Contains), name2+".2")
  1353. c.Assert(out, checker.Not(checker.Contains), name2+".3")
  1354. out, err = d.Cmd("service", "ps", id1, id2)
  1355. c.Assert(err, checker.IsNil)
  1356. c.Assert(out, checker.Contains, name1+".1")
  1357. c.Assert(out, checker.Contains, name1+".2")
  1358. c.Assert(out, checker.Contains, name1+".3")
  1359. c.Assert(out, checker.Contains, name2+".1")
  1360. c.Assert(out, checker.Contains, name2+".2")
  1361. c.Assert(out, checker.Contains, name2+".3")
  1362. }
  1363. func (s *DockerSwarmSuite) TestSwarmPublishDuplicatePorts(c *check.C) {
  1364. d := s.AddDaemon(c, true, true)
  1365. out, err := d.Cmd("service", "create", "--detach=true", "--publish", "5005:80", "--publish", "5006:80", "--publish", "80", "--publish", "80", "busybox", "top")
  1366. c.Assert(err, check.IsNil, check.Commentf(out))
  1367. id := strings.TrimSpace(out)
  1368. // make sure task has been deployed.
  1369. waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, 1)
  1370. // Total len = 4, with 2 dynamic ports and 2 non-dynamic ports
  1371. // Dynamic ports are likely to be 30000 and 30001 but doesn't matter
  1372. out, err = d.Cmd("service", "inspect", "--format", "{{.Endpoint.Ports}} len={{len .Endpoint.Ports}}", id)
  1373. c.Assert(err, check.IsNil, check.Commentf(out))
  1374. c.Assert(out, checker.Contains, "len=4")
  1375. c.Assert(out, checker.Contains, "{ tcp 80 5005 ingress}")
  1376. c.Assert(out, checker.Contains, "{ tcp 80 5006 ingress}")
  1377. }
  1378. func (s *DockerSwarmSuite) TestSwarmJoinWithDrain(c *check.C) {
  1379. d := s.AddDaemon(c, true, true)
  1380. out, err := d.Cmd("node", "ls")
  1381. c.Assert(err, checker.IsNil)
  1382. c.Assert(out, checker.Not(checker.Contains), "Drain")
  1383. out, err = d.Cmd("swarm", "join-token", "-q", "manager")
  1384. c.Assert(err, checker.IsNil)
  1385. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  1386. token := strings.TrimSpace(out)
  1387. d1 := s.AddDaemon(c, false, false)
  1388. out, err = d1.Cmd("swarm", "join", "--availability=drain", "--token", token, d.ListenAddr)
  1389. c.Assert(err, checker.IsNil)
  1390. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  1391. out, err = d.Cmd("node", "ls")
  1392. c.Assert(err, checker.IsNil)
  1393. c.Assert(out, checker.Contains, "Drain")
  1394. out, err = d1.Cmd("node", "ls")
  1395. c.Assert(err, checker.IsNil)
  1396. c.Assert(out, checker.Contains, "Drain")
  1397. }
  1398. func (s *DockerSwarmSuite) TestSwarmInitWithDrain(c *check.C) {
  1399. d := s.AddDaemon(c, false, false)
  1400. out, err := d.Cmd("swarm", "init", "--availability", "drain")
  1401. c.Assert(err, checker.IsNil, check.Commentf("out: %v", out))
  1402. out, err = d.Cmd("node", "ls")
  1403. c.Assert(err, checker.IsNil)
  1404. c.Assert(out, checker.Contains, "Drain")
  1405. }
  1406. func (s *DockerSwarmSuite) TestSwarmReadonlyRootfs(c *check.C) {
  1407. testRequires(c, DaemonIsLinux, UserNamespaceROMount)
  1408. d := s.AddDaemon(c, true, true)
  1409. out, err := d.Cmd("service", "create", "--name", "top", "--read-only", "busybox", "top")
  1410. c.Assert(err, checker.IsNil, check.Commentf(out))
  1411. // make sure task has been deployed.
  1412. waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, 1)
  1413. out, err = d.Cmd("service", "inspect", "--format", "{{ .Spec.TaskTemplate.ContainerSpec.ReadOnly }}", "top")
  1414. c.Assert(err, checker.IsNil, check.Commentf(out))
  1415. c.Assert(strings.TrimSpace(out), checker.Equals, "true")
  1416. containers := d.ActiveContainers()
  1417. out, err = d.Cmd("inspect", "--type", "container", "--format", "{{.HostConfig.ReadonlyRootfs}}", containers[0])
  1418. c.Assert(err, checker.IsNil, check.Commentf(out))
  1419. c.Assert(strings.TrimSpace(out), checker.Equals, "true")
  1420. }
  1421. func (s *DockerSwarmSuite) TestNetworkInspectWithDuplicateNames(c *check.C) {
  1422. d := s.AddDaemon(c, true, true)
  1423. name := "foo"
  1424. networkCreateRequest := types.NetworkCreateRequest{
  1425. Name: name,
  1426. NetworkCreate: types.NetworkCreate{
  1427. CheckDuplicate: false,
  1428. Driver: "bridge",
  1429. },
  1430. }
  1431. var n1 types.NetworkCreateResponse
  1432. status, body, err := d.SockRequest("POST", "/networks/create", networkCreateRequest)
  1433. c.Assert(err, checker.IsNil, check.Commentf(string(body)))
  1434. c.Assert(status, checker.Equals, http.StatusCreated, check.Commentf(string(body)))
  1435. c.Assert(json.Unmarshal(body, &n1), checker.IsNil)
  1436. // Full ID always works
  1437. out, err := d.Cmd("network", "inspect", "--format", "{{.ID}}", n1.ID)
  1438. c.Assert(err, checker.IsNil, check.Commentf(out))
  1439. c.Assert(strings.TrimSpace(out), checker.Equals, n1.ID)
  1440. // Name works if it is unique
  1441. out, err = d.Cmd("network", "inspect", "--format", "{{.ID}}", name)
  1442. c.Assert(err, checker.IsNil, check.Commentf(out))
  1443. c.Assert(strings.TrimSpace(out), checker.Equals, n1.ID)
  1444. var n2 types.NetworkCreateResponse
  1445. status, body, err = d.SockRequest("POST", "/networks/create", networkCreateRequest)
  1446. c.Assert(err, checker.IsNil, check.Commentf(string(body)))
  1447. c.Assert(status, checker.Equals, http.StatusCreated, check.Commentf(string(body)))
  1448. c.Assert(json.Unmarshal(body, &n2), checker.IsNil)
  1449. // Full ID always works
  1450. out, err = d.Cmd("network", "inspect", "--format", "{{.ID}}", n1.ID)
  1451. c.Assert(err, checker.IsNil, check.Commentf(out))
  1452. c.Assert(strings.TrimSpace(out), checker.Equals, n1.ID)
  1453. out, err = d.Cmd("network", "inspect", "--format", "{{.ID}}", n2.ID)
  1454. c.Assert(err, checker.IsNil, check.Commentf(out))
  1455. c.Assert(strings.TrimSpace(out), checker.Equals, n2.ID)
  1456. // Name with duplicates
  1457. out, err = d.Cmd("network", "inspect", "--format", "{{.ID}}", name)
  1458. c.Assert(err, checker.NotNil, check.Commentf(out))
  1459. c.Assert(out, checker.Contains, "network foo is ambiguous (2 matches found based on name)")
  1460. out, err = d.Cmd("network", "rm", n2.ID)
  1461. c.Assert(err, checker.IsNil, check.Commentf(out))
  1462. // Dupliates with name but with different driver
  1463. networkCreateRequest.NetworkCreate.Driver = "overlay"
  1464. status, body, err = d.SockRequest("POST", "/networks/create", networkCreateRequest)
  1465. c.Assert(err, checker.IsNil, check.Commentf(string(body)))
  1466. c.Assert(status, checker.Equals, http.StatusCreated, check.Commentf(string(body)))
  1467. c.Assert(json.Unmarshal(body, &n2), checker.IsNil)
  1468. // Full ID always works
  1469. out, err = d.Cmd("network", "inspect", "--format", "{{.ID}}", n1.ID)
  1470. c.Assert(err, checker.IsNil, check.Commentf(out))
  1471. c.Assert(strings.TrimSpace(out), checker.Equals, n1.ID)
  1472. out, err = d.Cmd("network", "inspect", "--format", "{{.ID}}", n2.ID)
  1473. c.Assert(err, checker.IsNil, check.Commentf(out))
  1474. c.Assert(strings.TrimSpace(out), checker.Equals, n2.ID)
  1475. // Name with duplicates
  1476. out, err = d.Cmd("network", "inspect", "--format", "{{.ID}}", name)
  1477. c.Assert(err, checker.NotNil, check.Commentf(out))
  1478. c.Assert(out, checker.Contains, "network foo is ambiguous (2 matches found based on name)")
  1479. }
  1480. func (s *DockerSwarmSuite) TestSwarmStopSignal(c *check.C) {
  1481. testRequires(c, DaemonIsLinux, UserNamespaceROMount)
  1482. d := s.AddDaemon(c, true, true)
  1483. out, err := d.Cmd("service", "create", "--name", "top", "--stop-signal=SIGHUP", "busybox", "top")
  1484. c.Assert(err, checker.IsNil, check.Commentf(out))
  1485. // make sure task has been deployed.
  1486. waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, 1)
  1487. out, err = d.Cmd("service", "inspect", "--format", "{{ .Spec.TaskTemplate.ContainerSpec.StopSignal }}", "top")
  1488. c.Assert(err, checker.IsNil, check.Commentf(out))
  1489. c.Assert(strings.TrimSpace(out), checker.Equals, "SIGHUP")
  1490. containers := d.ActiveContainers()
  1491. out, err = d.Cmd("inspect", "--type", "container", "--format", "{{.Config.StopSignal}}", containers[0])
  1492. c.Assert(err, checker.IsNil, check.Commentf(out))
  1493. c.Assert(strings.TrimSpace(out), checker.Equals, "SIGHUP")
  1494. out, err = d.Cmd("service", "update", "--stop-signal=SIGUSR1", "top")
  1495. c.Assert(err, checker.IsNil, check.Commentf(out))
  1496. out, err = d.Cmd("service", "inspect", "--format", "{{ .Spec.TaskTemplate.ContainerSpec.StopSignal }}", "top")
  1497. c.Assert(err, checker.IsNil, check.Commentf(out))
  1498. c.Assert(strings.TrimSpace(out), checker.Equals, "SIGUSR1")
  1499. }
  1500. func (s *DockerSwarmSuite) TestSwarmServiceLsFilterMode(c *check.C) {
  1501. d := s.AddDaemon(c, true, true)
  1502. out, err := d.Cmd("service", "create", "--name", "top1", "busybox", "top")
  1503. c.Assert(err, checker.IsNil, check.Commentf(out))
  1504. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  1505. out, err = d.Cmd("service", "create", "--name", "top2", "--mode=global", "busybox", "top")
  1506. c.Assert(err, checker.IsNil, check.Commentf(out))
  1507. c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
  1508. // make sure task has been deployed.
  1509. waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, 2)
  1510. out, err = d.Cmd("service", "ls")
  1511. c.Assert(err, checker.IsNil, check.Commentf(out))
  1512. c.Assert(out, checker.Contains, "top1")
  1513. c.Assert(out, checker.Contains, "top2")
  1514. c.Assert(out, checker.Not(checker.Contains), "localnet")
  1515. out, err = d.Cmd("service", "ls", "--filter", "mode=global")
  1516. c.Assert(out, checker.Not(checker.Contains), "top1")
  1517. c.Assert(out, checker.Contains, "top2")
  1518. c.Assert(err, checker.IsNil, check.Commentf(out))
  1519. out, err = d.Cmd("service", "ls", "--filter", "mode=replicated")
  1520. c.Assert(err, checker.IsNil, check.Commentf(out))
  1521. c.Assert(out, checker.Contains, "top1")
  1522. c.Assert(out, checker.Not(checker.Contains), "top2")
  1523. }