- 固件: 去掉 deepSleep(D0->RST 跳线依赖), 上电常驻每60秒轮询抓取上报; WiFi 掉线自动重连(30s超时), 失败也POST占位body让服务器记录fail - server: /api/raw 成功/失败均记 ReportRec(时间/来源/结果/客户端数/HTTP码), 持久化 reports.csv, /api/site 返回最近50条 - 看板: 新增"最近推送记录"面板(成功/失败徽标), 移动端兼容 - secrets.h.example 同步轮询版配置说明
617 lines
17 KiB
Go
617 lines
17 KiB
Go
package main
|
|
|
|
import (
|
|
"embed"
|
|
"encoding/csv"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
// SiteData 单个站点的数据(内存态)
|
|
type SiteData struct {
|
|
mu sync.RWMutex
|
|
name string
|
|
devices map[string]*Device
|
|
events []Event
|
|
lastSeen time.Time // 最近一次上报时间(在线判断)
|
|
// raw 模式(ESP8266 原始页面上报)的状态机字段
|
|
rawAbsentToOffline int // 连续缺席多少次判定下线(防抖)
|
|
rawAbsent map[string]int // mac -> 连续缺席次数
|
|
// reports 每次上报记录(含成功/失败),环形保留最近 50 条,持久化到 reports.csv
|
|
reports []ReportRec
|
|
}
|
|
|
|
// ReportRec 一次上报记录
|
|
type ReportRec struct {
|
|
Time time.Time `json:"time"`
|
|
Source string `json:"source"` // 上报来源(esp8266 序列号 / 客户端 IP / "report")
|
|
Result string `json:"result"` // ok / fail
|
|
Detail string `json:"detail"` // 错误或结果说明
|
|
Clients int `json:"clients"` // 成功时解析到的客户端数
|
|
Code int `json:"code"` // 收到/返回的 HTTP 码
|
|
}
|
|
|
|
// Server 服务器(server 模式)
|
|
type Server struct {
|
|
dataDir string
|
|
token string // 访问令牌,空则不校验
|
|
retainDays int
|
|
|
|
mu sync.RWMutex
|
|
sites map[string]*SiteData
|
|
// 站点名字→sig 用于展示
|
|
siteNames map[string]string
|
|
}
|
|
|
|
// ServerConfig server 模式配置
|
|
type ServerConfig struct {
|
|
Addr string
|
|
DataDir string
|
|
Token string
|
|
RetainDays int
|
|
}
|
|
|
|
func runServer(cfg ServerConfig) {
|
|
if cfg.RetainDays <= 0 {
|
|
cfg.RetainDays = 7
|
|
}
|
|
if err := os.MkdirAll(cfg.DataDir, 0755); err != nil {
|
|
fmt.Fprintf(os.Stderr, "创建数据目录失败: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
s := &Server{
|
|
dataDir: cfg.DataDir,
|
|
token: cfg.Token,
|
|
retainDays: cfg.RetainDays,
|
|
sites: make(map[string]*SiteData),
|
|
siteNames: make(map[string]string),
|
|
}
|
|
s.loadAll()
|
|
|
|
mux := http.NewServeMux()
|
|
mux.HandleFunc("/", s.handleIndex)
|
|
mux.HandleFunc("/api/report", s.handleReport)
|
|
mux.HandleFunc("/api/raw", s.handleRaw)
|
|
mux.HandleFunc("/api/sites", s.handleSites)
|
|
mux.HandleFunc("/api/site", s.handleSite)
|
|
srv := &http.Server{Addr: cfg.Addr, Handler: mux}
|
|
fmt.Printf("[%s] 看板服务器启动: http://%s | 数据目录 %s | 保留 %d 天\n",
|
|
time.Now().Format("2006-01-02 15:04:05"), cfg.Addr, cfg.DataDir, cfg.RetainDays)
|
|
if cfg.Token != "" {
|
|
fmt.Printf("[%s] 令牌认证: 启用\n", time.Now().Format("2006-01-02 15:04:05"))
|
|
} else {
|
|
fmt.Printf("[%s] 警告: 未设置令牌,任何人可上报/查看数据\n", time.Now().Format("2006-01-02 15:04:05"))
|
|
}
|
|
if err := srv.ListenAndServe(); err != nil {
|
|
fmt.Fprintf(os.Stderr, "服务器错误: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
// authOK 校验请求令牌
|
|
func (s *Server) authOK(r *http.Request) bool {
|
|
if s.token == "" {
|
|
return true
|
|
}
|
|
return r.Header.Get("X-Token") == s.token ||
|
|
r.URL.Query().Get("token") == s.token
|
|
}
|
|
|
|
func (s *Server) handleIndex(w http.ResponseWriter, r *http.Request) {
|
|
if r.URL.Path != "/" {
|
|
http.NotFound(w, r)
|
|
return
|
|
}
|
|
data, err := dashboardFS.ReadFile("web/dashboard.html")
|
|
if err != nil {
|
|
http.Error(w, "页面加载失败", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
if !s.authOK(r) {
|
|
http.Error(w, "403: 需要令牌(URL加 ?token=xxx 或 Header X-Token)", http.StatusForbidden)
|
|
return
|
|
}
|
|
w.Header().Set("Content-Type", "text/html; charset=utf-8")
|
|
w.Write(data)
|
|
}
|
|
|
|
// applyClients 将一次采集到的客户端列表应用到站点状态机:
|
|
// 产生 上线/下线 事件并追加到 sd.events。
|
|
// 调用方必须持有 sd.mu 写锁。
|
|
func (sd *SiteData) applyClients(now time.Time, clients []Client, absentToOffline int) error {
|
|
if sd.rawAbsent == nil {
|
|
sd.rawAbsent = make(map[string]int)
|
|
}
|
|
seen := make(map[string]bool, len(clients))
|
|
for _, c := range clients {
|
|
mac := c.MAC
|
|
if mac == "" {
|
|
continue
|
|
}
|
|
dev := sd.devices[mac]
|
|
if dev == nil {
|
|
dev = &Device{MAC: mac, Status: evOffline}
|
|
sd.devices[mac] = dev
|
|
}
|
|
dev.Name = c.Name
|
|
dev.LastIP = c.IP
|
|
if dev.FirstSeen.IsZero() {
|
|
dev.FirstSeen = now
|
|
}
|
|
if dev.Status == evOffline {
|
|
// 上线事件
|
|
dev.Status = evOnline
|
|
dev.OnlineCount++
|
|
t := now
|
|
dev.LastOnline = &t
|
|
sd.rawAbsent[mac] = 0
|
|
sd.recordRawEvent(now, evOnline, mac, c.IP, c.Name, c.LeaseDur)
|
|
}
|
|
seen[mac] = true
|
|
}
|
|
|
|
// 判定下线: 本次未出现的在线设备
|
|
for mac, dev := range sd.devices {
|
|
if dev.Status != evOnline || seen[mac] {
|
|
continue
|
|
}
|
|
sd.rawAbsent[mac]++
|
|
if sd.rawAbsent[mac] >= absentToOffline {
|
|
dev.Status = evOffline
|
|
t := now
|
|
dev.LastOffline = &t
|
|
if dev.LastOnline != nil {
|
|
dur := now.Sub(*dev.LastOnline)
|
|
dev.TotalOnline += int64(dur.Seconds())
|
|
h := int(dur.Hours())
|
|
m := int(dur.Minutes()) % 60
|
|
detail := fmt.Sprintf("在线时长 %02dh%02dm; 下线检测误差≤%s(DHCP租约)", h, m, "10m")
|
|
sd.recordRawEvent(now, evOffline, mac, dev.LastIP, dev.Name, detail)
|
|
} else {
|
|
sd.recordRawEvent(now, evOffline, mac, dev.LastIP, dev.Name, "")
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// recordRawEvent 追加一条事件到站点内存事件列表(raw 模式)
|
|
func (sd *SiteData) recordRawEvent(t time.Time, ev, mac, ip, name, detail string) {
|
|
sd.events = append(sd.events, Event{Timestamp: t, Event: ev, MAC: mac, IP: ip, Name: name, Detail: detail})
|
|
}
|
|
|
|
// handleReport 接收卷端上报
|
|
func (s *Server) handleReport(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodPost {
|
|
http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
|
|
return
|
|
}
|
|
var p ReportPayload
|
|
if err := json.NewDecoder(r.Body).Decode(&p); err != nil {
|
|
http.Error(w, "bad json: "+err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
if s.token != "" && p.Token != s.token {
|
|
http.Error(w, "401: token 错误", http.StatusUnauthorized)
|
|
return
|
|
}
|
|
if p.Site == "" {
|
|
http.Error(w, "site 不能为空", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
now := time.Now()
|
|
// lookup or 创建站点
|
|
s.mu.RLock()
|
|
sd, ok := s.sites[p.Site]
|
|
s.mu.RUnlock()
|
|
if !ok {
|
|
s.mu.Lock()
|
|
if sd, ok = s.sites[p.Site]; !ok {
|
|
sd = &SiteData{name: p.Site, devices: make(map[string]*Device)}
|
|
s.sites[p.Site] = sd
|
|
}
|
|
s.mu.Unlock()
|
|
}
|
|
|
|
sd.mu.Lock()
|
|
sd.lastSeen = now
|
|
|
|
// 合并事件(全量追加)
|
|
recev := 0
|
|
for _, e := range p.Events {
|
|
if e.Timestamp.IsZero() {
|
|
continue
|
|
}
|
|
sd.events = append(sd.events, e)
|
|
recev++
|
|
}
|
|
|
|
// 快照: 以服务器为准覆盖设备状态
|
|
if p.Snapshot != nil && p.Snapshot.Devices != nil {
|
|
for _, d := range p.Snapshot.Devices {
|
|
if d.MAC == "" {
|
|
continue
|
|
}
|
|
prev, existed := sd.devices[d.MAC]
|
|
if existed {
|
|
// 保留服务器已有累计数据,更新在线状态
|
|
prev.Status = d.Status
|
|
prev.Name = d.Name
|
|
prev.LastIP = d.LastIP
|
|
prev.LastOnline = d.LastOnline
|
|
if d.LastOffline != nil {
|
|
prev.LastOffline = d.LastOffline
|
|
}
|
|
if d.OnlineCount > prev.OnlineCount {
|
|
prev.OnlineCount = d.OnlineCount
|
|
}
|
|
if d.TotalOnline > prev.TotalOnline {
|
|
prev.TotalOnline = d.TotalOnline
|
|
}
|
|
if prev.FirstSeen.IsZero() {
|
|
prev.FirstSeen = d.FirstSeen
|
|
}
|
|
} else {
|
|
cp := *d
|
|
sd.devices[d.MAC] = &cp
|
|
}
|
|
}
|
|
}
|
|
sd.mu.Unlock()
|
|
|
|
// 持久化
|
|
s.saveSite(sd)
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(map[string]interface{}{"ok": true, "site": p.Site, "events_received": recev, "time": now})
|
|
}
|
|
|
|
// getOrCreateSite 返回指定站点,不存在则创建(带 raw 状态机默认值)
|
|
func (s *Server) getOrCreateSite(name string) *SiteData {
|
|
s.mu.RLock()
|
|
sd, ok := s.sites[name]
|
|
s.mu.RUnlock()
|
|
if ok {
|
|
return sd
|
|
}
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
if sd, ok = s.sites[name]; !ok {
|
|
sd = &SiteData{name: name, devices: make(map[string]*Device), rawAbsent: make(map[string]int), rawAbsentToOffline: 2}
|
|
s.sites[name] = sd
|
|
}
|
|
return sd
|
|
}
|
|
|
|
// recordReport 追加一条上报记录(环形保留最近 50 条)
|
|
// 调用方需持有 sd.mu 写锁
|
|
func (sd *SiteData) recordReport(t time.Time, source, result, detail string, clients int, code int) {
|
|
sd.reports = append(sd.reports, ReportRec{Time: t, Source: source, Result: result, Detail: detail, Clients: clients, Code: code})
|
|
const maxReports = 50
|
|
if len(sd.reports) > maxReports {
|
|
sd.reports = append([]ReportRec(nil), sd.reports[len(sd.reports)-maxReports:]...)
|
|
}
|
|
}
|
|
|
|
// handleRaw 接收采集端(ESP8266)上报的原始路由器页面 HTML。
|
|
// 认证方式: Header X-Token 或 query ?token,与站点校验一致。
|
|
// site 通过 Header X-Site 或 query ?site 指定。
|
|
// body 为 /userRpm/AssignedIpAddrListRpm.htm 的原始响应。
|
|
// 服务器端解析 DHCPDynList → 做上下线判定 → 记录事件 → 持久化。
|
|
// 每次上报(无论成败)都会记一条 reports 记录。
|
|
func (s *Server) handleRaw(w http.ResponseWriter, r *http.Request) {
|
|
now := time.Now()
|
|
// 来源: 采集端可通过 X-Source 上报自己的标识(如 ESP8266 MAC/序列号),否则用客户端 IP
|
|
source := r.Header.Get("X-Source")
|
|
if source == "" {
|
|
source = r.RemoteAddr
|
|
if i := strings.LastIndex(source, ":"); i >= 0 {
|
|
source = source[:i]
|
|
}
|
|
}
|
|
fail := func(code int, msg string) {
|
|
site := r.Header.Get("X-Site")
|
|
if site == "" {
|
|
site = r.URL.Query().Get("site")
|
|
}
|
|
if site != "" {
|
|
sd := s.getOrCreateSite(site)
|
|
sd.mu.Lock()
|
|
sd.recordReport(now, source, "fail", msg, 0, code)
|
|
sd.mu.Unlock()
|
|
s.saveSite(sd)
|
|
}
|
|
http.Error(w, msg, code)
|
|
}
|
|
|
|
if r.Method != http.MethodPost {
|
|
fail(http.StatusMethodNotAllowed, "method not allowed")
|
|
return
|
|
}
|
|
if !s.authOK(r) {
|
|
fail(http.StatusUnauthorized, "401: token 错误")
|
|
return
|
|
}
|
|
site := r.Header.Get("X-Site")
|
|
if site == "" {
|
|
site = r.URL.Query().Get("site")
|
|
}
|
|
if site == "" {
|
|
fail(http.StatusBadRequest, "缺少 site(Header X-Site 或 query ?site)")
|
|
return
|
|
}
|
|
|
|
body, err := io.ReadAll(r.Body)
|
|
if err != nil {
|
|
fail(http.StatusBadRequest, "读取 body 失败: "+err.Error())
|
|
return
|
|
}
|
|
if len(body) == 0 {
|
|
fail(http.StatusBadRequest, "body 为空")
|
|
return
|
|
}
|
|
|
|
// 服务器端解析
|
|
clients, err := parseDHCPPage(body)
|
|
if err != nil {
|
|
// 解析失败: 可能认证失败(403/锁页)或页面结构变化
|
|
text := string(body)
|
|
switch {
|
|
case strings.Contains(text, "403 Forbidden") || strings.Contains(text, "You have no authority"):
|
|
fail(http.StatusBadGateway, "路由器认证被拒绝(403): 检查采集端密码或路由器锁定")
|
|
return
|
|
case strings.Contains(text, "httpAutErrorArray") || strings.Contains(text, "pcPassword"):
|
|
fail(http.StatusBadGateway, "路由器认证失败: 密码不正确或多次输错被锁定")
|
|
return
|
|
}
|
|
fail(http.StatusBadRequest, "解析失败: "+err.Error())
|
|
return
|
|
}
|
|
|
|
sd := s.getOrCreateSite(site)
|
|
sd.mu.Lock()
|
|
sd.lastSeen = now
|
|
// 缺省防抖次数与 client 默认一致(2 次)
|
|
absent := sd.rawAbsentToOffline
|
|
if absent == 0 {
|
|
absent = 2
|
|
}
|
|
sd.applyClients(now, clients, absent)
|
|
devCount := len(sd.devices)
|
|
sd.recordReport(now, source, "ok", fmt.Sprintf("解析 %d 客户端", len(clients)), len(clients), 200)
|
|
sd.mu.Unlock()
|
|
|
|
// 持久化
|
|
s.saveSite(sd)
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(map[string]interface{}{
|
|
"ok": true,
|
|
"site": site,
|
|
"clients": len(clients),
|
|
"device_count": devCount,
|
|
"time": now,
|
|
})
|
|
}
|
|
|
|
// handleSites 站点列表
|
|
func (s *Server) handleSites(w http.ResponseWriter, r *http.Request) {
|
|
if !s.authOK(r) {
|
|
http.Error(w, "403", http.StatusForbidden)
|
|
return
|
|
}
|
|
s.mu.RLock()
|
|
type siteInfo struct {
|
|
Site string `json:"site"`
|
|
DeviceCount int `json:"device_count"`
|
|
OnlineCount int `json:"online_count"`
|
|
LastSeen string `json:"last_seen"`
|
|
IsOnline bool `json:"is_online"`
|
|
EventCount int `json:"event_count"`
|
|
}
|
|
list := make([]siteInfo, 0, len(s.sites))
|
|
onlineWindow := 3 * time.Minute
|
|
for name, sd := range s.sites {
|
|
sd.mu.RLock()
|
|
devs := len(sd.devices)
|
|
on := 0
|
|
for _, d := range sd.devices {
|
|
if d.Status == evOnline {
|
|
on++
|
|
}
|
|
}
|
|
last := sd.lastSeen
|
|
evc := len(sd.events)
|
|
sd.mu.RUnlock()
|
|
list = append(list, siteInfo{
|
|
Site: name,
|
|
DeviceCount: devs,
|
|
OnlineCount: on,
|
|
LastSeen: last.Format(time.RFC3339),
|
|
IsOnline: time.Since(last) < onlineWindow,
|
|
EventCount: evc,
|
|
})
|
|
}
|
|
s.mu.RUnlock()
|
|
sort.Slice(list, func(i, j int) bool { return list[i].Site < list[j].Site })
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
json.NewEncoder(w).Encode(map[string]interface{}{"sites": list, "retain_days": s.retainDays})
|
|
}
|
|
|
|
// handleSite 单个站点详情
|
|
func (s *Server) handleSite(w http.ResponseWriter, r *http.Request) {
|
|
if !s.authOK(r) {
|
|
http.Error(w, "403", http.StatusForbidden)
|
|
return
|
|
}
|
|
name := r.URL.Query().Get("site")
|
|
if name == "" {
|
|
http.Error(w, "缺少 site 参数", http.StatusBadRequest)
|
|
return
|
|
}
|
|
s.mu.RLock()
|
|
sd, ok := s.sites[name]
|
|
s.mu.RUnlock()
|
|
if !ok {
|
|
http.Error(w, "站点不存在", http.StatusNotFound)
|
|
return
|
|
}
|
|
|
|
sd.mu.RLock()
|
|
devs := make([]*Device, 0, len(sd.devices))
|
|
for _, d := range sd.devices {
|
|
cp := *d
|
|
devs = append(devs, &cp)
|
|
}
|
|
evs := append([]Event(nil), sd.events...)
|
|
reps := append([]ReportRec(nil), sd.reports...)
|
|
last := sd.lastSeen
|
|
sd.mu.RUnlock()
|
|
|
|
sort.Slice(devs, func(a, b int) bool {
|
|
if devs[a].Status != devs[b].Status {
|
|
return devs[a].Status == evOnline
|
|
}
|
|
return devs[a].MAC < devs[b].MAC
|
|
})
|
|
// 事件最新在前
|
|
for i, j := 0, len(evs)-1; i < j; i, j = i+1, j-1 {
|
|
evs[i], evs[j] = evs[j], evs[i]
|
|
}
|
|
// 上报记录最新在前
|
|
for i, j := 0, len(reps)-1; i < j; i, j = i+1, j-1 {
|
|
reps[i], reps[j] = reps[j], reps[i]
|
|
}
|
|
limit := 200
|
|
if v := r.URL.Query().Get("limit"); v != "" {
|
|
fmt.Sscanf(v, "%d", &limit)
|
|
}
|
|
if len(evs) > limit {
|
|
evs = evs[:limit]
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
json.NewEncoder(w).Encode(map[string]interface{}{
|
|
"site": name,
|
|
"devices": devs,
|
|
"events": evs,
|
|
"reports": reps,
|
|
"last_seen": last.Format(time.RFC3339),
|
|
"retain_days": s.retainDays,
|
|
})
|
|
}
|
|
|
|
// saveSite 持久化单站点数据
|
|
func (s *Server) saveSite(sd *SiteData) {
|
|
dir := filepath.Join(s.dataDir, "sites", sanitize(sd.name))
|
|
if err := os.MkdirAll(dir, 0755); err != nil {
|
|
fmt.Fprintf(os.Stderr, "创建站点目录失败: %v\n", err)
|
|
return
|
|
}
|
|
sd.mu.RLock()
|
|
defer sd.mu.RUnlock()
|
|
|
|
// devices.json
|
|
devData, _ := json.MarshalIndent(sd.devices, "", " ")
|
|
os.WriteFile(filepath.Join(dir, "devices.json"), devData, 0644)
|
|
|
|
// events.csv (增量快照: 全量重写,简单可靠,数据量小)
|
|
f, err := os.Create(filepath.Join(dir, "events.csv"))
|
|
if err == nil {
|
|
w := csv.NewWriter(f)
|
|
w.Write([]string{"timestamp", "event", "mac", "ip", "name", "detail"})
|
|
for _, e := range sd.events {
|
|
w.Write([]string{e.Timestamp.Format(time.RFC3339), e.Event, e.MAC, e.IP, e.Name, e.Detail})
|
|
}
|
|
w.Flush()
|
|
f.Close()
|
|
}
|
|
|
|
// reports.csv (每次上报记录)
|
|
f2, err := os.Create(filepath.Join(dir, "reports.csv"))
|
|
if err == nil {
|
|
w := csv.NewWriter(f2)
|
|
w.Write([]string{"timestamp", "source", "result", "detail", "clients", "code"})
|
|
for _, rp := range sd.reports {
|
|
w.Write([]string{rp.Time.Format(time.RFC3339), rp.Source, rp.Result, rp.Detail, strconv.Itoa(rp.Clients), strconv.Itoa(rp.Code)})
|
|
}
|
|
w.Flush()
|
|
f2.Close()
|
|
}
|
|
}
|
|
|
|
// sanitize 站点名防目录穿越
|
|
func sanitize(name string) string {
|
|
name = strings.ReplaceAll(name, "..", "_")
|
|
name = strings.ReplaceAll(name, "/", "_")
|
|
name = strings.ReplaceAll(name, "\\", "_")
|
|
return name
|
|
}
|
|
|
|
// loadAll 启动时加载所有站点数据
|
|
func (s *Server) loadAll() {
|
|
base := filepath.Join(s.dataDir, "sites")
|
|
entries, err := os.ReadDir(base)
|
|
if err != nil {
|
|
return // 目录不存在,首次运行
|
|
}
|
|
for _, e := range entries {
|
|
if !e.IsDir() {
|
|
continue
|
|
}
|
|
name := e.Name()
|
|
sd := &SiteData{name: name, devices: make(map[string]*Device)}
|
|
dir := filepath.Join(base, name)
|
|
|
|
if b, err := os.ReadFile(filepath.Join(dir, "devices.json")); err == nil {
|
|
json.Unmarshal(b, &sd.devices)
|
|
}
|
|
if rows, err := readCSV(filepath.Join(dir, "events.csv")); err == nil && len(rows) > 1 {
|
|
for _, r := range rows[1:] {
|
|
if len(r) < 6 {
|
|
continue
|
|
}
|
|
t, err := time.Parse(time.RFC3339, r[0])
|
|
if err != nil {
|
|
continue
|
|
}
|
|
sd.events = append(sd.events, Event{Timestamp: t, Event: r[1], MAC: r[2], IP: r[3], Name: r[4], Detail: r[5]})
|
|
}
|
|
}
|
|
if rows, err := readCSV(filepath.Join(dir, "reports.csv")); err == nil && len(rows) > 1 {
|
|
for _, r := range rows[1:] {
|
|
if len(r) < 6 {
|
|
continue
|
|
}
|
|
t, err := time.Parse(time.RFC3339, r[0])
|
|
if err != nil {
|
|
continue
|
|
}
|
|
clients, _ := strconv.Atoi(r[4])
|
|
code, _ := strconv.Atoi(r[5])
|
|
sd.reports = append(sd.reports, ReportRec{Time: t, Source: r[1], Result: r[2], Detail: r[3], Clients: clients, Code: code})
|
|
}
|
|
}
|
|
if len(sd.devices) > 0 || len(sd.events) > 0 {
|
|
sd.lastSeen = time.Now().Add(-24 * time.Hour) // 重启后推测离线
|
|
s.mu.Lock()
|
|
s.sites[name] = sd
|
|
s.mu.Unlock()
|
|
}
|
|
}
|
|
fmt.Printf("[%s] 已加载 %d 个站点\n", time.Now().Format("2006-01-02 15:04:05"), len(s.sites))
|
|
}
|
|
|
|
//go:embed web/dashboard.html
|
|
var dashboardFS embed.FS
|