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