From 91efacfabc086f14a9d4fe4f2d661a0e647915c2 Mon Sep 17 00:00:00 2001 From: Anton Kaliaev Date: Wed, 22 Nov 2017 17:44:39 -0600 Subject: [PATCH] remove types.Result --- types/code.go | 34 +++++++++++ types/errors.go | 58 ------------------ types/result.go | 152 +++++++----------------------------------------- 3 files changed, 56 insertions(+), 188 deletions(-) delete mode 100644 types/errors.go diff --git a/types/code.go b/types/code.go index c99a0bbe1..613c4cda3 100644 --- a/types/code.go +++ b/types/code.go @@ -1,3 +1,37 @@ package types +var ( + code2string = map[CodeType]string{ + CodeType_InternalError: "Internal error", + CodeType_EncodingError: "Encoding error", + CodeType_BadNonce: "Error bad nonce", + CodeType_Unauthorized: "Unauthorized", + CodeType_InsufficientFunds: "Insufficient funds", + CodeType_UnknownRequest: "Unknown request", + + CodeType_BaseDuplicateAddress: "Error (base) duplicate address", + CodeType_BaseEncodingError: "Error (base) encoding error", + CodeType_BaseInsufficientFees: "Error (base) insufficient fees", + CodeType_BaseInsufficientFunds: "Error (base) insufficient funds", + CodeType_BaseInsufficientGasPrice: "Error (base) insufficient gas price", + CodeType_BaseInvalidInput: "Error (base) invalid input", + CodeType_BaseInvalidOutput: "Error (base) invalid output", + CodeType_BaseInvalidPubKey: "Error (base) invalid pubkey", + CodeType_BaseInvalidSequence: "Error (base) invalid sequence", + CodeType_BaseInvalidSignature: "Error (base) invalid signature", + CodeType_BaseUnknownAddress: "Error (base) unknown address", + CodeType_BaseUnknownPlugin: "Error (base) unknown plugin", + CodeType_BaseUnknownPubKey: "Error (base) unknown pubkey", + } +) + func (c CodeType) IsOK() bool { return c == CodeType_OK } + +// HumanCode transforms code into a more humane format, such as "Internal error" instead of 0. +func HumanCode(code CodeType) string { + s, ok := code2string[code] + if !ok { + return "Unknown code" + } + return s +} diff --git a/types/errors.go b/types/errors.go deleted file mode 100644 index f63d2470f..000000000 --- a/types/errors.go +++ /dev/null @@ -1,58 +0,0 @@ -package types - -var ( - OK = NewResultOK(nil, "") - - ErrInternalError = NewError(CodeType_InternalError, "Internal error") - ErrEncodingError = NewError(CodeType_EncodingError, "Encoding error") - ErrBadNonce = NewError(CodeType_BadNonce, "Error bad nonce") - ErrUnauthorized = NewError(CodeType_Unauthorized, "Unauthorized") - ErrInsufficientFunds = NewError(CodeType_InsufficientFunds, "Insufficient funds") - ErrUnknownRequest = NewError(CodeType_UnknownRequest, "Unknown request") - - ErrBaseDuplicateAddress = NewError(CodeType_BaseDuplicateAddress, "Error (base) duplicate address") - ErrBaseEncodingError = NewError(CodeType_BaseEncodingError, "Error (base) encoding error") - ErrBaseInsufficientFees = NewError(CodeType_BaseInsufficientFees, "Error (base) insufficient fees") - ErrBaseInsufficientFunds = NewError(CodeType_BaseInsufficientFunds, "Error (base) insufficient funds") - ErrBaseInsufficientGasPrice = NewError(CodeType_BaseInsufficientGasPrice, "Error (base) insufficient gas price") - ErrBaseInvalidInput = NewError(CodeType_BaseInvalidInput, "Error (base) invalid input") - ErrBaseInvalidOutput = NewError(CodeType_BaseInvalidOutput, "Error (base) invalid output") - ErrBaseInvalidPubKey = NewError(CodeType_BaseInvalidPubKey, "Error (base) invalid pubkey") - ErrBaseInvalidSequence = NewError(CodeType_BaseInvalidSequence, "Error (base) invalid sequence") - ErrBaseInvalidSignature = NewError(CodeType_BaseInvalidSignature, "Error (base) invalid signature") - ErrBaseUnknownAddress = NewError(CodeType_BaseUnknownAddress, "Error (base) unknown address") - ErrBaseUnknownPlugin = NewError(CodeType_BaseUnknownPlugin, "Error (base) unknown plugin") - ErrBaseUnknownPubKey = NewError(CodeType_BaseUnknownPubKey, "Error (base) unknown pubkey") - - code2string = map[CodeType]string{ - CodeType_InternalError: "Internal error", - CodeType_EncodingError: "Encoding error", - CodeType_BadNonce: "Error bad nonce", - CodeType_Unauthorized: "Unauthorized", - CodeType_InsufficientFunds: "Insufficient funds", - CodeType_UnknownRequest: "Unknown request", - - CodeType_BaseDuplicateAddress: "Error (base) duplicate address", - CodeType_BaseEncodingError: "Error (base) encoding error", - CodeType_BaseInsufficientFees: "Error (base) insufficient fees", - CodeType_BaseInsufficientFunds: "Error (base) insufficient funds", - CodeType_BaseInsufficientGasPrice: "Error (base) insufficient gas price", - CodeType_BaseInvalidInput: "Error (base) invalid input", - CodeType_BaseInvalidOutput: "Error (base) invalid output", - CodeType_BaseInvalidPubKey: "Error (base) invalid pubkey", - CodeType_BaseInvalidSequence: "Error (base) invalid sequence", - CodeType_BaseInvalidSignature: "Error (base) invalid signature", - CodeType_BaseUnknownAddress: "Error (base) unknown address", - CodeType_BaseUnknownPlugin: "Error (base) unknown plugin", - CodeType_BaseUnknownPubKey: "Error (base) unknown pubkey", - } -) - -// HumanCode transforms code into a more humane format, such as "Internal error" instead of 0. -func HumanCode(code CodeType) string { - s, ok := code2string[code] - if !ok { - return "Unknown code" - } - return s -} diff --git a/types/result.go b/types/result.go index e37f6f497..78cea710c 100644 --- a/types/result.go +++ b/types/result.go @@ -6,107 +6,6 @@ import ( "github.com/tendermint/go-wire/data" ) -// Result is a common result object for ABCI calls. -// CONTRACT: a zero Result is OK. -// DEPRECATED: prefer raw types instead. -type Result struct { - Code CodeType `json:"code"` - Data data.Bytes `json:"data"` - Log string `json:"log"` // Can be non-deterministic - Tags []*KVPair `json:"tags"` -} - -func NewResult(code CodeType, data []byte, log string) Result { - return Result{ - Code: code, - Data: data, - Log: log, - } -} - -func (res Result) IsOK() bool { - return res.Code == CodeType_OK -} - -func (res Result) IsErr() bool { - return res.Code != CodeType_OK -} - -func (res Result) IsSameCode(compare Result) bool { - return res.Code == compare.Code -} - -func (res Result) Error() string { - return fmt.Sprintf("ABCI{code:%v, data:%X, log:%v}", res.Code, res.Data, res.Log) -} - -func (res Result) String() string { - return fmt.Sprintf("ABCI{code:%v, data:%X, log:%v}", res.Code, res.Data, res.Log) -} - -func (res Result) PrependLog(log string) Result { - return Result{ - Code: res.Code, - Data: res.Data, - Log: log + ";" + res.Log, - } -} - -func (res Result) AppendLog(log string) Result { - return Result{ - Code: res.Code, - Data: res.Data, - Log: res.Log + ";" + log, - } -} - -func (res Result) SetLog(log string) Result { - return Result{ - Code: res.Code, - Data: res.Data, - Log: log, - } -} - -func (res Result) SetData(data []byte) Result { - return Result{ - Code: res.Code, - Data: data, - Log: res.Log, - } -} - -//---------------------------------------- - -// NOTE: if data == nil and log == "", same as zero Result. -func NewResultOK(data []byte, log string) Result { - return Result{ - Code: CodeType_OK, - Data: data, - Log: log, - } -} - -func NewError(code CodeType, log string) Result { - return Result{ - Code: code, - Log: log, - } -} - -//---------------------------------------- -// Convenience methods for turning the -// pb type into one using data.Bytes - -// Convert ResponseCheckTx to standard Result -func (r *ResponseCheckTx) Result() Result { - return Result{ - Code: r.Code, - Data: r.Data, - Log: r.Log, - } -} - // IsErr returns true if Code is something other than OK. func (r ResponseCheckTx) IsErr() bool { return r.Code != CodeType_OK @@ -117,16 +16,6 @@ func (r ResponseCheckTx) Error() string { return fmtError(r.Code, r.Log) } -// Convert ResponseDeliverTx to standard Result -func (r *ResponseDeliverTx) Result() Result { - return Result{ - Code: r.Code, - Data: r.Data, - Log: r.Log, - Tags: r.Tags, - } -} - // IsErr returns true if Code is something other than OK. func (r ResponseDeliverTx) IsErr() bool { return r.Code != CodeType_OK @@ -137,6 +26,27 @@ func (r ResponseDeliverTx) Error() string { return fmtError(r.Code, r.Log) } +// IsErr returns true if Code is something other than OK. +func (r ResponseCommit) IsErr() bool { + return r.Code != CodeType_OK +} + +// Error implements error interface by formatting response as string. +func (r ResponseCommit) Error() string { + return fmtError(r.Code, r.Log) +} + +func fmtError(code CodeType, log string) string { + codeAsStr, ok := code2string[code] + if ok { + return fmt.Sprintf("%s (%v): %s", codeAsStr, code, log) + } else { + return fmt.Sprintf("Unknown error (%v): %s", code, log) + } +} + +// ResultQuery is a wrapper around ResponseQuery using data.Bytes instead of +// raw byte slices. type ResultQuery struct { Code CodeType `json:"code"` Index int64 `json:"index"` @@ -147,6 +57,7 @@ type ResultQuery struct { Log string `json:"log"` } +// Result converts response query to ResultQuery. func (r *ResponseQuery) Result() *ResultQuery { return &ResultQuery{ Code: r.Code, @@ -158,22 +69,3 @@ func (r *ResponseQuery) Result() *ResultQuery { Log: r.Log, } } - -// IsErr returns true if Code is something other than OK. -func (r ResponseCommit) IsErr() bool { - return r.Code != CodeType_OK -} - -// Error implements error interface by formatting response as string. -func (r ResponseCommit) Error() string { - return fmtError(r.Code, r.Log) -} - -func fmtError(code CodeType, log string) string { - codeAsStr, ok := code2string[code] - if ok { - return fmt.Sprintf("%s (%v): %s", codeAsStr, code, log) - } else { - return fmt.Sprintf("Unknown error (%v): %s", code, log) - } -}