Esempio n. 1
0
// AddServiceFlags add all supported service flags to the flagset.
func AddServiceFlags(flags *pflag.FlagSet) {
	flags.String("name", "", "service name")
	flags.StringSlice("label", nil, "service label (key=value)")

	flags.Uint64("replicas", 1, "number of replicas for the service (only works in replicated service mode)")

	flags.String("image", "", "container image")
	flags.StringSlice("args", nil, "container args")
	flags.StringSlice("env", nil, "container env")

	flags.StringSlice("ports", nil, "ports")
	flags.String("network", "", "network name")

	flags.String("memory-reservation", "", "amount of reserved memory (e.g. 512m)")
	flags.String("memory-limit", "", "memory limit (e.g. 512m)")
	flags.String("cpu-reservation", "", "number of CPU cores reserved (e.g. 0.5)")
	flags.String("cpu-limit", "", "CPU cores limit (e.g. 0.5)")

	flags.Uint64("update-parallelism", 0, "task update parallelism (0 = all at once)")
	flags.String("update-delay", "0s", "delay between task updates (0s = none)")

	flags.String("restart-condition", "any", "condition to restart the task (any, failure, none)")
	flags.String("restart-delay", "5s", "delay between task restarts")
	flags.Uint64("restart-max-attempts", 0, "maximum number of restart attempts (0 = unlimited)")
	flags.String("restart-window", "0s", "time window to evaluate restart attempts (0 = unbound)")

	flags.StringSlice("constraint", nil, "Placement constraint (node.labels.key==value)")

	// TODO(stevvooe): Replace these with a more interesting mount flag.
	flags.StringSlice("bind", nil, "define a bind mount")
	flags.StringSlice("volume", nil, "define a volume mount")
}
Esempio n. 2
0
// AddServiceFlags add all supported service flags to the flagset.
func AddServiceFlags(flags *pflag.FlagSet) {
	flags.String("name", "", "service name")
	flags.StringSlice("label", nil, "service label (key=value)")

	flags.Uint64("replicas", 1, "number of replicas for the service (only works in replicated service mode)")

	flags.String("image", "", "container image")
	flags.String("hostname", "", "container hostname")
	flags.StringSlice("command", nil, "override entrypoint")
	flags.StringSlice("args", nil, "container args")
	flags.StringSlice("env", nil, "container env")
	flags.Bool("tty", false, "open a tty on standard streams")
	flags.Bool("open-stdin", false, "open standard input")

	flags.StringSlice("ports", nil, "ports")
	flags.String("network", "", "network name")

	flags.String("memory-reservation", "", "amount of reserved memory (e.g. 512m)")
	flags.String("memory-limit", "", "memory limit (e.g. 512m)")
	flags.String("cpu-reservation", "", "number of CPU cores reserved (e.g. 0.5)")
	flags.String("cpu-limit", "", "CPU cores limit (e.g. 0.5)")

	flags.Uint64("update-parallelism", 0, "task update parallelism (0 = all at once)")
	flags.String("update-delay", "0s", "delay between task updates (0s = none)")
	flags.String("update-on-failure", "pause", "action on failure during update (pause|continue)")

	flags.String("restart-condition", "any", "condition to restart the task (any, failure, none)")
	flags.String("restart-delay", "5s", "delay between task restarts")
	flags.Uint64("restart-max-attempts", 0, "maximum number of restart attempts (0 = unlimited)")
	flags.String("restart-window", "0s", "time window to evaluate restart attempts (0 = unbound)")

	flags.StringSlice("constraint", nil, "Placement constraint (e.g. node.labels.key==value)")

	// TODO(stevvooe): Replace these with a more interesting mount flag.
	flags.StringSlice("bind", nil, "define a bind mount")
	flags.StringSlice("volume", nil, "define a volume mount")
	flags.StringSlice("tmpfs", nil, "define a tmpfs mount")

	flags.String("log-driver", "", "specify a log driver")
	flags.StringSlice("log-opt", nil, "log driver options, as key value pairs")
}
Esempio n. 3
0
// AddFlags adds all command line flags that will be used by Parse to the FlagSet
func AddFlags(flags *pflag.FlagSet) *ContainerOptions {
	copts := &ContainerOptions{
		flAttach:            opts.NewListOpts(ValidateAttach),
		flVolumes:           opts.NewListOpts(nil),
		flTmpfs:             opts.NewListOpts(nil),
		flBlkioWeightDevice: NewWeightdeviceOpt(ValidateWeightDevice),
		flDeviceReadBps:     NewThrottledeviceOpt(ValidateThrottleBpsDevice),
		flDeviceWriteBps:    NewThrottledeviceOpt(ValidateThrottleBpsDevice),
		flLinks:             opts.NewListOpts(ValidateLink),
		flAliases:           opts.NewListOpts(nil),
		flDeviceReadIOps:    NewThrottledeviceOpt(ValidateThrottleIOpsDevice),
		flDeviceWriteIOps:   NewThrottledeviceOpt(ValidateThrottleIOpsDevice),
		flEnv:               opts.NewListOpts(ValidateEnv),
		flLabels:            opts.NewListOpts(ValidateEnv),
		flDevices:           opts.NewListOpts(ValidateDevice),

		flUlimits: NewUlimitOpt(nil),
		flSysctls: opts.NewMapOpts(nil, opts.ValidateSysctl),

		flPublish:     opts.NewListOpts(nil),
		flExpose:      opts.NewListOpts(nil),
		flDNS:         opts.NewListOpts(opts.ValidateIPAddress),
		flDNSSearch:   opts.NewListOpts(opts.ValidateDNSSearch),
		flDNSOptions:  opts.NewListOpts(nil),
		flExtraHosts:  opts.NewListOpts(ValidateExtraHost),
		flVolumesFrom: opts.NewListOpts(nil),
		flEnvFile:     opts.NewListOpts(nil),
		flCapAdd:      opts.NewListOpts(nil),
		flCapDrop:     opts.NewListOpts(nil),
		flGroupAdd:    opts.NewListOpts(nil),
		flSecurityOpt: opts.NewListOpts(nil),
		flStorageOpt:  opts.NewListOpts(nil),
		flLabelsFile:  opts.NewListOpts(nil),
		flLoggingOpts: opts.NewListOpts(nil),

		flPrivileged:        flags.Bool("privileged", false, "Give extended privileges to this container"),
		flPidMode:           flags.String("pid", "", "PID namespace to use"),
		flUTSMode:           flags.String("uts", "", "UTS namespace to use"),
		flUsernsMode:        flags.String("userns", "", "User namespace to use"),
		flPublishAll:        flags.BoolP("publish-all", "P", false, "Publish all exposed ports to random ports"),
		flStdin:             flags.BoolP("interactive", "i", false, "Keep STDIN open even if not attached"),
		flTty:               flags.BoolP("tty", "t", false, "Allocate a pseudo-TTY"),
		flOomKillDisable:    flags.Bool("oom-kill-disable", false, "Disable OOM Killer"),
		flOomScoreAdj:       flags.Int("oom-score-adj", 0, "Tune host's OOM preferences (-1000 to 1000)"),
		flContainerIDFile:   flags.String("cidfile", "", "Write the container ID to the file"),
		flEntrypoint:        flags.String("entrypoint", "", "Overwrite the default ENTRYPOINT of the image"),
		flHostname:          flags.StringP("hostname", "h", "", "Container host name"),
		flMemoryString:      flags.StringP("memory", "m", "", "Memory limit"),
		flMemoryReservation: flags.String("memory-reservation", "", "Memory soft limit"),
		flMemorySwap:        flags.String("memory-swap", "", "Swap limit equal to memory plus swap: '-1' to enable unlimited swap"),
		flKernelMemory:      flags.String("kernel-memory", "", "Kernel memory limit"),
		flUser:              flags.StringP("user", "u", "", "Username or UID (format: <name|uid>[:<group|gid>])"),
		flWorkingDir:        flags.StringP("workdir", "w", "", "Working directory inside the container"),
		flCPUShares:         flags.Int64P("cpu-shares", "c", 0, "CPU shares (relative weight)"),
		flCPUPercent:        flags.Int64("cpu-percent", 0, "CPU percent (Windows only)"),
		flCPUPeriod:         flags.Int64("cpu-period", 0, "Limit CPU CFS (Completely Fair Scheduler) period"),
		flCPUQuota:          flags.Int64("cpu-quota", 0, "Limit CPU CFS (Completely Fair Scheduler) quota"),
		flCpusetCpus:        flags.String("cpuset-cpus", "", "CPUs in which to allow execution (0-3, 0,1)"),
		flCpusetMems:        flags.String("cpuset-mems", "", "MEMs in which to allow execution (0-3, 0,1)"),
		flBlkioWeight:       flags.Uint16("blkio-weight", 0, "Block IO (relative weight), between 10 and 1000"),
		flIOMaxBandwidth:    flags.String("io-maxbandwidth", "", "Maximum IO bandwidth limit for the system drive (Windows only)"),
		flIOMaxIOps:         flags.Uint64("io-maxiops", 0, "Maximum IOps limit for the system drive (Windows only)"),
		flSwappiness:        flags.Int64("memory-swappiness", -1, "Tune container memory swappiness (0 to 100)"),
		flNetMode:           flags.String("net", "default", "Connect a container to a network"),
		flMacAddress:        flags.String("mac-address", "", "Container MAC address (e.g. 92:d0:c6:0a:29:33)"),
		flIPv4Address:       flags.String("ip", "", "Container IPv4 address (e.g. 172.30.100.104)"),
		flIPv6Address:       flags.String("ip6", "", "Container IPv6 address (e.g. 2001:db8::33)"),
		flIpcMode:           flags.String("ipc", "", "IPC namespace to use"),
		flPidsLimit:         flags.Int64("pids-limit", 0, "Tune container pids limit (set -1 for unlimited)"),
		flRestartPolicy:     flags.String("restart", "no", "Restart policy to apply when a container exits"),
		flReadonlyRootfs:    flags.Bool("read-only", false, "Mount the container's root filesystem as read only"),
		flLoggingDriver:     flags.String("log-driver", "", "Logging driver for container"),
		flCgroupParent:      flags.String("cgroup-parent", "", "Optional parent cgroup for the container"),
		flVolumeDriver:      flags.String("volume-driver", "", "Optional volume driver for the container"),
		flStopSignal:        flags.String("stop-signal", signal.DefaultStopSignal, fmt.Sprintf("Signal to stop a container, %v by default", signal.DefaultStopSignal)),
		flIsolation:         flags.String("isolation", "", "Container isolation technology"),
		flShmSize:           flags.String("shm-size", "", "Size of /dev/shm, default value is 64MB"),
		flNoHealthcheck:     flags.Bool("no-healthcheck", false, "Disable any container-specified HEALTHCHECK"),
		flHealthCmd:         flags.String("health-cmd", "", "Command to run to check health"),
		flHealthInterval:    flags.Duration("health-interval", 0, "Time between running the check"),
		flHealthTimeout:     flags.Duration("health-timeout", 0, "Maximum time to allow one check to run"),
		flHealthRetries:     flags.Int("health-retries", 0, "Consecutive failures needed to report unhealthy"),
		flRuntime:           flags.String("runtime", "", "Runtime to use for this container"),
	}

	flags.VarP(&copts.flAttach, "attach", "a", "Attach to STDIN, STDOUT or STDERR")
	flags.Var(&copts.flBlkioWeightDevice, "blkio-weight-device", "Block IO weight (relative device weight)")
	flags.Var(&copts.flDeviceReadBps, "device-read-bps", "Limit read rate (bytes per second) from a device")
	flags.Var(&copts.flDeviceWriteBps, "device-write-bps", "Limit write rate (bytes per second) to a device")
	flags.Var(&copts.flDeviceReadIOps, "device-read-iops", "Limit read rate (IO per second) from a device")
	flags.Var(&copts.flDeviceWriteIOps, "device-write-iops", "Limit write rate (IO per second) to a device")
	flags.VarP(&copts.flVolumes, "volume", "v", "Bind mount a volume")
	flags.Var(&copts.flTmpfs, "tmpfs", "Mount a tmpfs directory")
	flags.Var(&copts.flLinks, "link", "Add link to another container")
	flags.Var(&copts.flAliases, "net-alias", "Add network-scoped alias for the container")
	flags.Var(&copts.flDevices, "device", "Add a host device to the container")
	flags.VarP(&copts.flLabels, "label", "l", "Set meta data on a container")
	flags.Var(&copts.flLabelsFile, "label-file", "Read in a line delimited file of labels")
	flags.VarP(&copts.flEnv, "env", "e", "Set environment variables")
	flags.Var(&copts.flEnvFile, "env-file", "Read in a file of environment variables")
	flags.VarP(&copts.flPublish, "publish", "p", "Publish a container's port(s) to the host")
	flags.Var(&copts.flExpose, "expose", "Expose a port or a range of ports")
	flags.Var(&copts.flDNS, "dns", "Set custom DNS servers")
	flags.Var(&copts.flDNSSearch, "dns-search", "Set custom DNS search domains")
	flags.Var(&copts.flDNSOptions, "dns-opt", "Set DNS options")
	flags.Var(&copts.flExtraHosts, "add-host", "Add a custom host-to-IP mapping (host:ip)")
	flags.Var(&copts.flVolumesFrom, "volumes-from", "Mount volumes from the specified container(s)")
	flags.Var(&copts.flCapAdd, "cap-add", "Add Linux capabilities")
	flags.Var(&copts.flCapDrop, "cap-drop", "Drop Linux capabilities")
	flags.Var(&copts.flGroupAdd, "group-add", "Add additional groups to join")
	flags.Var(&copts.flSecurityOpt, "security-opt", "Security Options")
	flags.Var(&copts.flStorageOpt, "storage-opt", "Set storage driver options per container")
	flags.Var(copts.flUlimits, "ulimit", "Ulimit options")
	flags.Var(copts.flSysctls, "sysctl", "Sysctl options")
	flags.Var(&copts.flLoggingOpts, "log-opt", "Log driver options")

	return copts
}