@@ -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]

 }

new file mode 100644

@@ -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

+}

deleted file mode 100644

@@ -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

-}

@@ -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),

@@ -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