package blocks import ( "bytes" "encoding/binary" "encoding/json" "io" . "github.com/tendermint/tendermint/binary" . "github.com/tendermint/tendermint/common" db_ "github.com/tendermint/tendermint/db" ) //----------------------------------------------------------------------------- /* Simple low level store for blocks, which is actually stored as separte parts (wire format). */ type BlockStore struct { height uint32 db db_.DB } func NewBlockStore(db db_.DB) *BlockStore { bsjson := LoadBlockStoreJSON(db) return &BlockStore{ height: bsjson.Height, db: db, } } // Height() returns the last known contiguous block height. func (bs *BlockStore) Height() uint32 { return bs.height } func (bs *BlockStore) GetReader(key []byte) io.Reader { bytez := bs.db.Get(key) if bytez == nil { return nil } return bytes.NewReader(bytez) } func (bs *BlockStore) LoadBlock(height uint32) *Block { var n int64 var err error meta := ReadBlockMeta(bs.GetReader(calcBlockMetaKey(height)), &n, &err) if err != nil { Panicf("Error reading block meta: %v", err) } bytez := []byte{} for i := uint16(0); i < meta.Parts.Total; i++ { part := bs.LoadBlockPart(height, i) bytez = append(bytez, part.Bytes...) } block := ReadBlock(bytes.NewReader(bytez), &n, &err) if err != nil { Panicf("Error reading block: %v", err) } return block } func (bs *BlockStore) LoadBlockPart(height uint32, index uint16) *Part { var n int64 var err error part := ReadPart(bs.GetReader(calcBlockPartKey(height, index)), &n, &err) if err != nil { Panicf("Error reading block part: %v", err) } return part } func (bs *BlockStore) LoadBlockMeta(height uint32) *BlockMeta { var n int64 var err error meta := ReadBlockMeta(bs.GetReader(calcBlockMetaKey(height)), &n, &err) if err != nil { Panicf("Error reading block meta: %v", err) } return meta } func (bs *BlockStore) LoadBlockValidation(height uint32) *Validation { var n int64 var err error validation := ReadValidation(bs.GetReader(calcBlockValidationKey(height)), &n, &err) if err != nil { Panicf("Error reading validation: %v", err) } return validation } func (bs *BlockStore) SaveBlock(block *Block, blockParts *PartSet) { height := block.Height if height != bs.height+1 { Panicf("BlockStore can only save contiguous blocks. Wanted %v, got %v", bs.height+1, height) } if !blockParts.IsComplete() { Panicf("BlockStore can only save complete block part sets") } meta := &BlockMeta{ Hash: block.Hash(), Parts: blockParts.Header(), Header: block.Header, } // Save block meta metaBytes := BinaryBytes(meta) bs.db.Set(calcBlockMetaKey(height), metaBytes) // Save block parts for i := uint16(0); i < blockParts.Total(); i++ { bs.saveBlockPart(height, i, blockParts.GetPart(i)) } // Save block validation (duplicate and separate) validationBytes := BinaryBytes(block.Validation) bs.db.Set(calcBlockValidationKey(height), validationBytes) // Save new BlockStoreJSON descriptor BlockStoreJSON{Height: height}.Save(bs.db) } func (bs *BlockStore) saveBlockPart(height uint32, index uint16, part *Part) { if height != bs.height+1 { Panicf("BlockStore can only save contiguous blocks. Wanted %v, got %v", bs.height+1, height) } partBytes := BinaryBytes(part) bs.db.Set(calcBlockPartKey(height, index), partBytes) } //----------------------------------------------------------------------------- type BlockMeta struct { Hash []byte // The BlockHash Parts PartSetHeader // The PartSetHeader, for transfer Header *Header // The block's Header } func ReadBlockMeta(r io.Reader, n *int64, err *error) *BlockMeta { return &BlockMeta{ Hash: ReadByteSlice(r, n, err), Parts: ReadPartSetHeader(r, n, err), Header: ReadHeader(r, n, err), } } func (bm *BlockMeta) WriteTo(w io.Writer) (n int64, err error) { WriteByteSlice(w, bm.Hash, &n, &err) WriteBinary(w, bm.Parts, &n, &err) WriteBinary(w, bm.Header, &n, &err) return } //----------------------------------------------------------------------------- func calcBlockMetaKey(height uint32) []byte { buf := [5]byte{'H'} binary.BigEndian.PutUint32(buf[1:5], height) return buf[:] } func calcBlockPartKey(height uint32, partIndex uint16) []byte { buf := [7]byte{'P'} binary.BigEndian.PutUint32(buf[1:5], height) binary.BigEndian.PutUint16(buf[5:7], partIndex) return buf[:] } func calcBlockValidationKey(height uint32) []byte { buf := [5]byte{'V'} binary.BigEndian.PutUint32(buf[1:5], height) return buf[:] } //----------------------------------------------------------------------------- var blockStoreKey = []byte("blockStore") type BlockStoreJSON struct { Height uint32 } func (bsj BlockStoreJSON) Save(db db_.DB) { bytes, err := json.Marshal(bsj) if err != nil { Panicf("Could not marshal state bytes: %v", err) } db.Set(blockStoreKey, bytes) } func LoadBlockStoreJSON(db db_.DB) BlockStoreJSON { bytes := db.Get(blockStoreKey) if bytes == nil { return BlockStoreJSON{ Height: 0, } } bsj := BlockStoreJSON{} err := json.Unmarshal(bytes, &bsj) if err != nil { Panicf("Could not unmarshal bytes: %X", bytes) } return bsj }