cli configuration and status api

fixes: #294, #279, #280, #290

_integration/cmp/provider.go

@@ -23,7 +23,7 @@ func providerCreate(root vars.Ref, key vars.Ref, paddr vars.Ref) gestalt.Compone
 }
 
 func providerRun(root vars.Ref, key vars.Ref, paddr vars.Ref) gestalt.Component {
-	return akash_(root, "provider-run", "provider", "run", paddr.Var(), "-k", key.Name()).
+	return akash_(root, "provider-run", "provider", "run", paddr.Var(), "-k", key.Name(), "--host", "localhost").
 		WithMeta(g.Require(paddr.Name()))
 }
 

cmd/akash/key.go

@@ -6,7 +6,6 @@ import (
 	"os"
 	"text/tabwriter"
 
-	"github.com/ovrclk/akash/cmd/akash/constants"
 	"github.com/ovrclk/akash/cmd/akash/session"
 	"github.com/spf13/cobra"
 
@@ -48,7 +47,12 @@ func doKeyCreateCommand(session session.Session, cmd *cobra.Command, args []stri
 		return err
 	}
 
-	info, _, err := kmgr.Create(args[0], constants.Password, ktype)
+	password, err := session.Password()
+	if err != nil {
+		return err
+	}
+
+	info, _, err := kmgr.Create(args[0], password, ktype)
 	if err != nil {
 		return err
 	}

cmd/akash/provider.go

@@ -5,7 +5,6 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/ovrclk/akash/cmd/akash/constants"
 	"github.com/ovrclk/akash/cmd/akash/session"
 	"github.com/ovrclk/akash/cmd/common"
 	"github.com/ovrclk/akash/keys"
@@ -71,7 +70,12 @@ func doCreateProviderCommand(session session.Session, cmd *cobra.Command, args [
 			return err
 		}
 
-		info, _, err := kmgr.Create(kname, constants.Password, ktype)
+		password, err := session.Password()
+		if err != nil {
+			return err
+		}
+
+		info, _, err := kmgr.Create(kname, password, ktype)
 		if err != nil {
 			return err
 		}
@@ -121,8 +125,10 @@ func runCommand() *cobra.Command {
 		Use:   "run <provider>",
 		Short: "respond to chain events",
 		Args:  cobra.ExactArgs(1),
-		RunE:  session.WithSession(session.RequireNode(doProviderRunCommand)),
+		RunE:  session.WithSession(session.RequireNode(session.RequireHost(doProviderRunCommand))),
 	}
+
+	session.AddFlagHost(cmd, cmd.PersistentFlags())
 
 	cmd.Flags().Bool("kube", false, "use kubernetes cluster")
 	cmd.Flags().String("manifest-ns", "lease", "set manifest namespace")
@@ -158,7 +164,7 @@ func doProviderRunCommand(session session.Session, cmd *cobra.Command, args []st
 		if err != nil {
 			return err
 		}
-		cclient, err = kube.NewClient(session.Log().With("cmp", "cluster-client"), ns)
+		cclient, err = kube.NewClient(session.Log().With("cmp", "cluster-client"), session.Host(), ns)
 		if err != nil {
 			return err
 		}

cmd/akash/session/base.go

@@ -4,24 +4,45 @@ import (
 	"os"
 	"path"
 
-	"github.com/ovrclk/akash/cmd/akash/constants"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
 
+const (
+	flagRootDir  = "data"
+	flagNode     = "node"
+	flagNonce    = "nonce"
+	flagKey      = "key"
+	flagKeyType  = "type"
+	flagNoWait   = "no-wait"
+	flagHost     = "host"
+	flagPassword = "password"
+	keyDir       = "keys"
+
+	defaultKeyType  = "ed25519"
+	defaultCodec    = "english"
+	defaultPassword = "0123456789"
+)
+
 func SetupBaseCommand(cmd *cobra.Command) {
 	cmd.PersistentPreRunE = func(cmd *cobra.Command, args []string) error {
-		root, _ := cmd.Flags().GetString(constants.FlagRootDir)
+		root, _ := cmd.Flags().GetString(flagRootDir)
 		return initCommandConfig(root)
 	}
 	cmd.PersistentPostRunE = func(cmd *cobra.Command, args []string) error {
 		return saveCommandConfig()
 	}
-	cmd.PersistentFlags().StringP(constants.FlagRootDir, "d", defaultRootDir(), "data directory")
+	cmd.PersistentFlags().StringP(flagRootDir, "d", defaultRootDir(), "data directory")
 }
 
 func initCommandConfig(root string) error {
 	viper.SetEnvPrefix("AKASH")
+
+	viper.BindEnv(flagNode)
+
+	viper.BindEnv(flagPassword)
+	viper.SetDefault(flagPassword, defaultPassword)
+
 	viper.AutomaticEnv()
 	viper.SetConfigFile(path.Join(root, "akash.toml"))
 

cmd/akash/session/flags.go

@@ -3,37 +3,41 @@ package session
 import (
 	"fmt"
 
-	"github.com/ovrclk/akash/cmd/akash/constants"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
 	"github.com/spf13/viper"
 	"github.com/tendermint/go-crypto/keys"
 )
 
 func AddFlagNode(cmd *cobra.Command, flags *pflag.FlagSet) {
-	flags.StringP(constants.FlagNode, "n", "http://localhost:46657", "node host")
-	viper.BindPFlag(constants.FlagNode, flags.Lookup(constants.FlagNode))
+	flags.StringP(flagNode, "n", "http://localhost:46657", "node host")
+	viper.BindPFlag(flagNode, flags.Lookup(flagNode))
 }
 
 func AddFlagKey(cmd *cobra.Command, flags *pflag.FlagSet) {
-	flags.StringP(constants.FlagKey, "k", "", "key name (required)")
-	cmd.MarkFlagRequired(constants.FlagKey)
+	flags.StringP(flagKey, "k", "", "key name (required)")
+	cmd.MarkFlagRequired(flagKey)
 }
 
 func AddFlagNonce(cmd *cobra.Command, flags *pflag.FlagSet) {
-	flags.Uint64(constants.FlagNonce, 0, "nonce (optional)")
+	flags.Uint64(flagNonce, 0, "nonce (optional)")
 }
 
 func AddFlagKeyType(cmd *cobra.Command, flags *pflag.FlagSet) {
-	flags.StringP(constants.FlagKeyType, "t", constants.KeyType, "Type of key (ed25519|secp256k1|ledger)")
+	flags.StringP(flagKeyType, "t", defaultKeyType, "Type of key (ed25519|secp256k1|ledger)")
 }
 
 func AddFlagWait(cmd *cobra.Command, flags *pflag.FlagSet) {
-	flags.Bool(constants.FlagNoWait, false, "Do not wait for lease creation")
+	flags.Bool(flagNoWait, false, "Do not wait for lease creation")
+}
+
+func AddFlagHost(cmd *cobra.Command, flags *pflag.FlagSet) {
+	flags.String(flagHost, "", "cluster host")
+	viper.BindPFlag(flagHost, flags.Lookup(flagHost))
 }
 
 func parseFlagKeyType(flags *pflag.FlagSet) (keys.CryptoAlgo, error) {
-	ktype, err := flags.GetString(constants.FlagKeyType)
+	ktype, err := flags.GetString(flagKeyType)
 	if err != nil {
 		return "", err
 	}

cmd/akash/session/flags_test.go

@@ -1,12 +1,10 @@
-package session_test
+package session
 
 import (
 	"os"
 	"strconv"
 	"testing"
 
-	"github.com/ovrclk/akash/cmd/akash/constants"
-	"github.com/ovrclk/akash/cmd/akash/session"
 	"github.com/ovrclk/akash/testutil"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
@@ -24,7 +22,7 @@ func TestNode_Env(t *testing.T) {
 
 	os.Setenv("AKASH_NODE", val)
 
-	assertCommand(t, session.AddFlagNode, func(sess session.Session, cmd *cobra.Command, args []string) error {
+	assertCommand(t, AddFlagNode, func(sess Session, cmd *cobra.Command, args []string) error {
 		assert.Equal(t, val, sess.Node())
 		return nil
 	})
@@ -33,62 +31,96 @@ func TestNode_Env(t *testing.T) {
 func TestNode_Flag(t *testing.T) {
 	const val = "foo.bar:123"
 
-	assertCommand(t, session.AddFlagNode, func(sess session.Session, cmd *cobra.Command, args []string) error {
+	assertCommand(t, AddFlagNode, func(sess Session, cmd *cobra.Command, args []string) error {
 		assert.Equal(t, val, sess.Node())
 		return nil
 	}, "-n", val)
 }
 
+func TestHost_Env(t *testing.T) {
+	const val = "bar"
+	defer os.Unsetenv("AKASH_HOST")
+
+	os.Setenv("AKASH_HOST", val)
+
+	assertCommand(t, AddFlagHost, func(sess Session, cmd *cobra.Command, args []string) error {
+		assert.Equal(t, val, sess.Host())
+		return nil
+	})
+}
+
+func TestHost_Flag(t *testing.T) {
+	const val = "foo"
+
+	assertCommand(t, AddFlagHost, func(sess Session, cmd *cobra.Command, args []string) error {
+		assert.Equal(t, val, sess.Host())
+		return nil
+	}, "--host", val)
+}
+
 func TestKey_Flag(t *testing.T) {
 	const val = "foo"
 
-	assertCommand(t, session.AddFlagKey, func(sess session.Session, cmd *cobra.Command, args []string) error {
+	assertCommand(t, AddFlagKey, func(sess Session, cmd *cobra.Command, args []string) error {
 		assert.Equal(t, val, sess.KeyName())
 		return nil
 	}, "-k", val)
 }
+func TestPassword_Env(t *testing.T) {
+	const val = "password"
+	defer os.Unsetenv("AKASH_PASSWORD")
+
+	os.Setenv("AKASH_PASSWORD", val)
+
+	assertCommand(t, AddFlagNode, func(sess Session, cmd *cobra.Command, args []string) error {
+		p, err := sess.Password()
+		assert.NoError(t, err)
+		assert.Equal(t, val, p)
+		return nil
+	})
+}
 
 func TestFlag_Nonce(t *testing.T) {
 	const val uint64 = 10
 	const key = "foo"
 
 	flagfn := func(cmd *cobra.Command, flags *pflag.FlagSet) {
-		session.AddFlagKey(cmd, flags)
-		session.AddFlagNonce(cmd, flags)
-		session.AddFlagNode(cmd, flags)
+		AddFlagKey(cmd, flags)
+		AddFlagNonce(cmd, flags)
+		AddFlagNode(cmd, flags)
 	}
 
-	assertCommand(t, flagfn, func(sess session.Session, cmd *cobra.Command, args []string) error {
+	assertCommand(t, flagfn, func(sess Session, cmd *cobra.Command, args []string) error {
 
 		kmgr, err := sess.KeyManager()
 		require.NoError(t, err)
 
-		_, _, err = kmgr.Create(key, constants.Password, keys.AlgoEd25519)
+		_, _, err = kmgr.Create(key, defaultPassword, keys.AlgoEd25519)
 		require.NoError(t, err)
 
 		nonce, err := sess.Nonce()
 		require.NoError(t, err)
 		require.Equal(t, val, nonce)
 		return nil
-	}, "--"+constants.FlagNonce, strconv.Itoa(int(val)), "-k", key, "-n", "node.address")
+	}, "--"+flagNonce, strconv.Itoa(int(val)), "-k", key, "-n", "node.address")
 }
 
-func assertCommand(t *testing.T, flagfn flagFn, fn session.Runner, args ...string) {
+func assertCommand(t *testing.T, flagfn flagFn, fn Runner, args ...string) {
 	testutil.WithAkashDir(t, func(basedir string) {
 		viper.Reset()
 
 		ran := false
 
 		cmd := &cobra.Command{
 			Use: "test",
-			RunE: session.WithSession(func(sess session.Session, cmd *cobra.Command, args []string) error {
+			RunE: WithSession(func(sess Session, cmd *cobra.Command, args []string) error {
 				ran = true
 				require.Equal(t, basedir, sess.RootDir(), "unexpected home dir")
 				return fn(sess, cmd, args)
 			}),
 		}
 
-		session.SetupBaseCommand(cmd)
+		SetupBaseCommand(cmd)
 
 		if flagfn != nil {
 			flagfn(cmd, cmd.Flags())