func main() { flag.Parse() if len(flag.Args()) == 0 { year := int(time.Now().Year()) month := int(time.Now().Month()) calendar(month, year) } else if len(flag.Args()) == 1 { year, err := strconv.Atoi(flag.Arg(0)) if err != nil { log.Fatal(err) } for month := 1; month <= 12; month++ { calendar(month, year) fmt.Println() } } else if len(flag.Args()) == 2 { month, err := strconv.Atoi(flag.Arg(0)) if err != nil { log.Fatal(err) } year, err := strconv.Atoi(flag.Arg(1)) if err != nil { log.Fatal(err) } calendar(month, year) } }
func main() { flag.Parse() switch { case *multiple != "": // ugly things about to happen... if flag.NArg() > 0 { // means it's using -a fmt.Print(performBasename(*multiple, *suffix, *zero)) // pick first from -a for _, v := range flag.Args() { // the rest... fmt.Print(performBasename(v, *suffix, *zero)) } } else { // means it's using --multiple, split em all for _, v := range strings.Split(*multiple, " ") { fmt.Print(performBasename(v, *suffix, *zero)) } } case *suffix != "": //implies -a fmt.Print(performBasename(flag.Args()[0], *suffix, *zero)) default: name := flag.Args()[0] suffix := "" if flag.NArg() == 2 { suffix = flag.Args()[1] } fmt.Print(performBasename(name, suffix, *zero)) } }
func main() { flag.Usage = func() { fmt.Fprintf(os.Stderr, "%s", Help) os.Exit(1) } flag.Parse() if *version { fmt.Printf("%s", Version) os.Exit(0) } if *unset != "" { os.Unsetenv(*unset) } cmd := new(exec.Cmd) cmd.Env = env // Check for "-" as an argument, because it means the same as "-i" if flag.Arg(0) == "-" { cmd.Env = make([]string, 0) } for i, arg := range flag.Args() { if strings.Index(arg, delim) > 0 { cmd.Env = append(cmd.Env, arg) } else if arg != "-" { if *nullEol { fatal.Fatalln("cannot specify --null (-0) with command") } cmd.Path = arg cmd.Args = append(cmd.Args, flag.Args()[i:]...) cmd.Stdin = os.Stdin cmd.Stdout = os.Stdout cmd.Stderr = os.Stderr err := execvp(cmd) if err != nil { fatal.Fatalln(err) } return } i++ } eol := '\n' if *nullEol { eol = '\x00' } for _, e := range env { fmt.Printf("%s%c", e, eol) } return }
func main() { var widthstr string flag.StringVarP(&widthstr, "width", "w", "100%", "Output width. Supports column count, percentage and decimals.") flag.Usage = usage flag.Parse() if len(flag.Args()) == 0 { flag.Usage() os.Exit(1) } width := getColumns(widthstr) - 1 // -1 for the reset column for _, fpath := range flag.Args() { im := aimg.NewImage(width) handleErr(im.ParseFile(fpath)) if terminal.IsTerminal(os.Stdout) { fmt.Print(im.BlankReset()) } im.WriteTo(os.Stdout) w, h := im.ActualSize() fmt.Println("File:", filepath.Base(fpath), "size:", w, "x", h) } }
func main() { flag.Usage = func() { fmt.Fprintf(os.Stderr, "%s", Help) os.Exit(1) } flag.Parse() if *version { fmt.Fprintf(os.Stdout, "%s", Version) os.Exit(0) } if len(flag.Args()) > 0 { for i := 0; i < len(flag.Args()); i++ { filename := flag.Arg(i) _, err := os.Stat(filename) if err == nil { now := time.Now() os.Chtimes(filename, now, now) } else if !(*nocreate) { f, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE, 0644) f.Close() if err != nil { log.Fatal(err) } } } } }
func main() { flag.Usage = func() { fmt.Fprintf(os.Stderr, "%s", Help) os.Exit(1) } flag.Parse() switch { case *version: fmt.Fprintf(os.Stdout, "%s", Version) os.Exit(0) case *wrap < 0: log.Fatalf("invalid wrap size: %d", *wrap) default: if len(flag.Args()) == 0 { readAndHandle(os.Stdin, decode, ignore, wrap) } else { for i := 0; i < len(flag.Args()); i++ { file, err := os.Open(flag.Args()[i]) if err != nil { log.Fatal(err) } readAndHandle(file, decode, ignore, wrap) } } } }
/* check the md5sum for all of files from cmdline */ func check_md5sum() bool { if len(flag.Args()) == 0 || (len(flag.Args()) == 1 && flag.Args()[0] == "-") { /* Known Issue: Ctrl+Z on cmd can not trigger io.EOF */ return check_md5sum_f(os.Stdin) } has_err := false for i := 0; i < len(flag.Args()); i++ { //output_e("use file: %s\n", flag.Args()[i]) file, err := os.Open(flag.Args()[i]) if err != nil { output_e("md5sum: %s\n", err.Error()) has_err = true continue } if b := check_md5sum_f(file); !b { has_err = true } file.Close() } return !has_err }
func main() { flag.Parse() if len(flag.Args()) == 0 { log.Fatal("need query") } args := flag.Args() if !*retweets { args = append(args, "-rt") } search := url.QueryEscape(strings.Join(args, " ")) query := fmt.Sprintf("%s?q=%s&count=%d", twSearchBase, search, *resnum) for { tw, err := twitquery(query) if err != nil { log.Fatal(err) } r := tw.Statuses for i := range r { if *reverse { fmt.Println(r[i]) } else { fmt.Println(r[len(r)-i-1]) } } if !*follow { // if not in follow mode we are done break } query = twSearchBase + tw.Meta.RefreshUrl time.Sleep(*followDelay) } }
func main() { flag.Usage = func() { fmt.Fprintf(os.Stderr, "%s", Help) os.Exit(1) } flag.Parse() switch { case *version: fmt.Fprintf(os.Stdout, "%s", Version) os.Exit(0) case *multiple: for _, v := range flag.Args() { dir := baseName(v, *suffix, *zero) fmt.Print(dir) } case *suffix != "": // Implies --multiple/-a for _, v := range flag.Args() { dir := baseName(v, *suffix, *zero) fmt.Print(dir) } default: dir := baseName(flag.Args()[0], *suffix, *zero) fmt.Print(dir) } }
func parseFlags() (*cmdConfig, *busltee.Config, error) { publisherConf := &busltee.Config{} cmdConf := &cmdConfig{} cmdConf.RollbarEnvironment = os.Getenv("ROLLBAR_ENVIRONMENT") cmdConf.RollbarToken = os.Getenv("ROLLBAR_TOKEN") // Connection related flags flag.BoolVarP(&publisherConf.Insecure, "insecure", "k", false, "allows insecure SSL connections") flag.IntVar(&publisherConf.Retry, "retry", 5, "max retries for connect timeout errors") flag.IntVar(&publisherConf.StreamRetry, "stream-retry", 60, "max retries for streamer disconnections") flag.Float64Var(&publisherConf.Timeout, "connect-timeout", 1, "max number of seconds to connect to busl URL") // Logging related flags flag.StringVar(&publisherConf.LogPrefix, "log-prefix", "", "log prefix") flag.StringVar(&publisherConf.LogFile, "log-file", "", "log file") flag.StringVar(&publisherConf.RequestID, "request-id", "", "request id") if flag.Parse(); len(flag.Args()) < 2 { return nil, nil, errors.New("insufficient args") } publisherConf.URL = flag.Arg(0) publisherConf.Args = flag.Args()[1:] return cmdConf, publisherConf, nil }
// The following command `remotectl -profile test.sh -list` would result in // len(args) <= i returning false. func parseArgs(args []string) (query, cmd string) { i := flag.NFlag() + 1 cmd = strings.Join(flag.Args(), " ") if len(args) > i && args[i] != "--" { query = flag.Args()[0] cmd = strings.Join(flag.Args()[1:], " ") } return query, cmd }
func main() { verbose := flag.BoolP("verbose", "v", false, "Verbose mode") flag.Parse() logger = initLogger(*verbose) switch { case len(flag.Args()) == 0: Serve() case len(flag.Args()) >= 1: RunCommand(flag.Arg(0), flag.Args()[1:]) default: printUsage() os.Exit(2) } }
// Parse the command from the command line func ParseCommand() (*Command, []string) { args := pflag.Args() if len(args) < 1 { fatal("No command supplied\n") } cmd := strings.ToLower(args[0]) args = args[1:] // Find the command doing a prefix match var command *Command for i := range Commands { trialCommand := &Commands[i] // exact command name found - use that if trialCommand.Name == cmd { command = trialCommand break } else if strings.HasPrefix(trialCommand.Name, cmd) { if command != nil { fs.Stats.Error() log.Fatalf("Not unique - matches multiple commands %q", cmd) } command = trialCommand } } if command == nil { fs.Stats.Error() log.Fatalf("Unknown command %q", cmd) } if command.Run == nil { syntaxError() } command.checkArgs(args) return command, args }
func main() { flag.Usage = func() { fmt.Fprintf(os.Stderr, "%s", Help) os.Exit(1) } flag.Parse() if *version { fmt.Printf("%s\n", Version) os.Exit(0) } args := flag.Args() if flag.NArg() == 0 { args = []string{"y"} } for { for i, arg := range args { os.Stdout.WriteString(arg) if i == len(args)-1 { os.Stdout.Write(LineFeed) } else { os.Stdout.Write(Space) } } } }
func parseArgs() args { result := args{} pflag.Usage = usage pflag.BoolVarP(&result.options.KeepGoing, "keep-going", "k", false, "") pflag.BoolVar(&result.options.CheckAll, "check-all", false, "") pflag.StringVarP(&result.scriptFile, "file", "f", "", "") verbose := pflag.BoolP("verbose", "v", false, "") quiet := pflag.BoolP("quiet", "q", false, "") topics := pflag.String("debug", "", "") pflag.Parse() if *topics != "" { result.debugTopics = strings.Split(*topics, ",") } // argh: really, we just want a callback for each occurence of -q // or -v, which decrements or increments verbosity if *quiet { result.verbosity = 0 } else if *verbose { result.verbosity = 2 } else { result.verbosity = 1 } result.options.Targets = pflag.Args() return result }
func main() { flag.Usage = func() { fmt.Fprintf(os.Stderr, "fsping: check responsiveness of mounted filesystems\n\n") flag.PrintDefaults() } flag.Parse() fsnum := 0 fsch := make(chan fs_t) fsmap := readmounts() args := flag.Args() // if extra args were specified keep only filesystems listed if len(args) > 0 { L: for fs, _ := range fsmap { for _, a := range args { if fs == a { continue L } } delete(fsmap, fs) } } // fire them up for _, fs := range fsmap { fsnum += 1 // fire off a goroutine for each mounted nfs // filesystem. fsch is used for completion // notifications go statit(fs, fsch) } // timeout ticker tick := time.Tick(*timeout) // collect results for fsnum > 0 { select { case fs := <-fsch: if *verbose || fs.err != nil { fmt.Println(fs) } fsmap[fs.path] = fs fsnum -= 1 case <-tick: // ticker has kicked in, print timeout // messages for filesystems that haven't // finished for _, fs := range fsmap { if !*quiet && !fs.done { fmt.Println(fs) } } os.Exit(1) } } }
func main() { logmgr.SetOutput(os.Stderr) if flagVerbose { logmgr.SetLevel(logrus.DebugLevel) } else { logmgr.SetLevel(logrus.InfoLevel) } flag.Parse() conf := &config.BuildConfig{ BuildDir: flagBuildDir, OutputDir: flag.Arg(0), Platform: flagPlatform, Arch: flagArch, } recipes := flag.Args()[1:] // Special case - passing a single 'all' means build all binaries. if len(recipes) == 1 && recipes[0] == "all" { recipes = builder.AllBinaries() } log.WithField("recipes", recipes).Info("Starting build") err := builder.Build(recipes, conf) if err != nil { log.WithField("err", err).Error("Error building") } else { log.Info("Successfully built") } }
func Go() { smtpAddr := "localhost:1025" goflag := false for _, g := range os.Args[1:] { if strings.HasPrefix(g, "-") && !strings.HasPrefix(g, "--") { if strings.HasPrefix(g, "-from ") || strings.HasPrefix(g, "-from=") || strings.HasPrefix(g, "-smtp-addr ") || strings.HasPrefix(g, "-smtp-addr=") { goflag = true break } } } host, err := os.Hostname() if err != nil { host = "localhost" } username := "******" user, err := user.Current() if err == nil && user != nil && len(user.Username) > 0 { username = user.Username } fromAddr := username + "@" + host var recip []string if goflag { flag.StringVar(&smtpAddr, "smtp-addr", smtpAddr, "SMTP server address") flag.StringVar(&fromAddr, "from", fromAddr, "SMTP sender") flag.Parse() recip = flag.Args() } else { pflag.StringVar(&smtpAddr, "smtp-addr", smtpAddr, "SMTP server address") pflag.StringVarP(&fromAddr, "from", "f", fromAddr, "SMTP sender") pflag.Parse() recip = pflag.Args() } if len(recip) == 0 { fmt.Fprintln(os.Stderr, "missing recipient") os.Exit(10) } body, err := ioutil.ReadAll(os.Stdin) if err != nil { fmt.Fprintln(os.Stderr, "error reading stdin") os.Exit(11) } err = smtp.SendMail(smtpAddr, nil, fromAddr, recip, body) if err != nil { fmt.Fprintln(os.Stderr, "error sending mail") log.Fatal(err) } }
func (cm *ConfigManager) parseFlags() { pflag.StringVarP(&cm.Flags.ConfigFile, "configfile", "c", DefaultConfigFile, "Path to config") pflag.StringVarP(&cm.Flags.DestHost, "dest-host", "d", "", "Destination syslog hostname or IP") pflag.IntVarP(&cm.Flags.DestPort, "dest-port", "p", 0, "Destination syslog port") if utils.CanDaemonize { pflag.BoolVarP(&cm.Flags.NoDaemonize, "no-detach", "D", false, "Don't daemonize and detach from the terminal") } else { cm.Flags.NoDaemonize = true } pflag.StringVarP(&cm.Flags.Facility, "facility", "f", "user", "Facility") pflag.StringVar(&cm.Flags.Hostname, "hostname", "", "Local hostname to send from") pflag.StringVar(&cm.Flags.PidFile, "pid-file", "", "Location of the PID file") // --parse-syslog pflag.StringVarP(&cm.Flags.Severity, "severity", "s", "notice", "Severity") // --strip-color pflag.BoolVar(&cm.Flags.UseTCP, "tcp", false, "Connect via TCP (no TLS)") pflag.BoolVar(&cm.Flags.UseTLS, "tls", false, "Connect via TCP with TLS") pflag.BoolVar(&cm.Flags.Poll, "poll", false, "Detect changes by polling instead of inotify") pflag.Var(&cm.Flags.RefreshInterval, "new-file-check-interval", "How often to check for new files") _ = pflag.Bool("no-eventmachine-tail", false, "No action, provided for backwards compatibility") _ = pflag.Bool("eventmachine-tail", false, "No action, provided for backwards compatibility") pflag.StringVar(&cm.Flags.DebugLogFile, "debug-log-cfg", "", "the debug log file") pflag.StringVar(&cm.Flags.LogLevels, "log", "<root>=INFO", "\"logging configuration <root>=INFO;first=TRACE\"") pflag.Parse() cm.FlagFiles = pflag.Args() }
func main() { var config Config flag.BoolVar(&DEBUG, "debug", false, "enable debug logging") flag.BoolVar(&QUIET, "quiet", false, "disable output") flag.StringVar(&config.FieldSep, "csv-fields-terminated-by", "\t", "field separator") flag.StringVar(&config.RowSep, "csv-records-terminated-by", "\n", "row separator") flag.StringVar(&config.NullString, "csv-null-string", "\\N", "output string for NULL values") flag.BoolVar(&config.DateEpoch, "epoch", true, "output datetime as epoch instead of RFC3339") defaults_file := flag.String("defaults-file", "my.cnf", "defaults file") defaults_group_suffix := flag.String("defaults-group-suffix", "", "defaults group suffix") format := flag.String("format", "json", "output format 'json' or 'csv'") flag.Usage = func() { fmt.Fprintf(os.Stderr, "Usage: mysqlcsvdump [options] database table > output.json\n\n") fmt.Fprintf(os.Stderr, "Reads connection info from ./my.cnf. Use '-' for table to send query in stdin\n\n") flag.PrintDefaults() } flag.Parse() args := flag.Args() if len(args) < 2 { flag.Usage() os.Exit(1) } dsn := getDSN(*defaults_file, "client"+*defaults_group_suffix, args[0]) rows := getRows(dsn, args[1]) if *format == "json" { NewJsonWriter(&config).WriteRows(rows) } else { NewCsvWriter(&config).WriteRows(rows) } }
func calculate(s *Stats) { if len(flag.Args()) == 0 { parse("<stdin>", os.Stdin, s) } for _, filename := range flag.Args() { if filename == "-" { parse("<stdin>", os.Stdin, s) continue } file, err := os.Open(filename) if err != nil { fail("%s\n", err.Error()) } parse(filename, file, s) } }
func main() { path := "" pflag.StringVarP(&path, "tsconfig", "t", "tsconfig.json", "your tsconfig.json path") pflag.Parse() if err := Update(path, pflag.Args()); err != nil { panic(err) } }
func main() { flag.Parse() if len(flag.Args()) < 1 { flag.Usage() os.Exit(-1) } config = NewConfig(flag.Args()[0]) r := mux.NewRouter() r.HandleFunc("/lambda", lambdaHandler) r.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) { w.Write([]byte("OK")) }) loggedRouter := handlers.LoggingHandler(os.Stdout, r) log.Fatal(http.ListenAndServe(":8080", loggedRouter)) }
func main() { bFlag := flag.StringP("body-numbering", "b", "t", "style") flag.Parse() if len(flag.Args()) == 0 { bytes, _ := ioutil.ReadAll(os.Stdin) lines := strings.Split(string(bytes), "\n") linecount := 0 for i := 0; i < len(lines)-1; i++ { if *bFlag == "t" { if len(strings.TrimSpace(lines[i])) > 0 { linecount++ fmt.Printf("%6d %s\n", linecount, lines[i]) } else { fmt.Println(lines[i]) } } else { linecount++ fmt.Printf("%6d %s\n", linecount, lines[i]) } } } else if len(flag.Args()) > 0 { linecount := 0 for j := 0; j < len(flag.Args()); j++ { bytes, _ := ioutil.ReadFile(flag.Arg(j)) lines := strings.Split(string(bytes), "\n") for i := 0; i < len(lines)-1; i++ { if *bFlag == "t" { if len(strings.TrimSpace(lines[i])) > 0 { linecount++ fmt.Printf("%6d %s\n", linecount, lines[i]) } else { fmt.Println(lines[i]) } } else { linecount++ fmt.Printf("%6d %s\n", linecount, lines[i]) } } } } }
/* generate the md5sum for all of files from cmdline */ func gen_md5sum() bool { if len(flag.Args()) == 0 || (len(flag.Args()) == 1 && flag.Args()[0] == "-") { /* Known Issue: Ctrl+Z on cmd can not trigger io.EOF */ sum := calc_md5sum(os.Stdin) fmt.Fprintf(os.Stdout, "%s *%s\n", sum, "-") return true } has_error := false for i := 0; i < len(flag.Args()); i++ { fn := flag.Args()[i] /* extends file lists when filename contains '*' */ filenames, _ := filepath.Glob(fn) if filenames == nil { filenames = append(filenames, fn) } for _, f := range filenames { file, err := os.Open(f) if err != nil { has_error = true fmt.Fprintf(os.Stderr, "md5sum: %s\n", err.Error()) continue } sum := calc_md5sum(file) file.Close() if sum != "" { has_error = true fmt.Fprintf(os.Stdout, "%s *%s\n", sum, f) } } } return !has_error }
func main() { cFlag := flag.BoolP("no-create", "c", false, "do not create file") flag.Parse() if len(flag.Args()) > 0 { for i := 0; i < len(flag.Args()); i++ { filename := flag.Arg(i) _, err := os.Stat(filename) if err == nil { now := time.Now() os.Chtimes(filename, now, now) } else { if !(*cFlag) { f, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE, 0644) f.Close() if err != nil { log.Fatal(err) } } } } } }
func main() { flag.Parse() for _, fname := range flag.Args() { if flagVerbose { log.Println("Checking file:", fname) } if err := check(fname); err != nil { log.Printf("Error checking file:", err) } } }
func main() { cfg, err := ReadConfig() if err != nil { log.Fatalf("Coult not read config: %v", err) } pflag.Usage = func() { fmt.Fprintln(os.Stderr, "Usage: slackcat [-c #channel] [-n name] [message]") } channel := pflag.StringP("channel", "c", cfg.Channel, "channel") name := pflag.StringP("name", "n", username(), "name") pflag.Parse() // was there a message on the command line? If so use it. args := pflag.Args() if len(args) > 0 { msg := SlackMsg{ Channel: *channel, Username: *name, Parse: "full", Text: strings.Join(args, " "), } err = msg.Post(cfg.WebhookUrl) if err != nil { log.Fatalf("Post failed: %v", err) } os.Exit(0) } // ...Otherwise scan stdin scanner := bufio.NewScanner(os.Stdin) for scanner.Scan() { msg := SlackMsg{ Channel: *channel, Username: *name, Parse: "full", Text: scanner.Text(), } err = msg.Post(cfg.WebhookUrl) if err != nil { log.Fatalf("Post failed: %v", err) } } if err := scanner.Err(); err != nil { log.Fatalf("Error reading: %v", err) } }
func main() { flagAppend := flag.BoolP("append", "a", false, "append to file") flag.Parse() bytes, _ := ioutil.ReadAll(os.Stdin) for i := 0; i < len(flag.Args()); i++ { if *flagAppend { f, err := os.OpenFile(flag.Args()[i], os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0644) if err != nil { log.Fatal(err) } f.Write(bytes) f.Close() } else { f, err := os.OpenFile(flag.Args()[i], os.O_WRONLY|os.O_CREATE, 0644) if err != nil { log.Fatal(err) } f.Write(bytes) f.Close() } } fmt.Printf("%s", string(bytes)) }
func main() { pflag.Usage = func() { fmt.Fprintln(os.Stderr, "Usage: hipcat [-r room] [message]") } cfg := Config{} err := cfg.Load() if err != nil { log.Fatalf("Failed to load config: %v", err) } cfg.bindFlags() pflag.Parse() if cfg.Room == "" { log.Println("Could not find a Room in HIPCAT_ROOM, /etc/hipcat.conf, /.hipcat.conf, ./hipcat.conf or passed with -r") pflag.Usage() os.Exit(1) } // was there a message on the command line? If so use it. args := pflag.Args() if len(args) > 0 { msg := RoomMessage{ Message: strings.Join(args, " "), } err = msg.Post(&cfg) if err != nil { log.Fatalf("Post failed: %v", err) } return } // ...Otherwise scan stdin scanner := bufio.NewScanner(os.Stdin) for scanner.Scan() { msg := RoomMessage{ Message: scanner.Text(), } err = msg.Post(&cfg) if err != nil { log.Fatalf("Post failed: %v", err) } } if err = scanner.Err(); err != nil { log.Fatalf("Error reading: %v", err) } }