OMC/be.ems
1
0
Fork 0
Code Issues Releases 3 Activity

ref: 网元数据将网元特有拆分直连模块

Browse Source
This commit is contained in:
TsMask
2025-06-11 16:32:50 +08:00
parent 1f3e07d5c7
commit f9648d1b26
56 changed files with 570 additions and 619 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/modules/network_element/controller/ne_config.go
View File

@@ -9,9 +9,9 @@ import (
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
"be.ems/src/framework/utils/parse"
neFetchlink "be.ems/src/modules/network_element/fetch_link"
"be.ems/src/modules/network_element/model"
neService "be.ems/src/modules/network_element/service"
neFetchlink "be.ems/src/modules/network_link/fetch_link"
traceService "be.ems/src/modules/trace/service"
"github.com/gin-gonic/gin"

134
src/modules/network_element/controller/ne_info.go
View File

@@ -2,16 +2,15 @@ package controller
import (
"fmt"
"strings"
"sync"
"be.ems/src/framework/i18n"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
"be.ems/src/framework/utils/parse"
neFetchlink "be.ems/src/modules/network_element/fetch_link"
"be.ems/src/modules/network_element/model"
neService "be.ems/src/modules/network_element/service"
neFetchlink "be.ems/src/modules/network_link/fetch_link"
"github.com/gin-gonic/gin"
)
@@ -345,7 +344,6 @@ func (s NeInfoController) Info(c *gin.Context) {
// @Description Network element information addition
// @Router /ne/info [post]
func (s NeInfoController) Add(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
var body model.NeInfo
err := c.ShouldBindBodyWithJSON(&body)
if err != nil {
@@ -358,68 +356,7 @@ func (s NeInfoController) Add(c *gin.Context) {
return
}
// 检查属性值唯一
uniqueInfo := s.neInfoService.CheckUniqueCoreIdAndNeType(body.CoreUID, body.NeUID, 0)
if !uniqueInfo {
// 网元信息操作【%s】失败，同类型下标识已存在
msg := i18n.TTemplate(language, "neInfo.errKeyExists", map[string]any{"key": body.NeUID})
c.JSON(200, resp.ErrMsg(msg))
return
}
// 获取网元状态是否正常
body.ServerState, err = neFetchlink.NeState(body)
if err != nil {
body.Status = 0
} else {
// 网元状态设置为在线
body.Status = 1
if parse.Boolean(body.ServerState["standby"]) {
body.Status = 3
}
// 下发网管配置信息给网元
if _, err = neFetchlink.NeConfigOMC(body); err != nil {
body.Status = 2
}
}
loginUserName := reqctx.LoginUserToUserName(c)
// 新增Version信息
neVersion := model.NeVersion{
CoreUID: body.CoreUID,
NeUID: body.NeUID,
NeType: body.NeType,
CreateBy: loginUserName,
}
// 新增License信息
neLicense := model.NeLicense{
CoreUID: body.CoreUID,
NeUID: body.NeUID,
NeType: body.NeType,
CreateBy: loginUserName,
}
// 已有网元可获取的信息
if body.ServerState != nil {
if v, ok := body.ServerState["version"]; ok && v != nil {
neVersion.Name = "-"
neVersion.Path = "-"
neVersion.Version = fmt.Sprint(v)
}
if v, ok := body.ServerState["capability"]; ok && v != nil {
neLicense.Capability = parse.Number(v)
}
if v, ok := body.ServerState["sn"]; ok && v != nil {
neLicense.SerialNum = fmt.Sprint(v)
}
if v, ok := body.ServerState["expire"]; ok && v != nil {
neLicense.ExpiryDate = fmt.Sprint(v)
neLicense.Status = "1"
}
}
s.neVersionService.Insert(neVersion)
s.neLicenseService.Insert(neLicense)
body.CreateBy = loginUserName
insertId := s.neInfoService.Insert(body)
if insertId > 0 {
@@ -456,15 +393,6 @@ func (s NeInfoController) Edit(c *gin.Context) {
return
}
// 检查属性值唯一
uniqueInfo := s.neInfoService.CheckUniqueCoreIdAndNeType(body.CoreUID, body.NeUID, body.ID)
if !uniqueInfo {
// 网元信息操作【%s】失败，同类型下标识已存在
msg := i18n.TTemplate(language, "neInfo.errKeyExists", map[string]any{"key": body.NeUID})
c.JSON(200, resp.ErrMsg(msg))
return
}
// 检查是否存在
neInfo := s.neInfoService.FindById(body.ID, false)
if neInfo.ID != body.ID {
@@ -472,68 +400,8 @@ func (s NeInfoController) Edit(c *gin.Context) {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "neInfo.noData")))
return
}
// 赋予主机ID
if neInfo.HostIDs != "" && len(body.Hosts) > 0 {
hostIDs := strings.Split(neInfo.HostIDs, ",")
for index, id := range hostIDs {
body.Hosts[index].ID = parse.Number(id)
}
}
// 获取网元状态是否正常
body.ServerState, err = neFetchlink.NeState(neInfo)
if err != nil {
body.Status = 0
} else {
// 网元状态设置为在线
body.Status = 1
if parse.Boolean(body.ServerState["standby"]) {
body.Status = 3
}
// 下发网管配置信息给网元
if _, err = neFetchlink.NeConfigOMC(body); err != nil {
body.Status = 2
}
}
loginUserName := reqctx.LoginUserToUserName(c)
neLicense := s.neLicenseService.FindByCoreUidAndNeUid(neInfo.CoreUID, neInfo.NeUID)
neVersion := s.neVersionService.FindByCoreUidAndNeUid(neInfo.CoreUID, neInfo.NeUID)
// 已有网元可获取的信息
if body.ServerState != nil {
if v, ok := body.ServerState["version"]; ok && v != nil {
neVersion.Name = "-"
neVersion.Path = "-"
neVersion.Version = fmt.Sprint(v)
neVersion.UpdateBy = loginUserName
}
if v, ok := body.ServerState["capability"]; ok && v != nil {
neLicense.Capability = parse.Number(v)
}
if v, ok := body.ServerState["sn"]; ok && v != nil {
neLicense.SerialNum = fmt.Sprint(v)
}
if v, ok := body.ServerState["expire"]; ok && v != nil {
neLicense.ExpiryDate = fmt.Sprint(v)
neLicense.Status = "1"
neLicense.UpdateBy = loginUserName
}
}
if neVersion.ID <= 0 {
if neVersion.NeType != body.NeType {
neVersion.NeType = body.NeType
}
s.neVersionService.Update(neVersion)
}
if neLicense.ID <= 0 {
if neLicense.NeType != body.NeType {
neLicense.NeType = body.NeType
}
s.neLicenseService.Update(neLicense)
}
body.UpdateBy = loginUserName
rows := s.neInfoService.Update(body)
if rows > 0 {

2
src/modules/network_element/controller/ne_license.go
View File

@@ -10,9 +10,9 @@ import (
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
"be.ems/src/framework/utils/parse"
neFetchlink "be.ems/src/modules/network_element/fetch_link"
"be.ems/src/modules/network_element/model"
neService "be.ems/src/modules/network_element/service"
neFetchlink "be.ems/src/modules/network_link/fetch_link"
)
// 实例化控制层 NeLicenseController 结构体

39
src/modules/network_element/fetch_link/alarm.go
View File

@@ -1,39 +0,0 @@
package fetchlink
import (
"encoding/json"
"fmt"
"strings"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/fetch"
"be.ems/src/modules/network_element/model"
)
// AlarmHistory 告警历史记录
func AlarmHistory(neInfo model.NeInfo) ([]map[string]any, error) {
// 网元参数配置信息
neUrl := fmt.Sprintf("http://%s:%d/api/rest/faultManagement/v1/elementType/%s/objectType/alarms", neInfo.IPAddr, neInfo.Port, strings.ToLower(neInfo.NeType))
resBytes, err := fetch.Get(neUrl, nil, 60_000)
var resData []map[string]any
if err != nil {
errStr := err.Error()
logger.Warnf("AlarmHistory Get \"%s\"", neUrl)
if !(strings.HasPrefix(errStr, "201") || strings.HasPrefix(errStr, "202") || strings.HasPrefix(errStr, "204")) {
logger.Errorf("AlarmHistory %s", err.Error())
return nil, fmt.Errorf("NeService Alarm History Info API Error")
}
}
if len(resBytes) == 0 {
return resData, nil
}
// 序列化结果
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("AlarmHistory Unmarshal %s", err.Error())
return nil, err
}
return resData, nil
}

105
src/modules/network_element/fetch_link/amf.go
View File

@@ -1,105 +0,0 @@
package fetchlink
import (
"encoding/json"
"fmt"
"strings"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/fetch"
"be.ems/src/modules/network_element/model"
)
// AMFNbInfoList AMF基站信息
//
// 查询参数 {"id":"7"}
//
// 返回结果 []
func AMFNbInfoList(neInfo model.NeInfo, data map[string]string) ([]map[string]any, error) {
neUrl := fmt.Sprintf("http://%s:%d/api/rest/ueManagement/v1/elementType/amf/objectType/nbInfo", neInfo.IPAddr, neInfo.Port)
// 查询参数拼接
query := []string{}
if v, ok := data["id"]; ok && v != "" {
query = append(query, fmt.Sprintf("nbId=%s", v))
}
if len(query) > 0 {
neUrl = fmt.Sprintf("%s?%s", neUrl, strings.Join(query, "&"))
}
var resData map[string]any
resBytes, err := fetch.Get(neUrl, nil, 60_000)
if err != nil {
errStr := err.Error()
logger.Warnf("AMFNbInfoList Get \"%s\"", neUrl)
logger.Errorf("AMFNbInfoList %s", errStr)
return nil, fmt.Errorf("NeService AMF API Error")
}
// 序列化结果 {"data":[{"id":"7","name":"NR-SA-GNB","address":"192.168.5.100:60110","ueNum":0}]}
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("AMFNbInfoList Unmarshal %s", err.Error())
return nil, err
}
// 固定返回字段，方便前端解析
if v, ok := resData["data"]; ok && v != nil {
if arr := v.([]any); len(arr) > 0 {
result := make([]map[string]any, len(arr))
for i, item := range arr {
result[i] = item.(map[string]any)
}
return result, nil
}
}
return []map[string]any{}, nil
}
// AMFGnbStateList AMF基站状态信息，对比配置项gnbList
//
// 返回结果 []
func AMFGnbStateList(neInfo model.NeInfo) ([]map[string]any, error) {
neUrl := fmt.Sprintf("http://%s:%d/api/rest/ueManagement/v1/elementType/amf/objectType/nbState", neInfo.IPAddr, neInfo.Port)
resBytes, err := fetch.Get(neUrl, nil, 60_000)
if err != nil {
errStr := err.Error()
logger.Warnf("AMFGnbStateList Get \"%s\"", neUrl)
logger.Errorf("AMFGnbStateList %s", errStr)
return nil, fmt.Errorf("NeService AMF API Error")
}
// 序列化结果
// {
// "data": [
// {
// "index": 1,
// "name": "Gnb",
// "address": "192.168.8.1",
// "position": "Area-B",
// "offTime": "2024-12-30T16:31:57+08:00",
// "onTime": "2024-12-30T15:41:59+08:00",
// "state": "OFF",
// "nbName": "SA",
// "ueNum": 1
// },
// ]
// }
var resData map[string]any
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("AMFGnbStateList Unmarshal %s", err.Error())
return nil, err
}
// 固定返回字段，方便前端解析
if v, ok := resData["data"]; ok && v != nil {
if arr := v.([]any); len(arr) > 0 {
result := make([]map[string]any, len(arr))
for i, item := range arr {
result[i] = item.(map[string]any)
}
return result, nil
}
}
return []map[string]any{}, nil
}

68
src/modules/network_element/fetch_link/hlr.go
View File

@@ -1,68 +0,0 @@
// 网元HLR服务8080端口。
// 融合到UDM网元，也许是UDM的HLR服务。
package fetchlink
import (
"encoding/json"
"fmt"
"strings"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/fetch"
"be.ems/src/modules/network_element/model"
)
// HLRTraceStart HLR跟踪任务开始
//
// data参数 {traceID:"跟踪任务ID", imsi:"IMSI和MSISDN必填一个，都带的话以IMSI为准", msisdn:""}
func HLRTraceStart(neInfo model.NeInfo, data map[string]any) (string, error) {
// 网元参数配置新增（array）
neUrl := fmt.Sprintf("http://%s:%d/trace-manage/v1/add-task", neInfo.IPAddr, neInfo.Port)
resBytes, err := fetch.PostJSON(neUrl, data, nil)
var resData map[string]string
if err != nil {
errStr := err.Error()
logger.Warnf("HLRTraceStart Post \"%s\"", neUrl)
logger.Errorf("HLRTraceStart %s", errStr)
return "", fmt.Errorf("NeService HLR API Error")
}
// 序列化结果
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("HLRTraceStart Unmarshal %s", err.Error())
return "", err
}
if v, ok := resData["code"]; ok && v == "0" {
return strings.TrimSpace(strings.ToLower(resData["message"])), nil
}
return "", fmt.Errorf("%s", resData["message"])
}
// HLRTraceStop HLR跟踪任务停止
//
// data参数 {traceIDArray: ["跟踪任务ID数组"]}
func HLRTraceStop(neInfo model.NeInfo, data map[string]any) (string, error) {
// 网元参数配置新增（array）
neUrl := fmt.Sprintf("http://%s:%d/trace-manage/v1/delete-task", neInfo.IPAddr, neInfo.Port)
resBytes, err := fetch.PostJSON(neUrl, data, nil)
var resData map[string]string
if err != nil {
errStr := err.Error()
logger.Warnf("HLRTraceStop Post \"%s\"", neUrl)
logger.Errorf("HLRTraceStop %s", errStr)
return "", fmt.Errorf("NeService HLR API Error")
}
// 序列化结果
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("HLRTraceStop Unmarshal %s", err.Error())
return "", err
}
if v, ok := resData["code"]; ok && v == "0" {
return strings.TrimSpace(strings.ToLower(resData["message"])), nil
}
return "", fmt.Errorf("%s", resData["message"])
}

