433 lines
11 KiB
Go
433 lines
11 KiB
Go
package web
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"fmt"
|
|
"html/template"
|
|
"io"
|
|
"io/fs"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"3588AdminBackend/internal/models"
|
|
"3588AdminBackend/internal/service"
|
|
"github.com/go-chi/chi/v5"
|
|
)
|
|
|
|
type UI struct {
|
|
discovery *service.DiscoveryService
|
|
registry *service.RegistryService
|
|
agent *service.AgentClient
|
|
tasks *service.TaskService
|
|
templates *service.TemplateService
|
|
|
|
tpl *template.Template
|
|
}
|
|
|
|
type PageData struct {
|
|
Title string
|
|
ContentHTML template.HTML
|
|
Message string
|
|
Error string
|
|
|
|
DeviceCount int
|
|
OnlineCount int
|
|
OfflineCount int
|
|
FoundCount int
|
|
|
|
Devices []*models.Device
|
|
Found []*models.Device
|
|
Device *models.Device
|
|
Tasks []models.Task
|
|
Task *models.Task
|
|
Templates []service.Template
|
|
Template *service.Template
|
|
|
|
RawJSON string
|
|
RawText string
|
|
TaskID string
|
|
DeviceIDs string
|
|
}
|
|
|
|
func NewUI(discovery *service.DiscoveryService, registry *service.RegistryService, agent *service.AgentClient, tasks *service.TaskService, templates *service.TemplateService) (*UI, error) {
|
|
tpl, err := template.New("layout").Funcs(template.FuncMap{
|
|
"json": func(v any) string {
|
|
b, _ := json.MarshalIndent(v, "", " ")
|
|
return string(b)
|
|
},
|
|
"ago": func(ms int64) string {
|
|
if ms <= 0 {
|
|
return "-"
|
|
}
|
|
d := time.Since(time.UnixMilli(ms))
|
|
if d < 0 {
|
|
d = 0
|
|
}
|
|
s := int64(d.Seconds())
|
|
switch {
|
|
case s < 60:
|
|
return fmt.Sprintf("%d秒前", s)
|
|
case s < 3600:
|
|
return fmt.Sprintf("%d分钟前", s/60)
|
|
case s < 86400:
|
|
return fmt.Sprintf("%d小时前", s/3600)
|
|
default:
|
|
return fmt.Sprintf("%d天前", s/86400)
|
|
}
|
|
},
|
|
}).ParseFS(uiFS, "ui/templates/*.html")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &UI{
|
|
discovery: discovery,
|
|
registry: registry,
|
|
agent: agent,
|
|
tasks: tasks,
|
|
templates: templates,
|
|
tpl: tpl,
|
|
}, nil
|
|
}
|
|
|
|
func (u *UI) Routes() (chi.Router, error) {
|
|
r := chi.NewRouter()
|
|
|
|
assets, err := fs.Sub(uiFS, "ui/assets")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
assetHandler := http.StripPrefix("/assets/", http.FileServer(http.FS(assets)))
|
|
r.Handle("/assets/*", http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
|
|
p := req.URL.Path
|
|
switch {
|
|
case strings.HasSuffix(p, ".css"):
|
|
w.Header().Set("Content-Type", "text/css; charset=utf-8")
|
|
case strings.HasSuffix(p, ".js"):
|
|
w.Header().Set("Content-Type", "text/javascript; charset=utf-8")
|
|
}
|
|
assetHandler.ServeHTTP(w, req)
|
|
}))
|
|
|
|
r.Get("/", func(w http.ResponseWriter, r *http.Request) {
|
|
http.Redirect(w, r, "/ui/devices", http.StatusFound)
|
|
})
|
|
|
|
r.Get("/devices", u.pageDevices)
|
|
r.Post("/discovery/search", u.actionDiscoverySearch)
|
|
r.Get("/devices/{id}", u.pageDevice)
|
|
r.Post("/devices/{id}/action", u.actionDeviceAction)
|
|
r.Get("/devices/{id}/logs", u.pageDeviceLogs)
|
|
r.Get("/devices/{id}/graphs", u.pageDeviceGraphs)
|
|
r.Post("/devices/{id}/config/apply", u.actionDeviceConfigApply)
|
|
r.Post("/devices/{id}/models/upload", u.actionDeviceModelUpload)
|
|
|
|
r.Get("/tasks", u.pageTasks)
|
|
r.Post("/tasks", u.actionCreateTask)
|
|
r.Get("/tasks/{id}", u.pageTask)
|
|
|
|
r.Get("/templates", u.pageTemplates)
|
|
r.Get("/templates/{name}", u.pageTemplate)
|
|
|
|
r.Get("/api", u.pageAPIConsole)
|
|
|
|
return r, nil
|
|
}
|
|
|
|
func (u *UI) render(w http.ResponseWriter, r *http.Request, content string, data PageData) {
|
|
var buf bytes.Buffer
|
|
if err := u.tpl.ExecuteTemplate(&buf, content, data); err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
data.ContentHTML = template.HTML(buf.String())
|
|
|
|
w.Header().Set("Content-Type", "text/html; charset=utf-8")
|
|
if err := u.tpl.ExecuteTemplate(w, "layout", data); err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
}
|
|
|
|
func (u *UI) findDevice(id string) (*models.Device, bool) {
|
|
devices := u.registry.GetDevices()
|
|
for _, d := range devices {
|
|
if d.DeviceID == id {
|
|
return d, true
|
|
}
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
func (u *UI) pageDevices(w http.ResponseWriter, r *http.Request) {
|
|
devices := u.registry.GetDevices()
|
|
online := 0
|
|
for _, d := range devices {
|
|
if d.Online {
|
|
online++
|
|
}
|
|
}
|
|
u.render(w, r, "devices", PageData{
|
|
Title: "设备",
|
|
Devices: devices,
|
|
DeviceCount: len(devices),
|
|
OnlineCount: online,
|
|
OfflineCount: len(devices) - online,
|
|
})
|
|
}
|
|
|
|
func (u *UI) actionDiscoverySearch(w http.ResponseWriter, r *http.Request) {
|
|
_ = r.ParseForm()
|
|
timeoutMs, _ := strconv.Atoi(strings.TrimSpace(r.FormValue("timeout_ms")))
|
|
if timeoutMs <= 0 {
|
|
timeoutMs = 1200
|
|
}
|
|
|
|
found, err := u.discovery.Search(timeoutMs)
|
|
devices := u.registry.GetDevices()
|
|
online := 0
|
|
for _, d := range devices {
|
|
if d.Online {
|
|
online++
|
|
}
|
|
}
|
|
data := PageData{Title: "设备", Devices: devices, Found: found, FoundCount: len(found), DeviceCount: len(devices), OnlineCount: online, OfflineCount: len(devices) - online}
|
|
if err != nil {
|
|
data.Error = err.Error()
|
|
}
|
|
u.render(w, r, "devices", data)
|
|
}
|
|
|
|
func (u *UI) pageDevice(w http.ResponseWriter, r *http.Request) {
|
|
id := chi.URLParam(r, "id")
|
|
dev, ok := u.findDevice(id)
|
|
if !ok {
|
|
http.NotFound(w, r)
|
|
return
|
|
}
|
|
u.render(w, r, "device", PageData{Title: "设备详情", Device: dev})
|
|
}
|
|
|
|
func (u *UI) actionDeviceAction(w http.ResponseWriter, r *http.Request) {
|
|
id := chi.URLParam(r, "id")
|
|
dev, ok := u.findDevice(id)
|
|
if !ok {
|
|
http.NotFound(w, r)
|
|
return
|
|
}
|
|
_ = r.ParseForm()
|
|
action := strings.TrimSpace(r.FormValue("action"))
|
|
|
|
method := "POST"
|
|
path := ""
|
|
switch action {
|
|
case "reload":
|
|
path = "/v1/media-server/reload"
|
|
case "rollback":
|
|
path = "/v1/media-server/rollback"
|
|
case "media_start":
|
|
path = "/v1/media-server/start"
|
|
case "media_restart":
|
|
path = "/v1/media-server/restart"
|
|
case "media_stop":
|
|
path = "/v1/media-server/stop"
|
|
case "media_status":
|
|
method = "GET"
|
|
path = "/v1/media-server/status"
|
|
case "info":
|
|
method = "GET"
|
|
path = "/v1/info"
|
|
default:
|
|
http.Error(w, "unknown action", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
body, code, err := u.agent.Do(method, dev.IP, dev.AgentPort, path, nil)
|
|
msg := fmt.Sprintf("%s %s -> %d", method, path, code)
|
|
data := PageData{Title: "设备详情", Device: dev, Message: msg, RawText: string(body)}
|
|
if err != nil {
|
|
data.Error = err.Error()
|
|
}
|
|
u.render(w, r, "device", data)
|
|
}
|
|
|
|
func (u *UI) pageDeviceLogs(w http.ResponseWriter, r *http.Request) {
|
|
id := chi.URLParam(r, "id")
|
|
dev, ok := u.findDevice(id)
|
|
if !ok {
|
|
http.NotFound(w, r)
|
|
return
|
|
}
|
|
limit := strings.TrimSpace(r.URL.Query().Get("limit"))
|
|
path := "/v1/logs/recent"
|
|
if limit != "" {
|
|
path += "?limit=" + urlQueryEscape(limit)
|
|
}
|
|
|
|
body, code, err := u.agent.Do("GET", dev.IP, dev.AgentPort, path, nil)
|
|
data := PageData{Title: "设备日志", Device: dev, Message: fmt.Sprintf("GET %s -> %d", path, code), RawText: string(body)}
|
|
if err != nil {
|
|
data.Error = err.Error()
|
|
}
|
|
u.render(w, r, "device_logs", data)
|
|
}
|
|
|
|
func (u *UI) pageDeviceGraphs(w http.ResponseWriter, r *http.Request) {
|
|
id := chi.URLParam(r, "id")
|
|
dev, ok := u.findDevice(id)
|
|
if !ok {
|
|
http.NotFound(w, r)
|
|
return
|
|
}
|
|
body, code, err := u.agent.Do("GET", dev.IP, dev.AgentPort, "/v1/graphs", nil)
|
|
data := PageData{Title: "设备图表", Device: dev, Message: fmt.Sprintf("GET /v1/graphs -> %d", code), RawText: string(body)}
|
|
if err != nil {
|
|
data.Error = err.Error()
|
|
}
|
|
u.render(w, r, "device_graphs", data)
|
|
}
|
|
|
|
func (u *UI) actionDeviceConfigApply(w http.ResponseWriter, r *http.Request) {
|
|
id := chi.URLParam(r, "id")
|
|
dev, ok := u.findDevice(id)
|
|
if !ok {
|
|
http.NotFound(w, r)
|
|
return
|
|
}
|
|
_ = r.ParseForm()
|
|
raw := strings.TrimSpace(r.FormValue("json"))
|
|
if raw == "" {
|
|
raw = `{"config":{}}`
|
|
}
|
|
|
|
body, code, err := u.agent.Do("PUT", dev.IP, dev.AgentPort, "/v1/config", []byte(raw))
|
|
data := PageData{Title: "设备详情", Device: dev, Message: fmt.Sprintf("PUT /v1/config -> %d", code), RawText: string(body), RawJSON: raw}
|
|
if err != nil {
|
|
data.Error = err.Error()
|
|
}
|
|
u.render(w, r, "device", data)
|
|
}
|
|
|
|
func (u *UI) actionDeviceModelUpload(w http.ResponseWriter, r *http.Request) {
|
|
id := chi.URLParam(r, "id")
|
|
dev, ok := u.findDevice(id)
|
|
if !ok {
|
|
http.NotFound(w, r)
|
|
return
|
|
}
|
|
|
|
if err := r.ParseMultipartForm(100 << 20); err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
name := strings.TrimSpace(r.FormValue("name"))
|
|
file, _, err := r.FormFile("file")
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
defer file.Close()
|
|
if name == "" {
|
|
http.Error(w, "name is required", http.StatusBadRequest)
|
|
return
|
|
}
|
|
data, err := io.ReadAll(file)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
path := fmt.Sprintf("/v1/models/%s", name)
|
|
resp, code, derr := u.agent.Do("PUT", dev.IP, dev.AgentPort, path, data)
|
|
out := PageData{Title: "设备详情", Device: dev, Message: fmt.Sprintf("PUT %s -> %d", path, code), RawText: string(resp)}
|
|
if derr != nil {
|
|
out.Error = derr.Error()
|
|
}
|
|
u.render(w, r, "device", out)
|
|
}
|
|
|
|
func (u *UI) pageTasks(w http.ResponseWriter, r *http.Request) {
|
|
u.render(w, r, "tasks", PageData{Title: "任务", Tasks: u.tasks.ListTasks(), Devices: u.registry.GetDevices()})
|
|
}
|
|
|
|
func (u *UI) actionCreateTask(w http.ResponseWriter, r *http.Request) {
|
|
_ = r.ParseForm()
|
|
typeStr := strings.TrimSpace(r.FormValue("type"))
|
|
if typeStr == "" {
|
|
typeStr = "config_apply"
|
|
}
|
|
ids := strings.TrimSpace(r.FormValue("device_ids"))
|
|
var deviceIDs []string
|
|
for _, p := range strings.Split(ids, ",") {
|
|
p = strings.TrimSpace(p)
|
|
if p != "" {
|
|
deviceIDs = append(deviceIDs, p)
|
|
}
|
|
}
|
|
raw := strings.TrimSpace(r.FormValue("payload_json"))
|
|
if raw == "" {
|
|
raw = `{"config":{}}`
|
|
}
|
|
var payload any
|
|
if err := json.Unmarshal([]byte(raw), &payload); err != nil {
|
|
u.render(w, r, "tasks", PageData{Title: "任务", Tasks: u.tasks.ListTasks(), Devices: u.registry.GetDevices(), Error: "payload_json 无效: " + err.Error(), RawJSON: raw, DeviceIDs: ids})
|
|
return
|
|
}
|
|
|
|
task, err := u.tasks.CreateTask(typeStr, deviceIDs, payload)
|
|
if err != nil {
|
|
u.render(w, r, "tasks", PageData{Title: "任务", Tasks: u.tasks.ListTasks(), Devices: u.registry.GetDevices(), Error: err.Error(), RawJSON: raw, DeviceIDs: ids})
|
|
return
|
|
}
|
|
http.Redirect(w, r, "/ui/tasks/"+task.ID, http.StatusFound)
|
|
}
|
|
|
|
func (u *UI) pageTask(w http.ResponseWriter, r *http.Request) {
|
|
id := chi.URLParam(r, "id")
|
|
items := u.tasks.ListTasks()
|
|
var task *models.Task
|
|
for i := range items {
|
|
if items[i].ID == id {
|
|
t := items[i]
|
|
task = &t
|
|
break
|
|
}
|
|
}
|
|
if task == nil {
|
|
http.NotFound(w, r)
|
|
return
|
|
}
|
|
u.render(w, r, "task", PageData{Title: "任务详情", Task: task, TaskID: id})
|
|
}
|
|
|
|
func (u *UI) pageTemplates(w http.ResponseWriter, r *http.Request) {
|
|
list, err := u.templates.ListTemplates()
|
|
data := PageData{Title: "模板", Templates: list}
|
|
if err != nil {
|
|
data.Error = err.Error()
|
|
}
|
|
u.render(w, r, "templates", data)
|
|
}
|
|
|
|
func (u *UI) pageTemplate(w http.ResponseWriter, r *http.Request) {
|
|
name := chi.URLParam(r, "name")
|
|
t, err := u.templates.GetTemplate(name)
|
|
if err != nil {
|
|
http.NotFound(w, r)
|
|
return
|
|
}
|
|
u.render(w, r, "template", PageData{Title: "模板详情", Template: t})
|
|
}
|
|
|
|
func (u *UI) pageAPIConsole(w http.ResponseWriter, r *http.Request) {
|
|
u.render(w, r, "api", PageData{Title: "接口调试"})
|
|
}
|
|
|
|
func urlQueryEscape(s string) string {
|
|
r := strings.NewReplacer("%", "%25", " ", "%20", "+", "%2B", "&", "%26", "=", "%3D", "?", "%3F")
|
|
return r.Replace(s)
|
|
}
|