func main() { flag.Usage = Usage flag.Parse() if *showVersion { fmt.Println("goobar", Version) os.Exit(0) } if *listenAddress == "" { fmt.Fprintln(os.Stderr, "you must supply an address to listen on") flag.Usage() os.Exit(1) } if *memcacheBackend == "" { fmt.Fprintln(os.Stderr, "you must specify a memcached backend") flag.Usage() os.Exit(1) } log.SetPrefix("goobar ") log.SetFlags(log.Ldate | log.Lmicroseconds) tsock, err := net.Listen("tcp", *listenAddress) if err != nil { panic(err) } server.Main(tsock) }
func main() { flag.Usage = usage flag.Parse() cachingHTTPClient = util.CachingHttpClient() if *tokenFlag == "" || cachingHTTPClient == nil { flag.Usage() return } ds = clientFlags.CreateDataset() if ds == nil { flag.Usage() return } defer ds.Store().Close() if err := clientFlags.CreateProgressFile(); err != nil { fmt.Println(err) } else { defer clientFlags.CloseProgressFile() } token := oauth2.Token{AccessToken: *tokenFlag} authHTTPClient = oauth2.NewClient(oauth2.NoContext, oauth2.StaticTokenSource(&token)) start = time.Now() var user = getUser() printStats(user) userRef := ds.Store().WriteValue(user) fmt.Printf("userRef: %s\n", userRef.TargetRef()) _, err := ds.Commit(userRef) d.Exp.NoError(err) }
func main() { flag.Usage = func() { fmt.Fprintf(os.Stderr, "Usage: %s size\n", os.Args[0]) fmt.Fprintf(os.Stderr, " Must specify an odd integer for size\n") flag.PrintDefaults() } flag.Parse() if flag.NArg() != 1 { flag.Usage() return } size, err := strconv.Atoi(flag.Arg(0)) if err != nil { flag.Usage() return } square, err := magicsquare.MagicSquare(size) if err != nil { flag.Usage() return } for _, row := range square { for _, col := range row { fmt.Printf("%5v", col) } fmt.Printf("\n") } }
func cmdCreateTeam() { if flagCmdCreateTeam { if len(flagTeamName) == 0 { fmt.Fprintln(os.Stderr, "flag needs an argument: -team_name") flag.Usage() os.Exit(1) } if len(flagEmail) == 0 { fmt.Fprintln(os.Stderr, "flag needs an argument: -email") flag.Usage() os.Exit(1) } c := &api.Context{} c.RequestId = model.NewId() c.IpAddress = "cmd_line" team := &model.Team{} team.DisplayName = flagTeamName team.Name = flagTeamName team.Email = flagEmail team.Type = model.TEAM_INVITE api.CreateTeam(c, team) if c.Err != nil { if c.Err.Message != "A team with that domain already exists" { l4g.Error("%v", c.Err) flushLogAndExit(1) } } os.Exit(0) } }
// Remember Exit(0) is success, Exit(1) is failure func main() { flag.Var(&slaveList, "control", "list of ip:port addresses to control") flag.Parse() if len(*testUrl) == 0 { flag.Usage() os.Exit(1) } if len(slaveList) > 0 && *listen != 0 { fmt.Fprintf(os.Stderr, "You can't have both --listen and --control flags") flag.Usage() os.Exit(1) } rand.Seed(time.Now().Unix()) // set up logging logWriter, err := os.OpenFile(*logFile, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666) if err != nil { println(err) os.Exit(1) } log.SetOutput(logWriter) TRACE = log.New(ioutil.Discard, "TRACE: ", log.Ldate|log.Ltime|log.Lshortfile) INFO = log.New(logWriter, "INFO: ", log.Ldate|log.Ltime|log.Lshortfile) ERROR = log.New(logWriter, "ERROR: ", log.Ldate|log.Ltime|log.Lshortfile) INFO.Println("beginning run") os.Exit(realMain()) }
func main() { token := os.Getenv("GITHUB_ACCESS_TOKEN") client := github.NewClient(token) flag.Usage = func() { fmt.Print(usage) } flag.Parse() args := flag.Args() if len(args) == 0 { flag.Usage() os.Exit(1) } switch args[0] { case "create": create(client, args[1:]) case "show": show(client, args[1:]) case "search": search(client, args[1:]) case "edit": edit(client, args[1:]) case "close": close(client, args[1:]) case "reopen": reopen(client, args[1:]) default: flag.Usage() os.Exit(1) } }
func commands(args []string) { var cfg config var err error fmt.Println(args) if len(args) == 0 { flag.Usage() return } switch args[0] { case "new": path := args[1] if path == "" { flag.Usage() os.Exit(1) } err = cfg.New(path) checkFatal(err) case "build": err = cfg.load("_config.yml") checkFatal(err) err = cfg.Build() checkFatal(err) case "serve": err = cfg.load("_config.yml") checkFatal(err) err = cfg.Serve() checkFatal(err) default: flag.Usage() } }
func init() { flag.StringVar(&in, "in", "", "BAM file to be processed.") flag.StringVar(&annot, "annot", "", "file name of a GFF file containing annotations.") flag.Float64Var(&thresh, "thresh", 1, "log score threshold for inclusion of feature.") flag.Var(&classes, "class", "comma separated set of annotation classes to analyse.") flag.BoolVar(&pretty, "pretty", true, "outfile JSON data indented.") flag.IntVar(&minLength, "min", 20, "minimum length read considered.") flag.IntVar(&maxLength, "max", 35, "maximum length read considered.") flag.IntVar(&minId, "minid", 90, "minimum percentage identity for mapped bases.") flag.IntVar(&minQ, "minQ", 20, "minimum per-base sequence quality.") flag.Float64Var(&minAvQ, "minAvQ", 30, "minimum average per-base sequence quality.") flag.IntVar(&mapQ, "mapQ", 0, "minimum mapping quality [0, 255).") flag.IntVar(&binLength, "bin", 1e7, "bin length.") help := flag.Bool("help", false, "output this usage message.") flag.Parse() mapQb = byte(mapQ) if *help { flag.Usage() os.Exit(0) } if in == "" || !annotOK(annot, classes) || mapQ < 0 || mapQ > 254 { flag.Usage() os.Exit(1) } }
func main() { help := flag.Bool("help", false, "show this message") inFile := flag.String("in", "", "input filename (required)") outFile := flag.String("out", "", "output filename (stdout if omitted)") flag.Parse() if *help { flag.Usage() os.Exit(0) } if len(*inFile) == 0 { flag.Usage() os.Exit(0) } pr := codejam.NewProblem(*inFile, *outFile) numTestCases := pr.ReadInt() if numTestCases < 1 { panic(fmt.Errorf("no testcases available")) } for testIndex := 1; testIndex <= numTestCases; testIndex++ { d := parse(pr, testIndex) solve(pr, d) } pr.Close() }
func cmdAssignRole() { if flagCmdAssignRole { if len(flagEmail) == 0 { fmt.Fprintln(os.Stderr, "flag needs an argument: -email") flag.Usage() os.Exit(1) } if !model.IsValidUserRoles(flagRole) { fmt.Fprintln(os.Stderr, "flag invalid argument: -role") flag.Usage() os.Exit(1) } c := getMockContext() var user *model.User if result := <-api.Srv.Store.User().GetByEmail(flagEmail); result.Err != nil { l4g.Error("%v", result.Err) flushLogAndExit(1) } else { user = result.Data.(*model.User) } if !user.IsInRole(flagRole) { api.UpdateUserRoles(c, user, flagRole) } os.Exit(0) } }
func realMain() int { flag.Parse() if help { flag.Usage() fmt.Fprint(os.Stderr, "Flags:\n") fmt.Fprint(os.Stderr, "\n") flag.PrintDefaults() return 0 } worker.files = flag.Args() // this is the list of files if len(worker.files) == 0 { flag.Usage() return 1 } err := worker.Work() if err != nil { if err == ErrProcess { return len(worker.errs) // the number of operations (files) that errored is the return code } return 1 } return 0 }
func cmdCreateTeam() { if flagCmdCreateTeam { if len(flagTeamName) == 0 { fmt.Fprintln(os.Stderr, "flag needs an argument: -team_name") flag.Usage() os.Exit(1) } if len(flagEmail) == 0 { fmt.Fprintln(os.Stderr, "flag needs an argument: -email") flag.Usage() os.Exit(1) } c := getMockContext() team := &model.Team{} team.DisplayName = flagTeamName team.Name = flagTeamName team.Email = flagEmail team.Type = model.TEAM_OPEN api.CreateTeam(c, team) if c.Err != nil { if c.Err.Id != "store.sql_team.save.domain_exists.app_error" { l4g.Error("%v", c.Err) flushLogAndExit(1) } } os.Exit(0) } }
func main() { var ihelp *bool = flag.Bool("h", false, "Print help information") var iport *int = flag.Int("p", 6666, "Port number") var iverb *int = flag.Int("v", 1, "Verbosity (0-6)") var idrop *int = flag.Int("r", 0, "Network packet drop percentage") var elim *int = flag.Int("k", 5, "Epoch limit") var ems *int = flag.Int("d", 2000, "Epoch duration (millisecconds)") flag.Parse() if *ihelp { flag.Usage() os.Exit(0) } var port int = *iport if flag.NArg() > 0 { nread, _ := fmt.Sscanf(flag.Arg(0), "%d", &port) if nread != 1 { flag.Usage() os.Exit(0) } } params := &lsp12.LspParams{*elim, *ems} lsplog.SetVerbose(*iverb) lspnet.SetWriteDropPercent(*idrop) fmt.Printf("Establishing server on port %d\n", port) srv, err := lsp12.NewLspServer(port, params) if err != nil { fmt.Printf("... failed. Error message %s\n", err.Error()) } else { runserver(srv) } }
func main() { flag.Parse() if email == "" || password == "" { fmt.Println("Invalid E-Mail or Password\n") flag.Usage() os.Exit(-1) } if flag.NArg() != 2 { flag.Usage() os.Exit(-1) } imsi := flag.Arg(0) protection := flag.Arg(1) c, err := goracom.NewClient(email, password) errToExit(err) s := c.NewSubscriber() if protection == "false" { sub, err := s.EnableTerminate(imsi) errToExit(err) printSubscriber(*sub) } else { sub, err := s.DisableTerminate(imsi) errToExit(err) printSubscriber(*sub) } }
func main() { flag.Parse() if helpFlag { flag.Usage() os.Exit(0) } if len(upstreamUrl) == 0 { fmt.Println("Missing argument -upstream") flag.Usage() os.Exit(1) } if len(dataplaneUrl) == 0 { fmt.Println("Missing argument -dataplane") flag.Usage() os.Exit(1) } notifier := gbp.NewNotifier(upstreamUrl, listenSocket) if err := notifier.NotifyEndpointUp(); err != nil { fmt.Println(err) os.Exit(1) } g, err := gbp.NewServer(upstreamUrl, dataplaneUrl) if err != nil { fmt.Println(err) os.Exit(1) } gbp.Info.Printf("GBP Server listening on %s\n", listenSocket) http.ListenAndServe(listenSocket, g.Handler()) }
func main() { log.SetFlags(0) flag.Parse() // Set the data directory. if flag.NArg() == 0 { flag.Usage() log.Fatal("Data path argument required") } if *stop == 0 { flag.Usage() log.Fatal("stop commit is required") } dbpath := flag.Arg(0) client := cluster.NewLocalClient("http://"+*node, 1) meta, err := client.StreamsMetadata() if err != nil { log.Fatal(err) } err = cluster.Clear(dbpath, *stop, meta.Closed) if err != nil { log.Fatal(err) } }
func main() { flag.Parse() if email == "" || password == "" { fmt.Println("Invalid E-Mail or Password\n") flag.Usage() os.Exit(-1) } if flag.NArg()%2 == 0 { flag.Usage() os.Exit(-1) } imsi := flag.Arg(0) tags := make([]map[string]string, (flag.NArg()-1)/2) idx := 0 for i := 1; i < flag.NArg(); i += 2 { k := flag.Arg(i) v := flag.Arg(i + 1) tag := map[string]string{"tagName": k, "tagValue": v} tags[idx] = tag idx++ } fmt.Println(tags) c, err := goracom.NewClient(email, password) errToExit(err) s := c.NewSubscriber() sub, err := s.Tags(imsi, tags) errToExit(err) printSubscriber(*sub) }
func main() { create := flag.Bool("create", false, "create shares from a secret") minimum := flag.Int("minimum", 3, "minimum shares required to recreate secret") shares := flag.Int("shares", 4, "total shares to create (shares >= minimum)") secret := flag.String("secret", "Hello, World!", "secret to share") combine := flag.Bool("combine", false, "combines shares into a secret") raw := flag.String("secrets", "", "comma separated list of shared secrets") flag.Parse() if *create == *combine { flag.Usage() } else if *create { if *minimum > *shares { flag.Usage() } else { values := sssa.Create(*minimum, *shares, *secret) for i := range values { fmt.Println(values[i]) } } } else { if *raw == "" { flag.Usage() } else { secrets := strings.Split(*raw, ",") value := sssa.Combine(secrets) fmt.Println("Secret: ", value) } } }
func main() { flag.Parse() if email == "" || password == "" { fmt.Println("Invalid E-Mail or Password\n") flag.Usage() os.Exit(-1) } if flag.NArg() != 2 { flag.Usage() os.Exit(-1) } imsi := flag.Arg(0) tm, err := strconv.ParseInt(flag.Arg(1), 10, 64) if err != nil { fmt.Printf("%s\n\n", err.Error()) flag.Usage() os.Exit(-1) } c, err := goracom.NewClient(email, password) errToExit(err) s := c.NewSubscriber() if tm == 0 { sub, err := s.UnsetExpiryTime(imsi) errToExit(err) printSubscriber(*sub) } else { sub, err := s.SetExpiryTime(imsi, tm) errToExit(err) printSubscriber(*sub) } }
func init() { flag.StringVar(&in, "in", "", "file name of a BAM file to be processed.") flag.StringVar(&annot, "annot", "", "file name of a GFF file containing annotations.") flag.Var(&classes, "class", "comma separated set of annotation classes to analyse.") flag.StringVar(&out, "out", "", "outfile name.") flag.IntVar(&minLength, "min", 20, "minimum length read considered.") flag.IntVar(&maxLength, "max", 35, "maximum length read considered.") flag.IntVar(&minId, "minid", 90, "minimum percentage identity for non-clipped bases.") flag.IntVar(&minQ, "minQ", 20, "minimum per-base sequence quality.") flag.IntVar(&filter, "f", 0, "filter on piwi type 0: no filter, 1: primary, 2: secondary.") flag.Float64Var(&minAvQ, "minAvQ", 30, "minimum average per-base sequence quality.") flag.IntVar(&mapQ, "mapQ", 0, "minimum mapping quality [0, 255).") flag.IntVar(&binLength, "bin", 1e7, "bin length.") flag.StringVar(&format, "format", "svg", "specifies the output format of the example: eps, jpg, jpeg, pdf, png, svg, and tiff.") help := flag.Bool("help", false, "output this usage message.") flag.Parse() mapQb = byte(mapQ) if *help { flag.Usage() os.Exit(0) } if in == "" || out == "" || annot == "" || len(classes) == 0 || mapQ < 0 || mapQ > 254 { flag.Usage() os.Exit(1) } for _, s := range []string{"eps", "jpg", "jpeg", "pdf", "png", "svg", "tiff"} { if format == s { return } } flag.Usage() os.Exit(1) }
func main() { var ipport string flag.StringVar(&ipport, "http", "127.0.0.1:8080", "The IP address and port to host the server at") flag.Usage = func() { fmt.Fprintf(os.Stderr, "Usage: staticserver -flags <directory to serve>\n") flag.PrintDefaults() } flag.Parse() if flag.NArg() != 1 { fmt.Fprintf(os.Stderr, "Error: You must specify a target directory to serve\n") flag.Usage() return } server, err := staticserver.NewStaticServer(flag.Arg(0)) if err != nil { fmt.Fprintf(os.Stderr, "Error: %s\n", err) flag.Usage() return } http.ListenAndServe(ipport, server) }
func main() { flag.Parse() if flag.NArg() < 2 { flag.Usage() } u := flag.Arg(0) cmdName := flag.Arg(1) cmd, ok := commands[cmdName] if !ok { fmt.Fprintf(os.Stderr, "Unknown command: %v\n", cmdName) flag.Usage() } if cmd.nargs == 0 { } else if cmd.nargs < 0 { reqargs := -cmd.nargs if flag.NArg()-2 < reqargs { fmt.Fprintf(os.Stderr, "Incorrect arguments for %v\n", cmdName) flag.Usage() } } else { if flag.NArg()-2 != cmd.nargs { fmt.Fprintf(os.Stderr, "Incorrect arguments for %v\n", cmdName) flag.Usage() } } cmd.f(u, flag.Args()[2:]) }
func main() { flag.Usage = func() { fmt.Fprintf(os.Stderr, "Usage: %s <command> [command-opts]\n", os.Args[0]) fmt.Fprintln(os.Stderr, "Commands:") for cmd, _ := range Commands { fmt.Fprintf(os.Stderr, " %s\n", cmd) } } flag.Parse() if flag.NArg() < 1 { flag.Usage() os.Exit(1) } subcommand := flag.Arg(0) if cmd, in := Commands[subcommand]; in { flags := flag.NewFlagSet(Cmd_Repo, flag.ExitOnError) cmd(os.Args[1:], flags) os.Exit(0) } fmt.Fprintf(os.Stderr, "Subcommand not recognized: %s\n", flag.Arg(0)) flag.Usage() os.Exit(1) }
func main() { flag.Parse() if *show_key { if flag.NArg() < 1 { flag.Usage() os.Exit(1) } for _, seed := range flag.Args() { key, err := issh.GetAuthorizedKey(seed) if err != nil { panic("Failed to create a key: " + err.Error()) } fmt.Printf("public key for \"%s\"\n"+ "command=\"exit 1\",no-port-forwarding,no-X11-forwarding,no-pty %s "+ "issh generated from seed: '%s'\n", seed, bytes.TrimRight(key, "\r\n \t"), seed) } return } if flag.NArg() != 2 { flag.Usage() os.Exit(1) } user, host, port := parseUserHostPort(flag.Arg(1)) stdout, exitcode, err := issh.Run(user, host, port, flag.Arg(0)) if err != nil { panic("Failed to execute remote command: " + err.Error()) } os.Stdout.Write(stdout) os.Exit(exitcode) }
func main() { flag.Usage = usage flag.Parse() args := flag.Args() if len(args) == 0 || args[0] == "-h" { flag.Usage() return } var cmd *Command name := args[0] for _, c := range commands { if strings.HasPrefix(c.Name, name) { cmd = c break } } if cmd == nil { fmt.Printf("error: unknown command %q\n", name) flag.Usage() os.Exit(1) } cmd.Exec(args[1:]) }
func main() { debug := false flag.Usage = Usage flag.Parse() options := gorazor.Option{} if debug { options["Debug"] = true } if flag.NArg() == 2 { arg1, arg2 := flag.Arg(0), flag.Arg(1) stat, err := os.Stat(arg1) if err != nil { fmt.Println(err) os.Exit(2) } if stat.IsDir() { fmt.Printf("Processing dir: %s %s\n", arg1, arg2) err := gorazor.GenFolder(arg1, arg2, options) if err != nil { fmt.Println(err) } } else if stat.Mode().IsRegular() { fmt.Printf("Processing file: %s %s\n", arg1, arg2) gorazor.GenFile(arg1, arg2, options) } else { flag.Usage() } } else { flag.Usage() } }
func main() { flag.Parse() if email == "" || password == "" { fmt.Println("Invalid E-Mail or Password\n") flag.Usage() os.Exit(-1) } if flag.NArg() != 2 { flag.Usage() os.Exit(-1) } imsi := flag.Arg(0) speed := flag.Arg(1) c, err := goracom.NewClient(email, password) errToExit(err) s := c.NewSubscriber() if sub, err := s.UpdateSpeedClass(imsi, speed); err == nil { printSubscriber(*sub) } else { errToExit(err) } }
// Program entry func main() { flag.Parse() flag.Usage = printDefaults if *isHelp { flag.Usage() os.Exit(0) } if *isTest { test() return } if *isDownload { if len(flag.Args()) == 0 { err := errors.New("no packages specified") handleError(err) } readCache() checkDepends(flag.Arg(0)) download(flag.Arg(0)) return } if *isSearch { search() return } flag.Usage() }
func main() { flag.Usage = Usage flag.Parse() if *port == "" || *remote == "" { flag.Usage() os.Exit(1) } if !*skipVerCheck { if vercheck.HasMinorUpdate( "https://raw.github.com/ciju/gotunnel/master/VERSION", "./VERSION", ) { l.Info("\nNew version of Gotunnel is available. Please update your code and run again. Or start with option -sc to continue with this version.\n") os.Exit(0) } } servInfo := make(chan string) go func() { serverat := <-servInfo fmt.Printf("Your site should be available at: \033[1;34m%s\033[0m\n", serverat) }() if !gtclient.SetupClient(*port, *remote, *subdomain, servInfo) { flag.Usage() os.Exit(1) } else { os.Exit(0) } }
func main() { log.SetFlags(0) flag.Usage = func() { log.Printf("Usage: cloudlus [OPTION] <subcommand> [OPTION] [args]\n") flag.PrintDefaults() log.Printf("Subcommands:\n") for cmd, _ := range cmds { log.Printf(" %v", cmd) } } flag.Parse() if len(flag.Args()) == 0 { flag.Usage() return } cmd, ok := cmds[flag.Arg(0)] if !ok { flag.Usage() return } cmd(flag.Arg(0), flag.Args()[1:]) }