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