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.

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