// Cancel deletes a user's account.
func Cancel(username string, password string, yes bool) error {
c, err := client.New()
if err != nil {
return err
}
if username == "" || password != "" {
fmt.Println("Please log in again in order to cancel this account")
if err = Login(c.ControllerURL.String(), username, password, c.SSLVerify); err != nil {
return err
}
}
if yes == false {
confirm := ""
c, err = client.New()
if err != nil {
return err
}
deletedUser := username
if deletedUser == "" {
deletedUser = c.Username
}
fmt.Printf("cancel account %s at %s? (y/N): ", deletedUser, c.ControllerURL.String())
fmt.Scanln(&confirm)
if strings.ToLower(confirm) == "y" {
yes = true
}
}
if yes == false {
fmt.Fprintln(os.Stderr, "Account not changed")
return nil
}
err = auth.Delete(c, username)
if err != nil {
return err
}
// If user targets themselves, logout.
if username != "" || c.Username == username {
if err := client.Delete(); err != nil {
return err
}
}
fmt.Println("Account cancelled")
return nil
}
// Regenerate regenenerates a user's token.
func Regenerate(username string, all bool) error {
c, err := client.New()
if err != nil {
return err
}
token, err := auth.Regenerate(c, username, all)
if err != nil {
return err
}
if username == "" && all == false {
c.Token = token
err = c.Save()
if err != nil {
return err
}
}
fmt.Println("Token Regenerated")
return nil
}
// KeyAdd adds keys.
func KeyAdd(keyLocation string) error {
c, err := client.New()
if err != nil {
return err
}
var key api.KeyCreateRequest
if keyLocation == "" {
key, err = chooseKey()
} else {
key, err = getKey(keyLocation)
}
if err != nil {
return err
}
fmt.Printf("Uploading %s to deis...", path.Base(key.Name))
if _, err = keys.New(c, key.ID, key.Public); err != nil {
fmt.Println()
return err
}
fmt.Println(" done")
return nil
}
// CertsList lists certs registered with the controller.
func CertsList(results int) error {
c, err := client.New()
if err != nil {
return err
}
if results == defaultLimit {
results = c.ResponseLimit
}
certList, _, err := certs.List(c, results)
if err != nil {
return err
}
if len(certList) == 0 {
fmt.Println("No certs")
return nil
}
certMap := make(map[string]string)
nameMax := 0
expiresMax := 0
for _, cert := range certList {
certMap[cert.Name] = cert.Expires
if len(cert.Name) > nameMax {
nameMax = len(cert.Name)
}
if len(cert.Expires) > nameMax {
expiresMax = len(cert.Expires)
}
}
nameHeader := "Common Name"
expiresHeader := "Expires"
tabSpaces := 5
bufferSpaces := tabSpaces
if nameMax < len(nameHeader) {
tabSpaces += len(nameHeader) - nameMax
nameMax = len(nameHeader)
} else {
bufferSpaces += nameMax - len(nameHeader)
}
if expiresMax < len(expiresHeader) {
expiresMax = len(expiresHeader)
}
fmt.Printf("%s%s%s\n", nameHeader, strings.Repeat(" ", bufferSpaces), expiresHeader)
fmt.Printf("%s%s%s\n", strings.Repeat("-", nameMax), strings.Repeat(" ", 5),
strings.Repeat("-", expiresMax))
fmt.Print(prettyprint.PrettyTabs(certMap, tabSpaces))
return nil
}
// Whoami prints the logged in user.
func Whoami() error {
c, err := client.New()
if err != nil {
return err
}
fmt.Printf("You are %s at %s\n", c.Username, c.ControllerURL.String())
return nil
}
// AppDestroy destroys an app.
func AppDestroy(appID, confirm string) error {
gitSession := false
c, err := client.New()
if err != nil {
return err
}
if appID == "" {
appID, err = git.DetectAppName(c.ControllerURL.Host)
if err != nil {
return err
}
gitSession = true
}
if confirm == "" {
fmt.Printf(` ! WARNING: Potentially Destructive Action
! This command will destroy the application: %s
! To proceed, type "%s" or re-run this command with --confirm=%s
> `, appID, appID, appID)
fmt.Scanln(&confirm)
}
if confirm != appID {
return fmt.Errorf("App %s does not match confirm %s, aborting.", appID, confirm)
}
startTime := time.Now()
fmt.Printf("Destroying %s...\n", appID)
if err = apps.Delete(c, appID); err != nil {
return err
}
fmt.Printf("done in %ds\n", int(time.Since(startTime).Seconds()))
if gitSession {
return git.DeleteRemote(appID)
}
return nil
}
func permsLoad(appID string, admin bool) (*client.Client, string, error) {
c, err := client.New()
if err != nil {
return nil, "", err
}
if !admin && appID == "" {
appID, err = git.DetectAppName(c.ControllerURL.Host)
if err != nil {
return nil, "", err
}
}
return c, appID, err
}
// KeyRemove removes keys.
func KeyRemove(keyID string) error {
c, err := client.New()
if err != nil {
return err
}
fmt.Printf("Removing %s SSH Key...", keyID)
if err = keys.Delete(c, keyID); err != nil {
fmt.Println()
return err
}
fmt.Println(" done")
return nil
}
func load(appID string) (*client.Client, string, error) {
c, err := client.New()
if err != nil {
return nil, "", err
}
if appID == "" {
appID, err = git.DetectAppName(c.ControllerURL.Host)
if err != nil {
return nil, "", err
}
}
return c, appID, nil
}
// Passwd changes a user's password.
func Passwd(username string, password string, newPassword string) error {
c, err := client.New()
if err != nil {
return err
}
if password == "" && username == "" {
fmt.Print("current password: "******"" {
fmt.Print("new password: "******"\nnew password (confirm): ")
passwordConfirm, err := readPassword()
fmt.Println()
if err != nil {
return err
}
if newPassword != passwordConfirm {
return errors.New("Password mismatch, not changing.")
}
}
err = auth.Passwd(c, username, password, newPassword)
if err != nil {
fmt.Fprint(os.Stderr, "Password change failed: ")
return err
}
fmt.Println("Password change succeeded.")
return nil
}
// AppCreate creates an app.
func AppCreate(id string, buildpack string, remote string, noRemote bool) error {
c, err := client.New()
if err != nil {
return err
}
fmt.Print("Creating Application... ")
quit := progress()
app, err := apps.New(c, id)
quit <- true
<-quit
if err != nil {
return err
}
fmt.Printf("done, created %s\n", app.ID)
if buildpack != "" {
configValues := api.Config{
Values: map[string]interface{}{
"BUILDPACK_URL": buildpack,
},
}
if _, err = config.Set(c, app.ID, configValues); err != nil {
return err
}
}
if !noRemote {
if err = git.CreateRemote(c.ControllerURL.Host, remote, app.ID); err != nil {
if err.Error() == "exit status 128" {
fmt.Println("To replace the existing git remote entry, run:")
fmt.Printf(" git remote rename deis deis.old && deis git:remote -a %s\n", app.ID)
}
return err
}
}
fmt.Println("remote available at", git.RemoteURL(c.ControllerURL.Host, app.ID))
return nil
}
// CertAdd adds a cert to the controller.
func CertAdd(cert, key, commonName, sans string) error {
c, err := client.New()
if err != nil {
return err
}
fmt.Print("Adding SSL endpoint... ")
quit := progress()
err = processCertsAdd(c, cert, key, commonName, sans)
quit <- true
<-quit
if err != nil {
return err
}
fmt.Println("done")
return nil
}
// CertRemove deletes a cert from the controller.
func CertRemove(commonName string) error {
c, err := client.New()
if err != nil {
return err
}
fmt.Printf("Removing %s... ", commonName)
quit := progress()
certs.Delete(c, commonName)
quit <- true
<-quit
if err == nil {
fmt.Println("done")
}
return err
}
// UsersList lists users registered with the controller.
func UsersList(results int) error {
c, err := client.New()
if err != nil {
return err
}
if results == defaultLimit {
results = c.ResponseLimit
}
users, count, err := users.List(c, results)
if err != nil {
return err
}
fmt.Printf("=== Users%s", limitCount(len(users), count))
for _, user := range users {
fmt.Println(user.Username)
}
return nil
}
// AppsList lists apps on the Deis controller.
func AppsList(results int) error {
c, err := client.New()
if err != nil {
return err
}
if results == defaultLimit {
results = c.ResponseLimit
}
apps, count, err := apps.List(c, results)
if err != nil {
return err
}
fmt.Printf("=== Apps%s", limitCount(len(apps), count))
for _, app := range apps {
fmt.Println(app.ID)
}
return nil
}
// KeysList lists a user's keys.
func KeysList(results int) error {
c, err := client.New()
if err != nil {
return err
}
if results == defaultLimit {
results = c.ResponseLimit
}
keys, count, err := keys.List(c, results)
if err != nil {
return err
}
fmt.Printf("=== %s Keys%s", c.Username, limitCount(len(keys), count))
for _, key := range keys {
fmt.Printf("%s %s...%s\n", key.ID, key.Public[:16], key.Public[len(key.Public)-10:])
}
return nil
}
// Register creates a account on a Deis controller.
func Register(controller string, username string, password string, email string,
sslVerify bool) error {
u, err := url.Parse(controller)
httpClient := client.CreateHTTPClient(sslVerify)
if err != nil {
return err
}
controllerURL, err := chooseScheme(*u)
if err != nil {
return err
}
if err = client.CheckConnection(httpClient, controllerURL); err != nil {
return err
}
if username == "" {
fmt.Print("username: "******"" {
fmt.Print("password: "******"\npassword (confirm): ")
passwordConfirm, err := readPassword()
fmt.Println()
if err != nil {
return err
}
if password != passwordConfirm {
return errors.New("Password mismatch, aborting registration.")
}
}
if email == "" {
fmt.Print("email: ")
fmt.Scanln(&email)
}
c := &client.Client{ControllerURL: controllerURL, SSLVerify: sslVerify, HTTPClient: httpClient}
tempClient, err := client.New()
if err == nil {
c.Token = tempClient.Token
}
err = auth.Register(c, username, password, email)
c.Token = ""
if err != nil {
fmt.Fprint(os.Stderr, "Registration failed: ")
return err
}
fmt.Printf("Registered %s\n", username)
return doLogin(c, username, password)
}