Auth list providers

Gopkg.toml

@@ -17,3 +17,7 @@
 [[constraint]]
   name = "github.com/spf13/afero"
   version = "1.0.2"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/olekukonko/tablewriter"

pkg/cmd/dcos.go

@@ -9,16 +9,20 @@ import (
 
 	"github.com/dcos/dcos-cli/pkg/config"
 	"github.com/spf13/cobra"
+	"io"
 )
 
 // rootCmd represents the base command when called without any subcommands.
 var rootCmd = &cobra.Command{
 	Use: "dcos",
 }
 
+var dcosConfig *Cluster
+
 // Execute adds all child commands to the root command and sets flags appropriately.
 // This is called by main.main(). It only needs to happen once to the rootCmd.
 func Execute() {
+	dcosConfig = attachedCluster()
 	if err := rootCmd.Execute(); err != nil {
 		fmt.Println(err)
 		os.Exit(1)
@@ -46,8 +50,27 @@ func attachedCluster() *Cluster {
 		os.Exit(1)
 	}
 
+	// Default to the old config path. If .dcos/clusters exists, it will search that for an attached cluster and if it
+	// finds one there, it will override this var to use that cluster's config instead.
+	configPath := filepath.Join(usr.HomeDir, ".dcos")
+
+	clustersDir := filepath.Join(configPath, "clusters")
+
+	// Find the config of the attached cluster.
+	err = filepath.Walk(clustersDir, func(path string, info os.FileInfo, err error) error {
+		if filepath.Base(path) == "attached" {
+			configPath = filepath.Dir(path)
+			return io.EOF
+		}
+		return nil
+	})
+	if err != io.EOF && err != filepath.SkipDir && err != nil {
+		fmt.Println(err)
+	}
+
+
 	// Make sure "~/.dcos/dcos.toml" exists.
-	path := filepath.Join(dir, "dcos.toml")
+	path := filepath.Join(configPath, "dcos.toml")
 	f, err := os.OpenFile(path, os.O_RDONLY|os.O_CREATE, 0600)
 	if err != nil {
 		fmt.Printf("Couldn't create config file \"%s\": %s.\n", path, err)

pkg/cmd/dcos_auth_listproviders.go

@@ -0,0 +1,120 @@
+package cmd
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"github.com/dcos/dcos-cli/pkg/httpclient"
+	"github.com/olekukonko/tablewriter"
+	"github.com/spf13/cobra"
+	"os"
+)
+
+// These are the different auth types that DC/OS supports with the names that they'll be given from the providers
+// endpoint.
+const (
+	AuthTypeDCOSUidPassword = "dcos-uid-password"
+	AuthTypeDCOSUidServiceKey = "dcos-uid-servicekey"
+	AuthTypeDCOSUidPasswordLDAP = "dcos-uid-password-ldap"
+	AuthTypeSAMLSpInitiated = "saml-sp-initiated"
+	AuthTypeOIDCAuthCodeFlow = "oidc-authorization-code-flow"
+	AuthTypeOIDCImplicitFlow = "oidc-implicit-flow"
+)
+
+var jsonOutput bool
+
+// authCmd represents the `dcos auth` subcommand.
+var authListProvidersCmd = &cobra.Command{
+	Use: "list-providers",
+	Run: listProviders,
+}
+
+func init() {
+	authCmd.AddCommand(authListProvidersCmd)
+	authListProvidersCmd.Flags().BoolVar(&jsonOutput, "json", false,
+		"returns providers in json format")
+}
+
+func listProviders(cmd *cobra.Command, args []string) {
+	providers, err := getProviders()
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+
+	if jsonOutput {
+		// re-marshal it into json with indents added in for pretty printing
+		out, err := json.MarshalIndent(providers, "", "\t")
+		if err != nil {
+			fmt.Println(err)
+			os.Exit(1)
+		}
+		fmt.Println(string(out))
+	} else {
+		table := tablewriter.NewWriter(os.Stdout)
+		table.SetHeader([]string{"PROVIDER ID", "AUTHENTICATION TYPE"})
+		// turn off wrapping because it seems to wrap even if the column is set to be wide enough
+		table.SetAutoWrapText(false)
+		table.SetBorder(false)
+		table.SetRowSeparator(" ")
+		table.SetColumnSeparator(" ")
+		table.SetCenterSeparator(" ")
+
+		for name, provider := range *providers {
+			desc, err := authTypeDescription(provider.AuthenticationType, provider)
+			if err != nil {
+				fmt.Printf("Unknown authentication type %s", provider.AuthenticationType)
+				os.Exit(1)
+			}
+			table.Append([]string{name, desc})
+		}
+		table.Render()
+	}
+}
+
+func getProviders() (*map[string]authProvider, error) {
+	var config = dcosConfig.Config
+	var client = httpclient.New(config)
+	var response, err = client.Get("/acs/api/v1/auth/providers")
+	if err != nil {
+		return nil, err
+	}
+	defer response.Body.Close()
+
+	var resp map[string]authProvider
+	err = json.NewDecoder(response.Body).Decode(&resp)
+	if err != nil {
+		return nil, err
+	}
+
+	return &resp, nil
+}
+
+func authTypeDescription(authType string, provider authProvider) (string, error) {
+	var desc string
+	if authType == AuthTypeDCOSUidPassword {
+		desc = "Log in using a standard DC/OS user account (username and password)"
+	} else if authType == AuthTypeDCOSUidServiceKey {
+		desc = "Log in using a DC/OS service user account (username and private key)"
+	} else if authType == AuthTypeDCOSUidPasswordLDAP {
+		desc = "Log in in using an LDAP user account (username and password)"
+	} else if authType == AuthTypeSAMLSpInitiated {
+		desc = fmt.Sprintf("Log in using SAML 2.0 (%s)", provider.Description)
+	} else if authType == AuthTypeOIDCAuthCodeFlow || authType == AuthTypeOIDCImplicitFlow {
+		desc = fmt.Sprintf("Log in using OpenID Connect(%s)", provider.Description)
+	} else {
+		return "", errors.New("unknown authentication type")
+	}
+	return desc, nil
+}
+
+type authProvider struct {
+	AuthenticationType string                 `json:"authentication-type"`
+	ClientMethod       string                 `json:"client-method"`
+	Config             authListProviderConfig `json:"config"`
+	Description        string                 `json:"description"`
+}
+
+type authListProviderConfig struct {
+	StartFlowUrl string `json:"start_flow_url"`
+}