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 {
"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
"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. " +
hostname := subCmd.StringArg("HOSTNAME", "", "The hostname used in the creation of a certs instance with the 'certs' command (i.e. \"star_example_com\")")
clientMaxBodySize := subCmd.IntOpt("client-max-body-size", -1, "The 'client_max_body_size' nginx config specified in megabytes")
proxyConnectTimeout := subCmd.IntOpt("proxy-connect-timeout", -1, "The 'proxy_connect_timeout' nginx config specified in seconds")
proxyReadTimeout := subCmd.IntOpt("proxy-read-timeout", -1, "The 'proxy_read_timeout' nginx config specified in seconds")
proxySendTimeout := subCmd.IntOpt("proxy-send-timeout", -1, "The 'proxy_send_timeout' nginx config specified in seconds")
proxyUpstreamTimeout := subCmd.IntOpt("proxy-upstream-timeout", -1, "The 'proxy_next_upstream_timeout' nginx config specified in seconds")
enableCORS := subCmd.BoolOpt("enable-cors", false, "Enable or disable all features related to full CORS support")
enableWebSockets := subCmd.BoolOpt("enable-websockets", false, "Enable or disable all features related to full websockets support")
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 := CmdCreate(*name, *serviceName, *hostname, *clientMaxBodySize, *proxyConnectTimeout, *proxyReadTimeout, *proxySendTimeout, *proxyUpstreamTimeout, *enableCORS, *enableWebSockets, New(settings), services.New(settings))
if err != nil {
logrus.Fatal(err.Error())
}
}
subCmd.Spec = "SITE_NAME SERVICE_NAME HOSTNAME [--client-max-body-size] [--proxy-connect-timeout] [--proxy-read-timeout] [--proxy-send-timeout] [--proxy-upstream-timeout] [--enable-cors] [--enable-websockets]"
}
},
}
var ListSubCmd = models.Command{
Name: "list",
ShortHelp: "List details for all site configurations",
LongHelp: "`sites list` lists all sites for the given environment. " +
"The names printed out can be used in the other sites commands. Here is a sample command\n\n" +
"```\ncatalyze -E \"<your_env_alias>\" sites list\n```",
ShortHelp: "Associates an environment",
LongHelp: "`associate` is the entry point of the cli. You need to associate an environment before you can run most other commands. " +
"Check out [scope](#global-scope) and [aliases](#environment-aliases) for more info on the value of the alias and default options. Here is a sample command\n\n" +
"```\ncatalyze associate My-Production-Environment app01 -a prod\n```",
CmdFunc: func(settings *models.Settings) func(cmd *cli.Cmd) {
return func(cmd *cli.Cmd) {
envName := cmd.StringArg("ENV_NAME", "", "The name of your environment")
serviceName := cmd.StringArg("SERVICE_NAME", "", "The name of the primary code service to associate with this environment (i.e. 'app01')")
alias := cmd.StringOpt("a alias", "", "A shorter name to reference your environment by for local commands")
remote := cmd.StringOpt("r remote", "catalyze", "The name of the remote")
defaultEnv := cmd.BoolOpt("d default", false, "[DEPRECATED] Specifies whether or not the associated environment will be the default")
cmd.Action = func() {
if _, err := auth.New(settings, prompts.New()).Signin(); err != nil {
logrus.Fatal(err.Error())
}
err := CmdAssociate(*envName, *serviceName, *alias, *remote, *defaultEnv, New(settings), git.New(), environments.New(settings), services.New(settings))
if err != nil {
logrus.Fatal(err.Error())
}
}
cmd.Spec = "ENV_NAME SERVICE_NAME [-a] [-r] [-d]"
}
},
}
// interfaces are the API calls
type IAssociate interface {
Associate(name, remote string, defaultEnv bool, env *models.Environment, chosenService *models.Service) error
}
// SAssociate is a concrete implementation of IAssociate
ShortHelp: "Execute a rake task",
LongHelp: "`rake` executes a rake task by its name asynchronously. " +
"Once executed, the output of the task can be seen through your logging Dashboard. Here is a sample command\n\n" +
"```\ncatalyze -E \"<your_env_alias>\" rake code-1 db:migrate\n```",
CmdFunc: func(settings *models.Settings) func(cmd *cli.Cmd) {
return func(cmd *cli.Cmd) {
serviceName := cmd.StringArg("SERVICE_NAME", "", "The service that will run the rake task. Defaults to the associated service.")
taskName := cmd.StringArg("TASK_NAME", "", "The name of the rake task to run")
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 := CmdRake(*serviceName, *taskName, settings.ServiceID, New(settings), services.New(settings))
if err != nil {
logrus.Fatal(err.Error())
}
}
cmd.Spec = "[SERVICE_NAME] TASK_NAME"
}
},
}
// IRake
type IRake interface {
Run(taskName, svcID string) error
}
// SRake is a concrete implementation of IRake
return func(subCmd *cli.Cmd) {
serviceName := subCmd.StringArg("SERVICE_NAME", "", "The name of the service to print metrics for")
json := subCmd.BoolOpt("json", false, "Output the data as json")
csv := subCmd.BoolOpt("csv", false, "Output the data as csv")
text := subCmd.BoolOpt("text", true, "Output the data in plain text")
spark := subCmd.BoolOpt("spark", false, "Output the data using spark lines")
stream := subCmd.BoolOpt("stream", false, "Repeat calls once per minute until this process is interrupted.")
mins := subCmd.IntOpt("m mins", 1, "How many minutes worth of metrics to retrieve.")
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 := CmdMetrics(*serviceName, CPU, *json, *csv, *text, *spark, *stream, *mins, New(settings), services.New(settings))
if err != nil {
logrus.Fatal(err.Error())
}
}
subCmd.Spec = "[SERVICE_NAME] [(--json | --csv | --text | --spark)] [--stream] [-m]"
}
},
}
var MemorySubCmd = models.Command{
Name: "memory",
ShortHelp: "Print service and environment memory metrics in your local time zone",
LongHelp: "`metrics memory` prints out memory metrics for your environment or individual services. " +
"You can print out metrics in csv, json, plain text, or spark lines format. " +
"If you want plain text format, simply omit the `--json`, `--csv`, and `--spark` flags. " +
CmdFunc: func(settings *models.Settings) func(cmd *cli.Cmd) {
return func(cmd *cli.Cmd) {
query := cmd.StringArg("QUERY", "*", "The query to send to your logging dashboard's elastic search (regex is supported)")
follow := cmd.BoolOpt("f follow", false, "Tail/follow the logs (Equivalent to -t)")
tail := cmd.BoolOpt("t tail", false, "Tail/follow the logs (Equivalent to -f)")
hours := cmd.IntOpt("hours", 0, "The number of hours before now (in combination with minutes and seconds) to retrieve logs")
mins := cmd.IntOpt("minutes", 0, "The number of minutes before now (in combination with hours and seconds) to retrieve logs")
secs := cmd.IntOpt("seconds", 0, "The number of seconds before now (in combination with hours and minutes) to retrieve logs")
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 := CmdLogs(*query, *follow || *tail, *hours, *mins, *secs, settings.EnvironmentID, settings, New(settings), prompts.New(), environments.New(settings), services.New(settings), sites.New(settings))
if err != nil {
logrus.Fatal(err.Error())
}
}
cmd.Spec = "[QUERY] [(-f | -t)] [--hours] [--minutes] [--seconds]"
}
},
}
// ILogs ...
type ILogs interface {
Output(queryString, sessionToken, domain string, follow bool, hours, minutes, seconds, from int, startTimestamp time.Time, endTimestamp time.Time, env *models.Environment) (int, time.Time, error)
Stream(queryString, sessionToken, domain string, follow bool, hours, minutes, seconds, from int, timestamp time.Time, env *models.Environment) error
Watch(queryString, domain, sessionToken string) 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"
}
},
}
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())
}
var formatter Formatter
if *json {
formatter = &JSONFormatter{}
} else if *yaml {
formatter = &YAMLFormatter{}
} else {
formatter = &PlainFormatter{}
}
err := CmdList(*serviceName, settings.ServiceID, formatter, New(settings), services.New(settings))
if err != nil {
logrus.Fatal(err.Error())
}
}
subCmd.Spec = "[SERVICE_NAME] [--json | --yaml]"
}
},
}
var SetSubCmd = models.Command{
Name: "set",
ShortHelp: "Set one or more new environment variables or update the values of existing ones",
LongHelp: "`vars set` allows you to add new environment variables or update the value of an existing environment variable on the given code service. " +
"You can set/update 1 or more environment variables at a time with this command by repeating the `-v` option multiple times. " +
"Once new environment variables are added or values updated, a [redeploy](#redeploy) is required for the given code service to have access to the new values. " +
ShortHelp: "List all releases for a given code service",
LongHelp: "`releases list` lists all of the releases for a given service. " +
"A release is automatically created each time a git push is performed. " +
"Here is a sample command\n\n" +
"```\ncatalyze -E \"<your_env_alias>\" releases list code-1\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 list releases for")
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 := CmdList(*serviceName, New(settings), services.New(settings))
if err != nil {
logrus.Fatal(err)
}
}
}
},
}
var RmSubCmd = models.Command{
Name: "rm",
ShortHelp: "Remove a release from a code service",
LongHelp: "`releases rm` removes an existing release. This is useful in the case of a misbehaving code service. " +
"Removing the release avoids the risk of rolling back to a \"bad\" build. Here is a sample command\n\n" +
"```\ncatalyze -E \"<your_env_alias>\" releases rm code-1 f93ced037f828dcaabccfc825e6d8d32cc5a1883\n```",
CmdFunc: func(settings *models.Settings) func(cmd *cli.Cmd) {
"You can always store the file locally, applying the same permissions as those on the remote server, by specifying an output file with the `-o` flag. Here is a sample command\n\n" +
"```\ncatalyze -E \"<your_env_alias>\" files download /etc/nginx/sites-enabled/mywebsite.com\n```",
CmdFunc: func(settings *models.Settings) func(cmd *cli.Cmd) {
return func(subCmd *cli.Cmd) {
serviceName := subCmd.StringArg("SERVICE_NAME", "service_proxy", "The name of the service to download a file from")
fileName := subCmd.StringArg("FILE_NAME", "", "The name of the service file from running \"catalyze files list\"")
output := subCmd.StringOpt("o output", "", "The downloaded file will be saved to the given location with the same file permissions as it has on the remote host. If those file permissions cannot be applied, a warning will be printed and default 0644 permissions applied. If no output is specified, stdout is used.")
force := subCmd.BoolOpt("f force", false, "If the specified output file already exists, automatically overwrite it")
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 := CmdDownload(*serviceName, *fileName, *output, *force, New(settings), services.New(settings))
if err != nil {
logrus.Fatal(err.Error())
}
}
subCmd.Spec = "[SERVICE_NAME] FILE_NAME [-o] [-f]"
}
},
}
var ListSubCmd = models.Command{
Name: "list",
ShortHelp: "List all files available for a given service",
LongHelp: "`files list` prints out a listing of all service files available for download. " +
"Nearly all service files are stored on the service_proxy and therefore you should not have to specify the `SERVICE_NAME` argument. " +
"Here is a sample command\n\n" +
"github.com/catalyzeio/cli/lib/prompts"
"github.com/catalyzeio/cli/models"
"github.com/jault3/mow.cli"
)
// 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: "domain",
ShortHelp: "Print out the temporary domain name of the environment",
LongHelp: "`domain` prints out the temporary domain name setup by Catalyze for an environment. " +
"This domain name typically takes the form podXXXXX.catalyzeapps.com but may vary based on the environment. Here is a sample command\n\n" +
"```\ncatalyze -E \"<your_env_alias>\" domain\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 := CmdDomain(settings.EnvironmentID, environments.New(settings), services.New(settings), sites.New(settings))
if err != nil {
logrus.Fatalln(err.Error())
}
}
}
},
}
ShortHelp: "Add the git remote for the given code service to the local git repo",
LongHelp: "`git-remote add` adds the proper git remote to a local git repository with the given remote name and service. " +
"Here is a sample command\n\n" +
"```\ncatalyze -E \"<your_env_alias>\" git-remote add code-1 -r catalyze-code-1\n```",
CmdFunc: func(settings *models.Settings) func(cmd *cli.Cmd) {
return func(subCmd *cli.Cmd) {
serviceName := subCmd.StringArg("SERVICE_NAME", "", "The name of the service to add a git remote for")
remote := subCmd.StringOpt("r remote", "catalyze", "The name of the git remote to be added")
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 := CmdAdd(*serviceName, *remote, New(), services.New(settings))
if err != nil {
logrus.Fatalln(err.Error())
}
}
subCmd.Spec = "SERVICE_NAME [-r]"
}
},
}
var ShowSubCmd = models.Command{
Name: "show",
ShortHelp: "Print out the git remote for a given code service",
LongHelp: "`git-remote show` prints out the git remote URL for the given service. " +
"This can be used to do a manual push or use the git remote for another purpose such as a CI integration. " +
"Here is a sample command\n\n" +
"```\ncatalyze -E \"<your_env_alias>\" certs create wildcard_mysitecom ~/path/to/cert.pem ~/path/to/priv.key\n```",
CmdFunc: func(settings *models.Settings) func(cmd *cli.Cmd) {
return func(subCmd *cli.Cmd) {
name := subCmd.StringArg("NAME", "", "The name of this SSL certificate plus private key pair")
pubKeyPath := subCmd.StringArg("PUBLIC_KEY_PATH", "", "The path to a public key file in PEM format")
privKeyPath := subCmd.StringArg("PRIVATE_KEY_PATH", "", "The path to an unencrypted private key file in PEM format")
selfSigned := subCmd.BoolOpt("s self-signed", false, "Whether or not the given SSL certificate and private key are self signed")
resolve := subCmd.BoolOpt("r resolve", true, "Whether or not to attempt to automatically resolve incomplete SSL certificate issues")
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 := CmdCreate(*name, *pubKeyPath, *privKeyPath, *selfSigned, *resolve, New(settings), services.New(settings), ssl.New(settings))
if err != nil {
logrus.Fatal(err.Error())
}
}
subCmd.Spec = "NAME PUBLIC_KEY_PATH PRIVATE_KEY_PATH [-s] [-r]"
}
},
}
var ListSubCmd = models.Command{
Name: "list",
ShortHelp: "List all existing domains that have SSL certificate and private key pairs",
LongHelp: "`certs list` lists all of the available certs you have created on your environment. " +
"The displayed names are the names that should be used as the `DOMAIN` parameter in the [sites create](#sites-create) command. Here is a sample command\n\n" +
"```\ncatalyze -E \"<your_env_alias>\" certs list\n```",
// 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"
}
},
}
"You should be using personal SSH keys with the [keys](#keys) command unless you are pushing code from Continuous Integration or Continuous Deployment scenarios. " +
"Deploy keys are intended to be shared among an organization. Here are some sample commands\n\n" +
"```\ncatalyze -E \"<your_env_alias>\" deploy-keys add app01_public ~/.ssh/app01_rsa.pub app01\n```",
CmdFunc: func(settings *models.Settings) func(cmd *cli.Cmd) {
return func(subCmd *cli.Cmd) {
name := subCmd.StringArg("NAME", "", "The name for the new key, for your own purposes")
path := subCmd.StringArg("KEY_PATH", "", "Relative path to the SSH key file")
serviceName := subCmd.StringArg("SERVICE_NAME", "", "The name of the code service to add this deploy key to")
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 := CmdAdd(*name, *path, *serviceName, New(settings), services.New(settings))
if err != nil {
logrus.Fatal(err.Error())
}
}
subCmd.Spec = "NAME KEY_PATH SERVICE_NAME"
}
},
}
var ListSubCmd = models.Command{
Name: "list",
ShortHelp: "List all deploy keys",
LongHelp: "`deploy-keys list` will list all of your previously uploaded deploy keys by name including the key's fingerprint in SHA256 format. Here is a sample command\n\n" +
"```\ncatalyze -E \"<your_env_alias>\" deploy-keys list app01\n```",
CmdFunc: func(settings *models.Settings) func(cmd *cli.Cmd) {
