Feature/cli cleanup aka confuse rigel

Makefile

@@ -19,15 +19,20 @@ dist:
 benchmark:
 	@go test -bench=. ./modules/...
 
-test: test_unit test_cli test_tutorial
+#test: test_unit test_cli test_tutorial
+test: test_unit test_cli
 
 test_unit:
 	@go test `glide novendor`
 	#go run tests/tendermint/*.go
 
 test_cli: tests/cli/shunit2
 	# sudo apt-get install jq
+	./tests/cli/keys.sh
+	./tests/cli/rpc.sh
+	./tests/cli/init.sh
 	./tests/cli/basictx.sh
+	./tests/cli/roles.sh
 	./tests/cli/counter.sh
 	./tests/cli/restart.sh
 	# @./tests/cli/ibc.sh

app/app.go

@@ -16,6 +16,7 @@ import (
 	"github.com/tendermint/basecoin/modules/coin"
 	"github.com/tendermint/basecoin/modules/fee"
 	"github.com/tendermint/basecoin/modules/nonce"
+	"github.com/tendermint/basecoin/modules/roles"
 	"github.com/tendermint/basecoin/stack"
 	sm "github.com/tendermint/basecoin/state"
 	"github.com/tendermint/basecoin/version"
@@ -56,14 +57,19 @@ func NewBasecoin(handler basecoin.Handler, eyesCli *eyes.Client, logger log.Logg
 // DefaultHandler - placeholder to just handle sendtx
 func DefaultHandler(feeDenom string) basecoin.Handler {
 	// use the default stack
-	h := coin.NewHandler()
-	d := stack.NewDispatcher(stack.WrapHandler(h))
+	c := coin.NewHandler()
+	r := roles.NewHandler()
+	d := stack.NewDispatcher(
+		stack.WrapHandler(c),
+		stack.WrapHandler(r),
+	)
 	return stack.New(
 		base.Logger{},
 		stack.Recovery{},
 		auth.Signatures{},
 		base.Chain{},
 		nonce.ReplayCheck{},
+		roles.NewMiddleware(),
 		fee.NewSimpleFeeMiddleware(coin.Coin{feeDenom, 0}, fee.Bank),
 	).Use(d)
 }
@@ -139,19 +145,22 @@ func (app *Basecoin) CheckTx(txBytes []byte) abci.Result {
 		return errors.Result(err)
 	}
 
-	// TODO: can we abstract this setup and commit logic??
+	// we also need to discard error changes, so we don't increment checktx
+	// sequence on error, but not delivertx
+	cache := app.cacheState.CacheWrap()
 	ctx := stack.NewContext(
 		app.state.GetChainID(),
 		app.height,
 		app.logger.With("call", "checktx"),
 	)
 	// checktx generally shouldn't touch the state, but we don't care
 	// here on the framework level, since the cacheState is thrown away next block
-	res, err := app.handler.CheckTx(ctx, app.cacheState, tx)
+	res, err := app.handler.CheckTx(ctx, cache, tx)
 
 	if err != nil {
 		return errors.Result(err)
 	}
+	cache.CacheSync()
 	return res.ToABCI()
 }
 

app/genesis_test.go

@@ -7,10 +7,12 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"github.com/tendermint/basecoin/modules/coin"
+
 	eyescli "github.com/tendermint/merkleeyes/client"
 	cmn "github.com/tendermint/tmlibs/common"
 	"github.com/tendermint/tmlibs/log"
+
+	"github.com/tendermint/basecoin/modules/coin"
 )
 
 const genesisFilepath = "./testdata/genesis.json"

cmd/basecli/commands/auto.go → client/commands/auto/cmd.go

