From cfdec76020e386e1d6ef6ae30ff880c535892abe Mon Sep 17 00:00:00 2001 From: Ethan Buchman Date: Wed, 23 May 2018 23:27:46 -0400 Subject: [PATCH] update everything for Params and Result types --- client/local_client.go | 48 ++++++++++---------- example/counter/counter.go | 42 ++++++++--------- example/kvstore/helpers.go | 2 +- example/kvstore/kvstore.go | 18 ++++---- example/kvstore/kvstore_test.go | 18 ++++---- example/kvstore/persistent_kvstore.go | 40 ++++++++--------- server/socket_server.go | 30 ++++++------- types/application.go | 65 +++++++++++++++------------ types/codetype.go | 32 +++++++++++++ types/params.go | 49 ++++++++++++++++++++ types/result.go | 36 +++++++++++++++ 11 files changed, 253 insertions(+), 127 deletions(-) diff --git a/client/local_client.go b/client/local_client.go index 64bf5fe08..804c558f3 100644 --- a/client/local_client.go +++ b/client/local_client.go @@ -53,21 +53,21 @@ func (app *localClient) EchoAsync(msg string) *ReqRes { func (app *localClient) InfoAsync(req types.RequestInfo) *ReqRes { app.mtx.Lock() - res := app.Application.Info(req) + res := app.Application.Info(types.ToParamsInfo(req)) app.mtx.Unlock() return app.callback( types.ToRequestInfo(req), - types.ToResponseInfo(res), + types.ToResponseInfo(types.FromResultInfo(res)), ) } func (app *localClient) SetOptionAsync(req types.RequestSetOption) *ReqRes { app.mtx.Lock() - res := app.Application.SetOption(req) + res := app.Application.SetOption(types.ToParamsSetOption(req)) app.mtx.Unlock() return app.callback( types.ToRequestSetOption(req), - types.ToResponseSetOption(res), + types.ToResponseSetOption(types.FromResultSetOption(res)), ) } @@ -77,7 +77,7 @@ func (app *localClient) DeliverTxAsync(tx []byte) *ReqRes { app.mtx.Unlock() return app.callback( types.ToRequestDeliverTx(tx), - types.ToResponseDeliverTx(res), + types.ToResponseDeliverTx(types.FromResultDeliverTx(res)), ) } @@ -87,17 +87,17 @@ func (app *localClient) CheckTxAsync(tx []byte) *ReqRes { app.mtx.Unlock() return app.callback( types.ToRequestCheckTx(tx), - types.ToResponseCheckTx(res), + types.ToResponseCheckTx(types.FromResultCheckTx(res)), ) } func (app *localClient) QueryAsync(req types.RequestQuery) *ReqRes { app.mtx.Lock() - res := app.Application.Query(req) + res := app.Application.Query(types.ToParamsQuery(req)) app.mtx.Unlock() return app.callback( types.ToRequestQuery(req), - types.ToResponseQuery(res), + types.ToResponseQuery(types.FromResultQuery(res)), ) } @@ -107,16 +107,16 @@ func (app *localClient) CommitAsync() *ReqRes { app.mtx.Unlock() return app.callback( types.ToRequestCommit(), - types.ToResponseCommit(res), + types.ToResponseCommit(types.FromResultCommit(res)), ) } func (app *localClient) InitChainAsync(req types.RequestInitChain) *ReqRes { app.mtx.Lock() - res := app.Application.InitChain(req) + res := app.Application.InitChain(types.ToParamsInitChain(req)) reqRes := app.callback( types.ToRequestInitChain(req), - types.ToResponseInitChain(res), + types.ToResponseInitChain(types.FromResultInitChain(res)), ) app.mtx.Unlock() return reqRes @@ -124,21 +124,21 @@ func (app *localClient) InitChainAsync(req types.RequestInitChain) *ReqRes { func (app *localClient) BeginBlockAsync(req types.RequestBeginBlock) *ReqRes { app.mtx.Lock() - res := app.Application.BeginBlock(req) + res := app.Application.BeginBlock(types.ToParamsBeginBlock(req)) app.mtx.Unlock() return app.callback( types.ToRequestBeginBlock(req), - types.ToResponseBeginBlock(res), + types.ToResponseBeginBlock(types.FromResultBeginBlock(res)), ) } func (app *localClient) EndBlockAsync(req types.RequestEndBlock) *ReqRes { app.mtx.Lock() - res := app.Application.EndBlock(req) + res := app.Application.EndBlock(types.ToParamsEndBlock(req)) app.mtx.Unlock() return app.callback( types.ToRequestEndBlock(req), - types.ToResponseEndBlock(res), + types.ToResponseEndBlock(types.FromResultEndBlock(res)), ) } @@ -154,63 +154,63 @@ func (app *localClient) EchoSync(msg string) (*types.ResponseEcho, error) { func (app *localClient) InfoSync(req types.RequestInfo) (*types.ResponseInfo, error) { app.mtx.Lock() - res := app.Application.Info(req) + res := types.FromResultInfo(app.Application.Info(types.ToParamsInfo(req))) app.mtx.Unlock() return &res, nil } func (app *localClient) SetOptionSync(req types.RequestSetOption) (*types.ResponseSetOption, error) { app.mtx.Lock() - res := app.Application.SetOption(req) + res := types.FromResultSetOption(app.Application.SetOption(types.ToParamsSetOption(req))) app.mtx.Unlock() return &res, nil } func (app *localClient) DeliverTxSync(tx []byte) (*types.ResponseDeliverTx, error) { app.mtx.Lock() - res := app.Application.DeliverTx(tx) + res := types.FromResultDeliverTx(app.Application.DeliverTx(tx)) app.mtx.Unlock() return &res, nil } func (app *localClient) CheckTxSync(tx []byte) (*types.ResponseCheckTx, error) { app.mtx.Lock() - res := app.Application.CheckTx(tx) + res := types.FromResultCheckTx(app.Application.CheckTx(tx)) app.mtx.Unlock() return &res, nil } func (app *localClient) QuerySync(req types.RequestQuery) (*types.ResponseQuery, error) { app.mtx.Lock() - res := app.Application.Query(req) + res := types.FromResultQuery(app.Application.Query(types.ToParamsQuery(req))) app.mtx.Unlock() return &res, nil } func (app *localClient) CommitSync() (*types.ResponseCommit, error) { app.mtx.Lock() - res := app.Application.Commit() + res := types.FromResultCommit(app.Application.Commit()) app.mtx.Unlock() return &res, nil } func (app *localClient) InitChainSync(req types.RequestInitChain) (*types.ResponseInitChain, error) { app.mtx.Lock() - res := app.Application.InitChain(req) + res := types.FromResultInitChain(app.Application.InitChain(types.ToParamsInitChain(req))) app.mtx.Unlock() return &res, nil } func (app *localClient) BeginBlockSync(req types.RequestBeginBlock) (*types.ResponseBeginBlock, error) { app.mtx.Lock() - res := app.Application.BeginBlock(req) + res := types.FromResultBeginBlock(app.Application.BeginBlock(types.ToParamsBeginBlock(req))) app.mtx.Unlock() return &res, nil } func (app *localClient) EndBlockSync(req types.RequestEndBlock) (*types.ResponseEndBlock, error) { app.mtx.Lock() - res := app.Application.EndBlock(req) + res := types.FromResultEndBlock(app.Application.EndBlock(types.ToParamsEndBlock(req))) app.mtx.Unlock() return &res, nil } diff --git a/example/counter/counter.go b/example/counter/counter.go index a6d5df6ab..3437da670 100644 --- a/example/counter/counter.go +++ b/example/counter/counter.go @@ -21,11 +21,11 @@ func NewCounterApplication(serial bool) *CounterApplication { return &CounterApplication{serial: serial} } -func (app *CounterApplication) Info(req types.RequestInfo) types.ResponseInfo { - return types.ResponseInfo{Data: cmn.Fmt("{\"hashes\":%v,\"txs\":%v}", app.hashCount, app.txCount)} +func (app *CounterApplication) Info(req types.ParamsInfo) types.ResultInfo { + return types.ResultInfo{Data: cmn.Fmt("{\"hashes\":%v,\"txs\":%v}", app.hashCount, app.txCount)} } -func (app *CounterApplication) SetOption(req types.RequestSetOption) types.ResponseSetOption { +func (app *CounterApplication) SetOption(req types.ParamsSetOption) types.ResultSetOption { key, value := req.Key, req.Value if key == "serial" && value == "on" { app.serial = true @@ -33,20 +33,20 @@ func (app *CounterApplication) SetOption(req types.RequestSetOption) types.Respo /* TODO Panic and have the ABCI server pass an exception. The client can call SetOptionSync() and get an `error`. - return types.ResponseSetOption{ + return types.ResultSetOption{ Error: cmn.Fmt("Unknown key (%s) or value (%s)", key, value), } */ - return types.ResponseSetOption{} + return types.ResultSetOption{} } - return types.ResponseSetOption{} + return types.ResultSetOption{} } -func (app *CounterApplication) DeliverTx(tx []byte) types.ResponseDeliverTx { +func (app *CounterApplication) DeliverTx(tx []byte) types.ResultDeliverTx { if app.serial { if len(tx) > 8 { - return types.ResponseDeliverTx{ + return types.ResultDeliverTx{ Code: code.CodeTypeEncodingError, Log: fmt.Sprintf("Max tx size is 8 bytes, got %d", len(tx))} } @@ -54,19 +54,19 @@ func (app *CounterApplication) DeliverTx(tx []byte) types.ResponseDeliverTx { copy(tx8[len(tx8)-len(tx):], tx) txValue := binary.BigEndian.Uint64(tx8) if txValue != uint64(app.txCount) { - return types.ResponseDeliverTx{ + return types.ResultDeliverTx{ Code: code.CodeTypeBadNonce, Log: fmt.Sprintf("Invalid nonce. Expected %v, got %v", app.txCount, txValue)} } } app.txCount++ - return types.ResponseDeliverTx{Code: code.CodeTypeOK} + return types.ResultDeliverTx{Code: code.CodeTypeOK} } -func (app *CounterApplication) CheckTx(tx []byte) types.ResponseCheckTx { +func (app *CounterApplication) CheckTx(tx []byte) types.ResultCheckTx { if app.serial { if len(tx) > 8 { - return types.ResponseCheckTx{ + return types.ResultCheckTx{ Code: code.CodeTypeEncodingError, Log: fmt.Sprintf("Max tx size is 8 bytes, got %d", len(tx))} } @@ -74,31 +74,31 @@ func (app *CounterApplication) CheckTx(tx []byte) types.ResponseCheckTx { copy(tx8[len(tx8)-len(tx):], tx) txValue := binary.BigEndian.Uint64(tx8) if txValue < uint64(app.txCount) { - return types.ResponseCheckTx{ + return types.ResultCheckTx{ Code: code.CodeTypeBadNonce, Log: fmt.Sprintf("Invalid nonce. Expected >= %v, got %v", app.txCount, txValue)} } } - return types.ResponseCheckTx{Code: code.CodeTypeOK} + return types.ResultCheckTx{Code: code.CodeTypeOK} } -func (app *CounterApplication) Commit() (resp types.ResponseCommit) { +func (app *CounterApplication) Commit() (resp types.ResultCommit) { app.hashCount++ if app.txCount == 0 { - return types.ResponseCommit{} + return types.ResultCommit{} } hash := make([]byte, 8) binary.BigEndian.PutUint64(hash, uint64(app.txCount)) - return types.ResponseCommit{Data: hash} + return types.ResultCommit{Data: hash} } -func (app *CounterApplication) Query(reqQuery types.RequestQuery) types.ResponseQuery { +func (app *CounterApplication) Query(reqQuery types.ParamsQuery) types.ResultQuery { switch reqQuery.Path { case "hash": - return types.ResponseQuery{Value: []byte(cmn.Fmt("%v", app.hashCount))} + return types.ResultQuery{Value: []byte(cmn.Fmt("%v", app.hashCount))} case "tx": - return types.ResponseQuery{Value: []byte(cmn.Fmt("%v", app.txCount))} + return types.ResultQuery{Value: []byte(cmn.Fmt("%v", app.txCount))} default: - return types.ResponseQuery{Log: cmn.Fmt("Invalid query path. Expected hash or tx, got %v", reqQuery.Path)} + return types.ResultQuery{Log: cmn.Fmt("Invalid query path. Expected hash or tx, got %v", reqQuery.Path)} } } diff --git a/example/kvstore/helpers.go b/example/kvstore/helpers.go index da826fe65..e302a6d17 100644 --- a/example/kvstore/helpers.go +++ b/example/kvstore/helpers.go @@ -32,7 +32,7 @@ func RandVals(cnt int) []types.Validator { // which allows tests to pass and is fine as long as you // don't make any tx that modify the validator state func InitKVStore(app *PersistentKVStoreApplication) { - app.InitChain(types.RequestInitChain{ + app.InitChain(types.ParamsInitChain{ Validators: RandVals(1), GenesisBytes: []byte("[]"), }) diff --git a/example/kvstore/kvstore.go b/example/kvstore/kvstore.go index 4ccbc56b0..573168df1 100644 --- a/example/kvstore/kvstore.go +++ b/example/kvstore/kvstore.go @@ -64,12 +64,12 @@ func NewKVStoreApplication() *KVStoreApplication { return &KVStoreApplication{state: state} } -func (app *KVStoreApplication) Info(req types.RequestInfo) (resInfo types.ResponseInfo) { - return types.ResponseInfo{Data: fmt.Sprintf("{\"size\":%v}", app.state.Size)} +func (app *KVStoreApplication) Info(req types.ParamsInfo) (resInfo types.ResultInfo) { + return types.ResultInfo{Data: fmt.Sprintf("{\"size\":%v}", app.state.Size)} } // tx is either "key=value" or just arbitrary bytes -func (app *KVStoreApplication) DeliverTx(tx []byte) types.ResponseDeliverTx { +func (app *KVStoreApplication) DeliverTx(tx []byte) types.ResultDeliverTx { var key, value []byte parts := bytes.Split(tx, []byte("=")) if len(parts) == 2 { @@ -84,24 +84,24 @@ func (app *KVStoreApplication) DeliverTx(tx []byte) types.ResponseDeliverTx { {[]byte("app.creator"), []byte("jae")}, {[]byte("app.key"), key}, } - return types.ResponseDeliverTx{Code: code.CodeTypeOK, Tags: tags} + return types.ResultDeliverTx{Code: code.CodeTypeOK, Tags: tags} } -func (app *KVStoreApplication) CheckTx(tx []byte) types.ResponseCheckTx { - return types.ResponseCheckTx{Code: code.CodeTypeOK} +func (app *KVStoreApplication) CheckTx(tx []byte) types.ResultCheckTx { + return types.ResultCheckTx{Code: code.CodeTypeOK} } -func (app *KVStoreApplication) Commit() types.ResponseCommit { +func (app *KVStoreApplication) Commit() types.ResultCommit { // Using a memdb - just return the big endian size of the db appHash := make([]byte, 8) binary.PutVarint(appHash, app.state.Size) app.state.AppHash = appHash app.state.Height += 1 saveState(app.state) - return types.ResponseCommit{Data: appHash} + return types.ResultCommit{Data: appHash} } -func (app *KVStoreApplication) Query(reqQuery types.RequestQuery) (resQuery types.ResponseQuery) { +func (app *KVStoreApplication) Query(reqQuery types.ParamsQuery) (resQuery types.ResultQuery) { if reqQuery.Prove { value := app.state.db.Get(prefixKey(reqQuery.Data)) resQuery.Index = -1 // TODO make Proof return index diff --git a/example/kvstore/kvstore_test.go b/example/kvstore/kvstore_test.go index ff3e49208..32c667979 100644 --- a/example/kvstore/kvstore_test.go +++ b/example/kvstore/kvstore_test.go @@ -25,7 +25,7 @@ func testKVStore(t *testing.T, app types.Application, tx []byte, key, value stri require.False(t, ar.IsErr(), ar) // make sure query is fine - resQuery := app.Query(types.RequestQuery{ + resQuery := app.Query(types.ParamsQuery{ Path: "/store", Data: []byte(key), }) @@ -33,7 +33,7 @@ func testKVStore(t *testing.T, app types.Application, tx []byte, key, value stri require.Equal(t, value, string(resQuery.Value)) // make sure proof is fine - resQuery = app.Query(types.RequestQuery{ + resQuery = app.Query(types.ParamsQuery{ Path: "/store", Data: []byte(key), Prove: true, @@ -79,7 +79,7 @@ func TestPersistentKVStoreInfo(t *testing.T) { InitKVStore(kvstore) height := int64(0) - resInfo := kvstore.Info(types.RequestInfo{}) + resInfo := kvstore.Info(types.ParamsInfo{}) if resInfo.LastBlockHeight != height { t.Fatalf("expected height of %d, got %d", height, resInfo.LastBlockHeight) } @@ -90,11 +90,11 @@ func TestPersistentKVStoreInfo(t *testing.T) { header := types.Header{ Height: int64(height), } - kvstore.BeginBlock(types.RequestBeginBlock{hash, header, nil, nil}) - kvstore.EndBlock(types.RequestEndBlock{header.Height}) + kvstore.BeginBlock(types.ParamsBeginBlock{hash, header, nil, nil}) + kvstore.EndBlock(types.ParamsEndBlock{header.Height}) kvstore.Commit() - resInfo = kvstore.Info(types.RequestInfo{}) + resInfo = kvstore.Info(types.ParamsInfo{}) if resInfo.LastBlockHeight != height { t.Fatalf("expected height of %d, got %d", height, resInfo.LastBlockHeight) } @@ -114,7 +114,7 @@ func TestValUpdates(t *testing.T) { nInit := 5 vals := RandVals(total) // iniitalize with the first nInit - kvstore.InitChain(types.RequestInitChain{ + kvstore.InitChain(types.ParamsInitChain{ Validators: vals[:nInit], }) @@ -176,13 +176,13 @@ func makeApplyBlock(t *testing.T, kvstore types.Application, heightInt int, diff Height: height, } - kvstore.BeginBlock(types.RequestBeginBlock{hash, header, nil, nil}) + kvstore.BeginBlock(types.ParamsBeginBlock{hash, header, nil, nil}) for _, tx := range txs { if r := kvstore.DeliverTx(tx); r.IsErr() { t.Fatal(r) } } - resEndBlock := kvstore.EndBlock(types.RequestEndBlock{header.Height}) + resEndBlock := kvstore.EndBlock(types.ParamsEndBlock{header.Height}) kvstore.Commit() valsEqual(t, diff, resEndBlock.ValidatorUpdates) diff --git a/example/kvstore/persistent_kvstore.go b/example/kvstore/persistent_kvstore.go index 02f7ce74a..00095869a 100644 --- a/example/kvstore/persistent_kvstore.go +++ b/example/kvstore/persistent_kvstore.go @@ -50,19 +50,19 @@ func (app *PersistentKVStoreApplication) SetLogger(l log.Logger) { app.logger = l } -func (app *PersistentKVStoreApplication) Info(req types.RequestInfo) types.ResponseInfo { +func (app *PersistentKVStoreApplication) Info(req types.ParamsInfo) types.ResultInfo { res := app.app.Info(req) res.LastBlockHeight = app.app.state.Height res.LastBlockAppHash = app.app.state.AppHash return res } -func (app *PersistentKVStoreApplication) SetOption(req types.RequestSetOption) types.ResponseSetOption { +func (app *PersistentKVStoreApplication) SetOption(req types.ParamsSetOption) types.ResultSetOption { return app.app.SetOption(req) } // tx is either "val:pubkey/power" or "key=value" or just arbitrary bytes -func (app *PersistentKVStoreApplication) DeliverTx(tx []byte) types.ResponseDeliverTx { +func (app *PersistentKVStoreApplication) DeliverTx(tx []byte) types.ResultDeliverTx { // if it starts with "val:", update the validator set // format is "val:pubkey/power" if isValidatorTx(tx) { @@ -75,40 +75,40 @@ func (app *PersistentKVStoreApplication) DeliverTx(tx []byte) types.ResponseDeli return app.app.DeliverTx(tx) } -func (app *PersistentKVStoreApplication) CheckTx(tx []byte) types.ResponseCheckTx { +func (app *PersistentKVStoreApplication) CheckTx(tx []byte) types.ResultCheckTx { return app.app.CheckTx(tx) } // Commit will panic if InitChain was not called -func (app *PersistentKVStoreApplication) Commit() types.ResponseCommit { +func (app *PersistentKVStoreApplication) Commit() types.ResultCommit { return app.app.Commit() } -func (app *PersistentKVStoreApplication) Query(reqQuery types.RequestQuery) types.ResponseQuery { +func (app *PersistentKVStoreApplication) Query(reqQuery types.ParamsQuery) types.ResultQuery { return app.app.Query(reqQuery) } // Save the validators in the merkle tree -func (app *PersistentKVStoreApplication) InitChain(req types.RequestInitChain) types.ResponseInitChain { +func (app *PersistentKVStoreApplication) InitChain(req types.ParamsInitChain) types.ResultInitChain { for _, v := range req.Validators { r := app.updateValidator(v) if r.IsErr() { app.logger.Error("Error updating validators", "r", r) } } - return types.ResponseInitChain{} + return types.ResultInitChain{} } // Track the block hash and header information -func (app *PersistentKVStoreApplication) BeginBlock(req types.RequestBeginBlock) types.ResponseBeginBlock { +func (app *PersistentKVStoreApplication) BeginBlock(req types.ParamsBeginBlock) types.ResultBeginBlock { // reset valset changes app.ValUpdates = make([]types.Validator, 0) - return types.ResponseBeginBlock{} + return types.ResultBeginBlock{} } // Update the validator set -func (app *PersistentKVStoreApplication) EndBlock(req types.RequestEndBlock) types.ResponseEndBlock { - return types.ResponseEndBlock{ValidatorUpdates: app.ValUpdates} +func (app *PersistentKVStoreApplication) EndBlock(req types.ParamsEndBlock) types.ResultEndBlock { + return types.ResultEndBlock{ValidatorUpdates: app.ValUpdates} } //--------------------------------------------- @@ -139,13 +139,13 @@ func isValidatorTx(tx []byte) bool { // format is "val:pubkey/power" // pubkey is raw 32-byte ed25519 key -func (app *PersistentKVStoreApplication) execValidatorTx(tx []byte) types.ResponseDeliverTx { +func (app *PersistentKVStoreApplication) execValidatorTx(tx []byte) types.ResultDeliverTx { tx = tx[len(ValidatorSetChangePrefix):] //get the pubkey and power pubKeyAndPower := strings.Split(string(tx), "/") if len(pubKeyAndPower) != 2 { - return types.ResponseDeliverTx{ + return types.ResultDeliverTx{ Code: code.CodeTypeEncodingError, Log: fmt.Sprintf("Expected 'pubkey/power'. Got %v", pubKeyAndPower)} } @@ -154,7 +154,7 @@ func (app *PersistentKVStoreApplication) execValidatorTx(tx []byte) types.Respon // decode the pubkey pubkey, err := hex.DecodeString(pubkeyS) if err != nil { - return types.ResponseDeliverTx{ + return types.ResultDeliverTx{ Code: code.CodeTypeEncodingError, Log: fmt.Sprintf("Pubkey (%s) is invalid hex", pubkeyS)} } @@ -162,7 +162,7 @@ func (app *PersistentKVStoreApplication) execValidatorTx(tx []byte) types.Respon // decode the power power, err := strconv.ParseInt(powerS, 10, 64) if err != nil { - return types.ResponseDeliverTx{ + return types.ResultDeliverTx{ Code: code.CodeTypeEncodingError, Log: fmt.Sprintf("Power (%s) is not an int", powerS)} } @@ -172,12 +172,12 @@ func (app *PersistentKVStoreApplication) execValidatorTx(tx []byte) types.Respon } // add, update, or remove a validator -func (app *PersistentKVStoreApplication) updateValidator(v types.Validator) types.ResponseDeliverTx { +func (app *PersistentKVStoreApplication) updateValidator(v types.Validator) types.ResultDeliverTx { key := []byte("val:" + string(v.PubKey.Data)) if v.Power == 0 { // remove validator if !app.app.state.db.Has(key) { - return types.ResponseDeliverTx{ + return types.ResultDeliverTx{ Code: code.CodeTypeUnauthorized, Log: fmt.Sprintf("Cannot remove non-existent validator %X", key)} } @@ -186,7 +186,7 @@ func (app *PersistentKVStoreApplication) updateValidator(v types.Validator) type // add or update validator value := bytes.NewBuffer(make([]byte, 0)) if err := types.WriteMessage(&v, value); err != nil { - return types.ResponseDeliverTx{ + return types.ResultDeliverTx{ Code: code.CodeTypeEncodingError, Log: fmt.Sprintf("Error encoding validator: %v", err)} } @@ -196,5 +196,5 @@ func (app *PersistentKVStoreApplication) updateValidator(v types.Validator) type // we only update the changes array if we successfully updated the tree app.ValUpdates = append(app.ValUpdates, v) - return types.ResponseDeliverTx{Code: code.CodeTypeOK} + return types.ResultDeliverTx{Code: code.CodeTypeOK} } diff --git a/server/socket_server.go b/server/socket_server.go index eb26dc353..d9aa97402 100644 --- a/server/socket_server.go +++ b/server/socket_server.go @@ -172,32 +172,32 @@ func (s *SocketServer) handleRequest(req *types.Request, responses chan<- *types case *types.Request_Flush: responses <- types.ToResponseFlush() case *types.Request_Info: - res := s.app.Info(*r.Info) - responses <- types.ToResponseInfo(res) + res := s.app.Info(types.ToParamsInfo(*r.Info)) + responses <- types.ToResponseInfo(types.FromResultInfo(res)) case *types.Request_SetOption: - res := s.app.SetOption(*r.SetOption) - responses <- types.ToResponseSetOption(res) + res := s.app.SetOption(types.ToParamsSetOption(*r.SetOption)) + responses <- types.ToResponseSetOption(types.FromResultSetOption(res)) case *types.Request_DeliverTx: res := s.app.DeliverTx(r.DeliverTx.Tx) - responses <- types.ToResponseDeliverTx(res) + responses <- types.ToResponseDeliverTx(types.FromResultDeliverTx(res)) case *types.Request_CheckTx: res := s.app.CheckTx(r.CheckTx.Tx) - responses <- types.ToResponseCheckTx(res) + responses <- types.ToResponseCheckTx(types.FromResultCheckTx(res)) case *types.Request_Commit: res := s.app.Commit() - responses <- types.ToResponseCommit(res) + responses <- types.ToResponseCommit(types.FromResultCommit(res)) case *types.Request_Query: - res := s.app.Query(*r.Query) - responses <- types.ToResponseQuery(res) + res := s.app.Query(types.ToParamsQuery(*r.Query)) + responses <- types.ToResponseQuery(types.FromResultQuery(res)) case *types.Request_InitChain: - res := s.app.InitChain(*r.InitChain) - responses <- types.ToResponseInitChain(res) + res := s.app.InitChain(types.ToParamsInitChain(*r.InitChain)) + responses <- types.ToResponseInitChain(types.FromResultInitChain(res)) case *types.Request_BeginBlock: - res := s.app.BeginBlock(*r.BeginBlock) - responses <- types.ToResponseBeginBlock(res) + res := s.app.BeginBlock(types.ToParamsBeginBlock(*r.BeginBlock)) + responses <- types.ToResponseBeginBlock(types.FromResultBeginBlock(res)) case *types.Request_EndBlock: - res := s.app.EndBlock(*r.EndBlock) - responses <- types.ToResponseEndBlock(res) + res := s.app.EndBlock(types.ToParamsEndBlock(*r.EndBlock)) + responses <- types.ToResponseEndBlock(types.FromResultEndBlock(res)) default: responses <- types.ToResponseException("Unknown request") } diff --git a/types/application.go b/types/application.go index d1eb40bce..03d0c8fb0 100644 --- a/types/application.go +++ b/types/application.go @@ -84,55 +84,64 @@ func NewGRPCApplication(app Application) *GRPCApplication { return &GRPCApplication{app} } -func (app *GRPCApplication) Echo(ctx context.Context, req *ParamsEcho) (*ResultEcho, error) { - return &ResultEcho{req.Message}, nil +func (app *GRPCApplication) Echo(ctx context.Context, req *RequestEcho) (*ResponseEcho, error) { + return &ResponseEcho{req.Message}, nil } -func (app *GRPCApplication) Flush(ctx context.Context, req *ParamsFlush) (*ResultFlush, error) { - return &ResultFlush{}, nil +func (app *GRPCApplication) Flush(ctx context.Context, req *RequestFlush) (*ResponseFlush, error) { + return &ResponseFlush{}, nil } -func (app *GRPCApplication) Info(ctx context.Context, req *ParamsInfo) (*ResultInfo, error) { - res := app.app.Info(*req) - return &res, nil +func (app *GRPCApplication) Info(ctx context.Context, req *RequestInfo) (*ResponseInfo, error) { + res := app.app.Info(ToParamsInfo(*req)) + r := FromResultInfo(res) + return &r, nil } -func (app *GRPCApplication) SetOption(ctx context.Context, req *ParamsSetOption) (*ResultSetOption, error) { - res := app.app.SetOption(*req) - return &res, nil +func (app *GRPCApplication) SetOption(ctx context.Context, req *RequestSetOption) (*ResponseSetOption, error) { + res := app.app.SetOption(ToParamsSetOption(*req)) + r := FromResultSetOption(res) + return &r, nil } -func (app *GRPCApplication) DeliverTx(ctx context.Context, req *ParamsDeliverTx) (*ResultDeliverTx, error) { +func (app *GRPCApplication) DeliverTx(ctx context.Context, req *RequestDeliverTx) (*ResponseDeliverTx, error) { res := app.app.DeliverTx(req.Tx) - return &res, nil + r := FromResultDeliverTx(res) + return &r, nil } -func (app *GRPCApplication) CheckTx(ctx context.Context, req *ParamsCheckTx) (*ResultCheckTx, error) { +func (app *GRPCApplication) CheckTx(ctx context.Context, req *RequestCheckTx) (*ResponseCheckTx, error) { res := app.app.CheckTx(req.Tx) - return &res, nil + r := FromResultCheckTx(res) + return &r, nil } -func (app *GRPCApplication) Query(ctx context.Context, req *ParamsQuery) (*ResultQuery, error) { - res := app.app.Query(*req) - return &res, nil +func (app *GRPCApplication) Query(ctx context.Context, req *RequestQuery) (*ResponseQuery, error) { + res := app.app.Query(ToParamsQuery(*req)) + r := FromResultQuery(res) + return &r, nil } -func (app *GRPCApplication) Commit(ctx context.Context, req *ParamsCommit) (*ResultCommit, error) { +func (app *GRPCApplication) Commit(ctx context.Context, req *RequestCommit) (*ResponseCommit, error) { res := app.app.Commit() - return &res, nil + r := FromResultCommit(res) + return &r, nil } -func (app *GRPCApplication) InitChain(ctx context.Context, req *ParamsInitChain) (*ResultInitChain, error) { - res := app.app.InitChain(*req) - return &res, nil +func (app *GRPCApplication) InitChain(ctx context.Context, req *RequestInitChain) (*ResponseInitChain, error) { + res := app.app.InitChain(ToParamsInitChain(*req)) + r := FromResultInitChain(res) + return &r, nil } -func (app *GRPCApplication) BeginBlock(ctx context.Context, req *ParamsBeginBlock) (*ResultBeginBlock, error) { - res := app.app.BeginBlock(*req) - return &res, nil +func (app *GRPCApplication) BeginBlock(ctx context.Context, req *RequestBeginBlock) (*ResponseBeginBlock, error) { + res := app.app.BeginBlock(ToParamsBeginBlock(*req)) + r := FromResultBeginBlock(res) + return &r, nil } -func (app *GRPCApplication) EndBlock(ctx context.Context, req *ParamsEndBlock) (*ResultEndBlock, error) { - res := app.app.EndBlock(*req) - return &res, nil +func (app *GRPCApplication) EndBlock(ctx context.Context, req *RequestEndBlock) (*ResponseEndBlock, error) { + res := app.app.EndBlock(ToParamsEndBlock(*req)) + r := FromResultEndBlock(res) + return &r, nil } diff --git a/types/codetype.go b/types/codetype.go index 5355a498b..287f9e814 100644 --- a/types/codetype.go +++ b/types/codetype.go @@ -33,3 +33,35 @@ func (r ResponseQuery) IsOK() bool { func (r ResponseQuery) IsErr() bool { return r.Code != CodeTypeOK } + +//---------------------------------------------------- + +// IsOK returns true if Code is OK. +func (r ResultCheckTx) IsOK() bool { + return r.Code == CodeTypeOK +} + +// IsErr returns true if Code is something other than OK. +func (r ResultCheckTx) IsErr() bool { + return r.Code != CodeTypeOK +} + +// IsOK returns true if Code is OK. +func (r ResultDeliverTx) IsOK() bool { + return r.Code == CodeTypeOK +} + +// IsErr returns true if Code is something other than OK. +func (r ResultDeliverTx) IsErr() bool { + return r.Code != CodeTypeOK +} + +// IsOK returns true if Code is OK. +func (r ResultQuery) IsOK() bool { + return r.Code == CodeTypeOK +} + +// IsErr returns true if Code is something other than OK. +func (r ResultQuery) IsErr() bool { + return r.Code != CodeTypeOK +} diff --git a/types/params.go b/types/params.go index 3e35119a8..476121ba7 100644 --- a/types/params.go +++ b/types/params.go @@ -11,16 +11,36 @@ type ParamsInfo struct { Version string `json:"version,omitempty"` } +func ToParamsInfo(req RequestInfo) ParamsInfo { + return ParamsInfo{ + Version: req.Version, + } +} + type ParamsSetOption struct { Key string `json:"key,omitempty"` Value string `json:"value,omitempty"` } +func ToParamsSetOption(req RequestSetOption) ParamsSetOption { + return ParamsSetOption{ + Key: req.Key, + Value: req.Value, + } +} + type ParamsInitChain struct { Validators []Validator `json:"validators"` GenesisBytes []byte `json:"genesis_bytes,omitempty"` } +func ToParamsInitChain(req RequestInitChain) ParamsInitChain { + return ParamsInitChain{ + Validators: req.Validators, + GenesisBytes: req.GenesisBytes, + } +} + type ParamsQuery struct { Data []byte `json:"data,omitempty"` Path string `json:"path,omitempty"` @@ -28,6 +48,15 @@ type ParamsQuery struct { Prove bool `json:"prove,omitempty"` } +func ToParamsQuery(req RequestQuery) ParamsQuery { + return ParamsQuery{ + Data: req.Data, + Path: req.Path, + Height: req.Height, + Prove: req.Prove, + } +} + type ParamsBeginBlock struct { Hash []byte `json:"hash,omitempty"` Header Header `json:"header"` @@ -35,6 +64,20 @@ type ParamsBeginBlock struct { ByzantineValidators []Evidence `json:"byzantine_validators"` } +func ToParamsBeginBlock(req RequestBeginBlock) ParamsBeginBlock { + vals := make([]SigningValidator, len(req.Validators)) + for i := 0; i < len(vals); i++ { + v := req.Validators[i] + vals[i] = *v + } + return ParamsBeginBlock{ + Hash: req.Hash, + Header: req.Header, + Validators: vals, + ByzantineValidators: req.ByzantineValidators, + } +} + type ParamsCheckTx struct { Tx []byte `json:"tx,omitempty"` } @@ -47,5 +90,11 @@ type ParamsEndBlock struct { Height int64 `json:"height,omitempty"` } +func ToParamsEndBlock(req RequestEndBlock) ParamsEndBlock { + return ParamsEndBlock{ + Height: req.Height, + } +} + type ParamsCommit struct { } diff --git a/types/result.go b/types/result.go index 8b14fdfbf..983efa254 100644 --- a/types/result.go +++ b/types/result.go @@ -21,6 +21,10 @@ type ResultInfo struct { LastBlockAppHash []byte `json:"last_block_app_hash,omitempty"` } +func FromResultInfo(res ResultInfo) ResponseInfo { + return ResponseInfo(res) +} + type ResultSetOption struct { Code uint32 `json:"code,omitempty"` // bytes data = 2; @@ -28,10 +32,18 @@ type ResultSetOption struct { Info string `json:"info,omitempty"` } +func FromResultSetOption(res ResultSetOption) ResponseSetOption { + return ResponseSetOption(res) +} + type ResultInitChain struct { Validators []Validator `json:"validators"` } +func FromResultInitChain(res ResultInitChain) ResponseInitChain { + return ResponseInitChain(res) +} + type ResultQuery struct { Code uint32 `json:"code,omitempty"` // bytes data = 2; // use "value" instead. @@ -44,10 +56,18 @@ type ResultQuery struct { Height int64 `json:"height,omitempty"` } +func FromResultQuery(res ResultQuery) ResponseQuery { + return ResponseQuery(res) +} + type ResultBeginBlock struct { Tags []common.KVPair `json:"tags,omitempty"` } +func FromResultBeginBlock(res ResultBeginBlock) ResponseBeginBlock { + return ResponseBeginBlock(res) +} + type ResultCheckTx struct { Code uint32 `json:"code,omitempty"` Data []byte `json:"data,omitempty"` @@ -59,6 +79,10 @@ type ResultCheckTx struct { Fee common.KI64Pair `json:"fee"` } +func FromResultCheckTx(res ResultCheckTx) ResponseCheckTx { + return ResponseCheckTx(res) +} + type ResultDeliverTx struct { Code uint32 `json:"code,omitempty"` Data []byte `json:"data,omitempty"` @@ -70,13 +94,25 @@ type ResultDeliverTx struct { Fee common.KI64Pair `json:"fee"` } +func FromResultDeliverTx(res ResultDeliverTx) ResponseDeliverTx { + return ResponseDeliverTx(res) +} + type ResultEndBlock struct { ValidatorUpdates []Validator `json:"validator_updates"` ConsensusParamUpdates *ConsensusParams `json:"consensus_param_updates,omitempty"` Tags []common.KVPair `json:"tags,omitempty"` } +func FromResultEndBlock(res ResultEndBlock) ResponseEndBlock { + return ResponseEndBlock(res) +} + type ResultCommit struct { // reserve 1 Data []byte `json:"data,omitempty"` } + +func FromResultCommit(res ResultCommit) ResponseCommit { + return ResponseCommit(res) +}