feat: introducing named profiles

```
As a Lacework CLI User with multiple Lacework Accounts,
I would like to be able to configure my Lacework CLI with multiple profiles,
So I can switch easily between accounts without having to reconfigure my configuration file.
```

This change is introducing named profiles and removing the parameter
`--config` since we will hardcode the config to be in
`$HOME/.lacework.toml`. Why? Since we can configure multiple profiles
today, we do not need to pass in any other config location.

Previous versions of the config are compatible to this change so there
are no breaking changes.

All environment variables previously defined continues to work in
addition to the new environment variable `LW_PROFILE` that switches the
profile to use.

Closes #36

Signed-off-by: Salim Afiune Maya <[email protected]>

Author: afiune

cli/cmd/api.go

@@ -81,7 +81,7 @@ func runApiCommand(_ *cobra.Command, args []string) error {
 		api.WithApiKeys(cli.KeyID, cli.Secret),
 	)
 	if err != nil {
-		return errors.Wrap(err, "unable to generate Lacework api client")
+		return errors.Wrap(err, "unable to generate api client")
 	}
 
 	response := new(map[string]interface{})

cli/cmd/cli_state.go

@@ -0,0 +1,156 @@
+//
+// Author:: Salim Afiune Maya (<[email protected]>)
+// Copyright:: Copyright 2020, Lacework Inc.
+// License:: Apache License, Version 2.0
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+package cmd
+
+import (
+	"fmt"
+
+	prettyjson "github.com/hokaccha/go-prettyjson"
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+	"go.uber.org/zap"
+)
+
+// cliState holds the state of the entire Lacework CLI
+type cliState struct {
+	Profile  string
+	Account  string
+	KeyID    string
+	Secret   string
+	Token    string
+	LogLevel string
+
+	JsonF *prettyjson.Formatter
+	Log   *zap.SugaredLogger
+
+	profileDetails map[string]interface{}
+}
+
+// NewDefaultState creates a new cliState with some defaults
+func NewDefaultState() cliState {
+	return cliState{
+		Profile: "default",
+		JsonF:   prettyjson.NewFormatter(),
+	}
+}
+
+// SetProfile sets the provided profile into the cliState and loads the entire
+// state of the Lacework CLI by calling 'LoadState()'
+func (c *cliState) SetProfile(profile string) error {
+	if profile == "" {
+		return errors.New("Specify a profile.")
+	}
+
+	c.Profile = profile
+	c.Log.Debugw("custom profile", "profile", profile)
+	return c.LoadState()
+}
+
+// LoadState loads the state of the cli in the following order, loads the
+// configured profile out from the viper loaded config, if the profile is
+// set to the default and it is not found, we assume that the user is running
+// the CLI with parameters or environment variables, so we proceed to load
+// those. Though, if the profile is NOT the default, we error out with some
+// breadcrumbs to help the user configure the CLI. After loading the profile,
+// this function verifies parameters and env variables coming from viper
+func (c *cliState) LoadState() error {
+	c.profileDetails = viper.GetStringMap(c.Profile)
+	if len(c.profileDetails) == 0 {
+		if c.Profile != "default" {
+			return fmt.Errorf(
+				"The profile '%s' could not be found.\n\nTry running 'lacework configure --profile %s'.",
+				c.Profile, c.Profile,
+			)
+		} else {
+			c.Log.Debugw("unable to load state from config")
+			c.loadStateFromViper()
+			return nil
+		}
+	}
+
+	c.KeyID = c.extractValueString("api_key")
+	c.Secret = c.extractValueString("api_secret")
+	c.Account = c.extractValueString("account")
+
+	c.Log.Debugw("state loaded",
+		"profile", c.Profile,
+		"account", c.Account,
+		"api_key", c.KeyID,
+		"api_secret", c.Secret,
+	)
+
+	c.loadStateFromViper()
+	return nil
+}
+
+// VerifySettings checks if the CLI state has the neccessary settings to run,
+// if not, it throws an error with breadcrumbs to help the user configure the CLI
+func (c *cliState) VerifySettings() error {
+	if c.Profile == "" ||
+		c.Account == "" ||
+		c.Secret == "" ||
+		c.KeyID == "" {
+		return fmt.Errorf(
+			"there is one or more settings missing.\n\nTry running 'lacework configure'.",
+		)
+	}
+
+	return nil
+}
+
+// loadStateFromViper loads parameters and environment variables
+// coming from viper into the CLI state
+func (c *cliState) loadStateFromViper() {
+	if v := viper.GetString("api_key"); v != "" {
+		c.KeyID = v
+		c.Log.Debugw("state updated", "api_key", c.KeyID)
+	}
+
+	if v := viper.GetString("api_secret"); v != "" {
+		c.Secret = v
+		c.Log.Debugw("state updated", "api_secret", c.Secret)
+	}
+
+	if v := viper.GetString("account"); v != "" {
+		c.Account = v
+		c.Log.Debugw("state updated", "account", c.Account)
+	}
+}
+
+func (c *cliState) extractValueString(key string) string {
+	if val, ok := c.profileDetails[key]; ok {
+		if str, ok := val.(string); ok {
+			return str
+		}
+		c.Log.Warnw("config value type mismatch",
+			"expected_type", "string",
+			"file", viper.ConfigFileUsed(),
+			"profile", c.Profile,
+			"key", key,
+			"value", val,
+		)
+		return ""
+	}
+	c.Log.Warnw("unable to find key from config",
+		"file", viper.ConfigFileUsed(),
+		"profile", c.Profile,
+		"key", key,
+	)
+	return ""
+}

