Function importChain

cmd/cpchain/cmd_chain.go:245–335

(ctx *cli.Context)

}

func importChain(ctx *cli.Context) error {
	if len(ctx.Args()) != 1 {
		log.Fatalf("This command requires a single argument for the imported file")
	}

	log.Info("Begin import")
	cfg, node := newConfigNode(ctx)

	primitive_register.RegisterPrimitiveContracts()
	chain, chainDb := commons.OpenChain(ctx, node, &cfg.Cpc)
	defer chainDb.Close()

	// Start periodically gathering memory profiles
	var peakMemAlloc, peakMemSys uint64
	go func() {
		stats := new(runtime.MemStats)
		for {
			runtime.ReadMemStats(stats)
			if atomic.LoadUint64(&peakMemAlloc) < stats.Alloc {
				atomic.StoreUint64(&peakMemAlloc, stats.Alloc)
			}
			if atomic.LoadUint64(&peakMemSys) < stats.Sys {
				atomic.StoreUint64(&peakMemSys, stats.Sys)
			}
			time.Sleep(5 * time.Second)
		}
	}()
	// Import the chain
	start := time.Now()

	if err := commons.ImportChain(chain, ctx.Args().First()); err != nil {
		log.Error("Import error", "err", err)
	}
	// flush the caches
	chain.Stop()

	fmt.Printf("Import done in %v.\n\n", time.Since(start))

	// Output pre-compaction stats mostly to see the import trashing
	db := chainDb.(*database.LDBDatabase)

	stats, err := db.LDB().GetProperty("leveldb.stats")
	if err != nil {
		log.Fatalf("Failed to read database stats: %v", err)
	}
	fmt.Println(stats)

	ioStats, err := db.LDB().GetProperty("leveldb.iostats")
	if err != nil {
		log.Fatalf("Failed to read database iostats: %v", err)
	}
	fmt.Println(ioStats)

	fmt.Printf("Trie cache misses:  %d\n", trie.CacheMisses())
	fmt.Printf("Trie cache unloads: %d\n\n", trie.CacheUnloads())

	// Print the memory statistics used by the importing
	mem := new(runtime.MemStats)