100
src/modules/network_element/fetch_link/ims.go
View File

@@ -1,100 +0,0 @@
package fetchlink
import (
"encoding/json"
"fmt"
"strings"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/fetch"
"be.ems/src/framework/utils/parse"
"be.ems/src/modules/network_element/model"
)
// IMSUeSessionNum IMS会话数量
//
// 返回结果 0
func IMSUeSessionNum(neInfo model.NeInfo) (int64, error) {
neUrl := fmt.Sprintf("http://%s:%d/api/rest/ueManagement/v1/elementType/ims/objectType/ueNum", neInfo.IPAddr, neInfo.Port)
resBytes, err := fetch.Get(neUrl, nil, 60_000)
if err != nil {
errStr := err.Error()
logger.Warnf("IMSUeSessionNum Get \"%s\"", neUrl)
logger.Errorf("IMSUeSessionNum %s", errStr)
return 0, fmt.Errorf("NeService IMS API Error")
}
// 序列化结果 {"data":{"ueNum":0}}
var resData map[string]any
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("IMSUeSessionNum Unmarshal %s", err.Error())
return 0, err
}
// 固定返回字段，方便前端解析
var ueNum int64 = 0
if v, ok := resData["data"]; ok && v != nil {
if num := v.(map[string]any)["ueNum"]; num != nil {
ueNum = parse.Number(num)
}
}
return ueNum, nil
}
// IMSUeSessionList IMS会话列表
//
// 查询参数 {"imsi":"460001230000002","msisdn":"12307551232"}
//
// 返回结果 []
func IMSUeSessionList(neInfo model.NeInfo, data map[string]string) ([]map[string]any, error) {
neUrl := fmt.Sprintf("http://%s:%d/api/rest/ueManagement/v1/elementType/ims/objectType/ueInfo", neInfo.IPAddr, neInfo.Port)
// 查询参数拼接
query := []string{}
if v, ok := data["imsi"]; ok && v != "" {
query = append(query, fmt.Sprintf("imsi=%s", v))
}
if v, ok := data["msisdn"]; ok && v != "" {
query = append(query, fmt.Sprintf("msisdn=%s", v))
}
if len(query) > 0 {
neUrl = fmt.Sprintf("%s?%s", neUrl, strings.Join(query, "&"))
}
resBytes, err := fetch.Get(neUrl, nil, 60_000)
if err != nil {
errStr := err.Error()
logger.Warnf("IMSUeSessionList Get \"%s\"", neUrl)
logger.Errorf("IMSUeSessionList %s", errStr)
return nil, fmt.Errorf("NeService IMS API Error")
}
// 序列化结果
// { "data":[
// {
// "activeTime": "2023-11-29 17:04:54",
// "barring": 0,
// "impu": "sip:12307551232@ims.mnc000.mcc460.3gppnetwork.org",
// "imsi": "460001230000002",
// "msisdn": "12307551232",
// "regState": 1
// }
// ] }
var resData map[string]any
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("IMSUeSessionList Unmarshal %s", err.Error())
return nil, err
}
// 固定返回字段，方便前端解析
if v, ok := resData["data"]; ok && v != nil {
if arr := v.([]any); len(arr) > 0 {
result := make([]map[string]any, len(arr))
for i, item := range arr {
result[i] = item.(map[string]any)
}
return result, nil
}
}
return []map[string]any{}, nil
}

