Add argocd login command

cmd/argocd/commands/app.go

@@ -13,6 +13,7 @@ import (
 	argoappv1 "github.com/argoproj/argo-cd/pkg/apis/application/v1alpha1"
 	"github.com/argoproj/argo-cd/server/application"
 	"github.com/argoproj/argo-cd/util"
+	"github.com/argoproj/argo-cd/util/cli"
 	"github.com/argoproj/argo-cd/util/diff"
 	"github.com/spf13/cobra"
 	"github.com/yudai/gojsondiff/formatter"
@@ -61,20 +62,15 @@ func NewApplicationAddCommand(clientOpts *argocdclient.ClientOptions) *cobra.Com
 			}
 			var app argoappv1.Application
 			if fileURL != "" {
-				var (
-					fileContents []byte
-					err          error
-				)
-				_, err = url.ParseRequestURI(fileURL)
+				_, err := url.ParseRequestURI(fileURL)
 				if err != nil {
-					fileContents, err = readLocalFile(fileURL)
+					err = cli.UnmarshalLocalFile(fileURL, &app)
 				} else {
-					fileContents, err = readRemoteFile(fileURL)
+					err = cli.UnmarshalRemoteFile(fileURL, &app)
 				}
 				if err != nil {
 					log.Fatal(err)
 				}
-				unmarshalApplication(fileContents, &app)
 
 			} else {
 				// all these params are required if we're here

cmd/argocd/commands/login.go

@@ -0,0 +1,79 @@
+package commands
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"log"
+	"os"
+	"strings"
+	"syscall"
+
+	"github.com/argoproj/argo-cd/errors"
+	argocdclient "github.com/argoproj/argo-cd/pkg/apiclient"
+	"github.com/argoproj/argo-cd/server/session"
+	"github.com/argoproj/argo-cd/util"
+	util_config "github.com/argoproj/argo-cd/util/config"
+	"github.com/spf13/cobra"
+	"golang.org/x/crypto/ssh/terminal"
+)
+
+// NewLoginCommand returns a new instance of `argocd login` command
+func NewLoginCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
+	var (
+		username string
+		password string
+	)
+	var command = &cobra.Command{
+		Use:   "login",
+		Short: "Log in to Argo CD",
+		Long:  "Log in to Argo CD",
+		Run: func(c *cobra.Command, args []string) {
+			for username == "" {
+				reader := bufio.NewReader(os.Stdin)
+				fmt.Print("Username: ")
+				usernameRaw, err := reader.ReadString('\n')
+				if err != nil {
+					log.Fatal(err)
+				}
+				username = strings.TrimSpace(usernameRaw)
+			}
+			for password == "" {
+				fmt.Print("Password: ")
+				passwordRaw, err := terminal.ReadPassword(syscall.Stdin)
+				if err != nil {
+					log.Fatal(err)
+				}
+				password = string(passwordRaw)
+				if password == "" {
+					fmt.Print("\n")
+				}
+			}
+
+			conn, sessionIf := argocdclient.NewClientOrDie(clientOpts).NewSessionClientOrDie()
+			defer util.Close(conn)
+
+			sessionRequest := session.SessionRequest{
+				Username: username,
+				Password: password,
+			}
+			createdSession, err := sessionIf.Create(context.Background(), &sessionRequest)
+			errors.CheckError(err)
+			fmt.Printf("user %q logged in successfully\n", username)
+
+			// now persist the new token
+			localConfig, err := util_config.ReadLocalConfig()
+			if err != nil {
+				log.Fatal(err)
+			}
+			localConfig.Sessions[clientOpts.ServerAddr] = createdSession.Token
+			err = util_config.WriteLocalConfig(localConfig)
+			if err != nil {
+				log.Fatal(err)
+			}
+
+		},
+	}
+	command.Flags().StringVar(&username, "username", "", "the username of an account to authenticate")
+	return command
+}

cmd/argocd/commands/root.go

