Merge pull request #23281 from yongtang/23211-spf13-cobra-update

Use spf13/cobra for docker update

api/client/commands.go

@@ -5,6 +5,5 @@ func (cli *DockerCli) Command(name string) func(...string) error {
 	return map[string]func(...string) error{
 		"exec":    cli.CmdExec,
 		"inspect": cli.CmdInspect,
-		"update":  cli.CmdUpdate,
 	}[name]
 }

api/client/container/update.go

@@ -0,0 +1,150 @@
+package container
+
+import (
+	"fmt"
+	"strings"
+
+	"golang.org/x/net/context"
+
+	"github.com/docker/docker/api/client"
+	"github.com/docker/docker/cli"
+	runconfigopts "github.com/docker/docker/runconfig/opts"
+	containertypes "github.com/docker/engine-api/types/container"
+	"github.com/docker/go-units"
+	"github.com/spf13/cobra"
+)
+
+type updateOptions struct {
+	blkioWeight       uint16
+	cpuPeriod         int64
+	cpuQuota          int64
+	cpusetCpus        string
+	cpusetMems        string
+	cpuShares         int64
+	memoryString      string
+	memoryReservation string
+	memorySwap        string
+	kernelMemory      string
+	restartPolicy     string
+
+	nFlag int
+
+	containers []string
+}
+
+// NewUpdateCommand creats a new cobra.Command for `docker update`
+func NewUpdateCommand(dockerCli *client.DockerCli) *cobra.Command {
+	var opts updateOptions
+
+	cmd := &cobra.Command{
+		Use:   "update [OPTIONS] CONTAINER [CONTAINER...]",
+		Short: "Update configuration of one or more containers",
+		Args:  cli.RequiresMinArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			opts.containers = args
+			opts.nFlag = cmd.Flags().NFlag()
+			return runUpdate(dockerCli, &opts)
+		},
+	}
+	cmd.SetFlagErrorFunc(flagErrorFunc)
+
+	flags := cmd.Flags()
+	flags.Uint16Var(&opts.blkioWeight, "blkio-weight", 0, "Block IO (relative weight), between 10 and 1000")
+	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.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)")
+	flags.StringVarP(&opts.memoryString, "memory", "m", "", "Memory limit")
+	flags.StringVar(&opts.memoryReservation, "memory-reservation", "", "Memory soft limit")
+	flags.StringVar(&opts.memorySwap, "memory-swap", "", "Swap limit equal to memory plus swap: '-1' to enable unlimited swap")
+	flags.StringVar(&opts.kernelMemory, "kernel-memory", "", "Kernel memory limit")
+	flags.StringVar(&opts.restartPolicy, "restart", "", "Restart policy to apply when a container exits")
+
+	return cmd
+}
+
+func runUpdate(dockerCli *client.DockerCli, opts *updateOptions) error {
+	var err error
+
+	if opts.nFlag == 0 {
+		return fmt.Errorf("You must provide one or more flags when using this command.")
+	}
+
+	var memory int64
+	if opts.memoryString != "" {
+		memory, err = units.RAMInBytes(opts.memoryString)
+		if err != nil {
+			return err
+		}
+	}
+
+	var memoryReservation int64
+	if opts.memoryReservation != "" {
+		memoryReservation, err = units.RAMInBytes(opts.memoryReservation)
+		if err != nil {
+			return err
+		}
+	}
+
+	var memorySwap int64
+	if opts.memorySwap != "" {
+		if opts.memorySwap == "-1" {
+			memorySwap = -1
+		} else {
+			memorySwap, err = units.RAMInBytes(opts.memorySwap)
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	var kernelMemory int64
+	if opts.kernelMemory != "" {
+		kernelMemory, err = units.RAMInBytes(opts.kernelMemory)
+		if err != nil {
+			return err
+		}
+	}
+
+	var restartPolicy containertypes.RestartPolicy
+	if opts.restartPolicy != "" {
+		restartPolicy, err = runconfigopts.ParseRestartPolicy(opts.restartPolicy)
+		if err != nil {
+			return err
+		}
+	}
+
+	resources := containertypes.Resources{
+		BlkioWeight:       opts.blkioWeight,
+		CpusetCpus:        opts.cpusetCpus,
+		CpusetMems:        opts.cpusetMems,
+		CPUShares:         opts.cpuShares,
+		Memory:            memory,
+		MemoryReservation: memoryReservation,
+		MemorySwap:        memorySwap,
+		KernelMemory:      kernelMemory,
+		CPUPeriod:         opts.cpuPeriod,
+		CPUQuota:          opts.cpuQuota,
+	}
+
+	updateConfig := containertypes.UpdateConfig{
+		Resources:     resources,
+		RestartPolicy: restartPolicy,
+	}
+
+	ctx := context.Background()
+
+	var errs []string
+	for _, container := range opts.containers {
+		if err := dockerCli.Client().ContainerUpdate(ctx, container, updateConfig); err != nil {
+			errs = append(errs, err.Error())
+		} else {
+			fmt.Fprintf(dockerCli.Out(), "%s\n", container)
+		}
+	}
+	if len(errs) > 0 {
+		return fmt.Errorf("%s", strings.Join(errs, "\n"))
+	}
+	return nil
+}

api/client/update.go

@@ -1,120 +0,0 @@
-package client
-
-import (
-	"fmt"
-	"strings"
-
-	"golang.org/x/net/context"
-
-	Cli "github.com/docker/docker/cli"
-	flag "github.com/docker/docker/pkg/mflag"
-	"github.com/docker/docker/runconfig/opts"
-	"github.com/docker/engine-api/types/container"
-	"github.com/docker/go-units"
-)
-
-// CmdUpdate updates resources of one or more containers.
-//
-// Usage: docker update [OPTIONS] CONTAINER [CONTAINER...]
-func (cli *DockerCli) CmdUpdate(args ...string) error {
-	cmd := Cli.Subcmd("update", []string{"CONTAINER [CONTAINER...]"}, Cli.DockerCommands["update"].Description, true)
-	flBlkioWeight := cmd.Uint16([]string{"-blkio-weight"}, 0, "Block IO (relative weight), between 10 and 1000")
-	flCPUPeriod := cmd.Int64([]string{"-cpu-period"}, 0, "Limit CPU CFS (Completely Fair Scheduler) period")
-	flCPUQuota := cmd.Int64([]string{"-cpu-quota"}, 0, "Limit CPU CFS (Completely Fair Scheduler) quota")
-	flCpusetCpus := cmd.String([]string{"-cpuset-cpus"}, "", "CPUs in which to allow execution (0-3, 0,1)")
-	flCpusetMems := cmd.String([]string{"-cpuset-mems"}, "", "MEMs in which to allow execution (0-3, 0,1)")
-	flCPUShares := cmd.Int64([]string{"c", "-cpu-shares"}, 0, "CPU shares (relative weight)")
-	flMemoryString := cmd.String([]string{"m", "-memory"}, "", "Memory limit")
-	flMemoryReservation := cmd.String([]string{"-memory-reservation"}, "", "Memory soft limit")
-	flMemorySwap := cmd.String([]string{"-memory-swap"}, "", "Swap limit equal to memory plus swap: '-1' to enable unlimited swap")
-	flKernelMemory := cmd.String([]string{"-kernel-memory"}, "", "Kernel memory limit")
-	flRestartPolicy := cmd.String([]string{"-restart"}, "", "Restart policy to apply when a container exits")
-
-	cmd.Require(flag.Min, 1)
-	cmd.ParseFlags(args, true)
-	if cmd.NFlag() == 0 {
-		return fmt.Errorf("You must provide one or more flags when using this command.")
-	}
-
-	var err error
-	var flMemory int64
-	if *flMemoryString != "" {
-		flMemory, err = units.RAMInBytes(*flMemoryString)
-		if err != nil {
-			return err
-		}
-	}
-
-	var memoryReservation int64
-	if *flMemoryReservation != "" {
-		memoryReservation, err = units.RAMInBytes(*flMemoryReservation)
-		if err != nil {
-			return err
-		}
-	}
-
-	var memorySwap int64
-	if *flMemorySwap != "" {
-		if *flMemorySwap == "-1" {
-			memorySwap = -1
-		} else {
-			memorySwap, err = units.RAMInBytes(*flMemorySwap)
-			if err != nil {
-				return err
-			}
-		}
-	}
-
-	var kernelMemory int64
-	if *flKernelMemory != "" {
-		kernelMemory, err = units.RAMInBytes(*flKernelMemory)
-		if err != nil {
-			return err
-		}
-	}
-
-	var restartPolicy container.RestartPolicy
-	if *flRestartPolicy != "" {
-		restartPolicy, err = opts.ParseRestartPolicy(*flRestartPolicy)
-		if err != nil {
-			return err
-		}
-	}
-
-	resources := container.Resources{
-		BlkioWeight:       *flBlkioWeight,
-		CpusetCpus:        *flCpusetCpus,
-		CpusetMems:        *flCpusetMems,
-		CPUShares:         *flCPUShares,
-		Memory:            flMemory,
-		MemoryReservation: memoryReservation,
-		MemorySwap:        memorySwap,
-		KernelMemory:      kernelMemory,
-		CPUPeriod:         *flCPUPeriod,
-		CPUQuota:          *flCPUQuota,
-	}
-
-	updateConfig := container.UpdateConfig{
-		Resources:     resources,
-		RestartPolicy: restartPolicy,
-	}
-
-	ctx := context.Background()
-
-	names := cmd.Args()
-	var errs []string
-
-	for _, name := range names {
-		if err := cli.client.ContainerUpdate(ctx, name, updateConfig); err != nil {
-			errs = append(errs, err.Error())
-		} else {
-			fmt.Fprintf(cli.out, "%s\n", name)
-		}
-	}
-
-	if len(errs) > 0 {
-		return fmt.Errorf("%s", strings.Join(errs, "\n"))
-	}
-
-	return nil
-}

cli/cobraadaptor/adaptor.go

@@ -66,6 +66,7 @@ func NewCobraAdaptor(clientFlags *cliflags.ClientFlags) CobraAdaptor {
 		container.NewStopCommand(dockerCli),
 		container.NewTopCommand(dockerCli),
 		container.NewUnpauseCommand(dockerCli),
+		container.NewUpdateCommand(dockerCli),
 		container.NewWaitCommand(dockerCli),
 		image.NewBuildCommand(dockerCli),
 		image.NewHistoryCommand(dockerCli),

cli/usage.go

@@ -10,7 +10,6 @@ type Command struct {
 var DockerCommandUsage = []Command{
 	{"exec", "Run a command in a running container"},
 	{"inspect", "Return low-level information on a container, image or task"},
-	{"update", "Update configuration of one or more containers"},
 }
 
 // DockerCommands stores all the docker command