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 "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
39 xfmodel "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/models"
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 //var myClient = &http.Client{Timeout: 1 * time.Second}
61 type HttpRestful struct {
63 LaunchRest LaunchRestHandler
64 RecvXappCallbackData RecvXappCallbackDataHandler
65 RecvNewE2Tdata RecvNewE2TdataHandler
66 ProvideXappHandleHandlerImpl ProvideXappHandleHandlerImpl
67 RetrieveStartupData RetrieveStartupDataHandler
70 func NewHttpRestful() *HttpRestful {
71 instance := new(HttpRestful)
72 instance.LaunchRest = launchRest
73 instance.RecvXappCallbackData = recvXappCallbackData
74 instance.RecvNewE2Tdata = recvNewE2Tdata
75 instance.ProvideXappHandleHandlerImpl = provideXappHandleHandlerImpl
76 instance.RetrieveStartupData = retrieveStartupData
80 // ToDo: Use Range over channel. Read and return only the latest one.
81 func recvXappCallbackData(dataChannel <-chan *models.XappCallbackData) (*[]rtmgr.XApp, error) {
82 var xappData *models.XappCallbackData
83 // Drain the channel as we are only looking for the latest value until
84 // xapp manager sends all xapp data with every request.
85 length := len(dataChannel)
86 //xapp.Logger.Info(length)
87 for i := 0; i <= length; i++ {
88 xapp.Logger.Info("data received")
89 // If no data received from the REST, it blocks.
90 xappData = <-dataChannel
93 var xapps []rtmgr.XApp
94 err := json.Unmarshal([]byte(xappData.XApps), &xapps)
97 xapp.Logger.Info("No data")
100 xapp.Logger.Debug("Nothing received on the Http interface")
104 func recvNewE2Tdata(dataChannel <-chan *models.E2tData) (*rtmgr.E2TInstance, string, error) {
105 var e2tData *models.E2tData
107 xapp.Logger.Info("data received")
109 e2tData = <-dataChannel
113 e2tinst := rtmgr.E2TInstance{
114 Ranlist: make([]string, len(e2tData.RanNamelist)),
117 e2tinst.Fqdn = *e2tData.E2TAddress
118 e2tinst.Name = "E2TERMINST"
119 copy(e2tinst.Ranlist, e2tData.RanNamelist)
120 if len(e2tData.RanNamelist) > 0 {
122 for _, meid := range e2tData.RanNamelist {
125 str = "mme_ar|" + *e2tData.E2TAddress + "|" + strings.TrimSuffix(meidar, " ")
127 return &e2tinst, str, nil
130 xapp.Logger.Info("No data")
133 xapp.Logger.Debug("Nothing received on the Http interface")
137 func validateXappCallbackData(callbackData *models.XappCallbackData) error {
138 if len(callbackData.XApps) == 0 {
139 return fmt.Errorf("invalid Data field: \"%s\"", callbackData.XApps)
141 var xapps []rtmgr.XApp
142 err := json.Unmarshal([]byte(callbackData.XApps), &xapps)
144 return fmt.Errorf("unmarshal failed: \"%s\"", err.Error())
149 func provideXappHandleHandlerImpl(datach chan<- *models.XappCallbackData, data *models.XappCallbackData) error {
151 xapp.Logger.Debug("Received callback data")
153 err := validateXappCallbackData(data)
155 xapp.Logger.Warn("XApp callback data validation failed: " + err.Error())
163 func validateXappSubscriptionData(data *models.XappSubscriptionData) error {
164 var err = fmt.Errorf("XApp instance not found: %v:%v", *data.Address, *data.Port)
165 for _, ep := range rtmgr.Eps {
166 if ep.Ip == *data.Address && ep.Port == *data.Port {
174 func validateE2tData(data *models.E2tData) error {
176 e2taddress_key := *data.E2TAddress
177 if e2taddress_key == "" {
178 return fmt.Errorf("E2TAddress is empty!!!")
180 stringSlice := strings.Split(e2taddress_key, ":")
181 if len(stringSlice) == 1 {
182 return fmt.Errorf("E2T E2TAddress is not a proper format like ip:port, %v", e2taddress_key)
185 _, err := net.LookupIP(stringSlice[0])
187 return fmt.Errorf("E2T E2TAddress DNS look up failed, E2TAddress: %v", stringSlice[0])
190 if checkValidaE2TAddress(e2taddress_key) {
191 return fmt.Errorf("E2TAddress already exist!!!, E2TAddress: %v", e2taddress_key)
197 func validateDeleteE2tData(data *models.E2tDeleteData) error {
199 if *data.E2TAddress == "" {
200 return fmt.Errorf("E2TAddress is empty!!!")
203 for _, element := range data.RanAssocList {
204 e2taddress_key := *element.E2TAddress
205 stringSlice := strings.Split(e2taddress_key, ":")
207 if len(stringSlice) == 1 {
208 return fmt.Errorf("E2T Delete - RanAssocList E2TAddress is not a proper format like ip:port, %v", e2taddress_key)
211 if !checkValidaE2TAddress(e2taddress_key) {
212 return fmt.Errorf("E2TAddress doesn't exist!!!, E2TAddress: %v", e2taddress_key)
219 func checkValidaE2TAddress(e2taddress string) bool {
221 _, exist := rtmgr.Eps[e2taddress]
226 func provideXappSubscriptionHandleImpl(subchan chan<- *models.XappSubscriptionData,
227 data *models.XappSubscriptionData) error {
228 xapp.Logger.Debug("Invoked provideXappSubscriptionHandleImpl")
229 err := validateXappSubscriptionData(data)
231 xapp.Logger.Error(err.Error())
235 //var val = string(*data.Address + ":" + strconv.Itoa(int(*data.Port)))
236 xapp.Logger.Debug("Endpoints: %v", rtmgr.Eps)
240 func subscriptionExists(data *models.XappSubscriptionData) bool {
242 sub := rtmgr.Subscription{SubID: *data.SubscriptionID, Fqdn: *data.Address, Port: *data.Port}
243 for _, elem := range rtmgr.Subs {
252 func deleteXappSubscriptionHandleImpl(subdelchan chan<- *models.XappSubscriptionData,
253 data *models.XappSubscriptionData) error {
254 xapp.Logger.Debug("Invoked deleteXappSubscriptionHandleImpl")
255 err := validateXappSubscriptionData(data)
257 xapp.Logger.Error(err.Error())
261 if !subscriptionExists(data) {
262 xapp.Logger.Warn("subscription not found: %d", *data.SubscriptionID)
263 err := fmt.Errorf("subscription not found: %d", *data.SubscriptionID)
271 func updateXappSubscriptionHandleImpl(subupdatechan chan<- *rtmgr.XappList, data *models.XappList, subid uint16) error {
272 xapp.Logger.Debug("Invoked updateXappSubscriptionHandleImpl")
274 var fqdnlist []rtmgr.FqDn
275 for _, item := range *data {
276 fqdnlist = append(fqdnlist, rtmgr.FqDn(*item))
278 xapplist := rtmgr.XappList{SubscriptionID: subid, FqdnList: fqdnlist}
279 var subdata models.XappSubscriptionData
282 subdata.SubscriptionID = &id
283 for _, items := range fqdnlist {
284 subdata.Address = items.Address
285 subdata.Port = items.Port
286 err := validateXappSubscriptionData(&subdata)
288 xapp.Logger.Error(err.Error())
292 subupdatechan <- &xapplist
296 func createNewE2tHandleHandlerImpl(e2taddchan chan<- *models.E2tData,
297 data *models.E2tData) error {
298 xapp.Logger.Debug("Invoked createNewE2tHandleHandlerImpl")
299 err := validateE2tData(data)
301 xapp.Logger.Error(err.Error())
308 func validateE2TAddressRANListData(assRanE2tData models.RanE2tMap) error {
310 xapp.Logger.Debug("Invoked.validateE2TAddressRANListData : %v", assRanE2tData)
312 for _, element := range assRanE2tData {
313 if *element.E2TAddress == "" {
314 return fmt.Errorf("E2T Instance - E2TAddress is empty!!!")
317 e2taddress_key := *element.E2TAddress
318 if !checkValidaE2TAddress(e2taddress_key) {
319 return fmt.Errorf("E2TAddress doesn't exist!!!, E2TAddress: %v", e2taddress_key)
326 func associateRanToE2THandlerImpl(assranchan chan<- models.RanE2tMap,
327 data models.RanE2tMap) error {
328 xapp.Logger.Debug("Invoked associateRanToE2THandlerImpl")
329 err := validateE2TAddressRANListData(data)
331 xapp.Logger.Warn(" Association of RAN to E2T Instance data validation failed: " + err.Error())
338 func disassociateRanToE2THandlerImpl(disassranchan chan<- models.RanE2tMap,
339 data models.RanE2tMap) error {
340 xapp.Logger.Debug("Invoked disassociateRanToE2THandlerImpl")
341 err := validateE2TAddressRANListData(data)
343 xapp.Logger.Warn(" Disassociation of RAN List from E2T Instance data validation failed: " + err.Error())
346 disassranchan <- data
350 func deleteE2tHandleHandlerImpl(e2tdelchan chan<- *models.E2tDeleteData,
351 data *models.E2tDeleteData) error {
352 xapp.Logger.Debug("Invoked deleteE2tHandleHandlerImpl")
354 err := validateDeleteE2tData(data)
356 xapp.Logger.Error(err.Error())
364 func dumpDebugData() (models.Debuginfo, error) {
365 var response models.Debuginfo
366 sdlEngine, _ := sdl.GetSdl("file")
367 rpeEngine, _ := rpe.GetRpe("rmrpush")
368 data, err := sdlEngine.ReadAll(xapp.Config.GetString("rtfile"))
369 if err != nil || data == nil {
370 xapp.Logger.Error("Cannot get data from sdl interface due to: " + err.Error())
373 response.RouteTable = *rpeEngine.GeneratePolicies(rtmgr.Eps, data)
375 prettyJSON, err := json.MarshalIndent(data, "", "")
376 response.RouteConfigs = string(prettyJSON)
381 func launchRest(nbiif *string, datach chan<- *models.XappCallbackData, subchan chan<- *models.XappSubscriptionData, subupdatechan chan<- *rtmgr.XappList,
382 subdelchan chan<- *models.XappSubscriptionData, e2taddchan chan<- *models.E2tData, assranchan chan<- models.RanE2tMap, disassranchan chan<- models.RanE2tMap, e2tdelchan chan<- *models.E2tDeleteData) {
383 swaggerSpec, err := loads.Embedded(restapi.SwaggerJSON, restapi.FlatSwaggerJSON)
386 xapp.Logger.Error(err.Error())
389 nbiUrl, err := url.Parse(*nbiif)
391 xapp.Logger.Error(err.Error())
394 api := operations.NewRoutingManagerAPI(swaggerSpec)
395 server := restapi.NewServer(api)
396 defer server.Shutdown()
398 server.Port, err = strconv.Atoi(nbiUrl.Port())
400 xapp.Logger.Error("Invalid NBI RestAPI port")
403 server.Host = "0.0.0.0"
405 api.HandleProvideXappHandleHandler = handle.ProvideXappHandleHandlerFunc(
406 func(params handle.ProvideXappHandleParams) middleware.Responder {
407 xapp.Logger.Info("Data received on Http interface")
408 err := provideXappHandleHandlerImpl(datach, params.XappCallbackData)
410 xapp.Logger.Error("Invalid XApp callback data: " + err.Error())
411 return handle.NewProvideXappHandleBadRequest()
413 return handle.NewGetHandlesOK()
416 api.HandleProvideXappSubscriptionHandleHandler = handle.ProvideXappSubscriptionHandleHandlerFunc(
417 func(params handle.ProvideXappSubscriptionHandleParams) middleware.Responder {
418 err := provideXappSubscriptionHandleImpl(subchan, params.XappSubscriptionData)
420 return handle.NewProvideXappSubscriptionHandleBadRequest()
422 //Delay the reponse as add subscription channel needs to update sdl and then sbi sends updated routes to all endpoints
423 time.Sleep(1 * time.Second)
424 return handle.NewGetHandlesOK()
427 api.HandleDeleteXappSubscriptionHandleHandler = handle.DeleteXappSubscriptionHandleHandlerFunc(
428 func(params handle.DeleteXappSubscriptionHandleParams) middleware.Responder {
429 err := deleteXappSubscriptionHandleImpl(subdelchan, params.XappSubscriptionData)
431 return handle.NewDeleteXappSubscriptionHandleNoContent()
433 //Delay the reponse as delete subscription channel needs to update sdl and then sbi sends updated routes to all endpoints
434 time.Sleep(1 * time.Second)
435 return handle.NewGetHandlesOK()
438 api.HandleUpdateXappSubscriptionHandleHandler = handle.UpdateXappSubscriptionHandleHandlerFunc(
439 func(params handle.UpdateXappSubscriptionHandleParams) middleware.Responder {
440 err := updateXappSubscriptionHandleImpl(subupdatechan, ¶ms.XappList, params.SubscriptionID)
442 return handle.NewUpdateXappSubscriptionHandleBadRequest()
444 //Delay the reponse as delete subscription channel needs to update sdl and then sbi sends updated routes to all endpoints
445 time.Sleep(1 * time.Second)
446 return handle.NewUpdateXappSubscriptionHandleCreated()
449 api.HandleCreateNewE2tHandleHandler = handle.CreateNewE2tHandleHandlerFunc(
450 func(params handle.CreateNewE2tHandleParams) middleware.Responder {
451 err := createNewE2tHandleHandlerImpl(e2taddchan, params.E2tData)
453 return handle.NewCreateNewE2tHandleBadRequest()
455 time.Sleep(1 * time.Second)
456 return handle.NewCreateNewE2tHandleCreated()
460 api.HandleAssociateRanToE2tHandleHandler = handle.AssociateRanToE2tHandleHandlerFunc(
461 func(params handle.AssociateRanToE2tHandleParams) middleware.Responder {
462 err := associateRanToE2THandlerImpl(assranchan, params.RanE2tList)
464 return handle.NewAssociateRanToE2tHandleBadRequest()
466 time.Sleep(1 * time.Second)
467 return handle.NewAssociateRanToE2tHandleCreated()
471 api.HandleDissociateRanHandler = handle.DissociateRanHandlerFunc(
472 func(params handle.DissociateRanParams) middleware.Responder {
473 err := disassociateRanToE2THandlerImpl(disassranchan, params.DissociateList)
475 return handle.NewDissociateRanBadRequest()
477 time.Sleep(1 * time.Second)
478 return handle.NewDissociateRanCreated()
482 api.HandleDeleteE2tHandleHandler = handle.DeleteE2tHandleHandlerFunc(
483 func(params handle.DeleteE2tHandleParams) middleware.Responder {
484 err := deleteE2tHandleHandlerImpl(e2tdelchan, params.E2tData)
486 return handle.NewDeleteE2tHandleBadRequest()
488 time.Sleep(1 * time.Second)
489 return handle.NewDeleteE2tHandleCreated()
492 api.DebugGetDebuginfoHandler = debug.GetDebuginfoHandlerFunc(
493 func(params debug.GetDebuginfoParams) middleware.Responder {
494 response, err := dumpDebugData()
496 return debug.NewGetDebuginfoCreated()
498 return debug.NewGetDebuginfoOK().WithPayload(&response)
501 // start to serve API
502 xapp.Logger.Info("Starting the HTTP Rest service")
503 if err := server.Serve(); err != nil {
504 xapp.Logger.Error(err.Error())
508 func httpGetXApps(xmurl string) (*[]rtmgr.XApp, error) {
509 xapp.Logger.Info("Invoked httprestful.httpGetXApps: " + xmurl)
510 r, err := myClient.Get(xmurl)
516 if r.StatusCode == 200 {
517 xapp.Logger.Debug("http client raw response: %v", r)
518 var xapps []rtmgr.XApp
519 err = json.NewDecoder(r.Body).Decode(&xapps)
521 xapp.Logger.Warn("Json decode failed: " + err.Error())
523 xapp.Logger.Info("HTTP GET: OK")
524 xapp.Logger.Debug("httprestful.httpGetXApps returns: %v", xapps)
527 xapp.Logger.Warn("httprestful got an unexpected http status code: %v", r.StatusCode)
531 func httpGetE2TList(e2murl string) (*[]rtmgr.E2tIdentity, error) {
532 xapp.Logger.Info("Invoked httprestful.httpGetE2TList: " + e2murl)
533 r, err := myClient.Get(e2murl)
539 if r.StatusCode == 200 {
540 xapp.Logger.Debug("http client raw response: %v", r)
541 var E2Tlist []rtmgr.E2tIdentity
542 err = json.NewDecoder(r.Body).Decode(&E2Tlist)
544 xapp.Logger.Warn("Json decode failed: " + err.Error())
546 xapp.Logger.Info("HTTP GET: OK")
547 xapp.Logger.Debug("httprestful.httpGetXApps returns: %v", E2Tlist)
550 xapp.Logger.Warn("httprestful got an unexpected http status code: %v", r.StatusCode)
554 func PopulateE2TMap(e2tDataList *[]rtmgr.E2tIdentity, e2ts map[string]rtmgr.E2TInstance, meids []string) {
555 xapp.Logger.Info("Invoked httprestful.PopulateE2TMap ")
557 for _, e2tData := range *e2tDataList {
560 e2tinst := rtmgr.E2TInstance{
561 Ranlist: make([]string, len(e2tData.Rannames)),
564 e2tinst.Fqdn = e2tData.E2taddress
565 e2tinst.Name = "E2TERMINST"
566 copy(e2tinst.Ranlist, e2tData.Rannames)
568 if len(e2tData.Rannames) > 0 {
570 for _, meid := range e2tData.Rannames {
573 str += "mme_ar|" + e2tData.E2taddress + "|" + strings.TrimSuffix(meidar, " ")
576 e2ts[e2tinst.Fqdn] = e2tinst
577 meids = append(meids,str)
581 func retrieveStartupData(xmurl string, nbiif string, fileName string, configfile string, e2murl string, sdlEngine sdl.Engine) error {
582 xapp.Logger.Info("Invoked retrieveStartupData ")
585 var xappData *[]rtmgr.XApp
586 xappData = new([]rtmgr.XApp)
587 xapp.Logger.Info("Trying to fetch XApps data from XAPP manager")
588 for i := 1; i <= maxRetries; i++ {
589 time.Sleep(2 * time.Second)
592 xappData, err := httpGetXApps(xmurl)
593 if xappData != nil && err == nil {
595 } else if err == nil {
596 readErr = errors.New("unexpected HTTP status code")
598 xapp.Logger.Warn("cannot get xapp data due to: " + err.Error())
603 if ( readErr != nil) {
608 e2ts := make(map[string]rtmgr.E2TInstance)
609 xapp.Logger.Info("Trying to fetch E2T data from E2manager")
610 for i := 1; i <= maxRetries; i++ {
613 e2tDataList, err := httpGetE2TList(e2murl)
614 if e2tDataList != nil && err == nil {
615 PopulateE2TMap(e2tDataList, e2ts, meids[:])
617 } else if err == nil {
618 readErr = errors.New("unexpected HTTP status code")
620 xapp.Logger.Warn("cannot get E2T data from E2M due to: " + err.Error())
623 time.Sleep(2 * time.Second)
626 if ( readErr != nil) {
630 pcData, confErr := rtmgr.GetPlatformComponents(configfile)
632 xapp.Logger.Error(confErr.Error())
635 xapp.Logger.Info("Recieved intial xapp data, E2T data and platform data, writing into SDL.")
636 // Combine the xapps data and platform data before writing to the SDL
637 ricData := &rtmgr.RicComponents{XApps: *xappData, Pcs: *pcData, E2Ts: e2ts, MeidMap: meids}
638 writeErr := sdlEngine.WriteAll(fileName, ricData)
640 xapp.Logger.Error(writeErr.Error())
643 xapp.Logger.Info("Trying to fetch Subscriptions data from Subscription manager")
644 /* for i := 1; i <= maxRetries; i++ {
646 sub_list, err := xapp.Subscription.QuerySubscriptions()
648 if sub_list != nil && err == nil {
649 PopulateSubscription(sub_list)
653 xapp.Logger.Warn("cannot get xapp data due to: " + readErr.Error())
655 time.Sleep(2 * time.Second)
658 if (readErr != nil) {
662 // post subscription req to appmgr
663 readErr = PostSubReq(xmurl, nbiif)
671 func (r *HttpRestful) Initialize(xmurl string, nbiif string, fileName string, configfile string, e2murl string,
672 sdlEngine sdl.Engine, rpeEngine rpe.Engine, triggerSBI chan<- bool, m *sync.Mutex) error {
673 err := r.RetrieveStartupData(xmurl, nbiif, fileName, configfile, e2murl, sdlEngine)
675 xapp.Logger.Error("Exiting as nbi failed to get the initial startup data from the xapp manager: " + err.Error())
679 datach := make(chan *models.XappCallbackData, 10)
680 subschan := make(chan *models.XappSubscriptionData, 10)
681 subdelchan := make(chan *models.XappSubscriptionData, 10)
682 subupdatechan := make(chan *rtmgr.XappList, 10)
683 e2taddchan := make(chan *models.E2tData, 10)
684 associateranchan := make(chan models.RanE2tMap, 10)
685 disassociateranchan := make(chan models.RanE2tMap, 10)
686 e2tdelchan := make(chan *models.E2tDeleteData, 10)
687 xapp.Logger.Info("Launching Rest Http service")
689 r.LaunchRest(&nbiif, datach, subschan, subupdatechan, subdelchan, e2taddchan, associateranchan, disassociateranchan, e2tdelchan)
694 data, err := r.RecvXappCallbackData(datach)
696 xapp.Logger.Error("cannot get data from rest api dute to: " + err.Error())
697 } else if data != nil {
698 xapp.Logger.Debug("Fetching all xApps deployed in xApp Manager through GET operation.")
699 alldata, err1 := httpGetXApps(xmurl)
700 if alldata != nil && err1 == nil {
702 sdlEngine.WriteXApps(fileName, alldata)
713 xapp.Logger.Debug("received XApp subscription data")
714 addSubscription(&rtmgr.Subs, data)
722 xapp.Logger.Debug("received XApp subscription delete data")
723 delSubscription(&rtmgr.Subs, data)
730 data := <-subupdatechan
731 xapp.Logger.Debug("received XApp subscription Merge data")
732 updateSubscription(data)
740 data, meiddata, _ := r.RecvNewE2Tdata(e2taddchan)
742 xapp.Logger.Debug("received create New E2T data")
744 sdlEngine.WriteNewE2TInstance(fileName, data, meiddata)
753 data := <-associateranchan
754 xapp.Logger.Debug("received associate RAN list to E2T instance mapping from E2 Manager")
756 sdlEngine.WriteAssRANToE2TInstance(fileName, data)
765 data := <-disassociateranchan
766 xapp.Logger.Debug("received disassociate RANs from E2T instance")
768 sdlEngine.WriteDisAssRANFromE2TInstance(fileName, data)
778 xapp.Logger.Debug("received Delete E2T data")
781 sdlEngine.WriteDeleteE2TInstance(fileName, data)
791 func (r *HttpRestful) Terminate() error {
795 func addSubscription(subs *rtmgr.SubscriptionList, xappSubData *models.XappSubscriptionData) bool {
796 xapp.Logger.Debug("Adding the subscription into the subscriptions list")
798 sub := rtmgr.Subscription{SubID: *xappSubData.SubscriptionID, Fqdn: *xappSubData.Address, Port: *xappSubData.Port}
799 for _, elem := range *subs {
801 xapp.Logger.Warn("rtmgr.addSubscription: Subscription already present: %v", elem)
806 *subs = append(*subs, sub)
811 func delSubscription(subs *rtmgr.SubscriptionList, xappSubData *models.XappSubscriptionData) bool {
812 xapp.Logger.Debug("Deleteing the subscription from the subscriptions list")
814 sub := rtmgr.Subscription{SubID: *xappSubData.SubscriptionID, Fqdn: *xappSubData.Address, Port: *xappSubData.Port}
815 for i, elem := range *subs {
818 // Since the order of the list is not important, we are swapping the last element
819 // with the matching element and replacing the list with list(n-1) elements.
820 (*subs)[len(*subs)-1], (*subs)[i] = (*subs)[i], (*subs)[len(*subs)-1]
821 *subs = (*subs)[:len(*subs)-1]
825 if present == false {
826 xapp.Logger.Warn("rtmgr.delSubscription: Subscription = %v, not present in the existing subscriptions", xappSubData)
831 func updateSubscription(data *rtmgr.XappList) {
833 var subdata models.XappSubscriptionData
835 var matchingsubid, deletecount uint8
836 id = int32(data.SubscriptionID)
837 subdata.SubscriptionID = &id
838 for _, subs := range rtmgr.Subs {
839 if int32(data.SubscriptionID) == subs.SubID {
844 for deletecount < matchingsubid {
845 for _, subs := range rtmgr.Subs {
846 if int32(data.SubscriptionID) == subs.SubID {
847 subdata.SubscriptionID = &subs.SubID
848 subdata.Address = &subs.Fqdn
849 subdata.Port = &subs.Port
850 xapp.Logger.Debug("Deletion Subscription List has %v", subdata)
851 delSubscription(&rtmgr.Subs, &subdata)
858 for _, items := range data.FqdnList {
859 subdata.Address = items.Address
860 subdata.Port = items.Port
861 xapp.Logger.Debug("Adding Subscription List has %v", subdata)
862 addSubscription(&rtmgr.Subs, &subdata)
867 func PopulateSubscription(sub_list xfmodel.SubscriptionList) {
868 for _, sub_row := range sub_list {
869 var subdata models.XappSubscriptionData
870 id := int32(sub_row.SubscriptionID)
871 subdata.SubscriptionID = &id
872 for _, ep := range sub_row.Endpoint {
874 stringSlice := strings.Split(ep, ":")
875 subdata.Address = &stringSlice[0]
876 intportval, _ := strconv.Atoi( stringSlice[1])
877 value := uint16(intportval)
878 subdata.Port = &value
879 xapp.Logger.Debug("Adding Subscription List has Address :%v, port :%v, SubscriptionID :%v ", subdata.Address, subdata.Address, subdata.SubscriptionID)
880 addSubscription(&rtmgr.Subs, &subdata)