pkg/rpe/rpe.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:     rpe.go
  26   Abstract:     Contains RPE (Route Policy Engine) module definitions and generic RPE components
  27   Date:         16 March 2019
  28 */
  29
  30 package rpe
  31
  32 import (
  33         "errors"
  34         "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
  35         "routing-manager/pkg/rtmgr"
  36         "routing-manager/pkg/sbi"
  37         "runtime"
  38         "strconv"
  39 )
  40
  41 var (
  42         SupportedRpes = []*EngineConfig{
  43                 {
  44                         Name:        "rmrpush",
  45                         Version:     "pubsush",
  46                         Protocol:    "rmruta",
  47                         Instance:    NewRmrPush(),
  48                         IsAvailable: true,
  49                 },
  50         }
  51 )
  52
  53 func GetRpe(rpeName string) (Engine, error) {
  54         for _, rpe := range SupportedRpes {
  55                 if rpe.Name == rpeName && rpe.IsAvailable {
  56                         return rpe.Instance, nil
  57                 }
  58         }
  59         return nil, errors.New("SBI:" + rpeName + " is not supported or still not a available")
  60 }
  61
  62 type Rpe struct {
  63 }
  64
  65 func getEndpointByName(eps *rtmgr.Endpoints, name string) *rtmgr.Endpoint {
  66         for _, ep := range *eps {
  67                 if ep.Name == name {
  68                         xapp.Logger.Debug("name: %s", ep.Name)
  69                         xapp.Logger.Debug("ep: %v", ep)
  70                         return ep
  71                 }
  72         }
  73         return nil
  74 }
  75
  76 func getEndpointListByName(eps *rtmgr.Endpoints, name string) []rtmgr.Endpoint {
  77         var eplist []rtmgr.Endpoint
  78
  79         for _, ep := range *eps {
  80                 if ep.Name == name {
  81                         xapp.Logger.Debug("name: %s", ep.Name)
  82                         xapp.Logger.Debug("ep: %v", ep)
  83                         eplist = append(eplist, *ep)
  84                 }
  85         }
  86         return eplist
  87 }
  88
  89 func getEndpointByUuid(uuid string) *rtmgr.Endpoint {
  90         endPoints := rtmgr.Eps
  91         for _, ep := range endPoints {
  92                 if ep.Uuid == uuid {
  93                         xapp.Logger.Debug("name: %s", ep.Uuid)
  94                         xapp.Logger.Debug("ep: %v", ep)
  95                         return ep
  96                 }
  97         }
  98         return nil
  99 }
 100
 101 func (r *Rpe) addRoute(messageType string, tx *rtmgr.Endpoint, rx *rtmgr.Endpoint, routeTable *rtmgr.RouteTable, subId int32, routeType string) {
 102         txList := rtmgr.EndpointList{}
 103         rxList := []rtmgr.EndpointList{}
 104
 105         if tx == nil && rx == nil {
 106                 pc, _, _, ok := runtime.Caller(1)
 107                 details := runtime.FuncForPC(pc)
 108                 if ok && details != nil {
 109                         xapp.Logger.Error("Route addition skipped: Either TX or RX endpoint not present. Caller function is %s", details.Name())
 110                 }
 111         } else {
 112                 if tx != nil {
 113                         txList = rtmgr.EndpointList{*tx}
 114                 }
 115                 if rx != nil {
 116                         rxList = []rtmgr.EndpointList{[]rtmgr.Endpoint{*rx}}
 117                 }
 118                 messageId := strconv.Itoa(xapp.RICMessageTypes[messageType])
 119                 route := rtmgr.RouteTableEntry{
 120                         MessageType: messageId,
 121                         TxList:      txList,
 122                         RxGroups:    rxList,
 123                         SubID:       subId,
 124                         RouteType:   routeType}
 125                 *routeTable = append(*routeTable, route)
 126                 //              xapp.Logger.Debug("Route added: MessageTyp: %v, Tx: %v, Rx: %v, SubId: %v", messageId, tx.Uuid, rx.Uuid, subId)
 127                 //              xapp.Logger.Trace("Route added: MessageTyp: %v, Tx: %v, Rx: %v, SubId: %v", messageId, tx, rx, subId)
 128         }
 129 }
 130
 131 func (r *Rpe) addRoute_rx_list(messageType string, tx *rtmgr.Endpoint, rx []rtmgr.Endpoint, routeTable *rtmgr.RouteTable, subId int32, routeType string) {
 132         txList := rtmgr.EndpointList{}
 133         rxList := []rtmgr.EndpointList{}
 134
 135         if tx != nil {
 136                 txList = rtmgr.EndpointList{*tx}
 137         }
 138
 139         if rx != nil {
 140                 rxList = []rtmgr.EndpointList{rx}
 141         }
 142
 143         messageId := strconv.Itoa(xapp.RICMessageTypes[messageType])
 144         route := rtmgr.RouteTableEntry{
 145                 MessageType: messageId,
 146                 TxList:      txList,
 147                 RxGroups:    rxList,
 148                 SubID:       subId,
 149                 RouteType:   routeType}
 150         *routeTable = append(*routeTable, route)
 151         //      xapp.Logger.Debug("Route added: MessageTyp: %v, Tx: %v, Rx: %v, SubId: %v", messageId, tx.Uuid, rx.Uuid, subId)
 152         //      xapp.Logger.Trace("Route added: MessageTyp: %v, Tx: %v, Rx: %v, SubId: %v", messageId, tx, rx, subId)
 153 }
 154
 155 func (r *Rpe) generateXappRoutes(xAppEp *rtmgr.Endpoint, e2TermEp *rtmgr.Endpoint, subManEp *rtmgr.Endpoint, routeTable *rtmgr.RouteTable) {
 156         xapp.Logger.Debug("rpe.generateXappRoutes invoked")
 157         xapp.Logger.Debug("Endpoint: %v, xAppType: %v", xAppEp.Name, xAppEp.XAppType)
 158         if xAppEp.XAppType != sbi.PlatformType && (len(xAppEp.TxMessages) > 0 || len(xAppEp.RxMessages) > 0) {
 159                 /// TODO ---
 160                 //xApp -> Subscription Manager
 161                 r.addRoute("RIC_SUB_REQ", xAppEp, subManEp, routeTable, -1, "")
 162                 r.addRoute("RIC_SUB_DEL_REQ", xAppEp, subManEp, routeTable, -1, "")
 163                 //xApp -> E2 Termination
 164                 //              r.addRoute("RIC_CONTROL_REQ", xAppEp, e2TermEp, routeTable, -1, "")
 165                 r.addRoute("RIC_CONTROL_REQ", xAppEp, nil, routeTable, -1, "%meid")
 166                 //E2 Termination -> xApp
 167                 ///             r.addRoute("RIC_CONTROL_ACK", e2TermEp, xAppEp, routeTable, -1, "")
 168                 ///             r.addRoute("RIC_CONTROL_FAILURE", e2TermEp, xAppEp, routeTable, -1, "")
 169                 r.addRoute("RIC_CONTROL_ACK", nil, xAppEp, routeTable, -1, "")
 170                 r.addRoute("RIC_CONTROL_FAILURE", nil, xAppEp, routeTable, -1, "")
 171         }
 172         //xApp->A1Mediator
 173         if xAppEp.XAppType != sbi.PlatformType && len(xAppEp.Policies) > 0 {
 174                 xapp.Logger.Debug("rpe.generateXappRoutes found policies section")
 175                 for _, policy := range xAppEp.Policies {
 176                         r.addRoute("A1_POLICY_REQ", nil, xAppEp, routeTable, policy, "")
 177                 }
 178         }
 179
 180 }
 181
 182 func (r *Rpe) generateSubscriptionRoutes(selectedxAppEp *rtmgr.Endpoint, e2TermEp *rtmgr.Endpoint, subManEp *rtmgr.Endpoint, routeTable *rtmgr.RouteTable) {
 183         xapp.Logger.Debug("rpe.addSubscriptionRoutes invoked")
 184         subscriptionList := &rtmgr.Subs
 185         for _, subscription := range *subscriptionList {
 186                 xapp.Logger.Debug("Subscription: %v", subscription)
 187                 xAppUuid := subscription.Fqdn + ":" + strconv.Itoa(int(subscription.Port))
 188                 xapp.Logger.Debug("xApp UUID: %v", xAppUuid)
 189                 xAppEp := getEndpointByUuid(xAppUuid)
 190                 if xAppEp.Uuid == selectedxAppEp.Uuid {
 191                         xapp.Logger.Debug("xApp UUID is matched for selected xApp.UUID: %v and xApp.Name: %v", selectedxAppEp.Uuid, selectedxAppEp.Name)
 192                         /// TODO
 193                         //Subscription Manager -> xApp
 194                         r.addRoute("RIC_SUB_RESP", subManEp, xAppEp, routeTable, subscription.SubID, "")
 195                         r.addRoute("RIC_SUB_FAILURE", subManEp, xAppEp, routeTable, subscription.SubID, "")
 196                         r.addRoute("RIC_SUB_DEL_RESP", subManEp, xAppEp, routeTable, subscription.SubID, "")
 197                         r.addRoute("RIC_SUB_DEL_FAILURE", subManEp, xAppEp, routeTable, subscription.SubID, "")
 198                         //E2 Termination -> xApp
 199                         r.addRoute("RIC_INDICATION", e2TermEp, xAppEp, routeTable, subscription.SubID, "")
 200                         r.addRoute("RIC_CONTROL_ACK", e2TermEp, xAppEp, routeTable, subscription.SubID, "")
 201                         r.addRoute("RIC_CONTROL_FAILURE", e2TermEp, xAppEp, routeTable, subscription.SubID, "")
 202                 }
 203         }
 204 }
 205
 206 func (r *Rpe) generatePlatformRoutes(e2TermEp []rtmgr.Endpoint, subManEp *rtmgr.Endpoint, e2ManEp *rtmgr.Endpoint, ueManEp *rtmgr.Endpoint, rsmEp *rtmgr.Endpoint, a1mediatorEp *rtmgr.Endpoint, routeTable *rtmgr.RouteTable) {
 207         xapp.Logger.Debug("rpe.generatePlatformRoutes invoked")
 208         //Platform Routes --- Subscription Routes
 209         //Subscription Manager -> E2 Termination
 210         for _, routes := range *rtmgr.PrsCfg {
 211                 var sendEp *rtmgr.Endpoint
 212                 var Ep *rtmgr.Endpoint
 213                 switch routes.SenderEndPoint {
 214                 case "SUBMAN":
 215                         sendEp = subManEp
 216                 case "E2MAN":
 217                         sendEp = e2ManEp
 218                 case "UEMAN":
 219                         sendEp = ueManEp
 220                 case "RSM":
 221                         sendEp = rsmEp
 222                 case "A1MEDIATOR":
 223                         sendEp = a1mediatorEp
 224                 }
 225                 switch routes.EndPoint {
 226                 case "SUBMAN":
 227                         Ep = subManEp
 228                 case "E2MAN":
 229                         Ep = e2ManEp
 230                 case "UEMAN":
 231                         Ep = ueManEp
 232                 case "RSM":
 233                         Ep = rsmEp
 234                 case "A1MEDIATOR":
 235                         Ep = a1mediatorEp
 236                 }
 237                 if routes.EndPoint == "E2TERMINST" && len(e2TermEp) > 0 {
 238                         r.addRoute_rx_list(routes.MessageType, sendEp, e2TermEp, routeTable, routes.SubscriptionId, routes.Meid)
 239                         continue
 240                 }
 241                 r.addRoute(routes.MessageType, sendEp, Ep, routeTable, routes.SubscriptionId, routes.Meid)
 242         }
 243 }
 244
 245 func (r *Rpe) generateRouteTable(endPointList rtmgr.Endpoints) *rtmgr.RouteTable {
 246         xapp.Logger.Debug("rpe.generateRouteTable invoked")
 247         xapp.Logger.Debug("Endpoint List:  %v", endPointList)
 248         routeTable := &rtmgr.RouteTable{}
 249         e2TermEp := getEndpointByName(&endPointList, "E2TERM")
 250         if e2TermEp == nil {
 251                 xapp.Logger.Error("Platform component not found: %v", "E2 Termination")
 252                 xapp.Logger.Debug("Endpoints: %v", endPointList)
 253         }
 254         subManEp := getEndpointByName(&endPointList, "SUBMAN")
 255         if subManEp == nil {
 256                 xapp.Logger.Error("Platform component not found: %v", "Subscription Manager")
 257                 xapp.Logger.Debug("Endpoints: %v", endPointList)
 258         }
 259         e2ManEp := getEndpointByName(&endPointList, "E2MAN")
 260         if e2ManEp == nil {
 261                 xapp.Logger.Error("Platform component not found: %v", "E2 Manager")
 262                 xapp.Logger.Debug("Endpoints: %v", endPointList)
 263         }
 264         ueManEp := getEndpointByName(&endPointList, "UEMAN")
 265         if ueManEp == nil {
 266                 xapp.Logger.Error("Platform component not found: %v", "UE Manger")
 267                 xapp.Logger.Debug("Endpoints: %v", endPointList)
 268         }
 269         rsmEp := getEndpointByName(&endPointList, "RSM")
 270         if rsmEp == nil {
 271                 xapp.Logger.Error("Platform component not found: %v", "Resource Status Manager")
 272                 xapp.Logger.Debug("Endpoints: %v", endPointList)
 273         }
 274         A1MediatorEp := getEndpointByName(&endPointList, "A1MEDIATOR")
 275         if A1MediatorEp == nil {
 276                 xapp.Logger.Error("Platform component not found: %v", "A1Mediator")
 277                 xapp.Logger.Debug("Endpoints: %v", endPointList)
 278         }
 279
 280         e2TermListEp := getEndpointListByName(&endPointList, "E2TERMINST")
 281         if len(e2TermListEp) == 0 {
 282                 xapp.Logger.Error("Platform component not found: %v", "E2 Termination List")
 283                 xapp.Logger.Debug("Endpoints: %v", endPointList)
 284         }
 285         r.generatePlatformRoutes(e2TermListEp, subManEp, e2ManEp, ueManEp, rsmEp, A1MediatorEp, routeTable)
 286
 287         for _, endPoint := range endPointList {
 288                 xapp.Logger.Debug("Endpoint: %v, xAppType: %v", endPoint.Name, endPoint.XAppType)
 289                 if endPoint.XAppType != sbi.PlatformType && (len(endPoint.TxMessages) > 0 || len(endPoint.RxMessages) > 0) {
 290                         r.generateXappRoutes(endPoint, e2TermEp, subManEp, routeTable)
 291                         r.generateSubscriptionRoutes(endPoint, e2TermEp, subManEp, routeTable)
 292                 }
 293         }
 294         return routeTable
 295 }