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 := strings.TrimSuffix(tmpstr[2],"\n")
 110
 111                     mapindex := "mme_del|"+MEID+"\n"
 112                     i := keys[mapindex].index
 113                     if keys[mapindex].flag {
 114                     copy(rawrt[i:], rawrt[i+1:])
 115                             rawrt[len(rawrt)-1] = ""
 116                             rawrt = rawrt[:len(rawrt)-1]
 117                             delete(keys,mapindex)
 118                             count--
 119                     }
 120         }
 121         }
 122         rawrt = append(rawrt, key+"meid_map|end|"+strconv.Itoa(count)+"\n")
 123
 124         xapp.Logger.Debug("rmr.GeneratePolicies returns: %v", rawrt)
 125         xapp.Logger.Debug("rmr.GeneratePolicies returns: %v", rcs)
 126         return &rawrt
 127 }
 128
 129 /*
 130 Produces the raw route message consumable by RMR
 131 */
 132 func (r *Rmr) generatePartialRMRPolicies(eps rtmgr.Endpoints, xappSubData *models.XappSubscriptionData, key string, updatetype rtmgr.RMRUpdateType) *[]string {
 133         rawrt := []string{key + "updatert|start\n"}
 134         rt := r.generatePartialRouteTable(eps, xappSubData, updatetype)
 135         for _, rte := range *rt {
 136                 rawrte := key + "mse|" + rte.MessageType
 137                 for _, tx := range rte.TxList {
 138                         rawrte += "," + tx.Ip + ":" + strconv.Itoa(int(tx.Port))
 139                 }
 140                 rawrte += "|" + strconv.Itoa(int(rte.SubID)) + "|"
 141                 group := ""
 142                 for _, rxg := range rte.RxGroups {
 143                         member := ""
 144                         for _, rx := range rxg {
 145                                 if member == "" {
 146                                         member += rx.Ip + ":" + strconv.Itoa(int(rx.Port))
 147                                 } else {
 148                                         member += "," + rx.Ip + ":" + strconv.Itoa(int(rx.Port))
 149                                 }
 150                         }
 151                         if group == "" {
 152                                 group += member
 153                         } else {
 154                                 group += ";" + member
 155                         }
 156                 }
 157                 rawrte += group
 158
 159                 if rte.RouteType == "%meid" {
 160                         rawrte += group + rte.RouteType
 161                 }
 162
 163                 rawrt = append(rawrt, rawrte+"\n")
 164         }
 165
 166         rawrt = append(rawrt, key+"updatert|end\n")
 167         //count := 0
 168
 169         xapp.Logger.Debug("rmr.GeneratePolicies returns: %v", rawrt)
 170         return &rawrt
 171 }
 172 func (r *RmrPush) GeneratePolicies(eps rtmgr.Endpoints, rcs *rtmgr.RicComponents) *[]string {
 173         xapp.Logger.Debug("Invoked rmr.GeneratePolicies, args: %v: ", eps)
 174         return r.generateRMRPolicies(eps, rcs, "")
 175 }
 176
 177 func (r *RmrPush) GenerateRouteTable(eps rtmgr.Endpoints) *rtmgr.RouteTable {
 178         return r.generateRouteTable(eps)
 179 }
 180
 181 func (r *RmrPush) GeneratePartialPolicies(eps rtmgr.Endpoints, xappSubData *models.XappSubscriptionData, updatetype rtmgr.RMRUpdateType) *[]string {
 182         xapp.Logger.Debug("Invoked rmr.GeneratePartialRMR, args: %v: ", eps)
 183         return r.generatePartialRMRPolicies(eps, xappSubData, "", updatetype)
 184 }