// SetEnvVars adds new env vars or updates the values of existing ones
func SetEnvVars(envVars map[string]string, settings *models.Settings) {
b, err := json.Marshal(envVars)
if err != nil {
fmt.Println(err.Error())
os.Exit(1)
}
httpclient.Post(b, fmt.Sprintf("%s/v1/environments/%s/services/%s/env", settings.PaasHost, settings.EnvironmentID, settings.ServiceID), true, settings)
}
// RedeployService redeploys the associated code service
func RedeployService(settings *models.Settings) {
redeploy := map[string]string{}
b, err := json.Marshal(redeploy)
if err != nil {
fmt.Println(err.Error())
os.Exit(1)
}
httpclient.Post(b, fmt.Sprintf("%s/v1/environments/%s/services/%s/redeploy", settings.PaasHost, settings.EnvironmentID, settings.ServiceID), true, settings)
}
// InitiateRakeTask kicks off a rake task for the associated code service. The
// logs for the rake task are viewable in the environments logging server.
func InitiateRakeTask(taskName string, settings *models.Settings) {
rakeTask := map[string]string{}
b, err := json.Marshal(rakeTask)
if err != nil {
fmt.Println(err.Error())
os.Exit(1)
}
httpclient.Post(b, fmt.Sprintf("%s/v1/environments/%s/services/%s/rake/%s", settings.PaasHost, settings.EnvironmentID, settings.ServiceID, url.QueryEscape(taskName)), true, settings)
}
// AddUserToEnvironment grants a user access to the associated env
func AddUserToEnvironment(usersID string, settings *models.Settings) {
body := map[string]string{}
b, err := json.Marshal(body)
if err != nil {
fmt.Println(err.Error())
os.Exit(1)
}
httpclient.Post(b, fmt.Sprintf("%s/v1/environments/%s/users/%s", settings.PaasHost, settings.EnvironmentID, usersID), true, settings)
}
// InitiateWorker starts a background worker for the associated code service
// for the given Procfile target.
func InitiateWorker(target string, settings *models.Settings) {
worker := map[string]string{
"target": target,
}
b, err := json.Marshal(worker)
if err != nil {
fmt.Println(err.Error())
os.Exit(1)
}
httpclient.Post(b, fmt.Sprintf("%s/v1/environments/%s/services/%s/background", settings.PaasHost, settings.EnvironmentID, settings.ServiceID), true, settings)
}
// CreateInvite invites a user by email to the associated environment. This user
// does not need to have a Dashboard account to send them an invite, but
// requires a Dashboard account to accept it.
func CreateInvite(email string, settings *models.Settings) *models.Invite {
i := models.Invite{
Email: email,
}
b, err := json.Marshal(i)
if err != nil {
panic(err)
}
resp := httpclient.Post(b, fmt.Sprintf("%s/v1/environments/%s/invites", settings.PaasHost, settings.EnvironmentID), true, settings)
var invite models.Invite
json.Unmarshal(resp, &invite)
return &invite
}
// CreateBackup kicks off a backup job for the given service. The task is
// returned which can be used to check on the status of the backup.
func CreateBackup(serviceID string, settings *models.Settings) *models.Task {
backup := map[string]string{
"archiveType": "cf",
"encryptionType": "aes",
}
b, err := json.Marshal(backup)
if err != nil {
fmt.Println(err.Error())
os.Exit(1)
}
resp := httpclient.Post(b, fmt.Sprintf("%s/v1/environments/%s/services/%s/backup", settings.PaasHost, settings.EnvironmentID, serviceID), true, settings)
var m map[string]string
json.Unmarshal(resp, &m)
return &models.Task{
ID: m["taskId"],
}
}
// RequestConsole asks for a console to be setup. The console is not immediately
// ready but the resulting taskID should be used to check on its status.
func RequestConsole(command string, serviceID string, settings *models.Settings) *models.Task {
console := map[string]string{}
if command != "" {
console["command"] = command
}
b, err := json.Marshal(console)
if err != nil {
fmt.Println(err.Error())
os.Exit(1)
}
resp := httpclient.Post(b, fmt.Sprintf("%s/v1/environments/%s/services/%s/console", settings.PaasHost, settings.EnvironmentID, serviceID), true, settings)
var m map[string]string
json.Unmarshal(resp, &m)
return &models.Task{
ID: m["taskId"],
}
}
// InitiateImport starts an import job for the given database service
func InitiateImport(tempURL string, filePath string, key string, iv string, options map[string]string, wipeFirst bool, serviceID string, settings *models.Settings) *models.Task {
httpclient.PutFile(filePath, tempURL, true, settings)
importParams := models.Import{
Location: tempURL,
Key: key,
IV: iv,
WipeFirst: wipeFirst,
Options: options,
}
b, err := json.Marshal(importParams)
if err != nil {
fmt.Println(err.Error())
os.Exit(1)
}
resp := httpclient.Post(b, fmt.Sprintf("%s/v1/environments/%s/services/%s/db/import", settings.PaasHost, settings.EnvironmentID, serviceID), true, settings)
var task models.Task
json.Unmarshal(resp, &task)
return &task
}
// SignIn signs in the user and retrieves a session. The passed in Settings
// object is updated with the most up to date credentials
func SignIn(settings *models.Settings) {
// if we're already signed in with a valid session, don't sign in again
if verify(settings) {
return
}
if settings.Username == "" || settings.Password == "" {
promptForCredentials(settings)
}
login := models.Login{
Username: settings.Username,
Password: settings.Password,
}
b, err := json.Marshal(login)
if err != nil {
fmt.Println(err.Error())
os.Exit(1)
}
resp := httpclient.Post(b, fmt.Sprintf("%s/v2/auth/signin", settings.BaasHost), true, settings)
var user models.User
json.Unmarshal(resp, &user)
settings.SessionToken = user.SessionToken
settings.UsersID = user.UsersID
config.SaveSettings(settings)
}
