main.go

package main

import (
	"bufio"
	_ "embed"
	"encoding/json"
	"fmt"
	"html/template"
	"log"
	"net/http"
	"os"
	"os/exec"
	"strconv"
	"strings"
	"sync"
	"time"
)

//go:embed static/index.html
var indexHTML string

var tmpl = template.Must(template.New("page").Funcs(template.FuncMap{
	"divf": func(a, b int64) float64 { return float64(a) / float64(b) },
}).Parse(indexHTML))

type Tunnel struct {
	Name      string  `json:"name"`
	Interface string  `json:"interface"`
	LocalIP   string  `json:"local_ip"`
	PeerIP    string  `json:"peer_ip"`
	Role      string  `json:"role"`
	Status    string  `json:"status"`
	PeerAlive bool    `json:"peer_alive"`
	BytesIn   int64   `json:"bytes_in"`
	BytesOut  int64   `json:"bytes_out"`
	RateIn    float64 `json:"rate_in_kbps"`
	RateOut   float64 `json:"rate_out_kbps"`
}

type Service struct {
	Name   string `json:"name"`
	Active bool   `json:"active"`
}

type Status struct {
	Hostname   string    `json:"hostname"`
	RemoteName string    `json:"remote_name"`
	Timestamp  string    `json:"timestamp"`
	Tunnels    []Tunnel  `json:"tunnels"`
	Services   []Service `json:"services"`
	TotalIn    int64     `json:"total_in_bytes"`
	TotalOut   int64     `json:"total_out_bytes"`
}

type TrafficSample struct {
	BytesIn  int64
	BytesOut int64
	Time     time.Time
}

type Monitor struct {
	mu               sync.Mutex
	status           Status
	prevTraffic      map[string]TrafficSample
	prevTunnelStatus map[string]string
	lastNotify       map[string]time.Time
	mailTo           string
}

var remoteNames = map[string]string{
	"Phicomm-N1": "Panther-X2",
	"Panther-X2": "Phicomm-N1",
}

func classifyTunnel(localIP string) (name, role string) {
	switch {
	case strings.HasPrefix(localIP, "10.99.0."):
		return "S2S-主", "主"
	case strings.HasPrefix(localIP, "10.99.1."):
		return "S2S-备", "备"
	case strings.HasPrefix(localIP, "10.9.0."), strings.HasPrefix(localIP, "10.10.0."):
		return "VPN", "-"
	default:
		return "未知", "-"
	}
}

func pingOK(addr string) bool {
	return exec.Command("ping", "-c", "1", "-W", "2", addr).Run() == nil
}

func serviceActive(name string) bool {
	out, err := exec.Command("systemctl", "is-active", name).Output()
	return err == nil && strings.TrimSpace(string(out)) == "active"
}

func parseProcNetDev() map[string][2]int64 {
	data, err := os.ReadFile("/proc/net/dev")
	if err != nil {
		return nil
	}
	r := make(map[string][2]int64)
	s := bufio.NewScanner(strings.NewReader(string(data)))
	for s.Scan() {
		l := s.Text()
		if !strings.Contains(l, ":") {
			continue
		}
		f := strings.Fields(l)
		iface := strings.TrimRight(f[0], ":")
		if !strings.HasPrefix(iface, "tun") {
			continue
		}
		in, _ := strconv.ParseInt(f[1], 10, 64)
		out, _ := strconv.ParseInt(f[9], 10, 64)
		r[iface] = [2]int64{in, out}
	}
	return r
}

func listTun() ([]string, error) {
	d, err := os.ReadDir("/sys/class/net")
	if err != nil {
		return nil, err
	}
	var r []string
	for _, e := range d {
		if strings.HasPrefix(e.Name(), "tun") {
			r = append(r, e.Name())
		}
	}
	return r, nil
}

func tunInfo(iface string) (localIP, peerIP string, up bool) {
	out, err := exec.Command("ip", "-o", "addr", "show", iface).Output()
	if err != nil {
		return "", "", false
	}
	s := string(out)
	parts := strings.Split(s, "inet ")
	if len(parts) < 2 {
		return "", "", false
	}
	ff := strings.Fields(parts[1])
	if len(ff) > 0 {
		localIP = strings.Split(ff[0], "/")[0]
	}
	for i, v := range ff {
		if v == "peer" && i+1 < len(ff) {
			peerIP = strings.Split(ff[i+1], "/")[0]
			break
		}
	}
	out2, _ := exec.Command("ip", "link", "show", iface).Output()
	up = strings.Contains(string(out2), "UP")
	return
}

