release revsuit vBeta0.1.0 (#15)

Co-authored-by: E99p1ant <[email protected]>
2026-09-26 08:31:52 +08:00 · 2021-05-16 12:11:35 +08:00
parent b39ee101f9
commit 5b63e90390
98 changed files with 2357 additions and 623 deletions
@@ -19,7 +19,7 @@ type Config struct {
 	Addr     string
 	Token    string
 	Database string
-	LogLevel string
+	LogLevel string `yaml:"log_level"`
 	Notice   noticeConfig
 	rhttp.Config
 	DNS   dns.Config
@@ -27,9 +27,8 @@ func ping(c *gin.Context) {
 }

 func events(c *gin.Context) {
-	log.Info("Receive connection from %v", c.Request.RemoteAddr)
+	log.Info("Receive client connection from %v", c.Request.RemoteAddr)
 	c.Stream(func(w io.Writer) bool {
-		c.SSEvent("message", "connect succeed")
 		select {
 		case <-c.Writer.CloseNotify():
 			return false
@@ -38,7 +37,7 @@ func events(c *gin.Context) {
 		}
 		return true
 	})
-	log.Info(c.Request.RemoteAddr, "disconnect")
+	log.Info("Client %s disconnect", c.Request.RemoteAddr)
 }

 func recovery(c *gin.Context) {
@@ -85,3 +84,11 @@ func recovery(c *gin.Context) {
 	}()
 	c.Next()
 }
+
+func version(c *gin.Context) {
+	c.JSON(200, gin.H{
+		"status": "succeed",
+		"error":  nil,
+		"result": VERSION,
+	})
+}
@@ -42,6 +42,7 @@ func (revsuit *Revsuit) registerPlatformRouter() {
 	api.GET("/auth", auth)
 	api.GET("/events", events)
 	api.GET("/ping", ping)
+	api.GET("/version", version)
 }

 func (revsuit *Revsuit) registerHttpRouter() {
@@ -54,6 +55,23 @@ func (revsuit *Revsuit) registerHttpRouter() {
 	}
 	revsuit.http.Router.StaticFS("/revsuit/admin", http.FS(fe))

+	// init settings router group
+	settingsGroup := revsuit.http.ApiGroup.Group("setting")
+	settingsGroup.GET("/exportRules", exportRules)
+	settingsGroup.POST("/importRules", importRules)
+	settingsGroup.GET("/getHttpConfig", revsuit.getHttpConfig)
+	settingsGroup.POST("/updateHttpConfig", revsuit.updateHttpConfig)
+	settingsGroup.GET("/getDnsConfig", revsuit.getDnsConfig)
+	settingsGroup.POST("/updateDnsConfig", revsuit.updateDnsConfig)
+	settingsGroup.GET("/getRmiConfig", revsuit.getRmiConfig)
+	settingsGroup.POST("/updateRmiConfig", revsuit.updateRmiConfig)
+	settingsGroup.GET("/getMySQLConfig", revsuit.getMySQLConfig)
+	settingsGroup.POST("/updateMySQLConfig", revsuit.updateMySQLConfig)
+	settingsGroup.GET("/getFtpConfig", revsuit.getFtpConfig)
+	settingsGroup.POST("/updateFtpConfig", revsuit.updateFtpConfig)
+	settingsGroup.GET("/getNoticeConfig", revsuit.getNoticeConfig)
+	settingsGroup.POST("/updateNoticeConfig", revsuit.updateNoticeConfig)
+
 	// init record router group
 	recordGroup := revsuit.http.ApiGroup.Group("/record")

@@ -14,7 +14,10 @@ import (
 	log "unknwon.dev/clog/v2"
 )

+const VERSION = "Beta0.1"
+
 type Revsuit struct {
+	config   *Config
 	logLevel log.Level

 	http  *http.Server
@@ -25,6 +28,11 @@ type Revsuit struct {
 }

 func initDatabase(dsn string) {
+	_ = log.NewConsole(100,
+		log.ConsoleConfig{
+			Level: log.LevelInfo,
+		})
+
 	err := database.InitDB("sqlite", dsn)
 	if err != nil {
 		log.Fatal(err.Error())
@@ -104,6 +112,10 @@ func initLog(level string) (logLevel log.Level) {
 		gin.SetMode(gin.ReleaseMode)
 		database.DB.Logger.LogMode(logger.Error)
 		logLevel = log.LevelFatal
+	default:
+		gin.SetMode(gin.DebugMode)
+		database.DB.Logger.LogMode(logger.Info)
+		logLevel = log.LevelInfo
 	}
 	_ = log.NewConsole(100,
 		log.ConsoleConfig{
@@ -138,29 +150,27 @@ func initNotice(nc noticeConfig) {

 func New(c *Config) *Revsuit {

-	logLevel := initLog(c.LogLevel)
 	initDatabase(c.Database)
+	logLevel := initLog(c.LogLevel)
 	initNotice(c.Notice)

 	s := &Revsuit{
+		config:   c,
 		logLevel: logLevel,
 		http:     http.GetServer(),
 	}
-	if c.DNS.Enable {
-		s.dns = dns.GetServer()
-	}
-	if c.MySQL.Enable {
-		s.mysql = mysql.GetServer()
-		s.mysql.Config = c.MySQL
-	}
-	if c.RMI.Enable {
-		s.rmi = rmi.GetServer()
-		s.rmi.Config = c.RMI
-	}
-	if c.FTP.Enable {
-		s.ftp = ftp.GetServer()
-		s.ftp.Config = c.FTP
-	}
+
+	s.dns = dns.GetServer()
+	s.dns.Config = c.DNS
+
+	s.mysql = mysql.GetServer()
+	s.mysql.Config = c.MySQL
+
+	s.rmi = rmi.GetServer()
+	s.rmi.Config = c.RMI
+
+	s.ftp = ftp.GetServer()
+	s.ftp.Config = c.FTP

 	if c.Addr != "" {
 		s.http.SetAddr(c.Addr)
@@ -178,16 +188,16 @@ func (revsuit *Revsuit) Run() {
 	defer log.Stop()
 	revsuit.registerRouter()

-	if revsuit.dns != nil {
+	if revsuit.dns != nil && revsuit.dns.Enable {
 		go revsuit.dns.Run()
 	}
-	if revsuit.mysql != nil {
-		go revsuit.mysql.Run()
-	}
-	if revsuit.rmi != nil {
+	if revsuit.rmi != nil && revsuit.rmi.Enable {
 		go revsuit.rmi.Run()
 	}
-	if revsuit.ftp != nil {
+	if revsuit.mysql != nil && revsuit.mysql.Enable {
+		go revsuit.mysql.Run()
+	}
+	if revsuit.ftp != nil && revsuit.ftp.Enable {
 		go revsuit.ftp.Run()
 	}

@@ -0,0 +1,367 @@
+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 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 {
+		err := db.Model(&rhttp.Rule{}).Create(&rule).Error
+		if err != nil {
+			errs = append(errs, errors.Wrap(err, fmt.Sprintf("http rule[%s]", rule.Name)).Error())
+			continue
+		}
+		count += 1
+	}
+
+	for _, rule := range rules.Dns {
+		err := db.Model(&dns.Rule{}).Create(&rule).Error
+		if err != nil {
+			errs = append(errs, errors.Wrap(err, fmt.Sprintf("dns rule[%s]", rule.Name)).Error())
+			continue
+		}
+		count += 1
+	}
+
+	for _, rule := range rules.Mysql {
+		err := db.Model(&mysql.Rule{}).Create(&rule).Error
+		if err != nil {
+			errs = append(errs, errors.Wrap(err, fmt.Sprintf("mysql rule[%s]", rule.Name)).Error())
+			continue
+		}
+		count += 1
+	}
+
+	for _, rule := range rules.Rmi {
+		err := db.Model(&rmi.Rule{}).Create(&rule).Error
+		if err != nil {
+			errs = append(errs, errors.Wrap(err, fmt.Sprintf("rmi rule[%s]", rule.Name)).Error())
+			continue
+		}
+		count += 1
+	}
+
+	for _, rule := range rules.Ftp {
+		err := db.Model(&ftp.Rule{}).Create(&rule).Error
+		if err != nil {
+			errs = append(errs, errors.Wrap(err, fmt.Sprintf("ftp rule[%s]", rule.Name)).Error())
+			continue
+		}
+		count += 1
+	}
+
+	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) getHttpConfig(c *gin.Context) {
+	var res = make(map[string]string)
+	res["Addr"] = revsuit.config.Addr
+	res["Token"] = revsuit.config.Token
+	res["Database"] = revsuit.config.Database
+	res["LogLevel"] = revsuit.config.LogLevel
+	res["IpHeader"] = revsuit.config.IpHeader
+
+	c.JSON(200, res)
+}
+
+func (revsuit *Revsuit) updateHttpConfig(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"])
+	}
+
+	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.PasvIP != revsuit.ftp.PasvIP {
+		revsuit.ftp.PasvIP = form.PasvIP
+		log.Info("Update ftp config [pasv_ip] to %s", form.PasvIP)
+	}
+
+	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)
+}