rtu_linux_services/web-ui.service/web_handler.go

package main

import (
	"bufio"
	"context"
	"encoding/json"
	"fmt"
	"io/fs"
	"net/http"
	"os"
	"os/exec"
	"strconv"
	"strings"
	"sync"
	"time"

	"hnyfkj.com.cn/rtu/linux/baseapp"
	"hnyfkj.com.cn/rtu/linux/utils/jsonrpc2"
)

const noValue = "--"

type LoginReq struct {
	Username string `json:"username"`
	Password string `json:"password"`
}

type LoginResp struct {
	Success bool `json:"success"`
}

func loginHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		w.WriteHeader(http.StatusMethodNotAllowed)
		return
	}

	var req LoginReq
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	ok := req.Username == "admin" && req.Password == "admin123456"

	if ok {
		sessionID := createSession()
		addSession(sessionID)

		http.SetCookie(w, &http.Cookie{
			Name:     "session_id",
			Value:    sessionID,
			Path:     "/",
			HttpOnly: true,
			SameSite: http.SameSiteStrictMode,
		})
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(LoginResp{Success: ok})
}

func logoutHandler(w http.ResponseWriter, r *http.Request) {
	if cookie, err := r.Cookie("session_id"); err == nil {
		sessionMu.Lock()
		delete(sessions, cookie.Value)
		sessionMu.Unlock()
	}

	http.SetCookie(w, &http.Cookie{
		Name:   "session_id",
		Value:  "",
		Path:   "/",
		MaxAge: -1,
	})

	http.Redirect(w, r, "/", http.StatusFound)
}

func getIMEIHandler(w http.ResponseWriter, r *http.Request) {
	data, err := os.ReadFile("/var/device_imei.txt")
	if err != nil {
		w.Write([]byte(noValue))
	} else {
		w.Write(append([]byte("🆔"), data...))
	}
}

func systemRebootHandler(w http.ResponseWriter, r *http.Request) {
	json.NewEncoder(w).Encode(map[string]bool{
		"ok": true,
	})

	go func() {
		time.Sleep(2 * time.Second)
		exec.Command("systemctl", "reboot").Run()
	}()

}

func (ui *WebUI) rootHandler(w http.ResponseWriter, r *http.Request) {
	path := r.URL.Path

	w.Header().Set("Content-Type", "text/html; charset=utf-8")
	w.Header().Set("Cache-Control", "no-store, no-cache, must-revalidate, max-age=0")
	w.Header().Set("Pragma", "no-cache")
	w.Header().Set("Expires", "0")

	// 1, 未登录时, 只能看登录页
	if !checkSession(r) {
		data, err := fs.ReadFile(ui.fs, "login.html")
		if err != nil {
			http.NotFound(w, r)
		} else {
			w.Write(data)
		}
		return
	}

	// 2, 登录成功, 展示应用首页
	if path == "/" {
		data, err := fs.ReadFile(ui.fs, "app.html")
		if err != nil {
			http.NotFound(w, r)
		} else {
			w.Write(data)
		}
		return
	}

	// 3, 在网站内跳转其它功能页
	if strings.HasPrefix(path, "/pages/") { // path 形如 "/pages/page1.html"
		data, err := fs.ReadFile(ui.fs, path[1:])
		if err != nil {
			http.NotFound(w, r)
		} else {
			w.Write(data)
		}
		return
	}

	// 4, 访问其它不认识的页面时
	http.NotFound(w, r)
}

var logCmds sync.Map /* pid -> *exec.Cmd, 用于管理日志流进程, 以便在前端关闭日志流时, 后端可以
   关闭对应的日志流进程, 解决frpc代理后, sse连接断开时, 日志流进程无法关闭的问题, 占用PID资源 */
var logFiles = map[string]string{
	"yfkj-camera-capture.service": "/opt/yfkj/camera-capture.service/log/camera-capture.log",
}

