134 lines
3.6 KiB
Go
134 lines
3.6 KiB
Go
// Module viewLogs — streaming journalctl via WebSocket.
|
|
// Dépôt indépendant : https://git.geronzi.fr/proxmoxPanel/viewLogs
|
|
package viewlogs
|
|
|
|
import (
|
|
_ "embed"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"git.geronzi.fr/proxmoxPanel/core/backend/modules"
|
|
gorillaws "github.com/gorilla/websocket"
|
|
)
|
|
|
|
//go:embed frontend/logs.html
|
|
var logsHTML []byte
|
|
|
|
// LogsModule gère la lecture des journaux systemd via journalctl.
|
|
type LogsModule struct{}
|
|
|
|
// New crée un LogsModule.
|
|
func New() *LogsModule { return &LogsModule{} }
|
|
|
|
func (m *LogsModule) ID() string { return "viewLogs" }
|
|
|
|
// Register enregistre les routes du module dans le CORE.
|
|
func (m *LogsModule) Register(r modules.Registry) error {
|
|
r.RegisterNavItem(modules.NavItemDef{
|
|
ID: "viewLogs",
|
|
Href: "/viewLogs/logs.html",
|
|
Icon: "lnid-scroll-angular-1",
|
|
Color: "#38bdf8",
|
|
LabelKey: "nav.logs",
|
|
})
|
|
r.RegisterPublicRoute("GET", "/viewLogs/logs.html", func(w http.ResponseWriter, req *http.Request) {
|
|
w.Header().Set("Content-Type", "text/html; charset=utf-8")
|
|
w.Write(logsHTML)
|
|
})
|
|
r.RegisterRoute("GET", "/api/logs/units", m.listUnits(r), false)
|
|
r.RegisterRoute("GET", "/ws/logs", m.streamLogs(r), false)
|
|
return nil
|
|
}
|
|
|
|
// listUnits retourne la liste des unités systemd présentes dans les journaux.
|
|
func (m *LogsModule) listUnits(r modules.Registry) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, req *http.Request) {
|
|
target := req.URL.Query().Get("target")
|
|
if target == "" {
|
|
target = "host"
|
|
}
|
|
out, _ := r.RunOnTarget(target, "journalctl --field=_SYSTEMD_UNIT --no-pager 2>/dev/null | sort -u | head -300")
|
|
units := []string{}
|
|
for _, line := range strings.Split(out, "\n") {
|
|
line = strings.TrimSpace(line)
|
|
if line != "" {
|
|
units = append(units, line)
|
|
}
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(units)
|
|
}
|
|
}
|
|
|
|
// wsUpgrader pour les WebSockets du module.
|
|
var wsUpgrader = gorillaws.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}
|
|
|
|
// streamLogs ouvre un WebSocket et stream journalctl via SSH.
|
|
func (m *LogsModule) streamLogs(r modules.Registry) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, req *http.Request) {
|
|
target := req.URL.Query().Get("target")
|
|
if target == "" {
|
|
target = "host"
|
|
}
|
|
unit := sanitizeUnit(req.URL.Query().Get("unit"))
|
|
linesStr := req.URL.Query().Get("lines")
|
|
lines := 100
|
|
if n, err := strconv.Atoi(linesStr); err == nil && n > 0 && n <= 2000 {
|
|
lines = n
|
|
}
|
|
|
|
conn, err := wsUpgrader.Upgrade(w, req, nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
defer conn.Close()
|
|
|
|
args := fmt.Sprintf("-f --no-pager -n %d", lines)
|
|
if unit != "" {
|
|
args += " -u " + unit
|
|
}
|
|
|
|
// Pour les cibles LXC, StreamOnTarget wrappera via pct exec
|
|
// On passe la commande journalctl directement ; buildTargetCmd dans le registry gère le wrapping
|
|
cmd := "journalctl " + args
|
|
|
|
output := make(chan string, 100)
|
|
if err := r.StreamOnTarget(target, cmd, output); err != nil {
|
|
conn.WriteMessage(gorillaws.TextMessage, []byte("Erreur : "+err.Error()))
|
|
return
|
|
}
|
|
|
|
done := make(chan struct{})
|
|
go func() {
|
|
defer close(done)
|
|
for chunk := range output {
|
|
if err := conn.WriteMessage(gorillaws.TextMessage, []byte(chunk)); err != nil {
|
|
break
|
|
}
|
|
}
|
|
}()
|
|
|
|
// Attendre fermeture WS
|
|
for {
|
|
_, _, err := conn.ReadMessage()
|
|
if err != nil {
|
|
break
|
|
}
|
|
}
|
|
<-done
|
|
}
|
|
}
|
|
|
|
func sanitizeUnit(unit string) string {
|
|
for _, c := range unit {
|
|
ok := (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
|
|
(c >= '0' && c <= '9') || c == '-' || c == '.' || c == '_' || c == '@' || c == ':'
|
|
if !ok {
|
|
return ""
|
|
}
|
|
}
|
|
return unit
|
|
}
|