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.

281 lines
8.8 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, s State) {
  69. saveState(db, s, stateKey)
  70. }
  71. func saveState(db dbm.DB, s State, key []byte) {
  72. nextHeight := s.LastBlockHeight + 1
  73. saveValidatorsInfo(db, nextHeight, s.LastHeightValidatorsChanged, s.Validators)
  74. saveConsensusParamsInfo(db, nextHeight, s.LastHeightConsensusParamsChanged, s.ConsensusParams)
  75. db.SetSync(stateKey, s.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. valInfo = loadValidatorsInfo(db, valInfo.LastHeightChanged)
  147. if valInfo == 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. }
  152. return valInfo.ValidatorSet, nil
  153. }
  154. func loadValidatorsInfo(db dbm.DB, height int64) *ValidatorsInfo {
  155. buf := db.Get(calcValidatorsKey(height))
  156. if len(buf) == 0 {
  157. return nil
  158. }
  159. v := new(ValidatorsInfo)
  160. err := cdc.UnmarshalBinaryBare(buf, v)
  161. if err != nil {
  162. // DATA HAS BEEN CORRUPTED OR THE SPEC HAS CHANGED
  163. cmn.Exit(cmn.Fmt(`LoadValidators: Data has been corrupted or its spec has changed:
  164. %v\n`, err))
  165. }
  166. // TODO: ensure that buf is completely read.
  167. return v
  168. }
  169. // saveValidatorsInfo persists the validator set for the next block to disk.
  170. // It should be called from s.Save(), right before the state itself is persisted.
  171. // If the validator set did not change after processing the latest block,
  172. // only the last height for which the validators changed is persisted.
  173. func saveValidatorsInfo(db dbm.DB, nextHeight, changeHeight int64, valSet *types.ValidatorSet) {
  174. valInfo := &ValidatorsInfo{
  175. LastHeightChanged: changeHeight,
  176. }
  177. if changeHeight == nextHeight {
  178. valInfo.ValidatorSet = valSet
  179. }
  180. db.SetSync(calcValidatorsKey(nextHeight), valInfo.Bytes())
  181. }
  182. //-----------------------------------------------------------------------------
  183. // ConsensusParamsInfo represents the latest consensus params, or the last height it changed
  184. type ConsensusParamsInfo struct {
  185. ConsensusParams types.ConsensusParams
  186. LastHeightChanged int64
  187. }
  188. // Bytes serializes the ConsensusParamsInfo using go-amino.
  189. func (params ConsensusParamsInfo) Bytes() []byte {
  190. return cdc.MustMarshalBinaryBare(params)
  191. }
  192. // LoadConsensusParams loads the ConsensusParams for a given height.
  193. func LoadConsensusParams(db dbm.DB, height int64) (types.ConsensusParams, error) {
  194. empty := types.ConsensusParams{}
  195. paramsInfo := loadConsensusParamsInfo(db, height)
  196. if paramsInfo == nil {
  197. return empty, ErrNoConsensusParamsForHeight{height}
  198. }
  199. if paramsInfo.ConsensusParams == empty {
  200. paramsInfo = loadConsensusParamsInfo(db, paramsInfo.LastHeightChanged)
  201. if paramsInfo == nil {
  202. cmn.PanicSanity(fmt.Sprintf(`Couldn't find consensus params at height %d as
  203. last changed from height %d`, paramsInfo.LastHeightChanged, height))
  204. }
  205. }
  206. return paramsInfo.ConsensusParams, nil
  207. }
  208. func loadConsensusParamsInfo(db dbm.DB, height int64) *ConsensusParamsInfo {
  209. buf := db.Get(calcConsensusParamsKey(height))
  210. if len(buf) == 0 {
  211. return nil
  212. }
  213. paramsInfo := new(ConsensusParamsInfo)
  214. err := cdc.UnmarshalBinaryBare(buf, paramsInfo)
  215. if err != nil {
  216. // DATA HAS BEEN CORRUPTED OR THE SPEC HAS CHANGED
  217. cmn.Exit(cmn.Fmt(`LoadConsensusParams: Data has been corrupted or its spec has changed:
  218. %v\n`, err))
  219. }
  220. // TODO: ensure that buf is completely read.
  221. return paramsInfo
  222. }
  223. // saveConsensusParamsInfo persists the consensus params for the next block to disk.
  224. // It should be called from s.Save(), right before the state itself is persisted.
  225. // If the consensus params did not change after processing the latest block,
  226. // only the last height for which they changed is persisted.
  227. func saveConsensusParamsInfo(db dbm.DB, nextHeight, changeHeight int64, params types.ConsensusParams) {
  228. paramsInfo := &ConsensusParamsInfo{
  229. LastHeightChanged: changeHeight,
  230. }
  231. if changeHeight == nextHeight {
  232. paramsInfo.ConsensusParams = params
  233. }
  234. db.SetSync(calcConsensusParamsKey(nextHeight), paramsInfo.Bytes())
  235. }