105
src/modules/network_element/fetch_link/mme.go
View File

@@ -1,105 +0,0 @@
package fetchlink
import (
"encoding/json"
"fmt"
"strings"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/fetch"
"be.ems/src/modules/network_element/model"
)
// MMENbInfoList MME基站信息
//
// 查询参数 {"id":"7"}
//
// 返回结果 []
func MMENbInfoList(neInfo model.NeInfo, data map[string]string) ([]map[string]any, error) {
neUrl := fmt.Sprintf("http://%s:%d/api/rest/ueManagement/v1/elementType/mme/objectType/nbInfo", neInfo.IPAddr, neInfo.Port)
// 查询参数拼接
query := []string{}
if v, ok := data["id"]; ok && v != "" {
query = append(query, fmt.Sprintf("nbId=%s", v))
}
if len(query) > 0 {
neUrl = fmt.Sprintf("%s?%s", neUrl, strings.Join(query, "&"))
}
var resData map[string]any
resBytes, err := fetch.Get(neUrl, nil, 60_000)
if err != nil {
errStr := err.Error()
logger.Warnf("MMENbInfoList Get \"%s\"", neUrl)
logger.Errorf("MMENbInfoList %s", errStr)
return nil, fmt.Errorf("NeService MME API Error")
}
// 序列化结果 {"data":[{"id":"7","name":"NR-SA-GNB","address":"192.168.5.100:60110","ueNum":0}]}
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("MMENbInfoList Unmarshal %s", err.Error())
return nil, err
}
// 固定返回字段，方便前端解析
if v, ok := resData["data"]; ok && v != nil {
if arr := v.([]any); len(arr) > 0 {
result := make([]map[string]any, len(arr))
for i, item := range arr {
result[i] = item.(map[string]any)
}
return result, nil
}
}
return []map[string]any{}, nil
}
// MMEEnbStateList MME基站状态信息，对比配置项enbList
//
// 返回结果 []
func MMEEnbStateList(neInfo model.NeInfo) ([]map[string]any, error) {
neUrl := fmt.Sprintf("http://%s:%d/api/rest/ueManagement/v1/elementType/mme/objectType/nbState", neInfo.IPAddr, neInfo.Port)
resBytes, err := fetch.Get(neUrl, nil, 60_000)
if err != nil {
errStr := err.Error()
logger.Warnf("MMEEnbStateList Get \"%s\"", neUrl)
logger.Errorf("MMEEnbStateList %s", errStr)
return nil, fmt.Errorf("NeService MME API Error")
}
// 序列化结果
// {
// "data": [
// {
// "index": 1,
// "name": "Enb",
// "address": "192.168.8.1",
// "position": "Area-B",
// "offTime": "2024-12-30T16:31:57+08:00",
// "onTime": "2024-12-30T15:41:59+08:00",
// "state": "OFF",
// "nbName": "SA",
// "ueNum": 1
// },
// ]
// }
var resData map[string]any
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("MMEEnbStateList Unmarshal %s", err.Error())
return nil, err
}
// 固定返回字段，方便前端解析
if v, ok := resData["data"]; ok && v != nil {
if arr := v.([]any); len(arr) > 0 {
result := make([]map[string]any, len(arr))
for i, item := range arr {
result[i] = item.(map[string]any)
}
return result, nil
}
}
return []map[string]any{}, nil
}

170
src/modules/network_element/fetch_link/ne_config.go
View File

