Merge pull request #107 from QuentinPerez/add_upload_ssh_key_at_login

upload ssh key

Author: moul

pkg/api/api.go

@@ -400,7 +400,7 @@ type ScalewayServer struct {
 	// StateDetail is the detailed status of the server
 	StateDetail string `json:"state_detail,omitempty"`
 
-	// PrivateIP reprensents the private IPV4 attached to the server (changes on each boot)
+	// PrivateIP represents the private IPV4 attached to the server (changes on each boot)
 	PrivateIP string `json:"private_ip,omitempty"`
 
 	// Bootscript is the unique identifier of the selected bootscript
@@ -497,6 +497,37 @@ type ScalewayImageDefinition struct {
 	Arch               string `json:"arch"`
 }
 
+// ScalewayTokenUserIDRoleDefinition represents a Scaleway Token UserId Role
+type ScalewayTokenUserIDRoleDefinition struct {
+	Organization string `json:"organization,omitempty"`
+	Role         string `json:"role,omitempty"`
+}
+
+// ScalewayTokenDefinition represents a Scaleway Token
+type ScalewayTokenDefinition struct {
+	UserID             string                            `json:"user_id"`
+	Description        string                            `json:"description,omitempty"`
+	Roles              ScalewayTokenUserIDRoleDefinition `json:"roles"`
+	Expires            string                            `json:"expires"`
+	InheritsUsersPerms bool                              `json:"inherits_user_perms"`
+	ID                 string                            `json:"id"`
+}
+
+// ScalewayTokensDefinition represents a Scaleway Tokens
+type ScalewayTokensDefinition struct {
+	Tokens []ScalewayTokenDefinition `json:"tokens"`
+}
+
+// ScalewayUserPatchKeyDefinition represents a key
+type ScalewayUserPatchKeyDefinition struct {
+	Key string `json:"key"`
+}
+
+// ScalewayUserPatchDefinition represents a User Patch
+type ScalewayUserPatchDefinition struct {
+	SSHPublicKeys []ScalewayUserPatchKeyDefinition `json:"ssh_public_keys"`
+}
+
 // FuncMap used for json inspection
 var FuncMap = template.FuncMap{
 	"json": func(v interface{}) string {
@@ -752,7 +783,7 @@ func (s *ScalewayAPI) DeleteServer(serverID string) error {
 func (s *ScalewayAPI) PostServer(definition ScalewayServerDefinition) (string, error) {
 	definition.Organization = s.Organization
 
-	resp, err := s.PostResponse(fmt.Sprintf("servers"), definition)
+	resp, err := s.PostResponse("servers", definition)
 	if err != nil {
 		return "", err
 	}
@@ -783,6 +814,34 @@ func (s *ScalewayAPI) PostServer(definition ScalewayServerDefinition) (string, e
 	return "", error
 }
 
+// PatchUser updates a user
+func (s *ScalewayAPI) PatchUser(UserID string, definition ScalewayUserPatchDefinition) error {
+	s.enableAccountAPI()
+	defer s.disableAccountAPI()
+	resp, err := s.PatchResponse(fmt.Sprintf("users/%s", UserID), definition)
+	if err != nil {
+		return err
+	}
+
+	defer resp.Body.Close()
+	decoder := json.NewDecoder(resp.Body)
+
+	// Succeed PATCH code
+	if resp.StatusCode == 200 {
+		return nil
+	}
+
+	var error ScalewayAPIError
+	err = decoder.Decode(&error)
+	if err != nil {
+		return err
+	}
+
+	error.StatusCode = resp.StatusCode
+	error.Debug()
+	return error
+}
+
 // PatchServer updates a server
 func (s *ScalewayAPI) PatchServer(serverID string, definition ScalewayServerPatchDefinition) error {
 	resp, err := s.PatchResponse(fmt.Sprintf("servers/%s", serverID), definition)
@@ -894,7 +953,7 @@ func (s *ScalewayAPI) PostVolume(definition ScalewayVolumeDefinition) (string, e
 	if definition.Type == "" {
 		definition.Type = "l_ssd"
 	}
-	resp, err := s.PostResponse(fmt.Sprintf("volumes"), definition)
+	resp, err := s.PostResponse("volumes", definition)
 	if err != nil {
 		return "", err
 	}
@@ -1201,20 +1260,46 @@ func (s *ScalewayAPI) GetTasks() (*[]ScalewayTask, error) {
 
 // CheckCredentials performs a dummy check to ensure we can contact the API
 func (s *ScalewayAPI) CheckCredentials() error {
-	s.enableAccountApi()
-	defer s.disableAccountApi()
+	s.enableAccountAPI()
+	defer s.disableAccountAPI()
 	query := url.Values{}
 	query.Set("token_id", s.Token)
 	resp, err := s.GetResponse("tokens?" + query.Encode())
 	if err != nil {
 		return err
 	}
 	if resp.StatusCode != 200 {
-		return fmt.Errorf("invalid credentials")
+		return fmt.Errorf("[%d] invalid credentials", resp.StatusCode)
 	}
 	return nil
 }
 
+// GetUserID returns the UserID
+func (s *ScalewayAPI) GetUserID() (string, error) {
+	s.enableAccountAPI()
+	defer s.disableAccountAPI()
+	resp, err := s.GetResponse("tokens")
+	if err != nil {
+		return "", err
+	}
+	if resp.StatusCode != 200 {
+		return "", fmt.Errorf("[%d] invalid credentials", resp.StatusCode)
+	}
+	defer resp.Body.Close()
+	var tokens ScalewayTokensDefinition
+	decoder := json.NewDecoder(resp.Body)
+	err = decoder.Decode(&tokens)
+	if err != nil {
+		return "", err
+	}
+	if len(tokens.Tokens) == 0 {
+		return "", fmt.Errorf("Unable to get tokens")
+	}
+	return tokens.Tokens[0].UserID, nil
+}
+
+//
+
 // GetServerID returns exactly one server matching or dies
 func (s *ScalewayAPI) GetServerID(needle string) string {
 	// Parses optional type prefix, i.e: "server:name" -> "name"
@@ -1322,10 +1407,10 @@ func (s *ScalewayAPI) HideAPICredentials(input string) string {
 	return output
 }
 
-func (s *ScalewayAPI) enableAccountApi() {
+func (s *ScalewayAPI) enableAccountAPI() {
 	s.APIUrl = s.AccountAPI
 }
 
-func (s *ScalewayAPI) disableAccountApi() {
+func (s *ScalewayAPI) disableAccountAPI() {
 	s.APIUrl = s.ComputeAPI
 }

pkg/commands/login.go

@@ -7,19 +7,75 @@ package commands
 import (
 	"bufio"
 	"fmt"
+	"io/ioutil"
 	"os"
+	"path/filepath"
+	"strconv"
 	"strings"
 
 	"github.com/scaleway/scaleway-cli/vendor/github.com/Sirupsen/logrus"
 	"github.com/scaleway/scaleway-cli/vendor/golang.org/x/crypto/ssh/terminal"
 
 	"github.com/scaleway/scaleway-cli/pkg/api"
+	"github.com/scaleway/scaleway-cli/pkg/utils"
 )
 
 // LoginArgs are arguments passed to `RunLogin`
 type LoginArgs struct {
 	Organization string
 	Token        string
+	SSHKey       string
+}
+
+// selectKey allows to choice a key in ~/.ssh
+func selectKey(args *LoginArgs) error {
+	fmt.Println("Do you want to upload a SSH key ?")
+	home, err := utils.GetHomeDir()
+	if err != nil {
+		return err
+	}
+	dir := filepath.Join(home, ".ssh")
+	files, err := ioutil.ReadDir(dir)
+	if err != nil {
+		return fmt.Errorf("Unable to open your ~/.ssh: %v", err)
+	}
+	var pubs []string
+
+	for i := range files {
+		if filepath.Ext(files[i].Name()) == ".pub" {
+			pubs = append(pubs, files[i].Name())
+		}
+	}
+	if len(pubs) == 0 {
+		return nil
+	}
+	fmt.Println("[0] I don't want to upload a key !")
+	for i := range pubs {
+		fmt.Printf("[%d] %s\n", i+1, pubs[i])
+	}
+	for {
+		promptUser("Which [id]: ", &args.SSHKey, true)
+		id, err := strconv.ParseUint(strings.TrimSpace(args.SSHKey), 10, 32)
+		if err != nil {
+			fmt.Println(err)
+			continue
+		}
+		if int(id) > len(pubs) {
+			fmt.Println("Out of range id must be lower than", len(pubs))
+			continue
+		}
+		args.SSHKey = ""
+		if id == 0 {
+			break
+		}
+		buff, err := ioutil.ReadFile(filepath.Join(dir, pubs[id-1]))
+		if err != nil {
+			return fmt.Errorf("Unable to open your key: %v", err)
+		}
+		args.SSHKey = string(buff[:len(buff)])
+		break
+	}
+	return nil
 }
 
 // RunLogin is the handler for 'scw login'
@@ -39,14 +95,35 @@ func RunLogin(ctx CommandContext, args LoginArgs) error {
 		Token:        strings.Trim(args.Token, "\n"),
 	}
 
-	api, err := api.NewScalewayAPI(cfg.ComputeAPI, cfg.AccountAPI, cfg.Organization, cfg.Token)
+	apiConnection, err := api.NewScalewayAPI(cfg.ComputeAPI, cfg.AccountAPI, cfg.Organization, cfg.Token)
 	if err != nil {
 		return fmt.Errorf("Unable to create ScalewayAPI: %s", err)
 	}
-	err = api.CheckCredentials()
+	err = apiConnection.CheckCredentials()
 	if err != nil {
 		return fmt.Errorf("Unable to contact ScalewayAPI: %s", err)
 	}
+	if err := selectKey(&args); err != nil {
+		logrus.Errorf("Unable to select a key: %v", err)
+	} else {
+		if args.SSHKey != "" {
+			userID, err := apiConnection.GetUserID()
+			if err != nil {
+				logrus.Errorf("Unable to contact ScalewayAPI: %s", err)
+			} else {
+
+				SSHKey := api.ScalewayUserPatchDefinition{
+					SSHPublicKeys: []api.ScalewayUserPatchKeyDefinition{{
+						Key: strings.Trim(args.SSHKey, "\n"),
+					}},
+				}
+
+				if err = apiConnection.PatchUser(userID, SSHKey); err != nil {
+					logrus.Errorf("Unable to patch SSHkey: %v", err)
+				}
+			}
+		}
+	}
 	return cfg.Save()
 }
 

pkg/utils/utils.go

@@ -166,17 +166,25 @@ func RemoveDuplicates(elements []string) []string {
 	return result
 }
 
-// GetConfigFilePath returns the path to the Scaleway CLI config file
-func GetConfigFilePath() (string, error) {
+// GetHomeDir returns the path to your home
+func GetHomeDir() (string, error) {
 	homeDir := os.Getenv("HOME") // *nix
 	if homeDir == "" {           // Windows
 		homeDir = os.Getenv("USERPROFILE")
 	}
 	if homeDir == "" {
 		return "", errors.New("user home directory not found")
 	}
+	return homeDir, nil
+}
 
-	return filepath.Join(homeDir, ".scwrc"), nil
+// GetConfigFilePath returns the path to the Scaleway CLI config file
+func GetConfigFilePath() (string, error) {
+	path, err := GetHomeDir()
+	if err != nil {
+		return "", err
+	}
+	return filepath.Join(path, ".scwrc"), nil
 }
 
 const termjsBin string = "termjs-cli"