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 := rtmgr.MessageTypes[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 := rtmgr.MessageTypes[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
 156
 157 func (r *Rpe) generateXappRoutes(xAppEp *rtmgr.Endpoint, e2TermEp *rtmgr.Endpoint, subManEp *rtmgr.Endpoint, routeTable *rtmgr.RouteTable) {
 158         xapp.Logger.Debug("rpe.generateXappRoutes invoked")
 159         xapp.Logger.Debug("Endpoint: %v, xAppType: %v", xAppEp.Name, xAppEp.XAppType)
 160         if xAppEp.XAppType != sbi.PlatformType && (len(xAppEp.TxMessages) > 0 || len(xAppEp.RxMessages) > 0) {
 161                 /// TODO ---
 162                 //xApp -> Subscription Manager
 163                 r.addRoute("RIC_SUB_REQ", xAppEp, subManEp, routeTable, -1, "")
 164                 r.addRoute("RIC_SUB_DEL_REQ", xAppEp, subManEp, routeTable, -1, "")
 165                 //xApp -> E2 Termination
 166                 r.addRoute("RIC_CONTROL_REQ", xAppEp, e2TermEp, routeTable, -1, "")
 167                 //E2 Termination -> xApp
 168                 r.addRoute("RIC_CONTROL_ACK", e2TermEp, xAppEp, routeTable, -1, "")
 169                 r.addRoute("RIC_CONTROL_FAILURE", e2TermEp, xAppEp, routeTable, -1, "")
 170         }
 171         //xApp->A1Mediator
 172         if xAppEp.XAppType != sbi.PlatformType && len(xAppEp.Policies) > 0 {
 173                 xapp.Logger.Debug("rpe.generateXappRoutes found policies section")
 174                 for _, policy := range xAppEp.Policies {
 175                         r.addRoute("A1_POLICY_REQ", nil, xAppEp, routeTable, policy, "")
 176                 }
 177         }
 178
 179 }
 180
 181 func (r *Rpe) generateSubscriptionRoutes(selectedxAppEp *rtmgr.Endpoint, e2TermEp *rtmgr.Endpoint, subManEp *rtmgr.Endpoint, routeTable *rtmgr.RouteTable) {
 182         xapp.Logger.Debug("rpe.addSubscriptionRoutes invoked")
 183         subscriptionList := &rtmgr.Subs
 184         for _, subscription := range *subscriptionList {
 185                 xapp.Logger.Debug("Subscription: %v", subscription)
 186                 xAppUuid := subscription.Fqdn + ":" + strconv.Itoa(int(subscription.Port))
 187                 xapp.Logger.Debug("xApp UUID: %v", xAppUuid)
 188                 xAppEp := getEndpointByUuid(xAppUuid)
 189                 if xAppEp.Uuid == selectedxAppEp.Uuid {
 190                         xapp.Logger.Debug("xApp UUID is matched for selected xApp.UUID: %v and xApp.Name: %v", selectedxAppEp.Uuid, selectedxAppEp.Name)
 191 /// TODO
 192                         //Subscription Manager -> xApp
 193                         r.addRoute("RIC_SUB_RESP", subManEp, xAppEp, routeTable, subscription.SubID, "")
 194                         r.addRoute("RIC_SUB_FAILURE", subManEp, xAppEp, routeTable, subscription.SubID, "")
 195                         r.addRoute("RIC_SUB_DEL_RESP", subManEp, xAppEp, routeTable, subscription.SubID, "")
 196                         r.addRoute("RIC_SUB_DEL_FAILURE", subManEp, xAppEp, routeTable, subscription.SubID, "")
 197                         //E2 Termination -> xApp
 198                         r.addRoute("RIC_INDICATION", e2TermEp, xAppEp, routeTable, subscription.SubID, "")
 199                         r.addRoute("RIC_CONTROL_ACK", e2TermEp, xAppEp, routeTable, subscription.SubID, "")
 200                         r.addRoute("RIC_CONTROL_FAILURE", e2TermEp, xAppEp, routeTable, subscription.SubID, "")
 201                 }
 202         }
 203 }
 204
 205 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) {
 206         xapp.Logger.Debug("rpe.generatePlatformRoutes invoked")
 207         //Platform Routes --- Subscription Routes
 208         //Subscription Manager -> E2 Termination
 209         r.addRoute("RIC_SUB_REQ", subManEp, nil, routeTable, -1, "%meid")
 210         r.addRoute("RIC_SUB_DEL_REQ", subManEp, nil, routeTable, -1, "%meid")
 211         //E2 Termination -> Subscription Manager
 212         r.addRoute("RIC_SUB_RESP", nil, subManEp, routeTable, -1, "")
 213         r.addRoute("RIC_SUB_DEL_RESP", nil, subManEp, routeTable, -1, "")
 214         r.addRoute("RIC_SUB_FAILURE", nil, subManEp, routeTable, -1, "")
 215         r.addRoute("RIC_SUB_DEL_FAILURE", nil, subManEp, routeTable, -1, "")
 216
 217         //TODO: UE Man Routes removed (since it is not existing)
 218         //UE Manager -> Subscription Manager
 219         //r.addRoute("RIC_SUB_REQ", ueManEp, subManEp, routeTable)
 220         //r.addRoute("RIC_SUB_DEL_REQ", ueManEp, subManEp, routeTable)
 221         ////UE Manager -> E2 Termination
 222         //r.addRoute("RIC_CONTROL_REQ", ueManEp, e2TermEp, routeTable)
 223
 224         //Platform Routes --- X2 Routes
 225         //E2 Manager -> E2 Termination
 226         r.addRoute("RIC_X2_SETUP_REQ", e2ManEp, nil, routeTable, -1, "%meid")
 227         r.addRoute("RIC_X2_RESET_REQ", e2ManEp, nil, routeTable, -1, "%meid")
 228         r.addRoute("RIC_X2_RESET_RESP", e2ManEp, nil, routeTable, -1, "%meid")
 229         r.addRoute("RIC_ENDC_X2_SETUP_REQ", e2ManEp, nil, routeTable, -1, "%meid")
 230         r.addRoute("RIC_ENB_CONF_UPDATE_ACK", e2ManEp, nil, routeTable, -1, "%meid")
 231         r.addRoute("RIC_ENB_CONF_UPDATE_FAILURE", e2ManEp, nil, routeTable, -1, "%meid")
 232         r.addRoute("RIC_ENDC_CONF_UPDATE_ACK", e2ManEp, nil, routeTable, -1, "%meid")
 233         r.addRoute("RIC_ENDC_CONF_UPDATE_FAILURE", e2ManEp, nil, routeTable, -1, "%meid")
 234
 235         if len(e2TermEp) > 0 {
 236                 r.addRoute_rx_list("RIC_SCTP_CLEAR_ALL", e2ManEp, e2TermEp, routeTable, -1, "")
 237                 r.addRoute_rx_list("E2_TERM_KEEP_ALIVE_REQ", e2ManEp, e2TermEp, routeTable, -1, "")
 238         }
 239
 240         //E2 Termination -> E2 Manager
 241         r.addRoute("E2_TERM_INIT", nil, e2ManEp, routeTable, -1, "")
 242         r.addRoute("RIC_X2_SETUP_RESP", nil, e2ManEp, routeTable, -1, "")
 243         r.addRoute("RIC_X2_SETUP_FAILURE", nil, e2ManEp, routeTable, -1, "")
 244         r.addRoute("RIC_X2_RESET_REQ", nil, e2ManEp, routeTable, -1, "")
 245         r.addRoute("RIC_X2_RESET_RESP", nil, e2ManEp, routeTable, -1, "")
 246         r.addRoute("RIC_ENDC_X2_SETUP_RESP", nil, e2ManEp, routeTable, -1, "")
 247         r.addRoute("RIC_ENDC_X2_SETUP_FAILURE", nil, e2ManEp, routeTable, -1, "")
 248         r.addRoute("RIC_ENDC_CONF_UPDATE", nil, e2ManEp, routeTable, -1, "")
 249         r.addRoute("RIC_SCTP_CONNECTION_FAILURE", nil, e2ManEp, routeTable, -1, "")
 250         r.addRoute("RIC_ERROR_INDICATION", nil, e2ManEp, routeTable, -1, "")
 251         r.addRoute("RIC_ENB_CONF_UPDATE", nil, e2ManEp, routeTable, -1, "")
 252         r.addRoute("RIC_ENB_LOAD_INFORMATION", nil, e2ManEp, routeTable, -1, "")
 253         r.addRoute("E2_TERM_KEEP_ALIVE_RESP", nil, e2ManEp, routeTable, -1, "")
 254
 255
 256
 257         //E2 Manager -> Resource Status Manager
 258         r.addRoute("RAN_CONNECTED", e2ManEp, rsmEp, routeTable, -1, "")
 259         r.addRoute("RAN_RESTARTED", e2ManEp, rsmEp, routeTable, -1, "")
 260         r.addRoute("RAN_RECONFIGURED", e2ManEp, rsmEp, routeTable, -1, "")
 261
 262         //Resource Status Manager -> E2 Termination
 263         r.addRoute("RIC_RES_STATUS_REQ", rsmEp, nil, routeTable, -1, "%meid")
 264         //E2 Termination -> Resource Status Manager
 265         r.addRoute("RIC_RES_STATUS_RESP", nil, rsmEp, routeTable, -1, "")
 266         r.addRoute("RIC_RES_STATUS_FAILURE", nil, rsmEp, routeTable, -1, "")
 267
 268         //ACxapp -> A1 Mediator
 269         r.addRoute("A1_POLICY_QUERY", nil, a1mediatorEp, routeTable, -1, "")
 270         r.addRoute("A1_POLICY_RESPONSE", nil, a1mediatorEp, routeTable, -1, "")
 271 }
 272
 273 func (r *Rpe) generateRouteTable(endPointList rtmgr.Endpoints) *rtmgr.RouteTable {
 274         xapp.Logger.Debug("rpe.generateRouteTable invoked")
 275         xapp.Logger.Debug("Endpoint List:  %v", endPointList)
 276         routeTable := &rtmgr.RouteTable{}
 277         e2TermEp := getEndpointByName(&endPointList, "E2TERM")
 278         if e2TermEp == nil {
 279                 xapp.Logger.Error("Platform component not found: %v", "E2 Termination")
 280                 xapp.Logger.Debug("Endpoints: %v", endPointList)
 281         }
 282         subManEp := getEndpointByName(&endPointList, "SUBMAN")
 283         if subManEp == nil {
 284                 xapp.Logger.Error("Platform component not found: %v", "Subscription Manager")
 285                 xapp.Logger.Debug("Endpoints: %v", endPointList)
 286         }
 287         e2ManEp := getEndpointByName(&endPointList, "E2MAN")
 288         if e2ManEp == nil {
 289                 xapp.Logger.Error("Platform component not found: %v", "E2 Manager")
 290                 xapp.Logger.Debug("Endpoints: %v", endPointList)
 291         }
 292         ueManEp := getEndpointByName(&endPointList, "UEMAN")
 293         if ueManEp == nil {
 294                 xapp.Logger.Error("Platform component not found: %v", "UE Manger")
 295                 xapp.Logger.Debug("Endpoints: %v", endPointList)
 296         }
 297         rsmEp := getEndpointByName(&endPointList, "RSM")
 298         if rsmEp == nil {
 299                 xapp.Logger.Error("Platform component not found: %v", "Resource Status Manager")
 300                 xapp.Logger.Debug("Endpoints: %v", endPointList)
 301         }
 302         A1MediatorEp := getEndpointByName(&endPointList, "A1MEDIATOR")
 303         if A1MediatorEp == nil {
 304                 xapp.Logger.Error("Platform component not found: %v", "A1Mediator")
 305                 xapp.Logger.Debug("Endpoints: %v", endPointList)
 306         }
 307
 308         e2TermListEp := getEndpointListByName(&endPointList, "E2TERMINST")
 309         if len(e2TermListEp) == 0 {
 310                 xapp.Logger.Error("Platform component not found: %v", "E2 Termination List")
 311                 xapp.Logger.Debug("Endpoints: %v", endPointList)
 312         }
 313         r.generatePlatformRoutes(e2TermListEp, subManEp, e2ManEp, ueManEp, rsmEp, A1MediatorEp, routeTable)
 314
 315         for _, endPoint := range endPointList {
 316                 xapp.Logger.Debug("Endpoint: %v, xAppType: %v", endPoint.Name, endPoint.XAppType)
 317                 if endPoint.XAppType != sbi.PlatformType && (len(endPoint.TxMessages) > 0 || len(endPoint.RxMessages) > 0) {
 318                         r.generateXappRoutes(endPoint, e2TermEp, subManEp, routeTable)
 319                         r.generateSubscriptionRoutes(endPoint, e2TermEp, subManEp, routeTable)
 320                 }
 321         }
 322         return routeTable
 323 }