// realMain is the real main function for the utility. It is necessary to work
// around the fact that deferred functions do not run when os.Exit() is called.
func realMain() error {
// Load configuration and parse command line.
tcfg, _, err := loadConfig()
if err != nil {
return err
}
cfg = tcfg
// Setup logging.
backendLogger := btclog.NewDefaultBackendLogger()
defer backendLogger.Flush()
log = btclog.NewSubsystemLogger(backendLogger, "")
database.UseLogger(btclog.NewSubsystemLogger(backendLogger, "BCDB: "))
blockchain.UseLogger(btclog.NewSubsystemLogger(backendLogger, "CHAN: "))
indexers.UseLogger(btclog.NewSubsystemLogger(backendLogger, "INDX: "))
// Load the block database.
db, err := loadBlockDB()
if err != nil {
log.Errorf("Failed to load database: %v", err)
return err
}
defer db.Close()
fi, err := os.Open(cfg.InFile)
if err != nil {
log.Errorf("Failed to open file %v: %v", cfg.InFile, err)
return err
}
defer fi.Close()
// Create a block importer for the database and input file and start it.
// The done channel returned from start will contain an error if
// anything went wrong.
importer, err := newBlockImporter(db, fi)
if err != nil {
log.Errorf("Failed create block importer: %v", err)
return err
}
// Perform the import asynchronously. This allows blocks to be
// processed and read in parallel. The results channel returned from
// Import contains the statistics about the import including an error
// if something went wrong.
log.Info("Starting import")
resultsChan := importer.Import()
results := <-resultsChan
if results.err != nil {
log.Errorf("%v", results.err)
return results.err
}
log.Infof("Processed a total of %d blocks (%d imported, %d already "+
"known)", results.blocksProcessed, results.blocksImported,
results.blocksProcessed-results.blocksImported)
return nil
}
// realMain is the real main function for the utility. It is necessary to work
// around the fact that deferred functions do not run when os.Exit() is called.
func realMain() error {
// Setup logging.
backendLogger := btclog.NewDefaultBackendLogger()
defer backendLogger.Flush()
log = btclog.NewSubsystemLogger(backendLogger, "")
dbLog := btclog.NewSubsystemLogger(backendLogger, "BCDB: ")
dbLog.SetLevel(btclog.DebugLvl)
database.UseLogger(dbLog)
// Setup the parser options and commands.
appName := filepath.Base(os.Args[0])
appName = strings.TrimSuffix(appName, filepath.Ext(appName))
parserFlags := flags.Options(flags.HelpFlag | flags.PassDoubleDash)
parser := flags.NewNamedParser(appName, parserFlags)
parser.AddGroup("Global Options", "", cfg)
parser.AddCommand("insecureimport",
"Insecurely import bulk block data from bootstrap.dat",
"Insecurely import bulk block data from bootstrap.dat. "+
"WARNING: This is NOT secure because it does NOT "+
"verify chain rules. It is only provided for testing "+
"purposes.", &importCfg)
parser.AddCommand("loadheaders",
"Time how long to load headers for all blocks in the database",
"", &headersCfg)
parser.AddCommand("fetchblock",
"Fetch the specific block hash from the database", "",
&fetchBlockCfg)
parser.AddCommand("fetchblockregion",
"Fetch the specified block region from the database", "",
&blockRegionCfg)
// Parse command line and invoke the Execute function for the specified
// command.
if _, err := parser.Parse(); err != nil {
if e, ok := err.(*flags.Error); ok && e.Type == flags.ErrHelp {
parser.WriteHelp(os.Stderr)
} else {
log.Error(err)
}
return err
}
return nil
}
// useLogger updates the logger references for subsystemID to logger. Invalid
// subsystems are ignored.
func useLogger(subsystemID string, logger btclog.Logger) {
if _, ok := subsystemLoggers[subsystemID]; !ok {
return
}
subsystemLoggers[subsystemID] = logger
switch subsystemID {
case "ADXR":
adxrLog = logger
case "AMGR":
amgrLog = logger
addrmgr.UseLogger(logger)
case "CMGR":
cmgrLog = logger
connmgr.UseLogger(logger)
case "BCDB":
bcdbLog = logger
database.UseLogger(logger)
case "BMGR":
bmgrLog = logger
case "BTCD":
btcdLog = logger
case "CHAN":
chanLog = logger
blockchain.UseLogger(logger)
case "DISC":
discLog = logger
case "INDX":
indxLog = logger
indexers.UseLogger(logger)
case "MINR":
minrLog = logger
mining.UseLogger(logger)
cpuminer.UseLogger(logger)
case "PEER":
peerLog = logger
peer.UseLogger(logger)
case "RPCS":
rpcsLog = logger
case "SCRP":
scrpLog = logger
txscript.UseLogger(logger)
case "SRVR":
srvrLog = logger
case "TXMP":
txmpLog = logger
mempool.UseLogger(logger)
}
}