@@ -1,170 +0,0 @@
package fetchlink
import (
"encoding/json"
"fmt"
"strings"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/fetch"
"be.ems/src/modules/network_element/model"
)
// NeConfigOMC 网元配置对端网管信息
func NeConfigOMC(neInfo model.NeInfo) (map[string]any, error) {
// 网元配置对端网管信息
neUrl := fmt.Sprintf("http://%s:%d/api/rest/systemManagement/v1/elementType/%s/objectType/config/omcNeConfig", neInfo.IPAddr, neInfo.Port, strings.ToLower(neInfo.NeType))
resBytes, err := fetch.PutJSON(neUrl, map[string]any{
"neId": neInfo.ID,
"neName": neInfo.NeName,
"port": neInfo.Port,
"province": neInfo.Province,
"pvFlag": neInfo.PvFlag,
"rmUID": neInfo.NeUID,
"vendorName": neInfo.VendorName,
"dn": neInfo.Dn,
}, nil)
var resData map[string]any
if err != nil {
errStr := err.Error()
if strings.HasPrefix(errStr, "201") || strings.HasPrefix(errStr, "204") {
return resData, nil
}
logger.Warnf("NeConfigOMC Put \"%s\"", neUrl)
logger.Errorf("NeConfigOMC %s", errStr)
return nil, fmt.Errorf("NeService Config OMC Update API Error")
}
// 200 成功无数据时
if len(resBytes) == 0 {
return resData, nil
}
// 序列化结果
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("NeConfigOMC Unmarshal %s", err.Error())
return nil, err
}
return resData, nil
}
// NeConfigInfo 网元配置信息
func NeConfigInfo(neInfo model.NeInfo, paramName string) (map[string]any, error) {
// 网元参数配置信息
neUrl := fmt.Sprintf("http://%s:%d/api/rest/systemManagement/v1/elementType/%s/objectType/config/%s", neInfo.IPAddr, neInfo.Port, strings.ToLower(neInfo.NeType), paramName)
resBytes, err := fetch.Get(neUrl, nil, 30_000)
if err != nil {
logger.Warnf("NeConfigInfo Get \"%s\"", neUrl)
logger.Errorf("NeConfigInfo %s", err.Error())
return nil, fmt.Errorf("NeService Config Info API Error")
}
// 序列化结果
var resData map[string]any
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("NeConfigInfo Unmarshal %s", err.Error())
return nil, err
}
// 网元参数配置信息为空时是{}，需要补充data属性
if _, ok := resData["data"]; !ok {
resData["data"] = []map[string]any{}
}
return resData, nil
}
// NeConfigUpdate 网元配置更新
func NeConfigUpdate(neInfo model.NeInfo, paramName, loc string, data map[string]any) (map[string]any, error) {
// array需要层级
if loc != "" {
loc = fmt.Sprintf("?loc=%v", loc)
}
// 网元参数配置新增（array）
neUrl := fmt.Sprintf("http://%s:%d/api/rest/systemManagement/v1/elementType/%s/objectType/config/%s%s", neInfo.IPAddr, neInfo.Port, strings.ToLower(neInfo.NeType), paramName, loc)
resBytes, err := fetch.PutJSON(neUrl, data, nil)
var resData map[string]any
if err != nil {
errStr := err.Error()
logger.Warnf("NeConfigUpdate Put \"%s\"", neUrl)
if strings.HasPrefix(errStr, "201") || strings.HasPrefix(errStr, "204") {
return resData, nil
}
logger.Errorf("NeConfigUpdate %s", errStr)
return nil, fmt.Errorf("NeService Config Update API Error")
}
// 200 成功无数据时
if len(resBytes) == 0 {
return resData, nil
}
// 序列化结果
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("NeConfigUpdate Unmarshal %s", err.Error())
return nil, err
}
return resData, nil
}
// NeConfigAdd 网元配置新增 array
func NeConfigAdd(neInfo model.NeInfo, paramName, loc string, data map[string]any) (map[string]any, error) {
// 网元参数配置新增（array）
neUrl := fmt.Sprintf("http://%s:%d/api/rest/systemManagement/v1/elementType/%s/objectType/config/%s?loc=%v", neInfo.IPAddr, neInfo.Port, strings.ToLower(neInfo.NeType), paramName, loc)
resBytes, err := fetch.PostJSON(neUrl, data, nil)
var resData map[string]any
if err != nil {
errStr := err.Error()
logger.Warnf("NeConfigAdd Post \"%s\"", neUrl)
if strings.HasPrefix(errStr, "201") || strings.HasPrefix(errStr, "204") {
return resData, nil
}
logger.Errorf("NeConfigAdd %s", errStr)
return nil, fmt.Errorf("NeService Config Add API Error")
}
// 200 成功无数据时
if len(resBytes) == 0 {
return resData, nil
}
// 序列化结果
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("NeConfigAdd Unmarshal %s", err.Error())
return nil, err
}
return resData, nil
}
// NeConfigDelete 网元配置删除 array
func NeConfigDelete(neInfo model.NeInfo, paramName, loc string) (map[string]any, error) {
// 网元参数配置删除（array）
neUrl := fmt.Sprintf("http://%s:%d/api/rest/systemManagement/v1/elementType/%s/objectType/config/%s?loc=%v", neInfo.IPAddr, neInfo.Port, strings.ToLower(neInfo.NeType), paramName, loc)
resBytes, err := fetch.Delete(neUrl, nil)
var resData map[string]any
if err != nil {
errStr := err.Error()
logger.Warnf("NeConfigDelete Delete \"%s\"", neUrl)
if strings.HasPrefix(errStr, "201") || strings.HasPrefix(errStr, "204") {
return resData, nil
}
logger.Errorf("NeConfigDelete %s", errStr)
return nil, fmt.Errorf("NeService Config Update API Error")
}
// 200 成功无数据时
if len(resBytes) == 0 {
return resData, nil
}
// 序列化结果
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("NeConfigInfoDel Unmarshal %s", err.Error())
return nil, err
}
return resData, nil
}

60
src/modules/network_element/fetch_link/ne_state.go
View File

@@ -1,60 +0,0 @@
package fetchlink
import (
"encoding/json"
"fmt"
"strings"
"time"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/fetch"
"be.ems/src/modules/network_element/model"
)
// NeState 获取网元端服务状态
func NeState(neInfo model.NeInfo) (map[string]any, error) {
// 网元状态
neUrl := fmt.Sprintf("http://%s:%d/api/rest/systemManagement/v1/elementType/%s/objectType/systemState", neInfo.IPAddr, neInfo.Port, strings.ToLower(neInfo.NeType))
resBytes, err := fetch.Get(neUrl, nil, 1000)
if err != nil {
logger.Errorf("NeState %s", err.Error())
return nil, fmt.Errorf("NeService System State API Error")
}
// 序列化结果
var resData map[string]any
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("NeState Unmarshal %s", err.Error())
return nil, err
}
// 检查是否有许可时间
if v, ok := resData["expiryDate"]; ok && v != nil {
expiryDate := v.(string)
// UPF存在2000的许可时间，MME会有空字符
if strings.HasPrefix(expiryDate, "2000") || expiryDate == "" {
logger.Warnf("NeState %s License Expiration Aanomaly. Get \"%s\"", neInfo.NeType, neUrl)
return nil, fmt.Errorf("%s License Expiration Aanomaly", neInfo.NeType)
}
}
return map[string]any{
"coreUid": neInfo.CoreUID,
"neUid": neInfo.NeUID,
"neType": neInfo.NeType,
"neName": neInfo.NeName,
"neIP": neInfo.IPAddr,
"refreshTime": time.Now().UnixMilli(), // 获取时间
"standby": resData["standby"], // 是否备用服务
"version": resData["version"],
"capability": resData["capability"],
"sn": resData["serialNum"],
"expire": resData["expiryDate"],
"hostname": resData["hostName"],
"os": resData["osInfo"],
"cpu": resData["cpuUsage"],
"mem": resData["memUsage"],
"disk": resData["diskSpace"],
}, nil
}

