示例#1
0
// 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 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
}
示例#3
0
// 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
}
示例#4
0
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
}