@@ -236,9 +236,12 @@ func addFlags(flags *pflag.FlagSet) *containerOptions {

 	flags.Int64Var(&copts.cpuPeriod, "cpu-period", 0, "Limit CPU CFS (Completely Fair Scheduler) period")

 	flags.Int64Var(&copts.cpuQuota, "cpu-quota", 0, "Limit CPU CFS (Completely Fair Scheduler) quota")

 	flags.Int64Var(&copts.cpuRealtimePeriod, "cpu-rt-period", 0, "Limit CPU real-time period in microseconds")

+	flags.SetAnnotation("cpu-rt-period", "version", []string{"1.25"})

 	flags.Int64Var(&copts.cpuRealtimeRuntime, "cpu-rt-runtime", 0, "Limit CPU real-time runtime in microseconds")

+	flags.SetAnnotation("cpu-rt-runtime", "version", []string{"1.25"})

 	flags.Int64VarP(&copts.cpuShares, "cpu-shares", "c", 0, "CPU shares (relative weight)")

 	flags.Var(&copts.cpus, "cpus", "Number of CPUs")

+	flags.SetAnnotation("cpus", "version", []string{"1.25"})

 	flags.Var(&copts.deviceReadBps, "device-read-bps", "Limit read rate (bytes per second) from a device")

 	flags.Var(&copts.deviceReadIOps, "device-read-iops", "Limit read rate (IO per second) from a device")

 	flags.Var(&copts.deviceWriteBps, "device-write-bps", "Limit write rate (bytes per second) to a device")

@@ -264,7 +267,9 @@ func addFlags(flags *pflag.FlagSet) *containerOptions {

 	flags.StringVar(&copts.runtime, "runtime", "", "Runtime to use for this container")

 	flags.BoolVar(&copts.init, "init", false, "Run an init inside the container that forwards signals and reaps processes")

+	flags.SetAnnotation("init", "version", []string{"1.25"})

 	flags.StringVar(&copts.initPath, "init-path", "", "Path to the docker-init binary")

+	flags.SetAnnotation("init-path", "version", []string{"1.25"})

 	return copts

 }

@@ -54,7 +54,9 @@ func NewUpdateCommand(dockerCli *command.DockerCli) *cobra.Command {

 	flags.Int64Var(&opts.cpuPeriod, "cpu-period", 0, "Limit CPU CFS (Completely Fair Scheduler) period")

 	flags.Int64Var(&opts.cpuQuota, "cpu-quota", 0, "Limit CPU CFS (Completely Fair Scheduler) quota")

 	flags.Int64Var(&opts.cpuRealtimePeriod, "cpu-rt-period", 0, "Limit the CPU real-time period in microseconds")

+	flags.SetAnnotation("cpu-rt-period", "version", []string{"1.25"})

 	flags.Int64Var(&opts.cpuRealtimeRuntime, "cpu-rt-runtime", 0, "Limit the CPU real-time runtime in microseconds")

+	flags.SetAnnotation("cpu-rt-runtime", "version", []string{"1.25"})

 	flags.StringVar(&opts.cpusetCpus, "cpuset-cpus", "", "CPUs in which to allow execution (0-3, 0,1)")

 	flags.StringVar(&opts.cpusetMems, "cpuset-mems", "", "MEMs in which to allow execution (0-3, 0,1)")

 	flags.Int64VarP(&opts.cpuShares, "cpu-shares", "c", 0, "CPU shares (relative weight)")

@@ -107,6 +107,7 @@ func NewBuildCommand(dockerCli *command.DockerCli) *cobra.Command {

 	flags.BoolVar(&options.compress, "compress", false, "Compress the build context using gzip")

 	flags.StringSliceVar(&options.securityOpt, "security-opt", []string{}, "Security options")

 	flags.StringVar(&options.networkMode, "network", "default", "Set the networking mode for the RUN instructions during build")

+	flags.SetAnnotation("network", "version", []string{"1.25"})

 	command.AddTrustedFlags(flags, true)

@@ -58,6 +58,7 @@ func newCreateCommand(dockerCli *command.DockerCli) *cobra.Command {

 	flags.BoolVar(&opts.internal, "internal", false, "Restrict external access to the network")

 	flags.BoolVar(&opts.ipv6, "ipv6", false, "Enable IPv6 networking")

 	flags.BoolVar(&opts.attachable, "attachable", false, "Enable manual container attachment")

+	flags.SetAnnotation("attachable", "version", []string{"1.25"})

 	flags.StringVar(&opts.ipamDriver, "ipam-driver", "default", "IP Address Management Driver")

 	flags.StringSliceVar(&opts.ipamSubnet, "subnet", []string{}, "Subnet in CIDR format that represents a network segment")

@@ -39,12 +39,18 @@ func newCreateCommand(dockerCli *command.DockerCli) *cobra.Command {

 	flags.Var(&opts.constraints, flagConstraint, "Placement constraints")

 	flags.Var(&opts.networks, flagNetwork, "Network attachments")

 	flags.Var(&opts.secrets, flagSecret, "Specify secrets to expose to the service")

+	flags.SetAnnotation(flagSecret, "version", []string{"1.25"})

 	flags.VarP(&opts.endpoint.publishPorts, flagPublish, "p", "Publish a port as a node port")

 	flags.Var(&opts.groups, flagGroup, "Set one or more supplementary user groups for the container")

+	flags.SetAnnotation(flagGroup, "version", []string{"1.25"})

 	flags.Var(&opts.dns, flagDNS, "Set custom DNS servers")

+	flags.SetAnnotation(flagDNS, "version", []string{"1.25"})

 	flags.Var(&opts.dnsOption, flagDNSOption, "Set DNS options")

+	flags.SetAnnotation(flagDNSOption, "version", []string{"1.25"})

 	flags.Var(&opts.dnsSearch, flagDNSSearch, "Set custom DNS search domains")

+	flags.SetAnnotation(flagDNSSearch, "version", []string{"1.25"})

 	flags.Var(&opts.hosts, flagHost, "Set one or more custom host-to-IP mappings (host:ip)")

+	flags.SetAnnotation(flagHost, "version", []string{"1.25"})

 	flags.SetInterspersed(false)

 	return cmd

@@ -445,6 +445,7 @@ func addServiceFlags(cmd *cobra.Command, opts *serviceOptions) {

 	flags.StringVarP(&opts.workdir, flagWorkdir, "w", "", "Working directory inside the container")

 	flags.StringVarP(&opts.user, flagUser, "u", "", "Username or UID (format: <name|uid>[:<group|gid>])")

 	flags.StringVar(&opts.hostname, flagHostname, "", "Container hostname")

+	flags.SetAnnotation(flagHostname, "version", []string{"1.25"})

 	flags.Var(&opts.resources.limitCPU, flagLimitCPU, "Limit CPUs")

 	flags.Var(&opts.resources.limitMemBytes, flagLimitMemory, "Limit Memory")

@@ -462,8 +463,10 @@ func addServiceFlags(cmd *cobra.Command, opts *serviceOptions) {

 	flags.Uint64Var(&opts.update.parallelism, flagUpdateParallelism, 1, "Maximum number of tasks updated simultaneously (0 to update all at once)")

 	flags.DurationVar(&opts.update.delay, flagUpdateDelay, time.Duration(0), "Delay between updates (ns|us|ms|s|m|h) (default 0s)")

 	flags.DurationVar(&opts.update.monitor, flagUpdateMonitor, time.Duration(0), "Duration after each task update to monitor for failure (ns|us|ms|s|m|h) (default 0s)")

+	flags.SetAnnotation(flagUpdateMonitor, "version", []string{"1.25"})

 	flags.StringVar(&opts.update.onFailure, flagUpdateFailureAction, "pause", "Action on update failure (pause|continue)")

 	flags.Var(&opts.update.maxFailureRatio, flagUpdateMaxFailureRatio, "Failure rate to tolerate during an update")

+	flags.SetAnnotation(flagUpdateMaxFailureRatio, "version", []string{"1.25"})

 	flags.StringVar(&opts.endpoint.mode, flagEndpointMode, "", "Endpoint mode (vip or dnsrr)")

@@ -473,12 +476,18 @@ func addServiceFlags(cmd *cobra.Command, opts *serviceOptions) {

 	flags.Var(&opts.logDriver.opts, flagLogOpt, "Logging driver options")

 	flags.StringVar(&opts.healthcheck.cmd, flagHealthCmd, "", "Command to run to check health")

+	flags.SetAnnotation(flagHealthCmd, "version", []string{"1.25"})

 	flags.Var(&opts.healthcheck.interval, flagHealthInterval, "Time between running the check (ns|us|ms|s|m|h)")

+	flags.SetAnnotation(flagHealthInterval, "version", []string{"1.25"})

 	flags.Var(&opts.healthcheck.timeout, flagHealthTimeout, "Maximum time to allow one check to run (ns|us|ms|s|m|h)")

+	flags.SetAnnotation(flagHealthTimeout, "version", []string{"1.25"})

 	flags.IntVar(&opts.healthcheck.retries, flagHealthRetries, 0, "Consecutive failures needed to report unhealthy")

+	flags.SetAnnotation(flagHealthRetries, "version", []string{"1.25"})

 	flags.BoolVar(&opts.healthcheck.noHealthcheck, flagNoHealthcheck, false, "Disable any container-specified HEALTHCHECK")

+	flags.SetAnnotation(flagNoHealthcheck, "version", []string{"1.25"})

 	flags.BoolVarP(&opts.tty, flagTTY, "t", false, "Allocate a pseudo-TTY")

+	flags.SetAnnotation(flagTTY, "version", []string{"1.25"})

 }

 const (

@@ -38,11 +38,14 @@ func newUpdateCommand(dockerCli *command.DockerCli) *cobra.Command {

 	flags.String("image", "", "Service image tag")

 	flags.String("args", "", "Service command args")

 	flags.Bool("rollback", false, "Rollback to previous specification")

+	flags.SetAnnotation("rollback", "version", []string{"1.25"})

 	flags.Bool("force", false, "Force update even if no changes require it")

+	flags.SetAnnotation("force", "version", []string{"1.25"})

 	addServiceFlags(cmd, serviceOpts)

 	flags.Var(newListOptsVar(), flagEnvRemove, "Remove an environment variable")

 	flags.Var(newListOptsVar(), flagGroupRemove, "Remove a previously added supplementary user group from the container")

+	flags.SetAnnotation(flagGroupRemove, "version", []string{"1.25"})

 	flags.Var(newListOptsVar(), flagLabelRemove, "Remove a label by its key")

 	flags.Var(newListOptsVar(), flagContainerLabelRemove, "Remove a container label by its key")

 	flags.Var(newListOptsVar(), flagMountRemove, "Remove a mount by its target path")

@@ -50,22 +53,33 @@ func newUpdateCommand(dockerCli *command.DockerCli) *cobra.Command {

 	flags.Var(&opts.PortOpt{}, flagPublishRemove, "Remove a published port by its target port")

 	flags.Var(newListOptsVar(), flagConstraintRemove, "Remove a constraint")

 	flags.Var(newListOptsVar(), flagDNSRemove, "Remove a custom DNS server")

+	flags.SetAnnotation(flagDNSRemove, "version", []string{"1.25"})

 	flags.Var(newListOptsVar(), flagDNSOptionRemove, "Remove a DNS option")

+	flags.SetAnnotation(flagDNSOptionRemove, "version", []string{"1.25"})

 	flags.Var(newListOptsVar(), flagDNSSearchRemove, "Remove a DNS search domain")

+	flags.SetAnnotation(flagDNSSearchRemove, "version", []string{"1.25"})

 	flags.Var(newListOptsVar(), flagHostRemove, "Remove a custom host-to-IP mapping (host:ip)")

+	flags.SetAnnotation(flagHostRemove, "version", []string{"1.25"})

 	flags.Var(&serviceOpts.labels, flagLabelAdd, "Add or update a service label")

 	flags.Var(&serviceOpts.containerLabels, flagContainerLabelAdd, "Add or update a container label")

 	flags.Var(&serviceOpts.env, flagEnvAdd, "Add or update an environment variable")

 	flags.Var(newListOptsVar(), flagSecretRemove, "Remove a secret")

+	flags.SetAnnotation(flagSecretRemove, "version", []string{"1.25"})

 	flags.Var(&serviceOpts.secrets, flagSecretAdd, "Add or update a secret on a service")

+	flags.SetAnnotation(flagSecretAdd, "version", []string{"1.25"})

 	flags.Var(&serviceOpts.mounts, flagMountAdd, "Add or update a mount on a service")

 	flags.Var(&serviceOpts.constraints, flagConstraintAdd, "Add or update a placement constraint")

 	flags.Var(&serviceOpts.endpoint.publishPorts, flagPublishAdd, "Add or update a published port")

 	flags.Var(&serviceOpts.groups, flagGroupAdd, "Add an additional supplementary user group to the container")

+	flags.SetAnnotation(flagGroupAdd, "version", []string{"1.25"})

 	flags.Var(&serviceOpts.dns, flagDNSAdd, "Add or update a custom DNS server")

+	flags.SetAnnotation(flagDNSAdd, "version", []string{"1.25"})

 	flags.Var(&serviceOpts.dnsOption, flagDNSOptionAdd, "Add or update a DNS option")

+	flags.SetAnnotation(flagDNSOptionAdd, "version", []string{"1.25"})

 	flags.Var(&serviceOpts.dnsSearch, flagDNSSearchAdd, "Add or update a custom DNS search domain")

+	flags.SetAnnotation(flagDNSSearchAdd, "version", []string{"1.25"})

 	flags.Var(&serviceOpts.hosts, flagHostAdd, "Add or update a custom host-to-IP mapping (host:ip)")

+	flags.SetAnnotation(flagHostAdd, "version", []string{"1.25"})

 	return cmd

 }

@@ -11,6 +11,7 @@ import (

 func addComposefileFlag(opt *string, flags *pflag.FlagSet) {

 	flags.StringVarP(opt, "compose-file", "c", "", "Path to a Compose file")

+	flags.SetAnnotation("compose-file", "version", []string{"1.25"})

 }

 func addBundlefileFlag(opt *string, flags *pflag.FlagSet) {

@@ -176,7 +176,9 @@ func addSwarmFlags(flags *pflag.FlagSet, opts *swarmOptions) {

 	flags.DurationVar(&opts.nodeCertExpiry, flagCertExpiry, time.Duration(90*24*time.Hour), "Validity period for node certificates (ns|us|ms|s|m|h)")

 	flags.Var(&opts.externalCA, flagExternalCA, "Specifications of one or more certificate signing endpoints")

 	flags.Uint64Var(&opts.maxSnapshots, flagMaxSnapshots, 0, "Number of additional Raft snapshots to retain")

+	flags.SetAnnotation(flagMaxSnapshots, "version", []string{"1.25"})

 	flags.Uint64Var(&opts.snapshotInterval, flagSnapshotInterval, 10000, "Number of log entries between Raft snapshots")

+	flags.SetAnnotation(flagSnapshotInterval, "version", []string{"1.25"})

 }

 func (opts *swarmOptions) mergeSwarmSpec(spec *swarm.Spec, flags *pflag.FlagSet) {