ngfchl
803 lines
24 KiB
Go
803 lines
24 KiB
Go
package main
|
|
|
|
import (
|
|
_ "embed"
|
|
"encoding/json"
|
|
"flag"
|
|
"fmt"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"runtime"
|
|
"strconv"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/gorilla/websocket"
|
|
"gopkg.in/yaml.v3"
|
|
)
|
|
|
|
// ═══════════════════════════════════════════════
|
|
// 日志
|
|
// ═══════════════════════════════════════════════
|
|
|
|
func init() {
|
|
log.SetFlags(0)
|
|
log.SetOutput(&logWriter{})
|
|
}
|
|
|
|
type logWriter struct{}
|
|
|
|
func (w *logWriter) Write(p []byte) (int, error) {
|
|
ts := time.Now().Format("15:04:05")
|
|
return fmt.Fprintf(os.Stderr, "%s %s", ts, p)
|
|
}
|
|
|
|
func logInfo(tag, format string, args ...interface{}) {
|
|
msg := fmt.Sprintf(format, args...)
|
|
log.Printf("[%-8s] %s", tag, msg)
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════
|
|
// 版本
|
|
// ═══════════════════════════════════════════════
|
|
|
|
var (
|
|
Version = "dev"
|
|
BuildTime = "unknown"
|
|
)
|
|
|
|
// ═══════════════════════════════════════════════
|
|
// 路径工具
|
|
// ═══════════════════════════════════════════════
|
|
|
|
func exeDir() string {
|
|
p, err := os.Executable()
|
|
if err != nil {
|
|
return "."
|
|
}
|
|
return filepath.Dir(p)
|
|
}
|
|
|
|
func resolvePath(baseDir, p string) string {
|
|
if filepath.IsAbs(p) {
|
|
return p
|
|
}
|
|
return filepath.Join(baseDir, p)
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════
|
|
// 配置结构
|
|
// ═══════════════════════════════════════════════
|
|
|
|
type AuthConfig struct {
|
|
MinerID string `yaml:"miner_id"`
|
|
Password string `yaml:"password"`
|
|
}
|
|
|
|
type ServerConfig struct {
|
|
Listen string `yaml:"listen"`
|
|
DevicesFile string `yaml:"devices_file"`
|
|
Auth AuthConfig `yaml:"auth"`
|
|
MinerUID string `yaml:"miner_uid"`
|
|
MinerAPIBase string `yaml:"miner_api_base"`
|
|
FetchInterval int `yaml:"fetch_interval"`
|
|
HistoryMax int `yaml:"history_max"`
|
|
}
|
|
|
|
func defaultConfig() ServerConfig {
|
|
return ServerConfig{
|
|
Listen: ":8080",
|
|
DevicesFile: "data/devices.yaml",
|
|
Auth: AuthConfig{MinerID: "admin", Password: "123456"},
|
|
MinerAPIBase: "https://pool.kryptex.com/prl/api/v3/miner/workers",
|
|
FetchInterval: 30,
|
|
HistoryMax: 200,
|
|
}
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════
|
|
// 配置加载（不存在则自动生成）
|
|
// ═══════════════════════════════════════════════
|
|
|
|
// ═══════════════════════════════════════════════
|
|
// 路径工具
|
|
// ═══════════════════════════════════════════════
|
|
|
|
// baseDir: 优先工作目录，其次 exe 目录
|
|
func baseDir() string {
|
|
// 当前工作目录
|
|
if wd, err := os.Getwd(); err == nil {
|
|
return wd
|
|
}
|
|
// exe 目录（打包后使用）
|
|
if p, err := os.Executable(); err == nil {
|
|
return filepath.Dir(p)
|
|
}
|
|
return "."
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════
|
|
// 配置加载（不存在则自动生成）
|
|
// ═══════════════════════════════════════════════
|
|
|
|
// 搜索顺序: explicit > 工作目录 > exe 目录
|
|
func findConfigPaths(explicit string) []string {
|
|
var paths []string
|
|
if explicit != "" {
|
|
paths = append(paths, explicit)
|
|
}
|
|
// 工作目录（go run 时 = 项目目录）
|
|
if wd, err := os.Getwd(); err == nil {
|
|
paths = append(paths, filepath.Join(wd, "server.yaml"))
|
|
}
|
|
// exe 目录（打包分发时 = exe 所在目录）
|
|
if p, err := os.Executable(); err == nil {
|
|
d := filepath.Dir(p)
|
|
if wd, _ := os.Getwd(); d != wd {
|
|
paths = append(paths, filepath.Join(d, "server.yaml"))
|
|
}
|
|
}
|
|
return paths
|
|
}
|
|
|
|
func loadOrCreateConfig(explicitPath string) (ServerConfig, string) {
|
|
cfg := defaultConfig()
|
|
paths := findConfigPaths(explicitPath)
|
|
|
|
// 1. 尝试找到已有配置文件
|
|
for _, p := range paths {
|
|
abs, _ := filepath.Abs(p)
|
|
raw, err := os.ReadFile(abs)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
if err := yaml.Unmarshal(raw, &cfg); err != nil {
|
|
logInfo("config", "解析 %s 失败: %v", abs, err)
|
|
continue
|
|
}
|
|
fillDefaults(&cfg)
|
|
logInfo("config", "已加载: %s", abs)
|
|
logInfo("config", "listen=%s devices=%s", cfg.Listen, cfg.DevicesFile)
|
|
return cfg, abs
|
|
}
|
|
|
|
// 2. 全部不存在 → 在第一个搜索路径生成默认配置
|
|
genPath, _ := filepath.Abs(paths[0])
|
|
fillDefaults(&cfg)
|
|
out, _ := yaml.Marshal(&cfg)
|
|
hdr := "# Hardware Monitor Server 配置\n#\n"
|
|
hdr += "# listen : 监听地址\n"
|
|
hdr += "# devices_file : 设备注册表路径 (相对于配置文件所在目录)\n"
|
|
hdr += "#\n"
|
|
hdr += "# auth:\n"
|
|
hdr += "# miner_id : 登录设备ID\n"
|
|
hdr += "# password : 登录密码 (明文)\n"
|
|
hdr += "#\n"
|
|
hdr += "# miner_uid : Kryptex 钱包地址\n"
|
|
hdr += "# miner_api_base: 矿池 API 地址\n"
|
|
hdr += "# fetch_interval: 拉取间隔 (秒)\n"
|
|
hdr += "# history_max : 算力历史最大条数\n"
|
|
hdr += "#\n"
|
|
hdr += "# 删除此文件可恢复默认配置\n\n"
|
|
dir := filepath.Dir(genPath)
|
|
os.MkdirAll(dir, 0755)
|
|
os.WriteFile(genPath, append([]byte(hdr), out...), 0644)
|
|
logInfo("config", "已生成默认配置: %s", genPath)
|
|
return cfg, genPath
|
|
}
|
|
|
|
func fillDefaults(cfg *ServerConfig) {
|
|
if cfg.Listen == "" {
|
|
cfg.Listen = ":8080"
|
|
}
|
|
if cfg.DevicesFile == "" {
|
|
cfg.DevicesFile = "data/devices.yaml"
|
|
}
|
|
if cfg.Auth.MinerID == "" {
|
|
cfg.Auth.MinerID = "admin"
|
|
}
|
|
if cfg.Auth.Password == "" {
|
|
cfg.Auth.Password = "123456"
|
|
}
|
|
if cfg.MinerAPIBase == "" {
|
|
cfg.MinerAPIBase = "https://pool.kryptex.com/prl/api/v3/miner/workers"
|
|
}
|
|
if cfg.FetchInterval <= 0 {
|
|
cfg.FetchInterval = 30
|
|
}
|
|
if cfg.HistoryMax <= 0 {
|
|
cfg.HistoryMax = 200
|
|
}
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════
|
|
// 设备注册表
|
|
// ═══════════════════════════════════════════════
|
|
|
|
type DeviceFile struct {
|
|
Devices map[string]*DeviceRecord `yaml:"devices"`
|
|
}
|
|
|
|
type DeviceRecord struct {
|
|
Name string `yaml:"machine_name" json:"machine_name"`
|
|
FirstSeen time.Time `yaml:"first_seen" json:"first_seen"`
|
|
LastSeen time.Time `yaml:"last_seen" json:"last_seen"`
|
|
Board BoardInfo `yaml:"motherboard" json:"motherboard"`
|
|
CPUModel string `yaml:"cpu_model" json:"cpu_model"`
|
|
CPUCoresP int `yaml:"cpu_cores_physical" json:"cpu_cores_physical"`
|
|
CPUCoresL int `yaml:"cpu_cores_logical" json:"cpu_cores_logical"`
|
|
GPUs []GPURec `yaml:"gpus" json:"gpus"`
|
|
}
|
|
|
|
type BoardInfo struct {
|
|
Manufacturer string `yaml:"manufacturer,omitempty" json:"manufacturer,omitempty"`
|
|
Product string `yaml:"product,omitempty" json:"product,omitempty"`
|
|
}
|
|
|
|
type GPURec struct {
|
|
Name string `yaml:"name" json:"name"`
|
|
VRAM float64 `yaml:"vram_total_mb" json:"vram_total_mb"`
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════
|
|
// 矿池数据
|
|
// ═══════════════════════════════════════════════
|
|
|
|
type MiningData struct {
|
|
Status string `json:"status"`
|
|
Coin string `json:"coin"`
|
|
Valid int `json:"valid"`
|
|
Stale int `json:"stale"`
|
|
Invalid int `json:"invalid"`
|
|
Hashrate30m float64 `json:"hashrate_30m"`
|
|
Hashrate3h float64 `json:"hashrate_3h"`
|
|
Hashrate24h float64 `json:"hashrate_24h"`
|
|
Agent string `json:"agent"`
|
|
Country string `json:"country"`
|
|
LastActive int64 `json:"last_active"`
|
|
OpenedAt int64 `json:"opened_at"`
|
|
FetchedAt time.Time `json:"fetched_at"`
|
|
}
|
|
|
|
type HashratePoint struct {
|
|
T string `json:"t"`
|
|
V float64 `json:"v"`
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════
|
|
// 消息结构
|
|
// ═══════════════════════════════════════════════
|
|
|
|
type AgentPayload struct {
|
|
MachineName string `json:"machine_name"`
|
|
Motherboard struct {
|
|
Manufacturer string `json:"manufacturer"`
|
|
Product string `json:"product"`
|
|
} `json:"motherboard"`
|
|
CPU struct {
|
|
Model string `json:"model"`
|
|
CoresPhysical int `json:"cores_physical"`
|
|
CoresLogical int `json:"cores_logical"`
|
|
} `json:"cpu"`
|
|
GPUs []struct {
|
|
Name string `json:"name"`
|
|
VRAM float64 `json:"vram_total_mb"`
|
|
} `json:"gpus"`
|
|
}
|
|
|
|
type BrowserDevice struct {
|
|
Info *DeviceRecord `json:"info"`
|
|
Live json.RawMessage `json:"live,omitempty"`
|
|
Online bool `json:"online"`
|
|
Mining *MiningData `json:"mining,omitempty"`
|
|
History []HashratePoint `json:"hash_history,omitempty"`
|
|
}
|
|
|
|
type BrowserMsg struct {
|
|
Type string `json:"type"`
|
|
Msg string `json:"msg,omitempty"`
|
|
Machine string `json:"machine,omitempty"`
|
|
Device *BrowserDevice `json:"device,omitempty"`
|
|
Mining *MiningData `json:"mining,omitempty"`
|
|
History []HashratePoint `json:"hash_history,omitempty"`
|
|
Devices map[string]*BrowserDevice `json:"devices,omitempty"`
|
|
}
|
|
|
|
type BrowserCmd struct {
|
|
Type string `json:"type"`
|
|
Action string `json:"action"`
|
|
Machine string `json:"machine"`
|
|
MinerID string `json:"miner_id"`
|
|
Password string `json:"password"`
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════
|
|
// Hub
|
|
// ═══════════════════════════════════════════════
|
|
|
|
type Hub struct {
|
|
mu sync.RWMutex
|
|
fileMu sync.Mutex
|
|
records map[string]*DeviceRecord
|
|
live map[string]json.RawMessage
|
|
monitors map[*websocket.Conn]struct{}
|
|
miningData map[string]*MiningData
|
|
hashHist map[string][]HashratePoint
|
|
devicesAbs string
|
|
config ServerConfig
|
|
}
|
|
|
|
func NewHub(cfg ServerConfig, devicesAbs string) *Hub {
|
|
h := &Hub{
|
|
records: make(map[string]*DeviceRecord),
|
|
live: make(map[string]json.RawMessage),
|
|
monitors: make(map[*websocket.Conn]struct{}),
|
|
miningData: make(map[string]*MiningData),
|
|
hashHist: make(map[string][]HashratePoint),
|
|
devicesAbs: devicesAbs,
|
|
config: cfg,
|
|
}
|
|
h.loadYAML()
|
|
return h
|
|
}
|
|
|
|
func (h *Hub) loadYAML() {
|
|
data, err := os.ReadFile(h.devicesAbs)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var f DeviceFile
|
|
if yaml.Unmarshal(data, &f) != nil || f.Devices == nil {
|
|
return
|
|
}
|
|
h.records = f.Devices
|
|
logInfo("yaml", "加载 %d 台设备", len(h.records))
|
|
for name, r := range h.records {
|
|
log.Printf(" · %-20s CPU: %-36s %s", name, r.CPUModel, r.LastSeen.Format("01-02 15:04"))
|
|
}
|
|
}
|
|
|
|
func (h *Hub) saveYAML() {
|
|
h.mu.RLock()
|
|
snap := make(map[string]*DeviceRecord, len(h.records))
|
|
for k, v := range h.records {
|
|
c := *v
|
|
snap[k] = &c
|
|
}
|
|
h.mu.RUnlock()
|
|
|
|
out, err := yaml.Marshal(&DeviceFile{Devices: snap})
|
|
if err != nil {
|
|
return
|
|
}
|
|
hdr := fmt.Sprintf("# Hardware Monitor — 设备注册表\n# 更新: %s\n\n", time.Now().Format("2006-01-02 15:04:05"))
|
|
dir := filepath.Dir(h.devicesAbs)
|
|
os.MkdirAll(dir, 0755)
|
|
h.fileMu.Lock()
|
|
defer h.fileMu.Unlock()
|
|
os.WriteFile(h.devicesAbs, append([]byte(hdr), out...), 0644)
|
|
}
|
|
|
|
func (h *Hub) UpdateDevice(raw json.RawMessage) {
|
|
var p AgentPayload
|
|
if json.Unmarshal(raw, &p) != nil || p.MachineName == "" {
|
|
return
|
|
}
|
|
name := p.MachineName
|
|
now := time.Now()
|
|
|
|
h.mu.Lock()
|
|
rec, existed := h.records[name]
|
|
if !existed {
|
|
rec = &DeviceRecord{Name: name, FirstSeen: now}
|
|
h.records[name] = rec
|
|
}
|
|
rec.LastSeen = now
|
|
rec.Board = BoardInfo{Manufacturer: p.Motherboard.Manufacturer, Product: p.Motherboard.Product}
|
|
rec.CPUModel = p.CPU.Model
|
|
rec.CPUCoresP = p.CPU.CoresPhysical
|
|
rec.CPUCoresL = p.CPU.CoresLogical
|
|
rec.GPUs = make([]GPURec, 0, len(p.GPUs))
|
|
for _, g := range p.GPUs {
|
|
rec.GPUs = append(rec.GPUs, GPURec{Name: g.Name, VRAM: g.VRAM})
|
|
}
|
|
cp := *rec
|
|
h.live[name] = raw
|
|
var md *MiningData
|
|
var hist []HashratePoint
|
|
if m, ok := h.miningData[name]; ok {
|
|
md = m
|
|
}
|
|
if hs, ok := h.hashHist[name]; ok {
|
|
hist = make([]HashratePoint, len(hs))
|
|
copy(hist, hs)
|
|
}
|
|
h.mu.Unlock()
|
|
|
|
if !existed {
|
|
logInfo("new", "%s CPU=%s", name, cp.CPUModel)
|
|
}
|
|
h.saveYAML()
|
|
h.broadcast(BrowserMsg{
|
|
Type: "device", Machine: name,
|
|
Device: &BrowserDevice{Info: &cp, Live: raw, Online: true, Mining: md, History: hist},
|
|
})
|
|
}
|
|
|
|
func (h *Hub) MarkOffline(name string) {
|
|
h.mu.Lock()
|
|
_, had := h.live[name]
|
|
delete(h.live, name)
|
|
rec, ok := h.records[name]
|
|
var c *DeviceRecord
|
|
if ok {
|
|
cp := *rec
|
|
c = &cp
|
|
}
|
|
var md *MiningData
|
|
var hist []HashratePoint
|
|
if m, ok := h.miningData[name]; ok {
|
|
md = m
|
|
}
|
|
if hs, ok := h.hashHist[name]; ok {
|
|
hist = make([]HashratePoint, len(hs))
|
|
copy(hist, hs)
|
|
}
|
|
h.mu.Unlock()
|
|
|
|
if had && c != nil {
|
|
h.broadcast(BrowserMsg{
|
|
Type: "device", Machine: name,
|
|
Device: &BrowserDevice{Info: c, Online: false, Mining: md, History: hist},
|
|
})
|
|
}
|
|
}
|
|
|
|
func (h *Hub) DeleteDevice(name string) {
|
|
h.mu.Lock()
|
|
_, ok := h.records[name]
|
|
delete(h.records, name)
|
|
delete(h.live, name)
|
|
h.mu.Unlock()
|
|
if ok {
|
|
h.saveYAML()
|
|
h.broadcast(BrowserMsg{Type: "remove", Machine: name})
|
|
logInfo("delete", "%s", name)
|
|
}
|
|
}
|
|
|
|
func (h *Hub) AddMonitor(c *websocket.Conn) {
|
|
h.mu.Lock()
|
|
h.monitors[c] = struct{}{}
|
|
h.mu.Unlock()
|
|
c.WriteJSON(BrowserMsg{Type: "snapshot", Devices: h.snapshot()})
|
|
logInfo("monitor+", "浏览器连接 (%d 在线)", len(h.monitors))
|
|
}
|
|
|
|
func (h *Hub) RemoveMonitor(c *websocket.Conn) {
|
|
h.mu.Lock()
|
|
delete(h.monitors, c)
|
|
h.mu.Unlock()
|
|
c.Close()
|
|
logInfo("monitor-", "浏览器断开 (%d 在线)", len(h.monitors))
|
|
}
|
|
|
|
func (h *Hub) snapshot() map[string]*BrowserDevice {
|
|
h.mu.RLock()
|
|
defer h.mu.RUnlock()
|
|
out := make(map[string]*BrowserDevice, len(h.records))
|
|
for name, rec := range h.records {
|
|
bd := &BrowserDevice{Info: rec, Online: false}
|
|
if live, ok := h.live[name]; ok {
|
|
bd.Live = live
|
|
bd.Online = true
|
|
}
|
|
if md, ok := h.miningData[name]; ok {
|
|
bd.Mining = md
|
|
if hs, ok := h.hashHist[name]; ok {
|
|
bd.History = make([]HashratePoint, len(hs))
|
|
copy(bd.History, hs)
|
|
}
|
|
}
|
|
out[name] = bd
|
|
}
|
|
return out
|
|
}
|
|
|
|
func (h *Hub) broadcast(msg BrowserMsg) {
|
|
data, _ := json.Marshal(msg)
|
|
h.mu.RLock()
|
|
defer h.mu.RUnlock()
|
|
for c := range h.monitors {
|
|
if err := c.WriteMessage(websocket.TextMessage, data); err != nil {
|
|
go h.RemoveMonitor(c)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (h *Hub) CleanStale() {
|
|
tick := time.NewTicker(10 * time.Second)
|
|
defer tick.Stop()
|
|
for range tick.C {
|
|
h.mu.RLock()
|
|
var stale []string
|
|
for name, rec := range h.records {
|
|
if _, online := h.live[name]; online && time.Since(rec.LastSeen) > 20*time.Second {
|
|
stale = append(stale, name)
|
|
}
|
|
}
|
|
h.mu.RUnlock()
|
|
for _, name := range stale {
|
|
h.MarkOffline(name)
|
|
logInfo("offline", "%s", name)
|
|
}
|
|
}
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════
|
|
// 矿池拉取
|
|
// ═══════════════════════════════════════════════
|
|
|
|
func (h *Hub) StartMinerFetcher() {
|
|
if h.config.MinerUID == "" {
|
|
logInfo("miner", "未配置 miner_uid，跳过")
|
|
return
|
|
}
|
|
url := h.config.MinerAPIBase + "/" + h.config.MinerUID
|
|
interval := time.Duration(h.config.FetchInterval) * time.Second
|
|
logInfo("miner", "启动 (每 %v)", interval)
|
|
|
|
h.fetchMinerData(url)
|
|
ticker := time.NewTicker(interval)
|
|
defer ticker.Stop()
|
|
for range ticker.C {
|
|
h.mu.RLock()
|
|
n := len(h.monitors)
|
|
h.mu.RUnlock()
|
|
if n > 0 {
|
|
h.fetchMinerData(url)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (h *Hub) fetchMinerData(url string) {
|
|
client := &http.Client{Timeout: 15 * time.Second}
|
|
resp, err := client.Get(url)
|
|
if err != nil {
|
|
logInfo("miner", "请求失败: %v", err)
|
|
return
|
|
}
|
|
defer resp.Body.Close()
|
|
if resp.StatusCode != 200 {
|
|
logInfo("miner", "HTTP %d", resp.StatusCode)
|
|
return
|
|
}
|
|
var apiResp struct {
|
|
Results []struct {
|
|
Worker string `json:"worker"`
|
|
Status string `json:"status"`
|
|
Coin string `json:"coin"`
|
|
Valid int `json:"valid"`
|
|
Stale int `json:"stale"`
|
|
Invalid int `json:"invalid"`
|
|
AvgHashrate24h string `json:"avg_hashrate_24h"`
|
|
AvgHashrate3h string `json:"avg_hashrate_3h"`
|
|
AvgHashrate30m string `json:"avg_hashrate_30m"`
|
|
Agent string `json:"agent"`
|
|
Country string `json:"country"`
|
|
LastActive int64 `json:"last_active"`
|
|
OpenedAt int64 `json:"opened_at"` // ★ 新增
|
|
} `json:"results"`
|
|
}
|
|
if json.NewDecoder(resp.Body).Decode(&apiResp) != nil {
|
|
return
|
|
}
|
|
|
|
now := time.Now()
|
|
h.mu.Lock()
|
|
for _, w := range apiResp.Results {
|
|
hr30m, _ := strconv.ParseFloat(w.AvgHashrate30m, 64)
|
|
hr3h, _ := strconv.ParseFloat(w.AvgHashrate3h, 64)
|
|
hr24h, _ := strconv.ParseFloat(w.AvgHashrate24h, 64)
|
|
h.miningData[w.Worker] = &MiningData{
|
|
Status: w.Status, Coin: w.Coin, Valid: w.Valid, Stale: w.Stale, Invalid: w.Invalid,
|
|
Hashrate30m: hr30m, Hashrate3h: hr3h, Hashrate24h: hr24h,
|
|
Agent: w.Agent, Country: w.Country,
|
|
LastActive: w.LastActive, OpenedAt: w.OpenedAt, // ★ 加 OpenedAt
|
|
FetchedAt: now,
|
|
}
|
|
h.hashHist[w.Worker] = append(h.hashHist[w.Worker], HashratePoint{T: now.Format(time.RFC3339), V: hr30m})
|
|
if len(h.hashHist[w.Worker]) > h.config.HistoryMax {
|
|
h.hashHist[w.Worker] = h.hashHist[w.Worker][len(h.hashHist[w.Worker])-h.config.HistoryMax:]
|
|
}
|
|
}
|
|
h.mu.Unlock()
|
|
|
|
for _, w := range apiResp.Results {
|
|
h.mu.RLock()
|
|
md := h.miningData[w.Worker]
|
|
hist := make([]HashratePoint, len(h.hashHist[w.Worker]))
|
|
copy(hist, h.hashHist[w.Worker])
|
|
h.mu.RUnlock()
|
|
h.broadcast(BrowserMsg{Type: "mining", Machine: w.Worker, Mining: md, History: hist})
|
|
}
|
|
logInfo("miner", "更新 %d 个 worker", len(apiResp.Results))
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════
|
|
// WebSocket
|
|
// ═══════════════════════════════════════════════
|
|
|
|
var upgrader = websocket.Upgrader{
|
|
CheckOrigin: func(r *http.Request) bool { return true },
|
|
ReadBufferSize: 65536,
|
|
WriteBufferSize: 262144,
|
|
}
|
|
|
|
func handleAgent(conn *websocket.Conn, hub *Hub) {
|
|
defer conn.Close()
|
|
addr := conn.RemoteAddr().String()
|
|
logInfo("agent+", "%s", addr)
|
|
defer logInfo("agent-", "%s", addr)
|
|
for {
|
|
_, raw, err := conn.ReadMessage()
|
|
if err != nil {
|
|
break
|
|
}
|
|
hub.UpdateDevice(raw)
|
|
}
|
|
}
|
|
|
|
func handleMonitor(conn *websocket.Conn, hub *Hub) {
|
|
addr := conn.RemoteAddr().String()
|
|
defer conn.Close()
|
|
|
|
// ① 要求认证
|
|
conn.WriteJSON(BrowserMsg{Type: "auth_required"})
|
|
|
|
// ② 等待认证 (15 秒超时)
|
|
conn.SetReadDeadline(time.Now().Add(15 * time.Second))
|
|
|
|
var authOK bool
|
|
for {
|
|
_, raw, err := conn.ReadMessage()
|
|
if err != nil {
|
|
logInfo("monitor", "认证超时: %s", addr)
|
|
return
|
|
}
|
|
|
|
var cmd BrowserCmd
|
|
if json.Unmarshal(raw, &cmd) != nil {
|
|
continue
|
|
}
|
|
if cmd.Type != "auth" {
|
|
continue
|
|
}
|
|
|
|
// 校验
|
|
if cmd.MinerID == hub.config.Auth.MinerID && cmd.Password == hub.config.Auth.Password {
|
|
authOK = true
|
|
break
|
|
}
|
|
|
|
logInfo("monitor", "认证失败: %s", addr)
|
|
conn.WriteJSON(BrowserMsg{Type: "auth_fail", Msg: "设备ID或密码错误"})
|
|
}
|
|
|
|
if !authOK {
|
|
return
|
|
}
|
|
|
|
// ③ 认证通过
|
|
conn.SetReadDeadline(time.Time{})
|
|
conn.WriteJSON(BrowserMsg{Type: "auth_ok"})
|
|
logInfo("monitor+", "认证通过: %s", addr)
|
|
|
|
// ④ 进入正常数据流
|
|
hub.AddMonitor(conn)
|
|
defer hub.RemoveMonitor(conn)
|
|
|
|
for {
|
|
_, raw, err := conn.ReadMessage()
|
|
if err != nil {
|
|
break
|
|
}
|
|
var cmd BrowserCmd
|
|
if json.Unmarshal(raw, &cmd) == nil && cmd.Action == "delete" && cmd.Machine != "" {
|
|
hub.DeleteDevice(cmd.Machine)
|
|
}
|
|
}
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════
|
|
// HTML
|
|
// ═══════════════════════════════════════════════
|
|
|
|
//go:embed templates/index.html
|
|
var indexHTML string
|
|
|
|
// ═══════════════════════════════════════════════
|
|
// main
|
|
// ═══════════════════════════════════════════════
|
|
|
|
func main() {
|
|
showVersion := flag.Bool("version", false, "显示版本信息")
|
|
configFlag := flag.String("config", "", "配置文件路径 (默认: 当前目录 server.yaml)")
|
|
flag.Parse()
|
|
|
|
if *showVersion {
|
|
fmt.Printf("Hardware Monitor Server %s\n", Version)
|
|
fmt.Printf("Build: %s / %s\n", BuildTime, runtime.GOOS+"/"+runtime.GOARCH)
|
|
return
|
|
}
|
|
|
|
base := baseDir() // ★ 改这里
|
|
|
|
cfgPath := *configFlag
|
|
if cfgPath == "" {
|
|
cfgPath = filepath.Join(base, "server.yaml")
|
|
}
|
|
cfg, cfgAbs := loadOrCreateConfig(cfgPath)
|
|
|
|
devicesAbs := resolvePath(filepath.Dir(cfgAbs), cfg.DevicesFile)
|
|
os.MkdirAll(filepath.Dir(devicesAbs), 0755)
|
|
|
|
hub := NewHub(cfg, devicesAbs)
|
|
go hub.CleanStale()
|
|
go hub.StartMinerFetcher()
|
|
|
|
mux := http.NewServeMux()
|
|
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
|
|
if r.URL.Path != "/" {
|
|
http.NotFound(w, r)
|
|
return
|
|
}
|
|
w.Header().Set("Content-Type", "text/html; charset=utf-8")
|
|
fmt.Fprint(w, indexHTML)
|
|
})
|
|
mux.HandleFunc("/ws/agent", func(w http.ResponseWriter, r *http.Request) {
|
|
if c, err := upgrader.Upgrade(w, r, nil); err == nil {
|
|
go handleAgent(c, hub)
|
|
}
|
|
})
|
|
mux.HandleFunc("/ws/monitor", func(w http.ResponseWriter, r *http.Request) {
|
|
if c, err := upgrader.Upgrade(w, r, nil); err == nil {
|
|
go handleMonitor(c, hub)
|
|
}
|
|
})
|
|
|
|
fmt.Println()
|
|
fmt.Println(" ╔═══════════════════════════════════════════╗")
|
|
fmt.Println(" ║ Hardware Monitor Server ║")
|
|
fmt.Printf(" ║ Version %-28s ║\n", Version)
|
|
fmt.Println(" ╠═══════════════════════════════════════════╣")
|
|
fmt.Printf(" ║ Dashboard : http://localhost%-13s ║\n", cfg.Listen)
|
|
fmt.Printf(" ║ Agent WS : ws://localhost%-12s/ws ║\n", cfg.Listen)
|
|
if cfgAbs != "" {
|
|
fmt.Printf(" ║ Config : %-29s║\n", trunc(cfgAbs, 29))
|
|
}
|
|
fmt.Printf(" ║ Devices : %-29s║\n", trunc(devicesAbs, 29))
|
|
if cfg.MinerUID != "" {
|
|
uid := cfg.MinerUID
|
|
if len(uid) > 22 {
|
|
uid = uid[:22] + "..."
|
|
}
|
|
fmt.Printf(" ║ Miner : %-29s║\n", uid)
|
|
} else {
|
|
fmt.Println(" ║ Miner : 未配置 ║")
|
|
}
|
|
fmt.Println(" ╚═══════════════════════════════════════════╝")
|
|
fmt.Println()
|
|
|
|
log.Fatal(http.ListenAndServe(cfg.Listen, mux))
|
|
}
|
|
|
|
func trunc(s string, n int) string {
|
|
if len(s) <= n {
|
|
return s
|
|
}
|
|
return "..." + s[len(s)-n+3:]
|
|
}
|