69
src/modules/network_element/fetch_link/ne_trace.go
View File

@@ -1,69 +0,0 @@
package fetchlink
import (
"encoding/json"
"fmt"
"strings"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/fetch"
"be.ems/src/modules/network_element/model"
)
// NeTraceAdd 网元跟踪任务新增
func NeTraceAdd(neInfo model.NeInfo, data any) (map[string]any, error) {
// 跟踪任务创建
neUrl := fmt.Sprintf("http://%s:%d/api/rest/traceManagement/v2/%s/subscriptions", neInfo.IPAddr, neInfo.Port, neInfo.NeType)
resBytes, err := fetch.PostJSON(neUrl, data, nil)
var resData map[string]any
if err != nil {
errStr := err.Error()
if !(strings.HasPrefix(errStr, "201") || strings.HasPrefix(errStr, "400")) {
logger.Warnf("NeTraceAdd POST \"%s\"", neUrl)
logger.Errorf("NeTraceAdd %s", errStr)
return nil, fmt.Errorf("NeService Trace Add API Error")
}
}
// 200 成功无数据时
if len(resBytes) == 0 {
return resData, nil
}
// 序列化结果
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("NeTraceAdd Unmarshal %s", err.Error())
return nil, err
}
return resData, nil
}
// NeTraceDelete 网元跟踪任务删除
func NeTraceDelete(neInfo model.NeInfo, traceId string) (map[string]any, error) {
neUrl := fmt.Sprintf("http://%s:%d/api/rest/traceManagement/v2/%s/subscriptions?id=%s", neInfo.IPAddr, neInfo.Port, neInfo.NeType, traceId)
resBytes, err := fetch.Delete(neUrl, nil)
var resData map[string]any
if err != nil {
errStr := err.Error()
if strings.HasPrefix(errStr, "201") || strings.HasPrefix(errStr, "204") {
return resData, nil
}
logger.Warnf("NeTraceDelete Delete \"%s\"", neUrl)
logger.Errorf("NeTraceDelete %s", errStr)
return nil, fmt.Errorf("NeService Trace Delete API Error")
}
// 200 成功无数据时
if len(resBytes) == 0 {
return resData, nil
}
// 序列化结果
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("NeTraceDelete Unmarshal %s", err.Error())
return nil, err
}
return resData, nil
}

280
src/modules/network_element/fetch_link/pcf.go
View File

