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 {
168 e2taddress_key := *data.E2TAddress
169 if e2taddress_key == "" {
170 return fmt.Errorf("E2TAddress is empty!!!")
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)
177 _, err := net.LookupIP(stringSlice[0])
179 return fmt.Errorf("E2T E2TAddress DNS look up failed, E2TAddress: %v", stringSlice[0])
182 if checkValidaE2TAddress(e2taddress_key) {
183 return fmt.Errorf("E2TAddress already exist!!!, E2TAddress: %v", e2taddress_key)
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 := validateE2tData(data)
293 xapp.Logger.Error(err.Error())
297 e2data, meiddata, _ := recvNewE2Tdata(data)
298 xapp.Logger.Debug("received create New E2T data")
300 sdlEngine.WriteNewE2TInstance(xapp.Config.GetString("rtfile"), e2data, meiddata)
302 return sendRoutesToAll()
306 func validateE2TAddressRANListData(assRanE2tData models.RanE2tMap) error {
308 xapp.Logger.Debug("Invoked.validateE2TAddressRANListData : %v", assRanE2tData)
310 for _, element := range assRanE2tData {
311 if *element.E2TAddress == "" {
312 return fmt.Errorf("E2T Instance - E2TAddress is empty!!!")
315 e2taddress_key := *element.E2TAddress
316 if !checkValidaE2TAddress(e2taddress_key) {
317 return fmt.Errorf("E2TAddress doesn't exist!!!, E2TAddress: %v", e2taddress_key)
324 func associateRanToE2THandlerImpl(data models.RanE2tMap) error {
325 xapp.Logger.Debug("Invoked associateRanToE2THandlerImpl")
326 err := validateE2TAddressRANListData(data)
328 xapp.Logger.Warn(" Association of RAN to E2T Instance data validation failed: " + err.Error())
331 xapp.Logger.Debug("received associate RAN list to E2T instance mapping from E2 Manager")
333 sdlEngine.WriteAssRANToE2TInstance(xapp.Config.GetString("rtfile"), data)
335 return sendRoutesToAll()
339 func disassociateRanToE2THandlerImpl(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 xapp.Logger.Debug("received disassociate RANs from E2T instance")
348 sdlEngine.WriteDisAssRANFromE2TInstance(xapp.Config.GetString("rtfile"), data)
350 return sendRoutesToAll()
354 func deleteE2tHandleHandlerImpl(data *models.E2tDeleteData) error {
355 xapp.Logger.Debug("Invoked deleteE2tHandleHandlerImpl")
357 err := validateDeleteE2tData(data)
359 xapp.Logger.Error(err.Error())
363 sdlEngine.WriteDeleteE2TInstance(xapp.Config.GetString("rtfile"), data)
365 return sendRoutesToAll()
369 func dumpDebugData() (models.Debuginfo, error) {
370 var response models.Debuginfo
371 sdlEngine, _ := sdl.GetSdl("file")
372 rpeEngine, _ := rpe.GetRpe("rmrpush")
373 data, err := sdlEngine.ReadAll(xapp.Config.GetString("rtfile"))
376 xapp.Logger.Error("Cannot get data from sdl interface due to: " + err.Error())
379 xapp.Logger.Debug("Cannot get data from sdl interface")
380 return response, errors.New("Cannot get data from sdl interface")
383 response.RouteTable = *rpeEngine.GeneratePolicies(rtmgr.Eps, data)
385 prettyJSON, err := json.MarshalIndent(data, "", "")
386 response.RouteConfigs = string(prettyJSON)
391 func launchRest(nbiif *string){
392 swaggerSpec, err := loads.Embedded(restapi.SwaggerJSON, restapi.FlatSwaggerJSON)
395 xapp.Logger.Error(err.Error())
398 nbiUrl, err := url.Parse(*nbiif)
400 xapp.Logger.Error(err.Error())
403 api := operations.NewRoutingManagerAPI(swaggerSpec)
404 server := restapi.NewServer(api)
405 defer server.Shutdown()
407 server.Port, err = strconv.Atoi(nbiUrl.Port())
409 xapp.Logger.Error("Invalid NBI RestAPI port")
412 server.Host = "0.0.0.0"
414 api.HandleProvideXappHandleHandler = handle.ProvideXappHandleHandlerFunc(
415 func(params handle.ProvideXappHandleParams) middleware.Responder {
416 xapp.Logger.Info("Data received on Http interface")
417 err := provideXappHandleHandlerImpl(params.XappCallbackData)
419 xapp.Logger.Error("Invalid XApp callback data: " + err.Error())
420 return handle.NewProvideXappHandleBadRequest()
422 return handle.NewGetHandlesOK()
425 api.HandleProvideXappSubscriptionHandleHandler = handle.ProvideXappSubscriptionHandleHandlerFunc(
426 func(params handle.ProvideXappSubscriptionHandleParams) middleware.Responder {
427 err := provideXappSubscriptionHandleImpl(params.XappSubscriptionData)
429 return handle.NewProvideXappSubscriptionHandleBadRequest()
431 return handle.NewGetHandlesOK()
434 api.HandleDeleteXappSubscriptionHandleHandler = handle.DeleteXappSubscriptionHandleHandlerFunc(
435 func(params handle.DeleteXappSubscriptionHandleParams) middleware.Responder {
436 err := deleteXappSubscriptionHandleImpl(params.XappSubscriptionData)
438 return handle.NewDeleteXappSubscriptionHandleNoContent()
440 return handle.NewGetHandlesOK()
443 api.HandleUpdateXappSubscriptionHandleHandler = handle.UpdateXappSubscriptionHandleHandlerFunc(
444 func(params handle.UpdateXappSubscriptionHandleParams) middleware.Responder {
445 err := updateXappSubscriptionHandleImpl(¶ms.XappList, params.SubscriptionID)
447 return handle.NewUpdateXappSubscriptionHandleBadRequest()
449 return handle.NewUpdateXappSubscriptionHandleCreated()
452 api.HandleCreateNewE2tHandleHandler = handle.CreateNewE2tHandleHandlerFunc(
453 func(params handle.CreateNewE2tHandleParams) middleware.Responder {
454 err := createNewE2tHandleHandlerImpl(params.E2tData)
456 return handle.NewCreateNewE2tHandleBadRequest()
458 return handle.NewCreateNewE2tHandleCreated()
462 api.HandleAssociateRanToE2tHandleHandler = handle.AssociateRanToE2tHandleHandlerFunc(
463 func(params handle.AssociateRanToE2tHandleParams) middleware.Responder {
464 err := associateRanToE2THandlerImpl(params.RanE2tList)
466 return handle.NewAssociateRanToE2tHandleBadRequest()
468 return handle.NewAssociateRanToE2tHandleCreated()
472 api.HandleDissociateRanHandler = handle.DissociateRanHandlerFunc(
473 func(params handle.DissociateRanParams) middleware.Responder {
474 err := disassociateRanToE2THandlerImpl(params.DissociateList)
476 return handle.NewDissociateRanBadRequest()
478 return handle.NewDissociateRanCreated()
482 api.HandleDeleteE2tHandleHandler = handle.DeleteE2tHandleHandlerFunc(
483 func(params handle.DeleteE2tHandleParams) middleware.Responder {
484 err := deleteE2tHandleHandlerImpl(params.E2tData)
486 return handle.NewDeleteE2tHandleBadRequest()
488 return handle.NewDeleteE2tHandleCreated()
491 api.DebugGetDebuginfoHandler = debug.GetDebuginfoHandlerFunc(
492 func(params debug.GetDebuginfoParams) middleware.Responder {
493 response, err := dumpDebugData()
495 return debug.NewGetDebuginfoCreated()
497 return debug.NewGetDebuginfoOK().WithPayload(&response)
500 api.HandleAddRmrRouteHandler = handle.AddRmrRouteHandlerFunc(
501 func(params handle.AddRmrRouteParams) middleware.Responder {
502 err := adddelrmrroute(params.RoutesList,true)
504 return handle.NewAddRmrRouteBadRequest()
506 return handle.NewAddRmrRouteCreated()
510 api.HandleDelRmrRouteHandler = handle.DelRmrRouteHandlerFunc(
511 func(params handle.DelRmrRouteParams) middleware.Responder {
512 err := adddelrmrroute(params.RoutesList,false)
514 return handle.NewDelRmrRouteBadRequest()
516 return handle.NewDelRmrRouteCreated()
520 // start to serve API
521 xapp.Logger.Info("Starting the HTTP Rest service")
522 if err := server.Serve(); err != nil {
523 xapp.Logger.Error(err.Error())
527 func httpGetXApps(xmurl string) (*[]rtmgr.XApp, error) {
528 xapp.Logger.Info("Invoked httprestful.httpGetXApps: " + xmurl)
529 r, err := myClient.Get(xmurl)
535 if r.StatusCode == 200 {
536 xapp.Logger.Debug("http client raw response: %v", r)
537 var xapps []rtmgr.XApp
538 err = json.NewDecoder(r.Body).Decode(&xapps)
540 xapp.Logger.Warn("Json decode failed: " + err.Error())
542 xapp.Logger.Info("HTTP GET: OK")
543 xapp.Logger.Debug("httprestful.httpGetXApps returns: %v", xapps)
546 xapp.Logger.Warn("httprestful got an unexpected http status code: %v", r.StatusCode)
550 func httpGetE2TList(e2murl string) (*[]rtmgr.E2tIdentity, error) {
551 xapp.Logger.Info("Invoked httprestful.httpGetE2TList: " + e2murl)
552 r, err := myClient.Get(e2murl)
558 if r.StatusCode == 200 {
559 xapp.Logger.Debug("http client raw response: %v", r)
560 var E2Tlist []rtmgr.E2tIdentity
561 err = json.NewDecoder(r.Body).Decode(&E2Tlist)
563 xapp.Logger.Warn("Json decode failed: " + err.Error())
565 xapp.Logger.Info("HTTP GET: OK")
566 xapp.Logger.Debug("httprestful.httpGetXApps returns: %v", E2Tlist)
569 xapp.Logger.Warn("httprestful got an unexpected http status code: %v", r.StatusCode)
573 func PopulateE2TMap(e2tDataList *[]rtmgr.E2tIdentity, e2ts map[string]rtmgr.E2TInstance, meids []string) {
574 xapp.Logger.Info("Invoked httprestful.PopulateE2TMap ")
576 for _, e2tData := range *e2tDataList {
579 e2tinst := rtmgr.E2TInstance{
580 Ranlist: make([]string, len(e2tData.Rannames)),
583 e2tinst.Fqdn = e2tData.E2taddress
584 e2tinst.Name = "E2TERMINST"
585 copy(e2tinst.Ranlist, e2tData.Rannames)
587 if len(e2tData.Rannames) > 0 {
589 for _, meid := range e2tData.Rannames {
592 str += "mme_ar|" + e2tData.E2taddress + "|" + strings.TrimSuffix(meidar, " ")
595 e2ts[e2tinst.Fqdn] = e2tinst
596 meids = append(meids, str)
600 func retrieveStartupData(xmurl string, nbiif string, fileName string, configfile string, e2murl string, sdlEngine sdl.Engine) error {
601 xapp.Logger.Info("Invoked retrieveStartupData ")
605 var xappData *[]rtmgr.XApp
606 xappData = new([]rtmgr.XApp)
607 xapp.Logger.Info("Trying to fetch XApps data from XAPP manager")
608 for i := 1; i <= maxRetries; i++ {
609 time.Sleep(2 * time.Second)
612 xappData, err = httpGetXApps(xmurl)
613 if xappData != nil && err == nil {
615 } else if err == nil {
616 readErr = errors.New("unexpected HTTP status code")
618 xapp.Logger.Warn("cannot get xapp data due to: " + err.Error())
628 e2ts := make(map[string]rtmgr.E2TInstance)
629 xapp.Logger.Info("Trying to fetch E2T data from E2manager")
630 for i := 1; i <= maxRetries; i++ {
633 e2tDataList, err := httpGetE2TList(e2murl)
634 if e2tDataList != nil && err == nil {
635 PopulateE2TMap(e2tDataList, e2ts, meids[:])
637 } else if err == nil {
638 readErr = errors.New("unexpected HTTP status code")
640 xapp.Logger.Warn("cannot get E2T data from E2M due to: " + err.Error())
643 time.Sleep(2 * time.Second)
650 pcData, confErr := rtmgr.GetPlatformComponents(configfile)
652 xapp.Logger.Error(confErr.Error())
655 xapp.Logger.Info("Recieved intial xapp data, E2T data and platform data, writing into SDL.")
656 // Combine the xapps data and platform data before writing to the SDL
657 ricData := &rtmgr.RicComponents{XApps: *xappData, Pcs: *pcData, E2Ts: e2ts, MeidMap: meids}
658 writeErr := sdlEngine.WriteAll(fileName, ricData)
660 xapp.Logger.Error(writeErr.Error())
663 xapp.Logger.Info("Trying to fetch Subscriptions data from Subscription manager")
664 for i := 1; i <= maxRetries; i++ {
666 sub_list, err := xapp.Subscription.QuerySubscriptions()
668 if sub_list != nil && err == nil {
669 PopulateSubscription(sub_list)
673 xapp.Logger.Warn("cannot get xapp data due to: " + readErr.Error())
675 time.Sleep(2 * time.Second)
682 // post subscription req to appmgr
683 readErr = PostSubReq(xmurl, nbiif)
688 //rlist := make(map[string]string)
689 xapp.Logger.Info("Reading SDL for any routes")
690 rlist,sdlerr := xapp.Sdl.Read("routes")
693 xapp.Logger.Info("Value is %s",rlist["routes"])
694 if rlist["routes"] != nil {
695 formstring := fmt.Sprintf("%s",rlist["routes"])
696 xapp.Logger.Info("Value of formed string = %s",formstring)
697 newstring := strings.Split(formstring," ")
698 for i,_ := range newstring {
699 xapp.Logger.Info("in Loop Value of formed string = %s",newstring)
700 rtmgr.DynamicRouteList = append(rtmgr.DynamicRouteList,newstring[i])
710 func (r *HttpRestful) Initialize(xmurl string, nbiif string, fileName string, configfile string, e2murl string,
711 sdlEngine sdl.Engine, rpeEngine rpe.Engine, m *sync.Mutex) error {
712 err := r.RetrieveStartupData(xmurl, nbiif, fileName, configfile, e2murl, sdlEngine)
714 xapp.Logger.Error("Exiting as nbi failed to get the initial startup data from the xapp manager: " + err.Error())
724 func (r *HttpRestful) Terminate() error {
728 func addSubscription(subs *rtmgr.SubscriptionList, xappSubData *models.XappSubscriptionData) bool {
729 xapp.Logger.Debug("Adding the subscription into the subscriptions list")
731 sub := rtmgr.Subscription{SubID: *xappSubData.SubscriptionID, Fqdn: *xappSubData.Address, Port: *xappSubData.Port}
732 for _, elem := range *subs {
734 xapp.Logger.Warn("rtmgr.addSubscription: Subscription already present: %v", elem)
739 *subs = append(*subs, sub)
744 func delSubscription(subs *rtmgr.SubscriptionList, xappSubData *models.XappSubscriptionData) bool {
745 xapp.Logger.Debug("Deleteing the subscription from the subscriptions list")
747 sub := rtmgr.Subscription{SubID: *xappSubData.SubscriptionID, Fqdn: *xappSubData.Address, Port: *xappSubData.Port}
748 for i, elem := range *subs {
751 // Since the order of the list is not important, we are swapping the last element
752 // with the matching element and replacing the list with list(n-1) elements.
753 (*subs)[len(*subs)-1], (*subs)[i] = (*subs)[i], (*subs)[len(*subs)-1]
754 *subs = (*subs)[:len(*subs)-1]
758 if present == false {
759 xapp.Logger.Warn("rtmgr.delSubscription: Subscription = %v, not present in the existing subscriptions", xappSubData)
764 func updateSubscription(data *rtmgr.XappList) {
766 var subdata models.XappSubscriptionData
768 var matchingsubid, deletecount uint8
769 id = int32(data.SubscriptionID)
770 subdata.SubscriptionID = &id
771 for _, subs := range rtmgr.Subs {
772 if int32(data.SubscriptionID) == subs.SubID {
777 for deletecount < matchingsubid {
778 for _, subs := range rtmgr.Subs {
779 if int32(data.SubscriptionID) == subs.SubID {
780 subdata.SubscriptionID = &subs.SubID
781 subdata.Address = &subs.Fqdn
782 subdata.Port = &subs.Port
783 xapp.Logger.Debug("Deletion Subscription List has %v", subdata)
784 delSubscription(&rtmgr.Subs, &subdata)
791 for _, items := range data.FqdnList {
792 subdata.Address = items.Address
793 subdata.Port = items.Port
794 xapp.Logger.Debug("Adding Subscription List has %v", subdata)
795 addSubscription(&rtmgr.Subs, &subdata)
800 func PopulateSubscription(sub_list xfmodel.SubscriptionList) {
801 for _, sub_row := range sub_list {
802 var subdata models.XappSubscriptionData
803 id := int32(sub_row.SubscriptionID)
804 subdata.SubscriptionID = &id
805 for _, ep := range sub_row.Endpoint {
807 stringSlice := strings.Split(ep, ":")
808 subdata.Address = &stringSlice[0]
809 intportval, _ := strconv.Atoi(stringSlice[1])
810 value := uint16(intportval)
811 subdata.Port = &value
812 xapp.Logger.Debug("Adding Subscription List has Address :%v, port :%v, SubscriptionID :%v ", subdata.Address, subdata.Address, subdata.SubscriptionID)
813 addSubscription(&rtmgr.Subs, &subdata)
818 func adddelrmrroute(routelist models.Routelist,rtflag bool) error {
819 xapp.Logger.Info("Updating rmrroute with Route list: %v,flag: %v", routelist,rtflag)
820 for _, rlist := range routelist {
823 if rlist.SubscriptionID == 0 {
826 subid = rlist.SubscriptionID
828 if rlist.SenderEndPoint == "" && rlist.SubscriptionID != 0 {
829 data = fmt.Sprintf("mse|%d|%d|%s\n",*rlist.MessageType,rlist.SubscriptionID,*rlist.TargetEndPoint)
830 } else if rlist.SenderEndPoint == "" && rlist.SubscriptionID == 0 {
831 data = fmt.Sprintf("mse|%d|-1|%s\n",*rlist.MessageType,*rlist.TargetEndPoint)
833 data = fmt.Sprintf("mse|%d,%s|%d|%s\n",*rlist.MessageType,rlist.SenderEndPoint,subid,*rlist.TargetEndPoint)
835 err := checkrepeatedroute(data)
839 xapp.Logger.Info("Given route %s is a duplicate",data)
841 rtmgr.DynamicRouteList = append(rtmgr.DynamicRouteList,data)
842 routearray := strings.Join(rtmgr.DynamicRouteList," ")
843 xapp.Sdl.Store("routes",routearray)
846 xapp.Logger.Info("Successfully deleted route: %s",data)
847 routearray := strings.Join(rtmgr.DynamicRouteList," ")
848 xapp.Sdl.Store("routes",routearray)
850 xapp.Logger.Info("No such route: %s",data)
851 return errors.New("No such route: " + data)
856 return sendRoutesToAll()
859 func checkrepeatedroute (data string) bool {
860 for i:=0;i<len(rtmgr.DynamicRouteList);i++ {
861 if rtmgr.DynamicRouteList[i] == data {
862 rtmgr.DynamicRouteList[i] = rtmgr.DynamicRouteList[len(rtmgr.DynamicRouteList)-1]
863 rtmgr.DynamicRouteList[len(rtmgr.DynamicRouteList)-1] = ""
864 rtmgr.DynamicRouteList = rtmgr.DynamicRouteList[:len(rtmgr.DynamicRouteList)-1]