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)
148 return sendRoutesToAll()
149 //return sendPartialRoutesToAll(nil, rtmgr.XappType)
157 func validateXappSubscriptionData(data *models.XappSubscriptionData) error {
158 var err = fmt.Errorf("XApp instance not found: %v:%v", *data.Address, *data.Port)
159 for _, ep := range rtmgr.Eps {
160 if ep.Ip == *data.Address && ep.Port == *data.Port {
168 func validateE2tData(data *models.E2tData) (error, bool) {
170 e2taddress_key := *data.E2TAddress
171 if e2taddress_key == "" {
172 return fmt.Errorf("E2TAddress is empty!!!"), false
174 stringSlice := strings.Split(e2taddress_key, ":")
175 if len(stringSlice) == 1 {
176 return fmt.Errorf("E2T E2TAddress is not a proper format like ip:port, %v", e2taddress_key), false
179 _, err := net.LookupIP(stringSlice[0])
181 return fmt.Errorf("E2T E2TAddress DNS look up failed, E2TAddress: %v", stringSlice[0]), false
184 if checkValidaE2TAddress(e2taddress_key) {
185 return fmt.Errorf("E2TAddress already exist!!!, E2TAddress: %v", e2taddress_key), true
191 func validateDeleteE2tData(data *models.E2tDeleteData) error {
193 if *data.E2TAddress == "" {
194 return fmt.Errorf("E2TAddress is empty!!!")
197 for _, element := range data.RanAssocList {
198 e2taddress_key := *element.E2TAddress
199 stringSlice := strings.Split(e2taddress_key, ":")
201 if len(stringSlice) == 1 {
202 return fmt.Errorf("E2T Delete - RanAssocList E2TAddress is not a proper format like ip:port, %v", e2taddress_key)
205 if !checkValidaE2TAddress(e2taddress_key) {
206 return fmt.Errorf("E2TAddress doesn't exist!!!, E2TAddress: %v", e2taddress_key)
213 func checkValidaE2TAddress(e2taddress string) bool {
215 _, exist := rtmgr.Eps[e2taddress]
220 func provideXappSubscriptionHandleImpl(data *models.XappSubscriptionData) error {
221 xapp.Logger.Debug("Invoked provideXappSubscriptionHandleImpl")
222 err := validateXappSubscriptionData(data)
224 xapp.Logger.Error(err.Error())
227 xapp.Logger.Debug("received XApp subscription data")
228 addSubscription(&rtmgr.Subs, data)
229 xapp.Logger.Debug("Endpoints: %v", rtmgr.Eps)
231 return sendPartialRoutesToAll(data, rtmgr.SubsType)
234 func subscriptionExists(data *models.XappSubscriptionData) bool {
236 sub := rtmgr.Subscription{SubID: *data.SubscriptionID, Fqdn: *data.Address, Port: *data.Port}
237 for _, elem := range rtmgr.Subs {
246 func deleteXappSubscriptionHandleImpl(data *models.XappSubscriptionData) error {
247 xapp.Logger.Debug("Invoked deleteXappSubscriptionHandleImpl")
248 err := validateXappSubscriptionData(data)
250 xapp.Logger.Error(err.Error())
254 if !subscriptionExists(data) {
255 xapp.Logger.Warn("subscription not found: %d", *data.SubscriptionID)
256 err := fmt.Errorf("subscription not found: %d", *data.SubscriptionID)
260 xapp.Logger.Debug("received XApp subscription delete data")
261 delSubscription(&rtmgr.Subs, data)
263 return sendRoutesToAll()
267 func updateXappSubscriptionHandleImpl(data *models.XappList, subid uint16) error {
268 xapp.Logger.Debug("Invoked updateXappSubscriptionHandleImpl")
270 var fqdnlist []rtmgr.FqDn
271 for _, item := range *data {
272 fqdnlist = append(fqdnlist, rtmgr.FqDn(*item))
274 xapplist := rtmgr.XappList{SubscriptionID: subid, FqdnList: fqdnlist}
275 var subdata models.XappSubscriptionData
278 subdata.SubscriptionID = &id
279 for _, items := range fqdnlist {
280 subdata.Address = items.Address
281 subdata.Port = items.Port
282 err := validateXappSubscriptionData(&subdata)
284 xapp.Logger.Error(err.Error())
288 xapp.Logger.Debug("received XApp subscription Merge data")
289 updateSubscription(&xapplist)
291 return sendRoutesToAll()
294 func createNewE2tHandleHandlerImpl(data *models.E2tData) error {
295 xapp.Logger.Debug("Invoked createNewE2tHandleHandlerImpl")
296 err, IsDuplicate := validateE2tData(data)
297 if IsDuplicate == true {
299 //return sendPartialRoutesToAll(nil, rtmgr.E2Type)
300 return sendRoutesToAll()
304 xapp.Logger.Error(err.Error())
308 e2data, meiddata, _ := recvNewE2Tdata(data)
309 xapp.Logger.Debug("received create New E2T data")
311 sdlEngine.WriteNewE2TInstance(xapp.Config.GetString("rtfile"), e2data, meiddata)
314 //sendPartialRoutesToAll(nil, rtmgr.E2Type)
316 time.Sleep(10 * time.Second)
317 for ep, value := range rtmgr.RMRConnStatus {
318 if ep == *data.E2TAddress && value == true {
323 return errors.New("Error while adding new E2T " + *data.E2TAddress)
327 func validateE2TAddressRANListData(assRanE2tData models.RanE2tMap) error {
329 xapp.Logger.Debug("Invoked.validateE2TAddressRANListData : %v", assRanE2tData)
331 for _, element := range assRanE2tData {
332 if *element.E2TAddress == "" {
333 return fmt.Errorf("E2T Instance - E2TAddress is empty!!!")
336 e2taddress_key := *element.E2TAddress
337 if !checkValidaE2TAddress(e2taddress_key) {
338 return fmt.Errorf("E2TAddress doesn't exist!!!, E2TAddress: %v", e2taddress_key)
345 func associateRanToE2THandlerImpl(data models.RanE2tMap) error {
346 xapp.Logger.Debug("Invoked associateRanToE2THandlerImpl")
347 err := validateE2TAddressRANListData(data)
349 xapp.Logger.Warn(" Association of RAN to E2T Instance data validation failed: " + err.Error())
352 xapp.Logger.Debug("received associate RAN list to E2T instance mapping from E2 Manager")
354 sdlEngine.WriteAssRANToE2TInstance(xapp.Config.GetString("rtfile"), data)
357 return sendRoutesToAll()
361 func disassociateRanToE2THandlerImpl(data models.RanE2tMap) error {
362 xapp.Logger.Debug("Invoked disassociateRanToE2THandlerImpl")
363 err := validateE2TAddressRANListData(data)
365 xapp.Logger.Warn(" Disassociation of RAN List from E2T Instance data validation failed: " + err.Error())
368 xapp.Logger.Debug("received disassociate RANs from E2T instance")
370 sdlEngine.WriteDisAssRANFromE2TInstance(xapp.Config.GetString("rtfile"), data)
373 return sendRoutesToAll()
377 func deleteE2tHandleHandlerImpl(data *models.E2tDeleteData) error {
378 xapp.Logger.Debug("Invoked deleteE2tHandleHandlerImpl")
380 err := validateDeleteE2tData(data)
382 xapp.Logger.Error(err.Error())
386 sdlEngine.WriteDeleteE2TInstance(xapp.Config.GetString("rtfile"), data)
389 return sendRoutesToAll()
393 func dumpDebugData() (models.Debuginfo, error) {
394 var response models.Debuginfo
395 sdlEngine, _ := sdl.GetSdl("file")
396 rpeEngine, _ := rpe.GetRpe("rmrpush")
397 data, err := sdlEngine.ReadAll(xapp.Config.GetString("rtfile"))
400 xapp.Logger.Error("Cannot get data from sdl interface due to: " + err.Error())
403 xapp.Logger.Debug("Cannot get data from sdl interface")
404 return response, errors.New("Cannot get data from sdl interface")
407 response.RouteTable = *rpeEngine.GeneratePolicies(rtmgr.Eps, data)
409 prettyJSON, err := json.MarshalIndent(data, "", "")
410 response.RouteConfigs = string(prettyJSON)
415 func launchRest(nbiif *string) {
416 swaggerSpec, err := loads.Embedded(restapi.SwaggerJSON, restapi.FlatSwaggerJSON)
419 xapp.Logger.Error(err.Error())
422 nbiUrl, err := url.Parse(*nbiif)
424 xapp.Logger.Error(err.Error())
427 api := operations.NewRoutingManagerAPI(swaggerSpec)
428 server := restapi.NewServer(api)
429 defer server.Shutdown()
431 server.Port, err = strconv.Atoi(nbiUrl.Port())
433 xapp.Logger.Error("Invalid NBI RestAPI port")
436 server.Host = "0.0.0.0"
438 api.HandleProvideXappHandleHandler = handle.ProvideXappHandleHandlerFunc(
439 func(params handle.ProvideXappHandleParams) middleware.Responder {
440 xapp.Logger.Info("Data received on Http interface")
441 err := provideXappHandleHandlerImpl(params.XappCallbackData)
443 xapp.Logger.Error("RoutingManager->AppManager request Failed: " + err.Error())
444 return handle.NewProvideXappHandleBadRequest()
446 xapp.Logger.Info("RoutingManager->AppManager request Success")
447 return handle.NewGetHandlesOK()
450 api.HandleProvideXappSubscriptionHandleHandler = handle.ProvideXappSubscriptionHandleHandlerFunc(
451 func(params handle.ProvideXappSubscriptionHandleParams) middleware.Responder {
452 err := provideXappSubscriptionHandleImpl(params.XappSubscriptionData)
454 xapp.Logger.Error("RoutingManager->SubManager Add Request Failed: " + err.Error())
455 return handle.NewProvideXappSubscriptionHandleBadRequest()
457 xapp.Logger.Info("RoutingManager->SubManager Add Request Success, subid = %v, requestor = %v", *params.XappSubscriptionData.SubscriptionID, *params.XappSubscriptionData.Address)
458 return handle.NewGetHandlesOK()
461 api.HandleDeleteXappSubscriptionHandleHandler = handle.DeleteXappSubscriptionHandleHandlerFunc(
462 func(params handle.DeleteXappSubscriptionHandleParams) middleware.Responder {
463 err := deleteXappSubscriptionHandleImpl(params.XappSubscriptionData)
465 xapp.Logger.Error("RoutingManager->SubManager Delete Request Failed: " + err.Error())
466 return handle.NewDeleteXappSubscriptionHandleNoContent()
468 xapp.Logger.Info("RoutingManager->SubManager Delete Request Success, subid = %v, requestor = %v", *params.XappSubscriptionData.SubscriptionID, *params.XappSubscriptionData.Address)
469 return handle.NewGetHandlesOK()
472 api.HandleUpdateXappSubscriptionHandleHandler = handle.UpdateXappSubscriptionHandleHandlerFunc(
473 func(params handle.UpdateXappSubscriptionHandleParams) middleware.Responder {
474 err := updateXappSubscriptionHandleImpl(¶ms.XappList, params.SubscriptionID)
476 return handle.NewUpdateXappSubscriptionHandleBadRequest()
478 return handle.NewUpdateXappSubscriptionHandleCreated()
481 api.HandleCreateNewE2tHandleHandler = handle.CreateNewE2tHandleHandlerFunc(
482 func(params handle.CreateNewE2tHandleParams) middleware.Responder {
483 err := createNewE2tHandleHandlerImpl(params.E2tData)
485 xapp.Logger.Error("RoutingManager->E2Manager AddE2T Request Failed: " + err.Error())
486 return handle.NewCreateNewE2tHandleBadRequest()
488 xapp.Logger.Info("RoutingManager->E2Manager AddE2T Request Success, E2T = %v", *params.E2tData.E2TAddress)
489 return handle.NewCreateNewE2tHandleCreated()
493 api.HandleAssociateRanToE2tHandleHandler = handle.AssociateRanToE2tHandleHandlerFunc(
494 func(params handle.AssociateRanToE2tHandleParams) middleware.Responder {
495 err := associateRanToE2THandlerImpl(params.RanE2tList)
497 xapp.Logger.Error("RoutingManager->E2Manager associateRanToE2T Request Failed: " + err.Error())
498 return handle.NewAssociateRanToE2tHandleBadRequest()
500 xapp.Logger.Info("RoutingManager->E2Manager associateRanToE2T Request Success, E2T = %v", params.RanE2tList)
501 return handle.NewAssociateRanToE2tHandleCreated()
505 api.HandleDissociateRanHandler = handle.DissociateRanHandlerFunc(
506 func(params handle.DissociateRanParams) middleware.Responder {
507 err := disassociateRanToE2THandlerImpl(params.DissociateList)
509 xapp.Logger.Error("RoutingManager->E2Manager DisassociateRanToE2T Request Failed: " + err.Error())
510 return handle.NewDissociateRanBadRequest()
512 xapp.Logger.Info("RoutingManager->E2Manager DisassociateRanToE2T Request Success, E2T = %v", params.DissociateList)
513 return handle.NewDissociateRanCreated()
517 api.HandleDeleteE2tHandleHandler = handle.DeleteE2tHandleHandlerFunc(
518 func(params handle.DeleteE2tHandleParams) middleware.Responder {
519 err := deleteE2tHandleHandlerImpl(params.E2tData)
521 xapp.Logger.Error("RoutingManager->E2Manager DeleteE2T Request Failed: " + err.Error())
522 return handle.NewDeleteE2tHandleBadRequest()
524 xapp.Logger.Info("RoutingManager->E2Manager DeleteE2T Request Success, E2T = %v", *params.E2tData.E2TAddress)
525 return handle.NewDeleteE2tHandleCreated()
528 api.DebugGetDebuginfoHandler = debug.GetDebuginfoHandlerFunc(
529 func(params debug.GetDebuginfoParams) middleware.Responder {
530 response, err := dumpDebugData()
532 return debug.NewGetDebuginfoCreated()
534 return debug.NewGetDebuginfoOK().WithPayload(&response)
537 api.HandleAddRmrRouteHandler = handle.AddRmrRouteHandlerFunc(
538 func(params handle.AddRmrRouteParams) middleware.Responder {
539 err := adddelrmrroute(params.RoutesList, true)
541 return handle.NewAddRmrRouteBadRequest()
543 return handle.NewAddRmrRouteCreated()
547 api.HandleDelRmrRouteHandler = handle.DelRmrRouteHandlerFunc(
548 func(params handle.DelRmrRouteParams) middleware.Responder {
549 err := adddelrmrroute(params.RoutesList, false)
551 return handle.NewDelRmrRouteBadRequest()
553 return handle.NewDelRmrRouteCreated()
557 // start to serve API
558 xapp.Logger.Info("Starting the HTTP Rest service")
559 if err := server.Serve(); err != nil {
560 xapp.Logger.Error(err.Error())
564 func httpGetXApps(xmurl string) (*[]rtmgr.XApp, error) {
565 xapp.Logger.Info("Invoked httprestful.httpGetXApps: " + xmurl)
566 r, err := myClient.Get(xmurl)
572 if r.StatusCode == 200 {
573 xapp.Logger.Debug("http client raw response: %v", r)
574 var xapps []rtmgr.XApp
575 err = json.NewDecoder(r.Body).Decode(&xapps)
577 xapp.Logger.Warn("Json decode failed: " + err.Error())
579 xapp.Logger.Info("HTTP GET: OK")
580 xapp.Logger.Debug("httprestful.httpGetXApps returns: %v", xapps)
583 xapp.Logger.Warn("httprestful got an unexpected http status code: %v", r.StatusCode)
587 func httpGetE2TList(e2murl string) (*[]rtmgr.E2tIdentity, error) {
588 xapp.Logger.Info("Invoked httprestful.httpGetE2TList: " + e2murl)
589 r, err := myClient.Get(e2murl)
595 if r.StatusCode == 200 {
596 xapp.Logger.Debug("http client raw response: %v", r)
597 var E2Tlist []rtmgr.E2tIdentity
598 err = json.NewDecoder(r.Body).Decode(&E2Tlist)
600 xapp.Logger.Warn("Json decode failed: " + err.Error())
602 xapp.Logger.Info("HTTP GET: OK")
603 xapp.Logger.Debug("httprestful.httpGetXApps returns: %v", E2Tlist)
606 xapp.Logger.Warn("httprestful got an unexpected http status code: %v", r.StatusCode)
610 func PopulateE2TMap(e2tDataList *[]rtmgr.E2tIdentity, e2ts map[string]rtmgr.E2TInstance, meids []string) {
611 xapp.Logger.Info("Invoked httprestful.PopulateE2TMap ")
613 for _, e2tData := range *e2tDataList {
616 e2tinst := rtmgr.E2TInstance{
617 Ranlist: make([]string, len(e2tData.Rannames)),
620 e2tinst.Fqdn = e2tData.E2taddress
621 e2tinst.Name = "E2TERMINST"
622 copy(e2tinst.Ranlist, e2tData.Rannames)
624 if len(e2tData.Rannames) > 0 {
626 for _, meid := range e2tData.Rannames {
629 str += "mme_ar|" + e2tData.E2taddress + "|" + strings.TrimSuffix(meidar, " ")
632 e2ts[e2tinst.Fqdn] = e2tinst
633 meids = append(meids, str)
637 func retrieveStartupData(xmurl string, nbiif string, fileName string, configfile string, e2murl string, sdlEngine sdl.Engine) error {
638 xapp.Logger.Info("Invoked retrieveStartupData ")
642 var xappData *[]rtmgr.XApp
643 xappData = new([]rtmgr.XApp)
644 xapp.Logger.Info("Trying to fetch XApps data from XAPP manager")
645 for i := 1; i <= maxRetries; i++ {
646 time.Sleep(2 * time.Second)
649 xappData, err = httpGetXApps(xmurl)
650 if xappData != nil && err == nil {
652 } else if err == nil {
653 readErr = errors.New("unexpected HTTP status code")
655 xapp.Logger.Warn("cannot get xapp data due to: " + err.Error())
665 e2ts := make(map[string]rtmgr.E2TInstance)
666 xapp.Logger.Info("Trying to fetch E2T data from E2manager")
667 for i := 1; i <= maxRetries; i++ {
670 e2tDataList, err := httpGetE2TList(e2murl)
671 if e2tDataList != nil && err == nil {
672 PopulateE2TMap(e2tDataList, e2ts, meids[:])
674 } else if err == nil {
675 readErr = errors.New("unexpected HTTP status code")
677 xapp.Logger.Warn("cannot get E2T data from E2M due to: " + err.Error())
680 time.Sleep(2 * time.Second)
687 pcData, confErr := rtmgr.GetPlatformComponents(configfile)
689 xapp.Logger.Error(confErr.Error())
692 xapp.Logger.Info("Recieved intial xapp data, E2T data and platform data, writing into SDL.")
693 // Combine the xapps data and platform data before writing to the SDL
694 ricData := &rtmgr.RicComponents{XApps: *xappData, Pcs: *pcData, E2Ts: e2ts, MeidMap: meids}
695 writeErr := sdlEngine.WriteAll(fileName, ricData)
697 xapp.Logger.Error(writeErr.Error())
700 xapp.Logger.Info("Trying to fetch Subscriptions data from Subscription manager")
701 for i := 1; i <= maxRetries; i++ {
703 sub_list, err := xapp.Subscription.QuerySubscriptions()
705 if sub_list != nil && err == nil {
706 PopulateSubscription(sub_list)
710 xapp.Logger.Warn("cannot get xapp data due to: " + readErr.Error())
712 time.Sleep(2 * time.Second)
719 // post subscription req to appmgr
720 readErr = PostSubReq(xmurl, nbiif)
725 //rlist := make(map[string]string)
726 xapp.Logger.Info("Reading SDL for any routes")
727 rlist, sdlerr := xapp.Sdl.Read("routes")
730 xapp.Logger.Info("Value is %s", rlist["routes"])
731 if rlist["routes"] != nil {
732 formstring := fmt.Sprintf("%s", rlist["routes"])
733 xapp.Logger.Info("Value of formed string = %s", formstring)
734 newstring := strings.Split(formstring, " ")
735 for i, _ := range newstring {
736 xapp.Logger.Info("in Loop Value of formed string = %s", newstring)
737 rtmgr.DynamicRouteList = append(rtmgr.DynamicRouteList, newstring[i])
747 func (r *HttpRestful) Initialize(xmurl string, nbiif string, fileName string, configfile string, e2murl string,
748 sdlEngine sdl.Engine, rpeEngine rpe.Engine, m *sync.Mutex) error {
749 err := r.RetrieveStartupData(xmurl, nbiif, fileName, configfile, e2murl, sdlEngine)
751 xapp.Logger.Error("Exiting as nbi failed to get the initial startup data from the xapp manager: " + err.Error())
761 func (r *HttpRestful) Terminate() error {
765 func addSubscription(subs *rtmgr.SubscriptionList, xappSubData *models.XappSubscriptionData) bool {
766 xapp.Logger.Debug("Adding the subscription into the subscriptions list")
768 sub := rtmgr.Subscription{SubID: *xappSubData.SubscriptionID, Fqdn: *xappSubData.Address, Port: *xappSubData.Port}
769 for _, elem := range *subs {
771 xapp.Logger.Warn("rtmgr.addSubscription: Subscription already present: %v", elem)
776 *subs = append(*subs, sub)
781 func delSubscription(subs *rtmgr.SubscriptionList, xappSubData *models.XappSubscriptionData) bool {
782 xapp.Logger.Debug("Deleteing the subscription from the subscriptions list")
784 sub := rtmgr.Subscription{SubID: *xappSubData.SubscriptionID, Fqdn: *xappSubData.Address, Port: *xappSubData.Port}
785 for i, elem := range *subs {
788 // Since the order of the list is not important, we are swapping the last element
789 // with the matching element and replacing the list with list(n-1) elements.
790 (*subs)[len(*subs)-1], (*subs)[i] = (*subs)[i], (*subs)[len(*subs)-1]
791 *subs = (*subs)[:len(*subs)-1]
795 if present == false {
796 xapp.Logger.Warn("rtmgr.delSubscription: Subscription = %v, not present in the existing subscriptions", xappSubData)
801 func updateSubscription(data *rtmgr.XappList) {
803 var subdata models.XappSubscriptionData
805 var matchingsubid, deletecount uint8
806 id = int32(data.SubscriptionID)
807 subdata.SubscriptionID = &id
808 for _, subs := range rtmgr.Subs {
809 if int32(data.SubscriptionID) == subs.SubID {
814 for deletecount < matchingsubid {
815 for _, subs := range rtmgr.Subs {
816 if int32(data.SubscriptionID) == subs.SubID {
817 subdata.SubscriptionID = &subs.SubID
818 subdata.Address = &subs.Fqdn
819 subdata.Port = &subs.Port
820 xapp.Logger.Debug("Deletion Subscription List has %v", subdata)
821 delSubscription(&rtmgr.Subs, &subdata)
828 for _, items := range data.FqdnList {
829 subdata.Address = items.Address
830 subdata.Port = items.Port
831 xapp.Logger.Debug("Adding Subscription List has %v", subdata)
832 addSubscription(&rtmgr.Subs, &subdata)
837 func PopulateSubscription(sub_list xfmodel.SubscriptionList) {
838 for _, sub_row := range sub_list {
839 var subdata models.XappSubscriptionData
840 id := int32(sub_row.SubscriptionID)
841 subdata.SubscriptionID = &id
842 for _, ep := range sub_row.Endpoint {
844 stringSlice := strings.Split(ep, ":")
845 subdata.Address = &stringSlice[0]
846 intportval, _ := strconv.Atoi(stringSlice[1])
847 value := uint16(intportval)
848 subdata.Port = &value
849 xapp.Logger.Debug("Adding Subscription List has Address :%v, port :%v, SubscriptionID :%v ", subdata.Address, subdata.Address, subdata.SubscriptionID)
850 addSubscription(&rtmgr.Subs, &subdata)
855 func adddelrmrroute(routelist models.Routelist, rtflag bool) error {
856 xapp.Logger.Info("Updating rmrroute with Route list: %v,flag: %v", routelist, rtflag)
857 for _, rlist := range routelist {
860 if rlist.SubscriptionID == 0 {
863 subid = rlist.SubscriptionID
865 if rlist.SenderEndPoint == "" && rlist.SubscriptionID != 0 {
866 data = fmt.Sprintf("mse|%d|%d|%s\n", *rlist.MessageType, rlist.SubscriptionID, *rlist.TargetEndPoint)
867 } else if rlist.SenderEndPoint == "" && rlist.SubscriptionID == 0 {
868 data = fmt.Sprintf("mse|%d|-1|%s\n", *rlist.MessageType, *rlist.TargetEndPoint)
870 data = fmt.Sprintf("mse|%d,%s|%d|%s\n", *rlist.MessageType, rlist.SenderEndPoint, subid, *rlist.TargetEndPoint)
872 err := checkrepeatedroute(data)
876 xapp.Logger.Info("Given route %s is a duplicate", data)
878 rtmgr.DynamicRouteList = append(rtmgr.DynamicRouteList, data)
879 routearray := strings.Join(rtmgr.DynamicRouteList, " ")
880 xapp.Sdl.Store("routes", routearray)
883 xapp.Logger.Info("Successfully deleted route: %s", data)
884 routearray := strings.Join(rtmgr.DynamicRouteList, " ")
885 xapp.Sdl.Store("routes", routearray)
887 xapp.Logger.Info("No such route: %s", data)
888 return errors.New("No such route: " + data)
894 return sendRoutesToAll()
897 func checkrepeatedroute(data string) bool {
898 for i := 0; i < len(rtmgr.DynamicRouteList); i++ {
899 if rtmgr.DynamicRouteList[i] == data {
900 rtmgr.DynamicRouteList[i] = rtmgr.DynamicRouteList[len(rtmgr.DynamicRouteList)-1]
901 rtmgr.DynamicRouteList[len(rtmgr.DynamicRouteList)-1] = ""
902 rtmgr.DynamicRouteList = rtmgr.DynamicRouteList[:len(rtmgr.DynamicRouteList)-1]