@@ -1,280 +0,0 @@
package fetchlink
import (
"encoding/json"
"fmt"
"strings"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/fetch"
"be.ems/src/modules/network_element/model"
)
// PCFRuleInfo PCF策略配置查询信息
func PCFRuleInfo(neInfo model.NeInfo, data map[string]string) ([]map[string]any, error) {
neUrl := fmt.Sprintf("http://%s:%d/api/rest/ueManagement/v1/elementType/pcf/objectType/ueInfo", neInfo.IPAddr, neInfo.Port)
// 查询参数拼接
query := []string{}
if v, ok := data["imsi"]; ok && v != "" {
query = append(query, fmt.Sprintf("imsi=%s", v))
}
if v, ok := data["msisdn"]; ok && v != "" {
query = append(query, fmt.Sprintf("msisdn=%s", v))
}
if len(query) > 0 {
neUrl = fmt.Sprintf("%s?%s", neUrl, strings.Join(query, "&"))
}
var resData map[string]any
resBytes, err := fetch.Get(neUrl, nil, 60_000)
if err != nil {
errStr := err.Error()
logger.Warnf("PCFRuleInfo Get \"%s\"", neUrl)
logger.Errorf("PCFRuleInfo %s", errStr)
return nil, fmt.Errorf("NeService PCF API Error")
}
// 序列化结果
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("PCFRuleInfo Unmarshal %s", err.Error())
return nil, err
}
// 固定返回字段，方便前端解析
if v, ok := resData["data"]; ok && v != nil {
if arr := v.([]any); len(arr) > 0 {
result := make([]map[string]any, len(arr))
for i, item := range arr {
result[i] = item.(map[string]any)
}
return result, nil
}
}
return []map[string]any{}, nil
}
// PCFRuleAdd PCF策略配置添加
func PCFRuleAdd(neInfo model.NeInfo, data any) error {
neUrl := fmt.Sprintf("http://%s:%d/api/rest/ueManagement/v1/elementType/pcf/objectType/ueInfo", neInfo.IPAddr, neInfo.Port)
resBytes, err := fetch.PostJSON(neUrl, data, nil)
if err != nil {
errStr := err.Error()
// 正常
if strings.HasPrefix(errStr, "201") {
return nil
}
// 错误结果
if strings.HasPrefix(errStr, "400") {
// 序列化结果
var resData map[string]any
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("PCFRuleAdd Unmarshal %s", err.Error())
return err
}
return fmt.Errorf("%s", resData["cause"])
}
logger.Warnf("PCFRuleAdd Put \"%s\"", neUrl)
logger.Errorf("PCFRuleAdd %s", errStr)
return fmt.Errorf("NeService PCF API Error")
}
return nil
}
// PCFRuleAddBatch PCF策略配置批量添加
func PCFRuleAddBatch(neInfo model.NeInfo, data map[string]any, num int64) error {
neUrl := fmt.Sprintf("http://%s:%d/api/rest/ueManagement/v1/elementType/pcf/objectType/ueInfo/batch/%d", neInfo.IPAddr, neInfo.Port, num)
resBytes, err := fetch.PostJSON(neUrl, data, nil)
if err != nil {
errStr := err.Error()
// 正常
if strings.HasPrefix(errStr, "201") {
return nil
}
// 错误结果
if strings.HasPrefix(errStr, "400") {
// 序列化结果
var resData map[string]any
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("PCFRuleAddBatch Unmarshal %s", err.Error())
return err
}
return fmt.Errorf("%s", resData["cause"])
}
logger.Warnf("PCFRuleAddBatch Put \"%s\"", neUrl)
logger.Errorf("PCFRuleAddBatch %s", errStr)
return fmt.Errorf("NeService PCF API Error")
}
return nil
}
// PCFRuleUpdate PCF策略配置修改
func PCFRuleUpdate(neInfo model.NeInfo, data map[string]any) error {
neUrl := fmt.Sprintf("http://%s:%d/api/rest/ueManagement/v1/elementType/pcf/objectType/ueInfo", neInfo.IPAddr, neInfo.Port)
resBytes, err := fetch.PutJSON(neUrl, data, nil)
if err != nil {
errStr := err.Error()
// 错误结果
if strings.HasPrefix(errStr, "400") {
// 序列化结果
var resData map[string]any
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("PCFRuleUpdate Unmarshal %s", err.Error())
return err
}
return fmt.Errorf("%s", resData["cause"])
}
logger.Warnf("PCFRuleUpdate Put \"%s\"", neUrl)
logger.Errorf("PCFRuleUpdate %s", errStr)
return fmt.Errorf("NeService PCF API Error")
}
return nil
}
// PCFRuleUpdateBatch PCF策略配置批量修改
func PCFRuleUpdateBatch(neInfo model.NeInfo, data map[string]any, num int64) error {
neUrl := fmt.Sprintf("http://%s:%d/api/rest/ueManagement/v1/elementType/pcf/objectType/ueInfo/batch/%d", neInfo.IPAddr, neInfo.Port, num)
resBytes, err := fetch.PutJSON(neUrl, data, nil)
if err != nil {
errStr := err.Error()
// 错误结果
if strings.HasPrefix(errStr, "400") {
// 序列化结果
var resData map[string]any
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("PCFRuleUpdateBatch Unmarshal %s", err.Error())
return err
}
return fmt.Errorf("%s", resData["cause"])
}
logger.Warnf("PCFRuleUpdateBatch Put \"%s\"", neUrl)
logger.Errorf("PCFRuleUpdateBatch %s", errStr)
return fmt.Errorf("NeService PCF API Error")
}
return nil
}
// PCFRuleDelete PCF策略配置删除
func PCFRuleDelete(neInfo model.NeInfo, imsi string) error {
neUrl := fmt.Sprintf("http://%s:%d/api/rest/ueManagement/v1/elementType/pcf/objectType/ueInfo?imsi=%s", neInfo.IPAddr, neInfo.Port, imsi)
resBytes, err := fetch.Delete(neUrl, nil)
if err != nil {
errStr := err.Error()
// 正常
if strings.HasPrefix(errStr, "204") {
return nil
}
// 错误结果
if strings.HasPrefix(errStr, "400") {
// 序列化结果
var resData map[string]any
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("PCFRuleDelete Unmarshal %s", err.Error())
return err
}
return fmt.Errorf("%s", resData["cause"])
}
logger.Warnf("PCFRuleDelete Delete \"%s\"", neUrl)
logger.Errorf("PCFRuleDelete %s", errStr)
return fmt.Errorf("NeService PCF API Error")
}
return nil
}
// PCFRuleDeleteBatch PCF策略配置批量删除
func PCFRuleDeleteBatch(neInfo model.NeInfo, imsi string, num int64) error {
neUrl := fmt.Sprintf("http://%s:%d/api/rest/ueManagement/v1/elementType/pcf/objectType/ueInfo/batch/%d?imsi=%s", neInfo.IPAddr, neInfo.Port, num, imsi)
resBytes, err := fetch.Delete(neUrl, nil)
if err != nil {
errStr := err.Error()
// 正常
if strings.HasPrefix(errStr, "204") {
return nil
}
// 错误结果
if strings.HasPrefix(errStr, "400") {
// 序列化结果
var resData map[string]any
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("PCFRuleDeleteBatch Unmarshal %s", err.Error())
return err
}
return fmt.Errorf("%s", resData["cause"])
}
logger.Warnf("PCFRuleDeleteBatch Delete \"%s\"", neUrl)
logger.Errorf("PCFRuleDeleteBatch %s", errStr)
return fmt.Errorf("NeService PCF API Error")
}
return nil
}
// PCFRuleExport PCF策略配置导出
func PCFRuleExport(neInfo model.NeInfo, data map[string]string) ([]byte, error) {
neUrl := fmt.Sprintf("http://%s:%d/api/rest/ueManagement/v1/elementType/pcf/objectType/ueInfo/file/export", neInfo.IPAddr, neInfo.Port)
// 查询参数拼接
query := []string{}
if v, ok := data["fileType"]; ok && v != "" {
query = append(query, fmt.Sprintf("fileType=%s", v))
}
if len(query) > 0 {
neUrl = fmt.Sprintf("%s?%s", neUrl, strings.Join(query, "&"))
}
resBytes, err := fetch.Get(neUrl, nil, 30_000)
if err != nil {
logger.Warnf("PCFRuleExport Get \"%s\"", neUrl)
logger.Errorf("PCFRuleExport %s", err.Error())
return nil, fmt.Errorf("NeService PCF API Error")
}
return resBytes, nil
}
// PCFRuleImport PCF策略配置导入
func PCFRuleImport(neInfo model.NeInfo, data map[string]any) (string, error) {
neUrl := fmt.Sprintf("http://%s:%d/api/rest/ueManagement/v1/elementType/pcf/objectType/ueInfo/file/import", neInfo.IPAddr, neInfo.Port)
resBytes, err := fetch.PutJSON(neUrl, data, nil)
var resData map[string]any
if err != nil {
errStr := err.Error()
// 错误结果
if strings.HasPrefix(errStr, "400") {
// 序列化结果
var resData map[string]any
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("PCFRuleDeleteBatch Unmarshal %s", err.Error())
return "", err
}
return "", fmt.Errorf("%s", resData["cause"])
}
logger.Warnf("PCFRuleImport Put \"%s\"", neUrl)
logger.Errorf("PCFRuleImport %s", errStr)
return "", fmt.Errorf("NeService PCF API Error")
}
// 200 成功无数据时
if len(resBytes) == 0 {
return "", nil
}
// 序列化结果
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("PCFRuleImport Unmarshal %s", err.Error())
return "", err
}
return fmt.Sprint(resData["data"]), nil
}

98
src/modules/network_element/fetch_link/smf.go
View File

