mirror of
https://github.com/kaspanet/kaspad.git
synced 2025-03-30 15:08:33 +00:00
7e81757e2f
* [NOD-1161] Name goroutines and log them by the name * [NOD-1161] Fix some goroutine names
89 lines
2.2 KiB
Go
89 lines
2.2 KiB
Go
// Copyright (c) 2013-2016 The btcsuite developers
|
|
// Use of this source code is governed by an ISC
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package main
|
|
|
|
import (
|
|
"os"
|
|
"runtime"
|
|
|
|
"github.com/kaspanet/kaspad/limits"
|
|
"github.com/kaspanet/kaspad/logs"
|
|
"github.com/kaspanet/kaspad/util/panics"
|
|
)
|
|
|
|
const (
|
|
// blockDBNamePrefix is the prefix for the kaspad block database.
|
|
blockDBNamePrefix = "blocks"
|
|
)
|
|
|
|
var (
|
|
cfg *ConfigFlags
|
|
log *logs.Logger
|
|
spawn func(string, func())
|
|
)
|
|
|
|
// 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 := logs.NewBackend()
|
|
defer os.Stdout.Sync()
|
|
log = backendLogger.Logger("MAIN")
|
|
spawn = panics.GoroutineWrapperFunc(log)
|
|
|
|
fi, err := os.Open(cfg.InFile)
|
|
if err != nil {
|
|
log.Errorf("Failed to open file %s: %s", 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(fi)
|
|
if err != nil {
|
|
log.Errorf("Failed create block importer: %s", 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("%s", 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
|
|
}
|
|
|
|
func main() {
|
|
// Use all processor cores and up some limits.
|
|
runtime.GOMAXPROCS(runtime.NumCPU())
|
|
if err := limits.SetLimits(); err != nil {
|
|
os.Exit(1)
|
|
}
|
|
|
|
// Work around defer not working after os.Exit()
|
|
if err := realMain(); err != nil {
|
|
os.Exit(1)
|
|
}
|
|
}
|