func init() { flag.StringVar(&options.CPUProfile, "cpuprofile", "", "write cpu profile to file") flag.Uint64Var(&options.SpoolSize, "spool-size", 1024, "Maximum number of events to spool before a flush is forced.") flag.IntVar(&options.NumWorkers, "num-workers", 1, "deprecated option, strictly for backwards compatibility. does nothing.") flag.DurationVar(&options.IdleTimeout, "idle-flush-time", 5*time.Second, "Maximum time to wait for a full spool before flushing anyway") flag.StringVar(&options.ConfigFile, "config", "", "The config file to load") flag.StringVar(&options.LogFile, "log-file", "", "Log file output") flag.StringVar(&options.PidFile, "pid-file", "lumberjack.pid", "destination to which a pidfile will be written") flag.BoolVar(&options.UseSyslog, "log-to-syslog", false, "Log to syslog instead of stdout. This option overrides the --log-file option.") flag.BoolVar(&options.FromBeginning, "from-beginning", false, "Read new files from the beginning, instead of the end") flag.StringVar(&options.HistoryPath, "progress-file", ".lumberjack", "path of file used to store progress data") flag.StringVar(&options.TempDir, "temp-dir", "/tmp", "directory for creating temp files") flag.IntVar(&options.NumThreads, "threads", 1, "Number of OS threads to use") flag.IntVar(&options.CmdPort, "cmd-port", 42586, "tcp command port number") flag.StringVar(&options.HttpPort, "http", "", "http port for debug info. No http server is run if this is left off. E.g.: http=:6060") }
func initFlags() { certPath := filepath.Join(os.Getenv("DOCKER_CERT_PATH")) if certPath == "" { certPath = filepath.Join(os.Getenv("HOME"), ".docker") } flag.BoolVar(&version, "version", false, "show version") flag.BoolVar(&watch, "watch", false, "watch for container changes") flag.BoolVar(&onlyExposed, "only-exposed", false, "only include containers with exposed ports") flag.BoolVar(&onlyPublished, "only-published", false, "only include containers with published ports (implies -only-exposed)") flag.StringVar(¬ifyCmd, "notify", "", "run command after template is regenerated (e.g `restart xyz`)") flag.StringVar(¬ifySigHUPContainerID, "notify-sighup", "", "send HUP signal to container. Equivalent to `docker kill -s HUP container-ID`") flag.Var(&configFiles, "config", "config files with template directives. Config files will be merged if this option is specified multiple times.") flag.IntVar(&interval, "interval", 0, "notify command interval (secs)") flag.StringVar(&endpoint, "endpoint", "", "docker api endpoint (tcp|unix://..). Default unix:///var/run/docker.sock") flag.StringVar(&tlsCert, "tlscert", filepath.Join(certPath, "cert.pem"), "path to TLS client certificate file") flag.StringVar(&tlsKey, "tlskey", filepath.Join(certPath, "key.pem"), "path to TLS client key file") flag.StringVar(&tlsCaCert, "tlscacert", filepath.Join(certPath, "ca.pem"), "path to TLS CA certificate file") flag.BoolVar(&tlsVerify, "tlsverify", os.Getenv("DOCKER_TLS_VERIFY") != "", "verify docker daemon's TLS certicate") flag.Usage = usage flag.Parse() }
func main() { var bindAddress string var port int flag.IntVar(&port, "port", 9125, "Port to listen on") flag.IntVar(&port, "p", 9125, "Port to listen on") flag.StringVar(&bindAddress, "bind", "0.0.0.0", "IP Address to listen on") flag.StringVar(&bindAddress, "b", "0.0.0.0", "IP Address to listen on") flag.StringVar(&prefix, "prefix", "statsrelay", "The prefix to use with self generated stats") flag.BoolVar(&verbose, "verbose", false, "Verbose output") flag.BoolVar(&verbose, "v", false, "Verbose output") flag.Parse() if len(flag.Args()) == 0 { log.Fatalf("One or most host specifications are needed to locate statsd daemons.\n") } hashRing = consistent.New() hashRing.NumberOfReplicas = 1 for _, v := range flag.Args() { var addr *net.UDPAddr var err error host := strings.Split(v, ":") switch len(host) { case 1: log.Printf("Invalid statsd location: %s\n", v) log.Fatalf("Must be of the form HOST:PORT or HOST:PORT:INSTANCE\n") case 2: addr, err = net.ResolveUDPAddr("udp", v) if err != nil { log.Printf("Error parsing HOST:PORT \"%s\"\n", v) log.Fatalf("%s\n", err.Error()) } case 3: addr, err = net.ResolveUDPAddr("udp", host[0]+":"+host[1]) if err != nil { log.Printf("Error parsing HOST:PORT:INSTANCE \"%s\"\n", v) log.Fatalf("%s\n", err.Error()) } default: log.Fatalf("Unrecongnized host specification: %s\n", v) } if addr != nil { udpAddr[v] = addr hashRing.Add(v) } } epochTime = time.Now().Unix() runServer(bindAddress, port) log.Printf("Normal shutdown.\n") }
func (c *cover) setOptions() { flag.BoolVar(&c.set, "cover", false, "Use the cover tool.") flag.BoolVar(&c.open, "open", true, "Open the results of the cover tool on the browser.") flag.Float64Var(&c.threshold, "threshold", defaultThreshold, "The accepted code coverage threshold.") }
func parseArgs() args { var a args // setup + parse flags flag.BoolVar(&a.listen, "listen", false, "listen for connections") flag.BoolVar(&a.listen, "l", false, "listen for connections (short)") flag.BoolVar(&a.verbose, "v", false, "verbose debugging") flag.Usage = Usage flag.Parse() osArgs := flag.Args() if len(osArgs) < 1 { exit("") } if a.listen { a.localAddr = osArgs[0] } else { if len(osArgs) > 1 { a.localAddr = osArgs[0] a.remoteAddr = osArgs[1] } else { a.remoteAddr = osArgs[0] } } return a }
func parseFlags() error { flag.BoolVar(&flagA, "a", flagA, "see 'go build' help") flag.BoolVar(&flagX, "x", flagX, "see 'go build' help") flag.BoolVar(&flagRace, "race", flagRace, "see 'go build' help") flag.StringVar(&flagTags, "tags", flagTags, "see 'go build' help") flag.BoolVar(&flagV, "v", flagV, "see 'go test' help") flag.IntVar(&flagCount, "count", flagCount, "see 'go test' help") flag.StringVar(&flagCPU, "cpu", flagCPU, "see 'go test' help") flag.StringVar(&flagParallel, "parallel", flagParallel, "see 'go test' help") flag.StringVar(&flagRun, "run", flagRun, "see 'go test' help") flag.BoolVar(&flagShort, "short", flagShort, "see 'go test' help") flag.StringVar(&flagTimeout, "timeout", flagTimeout, "see 'go test' help") flag.StringVar(&flagCoverMode, "covermode", flagCoverMode, "see 'go test' help") flag.StringVar(&flagCoverProfile, "coverprofile", flagCoverProfile, "see 'go test' help") flag.IntVar(&flagParallelPackages, "parallelpackages", flagParallelPackages, "Number of package test run in parallel") flag.Parse() if flagCoverProfile == "" { flagCoverProfile = "out.coverprofile" } if flagParallelPackages < 1 { return fmt.Errorf("flag parallelpackages must be greater than or equal to 1") } return nil }
func init() { flag.StringVar(&configFile, "c", "config.json", "the config file") flag.BoolVar(&version, "V", false, "show version") flag.BoolVar(&testMode, "t", false, "test config") flag.IntVar(&statPort, "s", -1, "set stat server port") flag.IntVar(&commitInterval, "i", 10, "set stat server port") }
func main() { var quiet bool var dontResolveSymlinks bool flag.BoolVar(&quiet, "q", false, "warnings will not be printed") flag.BoolVar(&dontResolveSymlinks, "s", false, "do not resolve symlink") flag.Parse() for _, path := range flag.Args() { s, err := filepath.Abs(path) if err != nil { if !quiet { fmt.Fprintln(os.Stderr, err) } continue } if !dontResolveSymlinks { s, err = filepath.EvalSymlinks(s) if err != nil { if !quiet { fmt.Fprintln(os.Stderr, err) } continue } } fmt.Println(s) } }
func init() { // Read configuration from files read_configurations() // Now override configuration with command line parameters flag.Usage = func() { fmt.Fprintf(os.Stderr, "Usage of %s:\n", os.Args[0]) flag.PrintDefaults() fmt.Fprintf(os.Stderr, "\n") fmt.Fprintf(os.Stderr, "The following configuration files will also be read:") fmt.Fprintf(os.Stderr, " (+ if file is present)\n") for _, file := range config_files() { if _, err := os.Stat(file); os.IsNotExist(err) { fmt.Fprintf(os.Stderr, " - %s\n", file) } else { fmt.Fprintf(os.Stderr, " + %s\n", file) } } } flag.StringVar(&cfg.Channel, "c", cfg.Channel, "Post input values to specified channel or user.") flag.StringVar(&cfg.IconURL, "i", cfg.IconURL, "This url is used as icon for posting.") flag.StringVar(&cfg.Language, "l", cfg.Language, "Specify the language used for syntax highlighting (ruby/python/...)") flag.StringVar(&cfg.MatterURL, "m", cfg.MatterURL, "Mattermost incoming webhooks URL.") flag.StringVar(&cfg.Title, "t", cfg.Title, "This title is added to posts. (not with -n)") flag.StringVar(&cfg.Username, "u", cfg.Username, "This username is used for posting.") flag.BoolVar(&cfg.Extra, "x", cfg.Extra, "Add extra info (user/hostname/timestamp).") flag.BoolVar(&cfg.NoBuffer, "n", cfg.NoBuffer, "Post input values without buffering.") flag.BoolVar(&cfg.PlainText, "p", cfg.PlainText, "Don't surround the post with triple backticks.") flag.BoolVar(&flagVersion, "version", false, "show version.") flag.Parse() }
func main() { flag.BoolVar(&fotki.Verbose, "v", false, "Be verbose") flag.BoolVar(&fotki.DryRun, "n", false, "Dry-run") flag.BoolVar(&fotki.Rescan, "rescan", false, "Rescan valid directories under root") flag.BoolVar(&fotki.RemoveOld, "move", false, "Remove the original files") scandir := flag.String("scan", "", "The directory to scan") rootdir := flag.String("root", "", "The root directory of the album") flag.Parse() if fotki.Verbose { fmt.Println("# scandir=", *scandir) fmt.Println("# rootdir=", *rootdir) } if *scandir == "" { fmt.Fprintln(os.Stderr, "scan flag is required") os.Exit(1) } if *rootdir == "" { fmt.Fprintln(os.Stderr, "root flag is required") os.Exit(1) } album := fotki.NewAlbum(*rootdir) check(album.Scan(*scandir)) check(album.Relocate()) album.ShowFailed() }
func init() { flag.StringVar(&Options.Zone, "z", "", "zone") flag.BoolVar(&Options.ShowVersion, "v", false, "show version and exit") flag.BoolVar(&Options.ShowVersion, "version", false, "show version and exit") flag.StringVar(&Options.LogFile, "log", "stdout", "log file") flag.StringVar(&Options.LogLevel, "level", "debug", "log level") flag.IntVar(&Options.LogRotateSize, "logsize", 10<<30, "max unrotated log file size") flag.StringVar(&Options.InfluxAddr, "influxaddr", "", "influxdb server addr") flag.StringVar(&Options.ManagerType, "man", "dummy", "manager type <dummy|mysql>") flag.StringVar(&Options.InfluxDbname, "influxdb", "", "influxdb db name") flag.StringVar(&Options.ListenAddr, "addr", ":9065", "monitor http server addr") flag.StringVar(&Options.HintedHandoffDir, "hhdirs", "hh", "hinted handoff dirs seperated by comma") flag.Parse() if Options.ShowVersion { fmt.Fprintf(os.Stderr, "%s-%s\n", gafka.Version, gafka.BuildId) os.Exit(0) } if Options.Zone == "" { panic("empty zone not allowed") } golog.SetOutput(ioutil.Discard) if Options.LogFile != "stdout" { SetupLogging(Options.LogFile, Options.LogLevel, "panic") } else { SetupLogging(Options.LogFile, Options.LogLevel, "") } ctx.LoadFromHome() }
func main() { flag.BoolVar(&CmdlineOptions.Verbose, "v", false, "Verbose") flag.BoolVar(&CmdlineOptions.WaitForEvent, "w", false, "For commands that return an event_id, wait for the event to complete.") InitRoutingTable() flag.Parse() route := FindMatchingRoute(flag.Args()) if CmdlineOptions.Verbose { fmt.Fprintf(os.Stderr, "Args: %s\n", flag.Args()) } if CmdlineOptions.Verbose { fmt.Fprintf(os.Stderr, "Route: %s\n", route) } if route == nil { fmt.Fprintf(os.Stderr, "Error: unrecognized command: %s\n", flag.Args()) ShowGeneralHelp(route) os.Exit(1) } if !InitConfig() { fmt.Fprintf(os.Stderr, "Invalid or Missing configuration file.\n") os.Exit(1) } if CmdlineOptions.Verbose { fmt.Fprintf(os.Stderr, "Config: %s\n", Config) } if route != nil { if CmdlineOptions.Verbose { fmt.Fprintf(os.Stderr, "Calling route: %s\n", route) } route.Handler(route) } }
func main() { var pubFile, privFile string var help, listen, stayOpen bool flag.BoolVar(&help, "h", false, "display a short usage message") flag.BoolVar(&stayOpen, "k", false, "keep listening after client disconnects") flag.BoolVar(&listen, "l", false, "listen for incoming connections") flag.StringVar(&privFile, "s", "", "path to signature key") flag.StringVar(&pubFile, "v", "", "path to verification key") flag.Parse() if help { usage() os.Exit(1) } loadID(privFile, pubFile) defer func() { if idPriv != nil { zero(idPriv[:], 0) } }() if listen { if flag.NArg() != 1 { fmt.Println("A port is required (and should be the only argument) when listening.") } listener(stayOpen, flag.Arg(0)) return } if flag.NArg() != 2 { fmt.Println("An address and port are required (and should be the only arguments).") } sender(flag.Arg(0) + ":" + flag.Arg(1)) }
func parseArgs() args { var a args // setup + parse flags flag.BoolVar(&a.listen, "listen", false, "listen for connections") flag.BoolVar(&a.listen, "l", false, "listen for connections (short)") flag.BoolVar(&a.verbose, "v", true, "verbose") flag.BoolVar(&a.debug, "debug", false, "debugging") // flag.StringVar(&a.keyfile, "key", "", "private key file") flag.IntVar(&a.keybits, "keybits", 2048, "num bits for generating private key") flag.Usage = Usage flag.Parse() osArgs := flag.Args() if len(osArgs) < 1 { exit("") } if a.verbose { out("verbose on") } if a.listen { a.localAddr = osArgs[0] } else { if len(osArgs) > 1 { a.localAddr = osArgs[0] a.remoteAddr = osArgs[1] } else { a.remoteAddr = osArgs[0] } } return a }
func init() { potentialQueues := os.Getenv("WORKER_QUEUES") potentialConcurrency := os.Getenv("WORKER_CONCURRENCY") concurrency = 25 if potentialConcurrency != "" { tmp, _ := strconv.ParseInt(potentialConcurrency, 10, 32) concurrency = int(tmp) } flag.StringVar(&queuesString, "queues", potentialQueues, "a comma-separated list of Resque queues") flag.Float64Var(&intervalFloat, "interval", 5.0, "sleep interval when no jobs are found") flag.IntVar(&concurrency, "concurrency", concurrency, "the maximum number of concurrently executing jobs") flag.IntVar(&connections, "connections", 2, "the maximum number of connections to the Redis database") redisProvider := os.Getenv("REDIS_PROVIDER") var redisEnvUri string if redisProvider != "" { redisEnvUri = os.Getenv(redisProvider) } else { redisEnvUri = os.Getenv("REDIS_URL") } if redisEnvUri == "" { redisEnvUri = "redis://localhost:6379/" } flag.StringVar(&uri, "uri", redisEnvUri, "the URI of the Redis server") flag.StringVar(&namespace, "namespace", "resque:", "the Redis namespace") flag.BoolVar(&exitOnComplete, "exit-on-complete", false, "exit when the queue is empty") flag.BoolVar(&useNumber, "use-number", false, "use json.Number instead of float64 when decoding numbers in JSON. will default to true soon") }
func main() { // Set up and parse command-line args. runtime.GOMAXPROCS(runtime.NumCPU()) flag.StringVar(&host, "host", "127.0.0.1", "") flag.Float64Var(&numSeconds, "num-seconds", 10, "") flag.IntVar(&numClients, "num-clients", 1, "") flag.IntVar(&numChannels, "num-channels", 50, "") flag.IntVar(&messageSize, "message-size", 20, "") flag.BoolVar(&useRedis, "redis", false, "") flag.BoolVar(&quiet, "quiet", false, "") flag.Parse() for i := 0; i < numChannels; i++ { channels = append(channels, strconv.Itoa(i)) } // Create publisher/subscriber goroutines, pausing to allow // publishers to hit full throttle RunWorkers(Publisher) time.Sleep(1 * time.Second) RunWorkers(Subscriber) // Consume metrics until --num-seconds has passed, and display // the median value. metrics := GetMetrics() sort.Ints(metrics) fmt.Println("Num clients", numClients, "median", metrics[len(metrics)/2], "msg/sec") }
// Main method. func main() { conf := config.New() help, version := false, false flag.BoolVar(&help, "help", false, "Prints command line options and exit.") flag.BoolVar(&version, "version", false, "Prints the etcdsh version and exit.") flag.StringVar(&conf.Machine, "machine", conf.Machine, "Connect to this etcd server.") flag.StringVar(&conf.PS1, "ps1", conf.PS1, "First prompt format") flag.StringVar(&conf.PS2, "ps2", conf.PS2, "Second prompt format") flag.BoolVar(&conf.Colors, "colors", conf.Colors, "Use colors in display.") flag.Parse() if help { printHelp() os.Exit(0) } if version { printVersion() os.Exit(0) } fmt.Printf("Connecting to %s\n", conf.Machine) client := etcd.NewClient([]string{conf.Machine}) controller := handlers.NewController(conf, client, os.Stdout, os.Stderr, os.Stdin) controller.Add(handlers.NewLsHandler(controller)) controller.Add(handlers.NewSetHandler(controller)) controller.Add(handlers.NewHelpHandler(controller)) controller.Add(handlers.NewCdHandler(controller)) controller.Add(handlers.NewGetHandler(controller)) os.Exit(controller.Start()) }
func parseCmdLineConfig() *Config { var c Config var listenAddr string flag.StringVar(&c.RcFile, "rc", "", "config file, defaults to $HOME/.meow/rc on Unix, ./rc.txt on Windows") // Specifying listen default value to StringVar would override config file options flag.StringVar(&listenAddr, "listen", "", "listen address, disables listen in config") flag.IntVar(&c.Core, "core", 2, "number of cores to use") flag.StringVar(&c.LogFile, "logFile", "", "write output to file") flag.BoolVar(&c.PrintVer, "version", false, "print version") flag.BoolVar(&c.EstimateTimeout, "estimate", true, "enable/disable estimate timeout") flag.Parse() if c.RcFile == "" { c.RcFile = getDefaultRcFile() } else { c.RcFile = expandTilde(c.RcFile) } if err := isFileExists(c.RcFile); err != nil { Fatal("fail to get config file:", err) } initConfig(c.RcFile) initDomainList(config.DirectFile, domainTypeDirect) initDomainList(config.ProxyFile, domainTypeProxy) if listenAddr != "" { configParser{}.ParseListen(listenAddr) cmdHasListenAddr = true // must come after parse } return &c }
func main() { flag.Usage = func() { fmt.Fprintf(os.Stderr, "Usage: %s [ <project directory> ]\n", os.Args[0]) flag.PrintDefaults() } var cf config flag.StringVar(&cf.projectName, "n", "", "base package name for the project, e.g. github.com/user/proj") flag.BoolVar(&cf.update, "u", false, "update dependency submodules from their remote repos") flag.BoolVar(&cf.prune, "p", false, "prune unused dependency submodules") flag.Parse() cf.rootDir = "." switch { case flag.NArg() == 1: cf.rootDir = flag.Arg(1) case flag.NArg() > 1: flag.Usage() os.Exit(2) } if err := run(&cf); err != nil { fmt.Fprintln(os.Stderr, err) os.Exit(1) } }
func init() { flag.StringVar(&dockerURL, "docker", "unix:///var/run/docker.sock", "Connection to Docker.") flag.StringVar(&cleanOld, "clean-old", "", "Delete all images older than this. Use units: 'h','m','s'") flag.BoolVar(&cleanNone, "clean-none", false, "Delete all untagged images. (<none>:<none>)") flag.StringVar(&stopOld, "stop-old", "", "Stop all container stat are running longer then this. Use units: 'h','m','s'") flag.BoolVar(&noConfirm, "yes", false, "Do not require confirmation.") }
func (g *Grep) AddFlags() { flag.BoolVar(&g.L, "l", false, "list matching files only") flag.BoolVar(&g.C, "c", false, "print match counts only") flag.BoolVar(&g.N, "n", false, "show line numbers") flag.BoolVar(&g.H, "h", false, "omit file names") flag.BoolVar(&g.Z, "0", false, "null delimit file names") }
func main() { var server, client bool flag.StringVar(&remote, "remote", "", "remote server") flag.IntVar(&port, "port", 8080, "the listen port") flag.BoolVar(&server, "server", false, "tls server mode") flag.BoolVar(&client, "client", false, "tls client mode") flag.StringVar(&cert, "cert", "", "the certificate file") flag.StringVar(&key, "key", "", "the private key") iniflags.Parse() if remote == "" { log.Fatal("please use --remote to special the server") } if server { if cert == "" || key == "" { log.Fatal("in server mode, you must special the certificate and private key") } server_main() return } if client { local_main() return } log.Fatal("please use --server or --client to special a work mode") }
func Parse() *Args { args := &Args{BootConfig: cluster.BootConfig{}} flag.StringVar(&args.BootConfig.User, "user", "ubuntu", "user to run QEMU as") flag.StringVar(&args.BootConfig.Kernel, "kernel", "rootfs/vmlinuz", "path to the Linux binary") flag.StringVar(&args.BootConfig.Network, "network", "10.52.0.1/24", "the network to use for vms") flag.StringVar(&args.BootConfig.NatIface, "nat", "eth0", "the interface to provide NAT to vms") flag.StringVar(&args.RootFS, "rootfs", "rootfs/rootfs.img", "filesystem image to use with QEMU") flag.StringVar(&args.CLI, "cli", "flynn", "path to flynn-cli binary") flag.StringVar(&args.Flynnrc, "flynnrc", "", "path to flynnrc file") flag.StringVar(&args.RouterIP, "router-ip", "127.0.0.1", "IP address of the router") flag.StringVar(&args.DBPath, "db", "flynn-test.db", "path to BoltDB database to store pending builds") flag.StringVar(&args.Backend, "backend", "libvirt-lxc", "the host backend to use") flag.StringVar(&args.ListenAddr, "listen", ":443", "runner https listen address") flag.StringVar(&args.TLSCert, "tls-cert", "", "TLS certificate") flag.StringVar(&args.TLSKey, "tls-key", "", "TLS key") flag.StringVar(&args.AssetsDir, "assets", "runner/assets", "path to the runner assets dir") flag.StringVar(&args.Run, "run", "", "regular expression selecting which tests and/or suites to run") flag.BoolVar(&args.Build, "build", true, "build Flynn") flag.BoolVar(&args.Debug, "debug", false, "enable debug output") flag.BoolVar(&args.Kill, "kill", true, "kill the cluster after running the tests") flag.BoolVar(&args.KeepRootFS, "keep-rootfs", false, "don't remove the rootfs which was built to run the tests") flag.Parse() return args }
func init() { flag.BoolVar(&mainInstance.flags.verbose, "verbose", false, "Add verbose log to stderr") flag.StringVar(&mainInstance.flags.verboseFile, "verbosefile", "", "Will verbose log to a filename rather than stderr") flag.IntVar(&mainInstance.flags.chunkSize, "chunksize", 250, "size to chunk xargs into") flag.StringVar(&mainInstance.flags.filenamePrefix, "filename_prefix", "", "Prefix to append to all generated files") flag.BoolVar(&mainInstance.flags.forceAbs, "abs", false, "will force abs paths for ... dirs") }
func main() { var ( showVersion bool ) flag.BoolVar(&showVersion, "v", false, "show version") flag.BoolVar(&showVersion, "version", false, "show version") flag.Parse() if showVersion { fmt.Println("version:", version) fmt.Println("build:", buildDate) checkLatest(version) return } log.Println("stretcher version:", version) stretcher.Init() err := stretcher.Run() if err != nil { log.Println(err) if os.Getenv("CONSUL_INDEX") != "" { // ensure exit 0 when running under `consul watch` return } else { os.Exit(1) } } }
func parse() params { var p params flag.BoolVar(&p.showHelp, "help", false, "Show this brief help listing") flag.BoolVar(&p.showVersion, "version", false, "Report the version info") flag.BoolVar(&p.verbose, "verbose", false, "Show a bit more runtime debugging") flag.BoolVar(&p.quiet, "quiet", false, "Exit quietly (and with success) if locked") flag.StringVar(&p.lockFilename, "lockfile", "", "File for lock") flag.BoolVar(&p.wait, "wait", false, "Wait for lockfile to appear (else exit on lock)") flag.IntVar(&p.sleep, "sleep", 2, "Sleep for <T> seconds on each wait loop") flag.IntVar(&p.retries, "retries", 5, "Attempts <N> retries in each wait loop") flag.IntVar(&p.maxtime, "maxtime", 10, "Wait for at most <T> seconds for a lock, then exit") flag.Parse() p.commandInfo = flag.Args() if p.showHelp || len(p.commandInfo) == 0 { showHelp() os.Exit(1) } if p.showVersion { showVersion() os.Exit(1) } if p.lockFilename == "" { fmt.Println("--lockfile option can't be empty") os.Exit(1) } return p }
func init() { flag.BoolVar(&isVerbose, "v", false, "") flag.BoolVar(&isVerbose, "verbose", false, "") flag.Usage = func() { fmt.Println(path.Base(os.Args[0]), "- Print DNSPOD table changes") fmt.Println() fmt.Println("Options:") fmt.Println(" -v, --verbose Show more output") fmt.Println() fmt.Println("Source: https://github.com/caiguanhao/dnspodd") } flag.Parse() githubClient = github.NewClient(oauth2.NewClient(oauth2.NoContext, oauth2.StaticTokenSource( &oauth2.Token{AccessToken: string(GITHUB_TOKEN)}, ))) if PROXY_URL != "" { proxy, err := url.Parse(PROXY_URL) if err == nil { http.DefaultTransport = &http.Transport{ Proxy: func(req *http.Request) (*url.URL, error) { if req.URL.Host == "api.github.com" { return proxy, nil } return nil, nil }, } } } }
func main() { hd, err := findHomeDir() if err != nil { log.Fatalf("Couldn't find home dir: %v", err) } pd := filepath.Join(hd, ".rad", "sad-packs") flag.StringVar(&config.packDir, "packdir", pd, "Path where packages will be installed") flag.StringVar(&config.sapAddr, "sapaddr", "geller.io:3025", "Addr where sap serves") flag.StringVar(&config.addr, "addr", "localhost:3024", "Addr where sad should serve") flag.BoolVar(&config.readOnly, "readonly", false, "Whether to allow modifications of installed packs.") flag.BoolVar(&config.devMode, "devmode", false, "Whether to run in dev mode.") flag.Parse() pd, err = filepath.Abs(config.packDir) if err != nil { log.Fatalf("Can't find absolute path for %v: %v\n", config.packDir, err) } config.packDir = pd setupGlobals() loadInstalled() registerBuildVersion() registerAssets() go waitAndOpenUrl("http://" + config.addr) serve(config.addr) }
func main() { flag.BoolVar(&fake, "n", false, "If true, don't actually do anything") flag.BoolVar(&verbose, "v", false, "Provide verbose output") flag.Var(&ignorePrefixes, "ignore", "Package prefix to ignore. Can be given multiple times.") flag.Parse() gopaths := filepath.SplitList(os.Getenv("GOPATH")) if len(gopaths) == 0 { log.Fatal("GOPATH must be set") } pkgName := flag.Arg(0) if pkgName == "" { log.Fatal("need a package name") } dest := flag.Arg(1) if dest == "" { log.Fatal("need a destination path") } ignorePrefixes = append(ignorePrefixes, pkgName) ignorePrefixes = append(ignorePrefixes, dest) rewrites = make(map[string]string) visited = make(map[string]bool) err := vendorize(pkgName, chooseGOPATH(gopaths, dest), dest) if err != nil { log.Fatal(err) } }
func main() { var targets strslice var showVersion bool flag.Var(&targets, "t", "target hostname") flag.BoolVar(&addPrefix, "p", false, "add hostname to line prefix") flag.BoolVar(&showVersion, "v", false, "show version") flag.Parse() if showVersion { fmt.Println("version:", version) return } command := flag.Args() if len(command) < 1 { flag.PrintDefaults() return } wg := &sync.WaitGroup{} for _, host := range targets { wg.Add(1) go func(h string) { remoteCommand(h, command) wg.Done() }(host) } wg.Wait() }