Ejemplo n.º 1
0
func loadCommands(app *cli.App) {
	app.Action = mainCmd

	app.Flags = []cli.Flag{
		cli.StringFlag{"assigned", "", "display issues assigned to <user>. Use '*' for all assigned, or 'none' for all unassigned."},
		cli.BoolFlag{"no-trunc", "do not truncate the issue name"},
	}

	app.Commands = []cli.Command{
		{
			Name:   "alru",
			Usage:  "Show the Age of the Least Recently Updated issue for this repo. Lower is better.",
			Action: alruCmd,
		},
		{
			Name:   "repo",
			Usage:  "List information about the current repository",
			Action: repositoryInfoCmd,
		},
		{
			Name:   "auth",
			Usage:  "Add a github token for authentication",
			Action: authCmd,
			Flags: []cli.Flag{
				cli.StringFlag{"add", "", "add new token for authentication"},
			},
		},
	}
}
Ejemplo n.º 2
0
func loadCommands(app *cli.App) {
	// Add top level flags and commands
	app.Action = mainCmd

	// Filters modify what type of pr to display
	filters := []cli.Flag{
		cli.BoolFlag{"no-merge", "display only prs that cannot be merged"},
		cli.BoolFlag{"lgtm", "display the number of LGTM"},
		cli.BoolFlag{"closed", "display closed prs"},
		cli.BoolFlag{"new", "display prs opened in the last 24 hours"},
	}
	// Options modify how to display prs
	options := []cli.Flag{
		cli.BoolFlag{"no-trunc", "don't truncate pr name"},
		cli.StringFlag{"user", "", "display only prs from <user>"},
		cli.StringFlag{"comment", "", "add a comment to the pr"},
	}
	app.Flags = append(filters, options...)

	// Add subcommands
	app.Commands = []cli.Command{
		{
			Name:   "repo",
			Usage:  "List information about the current repository",
			Action: repositoryInfoCmd,
		},
		{
			Name:   "auth",
			Usage:  "Add a github token for authentication",
			Action: authCmd,
			Flags: []cli.Flag{
				cli.StringFlag{"add", "", "add new token for authentication"},
			},
		},
		{
			Name:   "alru",
			Usage:  "Show the Age of the Least Recently Updated pull request for this repo. Lower is better.",
			Action: alruCmd,
		},
		{
			Name:   "merge",
			Usage:  "Merge a pull request",
			Action: mergeCmd,
			Flags: []cli.Flag{
				cli.StringFlag{"m", "", "commit message for merge"},
				cli.BoolFlag{"force", "merge a pull request that has not been approved"},
			},
		},
		{
			Name:   "checkout",
			Usage:  "Checkout a pull request into your local repo",
			Action: checkoutCmd,
		},
		{
			Name:   "approve",
			Usage:  "Approve a pull request by adding LGTM to the comments",
			Action: approveCmd,
		},
	}
}
Ejemplo n.º 3
0
Archivo: ping.go Proyecto: rodaine/esu
func setupPingCommand(app *cli.App) {
	app.Commands = append(app.Commands, cli.Command{
		Name:    "ping",
		Aliases: []string{"p"},
		Usage:   "ping the cluster to see if it's available",
		Action:  ping,
	},
	)
}
Ejemplo n.º 4
0
Archivo: app.go Proyecto: rodaine/esu
func setupGlobalCommands(app *cli.App) {
	app.Commands = []cli.Command{
		{
			Name:    "help",
			Aliases: []string{"man"},
			Usage:   "prints this help message",
			Action:  cli.ShowAppHelp,
		},
	}
}
Ejemplo n.º 5
0
func loadCommands(app *cli.App) {
	app.Action = mainCmd

	app.Flags = []cli.Flag{
		cli.StringFlag{"assigned", "", "display issues assigned to <user>. Use '*' for all assigned, or 'none' for all unassigned."},
		cli.StringFlag{"remote", "origin", "git remote to treat as origin"},
		cli.BoolFlag{"no-trunc", "do not truncate the issue name"},
		cli.IntFlag{"votes", -1, "display the number of votes '+1' filtered by the <number> specified."},
		cli.BoolFlag{"vote", "add '+1' to an specific issue."},
	}

	app.Commands = []cli.Command{
		{
			Name:   "alru",
			Usage:  "Show the Age of the Least Recently Updated issue for this repo. Lower is better.",
			Action: alruCmd,
		},
		{
			Name:   "repo",
			Usage:  "List information about the current repository",
			Action: repositoryInfoCmd,
		},
		{
			Name:   "take",
			Usage:  "Assign an issue to your github account",
			Action: takeCmd,
			Flags: []cli.Flag{
				cli.BoolFlag{"overwrite", "overwrites a taken issue"},
			},
		},
		{
			Name:   "search",
			Usage:  "Find issues by state and keyword.",
			Action: searchCmd,
			Flags: []cli.Flag{
				cli.StringFlag{"author", "", "Finds issues created by a certain user"},
				cli.StringFlag{"assignee", "", "Finds issues that are assigned to a certain user"},
				cli.StringFlag{"mentions", "", "Finds issues that mention a certain user"},
				cli.StringFlag{"commenter", "", "Finds issues that a certain user commented on"},
				cli.StringFlag{"involves", "", "Finds issues that were either created by a certain user, assigned to that user, mention that user, or were commented on by that user"},
				cli.StringFlag{"labels", "", "Filters issues based on their labels"},
				cli.StringFlag{"state", "", "Filter issues based on whether they’re open or closed"},
			},
		},
		{
			Name:   "auth",
			Usage:  "Add a github token for authentication",
			Action: authCmd,
			Flags: []cli.Flag{
				cli.StringFlag{"add", "", "add new token for authentication"},
			},
		},
	}
}
Ejemplo n.º 6
0
func loadCommands(app *cli.App) {
	// default to listing a service
	app.Action = getAction

	app.Flags = []cli.Flag{
		cli.BoolFlag{"json", "output to json"},
		cli.StringFlag{"host", os.Getenv("SKYDNS"), "url to SkyDNS's HTTP endpoints (defaults to env. var. SKYDNS)"},
		cli.StringFlag{"dns",
			func() string {
				if x := os.Getenv("SKYDNS_DNS"); x != "" {
					if strings.HasPrefix(x, "http") {
						return x
					}
					return "http://" + x // default to http for now
				}
				return "127.0.0.1:53"
			}(), "DNS port of SkyDNS's DNS endpoint (defaults to env. var. SKYDNS_DNS)"},
		cli.StringFlag{"domain",
			func() string {
				if x := os.Getenv("SKYDNS_DOMAIN"); x != "" {
					return x
				}
				return "skydns.local"
			}(), "DNS domain of SkyDNS (defaults to env. var. SKYDNS_DOMAIN))"},
		cli.StringFlag{"secret", "", "secret to authenticate with"},
	}

	app.Commands = []cli.Command{
		{
			Name:   "list",
			Usage:  "list a service from skydns",
			Action: getAction,
			Flags:  []cli.Flag{cli.BoolFlag{"d", "use DNS instead of HTTP"}},
		},
		{
			Name:   "add",
			Usage:  "add a new service to skydns",
			Action: addAction,
		},
		{
			Name:   "delete",
			Usage:  "delete a service from skydns",
			Action: deleteAction,
		},
		{
			Name:   "update",
			Usage:  "update a service's ttl in skydns",
			Action: updateAction,
		},
	}
}
Ejemplo n.º 7
0
func setCommands(app *cli.App) {
	commands := []cli.Command{}

	// TODO: Automaticaly load the commands based on the cmd directory content.
	commands = append(commands, cmd.Init())
	commands = append(commands, cmd.List())
	commands = append(commands, cmd.On())
	commands = append(commands, cmd.Log())
	commands = append(commands, cmd.Stop())
	commands = append(commands, cmd.Done())
	commands = append(commands, cmd.Status())

	app.Commands = commands
}
Ejemplo n.º 8
0
Archivo: qs.go Proyecto: qSlide/qslide
func main() {
	var app *cli.App
	app = cli.NewApp()
	app.Name = APP_NAME
	app.Version = APP_VER
	app.Usage = "email for mail sending, or web or none for run web interface!"
	app.Commands = []cli.Command{
		task.CmdWeb,
		task.CmdEmail,
	}
	app.Flags = append(app.Flags, []cli.Flag{}...)

	app.Run(os.Args)
}
Ejemplo n.º 9
0
func loadCommands(app *cli.App) {
	// default to listing a service
	app.Action = getAction

	app.Flags = []cli.Flag{
		cli.BoolFlag{"json", "output to json"},
		cli.StringFlag{"host", os.Getenv("SKYDNS"), "url to SkyDNS's HTTP endpoints (defaults to env. var. SKYDNS)"},
		cli.StringFlag{"dnsport",
			func() string {
				x := os.Getenv("SKYDNS_DNSPORT")
				if x == "" {
					x = "53"
				}
				return x
			}(), "DNS port of SkyDNS's DNS endpoint (defaults to env. var. SKYDNS_DNSPORT or 53)"},
		cli.StringFlag{"dnsdomain",
			func() string {
				x := os.Getenv("SKYDNS_DNSDOMAIN")
				if x == "" {
					x = "skydns.local"
				}
				return x
			}(), "DNS domain of SkyDNS (defaults to env. var. SKYDNS_DNSDOMAIN or skydns.local)"},
		cli.StringFlag{"secret", "", "secret to authenticate with"},
	}

	app.Commands = []cli.Command{
		{
			Name:   "list",
			Usage:  "list a service from skydns",
			Action: getAction,
			Flags:  []cli.Flag{cli.BoolFlag{"d", "use DNS instead of HTTP"}},
		},
		{
			Name:   "add",
			Usage:  "add a new service to skydns",
			Action: addAction,
		},
		{
			Name:   "delete",
			Usage:  "delete a service from skydns",
			Action: deleteAction,
		},
		{
			Name:   "update",
			Usage:  "update a service's ttl in skydns",
			Action: updateAction,
		},
	}
}
Ejemplo n.º 10
0
Archivo: jit.go Proyecto: Rentlio/jit
// Set application commands
func setCommands(app *cli.App, config *configuration) {
	app.Commands = []cli.Command{
		{
			Name:    "checkout",
			Aliases: []string{"co"},
			Usage:   "Checkout branch",
			Flags: []cli.Flag{
				cli.BoolFlag{
					Name:  "b",
					Usage: "Create new branch while checkout",
				},
			},
			Action: func(c *cli.Context) {
				valid := validateConfiguration(config)
				if !valid {
					fmt.Println(errorDecorator("Please provide valid configuration"))
					os.Exit(1)
				}
				checkoutBranch(c, config)
			},
		},
		{
			Name:    "version",
			Aliases: []string{"v"},
			Usage:   "Get version issues",
			Action: func(c *cli.Context) {
				valid := validateConfiguration(config)
				if !valid {
					fmt.Println(errorDecorator("Please provide valid configuration"))
					os.Exit(1)
				}
				getVersionIssues(c, config)
			},
		},
		{
			Name:    "description",
			Aliases: []string{"d"},
			Usage:   "Show issue description",
			Action: func(c *cli.Context) {
				valid := validateConfiguration(config)
				if !valid {
					fmt.Println(errorDecorator("Please provide valid configuration"))
					os.Exit(1)
				}
				showIssueDetails(c, config)
			},
		},
	}
}
Ejemplo n.º 11
0
//import "encoding/json"
// maybe pass in a points to Commands, so we can register
// subcommands? Or a register module to do the registering.
func Register(app *cli.App) string {
	app.Commands = []cli.Command{
		{
			Name: "cloudformation",
			Subcommands: []cli.Command{
				{
					Name:   "follow-stack-events",
					Usage:  "NAME...",
					Action: followStackEvents,
				},
			},
		},
	}
	return "Finished"
}
Ejemplo n.º 12
0
func AddToCLI(a *cli.App) {
	commands := []cli.Command{
		{
			Name:    "ec2",
			Usage:   "find EC2 instances that match a regex",
			Aliases: []string{"e"},
			Subcommands: []cli.Command{
				{
					Name:    "match",
					Aliases: []string{"m"},
					Usage:   "find EC2 instances that match a regex",
					Action:  Match,
				},
			},
		},
	}

	a.Commands = append(a.Commands, commands...)
}
Ejemplo n.º 13
0
Archivo: rdiff.go Proyecto: smtc/rsync
func setupCommands(app *cli.App) {
	app.Commands = []cli.Command{
		{
			Name:    "signature",
			Aliases: []string{"s"},
			Usage: "Signature generate use blake2 algorithm\n" +
				"     -b, --block-size=BYTES    Signature block size\n" +
				"     -s, --sum-size=BYTES      Set signature strength\n",
			Flags: []cli.Flag{
				cli.IntFlag{
					Name:  "block-size,b",
					Value: 2048,
					Usage: "Set signature block size",
				},
				cli.IntFlag{
					Name:  "sum-size,s",
					Value: 32,
					Usage: "Set signature strong checksum strength, 32 or 64",
				},
			},
			Action: doSign,
		},
		{
			Name:    "delta",
			Aliases: []string{"d"},
			Usage: "Delta-encoding options:\n" +
				"     -b, --block-size=BYTES    Signature block size\n" +
				"     -s, --sum-size=BYTES      Set signature strength\n",

			Action: doDelta,
		},
		{
			Name:    "patch",
			Aliases: []string{"p"},
			Usage: "complete a task on the list\n" +
				"     -b, --block-size=BYTES    Signature block size\n" +
				"     -s, --sum-size=BYTES      Set signature strength\n",

			Action: doPatch,
		},
	}
}
Ejemplo n.º 14
0
func initCommands(app *gcli.App) {
	app.Commands = []gcli.Command{
		createAlertCommand(),
		getAlertCommand(),
		attachFileCommand(),
		acknowledgeCommand(),
		renotifyCommand(),
		takeOwnershipCommand(),
		assignOwnerCommand(),
		addTeamCommand(),
		addRecipientCommand(),
		addTagsCommand(),
		addNoteCommand(),
		executeActionCommand(),
		closeAlertCommand(),
		deleteAlertCommand(),
		heartbeatCommand(),
		enableCommand(),
		disableCommand(),
	}
}
Ejemplo n.º 15
0
func setupClusterCommand(app *cli.App) {
	app.Commands = append(
		app.Commands,
		cli.Command{
			Name:     "cluster",
			Aliases:  []string{"c"},
			Usage:    "get information about the connected cluster",
			Action:   cli.ShowSubcommandHelp,
			HideHelp: true,
			Subcommands: []cli.Command{
				cli.Command{
					Name:    "health",
					Aliases: []string{"h"},
					Usage:   "get health information about the cluster",
					Action:  getClusterHealth,
				},
				cli.Command{
					Name:    "stats",
					Aliases: []string{"s"},
					Usage:   "get cluster-wide statistics, including indices, storage and nodes",
					Action:  getClusterStats,
				},
				cli.Command{
					Name:    "nodes",
					Aliases: []string{"n"},
					Usage:   "get information on the nodes in the cluster",
					Action:  getClusterNodes,
				},
				cli.Command{
					Name:        "update",
					Aliases:     []string{"u"},
					Usage:       "update the cluster settings via JSON",
					Description: "esu cluster update [PATH] -- Where PATH is a JSON document to update with. Alternatively, JSON can be piped into this command",
					Action:      putClusterSettings,
				},
			},
		},
	)
}
Ejemplo n.º 16
0
				Expect(fakeExitHandler.ExitCalledWith).To(Equal([]int{1}))
			})
		})

		Describe("App.Before", func() {
			Context("when running the target command", func() {
				It("does not verify the current target", func() {
					cliConfig.SetTarget("my-lattice.example.com")
					Expect(cliConfig.Save()).To(Succeed())

					commandRan := false

					cliApp.Commands = []cli.Command{
						cli.Command{
							Name: "target",
							Action: func(ctx *cli.Context) {
								commandRan = true
							},
						},
					}

					Expect(cliApp.Run([]string{"ltc", "target"})).To(Succeed())
					Expect(commandRan).To(BeTrue())
					Expect(fakeTargetVerifier.VerifyTargetCallCount()).To(Equal(0))
				})
			})

			Context("when running the help command", func() {
				It("does not verify the current target", func() {
					cliConfig.SetTarget("my-lattice.example.com")
					Expect(cliConfig.Save()).To(Succeed())
Ejemplo n.º 17
0
func BuildCommand(app *cli.App) {
	app.Commands = append(app.Commands, SubCommand())
}
Ejemplo n.º 18
0
func loadCommands(app *cli.App) {
	// Add top level flags and commands
	app.Action = mainCmd

	app.Flags = []cli.Flag{
		cli.StringFlag{"remote", "origin", "git remote to treat as origin"},
	}

	// Filters modify what type of pr to display
	filters := []cli.Flag{
		cli.BoolFlag{"no-merge", "display only prs that cannot be merged"},
		cli.BoolFlag{"lgtm", "display the number of LGTM"},
		cli.StringFlag{"state", "open", "display prs based on their state"},
		cli.BoolFlag{"new", "display prs opened in the last 24 hours"},
		cli.BoolFlag{"mine", "display only PRs I care about based on the MAINTAINERS files"},
		cli.StringFlag{"maintainer", "", "display only PRs a maintainer cares about based on the MAINTAINERS files"},
		cli.StringFlag{"sort", "updated", "sort the prs by (created, updated, popularity, long-running)"},
		cli.StringFlag{"assigned", "", "display only prs assigned to a user"},
		cli.BoolFlag{"unassigned", "display only unassigned prs"},
		cli.StringFlag{"dir", "", "display only prs that touch this dir"},
		cli.StringFlag{"extension", "", "display only prs that have files with this extension (no dot)"},
		cli.BoolFlag{"cleanup", "display only cleanup prs"},
	}
	app.Flags = append(app.Flags, filters...)

	// Options modify how to display prs
	options := []cli.Flag{
		cli.BoolFlag{"no-trunc", "don't truncate pr name"},
		cli.StringFlag{"user", "", "display only prs from <user>"},
		cli.StringFlag{"comment", "", "add a comment to the pr"},
	}
	app.Flags = append(app.Flags, options...)

	// Add subcommands
	app.Commands = []cli.Command{
		{
			Name:   "repo",
			Usage:  "List information about the current repository",
			Action: repositoryInfoCmd,
		},
		{
			Name:   "comment",
			Usage:  "Leave a comment on a pull request",
			Action: commentCmd,
		},
		{
			Name:   "comments",
			Usage:  "Show comments on a pull request",
			Action: commentsCmd,
		},
		{
			Name:   "auth",
			Usage:  "Add a github token for authentication",
			Action: authCmd,
			Flags: []cli.Flag{
				cli.StringFlag{"add", "", "add new token for authentication"},
				cli.StringFlag{"user", "", "add github user name"},
			},
		},
		{
			Name:   "alru",
			Usage:  "Show the Age of the Least Recently Updated pull request for this repo. Lower is better.",
			Action: alruCmd,
		},
		{
			Name:   "merge",
			Usage:  "Merge a pull request",
			Action: mergeCmd,
			Flags: []cli.Flag{
				cli.StringFlag{"m", "", "commit message for merge"},
				cli.BoolFlag{"force", "merge a pull request that has not been approved"},
			},
		},
		{
			Name:   "close",
			Usage:  "Close a pull request without merging it",
			Action: closeCmd,
			Flags:  []cli.Flag{},
		},
		{
			Name:   "checkout",
			Usage:  "Checkout a pull request into your local repo",
			Action: checkoutCmd,
		},
		{
			Name:   "send",
			Usage:  "Send a new pull request, or overwrite an existing one",
			Action: sendCmd,
		},
		{
			Name:   "approve",
			Usage:  "Approve a pull request by adding LGTM to the comments",
			Action: approveCmd,
		},
		{
			Name:   "take",
			Usage:  "Assign a pull request to your github account",
			Action: takeCmd,
			Flags: []cli.Flag{
				cli.BoolFlag{"steal", "steal the pull request from its current owner"},
			},
		},
		{
			Name:   "drop",
			Usage:  "Give up ownership of a pull request assigned to you",
			Action: dropCmd,
			Flags:  []cli.Flag{},
		},
		{
			Name:   "diff",
			Usage:  "Print the patch submitted by a pull request",
			Action: showCmd,
		},
		{
			Name:   "reviewers",
			Usage:  "Use the hierarchy of MAINTAINERS files to list who should review a pull request",
			Action: reviewersCmd,
		},
		{
			Name:   "contributors",
			Usage:  "Show the contributors list with additions, deletions, and commit counts. Default: sorted by Commits",
			Action: contributorsCmd,
			Flags: []cli.Flag{
				cli.BoolFlag{"additions", "sort by additions"},
				cli.BoolFlag{"deletions", "sort by deletions"},
				cli.BoolFlag{"commits", "sort by commits"},
				cli.IntFlag{"top", 10, "top N contributors"},
			},
		},
	}
}
Ejemplo n.º 19
0
func loadCommands(app *cli.App) {
	app.Action = mainCmd

	app.Flags = []cli.Flag{
		cli.StringFlag{Name: "assigned", Value: "", Usage: "display issues assigned to <user>. Use '*' for all assigned, or 'none' for all unassigned."},
		cli.StringFlag{Name: "remote", Value: gordon.GetDefaultGitRemote(), Usage: "git remote to treat as origin"},
		cli.StringFlag{Name: "milestone", Value: "", Usage: "display issues inside a particular <milestone>."},
		cli.BoolFlag{Name: "no-trunc", Usage: "do not truncate the issue name"},
		cli.BoolFlag{Name: "verbose", Usage: "show more verbose output on actions"},
		cli.IntFlag{Name: "votes", Value: -1, Usage: "display the number of votes '+1' filtered by the <number> specified."},
		cli.BoolFlag{Name: "vote", Usage: "add '+1' to an specific issue."},
		cli.BoolFlag{Name: "proposals", Usage: "Only show proposal issues"},
	}

	app.Commands = []cli.Command{
		{
			Name:   "alru",
			Usage:  "Show the Age of the Least Recently Updated issue for this repo. Lower is better.",
			Action: alruCmd,
		},
		{
			Name:   "repo",
			Usage:  "List information about the current repository",
			Action: repositoryInfoCmd,
		},
		{
			Name:   "take",
			Usage:  "Assign an issue to your github account",
			Action: takeCmd,
			Flags: []cli.Flag{
				cli.BoolFlag{Name: "overwrite", Usage: "overwrites a taken issue"},
			},
		},
		{
			Name:        "close",
			Usage:       "Close an issue",
			Description: "Provide the issue number for issue(s) to close for this repository",
			Action:      closeCmd,
			Flags:       []cli.Flag{},
		},
		{
			Name:   "search",
			Usage:  "Find issues by state and keyword.",
			Action: searchCmd,
			Flags: []cli.Flag{
				cli.StringFlag{Name: "author", Value: "", Usage: "Finds issues created by a certain user"},
				cli.StringFlag{Name: "assignee", Value: "", Usage: "Finds issues that are assigned to a certain user"},
				cli.StringFlag{Name: "mentions", Value: "", Usage: "Finds issues that mention a certain user"},
				cli.StringFlag{Name: "commenter", Value: "", Usage: "Finds issues that a certain user commented on"},
				cli.StringFlag{Name: "involves", Value: "", Usage: "Finds issues that were either created by a certain user, assigned to that user, mention that user, or were commented on by that user"},
				cli.StringFlag{Name: "labels", Value: "", Usage: "Filters issues based on their labels"},
				cli.StringFlag{Name: "state", Value: "", Usage: "Filter issues based on whether they’re open or closed"},
			},
		},
		{
			Name:   "auth",
			Usage:  "Add a github token for authentication",
			Action: authCmd,
			Flags: []cli.Flag{
				cli.StringFlag{Name: "add", Value: "", Usage: "add new token for authentication"},
			},
		},
	}
}
Ejemplo n.º 20
0
func loadCommands(app *cli.App) {
	// Add top level flags and commands
	app.Action = mainCmd

	// Filters modify what type of pr to display
	filters := []cli.Flag{
		cli.BoolFlag{"no-merge", "display only prs that cannot be merged"},
		cli.BoolFlag{"lgtm", "display the number of LGTM"},
		cli.StringFlag{"state", "open", "display prs based on their state"},
		cli.BoolFlag{"new", "display prs opened in the last 24 hours"},
		cli.BoolFlag{"mine", "display only PRs I care about based on the MAINTAINERS files"},
		cli.StringFlag{"sort", "updated", "sort the prs by (created, updated, popularity, long-running)"},
	}
	// Options modify how to display prs
	options := []cli.Flag{
		cli.BoolFlag{"no-trunc", "don't truncate pr name"},
		cli.StringFlag{"user", "", "display only prs from <user>"},
		cli.StringFlag{"comment", "", "add a comment to the pr"},
	}
	app.Flags = append(filters, options...)

	// Add subcommands
	app.Commands = []cli.Command{
		{
			Name:   "repo",
			Usage:  "List information about the current repository",
			Action: repositoryInfoCmd,
		},
		{
			Name:   "auth",
			Usage:  "Add a github token for authentication",
			Action: authCmd,
			Flags: []cli.Flag{
				cli.StringFlag{"add", "", "add new token for authentication"},
				cli.StringFlag{"user", "", "add github user name"},
			},
		},
		{
			Name:   "alru",
			Usage:  "Show the Age of the Least Recently Updated pull request for this repo. Lower is better.",
			Action: alruCmd,
		},
		{
			Name:   "merge",
			Usage:  "Merge a pull request",
			Action: mergeCmd,
			Flags: []cli.Flag{
				cli.StringFlag{"m", "", "commit message for merge"},
				cli.BoolFlag{"force", "merge a pull request that has not been approved"},
			},
		},
		{
			Name:   "checkout",
			Usage:  "Checkout a pull request into your local repo",
			Action: checkoutCmd,
		},
		{
			Name:   "approve",
			Usage:  "Approve a pull request by adding LGTM to the comments",
			Action: approveCmd,
		},
		{
			Name:   "diff",
			Usage:  "Print the patch submitted by a pull request",
			Action: showCmd,
		},
		{
			Name:   "reviewers",
			Usage:  "Use the hierarchy of MAINTAINERS files to list who should review a pull request",
			Action: reviewersCmd,
		},
		{
			Name:   "contributors",
			Usage:  "Show the contributors list with additions, deletions, and commit counts. Default: sorted by Commits",
			Action: contributorsCmd,
			Flags: []cli.Flag{
				cli.BoolFlag{"additions", "sort by additions"},
				cli.BoolFlag{"deletions", "sort by deletions"},
				cli.BoolFlag{"commits", "sort by commits"},
				cli.IntFlag{"top", 10, "top N contributors"},
			},
		},
	}
}
Ejemplo n.º 21
0
				Expect(fakeExitHandler.ExitCalledWith).To(Equal([]int{1}))
			})
		})

		Describe("App.Before", func() {
			Context("when running the target command", func() {
				It("does not verify the current target", func() {
					cliConfig.SetTarget("my-lattice.example.com")
					cliConfig.Save()

					commandRan := false

					cliApp.Commands = []cli.Command{
						cli.Command{
							Name: config_command_factory.TargetCommandName,
							Action: func(ctx *cli.Context) {
								commandRan = true
							},
						},
					}

					cliAppArgs := []string{"ltc", config_command_factory.TargetCommandName}

					err := cliApp.Run(cliAppArgs)

					Expect(err).ToNot(HaveOccurred())
					Expect(fakeTargetVerifier.VerifyTargetCallCount()).To(BeZero())
					Expect(commandRan).To(BeTrue())
				})
			})

			Context("when running the help command", func() {
Ejemplo n.º 22
0
func WrapApp(app *cli.App, wrappers ...CmdWrapper) {
	app.Commands = WrapAll(app.Commands, wrappers...)
}
Ejemplo n.º 23
0
func SetAction(a *cli.App) {
	a.Commands = []cli.Command{
		{
			Name:  "auth",
			Usage: "authorize",
			Action: func(c *cli.Context) {
				_, raw, err := auth.Exec(c)
				if err != nil {
					log.Fatal(err)
					return
				}
				println(string(raw))
				return
			},
			Flags: []cli.Flag{
				cli.StringFlag{
					Name:   "email, e",
					Value:  "email",
					EnvVar: "SORACOM_EMAIL",
				},
				cli.StringFlag{
					Name:   "password, p",
					Value:  "password",
					EnvVar: "SORACOM_PASSWORD",
				},
				cli.IntFlag{
					Name:  "token-timeout-seconds, t",
					Usage: "Timeout seconds of token",
					Value: 86400,
				},
			},
		},
		{
			Name:  "password-reset",
			Usage: "password reset",
			Subcommands: []cli.Command{
				{
					Name:  "issue",
					Usage: "get token of password reset from email",
					Flags: []cli.Flag{
						cli.StringFlag{
							Name:   "email, e",
							Value:  "email",
							EnvVar: "SORACOM_EMAIL",
						},
					},
					Action: func(c *cli.Context) {
						_, raw, err := auth.ExecPasswordResetTheIssue(c)
						if err != nil {
							log.Fatal(err)
							return
						}
						println(string(raw))
						return
					},
				},
				{
					Name:  "verify",
					Usage: "verify token of password reset",
					Flags: []cli.Flag{
						cli.StringFlag{
							Name:  "new-password, p",
							Value: "new-password",
						},
						cli.StringFlag{
							Name:  "verify-token, t",
							Value: "verify-token",
						},
					},
					Action: func(c *cli.Context) {
						_, raw, err := auth.ExecPasswordResetTheVerify(c)
						if err != nil {
							log.Fatal(err)
							return
						}
						println(string(raw))
						return
					},
				},
			},
		},
		{
			Name:  "operator",
			Usage: "operator",
			Subcommands: []cli.Command{
				{
					Name:  "token",
					Usage: "Update token of operator",
					Flags: []cli.Flag{
						cli.StringFlag{
							Name:   "api-key, a",
							Value:  "api-key",
							Usage:  "api key for SORACOM",
							EnvVar: "SORACOM_API_KEY",
						},
						cli.StringFlag{
							Name:   "token, t",
							Value:  "token",
							Usage:  "token for SORACOM",
							EnvVar: "SORACOM_TOKEN",
						},
						cli.IntFlag{
							Name:  "token-timeout-seconds, timeout",
							Usage: "Timeout seconds of token (default 86400)",
							Value: 86400,
						},
						cli.StringFlag{
							Name:  "operator-id, i",
							Value: "operator-id",
							Usage: "Set operator id",
						},
					},
					Action: func(c *cli.Context) {
						_, raw, err := operator.ExecToken(c)
						if err != nil {
							log.Fatal(err)
							return
						}
						println(string(raw))
						return
					},
				},
				{
					Name:  "password",
					Usage: "Update password",
					Flags: []cli.Flag{
						cli.StringFlag{
							Name:   "api-key, a",
							Value:  "api-key",
							Usage:  "api key for SORACOM",
							EnvVar: "SORACOM_API_KEY",
						},
						cli.StringFlag{
							Name:   "token, t",
							Value:  "token",
							Usage:  "token for SORACOM",
							EnvVar: "SORACOM_TOKEN",
						},
						cli.StringFlag{
							Name:  "operator-id, i",
							Value: "operator-id",
							Usage: "Set operator id",
						},
						cli.StringFlag{
							Name:  "current-password, c",
							Value: "current-password",
							Usage: "current password for SORACOM",
						},
						cli.StringFlag{
							Name:  "new-password, n",
							Value: "new-password",
							Usage: "new password for SORACOM",
						},
					},
					Action: func(c *cli.Context) {
						_, raw, err := operator.ExecPassword(c)
						if err != nil {
							log.Fatal(err)
							return
						}
						println(string(raw))
						return
					},
				},
				{
					Name:  "support_token",
					Usage: "get of token for support",
					Flags: []cli.Flag{
						cli.StringFlag{
							Name:   "api-key, a",
							Value:  "api-key",
							Usage:  "api key for SORACOM",
							EnvVar: "SORACOM_API_KEY",
						},
						cli.StringFlag{
							Name:   "token, t",
							Value:  "token",
							Usage:  "token for SORACOM",
							EnvVar: "SORACOM_TOKEN",
						},
						cli.StringFlag{
							Name:  "operator-id, i",
							Value: "operator-id",
							Usage: "Set operator id",
						},
					},
					Action: func(c *cli.Context) {
						_, raw, err := operator.ExecSupportToken(c)
						if err != nil {
							log.Fatal(err)
							return
						}
						println(string(raw))
						return
					},
				},
				{
					Name:  "invitation",
					Usage: "invitation new user",
					Flags: []cli.Flag{
						cli.StringFlag{
							Name:   "api-key, a",
							Value:  "api-key",
							Usage:  "api key for SORACOM",
							EnvVar: "SORACOM_API_KEY",
						},
						cli.StringFlag{
							Name:   "token, t",
							Value:  "token",
							Usage:  "token for SORACOM",
							EnvVar: "SORACOM_TOKEN",
						},
						cli.StringFlag{
							Name:  "email, e",
							Value: "email",
							Usage: "email for invitaiton",
						},
						cli.StringFlag{
							Name:  "password, p",
							Value: "password",
							Usage: "password for invitation user",
						},
					},
					Action: func(c *cli.Context) {
						_, raw, err := operator.ExecOperators(c)
						if err != nil {
							log.Fatal(err)
							return
						}
						println(string(raw))
						return
					},
				},
				{
					Name:  "verify",
					Usage: "verify of invitation user",
					Flags: []cli.Flag{
						cli.StringFlag{
							Name:   "api-key, a",
							Value:  "api-key",
							Usage:  "api key for SORACOM",
							EnvVar: "SORACOM_API_KEY",
						},
						cli.StringFlag{
							Name:   "token, t",
							Value:  "token",
							Usage:  "token for SORACOM",
							EnvVar: "SORACOM_TOKEN",
						},
						cli.StringFlag{
							Name:  "verify-token",
							Value: "verify-token",
							Usage: "verify token for intivation user",
						},
					},
					Action: func(c *cli.Context) {
						_, raw, err := operator.ExecVerify(c)
						if err != nil {
							log.Fatal(err)
							return
						}
						println(string(raw))
						return
					},
				},
				{
					Name:  "info",
					Usage: "get information of operator",
					Flags: []cli.Flag{
						cli.StringFlag{
							Name:   "api-key, a",
							Value:  "api-key",
							Usage:  "api key for SORACOM",
							EnvVar: "SORACOM_API_KEY",
						},
						cli.StringFlag{
							Name:   "token, t",
							Value:  "token",
							Usage:  "token for SORACOM",
							EnvVar: "SORACOM_TOKEN",
						},
						cli.StringFlag{
							Name:  "operator-id, i",
							Value: "operator-id",
							Usage: "Set operator id",
						},
					},
					Action: func(c *cli.Context) {
						_, raw, err := operator.ExecOperatorInfo(c)
						if err != nil {
							log.Fatal(err)
							return
						}
						println(string(raw))
						return
					},
				},
			},
		},
	}
}
Ejemplo n.º 24
0
func main() {
	var app *cli.App
	app = cli.NewApp()
	app.Name = "awsutils"
	app.Usage = "automation of Amazon Web Services configurations through their API"
	app.EnableBashCompletion = true
	app.Commands = []cli.Command{
		{
			Name:  "iam",
			Usage: "use the AWS iam API",
			Subcommands: []cli.Command{
				{
					Name:  "certs",
					Usage: "summarise certificate configurations available in your AWS account",
					Action: func(c *cli.Context) {
						out, err := exec.Command("aws", "iam", "list-server-certificates").Output()
						if err != nil {
							fmt.Println(err.Error())
							return
						}

						var r ListServerCertificatesResponse
						err = json.Unmarshal(out, &r)
						if err != nil {
							fmt.Println(err.Error())
							return
						}

						w := tabwriter.NewWriter(os.Stdout, 0, 4, 3, ' ', 0)
						fmt.Fprint(w, "ID\tName\tStatus\n")
						for _, cm := range r.ServerCertificateMetadataList {
							fmt.Fprintf(w, "%s\t%s\t%s\n", cm.ServerCertificateID, cm.ServerCertificateName, ResolveStatus(cm.Expiration))
						}
						w.Flush()
						// fmt.Printf("%+v\n", r)
					},
				},
			},
		},
		{
			Name:    "cloudfront",
			Aliases: []string{"cf"},
			Usage:   "use the AWS cloudfront API",
			Subcommands: []cli.Command{
				{
					Name:  "export-configs",
					Usage: "export the cloudfront distribution configurations",
					Action: func(c *cli.Context) {
						out, err := exec.Command("aws", "cloudfront", "list-distributions").Output()
						if err != nil {
							fmt.Println(err.Error())
							return
						}

						var r CloudFrontListDistributionsResponse
						err = json.Unmarshal(out, &r)
						if err != nil {
							fmt.Println(err.Error())
							return
						}

						w := tabwriter.NewWriter(os.Stdout, 0, 4, 3, ' ', 0)
						fmt.Fprint(w, "DomainName\n")
						for _, d := range r.Distributionlist.Items {
							fmt.Fprintf(w, "%+v\n", d.Origins.Items[0]["DomainName"])
							json, _ := json.MarshalIndent(d, "", "  ")

							fn := fmt.Sprintf("%s.json", d.Origins.Items[0]["Id"])
							f, err := os.Create(fn)
							if err != nil {
								cwd, _ := os.Getwd()
								fmt.Printf("Unable to create file '%s' in '%s'", fn, cwd)
								continue
							}
							f.Write(json)
							f.Close()
						}
						w.Flush()
					},
				},
				{
					Name:  "dists",
					Usage: "summarize the cloudfront distribution configurations",
					Flags: []cli.Flag{
						cli.StringFlag{
							Name:  "order-by",
							Value: "alias",
							Usage: "sort results on alias|origin|status",
						},
						cli.BoolFlag{
							Name:  "csv",
							Usage: "output as csv",
						},
					},
					Action: func(c *cli.Context) {
						out, err := exec.Command("aws", "cloudfront", "list-distributions").Output()
						if err != nil {
							fmt.Println(err.Error())
							return
						}

						var r CloudFrontListDistributionsResponse
						err = json.Unmarshal(out, &r)
						if err != nil {
							fmt.Println(err.Error())
							return
						}

						var list []DistSummary
						for _, d := range r.Distributionlist.Items {
							id := d.ID
							distDomain := d.DomainName
							status := d.Status
							origin := ""
							alias := ""

							if len(d.Origins.Items) > 0 {
								for _, o := range d.Origins.Items {
									if op, ok := o["OriginPath"].(string); ok && op == "" {
										origin = o["DomainName"].(string)
									}
								}
							}
							if len(d.Aliases.Items) > 0 {
								alias = strings.Join(d.Aliases.Items, ",")
							}

							list = append(list, DistSummary{ID: id, Domain: distDomain, Alias: alias, Origin: origin, Status: status})
						}

						switch c.String("order-by") {
						case "origin":
							sort.Sort(ByOrigin(list))
						case "status":
							sort.Sort(ByStatus(list))
						case "alias":
							sort.Sort(ByAlias(list))
						default:
							fmt.Println("Unrecognised value for", c.String("order-by"), ". Sorting by alias instead.")
							sort.Sort(ByAlias(list))
						}

						if c.Bool("csv") {
							fmt.Println("ID;Domain;Alias;Origin;Status")
							for _, s := range list {
								fmt.Printf(`"%s";"%s";"%s";"%s";"%s"`, s.ID, s.Domain, s.Alias, s.Origin, s.Status)
								fmt.Println()
							}
						} else {
							w := tabwriter.NewWriter(os.Stdout, 0, 4, 3, ' ', 0)
							fmt.Fprint(w, "ID\tDomain\tAlias\tOrigin\tStatus\n")
							for _, s := range list {
								fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\n", s.ID, s.Domain, s.Alias, s.Origin, s.Status)
							}
							w.Flush()
						}
					},
				},
			},
		},
	}

	app.Run(os.Args)
}
Ejemplo n.º 25
0
func cmds(app *cli.App) {
	app.Commands = []cli.Command{
		{
			Name:  "clean",
			Usage: "Clean package cache",
			Action: func(c *cli.Context) error {
				if len(c.Args()) == 1 {
					println(c.Args()[0])
				} else {
					cli.ShowSubcommandHelp(c)
				}
				return nil
			},
		},

		{
			Name:  "generate",
			Usage: "Generate package buildfiles",
			Action: func(c *cli.Context) error {
				if len(c.Args()) == 1 {
					println(c.Args()[0])
				} else {
					cli.ShowSubcommandHelp(c)
				}
				return nil
			},
		},

		{
			Name:  "info",
			Usage: "Print package info",
			Action: func(c *cli.Context) error {
				if len(c.Args()) == 1 {
					println(c.Args()[0])
				} else {
					cli.ShowSubcommandHelp(c)
				}
				return nil
			},
		},

		{
			Name:  "install",
			Usage: "Install packages",
			BashComplete: func(c *cli.Context) {
				flags := []string{
					"--force",
					"--no-script",
					"--skip-checksum",
				}
				if len(c.Args()) > 0 {
					return
				}
				for _, f := range flags {
					fmt.Println(f)
				}
			},
			Flags: []cli.Flag{
				cli.BoolFlag{
					Name:  "force, f",
					Usage: "Force install",
				},
				cli.BoolFlag{
					Name:  "no-script, n",
					Usage: "Do not run install script",
				},
				cli.BoolFlag{
					Name:  "skip-checksum, s",
					Usage: "Skip checksum",
				},
			},
			Action: func(c *cli.Context) error {
				if len(c.Args()) > 0 {
					for i := 0; i < len(c.Args()); i++ {
						p := parcel.New(c.GlobalString("root"))
						p.Install(c.Args()[i], c)
					}
				} else {
					cli.ShowSubcommandHelp(c)
				}
				return nil
			},
		},

		{
			Name:  "list",
			Usage: "List packages",
			Flags: []cli.Flag{
				cli.BoolFlag{
					Name:  "all, a",
					Usage: "List all info",
				},
				cli.BoolFlag{
					Name:  "checksum, c",
					Usage: "List installation status",
				},
				cli.BoolFlag{
					Name:  "description, d",
					Usage: "List description",
				},
				cli.BoolFlag{
					Name:  "status, s",
					Usage: "List installation status",
				},
			},
			Action: func(c *cli.Context) error {
				p := parcel.New(c.GlobalString("root"))
				p.List(c)
				return nil
			},
		},

		{
			Name:  "make",
			Usage: "Make package from source",
			Action: func(c *cli.Context) error {
				p := parcel.New(c.GlobalString("root"))
				if _, err := os.Stat("Makefile"); err == nil {
					p.Make(c.Args())
				} else {
					cli.ShowSubcommandHelp(c)
				}
				return nil
			},
		},

		{
			Name:  "pack",
			Usage: "Pack package tarball",
			Flags: []cli.Flag{
				cli.BoolFlag{
					Name:  "test, t",
					Usage: "Test package. Do not update database.",
				},
			},
			Action: func(c *cli.Context) error {
				p := parcel.New(c.GlobalString("root"))
				if _, err := os.Stat("Makefile"); err == nil && len(c.Args()) == 2 {
					p.Pack(c)
				} else {
					cli.ShowSubcommandHelp(c)
				}
				return nil
			},
		},

		{
			Name:  "fetch",
			Usage: "Fetch package from server",
			Action: func(c *cli.Context) error {
				p := parcel.New(c.GlobalString("root"))
				if len(c.Args()) == 1 {
					p.Fetch(c.Args()[0], "/")
				} else {
					cli.ShowSubcommandHelp(c)
				}
				return nil
			},
		},

		{
			Name:  "remove",
			Usage: "Remove packages",
			Action: func(c *cli.Context) error {
				if len(c.Args()) == 1 {
					println(c.Args()[0])
				} else {
					cli.ShowSubcommandHelp(c)
				}
				return nil
			},
		},

		{
			Name:  "search",
			Usage: "Search for packages",
			Action: func(c *cli.Context) error {
				if len(c.Args()) == 1 {
					println(c.Args()[0])
				} else {
					cli.ShowSubcommandHelp(c)
				}
				return nil
			},
		},

		{
			Name:  "show",
			Usage: "Show package files",
			Action: func(c *cli.Context) error {
				if len(c.Args()) == 1 {
					println(c.Args()[0])
				} else {
					cli.ShowSubcommandHelp(c)
				}
				return nil
			},
		},

		{
			Name:  "update",
			Usage: "Update package database",
			Action: func(c *cli.Context) error {
				config := cfg.Load("/etc/parcel/settings.ini")
				parcel.UpdateDatabase(c.GlobalString("root"), config)
				return nil
			},
		},
	}
}
Ejemplo n.º 26
0
					Expect(flagList).Should(ContainElement(t.Name))
				case cli.BoolFlag:
					Expect(flagList).Should(ContainElement(t.Name))
				case cli.DurationFlag:
					Expect(flagList).Should(ContainElement(t.Name))
				}
			}
		})

		It("does not append unexpected flag types", func() {
			cliApp = cli.NewApp()
			cliGenericFlag := cli.GenericFlag{Name: "capture-the-flag"}
			cliApp.Commands = []cli.Command{
				cli.Command{
					Name: "commander-keen",
					Flags: []cli.Flag{
						cliGenericFlag,
					},
				},
			}

			flagList := main.GetCommandFlags(cliApp, "commander-keen")
			Expect(flagList).ToNot(ContainElement(cliGenericFlag.Name))
		})
	})

	Describe("GetByCmdName", func() {
		It("returns command not found error", func() {
			_, err := main.GetByCmdName(cliApp, "zz")

			Expect(err).To(MatchError("Command not found"))
		})