func serviceLogHandler(w http.ResponseWriter, r *http.Request) {
	unit := r.URL.Query().Get("unit")
	if unit == "" {
		http.Error(w, "missing unit", http.StatusBadRequest)
		return
	}

	w.Header().Set("Content-Type", "text/event-stream")
	w.Header().Set("Cache-Control", "no-cache")
	w.Header().Set("Connection", "keep-alive")
	w.Header().Set("X-Accel-Buffering", "no")

	flusher, ok := w.(http.Flusher)
	if !ok {
		http.Error(w, "not supported", http.StatusInternalServerError)
		return
	}

	var cmd *exec.Cmd

	if file, ok := logFiles[unit]; ok {
		cmd = exec.Command(
			"tail",
			"-F",
			"-n",
			"10",
			"--",
			file,
		)
	} else {
		cmd = exec.Command(
			"journalctl",
			"-f",
			"-u",
			unit,
			"-n",
			"10",
			"--no-pager",
			"-q",
			"-o",
			"short-iso",
		)
	}

	stdout, err := cmd.StdoutPipe()
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	if err := cmd.Start(); err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	pid := cmd.Process.Pid
	logCmds.Store(pid, cmd)

	id := time.Now().UnixNano()
	if true {
		baseapp.Logger.Tracef("[服务日志流启动] id=%d unit=%s", id, unit)
	}

	fmt.Fprintf(w, "event: pid\ndata: %d\n\n", pid)
	flusher.Flush() // 发送PID给前端, 让前端在关闭日志流时, 可以通知后端关闭对应的日志流进程

	defer func() {
		logCmds.Delete(pid)
		if cmd.Process != nil {
			err := cmd.Process.Kill()
			baseapp.Logger.Tracef("[journalctl kill] pid=%d err=%v", cmd.Process.Pid, err)
		}
		cmd.Wait()

		baseapp.Logger.Tracef("[服务日志流关闭] id=%d unit=%s", id, unit)
	}()

	lines := make(chan string, 100)

	go func() {
		defer close(lines)

		scanner := bufio.NewScanner(stdout)
		scanner.Buffer(make([]byte, 1024), 1024*1024)

		for scanner.Scan() {
			select {
			case lines <- scanner.Text():
			case <-r.Context().Done():
				return
			}
		}

		_ = scanner.Err()
	}()

	for {
		select {
		case <-r.Context().Done():
			return
		case line, ok := <-lines:
			if !ok {
				return
			}
			if _, err := fmt.Fprintf(w, "data: %s\n\n", line); err != nil { // 实时推送日志
				return
			}
			flusher.Flush()
		}
	}
}

func serviceLogCloseHandler(w http.ResponseWriter, r *http.Request) {
	pid, err := strconv.Atoi(r.URL.Query().Get("pid"))
	if err != nil || pid <= 0 {
		http.Error(w, "invalid pid", http.StatusBadRequest)
		return
	}

	v, ok := logCmds.Load(pid)
	if !ok {
		http.Error(w, "pid not found", http.StatusNotFound)
		return
	}

	cmd := v.(*exec.Cmd)
	if cmd.Process == nil {
		logCmds.Delete(pid)
		return
	}

	data, err := os.ReadFile(fmt.Sprintf("/proc/%d/cmdline", pid))
	if err != nil {
		http.Error(w, "read cmdline failed", http.StatusInternalServerError)
		return
	}

	cmdline := strings.ReplaceAll(string(data), "\x00", " ")
	if !strings.Contains(cmdline, "journalctl") && !strings.Contains(cmdline, "tail") {
		http.Error(w, "not log process", http.StatusBadRequest) // 只允许关闭日志流进程, 防止误杀其它进程
		return
	}

	logCmds.Delete(pid)
	err = cmd.Process.Kill()
	baseapp.Logger.Tracef("[服务日志流关闭] pid=%d cmd=%s err=%v", pid, cmdline, err)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	w.WriteHeader(http.StatusOK)
}

func runShellAndWrite(w http.ResponseWriter, cmd string) {
	baseapp.Logger.Tracef("[执行命令] %s", cmd)

	out, err := exec.Command("sh", "-c", cmd).CombinedOutput()
	if err != nil {
		baseapp.Logger.Errorf("[命令失败] %s err=%v", cmd, err)

		http.Error(w, err.Error()+"\n"+string(out),
			http.StatusInternalServerError)
		return
	}

	w.Write(out)
}

func netInterfaces(w http.ResponseWriter, r *http.Request) {
	runShellAndWrite(w, "ifconfig")
}

