Merge remote-tracking branch 'origin/main' into multi-tenant

src/app.go

@@ -97,7 +97,10 @@ func initAppEngine() *gin.Engine {
 // 初始全局默认
 func initDefeat(app *gin.Engine) {
 	// 全局中间件
-	app.Use(errorcatch.ErrorCatch(), middleware.Report(), middleware.Cors(), security.Security())
+	if config.Env() == "local" {
+		app.Use(middleware.Report())
+	}
+	app.Use(errorcatch.ErrorCatch(), middleware.Cors(), security.Security())
 
 	// 静态目录-静态资源
 	if v := config.Get("staticFile.default"); v != nil {

src/framework/config/config/config.default.yaml

@@ -1,7 +1,7 @@
 # 项目信息
 framework:
   name: "OMC"
-  version: "2.2408.2"
+  version: "2.2408.3"
 
 # 应用服务配置
 server:
@@ -172,6 +172,13 @@ redis:
   # 多个数据源时可以用这个指定默认的数据源
   defaultDataSourceName: "default"
 
+# AES 加密
+aes:
+  # 接口密钥
+  apiKey: "T9ox2DCzpLfJIPzkH9pKhsOTMOEMJcFv"
+  # 网元主机密钥
+  hostKey: "AGT66VfY4SMaiT97a7df0aef1704d5c5"
+
 # 用户配置
 user:
   # 密码

src/framework/constants/result/result.go

@@ -8,8 +8,13 @@ const (
 	// 响应-msg错误失败
 	MSG_ERROR = "error"
 
-	// 响应-msg正常成功
-	CODE_SUCCESS = 1
 	// 响应-code正常成功
+	CODE_SUCCESS = 1
+	// 响应-msg正常成功
 	MSG_SUCCESS = "success"
+
+	// 响应-code加密数据
+	CODE_ENCRYPT = 2
+	// 响应-msg加密数据
+	MSG_ENCRYPT = "encrypt"
 )

src/framework/errorcatch/errorcatch.go

@@ -20,14 +20,14 @@ func ErrorCatch() gin.HandlerFunc {
 
 				// 返回错误响应给客户端
 				if config.Env() == "prod" {
-					c.JSON(500, result.ErrMsg("Internal Server Errors"))
+					c.JSON(500, result.CodeMsg(500, "Internal Server Errors"))
 				} else {
 					// 通过实现 error 接口的 Error() 方法自定义错误类型进行捕获
 					switch v := err.(type) {
 					case error:
-						c.JSON(500, result.ErrMsg(v.Error()))
+						c.JSON(500, result.CodeMsg(500, v.Error()))
 					default:
-						c.JSON(500, result.ErrMsg(fmt.Sprint(err)))
+						c.JSON(500, result.CodeMsg(500, fmt.Sprint(err)))
 					}
 				}
 

src/framework/middleware/crypto_api.go

@@ -0,0 +1,151 @@
+package middleware
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"strings"
+
+	"be.ems/src/framework/config"
+	constResult "be.ems/src/framework/constants/result"
+	"be.ems/src/framework/logger"
+	"be.ems/src/framework/utils/crypto"
+	"be.ems/src/framework/utils/parse"
+	"github.com/gin-gonic/gin"
+)
+
+// CryptoApi 接口加解密
+//
+// 示例参数：middleware.CryptoApi(true, true)
+//
+// 参数表示：对请求解密，对响应加密
+//
+// 请将中间件放在最前置，对请求优先处理
+func CryptoApi(requestDecrypt, responseEncrypt bool) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		// 请求解密时对请求data注入
+		if requestDecrypt {
+			method := c.Request.Method
+			contentType := c.ContentType()
+			contentDe := ""
+			// 请求参数解析
+			if method == "GET" {
+				contentDe = c.Query("data")
+			} else if contentType == gin.MIMEJSON {
+				var body struct {
+					Data string `json:"data" binding:"required"`
+				}
+				if err := c.ShouldBindJSON(&body); err == nil {
+					contentDe = body.Data
+				}
+			}
+
+			// 是否存在data字段数据
+			if contentDe == "" {
+				c.JSON(400, map[string]any{
+					"code": constResult.CODE_ERROR,
+					"msg":  "decrypt not found field data",
+				})
+				c.Abort() // 停止执行后续的处理函数
+				return
+			}
+
+			// 解密-原数据加密前含16位长度iv
+			apiKey := config.Get("aes.apiKey").(string)
+			dataBodyStr, err := crypto.AESDecryptBase64(contentDe, apiKey)
+			if err != nil {
+				logger.Errorf("CryptoApi decrypt err => %v", err)
+				c.JSON(400, map[string]any{
+					"code": constResult.CODE_ERROR,
+					"msg":  "decrypted data could not be parsed",
+				})
+				c.Abort() // 停止执行后续的处理函数
+				return
+			}
+
+			// 分配回请求体
+			if method == "GET" {
+				var urlParams map[string]any
+				json.Unmarshal([]byte(dataBodyStr), &urlParams)
+				rawQuery := []string{}
+				for k, v := range urlParams {
+					rawQuery = append(rawQuery, fmt.Sprintf("%s=%v", k, v))
+				}
+				c.Request.URL.RawQuery = strings.Join(rawQuery, "&")
+			} else if contentType == gin.MIMEJSON {
+				c.Request.Body = io.NopCloser(bytes.NewBuffer([]byte(dataBodyStr)))
+			}
+		}
+
+		// 响应加密时替换原有的响应体
+		var rbw *replaceBodyWriter
+		if responseEncrypt {
+			rbw = &replaceBodyWriter{
+				body:           &bytes.Buffer{},
+				ResponseWriter: c.Writer,
+			}
+			c.Writer = rbw
+		}
+
+		// 调用下一个处理程序
+		c.Next()
+
+		// 响应加密时对响应data数据进行加密
+		if responseEncrypt {
+			// 满足成功并带数据的响应进行加密
+			if c.Writer.Status() == 200 {
+				var resBody map[string]any
+				json.Unmarshal(rbw.body.Bytes(), &resBody)
+				codeV, codeOk := resBody["code"]
+				dataV, dataOk := resBody["data"]
+				if codeOk && dataOk {
+					if parse.Number(codeV) == constResult.CODE_SUCCESS {
+						byteBodyData, _ := json.Marshal(dataV)
+						// 加密-原数据头加入标记16位长度iv终止符
+						apiKey := config.Get("aes.apiKey").(string)
+						contentEn, err := crypto.AESEncryptBase64("=:)"+string(byteBodyData), apiKey)
+						if err != nil {
+							logger.Errorf("CryptoApi encrypt err => %v", err)
+							rbw.ReplaceWrite([]byte(fmt.Sprintf(`{"code":"%d","msg":"encrypt err"}`, constResult.CODE_ERROR)))
+						} else {
+							// 响应加密
+							byteBody, _ := json.Marshal(map[string]any{
+								"code": constResult.CODE_ENCRYPT,
+								"msg":  constResult.MSG_ENCRYPT,
+								"data": contentEn,
+							})
+							rbw.ReplaceWrite(byteBody)
+						}
+					}
+				} else {
+					rbw.ReplaceWrite(nil)
+				}
+			} else {
+				rbw.ReplaceWrite(nil)
+			}
+		}
+		//
+	}
+}
+
+// replaceBodyWriter 替换默认的响应体
+type replaceBodyWriter struct {
+	gin.ResponseWriter
+	body *bytes.Buffer
+}
+
+// Write 写入响应体
+func (r replaceBodyWriter) Write(b []byte) (int, error) {
+	return r.body.Write(b)
+}
+
+// ReplaceWrite 替换响应体
+func (r *replaceBodyWriter) ReplaceWrite(b []byte) (int, error) {
+	if b == nil {
+		return r.ResponseWriter.Write(r.body.Bytes())
+	}
+	r.body = &bytes.Buffer{}
+	r.body.Write(b)
+	return r.ResponseWriter.Write(r.body.Bytes())
+}

src/framework/middleware/report.go

@@ -1,6 +1,7 @@
 package middleware
 
 import (
+	"runtime"
 	"time"
 
 	"be.ems/src/framework/logger"
@@ -18,6 +19,10 @@ func Report() gin.HandlerFunc {
 
 		// 计算请求处理时间，并打印日志
 		duration := time.Since(start)
-		logger.Infof("%s %s report end=> %v", c.Request.Method, c.Request.RequestURI, duration)
+		// logger.Infof("%s %s report end=> %v", c.Request.Method, c.Request.RequestURI, duration)
+		// 获取当前活跃的goroutine数量
+		num := runtime.NumGoroutine()
+		// logger.Infof("当前活跃的goroutine数量 %d\n", num)
+		logger.Infof("\n访问接口 %s %s\n总耗时 %v\n当前活跃的goroutine数量 %d\n", c.Request.Method, c.Request.RequestURI, duration, num)
 	}
 }

src/framework/utils/crypto/aes.go

@@ -10,12 +10,12 @@ import (
 	"io"
 )
 
-// StringEncryptByAES 字符串AES加密
-func StringEncryptByAES(text string) (string, error) {
+// AESEncryptBase64 AES加密转Base64字符串
+func AESEncryptBase64(text, key string) (string, error) {
 	if len(text) == 0 {
 		return "", nil
 	}
-	xpass, err := aesEncryptWithSalt([]byte(text))
+	xpass, err := AESEncrypt([]byte(text), []byte(key))
 	if err != nil {
 		return "", err
 	}
@@ -23,8 +23,8 @@ func StringEncryptByAES(text string) (string, error) {
 	return pass64, nil
 }
 
-// StringDecryptByAES 字符串AES解密
-func StringDecryptByAES(text string) (string, error) {
+// AESDecryptBase64 AES解密解Base64字符串
+func AESDecryptBase64(text, key string) (string, error) {
 	if len(text) == 0 {
 		return "", nil
 	}
@@ -32,21 +32,16 @@ func StringDecryptByAES(text string) (string, error) {
 	if err != nil {
 		return "", err
 	}
-
-	tpass, err := aesDecryptWithSalt(bytesPass)
+	tpass, err := AESDecrypt(bytesPass, []byte(key))
 	if err != nil {
 		return "", err
 	}
 	return string(tpass), nil
 }
 
-// aesKey 字符串AES加解密密钥
-const aesKey = "AGT66VfY4SMaiT97a7df0aef1704d5c5"
-
-// const aesKey = "AGT66VfY4SMaiT97"
-// aesEncryptWithSalt AES加密
-func aesEncryptWithSalt(plaintext []byte) ([]byte, error) {
-	block, err := aes.NewCipher([]byte(aesKey))
+// AESEncrypt AES加密
+func AESEncrypt(plaintext, aeskey []byte) ([]byte, error) {
+	block, err := aes.NewCipher(aeskey)
 	if err != nil {
 		return nil, err
 	}
@@ -68,8 +63,8 @@ func aesEncryptWithSalt(plaintext []byte) ([]byte, error) {
 	return ciphertext, nil
 }
 
-// aesDecryptWithSalt AES解密
-func aesDecryptWithSalt(ciphertext []byte) ([]byte, error) {
+// AESDecrypt AES解密
+func AESDecrypt(ciphertext, aeskey []byte) ([]byte, error) {
 	blockSize := aes.BlockSize
 	if len(ciphertext) < blockSize {
 		return nil, fmt.Errorf("ciphertext too short")
@@ -77,12 +72,14 @@ func aesDecryptWithSalt(ciphertext []byte) ([]byte, error) {
 
 	iv := ciphertext[:blockSize]
 	ciphertext = ciphertext[blockSize:]
+	block, err := aes.NewCipher([]byte(aeskey))
 
-	block, err := aes.NewCipher([]byte(aesKey))
 	if err != nil {
 		return nil, err
 	}
-
+	if len(ciphertext) == 0 {
+		return nil, fmt.Errorf("ciphertext is invalid")
+	}
 	if len(ciphertext)%blockSize != 0 {
 		return nil, fmt.Errorf("ciphertext is not a multiple of the block size")
 	}

src/framework/utils/machine/launch.go

@@ -8,6 +8,7 @@ import (
 	"runtime"
 	"time"
 
+	"be.ems/src/framework/config"
 	"be.ems/src/framework/constants/common"
 	"be.ems/src/framework/logger"
 	"be.ems/src/framework/utils/cmd"
@@ -68,7 +69,8 @@ func codeFileRead() (map[string]any, error) {
 	}
 	content := string(bytes)
 	// 解密
-	contentDe, err := crypto.StringDecryptByAES(content)
+	hostKey := config.Get("aes.hostKey").(string)
+	contentDe, err := crypto.AESDecryptBase64(content, hostKey)
 	if err != nil {
 		logger.Errorf("CodeFileRead decrypt: %v", err.Error())
 		return mapData, fmt.Errorf("decrypt fail")
@@ -86,7 +88,8 @@ func codeFileRead() (map[string]any, error) {
 func codeFileWrite(data map[string]any) error {
 	jsonByte, _ := json.Marshal(data)
 	// 加密
-	contentEn, err := crypto.StringEncryptByAES(string(jsonByte))
+	hostKey := config.Get("aes.hostKey").(string)
+	contentEn, err := crypto.AESEncryptBase64(string(jsonByte), hostKey)
 	if err != nil {
 		logger.Errorf("insert encrypt: %v", err.Error())
 		return fmt.Errorf("encrypt fail")

src/framework/utils/ua/ua.go

@@ -1,8 +1,8 @@
 package ua
 
-import "github.com/mssola/user_agent"
+import "github.com/mssola/useragent"
 
 // 获取user-agent信息
-func Info(userAgent string) *user_agent.UserAgent {
-	return user_agent.New(userAgent)
+func Info(userAgent string) *useragent.UserAgent {
+	return useragent.New(userAgent)
 }

src/framework/vo/result/result.go

@@ -3,7 +3,7 @@ package result
 import (
 	"fmt"
 
-	"be.ems/src/framework/constants/result"
+	constResult "be.ems/src/framework/constants/result"
 )
 
 // CodeMsg 响应结果
@@ -17,8 +17,8 @@ func CodeMsg(code int, msg string) map[string]any {
 // 响应成功结果 map[string]any{}
 func Ok(v map[string]any) map[string]any {
 	args := make(map[string]any)
-	args["code"] = result.CODE_SUCCESS
-	args["msg"] = result.MSG_SUCCESS
+	args["code"] = constResult.CODE_SUCCESS
+	args["msg"] = constResult.MSG_SUCCESS
 	// v合并到args
 	for key, value := range v {
 		args[key] = value
@@ -29,7 +29,7 @@ func Ok(v map[string]any) map[string]any {
 // 响应成功结果信息
 func OkMsg(msg string) map[string]any {
 	args := make(map[string]any)
-	args["code"] = result.CODE_SUCCESS
+	args["code"] = constResult.CODE_SUCCESS
 	args["msg"] = msg
 	return args
 }
@@ -37,8 +37,8 @@ func OkMsg(msg string) map[string]any {
 // 响应成功结果数据
 func OkData(data any) map[string]any {
 	args := make(map[string]any)
-	args["code"] = result.CODE_SUCCESS
-	args["msg"] = result.MSG_SUCCESS
+	args["code"] = constResult.CODE_SUCCESS
+	args["msg"] = constResult.MSG_SUCCESS
 	args["data"] = data
 	return args
 }
@@ -46,8 +46,8 @@ func OkData(data any) map[string]any {
 // 响应失败结果 map[string]any{}
 func Err(v map[string]any) map[string]any {
 	args := make(map[string]any)
-	args["code"] = result.CODE_ERROR
-	args["msg"] = result.MSG_ERROR
+	args["code"] = constResult.CODE_ERROR
+	args["msg"] = constResult.MSG_ERROR
 	// v合并到args
 	for key, value := range v {
 		args[key] = value
@@ -58,7 +58,7 @@ func Err(v map[string]any) map[string]any {
 // 响应失败结果信息
 func ErrMsg(msg string, fmt ...any) map[string]any {
 	args := make(map[string]any)
-	args["code"] = result.CODE_ERROR
+	args["code"] = constResult.CODE_ERROR
 	args["msg"] = msg
 	return args
 }
@@ -66,7 +66,7 @@ func ErrMsg(msg string, fmt ...any) map[string]any {
 // 响应失败结果信息
 func ErrMsgFmt(msg string, args ...any) map[string]any {
 	argv := make(map[string]any)
-	argv["code"] = result.CODE_ERROR
+	argv["code"] = constResult.CODE_ERROR
 	argv["msg"] = fmt.Sprintf(msg, args...)
 	return argv
 }
@@ -74,8 +74,8 @@ func ErrMsgFmt(msg string, args ...any) map[string]any {
 // 响应失败结果数据
 func ErrData(data any) map[string]any {
 	args := make(map[string]any)
-	args["code"] = result.CODE_ERROR
-	args["msg"] = result.MSG_ERROR
+	args["code"] = constResult.CODE_ERROR
+	args["msg"] = constResult.MSG_ERROR
 	args["data"] = data
 	return args
 }

src/modules/common/common.go

@@ -52,6 +52,7 @@ func Setup(router *gin.Engine) {
 			// 	Count: 10,
 			// 	Type:  middleware.LIMIT_IP,
 			// }),
+			middleware.CryptoApi(true, true),
 			controller.NewAccount.Login,
 		)
 		indexGroup.GET("/getInfo", middleware.PreAuthorize(nil), controller.NewAccount.Info)
@@ -74,6 +75,7 @@ func Setup(router *gin.Engine) {
 			// 	Count: 10,
 			// 	Type:  middleware.LIMIT_IP,
 			// }),
+			middleware.CryptoApi(true, true),
 			controller.NewRegister.Register,
 		)
 	}

src/modules/monitor/controller/monitor.go

@@ -28,21 +28,14 @@ type MonitorController struct {
 func (s *MonitorController) Load(c *gin.Context) {
 	language := ctx.AcceptLanguage(c)
 	var querys struct {
-		// 数据类型all/load/cpu/memory/io/network
-		Type string `form:"type" binding:"required,oneof=all load cpu memory io network"`
-		// 开始时间
-		StartTime int64 `form:"startTime" binding:"required"`
-		// 结束时间
-		EndTime int64 `form:"endTime" binding:"required"`
-		// 网元类型
-		NeType string `form:"neType"`
-		// 网元ID
-		NeID string `form:"neId"`
-		// 名称，networ和iok时有效
-		Name string `form:"name"`
+		Type      string `form:"type" binding:"required,oneof=all load cpu memory io network"` // 数据类型all/load/cpu/memory/io/network
+		StartTime int64  `form:"startTime" binding:"required"`                                 // 开始时间
+		EndTime   int64  `form:"endTime" binding:"required"`                                   // 结束时间
+		NeType    string `form:"neType"`                                                       // 网元类型
+		NeID      string `form:"neId"`                                                         // 网元ID
+		Name      string `form:"name"`                                                         // 名称，networ和io时有效
 	}
-	err := c.ShouldBindQuery(&querys)
-	if err != nil {
+	if err := c.ShouldBindQuery(&querys); err != nil {
 		c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
 		return
 	}

src/modules/monitor/controller/system_info.go

@@ -24,12 +24,13 @@ type SystemInfoController struct {
 //
 // GET /
 func (s *SystemInfoController) Info(c *gin.Context) {
-	c.JSON(200, result.OkData(map[string]any{
+	data := map[string]any{
 		"cpu":     s.systemInfogService.CPUInfo(),
 		"memory":  s.systemInfogService.MemoryInfo(),
 		"network": s.systemInfogService.NetworkInfo(),
 		"time":    s.systemInfogService.TimeInfo(),
 		"system":  s.systemInfogService.SystemInfo(),
 		"disk":    s.systemInfogService.DiskInfo(),
-	}))
+	}
+	c.JSON(200, result.OkData(data))
 }

src/modules/monitor/service/monitor.impl.go

@@ -9,11 +9,11 @@ import (
 	"be.ems/src/modules/monitor/model"
 	"be.ems/src/modules/monitor/repository"
 	systemService "be.ems/src/modules/system/service"
-	"github.com/shirou/gopsutil/v3/cpu"
-	"github.com/shirou/gopsutil/v3/disk"
-	"github.com/shirou/gopsutil/v3/load"
-	"github.com/shirou/gopsutil/v3/mem"
-	"github.com/shirou/gopsutil/v3/net"
+	"github.com/shirou/gopsutil/v4/cpu"
+	"github.com/shirou/gopsutil/v4/disk"
+	"github.com/shirou/gopsutil/v4/load"
+	"github.com/shirou/gopsutil/v4/mem"
+	"github.com/shirou/gopsutil/v4/net"
 )
 
 // 实例化服务层 MonitorImpl 结构体

src/modules/monitor/service/monitor_test.go

@@ -5,11 +5,11 @@ import (
 	"testing"
 	"time"
 
-	"github.com/shirou/gopsutil/v3/cpu"
-	"github.com/shirou/gopsutil/v3/disk"
-	"github.com/shirou/gopsutil/v3/load"
-	"github.com/shirou/gopsutil/v3/mem"
-	"github.com/shirou/gopsutil/v3/net"
+	"github.com/shirou/gopsutil/v4/cpu"
+	"github.com/shirou/gopsutil/v4/disk"
+	"github.com/shirou/gopsutil/v4/load"
+	"github.com/shirou/gopsutil/v4/mem"
+	"github.com/shirou/gopsutil/v4/net"
 )
 
 func init() {

src/modules/monitor/service/system_info.impl.go

@@ -1,6 +1,7 @@
 package service
 
 import (
+	"context"
 	"fmt"
 	"os"
 	"runtime"
@@ -10,11 +11,11 @@ import (
 	"be.ems/src/framework/config"
 	"be.ems/src/framework/utils/parse"
 
-	"github.com/shirou/gopsutil/v3/cpu"
-	"github.com/shirou/gopsutil/v3/disk"
-	"github.com/shirou/gopsutil/v3/host"
-	"github.com/shirou/gopsutil/v3/mem"
-	"github.com/shirou/gopsutil/v3/net"
+	"github.com/shirou/gopsutil/v4/cpu"
+	"github.com/shirou/gopsutil/v4/disk"
+	"github.com/shirou/gopsutil/v4/host"
+	"github.com/shirou/gopsutil/v4/mem"
+	"github.com/shirou/gopsutil/v4/net"
 )
 
 // 实例化服务层 SystemInfoImpl 结构体
@@ -150,9 +151,12 @@ func (s *SystemInfoImpl) NetworkInfo() map[string]string {
 // DiskInfo 磁盘信息
 func (s *SystemInfoImpl) DiskInfo() []map[string]string {
 	disks := make([]map[string]string, 0)
+	ctx := context.Background()
+	ctx, cancel := context.WithTimeout(ctx, 1*time.Second)
+	defer cancel()
 
-	partitions, err := disk.Partitions(false)
-	if err != nil {
+	partitions, err := disk.PartitionsWithContext(ctx, false)
+	if err != context.DeadlineExceeded {
 		return disks
 	}
 

src/modules/network_element/ne_config_test.go

@@ -29,7 +29,7 @@ const (
 	// 配置文件路径
 	configParamDir = "../../../config/param"
 	// configParamFile = "*" // 目录下全部更新
-	configParamFile = "upf_param_config.yaml" // 单文件更新
+	configParamFile = "ims_param_config.yaml" // 单文件更新
 )
 
 func TestEncrypt(t *testing.T) {
@@ -217,7 +217,7 @@ func parseParamConfig(data map[string]any) ([]map[string]string, error) {
 					itemMap["paramSort"] = fmt.Sprint(iiv)
 				case "perms", "method":
 					itemMap["paramPerms"] = iiv.(string)
-				case "data", "list", "array":
+				case "list", "array": // 参数类型为数组
 					itemMap["paramType"] = iik
 					strByte, _ := json.Marshal(iiv)
 					itemMap["paramJson"] = string(strByte)

src/modules/network_element/network_element.go

@@ -80,15 +80,18 @@ func Setup(router *gin.Engine) {
 			controller.NewNeInfo.List,
 		)
 		neInfoGroup.GET("/:infoId",
+			middleware.CryptoApi(false, true),
 			middleware.PreAuthorize(nil),
 			controller.NewNeInfo.Info,
 		)
 		neInfoGroup.POST("",
+			middleware.CryptoApi(true, true),
 			middleware.PreAuthorize(nil),
 			collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.neInfo", collectlogs.BUSINESS_TYPE_INSERT)),
 			controller.NewNeInfo.Add,
 		)
 		neInfoGroup.PUT("",
+			middleware.CryptoApi(true, true),
 			middleware.PreAuthorize(nil),
 			collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.neInfo", collectlogs.BUSINESS_TYPE_UPDATE)),
 			controller.NewNeInfo.Edit,
@@ -108,6 +111,7 @@ func Setup(router *gin.Engine) {
 			controller.NewNeHost.List,
 		)
 		neHostGroup.GET("/:hostId",
+			middleware.CryptoApi(false, true),
 			middleware.PreAuthorize(nil),
 			controller.NewNeHost.Info,
 		)

src/modules/network_element/repository/ne_host.impl.go

@@ -7,7 +7,6 @@ import (
 
 	"be.ems/src/framework/datasource"
 	"be.ems/src/framework/logger"
-	"be.ems/src/framework/utils/crypto"
 	"be.ems/src/framework/utils/parse"
 	"be.ems/src/framework/utils/repo"
 	"be.ems/src/modules/network_element/model"
@@ -170,32 +169,7 @@ func (r *NeHostImpl) SelectByIds(hostIds []string) []model.NeHost {
 		return []model.NeHost{}
 	}
 	// 转换实体
-	rows := r.convertResultRows(results)
-	arr := &rows
-	for i := range *arr {
-		passwordDe, err := crypto.StringDecryptByAES((*arr)[i].Password)
-		if err != nil {
-			logger.Errorf("selectById %s decrypt: %v", (*arr)[i].HostID, err.Error())
-			(*arr)[i].Password = ""
-		} else {
-			(*arr)[i].Password = passwordDe
-		}
-		privateKeyDe, err := crypto.StringDecryptByAES((*arr)[i].PrivateKey)
-		if err != nil {
-			logger.Errorf("selectById %s decrypt: %v", (*arr)[i].HostID, err.Error())
-			(*arr)[i].PrivateKey = ""
-		} else {
-			(*arr)[i].PrivateKey = privateKeyDe
-		}
-		passPhraseDe, err := crypto.StringDecryptByAES((*arr)[i].PassPhrase)
-		if err != nil {
-			logger.Errorf("selectById %s decrypt: %v", (*arr)[i].HostID, err.Error())
-			(*arr)[i].PassPhrase = ""
-		} else {
-			(*arr)[i].PassPhrase = passPhraseDe
-		}
-	}
-	return rows
+	return r.convertResultRows(results)
 }
 
 // CheckUniqueNeHost 校验主机是否唯一
@@ -263,28 +237,13 @@ func (r *NeHostImpl) Insert(neHost model.NeHost) string {
 		params["auth_mode"] = neHost.AuthMode
 	}
 	if neHost.Password != "" {
-		passwordEn, err := crypto.StringEncryptByAES(neHost.Password)
-		if err != nil {
-			logger.Errorf("insert encrypt: %v", err.Error())
-			return ""
-		}
-		params["password"] = passwordEn
+		params["password"] = neHost.Password
 	}
 	if neHost.PrivateKey != "" {
-		privateKeyEn, err := crypto.StringEncryptByAES(neHost.PrivateKey)
-		if err != nil {
-			logger.Errorf("insert encrypt: %v", err.Error())
-			return ""
-		}
-		params["private_key"] = privateKeyEn
+		params["private_key"] = neHost.PrivateKey
 	}
 	if neHost.PassPhrase != "" {
-		passPhraseEn, err := crypto.StringEncryptByAES(neHost.PassPhrase)
-		if err != nil {
-			logger.Errorf("insert encrypt: %v", err.Error())
-			return ""
-		}
-		params["pass_phrase"] = passPhraseEn
+		params["pass_phrase"] = neHost.PassPhrase
 	}
 	if neHost.Remark != "" {
 		params["remark"] = neHost.Remark
@@ -361,28 +320,13 @@ func (r *NeHostImpl) Update(neHost model.NeHost) int64 {
 		params["auth_mode"] = neHost.AuthMode
 	}
 	if neHost.Password != "" {
-		passwordEn, err := crypto.StringEncryptByAES(neHost.Password)
-		if err != nil {
-			logger.Errorf("update encrypt: %v", err.Error())
-			return 0
-		}
-		params["password"] = passwordEn
+		params["password"] = neHost.Password
 	}
 	if neHost.PrivateKey != "" {
-		privateKeyEn, err := crypto.StringEncryptByAES(neHost.PrivateKey)
-		if err != nil {
-			logger.Errorf("update encrypt: %v", err.Error())
-			return 0
-		}
-		params["private_key"] = privateKeyEn
+		params["private_key"] = neHost.PrivateKey
 	}
 	if neHost.PassPhrase != "" {
-		passPhraseEn, err := crypto.StringEncryptByAES(neHost.PassPhrase)
-		if err != nil {
-			logger.Errorf("update encrypt: %v", err.Error())
-			return 0
-		}
-		params["pass_phrase"] = passPhraseEn
+		params["pass_phrase"] = neHost.PassPhrase
 	}
 	params["remark"] = neHost.Remark
 	if neHost.UpdateBy != "" {

src/modules/network_element/service/ne_host.impl.go

@@ -3,6 +3,9 @@ package service
 import (
 	"fmt"
 
+	"be.ems/src/framework/config"
+	"be.ems/src/framework/logger"
+	"be.ems/src/framework/utils/crypto"
 	"be.ems/src/modules/network_element/model"
 	"be.ems/src/modules/network_element/repository"
 )
@@ -30,12 +33,39 @@ func (r *NeHostImpl) SelectList(neHost model.NeHost) []model.NeHost {
 
 // SelectByIds 通过ID查询
 func (r *NeHostImpl) SelectById(hostId string) model.NeHost {
+	neHost := model.NeHost{}
 	if hostId == "" {
-		return model.NeHost{}
+		return neHost
 	}
 	neHosts := r.neHostRepository.SelectByIds([]string{hostId})
 	if len(neHosts) > 0 {
-		return neHosts[0]
+		neHost := neHosts[0]
+		hostKey := config.Get("aes.hostKey").(string)
+		if neHost.Password != "" {
+			passwordDe, err := crypto.AESDecryptBase64(neHost.Password, hostKey)
+			if err != nil {
+				logger.Errorf("select encrypt: %v", err.Error())
+				return neHost
+			}
+			neHost.Password = passwordDe
+		}
+		if neHost.PrivateKey != "" {
+			privateKeyDe, err := crypto.AESDecryptBase64(neHost.PrivateKey, hostKey)
+			if err != nil {
+				logger.Errorf("select encrypt: %v", err.Error())
+				return neHost
+			}
+			neHost.PrivateKey = privateKeyDe
+		}
+		if neHost.PassPhrase != "" {
+			passPhraseDe, err := crypto.AESDecryptBase64(neHost.PassPhrase, hostKey)
+			if err != nil {
+				logger.Errorf("select encrypt: %v", err.Error())
+				return neHost
+			}
+			neHost.PassPhrase = passPhraseDe
+		}
+		return neHost
 	}
 	return model.NeHost{}
 }
@@ -54,11 +84,61 @@ func (r *NeHostImpl) Inserts(neHosts []model.NeHost) int64 {
 
 // Insert 新增信息
 func (r *NeHostImpl) Insert(neHost model.NeHost) string {
+	hostKey := config.Get("aes.hostKey").(string)
+	if neHost.Password != "" {
+		passwordEn, err := crypto.AESEncryptBase64(neHost.Password, hostKey)
+		if err != nil {
+			logger.Errorf("insert encrypt: %v", err.Error())
+			return ""
+		}
+		neHost.Password = passwordEn
+	}
+	if neHost.PrivateKey != "" {
+		privateKeyEn, err := crypto.AESEncryptBase64(neHost.PrivateKey, hostKey)
+		if err != nil {
+			logger.Errorf("insert encrypt: %v", err.Error())
+			return ""
+		}
+		neHost.PrivateKey = privateKeyEn
+	}
+	if neHost.PassPhrase != "" {
+		passPhraseEn, err := crypto.AESEncryptBase64(neHost.PassPhrase, hostKey)
+		if err != nil {
+			logger.Errorf("insert encrypt: %v", err.Error())
+			return ""
+		}
+		neHost.PassPhrase = passPhraseEn
+	}
 	return r.neHostRepository.Insert(neHost)
 }
 
 // Update 修改信息
 func (r *NeHostImpl) Update(neHost model.NeHost) int64 {
+	hostKey := config.Get("aes.hostKey").(string)
+	if neHost.Password != "" {
+		passwordEn, err := crypto.AESEncryptBase64(neHost.Password, hostKey)
+		if err != nil {
+			logger.Errorf("update password encrypt: %v", err.Error())
+			return 0
+		}
+		neHost.Password = passwordEn
+	}
+	if neHost.PrivateKey != "" {
+		privateKeyEn, err := crypto.AESEncryptBase64(neHost.PrivateKey, hostKey)
+		if err != nil {
+			logger.Errorf("update private key encrypt: %v", err.Error())
+			return 0
+		}
+		neHost.PrivateKey = privateKeyEn
+	}
+	if neHost.PassPhrase != "" {
+		passPhraseEn, err := crypto.AESEncryptBase64(neHost.PassPhrase, hostKey)
+		if err != nil {
+			logger.Errorf("update pass phrase encrypt: %v", err.Error())
+			return 0
+		}
+		neHost.PassPhrase = passPhraseEn
+	}
 	return r.neHostRepository.Update(neHost)
 }
 

src/modules/network_element/service/ne_info.impl.go

@@ -208,7 +208,17 @@ func (r *NeInfoImpl) bandNeHosts(arr *[]model.NeInfo) {
 	for i := range *arr {
 		v := (*arr)[i]
 		if v.HostIDs != "" {
-			(*arr)[i].Hosts = NewNeHostImpl.neHostRepository.SelectByIds(strings.Split(v.HostIDs, ","))
+			hostIds := strings.Split(v.HostIDs, ",")
+			if len(hostIds) <= 1 {
+				continue
+			}
+			for _, hostId := range hostIds {
+				neHost := NewNeHostImpl.SelectById(hostId)
+				if neHost.HostID == "" || neHost.HostID != hostId {
+					continue
+				}
+				(*arr)[i].Hosts = append((*arr)[i].Hosts, neHost)
+			}
 		}
 	}
 }
@@ -222,12 +232,11 @@ func (r *NeInfoImpl) SelectById(infoId string, bandHost bool) model.NeInfo {
 	}
 	neInfos := r.neInfoRepository.SelectByIds([]string{infoId})
 	if len(neInfos) > 0 {
-		neInfo := neInfos[0]
 		// 带主机信息
-		if neInfo.HostIDs != "" && bandHost {
-			neInfo.Hosts = NewNeHostImpl.neHostRepository.SelectByIds(strings.Split(neInfo.HostIDs, ","))
+		if neInfos[0].HostIDs != "" && bandHost {
+			r.bandNeHosts(&neInfos)
 		}
-		return neInfo
+		return neInfos[0]
 	}
 	return model.NeInfo{}
 }
@@ -335,12 +344,17 @@ func (r *NeInfoImpl) NeRunSSHClient(neType, neId string) (*ssh.ConnSSH, error) {
 		logger.Errorf("NeRunSSHClient NeType:%s NeID:%s hostId not found", neType, neId)
 		return nil, fmt.Errorf("neinfo hostId not found")
 	}
-	neInfo.Hosts = NewNeHostImpl.neHostRepository.SelectByIds(strings.Split(neInfo.HostIDs, ","))
-	if len(neInfo.Hosts) <= 0 {
-		logger.Errorf("NeRunSSHClient Hosts %s not found", neInfo.HostIDs)
+	hostIds := strings.Split(neInfo.HostIDs, ",")
+	if len(hostIds) <= 1 {
+		logger.Errorf("NeRunTelnetClient hosts id %s not found", neInfo.HostIDs)
+		return nil, fmt.Errorf("neinfo host id not found")
+	}
+	hostId := hostIds[0] // 网元主机ssh 0：22
+	neHost := NewNeHostImpl.SelectById(hostId)
+	if neHost.HostID == "" || neHost.HostID != hostId {
+		logger.Errorf("NeRunTelnetClient Hosts %s not found", neInfo.HostIDs)
 		return nil, fmt.Errorf("neinfo host not found")
 	}
-	neHost := neInfo.Hosts[0] // 网元主机ssh 0：22
 	if neHost.HostType != "ssh" {
 		logger.Errorf("NeRunSSHClient Hosts first HostType %s not ssh", neHost.HostType)
 		return nil, fmt.Errorf("neinfo host type not ssh")
@@ -392,12 +406,17 @@ func (r *NeInfoImpl) NeRunTelnetClient(neType, neId string, num int) (*telnet.Co
 		logger.Errorf("NeRunTelnetClient NeType:%s NeID:%s hostId not found", neType, neId)
 		return nil, fmt.Errorf("neinfo hostId not found")
 	}
-	neInfo.Hosts = NewNeHostImpl.neHostRepository.SelectByIds(strings.Split(neInfo.HostIDs, ","))
-	if len(neInfo.Hosts) <= 0 {
+	hostIds := strings.Split(neInfo.HostIDs, ",")
+	if len(hostIds) <= 1 {
+		logger.Errorf("NeRunTelnetClient hosts id %s not found", neInfo.HostIDs)
+		return nil, fmt.Errorf("neinfo host id not found")
+	}
+	hostId := hostIds[num] // 网元主机telnet 1：4100 2：5200
+	neHost := NewNeHostImpl.SelectById(hostId)
+	if neHost.HostID == "" || neHost.HostID != hostId {
 		logger.Errorf("NeRunTelnetClient Hosts %s not found", neInfo.HostIDs)
 		return nil, fmt.Errorf("neinfo host not found")
 	}
-	neHost := neInfo.Hosts[num]
 
 	// 创建链接Telnet客户端
 	var connTelnet telnet.ConnTelnet

src/modules/ws/model/net_connect.go

@@ -1,6 +1,6 @@
 package model
 
-import "github.com/shirou/gopsutil/v3/net"
+import "github.com/shirou/gopsutil/v4/net"
 
 // NetConnectData 网络连接进程数据
 type NetConnectData struct {

src/modules/ws/processor/net_connect.go

@@ -8,8 +8,8 @@ import (
 	"be.ems/src/framework/logger"
 	"be.ems/src/framework/vo/result"
 	"be.ems/src/modules/ws/model"
-	"github.com/shirou/gopsutil/v3/net"
-	"github.com/shirou/gopsutil/v3/process"
+	"github.com/shirou/gopsutil/v4/net"
+	"github.com/shirou/gopsutil/v4/process"
 )
 
 // GetNetConnections 获取网络连接进程

src/modules/ws/processor/ps_process.go

@@ -12,7 +12,7 @@ import (
 	"be.ems/src/framework/utils/parse"
 	"be.ems/src/framework/vo/result"
 	"be.ems/src/modules/ws/model"
-	"github.com/shirou/gopsutil/v3/process"
+	"github.com/shirou/gopsutil/v4/process"
 )
 
 // GetProcessData 获取进程数据