/* See https://github.com/ethereum/tests/wiki/Blockchain-Tests-II
Whether a block is valid or not is a bit subtle, it's defined by presence of
blockHeader, transactions and uncleHeaders fields. If they are missing, the block is
invalid and we must verify that we do not accept it.
Since some tests mix valid and invalid blocks we need to check this for every block.
If a block is invalid it does not necessarily fail the test, if it's invalidness is
expected we are expected to ignore it and continue processing and then validate the
post state.
*/
func (t *BlockTest) TryBlocksInsert(chainManager *core.ChainManager) error {
// insert the test blocks, which will execute all transactions
for _, b := range t.Json.Blocks {
cb, err := mustConvertBlock(b)
if err != nil {
if b.BlockHeader == nil {
continue // OK - block is supposed to be invalid, continue with next block
} else {
return fmt.Errorf("Block RLP decoding failed when expected to succeed: %v", err)
}
}
// RLP decoding worked, try to insert into chain:
_, err = chainManager.InsertChain(types.Blocks{cb})
if err != nil {
if b.BlockHeader == nil {
continue // OK - block is supposed to be invalid, continue with next block
} else {
return fmt.Errorf("Block insertion into chain failed: %v", err)
}
}
if b.BlockHeader == nil {
return fmt.Errorf("Block insertion should have failed")
}
err = t.validateBlockHeader(b.BlockHeader, cb.Header())
if err != nil {
return fmt.Errorf("Block header validation failed: %v", err)
}
}
return nil
}
func hasAllBlocks(chain *core.ChainManager, bs []*types.Block) bool {
for _, b := range bs {
if !chain.HasBlock(b.Hash()) {
return false
}
}
return true
}
func ExportChain(chainmgr *core.ChainManager, fn string) error {
glog.Infoln("Exporting blockchain to", fn)
fh, err := os.OpenFile(fn, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, os.ModePerm)
if err != nil {
return err
}
defer fh.Close()
if err := chainmgr.Export(fh); err != nil {
return err
}
glog.Infoln("Exported blockchain to", fn)
return nil
}
func ExportAppendChain(chainmgr *core.ChainManager, fn string, first uint64, last uint64) error {
glog.Infoln("Exporting blockchain to", fn)
// TODO verify mode perms
fh, err := os.OpenFile(fn, os.O_CREATE|os.O_APPEND|os.O_WRONLY, os.ModePerm)
if err != nil {
return err
}
defer fh.Close()
if err := chainmgr.ExportN(fh, first, last); err != nil {
return err
}
glog.Infoln("Exported blockchain to", fn)
return nil
}
func (self *SQLDB) Refresh(chainManager *core.ChainManager) {
fromBlock, err := getLastBlockNumber(self.db)
if err != nil {
glog.V(logger.Error).Infoln("Error fetching last SQL block number", err)
return
}
toBlock := chainManager.CurrentBlock().Number().Uint64()
if fromBlock >= toBlock {
// sanity check TODO: redo the whole SQL DB in this case!
if fromBlock > toBlock {
glog.V(logger.Error).Infoln("SQL DB ahead of chain, recreating")
self.Close()
os.Remove(self.fn)
self.db, err = Init(self.fn)
if err != nil {
glog.V(logger.Error).Infoln("SQL DB Reinit:", err)
return
}
} else {
return
}
}
tx, err := self.db.Begin()
if err != nil {
glog.V(logger.Error).Infoln("SQL DB Begin:", err)
return
}
stmtBlock, err := tx.Prepare(`insert or replace into shift_blocks(number, hash) values(?, ?)`)
if err != nil {
glog.V(logger.Error).Infoln("SQL DB:", err)
return
}
defer stmtBlock.Close()
stmtTrans, err := tx.Prepare(`insert or replace into shift_transactions(hash, blocknumber, sender, receiver) values(?, ?, ?, ?)`)
if err != nil {
glog.V(logger.Error).Infoln("SQL DB:", err)
return
}
defer stmtTrans.Close()
glog.V(logger.Info).Infoln("SQL DB refreshing between blocks:", fromBlock, toBlock)
for i := fromBlock + 1; i <= toBlock; i++ {
block := chainManager.GetBlockByNumber(i)
// block
_, err = stmtBlock.Exec(i, block.Hash().Hex())
if err != nil {
glog.V(logger.Error).Infoln("SQL DB:", err)
tx.Rollback()
return
}
// transactions
for _, trans := range block.Transactions() {
sender, err := trans.From()
if err != nil {
glog.V(logger.Error).Infoln("SQL DB:", err)
continue
}
senderHex := sender.Hex()
receiver := trans.To()
receiverHex := ""
if receiver != nil {
receiverHex = receiver.Hex()
}
_, err = stmtTrans.Exec(trans.Hash().Hex(), i, senderHex, receiverHex)
if err != nil {
glog.V(logger.Error).Infoln("SQL DB:", err)
tx.Rollback()
return
}
}
}
tx.Commit()
}
func ImportChain(chain *core.ChainManager, fn string) error {
// Watch for Ctrl-C while the import is running.
// If a signal is received, the import will stop at the next batch.
interrupt := make(chan os.Signal, 1)
stop := make(chan struct{})
signal.Notify(interrupt, os.Interrupt)
defer signal.Stop(interrupt)
defer close(interrupt)
go func() {
if _, ok := <-interrupt; ok {
glog.Info("caught interrupt during import, will stop at next batch")
}
close(stop)
}()
checkInterrupt := func() bool {
select {
case <-stop:
return true
default:
return false
}
}
glog.Infoln("Importing blockchain", fn)
fh, err := os.Open(fn)
if err != nil {
return err
}
defer fh.Close()
stream := rlp.NewStream(fh, 0)
// Run actual the import.
blocks := make(types.Blocks, importBatchSize)
n := 0
for batch := 0; ; batch++ {
// Load a batch of RLP blocks.
if checkInterrupt() {
return fmt.Errorf("interrupted")
}
i := 0
for ; i < importBatchSize; i++ {
var b types.Block
if err := stream.Decode(&b); err == io.EOF {
break
} else if err != nil {
return fmt.Errorf("at block %d: %v", n, err)
}
// don't import first block
if b.NumberU64() == 0 {
i--
continue
}
blocks[i] = &b
n++
}
if i == 0 {
break
}
// Import the batch.
if checkInterrupt() {
return fmt.Errorf("interrupted")
}
if hasAllBlocks(chain, blocks[:i]) {
glog.Infof("skipping batch %d, all blocks present [%x / %x]",
batch, blocks[0].Hash().Bytes()[:4], blocks[i-1].Hash().Bytes()[:4])
continue
}
if _, err := chain.InsertChain(blocks[:i]); err != nil {
return fmt.Errorf("invalid block %d: %v", n, err)
}
}
return nil
}