@@ -1,98 +0,0 @@
package fetchlink
import (
"encoding/json"
"fmt"
"strings"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/fetch"
"be.ems/src/framework/utils/parse"
"be.ems/src/modules/network_element/model"
)
// SMFSubNum SMF在线订阅用户数量 只含5G用户数据
//
// 返回结果 0
func SMFSubNum(neInfo model.NeInfo) (int64, error) {
neUrl := fmt.Sprintf("http://%s:%d/api/rest/ueManagement/v1/elementType/smf/objectType/ueNum", neInfo.IPAddr, neInfo.Port)
resBytes, err := fetch.Get(neUrl, nil, 60_000)
if err != nil {
errStr := err.Error()
logger.Warnf("SMFSubNum Get \"%s\"", neUrl)
logger.Errorf("SMFSubNum %s", errStr)
return 0, fmt.Errorf("NeService SMF API Error")
}
// 序列化结果 {"data":{"ueNum":0}}
var resData map[string]any
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("IMSUeSession Unmarshal %s", err.Error())
return 0, err
}
// 固定返回字段，方便前端解析
var ueNum int64 = 0
if v, ok := resData["data"]; ok && v != nil {
if num := v.(map[string]any)["ueNum"]; num != nil {
ueNum = parse.Number(num)
}
}
return ueNum, nil
}
// SMFSubInfoList SMF在线订阅用户列表信息
//
// 查询参数 {"imsi":"360000100000130","msisdn":"8612300000130","upstate":"Inactive","pageNum":"1"}
//
// 返回结果 {"rows":[],"total":0}
func SMFSubInfoList(neInfo model.NeInfo, data map[string]string) (map[string]any, error) {
neUrl := fmt.Sprintf("http://%s:%d/api/rest/ueManagement/v1/elementType/smf/objectType/ueInfo", neInfo.IPAddr, neInfo.Port)
// 查询参数拼接
query := []string{}
if v, ok := data["imsi"]; ok && v != "" {
query = append(query, fmt.Sprintf("imsi=%s", v))
}
if v, ok := data["msisdn"]; ok && v != "" {
query = append(query, fmt.Sprintf("msisdn=%s", v))
}
if v, ok := data["upstate"]; ok && v != "" {
query = append(query, fmt.Sprintf("upstate=%s", v))
}
// 固定页数量50条
if v, ok := data["pageNum"]; ok && v != "" {
pageNum := parse.Number(v)
query = append(query, fmt.Sprintf("pageNum=%d", pageNum))
}
if len(query) > 0 {
neUrl = fmt.Sprintf("%s?%s", neUrl, strings.Join(query, "&"))
}
resBytes, err := fetch.Get(neUrl, nil, 60_000)
if err != nil {
logger.Warnf("SMFSubInfo Get \"%s\"", neUrl)
logger.Errorf("SMFSubInfo %s", err.Error())
return nil, fmt.Errorf("NeService SMF API Error")
}
// 序列化结果 {"data":[],"total":0}
var resData map[string]any
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("SMFSubInfo Unmarshal %s", err.Error())
return nil, err
}
// 固定返回字段，方便前端解析
if v, ok := resData["data"]; ok && v != nil {
resData["rows"] = v.([]any)
delete(resData, "data")
} else {
resData["rows"] = []any{}
}
if v, ok := resData["total"]; !ok || v == nil {
resData["total"] = 0
}
return resData, nil
}

39
src/modules/network_element/fetch_link/udm.go
View File

@@ -1,39 +0,0 @@
// 网元UDM服务，可能是8080、33030端口服务
// 融合的UDM网元视情况调整。
package fetchlink
import (
"encoding/json"
"fmt"
"strings"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/fetch"
)
// UDMImportAuth UDM导入鉴权数据
//
// data参数 {path:"服务器文件路径", k4:"可选，k4为空时Ki不加密。"}
func UDMImportAuth(udmIP string, data map[string]any) (string, error) {
// 网元参数配置新增（array）
neUrl := fmt.Sprintf("http://%s:8080/ue-manage/v1/import-auth", udmIP)
resBytes, err := fetch.PostJSON(neUrl, data, nil)
var resData map[string]string
if err != nil {
errStr := err.Error()
logger.Warnf("UDMImportAuth Post \"%s\"", neUrl)
logger.Errorf("UDMImportAuth %s", errStr)
return "", fmt.Errorf("NeService UDM API Error")
}
// 序列化结果
if err = json.Unmarshal(resBytes, &resData); err != nil {
logger.Errorf("UDMImportAuth Unmarshal %s", err.Error())
return "", err
}
if v, ok := resData["code"]; ok && v == "00000" {
return strings.TrimSpace(strings.ToLower(resData["message"])), nil
}
return "", fmt.Errorf("%s", resData["message"])
}

20
src/modules/network_element/model/core_info.go
View File

@@ -1,20 +0,0 @@
package model
// CoreInfo 核心网_基础信息 core_info
type CoreInfo struct {
ID int64 `json:"id" gorm:"column:id;primaryKey;autoIncrement"` // 核心网ID
CoreUID string `json:"coreUid" gorm:"column:core_uid"` // 核心网唯一标识
CoreName string `json:"coreName" gorm:"column:core_name"` // 核心网名称
CoreSN string `json:"coreSN" gorm:"column:core_sn"` // 核心网序列号
OmcId string `json:"omcId" gorm:"column:omc_id"` // OMC安装生成的唯一编码
Remark string `json:"remark" gorm:"column:remark"` // 备注
CreateBy string `json:"createBy" gorm:"column:create_by"` // 创建者
CreateTime int64 `json:"createTime" gorm:"column:create_time"` // 创建时间
UpdateBy string `json:"updateBy" gorm:"column:update_by"` // 更新者
UpdateTime int64 `json:"updateTime" gorm:"column:update_time"` // 更新时间
}
// TableName 表名称
func (*CoreInfo) TableName() string {
return "core_info"
}

2
src/modules/network_element/model/ne_info.go
View File

