Name: "status",
ShortHelp: "Get quick readout of the current status of your associated environment and all of its services",
LongHelp: "`status` will give a quick readout of your environment's health. " +
"This includes your environment name, environment ID, and for each service the name, size, build status, deploy status, and service ID. " +
"Here is a sample command\n\n" +
"```\ncatalyze -E \"<your_env_alias>\" status\n```",
CmdFunc: func(settings *models.Settings) func(cmd *cli.Cmd) {
return func(cmd *cli.Cmd) {
cmd.Action = func() {
if _, err := auth.New(settings, prompts.New()).Signin(); err != nil {
logrus.Fatal(err.Error())
}
if err := config.CheckRequiredAssociation(true, true, settings); err != nil {
logrus.Fatal(err.Error())
}
err := CmdStatus(settings.EnvironmentID, New(settings, jobs.New(settings)), environments.New(settings), services.New(settings))
if err != nil {
logrus.Fatal(err.Error())
}
}
}
},
}
// IStatus
type IStatus interface {
Status(env *models.Environment, services *[]models.Service) error
}
// SStatus is a concrete implementation of IStatus
type SStatus struct {
// Cmd is the contract between the user and the CLI. This specifies the command
// name, arguments, and required/optional arguments and flags for the command.
var Cmd = models.Command{
Name: "rollback",
ShortHelp: "Rollback a code service to a specific release",
LongHelp: "`rollback` is a way to redeploy older versions of your code service. " +
"You must specify the name of the service to rollback and the name of an existing release to rollback to. " +
"Releases can be found with the [releases list](#releases-list) command. Here are some sample commands\n\n" +
"```\ncatalyze -E \"<your_env_alias>\" rollback code-1 f93ced037f828dcaabccfc825e6d8d32cc5a1883\n```",
CmdFunc: func(settings *models.Settings) func(cmd *cli.Cmd) {
return func(cmd *cli.Cmd) {
serviceName := cmd.StringArg("SERVICE_NAME", "", "The name of the service to rollback")
releaseName := cmd.StringArg("RELEASE_NAME", "", "The name of the release to rollback to")
cmd.Action = func() {
if _, err := auth.New(settings, prompts.New()).Signin(); err != nil {
logrus.Fatal(err.Error())
}
if err := config.CheckRequiredAssociation(true, true, settings); err != nil {
logrus.Fatal(err.Error())
}
err := CmdRollback(*serviceName, *releaseName, jobs.New(settings), releases.New(settings), services.New(settings))
if err != nil {
logrus.Fatal(err.Error())
}
}
cmd.Spec = "SERVICE_NAME RELEASE_NAME"
}
},
}
"The backup is started and unless `-s` is specified, the CLI will poll every few seconds until it finishes. " +
"Regardless of a successful backup or not, the logs for the backup will be printed to the console when the backup is finished. " +
"If an error occurs and the logs are not printed, you can use the [db logs](#db-logs) command to print out historical backup job logs. Here is a sample command\n\n" +
"```\ncatalyze -E \"<your_env_alias>\" db backup db01\n```",
CmdFunc: func(settings *models.Settings) func(cmd *cli.Cmd) {
return func(subCmd *cli.Cmd) {
databaseName := subCmd.StringArg("DATABASE_NAME", "", "The name of the database service to create a backup for (i.e. 'db01')")
skipPoll := subCmd.BoolOpt("s skip-poll", false, "Whether or not to wait for the backup to finish")
subCmd.Action = func() {
if _, err := auth.New(settings, prompts.New()).Signin(); err != nil {
logrus.Fatal(err.Error())
}
if err := config.CheckRequiredAssociation(true, true, settings); err != nil {
logrus.Fatal(err.Error())
}
err := CmdBackup(*databaseName, *skipPoll, New(settings, crypto.New(), jobs.New(settings)), services.New(settings), jobs.New(settings))
if err != nil {
logrus.Fatal(err.Error())
}
}
subCmd.Spec = "DATABASE_NAME [-s]"
}
},
}
var DownloadSubCmd = models.Command{
Name: "download",
ShortHelp: "Download a previously created backup",
LongHelp: "`db download` downloads a previously created backup to your local hard drive. " +
"Be careful using this command as it could download PHI. " +
"Be sure that all hard drive encryption and necessary precautions have been taken before performing a download. " +
"When accessing a database service, the `COMMAND` argument is not needed because the appropriate prompt will be given to you. " +
"If you are connecting to an application service the `COMMAND` argument is required. Here are some sample commands\n\n" +
"```\ncatalyze -E \"<your_env_alias>\" console db01\n" +
"catalyze -E \"<your_env_alias>\" console app01 \"bundle exec rails console\"\n```",
CmdFunc: func(settings *models.Settings) func(cmd *cli.Cmd) {
return func(cmd *cli.Cmd) {
serviceName := cmd.StringArg("SERVICE_NAME", "", "The name of the service to open up a console for")
command := cmd.StringArg("COMMAND", "", "An optional command to run when the console becomes available")
cmd.Action = func() {
if _, err := auth.New(settings, prompts.New()).Signin(); err != nil {
logrus.Fatal(err.Error())
}
if err := config.CheckRequiredAssociation(true, true, settings); err != nil {
logrus.Fatal(err.Error())
}
err := CmdConsole(*serviceName, *command, New(settings, jobs.New(settings)), services.New(settings))
if err != nil {
logrus.Fatal(err.Error())
}
}
cmd.Spec = "SERVICE_NAME [COMMAND]"
}
},
}
// IConsole
type IConsole interface {
Open(command string, service *models.Service) error
Request(command string, service *models.Service) (*models.Job, error)
RetrieveTokens(jobID string, service *models.Service) (*models.ConsoleCredentials, error)
Destroy(jobID string, service *models.Service) error
serviceName := cmd.StringArg("SERVICE_NAME", "", "The name of the service to use to start a worker. Defaults to the associated service.")
target := cmd.StringArg("TARGET", "", "The name of the Procfile target to invoke as a worker")
cmd.Action = func() {
logrus.Warnln("This command has been moved! Please use \"catalyze worker deploy\" instead. This alias will be removed in the next CLI update.")
logrus.Warnln("You can list all available worker subcommands by running \"catalyze worker --help\".")
if _, err := auth.New(settings, prompts.New()).Signin(); err != nil {
logrus.Fatal(err.Error())
}
if err := config.CheckRequiredAssociation(true, true, settings); err != nil {
logrus.Fatal(err.Error())
}
if *target == "" {
logrus.Fatal("TARGET is a required argument")
}
err := CmdWorker(*serviceName, settings.ServiceID, *target, New(settings), services.New(settings), jobs.New(settings))
if err != nil {
logrus.Fatal(err.Error())
}
}
cmd.Spec = "[SERVICE_NAME] [TARGET]"
}
},
}
var DeploySubCmd = models.Command{
Name: "deploy",
ShortHelp: "Deploy new workers for a given service",
LongHelp: "`worker deploy` allows you to start a background process asynchronously. The TARGET must be specified in your Procfile. " +
"Once the worker is started, any output can be found in your logging Dashboard or using the [logs](#logs) command. " +
"Here is a sample command\n\n" +
var Cmd = models.Command{
Name: "redeploy",
ShortHelp: "Redeploy a service without having to do a git push. This will cause downtime for all redeploys (see the resources page for more details).",
LongHelp: "`redeploy` deploys an identical copy of the given service. " +
"For code services, this avoids having to perform a code push. You skip the git push and the build. " +
"For service proxies, new instances replace the old ones. " +
"All other service types cannot be redeployed with this command. " +
"For service proxy redeploys, there will be approximately 5 minutes of downtime. " +
"For code service redeploys, there will be approximately 30 seconds of downtime. " +
"Here is a sample command\n\n" +
"```\ncatalyze -E \"<your_env_alias>\" redeploy app01\n```",
CmdFunc: func(settings *models.Settings) func(cmd *cli.Cmd) {
return func(cmd *cli.Cmd) {
serviceName := cmd.StringArg("SERVICE_NAME", "", "The name of the service to redeploy (i.e. 'app01')")
cmd.Action = func() {
if _, err := auth.New(settings, prompts.New()).Signin(); err != nil {
logrus.Fatal(err.Error())
}
if err := config.CheckRequiredAssociation(true, true, settings); err != nil {
logrus.Fatal(err.Error())
}
err := CmdRedeploy(settings.EnvironmentID, *serviceName, jobs.New(settings), services.New(settings), environments.New(settings))
if err != nil {
logrus.Fatal(err.Error())
}
}
cmd.Spec = "SERVICE_NAME"
}
},
}
LongHelp: "`services stop` shuts down all running instances of a given service. " +
"This is useful when performing maintenance and a service must be shutdown to perform that maintenance. " +
"Take caution when running this command as all instances of the service, all workers, all rake tasks, and all open console sessions will be stopped. " +
"Here is a sample command\n\n" +
"```\ncatalyze -E \"<your_env_alias>\" services stop code-1\n```",
CmdFunc: func(settings *models.Settings) func(cmd *cli.Cmd) {
return func(subCmd *cli.Cmd) {
svcName := subCmd.StringArg("SERVICE_NAME", "", "The name of the service to stop")
subCmd.Action = func() {
if _, err := auth.New(settings, prompts.New()).Signin(); err != nil {
logrus.Fatal(err.Error())
}
if err := config.CheckRequiredAssociation(true, true, settings); err != nil {
logrus.Fatal(err.Error())
}
err := CmdStop(*svcName, New(settings), jobs.New(settings), prompts.New())
if err != nil {
logrus.Fatal(err.Error())
}
}
subCmd.Spec = "SERVICE_NAME"
}
},
}
// IServices
type IServices interface {
List() (*[]models.Service, error)
ListByEnvID(envID, podID string) (*[]models.Service, error)
Retrieve(svcID string) (*models.Service, error)
RetrieveByLabel(label string) (*models.Service, error)