// Run command.
func run(c *cobra.Command, args []string) error {
root.Project.Concurrency = concurrency
c.Root().PersistentFlags().Lookup("name string")
if err := root.Project.LoadFunctions(args...); err != nil {
return err
}
for _, s := range root.Env {
parts := strings.Split(s, "=")
root.Project.Setenv(parts[0], parts[1])
}
return root.Project.DeployAndClean()
}
func runGenAutocompleteCmd(cmd *cobra.Command, args []string) error {
if err := cmd.Root().GenBashCompletionFile(autoCompletePath); err != nil {
return err
}
fmt.Println("Generated bash completion file", autoCompletePath)
return nil
}
func runGenManCmd(cmd *cobra.Command, args []string) error {
info := build.GetInfo()
header := &doc.GenManHeader{
Section: "1",
Manual: "CockroachDB Manual",
Source: fmt.Sprintf("CockroachDB %s", info.Tag),
}
if !strings.HasSuffix(manPath, string(os.PathSeparator)) {
manPath += string(os.PathSeparator)
}
if _, err := os.Stat(manPath); err != nil {
if os.IsNotExist(err) {
if err := os.MkdirAll(manPath, 0755); err != nil {
return err
}
} else {
return err
}
}
if err := doc.GenManTree(cmd.Root(), header, manPath); err != nil {
return err
}
// TODO(cdo): The man page generated by the cobra package doesn't include a list of commands, so
// one has to notice the "See Also" section at the bottom of the page to know which commands
// are supported. I'd like to make this better somehow.
fmt.Println("Generated CockroachDB man pages in", manPath)
return nil
}
// Run command.
func run(c *cobra.Command, args []string) error {
stats.Track("Deploy", map[string]interface{}{
"concurrency": concurrency,
"has_alias": alias != "",
"env": len(env),
"args": len(args),
})
root.Project.Concurrency = concurrency
root.Project.Alias = alias
c.Root().PersistentFlags().Lookup("name string")
if err := root.Project.LoadFunctions(args...); err != nil {
return err
}
for _, fn := range root.Project.Functions {
stats.Track("Deploy Function", map[string]interface{}{
"runtime": fn.Runtime,
"has_alias": alias != "",
"env": len(env),
})
}
for _, s := range env {
parts := strings.SplitN(s, "=", 2)
if len(parts) == 2 {
root.Project.Setenv(parts[0], parts[1])
} else {
return fmt.Errorf("environment variable %s needs a value", parts[0])
}
}
return root.Project.DeployAndClean()
}
func RunHelp(cmd *cobra.Command, args []string) {
foundCmd, a, err := cmd.Root().Find(args)
// NOTE(andreykurilin): actually, I did not find any cases when foundCmd can be nil,
// but let's make this check since it is included in original code of initHelpCmd
// from github.com/spf13/cobra
if foundCmd == nil {
cmd.Printf("Unknown help topic %#q.\n", args)
cmd.Root().Usage()
} else if err != nil {
// print error message at first, since it can contain suggestions
cmd.Println(err)
argsString := strings.Join(args, " ")
var matchedMsgIsPrinted bool = false
for _, foundCmd := range foundCmd.Commands() {
if strings.Contains(foundCmd.Short, argsString) {
if !matchedMsgIsPrinted {
cmd.Printf("Matchers of string '%s' in short descriptions of commands: \n", argsString)
matchedMsgIsPrinted = true
}
cmd.Printf(" %-14s %s\n", foundCmd.Name(), foundCmd.Short)
}
}
if !matchedMsgIsPrinted {
// if nothing is found, just print usage
cmd.Root().Usage()
}
} else if len(a) == 0 {
// help message for help command :)
cmd.Root().Usage()
} else {
helpFunc := foundCmd.HelpFunc()
helpFunc(foundCmd, args)
}
}
func completeRunCmd(cmd *cobra.Command, args []string) {
cmd_line := os.Getenv("COMP_LINE")
if cmd_line == "" {
fmt.Println("This command is intended to be used as part of " +
" bash autocomplete. Its not intended to be called directly from " +
" the command line ")
return
}
root_cmd := cmd.Root()
args = strings.Split(cmd_line, " ")
found_cmd, _, _ := root_cmd.Find(args[1:])
if found_cmd == nil {
return
}
/* this is worth a long comment. We have to find a command line
* with the flags removed. To do this, I look at the command
* path for the command without flags, and remove anything that
* doesn't match */
found_args := strings.Split(found_cmd.CommandPath(), " ")
last_arg := found_args[len(found_args)-1]
/* what is remaining after the last parsed argument */
ind := strings.Index(cmd_line, last_arg)
ind += len(last_arg)
extra_str := cmd_line[ind:]
if len(extra_str) == 0 {
/* this matched an exact command with no space afterwards. There
* is no autocomplete except this command (to add a space) */
fmt.Println(found_cmd.Name())
return
}
/* skip flags for now. This just removes them */
/* skip over complete flags. So the current bash autocomplete will
* not complete flags */
cmd.Flags().VisitAll(func(flag *pflag.Flag) {
flg := fmt.Sprintf("--%s", flag.Name)
if flag.Value.Type() == "bool" {
/* skip the flag */
r := regexp.MustCompile(flg + "[\\W]+")
extra_str = r.ReplaceAllString(extra_str, "")
} else if flag.Value.Type() == "string" {
/* skip the string and the next word */
r := regexp.MustCompile(flg + "[\\W]+[^\\W]+[\\W]+")
extra_str = r.ReplaceAllString(extra_str, "")
}
sflg := fmt.Sprintf("-%s", flag.Shorthand)
if flag.Value.Type() == "bool" {
/* skip the flag */
r := regexp.MustCompile(sflg + "[\\W]+")
extra_str = r.ReplaceAllString(extra_str, "")
} else if flag.Value.Type() == "string" {
/* skip the string and the next word */
r := regexp.MustCompile(sflg + "[\\W]+[^\\W]+[\\W]+")
extra_str = r.ReplaceAllString(extra_str, "")
}
})
if len(extra_str) == 0 {
/* this matched an exact command with no space afterwards. There
* is no autocomplete except this command (to add a space) */
return
}
extra_str = strings.TrimLeft(extra_str, " ")
/* give flag hints if the person asks for them */
showShort := strings.HasPrefix(extra_str, "-") &&
!strings.HasPrefix(extra_str, "--")
showLong := strings.HasPrefix(extra_str, "--") ||
extra_str == "-"
if showLong {
r := regexp.MustCompile("^--[^\\W]+")
partial_flag := r.FindString(extra_str)
cmd.Flags().VisitAll(func(flag *pflag.Flag) {
flg := fmt.Sprintf("--%s", flag.Name)
if strings.HasPrefix(flg, partial_flag) {
fmt.Println(flg)
}
})
}
if showShort {
r := regexp.MustCompile("^-[^\\W]+")
partial_flag := r.FindString(extra_str)
cmd.Flags().VisitAll(func(flag *pflag.Flag) {
if len(flag.Shorthand) > 0 {
flg := fmt.Sprintf("-%s", flag.Shorthand)
if strings.HasPrefix(flg, partial_flag) {
fmt.Println(flg)
}
}
})
}
/* dump out valid arguments */
for _, c := range found_cmd.ValidArgs {
if strings.HasPrefix(c, extra_str) {
fmt.Printf("%s\n", c)
}
}
/* dump out possible sub commands */
for _, child_cmd := range found_cmd.Commands() {
if strings.HasPrefix(child_cmd.Name(), extra_str) {
fmt.Printf("%s\n", child_cmd.Name())
}
}
}
func runServer(cmd *cobra.Command, args []string) {
if completion {
cmd.Root().GenBashCompletion(os.Stdout)
os.Exit(0)
}
var (
srv *torus.Server
err error
)
switch {
case cfg.MetadataAddress == "":
srv, err = torus.NewServer(cfg, "temp", "mfile")
case debugInit:
err = torus.InitMDS("etcd", cfg, torus.GlobalMetadata{
BlockSize: 512 * 1024,
DefaultBlockSpec: blockset.MustParseBlockLayerSpec("crc,base"),
}, ring.Ketama)
if err != nil {
if err == torus.ErrExists {
fmt.Println("debug-init: Already exists")
} else {
fmt.Printf("Couldn't debug-init: %s\n", err)
os.Exit(1)
}
}
fallthrough
default:
srv, err = torus.NewServer(cfg, "etcd", "mfile")
}
if err != nil {
fmt.Printf("Couldn't start: %s\n", err)
os.Exit(1)
}
if autojoin {
err = doAutojoin(srv)
if err != nil {
fmt.Printf("Couldn't auto-join: %s\n", err)
os.Exit(1)
}
}
mainClose := make(chan bool)
signalChan := make(chan os.Signal, 1)
signal.Notify(signalChan, os.Interrupt)
if peerAddress != "" {
var u *url.URL
u, err = url.Parse(peerAddress)
if err != nil {
fmt.Printf("Couldn't parse peer address %s: %s\n", peerAddress, err)
os.Exit(1)
}
if u.Scheme == "" {
fmt.Printf("Peer address %s does not have URL scheme (http:// or tdp://)\n", peerAddress)
os.Exit(1)
}
err = distributor.ListenReplication(srv, u)
} else {
err = distributor.OpenReplication(srv)
}
defer srv.Close()
go func() {
for _ = range signalChan {
fmt.Println("\nReceived an interrupt, stopping services...")
close(mainClose)
os.Exit(0)
}
}()
if err != nil {
fmt.Println("couldn't use server:", err)
os.Exit(1)
}
if httpAddress != "" {
http.ServeHTTP(httpAddress, srv)
}
// Wait
<-mainClose
}
func completionAction(cmd *cobra.Command, args []string) {
cmd.Root().GenBashCompletion(os.Stdout)
}