func realMain() int {
args := os.Args[1:]
for _, arg := range args {
if arg == "-v" || arg == "--version" {
newArgs := make([]string, len(args)+1)
copy(newArgs[1:], args)
args = newArgs
break
}
}
cli := &cli.CLI{
Args: args,
Commands: Commands,
HelpFunc: cli.BasicHelpFunc("Baggage"),
}
exitCode, err := cli.Run()
if err != nil {
fmt.Fprintf(os.Stderr, "Error executing CLI: %s\n", err.Error())
return 1
}
return exitCode
}
func main() {
args := os.Args[1:]
// Get the command line args. We shortcut "--version" and "-v" to
// just show the version.
for _, arg := range args {
if arg == "-v" || arg == "--version" {
newArgs := make([]string, 1)
newArgs[0] = "version"
args = newArgs
break
}
}
cli := &cli.CLI{
Args: args,
Commands: Commands,
HelpFunc: cli.BasicHelpFunc("sr6"),
}
exitCode, err := cli.Run()
if err != nil {
fmt.Fprintf(os.Stderr, "Error executing CLI: %s\n", err.Error())
os.Exit(1)
}
os.Exit(exitCode)
}
// Just our main function to kick things off in a loop.
func realMain() int {
args := os.Args[1:]
for _, arg := range args {
if arg == "-v" || arg == "-version" || arg == "--version" {
newArgs := make([]string, len(args)+1)
newArgs[0] = "version"
copy(newArgs[1:], args)
args = newArgs
break
}
}
cli := &cli.CLI{
Args: args,
Commands: Commands,
HelpFunc: cli.FilteredHelpFunc(
CommandsInclude, cli.BasicHelpFunc("consul-snapshot")),
HelpWriter: os.Stdout,
}
exitCode, err := cli.Run()
if err != nil {
log.Fatalf("Error executing CLI: %s", err.Error())
return 1
}
return exitCode
}
// main - run our app
func main() {
args := os.Args[1:]
for _, arg := range args {
if arg == "-v" || arg == "--version" {
newArgs := make([]string, len(args)+1)
newArgs[0] = "version"
copy(newArgs[1:], args)
args = newArgs
break
}
}
cli := &cli.CLI{
Args: args,
Commands: Commands,
HelpFunc: cli.BasicHelpFunc("cloudconfig"),
}
exitCode, err := cli.Run()
if err != nil {
fmt.Fprintf(os.Stderr, "Error executing CLI: %s\n", err.Error())
}
os.Exit(exitCode)
}
func realMain(args []string, commands map[string]cli.CommandFactory) int {
for _, arg := range args {
if arg == "-v" || arg == "-version" || arg == "--version" {
newArgs := make([]string, len(args)+1)
newArgs[0] = "version"
copy(newArgs[1:], args)
args = newArgs
break
}
}
cmdNames := make([]string, 0, len(commands))
for cmdName := range commands {
cmdNames = append(cmdNames, cmdName)
}
cli := &cli.CLI{
Args: args,
Commands: commands,
HelpFunc: cli.FilteredHelpFunc(cmdNames, cli.BasicHelpFunc("gypsy")),
}
exitCode, err := cli.Run()
if err != nil {
log.Warnf("Error executing CLI: %s", err.Error())
return 1
}
return exitCode
}
// RunCustom execute mitchellh/cli and return its exit code.
func RunCustom(args []string, commands map[string]cli.CommandFactory) int {
for _, arg := range args {
// If the following options are provided,
// then execute gcli version command
if arg == "-v" || arg == "-version" || arg == "--version" {
args[1] = "version"
break
}
// Generating godoc (doc.go). This is only for gcli developper.
if arg == "-godoc" {
return runGodoc(commands)
}
}
cli := &cli.CLI{
Args: args[1:],
Commands: commands,
Version: Version,
HelpFunc: cli.BasicHelpFunc(Name),
HelpWriter: os.Stdout,
}
exitCode, err := cli.Run()
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to execute: %s\n", err.Error())
}
return exitCode
}
func main() {
log.SetOutput(ioutil.Discard)
args := os.Args[1:]
for _, arg := range args {
if arg == "--" {
break
}
if arg == "-v" || arg == "--version" {
fmt.Printf("%s v%s\n", Name, Version)
os.Exit(0)
}
}
cli := &cli.CLI{
Args: args,
Commands: Commands,
HelpFunc: cli.BasicHelpFunc("consulacl"),
}
exitCode, err := cli.Run()
if err != nil {
fmt.Fprintf(os.Stderr, "Error executing CLI: %s\n", err.Error())
os.Exit(1)
}
os.Exit(exitCode)
}
func run() (int, error) {
conf, err := config.Load()
if err != nil {
log.Fatalln(err)
}
c := &cli.CLI{
Name: aionName,
Version: aionVersion,
Args: os.Args[1:],
HelpFunc: cli.BasicHelpFunc(aionName),
Commands: map[string]cli.CommandFactory{
"show": command.NewShow(conf),
"version": command.NewVersion(aionVersion),
},
}
retval, err := c.Run()
if err != nil {
fmt.Fprintf(os.Stderr, "Error executing CLI: %s\n", err.Error())
return 1, err
}
return retval, nil
}
func realMain() int {
args := os.Args[1:]
// Get the command line args. We shortcut "--version" and "-v" to
// just show the version.
// Copied from https://github.com/hashicorp/consul/blob/master/main.go
for _, arg := range args {
if arg == "-v" || arg == "--version" {
newArgs := make([]string, len(args)+1)
newArgs[0] = "version"
copy(newArgs[1:], args)
args = newArgs
break
}
}
cli := &cli.CLI{
Args: args,
Commands: Commands,
HelpFunc: cli.BasicHelpFunc("spark"),
}
exitCode, err := cli.Run()
if err != nil {
fmt.Fprintf(os.Stderr, "Error executing CLI: %s\n", err.Error())
return 1
}
return exitCode
}
func main() {
ui = &cli.BasicUi{Writer: os.Stdout}
app := &cli.CLI{
HelpFunc: cli.BasicHelpFunc("spored"),
Args: os.Args[1:],
Version: env.VERSION,
Commands: map[string]cli.CommandFactory{
"crawl": func() (cli.Command, error) {
return &command.CrawlCommand{ui}, nil
},
"serve": func() (cli.Command, error) {
return &command.ServeCommand{ui}, nil
},
"stat": func() (cli.Command, error) {
return &command.StatCommand{ui}, nil
},
"total": func() (cli.Command, error) {
return &command.TotalCommand{ui}, nil
},
},
}
exitCode, err := app.Run()
if err != nil {
log.Println(err)
}
os.Exit(exitCode)
}
func realMain() int {
log.SetOutput(ioutil.Discard)
// Get the command line args. We shortcut "--version" and "-v" to
// just show the version.
args := os.Args[1:]
for _, arg := range args {
if arg == "-v" || arg == "--version" {
newArgs := make([]string, len(args)+1)
newArgs[0] = "version"
copy(newArgs[1:], args)
args = newArgs
break
}
}
cli := &cli.CLI{
Args: args,
Commands: Commands,
HelpFunc: cli.BasicHelpFunc("consul"),
}
exitCode, err := cli.Run()
if err != nil {
fmt.Fprintf(os.Stderr, "Error executing CLI: %s\n", err.Error())
return 1
}
return exitCode
}
func RunCustom(args []string, commands map[string]cli.CommandFactory) int {
// Get the command line args. We shortcut "--version" and "-v" to
// just show the version.
for _, arg := range args {
if arg == "-v" || arg == "-version" || arg == "--version" {
newArgs := make([]string, len(args)+1)
newArgs[0] = "version"
copy(newArgs[1:], args)
args = newArgs
break
}
}
cli := &cli.CLI{
Args: args,
Commands: commands,
Version: Version,
HelpFunc: cli.BasicHelpFunc(Name),
HelpWriter: os.Stdout,
}
exitCode, err := cli.Run()
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to execute: %s\n", err.Error())
}
return exitCode
}
func realMain() int {
ui = &cli.BasicUi{Writer: os.Stdout}
cli := &cli.CLI{
Args: os.Args[1:],
Commands: map[string]cli.CommandFactory{
"up": func() (cli.Command, error) {
return &UpCommand{}, nil
},
"down": func() (cli.Command, error) {
return &DownCommand{}, nil
},
"redo": func() (cli.Command, error) {
return &RedoCommand{}, nil
},
"status": func() (cli.Command, error) {
return &StatusCommand{}, nil
},
},
HelpFunc: cli.BasicHelpFunc("sql-migrate"),
Version: "1.0.0",
}
exitCode, err := cli.Run()
if err != nil {
fmt.Fprintf(os.Stderr, "Error executing CLI: %s\n", err.Error())
return 1
}
return exitCode
}
func main() {
// Get the command line args. We shortcut "--version" and "-v" to
// just show the version.
args := os.Args[1:]
for _, arg := range args {
if arg == "-v" || arg == "--version" {
newArgs := make([]string, len(args)+1)
newArgs[0] = "version"
copy(newArgs[1:], args)
args = newArgs
break
}
}
c := cli.NewCLI("dkron", VERSION)
c.Args = args
c.HelpFunc = cli.BasicHelpFunc("dkron")
ui := &cli.BasicUi{Writer: os.Stdout}
plugins := &Plugins{}
plugins.DiscoverPlugins()
// Make sure we clean up any managed plugins at the end of this
defer plugin.CleanupClients()
c.Commands = map[string]cli.CommandFactory{
"agent": func() (cli.Command, error) {
return &dkron.AgentCommand{
Ui: ui,
Version: VERSION,
ProcessorPlugins: plugins.Processors,
}, nil
},
"keygen": func() (cli.Command, error) {
return &dkron.KeygenCommand{
Ui: ui,
}, nil
},
"version": func() (cli.Command, error) {
return &dkron.VersionCommand{
Version: VERSION,
Ui: ui,
}, nil
},
}
exitStatus, err := c.Run()
if err != nil {
fmt.Fprintf(os.Stderr, "Error executing CLI: %s\n", err.Error())
os.Exit(1)
}
os.Exit(exitStatus)
}
func wrappedMain() int {
// Make sure we cleanup any plugins that were launched.
defer plugin.CleanupClients()
log.SetOutput(os.Stderr)
log.Printf(
"[INFO] Otto version: %s %s %s",
Version, VersionPrerelease, GitCommit)
// Setup signal handlers
initSignalHandlers()
// Load the configuration
config := BuiltinConfig
// Run checkpoint
go runCheckpoint(&config)
// Get the command line args. We shortcut "--version" and "-v" to
// just show the version.
args := os.Args[1:]
for _, arg := range args {
if arg == "-v" || arg == "-version" || arg == "--version" {
newArgs := make([]string, len(args)+1)
newArgs[0] = "version"
copy(newArgs[1:], args)
args = newArgs
break
}
}
cli := &cli.CLI{
Args: args,
Commands: Commands,
HelpFunc: cli.FilteredHelpFunc(
CommandsInclude, cli.BasicHelpFunc("otto")),
HelpWriter: os.Stdout,
}
exitCode, err := cli.Run()
if err != nil {
Ui.Error(fmt.Sprintf("Error executing CLI: %s", err.Error()))
return 1
}
return exitCode
}
func realMain() int {
cli := &cli.CLI{
Args: os.Args[1:],
Commands: Commands,
HelpFunc: cli.BasicHelpFunc("aneto"),
HelpWriter: os.Stdout,
Version: version.Version,
}
exitCode, err := cli.Run()
if err != nil {
Ui.Error(fmt.Sprintf("Error executing CLI: %s", err.Error()))
return 1
}
return exitCode
}
func run() int {
args := os.Args[1:]
cli := &cli.CLI{
Args: args,
Commands: command.Commands,
HelpFunc: cli.BasicHelpFunc("screwdriver"),
HelpWriter: os.Stdout,
}
exitCode, err := cli.Run()
if err != nil {
utils.ErrorOutput(err.Error())
return 1
}
return exitCode
}
func realMain() int {
args := os.Args[1:]
cli := &cli.CLI{
Name: "Depro",
Version: Version,
Commands: common.Commands(),
Args: args,
HelpFunc: cli.BasicHelpFunc("depro"),
}
exitCode, err := cli.Run()
if err != nil {
fmt.Fprintf(os.Stderr, "Error executing CLI: %s\n", err.Error())
return 1
}
return exitCode
}
// excludeHelpFunc filters commands we don't want to show from the list of
// commands displayed in packer's help text.
func excludeHelpFunc(commands map[string]cli.CommandFactory, exclude []string) cli.HelpFunc {
// Make search slice into a map so we can use use the `if found` idiom
// instead of a nested loop.
var excludes = make(map[string]interface{}, len(exclude))
for _, item := range exclude {
excludes[item] = nil
}
// Create filtered list of commands
helpCommands := []string{}
for command := range commands {
if _, found := excludes[command]; !found {
helpCommands = append(helpCommands, command)
}
}
return cli.FilteredHelpFunc(helpCommands, cli.BasicHelpFunc("packer"))
}
func main() {
args := os.Args[1:]
handleCommandOutsideOfProjectDir(args)
cli := &cli.CLI{
Args: args,
Commands: Commands,
HelpFunc: cli.BasicHelpFunc("fuel"),
}
exitStatus, err := cli.Run()
if err != nil {
log.Println(err)
}
os.Exit(exitStatus)
}
func realMain() int {
args := os.Args[1:]
c := &cli.CLI{
Args: args,
Version: "0.0.0",
Commands: Commands,
HelpFunc: cli.BasicHelpFunc("tool"),
}
exitCode, err := c.Run()
if err != nil {
fmt.Fprintf(os.Stderr, "Error executing CLI: %s\n", err)
return 1
}
return exitCode
}
func main() {
args := os.Args[1:]
// Get the command line args. We shortcut "--version" and "-v" to
// just show the version.
for _, arg := range args {
if arg == "-v" || arg == "--version" {
newArgs := make([]string, 1)
newArgs[0] = "version"
args = newArgs
break
}
}
cli := &cli.CLI{
Args: args,
Commands: Commands,
HelpFunc: cli.BasicHelpFunc("mixpanel"),
}
exitCode, err := cli.Run()
if err != nil {
fmt.Fprintf(os.Stderr, "Error executing CLI: %s\n", err.Error())
os.Exit(1)
}
os.Exit(exitCode)
// config, err := api.DefaultConfig()
// if err != nil {
// log.Fatal(err)
// }
// q := &api.QueryOptions{
// Key: config.Key,
// Secret: config.Secret,
// Expire: "1445934932",
// FromDate: "2015-01-02",
// ToDate: "2015-01-02",
// Format: "json",
// }
// client := api.NewClient(*config)
// client.Export(q)
}
func wrappedMain() int {
log.SetOutput(os.Stderr)
log.Printf("[INFO] KuuYee Otto version: %s %s %s", Version, VersionPrerelease, GitCommit)
// 设置信号处理器
initSignalHandlers()
// 载入配置
config := BuiltinConfig
fmt.Printf("[KuuYee]====> config: %+v\n", config)
// 运行检查点
go runCheckpoint(&config)
// 获取命令行参数。通过"--version"和"-v"显示版本
args := os.Args[1:]
for _, arg := range args {
if arg == "-v" || arg == "-version" || arg == "--version" {
newArgs := make([]string, len(args)+1)
newArgs[0] = "version"
copy(newArgs[1:], args)
args = newArgs
break
}
}
cli := &cli.CLI{
Args: args,
Commands: Commands,
HelpFunc: cli.FilteredHelpFunc(
CommandsInclude, cli.BasicHelpFunc("otto")),
HelpWriter: os.Stdout,
}
exitCode, err := cli.Run()
if err != nil {
Ui.Error(fmt.Sprintf("Error executing CLI: %s", err.Error()))
return 1
}
return exitCode
}
func wrappedMain() int {
log.SetOutput(os.Stderr)
// Load the configuration
config := BuiltinConfig
// Make sure we clean up any managed plugins at the end of this
defer plugin.CleanupClients()
// Initialize the TFConfig settings for the commands...
ContextOpts.Providers = config.ProviderFactories()
ContextOpts.Provisioners = config.ProvisionerFactories()
// Get the command line args. We shortcut "--version" and "-v" to
// just show the version.
args := os.Args[1:]
for _, arg := range args {
if arg == "-v" || arg == "-version" || arg == "--version" {
newArgs := make([]string, len(args)+1)
newArgs[0] = "version"
copy(newArgs[1:], args)
args = newArgs
break
}
}
cli := &cli.CLI{
Args: args,
Commands: Commands,
HelpFunc: cli.BasicHelpFunc("terraform"),
HelpWriter: os.Stdout,
}
exitCode, err := cli.Run()
if err != nil {
fmt.Fprintf(os.Stderr, "Error executing CLI: %s\n", err.Error())
return 1
}
return exitCode
}
func RunCustom(args []string, commands map[string]cli.CommandFactory) int {
// Get the command line args. We shortcut "--version" and "-v" to
// just show the version.
for _, arg := range args {
if arg == "-v" || arg == "-version" || arg == "--version" {
newArgs := make([]string, len(args)+1)
newArgs[0] = "version"
copy(newArgs[1:], args)
args = newArgs
break
}
}
// Build the commands to include in the help now.
commandsInclude := make([]string, 0, len(commands))
for k, _ := range commands {
switch k {
case "executor":
case "syslog":
case "fs ls", "fs cat", "fs stat":
case "check":
default:
commandsInclude = append(commandsInclude, k)
}
}
cli := &cli.CLI{
Args: args,
Commands: commands,
HelpFunc: cli.FilteredHelpFunc(commandsInclude, cli.BasicHelpFunc("nomad")),
}
exitCode, err := cli.Run()
if err != nil {
fmt.Fprintf(os.Stderr, "Error executing CLI: %s\n", err.Error())
return 1
}
return exitCode
}
func main() {
// Get the command line args. We shortcut "--version" and "-v" to
// just show the version.
args := os.Args[1:]
for _, arg := range args {
if arg == "-v" || arg == "--version" {
newArgs := make([]string, len(args)+1)
newArgs[0] = "version"
copy(newArgs[1:], args)
args = newArgs
break
}
}
c := cli.NewCLI("dkron", VERSION)
c.Args = args
c.HelpFunc = cli.BasicHelpFunc("dkron")
ui := &cli.BasicUi{Writer: os.Stdout}
c.Commands = map[string]cli.CommandFactory{
"server": func() (cli.Command, error) {
return &swiss.ServerCommand{
Ui: ui,
Version: VERSION,
}, nil
},
"worker": func() (cli.Command, error) {
return &swiss.Worker{}, nil
},
}
exitStatus, err := c.Run()
if err != nil {
fmt.Fprintf(os.Stderr, "Error executing CLI: %s\n", err.Error())
os.Exit(1)
}
os.Exit(exitStatus)
}
func main() {
c := cli.NewCLI("dcron", VERSION)
c.Args = os.Args[1:]
c.HelpFunc = cli.BasicHelpFunc("dcron")
ui := &cli.BasicUi{Writer: os.Stdout}
c.Commands = map[string]cli.CommandFactory{
"agent": func() (cli.Command, error) {
return &dcron.AgentCommand{
Ui: ui,
Version: VERSION,
}, nil
},
}
exitStatus, err := c.Run()
if err != nil {
log.Println(err)
}
os.Exit(exitStatus)
}
//DoMain runs the Xavi command line. This is packed as a reusable piece of code
//to allow directives to be registered via import into a main program
func DoMain(args []string, kvs kvstore.KVStore, writer io.Writer) int {
if err := commandSetup(kvs, writer); err != nil {
fmt.Println("Error setting up command line interface: ", err.Error())
return 1
}
cli := &cli.CLI{
Args: args,
Commands: xaviCommands,
HelpFunc: cli.BasicHelpFunc("xavi"),
HelpWriter: writer,
}
exitCode, err := cli.Run()
if err != nil {
fmt.Fprintf(os.Stderr, "Error executing CLI: %s\n", err.Error())
return 1
}
return exitCode
}
func main() {
args := os.Args[1:]
var err error
Config, err = config.CreatePolkaHomeConfigAsNeeded()
if err != nil {
log.Panic(err)
}
handleCommandOutsideOfProjectDir(args)
cli := &cli.CLI{
Args: args,
Commands: Commands,
HelpFunc: cli.BasicHelpFunc("polka"),
}
exitStatus, err := cli.Run()
if err != nil {
log.Println(err)
}
os.Exit(exitStatus)
}
// wrappedMain is called only when we're wrapped by panicwrap and
// returns the exit status to exit with.
func wrappedMain() int {
// If there is no explicit number of Go threads to use, then set it
if os.Getenv("GOMAXPROCS") == "" {
runtime.GOMAXPROCS(runtime.NumCPU())
}
log.SetOutput(os.Stderr)
log.Printf(
"[INFO] Packer version: %s %s %s",
Version, VersionPrerelease, GitCommit)
log.Printf("Packer Target OS/Arch: %s %s", runtime.GOOS, runtime.GOARCH)
log.Printf("Built with Go Version: %s", runtime.Version())
// Prepare stdin for plugin usage by switching it to a pipe
setupStdin()
config, err := loadConfig()
if err != nil {
fmt.Fprintf(os.Stderr, "Error loading configuration: \n\n%s\n", err)
return 1
}
log.Printf("Packer config: %+v", config)
// Fire off the checkpoint.
go runCheckpoint(config)
cacheDir := os.Getenv("PACKER_CACHE_DIR")
if cacheDir == "" {
cacheDir = "packer_cache"
}
cacheDir, err = filepath.Abs(cacheDir)
if err != nil {
fmt.Fprintf(os.Stderr, "Error preparing cache directory: \n\n%s\n", err)
return 1
}
log.Printf("Setting cache directory: %s", cacheDir)
cache := &packer.FileCache{CacheDir: cacheDir}
// Determine if we're in machine-readable mode by mucking around with
// the arguments...
args, machineReadable := extractMachineReadable(os.Args[1:])
defer plugin.CleanupClients()
// Setup the UI if we're being machine-readable
var ui packer.Ui = &packer.BasicUi{
Reader: os.Stdin,
Writer: os.Stdout,
ErrorWriter: os.Stdout,
}
if machineReadable {
ui = &packer.MachineReadableUi{
Writer: os.Stdout,
}
// Set this so that we don't get colored output in our machine-
// readable UI.
if err := os.Setenv("PACKER_NO_COLOR", "1"); err != nil {
fmt.Fprintf(os.Stderr, "Packer failed to initialize UI: %s\n", err)
return 1
}
}
// Create the CLI meta
CommandMeta = &command.Meta{
CoreConfig: &packer.CoreConfig{
Components: packer.ComponentFinder{
Builder: config.LoadBuilder,
Hook: config.LoadHook,
PostProcessor: config.LoadPostProcessor,
Provisioner: config.LoadProvisioner,
},
},
Cache: cache,
Ui: ui,
}
//setupSignalHandlers(env)
cli := &cli.CLI{
Args: args,
Commands: Commands,
HelpFunc: cli.BasicHelpFunc("packer"),
HelpWriter: os.Stdout,
Version: Version,
}
exitCode, err := cli.Run()
if err != nil {
fmt.Fprintf(os.Stderr, "Error executing CLI: %s\n", err)
return 1
}
return exitCode
}