func main() {
fmt.Println("Gocoin blockchain downloader version", lib.Version)
parse_command_line()
setup_runtime_vars()
if len(GocoinHomeDir) > 0 && GocoinHomeDir[len(GocoinHomeDir)-1] != os.PathSeparator {
GocoinHomeDir += string(os.PathSeparator)
}
if Testnet {
GocoinHomeDir += "tstnet" + string(os.PathSeparator)
Magic = [4]byte{0x0B, 0x11, 0x09, 0x07}
GenesisBlock = btc.NewUint256FromString("000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943")
fmt.Println("Using testnet3")
} else {
GocoinHomeDir += "btcnet" + string(os.PathSeparator)
}
fmt.Println("GocoinHomeDir:", GocoinHomeDir)
sys.LockDatabaseDir(GocoinHomeDir)
defer sys.UnlockDatabaseDir()
peersdb.Testnet = Testnet
peersdb.InitPeers(GocoinHomeDir)
StartTime = time.Now()
if open_blockchain() {
fmt.Printf("Blockchain opening aborted\n")
return
}
fmt.Println("Blockchain open in", time.Now().Sub(StartTime))
go do_usif()
download_headers()
if GlobalExit() {
TheBlockChain.Close()
return
}
var HighestTrustedBlock *btc.Uint256
if LastTrustedBlock == "all" {
HighestTrustedBlock = TheBlockChain.BlockTreeEnd.BlockHash
fmt.Println("Assume all blocks trusted")
} else if LastTrustedBlock == "auto" {
if LastBlockHeight > 6 {
use := LastBlockHeight - 6
ha := BlocksToGet[use]
HighestTrustedBlock = btc.NewUint256(ha[:])
fmt.Println("Assume last trusted block as", HighestTrustedBlock.String(), "at", use)
} else {
fmt.Println("-t=auto ignored since LastBlockHeight is only", LastBlockHeight)
}
} else if LastTrustedBlock != "" {
HighestTrustedBlock = btc.NewUint256FromString(LastTrustedBlock)
}
if HighestTrustedBlock != nil {
for k, h := range BlocksToGet {
if bytes.Equal(h[:], HighestTrustedBlock.Hash[:]) {
TrustUpTo = k
break
}
}
} else {
fmt.Println("WARNING: The trusted block not found (it will be very slow).")
}
for n := TheBlockChain.BlockTreeEnd; n != nil && n.Height > TheBlockChain.BlockTreeEnd.Height-BSLEN; n = n.Parent {
blocksize_update(int(n.BlockSize))
}
fmt.Println("Downloading blocks - BlocksToGet:", len(BlocksToGet), " avg_size:", avg_block_size())
usif_prompt()
StartTime = time.Now()
get_blocks()
fmt.Println("Up to block", TheBlockChain.BlockTreeEnd.Height, "in", time.Now().Sub(StartTime).String())
close_all_connections()
peersdb.ClosePeerDB()
StartTime = time.Now()
fmt.Print("All blocks done - defrag unspent")
qdb.SetDefragPercent(100)
for {
if !TheBlockChain.Unspent.Idle() {
break
}
fmt.Print(".")
}
fmt.Println("\nDefrag unspent done in", time.Now().Sub(StartTime).String())
TheBlockChain.Close()
return
}
func main() {
var ptr *byte
if unsafe.Sizeof(ptr) < 8 {
fmt.Println("WARNING: Gocoin client shall be build for 64-bit arch. It will likely crash now.")
}
fmt.Println("Gocoin client version", lib.Version)
runtime.GOMAXPROCS(runtime.NumCPU()) // It seems that Go does not do it by default
// Disable Ctrl+C
signal.Notify(killchan, os.Interrupt, os.Kill)
defer func() {
if r := recover(); r != nil {
err, ok := r.(error)
if !ok {
err = fmt.Errorf("pkg: %v", r)
}
fmt.Println("main panic recovered:", err.Error())
fmt.Println(string(debug.Stack()))
network.NetCloseAll()
common.CloseBlockChain()
peersdb.ClosePeerDB()
sys.UnlockDatabaseDir()
os.Exit(1)
}
}()
common.InitConfig()
host_init() // This will create the DB lock file and keep it open
peersTick := time.Tick(5 * time.Minute)
txPoolTick := time.Tick(time.Minute)
netTick := time.Tick(time.Second)
peersdb.Testnet = common.Testnet
peersdb.ConnectOnly = common.CFG.ConnectOnly
peersdb.Services = common.Services
peersdb.InitPeers(common.GocoinHomeDir)
common.Last.Block = common.BlockChain.BlockTreeEnd
common.Last.Time = time.Unix(int64(common.Last.Block.Timestamp()), 0)
if common.Last.Time.After(time.Now()) {
common.Last.Time = time.Now()
}
for k, v := range common.BlockChain.BlockIndex {
network.ReceivedBlocks[k] = &network.OneReceivedBlock{Time: time.Unix(int64(v.Timestamp()), 0)}
}
if common.CFG.TextUI.Enabled {
go textui.MainThread()
}
if common.CFG.WebUI.Interface != "" {
fmt.Println("Starting WebUI at", common.CFG.WebUI.Interface, "...")
go webui.ServerThread(common.CFG.WebUI.Interface)
}
for !usif.Exit_now {
common.CountSafe("MainThreadLoops")
for retryCachedBlocks {
retryCachedBlocks = retry_cached_blocks()
// We have done one per loop - now do something else if pending...
if len(network.NetBlocks) > 0 || len(usif.UiChannel) > 0 {
break
}
}
common.Busy("")
select {
case s := <-killchan:
fmt.Println("Got signal:", s)
usif.Exit_now = true
continue
case newbl := <-network.NetBlocks:
common.CountSafe("MainNetBlock")
HandleNetBlock(newbl)
case newtx := <-network.NetTxs:
common.CountSafe("MainNetTx")
network.HandleNetTx(newtx, false)
case newal := <-network.NetAlerts:
common.CountSafe("MainNetAlert")
fmt.Println("\007" + newal)
textui.ShowPrompt()
case <-netTick:
common.CountSafe("MainNetTick")
network.NetworkTick()
case cmd := <-usif.UiChannel:
common.CountSafe("MainUICmd")
common.Busy("UI command")
cmd.Handler(cmd.Param)
cmd.Done.Done()
continue
case <-peersTick:
peersdb.ExpirePeers()
case <-txPoolTick:
network.ExpireTxs()
case <-time.After(time.Second / 2):
common.CountSafe("MainThreadTouts")
if !retryCachedBlocks {
common.Busy("common.BlockChain.Idle()")
if common.BlockChain.Idle() {
common.CountSafe("ChainIdleUsed")
}
}
continue
}
}
network.NetCloseAll()
peersdb.ClosePeerDB()
if usif.DefragBlocksDB != 0 {
defrag_db()
}
common.CloseBlockChain()
sys.UnlockDatabaseDir()
}
