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 //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 ")
586 var xappData *[]rtmgr.XApp
587 xappData = new([]rtmgr.XApp)
588 xapp.Logger.Info("Trying to fetch XApps data from XAPP manager")
589 for i := 1; i <= maxRetries; i++ {
590 time.Sleep(2 * time.Second)
593 xappData, err = httpGetXApps(xmurl)
594 if xappData != nil && err == nil {
596 } else if err == nil {
597 readErr = errors.New("unexpected HTTP status code")
599 xapp.Logger.Warn("cannot get xapp data due to: " + err.Error())
609 e2ts := make(map[string]rtmgr.E2TInstance)
610 xapp.Logger.Info("Trying to fetch E2T data from E2manager")
611 for i := 1; i <= maxRetries; i++ {
614 e2tDataList, err := httpGetE2TList(e2murl)
615 if e2tDataList != nil && err == nil {
616 PopulateE2TMap(e2tDataList, e2ts, meids[:])
618 } else if err == nil {
619 readErr = errors.New("unexpected HTTP status code")
621 xapp.Logger.Warn("cannot get E2T data from E2M due to: " + err.Error())
624 time.Sleep(2 * time.Second)
631 pcData, confErr := rtmgr.GetPlatformComponents(configfile)
633 xapp.Logger.Error(confErr.Error())
636 xapp.Logger.Info("Recieved intial xapp data, E2T data and platform data, writing into SDL.")
637 // Combine the xapps data and platform data before writing to the SDL
638 ricData := &rtmgr.RicComponents{XApps: *xappData, Pcs: *pcData, E2Ts: e2ts, MeidMap: meids}
639 writeErr := sdlEngine.WriteAll(fileName, ricData)
641 xapp.Logger.Error(writeErr.Error())
644 xapp.Logger.Info("Trying to fetch Subscriptions data from Subscription manager")
645 for i := 1; i <= maxRetries; i++ {
647 sub_list, err := xapp.Subscription.QuerySubscriptions()
649 if sub_list != nil && err == nil {
650 PopulateSubscription(sub_list)
654 xapp.Logger.Warn("cannot get xapp data due to: " + readErr.Error())
656 time.Sleep(2 * time.Second)
663 // post subscription req to appmgr
664 readErr = PostSubReq(xmurl, nbiif)
672 func (r *HttpRestful) Initialize(xmurl string, nbiif string, fileName string, configfile string, e2murl string,
673 sdlEngine sdl.Engine, rpeEngine rpe.Engine, triggerSBI chan<- bool, m *sync.Mutex) error {
674 err := r.RetrieveStartupData(xmurl, nbiif, fileName, configfile, e2murl, sdlEngine)
676 xapp.Logger.Error("Exiting as nbi failed to get the initial startup data from the xapp manager: " + err.Error())
680 datach := make(chan *models.XappCallbackData, 10)
681 subschan := make(chan *models.XappSubscriptionData, 10)
682 subdelchan := make(chan *models.XappSubscriptionData, 10)
683 subupdatechan := make(chan *rtmgr.XappList, 10)
684 e2taddchan := make(chan *models.E2tData, 10)
685 associateranchan := make(chan models.RanE2tMap, 10)
686 disassociateranchan := make(chan models.RanE2tMap, 10)
687 e2tdelchan := make(chan *models.E2tDeleteData, 10)
688 xapp.Logger.Info("Launching Rest Http service")
690 r.LaunchRest(&nbiif, datach, subschan, subupdatechan, subdelchan, e2taddchan, associateranchan, disassociateranchan, e2tdelchan)
695 data, err := r.RecvXappCallbackData(datach)
697 xapp.Logger.Error("cannot get data from rest api dute to: " + err.Error())
698 } else if data != nil {
699 xapp.Logger.Debug("Fetching all xApps deployed in xApp Manager through GET operation.")
700 alldata, err1 := httpGetXApps(xmurl)
701 if alldata != nil && err1 == nil {
703 sdlEngine.WriteXApps(fileName, alldata)
714 xapp.Logger.Debug("received XApp subscription data")
715 addSubscription(&rtmgr.Subs, data)
723 xapp.Logger.Debug("received XApp subscription delete data")
724 delSubscription(&rtmgr.Subs, data)
731 data := <-subupdatechan
732 xapp.Logger.Debug("received XApp subscription Merge data")
733 updateSubscription(data)
741 data, meiddata, _ := r.RecvNewE2Tdata(e2taddchan)
743 xapp.Logger.Debug("received create New E2T data")
745 sdlEngine.WriteNewE2TInstance(fileName, data, meiddata)
754 data := <-associateranchan
755 xapp.Logger.Debug("received associate RAN list to E2T instance mapping from E2 Manager")
757 sdlEngine.WriteAssRANToE2TInstance(fileName, data)
766 data := <-disassociateranchan
767 xapp.Logger.Debug("received disassociate RANs from E2T instance")
769 sdlEngine.WriteDisAssRANFromE2TInstance(fileName, data)
779 xapp.Logger.Debug("received Delete E2T data")
782 sdlEngine.WriteDeleteE2TInstance(fileName, data)
792 func (r *HttpRestful) Terminate() error {
796 func addSubscription(subs *rtmgr.SubscriptionList, xappSubData *models.XappSubscriptionData) bool {
797 xapp.Logger.Debug("Adding the subscription into the subscriptions list")
799 sub := rtmgr.Subscription{SubID: *xappSubData.SubscriptionID, Fqdn: *xappSubData.Address, Port: *xappSubData.Port}
800 for _, elem := range *subs {
802 xapp.Logger.Warn("rtmgr.addSubscription: Subscription already present: %v", elem)
807 *subs = append(*subs, sub)
812 func delSubscription(subs *rtmgr.SubscriptionList, xappSubData *models.XappSubscriptionData) bool {
813 xapp.Logger.Debug("Deleteing the subscription from the subscriptions list")
815 sub := rtmgr.Subscription{SubID: *xappSubData.SubscriptionID, Fqdn: *xappSubData.Address, Port: *xappSubData.Port}
816 for i, elem := range *subs {
819 // Since the order of the list is not important, we are swapping the last element
820 // with the matching element and replacing the list with list(n-1) elements.
821 (*subs)[len(*subs)-1], (*subs)[i] = (*subs)[i], (*subs)[len(*subs)-1]
822 *subs = (*subs)[:len(*subs)-1]
826 if present == false {
827 xapp.Logger.Warn("rtmgr.delSubscription: Subscription = %v, not present in the existing subscriptions", xappSubData)
832 func updateSubscription(data *rtmgr.XappList) {
834 var subdata models.XappSubscriptionData
836 var matchingsubid, deletecount uint8
837 id = int32(data.SubscriptionID)
838 subdata.SubscriptionID = &id
839 for _, subs := range rtmgr.Subs {
840 if int32(data.SubscriptionID) == subs.SubID {
845 for deletecount < matchingsubid {
846 for _, subs := range rtmgr.Subs {
847 if int32(data.SubscriptionID) == subs.SubID {
848 subdata.SubscriptionID = &subs.SubID
849 subdata.Address = &subs.Fqdn
850 subdata.Port = &subs.Port
851 xapp.Logger.Debug("Deletion Subscription List has %v", subdata)
852 delSubscription(&rtmgr.Subs, &subdata)
859 for _, items := range data.FqdnList {
860 subdata.Address = items.Address
861 subdata.Port = items.Port
862 xapp.Logger.Debug("Adding Subscription List has %v", subdata)
863 addSubscription(&rtmgr.Subs, &subdata)
868 func PopulateSubscription(sub_list xfmodel.SubscriptionList) {
869 for _, sub_row := range sub_list {
870 var subdata models.XappSubscriptionData
871 id := int32(sub_row.SubscriptionID)
872 subdata.SubscriptionID = &id
873 for _, ep := range sub_row.Endpoint {
875 stringSlice := strings.Split(ep, ":")
876 subdata.Address = &stringSlice[0]
877 intportval, _ := strconv.Atoi(stringSlice[1])
878 value := uint16(intportval)
879 subdata.Port = &value
880 xapp.Logger.Debug("Adding Subscription List has Address :%v, port :%v, SubscriptionID :%v ", subdata.Address, subdata.Address, subdata.SubscriptionID)
881 addSubscription(&rtmgr.Subs, &subdata)