func json_system(w http.ResponseWriter, r *http.Request) {
if !ipchecker(r) {
return
}
var out struct {
Blocks_cached int
Known_peers int
Node_uptime uint64
Net_block_qsize int
Net_tx_qsize int
Heap_size uint64
Heap_sysmem uint64
Qdb_extramem int64
Ecdsa_verify_cnt uint64
}
out.Blocks_cached = len(network.CachedBlocks)
out.Known_peers = peersdb.PeerDB.Count()
out.Node_uptime = uint64(time.Now().Sub(common.StartTime).Seconds())
out.Net_block_qsize = len(network.NetBlocks)
out.Net_tx_qsize = len(network.NetTxs)
out.Heap_size, out.Heap_sysmem = sys.MemUsed()
out.Qdb_extramem = qdb.ExtraMemoryConsumed
out.Ecdsa_verify_cnt = btc.EcdsaVerifyCnt
bx, er := json.Marshal(out)
if er == nil {
w.Header()["Content-Type"] = []string{"application/json"}
w.Write(bx)
} else {
println(er.Error())
}
}
func show_mem(p string) {
al, sy := sys.MemUsed()
fmt.Println("Allocated:", al>>20, "MB")
fmt.Println("SystemMem:", sy>>20, "MB")
if p == "" {
return
}
if p == "free" {
fmt.Println("Freeing the mem...")
sys.FreeMem()
show_mem("")
return
}
if p == "gc" {
fmt.Println("Running GC...")
runtime.GC()
fmt.Println("Done.")
return
}
i, e := strconv.ParseInt(p, 10, 64)
if e != nil {
println(e.Error())
return
}
debug.SetGCPercent(int(i))
fmt.Println("GC treshold set to", i, "percent")
}
func show_info(par string) {
common.Busy_mutex.Lock()
if common.BusyWith != "" {
fmt.Println("Chain thread busy with:", common.BusyWith)
} else {
fmt.Println("Chain thread is idle")
}
common.Busy_mutex.Unlock()
network.MutexRcv.Lock()
fmt.Println("Last Header:", network.LastCommitedHeader.BlockHash.String(), "@", network.LastCommitedHeader.Height)
discarded := len(network.DiscardedBlocks)
cached := len(network.CachedBlocks)
b2g_len := len(network.BlocksToGet)
b2g_idx_len := len(network.IndexToBlocksToGet)
lb2g := network.LowestIndexToBlocksToGet
network.MutexRcv.Unlock()
common.Last.Mutex.Lock()
fmt.Println("Last Block :", common.Last.Block.BlockHash.String(), "@", common.Last.Block.Height)
fmt.Printf("Timestamp: %s, Diff: %.0f, Got: %s ago, ToGetFrom: %d\n",
time.Unix(int64(common.Last.Block.Timestamp()), 0).Format("2006/01/02 15:04:05"),
btc.GetDifficulty(common.Last.Block.Bits()), time.Now().Sub(common.Last.Time).String(),
lb2g)
fmt.Print("Median Time: ", time.Unix(int64(common.Last.Block.GetMedianTimePast()), 0).Format("2006/01/02 15:04:05"), ", ")
common.Last.Mutex.Unlock()
network.Mutex_net.Lock()
fmt.Printf("NetQueueSize:%d, NetConns:%d, Peers:%d, B2G:%d/%d\n", len(network.NetBlocks),
len(network.OpenCons), peersdb.PeerDB.Count(), b2g_len, b2g_idx_len)
network.Mutex_net.Unlock()
network.TxMutex.Lock()
fmt.Printf("TransactionsToSend:%d, TransactionsRejected:%d, TransactionsPending:%d/%d\n",
len(network.TransactionsToSend), len(network.TransactionsRejected),
len(network.TransactionsPending), len(network.NetTxs))
fmt.Printf("WaitingForInputs:%d, SpentOutputs:%d, Hashrate:%s, AverageFee:%.1f SpB\n",
len(network.WaitingForInputs), len(network.SpentOutputs), usif.GetNetworkHashRate(), common.GetAverageFee())
network.TxMutex.Unlock()
common.PrintStats()
// Memory used
al, sy := sys.MemUsed()
fmt.Println("Heap size:", al>>20, "MB Sys mem used:", sy>>20, "MB QDB extra mem:",
atomic.LoadInt64(&qdb.ExtraMemoryConsumed)>>20, "MB in",
atomic.LoadInt64(&qdb.ExtraMemoryAllocCnt), "recs")
var gs debug.GCStats
debug.ReadGCStats(&gs)
fmt.Println("Go version:", runtime.Version(), " LastGC:", time.Now().Sub(gs.LastGC).String(),
" NumGC:", gs.NumGC,
" PauseTotal:", gs.PauseTotal.String())
fmt.Println("Gocoin:", gocoin.Version,
" Uptime:", time.Now().Sub(common.StartTime).String(),
" ECDSA cnt:", btc.EcdsaVerifyCnt,
" cach:", cached, " dis:", discarded)
}
func show_info(par string) {
common.Busy_mutex.Lock()
if common.BusyWith != "" {
fmt.Println("Chain thread busy with:", common.BusyWith)
} else {
fmt.Println("Chain thread is idle")
}
common.Busy_mutex.Unlock()
common.Last.Mutex.Lock()
fmt.Println("Last Block:", common.Last.Block.BlockHash.String())
fmt.Printf("Height: %d @ %s, Diff: %.0f, Got: %s ago\n",
common.Last.Block.Height,
time.Unix(int64(common.Last.Block.Timestamp()), 0).Format("2006/01/02 15:04:05"),
btc.GetDifficulty(common.Last.Block.Bits()), time.Now().Sub(common.Last.Time).String())
common.Last.Mutex.Unlock()
network.Mutex_net.Lock()
fmt.Printf("BlocksCached: %d, NetQueueSize: %d, NetConns: %d, Peers: %d\n",
len(network.CachedBlocks), len(network.NetBlocks), len(network.OpenCons), network.PeerDB.Count())
network.Mutex_net.Unlock()
network.TxMutex.Lock()
fmt.Printf("TransactionsToSend:%d, TransactionsRejected:%d, TransactionsPending:%d/%d\n",
len(network.TransactionsToSend), len(network.TransactionsRejected),
len(network.TransactionsPending), len(network.NetTxs))
fmt.Printf("WaitingForInputs:%d, SpentOutputs:%d, Hashrate:%s\n",
len(network.WaitingForInputs), len(network.SpentOutputs), usif.GetNetworkHashRate())
network.TxMutex.Unlock()
common.PrintStats()
// Memory used
al, sy := sys.MemUsed()
fmt.Println("Go version:", runtime.Version())
fmt.Println("Heap size:", al>>20, "MB Sys mem used:", sy>>20, "MB",
" QDB Extra mem:", qdb.ExtraMemoryConsumed>>20, "MB in", qdb.ExtraMemoryAllocCnt, "parts")
var gs debug.GCStats
debug.ReadGCStats(&gs)
fmt.Println("LastGC:", time.Now().Sub(gs.LastGC).String(),
" NumGC:", gs.NumGC,
" PauseTotal:", gs.PauseTotal.String())
fmt.Println("Gocoin:", lib.Version,
" Threads:", sys.UseThreads,
" Uptime:", time.Now().Sub(common.StartTime).String(),
" ECDSA cnt:", btc.EcdsaVerifyCnt)
}
func host_init() {
var e error
BtcRootDir := sys.BitcoinHome()
common.GocoinHomeDir = common.CFG.Datadir + string(os.PathSeparator)
common.Testnet = common.CFG.Testnet // So chaging this value would will only affect the behaviour after restart
if common.CFG.Testnet { // testnet3
common.GenesisBlock = btc.NewUint256FromString("000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943")
common.Magic = [4]byte{0x0B, 0x11, 0x09, 0x07}
common.GocoinHomeDir += common.DataSubdir() + string(os.PathSeparator)
BtcRootDir += "testnet3" + string(os.PathSeparator)
common.MaxPeersNeeded = 2000
} else {
common.GenesisBlock = btc.NewUint256FromString("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f")
common.Magic = [4]byte{0xF9, 0xBE, 0xB4, 0xD9}
common.GocoinHomeDir += common.DataSubdir() + string(os.PathSeparator)
common.MaxPeersNeeded = 5000
}
// Lock the folder
os.MkdirAll(common.GocoinHomeDir, 0770)
sys.LockDatabaseDir(common.GocoinHomeDir)
fi, e := os.Stat(common.GocoinHomeDir + "blockchain.dat")
if e != nil {
os.RemoveAll(common.GocoinHomeDir)
fmt.Println("You seem to be running Gocoin for the fist time on this PC")
fi, e = os.Stat(BtcRootDir + "blocks/blk00000.dat")
if e == nil && fi.Size() > 1024*1024 {
fmt.Println("There is a database from Satoshi client on your disk...")
if textui.AskYesNo("Do you want to import this database into Gocoin?") {
import_blockchain(BtcRootDir + "blocks")
}
}
}
fmt.Println("Loading UTXO-db and P2SH/P2KH outputs of", btc.UintToBtc(common.AllBalMinVal), "BTC or more")
__exit := make(chan bool)
__done := make(chan bool)
go func() {
for {
select {
case s := <-killchan:
fmt.Println(s)
chain.AbortNow = true
case <-__exit:
__done <- true
return
}
}
}()
ext := &chain.NewChanOpts{NotifyTxAdd: wallet.TxNotifyAdd,
NotifyTxDel: wallet.TxNotifyDel, LoadWalk: wallet.NewUTXO,
UTXOVolatileMode: common.FLAG.VolatileUTXO,
UndoBlocks: common.FLAG.UndoBlocks,
SetBlocksDBCacheSize: true, BlocksDBCacheSize: int(common.CFG.Memory.MaxCachedBlocks)}
sta := time.Now().UnixNano()
common.BlockChain = chain.NewChainExt(common.GocoinHomeDir, common.GenesisBlock, common.FLAG.Rescan, ext)
sto := time.Now().UnixNano()
if chain.AbortNow {
fmt.Printf("Blockchain opening aborted after %.3f seconds\n", float64(sto-sta)/1e9)
common.BlockChain.Close()
sys.UnlockDatabaseDir()
os.Exit(1)
}
al, sy := sys.MemUsed()
fmt.Printf("Blockchain open in %.3f seconds. %d + %d MB of RAM used (%d)\n",
float64(sto-sta)/1e9, al>>20, qdb.ExtraMemoryConsumed>>20, sy>>20)
common.StartTime = time.Now()
__exit <- true
_ = <-__done
}
func p_home(w http.ResponseWriter, r *http.Request) {
if !ipchecker(r) {
return
}
// The handler also gets called for /favicon.ico
if r.URL.Path != "/" {
http.NotFound(w, r)
}
s := load_template("home.html")
wallet.BalanceMutex.Lock()
if len(wallet.MyBalance) > 0 {
wal := load_template("home_wal.html")
wal = strings.Replace(wal, "{TOTAL_BTC}", fmt.Sprintf("%.8f", float64(wallet.LastBalance)/1e8), 1)
wal = strings.Replace(wal, "{UNSPENT_OUTS}", fmt.Sprint(len(wallet.MyBalance)), 1)
s = strings.Replace(s, "<!--WALLET-->", wal, 1)
} else {
if wallet.MyWallet == nil {
s = strings.Replace(s, "<!--WALLET-->", "You have no wallet", 1)
} else {
s = strings.Replace(s, "<!--WALLET-->", "Your balance is <b>zero</b>", 1)
}
}
wallet.BalanceMutex.Unlock()
common.Last.Mutex.Lock()
s = strings.Replace(s, "{LAST_BLOCK_HASH}", common.Last.Block.BlockHash.String(), 1)
s = strings.Replace(s, "{LAST_BLOCK_HEIGHT}", fmt.Sprint(common.Last.Block.Height), 1)
s = strings.Replace(s, "{LAST_BLOCK_TIME}", time.Unix(int64(common.Last.Block.Timestamp()), 0).Format("2006/01/02 15:04:05"), 1)
s = strings.Replace(s, "{LAST_BLOCK_DIFF}", common.NumberToString(btc.GetDifficulty(common.Last.Block.Bits())), 1)
s = strings.Replace(s, "{LAST_BLOCK_RCVD}", time.Now().Sub(common.Last.Time).String(), 1)
common.Last.Mutex.Unlock()
s = strings.Replace(s, "<--NETWORK_HASHRATE-->", usif.GetNetworkHashRate(), 1)
s = strings.Replace(s, "{BLOCKS_CACHED}", fmt.Sprint(len(network.CachedBlocks)), 1)
s = strings.Replace(s, "{KNOWN_PEERS}", fmt.Sprint(network.PeerDB.Count()), 1)
s = strings.Replace(s, "{NODE_UPTIME}", time.Now().Sub(common.StartTime).String(), 1)
s = strings.Replace(s, "{NET_BLOCK_QSIZE}", fmt.Sprint(len(network.NetBlocks)), 1)
s = strings.Replace(s, "{NET_TX_QSIZE}", fmt.Sprint(len(network.NetTxs)), 1)
network.Mutex_net.Lock()
s = strings.Replace(s, "{OPEN_CONNS_TOTAL}", fmt.Sprint(len(network.OpenCons)), 1)
s = strings.Replace(s, "{OPEN_CONNS_OUT}", fmt.Sprint(network.OutConsActive), 1)
s = strings.Replace(s, "{OPEN_CONNS_IN}", fmt.Sprint(network.InConsActive), 1)
network.Mutex_net.Unlock()
common.LockBw()
common.TickRecv()
common.TickSent()
s = strings.Replace(s, "{DL_SPEED_NOW}", fmt.Sprint(common.DlBytesPrevSec>>10), 1)
s = strings.Replace(s, "{DL_SPEED_MAX}", fmt.Sprint(common.DownloadLimit>>10), 1)
s = strings.Replace(s, "{DL_TOTAL}", common.BytesToString(common.DlBytesTotal), 1)
s = strings.Replace(s, "{UL_SPEED_NOW}", fmt.Sprint(common.UlBytesPrevSec>>10), 1)
s = strings.Replace(s, "{UL_SPEED_MAX}", fmt.Sprint(common.UploadLimit>>10), 1)
s = strings.Replace(s, "{UL_TOTAL}", common.BytesToString(common.UlBytesTotal), 1)
common.UnlockBw()
network.ExternalIpMutex.Lock()
for ip, rec := range network.ExternalIp4 {
ips := fmt.Sprintf("<b title=\"%d times. Last seen %d min ago\">%d.%d.%d.%d</b> ",
rec[0], (uint(time.Now().Unix())-rec[1])/60,
byte(ip>>24), byte(ip>>16), byte(ip>>8), byte(ip))
s = templ_add(s, "<!--ONE_EXTERNAL_IP-->", ips)
}
network.ExternalIpMutex.Unlock()
al, sy := sys.MemUsed()
s = strings.Replace(s, "<!--HEAP_SIZE_MB-->", fmt.Sprint(al>>20), 1)
s = strings.Replace(s, "<!--HEAPSYS_MB-->", fmt.Sprint(sy>>20), 1)
s = strings.Replace(s, "<!--WDB_EXTRA_MB-->", fmt.Sprint(qdb.ExtraMemoryConsumed>>20), 1)
s = strings.Replace(s, "{ECDSA_VERIFY_COUNT}", fmt.Sprint(btc.EcdsaVerifyCnt), 1)
s = strings.Replace(s, "<!--NEW_BLOCK_BEEP-->", fmt.Sprint(common.CFG.Beeps.NewBlock), 1)
common.LockCfg()
dat, _ := json.Marshal(&common.CFG)
common.UnlockCfg()
s = strings.Replace(s, "{CONFIG_FILE}", strings.Replace(string(dat), ",\"", ", \"", -1), 1)
write_html_head(w, r)
w.Write([]byte(s))
write_html_tail(w)
}
func host_init() {
var e error
BtcRootDir := sys.BitcoinHome()
if common.CFG.Datadir == "" {
common.GocoinHomeDir = BtcRootDir + "gocoin" + string(os.PathSeparator)
} else {
common.GocoinHomeDir = common.CFG.Datadir + string(os.PathSeparator)
}
common.Testnet = common.CFG.Testnet // So chaging this value would will only affect the behaviour after restart
if common.CFG.Testnet { // testnet3
common.GenesisBlock = btc.NewUint256FromString("000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943")
common.Magic = [4]byte{0x0B, 0x11, 0x09, 0x07}
common.GocoinHomeDir += "tstnet" + string(os.PathSeparator)
BtcRootDir += "testnet3" + string(os.PathSeparator)
network.AlertPubKey, _ = hex.DecodeString("04302390343f91cc401d56d68b123028bf52e5fca1939df127f63c6467cdf9c8e2c14b61104cf817d0b780da337893ecc4aaff1309e536162dabbdb45200ca2b0a")
common.MaxPeersNeeded = 100
} else {
common.GenesisBlock = btc.NewUint256FromString("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f")
common.Magic = [4]byte{0xF9, 0xBE, 0xB4, 0xD9}
common.GocoinHomeDir += "btcnet" + string(os.PathSeparator)
network.AlertPubKey, _ = hex.DecodeString("04fc9702847840aaf195de8442ebecedf5b095cdbb9bc716bda9110971b28a49e0ead8564ff0db22209e0374782c093bb899692d524e9d6a6956e7c5ecbcd68284")
common.MaxPeersNeeded = 1000
}
// Lock the folder
os.MkdirAll(common.GocoinHomeDir, 0770)
os.MkdirAll(common.GocoinHomeDir+"wallet", 0770)
sys.LockDatabaseDir(common.GocoinHomeDir)
fi, e := os.Stat(common.GocoinHomeDir + "blockchain.dat")
if e != nil {
os.RemoveAll(common.GocoinHomeDir)
fmt.Println("You seem to be running Gocoin for the fist time on this PC")
fi, e = os.Stat(BtcRootDir + "blocks/blk00000.dat")
if e == nil && fi.Size() > 1024*1024 {
fmt.Println("There is a database from Satoshi client on your disk...")
if textui.AskYesNo("Do you want to import this database into Gocoin?") {
import_blockchain(BtcRootDir + "blocks")
}
}
}
// cache the current balance of all the addresses from the current wallet files
wallet.LoadAllWallets()
fmt.Println("Loading UTXO database while checking balance of", len(wallet.MyWallet.Addrs),
"addresses... (press Ctrl-C to interrupt)")
__exit := make(chan bool)
__done := make(chan bool)
go func() {
for {
select {
case s := <-killchan:
fmt.Println(s)
chain.AbortNow = true
case <-__exit:
__done <- true
return
}
}
}()
ext := &chain.NewChanOpts{NotifyTx: wallet.TxNotify,
NotifyStealthTx: wallet.StealthNotify,
LoadWalk: wallet.NewUTXO, LoadFlush: wallet.DoPendingStealths}
sta := time.Now().UnixNano()
common.BlockChain = chain.NewChainExt(common.GocoinHomeDir, common.GenesisBlock, common.FLAG.Rescan, ext)
sto := time.Now().UnixNano()
if chain.AbortNow {
fmt.Printf("Blockchain opening aborted after %.3f seconds\n", float64(sto-sta)/1e9)
common.BlockChain.Close()
sys.UnlockDatabaseDir()
os.Exit(1)
}
wallet.ChainInitDone()
al, sy := sys.MemUsed()
fmt.Printf("Blockchain open in %.3f seconds. %d + %d MB of RAM used (%d)\n",
float64(sto-sta)/1e9, al>>20, qdb.ExtraMemoryConsumed>>20, sy>>20)
common.StartTime = time.Now()
__exit <- true
_ = <-__done
}
func show_free_mem() {
al, sy := sys.MemUsed()
fmt.Println("HEAP size", al>>20, "MB, SysMEM used", sy>>20, "MB")
}
