update.go 29 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949
  1. package service
  2. import (
  3. "fmt"
  4. "sort"
  5. "strings"
  6. "time"
  7. "github.com/docker/docker/api/types"
  8. "github.com/docker/docker/api/types/container"
  9. mounttypes "github.com/docker/docker/api/types/mount"
  10. "github.com/docker/docker/api/types/swarm"
  11. "github.com/docker/docker/api/types/versions"
  12. "github.com/docker/docker/cli"
  13. "github.com/docker/docker/cli/command"
  14. "github.com/docker/docker/client"
  15. "github.com/docker/docker/opts"
  16. runconfigopts "github.com/docker/docker/runconfig/opts"
  17. "github.com/docker/go-connections/nat"
  18. "github.com/pkg/errors"
  19. "github.com/spf13/cobra"
  20. "github.com/spf13/pflag"
  21. "golang.org/x/net/context"
  22. )
  23. func newUpdateCommand(dockerCli *command.DockerCli) *cobra.Command {
  24. serviceOpts := newServiceOptions()
  25. cmd := &cobra.Command{
  26. Use: "update [OPTIONS] SERVICE",
  27. Short: "Update a service",
  28. Args: cli.ExactArgs(1),
  29. RunE: func(cmd *cobra.Command, args []string) error {
  30. return runUpdate(dockerCli, cmd.Flags(), serviceOpts, args[0])
  31. },
  32. }
  33. flags := cmd.Flags()
  34. flags.String("image", "", "Service image tag")
  35. flags.Var(&ShlexOpt{}, "args", "Service command args")
  36. flags.Bool("rollback", false, "Rollback to previous specification")
  37. flags.SetAnnotation("rollback", "version", []string{"1.25"})
  38. flags.Bool("force", false, "Force update even if no changes require it")
  39. flags.SetAnnotation("force", "version", []string{"1.25"})
  40. addServiceFlags(flags, serviceOpts)
  41. flags.Var(newListOptsVar(), flagEnvRemove, "Remove an environment variable")
  42. flags.Var(newListOptsVar(), flagGroupRemove, "Remove a previously added supplementary user group from the container")
  43. flags.SetAnnotation(flagGroupRemove, "version", []string{"1.25"})
  44. flags.Var(newListOptsVar(), flagLabelRemove, "Remove a label by its key")
  45. flags.Var(newListOptsVar(), flagContainerLabelRemove, "Remove a container label by its key")
  46. flags.Var(newListOptsVar(), flagMountRemove, "Remove a mount by its target path")
  47. // flags.Var(newListOptsVar().WithValidator(validatePublishRemove), flagPublishRemove, "Remove a published port by its target port")
  48. flags.Var(&opts.PortOpt{}, flagPublishRemove, "Remove a published port by its target port")
  49. flags.Var(newListOptsVar(), flagConstraintRemove, "Remove a constraint")
  50. flags.Var(newListOptsVar(), flagDNSRemove, "Remove a custom DNS server")
  51. flags.SetAnnotation(flagDNSRemove, "version", []string{"1.25"})
  52. flags.Var(newListOptsVar(), flagDNSOptionRemove, "Remove a DNS option")
  53. flags.SetAnnotation(flagDNSOptionRemove, "version", []string{"1.25"})
  54. flags.Var(newListOptsVar(), flagDNSSearchRemove, "Remove a DNS search domain")
  55. flags.SetAnnotation(flagDNSSearchRemove, "version", []string{"1.25"})
  56. flags.Var(newListOptsVar(), flagHostRemove, "Remove a custom host-to-IP mapping (host:ip)")
  57. flags.SetAnnotation(flagHostRemove, "version", []string{"1.25"})
  58. flags.Var(&serviceOpts.labels, flagLabelAdd, "Add or update a service label")
  59. flags.Var(&serviceOpts.containerLabels, flagContainerLabelAdd, "Add or update a container label")
  60. flags.Var(&serviceOpts.env, flagEnvAdd, "Add or update an environment variable")
  61. flags.Var(newListOptsVar(), flagSecretRemove, "Remove a secret")
  62. flags.SetAnnotation(flagSecretRemove, "version", []string{"1.25"})
  63. flags.Var(&serviceOpts.secrets, flagSecretAdd, "Add or update a secret on a service")
  64. flags.SetAnnotation(flagSecretAdd, "version", []string{"1.25"})
  65. flags.Var(&serviceOpts.mounts, flagMountAdd, "Add or update a mount on a service")
  66. flags.Var(&serviceOpts.constraints, flagConstraintAdd, "Add or update a placement constraint")
  67. flags.Var(&serviceOpts.placementPrefs, flagPlacementPrefAdd, "Add a placement preference")
  68. flags.SetAnnotation(flagPlacementPrefAdd, "version", []string{"1.28"})
  69. flags.Var(&placementPrefOpts{}, flagPlacementPrefRemove, "Remove a placement preference")
  70. flags.SetAnnotation(flagPlacementPrefRemove, "version", []string{"1.28"})
  71. flags.Var(&serviceOpts.endpoint.publishPorts, flagPublishAdd, "Add or update a published port")
  72. flags.Var(&serviceOpts.groups, flagGroupAdd, "Add an additional supplementary user group to the container")
  73. flags.SetAnnotation(flagGroupAdd, "version", []string{"1.25"})
  74. flags.Var(&serviceOpts.dns, flagDNSAdd, "Add or update a custom DNS server")
  75. flags.SetAnnotation(flagDNSAdd, "version", []string{"1.25"})
  76. flags.Var(&serviceOpts.dnsOption, flagDNSOptionAdd, "Add or update a DNS option")
  77. flags.SetAnnotation(flagDNSOptionAdd, "version", []string{"1.25"})
  78. flags.Var(&serviceOpts.dnsSearch, flagDNSSearchAdd, "Add or update a custom DNS search domain")
  79. flags.SetAnnotation(flagDNSSearchAdd, "version", []string{"1.25"})
  80. flags.Var(&serviceOpts.hosts, flagHostAdd, "Add or update a custom host-to-IP mapping (host:ip)")
  81. flags.SetAnnotation(flagHostAdd, "version", []string{"1.25"})
  82. return cmd
  83. }
  84. func newListOptsVar() *opts.ListOpts {
  85. return opts.NewListOptsRef(&[]string{}, nil)
  86. }
  87. func runUpdate(dockerCli *command.DockerCli, flags *pflag.FlagSet, opts *serviceOptions, serviceID string) error {
  88. apiClient := dockerCli.Client()
  89. ctx := context.Background()
  90. service, _, err := apiClient.ServiceInspectWithRaw(ctx, serviceID)
  91. if err != nil {
  92. return err
  93. }
  94. rollback, err := flags.GetBool("rollback")
  95. if err != nil {
  96. return err
  97. }
  98. // There are two ways to do user-requested rollback. The old way is
  99. // client-side, but with a sufficiently recent daemon we prefer
  100. // server-side, because it will honor the rollback parameters.
  101. var (
  102. clientSideRollback bool
  103. serverSideRollback bool
  104. )
  105. spec := &service.Spec
  106. if rollback {
  107. // Rollback can't be combined with other flags.
  108. otherFlagsPassed := false
  109. flags.VisitAll(func(f *pflag.Flag) {
  110. if f.Name == "rollback" {
  111. return
  112. }
  113. if flags.Changed(f.Name) {
  114. otherFlagsPassed = true
  115. }
  116. })
  117. if otherFlagsPassed {
  118. return errors.New("other flags may not be combined with --rollback")
  119. }
  120. if versions.LessThan(dockerCli.Client().ClientVersion(), "1.28") {
  121. clientSideRollback = true
  122. spec = service.PreviousSpec
  123. if spec == nil {
  124. return errors.Errorf("service does not have a previous specification to roll back to")
  125. }
  126. } else {
  127. serverSideRollback = true
  128. }
  129. }
  130. updateOpts := types.ServiceUpdateOptions{}
  131. if serverSideRollback {
  132. updateOpts.Rollback = "previous"
  133. }
  134. err = updateService(flags, spec)
  135. if err != nil {
  136. return err
  137. }
  138. if flags.Changed("image") {
  139. if err := resolveServiceImageDigest(dockerCli, spec); err != nil {
  140. return err
  141. }
  142. }
  143. updatedSecrets, err := getUpdatedSecrets(apiClient, flags, spec.TaskTemplate.ContainerSpec.Secrets)
  144. if err != nil {
  145. return err
  146. }
  147. spec.TaskTemplate.ContainerSpec.Secrets = updatedSecrets
  148. // only send auth if flag was set
  149. sendAuth, err := flags.GetBool(flagRegistryAuth)
  150. if err != nil {
  151. return err
  152. }
  153. if sendAuth {
  154. // Retrieve encoded auth token from the image reference
  155. // This would be the old image if it didn't change in this update
  156. image := spec.TaskTemplate.ContainerSpec.Image
  157. encodedAuth, err := command.RetrieveAuthTokenFromImage(ctx, dockerCli, image)
  158. if err != nil {
  159. return err
  160. }
  161. updateOpts.EncodedRegistryAuth = encodedAuth
  162. } else if clientSideRollback {
  163. updateOpts.RegistryAuthFrom = types.RegistryAuthFromPreviousSpec
  164. } else {
  165. updateOpts.RegistryAuthFrom = types.RegistryAuthFromSpec
  166. }
  167. response, err := apiClient.ServiceUpdate(ctx, service.ID, service.Version, *spec, updateOpts)
  168. if err != nil {
  169. return err
  170. }
  171. for _, warning := range response.Warnings {
  172. fmt.Fprintln(dockerCli.Err(), warning)
  173. }
  174. fmt.Fprintf(dockerCli.Out(), "%s\n", serviceID)
  175. if opts.detach {
  176. if !flags.Changed("detach") {
  177. fmt.Fprintln(dockerCli.Err(), "Since --detach=false was not specified, tasks will be updated in the background.\n"+
  178. "In a future release, --detach=false will become the default.")
  179. }
  180. return nil
  181. }
  182. return waitOnService(ctx, dockerCli, serviceID, opts)
  183. }
  184. func updateService(flags *pflag.FlagSet, spec *swarm.ServiceSpec) error {
  185. updateString := func(flag string, field *string) {
  186. if flags.Changed(flag) {
  187. *field, _ = flags.GetString(flag)
  188. }
  189. }
  190. updateInt64Value := func(flag string, field *int64) {
  191. if flags.Changed(flag) {
  192. *field = flags.Lookup(flag).Value.(int64Value).Value()
  193. }
  194. }
  195. updateFloatValue := func(flag string, field *float32) {
  196. if flags.Changed(flag) {
  197. *field = flags.Lookup(flag).Value.(*floatValue).Value()
  198. }
  199. }
  200. updateDuration := func(flag string, field *time.Duration) {
  201. if flags.Changed(flag) {
  202. *field, _ = flags.GetDuration(flag)
  203. }
  204. }
  205. updateDurationOpt := func(flag string, field **time.Duration) {
  206. if flags.Changed(flag) {
  207. val := *flags.Lookup(flag).Value.(*DurationOpt).Value()
  208. *field = &val
  209. }
  210. }
  211. updateUint64 := func(flag string, field *uint64) {
  212. if flags.Changed(flag) {
  213. *field, _ = flags.GetUint64(flag)
  214. }
  215. }
  216. updateUint64Opt := func(flag string, field **uint64) {
  217. if flags.Changed(flag) {
  218. val := *flags.Lookup(flag).Value.(*Uint64Opt).Value()
  219. *field = &val
  220. }
  221. }
  222. cspec := &spec.TaskTemplate.ContainerSpec
  223. task := &spec.TaskTemplate
  224. taskResources := func() *swarm.ResourceRequirements {
  225. if task.Resources == nil {
  226. task.Resources = &swarm.ResourceRequirements{}
  227. }
  228. return task.Resources
  229. }
  230. updateLabels(flags, &spec.Labels)
  231. updateContainerLabels(flags, &cspec.Labels)
  232. updateString("image", &cspec.Image)
  233. updateStringToSlice(flags, "args", &cspec.Args)
  234. updateStringToSlice(flags, flagEntrypoint, &cspec.Command)
  235. updateEnvironment(flags, &cspec.Env)
  236. updateString(flagWorkdir, &cspec.Dir)
  237. updateString(flagUser, &cspec.User)
  238. updateString(flagHostname, &cspec.Hostname)
  239. if err := updateMounts(flags, &cspec.Mounts); err != nil {
  240. return err
  241. }
  242. if flags.Changed(flagLimitCPU) || flags.Changed(flagLimitMemory) {
  243. taskResources().Limits = &swarm.Resources{}
  244. updateInt64Value(flagLimitCPU, &task.Resources.Limits.NanoCPUs)
  245. updateInt64Value(flagLimitMemory, &task.Resources.Limits.MemoryBytes)
  246. }
  247. if flags.Changed(flagReserveCPU) || flags.Changed(flagReserveMemory) {
  248. taskResources().Reservations = &swarm.Resources{}
  249. updateInt64Value(flagReserveCPU, &task.Resources.Reservations.NanoCPUs)
  250. updateInt64Value(flagReserveMemory, &task.Resources.Reservations.MemoryBytes)
  251. }
  252. updateDurationOpt(flagStopGracePeriod, &cspec.StopGracePeriod)
  253. if anyChanged(flags, flagRestartCondition, flagRestartDelay, flagRestartMaxAttempts, flagRestartWindow) {
  254. if task.RestartPolicy == nil {
  255. task.RestartPolicy = &swarm.RestartPolicy{}
  256. }
  257. if flags.Changed(flagRestartCondition) {
  258. value, _ := flags.GetString(flagRestartCondition)
  259. task.RestartPolicy.Condition = swarm.RestartPolicyCondition(value)
  260. }
  261. updateDurationOpt(flagRestartDelay, &task.RestartPolicy.Delay)
  262. updateUint64Opt(flagRestartMaxAttempts, &task.RestartPolicy.MaxAttempts)
  263. updateDurationOpt(flagRestartWindow, &task.RestartPolicy.Window)
  264. }
  265. if anyChanged(flags, flagConstraintAdd, flagConstraintRemove) {
  266. if task.Placement == nil {
  267. task.Placement = &swarm.Placement{}
  268. }
  269. updatePlacementConstraints(flags, task.Placement)
  270. }
  271. if anyChanged(flags, flagPlacementPrefAdd, flagPlacementPrefRemove) {
  272. if task.Placement == nil {
  273. task.Placement = &swarm.Placement{}
  274. }
  275. updatePlacementPreferences(flags, task.Placement)
  276. }
  277. if err := updateReplicas(flags, &spec.Mode); err != nil {
  278. return err
  279. }
  280. if anyChanged(flags, flagUpdateParallelism, flagUpdateDelay, flagUpdateMonitor, flagUpdateFailureAction, flagUpdateMaxFailureRatio, flagUpdateOrder) {
  281. if spec.UpdateConfig == nil {
  282. spec.UpdateConfig = &swarm.UpdateConfig{}
  283. }
  284. updateUint64(flagUpdateParallelism, &spec.UpdateConfig.Parallelism)
  285. updateDuration(flagUpdateDelay, &spec.UpdateConfig.Delay)
  286. updateDuration(flagUpdateMonitor, &spec.UpdateConfig.Monitor)
  287. updateString(flagUpdateFailureAction, &spec.UpdateConfig.FailureAction)
  288. updateFloatValue(flagUpdateMaxFailureRatio, &spec.UpdateConfig.MaxFailureRatio)
  289. updateString(flagUpdateOrder, &spec.UpdateConfig.Order)
  290. }
  291. if anyChanged(flags, flagRollbackParallelism, flagRollbackDelay, flagRollbackMonitor, flagRollbackFailureAction, flagRollbackMaxFailureRatio, flagRollbackOrder) {
  292. if spec.RollbackConfig == nil {
  293. spec.RollbackConfig = &swarm.UpdateConfig{}
  294. }
  295. updateUint64(flagRollbackParallelism, &spec.RollbackConfig.Parallelism)
  296. updateDuration(flagRollbackDelay, &spec.RollbackConfig.Delay)
  297. updateDuration(flagRollbackMonitor, &spec.RollbackConfig.Monitor)
  298. updateString(flagRollbackFailureAction, &spec.RollbackConfig.FailureAction)
  299. updateFloatValue(flagRollbackMaxFailureRatio, &spec.RollbackConfig.MaxFailureRatio)
  300. updateString(flagRollbackOrder, &spec.RollbackConfig.Order)
  301. }
  302. if flags.Changed(flagEndpointMode) {
  303. value, _ := flags.GetString(flagEndpointMode)
  304. if spec.EndpointSpec == nil {
  305. spec.EndpointSpec = &swarm.EndpointSpec{}
  306. }
  307. spec.EndpointSpec.Mode = swarm.ResolutionMode(value)
  308. }
  309. if anyChanged(flags, flagGroupAdd, flagGroupRemove) {
  310. if err := updateGroups(flags, &cspec.Groups); err != nil {
  311. return err
  312. }
  313. }
  314. if anyChanged(flags, flagPublishAdd, flagPublishRemove) {
  315. if spec.EndpointSpec == nil {
  316. spec.EndpointSpec = &swarm.EndpointSpec{}
  317. }
  318. if err := updatePorts(flags, &spec.EndpointSpec.Ports); err != nil {
  319. return err
  320. }
  321. }
  322. if anyChanged(flags, flagDNSAdd, flagDNSRemove, flagDNSOptionAdd, flagDNSOptionRemove, flagDNSSearchAdd, flagDNSSearchRemove) {
  323. if cspec.DNSConfig == nil {
  324. cspec.DNSConfig = &swarm.DNSConfig{}
  325. }
  326. if err := updateDNSConfig(flags, &cspec.DNSConfig); err != nil {
  327. return err
  328. }
  329. }
  330. if anyChanged(flags, flagHostAdd, flagHostRemove) {
  331. if err := updateHosts(flags, &cspec.Hosts); err != nil {
  332. return err
  333. }
  334. }
  335. if err := updateLogDriver(flags, &spec.TaskTemplate); err != nil {
  336. return err
  337. }
  338. force, err := flags.GetBool("force")
  339. if err != nil {
  340. return err
  341. }
  342. if force {
  343. spec.TaskTemplate.ForceUpdate++
  344. }
  345. if err := updateHealthcheck(flags, cspec); err != nil {
  346. return err
  347. }
  348. if flags.Changed(flagTTY) {
  349. tty, err := flags.GetBool(flagTTY)
  350. if err != nil {
  351. return err
  352. }
  353. cspec.TTY = tty
  354. }
  355. if flags.Changed(flagReadOnly) {
  356. readOnly, err := flags.GetBool(flagReadOnly)
  357. if err != nil {
  358. return err
  359. }
  360. cspec.ReadOnly = readOnly
  361. }
  362. updateString(flagStopSignal, &cspec.StopSignal)
  363. return nil
  364. }
  365. func updateStringToSlice(flags *pflag.FlagSet, flag string, field *[]string) {
  366. if !flags.Changed(flag) {
  367. return
  368. }
  369. *field = flags.Lookup(flag).Value.(*ShlexOpt).Value()
  370. }
  371. func anyChanged(flags *pflag.FlagSet, fields ...string) bool {
  372. for _, flag := range fields {
  373. if flags.Changed(flag) {
  374. return true
  375. }
  376. }
  377. return false
  378. }
  379. func updatePlacementConstraints(flags *pflag.FlagSet, placement *swarm.Placement) {
  380. if flags.Changed(flagConstraintAdd) {
  381. values := flags.Lookup(flagConstraintAdd).Value.(*opts.ListOpts).GetAll()
  382. placement.Constraints = append(placement.Constraints, values...)
  383. }
  384. toRemove := buildToRemoveSet(flags, flagConstraintRemove)
  385. newConstraints := []string{}
  386. for _, constraint := range placement.Constraints {
  387. if _, exists := toRemove[constraint]; !exists {
  388. newConstraints = append(newConstraints, constraint)
  389. }
  390. }
  391. // Sort so that result is predictable.
  392. sort.Strings(newConstraints)
  393. placement.Constraints = newConstraints
  394. }
  395. func updatePlacementPreferences(flags *pflag.FlagSet, placement *swarm.Placement) {
  396. var newPrefs []swarm.PlacementPreference
  397. if flags.Changed(flagPlacementPrefRemove) {
  398. for _, existing := range placement.Preferences {
  399. removed := false
  400. for _, removal := range flags.Lookup(flagPlacementPrefRemove).Value.(*placementPrefOpts).prefs {
  401. if removal.Spread != nil && existing.Spread != nil && removal.Spread.SpreadDescriptor == existing.Spread.SpreadDescriptor {
  402. removed = true
  403. break
  404. }
  405. }
  406. if !removed {
  407. newPrefs = append(newPrefs, existing)
  408. }
  409. }
  410. } else {
  411. newPrefs = placement.Preferences
  412. }
  413. if flags.Changed(flagPlacementPrefAdd) {
  414. for _, addition := range flags.Lookup(flagPlacementPrefAdd).Value.(*placementPrefOpts).prefs {
  415. newPrefs = append(newPrefs, addition)
  416. }
  417. }
  418. placement.Preferences = newPrefs
  419. }
  420. func updateContainerLabels(flags *pflag.FlagSet, field *map[string]string) {
  421. if flags.Changed(flagContainerLabelAdd) {
  422. if *field == nil {
  423. *field = map[string]string{}
  424. }
  425. values := flags.Lookup(flagContainerLabelAdd).Value.(*opts.ListOpts).GetAll()
  426. for key, value := range runconfigopts.ConvertKVStringsToMap(values) {
  427. (*field)[key] = value
  428. }
  429. }
  430. if *field != nil && flags.Changed(flagContainerLabelRemove) {
  431. toRemove := flags.Lookup(flagContainerLabelRemove).Value.(*opts.ListOpts).GetAll()
  432. for _, label := range toRemove {
  433. delete(*field, label)
  434. }
  435. }
  436. }
  437. func updateLabels(flags *pflag.FlagSet, field *map[string]string) {
  438. if flags.Changed(flagLabelAdd) {
  439. if *field == nil {
  440. *field = map[string]string{}
  441. }
  442. values := flags.Lookup(flagLabelAdd).Value.(*opts.ListOpts).GetAll()
  443. for key, value := range runconfigopts.ConvertKVStringsToMap(values) {
  444. (*field)[key] = value
  445. }
  446. }
  447. if *field != nil && flags.Changed(flagLabelRemove) {
  448. toRemove := flags.Lookup(flagLabelRemove).Value.(*opts.ListOpts).GetAll()
  449. for _, label := range toRemove {
  450. delete(*field, label)
  451. }
  452. }
  453. }
  454. func updateEnvironment(flags *pflag.FlagSet, field *[]string) {
  455. if flags.Changed(flagEnvAdd) {
  456. envSet := map[string]string{}
  457. for _, v := range *field {
  458. envSet[envKey(v)] = v
  459. }
  460. value := flags.Lookup(flagEnvAdd).Value.(*opts.ListOpts)
  461. for _, v := range value.GetAll() {
  462. envSet[envKey(v)] = v
  463. }
  464. *field = []string{}
  465. for _, v := range envSet {
  466. *field = append(*field, v)
  467. }
  468. }
  469. toRemove := buildToRemoveSet(flags, flagEnvRemove)
  470. *field = removeItems(*field, toRemove, envKey)
  471. }
  472. func getUpdatedSecrets(apiClient client.SecretAPIClient, flags *pflag.FlagSet, secrets []*swarm.SecretReference) ([]*swarm.SecretReference, error) {
  473. newSecrets := []*swarm.SecretReference{}
  474. toRemove := buildToRemoveSet(flags, flagSecretRemove)
  475. for _, secret := range secrets {
  476. if _, exists := toRemove[secret.SecretName]; !exists {
  477. newSecrets = append(newSecrets, secret)
  478. }
  479. }
  480. if flags.Changed(flagSecretAdd) {
  481. values := flags.Lookup(flagSecretAdd).Value.(*opts.SecretOpt).Value()
  482. addSecrets, err := ParseSecrets(apiClient, values)
  483. if err != nil {
  484. return nil, err
  485. }
  486. newSecrets = append(newSecrets, addSecrets...)
  487. }
  488. return newSecrets, nil
  489. }
  490. func envKey(value string) string {
  491. kv := strings.SplitN(value, "=", 2)
  492. return kv[0]
  493. }
  494. func itemKey(value string) string {
  495. return value
  496. }
  497. func buildToRemoveSet(flags *pflag.FlagSet, flag string) map[string]struct{} {
  498. var empty struct{}
  499. toRemove := make(map[string]struct{})
  500. if !flags.Changed(flag) {
  501. return toRemove
  502. }
  503. toRemoveSlice := flags.Lookup(flag).Value.(*opts.ListOpts).GetAll()
  504. for _, key := range toRemoveSlice {
  505. toRemove[key] = empty
  506. }
  507. return toRemove
  508. }
  509. func removeItems(
  510. seq []string,
  511. toRemove map[string]struct{},
  512. keyFunc func(string) string,
  513. ) []string {
  514. newSeq := []string{}
  515. for _, item := range seq {
  516. if _, exists := toRemove[keyFunc(item)]; !exists {
  517. newSeq = append(newSeq, item)
  518. }
  519. }
  520. return newSeq
  521. }
  522. type byMountSource []mounttypes.Mount
  523. func (m byMountSource) Len() int { return len(m) }
  524. func (m byMountSource) Swap(i, j int) { m[i], m[j] = m[j], m[i] }
  525. func (m byMountSource) Less(i, j int) bool {
  526. a, b := m[i], m[j]
  527. if a.Source == b.Source {
  528. return a.Target < b.Target
  529. }
  530. return a.Source < b.Source
  531. }
  532. func updateMounts(flags *pflag.FlagSet, mounts *[]mounttypes.Mount) error {
  533. mountsByTarget := map[string]mounttypes.Mount{}
  534. if flags.Changed(flagMountAdd) {
  535. values := flags.Lookup(flagMountAdd).Value.(*opts.MountOpt).Value()
  536. for _, mount := range values {
  537. if _, ok := mountsByTarget[mount.Target]; ok {
  538. return errors.Errorf("duplicate mount target")
  539. }
  540. mountsByTarget[mount.Target] = mount
  541. }
  542. }
  543. // Add old list of mount points minus updated one.
  544. for _, mount := range *mounts {
  545. if _, ok := mountsByTarget[mount.Target]; !ok {
  546. mountsByTarget[mount.Target] = mount
  547. }
  548. }
  549. newMounts := []mounttypes.Mount{}
  550. toRemove := buildToRemoveSet(flags, flagMountRemove)
  551. for _, mount := range mountsByTarget {
  552. if _, exists := toRemove[mount.Target]; !exists {
  553. newMounts = append(newMounts, mount)
  554. }
  555. }
  556. sort.Sort(byMountSource(newMounts))
  557. *mounts = newMounts
  558. return nil
  559. }
  560. func updateGroups(flags *pflag.FlagSet, groups *[]string) error {
  561. if flags.Changed(flagGroupAdd) {
  562. values := flags.Lookup(flagGroupAdd).Value.(*opts.ListOpts).GetAll()
  563. *groups = append(*groups, values...)
  564. }
  565. toRemove := buildToRemoveSet(flags, flagGroupRemove)
  566. newGroups := []string{}
  567. for _, group := range *groups {
  568. if _, exists := toRemove[group]; !exists {
  569. newGroups = append(newGroups, group)
  570. }
  571. }
  572. // Sort so that result is predictable.
  573. sort.Strings(newGroups)
  574. *groups = newGroups
  575. return nil
  576. }
  577. func removeDuplicates(entries []string) []string {
  578. hit := map[string]bool{}
  579. newEntries := []string{}
  580. for _, v := range entries {
  581. if !hit[v] {
  582. newEntries = append(newEntries, v)
  583. hit[v] = true
  584. }
  585. }
  586. return newEntries
  587. }
  588. func updateDNSConfig(flags *pflag.FlagSet, config **swarm.DNSConfig) error {
  589. newConfig := &swarm.DNSConfig{}
  590. nameservers := (*config).Nameservers
  591. if flags.Changed(flagDNSAdd) {
  592. values := flags.Lookup(flagDNSAdd).Value.(*opts.ListOpts).GetAll()
  593. nameservers = append(nameservers, values...)
  594. }
  595. nameservers = removeDuplicates(nameservers)
  596. toRemove := buildToRemoveSet(flags, flagDNSRemove)
  597. for _, nameserver := range nameservers {
  598. if _, exists := toRemove[nameserver]; !exists {
  599. newConfig.Nameservers = append(newConfig.Nameservers, nameserver)
  600. }
  601. }
  602. // Sort so that result is predictable.
  603. sort.Strings(newConfig.Nameservers)
  604. search := (*config).Search
  605. if flags.Changed(flagDNSSearchAdd) {
  606. values := flags.Lookup(flagDNSSearchAdd).Value.(*opts.ListOpts).GetAll()
  607. search = append(search, values...)
  608. }
  609. search = removeDuplicates(search)
  610. toRemove = buildToRemoveSet(flags, flagDNSSearchRemove)
  611. for _, entry := range search {
  612. if _, exists := toRemove[entry]; !exists {
  613. newConfig.Search = append(newConfig.Search, entry)
  614. }
  615. }
  616. // Sort so that result is predictable.
  617. sort.Strings(newConfig.Search)
  618. options := (*config).Options
  619. if flags.Changed(flagDNSOptionAdd) {
  620. values := flags.Lookup(flagDNSOptionAdd).Value.(*opts.ListOpts).GetAll()
  621. options = append(options, values...)
  622. }
  623. options = removeDuplicates(options)
  624. toRemove = buildToRemoveSet(flags, flagDNSOptionRemove)
  625. for _, option := range options {
  626. if _, exists := toRemove[option]; !exists {
  627. newConfig.Options = append(newConfig.Options, option)
  628. }
  629. }
  630. // Sort so that result is predictable.
  631. sort.Strings(newConfig.Options)
  632. *config = newConfig
  633. return nil
  634. }
  635. type byPortConfig []swarm.PortConfig
  636. func (r byPortConfig) Len() int { return len(r) }
  637. func (r byPortConfig) Swap(i, j int) { r[i], r[j] = r[j], r[i] }
  638. func (r byPortConfig) Less(i, j int) bool {
  639. // We convert PortConfig into `port/protocol`, e.g., `80/tcp`
  640. // In updatePorts we already filter out with map so there is duplicate entries
  641. return portConfigToString(&r[i]) < portConfigToString(&r[j])
  642. }
  643. func portConfigToString(portConfig *swarm.PortConfig) string {
  644. protocol := portConfig.Protocol
  645. mode := portConfig.PublishMode
  646. return fmt.Sprintf("%v:%v/%s/%s", portConfig.PublishedPort, portConfig.TargetPort, protocol, mode)
  647. }
  648. func updatePorts(flags *pflag.FlagSet, portConfig *[]swarm.PortConfig) error {
  649. // The key of the map is `port/protocol`, e.g., `80/tcp`
  650. portSet := map[string]swarm.PortConfig{}
  651. // Build the current list of portConfig
  652. for _, entry := range *portConfig {
  653. if _, ok := portSet[portConfigToString(&entry)]; !ok {
  654. portSet[portConfigToString(&entry)] = entry
  655. }
  656. }
  657. newPorts := []swarm.PortConfig{}
  658. // Clean current ports
  659. toRemove := flags.Lookup(flagPublishRemove).Value.(*opts.PortOpt).Value()
  660. portLoop:
  661. for _, port := range portSet {
  662. for _, pConfig := range toRemove {
  663. if equalProtocol(port.Protocol, pConfig.Protocol) &&
  664. port.TargetPort == pConfig.TargetPort &&
  665. equalPublishMode(port.PublishMode, pConfig.PublishMode) {
  666. continue portLoop
  667. }
  668. }
  669. newPorts = append(newPorts, port)
  670. }
  671. // Check to see if there are any conflict in flags.
  672. if flags.Changed(flagPublishAdd) {
  673. ports := flags.Lookup(flagPublishAdd).Value.(*opts.PortOpt).Value()
  674. for _, port := range ports {
  675. if _, ok := portSet[portConfigToString(&port)]; ok {
  676. continue
  677. }
  678. //portSet[portConfigToString(&port)] = port
  679. newPorts = append(newPorts, port)
  680. }
  681. }
  682. // Sort the PortConfig to avoid unnecessary updates
  683. sort.Sort(byPortConfig(newPorts))
  684. *portConfig = newPorts
  685. return nil
  686. }
  687. func equalProtocol(prot1, prot2 swarm.PortConfigProtocol) bool {
  688. return prot1 == prot2 ||
  689. (prot1 == swarm.PortConfigProtocol("") && prot2 == swarm.PortConfigProtocolTCP) ||
  690. (prot2 == swarm.PortConfigProtocol("") && prot1 == swarm.PortConfigProtocolTCP)
  691. }
  692. func equalPublishMode(mode1, mode2 swarm.PortConfigPublishMode) bool {
  693. return mode1 == mode2 ||
  694. (mode1 == swarm.PortConfigPublishMode("") && mode2 == swarm.PortConfigPublishModeIngress) ||
  695. (mode2 == swarm.PortConfigPublishMode("") && mode1 == swarm.PortConfigPublishModeIngress)
  696. }
  697. func equalPort(targetPort nat.Port, port swarm.PortConfig) bool {
  698. return (string(port.Protocol) == targetPort.Proto() &&
  699. port.TargetPort == uint32(targetPort.Int()))
  700. }
  701. func updateReplicas(flags *pflag.FlagSet, serviceMode *swarm.ServiceMode) error {
  702. if !flags.Changed(flagReplicas) {
  703. return nil
  704. }
  705. if serviceMode == nil || serviceMode.Replicated == nil {
  706. return errors.Errorf("replicas can only be used with replicated mode")
  707. }
  708. serviceMode.Replicated.Replicas = flags.Lookup(flagReplicas).Value.(*Uint64Opt).Value()
  709. return nil
  710. }
  711. func updateHosts(flags *pflag.FlagSet, hosts *[]string) error {
  712. // Combine existing Hosts (in swarmkit format) with the host to add (convert to swarmkit format)
  713. if flags.Changed(flagHostAdd) {
  714. values := convertExtraHostsToSwarmHosts(flags.Lookup(flagHostAdd).Value.(*opts.ListOpts).GetAll())
  715. *hosts = append(*hosts, values...)
  716. }
  717. // Remove duplicate
  718. *hosts = removeDuplicates(*hosts)
  719. keysToRemove := make(map[string]struct{})
  720. if flags.Changed(flagHostRemove) {
  721. var empty struct{}
  722. extraHostsToRemove := flags.Lookup(flagHostRemove).Value.(*opts.ListOpts).GetAll()
  723. for _, entry := range extraHostsToRemove {
  724. key := strings.SplitN(entry, ":", 2)[0]
  725. keysToRemove[key] = empty
  726. }
  727. }
  728. newHosts := []string{}
  729. for _, entry := range *hosts {
  730. // Since this is in swarmkit format, we need to find the key, which is canonical_hostname of:
  731. // IP_address canonical_hostname [aliases...]
  732. parts := strings.Fields(entry)
  733. if len(parts) > 1 {
  734. key := parts[1]
  735. if _, exists := keysToRemove[key]; !exists {
  736. newHosts = append(newHosts, entry)
  737. }
  738. } else {
  739. newHosts = append(newHosts, entry)
  740. }
  741. }
  742. // Sort so that result is predictable.
  743. sort.Strings(newHosts)
  744. *hosts = newHosts
  745. return nil
  746. }
  747. // updateLogDriver updates the log driver only if the log driver flag is set.
  748. // All options will be replaced with those provided on the command line.
  749. func updateLogDriver(flags *pflag.FlagSet, taskTemplate *swarm.TaskSpec) error {
  750. if !flags.Changed(flagLogDriver) {
  751. return nil
  752. }
  753. name, err := flags.GetString(flagLogDriver)
  754. if err != nil {
  755. return err
  756. }
  757. if name == "" {
  758. return nil
  759. }
  760. taskTemplate.LogDriver = &swarm.Driver{
  761. Name: name,
  762. Options: runconfigopts.ConvertKVStringsToMap(flags.Lookup(flagLogOpt).Value.(*opts.ListOpts).GetAll()),
  763. }
  764. return nil
  765. }
  766. func updateHealthcheck(flags *pflag.FlagSet, containerSpec *swarm.ContainerSpec) error {
  767. if !anyChanged(flags, flagNoHealthcheck, flagHealthCmd, flagHealthInterval, flagHealthRetries, flagHealthTimeout, flagHealthStartPeriod) {
  768. return nil
  769. }
  770. if containerSpec.Healthcheck == nil {
  771. containerSpec.Healthcheck = &container.HealthConfig{}
  772. }
  773. noHealthcheck, err := flags.GetBool(flagNoHealthcheck)
  774. if err != nil {
  775. return err
  776. }
  777. if noHealthcheck {
  778. if !anyChanged(flags, flagHealthCmd, flagHealthInterval, flagHealthRetries, flagHealthTimeout, flagHealthStartPeriod) {
  779. containerSpec.Healthcheck = &container.HealthConfig{
  780. Test: []string{"NONE"},
  781. }
  782. return nil
  783. }
  784. return errors.Errorf("--%s conflicts with --health-* options", flagNoHealthcheck)
  785. }
  786. if len(containerSpec.Healthcheck.Test) > 0 && containerSpec.Healthcheck.Test[0] == "NONE" {
  787. containerSpec.Healthcheck.Test = nil
  788. }
  789. if flags.Changed(flagHealthInterval) {
  790. val := *flags.Lookup(flagHealthInterval).Value.(*PositiveDurationOpt).Value()
  791. containerSpec.Healthcheck.Interval = val
  792. }
  793. if flags.Changed(flagHealthTimeout) {
  794. val := *flags.Lookup(flagHealthTimeout).Value.(*PositiveDurationOpt).Value()
  795. containerSpec.Healthcheck.Timeout = val
  796. }
  797. if flags.Changed(flagHealthStartPeriod) {
  798. val := *flags.Lookup(flagHealthStartPeriod).Value.(*PositiveDurationOpt).Value()
  799. containerSpec.Healthcheck.StartPeriod = val
  800. }
  801. if flags.Changed(flagHealthRetries) {
  802. containerSpec.Healthcheck.Retries, _ = flags.GetInt(flagHealthRetries)
  803. }
  804. if flags.Changed(flagHealthCmd) {
  805. cmd, _ := flags.GetString(flagHealthCmd)
  806. if cmd != "" {
  807. containerSpec.Healthcheck.Test = []string{"CMD-SHELL", cmd}
  808. } else {
  809. containerSpec.Healthcheck.Test = nil
  810. }
  811. }
  812. return nil
  813. }