func netRoutes(w http.ResponseWriter, r *http.Request) {
	runShellAndWrite(w, "route -n")
}

func netDNS(w http.ResponseWriter, r *http.Request) {
	runShellAndWrite(w, "cat /etc/resolv.conf")
}

func callRPCResult(ctx context.Context, port int, method string, params any, result any) error {
	url := fmt.Sprintf("http://127.0.0.1:%d/rpc", port)

	req, _ := json.Marshal(params)
	baseapp.Logger.Tracef("[接收RPC请求] %s %s params=%s\n", url, method, string(req))

	client, err := jsonrpc2.NewRPCClient(url)
	if err != nil {
		return err
	}

	resp, err := client.Call(ctx, method, params)
	if err != nil {
		return err
	}

	baseapp.Logger.Tracef("[发送RPC应答] %s result=%s err=%v\n", method, string(resp.Result), resp.Error)

	if resp.Error != nil {
		return fmt.Errorf("%s", resp.Error.Message)
	}

	if result == nil {
		return nil
	}

	return json.Unmarshal(resp.Result, result)
}

func callRPCResponse(w http.ResponseWriter, r *http.Request, port int, method string, params any) {
	url := fmt.Sprintf("http://127.0.0.1:%d/rpc", port)

	req, _ := json.Marshal(params)
	baseapp.Logger.Tracef("[接收RPC请求] %s %s params=%s\n", url, method, string(req))

	client, err := jsonrpc2.NewRPCClient(url)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	resp, err := client.Call(r.Context(), method, params)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	baseapp.Logger.Tracef("[发送RPC应答] %s result=%s err=%v\n", method, string(resp.Result), resp.Error)

	if resp.Error != nil {
		http.Error(w, resp.Error.Message, http.StatusBadRequest)
		return
	}

	w.Header().Set("Content-Type", "application/json; charset=utf-8")
	w.Write(resp.Result)
}

func serviceLogLevel(w http.ResponseWriter, r *http.Request, port int) {
	switch r.Method {
	case http.MethodGet:
		callRPCResponse(w, r, port, "basic.getLogLevel", nil)

	case http.MethodPost:
		var req struct {
			Level string `json:"level"`
		}

		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
			http.Error(w, err.Error(), http.StatusBadRequest)
			return
		}

		callRPCResponse(w, r, port, "basic.setLogLevel", map[string]string{"log_level": req.Level})

	default:
		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
	}
}

func serviceLogLevelHandler(port int) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		serviceLogLevel(w, r, port)
	}
}

type SystemdServiceStatus struct {
	Loaded  bool
	Active  bool
	Running bool
	Raw     string
}

func serviceStatus(name string) (SystemdServiceStatus, error) {
	var st SystemdServiceStatus

	out, err := exec.Command("systemctl", "show", name,
		"-p", "LoadState",
		"-p", "ActiveState",
		"-p", "SubState",
	).Output()
	if err != nil {
		return st, err
	}

	s := string(out)
	st.Raw = s

	st.Loaded = strings.Contains(s, "LoadState=loaded")
	st.Active = strings.Contains(s, "ActiveState=active")
	st.Running = st.Active && strings.Contains(s, "SubState=running")

	return st, nil
}

func systemctl(args ...string) error {
	out, err := exec.Command("systemctl", args...).CombinedOutput()
	if err != nil {
		return fmt.Errorf("systemctl %v failed: %v %s", args, err, string(out))
	}
	return nil
}

func serviceControlHandler(w http.ResponseWriter, r *http.Request) {
	var req struct {
		Name   string `json:"name"`
		Action string `json:"action"`
		Secret string `json:"secret"`
	}

	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, "参数错误", http.StatusBadRequest)
		return
	}

	if req.Secret != "yfkj123456" {
		http.Error(w, "密码错误", http.StatusForbidden)
		return
	}

	if req.Action == "stop" && req.Name == "yfkj-frp-client.service" {
		go func() {
			_ = systemctl(req.Action, req.Name)
		}()

		json.NewEncoder(w).Encode(map[string]bool{"ok": true})
		return
	}

	if err := systemctl(req.Action, req.Name); err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	json.NewEncoder(w).Encode(map[string]bool{"ok": true})
}