148 lines
5.1 KiB
Go
148 lines
5.1 KiB
Go
package container
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
|
|
"github.com/docker/cli/cli"
|
|
"github.com/docker/cli/cli/command"
|
|
"github.com/docker/cli/cli/command/completion"
|
|
"github.com/docker/cli/opts"
|
|
containertypes "github.com/moby/moby/api/types/container"
|
|
"github.com/moby/moby/client"
|
|
"github.com/spf13/cobra"
|
|
)
|
|
|
|
type updateOptions struct {
|
|
blkioWeight uint16
|
|
cpuPeriod int64
|
|
cpuQuota int64
|
|
cpuRealtimePeriod int64
|
|
cpuRealtimeRuntime int64
|
|
cpusetCpus string
|
|
cpusetMems string
|
|
cpuShares int64
|
|
memory opts.MemBytes
|
|
memoryReservation opts.MemBytes
|
|
memorySwap opts.MemSwapBytes
|
|
restartPolicy string
|
|
pidsLimit int64
|
|
cpus opts.NanoCPUs
|
|
|
|
nFlag int
|
|
|
|
containers []string
|
|
}
|
|
|
|
// newUpdateCommand creates a new cobra.Command for "docker container update".
|
|
func newUpdateCommand(dockerCLI command.Cli) *cobra.Command {
|
|
var options 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 {
|
|
options.containers = args
|
|
options.nFlag = cmd.Flags().NFlag()
|
|
return runUpdate(cmd.Context(), dockerCLI, &options)
|
|
},
|
|
Annotations: map[string]string{
|
|
"aliases": "docker container update, docker update",
|
|
},
|
|
ValidArgsFunction: completion.ContainerNames(dockerCLI, true),
|
|
DisableFlagsInUseLine: true,
|
|
}
|
|
|
|
flags := cmd.Flags()
|
|
flags.Uint16Var(&options.blkioWeight, "blkio-weight", 0, `Block IO (relative weight), between 10 and 1000, or 0 to disable (default 0)`)
|
|
flags.Int64Var(&options.cpuPeriod, "cpu-period", 0, "Limit CPU CFS (Completely Fair Scheduler) period")
|
|
flags.Int64Var(&options.cpuQuota, "cpu-quota", 0, "Limit CPU CFS (Completely Fair Scheduler) quota")
|
|
flags.Int64Var(&options.cpuRealtimePeriod, "cpu-rt-period", 0, "Limit the CPU real-time period in microseconds")
|
|
_ = flags.SetAnnotation("cpu-rt-period", "version", []string{"1.25"})
|
|
flags.Int64Var(&options.cpuRealtimeRuntime, "cpu-rt-runtime", 0, "Limit the CPU real-time runtime in microseconds")
|
|
_ = flags.SetAnnotation("cpu-rt-runtime", "version", []string{"1.25"})
|
|
flags.StringVar(&options.cpusetCpus, "cpuset-cpus", "", "CPUs in which to allow execution (0-3, 0,1)")
|
|
flags.StringVar(&options.cpusetMems, "cpuset-mems", "", "MEMs in which to allow execution (0-3, 0,1)")
|
|
flags.Int64VarP(&options.cpuShares, "cpu-shares", "c", 0, "CPU shares (relative weight)")
|
|
flags.VarP(&options.memory, "memory", "m", "Memory limit")
|
|
flags.Var(&options.memoryReservation, "memory-reservation", "Memory soft limit")
|
|
flags.Var(&options.memorySwap, "memory-swap", `Swap limit equal to memory plus swap: -1 to enable unlimited swap`)
|
|
|
|
flags.StringVar(&options.restartPolicy, "restart", "", "Restart policy to apply when a container exits")
|
|
flags.Int64Var(&options.pidsLimit, "pids-limit", 0, `Tune container pids limit (set -1 for unlimited)`)
|
|
_ = flags.SetAnnotation("pids-limit", "version", []string{"1.40"})
|
|
|
|
flags.Var(&options.cpus, "cpus", "Number of CPUs")
|
|
_ = flags.SetAnnotation("cpus", "version", []string{"1.29"})
|
|
|
|
_ = cmd.RegisterFlagCompletionFunc("restart", completeRestartPolicies)
|
|
|
|
// TODO(thaJeztah): remove in next release (v30.0, or v29.x)
|
|
var stub opts.MemBytes
|
|
flags.Var(&stub, "kernel-memory", "Kernel memory limit (deprecated)")
|
|
_ = flags.MarkDeprecated("kernel-memory", "and no longer supported by the kernel")
|
|
|
|
return cmd
|
|
}
|
|
|
|
func runUpdate(ctx context.Context, dockerCli command.Cli, options *updateOptions) error {
|
|
var err error
|
|
|
|
if options.nFlag == 0 {
|
|
return errors.New("you must provide one or more flags when using this command")
|
|
}
|
|
|
|
var restartPolicy containertypes.RestartPolicy
|
|
if options.restartPolicy != "" {
|
|
restartPolicy, err = opts.ParseRestartPolicy(options.restartPolicy)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
var pidsLimit *int64
|
|
if options.pidsLimit != 0 {
|
|
pidsLimit = &options.pidsLimit
|
|
}
|
|
|
|
updateConfig := client.ContainerUpdateOptions{
|
|
Resources: &containertypes.Resources{
|
|
BlkioWeight: options.blkioWeight,
|
|
CpusetCpus: options.cpusetCpus,
|
|
CpusetMems: options.cpusetMems,
|
|
CPUShares: options.cpuShares,
|
|
Memory: options.memory.Value(),
|
|
MemoryReservation: options.memoryReservation.Value(),
|
|
MemorySwap: options.memorySwap.Value(),
|
|
CPUPeriod: options.cpuPeriod,
|
|
CPUQuota: options.cpuQuota,
|
|
CPURealtimePeriod: options.cpuRealtimePeriod,
|
|
CPURealtimeRuntime: options.cpuRealtimeRuntime,
|
|
NanoCPUs: options.cpus.Value(),
|
|
PidsLimit: pidsLimit,
|
|
},
|
|
RestartPolicy: &restartPolicy,
|
|
}
|
|
|
|
var (
|
|
warns []string
|
|
errs []error
|
|
)
|
|
for _, ctr := range options.containers {
|
|
r, err := dockerCli.Client().ContainerUpdate(ctx, ctr, updateConfig)
|
|
if err != nil {
|
|
errs = append(errs, err)
|
|
} else {
|
|
_, _ = fmt.Fprintln(dockerCli.Out(), ctr)
|
|
}
|
|
warns = append(warns, r.Warnings...)
|
|
}
|
|
if len(warns) > 0 {
|
|
_, _ = fmt.Fprintln(dockerCli.Out(), strings.Join(warns, "\n"))
|
|
}
|
|
return errors.Join(errs...)
|
|
}
|