You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

282 lines
8.9 KiB

7 years ago
7 years ago
7 years ago
7 years ago
7 years ago
7 years ago
7 years ago
7 years ago
7 years ago
7 years ago
7 years ago
7 years ago
7 years ago
7 years ago
7 years ago
7 years ago
7 years ago
7 years ago
7 years ago
7 years ago
  1. package state
  2. import (
  3. "fmt"
  4. abci "github.com/tendermint/abci/types"
  5. "github.com/tendermint/tendermint/types"
  6. cmn "github.com/tendermint/tmlibs/common"
  7. dbm "github.com/tendermint/tmlibs/db"
  8. )
  9. //------------------------------------------------------------------------
  10. func calcValidatorsKey(height int64) []byte {
  11. return []byte(cmn.Fmt("validatorsKey:%v", height))
  12. }
  13. func calcConsensusParamsKey(height int64) []byte {
  14. return []byte(cmn.Fmt("consensusParamsKey:%v", height))
  15. }
  16. func calcABCIResponsesKey(height int64) []byte {
  17. return []byte(cmn.Fmt("abciResponsesKey:%v", height))
  18. }
  19. // LoadStateFromDBOrGenesisFile loads the most recent state from the database,
  20. // or creates a new one from the given genesisFilePath and persists the result
  21. // to the database.
  22. func LoadStateFromDBOrGenesisFile(stateDB dbm.DB, genesisFilePath string) (State, error) {
  23. state := LoadState(stateDB)
  24. if state.IsEmpty() {
  25. var err error
  26. state, err = MakeGenesisStateFromFile(genesisFilePath)
  27. if err != nil {
  28. return state, err
  29. }
  30. SaveState(stateDB, state)
  31. }
  32. return state, nil
  33. }
  34. // LoadStateFromDBOrGenesisDoc loads the most recent state from the database,
  35. // or creates a new one from the given genesisDoc and persists the result
  36. // to the database.
  37. func LoadStateFromDBOrGenesisDoc(stateDB dbm.DB, genesisDoc *types.GenesisDoc) (State, error) {
  38. state := LoadState(stateDB)
  39. if state.IsEmpty() {
  40. var err error
  41. state, err = MakeGenesisState(genesisDoc)
  42. if err != nil {
  43. return state, err
  44. }
  45. SaveState(stateDB, state)
  46. }
  47. return state, nil
  48. }
  49. // LoadState loads the State from the database.
  50. func LoadState(db dbm.DB) State {
  51. return loadState(db, stateKey)
  52. }
  53. func loadState(db dbm.DB, key []byte) (state State) {
  54. buf := db.Get(key)
  55. if len(buf) == 0 {
  56. return state
  57. }
  58. err := cdc.UnmarshalBinaryBare(buf, &state)
  59. if err != nil {
  60. // DATA HAS BEEN CORRUPTED OR THE SPEC HAS CHANGED
  61. cmn.Exit(cmn.Fmt(`LoadState: Data has been corrupted or its spec has changed:
  62. %v\n`, err))
  63. }
  64. // TODO: ensure that buf is completely read.
  65. return state
  66. }
  67. // SaveState persists the State, the ValidatorsInfo, and the ConsensusParamsInfo to the database.
  68. func SaveState(db dbm.DB, state State) {
  69. saveState(db, state, stateKey)
  70. }
  71. func saveState(db dbm.DB, state State, key []byte) {
  72. nextHeight := state.LastBlockHeight + 1
  73. saveValidatorsInfo(db, nextHeight, state.LastHeightValidatorsChanged, state.Validators)
  74. saveConsensusParamsInfo(db, nextHeight, state.LastHeightConsensusParamsChanged, state.ConsensusParams)
  75. db.SetSync(stateKey, state.Bytes())
  76. }
  77. //------------------------------------------------------------------------
  78. // ABCIResponses retains the responses
  79. // of the various ABCI calls during block processing.
  80. // It is persisted to disk for each height before calling Commit.
  81. type ABCIResponses struct {
  82. DeliverTx []*abci.ResponseDeliverTx
  83. EndBlock *abci.ResponseEndBlock
  84. }
  85. // NewABCIResponses returns a new ABCIResponses
  86. func NewABCIResponses(block *types.Block) *ABCIResponses {
  87. resDeliverTxs := make([]*abci.ResponseDeliverTx, block.NumTxs)
  88. if block.NumTxs == 0 {
  89. // This makes Amino encoding/decoding consistent.
  90. resDeliverTxs = nil
  91. }
  92. return &ABCIResponses{
  93. DeliverTx: resDeliverTxs,
  94. }
  95. }
  96. // Bytes serializes the ABCIResponse using go-amino.
  97. func (arz *ABCIResponses) Bytes() []byte {
  98. return cdc.MustMarshalBinaryBare(arz)
  99. }
  100. func (arz *ABCIResponses) ResultsHash() []byte {
  101. results := types.NewResults(arz.DeliverTx)
  102. return results.Hash()
  103. }
  104. // LoadABCIResponses loads the ABCIResponses for the given height from the database.
  105. // This is useful for recovering from crashes where we called app.Commit and before we called
  106. // s.Save(). It can also be used to produce Merkle proofs of the result of txs.
  107. func LoadABCIResponses(db dbm.DB, height int64) (*ABCIResponses, error) {
  108. buf := db.Get(calcABCIResponsesKey(height))
  109. if len(buf) == 0 {
  110. return nil, ErrNoABCIResponsesForHeight{height}
  111. }
  112. abciResponses := new(ABCIResponses)
  113. err := cdc.UnmarshalBinaryBare(buf, abciResponses)
  114. if err != nil {
  115. // DATA HAS BEEN CORRUPTED OR THE SPEC HAS CHANGED
  116. cmn.Exit(cmn.Fmt(`LoadABCIResponses: Data has been corrupted or its spec has
  117. changed: %v\n`, err))
  118. }
  119. // TODO: ensure that buf is completely read.
  120. return abciResponses, nil
  121. }
  122. // SaveABCIResponses persists the ABCIResponses to the database.
  123. // This is useful in case we crash after app.Commit and before s.Save().
  124. // Responses are indexed by height so they can also be loaded later to produce Merkle proofs.
  125. func saveABCIResponses(db dbm.DB, height int64, abciResponses *ABCIResponses) {
  126. db.SetSync(calcABCIResponsesKey(height), abciResponses.Bytes())
  127. }
  128. //-----------------------------------------------------------------------------
  129. // ValidatorsInfo represents the latest validator set, or the last height it changed
  130. type ValidatorsInfo struct {
  131. ValidatorSet *types.ValidatorSet
  132. LastHeightChanged int64
  133. }
  134. // Bytes serializes the ValidatorsInfo using go-amino.
  135. func (valInfo *ValidatorsInfo) Bytes() []byte {
  136. return cdc.MustMarshalBinaryBare(valInfo)
  137. }
  138. // LoadValidators loads the ValidatorSet for a given height.
  139. // Returns ErrNoValSetForHeight if the validator set can't be found for this height.
  140. func LoadValidators(db dbm.DB, height int64) (*types.ValidatorSet, error) {
  141. valInfo := loadValidatorsInfo(db, height)
  142. if valInfo == nil {
  143. return nil, ErrNoValSetForHeight{height}
  144. }
  145. if valInfo.ValidatorSet == nil {
  146. valInfo2 := loadValidatorsInfo(db, valInfo.LastHeightChanged)
  147. if valInfo2 == nil {
  148. cmn.PanicSanity(fmt.Sprintf(`Couldn't find validators at height %d as
  149. last changed from height %d`, valInfo.LastHeightChanged, height))
  150. }
  151. valInfo = valInfo2
  152. }
  153. return valInfo.ValidatorSet, nil
  154. }
  155. func loadValidatorsInfo(db dbm.DB, height int64) *ValidatorsInfo {
  156. buf := db.Get(calcValidatorsKey(height))
  157. if len(buf) == 0 {
  158. return nil
  159. }
  160. v := new(ValidatorsInfo)
  161. err := cdc.UnmarshalBinaryBare(buf, v)
  162. if err != nil {
  163. // DATA HAS BEEN CORRUPTED OR THE SPEC HAS CHANGED
  164. cmn.Exit(cmn.Fmt(`LoadValidators: Data has been corrupted or its spec has changed:
  165. %v\n`, err))
  166. }
  167. // TODO: ensure that buf is completely read.
  168. return v
  169. }
  170. // saveValidatorsInfo persists the validator set for the next block to disk.
  171. // It should be called from s.Save(), right before the state itself is persisted.
  172. // If the validator set did not change after processing the latest block,
  173. // only the last height for which the validators changed is persisted.
  174. func saveValidatorsInfo(db dbm.DB, nextHeight, changeHeight int64, valSet *types.ValidatorSet) {
  175. valInfo := &ValidatorsInfo{
  176. LastHeightChanged: changeHeight,
  177. }
  178. if changeHeight == nextHeight {
  179. valInfo.ValidatorSet = valSet
  180. }
  181. db.SetSync(calcValidatorsKey(nextHeight), valInfo.Bytes())
  182. }
  183. //-----------------------------------------------------------------------------
  184. // ConsensusParamsInfo represents the latest consensus params, or the last height it changed
  185. type ConsensusParamsInfo struct {
  186. ConsensusParams types.ConsensusParams
  187. LastHeightChanged int64
  188. }
  189. // Bytes serializes the ConsensusParamsInfo using go-amino.
  190. func (params ConsensusParamsInfo) Bytes() []byte {
  191. return cdc.MustMarshalBinaryBare(params)
  192. }
  193. // LoadConsensusParams loads the ConsensusParams for a given height.
  194. func LoadConsensusParams(db dbm.DB, height int64) (types.ConsensusParams, error) {
  195. empty := types.ConsensusParams{}
  196. paramsInfo := loadConsensusParamsInfo(db, height)
  197. if paramsInfo == nil {
  198. return empty, ErrNoConsensusParamsForHeight{height}
  199. }
  200. if paramsInfo.ConsensusParams == empty {
  201. paramsInfo = loadConsensusParamsInfo(db, paramsInfo.LastHeightChanged)
  202. if paramsInfo == nil {
  203. cmn.PanicSanity(fmt.Sprintf(`Couldn't find consensus params at height %d as
  204. last changed from height %d`, paramsInfo.LastHeightChanged, height))
  205. }
  206. }
  207. return paramsInfo.ConsensusParams, nil
  208. }
  209. func loadConsensusParamsInfo(db dbm.DB, height int64) *ConsensusParamsInfo {
  210. buf := db.Get(calcConsensusParamsKey(height))
  211. if len(buf) == 0 {
  212. return nil
  213. }
  214. paramsInfo := new(ConsensusParamsInfo)
  215. err := cdc.UnmarshalBinaryBare(buf, paramsInfo)
  216. if err != nil {
  217. // DATA HAS BEEN CORRUPTED OR THE SPEC HAS CHANGED
  218. cmn.Exit(cmn.Fmt(`LoadConsensusParams: Data has been corrupted or its spec has changed:
  219. %v\n`, err))
  220. }
  221. // TODO: ensure that buf is completely read.
  222. return paramsInfo
  223. }
  224. // saveConsensusParamsInfo persists the consensus params for the next block to disk.
  225. // It should be called from s.Save(), right before the state itself is persisted.
  226. // If the consensus params did not change after processing the latest block,
  227. // only the last height for which they changed is persisted.
  228. func saveConsensusParamsInfo(db dbm.DB, nextHeight, changeHeight int64, params types.ConsensusParams) {
  229. paramsInfo := &ConsensusParamsInfo{
  230. LastHeightChanged: changeHeight,
  231. }
  232. if changeHeight == nextHeight {
  233. paramsInfo.ConsensusParams = params
  234. }
  235. db.SetSync(calcConsensusParamsKey(nextHeight), paramsInfo.Bytes())
  236. }