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)
}