Example #1
func (c *FlagEnv) AddStringSlice(name string, val []string, usage string) {
	strslice := cli.StringSlice(val)
	camelName := camelCase(name)
	envName := c.toENVName(name)
	c.flags[camelName] = &flag{
		name: name,
		cliFlag: cli.StringSliceFlag{
			Name:   name,
			Value:  &strslice,
			Usage:  usage,
			EnvVar: c.toENVName(name),
		flagType:    stringSliceFlag,
		envName:     envName,
		defStrSlice: val,
Example #2
	return os.Getenv("SWARM_DISCOVERY")

var (
	flJoinAdvertise = cli.StringFlag{
		Name:   "advertise, addr",
		Usage:  "Address of the Docker Engine joining the cluster. Swarm manager(s) MUST be able to reach the Docker Engine at this address.",
	flManageAdvertise = cli.StringFlag{
		Name:   "advertise, addr",
		Usage:  "Address of the swarm manager joining the cluster. Other swarm manager(s) MUST be able to reach the swarm manager at this address.",
	// hack for go vet
	flHostsValue = cli.StringSlice([]string{"tcp://"})

	flHosts = cli.StringSliceFlag{
		Name:   "host, H",
		Value:  &flHostsValue,
		Usage:  "ip/socket to listen on",
		EnvVar: "SWARM_HOST",
	flHeartBeat = cli.StringFlag{
		Name:  "heartbeat",
		Value: "20s",
		Usage: "period between each heartbeat",
	flTTL = cli.StringFlag{
		Name:  "ttl",
		Value: "60s",
Example #3
package main

import "github.com/codegangsta/cli"

var (
	flHostsValue = cli.StringSlice([]string{""})

	flHosts = cli.StringSliceFlag{
		Name:   "host, H",
		Value:  &flHostsValue,
		Usage:  "ip/socket to listen on",
		EnvVar: "PROTON_HOST",

	flFirst = cli.BoolFlag{
		Name:   "first",
		Usage:  "be the first node for topology construction; implied by --first=true",

	flWithRaftLogs = cli.BoolFlag{
		Name:   "withRaftLogs",
		Usage:  "print raft logs for heartbeats and log processing",

	flReplication = cli.BoolFlag{
		Name:   "replication, R",
		Usage:  "take part in log replication; implied by --replication=true",
Example #4
var (
	flStore = cli.StringFlag{
		Name:  "rootdir",
		Value: homepath(".swarm"),
		Usage: "",
	flAddr = cli.StringFlag{
		Name:   "addr",
		Value:  "",
		Usage:  "ip to advertise",
		EnvVar: "SWARM_ADDR",

	// hack for go vet
	flHostsValue = cli.StringSlice([]string{"tcp://"})

	flHosts = cli.StringSliceFlag{
		Name:   "host, H",
		Value:  &flHostsValue,
		Usage:  "ip/socket to listen on",
		EnvVar: "SWARM_HOST",
	flHeartBeat = cli.IntFlag{
		Name:  "heartbeat, hb",
		Value: 25,
		Usage: "time in second between each heartbeat",
	flEnableCors = cli.BoolFlag{
		Name:  "api-enable-cors, cors",
		Usage: "enable CORS headers in the remote API",
Example #5
// New instantiates a new command-line client
func New(driver api.API) *ServicedCli {
	var (
		rpcPort          = configInt("RPC_PORT", defaultRPCPort)
		agentEndpoint    = getLocalAgentEndpoint(rpcPort)
		varPath          = api.GetVarPath()
		esStartupTimeout = api.GetESStartupTimeout()
		dockerDNS        = cli.StringSlice(api.GetDockerDNS())

	c := &ServicedCli{
		driver: driver,
		app:    cli.NewApp(),

	c.app.Name = "serviced"
	c.app.Usage = "A container-based management system"
	c.app.Version = fmt.Sprintf("%s - %s ", servicedversion.Version, servicedversion.Gitcommit)
	c.app.EnableBashCompletion = true
	c.app.Before = c.cmdInit
	staticIps := cli.StringSlice{}
	if len(configEnv("STATIC_IPS", "")) > 0 {
		staticIps = cli.StringSlice(strings.Split(configEnv("STATIC_IPS", ""), ","))

	defaultDockerRegistry := docker.DEFAULT_REGISTRY
	if hostname, err := os.Hostname(); err == nil {
		defaultDockerRegistry = fmt.Sprintf("%s:5000", hostname)

	zks := cli.StringSlice{}
	if len(configEnv("ZK", "")) > 0 {
		zks = cli.StringSlice(strings.Split(configEnv("ZK", ""), ","))

	isvcs_env := cli.StringSlice{}
	if env := configEnv("ISVCS_ENV", ""); len(env) != 0 {
		isvcs_env = append(isvcs_env, env)
	for i := 0; ; i++ {
		if env := configEnv(fmt.Sprintf("ISVCS_ENV_%d", i), ""); len(env) != 0 {
			isvcs_env = append(isvcs_env, env)
		} else {

	/* TODO: 1.1
	remotezks := cli.StringSlice{}
	if len(configEnv("REMOTE_ZK", "")) > 0 {
		zks = cli.StringSlice(strings.Split(configEnv("REMOTE_ZK", ""), ","))

	aliases := cli.StringSlice{}
	if len(configEnv("VHOST_ALIASES", "")) > 0 {
		aliases = cli.StringSlice(strings.Split(configEnv("VHOST_ALIASES", ""), ","))

	defaultAdminGroup := "sudo"
	if utils.Platform == utils.Rhel {
		defaultAdminGroup = "wheel"

	c.app.Flags = []cli.Flag{
		cli.StringFlag{"docker-registry", configEnv("DOCKER_REGISTRY", defaultDockerRegistry), "local docker registry to use"},
		cli.StringSliceFlag{"static-ip", &staticIps, "static ips for this agent to advertise"},
		cli.StringFlag{"endpoint", configEnv("ENDPOINT", agentEndpoint), fmt.Sprintf("endpoint for remote serviced (example.com:%d)", defaultRPCPort)},
		cli.StringFlag{"outbound", configEnv("OUTBOUND_IP", ""), "outbound ip address"},
		cli.StringFlag{"uiport", configEnv("UI_PORT", ":443"), "port for ui"},
		cli.StringFlag{"nfs-client", configEnv("NFS_CLIENT", "1"), "establish agent as an nfs client sharing data, 0 to disable"},
		cli.IntFlag{"listen", rpcPort, fmt.Sprintf("rpc port for serviced (%d)", defaultRPCPort)},
		cli.StringSliceFlag{"docker-dns", &dockerDNS, "docker dns configuration used for running containers"},
		cli.BoolFlag{"master", "run in master mode, i.e., the control center service"},
		cli.BoolFlag{"agent", "run in agent mode, i.e., a host in a resource pool"},
		cli.IntFlag{"mux", configInt("MUX_PORT", 22250), "multiplexing port"},
		cli.StringFlag{"var", configEnv("VARPATH", varPath), "path to store serviced data"},
		cli.StringFlag{"keyfile", configEnv("KEY_FILE", ""), "path to private key file (defaults to compiled in private key)"},
		cli.StringFlag{"certfile", configEnv("CERT_FILE", ""), "path to public certificate file (defaults to compiled in public cert)"},
		cli.StringSliceFlag{"zk", &zks, "Specify a zookeeper instance to connect to (e.g. -zk localhost:2181)"},
		// TODO: 1.1
		// cli.StringSliceFlag{"remote-zk", &remotezks, "Specify a zookeeper instance to connect to (e.g. -remote-zk remote:2181)"},
		cli.StringSliceFlag{"mount", &cli.StringSlice{}, "bind mount: DOCKER_IMAGE,HOST_PATH[,CONTAINER_PATH]"},
		cli.StringFlag{"fstype", configEnv("FS_TYPE", "rsync"), "driver for underlying file system"},
		cli.StringSliceFlag{"alias", &aliases, "list of aliases for this host, e.g., localhost"},
		cli.IntFlag{"es-startup-timeout", esStartupTimeout, "time to wait on elasticsearch startup before bailing"},
		cli.IntFlag{"max-container-age", configInt("MAX_CONTAINER_AGE", 60*60*24), "maximum age (seconds) of a stopped container before removing"},
		cli.IntFlag{"max-dfs-timeout", configInt("MAX_DFS_TIMEOUT", 60*5), "max timeout to perform a dfs snapshot"},
		cli.StringFlag{"virtual-address-subnet", configEnv("VIRTUAL_ADDRESS_SUBNET", "10.3"), "/16 subnet for virtual addresses"},
		cli.StringFlag{"master-pool-id", configEnv("MASTER_POOLID", "default"), "master's pool ID"},
		cli.StringFlag{"admin-group", configEnv("ADMIN_GROUP", defaultAdminGroup), "system group that can log in to control center"},

		cli.BoolTFlag{"report-stats", "report container statistics"},
		cli.StringFlag{"host-stats", configEnv("STATS_PORT", ""), "container statistics for host:port"},
		cli.IntFlag{"stats-period", configInt("STATS_PERIOD", 10), "Period (seconds) for container statistics reporting"},
		cli.StringFlag{"mc-username", "scott", "Username for Zenoss metric consumer"},
		cli.StringFlag{"mc-password", "tiger", "Password for the Zenoss metric consumer"},
		cli.StringFlag{"cpuprofile", "", "write cpu profile to file"},
		cli.StringSliceFlag{"isvcs-env", &isvcs_env, "internal-service environment variable: ISVC:KEY=VAL"},
		cli.IntFlag{"debug-port", configInt("DEBUG_PORT", 6006), "Port on which to listen for profiler connections"},
		cli.IntFlag{"max-rpc-clients", configInt("MAX_RPC_CLIENTS", 3), "max number of rpc clients to an endpoint"},
		cli.IntFlag{"rpc-dial-timeout", configInt("RPC_DIAL_TIMEOUT", 30), "timeout for creating rpc connections"},
		cli.IntFlag{"snapshot-ttl", configInt("SNAPSHOT_TTL", 12), "snapshot TTL in hours, 0 to disable"},

		// Reimplementing GLOG flags :(
		cli.BoolTFlag{"logtostderr", "log to standard error instead of files"},
		cli.BoolFlag{"alsologtostderr", "log to standard error as well as files"},
		cli.StringFlag{"logstashurl", configEnv("LOG_ADDRESS", ""), "logstash url and port"},
		cli.StringFlag{"logstash-es", configEnv("LOGSTASH_ES", ""), "host and port for logstash elastic search"},
		cli.IntFlag{"logstash-max-days", configInt("LOGSTASH_MAX_DAYS", 14), "days to keep Logstash data"},
		cli.IntFlag{"logstash-max-size", configInt("LOGSTASH_MAX_SIZE", 10), "max size of Logstash data to keep in gigabytes"},
		cli.IntFlag{"v", configInt("LOG_LEVEL", 0), "log level for V logs"},
		cli.StringFlag{"stderrthreshold", "", "logs at or above this threshold go to stderr"},
		cli.StringFlag{"vmodule", "", "comma-separated list of pattern=N settings for file-filtered logging"},
		cli.StringFlag{"log_backtrace_at", "", "when logging hits line file:N, emit a stack trace"},


	return c
Example #6
File: main.go Project: pjvds/edgy

	for _, one := range all {
		go pipe(one)

	go func() {
	return out

var defaultHosts = cli.StringSlice([]string{"localhost:5050"})

func main() {

	app := cli.NewApp()
	app.Name = "edgy command line interface"
	app.Commands = []cli.Command{
			Name: "publish",
			Flags: []cli.Flag{
					Name:   "hosts",
					Value:  "localhost:5050",
					EnvVar: "EDGY_HOSTS",