func runServerReboot(c *cli.Context) { stack := mustStack(c) if len(c.Args()) != 0 { cli.ShowSubcommandHelp(c) os.Exit(2) } serverName := c.String("server") servers, err := client.Servers(stack.Uid) if err != nil { printFatal(err.Error()) } server, err := findServer(servers, serverName) if err != nil { printFatal(err.Error()) } if server == nil { printFatal("Server '" + serverName + "' not found") } fmt.Printf("Server: %s\n", server.Name) // confirmation is needed if the stack is production if !c.Bool("y") { mustConfirm("This operation will reboot your server during which time your server will not be available. Proceed with reboot? [yes/N]", "yes") } executeServerReboot(*stack, *server) }
func runEnvVars(c *cli.Context) { w := tabwriter.NewWriter(os.Stdout, 1, 2, 2, ' ', 0) defer w.Flush() var envVars []cloud66.StackEnvVar var err error stack := mustStack(c) envVars, err = client.StackEnvVars(stack.Uid) must(err) envVarKeys := c.Args() flagShowHistory := c.Bool("history") sort.Strings(envVarKeys) if len(envVarKeys) == 0 { printEnvVarsList(w, envVars, flagShowHistory) } else { // filter out the unwanted env_vars var filteredEnvVars []cloud66.StackEnvVar for _, i := range envVars { sorted := sort.SearchStrings(envVarKeys, i.Key) if sorted < len(envVarKeys) && envVarKeys[sorted] == i.Key { filteredEnvVars = append(filteredEnvVars, i) } } printEnvVarsList(w, filteredEnvVars, flagShowHistory) } }
func runContainers(c *cli.Context) { stack := mustStack(c) w := tabwriter.NewWriter(os.Stdout, 1, 2, 2, ' ', 0) defer w.Flush() flagServer := c.String("server") flagServiceName := c.String("service") flagTruncate := c.Bool("trunc") var serverUid *string if flagServer == "" { serverUid = nil } else { servers, err := client.Servers(stack.Uid) if err != nil { printFatal(err.Error()) } server, err := findServer(servers, flagServer) if err != nil { printFatal(err.Error()) } if server == nil { printFatal("Server '" + flagServer + "' not found") } fmt.Printf("Server: %s\n", server.Name) serverUid = &server.Uid } containers, err := client.GetContainers(stack.Uid, serverUid, &flagServiceName) must(err) printContainerList(w, containers, flagTruncate) }
func runBackups(c *cli.Context) { var dbType = c.String("dbtype") w := tabwriter.NewWriter(os.Stdout, 1, 2, 2, ' ', 0) defer w.Flush() stack := mustStack(c) backups, err := client.ManagedBackups(stack.Uid) must(err) var dbTypeGroup = map[string][]cloud66.ManagedBackup{} if c.Bool("latest") { for _, i := range backups { if dbTypeGroup[i.DbType] == nil { // it's a new one dbTypeGroup[i.DbType] = []cloud66.ManagedBackup{i} } else { dbTypeGroup[i.DbType] = append(dbTypeGroup[i.DbType], i) } } // now sort each group topResults := []cloud66.ManagedBackup{} for _, v := range dbTypeGroup { sort.Sort(backupsByDate(v)) topResults = append(topResults, v[0]) } printBackupList(w, topResults, dbType) } else { printBackupList(w, backups, dbType) } }
func runNewBackup(c *cli.Context) { stack := mustStack(c) var flagDbTypes *string if c.IsSet("dbtypes") { flagDbTypes = new(string) *flagDbTypes = c.String("dbtypes") } var flagFrequency *string if c.IsSet("frequency") { flagFrequency = new(string) *flagFrequency = c.String("frequency") } var flagKeep *int if c.IsSet("keep") { flagKeep = new(int) *flagKeep = c.Int("keep") } var flagGzip *bool if c.IsSet("gzip") { flagGzip = new(bool) *flagGzip = c.Bool("gzip") } var flagExcludetables *string if c.IsSet("exclude-tables") { flagExcludetables = new(string) *flagExcludetables = c.String("exclude-tables") } var flagRunonreplica *bool if c.IsSet("run-on-replica") { flagRunonreplica = new(bool) *flagRunonreplica = c.Bool("run-on-replica") } err := client.NewBackup(stack.Uid, flagDbTypes, flagFrequency, flagKeep, flagGzip, flagExcludetables, flagRunonreplica) if err != nil { printFatal("Error during backup creation: " + err.Error()) return } fmt.Println("queued for creation") }
func runRedeploy(c *cli.Context) { stack := mustStack(c) // confirmation is needed if the stack is production if stack.Environment == "production" && !c.Bool("y") { mustConfirm("This is a production stack. Proceed with deployment? [yes/N]", "yes") } if len(c.StringSlice("service")) > 0 { fmt.Printf("Deploying service(s): ") for i, service := range c.StringSlice("service") { if i > 0 { fmt.Printf(", ") } fmt.Printf(service) } fmt.Printf("\n") } result, err := client.RedeployStack(stack.Uid, c.String("git-ref"), c.StringSlice("service")) must(err) if !c.Bool("listen") || result.Queued { // its queued - just message and exit fmt.Println(result.Message) } else { // tail the logs go StartListen(stack) stack, err = WaitStackBuild(stack.Uid, false) must(err) if stack.HealthCode == 2 || stack.HealthCode == 4 || stack.StatusCode == 2 || stack.StatusCode == 7 { fmt.Println("Completed with some errors!") } else { fmt.Println("Completed successfully!") } } }