certusone
/
tendermint
mirror of https://github.com/certusone/tendermint.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #54 from roylee17/lint 

Lint
This commit is contained in:
Jae Kwon 2017-01-23 20:23:14 -08:00 committed by GitHub
parent 6efadac330 55cb08722d
commit a33b75fe8b
21 changed files with 160 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
client/client.go
View File

@ -5,11 +5,11 @@ import (
"sync" "sync"
"github.com/tendermint/abci/types" "github.com/tendermint/abci/types"
. "github.com/tendermint/go-common" common "github.com/tendermint/go-common"
) )
type Client interface { type Client interface {
Service common.Service
SetResponseCallback(Callback) SetResponseCallback(Callback)
Error() error Error() error

30
client/grpc_client.go
View File

@ -1,6 +1,7 @@
package abcicli package abcicli
import ( import (
"fmt"
"net" "net"
"sync" "sync"
"time" "time"
@ -9,13 +10,13 @@ import (
grpc "google.golang.org/grpc" grpc "google.golang.org/grpc"
"github.com/tendermint/abci/types" "github.com/tendermint/abci/types"
. "github.com/tendermint/go-common" common "github.com/tendermint/go-common"
) )
// A stripped copy of the remoteClient that makes // A stripped copy of the remoteClient that makes
// synchronous calls using grpc // synchronous calls using grpc
type grpcClient struct { type grpcClient struct {
BaseService common.BaseService
mustConnect bool mustConnect bool
client types.ABCIApplicationClient client types.ABCIApplicationClient
@ -31,13 +32,13 @@ func NewGRPCClient(addr string, mustConnect bool) (*grpcClient, error) {
addr: addr, addr: addr,
mustConnect: mustConnect, mustConnect: mustConnect,
} }
cli.BaseService = *NewBaseService(nil, "grpcClient", cli) cli.BaseService = *common.NewBaseService(nil, "grpcClient", cli)
_, err := cli.Start() // Just start it, it's confusing for callers to remember to start. _, err := cli.Start() // Just start it, it's confusing for callers to remember to start.
return cli, err return cli, err
} }
func dialerFunc(addr string, timeout time.Duration) (net.Conn, error) { func dialerFunc(addr string, timeout time.Duration) (net.Conn, error) {
return Connect(addr) return common.Connect(addr)
} }
func (cli *grpcClient) OnStart() error { func (cli *grpcClient) OnStart() error {
@ -49,12 +50,11 @@ RETRY_LOOP:
if err != nil { if err != nil {
if cli.mustConnect { if cli.mustConnect {
return err return err
} else { }
log.Warn(Fmt("abci.grpcClient failed to connect to %v. Retrying...\n", cli.addr)) log.Warn(fmt.Sprintf("abci.grpcClient failed to connect to %v. Retrying...\n", cli.addr))
time.Sleep(time.Second * 3) time.Sleep(time.Second * 3)
continue RETRY_LOOP continue RETRY_LOOP
} }
}
client := types.NewABCIApplicationClient(conn) client := types.NewABCIApplicationClient(conn)
@ -93,7 +93,7 @@ func (cli *grpcClient) StopForError(err error) {
} }
cli.mtx.Unlock() cli.mtx.Unlock()
log.Warn(Fmt("Stopping abci.grpcClient for error: %v", err.Error())) log.Warn(fmt.Sprintf("Stopping abci.grpcClient for error: %v", err.Error()))
cli.Stop() cli.Stop()
} }
@ -267,11 +267,10 @@ func (cli *grpcClient) InfoSync() (resInfo types.ResponseInfo, err error) {
if err = cli.Error(); err != nil { if err = cli.Error(); err != nil {
return resInfo, err return resInfo, err
} }
if resInfo_ := reqres.Response.GetInfo(); resInfo_ != nil { if info := reqres.Response.GetInfo(); info != nil {
return *resInfo_, nil return *info, nil
} else {
return resInfo, nil
} }
return resInfo, nil
} }
func (cli *grpcClient) SetOptionSync(key string, value string) (res types.Result) { func (cli *grpcClient) SetOptionSync(key string, value string) (res types.Result) {
@ -334,9 +333,8 @@ func (cli *grpcClient) EndBlockSync(height uint64) (resEndBlock types.ResponseEn
if err := cli.Error(); err != nil { if err := cli.Error(); err != nil {
return resEndBlock, err return resEndBlock, err
} }
if resEndBlock_ := reqres.Response.GetEndBlock(); resEndBlock_ != nil { if blk := reqres.Response.GetEndBlock(); blk != nil {
return *resEndBlock_, nil return *blk, nil
} else {
return resEndBlock, nil
} }
return resEndBlock, nil
} }

6
client/local_client.go
View File

@ -4,11 +4,11 @@ import (
"sync" "sync"
types "github.com/tendermint/abci/types" types "github.com/tendermint/abci/types"
. "github.com/tendermint/go-common" common "github.com/tendermint/go-common"
) )
type localClient struct { type localClient struct {
BaseService common.BaseService
mtx *sync.Mutex mtx *sync.Mutex
types.Application types.Application
Callback Callback
@ -22,7 +22,7 @@ func NewLocalClient(mtx *sync.Mutex, app types.Application) *localClient {
mtx: mtx, mtx: mtx,
Application: app, Application: app,
} }
cli.BaseService = *NewBaseService(log, "localClient", cli) cli.BaseService = *common.NewBaseService(log, "localClient", cli)
return cli return cli
} }

34
client/socket_client.go
View File

