ODU slice assurance usecase - Improvements

[nonrtric.git] / test / usecases / odusliceassurance / goversion / internal / structures / sliceassurance.go

diff --git a/test/usecases/odusliceassurance/goversion/internal/structures/sliceassurance.go b/test/usecases/odusliceassurance/goversion/internal/structures/sliceassurance.go
index b73deb2..c243d18 100644 (file)
--- a/test/usecases/odusliceassurance/goversion/internal/structures/sliceassurance.go
+++ b/test/usecases/odusliceassurance/goversion/internal/structures/sliceassurance.go
@@ -20,38 +20,116 @@
 
 package structures
 
+import (
+       "fmt"
+       "regexp"
+       "strconv"
+
+       "oransc.org/usecase/oduclosedloop/messages"
+)
+
+type MapKey struct {
+       Duid string
+       sd   int
+       sst  int
+}
+
 type SliceAssuranceMeas struct {
-       Metrics  []*SliceMetric
+       Metrics  map[MapKey]*SliceMetric
        Policies map[string]*PolicyRatio
 }
 
 func NewSliceAssuranceMeas() *SliceAssuranceMeas {
        s := SliceAssuranceMeas{}
-       s.Metrics = make([]*SliceMetric, 0)
+       s.Metrics = make(map[MapKey]*SliceMetric)
        s.Policies = make(map[string]*PolicyRatio)
        return &s
 }
 
-func (sa *SliceAssuranceMeas) AddNewPolicy(pr *PolicyRatio) {
-       sa.Policies[pr.PolicyRatioId] = pr
+func (sa *SliceAssuranceMeas) AddNewPolicy(duid string, rrmPolicyRatio messages.RRMPolicyRatio) {
+       for _, policyMember := range rrmPolicyRatio.RRMPolicyMembers {
+               metric := sa.GetSliceMetric(duid, policyMember.SliceDifferentiator, policyMember.SliceServiceType)
+               if metric != nil {
+                       pr := NewPolicyRatio(rrmPolicyRatio.Id, rrmPolicyRatio.RRMPolicyMaxRatio, rrmPolicyRatio.RRMPolicyMinRatio, rrmPolicyRatio.RRMPolicyDedicatedRatio)
+                       sa.Policies[pr.PolicyRatioId] = pr
+                       metric.RRMPolicyRatioId = rrmPolicyRatio.Id
+               }
+       }
 }
 
 func (sa *SliceAssuranceMeas) GetSliceMetric(duid string, sd int, sst int) *SliceMetric {
-       for _, metric := range sa.Metrics {
-               if metric.DUId == duid && metric.SliceDiff == sd && metric.SliceServiceType == sst {
-                       return metric
-               }
+       key := MapKey{duid, sd, sst}
+       value, check := sa.Metrics[key]
+
+       if check {
+               return value
        }
+
        return nil
 }
 
-func (sa *SliceAssuranceMeas) AddOrUpdateMetric(sm *SliceMetric) {
-       metric := sa.GetSliceMetric(sm.DUId, sm.SliceDiff, sm.SliceServiceType)
-       if metric != nil {
-               for key, value := range sm.PM {
-                       metric.PM[key] = value
+func (sa *SliceAssuranceMeas) AddOrUpdateMetric(meas messages.Measurement) (string, error) {
+
+       var duid string
+       var sd, sst int
+
+       regex := *regexp.MustCompile(`\/network-function\/distributed-unit-functions\[id=\'(.*)\'\]/cell\[id=\'(.*)\'\]/supported-measurements\/performance-measurement-type\[\.=\'(.*)\'\]\/supported-snssai-subcounter-instances\/slice-differentiator\[\.=(\d)\]\[slice-service-type=(\d+)\]`)
+       res := regex.FindAllStringSubmatch(meas.MeasurementTypeInstanceReference, -1)
+
+       if res != nil && len(res[0]) == 6 {
+               duid = res[0][1]
+               sd = toInt(res[0][4])
+               sst = toInt(res[0][5])
+
+               key := MapKey{duid, sd, sst}
+               value, check := sa.Metrics[key]
+
+               if check {
+                       sa.updateMetric(key, value, res[0][3], meas.Value)
+               } else {
+                       // Only add new one if value exceeds threshold
+                       sa.addMetric(res, meas.Value)
                }
        } else {
-               sa.Metrics = append(sa.Metrics, sm)
+               return duid, fmt.Errorf(" wrong format for MeasurementTypeInstanceReference")
+       }
+       return duid, nil
+}
+
+func (sa *SliceAssuranceMeas) addMetric(res [][]string, metricValue int) {
+       if metricValue > 700 {
+               metric := NewSliceMetric(res[0][1], res[0][2], toInt(res[0][4]), toInt(res[0][5]))
+               metric.PM[res[0][3]] = metricValue
+               key := MapKey{res[0][1], toInt(res[0][4]), toInt(res[0][5])}
+               sa.Metrics[key] = metric
+       }
+}
+
+func (sa *SliceAssuranceMeas) updateMetric(key MapKey, value *SliceMetric, metricName string, metricValue int) {
+       if metricValue < 700 {
+               delete(sa.Metrics, key)
+       } else {
+               value.PM[metricName] = metricValue
+       }
+}
+
+func toInt(num string) int {
+       res, err := strconv.Atoi(num)
+       if err != nil {
+               return -1
+       }
+       return res
+}
+
+func (sa *SliceAssuranceMeas) PrintStructures() {
+       fmt.Printf("SliceAssurance Metrics: \n")
+       for key, metric := range sa.Metrics {
+               fmt.Printf("Key: %+v\n", key)
+               fmt.Printf("Metric: %+v\n", metric)
+       }
+       fmt.Printf("SliceAssurance Policies: \n")
+       for key, metric := range sa.Policies {
+               fmt.Printf("Key: %+v\n", key)
+               fmt.Printf("Metric: %+v\n", metric)
        }
 }