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         "routing-manager/pkg/rtmgr"
  35         "routing-manager/pkg/sbi"
  36         "strconv"
  37         "runtime"
  38 )
  39
  40 var (
  41         SupportedRpes = []*EngineConfig{
  42                 {
  43                         Name:        "rmrpush",
  44                         Version:     "pubsush",
  45                         Protocol:    "rmruta",
  46                         Instance:    NewRmrPush(),
  47                         IsAvailable: true,
  48                 },
  49         }
  50 )
  51
  52 func GetRpe(rpeName string) (Engine, error) {
  53         for _, rpe := range SupportedRpes {
  54                 if rpe.Name == rpeName && rpe.IsAvailable {
  55                         return rpe.Instance, nil
  56                 }
  57         }
  58         return nil, errors.New("SBI:" + rpeName + " is not supported or still not a available")
  59 }
  60
  61 type Rpe struct {
  62 }
  63
  64 func getEndpointByName(eps *rtmgr.Endpoints, name string) *rtmgr.Endpoint {
  65         for _, ep := range *eps {
  66                 if ep.Name == name {
  67                         rtmgr.Logger.Debug("name: %s", ep.Name)
  68                         rtmgr.Logger.Debug("ep: %v", ep)
  69                         return ep
  70                 }
  71         }
  72         return nil
  73 }
  74
  75 func getEndpointByUuid(uuid string) *rtmgr.Endpoint {
  76         endPoints := rtmgr.Eps
  77         for _, ep := range endPoints {
  78                 if ep.Uuid == uuid {
  79                         rtmgr.Logger.Debug("name: %s", ep.Uuid)
  80                         rtmgr.Logger.Debug("ep: %v", ep)
  81                         return ep
  82                 }
  83         }
  84         return nil
  85 }
  86
  87 func (r *Rpe) addRoute(messageType string, tx *rtmgr.Endpoint, rx *rtmgr.Endpoint, routeTable *rtmgr.RouteTable, subId int32) {
  88         if tx != nil && rx != nil {
  89                 txList := rtmgr.EndpointList{*tx}
  90                 rxList := []rtmgr.EndpointList{[]rtmgr.Endpoint{*rx}}
  91                 messageId := rtmgr.MessageTypes[messageType]
  92                 route := rtmgr.RouteTableEntry{
  93                                 MessageType: messageId,
  94                                 TxList:      txList,
  95                                 RxGroups:    rxList,
  96                                 SubID:       subId}
  97                         *routeTable = append(*routeTable, route)
  98                         rtmgr.Logger.Debug("Route added: MessageTyp: %v, Tx: %v, Rx: %v, SubId: %v", messageId, tx.Uuid, rx.Uuid, subId)
  99                         rtmgr.Logger.Trace("Route added: MessageTyp: %v, Tx: %v, Rx: %v, SubId: %v", messageId, tx, rx, subId)
 100                 } else {
 101                         pc,_,_,ok := runtime.Caller(1)
 102                         details := runtime.FuncForPC(pc)
 103                         if ok && details != nil {
 104                                 rtmgr.Logger.Error("Route addition skipped: Either TX or RX endpoint not present. Caller function is %s", details.Name())
 105                         }
 106                 }
 107 }
 108
 109 func (r *Rpe) generateXappRoutes(xAppEp *rtmgr.Endpoint, e2TermEp *rtmgr.Endpoint, subManEp *rtmgr.Endpoint, routeTable *rtmgr.RouteTable) {
 110         rtmgr.Logger.Debug("rpe.generateXappRoutes invoked")
 111         rtmgr.Logger.Debug("Endpoint: %v, xAppType: %v", xAppEp.Name, xAppEp.XAppType)
 112         if xAppEp.XAppType != sbi.PlatformType && ( len(xAppEp.TxMessages) > 0 || len(xAppEp.RxMessages) > 0 ) {
 113                 //xApp -> Subscription Manager
 114                 r.addRoute("RIC_SUB_REQ", xAppEp, subManEp, routeTable, -1)
 115                 r.addRoute("RIC_SUB_DEL_REQ", xAppEp, subManEp, routeTable, -1)
 116                 //xApp -> E2 Termination
 117                 r.addRoute("RIC_CONTROL_REQ", xAppEp, e2TermEp, routeTable, -1)
 118                 //E2 Termination -> xApp
 119                 r.addRoute("RIC_CONTROL_ACK", e2TermEp, xAppEp, routeTable, -1)
 120                 r.addRoute("RIC_CONTROL_FAILURE", e2TermEp, xAppEp, routeTable, -1)
 121         }
 122 }
 123
 124 func (r *Rpe) generateSubscriptionRoutes(selectedxAppEp *rtmgr.Endpoint, e2TermEp *rtmgr.Endpoint, subManEp *rtmgr.Endpoint, routeTable *rtmgr.RouteTable) {
 125         rtmgr.Logger.Debug("rpe.addSubscriptionRoutes invoked")
 126         subscriptionList := &rtmgr.Subs
 127         for _, subscription := range *subscriptionList {
 128                 rtmgr.Logger.Debug("Subscription: %v", subscription)
 129                 xAppUuid := subscription.Fqdn + ":" + strconv.Itoa(int(subscription.Port))
 130                 rtmgr.Logger.Debug("xApp UUID: %v", xAppUuid)
 131                 xAppEp := getEndpointByUuid(xAppUuid)
 132                 if xAppEp.Uuid == selectedxAppEp.Uuid {
 133                         rtmgr.Logger.Debug("xApp UUID is matched for selected xApp.UUID: %v and xApp.Name: %v", selectedxAppEp.Uuid, selectedxAppEp.Name)
 134                         //Subscription Manager -> xApp
 135                         r.addRoute("RIC_SUB_RESP", subManEp, xAppEp, routeTable, subscription.SubID)
 136                         r.addRoute("RIC_SUB_FAILURE", subManEp, xAppEp, routeTable, subscription.SubID)
 137                         r.addRoute("RIC_SUB_DEL_RESP", subManEp, xAppEp, routeTable, subscription.SubID)
 138                         r.addRoute("RIC_SUB_DEL_FAILURE", subManEp, xAppEp, routeTable, subscription.SubID)
 139                         //E2 Termination -> xApp
 140                         r.addRoute("RIC_INDICATION", e2TermEp, xAppEp, routeTable, subscription.SubID)
 141                         r.addRoute("RIC_CONTROL_ACK", e2TermEp, xAppEp, routeTable, subscription.SubID)
 142                         r.addRoute("RIC_CONTROL_FAILURE", e2TermEp, xAppEp, routeTable, subscription.SubID)
 143                 }
 144         }
 145 }
 146
 147 func (r *Rpe) generatePlatformRoutes(e2TermEp *rtmgr.Endpoint, subManEp *rtmgr.Endpoint, e2ManEp *rtmgr.Endpoint, ueManEp *rtmgr.Endpoint, rsmEp *rtmgr.Endpoint, routeTable *rtmgr.RouteTable) {
 148         rtmgr.Logger.Debug("rpe.generatePlatformRoutes invoked")
 149         //Platform Routes --- Subscription Routes
 150         //Subscription Manager -> E2 Termination
 151         r.addRoute("RIC_SUB_REQ", subManEp, e2TermEp, routeTable, -1)
 152         r.addRoute("RIC_SUB_DEL_REQ", subManEp, e2TermEp, routeTable, -1)
 153         //E2 Termination -> Subscription Manager
 154         r.addRoute("RIC_SUB_RESP", e2TermEp, subManEp, routeTable, -1)
 155         r.addRoute("RIC_SUB_DEL_RESP", e2TermEp, subManEp, routeTable, -1)
 156         r.addRoute("RIC_SUB_FAILURE", e2TermEp, subManEp, routeTable, -1)
 157         r.addRoute("RIC_SUB_DEL_FAILURE", e2TermEp, subManEp, routeTable, -1)
 158         //TODO: UE Man Routes removed (since it is not existing)
 159         //UE Manager -> Subscription Manager
 160         //r.addRoute("RIC_SUB_REQ", ueManEp, subManEp, routeTable)
 161         //r.addRoute("RIC_SUB_DEL_REQ", ueManEp, subManEp, routeTable)
 162         ////UE Manager -> E2 Termination
 163         //r.addRoute("RIC_CONTROL_REQ", ueManEp, e2TermEp, routeTable)
 164
 165         //Platform Routes --- X2 Routes
 166         //E2 Manager -> E2 Termination
 167         r.addRoute("RIC_X2_SETUP_REQ", e2ManEp, e2TermEp, routeTable, -1)
 168         r.addRoute("RIC_X2_RESET_REQ", e2ManEp, e2TermEp, routeTable, -1)
 169         r.addRoute("RIC_X2_RESET_RESP", e2ManEp, e2TermEp, routeTable, -1)
 170         r.addRoute("RIC_ENDC_X2_SETUP_REQ", e2ManEp, e2TermEp, routeTable, -1)
 171         r.addRoute("RIC_SCTP_CLEAR_ALL", e2ManEp, e2TermEp, routeTable, -1)
 172         r.addRoute("RIC_ENB_CONF_UPDATE_ACK", e2ManEp, e2TermEp, routeTable, -1)
 173         r.addRoute("RIC_ENB_CONF_UPDATE_FAILURE", e2ManEp, e2TermEp, routeTable, -1)
 174         r.addRoute("RIC_ENDC_CONF_UPDATE_ACK", e2ManEp, e2TermEp, routeTable, -1)
 175         r.addRoute("RIC_ENDC_CONF_UPDATE_FAILURE", e2ManEp, e2TermEp, routeTable, -1)
 176         //E2 Termination -> E2 Manager
 177         r.addRoute("E2_TERM_INIT", e2TermEp, e2ManEp, routeTable, -1)
 178         r.addRoute("RIC_X2_SETUP_RESP", e2TermEp, e2ManEp, routeTable, -1)
 179         r.addRoute("RIC_X2_SETUP_FAILURE", e2TermEp, e2ManEp, routeTable, -1)
 180         r.addRoute("RIC_X2_RESET_REQ", e2TermEp, e2ManEp, routeTable, -1)
 181         r.addRoute("RIC_X2_RESET_RESP", e2TermEp, e2ManEp, routeTable, -1)
 182         r.addRoute("RIC_ENDC_X2_SETUP_RESP", e2TermEp, e2ManEp, routeTable, -1)
 183         r.addRoute("RIC_ENDC_X2_SETUP_FAILURE", e2TermEp, e2ManEp, routeTable, -1)
 184         r.addRoute("RIC_ENDC_CONF_UPDATE", e2TermEp, e2ManEp, routeTable, -1)
 185         r.addRoute("RIC_SCTP_CONNECTION_FAILURE", e2TermEp, e2ManEp, routeTable, -1)
 186         r.addRoute("RIC_ERROR_INDICATION", e2TermEp, e2ManEp, routeTable, -1)
 187         r.addRoute("RIC_ENB_CONF_UPDATE", e2TermEp, e2ManEp, routeTable, -1)
 188         r.addRoute("RIC_ENB_LOAD_INFORMATION", e2TermEp, e2ManEp, routeTable, -1)
 189         //E2 Manager -> Resource Status Manager
 190         r.addRoute("RAN_CONNECTED", e2ManEp, rsmEp, routeTable, -1)
 191         r.addRoute("RAN_RESTARTED", e2ManEp, rsmEp, routeTable, -1)
 192         r.addRoute("RAN_RECONFIGURED", e2ManEp, rsmEp, routeTable, -1)
 193         //Resource Status Manager -> E2 Termination
 194         r.addRoute("RIC_RES_STATUS_REQ", rsmEp, e2TermEp, routeTable, -1)
 195         //E2 Termination -> Resource Status Manager
 196         r.addRoute("RIC_RES_STATUS_RESP", e2TermEp, rsmEp, routeTable, -1)
 197         r.addRoute("RIC_RES_STATUS_FAILURE", e2TermEp, rsmEp, routeTable, -1)
 198 }
 199
 200 func (r *Rpe) generateRouteTable(endPointList rtmgr.Endpoints) *rtmgr.RouteTable {
 201         rtmgr.Logger.Debug("rpe.generateRouteTable invoked")
 202         rtmgr.Logger.Debug("Endpoint List:  %v", endPointList)
 203         routeTable := &rtmgr.RouteTable{}
 204         e2TermEp := getEndpointByName(&endPointList, "E2TERM")
 205         if e2TermEp == nil {
 206                 rtmgr.Logger.Error("Platform component not found: %v", "E2 Termination")
 207                 rtmgr.Logger.Debug("Endpoints: %v", endPointList)
 208         }
 209         subManEp := getEndpointByName(&endPointList, "SUBMAN")
 210         if subManEp == nil {
 211                 rtmgr.Logger.Error("Platform component not found: %v", "Subscription Manager")
 212                 rtmgr.Logger.Debug("Endpoints: %v", endPointList)
 213         }
 214         e2ManEp := getEndpointByName(&endPointList, "E2MAN")
 215         if e2ManEp == nil {
 216                 rtmgr.Logger.Error("Platform component not found: %v", "E2 Manager")
 217                 rtmgr.Logger.Debug("Endpoints: %v", endPointList)
 218         }
 219         ueManEp := getEndpointByName(&endPointList, "UEMAN")
 220         if ueManEp == nil {
 221                 rtmgr.Logger.Error("Platform component not found: %v", "UE Manger")
 222                 rtmgr.Logger.Debug("Endpoints: %v", endPointList)
 223         }
 224         rsmEp := getEndpointByName(&endPointList, "RSM")
 225         if rsmEp == nil {
 226                 rtmgr.Logger.Error("Platform component not found: %v", "Resource Status Manager")
 227                 rtmgr.Logger.Debug("Endpoints: %v", endPointList)
 228         }
 229         r.generatePlatformRoutes(e2TermEp, subManEp, e2ManEp, ueManEp, rsmEp, routeTable)
 230
 231         for _, endPoint := range endPointList {
 232                 rtmgr.Logger.Debug("Endpoint: %v, xAppType: %v", endPoint.Name, endPoint.XAppType)
 233                 if endPoint.XAppType != sbi.PlatformType && ( len(endPoint.TxMessages) > 0 || len(endPoint.RxMessages) > 0 ) {
 234                         r.generateXappRoutes(endPoint, e2TermEp, subManEp, routeTable)
 235                         r.generateSubscriptionRoutes(endPoint, e2TermEp, subManEp, routeTable)
 236                 }
 237         }
 238         return routeTable
 239 }