268 lines
7.6 KiB
Go
268 lines
7.6 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/xml"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"os"
|
|
"regexp"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
pmschema "ems.agt/crontask/pm/schema"
|
|
"ems.agt/lib/global"
|
|
"ems.agt/lib/log"
|
|
|
|
"gopkg.in/yaml.v3"
|
|
)
|
|
|
|
var (
|
|
neTypes = []string{"AMF", "SMF", "UDM", "UPF", "AUSF"}
|
|
)
|
|
|
|
func (t *TaskFunc) GenPmXmlFile(uri, params, body string) {
|
|
for _, neType := range neTypes {
|
|
log.Debugf("GenPmXmlFile process %s xml file", neType)
|
|
t.GenNFPMXmlFile(neType)
|
|
}
|
|
}
|
|
|
|
func (t *TaskFunc) ReadPmYaml(cmfile string) (map[string]interface{}, error) {
|
|
log.Debug("cmfile:", cmfile)
|
|
file, err := ioutil.ReadFile(cmfile)
|
|
if err != nil {
|
|
log.Error(err)
|
|
return nil, err
|
|
}
|
|
log.Debug("file:", file)
|
|
resultMap := make(map[string]interface{})
|
|
err = yaml.Unmarshal(file, resultMap)
|
|
if err != nil {
|
|
log.Error(err)
|
|
return nil, err
|
|
}
|
|
|
|
log.Debug("resultMap:", resultMap)
|
|
return resultMap, nil
|
|
}
|
|
|
|
func (t *TaskFunc) IsPseudoSubPmName(pmName string) bool {
|
|
return strings.Contains(pmName, "._")
|
|
}
|
|
|
|
func (t *TaskFunc) GenNFPMXmlFile(neType string) error {
|
|
var nes []NeInfo
|
|
_, err := XormGetNeInfoByType(neType, &nes)
|
|
if err != nil {
|
|
log.Error("Failed to get all ne info:", err)
|
|
return err
|
|
}
|
|
|
|
// cfile := fmt.Sprintf("%s/pm-%s.yaml", yamlConfig.NBI.PM.CfgFileDir, strings.ToLower(neType))
|
|
|
|
// resultMap, _ := t.ReadPmYaml(cfile)
|
|
|
|
ti := time.Now()
|
|
var startTime string
|
|
timestamp := ti.Format("2006-01-02 15:04:05")
|
|
|
|
index := global.GetCurrentTimeSliceIndexByPeriod(ti, 15)
|
|
date := time.Now().Format("2006-01-02")
|
|
log.Debugf("date: %s index:%d", date, index)
|
|
|
|
_, offset := ti.Zone()
|
|
var tzOffset string
|
|
if offset >= 0 {
|
|
tzOffset = "UTC+" + strconv.Itoa(offset/3600)
|
|
} else {
|
|
tzOffset = "UTC" + strconv.Itoa(offset/3600)
|
|
}
|
|
|
|
pmFile := new(pmschema.PmFile)
|
|
|
|
var pms []NorthboundPm
|
|
_, err = XormGetNorthboundPm(date, index, neType, &pms)
|
|
if err != nil {
|
|
log.Error("Failed to get northbound_pm:", err)
|
|
return err
|
|
}
|
|
|
|
if len(pms) == 0 {
|
|
log.Errorf("%s:%v", neType, global.ErrPMNotFoundData)
|
|
return global.ErrPMNotFoundData
|
|
}
|
|
|
|
pmFile.XsAttr = "http://www.w3.org/2001/XMLSchema"
|
|
pmFile.XsiAttr = "http://www.w3.org/2001/XMLSchema-instance"
|
|
/*
|
|
objectTypes := make([]string, 0)
|
|
sortValues := make(map[string]interface{})
|
|
keys := make([]string, 0)
|
|
if len(pms) > 0 {
|
|
for _, data := range pms[0].Datas {
|
|
for _, pmData := range data.PmDatas {
|
|
sortValues[pmData.PmName] = pmData.SubDatas
|
|
keys = append(keys, pmData.PmName)
|
|
}
|
|
objectTypes = append(objectTypes, data.ObjectType)
|
|
}
|
|
sort.Strings(keys)
|
|
sort.Strings(objectTypes)
|
|
}
|
|
log.Debug("objectTypes:", objectTypes)
|
|
log.Debug("keys:", keys)
|
|
*/
|
|
var measurement pmschema.Measurements
|
|
for _, pm := range pms {
|
|
for _, pdata := range pm.Datas {
|
|
measurement = pmschema.Measurements{ObjectType: pdata.ObjectType}
|
|
measurement.PmData.Object.RmUIDAttr = pm.RmUID
|
|
measurement.PmData.Object.DnAttr = pm.Dn
|
|
measurement.PmData.Object.UserLabelAttr = pm.NeName
|
|
startTime = pm.StartTime
|
|
|
|
i := 1
|
|
for _, pmData := range pdata.KPIs {
|
|
measurement.PmName.N = append(measurement.PmName.N, pmschema.N{IAttr: i, Value: pmData.KPIID})
|
|
cv := pmschema.CV{IAttr: i}
|
|
isPseudo := true
|
|
value := "0"
|
|
reg := regexp.MustCompile(`_\w+`)
|
|
//sns := strings.Split(pmData.KPIID, "_")
|
|
for _, v := range pmData.KPIValues {
|
|
if fmt.Sprintf("%v", v.Name) == "Total" {
|
|
isPseudo = false
|
|
value = fmt.Sprintf("%v", v.Value)
|
|
break
|
|
} else {
|
|
isPseudo = true
|
|
//if len(sns) > 1 {
|
|
// sns := strings.Split(sns[1], ".")
|
|
//}
|
|
sn := reg.ReplaceAllString(pmData.KPIID, v.Name)
|
|
//sn := sns[0] + v.Name
|
|
// cv.NV = append(cv.NV, pmschema.NV{SN: sn, SV: fmt.Sprintf("%v", v.Value)})
|
|
cv.SN = append(cv.SN, sn)
|
|
cv.SV = append(cv.SV, fmt.Sprintf("%v", v.Value))
|
|
}
|
|
}
|
|
if isPseudo == false {
|
|
measurement.PmData.Object.V = append(measurement.PmData.Object.V, pmschema.V{IAttr: i, Value: value})
|
|
} else {
|
|
measurement.PmData.Object.CV = append(measurement.PmData.Object.CV, cv)
|
|
}
|
|
|
|
i++
|
|
//measurement.PmData.Object.V = append(measurement.PmData.Object.V, pmschema.V{IAttr: i, Value: sortValues[pmName].Value})
|
|
//measurement.PmData.Object.CV = sortValues[pmName].Value
|
|
}
|
|
pmFile.Measurements = append(pmFile.Measurements, measurement)
|
|
|
|
}
|
|
}
|
|
|
|
pmFile.FileHeader = pmschema.FileHeader{
|
|
TimeStamp: timestamp,
|
|
TimeZone: tzOffset,
|
|
Period: 15,
|
|
VendorName: "Ruijie Network",
|
|
ElementType: neType,
|
|
PmVersion: global.Version,
|
|
StartTime: startTime,
|
|
}
|
|
/*
|
|
for _, obj := range objectTypes {
|
|
measurement := pmschema.Measurements{ObjectType: obj}
|
|
|
|
for _, pm := range pms {
|
|
measurement.PmData.Object.RmUIDAttr = pm.RmUID
|
|
measurement.PmData.Object.DnAttr = pm.Dn
|
|
measurement.PmData.Object.UserLabelAttr = pm.NeName
|
|
for _, pdata := range pm.Datas {
|
|
measurement := pmschema.Measurements{ObjectType: pdata.ObjectType}
|
|
if pdata.ObjectType == obj {
|
|
i := 1
|
|
for _, pmName := range keys {
|
|
measurement.PmName.N = append(measurement.PmName.N, pmschema.N{IAttr: i, Value: pmName})
|
|
measurement.PmData.Object.V = append(measurement.PmData.Object.V, pmschema.V{IAttr: i, Value: "1"})
|
|
i++
|
|
//measurement.PmData.Object.V = append(measurement.PmData.Object.V, pmschema.V{IAttr: i, Value: sortValues[pmName].Value})
|
|
//measurement.PmData.Object.CV = sortValues[pmName].Value
|
|
}
|
|
}
|
|
}
|
|
}
|
|
pmFile.Measurements = append(pmFile.Measurements, measurement)
|
|
}
|
|
*/
|
|
|
|
/*
|
|
for k, pm := range pms {
|
|
measurement := pmschema.Measurements{ObjectType: "gold_kpi"}
|
|
|
|
for s, ne := range nes {
|
|
rmUID := fmt.Sprintf("01000HX%sBJ0D0%d", neType, s+1)
|
|
vmId := fmt.Sprintf("kylin10.0-00%d-%s", s+1, neType)
|
|
measurement.PmName.
|
|
vnfInstanceID := fmt.Sprintf("2%xd55b4-%d018-41f4-af%d5-28b%d828788", s+10, s+6, s+4, s+3)
|
|
object := pmschema.Object{RmUIDAttr: rmUID,
|
|
DnAttr: "DC=www.ruijie.com.cn,SubNetwork=10001,SubNetwork=114214,ManagedElement=325",
|
|
UserLabelAttr: ne.NeName, PVFlagAttr: ne.PvFlag, VMIDAttr: vmId, VNFInstanceIDAttr: vnfInstanceID}
|
|
|
|
i := 1
|
|
for _, p := range keys {
|
|
if s == 0 {
|
|
objects.FieldName.N = append(objects.FieldName.N, pmschema.N{IAttr: i, Value: p})
|
|
}
|
|
var v string
|
|
switch p {
|
|
case "Id":
|
|
v = ne.NeId
|
|
case "UserLabel":
|
|
v = ne.NeName
|
|
case "VendorName":
|
|
v = "Ruijie Network"
|
|
case "SwVersion":
|
|
v = global.Version
|
|
case "PatchInfo":
|
|
v = "-"
|
|
case "AdministrativeState":
|
|
v = AdminStateUnlocked
|
|
case "OperationalState":
|
|
v = OperationStateEnabled
|
|
case "VnfInstanceId":
|
|
v = vnfInstanceID
|
|
default:
|
|
if sortResult[p] == "" {
|
|
v = "-"
|
|
} else {
|
|
v = fmt.Sprintf("%s", sortResult[p])
|
|
}
|
|
}
|
|
object.V = append(object.V, cmschema.V{IAttr: i, Value: v})
|
|
i++
|
|
}
|
|
objects.FieldValue.Object = append(objects.FieldValue.Object, object)
|
|
}
|
|
pmFile.Measurements = append(pmFile.Measurements, measurement)
|
|
}
|
|
*/
|
|
|
|
x, _ := xml.MarshalIndent(pmFile, "", " ")
|
|
x = append([]byte(xml.Header), x...)
|
|
|
|
folderName := global.GetFmtTimeString(global.DateTime, startTime, global.DateHour)
|
|
folderPath := global.CreateDir(folderName, yamlConfig.NBI.PM.XmlFileDir)
|
|
timefile := global.GetFmtTimeString(global.DateTime, startTime, global.DateData)
|
|
xmlfile := fmt.Sprintf("%s/PM-%s-%s-%s-15-001.xml", folderPath, neType, global.Version, timefile)
|
|
log.Debugf("folderPath:%s, xmlfile:%s", folderPath, xmlfile)
|
|
err = os.WriteFile(xmlfile, x, 0664)
|
|
if err != nil {
|
|
log.Error("Failed to write xml file:", err)
|
|
|
|
return err
|
|
}
|
|
return nil
|
|
}
|