2 ==================================================================================
3 Copyright (c) 2019 AT&T Intellectual Property.
4 Copyright (c) 2019 Nokia
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
10 http://www.apache.org/licenses/LICENSE-2.0
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.
19 This source code is part of the near-RT RIC (RAN Intelligent Controller)
20 platform project (RICP).
22 ==================================================================================
25 Mnemonic: httprestful.go
26 Abstract: HTTP Restful API NBI implementation
27 Based on Swagger generated code
33 //noinspection GoUnresolvedReference,GoUnresolvedReference,GoUnresolvedReference,GoUnresolvedReference,GoUnresolvedReference,GoUnresolvedReference
38 xfmodel "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/models"
39 "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
40 "github.com/go-openapi/loads"
41 "github.com/go-openapi/runtime/middleware"
45 "routing-manager/pkg/models"
46 "routing-manager/pkg/restapi"
47 "routing-manager/pkg/restapi/operations"
48 "routing-manager/pkg/restapi/operations/debug"
49 "routing-manager/pkg/restapi/operations/handle"
50 "routing-manager/pkg/rpe"
51 "routing-manager/pkg/rtmgr"
52 "routing-manager/pkg/sdl"
59 type HttpRestful struct {
61 LaunchRest LaunchRestHandler
62 RetrieveStartupData RetrieveStartupDataHandler
65 func NewHttpRestful() *HttpRestful {
66 instance := new(HttpRestful)
67 instance.LaunchRest = launchRest
68 instance.RetrieveStartupData = retrieveStartupData
72 func recvXappCallbackData(xappData *models.XappCallbackData) (*[]rtmgr.XApp, error) {
74 var xapps []rtmgr.XApp
75 err := json.Unmarshal([]byte(xappData.XApps), &xapps)
78 xapp.Logger.Info("No data")
81 xapp.Logger.Debug("Nothing received on the Http interface")
85 func recvNewE2Tdata(e2tData *models.E2tData) (*rtmgr.E2TInstance, string, error) {
87 xapp.Logger.Info("data received")
91 e2tinst := rtmgr.E2TInstance{
92 Ranlist: make([]string, len(e2tData.RanNamelist)),
95 e2tinst.Fqdn = *e2tData.E2TAddress
96 e2tinst.Name = "E2TERMINST"
97 copy(e2tinst.Ranlist, e2tData.RanNamelist)
98 if len(e2tData.RanNamelist) > 0 {
100 for _, meid := range e2tData.RanNamelist {
103 str = "mme_ar|" + *e2tData.E2TAddress + "|" + strings.TrimSuffix(meidar, " ")
105 return &e2tinst, str, nil
108 xapp.Logger.Info("No data")
111 xapp.Logger.Debug("Nothing received on the Http interface")
115 func validateXappCallbackData(callbackData *models.XappCallbackData) error {
116 if len(callbackData.XApps) == 0 {
117 return fmt.Errorf("invalid Data field: \"%s\"", callbackData.XApps)
119 var xapps []rtmgr.XApp
120 err := json.Unmarshal([]byte(callbackData.XApps), &xapps)
122 return fmt.Errorf("unmarshal failed: \"%s\"", err.Error())
127 func provideXappHandleHandlerImpl(data *models.XappCallbackData) error {
129 xapp.Logger.Debug("Received callback data")
132 err := validateXappCallbackData(data)
134 xapp.Logger.Warn("XApp callback data validation failed: " + err.Error())
137 appdata, err := recvXappCallbackData(data)
139 xapp.Logger.Error("cannot get data from rest api dute to: " + err.Error())
140 } else if appdata != nil {
141 xapp.Logger.Debug("Fetching all xApps deployed in xApp Manager through GET operation.")
142 alldata, err1 := httpGetXApps(xapp.Config.GetString("xmurl"))
143 if alldata != nil && err1 == nil {
145 sdlEngine.WriteXApps(xapp.Config.GetString("rtfile"), alldata)
147 return sendRoutesToAll()
155 func validateXappSubscriptionData(data *models.XappSubscriptionData) error {
156 var err = fmt.Errorf("XApp instance not found: %v:%v", *data.Address, *data.Port)
157 for _, ep := range rtmgr.Eps {
158 if ep.Ip == *data.Address && ep.Port == *data.Port {
166 func validateE2tData(data *models.E2tData) (error, bool) {
168 e2taddress_key := *data.E2TAddress
169 if e2taddress_key == "" {
170 return fmt.Errorf("E2TAddress is empty!!!"), false
172 stringSlice := strings.Split(e2taddress_key, ":")
173 if len(stringSlice) == 1 {
174 return fmt.Errorf("E2T E2TAddress is not a proper format like ip:port, %v", e2taddress_key), false
177 _, err := net.LookupIP(stringSlice[0])
179 return fmt.Errorf("E2T E2TAddress DNS look up failed, E2TAddress: %v", stringSlice[0]), false
182 if checkValidaE2TAddress(e2taddress_key) {
183 return fmt.Errorf("E2TAddress already exist!!!, E2TAddress: %v", e2taddress_key), true
189 func validateDeleteE2tData(data *models.E2tDeleteData) error {
191 if *data.E2TAddress == "" {
192 return fmt.Errorf("E2TAddress is empty!!!")
195 for _, element := range data.RanAssocList {
196 e2taddress_key := *element.E2TAddress
197 stringSlice := strings.Split(e2taddress_key, ":")
199 if len(stringSlice) == 1 {
200 return fmt.Errorf("E2T Delete - RanAssocList E2TAddress is not a proper format like ip:port, %v", e2taddress_key)
203 if !checkValidaE2TAddress(e2taddress_key) {
204 return fmt.Errorf("E2TAddress doesn't exist!!!, E2TAddress: %v", e2taddress_key)
211 func checkValidaE2TAddress(e2taddress string) bool {
213 _, exist := rtmgr.Eps[e2taddress]
218 func provideXappSubscriptionHandleImpl(data *models.XappSubscriptionData) error {
219 xapp.Logger.Debug("Invoked provideXappSubscriptionHandleImpl")
220 err := validateXappSubscriptionData(data)
222 xapp.Logger.Error(err.Error())
225 xapp.Logger.Debug("received XApp subscription data")
226 addSubscription(&rtmgr.Subs, data)
227 xapp.Logger.Debug("Endpoints: %v", rtmgr.Eps)
228 return sendRoutesToAll()
231 func subscriptionExists(data *models.XappSubscriptionData) bool {
233 sub := rtmgr.Subscription{SubID: *data.SubscriptionID, Fqdn: *data.Address, Port: *data.Port}
234 for _, elem := range rtmgr.Subs {
243 func deleteXappSubscriptionHandleImpl(data *models.XappSubscriptionData) error {
244 xapp.Logger.Debug("Invoked deleteXappSubscriptionHandleImpl")
245 err := validateXappSubscriptionData(data)
247 xapp.Logger.Error(err.Error())
251 if !subscriptionExists(data) {
252 xapp.Logger.Warn("subscription not found: %d", *data.SubscriptionID)
253 err := fmt.Errorf("subscription not found: %d", *data.SubscriptionID)
257 xapp.Logger.Debug("received XApp subscription delete data")
258 delSubscription(&rtmgr.Subs, data)
259 return sendRoutesToAll()
263 func updateXappSubscriptionHandleImpl(data *models.XappList, subid uint16) error {
264 xapp.Logger.Debug("Invoked updateXappSubscriptionHandleImpl")
266 var fqdnlist []rtmgr.FqDn
267 for _, item := range *data {
268 fqdnlist = append(fqdnlist, rtmgr.FqDn(*item))
270 xapplist := rtmgr.XappList{SubscriptionID: subid, FqdnList: fqdnlist}
271 var subdata models.XappSubscriptionData
274 subdata.SubscriptionID = &id
275 for _, items := range fqdnlist {
276 subdata.Address = items.Address
277 subdata.Port = items.Port
278 err := validateXappSubscriptionData(&subdata)
280 xapp.Logger.Error(err.Error())
284 xapp.Logger.Debug("received XApp subscription Merge data")
285 updateSubscription(&xapplist)
286 return sendRoutesToAll()
289 func createNewE2tHandleHandlerImpl(data *models.E2tData) error {
290 xapp.Logger.Debug("Invoked createNewE2tHandleHandlerImpl")
291 err, IsDuplicate := validateE2tData(data)
292 if IsDuplicate == true {
293 return sendRoutesToAll()
297 xapp.Logger.Error(err.Error())
301 e2data, meiddata, _ := recvNewE2Tdata(data)
302 xapp.Logger.Debug("received create New E2T data")
304 sdlEngine.WriteNewE2TInstance(xapp.Config.GetString("rtfile"), e2data, meiddata)
306 return sendRoutesToAll()
310 func validateE2TAddressRANListData(assRanE2tData models.RanE2tMap) error {
312 xapp.Logger.Debug("Invoked.validateE2TAddressRANListData : %v", assRanE2tData)
314 for _, element := range assRanE2tData {
315 if *element.E2TAddress == "" {
316 return fmt.Errorf("E2T Instance - E2TAddress is empty!!!")
319 e2taddress_key := *element.E2TAddress
320 if !checkValidaE2TAddress(e2taddress_key) {
321 return fmt.Errorf("E2TAddress doesn't exist!!!, E2TAddress: %v", e2taddress_key)
328 func associateRanToE2THandlerImpl(data models.RanE2tMap) error {
329 xapp.Logger.Debug("Invoked associateRanToE2THandlerImpl")
330 err := validateE2TAddressRANListData(data)
332 xapp.Logger.Warn(" Association of RAN to E2T Instance data validation failed: " + err.Error())
335 xapp.Logger.Debug("received associate RAN list to E2T instance mapping from E2 Manager")
337 sdlEngine.WriteAssRANToE2TInstance(xapp.Config.GetString("rtfile"), data)
339 return sendRoutesToAll()
343 func disassociateRanToE2THandlerImpl(data models.RanE2tMap) error {
344 xapp.Logger.Debug("Invoked disassociateRanToE2THandlerImpl")
345 err := validateE2TAddressRANListData(data)
347 xapp.Logger.Warn(" Disassociation of RAN List from E2T Instance data validation failed: " + err.Error())
350 xapp.Logger.Debug("received disassociate RANs from E2T instance")
352 sdlEngine.WriteDisAssRANFromE2TInstance(xapp.Config.GetString("rtfile"), data)
354 return sendRoutesToAll()
358 func deleteE2tHandleHandlerImpl(data *models.E2tDeleteData) error {
359 xapp.Logger.Debug("Invoked deleteE2tHandleHandlerImpl")
361 err := validateDeleteE2tData(data)
363 xapp.Logger.Error(err.Error())
367 sdlEngine.WriteDeleteE2TInstance(xapp.Config.GetString("rtfile"), data)
369 return sendRoutesToAll()
373 func dumpDebugData() (models.Debuginfo, error) {
374 var response models.Debuginfo
375 sdlEngine, _ := sdl.GetSdl("file")
376 rpeEngine, _ := rpe.GetRpe("rmrpush")
377 data, err := sdlEngine.ReadAll(xapp.Config.GetString("rtfile"))
380 xapp.Logger.Error("Cannot get data from sdl interface due to: " + err.Error())
383 xapp.Logger.Debug("Cannot get data from sdl interface")
384 return response, errors.New("Cannot get data from sdl interface")
387 response.RouteTable = *rpeEngine.GeneratePolicies(rtmgr.Eps, data)
389 prettyJSON, err := json.MarshalIndent(data, "", "")
390 response.RouteConfigs = string(prettyJSON)
395 func launchRest(nbiif *string) {
396 swaggerSpec, err := loads.Embedded(restapi.SwaggerJSON, restapi.FlatSwaggerJSON)
399 xapp.Logger.Error(err.Error())
402 nbiUrl, err := url.Parse(*nbiif)
404 xapp.Logger.Error(err.Error())
407 api := operations.NewRoutingManagerAPI(swaggerSpec)
408 server := restapi.NewServer(api)
409 defer server.Shutdown()
411 server.Port, err = strconv.Atoi(nbiUrl.Port())
413 xapp.Logger.Error("Invalid NBI RestAPI port")
416 server.Host = "0.0.0.0"
418 api.HandleProvideXappHandleHandler = handle.ProvideXappHandleHandlerFunc(
419 func(params handle.ProvideXappHandleParams) middleware.Responder {
420 xapp.Logger.Info("Data received on Http interface")
421 err := provideXappHandleHandlerImpl(params.XappCallbackData)
423 xapp.Logger.Error("RoutingManager->AppManager request Failed: " + err.Error())
424 return handle.NewProvideXappHandleBadRequest()
426 xapp.Logger.Info("RoutingManager->AppManager request Success")
427 return handle.NewGetHandlesOK()
430 api.HandleProvideXappSubscriptionHandleHandler = handle.ProvideXappSubscriptionHandleHandlerFunc(
431 func(params handle.ProvideXappSubscriptionHandleParams) middleware.Responder {
432 err := provideXappSubscriptionHandleImpl(params.XappSubscriptionData)
434 xapp.Logger.Error("RoutingManager->SubManager Add Request Failed: " + err.Error())
435 return handle.NewProvideXappSubscriptionHandleBadRequest()
437 xapp.Logger.Info("RoutingManager->SubManager Add Request Success, subid = %v, requestor = %v", *params.XappSubscriptionData.SubscriptionID, *params.XappSubscriptionData.Address)
438 return handle.NewGetHandlesOK()
441 api.HandleDeleteXappSubscriptionHandleHandler = handle.DeleteXappSubscriptionHandleHandlerFunc(
442 func(params handle.DeleteXappSubscriptionHandleParams) middleware.Responder {
443 err := deleteXappSubscriptionHandleImpl(params.XappSubscriptionData)
445 xapp.Logger.Error("RoutingManager->SubManager Delete Request Failed: " + err.Error())
446 return handle.NewDeleteXappSubscriptionHandleNoContent()
448 xapp.Logger.Info("RoutingManager->SubManager Delete Request Success, subid = %v, requestor = %v", *params.XappSubscriptionData.SubscriptionID, *params.XappSubscriptionData.Address)
449 return handle.NewGetHandlesOK()
452 api.HandleUpdateXappSubscriptionHandleHandler = handle.UpdateXappSubscriptionHandleHandlerFunc(
453 func(params handle.UpdateXappSubscriptionHandleParams) middleware.Responder {
454 err := updateXappSubscriptionHandleImpl(¶ms.XappList, params.SubscriptionID)
456 return handle.NewUpdateXappSubscriptionHandleBadRequest()
458 return handle.NewUpdateXappSubscriptionHandleCreated()
461 api.HandleCreateNewE2tHandleHandler = handle.CreateNewE2tHandleHandlerFunc(
462 func(params handle.CreateNewE2tHandleParams) middleware.Responder {
463 err := createNewE2tHandleHandlerImpl(params.E2tData)
465 xapp.Logger.Error("RoutingManager->E2Manager AddE2T Request Failed: " + err.Error())
466 return handle.NewCreateNewE2tHandleBadRequest()
468 xapp.Logger.Info("RoutingManager->E2Manager AddE2T Request Success, E2T = %v", *params.E2tData.E2TAddress)
469 return handle.NewCreateNewE2tHandleCreated()
473 api.HandleAssociateRanToE2tHandleHandler = handle.AssociateRanToE2tHandleHandlerFunc(
474 func(params handle.AssociateRanToE2tHandleParams) middleware.Responder {
475 err := associateRanToE2THandlerImpl(params.RanE2tList)
477 xapp.Logger.Error("RoutingManager->E2Manager associateRanToE2T Request Failed: " + err.Error())
478 return handle.NewAssociateRanToE2tHandleBadRequest()
480 xapp.Logger.Info("RoutingManager->E2Manager associateRanToE2T Request Success, E2T = %v", params.RanE2tList)
481 return handle.NewAssociateRanToE2tHandleCreated()
485 api.HandleDissociateRanHandler = handle.DissociateRanHandlerFunc(
486 func(params handle.DissociateRanParams) middleware.Responder {
487 err := disassociateRanToE2THandlerImpl(params.DissociateList)
489 xapp.Logger.Error("RoutingManager->E2Manager DisassociateRanToE2T Request Failed: " + err.Error())
490 return handle.NewDissociateRanBadRequest()
492 xapp.Logger.Info("RoutingManager->E2Manager DisiassociateRanToE2T Request Success, E2T = %v", params.DissociateList)
493 return handle.NewDissociateRanCreated()
497 api.HandleDeleteE2tHandleHandler = handle.DeleteE2tHandleHandlerFunc(
498 func(params handle.DeleteE2tHandleParams) middleware.Responder {
499 err := deleteE2tHandleHandlerImpl(params.E2tData)
501 xapp.Logger.Error("RoutingManager->E2Manager DeleteE2T Request Failed: " + err.Error())
502 return handle.NewDeleteE2tHandleBadRequest()
504 xapp.Logger.Info("RoutingManager->E2Manager DeleteE2T Request Success, E2T = %v", *params.E2tData.E2TAddress)
505 return handle.NewDeleteE2tHandleCreated()
508 api.DebugGetDebuginfoHandler = debug.GetDebuginfoHandlerFunc(
509 func(params debug.GetDebuginfoParams) middleware.Responder {
510 response, err := dumpDebugData()
512 return debug.NewGetDebuginfoCreated()
514 return debug.NewGetDebuginfoOK().WithPayload(&response)
517 api.HandleAddRmrRouteHandler = handle.AddRmrRouteHandlerFunc(
518 func(params handle.AddRmrRouteParams) middleware.Responder {
519 err := adddelrmrroute(params.RoutesList, true)
521 return handle.NewAddRmrRouteBadRequest()
523 return handle.NewAddRmrRouteCreated()
527 api.HandleDelRmrRouteHandler = handle.DelRmrRouteHandlerFunc(
528 func(params handle.DelRmrRouteParams) middleware.Responder {
529 err := adddelrmrroute(params.RoutesList, false)
531 return handle.NewDelRmrRouteBadRequest()
533 return handle.NewDelRmrRouteCreated()
537 // start to serve API
538 xapp.Logger.Info("Starting the HTTP Rest service")
539 if err := server.Serve(); err != nil {
540 xapp.Logger.Error(err.Error())
544 func httpGetXApps(xmurl string) (*[]rtmgr.XApp, error) {
545 xapp.Logger.Info("Invoked httprestful.httpGetXApps: " + xmurl)
546 r, err := myClient.Get(xmurl)
552 if r.StatusCode == 200 {
553 xapp.Logger.Debug("http client raw response: %v", r)
554 var xapps []rtmgr.XApp
555 err = json.NewDecoder(r.Body).Decode(&xapps)
557 xapp.Logger.Warn("Json decode failed: " + err.Error())
559 xapp.Logger.Info("HTTP GET: OK")
560 xapp.Logger.Debug("httprestful.httpGetXApps returns: %v", xapps)
563 xapp.Logger.Warn("httprestful got an unexpected http status code: %v", r.StatusCode)
567 func httpGetE2TList(e2murl string) (*[]rtmgr.E2tIdentity, error) {
568 xapp.Logger.Info("Invoked httprestful.httpGetE2TList: " + e2murl)
569 r, err := myClient.Get(e2murl)
575 if r.StatusCode == 200 {
576 xapp.Logger.Debug("http client raw response: %v", r)
577 var E2Tlist []rtmgr.E2tIdentity
578 err = json.NewDecoder(r.Body).Decode(&E2Tlist)
580 xapp.Logger.Warn("Json decode failed: " + err.Error())
582 xapp.Logger.Info("HTTP GET: OK")
583 xapp.Logger.Debug("httprestful.httpGetXApps returns: %v", E2Tlist)
586 xapp.Logger.Warn("httprestful got an unexpected http status code: %v", r.StatusCode)
590 func PopulateE2TMap(e2tDataList *[]rtmgr.E2tIdentity, e2ts map[string]rtmgr.E2TInstance, meids []string) {
591 xapp.Logger.Info("Invoked httprestful.PopulateE2TMap ")
593 for _, e2tData := range *e2tDataList {
596 e2tinst := rtmgr.E2TInstance{
597 Ranlist: make([]string, len(e2tData.Rannames)),
600 e2tinst.Fqdn = e2tData.E2taddress
601 e2tinst.Name = "E2TERMINST"
602 copy(e2tinst.Ranlist, e2tData.Rannames)
604 if len(e2tData.Rannames) > 0 {
606 for _, meid := range e2tData.Rannames {
609 str += "mme_ar|" + e2tData.E2taddress + "|" + strings.TrimSuffix(meidar, " ")
612 e2ts[e2tinst.Fqdn] = e2tinst
613 meids = append(meids, str)
617 func retrieveStartupData(xmurl string, nbiif string, fileName string, configfile string, e2murl string, sdlEngine sdl.Engine) error {
618 xapp.Logger.Info("Invoked retrieveStartupData ")
622 var xappData *[]rtmgr.XApp
623 xappData = new([]rtmgr.XApp)
624 xapp.Logger.Info("Trying to fetch XApps data from XAPP manager")
625 for i := 1; i <= maxRetries; i++ {
626 time.Sleep(2 * time.Second)
629 xappData, err = httpGetXApps(xmurl)
630 if xappData != nil && err == nil {
632 } else if err == nil {
633 readErr = errors.New("unexpected HTTP status code")
635 xapp.Logger.Warn("cannot get xapp data due to: " + err.Error())
645 e2ts := make(map[string]rtmgr.E2TInstance)
646 xapp.Logger.Info("Trying to fetch E2T data from E2manager")
647 for i := 1; i <= maxRetries; i++ {
650 e2tDataList, err := httpGetE2TList(e2murl)
651 if e2tDataList != nil && err == nil {
652 PopulateE2TMap(e2tDataList, e2ts, meids[:])
654 } else if err == nil {
655 readErr = errors.New("unexpected HTTP status code")
657 xapp.Logger.Warn("cannot get E2T data from E2M due to: " + err.Error())
660 time.Sleep(2 * time.Second)
667 pcData, confErr := rtmgr.GetPlatformComponents(configfile)
669 xapp.Logger.Error(confErr.Error())
672 xapp.Logger.Info("Recieved intial xapp data, E2T data and platform data, writing into SDL.")
673 // Combine the xapps data and platform data before writing to the SDL
674 ricData := &rtmgr.RicComponents{XApps: *xappData, Pcs: *pcData, E2Ts: e2ts, MeidMap: meids}
675 writeErr := sdlEngine.WriteAll(fileName, ricData)
677 xapp.Logger.Error(writeErr.Error())
680 xapp.Logger.Info("Trying to fetch Subscriptions data from Subscription manager")
681 for i := 1; i <= maxRetries; i++ {
683 sub_list, err := xapp.Subscription.QuerySubscriptions()
685 if sub_list != nil && err == nil {
686 PopulateSubscription(sub_list)
690 xapp.Logger.Warn("cannot get xapp data due to: " + readErr.Error())
692 time.Sleep(2 * time.Second)
699 // post subscription req to appmgr
700 readErr = PostSubReq(xmurl, nbiif)
705 //rlist := make(map[string]string)
706 xapp.Logger.Info("Reading SDL for any routes")
707 rlist, sdlerr := xapp.Sdl.Read("routes")
710 xapp.Logger.Info("Value is %s", rlist["routes"])
711 if rlist["routes"] != nil {
712 formstring := fmt.Sprintf("%s", rlist["routes"])
713 xapp.Logger.Info("Value of formed string = %s", formstring)
714 newstring := strings.Split(formstring, " ")
715 for i, _ := range newstring {
716 xapp.Logger.Info("in Loop Value of formed string = %s", newstring)
717 rtmgr.DynamicRouteList = append(rtmgr.DynamicRouteList, newstring[i])
727 func (r *HttpRestful) Initialize(xmurl string, nbiif string, fileName string, configfile string, e2murl string,
728 sdlEngine sdl.Engine, rpeEngine rpe.Engine, m *sync.Mutex) error {
729 err := r.RetrieveStartupData(xmurl, nbiif, fileName, configfile, e2murl, sdlEngine)
731 xapp.Logger.Error("Exiting as nbi failed to get the initial startup data from the xapp manager: " + err.Error())
741 func (r *HttpRestful) Terminate() error {
745 func addSubscription(subs *rtmgr.SubscriptionList, xappSubData *models.XappSubscriptionData) bool {
746 xapp.Logger.Debug("Adding the subscription into the subscriptions list")
748 sub := rtmgr.Subscription{SubID: *xappSubData.SubscriptionID, Fqdn: *xappSubData.Address, Port: *xappSubData.Port}
749 for _, elem := range *subs {
751 xapp.Logger.Warn("rtmgr.addSubscription: Subscription already present: %v", elem)
756 *subs = append(*subs, sub)
761 func delSubscription(subs *rtmgr.SubscriptionList, xappSubData *models.XappSubscriptionData) bool {
762 xapp.Logger.Debug("Deleteing the subscription from the subscriptions list")
764 sub := rtmgr.Subscription{SubID: *xappSubData.SubscriptionID, Fqdn: *xappSubData.Address, Port: *xappSubData.Port}
765 for i, elem := range *subs {
768 // Since the order of the list is not important, we are swapping the last element
769 // with the matching element and replacing the list with list(n-1) elements.
770 (*subs)[len(*subs)-1], (*subs)[i] = (*subs)[i], (*subs)[len(*subs)-1]
771 *subs = (*subs)[:len(*subs)-1]
775 if present == false {
776 xapp.Logger.Warn("rtmgr.delSubscription: Subscription = %v, not present in the existing subscriptions", xappSubData)
781 func updateSubscription(data *rtmgr.XappList) {
783 var subdata models.XappSubscriptionData
785 var matchingsubid, deletecount uint8
786 id = int32(data.SubscriptionID)
787 subdata.SubscriptionID = &id
788 for _, subs := range rtmgr.Subs {
789 if int32(data.SubscriptionID) == subs.SubID {
794 for deletecount < matchingsubid {
795 for _, subs := range rtmgr.Subs {
796 if int32(data.SubscriptionID) == subs.SubID {
797 subdata.SubscriptionID = &subs.SubID
798 subdata.Address = &subs.Fqdn
799 subdata.Port = &subs.Port
800 xapp.Logger.Debug("Deletion Subscription List has %v", subdata)
801 delSubscription(&rtmgr.Subs, &subdata)
808 for _, items := range data.FqdnList {
809 subdata.Address = items.Address
810 subdata.Port = items.Port
811 xapp.Logger.Debug("Adding Subscription List has %v", subdata)
812 addSubscription(&rtmgr.Subs, &subdata)
817 func PopulateSubscription(sub_list xfmodel.SubscriptionList) {
818 for _, sub_row := range sub_list {
819 var subdata models.XappSubscriptionData
820 id := int32(sub_row.SubscriptionID)
821 subdata.SubscriptionID = &id
822 for _, ep := range sub_row.Endpoint {
824 stringSlice := strings.Split(ep, ":")
825 subdata.Address = &stringSlice[0]
826 intportval, _ := strconv.Atoi(stringSlice[1])
827 value := uint16(intportval)
828 subdata.Port = &value
829 xapp.Logger.Debug("Adding Subscription List has Address :%v, port :%v, SubscriptionID :%v ", subdata.Address, subdata.Address, subdata.SubscriptionID)
830 addSubscription(&rtmgr.Subs, &subdata)
835 func adddelrmrroute(routelist models.Routelist, rtflag bool) error {
836 xapp.Logger.Info("Updating rmrroute with Route list: %v,flag: %v", routelist, rtflag)
837 for _, rlist := range routelist {
840 if rlist.SubscriptionID == 0 {
843 subid = rlist.SubscriptionID
845 if rlist.SenderEndPoint == "" && rlist.SubscriptionID != 0 {
846 data = fmt.Sprintf("mse|%d|%d|%s\n", *rlist.MessageType, rlist.SubscriptionID, *rlist.TargetEndPoint)
847 } else if rlist.SenderEndPoint == "" && rlist.SubscriptionID == 0 {
848 data = fmt.Sprintf("mse|%d|-1|%s\n", *rlist.MessageType, *rlist.TargetEndPoint)
850 data = fmt.Sprintf("mse|%d,%s|%d|%s\n", *rlist.MessageType, rlist.SenderEndPoint, subid, *rlist.TargetEndPoint)
852 err := checkrepeatedroute(data)
856 xapp.Logger.Info("Given route %s is a duplicate", data)
858 rtmgr.DynamicRouteList = append(rtmgr.DynamicRouteList, data)
859 routearray := strings.Join(rtmgr.DynamicRouteList, " ")
860 xapp.Sdl.Store("routes", routearray)
863 xapp.Logger.Info("Successfully deleted route: %s", data)
864 routearray := strings.Join(rtmgr.DynamicRouteList, " ")
865 xapp.Sdl.Store("routes", routearray)
867 xapp.Logger.Info("No such route: %s", data)
868 return errors.New("No such route: " + data)
873 return sendRoutesToAll()
876 func checkrepeatedroute(data string) bool {
877 for i := 0; i < len(rtmgr.DynamicRouteList); i++ {
878 if rtmgr.DynamicRouteList[i] == data {
879 rtmgr.DynamicRouteList[i] = rtmgr.DynamicRouteList[len(rtmgr.DynamicRouteList)-1]
880 rtmgr.DynamicRouteList[len(rtmgr.DynamicRouteList)-1] = ""
881 rtmgr.DynamicRouteList = rtmgr.DynamicRouteList[:len(rtmgr.DynamicRouteList)-1]