func (m *Monitor) collect() {
	hostname, _ := os.Hostname()
	remoteName := remoteNames[hostname]
	if remoteName == "" {
		remoteName = "远端"
	}
	ifaces, err := listTun()
	if err != nil {
		log.Printf("list tun: %v", err)
		return
	}
	traffic := parseProcNetDev()
	now := time.Now()
	var tunnels []Tunnel
	prev := make(map[string]TrafficSample)
	var totalIn, totalOut int64
	for _, iface := range ifaces {
		localIP, peerIP, up := tunInfo(iface)
		name, role := classifyTunnel(localIP)
		t := Tunnel{
			Name:      name,
			Interface: iface,
			LocalIP:   localIP,
			PeerIP:    peerIP,
			Role:      role,
			Status:    "down",
		}
		if up {
			t.Status = "up"
		}
		if peerIP != "" && up {
			t.PeerAlive = pingOK(peerIP)
		}
		if tr, ok := traffic[iface]; ok {
			t.BytesIn = tr[0]
			t.BytesOut = tr[1]
			totalIn += tr[0]
			totalOut += tr[1]
			if p, ok := m.prevTraffic[iface]; ok {
				elapsed := now.Sub(p.Time).Seconds()
				if elapsed > 0 {
					t.RateIn = float64(tr[0]-p.BytesIn) / elapsed / 1024
					t.RateOut = float64(tr[1]-p.BytesOut) / elapsed / 1024
				}
			}
			prev[iface] = TrafficSample{tr[0], tr[1], now}
		}
		tunnels = append(tunnels, t)
	}
	m.prevTraffic = prev

	for _, t := range tunnels {
		old, seen := m.prevTunnelStatus[t.Interface]
		if seen && old != t.Status && t.Name != "未知" {
			m.notify(t.Name, t.Interface, old, t.Status)
		}
		m.prevTunnelStatus[t.Interface] = t.Status
	}

	services := []Service{
		{"openvpn-server@server", serviceActive("openvpn-server@server")},
		{"openvpn-server@server-tcp", serviceActive("openvpn-server@server-tcp")},
		{"openvpn-server@s2s", serviceActive("openvpn-server@s2s")},
		{"openvpn-client@s2s-backup", serviceActive("openvpn-client@s2s-backup")},
	}
	m.mu.Lock()
	m.status = Status{
		Hostname:   hostname,
		RemoteName: remoteName,
		Timestamp:  now.Format("2006-01-02 15:04:05"),
		Tunnels:    tunnels,
		Services:   services,
		TotalIn:    totalIn,
		TotalOut:   totalOut,
	}
	m.mu.Unlock()
}

func (m *Monitor) notify(name, iface, oldStatus, newStatus string) {
	if m.mailTo == "" {
		return
	}
	if last, ok := m.lastNotify[iface]; ok && time.Since(last) < 60*time.Second {
		return
	}
	m.lastNotify[iface] = time.Now()

	hostname, _ := os.Hostname()
	now := time.Now().Format("2006-01-02 15:04:05")
	subject := fmt.Sprintf("[Tunnel] %s: %s→%s on %s", name, oldStatus, newStatus, hostname)
	body := fmt.Sprintf("隧道: %s (%s)\n本机: %s\n旧状态: %s\n新状态: %s\n时间: %s",
		name, iface, hostname, oldStatus, newStatus, now)

	cmd := exec.Command("msmtp", m.mailTo)
	cmd.Stdin = strings.NewReader(fmt.Sprintf("Subject: %s\n\n%s\n", subject, body))
	if err := cmd.Run(); err != nil {
		log.Printf("mail %s: %v", name, err)
	}
}

func (m *Monitor) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	m.mu.Lock()
	s := m.status
	m.mu.Unlock()
	w.Header().Set("Access-Control-Allow-Origin", "*")
	switch r.URL.Path {
	case "/api/status":
		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(s)
	case "/":
		w.Header().Set("Content-Type", "text/html; charset=utf-8")
		tmpl.Execute(w, s)
	default:
		http.NotFound(w, r)
	}
}

func main() {
	log.SetFlags(log.Lshortfile)
	m := &Monitor{
		prevTraffic:      make(map[string]TrafficSample),
		prevTunnelStatus: make(map[string]string),
		lastNotify:       make(map[string]time.Time),
		mailTo:           os.Getenv("MAIL_TO"),
	}
	m.collect()
	go func() {
		for {
			time.Sleep(3 * time.Second)
			m.collect()
		}
	}()
	http.Handle("/", m)
	addr := "127.0.0.1:8899"
	log.Printf("listen %s", addr)
	if err := http.ListenAndServe(addr, nil); err != nil {
		log.Fatal(err)
	}
}