func ExportDChain(db interfaces.DBOverlay) error {
fmt.Printf("ExportDChain\n")
// get all ecBlocks from db
dBlocks, err := db.FetchAllDBlocks()
if err != nil {
return err
}
sort.Sort(util.ByDBlockIDAccending(dBlocks))
for _, block := range dBlocks {
err = ExportBlock(block.(interfaces.DatabaseBatchable))
if err != nil {
return err
}
}
return nil
}
func (be *BlockExtractor) ExportDChain(db interfaces.DBOverlay) error {
fmt.Printf("ExportDChain\n")
// get all ecBlocks from db
dBlocks, err := db.FetchAllDBlocks()
if err != nil {
return err
}
sort.Sort(util.ByDBlockIDAccending(dBlocks))
for _, block := range dBlocks {
//Making sure Hash and KeyMR are set for the JSON export
block.GetFullHash()
block.GetKeyMR()
err = be.ExportBlock(block.(interfaces.DatabaseBatchable))
if err != nil {
return err
}
}
return nil
}
func CopyDB(dbase1, dbase2 interfaces.DBOverlay) {
processing := ""
defer func() {
if r := recover(); r != nil {
err := fmt.Errorf("Error processing: %v", processing)
panic(err)
}
}()
dBlocks, err := dbase1.FetchAllDBlocks()
if err != nil {
panic(err)
}
prevECHash := primitives.NewZeroHash()
for _, dBlock := range dBlocks {
dbase2.StartMultiBatch()
err := dbase2.ProcessDBlockMultiBatch(dBlock)
if err != nil {
panic(err)
}
for _, dbEntry := range dBlock.GetDBEntries() {
switch dbEntry.GetChainID().String() {
case "000000000000000000000000000000000000000000000000000000000000000a":
aBlock, err := dbase1.FetchABlock(dbEntry.GetKeyMR())
if err != nil {
panic(err)
}
err = dbase2.ProcessABlockMultiBatch(aBlock)
if err != nil {
panic(err)
}
break
case "000000000000000000000000000000000000000000000000000000000000000c":
ecBlock, err := dbase1.FetchECBlock(dbEntry.GetKeyMR())
if err != nil {
panic(err)
}
if ecBlock.GetHeader().GetPrevHeaderHash().IsSameAs(prevECHash) == false {
prev, err := dbase1.FetchECBlock(ecBlock.GetHeader().GetPrevHeaderHash())
if err != nil {
panic(err)
}
err = dbase2.ProcessECBlockMultiBatch(prev, true)
if err != nil {
panic(err)
}
}
err = dbase2.ProcessECBlockMultiBatch(ecBlock, true)
if err != nil {
panic(err)
}
prevECHash = dbEntry.GetKeyMR()
break
case "000000000000000000000000000000000000000000000000000000000000000f":
fBlock, err := dbase1.FetchFBlock(dbEntry.GetKeyMR())
if err != nil {
panic(err)
}
err = dbase2.ProcessFBlockMultiBatch(fBlock)
if err != nil {
panic(err)
}
break
default:
processing = fmt.Sprintf("%v - %v - %v", dBlock.GetKeyMR().String(), dbEntry.GetChainID().String(), dbEntry.GetKeyMR().String())
eBlock, err := dbase1.FetchEBlock(dbEntry.GetKeyMR())
if err != nil {
panic(err)
}
err = dbase2.ProcessEBlockMultiBatch(eBlock, true)
if err != nil {
panic(err)
}
for _, h := range eBlock.GetEntryHashes() {
entry, err := dbase1.FetchEntry(h)
if err != nil {
panic(err)
}
err = dbase2.InsertEntryMultiBatch(entry)
if err != nil {
panic(err)
}
}
break
}
}
if err := dbase2.ExecuteMultiBatch(); err != nil {
panic(err)
}
if dBlock.GetDatabaseHeight()%1000 == 0 {
fmt.Printf("Processed block #%v\n", dBlock.GetDatabaseHeight())
}
}
}