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
var ms runtime.MemStats
var gs debug.GCStats
runtime.ReadMemStats(&ms)
fmt.Println("Go version:", runtime.Version(),
" Heap size:", ms.Alloc>>20, "MB",
" Sys mem used", ms.Sys>>20, "MB")
debug.ReadGCStats(&gs)
fmt.Println("LastGC:", time.Now().Sub(gs.LastGC).String(),
" NumGC:", gs.NumGC,
" PauseTotal:", gs.PauseTotal.String())
fmt.Println("Gocoin:", btc.SourcesTag,
" Threads:", btc.UseThreads,
" Uptime:", time.Now().Sub(common.StartTime).String(),
" ECDSA cnt:", btc.EcdsaVerifyCnt)
}
func GetNetworkHashRate() string {
hours := common.CFG.HashrateHours
common.Last.Mutex.Lock()
end := common.Last.Block
common.Last.Mutex.Unlock()
now := time.Now().Unix()
cnt := 0
var diff float64
for ; end != nil; cnt++ {
if now-int64(end.Timestamp()) > int64(hours)*3600 {
break
}
diff += btc.GetDifficulty(end.Bits())
end = end.Parent
}
if cnt == 0 {
return "0"
}
diff /= float64(cnt)
bph := float64(cnt) / float64(hours)
return common.HashrateToString(bph / 6 * diff * 7158278.826667)
}
func p_home(w http.ResponseWriter, r *http.Request) {
if !ipchecker(r) {
return
}
s := load_template("home.html")
wallet.LockBal()
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.UnlockBal()
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, "{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, cnt := range network.ExternalIp4 {
s = strings.Replace(s, "{ONE_EXTERNAL_IP}",
fmt.Sprintf("%dx%d.%d.%d.%d {ONE_EXTERNAL_IP}", cnt,
byte(ip>>24), byte(ip>>16), byte(ip>>8), byte(ip)), 1)
}
network.ExternalIpMutex.Unlock()
s = strings.Replace(s, "{ONE_EXTERNAL_IP}", "", 1)
var ms runtime.MemStats
runtime.ReadMemStats(&ms)
s = strings.Replace(s, "{HEAP_SIZE_MB}", fmt.Sprint(ms.Alloc>>20), 1)
s = strings.Replace(s, "{SYSMEM_USED_MB}", fmt.Sprint(ms.Sys>>20), 1)
s = strings.Replace(s, "{ECDSA_VERIFY_COUNT}", fmt.Sprint(btc.EcdsaVerifyCnt), 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 p_miners(w http.ResponseWriter, r *http.Request) {
if !ipchecker(r) {
return
}
m := make(map[string]omv, 20)
var unkn, om omv
cnt := 0
common.Last.Mutex.Lock()
end := common.Last.Block
common.Last.Mutex.Unlock()
var lastts int64
var diff float64
var totbts uint64
current_mid := -1
now := time.Now().Unix()
common.LockCfg()
minerid := common.CFG.Beeps.MinerID
common.UnlockCfg()
next_diff_change := 2016 - end.Height%2016
for ; end != nil; cnt++ {
if now-int64(end.Timestamp()) > int64(common.CFG.MiningStatHours)*3600 {
break
}
lastts = int64(end.Timestamp())
bl, _, e := common.BlockChain.Blocks.BlockGet(end.BlockHash)
if e != nil {
return
}
diff += btc.GetDifficulty(end.Bits())
miner, mid := common.BlocksMiner(bl)
if miner != "" {
om = m[miner]
om.cnt++
om.bts += uint64(len(bl))
om.mid = mid
m[miner] = om
if current_mid == -1 && minerid == common.MinerIds[mid][1] {
current_mid = mid
}
} else {
unkn.cnt++
unkn.bts += uint64(len(bl))
}
totbts += uint64(len(bl))
end = end.Parent
}
if cnt == 0 {
write_html_head(w, r)
w.Write([]byte(fmt.Sprint("No blocks in last ", common.CFG.MiningStatHours, " hours")))
write_html_tail(w)
return
}
srt := make(onemiernstat, len(m))
i := 0
for k, v := range m {
srt[i].name = k
srt[i].omv = v
i++
}
sort.Sort(srt)
mnrs := load_template("miners.html")
onerow := load_template("miners_row.html")
diff /= float64(cnt)
bph := float64(cnt) / float64(common.CFG.MiningStatHours)
hrate := bph / 6 * diff * 7158278.826667
mnrs = strings.Replace(mnrs, "{MINING_HOURS}", fmt.Sprint(common.CFG.MiningStatHours), 1)
mnrs = strings.Replace(mnrs, "{BLOCKS_COUNT}", fmt.Sprint(cnt), 1)
mnrs = strings.Replace(mnrs, "{FIRST_BLOCK_TIME}", time.Unix(lastts, 0).Format("2006-01-02 15:04:05"), 1)
mnrs = strings.Replace(mnrs, "{AVG_BLOCKS_PER_HOUR}", fmt.Sprintf("%.2f", bph), 1)
mnrs = strings.Replace(mnrs, "{AVG_DIFFICULTY}", common.NumberToString(diff), 1)
mnrs = strings.Replace(mnrs, "{AVG_HASHDATE}", common.HashrateToString(hrate), 1)
mnrs = strings.Replace(mnrs, "{AVG_BLOCKSIZE}", fmt.Sprintf("%.1fKB", float64(totbts)/float64(cnt)/1000), 1)
mnrs = strings.Replace(mnrs, "{DIFF_CHANGE_IN}", fmt.Sprint(next_diff_change), 1)
mnrs = strings.Replace(mnrs, "{MINER_MON_IDX}", fmt.Sprint(current_mid), 1)
for i := range srt {
s := onerow
s = strings.Replace(s, "{MINER_NAME}", srt[i].name, 1)
s = strings.Replace(s, "{BLOCK_COUNT}", fmt.Sprint(srt[i].cnt), 1)
s = strings.Replace(s, "{TOTAL_PERCENT}", fmt.Sprintf("%.0f", 100*float64(srt[i].cnt)/float64(cnt)), 1)
s = strings.Replace(s, "{MINER_HASHRATE}", common.HashrateToString(hrate*float64(srt[i].cnt)/float64(cnt)), 1)
s = strings.Replace(s, "{AVG_BLOCK_SIZE}", fmt.Sprintf("%.1fKB", float64(srt[i].bts)/float64(srt[i].cnt)/1000), 1)
s = strings.Replace(s, "{MINER_ID}", fmt.Sprint(srt[i].mid), -1)
mnrs = templ_add(mnrs, "<!--MINER_ROW-->", s)
}
onerow = strings.Replace(onerow, "{MINER_NAME}", "<i>Unknown</i>", 1)
onerow = strings.Replace(onerow, "{BLOCK_COUNT}", fmt.Sprint(unkn.cnt), 1)
onerow = strings.Replace(onerow, "{TOTAL_PERCENT}", fmt.Sprintf("%.0f", 100*float64(unkn.cnt)/float64(cnt)), 1)
onerow = strings.Replace(onerow, "{MINER_HASHRATE}", common.HashrateToString(hrate*float64(unkn.cnt)/float64(cnt)), 1)
onerow = strings.Replace(onerow, "{AVG_BLOCK_SIZE}", fmt.Sprintf("%.1fKB", float64(unkn.bts)/float64(unkn.cnt)/1000), 1)
onerow = strings.Replace(onerow, "{MINER_ID}", "-1", -1)
mnrs = templ_add(mnrs, "<!--MINER_ROW-->", onerow)
write_html_head(w, r)
w.Write([]byte(mnrs))
write_html_tail(w)
}
func do_mining(s string) {
var totbtc, hrs uint64
if s != "" {
hrs, _ = strconv.ParseUint(s, 10, 64)
}
if hrs == 0 {
hrs = uint64(common.CFG.MiningStatHours)
}
fmt.Println("Looking back", hrs, "hours...")
lim := uint32(time.Now().Add(-time.Hour * time.Duration(hrs)).Unix())
common.Last.Mutex.Lock()
bte := common.Last.Block
end := bte
common.Last.Mutex.Unlock()
cnt, diff := 0, float64(0)
tot_blocks, tot_blocks_len := 0, 0
for end.Timestamp() >= lim {
bl, _, e := common.BlockChain.Blocks.BlockGet(end.BlockHash)
if e != nil {
println(cnt, e.Error())
return
}
block, e := btc.NewBlock(bl)
if e != nil {
println("btc.NewBlock failed", e.Error())
return
}
tot_blocks++
tot_blocks_len += len(bl)
diff += btc.GetDifficulty(block.Bits())
if common.MinedByUs(bl) {
block.BuildTxList()
totbtc += block.Txs[0].TxOut[0].Value
cnt++
fmt.Printf("%4d) %6d %s %s %5.2f => %5.2f BTC total, %d txs, %.1f KB\n",
cnt, end.Height, end.BlockHash.String(),
time.Unix(int64(end.Timestamp()), 0).Format("2006-01-02 15:04:05"),
float64(block.Txs[0].TxOut[0].Value)/1e8, float64(totbtc)/1e8,
len(block.Txs), float64(len(bl))/1e3)
}
end = end.Parent
}
if tot_blocks == 0 {
fmt.Println("There are no blocks from the last", hrs, "hour(s)")
return
}
diff /= float64(tot_blocks)
common.LockCfg()
if common.CFG.Beeps.MinerID != "" {
fmt.Printf("%.8f BTC mined by %s, in %d blocks for the last %d hours\n",
float64(totbtc)/1e8, common.CFG.Beeps.MinerID, cnt, hrs)
}
common.UnlockCfg()
if cnt > 0 {
fmt.Printf("Projected weekly income : %.0f BTC, estimated hashrate : %s\n",
7*24*float64(totbtc)/float64(hrs)/1e8,
common.HashrateToString(float64(cnt)/float64(6*hrs)*diff*7158278.826667))
}
bph := float64(tot_blocks) / float64(hrs)
fmt.Printf("Total network hashrate : %s @ average diff %.0f (%.2f bph)\n",
common.HashrateToString(bph/6*diff*7158278.826667), diff, bph)
fmt.Printf("Average block size was %.1f KB, next difficulty change in %d blocks\n",
float64(tot_blocks_len/tot_blocks)/1e3, 2016-bte.Height%2016)
}