mirrors/nginx-ui
1
0
Fork 0
mirror of https://github.com/0xJacky/nginx-ui.git synced 2025-05-11 02:15:48 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

fix: log path error caused by multi log params #301

Browse source 
close #301
This commit is contained in:
Jacky 2024-02-19 10:59:42 +08:00
parent 99da617d61
commit fdaa11872a
1 changed files with 233 additions and 228 deletions
Download patch file Download diff file Expand all files Collapse all files

461
api/nginx/nginx_log.go
View file

@ -1,300 +1,305 @@
package nginx package nginx
import ( import (
"encoding/json" "encoding/json"
"github.com/0xJacky/Nginx-UI/api" "github.com/0xJacky/Nginx-UI/api"
"github.com/0xJacky/Nginx-UI/internal/logger" "github.com/0xJacky/Nginx-UI/internal/logger"
"github.com/0xJacky/Nginx-UI/internal/nginx" "github.com/0xJacky/Nginx-UI/internal/nginx"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"github.com/gorilla/websocket" "github.com/gorilla/websocket"
"github.com/hpcloud/tail" "github.com/hpcloud/tail"
"github.com/pkg/errors" "github.com/pkg/errors"
"github.com/spf13/cast" "github.com/spf13/cast"
"io" "io"
"net/http" "net/http"
"os" "os"
"strings"
) )
const ( const (
PageSize = 128 * 1024 PageSize = 128 * 1024
) )
type controlStruct struct { type controlStruct struct {
Type string `json:"type"` Type string `json:"type"`
ConfName string `json:"conf_name"` ConfName string `json:"conf_name"`
ServerIdx int `json:"server_idx"` ServerIdx int `json:"server_idx"`
DirectiveIdx int `json:"directive_idx"` DirectiveIdx int `json:"directive_idx"`
} }
type nginxLogPageResp struct { type nginxLogPageResp struct {
Content string `json:"content"` Content string `json:"content"`
Page int64 `json:"page"` Page int64 `json:"page"`
} }
func GetNginxLogPage(c *gin.Context) { func GetNginxLogPage(c *gin.Context) {
page := cast.ToInt64(c.Query("page")) page := cast.ToInt64(c.Query("page"))
if page < 0 { if page < 0 {
page = 0 page = 0
} }
var control controlStruct var control controlStruct
if !api.BindAndValid(c, &control) { if !api.BindAndValid(c, &control) {
return return
} }
logPath, err := getLogPath(&control) logPath, err := getLogPath(&control)
if err != nil { if err != nil {
logger.Error(err) logger.Error(err)
return return
} }
logFileStat, err := os.Stat(logPath) logFileStat, err := os.Stat(logPath)
if err != nil { if err != nil {
c.JSON(http.StatusOK, nginxLogPageResp{}) c.JSON(http.StatusOK, nginxLogPageResp{})
logger.Error(err) logger.Error(err)
return return
} }
if !logFileStat.Mode().IsRegular() { if !logFileStat.Mode().IsRegular() {
c.JSON(http.StatusOK, nginxLogPageResp{}) c.JSON(http.StatusOK, nginxLogPageResp{})
logger.Error("log file is not regular file:", logPath) logger.Error("log file is not regular file:", logPath)
return return
} }
f, err := os.Open(logPath) f, err := os.Open(logPath)
if err != nil { if err != nil {
c.JSON(http.StatusOK, nginxLogPageResp{}) c.JSON(http.StatusOK, nginxLogPageResp{})
logger.Error(err) logger.Error(err)
return return
} }
totalPage := logFileStat.Size() / PageSize totalPage := logFileStat.Size() / PageSize
if logFileStat.Size()%PageSize > 0 { if logFileStat.Size()%PageSize > 0 {
totalPage++ totalPage++
} }
var buf []byte var buf []byte
var offset int64 var offset int64
if page == 0 { if page == 0 {
page = totalPage page = totalPage
} }
buf = make([]byte, PageSize) buf = make([]byte, PageSize)
offset = (page - 1) * PageSize offset = (page - 1) * PageSize
// seek // seek
_, err = f.Seek(offset, io.SeekStart) _, err = f.Seek(offset, io.SeekStart)
if err != nil && err != io.EOF { if err != nil && err != io.EOF {
c.JSON(http.StatusOK, nginxLogPageResp{}) c.JSON(http.StatusOK, nginxLogPageResp{})
logger.Error(err) logger.Error(err)
return return
} }
n, err := f.Read(buf) n, err := f.Read(buf)
if err != nil && err != io.EOF { if err != nil && err != io.EOF {
c.JSON(http.StatusOK, nginxLogPageResp{}) c.JSON(http.StatusOK, nginxLogPageResp{})
logger.Error(err) logger.Error(err)
return return
} }
c.JSON(http.StatusOK, nginxLogPageResp{ c.JSON(http.StatusOK, nginxLogPageResp{
Page: page, Page: page,
Content: string(buf[:n]), Content: string(buf[:n]),
}) })
} }
func getLogPath(control *controlStruct) (logPath string, err error) { func getLogPath(control *controlStruct) (logPath string, err error) {
switch control.Type { switch control.Type {
case "site": case "site":
var config *nginx.NgxConfig var config *nginx.NgxConfig
path := nginx.GetConfPath("sites-available", control.ConfName) path := nginx.GetConfPath("sites-available", control.ConfName)
config, err = nginx.ParseNgxConfig(path) config, err = nginx.ParseNgxConfig(path)
if err != nil { if err != nil {
err = errors.Wrap(err, "error parsing ngx config") err = errors.Wrap(err, "error parsing ngx config")
return return
} }
if control.ServerIdx >= len(config.Servers) { if control.ServerIdx >= len(config.Servers) {
err = errors.New("serverIdx out of range") err = errors.New("serverIdx out of range")
return return
} }
if control.DirectiveIdx >= len(config.Servers[control.ServerIdx].Directives) { if control.DirectiveIdx >= len(config.Servers[control.ServerIdx].Directives) {
err = errors.New("DirectiveIdx out of range") err = errors.New("DirectiveIdx out of range")
return return
} }
directive := config.Servers[control.ServerIdx].Directives[control.DirectiveIdx] directive := config.Servers[control.ServerIdx].Directives[control.DirectiveIdx]
switch directive.Directive { switch directive.Directive {
case "access_log", "error_log": case "access_log", "error_log":
// ok // ok
default: default:
err = errors.New("directive.Params neither access_log nor error_log") err = errors.New("directive.Params neither access_log nor error_log")
return return
} }
if directive.Params == "" { if directive.Params == "" {
err = errors.New("directive.Params is empty") err = errors.New("directive.Params is empty")
return return
} }
logPath = directive.Params // fix: access_log /var/log/test.log main;
p := strings.Split(directive.Params, " ")
if len(p) > 0 {
logPath = p[0]
}
case "error":
path := nginx.GetErrorLogPath()
case "error": if path == "" {
path := nginx.GetErrorLogPath() err = errors.New("settings.NginxLogSettings.ErrorLogPath is empty," +
" refer to https://nginxui.com/zh_CN/guide/config-nginx-log.html for more information")
return
}
if path == "" { logPath = path
err = errors.New("settings.NginxLogSettings.ErrorLogPath is empty," + default:
" refer to https://nginxui.com/zh_CN/guide/config-nginx-log.html for more information") path := nginx.GetAccessLogPath()
return
}
logPath = path if path == "" {
default: err = errors.New("settings.NginxLogSettings.AccessLogPath is empty," +
path := nginx.GetAccessLogPath() " refer to https://nginxui.com/zh_CN/guide/config-nginx-log.html for more information")
return
}
if path == "" { logPath = path
err = errors.New("settings.NginxLogSettings.AccessLogPath is empty," + }
" refer to https://nginxui.com/zh_CN/guide/config-nginx-log.html for more information")
return
}
logPath = path return
}
return
} }
func tailNginxLog(ws *websocket.Conn, controlChan chan controlStruct, errChan chan error) { func tailNginxLog(ws *websocket.Conn, controlChan chan controlStruct, errChan chan error) {
defer func() { defer func() {
if err := recover(); err != nil { if err := recover(); err != nil {
logger.Error(err) logger.Error(err)
return return
} }
}() }()
control := <-controlChan control := <-controlChan
for { for {
logPath, err := getLogPath(&control) logPath, err := getLogPath(&control)
if err != nil { if err != nil {
errChan <- err errChan <- err
return return
} }
seek := tail.SeekInfo{ seek := tail.SeekInfo{
Offset: 0, Offset: 0,
Whence: io.SeekEnd, Whence: io.SeekEnd,
} }
stat, err := os.Stat(logPath) stat, err := os.Stat(logPath)
if os.IsNotExist(err) { if os.IsNotExist(err) {
errChan <- errors.New("[error] log path not exists " + logPath) errChan <- errors.New("[error] log path not exists " + logPath)
return return
} }
if !stat.Mode().IsRegular() { if !stat.Mode().IsRegular() {
errChan <- errors.New("[error] " + logPath + " is not a regular file. " + errChan <- errors.New("[error] " + logPath + " is not a regular file. " +
"If you are using nginx-ui in docker container, please refer to " + "If you are using nginx-ui in docker container, please refer to " +
"https://nginxui.com/zh_CN/guide/config-nginx-log.html for more information.") "https://nginxui.com/zh_CN/guide/config-nginx-log.html for more information.")
return return
} }
// Create a tail // Create a tail
t, err := tail.TailFile(logPath, tail.Config{Follow: true, t, err := tail.TailFile(logPath, tail.Config{Follow: true,
ReOpen: true, Location: &seek}) ReOpen: true, Location: &seek})
if err != nil { if err != nil {
errChan <- errors.Wrap(err, "error tailing log") errChan <- errors.Wrap(err, "error tailing log")
return return
} }
for { for {
var next = false var next = false
select { select {
case line := <-t.Lines: case line := <-t.Lines:
// Print the text of each received line // Print the text of each received line
if line == nil { if line == nil {
continue continue
} }
err = ws.WriteMessage(websocket.TextMessage, []byte(line.Text)) err = ws.WriteMessage(websocket.TextMessage, []byte(line.Text))
if err != nil && websocket.IsUnexpectedCloseError(err, websocket.CloseNormalClosure) { if err != nil && websocket.IsUnexpectedCloseError(err, websocket.CloseNormalClosure) {
errChan <- errors.Wrap(err, "error tailNginxLog write message") errChan <- errors.Wrap(err, "error tailNginxLog write message")
return return
} }
case control = <-controlChan: case control = <-controlChan:
next = true next = true
break break
} }
if next { if next {
break break
} }
} }
} }
} }
func handleLogControl(ws *websocket.Conn, controlChan chan controlStruct, errChan chan error) { func handleLogControl(ws *websocket.Conn, controlChan chan controlStruct, errChan chan error) {
defer func() { defer func() {
if err := recover(); err != nil { if err := recover(); err != nil {
logger.Error(err) logger.Error(err)
return return
} }
}() }()
for { for {
msgType, payload, err := ws.ReadMessage() msgType, payload, err := ws.ReadMessage()
if err != nil && websocket.IsUnexpectedCloseError(err, websocket.CloseNormalClosure) { if err != nil && websocket.IsUnexpectedCloseError(err, websocket.CloseNormalClosure) {
errChan <- errors.Wrap(err, "error handleLogControl read message") errChan <- errors.Wrap(err, "error handleLogControl read message")
return return
} }
if msgType != websocket.TextMessage { if msgType != websocket.TextMessage {
errChan <- errors.New("error handleLogControl message type") errChan <- errors.New("error handleLogControl message type")
return return
} }
var msg controlStruct var msg controlStruct
err = json.Unmarshal(payload, &msg) err = json.Unmarshal(payload, &msg)
if err != nil { if err != nil {
errChan <- errors.Wrap(err, "error ReadWsAndWritePty json.Unmarshal") errChan <- errors.Wrap(err, "error ReadWsAndWritePty json.Unmarshal")
return return
} }
controlChan <- msg controlChan <- msg
} }
} }
func Log(c *gin.Context) { func Log(c *gin.Context) {
var upGrader = websocket.Upgrader{ var upGrader = websocket.Upgrader{
CheckOrigin: func(r *http.Request) bool { CheckOrigin: func(r *http.Request) bool {
return true return true
}, },
} }
// upgrade http to websocket // upgrade http to websocket
ws, err := upGrader.Upgrade(c.Writer, c.Request, nil) ws, err := upGrader.Upgrade(c.Writer, c.Request, nil)
if err != nil { if err != nil {
logger.Error(err) logger.Error(err)
return return
} }
defer ws.Close() defer ws.Close()
errChan := make(chan error, 1) errChan := make(chan error, 1)
controlChan := make(chan controlStruct, 1) controlChan := make(chan controlStruct, 1)
go tailNginxLog(ws, controlChan, errChan) go tailNginxLog(ws, controlChan, errChan)
go handleLogControl(ws, controlChan, errChan) go handleLogControl(ws, controlChan, errChan)
if err = <-errChan; err != nil { if err = <-errChan; err != nil {
logger.Error(err) logger.Error(err)
_ = ws.WriteMessage(websocket.TextMessage, []byte(err.Error())) _ = ws.WriteMessage(websocket.TextMessage, []byte(err.Error()))
return return
} }
} }