Ejemplo n.º 1
0
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
}
Ejemplo n.º 2
0
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
}
Ejemplo n.º 3
0
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())
		}
	}
}