@@ -1,4 +1,4 @@
-package commands
+package auto
 
 import (
 	"os"

client/commands/common.go

@@ -0,0 +1,141 @@
+/*
+Package commands contains any general setup/helpers valid for all subcommands
+*/
+package commands
+
+import (
+	"encoding/hex"
+	"strings"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+
+	"github.com/tendermint/light-client/certifiers"
+	"github.com/tendermint/light-client/certifiers/client"
+	"github.com/tendermint/light-client/certifiers/files"
+	"github.com/tendermint/tmlibs/cli"
+	cmn "github.com/tendermint/tmlibs/common"
+
+	rpcclient "github.com/tendermint/tendermint/rpc/client"
+
+	"github.com/tendermint/basecoin"
+	"github.com/tendermint/basecoin/modules/auth"
+)
+
+var (
+	trustedProv certifiers.Provider
+	sourceProv  certifiers.Provider
+)
+
+const (
+	ChainFlag = "chain-id"
+	NodeFlag  = "node"
+)
+
+// AddBasicFlags adds --node and --chain-id, which we need for everything
+func AddBasicFlags(cmd *cobra.Command) {
+	cmd.PersistentFlags().String(ChainFlag, "", "Chain ID of tendermint node")
+	cmd.PersistentFlags().String(NodeFlag, "", "<host>:<port> to tendermint rpc interface for this chain")
+}
+
+// GetChainID reads ChainID from the flags
+func GetChainID() string {
+	return viper.GetString(ChainFlag)
+}
+
+// GetNode prepares a simple rpc.Client from the flags
+func GetNode() rpcclient.Client {
+	return rpcclient.NewHTTP(viper.GetString(NodeFlag), "/websocket")
+}
+
+// GetProviders creates a trusted (local) seed provider and a remote
+// provider based on configuration.
+func GetProviders() (trusted certifiers.Provider, source certifiers.Provider) {
+	if trustedProv == nil || sourceProv == nil {
+		// initialize provider with files stored in homedir
+		rootDir := viper.GetString(cli.HomeFlag)
+		trustedProv = certifiers.NewCacheProvider(
+			certifiers.NewMemStoreProvider(),
+			files.NewProvider(rootDir),
+		)
+		node := viper.GetString(NodeFlag)
+		sourceProv = client.NewHTTP(node)
+	}
+	return trustedProv, sourceProv
+}
+
+// GetCertifier constructs a dynamic certifier from the config info
+func GetCertifier() (*certifiers.InquiringCertifier, error) {
+	// load up the latest store....
+	trust, source := GetProviders()
+
+	// this gets the most recent verified seed
+	seed, err := certifiers.LatestSeed(trust)
+	if certifiers.IsSeedNotFoundErr(err) {
+		return nil, errors.New("Please run init first to establish a root of trust")
+	}
+	if err != nil {
+		return nil, err
+	}
+	cert := certifiers.NewInquiring(
+		viper.GetString(ChainFlag), seed.Validators, trust, source)
+	return cert, nil
+}
+
+// ParseActor parses an address of form:
+// [<chain>:][<app>:]<hex address>
+// into a basecoin.Actor.
+// If app is not specified or "", then assume auth.NameSigs
+func ParseActor(input string) (res basecoin.Actor, err error) {
+	chain, app := "", auth.NameSigs
+	input = strings.TrimSpace(input)
+	spl := strings.SplitN(input, ":", 3)
+
+	if len(spl) == 3 {
+		chain = spl[0]
+		spl = spl[1:]
+	}
+	if len(spl) == 2 {
+		if spl[0] != "" {
+			app = spl[0]
+		}
+		spl = spl[1:]
+	}
+
+	addr, err := hex.DecodeString(cmn.StripHex(spl[0]))
+	if err != nil {
+		return res, errors.Errorf("Address is invalid hex: %v\n", err)
+	}
+	res = basecoin.Actor{
+		ChainID: chain,
+		App:     app,
+		Address: addr,
+	}
+	return
+}
+
+// ParseActors takes a comma-separated list of actors and parses them into
+// a slice
+func ParseActors(key string) (signers []basecoin.Actor, err error) {
+	var act basecoin.Actor
+	for _, k := range strings.Split(key, ",") {
+		act, err = ParseActor(k)
+		if err != nil {
+			return
+		}
+		signers = append(signers, act)
+	}
+	return
+}
+
+// GetOneArg makes sure there is exactly one positional argument
+func GetOneArg(args []string, argname string) (string, error) {
+	if len(args) == 0 {
+		return "", errors.Errorf("Missing required argument [%s]", argname)
+	}
+	if len(args) > 1 {
+		return "", errors.Errorf("Only accepts one argument [%s]", argname)
+	}
+	return args[0], nil
+}