// InstallFlags adds flags for the common options on the FlagSet func (commonOpts *CommonOptions) InstallFlags(flags *pflag.FlagSet) { if dockerCertPath == "" { dockerCertPath = cliconfig.Dir() } flags.BoolVarP(&commonOpts.Debug, "debug", "D", false, "Enable debug mode") flags.StringVarP(&commonOpts.LogLevel, "log-level", "l", "info", "Set the logging level (\"debug\", \"info\", \"warn\", \"error\", \"fatal\")") flags.BoolVar(&commonOpts.TLS, "tls", false, "Use TLS; implied by --tlsverify") flags.BoolVar(&commonOpts.TLSVerify, FlagTLSVerify, dockerTLSVerify, "Use TLS and verify the remote") // TODO use flag flags.String("identity"}, "i", "", "Path to libtrust key file") commonOpts.TLSOptions = &tlsconfig.Options{ CAFile: filepath.Join(dockerCertPath, DefaultCaFile), CertFile: filepath.Join(dockerCertPath, DefaultCertFile), KeyFile: filepath.Join(dockerCertPath, DefaultKeyFile), } tlsOptions := commonOpts.TLSOptions flags.Var(opts.NewQuotedString(&tlsOptions.CAFile), "tlscacert", "Trust certs signed only by this CA") flags.Var(opts.NewQuotedString(&tlsOptions.CertFile), "tlscert", "Path to TLS certificate file") flags.Var(opts.NewQuotedString(&tlsOptions.KeyFile), "tlskey", "Path to TLS key file") hostOpt := opts.NewNamedListOptsRef("hosts", &commonOpts.Hosts, opts.ValidateHost) flags.VarP(hostOpt, "host", "H", "Daemon socket(s) to connect to") }
func varFlag(f *pflag.FlagSet, value pflag.Value, flagInfo cliflags.FlagInfo) { if flagInfo.Shorthand == "" { f.Var(value, flagInfo.Name, makeUsageString(flagInfo)) } else { f.VarP(value, flagInfo.Name, flagInfo.Shorthand, makeUsageString(flagInfo)) } setFlagFromEnv(f, flagInfo) }
func initDeploymentFlags(fs *pflag.FlagSet, f *fg.Flags) { fs.StringVarP(&f.JobPath, "job", "j", defaultJobPath, "filename of the job description") fs.StringVarP(&f.ClusterPath, "cluster", "c", defaultClusterPath, "cluster description name or filename") fs.StringVarP(&f.TunnelOverride, "tunnel", "t", defaultTunnelOverride, "SSH endpoint to tunnel through with fleet (cluster override)") fs.StringSliceVarP(&f.Groups, "groups", "g", defaultGroups, "target task groups to deploy") fs.BoolVarP(&f.Force, "force", "f", defaultForce, "wheather to confirm destroy or not") fs.BoolVarP(&f.AutoContinue, "yes", "y", false, "auto continue on confirmation") fs.BoolVarP(&f.DryRun, "dry-run", "d", defaultDryRun, "wheather to schedule units or not") fs.UintVar(&f.ScalingGroup, "scaling-group", defaultScalingGroup, "scaling group to deploy") fs.BoolVarP(&f.Local, "local", "l", defaultLocal, "User local vagrant test cluster") fs.DurationVar(&f.StopDelay, "stop-delay", defaultStopDelay, "Time between stop and destroy") fs.DurationVar(&f.DestroyDelay, "destroy-delay", defaultDestroyDelay, "Time between destroy and re-create") fs.DurationVar(&f.SliceDelay, "slice-delay", defaultSliceDelay, "Time between update of scaling slices") fs.VarP(&f.Options, "option", "o", "Set an option (key=value)") f.VaultCACert = os.Getenv("VAULT_CACERT") f.VaultCAPath = os.Getenv("VAULT_CAPATH") fs.StringVar(&f.VaultAddr, "vault-addr", "", "URL of the vault (defaults to VAULT_ADDR environment variable)") fs.StringVar(&f.VaultCACert, "vault-cacert", f.VaultCACert, "Path to a PEM-encoded CA cert file to use to verify the Vault server SSL certificate") fs.StringVar(&f.VaultCAPath, "vault-capath", f.VaultCAPath, "Path to a directory of PEM-encoded CA cert files to verify the Vault server SSL certificate") fs.StringVarP(&f.GithubToken, "github-token", "G", "", "Personal github token for secret logins") fs.StringVar(&f.GithubTokenPath, "github-token-path", defaultGithubTokenPath, "Path of a file containing your github token") }
// AddFlags adds all command line flags that will be used by Parse to the FlagSet func AddFlags(flags *pflag.FlagSet) *ContainerOptions { copts := &ContainerOptions{ aliases: opts.NewListOpts(nil), attach: opts.NewListOpts(ValidateAttach), blkioWeightDevice: NewWeightdeviceOpt(ValidateWeightDevice), capAdd: opts.NewListOpts(nil), capDrop: opts.NewListOpts(nil), dns: opts.NewListOpts(opts.ValidateIPAddress), dnsOptions: opts.NewListOpts(nil), dnsSearch: opts.NewListOpts(opts.ValidateDNSSearch), deviceReadBps: NewThrottledeviceOpt(ValidateThrottleBpsDevice), deviceReadIOps: NewThrottledeviceOpt(ValidateThrottleIOpsDevice), deviceWriteBps: NewThrottledeviceOpt(ValidateThrottleBpsDevice), deviceWriteIOps: NewThrottledeviceOpt(ValidateThrottleIOpsDevice), devices: opts.NewListOpts(ValidateDevice), env: opts.NewListOpts(ValidateEnv), envFile: opts.NewListOpts(nil), expose: opts.NewListOpts(nil), extraHosts: opts.NewListOpts(ValidateExtraHost), groupAdd: opts.NewListOpts(nil), labels: opts.NewListOpts(ValidateEnv), labelsFile: opts.NewListOpts(nil), linkLocalIPs: opts.NewListOpts(nil), links: opts.NewListOpts(ValidateLink), loggingOpts: opts.NewListOpts(nil), publish: opts.NewListOpts(nil), securityOpt: opts.NewListOpts(nil), storageOpt: opts.NewListOpts(nil), sysctls: opts.NewMapOpts(nil, opts.ValidateSysctl), tmpfs: opts.NewListOpts(nil), ulimits: NewUlimitOpt(nil), volumes: opts.NewListOpts(nil), volumesFrom: opts.NewListOpts(nil), } // General purpose flags flags.VarP(&copts.attach, "attach", "a", "Attach to STDIN, STDOUT or STDERR") flags.Var(&copts.devices, "device", "Add a host device to the container") flags.VarP(&copts.env, "env", "e", "Set environment variables") flags.Var(&copts.envFile, "env-file", "Read in a file of environment variables") flags.StringVar(&copts.entrypoint, "entrypoint", "", "Overwrite the default ENTRYPOINT of the image") flags.Var(&copts.groupAdd, "group-add", "Add additional groups to join") flags.StringVarP(&copts.hostname, "hostname", "h", "", "Container host name") flags.BoolVarP(&copts.stdin, "interactive", "i", false, "Keep STDIN open even if not attached") flags.VarP(&copts.labels, "label", "l", "Set meta data on a container") flags.Var(&copts.labelsFile, "label-file", "Read in a line delimited file of labels") flags.BoolVar(&copts.readonlyRootfs, "read-only", false, "Mount the container's root filesystem as read only") flags.StringVar(&copts.restartPolicy, "restart", "no", "Restart policy to apply when a container exits") flags.StringVar(&copts.stopSignal, "stop-signal", signal.DefaultStopSignal, fmt.Sprintf("Signal to stop a container, %v by default", signal.DefaultStopSignal)) flags.Var(copts.sysctls, "sysctl", "Sysctl options") flags.BoolVarP(&copts.tty, "tty", "t", false, "Allocate a pseudo-TTY") flags.Var(copts.ulimits, "ulimit", "Ulimit options") flags.StringVarP(&copts.user, "user", "u", "", "Username or UID (format: <name|uid>[:<group|gid>])") flags.StringVarP(&copts.workingDir, "workdir", "w", "", "Working directory inside the container") flags.BoolVar(&copts.autoRemove, "rm", false, "Automatically remove the container when it exits") // Security flags.Var(&copts.capAdd, "cap-add", "Add Linux capabilities") flags.Var(&copts.capDrop, "cap-drop", "Drop Linux capabilities") flags.BoolVar(&copts.privileged, "privileged", false, "Give extended privileges to this container") flags.Var(&copts.securityOpt, "security-opt", "Security Options") flags.StringVar(&copts.usernsMode, "userns", "", "User namespace to use") flags.StringVar(&copts.credentialSpec, "credentialspec", "", "Credential spec for managed service account (Windows only)") // Network and port publishing flag flags.Var(&copts.extraHosts, "add-host", "Add a custom host-to-IP mapping (host:ip)") flags.Var(&copts.dns, "dns", "Set custom DNS servers") flags.Var(&copts.dnsOptions, "dns-opt", "Set DNS options") flags.Var(&copts.dnsSearch, "dns-search", "Set custom DNS search domains") flags.Var(&copts.expose, "expose", "Expose a port or a range of ports") flags.StringVar(&copts.ipv4Address, "ip", "", "Container IPv4 address (e.g. 172.30.100.104)") flags.StringVar(&copts.ipv6Address, "ip6", "", "Container IPv6 address (e.g. 2001:db8::33)") flags.Var(&copts.links, "link", "Add link to another container") flags.Var(&copts.linkLocalIPs, "link-local-ip", "Container IPv4/IPv6 link-local addresses") flags.StringVar(&copts.macAddress, "mac-address", "", "Container MAC address (e.g. 92:d0:c6:0a:29:33)") flags.VarP(&copts.publish, "publish", "p", "Publish a container's port(s) to the host") flags.BoolVarP(&copts.publishAll, "publish-all", "P", false, "Publish all exposed ports to random ports") // We allow for both "--net" and "--network", although the latter is the recommended way. flags.StringVar(&copts.netMode, "net", "default", "Connect a container to a network") flags.StringVar(&copts.netMode, "network", "default", "Connect a container to a network") flags.MarkHidden("net") // We allow for both "--net-alias" and "--network-alias", although the latter is the recommended way. flags.Var(&copts.aliases, "net-alias", "Add network-scoped alias for the container") flags.Var(&copts.aliases, "network-alias", "Add network-scoped alias for the container") flags.MarkHidden("net-alias") // Logging and storage flags.StringVar(&copts.loggingDriver, "log-driver", "", "Logging driver for the container") flags.StringVar(&copts.volumeDriver, "volume-driver", "", "Optional volume driver for the container") flags.Var(&copts.loggingOpts, "log-opt", "Log driver options") flags.Var(&copts.storageOpt, "storage-opt", "Storage driver options for the container") flags.Var(&copts.tmpfs, "tmpfs", "Mount a tmpfs directory") flags.Var(&copts.volumesFrom, "volumes-from", "Mount volumes from the specified container(s)") flags.VarP(&copts.volumes, "volume", "v", "Bind mount a volume") // Health-checking flags.StringVar(&copts.healthCmd, "health-cmd", "", "Command to run to check health") flags.DurationVar(&copts.healthInterval, "health-interval", 0, "Time between running the check") flags.IntVar(&copts.healthRetries, "health-retries", 0, "Consecutive failures needed to report unhealthy") flags.DurationVar(&copts.healthTimeout, "health-timeout", 0, "Maximum time to allow one check to run") flags.BoolVar(&copts.noHealthcheck, "no-healthcheck", false, "Disable any container-specified HEALTHCHECK") // Resource management flags.Uint16Var(&copts.blkioWeight, "blkio-weight", 0, "Block IO (relative weight), between 10 and 1000") flags.Var(&copts.blkioWeightDevice, "blkio-weight-device", "Block IO weight (relative device weight)") flags.StringVar(&copts.containerIDFile, "cidfile", "", "Write the container ID to the file") flags.StringVar(&copts.cpusetCpus, "cpuset-cpus", "", "CPUs in which to allow execution (0-3, 0,1)") flags.StringVar(&copts.cpusetMems, "cpuset-mems", "", "MEMs in which to allow execution (0-3, 0,1)") flags.Int64Var(&copts.cpuPercent, "cpu-percent", 0, "CPU percent (Windows only)") 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.Int64VarP(&copts.cpuShares, "cpu-shares", "c", 0, "CPU shares (relative weight)") 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") flags.Var(&copts.deviceWriteIOps, "device-write-iops", "Limit write rate (IO per second) to a device") flags.StringVar(&copts.ioMaxBandwidth, "io-maxbandwidth", "", "Maximum IO bandwidth limit for the system drive (Windows only)") flags.Uint64Var(&copts.ioMaxIOps, "io-maxiops", 0, "Maximum IOps limit for the system drive (Windows only)") flags.StringVar(&copts.kernelMemory, "kernel-memory", "", "Kernel memory limit") flags.StringVarP(&copts.memoryString, "memory", "m", "", "Memory limit") flags.StringVar(&copts.memoryReservation, "memory-reservation", "", "Memory soft limit") flags.StringVar(&copts.memorySwap, "memory-swap", "", "Swap limit equal to memory plus swap: '-1' to enable unlimited swap") flags.Int64Var(&copts.swappiness, "memory-swappiness", -1, "Tune container memory swappiness (0 to 100)") flags.BoolVar(&copts.oomKillDisable, "oom-kill-disable", false, "Disable OOM Killer") flags.IntVar(&copts.oomScoreAdj, "oom-score-adj", 0, "Tune host's OOM preferences (-1000 to 1000)") flags.Int64Var(&copts.pidsLimit, "pids-limit", 0, "Tune container pids limit (set -1 for unlimited)") // Low-level execution (cgroups, namespaces, ...) flags.StringVar(&copts.cgroupParent, "cgroup-parent", "", "Optional parent cgroup for the container") flags.StringVar(&copts.ipcMode, "ipc", "", "IPC namespace to use") flags.StringVar(&copts.isolation, "isolation", "", "Container isolation technology") flags.StringVar(&copts.pidMode, "pid", "", "PID namespace to use") flags.StringVar(&copts.shmSize, "shm-size", "", "Size of /dev/shm, default value is 64MB") flags.StringVar(&copts.utsMode, "uts", "", "UTS namespace to use") 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.StringVar(&copts.initPath, "init-path", "", "Path to the docker-init binary") return copts }
// 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 }
// BindListFlag binds a flag that expects a kube list value. Note that if the target // comes pre-populated, that list is not erased; anything the user puts in the flag // is added on. This is probably a bug in k8s impl of StringList. func (i FlagInfo) BindListFlag(flags *pflag.FlagSet, target *kutil.StringList) { // assume flags with no longname are not desired if len(i.LongName) > 0 { flags.VarP(target, i.LongName, i.ShortName, i.Description) } }