@ -11,7 +11,7 @@ import (
"time" "time"
"github.com/tendermint/abci/types" "github.com/tendermint/abci/types"
. "github.com/tendermint/go-common" common "github.com/tendermint/go-common"
) )
const ( const (
@ -27,10 +27,10 @@ const flushThrottleMS = 20 // Don't wait longer than...
// the application in general is not meant to be interfaced // the application in general is not meant to be interfaced
// with concurrent callers. // with concurrent callers.
type socketClient struct { type socketClient struct {
BaseService common.BaseService
reqQueue chan *ReqRes reqQueue chan *ReqRes
flushTimer *ThrottleTimer flushTimer *common.ThrottleTimer
mustConnect bool mustConnect bool
mtx sync.Mutex mtx sync.Mutex
@ -45,14 +45,14 @@ type socketClient struct {
func NewSocketClient(addr string, mustConnect bool) (*socketClient, error) { func NewSocketClient(addr string, mustConnect bool) (*socketClient, error) {
cli := &socketClient{ cli := &socketClient{
reqQueue: make(chan *ReqRes, reqQueueSize), reqQueue: make(chan *ReqRes, reqQueueSize),
flushTimer: NewThrottleTimer("socketClient", flushThrottleMS), flushTimer: common.NewThrottleTimer("socketClient", flushThrottleMS),
mustConnect: mustConnect, mustConnect: mustConnect,
addr: addr, addr: addr,
reqSent: list.New(), reqSent: list.New(),
resCb: nil, resCb: nil,
} }
cli.BaseService = *NewBaseService(nil, "socketClient", cli) cli.BaseService = *common.NewBaseService(nil, "socketClient", cli)
_, err := cli.Start() // Just start it, it's confusing for callers to remember to start. _, err := cli.Start() // Just start it, it's confusing for callers to remember to start.
return cli, err return cli, err
@ -65,16 +65,15 @@ func (cli *socketClient) OnStart() error {
var conn net.Conn var conn net.Conn
RETRY_LOOP: RETRY_LOOP:
for { for {
conn, err = Connect(cli.addr) conn, err = common.Connect(cli.addr)
if err != nil { if err != nil {
if cli.mustConnect { if cli.mustConnect {
return err return err
} else { }
log.Warn(Fmt("abci.socketClient failed to connect to %v. Retrying...", cli.addr)) log.Warn(fmt.Sprintf("abci.socketClient failed to connect to %v. Retrying...", cli.addr))
time.Sleep(time.Second * 3) time.Sleep(time.Second * 3)
continue RETRY_LOOP continue RETRY_LOOP
} }
}
cli.conn = conn cli.conn = conn
go cli.sendRequestsRoutine(conn) go cli.sendRequestsRoutine(conn)
@ -82,7 +81,6 @@ RETRY_LOOP:
return nil return nil
} }
return nil // never happens
} }
func (cli *socketClient) OnStop() { func (cli *socketClient) OnStop() {
@ -109,7 +107,7 @@ func (cli *socketClient) StopForError(err error) {
} }
cli.mtx.Unlock() cli.mtx.Unlock()
log.Warn(Fmt("Stopping abci.socketClient for error: %v", err.Error())) log.Warn(fmt.Sprintf("Stopping abci.socketClient for error: %v", err.Error()))
cli.Stop() cli.Stop()
} }
@ -298,11 +296,10 @@ func (cli *socketClient) InfoSync() (resInfo types.ResponseInfo, err error) {
if err := cli.Error(); err != nil { if err := cli.Error(); err != nil {
return resInfo, err return resInfo, err
} }
if resInfo_ := reqres.Response.GetInfo(); resInfo_ != nil { if info := reqres.Response.GetInfo(); info != nil {
return *resInfo_, nil return *info, nil
} else {
return resInfo, nil
} }
return resInfo, nil
} }
func (cli *socketClient) SetOptionSync(key string, value string) (res types.Result) { func (cli *socketClient) SetOptionSync(key string, value string) (res types.Result) {
@ -379,11 +376,10 @@ func (cli *socketClient) EndBlockSync(height uint64) (resEndBlock types.Response
if err := cli.Error(); err != nil { if err := cli.Error(); err != nil {
return resEndBlock, err return resEndBlock, err
} }
if resEndBlock_ := reqres.Response.GetEndBlock(); resEndBlock_ != nil { if blk := reqres.Response.GetEndBlock(); blk != nil {
return *resEndBlock_, nil return *blk, nil
} else {
return resEndBlock, nil
} }
return resEndBlock, nil
} }
//---------------------------------------- //----------------------------------------

10
cmd/abci-cli/tmsp-cli.go
View File

@ -6,12 +6,12 @@ import (
"errors" "errors"
"fmt" "fmt"
"io" "io"
"log"
"os" "os"
"strings" "strings"
"github.com/tendermint/abci/client" "github.com/tendermint/abci/client"
"github.com/tendermint/abci/types" "github.com/tendermint/abci/types"
. "github.com/tendermint/go-common"
"github.com/urfave/cli" "github.com/urfave/cli"
) )
@ -135,7 +135,7 @@ func main() {
app.Before = before app.Before = before
err := app.Run(os.Args) err := app.Run(os.Args)
if err != nil { if err != nil {
Exit(err.Error()) log.Fatal(err.Error())
} }
} }
@ -145,7 +145,7 @@ func before(c *cli.Context) error {
var err error var err error
client, err = abcicli.NewClient(c.GlobalString("address"), c.GlobalString("abci"), false) client, err = abcicli.NewClient(c.GlobalString("address"), c.GlobalString("abci"), false)
if err != nil { if err != nil {
Exit(err.Error()) log.Fatal(err.Error())
} }
} }
return nil return nil
@ -244,7 +244,7 @@ func cmdSetOption(c *cli.Context) error {
return errors.New("Command set_option takes 2 arguments (key, value)") return errors.New("Command set_option takes 2 arguments (key, value)")
} }
res := client.SetOptionSync(args[0], args[1]) res := client.SetOptionSync(args[0], args[1])
rsp := newResponse(res, Fmt("%s=%s", args[0], args[1]), false) rsp := newResponse(res, fmt.Sprintf("%s=%s", args[0], args[1]), false)
printResponse(c, rsp) printResponse(c, rsp)
return nil return nil
} }
@ -284,7 +284,7 @@ func cmdCheckTx(c *cli.Context) error {
// Get application Merkle root hash // Get application Merkle root hash
func cmdCommit(c *cli.Context) error { func cmdCommit(c *cli.Context) error {
res := client.CommitSync() res := client.CommitSync()
rsp := newResponse(res, Fmt("0x%X", res.Data), false) rsp := newResponse(res, fmt.Sprintf("0x%X", res.Data), false)
printResponse(c, rsp) printResponse(c, rsp)
return nil return nil
} }

7
cmd/counter/main.go
View File

@ -2,10 +2,11 @@ package main
import ( import (
"flag" "flag"
"log"
"github.com/tendermint/abci/example/counter" "github.com/tendermint/abci/example/counter"
"github.com/tendermint/abci/server" "github.com/tendermint/abci/server"
. "github.com/tendermint/go-common" common "github.com/tendermint/go-common"
) )
func main() { func main() {
@ -19,11 +20,11 @@ func main() {
// Start the listener // Start the listener
srv, err := server.NewServer(*addrPtr, *abciPtr, app) srv, err := server.NewServer(*addrPtr, *abciPtr, app)
if err != nil { if err != nil {
Exit(err.Error()) log.Fatal(err.Error())
} }
// Wait forever // Wait forever
TrapSignal(func() { common.TrapSignal(func() {
// Cleanup // Cleanup
srv.Stop() srv.Stop()
}) })

7
cmd/dummy/main.go
View File

@ -2,11 +2,12 @@ package main
import ( import (
"flag" "flag"
"log"
"github.com/tendermint/abci/example/dummy" "github.com/tendermint/abci/example/dummy"
"github.com/tendermint/abci/server" "github.com/tendermint/abci/server"
"github.com/tendermint/abci/types" "github.com/tendermint/abci/types"
. "github.com/tendermint/go-common" common "github.com/tendermint/go-common"
) )
func main() { func main() {
@ -27,11 +28,11 @@ func main() {
// Start the listener // Start the listener
srv, err := server.NewServer(*addrPtr, *abciPtr, app) srv, err := server.NewServer(*addrPtr, *abciPtr, app)
if err != nil { if err != nil {
Exit(err.Error()) log.Fatal(err.Error())
} }
// Wait forever // Wait forever
TrapSignal(func() { common.TrapSignal(func() {
// Cleanup // Cleanup
srv.Stop() srv.Stop()
}) })

14
example/chain_aware/chain_aware_app.go
View File

@ -2,10 +2,12 @@ package main
import ( import (
"flag" "flag"
"fmt"
"log"
"github.com/tendermint/abci/server" "github.com/tendermint/abci/server"
"github.com/tendermint/abci/types" "github.com/tendermint/abci/types"
. "github.com/tendermint/go-common" common "github.com/tendermint/go-common"
) )
func main() { func main() {
@ -17,11 +19,11 @@ func main() {
// Start the listener // Start the listener
srv, err := server.NewServer(*addrPtr, *abciPtr, NewChainAwareApplication()) srv, err := server.NewServer(*addrPtr, *abciPtr, NewChainAwareApplication())
if err != nil { if err != nil {
Exit(err.Error()) log.Fatal(err.Error())
} }
// Wait forever // Wait forever
TrapSignal(func() { common.TrapSignal(func() {
// Cleanup // Cleanup
srv.Stop() srv.Stop()
}) })
@ -58,16 +60,16 @@ func (app *ChainAwareApplication) Commit() types.Result {
} }
func (app *ChainAwareApplication) Query(query []byte) types.Result { func (app *ChainAwareApplication) Query(query []byte) types.Result {
return types.NewResultOK([]byte(Fmt("%d,%d", app.beginCount, app.endCount)), "") return types.NewResultOK([]byte(fmt.Sprintf("%d,%d", app.beginCount, app.endCount)), "")
} }
func (app *ChainAwareApplication) BeginBlock(hash []byte, header *types.Header) { func (app *ChainAwareApplication) BeginBlock(hash []byte, header *types.Header) {
app.beginCount += 1 app.beginCount++
return return
} }
func (app *ChainAwareApplication) EndBlock(height uint64) (resEndBlock types.ResponseEndBlock) { func (app *ChainAwareApplication) EndBlock(height uint64) (resEndBlock types.ResponseEndBlock) {
app.endCount += 1 app.endCount++
return return
} }

5
example/chain_aware/chain_aware_test.go
View File

@ -1,6 +1,8 @@
package main package main
import ( import (
"fmt"
"log"
"strconv" "strconv"
"strings" "strings"
"testing" "testing"
@ -8,7 +10,6 @@ import (
"github.com/tendermint/abci/client" "github.com/tendermint/abci/client"
"github.com/tendermint/abci/server" "github.com/tendermint/abci/server"
"github.com/tendermint/abci/types" "github.com/tendermint/abci/types"
. "github.com/tendermint/go-common"
) )
func TestChainAware(t *testing.T) { func TestChainAware(t *testing.T) {
@ -25,7 +26,7 @@ func TestChainAware(t *testing.T) {
// Connect to the socket // Connect to the socket
client, err := abcicli.NewSocketClient("unix://test.sock", false) client, err := abcicli.NewSocketClient("unix://test.sock", false)
if err != nil { if err != nil {
Exit(Fmt("Error starting socket client: %v", err.Error())) log.Fatal(fmt.Sprintf("Error starting socket client: %v", err.Error()))
} }
client.Start() client.Start()
defer client.Stop() defer client.Stop()

26
example/counter/counter.go
View File

@ -2,9 +2,9 @@ package counter
import ( import (
"encoding/binary" "encoding/binary"
"fmt"
"github.com/tendermint/abci/types" "github.com/tendermint/abci/types"
. "github.com/tendermint/go-common"
) )
type CounterApplication struct { type CounterApplication struct {
@ -18,7 +18,7 @@ func NewCounterApplication(serial bool) *CounterApplication {
} }
func (app *CounterApplication) Info() types.ResponseInfo { func (app *CounterApplication) Info() types.ResponseInfo {
return types.ResponseInfo{Data: Fmt("{\"hashes\":%v,\"txs\":%v}", app.hashCount, app.txCount)} return types.ResponseInfo{Data: fmt.Sprintf("{\"hashes\":%v,\"txs\":%v}", app.hashCount, app.txCount)}
} }
func (app *CounterApplication) SetOption(key string, value string) (log string) { func (app *CounterApplication) SetOption(key string, value string) (log string) {
@ -31,44 +31,42 @@ func (app *CounterApplication) SetOption(key string, value string) (log string)
func (app *CounterApplication) DeliverTx(tx []byte) types.Result { func (app *CounterApplication) DeliverTx(tx []byte) types.Result {
if app.serial { if app.serial {
if len(tx) > 8 { if len(tx) > 8 {
return types.ErrEncodingError.SetLog(Fmt("Max tx size is 8 bytes, got %d", len(tx))) return types.ErrEncodingError.SetLog(fmt.Sprintf("Max tx size is 8 bytes, got %d", len(tx)))
} }
tx8 := make([]byte, 8) tx8 := make([]byte, 8)
copy(tx8[len(tx8)-len(tx):], tx) copy(tx8[len(tx8)-len(tx):], tx)
txValue := binary.BigEndian.Uint64(tx8) txValue := binary.BigEndian.Uint64(tx8)
if txValue != uint64(app.txCount) { if txValue != uint64(app.txCount) {
return types.ErrBadNonce.SetLog(Fmt("Invalid nonce. Expected %v, got %v", app.txCount, txValue)) return types.ErrBadNonce.SetLog(fmt.Sprintf("Invalid nonce. Expected %v, got %v", app.txCount, txValue))
} }
} }
app.txCount += 1 app.txCount++
return types.OK return types.OK
} }
func (app *CounterApplication) CheckTx(tx []byte) types.Result { func (app *CounterApplication) CheckTx(tx []byte) types.Result {
if app.serial { if app.serial {
if len(tx) > 8 { if len(tx) > 8 {
return types.ErrEncodingError.SetLog(Fmt("Max tx size is 8 bytes, got %d", len(tx))) return types.ErrEncodingError.SetLog(fmt.Sprintf("Max tx size is 8 bytes, got %d", len(tx)))
} }
tx8 := make([]byte, 8) tx8 := make([]byte, 8)
copy(tx8[len(tx8)-len(tx):], tx) copy(tx8[len(tx8)-len(tx):], tx)
txValue := binary.BigEndian.Uint64(tx8) txValue := binary.BigEndian.Uint64(tx8)
if txValue < uint64(app.txCount) { if txValue < uint64(app.txCount) {
return types.ErrBadNonce.SetLog(Fmt("Invalid nonce. Expected >= %v, got %v", app.txCount, txValue)) return types.ErrBadNonce.SetLog(fmt.Sprintf("Invalid nonce. Expected >= %v, got %v", app.txCount, txValue))
} }
} }
return types.OK return types.OK
} }
func (app *CounterApplication) Commit() types.Result { func (app *CounterApplication) Commit() types.Result {
app.hashCount += 1 app.hashCount++
if app.txCount == 0 { if app.txCount == 0 {
return types.OK return types.OK
} else { }
hash := make([]byte, 8) hash := make([]byte, 8)
binary.BigEndian.PutUint64(hash, uint64(app.txCount)) binary.BigEndian.PutUint64(hash, uint64(app.txCount))
return types.NewResultOK(hash, "") return types.NewResultOK(hash, "")
}
} }
func (app *CounterApplication) Query(query []byte) types.Result { func (app *CounterApplication) Query(query []byte) types.Result {
@ -76,10 +74,10 @@ func (app *CounterApplication) Query(query []byte) types.Result {
switch queryStr { switch queryStr {
case "hash": case "hash":
return types.NewResultOK(nil, Fmt("%v", app.hashCount)) return types.NewResultOK(nil, fmt.Sprintf("%v", app.hashCount))
case "tx": case "tx":
return types.NewResultOK(nil, Fmt("%v", app.txCount)) return types.NewResultOK(nil, fmt.Sprintf("%v", app.txCount))
} }
return types.ErrUnknownRequest.SetLog(Fmt("Invalid nonce. Expected hash or tx, got %v", queryStr)) return types.ErrUnknownRequest.SetLog(fmt.Sprintf("Invalid nonce. Expected hash or tx, got %v", queryStr))
} }

4
example/dummy/dummy.go
View File

@ -2,10 +2,10 @@ package dummy
import ( import (
"encoding/hex" "encoding/hex"
"fmt"
"strings" "strings"
"github.com/tendermint/abci/types" "github.com/tendermint/abci/types"
. "github.com/tendermint/go-common"
"github.com/tendermint/go-merkle" "github.com/tendermint/go-merkle"
"github.com/tendermint/go-wire" "github.com/tendermint/go-wire"
) )
@ -20,7 +20,7 @@ func NewDummyApplication() *DummyApplication {
} }
func (app *DummyApplication) Info() (resInfo types.ResponseInfo) { func (app *DummyApplication) Info() (resInfo types.ResponseInfo) {
return types.ResponseInfo{Data: Fmt("{\"size\":%v}", app.state.Size())} return types.ResponseInfo{Data: fmt.Sprintf("{\"size\":%v}", app.state.Size())}
} }
func (app *DummyApplication) SetOption(key string, value string) (log string) { func (app *DummyApplication) SetOption(key string, value string) (log string) {

7
example/dummy/dummy_test.go
View File

@ -2,12 +2,13 @@ package dummy
import ( import (
"bytes" "bytes"
"fmt"
"io/ioutil" "io/ioutil"
"sort" "sort"
"testing" "testing"
"github.com/tendermint/abci/types" "github.com/tendermint/abci/types"
. "github.com/tendermint/go-common" common "github.com/tendermint/go-common"
"github.com/tendermint/go-crypto" "github.com/tendermint/go-crypto"
"github.com/tendermint/go-wire" "github.com/tendermint/go-wire"
) )
@ -107,8 +108,8 @@ func TestValSetChanges(t *testing.T) {
nInit := 5 nInit := 5
vals := make([]*types.Validator, total) vals := make([]*types.Validator, total)
for i := 0; i < total; i++ { for i := 0; i < total; i++ {
pubkey := crypto.GenPrivKeyEd25519FromSecret([]byte(Fmt("test%d", i))).PubKey().Bytes() pubkey := crypto.GenPrivKeyEd25519FromSecret([]byte(fmt.Sprintf("test%d", i))).PubKey().Bytes()
power := RandInt() power := common.RandInt()
vals[i] = &types.Validator{pubkey, uint64(power)} vals[i] = &types.Validator{pubkey, uint64(power)}
} }
// iniitalize with the first nInit // iniitalize with the first nInit

19
example/dummy/persistent_dummy.go
View File

@ -3,11 +3,12 @@ package dummy
import ( import (
"bytes" "bytes"
"encoding/hex" "encoding/hex"
"fmt"
"strconv" "strconv"
"strings" "strings"
"github.com/tendermint/abci/types" "github.com/tendermint/abci/types"
. "github.com/tendermint/go-common" common "github.com/tendermint/go-common"
dbm "github.com/tendermint/go-db" dbm "github.com/tendermint/go-db"
"github.com/tendermint/go-merkle" "github.com/tendermint/go-merkle"
"github.com/tendermint/go-wire" "github.com/tendermint/go-wire"
@ -135,7 +136,7 @@ func LoadLastBlock(db dbm.DB) (lastBlock LastBlockInfo) {
wire.ReadBinaryPtr(&lastBlock, r, 0, n, err) wire.ReadBinaryPtr(&lastBlock, r, 0, n, err)
if *err != nil { if *err != nil {
// DATA HAS BEEN CORRUPTED OR THE SPEC HAS CHANGED // DATA HAS BEEN CORRUPTED OR THE SPEC HAS CHANGED
Exit(Fmt("Data has been corrupted or its spec has changed: %v\n", *err)) log.Crit(fmt.Sprintf("Data has been corrupted or its spec has changed: %v\n", *err))
} }
// TODO: ensure that buf is completely read. // TODO: ensure that buf is completely read.
} }
@ -149,7 +150,7 @@ func SaveLastBlock(db dbm.DB, lastBlock LastBlockInfo) {
wire.WriteBinary(lastBlock, buf, n, err) wire.WriteBinary(lastBlock, buf, n, err)
if *err != nil { if *err != nil {
// TODO // TODO
PanicCrisis(*err) common.PanicCrisis(*err)
} }
db.Set(lastBlockKey, buf.Bytes()) db.Set(lastBlockKey, buf.Bytes())
} }
@ -173,7 +174,7 @@ func (app *PersistentDummyApplication) Validators() (validators []*types.Validat
} }
func MakeValSetChangeTx(pubkey []byte, power uint64) []byte { func MakeValSetChangeTx(pubkey []byte, power uint64) []byte {
return []byte(Fmt("val:%X/%d", pubkey, power)) return []byte(fmt.Sprintf("val:%X/%d", pubkey, power))
} }
func isValidatorTx(tx []byte) bool { func isValidatorTx(tx []byte) bool {
@ -188,16 +189,16 @@ func (app *PersistentDummyApplication) execValidatorTx(tx []byte) types.Result {
tx = tx[len(ValidatorSetChangePrefix):] tx = tx[len(ValidatorSetChangePrefix):]
pubKeyAndPower := strings.Split(string(tx), "/") pubKeyAndPower := strings.Split(string(tx), "/")
if len(pubKeyAndPower) != 2 { if len(pubKeyAndPower) != 2 {
return types.ErrEncodingError.SetLog(Fmt("Expected 'pubkey/power'. Got %v", pubKeyAndPower)) return types.ErrEncodingError.SetLog(fmt.Sprintf("Expected 'pubkey/power'. Got %v", pubKeyAndPower))
} }
pubkeyS, powerS := pubKeyAndPower[0], pubKeyAndPower[1] pubkeyS, powerS := pubKeyAndPower[0], pubKeyAndPower[1]
pubkey, err := hex.DecodeString(pubkeyS) pubkey, err := hex.DecodeString(pubkeyS)
if err != nil { if err != nil {
return types.ErrEncodingError.SetLog(Fmt("Pubkey (%s) is invalid hex", pubkeyS)) return types.ErrEncodingError.SetLog(fmt.Sprintf("Pubkey (%s) is invalid hex", pubkeyS))
} }
power, err := strconv.Atoi(powerS) power, err := strconv.Atoi(powerS)
if err != nil { if err != nil {
return types.ErrEncodingError.SetLog(Fmt("Power (%s) is not an int", powerS)) return types.ErrEncodingError.SetLog(fmt.Sprintf("Power (%s) is not an int", powerS))
} }
// update // update
@ -210,14 +211,14 @@ func (app *PersistentDummyApplication) updateValidator(v *types.Validator) types
if v.Power == 0 { if v.Power == 0 {
// remove validator // remove validator
if !app.app.state.Has(key) { if !app.app.state.Has(key) {
return types.ErrUnauthorized.SetLog(Fmt("Cannot remove non-existent validator %X", key)) return types.ErrUnauthorized.SetLog(fmt.Sprintf("Cannot remove non-existent validator %X", key))
} }
app.app.state.Remove(key) app.app.state.Remove(key)
} else { } else {
// add or update validator // add or update validator
value := bytes.NewBuffer(make([]byte, 0)) value := bytes.NewBuffer(make([]byte, 0))
if err := types.WriteMessage(v, value); err != nil { if err := types.WriteMessage(v, value); err != nil {
return types.ErrInternalError.SetLog(Fmt("Error encoding validator: %v", err)) return types.ErrInternalError.SetLog(fmt.Sprintf("Error encoding validator: %v", err))
} }
app.app.state.Set(key, value.Bytes()) app.app.state.Set(key, value.Bytes())
} }

20
example/example_test.go
View File

@ -2,20 +2,22 @@ package example
import ( import (
"fmt" "fmt"
"log"
"net" "net"
"reflect" "reflect"
"testing" "testing"
"time" "time"
"golang.org/x/net/context"
"google.golang.org/grpc" "google.golang.org/grpc"
"golang.org/x/net/context"
"github.com/tendermint/abci/client" "github.com/tendermint/abci/client"
"github.com/tendermint/abci/example/dummy" "github.com/tendermint/abci/example/dummy"
nilapp "github.com/tendermint/abci/example/nil" nilapp "github.com/tendermint/abci/example/nil"
"github.com/tendermint/abci/server" "github.com/tendermint/abci/server"
"github.com/tendermint/abci/types" "github.com/tendermint/abci/types"
. "github.com/tendermint/go-common" common "github.com/tendermint/go-common"
) )
func TestDummy(t *testing.T) { func TestDummy(t *testing.T) {
@ -40,14 +42,14 @@ func testStream(t *testing.T, app types.Application) {
// Start the listener // Start the listener
server, err := server.NewSocketServer("unix://test.sock", app) server, err := server.NewSocketServer("unix://test.sock", app)
if err != nil { if err != nil {
Exit(Fmt("Error starting socket server: %v", err.Error())) log.Fatal(fmt.Sprintf("Error starting socket server: %v", err.Error()))
} }
defer server.Stop() defer server.Stop()
// Connect to the socket // Connect to the socket
client, err := abcicli.NewSocketClient("unix://test.sock", false) client, err := abcicli.NewSocketClient("unix://test.sock", false)
if err != nil { if err != nil {
Exit(Fmt("Error starting socket client: %v", err.Error())) log.Fatal(fmt.Sprintf("Error starting socket client: %v", err.Error()))
} }
client.Start() client.Start()
defer client.Stop() defer client.Stop()
@ -58,7 +60,7 @@ func testStream(t *testing.T, app types.Application) {
// Process response // Process response
switch r := res.Value.(type) { switch r := res.Value.(type) {
case *types.Response_DeliverTx: case *types.Response_DeliverTx:
counter += 1 counter++
if r.DeliverTx.Code != types.CodeType_OK { if r.DeliverTx.Code != types.CodeType_OK {
t.Error("DeliverTx failed with ret_code", r.DeliverTx.Code) t.Error("DeliverTx failed with ret_code", r.DeliverTx.Code)
} }
@ -103,7 +105,7 @@ func testStream(t *testing.T, app types.Application) {
// test grpc // test grpc
func dialerFunc(addr string, timeout time.Duration) (net.Conn, error) { func dialerFunc(addr string, timeout time.Duration) (net.Conn, error) {
return Connect(addr) return common.Connect(addr)
} }
func testGRPCSync(t *testing.T, app *types.GRPCApplication) { func testGRPCSync(t *testing.T, app *types.GRPCApplication) {
@ -113,14 +115,14 @@ func testGRPCSync(t *testing.T, app *types.GRPCApplication) {
// Start the listener // Start the listener
server, err := server.NewGRPCServer("unix://test.sock", app) server, err := server.NewGRPCServer("unix://test.sock", app)
if err != nil { if err != nil {
Exit(Fmt("Error starting GRPC server: %v", err.Error())) log.Fatal(fmt.Sprintf("Error starting GRPC server: %v", err.Error()))
} }
defer server.Stop() defer server.Stop()
// Connect to the socket // Connect to the socket
conn, err := grpc.Dial("unix://test.sock", grpc.WithInsecure(), grpc.WithDialer(dialerFunc)) conn, err := grpc.Dial("unix://test.sock", grpc.WithInsecure(), grpc.WithDialer(dialerFunc))
if err != nil { if err != nil {
Exit(Fmt("Error dialing GRPC server: %v", err.Error())) log.Fatal(fmt.Sprintf("Error dialing GRPC server: %v", err.Error()))
} }
defer conn.Close() defer conn.Close()
@ -133,7 +135,7 @@ func testGRPCSync(t *testing.T, app *types.GRPCApplication) {
if err != nil { if err != nil {
t.Fatalf("Error in GRPC DeliverTx: %v", err.Error()) t.Fatalf("Error in GRPC DeliverTx: %v", err.Error())
} }
counter += 1 counter++
if response.Code != types.CodeType_OK { if response.Code != types.CodeType_OK {
t.Error("DeliverTx failed with ret_code", response.Code) t.Error("DeliverTx failed with ret_code", response.Code)
} }

8
server/grpc_server.go
View File

@ -7,13 +7,13 @@ import (
"google.golang.org/grpc" "google.golang.org/grpc"
"github.com/tendermint/abci/types" "github.com/tendermint/abci/types"
. "github.com/tendermint/go-common" common "github.com/tendermint/go-common"
) )
// var maxNumberConnections = 2 // var maxNumberConnections = 2
type GRPCServer struct { type GRPCServer struct {
BaseService common.BaseService
proto string proto string
addr string addr string
@ -23,7 +23,7 @@ type GRPCServer struct {
app types.ABCIApplicationServer app types.ABCIApplicationServer
} }
func NewGRPCServer(protoAddr string, app types.ABCIApplicationServer) (Service, error) { func NewGRPCServer(protoAddr string, app types.ABCIApplicationServer) (common.Service, error) {
parts := strings.SplitN(protoAddr, "://", 2) parts := strings.SplitN(protoAddr, "://", 2)
proto, addr := parts[0], parts[1] proto, addr := parts[0], parts[1]
s := &GRPCServer{ s := &GRPCServer{
@ -32,7 +32,7 @@ func NewGRPCServer(protoAddr string, app types.ABCIApplicationServer) (Service,
listener: nil, listener: nil,
app: app, app: app,
} }
s.BaseService = *NewBaseService(nil, "ABCIServer", s) s.BaseService = *common.NewBaseService(nil, "ABCIServer", s)
_, err := s.Start() // Just start it _, err := s.Start() // Just start it
return s, err return s, err
} }

6
server/server.go
View File

@ -4,11 +4,11 @@ import (
"fmt" "fmt"
"github.com/tendermint/abci/types" "github.com/tendermint/abci/types"
. "github.com/tendermint/go-common" common "github.com/tendermint/go-common"
) )
func NewServer(protoAddr, transport string, app types.Application) (Service, error) { func NewServer(protoAddr, transport string, app types.Application) (common.Service, error) {
var s Service var s common.Service
var err error var err error
switch transport { switch transport {
case "socket": case "socket":

12
server/socket_server.go
View File

@ -9,13 +9,13 @@ import (
"sync" "sync"
"github.com/tendermint/abci/types" "github.com/tendermint/abci/types"
. "github.com/tendermint/go-common" common "github.com/tendermint/go-common"
) )
// var maxNumberConnections = 2 // var maxNumberConnections = 2
type SocketServer struct { type SocketServer struct {
BaseService common.BaseService
proto string proto string
addr string addr string
@ -29,7 +29,7 @@ type SocketServer struct {
app types.Application app types.Application
} }
func NewSocketServer(protoAddr string, app types.Application) (Service, error) { func NewSocketServer(protoAddr string, app types.Application) (common.Service, error) {
parts := strings.SplitN(protoAddr, "://", 2) parts := strings.SplitN(protoAddr, "://", 2)
proto, addr := parts[0], parts[1] proto, addr := parts[0], parts[1]
s := &SocketServer{ s := &SocketServer{
@ -39,7 +39,7 @@ func NewSocketServer(protoAddr string, app types.Application) (Service, error) {
app: app, app: app,
conns: make(map[int]net.Conn), conns: make(map[int]net.Conn),
} }
s.BaseService = *NewBaseService(nil, "ABCIServer", s) s.BaseService = *common.NewBaseService(nil, "ABCIServer", s)
_, err := s.Start() // Just start it _, err := s.Start() // Just start it
return s, err return s, err
} }
@ -72,7 +72,7 @@ func (s *SocketServer) addConn(conn net.Conn) int {
defer s.connsMtx.Unlock() defer s.connsMtx.Unlock()
connID := s.nextConnID connID := s.nextConnID
s.nextConnID += 1 s.nextConnID++
s.conns[connID] = conn s.conns[connID] = conn
return connID return connID
@ -100,7 +100,7 @@ func (s *SocketServer) acceptConnectionsRoutine() {
if !s.IsRunning() { if !s.IsRunning() {
return // Ignore error from listener closing. return // Ignore error from listener closing.
} }
Exit("Failed to accept connection: " + err.Error()) log.Crit("Failed to accept connection: " + err.Error())
} else { } else {
log.Notice("Accepted a new connection") log.Notice("Accepted a new connection")
} }

18
tests/benchmarks/parallel/parallel.go
View File

@ -3,17 +3,17 @@ package main
import ( import (
"bufio" "bufio"
"fmt" "fmt"
//"encoding/hex" "log"
"github.com/tendermint/abci/types" "github.com/tendermint/abci/types"
. "github.com/tendermint/go-common" common "github.com/tendermint/go-common"
) )
func main() { func main() {
conn, err := Connect("unix://test.sock") conn, err := common.Connect("unix://test.sock")
if err != nil { if err != nil {
Exit(err.Error()) log.Fatal(err.Error())
} }
// Read a bunch of responses // Read a bunch of responses
@ -23,9 +23,9 @@ func main() {
var res = &types.Response{} var res = &types.Response{}
err := types.ReadMessage(conn, res) err := types.ReadMessage(conn, res)
if err != nil { if err != nil {
Exit(err.Error()) log.Fatal(err.Error())
} }
counter += 1 counter++
if counter%1000 == 0 { if counter%1000 == 0 {
fmt.Println("Read", counter) fmt.Println("Read", counter)
} }
@ -40,14 +40,14 @@ func main() {
err := types.WriteMessage(req, bufWriter) err := types.WriteMessage(req, bufWriter)
if err != nil { if err != nil {
Exit(err.Error()) log.Fatal(err.Error())
} }
err = bufWriter.Flush() err = bufWriter.Flush()
if err != nil { if err != nil {
Exit(err.Error()) log.Fatal(err.Error())
} }
counter += 1 counter++
if counter%1000 == 0 { if counter%1000 == 0 {
fmt.Println("Write", counter) fmt.Println("Write", counter)
} }

15
tests/benchmarks/simple/simple.go
View File

@ -2,21 +2,20 @@ package main
import ( import (
"bufio" "bufio"
"errors"
"fmt" "fmt"
"log"
"net" "net"
"reflect" "reflect"
//"encoding/hex"
"github.com/tendermint/abci/types" "github.com/tendermint/abci/types"
. "github.com/tendermint/go-common" common "github.com/tendermint/go-common"
) )
func main() { func main() {
conn, err := Connect("unix://test.sock") conn, err := common.Connect("unix://test.sock")
if err != nil { if err != nil {
Exit(err.Error()) log.Fatal(err.Error())
} }
// Make a bunch of requests // Make a bunch of requests
@ -25,9 +24,9 @@ func main() {
req := types.ToRequestEcho("foobar") req := types.ToRequestEcho("foobar")
_, err := makeRequest(conn, req) _, err := makeRequest(conn, req)
if err != nil { if err != nil {
Exit(err.Error()) log.Fatal(err.Error())
} }
counter += 1 counter++
if counter%1000 == 0 { if counter%1000 == 0 {
fmt.Println(counter) fmt.Println(counter)
} }
@ -63,7 +62,7 @@ func makeRequest(conn net.Conn, req *types.Request) (*types.Response, error) {
return nil, err return nil, err
} }
if _, ok := resFlush.Value.(*types.Response_Flush); !ok { if _, ok := resFlush.Value.(*types.Response_Flush); !ok {
return nil, errors.New(Fmt("Expected flush response but got something else: %v", reflect.TypeOf(resFlush))) return nil, fmt.Errorf("Expected flush response but got something else: %v", reflect.TypeOf(resFlush))
} }
return res, nil return res, nil

32
tests/test_app/app.go
View File

@ -2,18 +2,16 @@ package main
import ( import (
"bytes" "bytes"
"fmt"
"os" "os"
"time" "time"
"github.com/tendermint/abci/client" "github.com/tendermint/abci/client"
"github.com/tendermint/abci/types" "github.com/tendermint/abci/types"
. "github.com/tendermint/go-common"
"github.com/tendermint/go-process" "github.com/tendermint/go-process"
) )
//---------------------------------------- func startApp(abciApp string) *process.Process {
func StartApp(abciApp string) *process.Process {
// Start the app // Start the app
//outBuf := NewBufferCloser(nil) //outBuf := NewBufferCloser(nil)
proc, err := process.StartProcess("abci_app", proc, err := process.StartProcess("abci_app",
@ -33,7 +31,7 @@ func StartApp(abciApp string) *process.Process {
return proc return proc
} }
func StartClient(abciType string) abcicli.Client { func startClient(abciType string) abcicli.Client {
// Start client // Start client
client, err := abcicli.NewClient("tcp://127.0.0.1:46658", abciType, true) client, err := abcicli.NewClient("tcp://127.0.0.1:46658", abciType, true)
if err != nil { if err != nil {
@ -42,51 +40,51 @@ func StartClient(abciType string) abcicli.Client {
return client return client
} }
func SetOption(client abcicli.Client, key, value string) { func setOption(client abcicli.Client, key, value string) {
res := client.SetOptionSync(key, value) res := client.SetOptionSync(key, value)
_, _, log := res.Code, res.Data, res.Log _, _, log := res.Code, res.Data, res.Log
if res.IsErr() { if res.IsErr() {
panic(Fmt("setting %v=%v: \nlog: %v", key, value, log)) panic(fmt.Sprintf("setting %v=%v: \nlog: %v", key, value, log))
} }
} }
func Commit(client abcicli.Client, hashExp []byte) { func commit(client abcicli.Client, hashExp []byte) {
res := client.CommitSync() res := client.CommitSync()
_, data, log := res.Code, res.Data, res.Log _, data, log := res.Code, res.Data, res.Log
if res.IsErr() { if res.IsErr() {
panic(Fmt("committing %v\nlog: %v", log)) panic(fmt.Sprintf("committing %v\nlog: %v", log))
} }
if !bytes.Equal(res.Data, hashExp) { if !bytes.Equal(res.Data, hashExp) {
panic(Fmt("Commit hash was unexpected. Got %X expected %X", panic(fmt.Sprintf("Commit hash was unexpected. Got %X expected %X",
data, hashExp)) data, hashExp))
} }
} }
func DeliverTx(client abcicli.Client, txBytes []byte, codeExp types.CodeType, dataExp []byte) { func deliverTx(client abcicli.Client, txBytes []byte, codeExp types.CodeType, dataExp []byte) {
res := client.DeliverTxSync(txBytes) res := client.DeliverTxSync(txBytes)
code, data, log := res.Code, res.Data, res.Log code, data, log := res.Code, res.Data, res.Log
if code != codeExp { if code != codeExp {
panic(Fmt("DeliverTx response code was unexpected. Got %v expected %v. Log: %v", panic(fmt.Sprintf("DeliverTx response code was unexpected. Got %v expected %v. Log: %v",
code, codeExp, log)) code, codeExp, log))
} }
if !bytes.Equal(data, dataExp) { if !bytes.Equal(data, dataExp) {
panic(Fmt("DeliverTx response data was unexpected. Got %X expected %X", panic(fmt.Sprintf("DeliverTx response data was unexpected. Got %X expected %X",
data, dataExp)) data, dataExp))
} }
} }
func CheckTx(client abcicli.Client, txBytes []byte, codeExp types.CodeType, dataExp []byte) { func checkTx(client abcicli.Client, txBytes []byte, codeExp types.CodeType, dataExp []byte) {
res := client.CheckTxSync(txBytes) res := client.CheckTxSync(txBytes)
code, data, log := res.Code, res.Data, res.Log code, data, log := res.Code, res.Data, res.Log
if res.IsErr() { if res.IsErr() {
panic(Fmt("checking tx %X: %v\nlog: %v", txBytes, log)) panic(fmt.Sprintf("checking tx %X: %v\nlog: %v", txBytes, log))
} }
if code != codeExp { if code != codeExp {
panic(Fmt("CheckTx response code was unexpected. Got %v expected %v. Log: %v", panic(fmt.Sprintf("CheckTx response code was unexpected. Got %v expected %v. Log: %v",
code, codeExp, log)) code, codeExp, log))
} }
if !bytes.Equal(data, dataExp) { if !bytes.Equal(data, dataExp) {
panic(Fmt("CheckTx response data was unexpected. Got %X expected %X", panic(fmt.Sprintf("CheckTx response data was unexpected. Got %X expected %X",
data, dataExp)) data, dataExp))
} }
} }

30
tests/test_app/main.go
View File

@ -27,22 +27,22 @@ func testCounter() {
} }
fmt.Printf("Running %s test with abci=%s\n", abciApp, abciType) fmt.Printf("Running %s test with abci=%s\n", abciApp, abciType)
appProc := StartApp(abciApp) appProc := startApp(abciApp)
defer appProc.StopProcess(true) defer appProc.StopProcess(true)
client := StartClient(abciType) client := startClient(abciType)
defer client.Stop() defer client.Stop()
SetOption(client, "serial", "on") setOption(client, "serial", "on")
Commit(client, nil) commit(client, nil)
DeliverTx(client, []byte("abc"), types.CodeType_BadNonce, nil) deliverTx(client, []byte("abc"), types.CodeType_BadNonce, nil)
Commit(client, nil) commit(client, nil)
DeliverTx(client, []byte{0x00}, types.CodeType_OK, nil) deliverTx(client, []byte{0x00}, types.CodeType_OK, nil)
Commit(client, []byte{0, 0, 0, 0, 0, 0, 0, 1}) commit(client, []byte{0, 0, 0, 0, 0, 0, 0, 1})
DeliverTx(client, []byte{0x00}, types.CodeType_BadNonce, nil) deliverTx(client, []byte{0x00}, types.CodeType_BadNonce, nil)
DeliverTx(client, []byte{0x01}, types.CodeType_OK, nil) deliverTx(client, []byte{0x01}, types.CodeType_OK, nil)
DeliverTx(client, []byte{0x00, 0x02}, types.CodeType_OK, nil) deliverTx(client, []byte{0x00, 0x02}, types.CodeType_OK, nil)
DeliverTx(client, []byte{0x00, 0x03}, types.CodeType_OK, nil) deliverTx(client, []byte{0x00, 0x03}, types.CodeType_OK, nil)
DeliverTx(client, []byte{0x00, 0x00, 0x04}, types.CodeType_OK, nil) deliverTx(client, []byte{0x00, 0x00, 0x04}, types.CodeType_OK, nil)
DeliverTx(client, []byte{0x00, 0x00, 0x06}, types.CodeType_BadNonce, nil) deliverTx(client, []byte{0x00, 0x00, 0x06}, types.CodeType_BadNonce, nil)
Commit(client, []byte{0, 0, 0, 0, 0, 0, 0, 5}) commit(client, []byte{0, 0, 0, 0, 0, 0, 0, 5})
} }