func onUsageErrorFor(commandName string) func(context *cli.Context, err error, isSubcommand bool) error { return func(context *cli.Context, err error, isSubcommand bool) error { fmt.Fprintf(context.App.Writer, "Error: %v\n\n", err) cli.ShowCommandHelp(context, commandName) return err } }
func onCommandUsageError(command string) gcli.OnUsageErrorFunc { return func(c *gcli.Context, err error, isSubcommand bool) error { fmt.Fprintf(c.App.Writer, "Error: %v\n\n", err) gcli.ShowCommandHelp(c, command) return nil } }
Value: "", Usage: "specify the file to write the process id to", }, cli.BoolFlag{ Name: "no-pivot", Usage: "do not use pivot root to jail process inside rootfs. This should be used whenever the rootfs is on top of a ramdisk", }, cli.BoolFlag{ Name: "no-new-keyring", Usage: "do not create a new session keyring for the container. This will cause the container to inherit the calling processes session key", }, }, Action: func(context *cli.Context) error { if context.NArg() != 1 { fmt.Printf("Incorrect Usage.\n\n") cli.ShowCommandHelp(context, "create") return fmt.Errorf("runc: \"create\" requires exactly one argument") } spec, err := setupSpec(context) if err != nil { return err } status, err := startContainer(context, spec, true) if err != nil { return err } // exit with the container's exit status so any external supervisor is // notified of the exit with the correct exit status. os.Exit(status) return nil },
func main() { app := cli.NewApp() app.Name = ProjectName app.Usage = Usage app.Version = Version app.Flags = []cli.Flag{ cli.BoolFlag{ Name: "verbose", Usage: "show more output", }, cli.BoolFlag{ Name: "e, env", Usage: "load AWS credentials from environment", }, cli.BoolFlag{ Name: "commit", Usage: "compiled git commit", }, } app.Action = func(ctx *cli.Context) error { args := ctx.Args() if ctx.Bool("commit") { CommitMessage() } else if args.Present() { cli.ShowCommandHelp(ctx, args.First()) } else { cli.ShowAppHelp(ctx) } return nil } // Commands app.Commands = []cli.Command{ { Name: "plan", Flags: []cli.Flag{ cli.BoolFlag{ Name: "destroy", Usage: "plan destroy", }, cli.BoolFlag{ Name: "no-sync", Usage: "Don't perform initial s3 sync", }, cli.StringFlag{ Name: "security", Usage: "security provider, current options <default>, <aws-internal>", }, cli.StringFlag{ Name: "security-role", Usage: "security iam role if using -security=aws-internal security", }, cli.StringFlag{ Name: "config-location", Usage: "config location, must be format <location>/<environment>.tfvars", }, }, Usage: "terraform plan", Action: CmdPlan, }, { Name: "apply", Flags: []cli.Flag{ cli.BoolFlag{ Name: "no-sync", Usage: "Don't perform initial s3 sync", }, cli.StringFlag{ Name: "security", Usage: "security provider, current options <default>, <aws-internal>", }, cli.StringFlag{ Name: "security-role", Usage: "security iam role if using -security=aws-internal security", }, cli.StringFlag{ Name: "config-location", Usage: "config location, must be format <location>/<environment>.tfvars", }, }, Usage: "terraform apply", Action: CmdApply, }, { Name: "destroy", Flags: []cli.Flag{ cli.BoolFlag{ Name: "force", Usage: "Force destroy", }, cli.BoolFlag{ Name: "no-sync", Usage: "Don't perform initial s3 sync", }, cli.StringFlag{ Name: "security", Usage: "security provider, current options <default>, <aws-internal>", }, cli.StringFlag{ Name: "security-role", Usage: "security iam role if using -security=aws-internal security", }, cli.StringFlag{ Name: "config-location", Usage: "config location, must be format <location>/<environment>.tfvars", }, }, Usage: "terraform destroy", Action: CmdDestroy, }, { Name: "refresh", Flags: []cli.Flag{ cli.BoolFlag{ Name: "no-sync", Usage: "Don't perform initial s3 sync", }, cli.StringFlag{ Name: "security", Usage: "security provider, current options <default>, <aws-internal>", }, cli.StringFlag{ Name: "security-role", Usage: "security iam role if using -security=aws-internal security", }, cli.StringFlag{ Name: "config-location", Usage: "config location, must be format <location>/<environment>.tfvars", }, }, Usage: "terraform refresh", Action: CmdRefresh, }, { Name: "taint", Flags: []cli.Flag{ cli.BoolFlag{ Name: "no-sync", Usage: "Don't perform initial s3 sync", }, cli.StringFlag{ Name: "module", Usage: "tainted module path", }, cli.StringFlag{ Name: "security", Usage: "security provider, current options <default>, <aws-internal>", }, cli.StringFlag{ Name: "security-role", Usage: "security iam role if using -security=aws-internal security", }, cli.StringFlag{ Name: "config-location", Usage: "config location, must be format <location>/<environment>.tfvars", }, }, Usage: "terraform taint", Action: CmdTaint, }, { Name: "untaint", Flags: []cli.Flag{ cli.BoolFlag{ Name: "no-sync", Usage: "Don't perform initial s3 sync", }, cli.StringFlag{ Name: "module", Usage: "tainted module path", }, cli.StringFlag{ Name: "security", Usage: "security provider, current options <default>, <aws-internal>", }, cli.StringFlag{ Name: "security-role", Usage: "security iam role if using -security=aws-internal security", }, cli.StringFlag{ Name: "config-location", Usage: "config location, must be format <location>/<environment>.tfvars", }, }, Usage: "terraform untaint", Action: CmdUntaint, }, { Name: "download", Flags: []cli.Flag{ cli.StringFlag{ Name: "config-location", Usage: "config location, must be format <location>/<environment>.tfvars", }, }, Usage: "download existing state to s3", Action: CmdDownload, }, { Name: "upload", Flags: []cli.Flag{ cli.StringFlag{ Name: "config-location", Usage: "config location, must be format <location>/<environment>.tfvars", }, }, Usage: "upload existing state to s3", Action: CmdUpload, }, } app.Run(os.Args) }
func main() { app := cli.NewApp() app.Name = "pgclimb" app.Version = "0.2" app.Usage = "Export data from PostgreSQL into different data formats" app.Flags = []cli.Flag{ cli.StringFlag{ Name: "dbname, d", Value: "postgres", Usage: "database", EnvVar: "DB_NAME", }, cli.StringFlag{ Name: "host", Value: "localhost", Usage: "host name", EnvVar: "DB_HOST", }, cli.StringFlag{ Name: "port, p", Value: "5432", Usage: "port", EnvVar: "DB_PORT", }, cli.StringFlag{ Name: "username, U", Value: "postgres", Usage: "username", EnvVar: "DB_USER", }, cli.BoolFlag{ Name: "ssl", Usage: "require ssl mode", }, cli.StringFlag{ Name: "password, pass", Value: "", Usage: "password", EnvVar: "DB_PASS", }, cli.StringFlag{ Name: "query, command, c", Value: "", Usage: "SQL query to execute", EnvVar: "DB_QUERY", }, cli.StringFlag{ Name: "file, f", Value: "", Usage: "SQL query filename", }, cli.StringFlag{ Name: "output, o", Value: "", Usage: "Output filename", }, } app.Commands = []cli.Command{ { Name: "template", Usage: "Export data with custom template", Action: func(c *cli.Context) error { changeHelpTemplateArgs("<template>") templateArg := c.Args().First() if templateArg == "" { cli.ShowCommandHelp(c, "template") os.Exit(1) } rawTemplate := parseTemplate(templateArg) writer := parseWriter(c) exportFormat(c, formats.NewTemplateFormat(writer, rawTemplate)) return nil }, }, { Name: "jsonlines", Usage: "Export newline-delimited JSON objects", Action: func(c *cli.Context) error { format := formats.NewJSONLinesFormat(parseWriter(c)) exportFormat(c, format) return nil }, }, { Name: "json", Usage: "Export JSON document", Action: func(c *cli.Context) error { format := formats.NewJSONArrayFormat(parseWriter(c)) exportFormat(c, format) return nil }, }, { Name: "csv", Usage: "Export CSV", Flags: []cli.Flag{ cli.StringFlag{ Name: "delimiter", Value: ",", Usage: "column delimiter", }, cli.BoolFlag{ Name: "header", Usage: "output header row", }, }, Action: func(c *cli.Context) error { delimiter, _ := utf8.DecodeRuneInString(c.String("delimiter")) format := formats.NewCsvFormat( parseWriter(c), delimiter, c.Bool("header"), ) exportFormat(c, format) return nil }, }, { Name: "tsv", Usage: "Export TSV", Flags: []cli.Flag{ cli.BoolFlag{ Name: "header", Usage: "output header row", }, }, Action: func(c *cli.Context) error { format := formats.NewCsvFormat( parseWriter(c), '\t', c.Bool("header"), ) exportFormat(c, format) return nil }, }, { Name: "xml", Usage: "Export XML", Action: func(c *cli.Context) error { format := formats.NewXMLFormat(parseWriter(c)) exportFormat(c, format) return nil }, }, { Name: "xlsx", Usage: "Export XLSX spreadsheets", Flags: []cli.Flag{ cli.StringFlag{ Name: "sheet", Value: "data", Usage: "spreadsheet name", }, }, Action: func(c *cli.Context) error { format, err := formats.NewXlsxFormat( c.GlobalString("output"), c.String("sheet"), ) exitOnError(err) exportFormat(c, format) return nil }, }, } app.Run(os.Args) }
// Main entry point for cli53 application func Main(args []string) int { cli.OsExiter = func(c int) { // noop - don't exit } commonFlags := []cli.Flag{ cli.BoolFlag{ Name: "debug, d", Usage: "enable debug logging", }, cli.StringFlag{ Name: "profile", Usage: "profile to use from credentials file", }, } app := cli.NewApp() app.Name = "cli53" app.Usage = "manage route53 DNS" app.Version = version app.Commands = []cli.Command{ { Name: "list", Aliases: []string{"l"}, Usage: "list domains", Flags: append(commonFlags, cli.StringFlag{ Name: "format, f", Value: "table", Usage: "output format: text, json, jl, table, csv", }, ), Action: func(c *cli.Context) error { r53 = getService(c) if len(c.Args()) != 0 { cli.ShowCommandHelp(c, "list") return cli.NewExitError("No parameters expected", 1) } formatter := getFormatter(c) if formatter == nil { return cli.NewExitError("Unknown format", 1) } listZones(formatter) return nil }, }, { Name: "create", Usage: "create a domain", ArgsUsage: "domain.name", Flags: append(commonFlags, cli.StringFlag{ Name: "comment", Value: "", Usage: "comment on the domain", }, cli.StringFlag{ Name: "vpc-id", Value: "", Usage: "create a private zone in the VPC", }, cli.StringFlag{ Name: "vpc-region", Value: "", Usage: "VPC region (required if vpcId is specified)", }, cli.StringFlag{ Name: "delegation-set-id", Value: "", Usage: "use the given delegation set", }, ), Action: func(c *cli.Context) error { r53 = getService(c) if len(c.Args()) != 1 { cli.ShowCommandHelp(c, "create") return cli.NewExitError("Expected exactly 1 parameter", 1) } createZone(c.Args().First(), c.String("comment"), c.String("vpc-id"), c.String("vpc-region"), c.String("delegation-set-id")) return nil }, }, { Name: "delete", Usage: "delete a domain", ArgsUsage: "name|ID", Flags: append(commonFlags, cli.BoolFlag{ Name: "purge", Usage: "remove any existing records on the domain (otherwise deletion will fail)", }, ), Action: func(c *cli.Context) error { r53 = getService(c) if len(c.Args()) != 1 { cli.ShowCommandHelp(c, "delete") return cli.NewExitError("Expected exactly 1 parameter", 1) } domain := c.Args().First() deleteZone(domain, c.Bool("purge")) return nil }, }, { Name: "import", Usage: "import a bind zone file", ArgsUsage: "name|ID", Flags: append(commonFlags, cli.StringFlag{ Name: "file", Value: "", Usage: "bind zone filename, or - for stdin (required)", }, cli.BoolFlag{ Name: "wait", Usage: "wait for changes to become live", }, cli.BoolFlag{ Name: "editauth", Usage: "include SOA and NS records from zone file", }, cli.BoolFlag{ Name: "replace", Usage: "replace all existing records", }, cli.BoolFlag{ Name: "dry-run, n", Usage: "perform a trial run with no changes made", }, ), Action: func(c *cli.Context) error { r53 = getService(c) if len(c.Args()) != 1 { cli.ShowCommandHelp(c, "import") return cli.NewExitError("Expected exactly 1 parameter", 1) } args := importArgs{ name: c.Args().First(), file: c.String("file"), wait: c.Bool("wait"), editauth: c.Bool("editauth"), replace: c.Bool("replace"), dryrun: c.Bool("dry-run"), } importBind(args) return nil }, }, { Name: "instances", Usage: "dynamically update your dns with EC2 instance names", ArgsUsage: "name|ID", Flags: append(commonFlags, cli.StringFlag{ Name: "off", Value: "", Usage: "if provided, then records for stopped instances will be updated. This option gives the dns name the CNAME should revert to", }, cli.StringSliceFlag{ Name: "region", EnvVar: "AWS_REGION", Usage: "a list of regions to check", }, cli.BoolFlag{ Name: "wait", Usage: "wait for changes to become live", }, cli.IntFlag{ Name: "ttl, x", Value: 60, Usage: "resource record ttl", }, cli.StringFlag{ Name: "match", Value: "", Usage: "regular expression to select which Name tags to use", }, cli.BoolFlag{ Name: "internal, i", Usage: "always use the internal hostname", }, cli.BoolFlag{ Name: "a-record, a", Usage: "write an A record (IP) instead of CNAME", }, cli.BoolFlag{ Name: "dry-run, n", Usage: "dry run - don't make any changes", }, ), Action: func(c *cli.Context) error { config := getConfig(c) r53 = getService(c) if len(c.Args()) != 1 { cli.ShowCommandHelp(c, "instances") return cli.NewExitError("Expected exactly 1 parameter", 1) } args := instancesArgs{ name: c.Args().First(), off: c.String("off"), regions: c.StringSlice("region"), wait: c.Bool("wait"), ttl: c.Int("ttl"), match: c.String("match"), internal: c.Bool("internal"), aRecord: c.Bool("a-record"), dryRun: c.Bool("dry-run"), } instances(args, config) return nil }, }, { Name: "export", Usage: "export a bind zone file (to stdout)", ArgsUsage: "name|ID", Flags: append(commonFlags, cli.BoolFlag{ Name: "full, f", Usage: "export prefixes as full names", }, ), Action: func(c *cli.Context) error { r53 = getService(c) if len(c.Args()) != 1 { cli.ShowCommandHelp(c, "export") return cli.NewExitError("Expected exactly 1 parameter", 1) } exportBind(c.Args().First(), c.Bool("full")) return nil }, }, { Name: "rrcreate", Aliases: []string{"rc"}, Usage: "create one or more records", ArgsUsage: "zone record [record...]", Flags: append(commonFlags, cli.BoolFlag{ Name: "wait", Usage: "wait for changes to become live", }, cli.BoolFlag{ Name: "append", Usage: "append the record", }, cli.BoolFlag{ Name: "replace", Usage: "replace the record", }, cli.StringFlag{ Name: "identifier, i", Usage: "record set identifier (for routed records)", }, cli.StringFlag{ Name: "failover", Usage: "PRIMARY or SECONDARY on a failover routing", }, cli.StringFlag{ Name: "health-check", Usage: "associated health check id for failover PRIMARY", }, cli.IntFlag{ Name: "weight", Usage: "weight on a weighted routing", }, cli.StringFlag{ Name: "region", Usage: "region for latency-based routing", }, cli.StringFlag{ Name: "country-code", Usage: "country code for geolocation routing", }, cli.StringFlag{ Name: "continent-code", Usage: "continent code for geolocation routing", }, cli.StringFlag{ Name: "subdivision-code", Usage: "subdivision code for geolocation routing", }, ), Action: func(c *cli.Context) error { r53 = getService(c) if len(c.Args()) < 2 { cli.ShowCommandHelp(c, "rrcreate") return cli.NewExitError("Expected at least 2 parameters", 1) } var weight *int if c.IsSet("weight") { weight = aws.Int(c.Int("weight")) } args := createArgs{ name: c.Args()[0], records: c.Args()[1:], wait: c.Bool("wait"), append: c.Bool("append"), replace: c.Bool("replace"), identifier: c.String("identifier"), failover: c.String("failover"), healthCheckId: c.String("health-check"), weight: weight, region: c.String("region"), countryCode: c.String("country-code"), continentCode: c.String("continent-code"), subdivisionCode: c.String("subdivision-code"), } if args.validate() { createRecords(args) } else { return cli.NewExitError("Validation error", 1) } return nil }, }, { Name: "rrdelete", Aliases: []string{"rd"}, Usage: "delete a record", ArgsUsage: "zone prefix type", Flags: append(commonFlags, cli.BoolFlag{ Name: "wait", Usage: "wait for changes to become live", }, cli.StringFlag{ Name: "identifier, i", Usage: "record set identifier to delete", }, ), Action: func(c *cli.Context) error { r53 = getService(c) if len(c.Args()) != 3 { cli.ShowCommandHelp(c, "rrdelete") return cli.NewExitError("Expected exactly 3 parameters", 1) } deleteRecord(c.Args()[0], c.Args()[1], c.Args()[2], c.Bool("wait"), c.String("identifier")) return nil }, }, { Name: "rrpurge", Usage: "delete all the records (danger!)", ArgsUsage: "name|ID", Flags: append(commonFlags, cli.BoolFlag{ Name: "confirm", Usage: "confirm you definitely want to do this!", }, cli.BoolFlag{ Name: "wait", Usage: "wait for changes to become live", }, ), Action: func(c *cli.Context) error { r53 = getService(c) if len(c.Args()) != 1 { cli.ShowCommandHelp(c, "rrpurge") return cli.NewExitError("Expected exactly 1 parameter", 1) } if !c.Bool("confirm") { return cli.NewExitError("You must --confirm this action", 1) } purgeRecords(c.Args().First(), c.Bool("wait")) return nil }, }, { Name: "dslist", Usage: "list reusable delegation sets", Flags: commonFlags, Action: func(c *cli.Context) error { r53 = getService(c) listReusableDelegationSets() return nil }, }, { Name: "dscreate", Usage: "create a reusable delegation set", Flags: append(commonFlags, cli.StringFlag{ Name: "zone-id", Value: "", Usage: "convert the given zone delegation set (optional)", }, ), Action: func(c *cli.Context) error { r53 = getService(c) createReusableDelegationSet(c.String("zone-id")) return nil }, }, { Name: "dsdelete", Usage: "delete a reusable delegation set", ArgsUsage: "id", Flags: commonFlags, Action: func(c *cli.Context) error { r53 = getService(c) if len(c.Args()) != 1 { cli.ShowCommandHelp(c, "dsdelete") return cli.NewExitError("Expected exactly 1 parameter", 1) } deleteReusableDelegationSet(c.Args().First()) return nil }, }, } err := app.Run(args) exitCode := 0 if err != nil { if _, ok := err.(*cli.ExitError); !ok { // Exit errors are already printed fmt.Println(err) } exitCode = 1 } return exitCode }
func main() { app := cli.NewApp() app.Name = "kənˈtrīv" app.Version = "19.99.0" app.Compiled = time.Now() app.Authors = []cli.Author{ cli.Author{ Name: "Example Human", Email: "*****@*****.**", }, } app.Copyright = "(c) 1999 Serious Enterprise" app.HelpName = "contrive" app.Usage = "demonstrate available API" app.UsageText = "contrive - demonstrating the available API" app.ArgsUsage = "[args and such]" app.Commands = []cli.Command{ cli.Command{ Name: "doo", Aliases: []string{"do"}, Category: "motion", Usage: "do the doo", UsageText: "doo - does the dooing", Description: "no really, there is a lot of dooing to be done", ArgsUsage: "[arrgh]", Flags: []cli.Flag{ cli.BoolFlag{Name: "forever, forevvarr"}, }, Subcommands: cli.Commands{ cli.Command{ Name: "wop", Action: wopAction, }, }, SkipFlagParsing: false, HideHelp: false, Hidden: false, HelpName: "doo!", BashComplete: func(c *cli.Context) { fmt.Fprintf(c.App.Writer, "--better\n") }, Before: func(c *cli.Context) error { fmt.Fprintf(c.App.Writer, "brace for impact\n") return nil }, After: func(c *cli.Context) error { fmt.Fprintf(c.App.Writer, "did we lose anyone?\n") return nil }, Action: func(c *cli.Context) error { c.Command.FullName() c.Command.HasName("wop") c.Command.Names() c.Command.VisibleFlags() fmt.Fprintf(c.App.Writer, "dodododododoodododddooooododododooo\n") if c.Bool("forever") { c.Command.Run(c) } return nil }, OnUsageError: func(c *cli.Context, err error, isSubcommand bool) error { fmt.Fprintf(c.App.Writer, "for shame\n") return err }, }, } app.Flags = []cli.Flag{ cli.BoolFlag{Name: "fancy"}, cli.BoolTFlag{Name: "fancier"}, cli.DurationFlag{Name: "howlong, H", Value: time.Second * 3}, cli.Float64Flag{Name: "howmuch"}, cli.GenericFlag{Name: "wat", Value: &genericType{}}, cli.Int64Flag{Name: "longdistance"}, cli.Int64SliceFlag{Name: "intervals"}, cli.IntFlag{Name: "distance"}, cli.IntSliceFlag{Name: "times"}, cli.StringFlag{Name: "dance-move, d"}, cli.StringSliceFlag{Name: "names, N"}, cli.UintFlag{Name: "age"}, cli.Uint64Flag{Name: "bigage"}, } app.EnableBashCompletion = true app.HideHelp = false app.HideVersion = false app.BashComplete = func(c *cli.Context) { fmt.Fprintf(c.App.Writer, "lipstick\nkiss\nme\nlipstick\nringo\n") } app.Before = func(c *cli.Context) error { fmt.Fprintf(c.App.Writer, "HEEEERE GOES\n") return nil } app.After = func(c *cli.Context) error { fmt.Fprintf(c.App.Writer, "Phew!\n") return nil } app.CommandNotFound = func(c *cli.Context, command string) { fmt.Fprintf(c.App.Writer, "Thar be no %q here.\n", command) } app.OnUsageError = func(c *cli.Context, err error, isSubcommand bool) error { if isSubcommand { return err } fmt.Fprintf(c.App.Writer, "WRONG: %#v\n", err) return nil } app.Action = func(c *cli.Context) error { cli.DefaultAppComplete(c) cli.HandleExitCoder(errors.New("not an exit coder, though")) cli.ShowAppHelp(c) cli.ShowCommandCompletions(c, "nope") cli.ShowCommandHelp(c, "also-nope") cli.ShowCompletions(c) cli.ShowSubcommandHelp(c) cli.ShowVersion(c) categories := c.App.Categories() categories.AddCommand("sounds", cli.Command{ Name: "bloop", }) for _, category := range c.App.Categories() { fmt.Fprintf(c.App.Writer, "%s\n", category.Name) fmt.Fprintf(c.App.Writer, "%#v\n", category.Commands) fmt.Fprintf(c.App.Writer, "%#v\n", category.VisibleCommands()) } fmt.Printf("%#v\n", c.App.Command("doo")) if c.Bool("infinite") { c.App.Run([]string{"app", "doo", "wop"}) } if c.Bool("forevar") { c.App.RunAsSubcommand(c) } c.App.Setup() fmt.Printf("%#v\n", c.App.VisibleCategories()) fmt.Printf("%#v\n", c.App.VisibleCommands()) fmt.Printf("%#v\n", c.App.VisibleFlags()) fmt.Printf("%#v\n", c.Args().First()) if len(c.Args()) > 0 { fmt.Printf("%#v\n", c.Args()[1]) } fmt.Printf("%#v\n", c.Args().Present()) fmt.Printf("%#v\n", c.Args().Tail()) set := flag.NewFlagSet("contrive", 0) nc := cli.NewContext(c.App, set, c) fmt.Printf("%#v\n", nc.Args()) fmt.Printf("%#v\n", nc.Bool("nope")) fmt.Printf("%#v\n", nc.BoolT("nerp")) fmt.Printf("%#v\n", nc.Duration("howlong")) fmt.Printf("%#v\n", nc.Float64("hay")) fmt.Printf("%#v\n", nc.Generic("bloop")) fmt.Printf("%#v\n", nc.Int64("bonk")) fmt.Printf("%#v\n", nc.Int64Slice("burnks")) fmt.Printf("%#v\n", nc.Int("bips")) fmt.Printf("%#v\n", nc.IntSlice("blups")) fmt.Printf("%#v\n", nc.String("snurt")) fmt.Printf("%#v\n", nc.StringSlice("snurkles")) fmt.Printf("%#v\n", nc.Uint("flub")) fmt.Printf("%#v\n", nc.Uint64("florb")) fmt.Printf("%#v\n", nc.GlobalBool("global-nope")) fmt.Printf("%#v\n", nc.GlobalBoolT("global-nerp")) fmt.Printf("%#v\n", nc.GlobalDuration("global-howlong")) fmt.Printf("%#v\n", nc.GlobalFloat64("global-hay")) fmt.Printf("%#v\n", nc.GlobalGeneric("global-bloop")) fmt.Printf("%#v\n", nc.GlobalInt("global-bips")) fmt.Printf("%#v\n", nc.GlobalIntSlice("global-blups")) fmt.Printf("%#v\n", nc.GlobalString("global-snurt")) fmt.Printf("%#v\n", nc.GlobalStringSlice("global-snurkles")) fmt.Printf("%#v\n", nc.FlagNames()) fmt.Printf("%#v\n", nc.GlobalFlagNames()) fmt.Printf("%#v\n", nc.GlobalIsSet("wat")) fmt.Printf("%#v\n", nc.GlobalSet("wat", "nope")) fmt.Printf("%#v\n", nc.NArg()) fmt.Printf("%#v\n", nc.NumFlags()) fmt.Printf("%#v\n", nc.Parent()) nc.Set("wat", "also-nope") ec := cli.NewExitError("ohwell", 86) fmt.Fprintf(c.App.Writer, "%d", ec.ExitCode()) fmt.Printf("made it!\n") return ec } if os.Getenv("HEXY") != "" { app.Writer = &hexWriter{} app.ErrWriter = &hexWriter{} } app.Metadata = map[string]interface{}{ "layers": "many", "explicable": false, "whatever-values": 19.99, } app.Run(os.Args) }
// Main entry point for cli53 application func Main(args []string) int { cli.OsExiter = func(c int) { // noop - don't exit } commonFlags := []cli.Flag{ cli.BoolFlag{ Name: "debug, d", Usage: "enable debug logging", }, cli.StringFlag{ Name: "profile", Usage: "profile to use from credentials file", }, } app := cli.NewApp() app.Name = "cli53" app.Usage = "manage route53 DNS" app.Version = version app.Commands = []cli.Command{ { Name: "list", Aliases: []string{"l"}, Usage: "list domains", Flags: commonFlags, Action: func(c *cli.Context) error { r53 = getService(c.Bool("debug"), c.String("profile")) if len(c.Args()) != 0 { cli.ShowCommandHelp(c, "list") return cli.NewExitError("No parameters expected", 1) } listZones() return nil }, }, { Name: "create", Usage: "create a domain", ArgsUsage: "domain.name", Flags: append(commonFlags, cli.StringFlag{ Name: "comment", Value: "", Usage: "comment on the domain", }, cli.StringFlag{ Name: "vpc-id", Value: "", Usage: "create a private zone in the VPC", }, cli.StringFlag{ Name: "vpc-region", Value: "", Usage: "VPC region (required if vpcId is specified)", }, cli.StringFlag{ Name: "delegation-set-id", Value: "", Usage: "use the given delegation set", }, ), Action: func(c *cli.Context) error { r53 = getService(c.Bool("debug"), c.String("profile")) if len(c.Args()) != 1 { cli.ShowCommandHelp(c, "create") return cli.NewExitError("Expected exactly 1 parameter", 1) } createZone(c.Args().First(), c.String("comment"), c.String("vpc-id"), c.String("vpc-region"), c.String("delegation-set-id")) return nil }, }, { Name: "delete", Usage: "delete a domain", ArgsUsage: "zone", Flags: append(commonFlags, cli.BoolFlag{ Name: "purge", Usage: "remove any existing records on the domain (otherwise deletion will fail)", }, ), Action: func(c *cli.Context) error { r53 = getService(c.Bool("debug"), c.String("profile")) if len(c.Args()) != 1 { cli.ShowCommandHelp(c, "delete") return cli.NewExitError("Expected exactly 1 parameter", 1) } domain := c.Args().First() deleteZone(domain, c.Bool("purge")) return nil }, }, { Name: "import", Usage: "import a bind zone file", ArgsUsage: "zone", Flags: append(commonFlags, cli.StringFlag{ Name: "file", Value: "", Usage: "bind zone file (required)", }, cli.BoolFlag{ Name: "wait", Usage: "wait for changes to become live", }, cli.BoolFlag{ Name: "editauth", Usage: "include SOA and NS records from zone file", }, cli.BoolFlag{ Name: "replace", Usage: "replace all existing records", }, ), Action: func(c *cli.Context) error { r53 = getService(c.Bool("debug"), c.String("profile")) if len(c.Args()) != 1 { cli.ShowCommandHelp(c, "import") return cli.NewExitError("Expected exactly 1 parameter", 1) } importBind(c.Args().First(), c.String("file"), c.Bool("wait"), c.Bool("editauth"), c.Bool("replace")) return nil }, }, { Name: "export", Usage: "export a bind zone file (to stdout)", ArgsUsage: "zone", Flags: append(commonFlags, cli.BoolFlag{ Name: "full, f", Usage: "export prefixes as full names", }, ), Action: func(c *cli.Context) error { r53 = getService(c.Bool("debug"), c.String("profile")) if len(c.Args()) != 1 { cli.ShowCommandHelp(c, "export") return cli.NewExitError("Expected exactly 1 parameter", 1) } exportBind(c.Args().First(), c.Bool("full")) return nil }, }, { Name: "rrcreate", Aliases: []string{"rc"}, Usage: "create one or more records", ArgsUsage: "zone record [record...]", Flags: append(commonFlags, cli.BoolFlag{ Name: "wait", Usage: "wait for changes to become live", }, cli.BoolFlag{ Name: "append", Usage: "append the record", }, cli.BoolFlag{ Name: "replace", Usage: "replace the record", }, cli.StringFlag{ Name: "identifier, i", Usage: "record set identifier (for routed records)", }, cli.StringFlag{ Name: "failover", Usage: "PRIMARY or SECONDARY on a failover routing", }, cli.StringFlag{ Name: "health-check", Usage: "associated health check id for failover PRIMARY", }, cli.IntFlag{ Name: "weight", Usage: "weight on a weighted routing", }, cli.StringFlag{ Name: "region", Usage: "region for latency-based routing", }, cli.StringFlag{ Name: "country-code", Usage: "country code for geolocation routing", }, cli.StringFlag{ Name: "continent-code", Usage: "continent code for geolocation routing", }, cli.StringFlag{ Name: "subdivision-code", Usage: "subdivision code for geolocation routing", }, ), Action: func(c *cli.Context) error { r53 = getService(c.Bool("debug"), c.String("profile")) if len(c.Args()) < 2 { cli.ShowCommandHelp(c, "rrcreate") return cli.NewExitError("Expected at least 2 parameters", 1) } var weight *int if c.IsSet("weight") { weight = aws.Int(c.Int("weight")) } args := createArgs{ name: c.Args()[0], records: c.Args()[1:], wait: c.Bool("wait"), append: c.Bool("append"), replace: c.Bool("replace"), identifier: c.String("identifier"), failover: c.String("failover"), healthCheckId: c.String("health-check"), weight: weight, region: c.String("region"), countryCode: c.String("country-code"), continentCode: c.String("continent-code"), subdivisionCode: c.String("subdivision-code"), } if args.validate() { createRecords(args) } else { return cli.NewExitError("Validation error", 1) } return nil }, }, { Name: "rrdelete", Aliases: []string{"rd"}, Usage: "delete a record", ArgsUsage: "zone prefix type", Flags: append(commonFlags, cli.BoolFlag{ Name: "wait", Usage: "wait for changes to become live", }, cli.StringFlag{ Name: "identifier, i", Usage: "record set identifier to delete", }, ), Action: func(c *cli.Context) error { r53 = getService(c.Bool("debug"), c.String("profile")) if len(c.Args()) != 3 { cli.ShowCommandHelp(c, "rrdelete") return cli.NewExitError("Expected exactly 3 parameters", 1) } deleteRecord(c.Args()[0], c.Args()[1], c.Args()[2], c.Bool("wait"), c.String("identifier")) return nil }, }, { Name: "rrpurge", Usage: "delete all the records (danger!)", ArgsUsage: "zone", Flags: append(commonFlags, cli.BoolFlag{ Name: "confirm", Usage: "confirm you definitely want to do this!", }, cli.BoolFlag{ Name: "wait", Usage: "wait for changes to become live", }, ), Action: func(c *cli.Context) error { r53 = getService(c.Bool("debug"), c.String("profile")) if len(c.Args()) != 1 { cli.ShowCommandHelp(c, "rrpurge") return cli.NewExitError("Expected exactly 1 parameter", 1) } if !c.Bool("confirm") { return cli.NewExitError("You must --confirm this action", 1) } purgeRecords(c.Args().First(), c.Bool("wait")) return nil }, }, { Name: "dslist", Usage: "list reusable delegation sets", Flags: commonFlags, Action: func(c *cli.Context) error { r53 = getService(c.Bool("debug"), c.String("profile")) listReusableDelegationSets() return nil }, }, { Name: "dscreate", Usage: "create a reusable delegation set", Flags: append(commonFlags, cli.StringFlag{ Name: "zone-id", Value: "", Usage: "convert the given zone delegation set (optional)", }, ), Action: func(c *cli.Context) error { r53 = getService(c.Bool("debug"), c.String("profile")) createReusableDelegationSet(c.String("zone-id")) return nil }, }, { Name: "dsdelete", Usage: "delete a reusable delegation set", ArgsUsage: "id", Flags: commonFlags, Action: func(c *cli.Context) error { r53 = getService(c.Bool("debug"), c.String("profile")) if len(c.Args()) != 1 { cli.ShowCommandHelp(c, "dsdelete") return cli.NewExitError("Expected exactly 1 parameter", 1) } deleteReusableDelegationSet(c.Args().First()) return nil }, }, } err := app.Run(args) exitCode := 0 if err != nil { if _, ok := err.(*cli.ExitError); !ok { // Exit errors are already printed fmt.Println(err) } exitCode = 1 } return exitCode }
//Run main entry func Run() error { app := cli.NewApp() app.Name = "chaos" app.Version = "v20160606" app.Usage = "it-package web application." app.EnableBashCompletion = true app.Commands = []cli.Command{ { Name: "init", Aliases: []string{"i"}, Usage: "init config file", Flags: []cli.Flag{ cli.StringFlag{ Name: "environment, e", Value: "development", Usage: "environment, like: development, production, test...", }, }, Action: func(c *cli.Context) error { const fn = "config.toml" if _, err := os.Stat(fn); err == nil { return fmt.Errorf("file %s already exists", fn) } fmt.Printf("generate file %s\n", fn) viper.Set("env", c.String("environment")) args := viper.AllSettings() fd, err := os.Create(fn) if err != nil { log.Println(err) return err } defer fd.Close() end := toml.NewEncoder(fd) err = end.Encode(args) return err }, }, { Name: "server", Aliases: []string{"s"}, Usage: "start the app server", Action: IocAction(func(*cli.Context, *inject.Graph) error { if IsProduction() { gin.SetMode(gin.ReleaseMode) } rt := gin.Default() rt.Use(i18n.LocaleHandler) Loop(func(en Engine) error { en.Mount(rt) return nil }) adr := fmt.Sprintf(":%d", viper.GetInt("http.port")) hnd := cors.New(cors.Options{ AllowCredentials: true, AllowedMethods: []string{"GET", "POST", "PUT", "DELETE", "PATCH"}, AllowedHeaders: []string{"*"}, //Debug: true, }).Handler(rt) if IsProduction() { return endless.ListenAndServe(adr, hnd) } return http.ListenAndServe(adr, hnd) }), }, { Name: "worker", Aliases: []string{"w"}, Usage: "start the worker progress", Action: IocAction(func(*cli.Context, *inject.Graph) error { Loop(func(en Engine) error { en.Worker() return nil }) workers.Run() return nil }), }, { Name: "openssl", Aliases: []string{"ssl"}, Usage: "generate ssl certificates", Flags: []cli.Flag{ cli.StringFlag{ Name: "name, n", Usage: "name", }, cli.StringFlag{ Name: "country, c", Value: "Earth", Usage: "country", }, cli.StringFlag{ Name: "organization, o", Value: "Mother Nature", Usage: "organization", }, cli.IntFlag{ Name: "years, y", Value: 1, Usage: "years", }, }, Action: Action(func(c *cli.Context) error { name := c.String("name") if len(name) == 0 { cli.ShowCommandHelp(c, "openssl") return nil } root := path.Join("etc", "ssl", name) key, crt, err := CreateCertificate( true, pkix.Name{ Country: []string{c.String("country")}, Organization: []string{c.String("organization")}, }, c.Int("years"), ) if err != nil { return err } fnk := path.Join(root, "key.pem") fnc := path.Join(root, "crt.pem") fmt.Printf("generate pem file %s\n", fnk) err = WritePemFile(fnk, "RSA PRIVATE KEY", key) fmt.Printf("test: openssl rsa -noout -text -in %s\n", fnk) if err == nil { fmt.Printf("generate pem file %s\n", fnc) err = WritePemFile(fnc, "CERTIFICATE", crt) fmt.Printf("test: openssl x509 -noout -text -in %s\n", fnc) } if err == nil { fmt.Printf( "verify: diff <(openssl rsa -noout -modulus -in %s) <(openssl x509 -noout -modulus -in %s)", fnk, fnc, ) } return err }), }, } for _, en := range engines { cmd := en.Shell() app.Commands = append(app.Commands, cmd...) } return app.Run(os.Args) }