type HttpRestful struct {
Engine
- LaunchRest LaunchRestHandler
- RetrieveStartupData RetrieveStartupDataHandler
+ LaunchRest LaunchRestHandler
+ RetrieveStartupData RetrieveStartupDataHandler
}
func NewHttpRestful() *HttpRestful {
}
func provideXappHandleHandlerImpl(data *models.XappCallbackData) error {
- if data != nil {
+ if data == nil {
xapp.Logger.Debug("Received callback data")
+ return nil
}
err := validateXappCallbackData(data)
if err != nil {
return err
} else {
appdata, err := recvXappCallbackData(data)
- if err != nil {
+ if err != nil {
xapp.Logger.Error("cannot get data from rest api dute to: " + err.Error())
- } else if appdata != nil {
- xapp.Logger.Debug("Fetching all xApps deployed in xApp Manager through GET operation.")
- alldata, err1 := httpGetXApps(xapp.Config.GetString("xmurl"))
- if alldata != nil && err1 == nil {
- m.Lock()
- sdlEngine.WriteXApps(xapp.Config.GetString("rtfile"), alldata)
- m.Unlock()
+ } else if appdata != nil {
+ xapp.Logger.Debug("Fetching all xApps deployed in xApp Manager through GET operation.")
+ alldata, err1 := httpGetXApps(xapp.Config.GetString("xmurl"))
+ if alldata != nil && err1 == nil {
+ m.Lock()
+ sdlEngine.WriteXApps(xapp.Config.GetString("rtfile"), alldata)
+ m.Unlock()
+ updateEp()
return sendRoutesToAll()
- }
- }
+ //return sendPartialRoutesToAll(nil, rtmgr.XappType)
+ }
+ }
return nil
}
return err
}
-func validateE2tData(data *models.E2tData) error {
+func validateE2tData(data *models.E2tData) (error, bool) {
e2taddress_key := *data.E2TAddress
if e2taddress_key == "" {
- return fmt.Errorf("E2TAddress is empty!!!")
+ return fmt.Errorf("E2TAddress is empty!!!"), false
}
stringSlice := strings.Split(e2taddress_key, ":")
if len(stringSlice) == 1 {
- return fmt.Errorf("E2T E2TAddress is not a proper format like ip:port, %v", e2taddress_key)
+ return fmt.Errorf("E2T E2TAddress is not a proper format like ip:port, %v", e2taddress_key), false
}
_, err := net.LookupIP(stringSlice[0])
if err != nil {
- return fmt.Errorf("E2T E2TAddress DNS look up failed, E2TAddress: %v", stringSlice[0])
+ return fmt.Errorf("E2T E2TAddress DNS look up failed, E2TAddress: %v", stringSlice[0]), false
}
if checkValidaE2TAddress(e2taddress_key) {
- return fmt.Errorf("E2TAddress already exist!!!, E2TAddress: %v", e2taddress_key)
+ return fmt.Errorf("E2TAddress already exist!!!, E2TAddress: %v", e2taddress_key), true
}
- return nil
+ return nil, false
}
func validateDeleteE2tData(data *models.E2tDeleteData) error {
xapp.Logger.Error(err.Error())
return err
}
- xapp.Logger.Debug("received XApp subscription data")
- addSubscription(&rtmgr.Subs, data)
+ xapp.Logger.Debug("received XApp subscription data")
+ addSubscription(&rtmgr.Subs, data)
xapp.Logger.Debug("Endpoints: %v", rtmgr.Eps)
- return sendRoutesToAll()
+ updateEp()
+ return sendPartialRoutesToAll(data, rtmgr.SubsType)
}
func subscriptionExists(data *models.XappSubscriptionData) bool {
return err
}
- xapp.Logger.Debug("received XApp subscription delete data")
- delSubscription(&rtmgr.Subs, data)
+ xapp.Logger.Debug("received XApp subscription delete data")
+ delSubscription(&rtmgr.Subs, data)
+ updateEp()
return sendRoutesToAll()
}
return err
}
}
- xapp.Logger.Debug("received XApp subscription Merge data")
- updateSubscription(&xapplist)
+ xapp.Logger.Debug("received XApp subscription Merge data")
+ updateSubscription(&xapplist)
+ updateEp()
return sendRoutesToAll()
}
func createNewE2tHandleHandlerImpl(data *models.E2tData) error {
xapp.Logger.Debug("Invoked createNewE2tHandleHandlerImpl")
- err := validateE2tData(data)
+ err, IsDuplicate := validateE2tData(data)
+ if IsDuplicate == true {
+ updateEp()
+ //return sendPartialRoutesToAll(nil, rtmgr.E2Type)
+ return sendRoutesToAll()
+ }
+
if err != nil {
xapp.Logger.Error(err.Error())
return err
}
//e2taddchan <- data
e2data, meiddata, _ := recvNewE2Tdata(data)
- xapp.Logger.Debug("received create New E2T data")
- m.Lock()
- sdlEngine.WriteNewE2TInstance(xapp.Config.GetString("rtfile"), e2data, meiddata)
- m.Unlock()
- return sendRoutesToAll()
+ xapp.Logger.Debug("received create New E2T data")
+ m.Lock()
+ sdlEngine.WriteNewE2TInstance(xapp.Config.GetString("rtfile"), e2data, meiddata)
+ m.Unlock()
+ updateEp()
+ //sendPartialRoutesToAll(nil, rtmgr.E2Type)
+ sendRoutesToAll()
+ time.Sleep(10 * time.Second)
+ for ep, value := range rtmgr.RMRConnStatus {
+ if ep == *data.E2TAddress && value == true {
+ return nil
+ }
+ }
+
+ return errors.New("Error while adding new E2T " + *data.E2TAddress)
}
xapp.Logger.Warn(" Association of RAN to E2T Instance data validation failed: " + err.Error())
return err
}
- xapp.Logger.Debug("received associate RAN list to E2T instance mapping from E2 Manager")
- m.Lock()
- sdlEngine.WriteAssRANToE2TInstance(xapp.Config.GetString("rtfile"), data)
- m.Unlock()
+ xapp.Logger.Debug("received associate RAN list to E2T instance mapping from E2 Manager")
+ m.Lock()
+ sdlEngine.WriteAssRANToE2TInstance(xapp.Config.GetString("rtfile"), data)
+ m.Unlock()
+ updateEp()
return sendRoutesToAll()
}
xapp.Logger.Warn(" Disassociation of RAN List from E2T Instance data validation failed: " + err.Error())
return err
}
- xapp.Logger.Debug("received disassociate RANs from E2T instance")
- m.Lock()
- sdlEngine.WriteDisAssRANFromE2TInstance(xapp.Config.GetString("rtfile"), data)
- m.Unlock()
+ xapp.Logger.Debug("received disassociate RANs from E2T instance")
+ m.Lock()
+ sdlEngine.WriteDisAssRANFromE2TInstance(xapp.Config.GetString("rtfile"), data)
+ m.Unlock()
+ updateEp()
return sendRoutesToAll()
}
xapp.Logger.Error(err.Error())
return err
}
- m.Lock()
- sdlEngine.WriteDeleteE2TInstance(xapp.Config.GetString("rtfile"), data)
- m.Unlock()
+ m.Lock()
+ sdlEngine.WriteDeleteE2TInstance(xapp.Config.GetString("rtfile"), data)
+ m.Unlock()
+ updateEp()
return sendRoutesToAll()
}
sdlEngine, _ := sdl.GetSdl("file")
rpeEngine, _ := rpe.GetRpe("rmrpush")
data, err := sdlEngine.ReadAll(xapp.Config.GetString("rtfile"))
- if err != nil || data == nil {
- xapp.Logger.Error("Cannot get data from sdl interface due to: " + err.Error())
- return response, err
+ if data == nil {
+ if err != nil {
+ xapp.Logger.Error("Cannot get data from sdl interface due to: " + err.Error())
+ return response, err
+ } else {
+ xapp.Logger.Debug("Cannot get data from sdl interface")
+ return response, errors.New("Cannot get data from sdl interface")
+ }
}
response.RouteTable = *rpeEngine.GeneratePolicies(rtmgr.Eps, data)
return response, err
}
-func launchRest(nbiif *string){
+func launchRest(nbiif *string) {
swaggerSpec, err := loads.Embedded(restapi.SwaggerJSON, restapi.FlatSwaggerJSON)
if err != nil {
//log.Fatalln(err)
xapp.Logger.Info("Data received on Http interface")
err := provideXappHandleHandlerImpl(params.XappCallbackData)
if err != nil {
- xapp.Logger.Error("Invalid XApp callback data: " + err.Error())
+ xapp.Logger.Error("RoutingManager->AppManager request Failed: " + err.Error())
return handle.NewProvideXappHandleBadRequest()
} else {
+ xapp.Logger.Info("RoutingManager->AppManager request Success")
return handle.NewGetHandlesOK()
}
})
func(params handle.ProvideXappSubscriptionHandleParams) middleware.Responder {
err := provideXappSubscriptionHandleImpl(params.XappSubscriptionData)
if err != nil {
+ xapp.Logger.Error("RoutingManager->SubManager Add Request Failed: " + err.Error())
return handle.NewProvideXappSubscriptionHandleBadRequest()
} else {
+ xapp.Logger.Info("RoutingManager->SubManager Add Request Success, subid = %v, requestor = %v", *params.XappSubscriptionData.SubscriptionID, *params.XappSubscriptionData.Address)
return handle.NewGetHandlesOK()
}
})
func(params handle.DeleteXappSubscriptionHandleParams) middleware.Responder {
err := deleteXappSubscriptionHandleImpl(params.XappSubscriptionData)
if err != nil {
+ xapp.Logger.Error("RoutingManager->SubManager Delete Request Failed: " + err.Error())
return handle.NewDeleteXappSubscriptionHandleNoContent()
} else {
+ xapp.Logger.Info("RoutingManager->SubManager Delete Request Success, subid = %v, requestor = %v", *params.XappSubscriptionData.SubscriptionID, *params.XappSubscriptionData.Address)
return handle.NewGetHandlesOK()
}
})
func(params handle.CreateNewE2tHandleParams) middleware.Responder {
err := createNewE2tHandleHandlerImpl(params.E2tData)
if err != nil {
+ xapp.Logger.Error("RoutingManager->E2Manager AddE2T Request Failed: " + err.Error())
return handle.NewCreateNewE2tHandleBadRequest()
} else {
+ xapp.Logger.Info("RoutingManager->E2Manager AddE2T Request Success, E2T = %v", *params.E2tData.E2TAddress)
return handle.NewCreateNewE2tHandleCreated()
}
})
func(params handle.AssociateRanToE2tHandleParams) middleware.Responder {
err := associateRanToE2THandlerImpl(params.RanE2tList)
if err != nil {
+ xapp.Logger.Error("RoutingManager->E2Manager associateRanToE2T Request Failed: " + err.Error())
return handle.NewAssociateRanToE2tHandleBadRequest()
} else {
+ xapp.Logger.Info("RoutingManager->E2Manager associateRanToE2T Request Success, E2T = %v", params.RanE2tList)
return handle.NewAssociateRanToE2tHandleCreated()
}
})
func(params handle.DissociateRanParams) middleware.Responder {
err := disassociateRanToE2THandlerImpl(params.DissociateList)
if err != nil {
+ xapp.Logger.Error("RoutingManager->E2Manager DisassociateRanToE2T Request Failed: " + err.Error())
return handle.NewDissociateRanBadRequest()
} else {
+ xapp.Logger.Info("RoutingManager->E2Manager DisassociateRanToE2T Request Success, E2T = %v", params.DissociateList)
return handle.NewDissociateRanCreated()
}
})
func(params handle.DeleteE2tHandleParams) middleware.Responder {
err := deleteE2tHandleHandlerImpl(params.E2tData)
if err != nil {
+ xapp.Logger.Error("RoutingManager->E2Manager DeleteE2T Request Failed: " + err.Error())
return handle.NewDeleteE2tHandleBadRequest()
} else {
+ xapp.Logger.Info("RoutingManager->E2Manager DeleteE2T Request Success, E2T = %v", *params.E2tData.E2TAddress)
return handle.NewDeleteE2tHandleCreated()
}
})
return debug.NewGetDebuginfoOK().WithPayload(&response)
}
})
+ api.HandleAddRmrRouteHandler = handle.AddRmrRouteHandlerFunc(
+ func(params handle.AddRmrRouteParams) middleware.Responder {
+ err := adddelrmrroute(params.RoutesList, true)
+ if err != nil {
+ return handle.NewAddRmrRouteBadRequest()
+ } else {
+ return handle.NewAddRmrRouteCreated()
+ }
+
+ })
+ api.HandleDelRmrRouteHandler = handle.DelRmrRouteHandlerFunc(
+ func(params handle.DelRmrRouteParams) middleware.Responder {
+ err := adddelrmrroute(params.RoutesList, false)
+ if err != nil {
+ return handle.NewDelRmrRouteBadRequest()
+ } else {
+ return handle.NewDelRmrRouteCreated()
+ }
+ })
+
// start to serve API
xapp.Logger.Info("Starting the HTTP Rest service")
if err := server.Serve(); err != nil {
xapp.Logger.Info("Trying to fetch Subscriptions data from Subscription manager")
for i := 1; i <= maxRetries; i++ {
- readErr = nil
- sub_list, err := xapp.Subscription.QuerySubscriptions()
+ readErr = nil
+ sub_list, err := xapp.Subscription.QuerySubscriptions()
- if sub_list != nil && err == nil {
- PopulateSubscription(sub_list)
- break
- } else {
- readErr = err
- xapp.Logger.Warn("cannot get xapp data due to: " + readErr.Error())
- }
- time.Sleep(2 * time.Second)
+ if sub_list != nil && err == nil {
+ PopulateSubscription(sub_list)
+ break
+ } else {
+ readErr = err
+ xapp.Logger.Warn("cannot get xapp data due to: " + readErr.Error())
}
+ time.Sleep(2 * time.Second)
+ }
if readErr != nil {
return readErr
// post subscription req to appmgr
readErr = PostSubReq(xmurl, nbiif)
+ if readErr != nil {
+ return readErr
+ }
+
+ //rlist := make(map[string]string)
+ xapp.Logger.Info("Reading SDL for any routes")
+ rlist, sdlerr := xapp.Sdl.Read("routes")
+ readErr = sdlerr
if readErr == nil {
+ xapp.Logger.Info("Value is %s", rlist["routes"])
+ if rlist["routes"] != nil {
+ formstring := fmt.Sprintf("%s", rlist["routes"])
+ xapp.Logger.Info("Value of formed string = %s", formstring)
+ newstring := strings.Split(formstring, " ")
+ for i, _ := range newstring {
+ xapp.Logger.Info("in Loop Value of formed string = %s", newstring)
+ rtmgr.DynamicRouteList = append(rtmgr.DynamicRouteList, newstring[i])
+ }
+ }
+
return nil
}
}
}
}
+
+func adddelrmrroute(routelist models.Routelist, rtflag bool) error {
+ xapp.Logger.Info("Updating rmrroute with Route list: %v,flag: %v", routelist, rtflag)
+ for _, rlist := range routelist {
+ var subid int32
+ var data string
+ if rlist.SubscriptionID == 0 {
+ subid = -1
+ } else {
+ subid = rlist.SubscriptionID
+ }
+ if rlist.SenderEndPoint == "" && rlist.SubscriptionID != 0 {
+ data = fmt.Sprintf("mse|%d|%d|%s\n", *rlist.MessageType, rlist.SubscriptionID, *rlist.TargetEndPoint)
+ } else if rlist.SenderEndPoint == "" && rlist.SubscriptionID == 0 {
+ data = fmt.Sprintf("mse|%d|-1|%s\n", *rlist.MessageType, *rlist.TargetEndPoint)
+ } else {
+ data = fmt.Sprintf("mse|%d,%s|%d|%s\n", *rlist.MessageType, rlist.SenderEndPoint, subid, *rlist.TargetEndPoint)
+ }
+ err := checkrepeatedroute(data)
+
+ if rtflag == true {
+ if err == true {
+ xapp.Logger.Info("Given route %s is a duplicate", data)
+ }
+ rtmgr.DynamicRouteList = append(rtmgr.DynamicRouteList, data)
+ routearray := strings.Join(rtmgr.DynamicRouteList, " ")
+ xapp.Sdl.Store("routes", routearray)
+ } else {
+ if err == true {
+ xapp.Logger.Info("Successfully deleted route: %s", data)
+ routearray := strings.Join(rtmgr.DynamicRouteList, " ")
+ xapp.Sdl.Store("routes", routearray)
+ } else {
+ xapp.Logger.Info("No such route: %s", data)
+ return errors.New("No such route: " + data)
+ }
+
+ }
+ }
+ updateEp()
+ return sendRoutesToAll()
+}
+
+func checkrepeatedroute(data string) bool {
+ for i := 0; i < len(rtmgr.DynamicRouteList); i++ {
+ if rtmgr.DynamicRouteList[i] == data {
+ rtmgr.DynamicRouteList[i] = rtmgr.DynamicRouteList[len(rtmgr.DynamicRouteList)-1]
+ rtmgr.DynamicRouteList[len(rtmgr.DynamicRouteList)-1] = ""
+ rtmgr.DynamicRouteList = rtmgr.DynamicRouteList[:len(rtmgr.DynamicRouteList)-1]
+ return true
+ }
+ }
+ return false
+}
Code Review / ric-plt / rtmgr.git / blobdiff