870 lines
22 KiB
Go
870 lines
22 KiB
Go
package services
|
||
|
||
import (
|
||
"bytes"
|
||
"fmt"
|
||
"go-site-clone/config"
|
||
"go-site-clone/types"
|
||
"log"
|
||
"os"
|
||
"os/exec"
|
||
"path/filepath"
|
||
"runtime"
|
||
"strings"
|
||
"text/template"
|
||
"time"
|
||
)
|
||
|
||
type NginxService struct {
|
||
Process *exec.Cmd
|
||
Running bool
|
||
}
|
||
|
||
// NginxSiteConfig 站点配置结构
|
||
type NginxSiteConfig struct {
|
||
ID string // 站点唯一ID
|
||
Name string // 站点名称
|
||
Domains []string // 域名列表
|
||
Port int // 监听端口
|
||
Path string // 网站根目录路径
|
||
Index string // 默认首页文件
|
||
Enabled bool // 是否启用
|
||
}
|
||
|
||
// 启动 Nginx
|
||
func (n *NginxService) StartNginx() error {
|
||
if n.Running {
|
||
return fmt.Errorf("nginx 已经在运行中")
|
||
}
|
||
|
||
appConfig, err := config.LoadConfig()
|
||
if err != nil {
|
||
return fmt.Errorf("加载配置失败: %v", err)
|
||
}
|
||
|
||
// 获取 nginx 可执行文件路径
|
||
nginxPath := appConfig.Nginx.NginxPath
|
||
if nginxPath == "" {
|
||
nginxPath = "plugin/nginx/nginx.exe"
|
||
}
|
||
|
||
// 检查 nginx 文件是否存在
|
||
if _, err := os.Stat(nginxPath); os.IsNotExist(err) {
|
||
return fmt.Errorf("nginx 可执行文件不存在: %s", nginxPath)
|
||
}
|
||
|
||
// 获取绝对路径
|
||
absPath, err := filepath.Abs(nginxPath)
|
||
if err != nil {
|
||
return fmt.Errorf("获取 Nginx 路径失败: %v", err)
|
||
}
|
||
|
||
// 启动 nginx
|
||
cmd := exec.Command(absPath)
|
||
cmd.Dir = filepath.Dir(absPath)
|
||
|
||
// 设置输出
|
||
var stdout, stderr bytes.Buffer
|
||
cmd.Stdout = &stdout
|
||
cmd.Stderr = &stderr
|
||
|
||
err = cmd.Start()
|
||
if err != nil {
|
||
return fmt.Errorf("启动 Nginx 失败: %v, stderr: %s", err, stderr.String())
|
||
}
|
||
|
||
n.Process = cmd
|
||
n.Running = true
|
||
|
||
// 保存 PID 到文件，用于后续检测
|
||
pidFile := filepath.Join(filepath.Dir(absPath), "logs", "nginx.pid")
|
||
pid := cmd.Process.Pid
|
||
if err := os.WriteFile(pidFile, []byte(fmt.Sprintf("%d", pid)), 0644); err != nil {
|
||
log.Printf("警告: 保存 PID 文件失败: %v", err)
|
||
}
|
||
|
||
log.Printf("Nginx 启动成功, PID: %d", pid)
|
||
return nil
|
||
}
|
||
|
||
// 停止 Nginx
|
||
func (n *NginxService) StopNginx() error {
|
||
if !n.Running {
|
||
return fmt.Errorf("nginx 未运行")
|
||
}
|
||
|
||
appConfig, err := config.LoadConfig()
|
||
if err != nil {
|
||
return fmt.Errorf("加载配置失败: %v", err)
|
||
}
|
||
|
||
nginxPath := appConfig.Nginx.NginxPath
|
||
if nginxPath == "" {
|
||
nginxPath = "plugin/nginx/nginx.exe"
|
||
}
|
||
|
||
// 获取绝对路径
|
||
absPath, _ := filepath.Abs(nginxPath)
|
||
nginxDir := filepath.Dir(absPath)
|
||
|
||
// 首先尝试优雅停止
|
||
stopCmd := exec.Command(nginxPath, "-s", "quit")
|
||
stopCmd.Dir = filepath.Dir(nginxPath)
|
||
err = stopCmd.Run()
|
||
|
||
// 等待一段时间让进程退出
|
||
time.Sleep(1 * time.Second)
|
||
|
||
// 检查进程是否还在运行
|
||
stillRunning := false
|
||
if runtime.GOOS == "windows" {
|
||
// Windows 下检查所有 nginx.exe 进程
|
||
stillRunning = n.checkAnyNginxProcess(nginxDir)
|
||
}
|
||
|
||
// 如果还有进程在运行，强制杀死
|
||
if stillRunning || err != nil {
|
||
log.Println("优雅停止失败或进程仍在运行，执行强制停止")
|
||
|
||
if runtime.GOOS == "windows" {
|
||
// Windows 下使用 taskkill 强制杀死所有 nginx.exe 进程
|
||
n.killAllNginxProcesses(nginxDir)
|
||
} else {
|
||
// Linux/Mac 下使用 nginx -s stop
|
||
stopCmd := exec.Command(nginxPath, "-s", "stop")
|
||
stopCmd.Dir = filepath.Dir(nginxPath)
|
||
stopCmd.Run()
|
||
}
|
||
|
||
// 再等待一下确保进程退出
|
||
time.Sleep(500 * time.Millisecond)
|
||
}
|
||
|
||
n.Running = false
|
||
n.Process = nil
|
||
|
||
// 删除 PID 文件
|
||
pidFile := filepath.Join(nginxDir, "logs", "nginx.pid")
|
||
os.Remove(pidFile) // 忽略错误
|
||
|
||
log.Println("Nginx 已停止")
|
||
return nil
|
||
}
|
||
|
||
// 重启 Nginx
|
||
func (n *NginxService) RestartNginx() error {
|
||
if n.Running {
|
||
if err := n.StopNginx(); err != nil {
|
||
return fmt.Errorf("停止 Nginx 失败: %v", err)
|
||
}
|
||
// 等待一段时间确保完全停止
|
||
time.Sleep(2 * time.Second)
|
||
}
|
||
|
||
return n.StartNginx()
|
||
}
|
||
|
||
// 重载配置
|
||
func (n *NginxService) ReloadNginx() error {
|
||
if !n.Running {
|
||
return fmt.Errorf("nginx 未运行")
|
||
}
|
||
|
||
appConfig, err := config.LoadConfig()
|
||
if err != nil {
|
||
return fmt.Errorf("加载配置失败: %v", err)
|
||
}
|
||
|
||
nginxPath := appConfig.Nginx.NginxPath
|
||
if nginxPath == "" {
|
||
nginxPath = "plugin/nginx/nginx.exe"
|
||
}
|
||
|
||
// 获取绝对路径
|
||
absPath, err := filepath.Abs(nginxPath)
|
||
if err != nil {
|
||
return fmt.Errorf("获取 nginx 路径失败: %v", err)
|
||
}
|
||
|
||
// 执行重载命令
|
||
reloadCmd := exec.Command(absPath, "-s", "reload")
|
||
reloadCmd.Dir = filepath.Dir(absPath)
|
||
|
||
if err := reloadCmd.Run(); err != nil {
|
||
return fmt.Errorf("重载配置失败: %v", err)
|
||
}
|
||
|
||
log.Println("Nginx 配置已重载")
|
||
return nil
|
||
}
|
||
|
||
// 检查 Nginx 状态
|
||
func (n *NginxService) CheckStatus() (bool, error) {
|
||
appConfig, err := config.LoadConfig()
|
||
if err != nil {
|
||
return false, fmt.Errorf("加载配置失败: %v", err)
|
||
}
|
||
|
||
nginxPath := appConfig.Nginx.NginxPath
|
||
if nginxPath == "" {
|
||
nginxPath = "plugin/nginx/nginx.exe"
|
||
}
|
||
|
||
// 获取 nginx 目录的绝对路径
|
||
nginxDir := filepath.Dir(nginxPath)
|
||
absNginxDir, err := filepath.Abs(nginxDir)
|
||
if err != nil {
|
||
return false, err
|
||
}
|
||
|
||
// 读取 PID 文件
|
||
pidFile := filepath.Join(absNginxDir, "logs", "nginx.pid")
|
||
pidData, err := os.ReadFile(pidFile)
|
||
if err != nil {
|
||
// PID 文件不存在，说明没有运行或异常退出
|
||
return false, nil
|
||
}
|
||
|
||
// 解析 PID
|
||
var pid int
|
||
if _, err := fmt.Sscanf(string(pidData), "%d", &pid); err != nil {
|
||
return false, fmt.Errorf("解析 PID 文件失败: %v", err)
|
||
}
|
||
|
||
if runtime.GOOS == "windows" {
|
||
// Windows 下检查进程是否存在并验证路径
|
||
return n.checkWindowsProcess(pid, absNginxDir)
|
||
} else {
|
||
// Linux/Mac 下检查进程
|
||
return n.checkUnixProcess(pid)
|
||
}
|
||
}
|
||
|
||
// 测试配置文件
|
||
func (n *NginxService) TestConfig() error {
|
||
appConfig, err := config.LoadConfig()
|
||
if err != nil {
|
||
return fmt.Errorf("加载配置失败: %v", err)
|
||
}
|
||
|
||
nginxPath := appConfig.Nginx.NginxPath
|
||
if nginxPath == "" {
|
||
nginxPath = "plugin/nginx/nginx.exe"
|
||
}
|
||
|
||
// 获取绝对路径
|
||
absPath, err := filepath.Abs(nginxPath)
|
||
if err != nil {
|
||
return fmt.Errorf("获取 nginx 路径失败: %v", err)
|
||
}
|
||
|
||
// 执行配置测试
|
||
testCmd := exec.Command(absPath, "-t")
|
||
testCmd.Dir = filepath.Dir(absPath)
|
||
|
||
var stderr bytes.Buffer
|
||
testCmd.Stderr = &stderr
|
||
|
||
if err := testCmd.Run(); err != nil {
|
||
return fmt.Errorf("配置文件测试失败: %s", stderr.String())
|
||
}
|
||
|
||
log.Println("Nginx 配置文件测试通过")
|
||
return nil
|
||
}
|
||
|
||
// 添加站点配置
|
||
func (n *NginxService) AddSite(site types.NginxSiteConfig) error {
|
||
appConfig, err := config.LoadConfig()
|
||
if err != nil {
|
||
return fmt.Errorf("加载配置失败: %v", err)
|
||
}
|
||
|
||
// 生成配置文件内容
|
||
confContent, err := n.generateSiteConfig(site)
|
||
if err != nil {
|
||
return fmt.Errorf("生成配置失败: %v", err)
|
||
}
|
||
|
||
// 根据启用状态选择目录
|
||
hostsDir := filepath.Join(filepath.Dir(appConfig.Nginx.NginxConfPath), "hosts")
|
||
disabledDir := filepath.Join(filepath.Dir(appConfig.Nginx.NginxConfPath), "hosts.disabled")
|
||
|
||
var targetDir string
|
||
if site.Enabled {
|
||
targetDir = hostsDir
|
||
} else {
|
||
targetDir = disabledDir
|
||
}
|
||
|
||
// 确保目录存在
|
||
if err := os.MkdirAll(targetDir, 0755); err != nil {
|
||
return fmt.Errorf("创建目录失败: %v", err)
|
||
}
|
||
|
||
// 写入配置文件
|
||
confPath := filepath.Join(targetDir, fmt.Sprintf("%s.conf", site.Name))
|
||
if err := os.WriteFile(confPath, []byte(confContent), 0644); err != nil {
|
||
return fmt.Errorf("写入配置文件失败: %v", err)
|
||
}
|
||
|
||
log.Printf("站点配置已添加: %s (启用: %v)", confPath, site.Enabled)
|
||
|
||
// 如果启用且 Nginx 正在运行,重载配置
|
||
if site.Enabled && n.Running {
|
||
if err := n.ReloadNginx(); err != nil {
|
||
// 重载失败只记录警告，不影响添加操作
|
||
log.Printf("警告: 重载 nginx 配置失败: %v", err)
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// 删除站点配置
|
||
func (n *NginxService) DeleteSite(siteName string) error {
|
||
appConfig, err := config.LoadConfig()
|
||
if err != nil {
|
||
return fmt.Errorf("加载配置失败: %v", err)
|
||
}
|
||
|
||
hostsDir := filepath.Join(filepath.Dir(appConfig.Nginx.NginxConfPath), "hosts")
|
||
disabledDir := filepath.Join(filepath.Dir(appConfig.Nginx.NginxConfPath), "hosts.disabled")
|
||
|
||
// 先尝试从启用目录删除
|
||
confPath := filepath.Join(hostsDir, fmt.Sprintf("%s.conf", siteName))
|
||
err = os.Remove(confPath)
|
||
if err != nil && os.IsNotExist(err) {
|
||
// 如果启用目录没有，尝试从禁用目录删除
|
||
confPath = filepath.Join(disabledDir, fmt.Sprintf("%s.conf", siteName))
|
||
err = os.Remove(confPath)
|
||
}
|
||
|
||
if err != nil {
|
||
if os.IsNotExist(err) {
|
||
return fmt.Errorf("站点配置不存在: %s", siteName)
|
||
}
|
||
return fmt.Errorf("删除配置文件失败: %v", err)
|
||
}
|
||
|
||
log.Printf("站点配置已删除: %s", siteName)
|
||
|
||
// 如果 Nginx 正在运行,重载配置
|
||
if n.Running {
|
||
if err := n.ReloadNginx(); err != nil {
|
||
// 重载失败只记录警告，不影响删除操作
|
||
log.Printf("警告: 重载 nginx 配置失败: %v", err)
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// 更新站点配置
|
||
func (n *NginxService) UpdateSite(site types.NginxSiteConfig) error {
|
||
// 先删除旧配置
|
||
if err := n.DeleteSite(site.Name); err != nil {
|
||
// 如果配置不存在,继续添加新配置
|
||
if !strings.Contains(err.Error(), "不存在") {
|
||
return err
|
||
}
|
||
}
|
||
|
||
// 添加新配置
|
||
return n.AddSite(site)
|
||
}
|
||
|
||
// 获取所有站点配置
|
||
func (n *NginxService) GetAllSites() ([]types.NginxSiteConfig, error) {
|
||
appConfig, err := config.LoadConfig()
|
||
if err != nil {
|
||
return nil, fmt.Errorf("加载配置失败: %v", err)
|
||
}
|
||
|
||
hostsDir := filepath.Join(filepath.Dir(appConfig.Nginx.NginxConfPath), "hosts")
|
||
disabledDir := filepath.Join(filepath.Dir(appConfig.Nginx.NginxConfPath), "hosts.disabled")
|
||
|
||
// 检查目录是否存在
|
||
if _, err := os.Stat(hostsDir); os.IsNotExist(err) {
|
||
os.MkdirAll(hostsDir, 0755)
|
||
}
|
||
if _, err := os.Stat(disabledDir); os.IsNotExist(err) {
|
||
os.MkdirAll(disabledDir, 0755)
|
||
}
|
||
|
||
var sites []types.NginxSiteConfig
|
||
|
||
// 读取启用的站点
|
||
enabledFiles, err := os.ReadDir(hostsDir)
|
||
if err == nil {
|
||
for _, file := range enabledFiles {
|
||
if !file.IsDir() && strings.HasSuffix(file.Name(), ".conf") {
|
||
siteName := strings.TrimSuffix(file.Name(), ".conf")
|
||
confPath := filepath.Join(hostsDir, file.Name())
|
||
site, err := n.parseSiteConfig(confPath, siteName, true)
|
||
if err != nil {
|
||
log.Printf("警告: 解析配置文件失败 %s: %v", file.Name(), err)
|
||
continue
|
||
}
|
||
sites = append(sites, site)
|
||
}
|
||
}
|
||
}
|
||
|
||
// 读取禁用的站点
|
||
disabledFiles, err := os.ReadDir(disabledDir)
|
||
if err == nil {
|
||
for _, file := range disabledFiles {
|
||
if !file.IsDir() && strings.HasSuffix(file.Name(), ".conf") {
|
||
siteName := strings.TrimSuffix(file.Name(), ".conf")
|
||
confPath := filepath.Join(disabledDir, file.Name())
|
||
site, err := n.parseSiteConfig(confPath, siteName, false)
|
||
if err != nil {
|
||
log.Printf("警告: 解析配置文件失败 %s: %v", file.Name(), err)
|
||
continue
|
||
}
|
||
sites = append(sites, site)
|
||
}
|
||
}
|
||
}
|
||
|
||
return sites, nil
|
||
}
|
||
|
||
// 解析站点配置文件
|
||
func (n *NginxService) parseSiteConfig(confPath string, siteName string, enabled bool) (types.NginxSiteConfig, error) {
|
||
content, err := os.ReadFile(confPath)
|
||
if err != nil {
|
||
return types.NginxSiteConfig{}, err
|
||
}
|
||
|
||
config := types.NginxSiteConfig{
|
||
Name: siteName,
|
||
Enabled: enabled,
|
||
Domains: []string{},
|
||
}
|
||
|
||
// 简单解析配置文件内容
|
||
lines := strings.Split(string(content), "\n")
|
||
for _, line := range lines {
|
||
line = strings.TrimSpace(line)
|
||
|
||
// 解析 listen 端口
|
||
if strings.HasPrefix(line, "listen") {
|
||
parts := strings.Fields(line)
|
||
if len(parts) >= 2 {
|
||
portStr := strings.TrimSuffix(parts[1], ";")
|
||
var port int
|
||
fmt.Sscanf(portStr, "%d", &port)
|
||
config.Port = port
|
||
}
|
||
}
|
||
|
||
// 解析 server_name 域名
|
||
if strings.HasPrefix(line, "server_name") {
|
||
parts := strings.Fields(line)
|
||
if len(parts) >= 2 {
|
||
for i := 1; i < len(parts); i++ {
|
||
domain := strings.TrimSuffix(parts[i], ";")
|
||
if domain != "" {
|
||
config.Domains = append(config.Domains, domain)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 解析 root 路径
|
||
if strings.HasPrefix(line, "root") {
|
||
parts := strings.Fields(line)
|
||
if len(parts) >= 2 {
|
||
path := strings.Trim(parts[1], "\";")
|
||
config.Path = path
|
||
}
|
||
}
|
||
|
||
// 解析 index
|
||
if strings.HasPrefix(line, "index") {
|
||
parts := strings.Fields(line)
|
||
if len(parts) >= 2 {
|
||
index := strings.TrimSuffix(parts[1], ";")
|
||
config.Index = index
|
||
}
|
||
}
|
||
}
|
||
|
||
return config, nil
|
||
}
|
||
|
||
// 启用站点
|
||
func (n *NginxService) EnableSite(siteName string) error {
|
||
// 对于当前的配置结构,所有在 hosts 目录下的配置都是启用的
|
||
// 如果需要禁用,可以移动到其他目录
|
||
appConfig, err := config.LoadConfig()
|
||
if err != nil {
|
||
return fmt.Errorf("加载配置失败: %v", err)
|
||
}
|
||
|
||
hostsDir := filepath.Join(filepath.Dir(appConfig.Nginx.NginxConfPath), "hosts")
|
||
disabledDir := filepath.Join(filepath.Dir(appConfig.Nginx.NginxConfPath), "hosts.disabled")
|
||
|
||
// 从 disabled 移动到 hosts
|
||
srcPath := filepath.Join(disabledDir, fmt.Sprintf("%s.conf", siteName))
|
||
dstPath := filepath.Join(hostsDir, fmt.Sprintf("%s.conf", siteName))
|
||
|
||
if _, err := os.Stat(srcPath); os.IsNotExist(err) {
|
||
return fmt.Errorf("站点配置不存在或已启用")
|
||
}
|
||
|
||
if err := os.MkdirAll(hostsDir, 0755); err != nil {
|
||
return err
|
||
}
|
||
|
||
if err := os.Rename(srcPath, dstPath); err != nil {
|
||
return fmt.Errorf("启用站点失败: %v", err)
|
||
}
|
||
|
||
// 重载配置
|
||
if n.Running {
|
||
if err := n.ReloadNginx(); err != nil {
|
||
log.Printf("警告: 重载 nginx 配置失败: %v", err)
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// 禁用站点
|
||
func (n *NginxService) DisableSite(siteName string) error {
|
||
appConfig, err := config.LoadConfig()
|
||
if err != nil {
|
||
return fmt.Errorf("加载配置失败: %v", err)
|
||
}
|
||
|
||
hostsDir := filepath.Join(filepath.Dir(appConfig.Nginx.NginxConfPath), "hosts")
|
||
disabledDir := filepath.Join(filepath.Dir(appConfig.Nginx.NginxConfPath), "hosts.disabled")
|
||
|
||
// 从 hosts 移动到 disabled
|
||
srcPath := filepath.Join(hostsDir, fmt.Sprintf("%s.conf", siteName))
|
||
dstPath := filepath.Join(disabledDir, fmt.Sprintf("%s.conf", siteName))
|
||
|
||
if _, err := os.Stat(srcPath); os.IsNotExist(err) {
|
||
return fmt.Errorf("站点配置不存在或已禁用")
|
||
}
|
||
|
||
if err := os.MkdirAll(disabledDir, 0755); err != nil {
|
||
return err
|
||
}
|
||
|
||
if err := os.Rename(srcPath, dstPath); err != nil {
|
||
return fmt.Errorf("禁用站点失败: %v", err)
|
||
}
|
||
|
||
// 重载配置
|
||
if n.Running {
|
||
if err := n.ReloadNginx(); err != nil {
|
||
log.Printf("警告: 重载 nginx 配置失败: %v", err)
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// 生成站点配置文件内容
|
||
func (n *NginxService) generateSiteConfig(site types.NginxSiteConfig) (string, error) {
|
||
// 如果用户提供了路径，使用用户的路径
|
||
var absPath string
|
||
var err error
|
||
|
||
if site.Path != "" {
|
||
// 用户提供的路径（相对路径或绝对路径）
|
||
if filepath.IsAbs(site.Path) {
|
||
absPath = site.Path
|
||
} else {
|
||
// 相对路径，转换为绝对路径
|
||
absPath, err = filepath.Abs(site.Path)
|
||
if err != nil {
|
||
return "", fmt.Errorf("获取站点路径失败: %v", err)
|
||
}
|
||
}
|
||
} else {
|
||
// 如果没有提供路径，使用配置中的默认目录
|
||
appConfig, err := config.LoadConfig()
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
|
||
sitePath := filepath.Join(appConfig.SiteFileDir, site.Name)
|
||
absPath, err = filepath.Abs(sitePath)
|
||
if err != nil {
|
||
return "", fmt.Errorf("获取站点路径失败: %v", err)
|
||
}
|
||
}
|
||
|
||
// Windows 路径处理（nginx 需要使用正斜杠）
|
||
if runtime.GOOS == "windows" {
|
||
absPath = strings.ReplaceAll(absPath, "\\", "/")
|
||
}
|
||
|
||
// 默认首页
|
||
if site.Index == "" {
|
||
site.Index = "index.html"
|
||
}
|
||
|
||
// 生成域名列表字符串
|
||
domains := strings.Join(site.Domains, " ")
|
||
|
||
// 使用模板生成配置
|
||
tmpl, err := template.New("nginx").Parse(types.NGINX_CONF_TMP)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
|
||
// 获取当前时间
|
||
createTime := time.Now().Format("2006-01-02 15:04:05")
|
||
|
||
data := map[string]interface{}{
|
||
"SiteName": site.Name,
|
||
"Port": site.Port,
|
||
"Host": domains,
|
||
"FilePath": absPath,
|
||
"Index": site.Index,
|
||
"CreateTime": createTime,
|
||
}
|
||
|
||
var buf bytes.Buffer
|
||
if err := tmpl.Execute(&buf, data); err != nil {
|
||
return "", err
|
||
}
|
||
|
||
return buf.String(), nil
|
||
}
|
||
|
||
// 获取 Nginx 日志
|
||
func (n *NginxService) GetAccessLog(lines int) ([]string, error) {
|
||
appConfig, err := config.LoadConfig()
|
||
if err != nil {
|
||
return nil, fmt.Errorf("加载配置失败: %v", err)
|
||
}
|
||
|
||
logPath := filepath.Join(filepath.Dir(appConfig.Nginx.NginxPath), "logs", "access.log")
|
||
return n.readLogLines(logPath, lines)
|
||
}
|
||
|
||
// 获取错误日志
|
||
func (n *NginxService) GetErrorLog(lines int) ([]string, error) {
|
||
appConfig, err := config.LoadConfig()
|
||
if err != nil {
|
||
return nil, fmt.Errorf("加载配置失败: %v", err)
|
||
}
|
||
|
||
logPath := filepath.Join(filepath.Dir(appConfig.Nginx.NginxPath), "logs", "error.log")
|
||
return n.readLogLines(logPath, lines)
|
||
}
|
||
|
||
// 读取日志文件指定行数
|
||
func (n *NginxService) readLogLines(filePath string, lines int) ([]string, error) {
|
||
content, err := os.ReadFile(filePath)
|
||
if err != nil {
|
||
if os.IsNotExist(err) {
|
||
return []string{}, nil
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
allLines := strings.Split(string(content), "\n")
|
||
start := len(allLines) - lines
|
||
if start < 0 {
|
||
start = 0
|
||
}
|
||
|
||
return allLines[start:], nil
|
||
}
|
||
|
||
// 清空日志
|
||
func (n *NginxService) ClearLogs() error {
|
||
appConfig, err := config.LoadConfig()
|
||
if err != nil {
|
||
return fmt.Errorf("加载配置失败: %v", err)
|
||
}
|
||
|
||
logsDir := filepath.Join(filepath.Dir(appConfig.Nginx.NginxPath), "logs")
|
||
|
||
// 清空 access.log
|
||
accessLog := filepath.Join(logsDir, "access.log")
|
||
if err := os.WriteFile(accessLog, []byte(""), 0644); err != nil {
|
||
return fmt.Errorf("清空访问日志失败: %v", err)
|
||
}
|
||
|
||
// 清空 error.log
|
||
errorLog := filepath.Join(logsDir, "error.log")
|
||
if err := os.WriteFile(errorLog, []byte(""), 0644); err != nil {
|
||
return fmt.Errorf("清空错误日志失败: %v", err)
|
||
}
|
||
|
||
log.Println("Nginx 日志已清空")
|
||
return nil
|
||
}
|
||
|
||
// Windows 下检查进程
|
||
func (n *NginxService) checkWindowsProcess(pid int, nginxDir string) (bool, error) {
|
||
// 使用 tasklist 检查进程是否存在
|
||
cmd := exec.Command("tasklist", "/FI", fmt.Sprintf("PID eq %d", pid), "/FO", "CSV", "/NH")
|
||
output, err := cmd.Output()
|
||
if err != nil {
|
||
return false, err
|
||
}
|
||
|
||
outputStr := string(output)
|
||
// 如果输出包含 "INFO: No tasks"，说明进程不存在
|
||
if strings.Contains(outputStr, "INFO:") || !strings.Contains(outputStr, "nginx.exe") {
|
||
return false, nil
|
||
}
|
||
|
||
// 进程存在，进一步验证进程路径（可选，但更严格）
|
||
// 使用 wmic 获取进程的可执行文件路径
|
||
cmd = exec.Command("wmic", "process", "where", fmt.Sprintf("ProcessId=%d", pid), "get", "ExecutablePath", "/format:list")
|
||
output, err = cmd.Output()
|
||
if err != nil {
|
||
// 如果获取路径失败，但进程存在，认为是运行中
|
||
return true, nil
|
||
}
|
||
|
||
outputStr = string(output)
|
||
// 检查路径是否包含我们的 nginx 目录
|
||
nginxDirNorm := strings.ToLower(strings.ReplaceAll(nginxDir, "/", "\\"))
|
||
outputStrNorm := strings.ToLower(outputStr)
|
||
|
||
return strings.Contains(outputStrNorm, nginxDirNorm), nil
|
||
}
|
||
|
||
// Unix/Linux 下检查进程
|
||
func (n *NginxService) checkUnixProcess(pid int) (bool, error) {
|
||
// 检查 /proc/pid 是否存在
|
||
procPath := fmt.Sprintf("/proc/%d", pid)
|
||
if _, err := os.Stat(procPath); os.IsNotExist(err) {
|
||
return false, nil
|
||
}
|
||
|
||
// 读取进程的 cmdline 验证是否是 nginx
|
||
cmdlinePath := filepath.Join(procPath, "cmdline")
|
||
cmdline, err := os.ReadFile(cmdlinePath)
|
||
if err != nil {
|
||
return false, err
|
||
}
|
||
|
||
return strings.Contains(string(cmdline), "nginx"), nil
|
||
}
|
||
|
||
// 检查是否有任何 nginx 进程在运行（Windows）
|
||
func (n *NginxService) checkAnyNginxProcess(nginxDir string) bool {
|
||
cmd := exec.Command("tasklist", "/FI", "IMAGENAME eq nginx.exe", "/FO", "CSV", "/NH")
|
||
output, err := cmd.Output()
|
||
if err != nil {
|
||
return false
|
||
}
|
||
|
||
outputStr := string(output)
|
||
// 检查是否有 nginx.exe 进程
|
||
if !strings.Contains(outputStr, "nginx.exe") {
|
||
return false
|
||
}
|
||
|
||
// 进一步验证是否是本项目的 nginx（通过路径）
|
||
lines := strings.Split(outputStr, "\n")
|
||
for _, line := range lines {
|
||
if !strings.Contains(line, "nginx.exe") {
|
||
continue
|
||
}
|
||
|
||
// 提取 PID
|
||
fields := strings.Split(line, "\",\"")
|
||
if len(fields) < 2 {
|
||
continue
|
||
}
|
||
|
||
pidStr := strings.Trim(fields[1], "\"")
|
||
var pid int
|
||
if _, err := fmt.Sscanf(pidStr, "%d", &pid); err != nil {
|
||
continue
|
||
}
|
||
|
||
// 检查这个进程的路径
|
||
cmd = exec.Command("wmic", "process", "where", fmt.Sprintf("ProcessId=%d", pid), "get", "ExecutablePath", "/format:list")
|
||
output, err := cmd.Output()
|
||
if err != nil {
|
||
continue
|
||
}
|
||
|
||
outputStr := string(output)
|
||
nginxDirNorm := strings.ToLower(strings.ReplaceAll(nginxDir, "/", "\\"))
|
||
if strings.Contains(strings.ToLower(outputStr), nginxDirNorm) {
|
||
return true
|
||
}
|
||
}
|
||
|
||
return false
|
||
}
|
||
|
||
// 杀死所有本项目的 nginx 进程（Windows）
|
||
func (n *NginxService) killAllNginxProcesses(nginxDir string) error {
|
||
// 获取所有 nginx.exe 进程
|
||
cmd := exec.Command("tasklist", "/FI", "IMAGENAME eq nginx.exe", "/FO", "CSV", "/NH")
|
||
output, err := cmd.Output()
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
outputStr := string(output)
|
||
if !strings.Contains(outputStr, "nginx.exe") {
|
||
return nil // 没有 nginx 进程
|
||
}
|
||
|
||
// 解析每个进程并杀死属于本项目的
|
||
lines := strings.Split(outputStr, "\n")
|
||
nginxDirNorm := strings.ToLower(strings.ReplaceAll(nginxDir, "/", "\\"))
|
||
|
||
for _, line := range lines {
|
||
if !strings.Contains(line, "nginx.exe") {
|
||
continue
|
||
}
|
||
|
||
// 提取 PID
|
||
fields := strings.Split(line, "\",\"")
|
||
if len(fields) < 2 {
|
||
continue
|
||
}
|
||
|
||
pidStr := strings.Trim(fields[1], "\"")
|
||
var pid int
|
||
if _, err := fmt.Sscanf(pidStr, "%d", &pid); err != nil {
|
||
continue
|
||
}
|
||
|
||
// 验证进程路径是否属于本项目
|
||
cmd = exec.Command("wmic", "process", "where", fmt.Sprintf("ProcessId=%d", pid), "get", "ExecutablePath", "/format:list")
|
||
output, err := cmd.Output()
|
||
if err != nil {
|
||
// 如果无法获取路径，为了安全起见，杀死这个进程
|
||
// （因为我们已经通过其他方式确认这是 nginx.exe）
|
||
killCmd := exec.Command("taskkill", "/F", "/PID", pidStr)
|
||
killCmd.Run()
|
||
log.Printf("已杀死 nginx 进程 PID: %s", pidStr)
|
||
continue
|
||
}
|
||
|
||
// 检查路径是否匹配
|
||
pathOutput := strings.ToLower(string(output))
|
||
if strings.Contains(pathOutput, nginxDirNorm) {
|
||
// 强制杀死进程
|
||
killCmd := exec.Command("taskkill", "/F", "/PID", pidStr)
|
||
if err := killCmd.Run(); err != nil {
|
||
log.Printf("警告: 杀死进程 PID %s 失败: %v", pidStr, err)
|
||
} else {
|
||
log.Printf("已杀死 nginx 进程 PID: %s", pidStr)
|
||
}
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|