@@ -25,6 +25,7 @@ func NewCommand() *cobra.Command {
 	command.AddCommand(cli.NewVersionCmd(cliName))
 	command.AddCommand(NewClusterCommand(&clientOpts, pathOpts))
 	command.AddCommand(NewApplicationCommand(&clientOpts))
+	command.AddCommand(NewLoginCommand(&clientOpts))
 	command.AddCommand(NewRepoCommand(&clientOpts))
 	command.AddCommand(NewInstallCommand())
 	command.AddCommand(NewUninstallCommand())

pkg/apiclient/apiclient.go

@@ -12,6 +12,7 @@ import (
 	"github.com/argoproj/argo-cd/server/application"
 	"github.com/argoproj/argo-cd/server/cluster"
 	"github.com/argoproj/argo-cd/server/repository"
+	"github.com/argoproj/argo-cd/server/session"
 	grpc_util "github.com/argoproj/argo-cd/util/grpc"
 	log "github.com/sirupsen/logrus"
 	"google.golang.org/grpc"
@@ -31,6 +32,8 @@ type ServerClient interface {
 	NewClusterClientOrDie() (*grpc.ClientConn, cluster.ClusterServiceClient)
 	NewApplicationClient() (*grpc.ClientConn, application.ApplicationServiceClient, error)
 	NewApplicationClientOrDie() (*grpc.ClientConn, application.ApplicationServiceClient)
+	NewSessionClient() (*grpc.ClientConn, session.SessionServiceClient, error)
+	NewSessionClientOrDie() (*grpc.ClientConn, session.SessionServiceClient)
 }
 
 type ClientOptions struct {
@@ -143,3 +146,20 @@ func (c *client) NewApplicationClientOrDie() (*grpc.ClientConn, application.Appl
 	}
 	return conn, repoIf
 }
+
+func (c *client) NewSessionClient() (*grpc.ClientConn, session.SessionServiceClient, error) {
+	conn, err := c.NewConn()
+	if err != nil {
+		return nil, nil, err
+	}
+	sessionIf := session.NewSessionServiceClient(conn)
+	return conn, sessionIf, nil
+}
+
+func (c *client) NewSessionClientOrDie() (*grpc.ClientConn, session.SessionServiceClient) {
+	conn, sessionIf, err := c.NewSessionClient()
+	if err != nil {
+		log.Fatalf("Failed to establish connection to %s: %v", c.ServerAddr, err)
+	}
+	return conn, sessionIf
+}

util/cli/config.go

@@ -0,0 +1,74 @@
+package cli
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"net/http"
+
+	"github.com/ghodss/yaml"
+)
+
+// unmarshalObject tries to convert a YAML or JSON byte array into the provided type.
+func unmarshalObject(data []byte, obj interface{}) error {
+	// first, try unmarshaling as JSON
+	// Based on technique from Kubectl, which supports both YAML and JSON:
+	//   https://mlafeldt.github.io/blog/teaching-go-programs-to-love-json-and-yaml/
+	//   http://ghodss.com/2014/the-right-way-to-handle-yaml-in-golang/
+	// Short version: JSON unmarshaling won't zero out null fields; YAML unmarshaling will.
+	// This may have unintended effects or hard-to-catch issues when populating our application object.
+	jsonData, err := yaml.YAMLToJSON(data)
+	if err != nil {
+		return err
+	}
+
+	err = json.Unmarshal(jsonData, &obj)
+	if err != nil {
+		return err
+	}
+
+	return err
+}
+
+// MarshalLocalYAMLFile writes JSON or YAML to a file on disk.
+// The caller is responsible for checking error return values.
+func MarshalLocalYAMLFile(path string, obj interface{}) error {
+	yamlData, err := yaml.Marshal(obj)
+	if err == nil {
+		err = ioutil.WriteFile(path, yamlData, 0600)
+	}
+	return err
+}
+
+// UnmarshalLocalFile retrieves JSON or YAML from a file on disk.
+// The caller is responsible for checking error return values.
+func UnmarshalLocalFile(path string, obj interface{}) error {
+	data, err := ioutil.ReadFile(path)
+	if err == nil {
+		err = unmarshalObject(data, obj)
+	}
+	return err
+}
+
+// UnmarshalRemoteFile retrieves JSON or YAML through a GET request.
+// The caller is responsible for checking error return values.
+func UnmarshalRemoteFile(url string, obj interface{}) error {
+	data, err := readRemoteFile(url)
+	if err == nil {
+		err = unmarshalObject(data, obj)
+	}
+	return err
+}
+
+// ReadRemoteFile issues a GET request to retrieve the contents of the specified URL as a byte array.
+// The caller is responsible for checking error return values.
+func readRemoteFile(url string) ([]byte, error) {
+	var data []byte
+	resp, err := http.Get(url)
+	if err == nil {
+		defer func() {
+			_ = resp.Body.Close()
+		}()
+		data, err = ioutil.ReadAll(resp.Body)
+	}
+	return data, err
+}