mirror of
https://github.com/Li4n0/revsuit.git
synced 2026-09-22 06:40:43 +08:00
403 lines
9.2 KiB
Go
403 lines
9.2 KiB
Go
package server
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"time"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/li4n0/revsuit/internal/database"
|
|
"github.com/li4n0/revsuit/pkg/dns"
|
|
"github.com/li4n0/revsuit/pkg/ftp"
|
|
"github.com/li4n0/revsuit/pkg/mysql"
|
|
"github.com/li4n0/revsuit/pkg/rhttp"
|
|
"github.com/li4n0/revsuit/pkg/rmi"
|
|
"github.com/pkg/errors"
|
|
"gopkg.in/yaml.v3"
|
|
log "unknwon.dev/clog/v2"
|
|
)
|
|
|
|
type Rules struct {
|
|
Http []rhttp.Rule
|
|
Dns []dns.Rule
|
|
Mysql []mysql.Rule
|
|
Rmi []rmi.Rule
|
|
Ftp []ftp.Rule
|
|
}
|
|
|
|
func exportRules(c *gin.Context) {
|
|
var (
|
|
db = database.DB
|
|
rules Rules
|
|
)
|
|
|
|
db.Model(&rhttp.Rule{}).Find(&rules.Http)
|
|
db.Model(&dns.Rule{}).Find(&rules.Dns)
|
|
db.Model(&mysql.Rule{}).Find(&rules.Mysql)
|
|
db.Model(&rmi.Rule{}).Find(&rules.Rmi)
|
|
db.Model(&ftp.Rule{}).Find(&rules.Ftp)
|
|
|
|
out, err := yaml.Marshal(rules)
|
|
if err != nil {
|
|
log.Warn("export rules error: %s", err)
|
|
}
|
|
c.Header("Content-Disposition", fmt.Sprintf("attachment;filename=revsuit_rules_%s.yaml", time.Now().Format("20060102150405")))
|
|
c.String(200, string(out))
|
|
}
|
|
|
|
func (revsuit *Revsuit) importRules(c *gin.Context) {
|
|
var (
|
|
db = database.DB
|
|
rules Rules
|
|
count int
|
|
errs []string
|
|
)
|
|
|
|
f, err := c.FormFile("rules")
|
|
if err != nil {
|
|
c.JSON(400, gin.H{
|
|
"status": "failed",
|
|
"error": err.Error(),
|
|
"result": nil,
|
|
})
|
|
log.Trace("%v", err)
|
|
return
|
|
}
|
|
|
|
file, _ := f.Open()
|
|
content, err := io.ReadAll(file)
|
|
if err != nil {
|
|
c.JSON(400, gin.H{
|
|
"status": "failed",
|
|
"error": err.Error(),
|
|
"result": nil,
|
|
})
|
|
log.Trace("%v", err)
|
|
return
|
|
}
|
|
|
|
err = yaml.Unmarshal(content, &rules)
|
|
if err != nil {
|
|
c.JSON(400, gin.H{
|
|
"status": "failed",
|
|
"error": err.Error(),
|
|
"result": nil,
|
|
})
|
|
return
|
|
}
|
|
|
|
for _, rule := range rules.Http {
|
|
if err := db.Model(&rhttp.Rule{}).Create(&rule).Error; err != nil {
|
|
errs = append(errs, errors.Wrap(err, fmt.Sprintf("http rule[%s]", rule.Name)).Error())
|
|
continue
|
|
}
|
|
count++
|
|
}
|
|
if err := revsuit.http.UpdateRules(); err != nil {
|
|
errs = append(errs, err.Error())
|
|
}
|
|
|
|
for _, rule := range rules.Dns {
|
|
if err := db.Model(&dns.Rule{}).Create(&rule).Error; err != nil {
|
|
errs = append(errs, errors.Wrap(err, fmt.Sprintf("dns rule[%s]", rule.Name)).Error())
|
|
continue
|
|
}
|
|
count++
|
|
}
|
|
if err := revsuit.dns.UpdateRules(); err != nil {
|
|
errs = append(errs, err.Error())
|
|
}
|
|
|
|
for _, rule := range rules.Mysql {
|
|
if err := db.Model(&mysql.Rule{}).Create(&rule).Error; err != nil {
|
|
errs = append(errs, errors.Wrap(err, fmt.Sprintf("mysql rule[%s]", rule.Name)).Error())
|
|
continue
|
|
}
|
|
count++
|
|
}
|
|
if err := revsuit.mysql.UpdateRules(); err != nil {
|
|
errs = append(errs, err.Error())
|
|
}
|
|
|
|
for _, rule := range rules.Rmi {
|
|
if err := db.Model(&rmi.Rule{}).Create(&rule).Error; err != nil {
|
|
errs = append(errs, errors.Wrap(err, fmt.Sprintf("rmi rule[%s]", rule.Name)).Error())
|
|
continue
|
|
}
|
|
count++
|
|
}
|
|
if err := revsuit.rmi.UpdateRules(); err != nil {
|
|
errs = append(errs, err.Error())
|
|
}
|
|
|
|
for _, rule := range rules.Ftp {
|
|
if err := db.Model(&ftp.Rule{}).Create(&rule).Error; err != nil {
|
|
errs = append(errs, errors.Wrap(err, fmt.Sprintf("ftp rule[%s]", rule.Name)).Error())
|
|
continue
|
|
}
|
|
count++
|
|
}
|
|
if err := revsuit.ftp.UpdateRules(); err != nil {
|
|
errs = append(errs, err.Error())
|
|
}
|
|
|
|
c.JSON(200, gin.H{
|
|
"status": "succeed",
|
|
"error": errs,
|
|
"result": fmt.Sprintf("%d rules were imported successfully, %d failed.", count, len(errs)),
|
|
})
|
|
}
|
|
|
|
func (revsuit *Revsuit) getPlatformConfig(c *gin.Context) {
|
|
var res = make(map[string]string)
|
|
res["Addr"] = revsuit.config.Addr
|
|
res["Token"] = revsuit.config.Token
|
|
res["Domain"] = revsuit.config.Domain
|
|
res["ExternalIP"] = revsuit.config.ExternalIP
|
|
res["Database"] = revsuit.config.Database
|
|
res["LogLevel"] = revsuit.config.LogLevel
|
|
res["IpHeader"] = revsuit.config.IpHeader
|
|
|
|
c.JSON(200, res)
|
|
}
|
|
|
|
func (revsuit *Revsuit) updatePlatformConfig(c *gin.Context) {
|
|
var form = make(map[string]string)
|
|
|
|
if err := c.ShouldBindJSON(&form); err != nil {
|
|
c.JSON(400, gin.H{
|
|
"status": "failed",
|
|
"error": err.Error(),
|
|
"data": nil,
|
|
})
|
|
return
|
|
}
|
|
|
|
if form["LogLevel"] != revsuit.config.LogLevel {
|
|
revsuit.logLevel = initLog(form["LogLevel"])
|
|
revsuit.config.LogLevel = form["LogLevel"]
|
|
if revsuit.logLevel == log.LevelTrace {
|
|
revsuit.http.Router.Use(gin.Logger())
|
|
}
|
|
log.Info("Update platform config [log_level] to %s", form["LogLevel"])
|
|
}
|
|
|
|
if form["Token"] != revsuit.config.Token {
|
|
revsuit.config.Token = form["Token"]
|
|
revsuit.http.SetToken(form["Token"])
|
|
log.Info("Update platform config [token] to %s", form["Token"])
|
|
}
|
|
|
|
if form["Database"] != revsuit.config.Database {
|
|
revsuit.config.Database = form["Database"]
|
|
initDatabase(form["Database"])
|
|
log.Info("Update platform config [database] to %s", form["Database"])
|
|
}
|
|
|
|
if form["IpHeader"] != revsuit.config.IpHeader {
|
|
revsuit.config.IpHeader = form["IpHeader"]
|
|
revsuit.http.SetIpHeader(form["IpHeader"])
|
|
log.Info("Update http config [ip_header] to %s", form["IpHeader"])
|
|
}
|
|
|
|
if form["Domain"] != revsuit.config.Domain {
|
|
revsuit.config.Domain = form["Domain"]
|
|
revsuit.dns.SetServerDomain(form["Domain"])
|
|
log.Info("Update platform config [domain] to %s", form["Domain"])
|
|
if revsuit.dns.Enable {
|
|
revsuit.dns.Restart()
|
|
}
|
|
}
|
|
|
|
if form["ExternalIP"] != revsuit.config.ExternalIP {
|
|
revsuit.config.ExternalIP = form["ExternalIP"]
|
|
revsuit.dns.SetServerIP(form["ExternalIP"])
|
|
revsuit.ftp.SetPasvIP(form["ExternalIP"])
|
|
log.Info("Update platform config [ExternalIP] to %s", form["ExternalIP"])
|
|
if revsuit.dns.Enable {
|
|
revsuit.dns.Restart()
|
|
}
|
|
if revsuit.ftp.Enable {
|
|
revsuit.ftp.Restart()
|
|
}
|
|
}
|
|
|
|
if form["Token"] != revsuit.config.Token {
|
|
revsuit.config.Token = form["Token"]
|
|
revsuit.http.SetToken(form["Token"])
|
|
log.Info("Update platform config [token] to %s", form["Token"])
|
|
}
|
|
|
|
c.JSON(200, gin.H{
|
|
"status": "succeed",
|
|
"error": nil,
|
|
"result": "update succeed",
|
|
})
|
|
}
|
|
|
|
func (revsuit *Revsuit) getFtpConfig(c *gin.Context) {
|
|
c.JSON(200, revsuit.ftp.Config)
|
|
}
|
|
|
|
func (revsuit *Revsuit) updateFtpConfig(c *gin.Context) {
|
|
var form = ftp.Config{}
|
|
|
|
if err := c.ShouldBindJSON(&form); err != nil {
|
|
c.JSON(400, gin.H{
|
|
"status": "failed",
|
|
"error": err.Error(),
|
|
"data": nil,
|
|
})
|
|
return
|
|
}
|
|
|
|
if form.Addr != revsuit.ftp.Addr {
|
|
revsuit.ftp.Addr = form.Addr
|
|
log.Info("Update ftp config [addr] to %s", form.Addr)
|
|
}
|
|
|
|
if form.PasvPort != revsuit.ftp.PasvPort {
|
|
revsuit.ftp.PasvPort = form.PasvPort
|
|
log.Info("Update ftp config [pasv_port] to %d", form.PasvPort)
|
|
}
|
|
|
|
if form.Enable != revsuit.ftp.Enable {
|
|
log.Info("Update ftp config [enable] to %v", form.Enable)
|
|
if form.Enable {
|
|
go revsuit.ftp.Run()
|
|
} else {
|
|
revsuit.ftp.Stop()
|
|
}
|
|
return
|
|
}
|
|
|
|
if revsuit.ftp.Enable {
|
|
revsuit.ftp.Restart()
|
|
}
|
|
}
|
|
|
|
func (revsuit *Revsuit) getDnsConfig(c *gin.Context) {
|
|
c.JSON(200, revsuit.dns.Config)
|
|
}
|
|
|
|
func (revsuit *Revsuit) updateDnsConfig(c *gin.Context) {
|
|
var form = dns.Config{}
|
|
|
|
if err := c.ShouldBindJSON(&form); err != nil {
|
|
c.JSON(400, gin.H{
|
|
"status": "failed",
|
|
"error": err.Error(),
|
|
"data": nil,
|
|
})
|
|
return
|
|
}
|
|
|
|
if form.Enable != revsuit.dns.Enable {
|
|
log.Info("Update dns config [enable] to %v", form.Enable)
|
|
if form.Enable {
|
|
go revsuit.dns.Run()
|
|
} else {
|
|
revsuit.dns.Stop()
|
|
}
|
|
return
|
|
}
|
|
}
|
|
|
|
func (revsuit *Revsuit) getMySQLConfig(c *gin.Context) {
|
|
c.JSON(200, revsuit.mysql.Config)
|
|
}
|
|
|
|
func (revsuit *Revsuit) updateMySQLConfig(c *gin.Context) {
|
|
var form = mysql.Config{}
|
|
|
|
if err := c.ShouldBindJSON(&form); err != nil {
|
|
c.JSON(400, gin.H{
|
|
"status": "failed",
|
|
"error": err.Error(),
|
|
"data": nil,
|
|
})
|
|
return
|
|
}
|
|
|
|
if form.Addr != revsuit.mysql.Addr {
|
|
revsuit.mysql.Addr = form.Addr
|
|
log.Info("Update mysql config [addr] to %s", form.Addr)
|
|
}
|
|
|
|
if form.VersionString != revsuit.mysql.VersionString {
|
|
revsuit.mysql.VersionString = form.VersionString
|
|
log.Info("Update mysql config [version_string] to %s", form.VersionString)
|
|
}
|
|
|
|
if form.Enable != revsuit.mysql.Enable {
|
|
log.Info("Update mysql config [enable] to %v", form.Enable)
|
|
if form.Enable {
|
|
go revsuit.mysql.Run()
|
|
} else {
|
|
revsuit.mysql.Stop()
|
|
}
|
|
return
|
|
}
|
|
|
|
if revsuit.mysql.Enable {
|
|
revsuit.mysql.Restart()
|
|
}
|
|
}
|
|
|
|
func (revsuit *Revsuit) getRmiConfig(c *gin.Context) {
|
|
c.JSON(200, revsuit.rmi.Config)
|
|
}
|
|
|
|
func (revsuit *Revsuit) updateRmiConfig(c *gin.Context) {
|
|
var form = rmi.Config{}
|
|
|
|
if err := c.ShouldBindJSON(&form); err != nil {
|
|
c.JSON(400, gin.H{
|
|
"status": "failed",
|
|
"error": err.Error(),
|
|
"data": nil,
|
|
})
|
|
return
|
|
}
|
|
|
|
if form.Addr != revsuit.rmi.Addr {
|
|
revsuit.rmi.Addr = form.Addr
|
|
log.Info("Update rmi config [addr] to %s", form.Addr)
|
|
}
|
|
|
|
if form.Enable != revsuit.rmi.Enable {
|
|
log.Info("Update rmi config [enable] to %v", form.Enable)
|
|
if form.Enable {
|
|
go revsuit.rmi.Run()
|
|
} else {
|
|
revsuit.rmi.Stop()
|
|
}
|
|
return
|
|
}
|
|
|
|
if revsuit.rmi.Enable {
|
|
revsuit.rmi.Restart()
|
|
}
|
|
}
|
|
|
|
func (revsuit *Revsuit) getNoticeConfig(c *gin.Context) {
|
|
c.JSON(200, revsuit.config.Notice)
|
|
}
|
|
|
|
func (revsuit *Revsuit) updateNoticeConfig(c *gin.Context) {
|
|
var form = noticeConfig{}
|
|
|
|
if err := c.ShouldBindJSON(&form); err != nil {
|
|
c.JSON(400, gin.H{
|
|
"status": "failed",
|
|
"error": err.Error(),
|
|
"data": nil,
|
|
})
|
|
return
|
|
}
|
|
|
|
log.Info("Update notice config")
|
|
revsuit.config.Notice = form
|
|
initNotice(form)
|
|
}
|