X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=pkg%2Frpe%2Frpe.go;h=e8daf6146d2c958d57e08c431491771367270508;hb=eb2ff0d217caf158dd15424bf70f8aa79c3742b1;hp=5dd8f4d250bf00383d57d7242db0e5fef40a1310;hpb=edd45717efffb32e407206a647f38579757f4908;p=ric-plt%2Frtmgr.git

diff --git a/pkg/rpe/rpe.go b/pkg/rpe/rpe.go
index 5dd8f4d..e8daf61 100644
--- a/pkg/rpe/rpe.go
+++ b/pkg/rpe/rpe.go
@@ -27,18 +27,12 @@ package rpe
 import (
 	"errors"
 	"routing-manager/pkg/rtmgr"
+	"routing-manager/pkg/sbi"
 	"strconv"
 )
 
 var (
 	SupportedRpes = []*RpeEngineConfig{
-		&RpeEngineConfig{
-			Name:        "rmrpub",
-			Version:     "pubsub",
-			Protocol:    "rmruta",
-			Instance:    NewRmrPub(),
-			IsAvailable: true,
-		},
 		&RpeEngineConfig{
 			Name:        "rmrpush",
 			Version:     "pubsush",
@@ -61,105 +55,6 @@ func GetRpe(rpeName string) (RpeEngine, error) {
 type Rpe struct {
 }
 
-/*
-Gets the raw xApp list and generates the list of sender endpoints and receiver endpoint groups
-Returns the Tx EndpointList map where the key is the messge type and also returns the nested map of Rx EndpointList's map where keys are message type and xapp type
-Endpoint object's message type already transcoded to integer id
-*/
-
-func (r *Rpe) getRouteRxTxLists(eps rtmgr.Endpoints) (*map[string]rtmgr.EndpointList, *map[string]map[string]rtmgr.EndpointList) {
-	txlist := make(map[string]rtmgr.EndpointList)
-	rxgroups := make(map[string]map[string]rtmgr.EndpointList)
-	for _, ep := range eps {
-		for _, message := range ep.RxMessages {
-			messageid := rtmgr.MESSAGETYPES[message]
-			if _, ok := rxgroups[messageid]; !ok {
-				rxgroups[messageid] = make(map[string]rtmgr.EndpointList)
-			}
-			rxgroups[messageid][ep.XAppType] = append(rxgroups[messageid][ep.XAppType], (*ep))
-		}
-		for _, message := range ep.TxMessages {
-			messageid := rtmgr.MESSAGETYPES[message]
-			txlist[messageid] = append(txlist[messageid], (*ep))
-		}
-	}
-	return &txlist, &rxgroups
-}
-
-/*
-Gets the raw xapp list and creates a route table for
-Returns the array of route table entries
-*/
-func (r *Rpe) getRouteTable(eps rtmgr.Endpoints) *rtmgr.RouteTable {
-	tx, rx := r.getRouteRxTxLists(eps)
-	var rt rtmgr.RouteTable
-	for _, messagetype := range rtmgr.MESSAGETYPES {
-		/*if _, ok := (*tx)[messagetype]; !ok {
-			continue
-		}
-		if _, ok := (*rx)[messagetype]; !ok {
-			continue
-		}*/
-		txList, ok := (*tx)[messagetype]
-		if !ok {
-			txList = rtmgr.EndpointList{}
-		}
-		var rxgroups []rtmgr.EndpointList
-		for _, endpointlist := range (*rx)[messagetype] {
-			rxgroups = append(rxgroups, endpointlist)
-		}
-		if len(txList) > 0 || len(rxgroups) > 0 {
-			rte := rtmgr.RouteTableEntry{
-				messagetype,
-				txList,
-				rxgroups,
-				-1,
-			}
-			rt = append(rt, rte)
-		}
-	}
-	r.addStaticRoutes(eps, &rt)
-	r.addSubscriptionRoutes(eps, &rt, &rtmgr.Subs)
-	return &rt
-}
-
-/*
-Adds specific static routes to the route table
-which cannot be calculated with endpoint tx/rx message types.
-*/
-func (r *Rpe) addStaticRoutes(eps rtmgr.Endpoints, rt *rtmgr.RouteTable) {
-	var uemanep, submanep *rtmgr.Endpoint
-	for _, ep := range eps {
-		if ep.Name == "UEMAN" {
-			uemanep = ep
-		}
-		if ep.Name == "SUBMAN" {
-			submanep = ep
-		}
-	}
-
-	if uemanep != nil && submanep != nil {
-		txlist := rtmgr.EndpointList{*uemanep}
-		rxlist := []rtmgr.EndpointList{[]rtmgr.Endpoint{*submanep}}
-		rte1 := rtmgr.RouteTableEntry{
-			rtmgr.MESSAGETYPES["RIC_SUB_REQ"],
-			txlist,
-			rxlist,
-			-1,
-		}
-		rte2 := rtmgr.RouteTableEntry{
-			rtmgr.MESSAGETYPES["RIC_SUB_DEL_REQ"],
-			txlist,
-			rxlist,
-			-1,
-		}
-		*rt = append(*rt, rte1)
-		*rt = append(*rt, rte2)
-	} else {
-		rtmgr.Logger.Warn("Cannot get the static route details of the platform components UEMAN/SUBMAN")
-	}
-}
-
 func getEndpointByName(eps *rtmgr.Endpoints, name string) *rtmgr.Endpoint {
 	for _, ep := range *eps {
 		if ep.Name == name {
@@ -171,8 +66,9 @@ func getEndpointByName(eps *rtmgr.Endpoints, name string) *rtmgr.Endpoint {
 	return nil
 }
 
-func getEndpointByUuid(eps *rtmgr.Endpoints, uuid string) *rtmgr.Endpoint {
-	for _, ep := range *eps {
+func getEndpointByUuid(uuid string) *rtmgr.Endpoint {
+	endPoints := rtmgr.Eps
+	for _, ep := range endPoints {
 		if ep.Uuid == uuid {
 			rtmgr.Logger.Debug("name: %s", ep.Uuid)
 			rtmgr.Logger.Debug("ep: %v", ep)
@@ -181,53 +77,139 @@ func getEndpointByUuid(eps *rtmgr.Endpoints, uuid string) *rtmgr.Endpoint {
 	}
 	return nil
 }
-func (r *Rpe) addSubscriptionRoutes(eps rtmgr.Endpoints, rt *rtmgr.RouteTable, subs *rtmgr.SubscriptionList) {
-	rtmgr.Logger.Debug("rpe.addSubscriptionRoutes invoked")
-	rtmgr.Logger.Debug("params: %v", eps)
-	var e2termep, submanep, xappEp *rtmgr.Endpoint
-	var xappName string
-	e2termep = getEndpointByName(&eps, "E2TERM")
-	submanep = getEndpointByName(&eps, "SUBMAN")
-	if e2termep != nil && submanep != nil {
-		// looping through the subscription list, add routes one by one
-		for _, sub := range *subs {
-			// SubMan -> XApp
-			xappName = sub.Fqdn + ":" + strconv.Itoa(int(sub.Port))
-			xappEp = getEndpointByUuid(&eps, xappName)
-			if xappEp == nil {
-				rtmgr.Logger.Error("XApp not found: %s", xappName)
-				rtmgr.Logger.Debug("Endpoints: %v", eps)
-			} else {
-				txlist := rtmgr.EndpointList{*submanep}
-				rxlist := []rtmgr.EndpointList{[]rtmgr.Endpoint{*xappEp}}
-				subManMsgs := []string{"RIC_SUB_RESP", "RIC_SUB_FAILURE", "RIC_SUB_DEL_RESP", "RIC_SUB_DEL_FAILURE"}
-				for _, entry := range subManMsgs {
-					rte := rtmgr.RouteTableEntry{
-						rtmgr.MESSAGETYPES[entry],
-						txlist,
-						rxlist,
-						sub.SubID,
-					}
-					*rt = append(*rt, rte)
-				}
-				// E2Term -> XApp
-				txlist = rtmgr.EndpointList{*e2termep}
-				rxlist = []rtmgr.EndpointList{[]rtmgr.Endpoint{*xappEp}}
-				e2apMsgs := []string{"RIC_CONTROL_ACK", "RIC_CONTROL_FAILURE", "RIC_INDICATION"}
-				for _, entry := range e2apMsgs {
-					rte := rtmgr.RouteTableEntry{
-						rtmgr.MESSAGETYPES[entry],
-						txlist,
-						rxlist,
-						sub.SubID,
-					}
-					*rt = append(*rt, rte)
-				}
-			}
+
+func (r *Rpe) addRoute(messageType string, tx *rtmgr.Endpoint, rx *rtmgr.Endpoint, routeTable *rtmgr.RouteTable) {
+	txList := rtmgr.EndpointList{*tx}
+	rxList := []rtmgr.EndpointList{[]rtmgr.Endpoint{*rx}}
+	messageId := rtmgr.MESSAGETYPES[messageType]
+	route := rtmgr.RouteTableEntry{
+		messageId,
+		txList,
+		rxList,
+		-1}
+	*routeTable = append(*routeTable, route)
+	rtmgr.Logger.Debug("Route added: MessageTyp: %v, Tx: %v, Rx: %v, SubId: -1", messageId, txList, rxList)
+}
+
+func (r *Rpe) addSubscriptionRoute(messageType string, tx *rtmgr.Endpoint, rx *rtmgr.Endpoint, routeTable *rtmgr.RouteTable, subId int32) {
+	txList := rtmgr.EndpointList{*tx}
+	rxList := []rtmgr.EndpointList{[]rtmgr.Endpoint{*rx}}
+	messageId := rtmgr.MESSAGETYPES[messageType]
+	route := rtmgr.RouteTableEntry{
+		messageId,
+		txList,
+		rxList,
+		subId,
+	}
+	*routeTable = append(*routeTable, route)
+	rtmgr.Logger.Debug("Route added: MessageTyp: %v, Tx: %v, Rx: %v, SubId: %v", messageId, txList, rxList, subId)
+}
+
+func (r *Rpe) generateXappRoutes(e2TermEp *rtmgr.Endpoint, subManEp *rtmgr.Endpoint, routeTable *rtmgr.RouteTable) {
+	rtmgr.Logger.Debug("rpe.generateXappRoutes invoked")
+	endPointList := rtmgr.Eps
+	for _, endPoint := range endPointList {
+		rtmgr.Logger.Debug("Endpoint: %v, xAppType: %v", endPoint.Name, endPoint.XAppType)
+		if endPoint.XAppType != sbi.PLATFORMTYPE && len(endPoint.TxMessages) > 0 && len(endPoint.RxMessages) > 0 {
+			//xApp -> Subscription Manager
+			r.addRoute("RIC_SUB_REQ", endPoint, subManEp, routeTable)
+			r.addRoute("RIC_SUB_DEL_REQ", endPoint, subManEp, routeTable)
+			//xApp -> E2 Termination
+			r.addRoute("RIC_CONTROL_REQ", endPoint, e2TermEp, routeTable)
 		}
-		rtmgr.Logger.Debug("addSubscriptionRoutes eps: %v", eps)
-	} else {
-		rtmgr.Logger.Warn("Subscription route update failure: Cannot get the static route details of the platform components E2TERM/SUBMAN")
 	}
+}
 
+func (r *Rpe) generateSubscriptionRoutes(e2TermEp *rtmgr.Endpoint, subManEp *rtmgr.Endpoint, routeTable *rtmgr.RouteTable) {
+	rtmgr.Logger.Debug("rpe.addSubscriptionRoutes invoked")
+	subscriptionList := rtmgr.Subs
+	for _, subscription := range subscriptionList {
+		rtmgr.Logger.Debug("Subscription: %v", subscription)
+		xAppUuid := subscription.Fqdn + ":" + strconv.Itoa(int(subscription.Port))
+		rtmgr.Logger.Debug("xApp UUID: %v", xAppUuid)
+		xAppEp := getEndpointByUuid(xAppUuid)
+		//Subscription Manager -> xApp
+		r.addSubscriptionRoute("RIC_SUB_RESP", subManEp, xAppEp, routeTable, subscription.SubID)
+		r.addSubscriptionRoute("RIC_SUB_FAILURE", subManEp, xAppEp, routeTable, subscription.SubID)
+		r.addSubscriptionRoute("RIC_SUB_DEL_RESP", subManEp, xAppEp, routeTable, subscription.SubID)
+		r.addSubscriptionRoute("RIC_SUB_DEL_FAILURE", subManEp, xAppEp, routeTable, subscription.SubID)
+		//E2 Termination -> xApp
+		r.addSubscriptionRoute("RIC_INDICATION", e2TermEp, xAppEp, routeTable, subscription.SubID)
+		r.addSubscriptionRoute("RIC_CONTROL_ACK", e2TermEp, xAppEp, routeTable, subscription.SubID)
+		r.addSubscriptionRoute("RIC_CONTROL_FAILURE", e2TermEp, xAppEp, routeTable, subscription.SubID)
+	}
+}
+
+func (r *Rpe) generatePlatformRoutes(e2TermEp *rtmgr.Endpoint, subManEp *rtmgr.Endpoint, e2ManEp *rtmgr.Endpoint, ueManEp *rtmgr.Endpoint, routeTable *rtmgr.RouteTable) {
+	rtmgr.Logger.Debug("rpe.generatePlatformRoutes invoked")
+	//Platform Routes --- Subscription Routes
+	//Subscription Manager -> E2 Termination
+	r.addRoute("RIC_SUB_REQ", subManEp, e2TermEp, routeTable)
+	r.addRoute("RIC_SUB_DEL_REQ", subManEp, e2TermEp, routeTable)
+	//E2 Termination -> Subscription Manager
+	r.addRoute("RIC_SUB_RESP", e2TermEp, subManEp, routeTable)
+	r.addRoute("RIC_SUB_DEL_RESP", e2TermEp, subManEp, routeTable)
+	r.addRoute("RIC_SUB_FAILURE", e2TermEp, subManEp, routeTable)
+	r.addRoute("RIC_SUB_DEL_FAILURE", e2TermEp, subManEp, routeTable)
+	//TODO: UE Man Routes removed (since it is not existing)
+	//UE Manager -> Subscription Manager
+	//r.addRoute("RIC_SUB_REQ", ueManEp, subManEp, routeTable)
+	//r.addRoute("RIC_SUB_DEL_REQ", ueManEp, subManEp, routeTable)
+	////UE Manager -> E2 Termination
+	//r.addRoute("RIC_CONTROL_REQ", ueManEp, e2TermEp, routeTable)
+
+	//Platform Routes --- X2 Routes
+	//E2 Manager -> E2 Termination
+	r.addRoute("RIC_X2_SETUP_REQ", e2ManEp, e2TermEp, routeTable)
+	r.addRoute("RIC_X2_SETUP_RESP", e2ManEp, e2TermEp, routeTable)
+	r.addRoute("RIC_X2_SETUP_FAILURE", e2ManEp, e2TermEp, routeTable)
+	r.addRoute("RIC_X2_RESET_RESP", e2ManEp, e2TermEp, routeTable)
+	r.addRoute("RIC_ENDC_X2_SETUP_REQ", e2ManEp, e2TermEp, routeTable)
+	r.addRoute("RIC_ENDC_X2_SETUP_RESP", e2ManEp, e2TermEp, routeTable)
+	r.addRoute("RIC_ENDC_X2_SETUP_FAILURE", e2ManEp, e2TermEp, routeTable)
+	//E2 Termination -> E2 Manager
+	r.addRoute("RIC_X2_SETUP_REQ", e2TermEp, e2ManEp, routeTable)
+	r.addRoute("RIC_X2_SETUP_RESP", e2TermEp, e2ManEp, routeTable)
+	r.addRoute("RIC_X2_RESET", e2TermEp, e2ManEp, routeTable)
+	r.addRoute("RIC_X2_RESOURCE_STATUS_RESPONSE", e2TermEp, e2ManEp, routeTable)
+	r.addRoute("RIC_X2_RESET_RESP", e2TermEp, e2ManEp, routeTable)
+	r.addRoute("RIC_ENDC_X2_SETUP_REQ", e2ManEp, e2TermEp, routeTable)
+	r.addRoute("RIC_ENDC_X2_SETUP_RESP", e2ManEp, e2TermEp, routeTable)
+	r.addRoute("RIC_ENDC_X2_SETUP_FAILURE", e2ManEp, e2TermEp, routeTable)
+}
+
+func (r *Rpe) generateRouteTable(endPointList rtmgr.Endpoints) *rtmgr.RouteTable {
+	rtmgr.Logger.Debug("rpe.generateRouteTable invoked")
+	rtmgr.Logger.Debug("Endpoint List:  %v", endPointList)
+	routeTable := &rtmgr.RouteTable{}
+	e2TermEp := getEndpointByName(&endPointList, "E2TERM")
+	if e2TermEp == nil {
+		rtmgr.Logger.Error("Platform component not found: %v", "E2 Termination")
+		rtmgr.Logger.Debug("Endpoints: %v", endPointList)
+	}
+	subManEp := getEndpointByName(&endPointList, "SUBMAN")
+	if subManEp == nil {
+		rtmgr.Logger.Error("Platform component not found: %v", "Subscription Manager")
+		rtmgr.Logger.Debug("Endpoints: %v", endPointList)
+	}
+	e2ManEp := getEndpointByName(&endPointList, "E2MAN")
+	if e2ManEp == nil {
+		rtmgr.Logger.Error("Platform component not found: %v", "E2 Manager")
+		rtmgr.Logger.Debug("Endpoints: %v", endPointList)
+	}
+	ueManEp := getEndpointByName(&endPointList, "UEMAN")
+	if ueManEp == nil {
+		rtmgr.Logger.Error("Platform component not found: %v", "UE Manger")
+		rtmgr.Logger.Debug("Endpoints: %v", endPointList)
+	}
+	r.generatePlatformRoutes(e2TermEp, subManEp, e2ManEp, ueManEp, routeTable)
+
+	for _, endPoint := range endPointList {
+		rtmgr.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(e2TermEp, subManEp, routeTable)
+			r.generateSubscriptionRoutes(e2TermEp, subManEp, routeTable)
+		}
+	}
+	return routeTable
 }