nginx-ui/internal/config/sync.go

package config

import (
    "bytes"
    "crypto/tls"
    "encoding/json"
    "fmt"
    "github.com/0xJacky/Nginx-UI/internal/helper"
    "github.com/0xJacky/Nginx-UI/internal/logger"
    "github.com/0xJacky/Nginx-UI/internal/nginx"
    "github.com/0xJacky/Nginx-UI/internal/notification"
    "github.com/0xJacky/Nginx-UI/model"
    "github.com/0xJacky/Nginx-UI/query"
    "github.com/0xJacky/Nginx-UI/settings"
    "github.com/gin-gonic/gin"
    "io"
    "net/http"
    "os"
    "path/filepath"
    "strings"
)

type SyncConfigPayload struct {
    Name        string `json:"name"`
    Filepath    string `json:"filepath"`
    NewFilepath string `json:"new_filepath"`
    Content     string `json:"content"`
    Overwrite   bool   `json:"overwrite"`
}

func SyncToRemoteServer(c *model.Config, newFilepath string) (err error) {
    if c.Filepath == "" || len(c.SyncNodeIds) == 0 {
        return
    }

    nginxConfPath := nginx.GetConfPath()
    if !helper.IsUnderDirectory(c.Filepath, nginxConfPath) {
        return fmt.Errorf("config: %s is not under the nginx conf path: %s",
            c.Filepath, nginxConfPath)
    }

    if newFilepath != "" && !helper.IsUnderDirectory(newFilepath, nginxConfPath) {
        return fmt.Errorf("config: %s is not under the nginx conf path: %s",
            c.Filepath, nginxConfPath)
    }

    currentPath := c.Filepath
    if newFilepath != "" {
        currentPath = newFilepath
    }
    configBytes, err := os.ReadFile(currentPath)
    if err != nil {
        return
    }

    payload := &SyncConfigPayload{
        Name:        c.Name,
        Filepath:    c.Filepath,
        NewFilepath: newFilepath,
        Content:     string(configBytes),
        Overwrite:   c.SyncOverwrite,
    }
    payloadBytes, err := json.Marshal(payload)
    if err != nil {
        return
    }

    q := query.Environment
    envs, _ := q.Where(q.ID.In(c.SyncNodeIds...)).Find()
    for _, env := range envs {
        go func() {
            err := payload.deploy(env, c, payloadBytes)
            if err != nil {
                logger.Error(err)
            }
        }()
    }

    return
}

func SyncRenameOnRemoteServer(origPath, newPath string, syncNodeIds []int) (err error) {
    if origPath == "" || newPath == "" || len(syncNodeIds) == 0 {
        return
    }

    nginxConfPath := nginx.GetConfPath()
    if !helper.IsUnderDirectory(origPath, nginxConfPath) {
        return fmt.Errorf("config: %s is not under the nginx conf path: %s",
            origPath, nginxConfPath)
    }

    if !helper.IsUnderDirectory(newPath, nginxConfPath) {
        return fmt.Errorf("config: %s is not under the nginx conf path: %s",
            newPath, nginxConfPath)
    }

    payload := &RenameConfigPayload{
        Filepath:    origPath,
        NewFilepath: newPath,
    }

    q := query.Environment
    envs, _ := q.Where(q.ID.In(syncNodeIds...)).Find()
    for _, env := range envs {
        go func() {
            err := payload.rename(env)
            if err != nil {
                logger.Error(err)
            }
        }()
    }

    return
}

type SyncNotificationPayload struct {
    StatusCode int    `json:"status_code"`
    ConfigName string `json:"config_name"`
    EnvName    string `json:"env_name"`
    RespBody   string `json:"resp_body"`
}

func (p *SyncConfigPayload) deploy(env *model.Environment, c *model.Config, payloadBytes []byte) (err error) {
    client := http.Client{
        Transport: &http.Transport{
            TLSClientConfig: &tls.Config{InsecureSkipVerify: settings.ServerSettings.InsecureSkipVerify},
        },
    }
    url, err := env.GetUrl("/api/config")
    if err != nil {
        return
    }
    req, err := http.NewRequest(http.MethodPost, url, bytes.NewBuffer(payloadBytes))
    if err != nil {
        return
    }
    req.Header.Set("X-Node-Secret", env.Token)
    resp, err := client.Do(req)
    if err != nil {
        return
    }
    defer resp.Body.Close()

    respBody, err := io.ReadAll(resp.Body)
    if err != nil {
        return
    }

    notificationPayload := &SyncNotificationPayload{
        StatusCode: resp.StatusCode,
        ConfigName: c.Name,
        EnvName:    env.Name,
        RespBody:   string(respBody),
    }

    notificationPayloadBytes, err := json.Marshal(notificationPayload)
    if err != nil {
        return
    }

    if resp.StatusCode != http.StatusOK {
        notification.Error("Sync Config Error", string(notificationPayloadBytes))
        return
    }

    notification.Success("Sync Config Success", string(notificationPayloadBytes))

    // handle rename
    if p.NewFilepath == "" || p.Filepath == p.NewFilepath {
        return
    }

    payload := &RenameConfigPayload{
        Filepath:    p.Filepath,
        NewFilepath: p.NewFilepath,
    }

    err = payload.rename(env)

    return
}

type RenameConfigPayload struct {
    Filepath    string `json:"filepath"`
    NewFilepath string `json:"new_filepath"`
}

type SyncRenameNotificationPayload struct {
    StatusCode int    `json:"status_code"`
    OrigPath   string `json:"orig_path"`
    NewPath    string `json:"new_path"`
    EnvName    string `json:"env_name"`
    RespBody   string `json:"resp_body"`
}

func (p *RenameConfigPayload) rename(env *model.Environment) (err error) {
    // handle rename
    if p.NewFilepath == "" || p.Filepath == p.NewFilepath {
        return
    }

    client := http.Client{
        Transport: &http.Transport{
            TLSClientConfig: &tls.Config{InsecureSkipVerify: settings.ServerSettings.InsecureSkipVerify},
        },
    }

    payloadBytes, err := json.Marshal(gin.H{
        "base_path": strings.ReplaceAll(filepath.Dir(p.Filepath), nginx.GetConfPath(), ""),
        "orig_name": filepath.Base(p.Filepath),
        "new_name":  filepath.Base(p.NewFilepath),
    })
    if err != nil {
        return
    }
    url, err := env.GetUrl("/api/config_rename")
    if err != nil {
        return
    }
    req, err := http.NewRequest(http.MethodPost, url, bytes.NewBuffer(payloadBytes))
    if err != nil {
        return
    }
    req.Header.Set("X-Node-Secret", env.Token)
    resp, err := client.Do(req)
    if err != nil {
        return
    }
    defer resp.Body.Close()

    respBody, err := io.ReadAll(resp.Body)
    if err != nil {
        return
    }

    notificationPayload := &SyncRenameNotificationPayload{
        StatusCode: resp.StatusCode,
        OrigPath:   p.Filepath,
        NewPath:    p.NewFilepath,
        EnvName:    env.Name,
        RespBody:   string(respBody),
    }

    notificationPayloadBytes, err := json.Marshal(notificationPayload)
    if err != nil {
        return
    }

    if resp.StatusCode != http.StatusOK {
        notification.Error("Rename Remote Config Error", string(notificationPayloadBytes))
        return
    }

    notification.Success("Rename Remote Config Success", string(notificationPayloadBytes))

    return
}