cli/cmd/configure.go

@@ -32,20 +32,47 @@ import (
 	"github.com/spf13/viper"
 )
 
-// the representation of the ~/.lacework.toml
-type config struct {
-	Account   string `toml:"account"`
-	ApiKey    string `toml:"api_key"`
-	ApiSecret string `toml:"api_secret"`
+// Profiles is the representation of the ~/.lacework.toml
+//
+// Example:
+//
+// [default]
+// account = "example"
+// api_key = "EXAMPLE_0123456789"
+// api_secret = "_0123456789"
+//
+// [dev]
+// account = "dev"
+// api_key = "DEV_0123456789"
+// api_secret = "_0123456789"
+type Profiles map[string]credsDetails
+
+type credsDetails struct {
+	Account   string `toml:"account" json:"account"`
+	ApiKey    string `toml:"api_key" json:"api_key"`
+	ApiSecret string `toml:"api_secret" json:"api_secret"`
 }
 
 var (
 	// configureCmd represents the configure command
 	configureCmd = &cobra.Command{
 		Use:   "configure",
-		Short: "Set up your Lacework cli",
+		Short: "Configure the Lacework CLI",
 		Args:  cobra.NoArgs,
+		Long: `
+Configure settings that the Lacework CLI uses to interact with the Lacework
+platform. These include your Lacework account, API access key and secret.
+
+If this command is run with no arguments, the Lacework CLI will store all
+settings under the default profile. The information in the default profile
+is used any time you run a Lacework CLI command that doesn't explicitly
+specify a profile to use.
+
+You can configure multiple profiles by using the --profile argument. If a
+config file does not exist (the default location is ~/.lacework.toml), the
+Lacework CLI will create it for you.`,
 		RunE: func(_ *cobra.Command, _ []string) error {
+			cli.Log.Debugw("configuring cli", "profile", cli.Profile)
 			var (
 				promptAccount = promptui.Prompt{
 					Label:   "Account",
@@ -95,21 +122,47 @@ var (
 			}
 
 			var (
-				c        = config{account, apiKey, apiSecret}
+				profiles = Profiles{}
 				buf      = new(bytes.Buffer)
 				confPath = viper.ConfigFileUsed()
 			)
 
-			if err := toml.NewEncoder(buf).Encode(c); err != nil {
-				return err
-			}
-
 			if confPath == "" {
 				home, err := homedir.Dir()
 				if err != nil {
 					return err
 				}
 				confPath = path.Join(home, ".lacework.toml")
+				cli.Log.Debugw("generating new config file",
+					"path", confPath,
+				)
+			} else {
+				if _, err := toml.DecodeFile(confPath, &profiles); err != nil {
+					cli.Log.Debugw("unable to decode profiles from config, trying previous config",
+						"path", confPath, "error", err,
+					)
+
+					var oldcreds credsDetails
+					if _, err2 := toml.DecodeFile(confPath, &oldcreds); err2 != nil {
+						cli.Log.Debugw("unable to decode old config, no more options, exit",
+							"error", err2,
+						)
+						return err
+					}
+					profiles["default"] = oldcreds
+				}
+				cli.Log.Debugw("profiles loaded from config, updating", "profiles", profiles)
+			}
+
+			profiles[cli.Profile] = credsDetails{
+				Account:   account,
+				ApiKey:    apiKey,
+				ApiSecret: apiSecret,
+			}
+
+			cli.Log.Debugw("storing updated profiles", "profiles", profiles)
+			if err := toml.NewEncoder(buf).Encode(profiles); err != nil {
+				return err
 			}
 
 			err = ioutil.WriteFile(confPath, buf.Bytes(), 0600)

cli/cmd/integration.go

@@ -45,7 +45,7 @@ var (
 				api.WithApiKeys(cli.KeyID, cli.Secret),
 			)
 			if err != nil {
-				return errors.Wrap(err, "unable to generate Lacework api client")
+				return errors.Wrap(err, "unable to generate api client")
 			}
 
 			integrations, err := lacework.Integrations.List()