pkg/rpe/rmr.go

   1 /*
   2 ==================================================================================
   3   Copyright (c) 2019 AT&T Intellectual Property.
   4   Copyright (c) 2019 Nokia
   5
   6    Licensed under the Apache License, Version 2.0 (the "License");
   7    you may not use this file except in compliance with the License.
   8    You may obtain a copy of the License at
   9
  10        http://www.apache.org/licenses/LICENSE-2.0
  11
  12    Unless required by applicable law or agreed to in writing, software
  13    distributed under the License is distributed on an "AS IS" BASIS,
  14    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15    See the License for the specific language governing permissions and
  16    limitations under the License.
  17
  18
  19    This source code is part of the near-RT RIC (RAN Intelligent Controller)
  20    platform project (RICP).
  21
  22 ==================================================================================
  23 */
  24 /*
  25   Mnemonic:     rmr.go
  26   Abstract:     RMR Route Policy implementation
  27                 Produces RMR (RIC Management Routing) formatted route messages
  28   Date:         16 March 2019
  29 */
  30
  31 package rpe
  32
  33 import (
  34         "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
  35         "routing-manager/pkg/models"
  36         "routing-manager/pkg/rtmgr"
  37         "strconv"
  38         "strings"
  39 )
  40
  41 type Rmr struct {
  42         Rpe
  43 }
  44
  45 type RmrPush struct {
  46         Rmr
  47 }
  48
  49 func NewRmrPush() *RmrPush {
  50         instance := new(RmrPush)
  51         return instance
  52 }
  53
  54 /*
  55 Produces the raw route message consumable by RMR
  56 */
  57 func (r *Rmr) generateRMRPolicies(eps rtmgr.Endpoints, rcs *rtmgr.RicComponents, key string) *[]string {
  58         rawrt := []string{key + "newrt|start\n"}
  59         rt := r.generateRouteTable(eps)
  60         for _, rte := range *rt {
  61                 rawrte := key + "mse|" + rte.MessageType
  62                 for _, tx := range rte.TxList {
  63                         rawrte += "," + tx.Ip + ":" + strconv.Itoa(int(tx.Port))
  64                 }
  65                 rawrte += "|" + strconv.Itoa(int(rte.SubID)) + "|"
  66                 group := ""
  67                 for _, rxg := range rte.RxGroups {
  68                         member := ""
  69                         for _, rx := range rxg {
  70                                 if member == "" {
  71                                         member += rx.Ip + ":" + strconv.Itoa(int(rx.Port))
  72                                 } else {
  73                                         member += "," + rx.Ip + ":" + strconv.Itoa(int(rx.Port))
  74                                 }
  75                         }
  76                         if group == "" {
  77                                 group += member
  78                         } else {
  79                                 group += ";" + member
  80                         }
  81                 }
  82                 rawrte += group
  83
  84                 if rte.RouteType == "%meid" {
  85                         rawrte += group + rte.RouteType
  86                 }
  87
  88                 rawrt = append(rawrt, rawrte+"\n")
  89         }
  90         for _, val := range rtmgr.DynamicRouteList {
  91                 rawrt = append(rawrt, val)
  92         }
  93
  94         rawrt = append(rawrt, key+"newrt|end\n")
  95         count := 0
  96
  97         rawrt = append(rawrt, key+"meid_map|start\n")
  98         keys := make(map[string]RouteIndex)
  99         for _, value := range rcs.MeidMap {
 100                 if _, v := keys[key+value+"\n"]; !v {
 101                         rawrt = append(rawrt, key+value+"\n")
 102                         appendedindex := uint16(len(rawrt) - 1)
 103                         keys[key+value+"\n"] = RouteIndex{true, appendedindex}
 104                         count++
 105                 }
 106                 if strings.Contains(value, "mme_ar") {
 107                         tmpstr := strings.Split(value, "|")
 108
 109                         //MEID entry for mme_ar must always contain 3 strings speartred by | i.e "mme_ar|<string1>|<string2>"
 110                         MEID := strings.TrimSuffix(tmpstr[2], "\n")
 111
 112                         mapindex := "mme_del|" + MEID + "\n"
 113                         i := keys[mapindex].index
 114                         if keys[mapindex].flag {
 115                                 copy(rawrt[i:], rawrt[i+1:])
 116                                 rawrt[len(rawrt)-1] = ""
 117                                 rawrt = rawrt[:len(rawrt)-1]
 118                                 delete(keys, mapindex)
 119                                 count--
 120                         }
 121                 }
 122         }
 123         rawrt = append(rawrt, key+"meid_map|end|"+strconv.Itoa(count)+"\n")
 124
 125         xapp.Logger.Debug("rmr.GeneratePolicies returns: %v", rawrt)
 126         xapp.Logger.Debug("rmr.GeneratePolicies returns: %v", rcs)
 127         return &rawrt
 128 }
 129
 130 /*
 131 Produces the raw route message consumable by RMR
 132 */
 133 func (r *Rmr) generatePartialRMRPolicies(eps rtmgr.Endpoints, xappSubData *models.XappSubscriptionData, key string, updatetype rtmgr.RMRUpdateType) *[]string {
 134         rawrt := []string{key + "updatert|start\n"}
 135         rt := r.generatePartialRouteTable(eps, xappSubData, updatetype)
 136         for _, rte := range *rt {
 137                 rawrte := key + "mse|" + rte.MessageType
 138                 for _, tx := range rte.TxList {
 139                         rawrte += "," + tx.Ip + ":" + strconv.Itoa(int(tx.Port))
 140                 }
 141                 rawrte += "|" + strconv.Itoa(int(rte.SubID)) + "|"
 142                 group := ""
 143                 for _, rxg := range rte.RxGroups {
 144                         member := ""
 145                         for _, rx := range rxg {
 146                                 if member == "" {
 147                                         member += rx.Ip + ":" + strconv.Itoa(int(rx.Port))
 148                                 } else {
 149                                         member += "," + rx.Ip + ":" + strconv.Itoa(int(rx.Port))
 150                                 }
 151                         }
 152                         if group == "" {
 153                                 group += member
 154                         } else {
 155                                 group += ";" + member
 156                         }
 157                 }
 158                 rawrte += group
 159
 160                 if rte.RouteType == "%meid" {
 161                         rawrte += group + rte.RouteType
 162                 }
 163
 164                 rawrt = append(rawrt, rawrte+"\n")
 165         }
 166
 167         rawrt = append(rawrt, key+"updatert|end\n")
 168         //count := 0
 169
 170         xapp.Logger.Debug("rmr.GeneratePolicies returns: %v", rawrt)
 171         return &rawrt
 172 }
 173 func (r *RmrPush) GeneratePolicies(eps rtmgr.Endpoints, rcs *rtmgr.RicComponents) *[]string {
 174         xapp.Logger.Debug("Invoked rmr.GeneratePolicies, args: %v: ", eps)
 175         return r.generateRMRPolicies(eps, rcs, "")
 176 }
 177
 178 func (r *RmrPush) GenerateRouteTable(eps rtmgr.Endpoints) *rtmgr.RouteTable {
 179         return r.generateRouteTable(eps)
 180 }
 181
 182 func (r *RmrPush) GeneratePartialPolicies(eps rtmgr.Endpoints, xappSubData *models.XappSubscriptionData, updatetype rtmgr.RMRUpdateType) *[]string {
 183         xapp.Logger.Debug("Invoked rmr.GeneratePartialRMR, args: %v: ", eps)
 184         return r.generatePartialRMRPolicies(eps, xappSubData, "", updatetype)
 185 }