| /* |
| ================================================================================== |
| Copyright (c) 2019 AT&T Intellectual Property. |
| Copyright (c) 2019 Nokia |
| |
| Licensed under the Apache License, Version 2.0 (the "License"); |
| you may not use this file except in compliance with the License. |
| You may obtain a copy of the License at |
| |
| http://www.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, software |
| distributed under the License is distributed on an "AS IS" BASIS, |
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| See the License for the specific language governing permissions and |
| limitations under the License. |
| |
| |
| This source code is part of the near-RT RIC (RAN Intelligent Controller) |
| platform project (RICP). |
| |
| ================================================================================== |
| */ |
| /* |
| Mnemonic: rpe.go |
| Abstract: Contains RPE (Route Policy Engine) module definitions and generic RPE components |
| Date: 16 March 2019 |
| */ |
| |
| package rpe |
| |
| import ( |
| "errors" |
| "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp" |
| "routing-manager/pkg/models" |
| "routing-manager/pkg/rtmgr" |
| "routing-manager/pkg/sbi" |
| "runtime" |
| "strconv" |
| ) |
| |
| var ( |
| SupportedRpes = []*EngineConfig{ |
| { |
| Name: "rmrpush", |
| Version: "pubsush", |
| Protocol: "rmruta", |
| Instance: NewRmrPush(), |
| IsAvailable: true, |
| }, |
| } |
| ) |
| |
| func GetRpe(rpeName string) (Engine, error) { |
| for _, rpe := range SupportedRpes { |
| if rpe.Name == rpeName && rpe.IsAvailable { |
| return rpe.Instance, nil |
| } |
| } |
| return nil, errors.New("SBI:" + rpeName + " is not supported or still not a available") |
| } |
| |
| type Rpe struct { |
| } |
| |
| func getEndpointByName(eps *rtmgr.Endpoints, name string) *rtmgr.Endpoint { |
| for _, ep := range *eps { |
| if ep.Name == name { |
| xapp.Logger.Debug("name: %s", ep.Name) |
| xapp.Logger.Debug("ep: %v", ep) |
| return ep |
| } |
| } |
| return nil |
| } |
| |
| func getEndpointListByName(eps *rtmgr.Endpoints, name string) []rtmgr.Endpoint { |
| var eplist []rtmgr.Endpoint |
| |
| for _, ep := range *eps { |
| if ep.Name == name { |
| xapp.Logger.Debug("name: %s", ep.Name) |
| xapp.Logger.Debug("ep: %v", ep) |
| eplist = append(eplist, *ep) |
| } |
| } |
| return eplist |
| } |
| |
| func getEndpointByUuid(uuid string) *rtmgr.Endpoint { |
| endPoints := rtmgr.Eps |
| for _, ep := range endPoints { |
| if ep.Uuid == uuid { |
| xapp.Logger.Debug("name: %s", ep.Uuid) |
| xapp.Logger.Debug("ep: %v", ep) |
| return ep |
| } |
| } |
| return nil |
| } |
| |
| func (r *Rpe) addRoute(messageType string, tx *rtmgr.Endpoint, rx *rtmgr.Endpoint, routeTable *rtmgr.RouteTable, subId int32, routeType string) { |
| txList := rtmgr.EndpointList{} |
| rxList := []rtmgr.EndpointList{} |
| |
| if tx == nil && rx == nil { |
| pc, _, _, ok := runtime.Caller(1) |
| details := runtime.FuncForPC(pc) |
| if ok && details != nil { |
| xapp.Logger.Error("Route addition skipped: Either TX or RX endpoint not present. Caller function is %s", details.Name()) |
| } |
| } else { |
| if tx != nil { |
| txList = rtmgr.EndpointList{*tx} |
| } |
| if rx != nil { |
| rxList = []rtmgr.EndpointList{[]rtmgr.Endpoint{*rx}} |
| } |
| //messageId := strconv.Itoa(xapp.RICMessageTypes[messageType]) |
| messageId := rtmgr.Mtype[messageType] |
| route := rtmgr.RouteTableEntry{ |
| MessageType: messageId, |
| TxList: txList, |
| RxGroups: rxList, |
| SubID: subId, |
| RouteType: routeType} |
| *routeTable = append(*routeTable, route) |
| // xapp.Logger.Debug("Route added: MessageTyp: %v, Tx: %v, Rx: %v, SubId: %v", messageId, tx.Uuid, rx.Uuid, subId) |
| // xapp.Logger.Trace("Route added: MessageTyp: %v, Tx: %v, Rx: %v, SubId: %v", messageId, tx, rx, subId) |
| } |
| } |
| |
| func (r *Rpe) addRoute_rx_list(messageType string, tx *rtmgr.Endpoint, rx []rtmgr.Endpoint, routeTable *rtmgr.RouteTable, subId int32, routeType string) { |
| txList := rtmgr.EndpointList{} |
| rxList := []rtmgr.EndpointList{} |
| |
| if tx != nil { |
| txList = rtmgr.EndpointList{*tx} |
| } |
| |
| if rx != nil { |
| for _, item := range rx { |
| ep := []rtmgr.Endpoint{item} |
| rxList = append(rxList, ep) |
| } |
| } |
| |
| //messageId := strconv.Itoa(xapp.RICMessageTypes[messageType]) |
| messageId := rtmgr.Mtype[messageType] |
| route := rtmgr.RouteTableEntry{ |
| MessageType: messageId, |
| TxList: txList, |
| RxGroups: rxList, |
| SubID: subId, |
| RouteType: routeType} |
| *routeTable = append(*routeTable, route) |
| // xapp.Logger.Debug("Route added: MessageTyp: %v, Tx: %v, Rx: %v, SubId: %v", messageId, tx.Uuid, rx.Uuid, subId) |
| // xapp.Logger.Trace("Route added: MessageTyp: %v, Tx: %v, Rx: %v, SubId: %v", messageId, tx, rx, subId) |
| } |
| |
| func (r *Rpe) generateXappRoutes(xAppEp *rtmgr.Endpoint, subManEp *rtmgr.Endpoint, routeTable *rtmgr.RouteTable) { |
| xapp.Logger.Debug("rpe.generateXappRoutes invoked") |
| xapp.Logger.Debug("Endpoint: %v, xAppType: %v", xAppEp.Name, xAppEp.XAppType) |
| if xAppEp.XAppType != sbi.PlatformType && (len(xAppEp.TxMessages) > 0 || len(xAppEp.RxMessages) > 0) { |
| /// TODO --- |
| //xApp -> Subscription Manager |
| r.addRoute("RIC_SUB_REQ", xAppEp, subManEp, routeTable, -1, "") |
| r.addRoute("RIC_SUB_DEL_REQ", xAppEp, subManEp, routeTable, -1, "") |
| //xApp -> E2 Termination |
| // r.addRoute("RIC_CONTROL_REQ", xAppEp, e2TermEp, routeTable, -1, "") |
| r.addRoute("RIC_CONTROL_REQ", xAppEp, nil, routeTable, -1, "%meid") |
| //E2 Termination -> xApp |
| /// r.addRoute("RIC_CONTROL_ACK", e2TermEp, xAppEp, routeTable, -1, "") |
| /// r.addRoute("RIC_CONTROL_FAILURE", e2TermEp, xAppEp, routeTable, -1, "") |
| r.addRoute("RIC_CONTROL_ACK", nil, xAppEp, routeTable, -1, "") |
| r.addRoute("RIC_CONTROL_FAILURE", nil, xAppEp, routeTable, -1, "") |
| } |
| //xApp->A1Mediator |
| if xAppEp.XAppType != sbi.PlatformType && len(xAppEp.Policies) > 0 { |
| xapp.Logger.Debug("rpe.generateXappRoutes found policies section") |
| for _, policy := range xAppEp.Policies { |
| r.addRoute("A1_POLICY_REQ", nil, xAppEp, routeTable, policy, "") |
| } |
| } |
| |
| } |
| |
| func (r *Rpe) generateXappToXappRoutes(RecvxAppEp *rtmgr.Endpoint, endPointList rtmgr.Endpoints, routeTable *rtmgr.RouteTable) { |
| xapp.Logger.Debug("rpe.generateXappToXappRoutes invoked") |
| |
| for _, rxmsg := range RecvxAppEp.RxMessages { |
| |
| var src_present bool |
| identicalMsg := false |
| var RxGrp []rtmgr.Endpoint |
| xapp.Logger.Debug("RecvxAppEp.RxMessages Endpoint: %v, xAppType: %v and rxmsg: %v ", RecvxAppEp.Name, RecvxAppEp.XAppType, rxmsg) |
| if rxmsg != "RIC_SUB_RESP" && rxmsg != "RIC_SUB_FAILURE" && rxmsg != "RIC_SUB_DEL_RESP" && rxmsg != "RIC_SUB_DEL_FAILURE" && rxmsg != "RIC_INDICATION" && rxmsg != "RIC_CONTROL_ACK" && rxmsg != "RIC_CONTROL_FAILURE" && rxmsg != "A1_POLICY_REQ" { |
| for _, SrcxAppEp := range endPointList { |
| if SrcxAppEp.XAppType != sbi.PlatformType && (len(SrcxAppEp.TxMessages) > 0) && SrcxAppEp.Name != RecvxAppEp.Name { |
| for _, txmsg := range SrcxAppEp.TxMessages { |
| if rxmsg == txmsg { |
| r.addRoute(rxmsg, SrcxAppEp, RecvxAppEp, routeTable, -1, "") |
| src_present = true |
| break |
| } |
| } |
| } |
| } |
| for _, SrcxAppEp := range endPointList { |
| |
| if SrcxAppEp.XAppType != sbi.PlatformType && (len(SrcxAppEp.RxMessages) > 0) && SrcxAppEp.Name != RecvxAppEp.Name { |
| for _, newrxmsg := range SrcxAppEp.RxMessages { |
| if newrxmsg == rxmsg { |
| RxGrp = append(RxGrp, *SrcxAppEp) |
| identicalMsg = true |
| } |
| } |
| } |
| } |
| if src_present == false && identicalMsg == false { |
| xapp.Logger.Debug("Message type %v,for SrcxAppEp.Name %v", rxmsg, RecvxAppEp) |
| r.addRoute(rxmsg, nil, RecvxAppEp, routeTable, -1, "") |
| } |
| if identicalMsg == true { |
| xapp.Logger.Debug("Appending Message type %v,for SrcxAppEp.Name %v", rxmsg, RecvxAppEp) |
| RxGrp = append(RxGrp, *RecvxAppEp) |
| r.addRoute_rx_list(rxmsg, nil, RxGrp, routeTable, -1, "") |
| //return |
| } |
| } |
| } |
| } |
| |
| func (r *Rpe) generateSubscriptionRoutes(selectedxAppEp *rtmgr.Endpoint, subManEp *rtmgr.Endpoint, routeTable *rtmgr.RouteTable) { |
| xapp.Logger.Debug("rpe.addSubscriptionRoutes invoked") |
| subscriptionList := &rtmgr.Subs |
| for _, subscription := range *subscriptionList { |
| xapp.Logger.Debug("Subscription: %v", subscription) |
| xAppUuid := subscription.Fqdn + ":" + strconv.Itoa(int(subscription.Port)) |
| xapp.Logger.Debug("xApp UUID: %v", xAppUuid) |
| xAppEp := getEndpointByUuid(xAppUuid) |
| if xAppEp != nil { |
| if xAppEp.Uuid == selectedxAppEp.Uuid { |
| xapp.Logger.Debug("xApp UUID is matched for selected xApp.UUID: %v and xApp.Name: %v", selectedxAppEp.Uuid, selectedxAppEp.Name) |
| /// TODO |
| //Subscription Manager -> xApp |
| r.addRoute("RIC_SUB_RESP", subManEp, xAppEp, routeTable, subscription.SubID, "") |
| r.addRoute("RIC_SUB_FAILURE", subManEp, xAppEp, routeTable, subscription.SubID, "") |
| r.addRoute("RIC_SUB_DEL_RESP", subManEp, xAppEp, routeTable, subscription.SubID, "") |
| r.addRoute("RIC_SUB_DEL_FAILURE", subManEp, xAppEp, routeTable, subscription.SubID, "") |
| //E2 Termination -> xApp |
| r.addRoute("RIC_INDICATION", nil, xAppEp, routeTable, subscription.SubID, "") |
| r.addRoute("RIC_CONTROL_ACK", nil, xAppEp, routeTable, subscription.SubID, "") |
| r.addRoute("RIC_CONTROL_FAILURE", nil, xAppEp, routeTable, subscription.SubID, "") |
| } |
| } else { |
| xapp.Logger.Error("generateSubscriptionRoutes xAppEp is nil, xApp UUID: %v", xAppUuid) |
| } |
| } |
| } |
| |
| func (r *Rpe) generatePartialSubscriptionTable(xappSubData *models.XappSubscriptionData, subManEp *rtmgr.Endpoint, routeTable *rtmgr.RouteTable) { |
| xapp.Logger.Debug("rpe.addSingleSubscriptionRoutes invoked") |
| xAppUuid := *xappSubData.Address + ":" + strconv.Itoa(int(*xappSubData.Port)) |
| xapp.Logger.Debug("xApp UUID: %v", xAppUuid) |
| xAppEp := getEndpointByUuid(xAppUuid) |
| if xAppEp != nil { |
| //Subscription Manager -> xApp |
| r.addRoute("RIC_SUB_RESP", subManEp, xAppEp, routeTable, *xappSubData.SubscriptionID, "") |
| r.addRoute("RIC_SUB_FAILURE", subManEp, xAppEp, routeTable, *xappSubData.SubscriptionID, "") |
| r.addRoute("RIC_SUB_DEL_RESP", subManEp, xAppEp, routeTable, *xappSubData.SubscriptionID, "") |
| r.addRoute("RIC_SUB_DEL_FAILURE", subManEp, xAppEp, routeTable, *xappSubData.SubscriptionID, "") |
| //E2 Termination -> xApp |
| r.addRoute("RIC_INDICATION", nil, xAppEp, routeTable, *xappSubData.SubscriptionID, "") |
| r.addRoute("RIC_CONTROL_ACK", nil, xAppEp, routeTable, *xappSubData.SubscriptionID, "") |
| r.addRoute("RIC_CONTROL_FAILURE", nil, xAppEp, routeTable, *xappSubData.SubscriptionID, "") |
| } else { |
| xapp.Logger.Error("generateSubscriptionRoutes xAppEp is nil, xApp UUID: %v", xAppUuid) |
| } |
| } |
| |
| func (r *Rpe) generatePlatformRoutes(e2TermEp []rtmgr.Endpoint, subManEp *rtmgr.Endpoint, e2ManEp *rtmgr.Endpoint, a1mediatorEp *rtmgr.Endpoint, routeTable *rtmgr.RouteTable) { |
| xapp.Logger.Debug("rpe.generatePlatformRoutes invoked") |
| //Platform Routes --- Subscription Routes |
| //Subscription Manager -> E2 Termination |
| if rtmgr.PrsCfg == nil { |
| xapp.Logger.Info("No static routes configuration") |
| return |
| } |
| for _, routes := range *rtmgr.PrsCfg { |
| var sendEp *rtmgr.Endpoint |
| var Ep *rtmgr.Endpoint |
| switch routes.SenderEndPoint { |
| case "SUBMAN": |
| sendEp = subManEp |
| case "E2MAN": |
| sendEp = e2ManEp |
| //case "RSM":, |
| // sendEp = rsmEp |
| case "A1MEDIATOR": |
| sendEp = a1mediatorEp |
| } |
| switch routes.EndPoint { |
| case "SUBMAN": |
| Ep = subManEp |
| case "E2MAN": |
| Ep = e2ManEp |
| //case "UEMAN": |
| // Ep = ueManEp |
| //case "RSM": |
| // Ep = rsmEp |
| case "A1MEDIATOR": |
| Ep = a1mediatorEp |
| } |
| |
| r.addRoute(routes.MessageType, sendEp, Ep, routeTable, routes.SubscriptionId, routes.Meid) |
| } |
| |
| if len(e2TermEp) > 0 { |
| r.addRoute_rx_list("RIC_SCTP_CLEAR_ALL", e2ManEp, e2TermEp, routeTable, -1, "") |
| r.addRoute_rx_list("E2_TERM_KEEP_ALIVE_REQ", e2ManEp, e2TermEp, routeTable, -1, "") |
| r.addRoute_rx_list("RIC_E2_SETUP_RESP", e2ManEp, e2TermEp, routeTable, -1, "") |
| r.addRoute_rx_list("RIC_E2_SETUP_FAILURE", e2ManEp, e2TermEp, routeTable, -1, "") |
| } |
| } |
| |
| func (r *Rpe) generatePartialRouteTable(endPointList rtmgr.Endpoints, xappSubData *models.XappSubscriptionData, updatetype rtmgr.RMRUpdateType) *rtmgr.RouteTable { |
| xapp.Logger.Debug("rpe.generatePartialRouteTable invoked") |
| xapp.Logger.Debug("Endpoint List: %v", endPointList) |
| routeTable := &rtmgr.RouteTable{} |
| subManEp := getEndpointByName(&endPointList, "SUBMAN") |
| if subManEp == nil { |
| xapp.Logger.Error("Platform component not found: %v", "Subscription Manager") |
| xapp.Logger.Debug("Endpoints: %v", endPointList) |
| } |
| /*e2TermListEp := getEndpointListByName(&endPointList, "E2TERMINST") |
| if len(e2TermListEp) == 0 { |
| xapp.Logger.Error("Platform component not found: %v", "E2 Termination List") |
| xapp.Logger.Debug("Endpoints: %v", endPointList) |
| } |
| e2ManEp := getEndpointByName(&endPointList, "E2MAN") |
| if e2ManEp == nil { |
| xapp.Logger.Error("Platform component not found: %v", "E2 Manager") |
| xapp.Logger.Debug("Endpoints: %v", endPointList) |
| }*/ |
| |
| if xappSubData != nil && updatetype == rtmgr.SubsType { |
| xapp.Logger.Info("Updating partial subscription routes") |
| r.generatePartialSubscriptionTable(xappSubData, subManEp, routeTable) |
| } |
| /*if updatetype == rtmgr.XappType { |
| xapp.Logger.Info("Updating partial xapp routes") |
| for _, endPoint := range endPointList { |
| xapp.Logger.Debug("Endpoint: %v, xAppType: %v", endPoint.Name, endPoint.XAppType) |
| if endPoint.XAppType != sbi.PlatformType && (len(endPoint.TxMessages) > 0 || len(endPoint.RxMessages) > 0) { |
| r.generateXappRoutes(endPoint, subManEp, routeTable) |
| r.generateXappToXappRoutes(endPoint, endPointList, routeTable) |
| } |
| } |
| } |
| if updatetype == rtmgr.E2Type { |
| xapp.Logger.Info("Updating partial E2 routes") |
| if len(e2TermListEp) > 0 { |
| r.addRoute_rx_list("RIC_SCTP_CLEAR_ALL", e2ManEp, e2TermListEp, routeTable, -1, "") |
| r.addRoute_rx_list("E2_TERM_KEEP_ALIVE_REQ", e2ManEp, e2TermListEp, routeTable, -1, "") |
| r.addRoute_rx_list("RIC_E2_SETUP_RESP", e2ManEp, e2TermListEp, routeTable, -1, "") |
| r.addRoute_rx_list("RIC_E2_SETUP_FAILURE", e2ManEp, e2TermListEp, routeTable, -1, "") |
| } |
| }*/ |
| |
| return routeTable |
| |
| } |
| |
| func (r *Rpe) generateRouteTable(endPointList rtmgr.Endpoints) *rtmgr.RouteTable { |
| xapp.Logger.Debug("rpe.generateRouteTable invoked") |
| xapp.Logger.Debug("Endpoint List: %v", endPointList) |
| routeTable := &rtmgr.RouteTable{} |
| /*e2TermEp := getEndpointByName(&endPointList, "E2TERM") |
| if e2TermEp == nil { |
| xapp.Logger.Error("Platform component not found: %v", "E2 Termination") |
| xapp.Logger.Debug("Endpoints: %v", endPointList) |
| }*/ |
| subManEp := getEndpointByName(&endPointList, "SUBMAN") |
| if subManEp == nil { |
| xapp.Logger.Error("Platform component not found: %v", "Subscription Manager") |
| xapp.Logger.Debug("Endpoints: %v", endPointList) |
| } |
| e2ManEp := getEndpointByName(&endPointList, "E2MAN") |
| if e2ManEp == nil { |
| xapp.Logger.Error("Platform component not found: %v", "E2 Manager") |
| xapp.Logger.Debug("Endpoints: %v", endPointList) |
| } |
| /*rsmEp := getEndpointByName(&endPointList, "RSM") |
| if rsmEp == nil { |
| xapp.Logger.Error("Platform component not found: %v", "Resource Status Manager") |
| xapp.Logger.Debug("Endpoints: %v", endPointList) |
| }*/ |
| A1MediatorEp := getEndpointByName(&endPointList, "A1MEDIATOR") |
| if A1MediatorEp == nil { |
| xapp.Logger.Error("Platform component not found: %v", "A1Mediator") |
| xapp.Logger.Debug("Endpoints: %v", endPointList) |
| } |
| |
| e2TermListEp := getEndpointListByName(&endPointList, "E2TERMINST") |
| if len(e2TermListEp) == 0 { |
| xapp.Logger.Error("Platform component not found: %v", "E2 Termination List") |
| xapp.Logger.Debug("Endpoints: %v", endPointList) |
| } |
| r.generatePlatformRoutes(e2TermListEp, subManEp, e2ManEp, A1MediatorEp, routeTable) |
| |
| for _, endPoint := range endPointList { |
| xapp.Logger.Debug("Endpoint: %v, xAppType: %v", endPoint.Name, endPoint.XAppType) |
| if endPoint.XAppType != sbi.PlatformType && (len(endPoint.TxMessages) > 0 || len(endPoint.RxMessages) > 0) { |
| r.generateXappRoutes(endPoint, subManEp, routeTable) |
| r.generateSubscriptionRoutes(endPoint, subManEp, routeTable) |
| r.generateXappToXappRoutes(endPoint, endPointList, routeTable) |
| |
| } |
| } |
| return routeTable |
| } |