func validateDBSignature(aBlock *common.AdminBlock, dchain *common.DChain) bool {
dbSigEntry := aBlock.GetDBSignature()
if dbSigEntry == nil {
if aBlock.Header.DBHeight == 0 {
return true
} else {
return false
}
} else {
dbSig := dbSigEntry.(*common.DBSignatureEntry)
if serverPubKey.String() != dbSig.PubKey.String() {
return false
} else {
// obtain the previous directory block
dblk := dchain.Blocks[aBlock.Header.DBHeight-1]
if dblk == nil {
return false
} else {
// validatet the signature
bHeader, _ := dblk.Header.MarshalBinary()
if !serverPubKey.Verify(bHeader, (*[64]byte)(dbSig.PrevDBSig)) {
procLog.Infof("No valid signature found in Admin Block = %s\n", spew.Sdump(aBlock))
return false
}
}
}
}
return true
}
// FetchAllABlocks gets all of the admin blocks
func (db *LevelDb) FetchAllABlocks() (aBlocks []common.AdminBlock, err error) {
db.dbLock.RLock()
defer db.dbLock.RUnlock()
var fromkey = []byte{byte(TBL_AB)} // Table Name (1 bytes) // Timestamp (8 bytes)
var tokey = []byte{byte(TBL_AB + 1)} // Table Name (1 bytes)
var iter iterator.Iterator
aBlockSlice := make([]common.AdminBlock, 0, 10)
iter = db.lDb.NewIterator(&util.Range{Start: fromkey, Limit: tokey}, db.ro)
for iter.Next() {
var aBlock common.AdminBlock
_, err := aBlock.UnmarshalBinaryData(iter.Value())
if err != nil {
return nil, err
}
//TODO: to be optimized??
_, err = aBlock.PartialHash()
if err != nil {
return nil, err
}
aBlockSlice = append(aBlockSlice, aBlock)
}
iter.Release()
err = iter.Error()
return aBlockSlice, nil
}
func exportABlock(block *common.AdminBlock) {
if block == nil || procLog.Level() < factomlog.Info {
return
}
data, err := block.MarshalBinary()
if err != nil {
panic(err)
}
strChainID := block.Header.AdminChainID.String()
if fileNotExists(dataStorePath + strChainID) {
err := os.MkdirAll(dataStorePath+strChainID, 0777)
if err == nil {
procLog.Info("Created directory " + dataStorePath + strChainID)
} else {
procLog.Error(err)
}
}
err = ioutil.WriteFile(fmt.Sprintf(dataStorePath+strChainID+"/store.%09d.block", block.Header.DBHeight), data, 0777)
if err != nil {
panic(err)
}
}
// ProcessABlockBatch inserts the AdminBlock
func (db *LevelDb) ProcessABlockBatch(block *common.AdminBlock) error {
if block != nil {
if db.lbatch == nil {
db.lbatch = new(leveldb.Batch)
}
defer db.lbatch.Reset()
binaryBlock, err := block.MarshalBinary()
if err != nil {
return err
}
abHash, err := block.PartialHash()
if err != nil {
return err
}
// Insert the binary factom block
var key []byte = []byte{byte(TBL_AB)}
key = append(key, abHash.Bytes()...)
db.lbatch.Put(key, binaryBlock)
// Insert the admin block number cross reference
key = []byte{byte(TBL_AB_NUM)}
key = append(key, block.Header.AdminChainID.Bytes()...)
bytes := make([]byte, 4)
binary.BigEndian.PutUint32(bytes, block.Header.DBHeight)
key = append(key, bytes...)
db.lbatch.Put(key, abHash.Bytes())
// Update the chain head reference
key = []byte{byte(TBL_CHAIN_HEAD)}
key = append(key, common.ADMIN_CHAINID...)
db.lbatch.Put(key, abHash.Bytes())
err = db.lDb.Write(db.lbatch, db.wo)
if err != nil {
log.Println("batch failed %v\n", err)
return err
}
}
return nil
}
func (db *LevelDb) ProcessABlockMultiBatch(block *common.AdminBlock) error {
if block == nil {
return nil
}
if db.lbatch == nil {
return fmt.Errorf("db.lbatch == nil")
}
binaryBlock, err := block.MarshalBinary()
if err != nil {
return err
}
abHash, err := block.PartialHash()
if err != nil {
return err
}
// Insert the binary factom block
var key = []byte{byte(TBL_AB)}
key = append(key, abHash.Bytes()...)
db.lbatch.Put(key, binaryBlock)
// Insert the admin block number cross reference
key = []byte{byte(TBL_AB_NUM)}
key = append(key, common.ADMIN_CHAINID...)
bytes := make([]byte, 4)
binary.BigEndian.PutUint32(bytes, block.Header.DBHeight)
key = append(key, bytes...)
db.lbatch.Put(key, abHash.Bytes())
// Update the chain head reference
key = []byte{byte(TBL_CHAIN_HEAD)}
key = append(key, common.ADMIN_CHAINID...)
db.lbatch.Put(key, abHash.Bytes())
return nil
}
func ParseAdminBlock(chainID, hash string, rawBlock []byte, blockTime string) (*Block, error) {
answer := new(Block)
aBlock := new(common.AdminBlock)
_, err := aBlock.UnmarshalBinaryData(rawBlock)
if err != nil {
return nil, err
}
answer.ChainID = chainID
fullHash, err := aBlock.LedgerKeyMR()
if err != nil {
return nil, err
}
answer.FullHash = fullHash.String()
partialHash, err := aBlock.PartialHash()
if err != nil {
return nil, err
}
answer.PartialHash = partialHash.String()
answer.EntryCount = len(aBlock.ABEntries)
answer.PrevBlockHash = fmt.Sprintf("%x", aBlock.Header.PrevLedgerKeyMR.GetBytes())
answer.EntryList = make([]*Entry, answer.EntryCount)
answer.BinaryString = fmt.Sprintf("%x", rawBlock)
for i, v := range aBlock.ABEntries {
marshalled, err := v.MarshalBinary()
if err != nil {
return nil, err
}
entry := new(Entry)
entry.BinaryString = fmt.Sprintf("%x", marshalled)
entry.Hash = v.Hash().String()
entry.Timestamp = blockTime
entry.ChainID = chainID
entry.JSONString, err = v.JSONString()
if err != nil {
return nil, err
}
entry.SpewString = v.Spew()
entry.ShortEntry = v.Interpret()
answer.EntryList[i] = entry
}
answer.JSONString, err = aBlock.JSONString()
if err != nil {
return nil, err
}
answer.SpewString = aBlock.Spew()
answer.BinaryString = fmt.Sprintf("%x", rawBlock)
answer.IsAdminBlock = true
return answer, nil
}