var retval string = ""
var filler string = ""
for _, entry := range entries {
- retval += filler + entry.String()
- filler = " "
+ if entry != nil {
+ retval += filler + entry.String()
+ filler = " "
+ } else {
+ retval += filler + "(NIL)"
+ }
}
if err != nil {
retval += filler + "err(" + err.Error() + ")"
var e2tMaxSubDelReqTryCount uint64 // Initial try + retry
var readSubsFromDb string
var restDuplicateCtrl duplicateCtrl
+var dbRetryForever string
+var dbTryCount int
type Control struct {
*xapp.RMRClient
e2ap *E2ap
registry *Registry
tracker *Tracker
- db Sdlnterface
+ e2SubsDb Sdlnterface
+ restSubsDb Sdlnterface
CntRecvMsg uint64
ResetTestFlag bool
Counters map[string]xapp.Counter
c := &Control{e2ap: new(E2ap),
registry: registry,
tracker: tracker,
- db: CreateSdl(),
+ e2SubsDb: CreateSdl(),
+ restSubsDb: CreateRESTSdl(),
Counters: xapp.Metric.RegisterCounterGroup(GetMetricsOpts(), "SUBMGR"),
LoggerLevel: 3,
}
// Register REST handler for testing support
xapp.Resource.InjectRoute("/ric/v1/test/{testId}", c.TestRestHandler, "POST")
+ xapp.Resource.InjectRoute("/ric/v1/restsubscriptions", c.GetAllRestSubscriptions, "GET")
xapp.Resource.InjectRoute("/ric/v1/symptomdata", c.SymptomDataHandler, "GET")
go xapp.Subscription.Listen(c.SubscriptionHandler, c.QueryHandler, c.SubscriptionDeleteHandlerCB)
restDuplicateCtrl.Init()
// Read subscriptions from db
- xapp.Logger.Info("Reading subscriptions from db")
- subIds, register, err := c.ReadAllSubscriptionsFromSdl()
- if err != nil {
- xapp.Logger.Error("%v", err)
- } else {
- c.registry.subIds = subIds
- c.registry.register = register
- c.HandleUncompletedSubscriptions(register)
- }
+ c.ReadE2Subscriptions()
+ c.ReadRESTSubscriptions()
return c
}
xapp.Resource.SendSymptomDataJson(w, r, subscriptions, "platform/subscriptions.json")
}
+//-------------------------------------------------------------------
+//
+//-------------------------------------------------------------------
+func (c *Control) GetAllRestSubscriptions(w http.ResponseWriter, r *http.Request) {
+ xapp.Logger.Info("GetAllRestSubscriptions() called")
+ response := c.registry.GetAllRestSubscriptions()
+ w.Write(response)
+}
+
+//-------------------------------------------------------------------
+//
+//-------------------------------------------------------------------
+func (c *Control) ReadE2Subscriptions() error {
+ var err error
+ var subIds []uint32
+ var register map[uint32]*Subscription
+ for i := 0; dbRetryForever == "true" || i < dbTryCount; i++ {
+ xapp.Logger.Info("Reading E2 subscriptions from db")
+ subIds, register, err = c.ReadAllSubscriptionsFromSdl()
+ if err != nil {
+ xapp.Logger.Error("%v", err)
+ <-time.After(1 * time.Second)
+ } else {
+ c.registry.subIds = subIds
+ c.registry.register = register
+ c.HandleUncompletedSubscriptions(register)
+ return nil
+ }
+ }
+ xapp.Logger.Info("Continuing without retring")
+ return err
+}
+
+//-------------------------------------------------------------------
+//
+//-------------------------------------------------------------------
+func (c *Control) ReadRESTSubscriptions() error {
+ var err error
+ var restSubscriptions map[string]*RESTSubscription
+ for i := 0; dbRetryForever == "true" || i < dbTryCount; i++ {
+ xapp.Logger.Info("Reading REST subscriptions from db")
+ restSubscriptions, err = c.ReadAllRESTSubscriptionsFromSdl()
+ if err != nil {
+ xapp.Logger.Error("%v", err)
+ <-time.After(1 * time.Second)
+ } else {
+ c.registry.restSubscriptions = restSubscriptions
+ return nil
+ }
+ }
+ xapp.Logger.Info("Continuing without retring")
+ return err
+}
+
//-------------------------------------------------------------------
//
//-------------------------------------------------------------------
}
xapp.Logger.Info("e2tRecvMsgTimeout %v", e2tRecvMsgTimeout)
- // Internal cfg parameter, used to define a wait time for RMR route clean-up. None default
- // value 100ms used currently only in unittests.
- waitRouteCleanup_ms = viper.GetDuration("controls.waitRouteCleanup_ms") * 1000000
- if waitRouteCleanup_ms == 0 {
- waitRouteCleanup_ms = 5000 * 1000000
- }
- xapp.Logger.Info("waitRouteCleanup %v", waitRouteCleanup_ms)
-
e2tMaxSubReqTryCount = viper.GetUint64("controls.e2tMaxSubReqTryCount")
if e2tMaxSubReqTryCount == 0 {
e2tMaxSubReqTryCount = 1
readSubsFromDb = "true"
}
xapp.Logger.Info("readSubsFromDb %v", readSubsFromDb)
+
+ dbTryCount = viper.GetInt("controls.dbTryCount")
+ if dbTryCount == 0 {
+ dbTryCount = 200
+ }
+ xapp.Logger.Info("dbTryCount %v", dbTryCount)
+
+ dbRetryForever = viper.GetString("controls.dbRetryForever")
+ if dbRetryForever == "" {
+ dbRetryForever = "true"
+ }
+ xapp.Logger.Info("dbRetryForever %v", dbRetryForever)
+
c.LoggerLevel = viper.GetUint32("logger.level")
if c.LoggerLevel == 0 {
c.LoggerLevel = 3
}
+ xapp.Logger.Info("LoggerLevel %v", c.LoggerLevel)
+
+ // Internal cfg parameter, used to define a wait time for RMR route clean-up. None default
+ // value 100ms used currently only in unittests.
+ waitRouteCleanup_ms = viper.GetDuration("controls.waitRouteCleanup_ms") * 1000000
+ if waitRouteCleanup_ms == 0 {
+ waitRouteCleanup_ms = 5000 * 1000000
+ }
+ xapp.Logger.Info("waitRouteCleanup %v", waitRouteCleanup_ms)
}
//-------------------------------------------------------------------
xapp.Run(c)
}
+//-------------------------------------------------------------------
+//
+//-------------------------------------------------------------------
+func (c *Control) GetOrCreateRestSubscription(p *models.SubscriptionParams, md5sum string, xAppRmrEndpoint string) (*RESTSubscription, string, error) {
+
+ var restSubId string
+ var restSubscription *RESTSubscription
+ var err error
+
+ prevRestSubsId, exists := restDuplicateCtrl.GetLastKnownRestSubsIdBasedOnMd5sum(md5sum)
+ if p.SubscriptionID == "" {
+ if exists {
+ restSubscription, err = c.registry.GetRESTSubscription(prevRestSubsId, false)
+ if restSubscription != nil {
+ restSubId = prevRestSubsId
+ if err == nil {
+ xapp.Logger.Info("Existing restSubId %s found by MD5sum %s for a request without subscription ID - using previous subscription", prevRestSubsId, md5sum)
+ } else {
+ xapp.Logger.Info("Existing restSubId %s found by MD5sum %s for a request without subscription ID - Note: %s", prevRestSubsId, md5sum, err.Error())
+ }
+ } else {
+ xapp.Logger.Info("None existing restSubId %s referred by MD5sum %s for a request without subscription ID - deleting cached entry", prevRestSubsId, md5sum)
+ restDuplicateCtrl.DeleteLastKnownRestSubsIdBasedOnMd5sum(md5sum)
+ }
+ }
+
+ if restSubscription == nil {
+ restSubId = ksuid.New().String()
+ restSubscription, err = c.registry.CreateRESTSubscription(&restSubId, &xAppRmrEndpoint, p.Meid)
+ if err != nil {
+ xapp.Logger.Error("%s", err.Error())
+ c.UpdateCounter(cRestSubFailToXapp)
+ return nil, "", err
+ }
+ }
+ } else {
+ restSubId = p.SubscriptionID
+
+ xapp.Logger.Info("RestSubscription ID %s provided via REST request", restSubId)
+
+ restSubscription, err = c.registry.GetRESTSubscription(restSubId, false)
+ if err != nil {
+ xapp.Logger.Error("%s", err.Error())
+ c.UpdateCounter(cRestSubFailToXapp)
+ return nil, "", err
+ }
+
+ if !exists {
+ xapp.Logger.Info("Existing restSubscription found for ID %s, new request based on md5sum", restSubId)
+ } else {
+ xapp.Logger.Info("Existing restSubscription found for ID %s(%s), re-transmission based on md5sum match with previous request", prevRestSubsId, restSubId)
+ }
+ }
+
+ return restSubscription, restSubId, nil
+}
+
//-------------------------------------------------------------------
//
//-------------------------------------------------------------------
c.UpdateCounter(cRestSubFailToXapp)
return nil, err
}
- var restSubId string
- var restSubscription *RESTSubscription
- if p.SubscriptionID == "" {
- restSubId = ksuid.New().String()
- restSubscription, err = c.registry.CreateRESTSubscription(&restSubId, &xAppRmrEndpoint, p.Meid)
- if err != nil {
- xapp.Logger.Error("%s", err.Error())
- c.UpdateCounter(cRestSubFailToXapp)
- return nil, err
- }
- } else {
- restSubId = p.SubscriptionID
- restSubscription, err = c.registry.GetRESTSubscription(restSubId, false)
- if err != nil {
- xapp.Logger.Error("%s", err.Error())
- c.UpdateCounter(cRestSubFailToXapp)
- return nil, err
- }
+ md5sum, err := CalculateRequestMd5sum(params)
+ if err != nil {
+ xapp.Logger.Error("Failed to generate md5sum from incoming request - %s", err.Error())
+ }
+
+ restSubscription, restSubId, err := c.GetOrCreateRestSubscription(p, md5sum, xAppRmrEndpoint)
+ if err != nil {
+ xapp.Logger.Error("Failed to get/allocate REST subscription")
+ return nil, err
}
subResp.SubscriptionID = &restSubId
err = c.e2ap.FillSubscriptionReqMsgs(params, &subReqList, restSubscription)
if err != nil {
xapp.Logger.Error("%s", err.Error())
+ restDuplicateCtrl.DeleteLastKnownRestSubsIdBasedOnMd5sum(md5sum)
c.registry.DeleteRESTSubscription(&restSubId)
c.UpdateCounter(cRestSubFailToXapp)
return nil, err
}
- err, duplicate, md5sum := restDuplicateCtrl.IsDuplicateToOngoingTransaction(restSubId, params)
-
- if err != nil {
- // We were unable to detect whether this request was duplicate or not, proceed
- xapp.Logger.Info("%s - proceeding with the request", err.Error())
- } else {
- if duplicate {
- if *p.SubscriptionDetails[0].ActionToBeSetupList[0].ActionType == "report" {
- xapp.Logger.Info("Retransmission blocker dropped for report typer of request")
- c.UpdateCounter(cRestSubRespToXapp)
- return &subResp, nil
- }
- }
- restSubscription.Md5sumOngoing = md5sum
+ duplicate := restDuplicateCtrl.IsDuplicateToOngoingTransaction(restSubId, md5sum)
+ if duplicate {
+ xapp.Logger.Info("Retransmission blocker direct ACK for request of restSubsId %s restSubId MD5sum %s as retransmission", restSubId, md5sum)
+ c.UpdateCounter(cRestSubRespToXapp)
+ return &subResp, nil
}
- go c.processSubscriptionRequests(restSubscription, &subReqList, p.ClientEndpoint, p.Meid, &restSubId, xAppRmrEndpoint)
+ c.WriteRESTSubscriptionToDb(restSubId, restSubscription)
+
+ go c.processSubscriptionRequests(restSubscription, &subReqList, p.ClientEndpoint, p.Meid, &restSubId, xAppRmrEndpoint, md5sum)
c.UpdateCounter(cRestSubRespToXapp)
return &subResp, nil
}
-func (c *Control) sendUnsuccesfullResponseNotification(restSubId *string, restSubscription *RESTSubscription, xAppEventInstanceID int64, err error,
- clientEndpoint *models.SubscriptionParamsClientEndpoint, trans *TransactionXapp) {
-
- // Send notification to xApp that prosessing of a Subscription Request has failed.
- e2EventInstanceID := (int64)(0)
- errorCause := err.Error()
- resp := &models.SubscriptionResponse{
- SubscriptionID: restSubId,
- SubscriptionInstances: []*models.SubscriptionInstance{
- &models.SubscriptionInstance{E2EventInstanceID: &e2EventInstanceID,
- ErrorCause: &errorCause,
- XappEventInstanceID: &xAppEventInstanceID},
- },
- }
- // Mark REST subscription request processed.
- restSubscription.SetProcessed()
- if trans != nil {
- xapp.Logger.Info("Sending unsuccessful REST notification (cause %s) to endpoint=%v:%v, XappEventInstanceID=%v, E2EventInstanceID=%v, %s",
- errorCause, clientEndpoint.Host, *clientEndpoint.HTTPPort, xAppEventInstanceID, e2EventInstanceID, idstring(nil, trans))
- } else {
- xapp.Logger.Info("Sending unsuccessful REST notification (cause %s) to endpoint=%v:%v, XappEventInstanceID=%v, E2EventInstanceID=%v",
- errorCause, clientEndpoint.Host, *clientEndpoint.HTTPPort, xAppEventInstanceID, e2EventInstanceID)
- }
- xapp.Subscription.Notify(resp, *clientEndpoint)
- c.UpdateCounter(cRestSubFailNotifToXapp)
-}
-
-func (c *Control) sendSuccesfullResponseNotification(restSubId *string, restSubscription *RESTSubscription, xAppEventInstanceID int64, e2EventInstanceID int64,
- clientEndpoint *models.SubscriptionParamsClientEndpoint, trans *TransactionXapp) {
-
- // Store successfully processed InstanceId for deletion
- restSubscription.AddE2InstanceId((uint32)(e2EventInstanceID))
- restSubscription.AddXappIdToE2Id(xAppEventInstanceID, e2EventInstanceID)
-
- // Send notification to xApp that a Subscription Request has been processed.
- resp := &models.SubscriptionResponse{
- SubscriptionID: restSubId,
- SubscriptionInstances: []*models.SubscriptionInstance{
- &models.SubscriptionInstance{E2EventInstanceID: &e2EventInstanceID,
- ErrorCause: nil,
- XappEventInstanceID: &xAppEventInstanceID},
- },
- }
- // Mark REST subscription request processesd.
- restSubscription.SetProcessed()
- xapp.Logger.Info("Sending successful REST notification to endpoint=%v:%v, XappEventInstanceID=%v, E2EventInstanceID=%v, %s",
- clientEndpoint.Host, *clientEndpoint.HTTPPort, xAppEventInstanceID, e2EventInstanceID, idstring(nil, trans))
- xapp.Subscription.Notify(resp, *clientEndpoint)
- c.UpdateCounter(cRestSubNotifToXapp)
-}
-
//-------------------------------------------------------------------
//
//-------------------------------------------------------------------
func (c *Control) processSubscriptionRequests(restSubscription *RESTSubscription, subReqList *e2ap.SubscriptionRequestList,
- clientEndpoint *models.SubscriptionParamsClientEndpoint, meid *string, restSubId *string, xAppRmrEndpoint string) {
+ clientEndpoint *models.SubscriptionParamsClientEndpoint, meid *string, restSubId *string, xAppRmrEndpoint string, md5sum string) {
xapp.Logger.Info("Subscription Request count=%v ", len(subReqList.E2APSubscriptionRequests))
var xAppEventInstanceID int64
var e2EventInstanceID int64
- defer restDuplicateCtrl.TransactionComplete(restSubscription.Md5sumOngoing)
+ defer restDuplicateCtrl.SetMd5sumFromLastOkRequest(*restSubId, md5sum)
for index := 0; index < len(subReqList.E2APSubscriptionRequests); index++ {
subReqMsg := subReqList.E2APSubscriptionRequests[index]
xapp.Logger.Info("Handle SubscriptionRequest index=%v, %s", index, idstring(nil, trans))
- subRespMsg, err := c.handleSubscriptionRequest(trans, &subReqMsg, meid, restSubId)
+ subRespMsg, err := c.handleSubscriptionRequest(trans, &subReqMsg, meid, *restSubId)
+
+ xapp.Logger.Info("Handled SubscriptionRequest index=%v, %s", index, idstring(nil, trans))
+
if err != nil {
c.sendUnsuccesfullResponseNotification(restSubId, restSubscription, xAppEventInstanceID, err, clientEndpoint, trans)
} else {
e2EventInstanceID = (int64)(subRespMsg.RequestId.InstanceId)
- xapp.Logger.Info("SubscriptionRequest index=%v processed successfully. endpoint=%v:%v, XappEventInstanceID=%v, E2EventInstanceID=%v, %s",
- index, clientEndpoint.Host, *clientEndpoint.HTTPPort, xAppEventInstanceID, e2EventInstanceID, idstring(nil, trans))
+ restSubscription.AddMd5Sum(md5sum)
+ xapp.Logger.Info("SubscriptionRequest index=%v processed successfullyfor %s. endpoint=%v:%v, XappEventInstanceID=%v, E2EventInstanceID=%v, %s",
+ index, *restSubId, clientEndpoint.Host, *clientEndpoint.HTTPPort, xAppEventInstanceID, e2EventInstanceID, idstring(nil, trans))
c.sendSuccesfullResponseNotification(restSubId, restSubscription, xAppEventInstanceID, e2EventInstanceID, clientEndpoint, trans)
}
trans.Release()
//
//------------------------------------------------------------------
func (c *Control) handleSubscriptionRequest(trans *TransactionXapp, subReqMsg *e2ap.E2APSubscriptionRequest, meid *string,
- restSubId *string) (*e2ap.E2APSubscriptionResponse, error) {
+ restSubId string) (*e2ap.E2APSubscriptionResponse, error) {
err := c.tracker.Track(trans)
if err != nil {
return nil, err
}
+//-------------------------------------------------------------------
+//
+//-------------------------------------------------------------------
+func (c *Control) sendUnsuccesfullResponseNotification(restSubId *string, restSubscription *RESTSubscription, xAppEventInstanceID int64, err error,
+ clientEndpoint *models.SubscriptionParamsClientEndpoint, trans *TransactionXapp) {
+
+ // Send notification to xApp that prosessing of a Subscription Request has failed.
+ e2EventInstanceID := (int64)(0)
+ errorCause := err.Error()
+ resp := &models.SubscriptionResponse{
+ SubscriptionID: restSubId,
+ SubscriptionInstances: []*models.SubscriptionInstance{
+ &models.SubscriptionInstance{E2EventInstanceID: &e2EventInstanceID,
+ ErrorCause: &errorCause,
+ XappEventInstanceID: &xAppEventInstanceID},
+ },
+ }
+ // Mark REST subscription request processed.
+ restSubscription.SetProcessed(err)
+ c.UpdateRESTSubscriptionInDB(*restSubId, restSubscription, false)
+ if trans != nil {
+ xapp.Logger.Info("Sending unsuccessful REST notification (cause %s) to endpoint=%v:%v, XappEventInstanceID=%v, E2EventInstanceID=%v, %s",
+ errorCause, clientEndpoint.Host, *clientEndpoint.HTTPPort, xAppEventInstanceID, e2EventInstanceID, idstring(nil, trans))
+ } else {
+ xapp.Logger.Info("Sending unsuccessful REST notification (cause %s) to endpoint=%v:%v, XappEventInstanceID=%v, E2EventInstanceID=%v",
+ errorCause, clientEndpoint.Host, *clientEndpoint.HTTPPort, xAppEventInstanceID, e2EventInstanceID)
+ }
+
+ c.UpdateCounter(cRestSubFailNotifToXapp)
+ xapp.Subscription.Notify(resp, *clientEndpoint)
+}
+
+//-------------------------------------------------------------------
+//
+//-------------------------------------------------------------------
+func (c *Control) sendSuccesfullResponseNotification(restSubId *string, restSubscription *RESTSubscription, xAppEventInstanceID int64, e2EventInstanceID int64,
+ clientEndpoint *models.SubscriptionParamsClientEndpoint, trans *TransactionXapp) {
+
+ // Store successfully processed InstanceId for deletion
+ restSubscription.AddE2InstanceId((uint32)(e2EventInstanceID))
+ restSubscription.AddXappIdToE2Id(xAppEventInstanceID, e2EventInstanceID)
+
+ // Send notification to xApp that a Subscription Request has been processed.
+ resp := &models.SubscriptionResponse{
+ SubscriptionID: restSubId,
+ SubscriptionInstances: []*models.SubscriptionInstance{
+ &models.SubscriptionInstance{E2EventInstanceID: &e2EventInstanceID,
+ ErrorCause: nil,
+ XappEventInstanceID: &xAppEventInstanceID},
+ },
+ }
+ // Mark REST subscription request processesd.
+ restSubscription.SetProcessed(nil)
+ c.UpdateRESTSubscriptionInDB(*restSubId, restSubscription, false)
+ xapp.Logger.Info("Sending successful REST notification to endpoint=%v:%v, XappEventInstanceID=%v, E2EventInstanceID=%v, %s",
+ clientEndpoint.Host, *clientEndpoint.HTTPPort, xAppEventInstanceID, e2EventInstanceID, idstring(nil, trans))
+
+ c.UpdateCounter(cRestSubNotifToXapp)
+ xapp.Subscription.Notify(resp, *clientEndpoint)
+}
+
//-------------------------------------------------------------------
//
//-------------------------------------------------------------------
xAppRmrEndPoint := restSubscription.xAppRmrEndPoint
go func() {
+ xapp.Logger.Info("Deleteting handler: processing instances = %v", restSubscription.InstanceIds)
for _, instanceId := range restSubscription.InstanceIds {
xAppEventInstanceID, err := c.SubscriptionDeleteHandler(&restSubId, &xAppRmrEndPoint, &restSubscription.Meid, instanceId)
restSubscription.DeleteXappIdToE2Id(xAppEventInstanceID)
restSubscription.DeleteE2InstanceId(instanceId)
}
+ restDuplicateCtrl.DeleteLastKnownRestSubsIdBasedOnMd5sum(restSubscription.lastReqMd5sum)
c.registry.DeleteRESTSubscription(&restSubId)
+ c.RemoveRESTSubscriptionFromDb(restSubId)
}()
c.UpdateCounter(cRestSubDelRespToXapp)
if s == "emptydb" {
xapp.Logger.Info("RemoveAllSubscriptionsFromSdl() called")
c.RemoveAllSubscriptionsFromSdl()
+ c.RemoveAllRESTSubscriptionsFromSdl()
return
}
case *e2ap.E2APSubscriptionFailure:
removeSubscriptionFromDb = true
subRfMsg, valid = subs.SetCachedResponse(event, false)
- xapp.Logger.Info("SUBS-SubReq: internal delete due event(%s) %s", typeofSubsMessage(event), idstring(nil, trans, subs, parentTrans))
+ xapp.Logger.Info("SUBS-SubReq: internal delete due failure event(%s) %s", typeofSubsMessage(event), idstring(nil, trans, subs, parentTrans))
c.sendE2TSubscriptionDeleteRequest(subs, trans, parentTrans)
case *SubmgrRestartTestEvent:
// This simulates that no response has been received and after restart subscriptions are restored from db
xapp.Logger.Debug("Test restart flag is active. Dropping this transaction to test restart case")
return
default:
- xapp.Logger.Info("SUBS-SubReq: internal delete due event(%s) %s", typeofSubsMessage(event), idstring(nil, trans, subs, parentTrans))
+ xapp.Logger.Info("SUBS-SubReq: internal delete due default event(%s) %s", typeofSubsMessage(event), idstring(nil, trans, subs, parentTrans))
removeSubscriptionFromDb = true
subRfMsg, valid = subs.SetCachedResponse(nil, false)
c.sendE2TSubscriptionDeleteRequest(subs, trans, parentTrans)
}
}
+//-------------------------------------------------------------------
+//
+//-------------------------------------------------------------------
+func (c *Control) WriteRESTSubscriptionToDb(restSubId string, restSubs *RESTSubscription) {
+ xapp.Logger.Debug("WriteRESTSubscriptionToDb() restSubId = %s", restSubId)
+ err := c.WriteRESTSubscriptionToSdl(restSubId, restSubs)
+ if err != nil {
+ xapp.Logger.Error("%v", err)
+ }
+}
+
+//-------------------------------------------------------------------
+//
+//-------------------------------------------------------------------
+func (c *Control) UpdateRESTSubscriptionInDB(restSubId string, restSubs *RESTSubscription, removeRestSubscriptionFromDb bool) {
+
+ if removeRestSubscriptionFromDb == true {
+ // Subscription was written in db already when subscription request was sent to BTS, except for merged request
+ c.RemoveRESTSubscriptionFromDb(restSubId)
+ } else {
+ c.WriteRESTSubscriptionToDb(restSubId, restSubs)
+ }
+}
+
+//-------------------------------------------------------------------
+//
+//-------------------------------------------------------------------
+func (c *Control) RemoveRESTSubscriptionFromDb(restSubId string) {
+ xapp.Logger.Debug("RemoveRESTSubscriptionFromDb() restSubId = %s", restSubId)
+ err := c.RemoveRESTSubscriptionFromSdl(restSubId)
+ if err != nil {
+ xapp.Logger.Error("%v", err)
+ }
+}
+
func (c *Control) SendSubscriptionDeleteReq(subs *Subscription) {
const ricRequestorId = 123
func (c *Control) PrintRESTSubscriptionRequest(p *models.SubscriptionParams) {
fmt.Println("CRESTSubscriptionRequest")
+
+ if p == nil {
+ return
+ }
+
+ if p.SubscriptionID != "" {
+ fmt.Println(" SubscriptionID = ", p.SubscriptionID)
+ } else {
+ fmt.Println(" SubscriptionID = ''")
+ }
+
fmt.Printf(" ClientEndpoint.Host = %s\n", p.ClientEndpoint.Host)
if p.ClientEndpoint.HTTPPort != nil {