type Control struct {
*xapp.RMRClient
- e2ap *E2ap
- registry *Registry
- tracker *Tracker
- db Sdlnterface
- //subscriber *xapp.Subscriber
+ e2ap *E2ap
+ registry *Registry
+ tracker *Tracker
+ db Sdlnterface
CntRecvMsg uint64
ResetTestFlag bool
Counters map[string]xapp.Counter
+ LoggerLevel uint32
}
type RMRMeid struct {
tracker.Init()
c := &Control{e2ap: new(E2ap),
- registry: registry,
- tracker: tracker,
- db: CreateSdl(),
- //subscriber: subscriber,
- Counters: xapp.Metric.RegisterCounterGroup(GetMetricsOpts(), "SUBMGR"),
+ registry: registry,
+ tracker: tracker,
+ db: CreateSdl(),
+ Counters: xapp.Metric.RegisterCounterGroup(GetMetricsOpts(), "SUBMGR"),
+ LoggerLevel: 3,
}
c.ReadConfigParameters("")
readSubsFromDb = "true"
}
xapp.Logger.Info("readSubsFromDb %v", readSubsFromDb)
+ c.LoggerLevel = viper.GetUint32("logger.level")
+ if c.LoggerLevel == 0 {
+ c.LoggerLevel = 3
+ }
}
//-------------------------------------------------------------------
//-------------------------------------------------------------------
func (c *Control) SubscriptionHandler(params interface{}) (*models.SubscriptionResponse, error) {
- restSubId := ksuid.New().String()
+ c.CntRecvMsg++
+ c.UpdateCounter(cRestSubReqFromXapp)
+
subResp := models.SubscriptionResponse{}
- subResp.SubscriptionID = &restSubId
p := params.(*models.SubscriptionParams)
- c.CntRecvMsg++
-
- c.UpdateCounter(cRestSubReqFromXapp)
+ if c.LoggerLevel > 2 {
+ c.PrintRESTSubscriptionRequest(p)
+ }
if p.ClientEndpoint == nil {
xapp.Logger.Error("ClientEndpoint == nil")
+ c.UpdateCounter(cRestSubFailToXapp)
return nil, fmt.Errorf("")
}
_, xAppRmrEndpoint, err := ConstructEndpointAddresses(*p.ClientEndpoint)
if err != nil {
xapp.Logger.Error("%s", err.Error())
+ 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
+ }
- restSubscription, err := c.registry.CreateRESTSubscription(&restSubId, &xAppRmrEndpoint, p.Meid)
- if err != nil {
- xapp.Logger.Error("%s", err.Error())
- 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
+ }
}
+ subResp.SubscriptionID = &restSubId
subReqList := e2ap.SubscriptionRequestList{}
err = c.e2ap.FillSubscriptionReqMsgs(params, &subReqList, restSubscription)
if err != nil {
xapp.Logger.Error("%s", err.Error())
c.registry.DeleteRESTSubscription(&restSubId)
+ c.UpdateCounter(cRestSubFailToXapp)
return nil, err
}
go c.processSubscriptionRequests(restSubscription, &subReqList, p.ClientEndpoint, p.Meid, &restSubId)
+ c.UpdateCounter(cRestSubRespToXapp)
return &subResp, nil
-
}
//-------------------------------------------------------------------
_, xAppRmrEndpoint, err := ConstructEndpointAddresses(*clientEndpoint)
if err != nil {
- xapp.Logger.Error("%s", err.Error())
+ c.registry.DeleteRESTSubscription(restSubId)
+ xapp.Logger.Error("XAPP-SubReq transaction not created, endpoint createtion failed for RESTSubId=%s, Meid=%s", *restSubId, *meid)
return
}
- var requestorID int64
- var instanceId int64
+ var xAppEventInstanceID int64
+ var e2EventInstanceID int64
+ var errorCause string
for index := 0; index < len(subReqList.E2APSubscriptionRequests); index++ {
subReqMsg := subReqList.E2APSubscriptionRequests[index]
}
defer trans.Release()
+ xAppEventInstanceID = (int64)(subReqMsg.RequestId.Id)
xapp.Logger.Info("Handle SubscriptionRequest index=%v, %s", index, idstring(nil, trans))
subRespMsg, err := c.handleSubscriptionRequest(trans, &subReqMsg, meid, restSubId)
if err != nil {
- // Send notification to xApp that prosessing of a Subscription Request has failed. Currently it is not possible
- // to indicate error. Such possibility should be added. As a workaround requestorID and instanceId are set to zero value
- requestorID = (int64)(0)
- instanceId = (int64)(0)
+ // 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{RequestorID: &requestorID, InstanceID: &instanceId},
+ &models.SubscriptionInstance{E2EventInstanceID: &e2EventInstanceID,
+ ErrorCause: &errorCause,
+ XappEventInstanceID: &xAppEventInstanceID},
},
}
// Mark REST subscription request processed.
restSubscription.SetProcessed()
- xapp.Logger.Info("Sending unsuccessful REST notification to endpoint=%v:%v, InstanceId=%v, %s", clientEndpoint.Host, clientEndpoint.HTTPPort, instanceId, idstring(nil, trans))
+ 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))
xapp.Subscription.Notify(resp, *clientEndpoint)
+ c.UpdateCounter(cRestSubFailNotifToXapp)
} else {
- xapp.Logger.Info("SubscriptionRequest index=%v processed successfully. endpoint=%v, InstanceId=%v, %s", index, *clientEndpoint, instanceId, idstring(nil, trans))
+ 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))
// Store successfully processed InstanceId for deletion
- restSubscription.AddInstanceId(subRespMsg.RequestId.InstanceId)
+ restSubscription.AddE2InstanceId(subRespMsg.RequestId.InstanceId)
+ restSubscription.AddXappIdToE2Id(xAppEventInstanceID, e2EventInstanceID)
// Send notification to xApp that a Subscription Request has been processed.
- requestorID = (int64)(subRespMsg.RequestId.Id)
- instanceId = (int64)(subRespMsg.RequestId.InstanceId)
resp := &models.SubscriptionResponse{
SubscriptionID: restSubId,
SubscriptionInstances: []*models.SubscriptionInstance{
- &models.SubscriptionInstance{RequestorID: &requestorID, InstanceID: &instanceId},
+ &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, InstanceId=%v, %s", *clientEndpoint, instanceId, idstring(nil, trans))
+ 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)
}
- c.UpdateCounter(cRestSubRespToXapp)
}
}
err := c.tracker.Track(trans)
if err != nil {
- err = fmt.Errorf("XAPP-SubReq: %s", idstring(err, trans))
- xapp.Logger.Error("%s", err.Error())
+ xapp.Logger.Error("XAPP-SubReq Tracking error: %s", idstring(err, trans))
+ err = fmt.Errorf("Tracking failure")
return nil, err
}
subs, err := c.registry.AssignToSubscription(trans, subReqMsg, c.ResetTestFlag, c)
if err != nil {
- err = fmt.Errorf("XAPP-SubReq: %s", idstring(err, trans))
- xapp.Logger.Error("%s", err.Error())
+ xapp.Logger.Error("XAPP-SubReq Assign error: %s", idstring(err, trans))
return nil, err
}
trans.Release()
return themsg, nil
case *e2ap.E2APSubscriptionFailure:
- err = fmt.Errorf("SubscriptionFailure received")
+ err = fmt.Errorf("E2 SubscriptionFailure received")
return nil, err
default:
+ err = fmt.Errorf("unexpected E2 subscription response received")
break
}
+ } else {
+ err = fmt.Errorf("E2 subscription response timeout")
}
- err = fmt.Errorf("XAPP-SubReq: failed %s", idstring(err, trans, subs))
- xapp.Logger.Error("%s", err.Error())
+
+ xapp.Logger.Error("XAPP-SubReq E2 subscription failed %s", idstring(err, trans, subs))
c.registry.RemoveFromSubscription(subs, trans, waitRouteCleanup_ms, c)
return nil, err
}
xapp.Logger.Info("SubscriptionDeleteRequest from XAPP")
- restSubscription, err := c.registry.GetRESTSubscription(restSubId)
+ restSubscription, err := c.registry.GetRESTSubscription(restSubId, true)
if err != nil {
xapp.Logger.Error("%s", err.Error())
if restSubscription == nil {
xAppRmrEndPoint := restSubscription.xAppRmrEndPoint
go func() {
for _, instanceId := range restSubscription.InstanceIds {
- err := c.SubscriptionDeleteHandler(&restSubId, &xAppRmrEndPoint, &restSubscription.Meid, instanceId)
+ xAppEventInstanceID, err := c.SubscriptionDeleteHandler(&restSubId, &xAppRmrEndPoint, &restSubscription.Meid, instanceId)
+
if err != nil {
xapp.Logger.Error("%s", err.Error())
//return err
}
xapp.Logger.Info("Deleteting instanceId = %v", instanceId)
- restSubscription.DeleteInstanceId(instanceId)
+ restSubscription.DeleteXappIdToE2Id(xAppEventInstanceID)
+ restSubscription.DeleteE2InstanceId(instanceId)
}
c.registry.DeleteRESTSubscription(&restSubId)
}()
//-------------------------------------------------------------------
//
//-------------------------------------------------------------------
-func (c *Control) SubscriptionDeleteHandler(restSubId *string, endPoint *string, meid *string, instanceId uint32) error {
+func (c *Control) SubscriptionDeleteHandler(restSubId *string, endPoint *string, meid *string, instanceId uint32) (int64, error) {
- trans := c.tracker.NewXappTransaction(xapp.NewRmrEndpoint(*endPoint), *restSubId, e2ap.RequestId{0, 0}, &xapp.RMRMeid{RanName: *meid})
+ var xAppEventInstanceID int64
+ subs, err := c.registry.GetSubscriptionFirstMatch([]uint32{instanceId})
+ if err != nil {
+ xapp.Logger.Info("Subscription Delete Handler subscription for restSubId=%v, E2EventInstanceID=%v not found %s",
+ restSubId, instanceId, idstring(err, nil))
+ return xAppEventInstanceID, nil
+ }
+
+ xAppEventInstanceID = int64(subs.ReqId.Id)
+ trans := c.tracker.NewXappTransaction(xapp.NewRmrEndpoint(*endPoint), *restSubId, e2ap.RequestId{subs.ReqId.Id, 0}, &xapp.RMRMeid{RanName: *meid})
if trans == nil {
err := fmt.Errorf("XAPP-SubDelReq transaction not created. restSubId %s, endPoint %s, meid %s, instanceId %v", *restSubId, *endPoint, *meid, instanceId)
xapp.Logger.Error("%s", err.Error())
}
defer trans.Release()
- err := c.tracker.Track(trans)
- if err != nil {
- err := fmt.Errorf("XAPP-SubDelReq %s:", idstring(err, trans))
- xapp.Logger.Error("%s", err.Error())
- return &time.ParseError{}
- }
-
- subs, err := c.registry.GetSubscriptionFirstMatch([]uint32{instanceId})
+ err = c.tracker.Track(trans)
if err != nil {
err := fmt.Errorf("XAPP-SubDelReq %s:", idstring(err, trans))
xapp.Logger.Error("%s", err.Error())
- return err
+ return xAppEventInstanceID, &time.ParseError{}
}
//
// Wake subs delete
c.registry.RemoveFromSubscription(subs, trans, waitRouteCleanup_ms, c)
- return nil
+ return xAppEventInstanceID, nil
}
//-------------------------------------------------------------------
var err error
var event interface{} = nil
var timedOut bool = false
+ const ricRequestorId = 123
subReqMsg := subs.SubReqMsg
subReqMsg.RequestId = subs.GetReqId().RequestId
+ subReqMsg.RequestId.Id = ricRequestorId
trans.Mtype, trans.Payload, err = c.e2ap.PackSubscriptionRequest(subReqMsg)
if err != nil {
xapp.Logger.Error("SUBS-SubReq: %s", idstring(err, trans, subs, parentTrans))
var err error
var event interface{}
var timedOut bool
+ const ricRequestorId = 123
subDelReqMsg := &e2ap.E2APSubscriptionDeleteRequest{}
subDelReqMsg.RequestId = subs.GetReqId().RequestId
+ subDelReqMsg.RequestId.Id = ricRequestorId
subDelReqMsg.FunctionId = subs.SubReqMsg.FunctionId
trans.Mtype, trans.Payload, err = c.e2ap.PackSubscriptionDeleteRequest(subDelReqMsg)
if err != nil {
func (c *Control) SendSubscriptionDeleteReq(subs *Subscription) {
+ const ricRequestorId = 123
xapp.Logger.Debug("Sending subscription delete due to restart. subId = %v", subs.ReqId.InstanceId)
// Send delete for every endpoint in the subscription
subDelReqMsg := &e2ap.E2APSubscriptionDeleteRequest{}
subDelReqMsg.RequestId = subs.GetReqId().RequestId
+ subDelReqMsg.RequestId.Id = ricRequestorId
subDelReqMsg.FunctionId = subs.SubReqMsg.FunctionId
mType, payload, err := c.e2ap.PackSubscriptionDeleteRequest(subDelReqMsg)
if err != nil {
c.handleXAPPSubscriptionDeleteRequest(params)
}
}
+
+func (c *Control) PrintRESTSubscriptionRequest(p *models.SubscriptionParams) {
+
+ fmt.Println("CRESTSubscriptionRequest")
+ fmt.Printf(" ClientEndpoint.Host = %s\n", p.ClientEndpoint.Host)
+
+ if p.ClientEndpoint.HTTPPort != nil {
+ fmt.Printf(" ClientEndpoint.HTTPPort = %v\n", *p.ClientEndpoint.HTTPPort)
+ } else {
+ fmt.Println(" ClientEndpoint.HTTPPort = nil")
+ }
+
+ if p.ClientEndpoint.RMRPort != nil {
+ fmt.Printf(" ClientEndpoint.RMRPort = %v\n", *p.ClientEndpoint.RMRPort)
+ } else {
+ fmt.Println(" ClientEndpoint.RMRPort = nil")
+ }
+
+ if p.Meid != nil {
+ fmt.Printf(" Meid = %s\n", *p.Meid)
+ } else {
+ fmt.Println(" Meid = nil")
+ }
+
+ for _, subscriptionDetail := range p.SubscriptionDetails {
+ if p.RANFunctionID != nil {
+ fmt.Printf(" RANFunctionID = %v\n", *p.RANFunctionID)
+ } else {
+ fmt.Println(" RANFunctionID = nil")
+ }
+ fmt.Printf(" SubscriptionDetail.XappEventInstanceID = %v\n", *subscriptionDetail.XappEventInstanceID)
+ fmt.Printf(" SubscriptionDetail.EventTriggers = %v\n", subscriptionDetail.EventTriggers)
+
+ for _, actionToBeSetup := range subscriptionDetail.ActionToBeSetupList {
+ fmt.Printf(" SubscriptionDetail.ActionToBeSetup.ActionID = %v\n", *actionToBeSetup.ActionID)
+ fmt.Printf(" SubscriptionDetail.ActionToBeSetup.ActionType = %s\n", *actionToBeSetup.ActionType)
+ fmt.Printf(" SubscriptionDetail.ActionToBeSetup.ActionDefinition = %v\n", actionToBeSetup.ActionDefinition)
+
+ if actionToBeSetup.SubsequentAction != nil {
+ fmt.Printf(" SubscriptionDetail.ActionToBeSetup.SubsequentAction.SubsequentActionType = %s\n", *actionToBeSetup.SubsequentAction.SubsequentActionType)
+ fmt.Printf(" SubscriptionDetail.ActionToBeSetup..SubsequentAction.TimeToWait = %s\n", *actionToBeSetup.SubsequentAction.TimeToWait)
+ } else {
+ fmt.Println(" SubscriptionDetail.ActionToBeSetup.SubsequentAction = nil")
+ }
+ }
+ }
+}