@@ -4,7 +4,7 @@ package model
type NeInfo struct {
ID int64 `json:"id" gorm:"column:id;primaryKey;autoIncrement"` // 网元ID
CoreUID string `json:"coreUid" gorm:"column:core_uid" binding:"required"` // 核心网唯一标识
NeUID string `json:"neUid" gorm:"column:ne_uid" binding:"required"` // 网元唯一标识
NeUID string `json:"neUid" gorm:"column:ne_uid"` // 网元唯一标识
NeType string `json:"neType" gorm:"column:ne_type" binding:"required"` // 网元类型
NeName string `json:"neName" gorm:"column:ne_name"` // 网元名称
IPAddr string `json:"ipAddr" gorm:"column:ip_addr" binding:"required"` // 网元服务IP

22
src/modules/network_element/repository/ne_info.go
View File

@@ -202,28 +202,6 @@ func (r NeInfo) SelectNeInfoByCoreUidAndNeUid(coreUid, neUid string) model.NeInf
return row
}
// CheckUniqueCoreIdAndNeType 校验同类型下标识是否唯一
func (r NeInfo) CheckUniqueCoreIdAndNeType(neInfo model.NeInfo) int64 {
tx := db.DB("").Model(&model.NeInfo{})
// 查询条件拼接
if neInfo.NeType != "" {
tx = tx.Where("ne_type = ?", neInfo.NeType)
}
if neInfo.CoreUID != "" {
tx = tx.Where("core_uid = ?", neInfo.CoreUID)
}
if neInfo.NeUID != "" {
tx = tx.Where("ne_uid = ?", neInfo.NeUID)
}
// 查询数据
var id int64 = 0
if err := tx.Limit(1).Select("id").Find(&id).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return id
}
return id
}
// UpdateState 修改状态
func (r NeInfo) UpdateState(id int64, status int64) int64 {
if id <= 0 {

127
src/modules/network_element/service/ne_info.go
View File

@@ -16,9 +16,9 @@ import (
"be.ems/src/framework/telnet"
"be.ems/src/framework/utils/generate"
"be.ems/src/framework/utils/parse"
neFetchlink "be.ems/src/modules/network_element/fetch_link"
"be.ems/src/modules/network_element/model"
"be.ems/src/modules/network_element/repository"
neFetchlink "be.ems/src/modules/network_link/fetch_link"
)
// 实例化服务层 NeInfo 结构体
@@ -240,6 +240,27 @@ func (r NeInfo) FindById(id int64, bandHost bool) model.NeInfo {
// Insert 新增信息
func (r NeInfo) Insert(neInfo model.NeInfo) int64 {
if neInfo.CoreUID == "" {
return 0
}
neInfo.NeUID = strings.ToUpper(generate.Code(8))
// 获取网元状态是否正常
serverState, err := neFetchlink.NeState(neInfo)
if err != nil {
neInfo.Status = 0
} else {
// 网元状态设置为在线
neInfo.Status = 1
if parse.Boolean(serverState["standby"]) {
neInfo.Status = 3
}
// 下发网管配置信息给网元
if _, err = neFetchlink.NeConfigOMC(neInfo); err != nil {
neInfo.Status = 2
}
}
// 主机信息新增
if neInfo.Hosts != nil {
uuid := generate.Code(4)
@@ -258,6 +279,39 @@ func (r NeInfo) Insert(neInfo model.NeInfo) int64 {
insertId := r.neInfoRepository.Insert(neInfo)
if insertId > 0 {
// 新增Version信息
neVersion := model.NeVersion{
CoreUID: neInfo.CoreUID,
NeUID: neInfo.NeUID,
NeType: neInfo.NeType,
CreateBy: neInfo.CreateBy,
}
if v, ok := serverState["version"]; ok && v != nil {
neVersion.Name = "-"
neVersion.Path = "-"
neVersion.Version = fmt.Sprint(v)
}
NewNeVersion.Insert(neVersion)
// 新增License信息
neLicense := model.NeLicense{
CoreUID: neInfo.CoreUID,
NeUID: neInfo.NeUID,
NeType: neInfo.NeType,
CreateBy: neInfo.CreateBy,
}
if v, ok := serverState["capability"]; ok && v != nil {
neLicense.Capability = parse.Number(v)
}
if v, ok := serverState["sn"]; ok && v != nil {
neLicense.SerialNum = fmt.Sprint(v)
}
if v, ok := serverState["expire"]; ok && v != nil {
neLicense.ExpiryDate = fmt.Sprint(v)
neLicense.Status = "1"
}
NewNeLicense.Insert(neLicense)
r.RefreshByCoreUidAndNeUid(neInfo.CoreUID, neInfo.NeUID) // 刷新缓存
}
return insertId
@@ -265,12 +319,32 @@ func (r NeInfo) Insert(neInfo model.NeInfo) int64 {
// Update 修改信息
func (r NeInfo) Update(neInfo model.NeInfo) int64 {
// 获取网元状态是否正常
serverState, err := neFetchlink.NeState(neInfo)
if err != nil {
neInfo.Status = 0
} else {
// 网元状态设置为在线
neInfo.Status = 1
if parse.Boolean(serverState["standby"]) {
neInfo.Status = 3
}
// 下发网管配置信息给网元
if _, err = neFetchlink.NeConfigOMC(neInfo); err != nil {
neInfo.Status = 2
}
}
// 主机信息更新
if neInfo.Hosts != nil {
if neInfo.HostIDs != "" && len(neInfo.Hosts) > 0 {
hostIDs := strings.Split(neInfo.HostIDs, ",")
for index, id := range hostIDs {
neInfo.Hosts[index].ID = parse.Number(id)
}
uuid := generate.Code(4)
for _, host := range neInfo.Hosts {
if host.ID != 0 {
host.Title = fmt.Sprintf("%s_%d_%s", neInfo.NeName, host.Port, uuid)
host.Title = fmt.Sprintf("%s_%d_%s", neInfo.NeType, host.Port, uuid)
host.GroupID = "1"
host.UpdateBy = neInfo.UpdateBy
r.neHostService.Update(host)
@@ -280,6 +354,41 @@ func (r NeInfo) Update(neInfo model.NeInfo) int64 {
num := r.neInfoRepository.Update(neInfo)
if num > 0 {
// 版本信息更新
neVersion := NewNeVersion.FindByCoreUidAndNeUid(neInfo.CoreUID, neInfo.NeUID)
if neVersion.ID != 0 {
if neVersion.NeType != neInfo.NeType {
neVersion.NeType = neInfo.NeType
}
if v, ok := serverState["version"]; ok && v != neVersion.Version {
neVersion.Name = "-"
neVersion.Path = "-"
neVersion.Version = fmt.Sprint(v)
}
neVersion.UpdateBy = neInfo.UpdateBy
NewNeVersion.Update(neVersion)
}
// License信息更新
neLicense := NewNeLicense.FindByCoreUidAndNeUid(neInfo.CoreUID, neInfo.NeUID)
if neLicense.ID != 0 {
if neLicense.NeType != neInfo.NeType {
neLicense.NeType = neInfo.NeType
}
if v, ok := serverState["capability"]; ok && v != nil {
neLicense.Capability = parse.Number(v)
}
if v, ok := serverState["sn"]; ok && v != nil {
neLicense.SerialNum = fmt.Sprint(v)
}
if v, ok := serverState["expire"]; ok && v != nil {
neLicense.ExpiryDate = fmt.Sprint(v)
neLicense.Status = "1"
}
neLicense.UpdateBy = neInfo.UpdateBy
NewNeLicense.Update(neLicense)
}
r.RefreshByCoreUidAndNeUid(neInfo.CoreUID, neInfo.NeUID) // 刷新缓存
}
return num
@@ -324,18 +433,6 @@ func (r NeInfo) DeleteByIds(ids []int64) (int64, error) {
return 0, fmt.Errorf("delete fail")
}
// CheckUniqueCoreUidAndNeUid 校验同类型下标识是否唯一
func (r NeInfo) CheckUniqueCoreIdAndNeType(coreUid, neUid string, id int64) bool {
uniqueId := r.neInfoRepository.CheckUniqueCoreIdAndNeType(model.NeInfo{
CoreUID: coreUid,
NeUID: neUid,
})
if uniqueId == id {
return true
}
return uniqueId == 0
}
// NeRunSSHClient 网元主机的SSH客户端-为创建相关连接，注意结束后 Close()
func (r NeInfo) NeRunSSHClient(coreUid, neUid string) (*ssh.ConnSSH, error) {
neInfo := r.FindByCoreUidAndNeUid(coreUid, neUid)

2
src/modules/network_element/service/ne_version.go
View File

@@ -9,9 +9,9 @@ import (
"be.ems/src/framework/ssh"
"be.ems/src/framework/utils/file"
neFetchlink "be.ems/src/modules/network_element/fetch_link"
"be.ems/src/modules/network_element/model"
"be.ems/src/modules/network_element/repository"
neFetchlink "be.ems/src/modules/network_link/fetch_link"
)
// 实例化服务层 NeVersion 结构体