"fmt"
"gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
rtmgrclient "gerrit.o-ran-sc.org/r/ric-plt/submgr/pkg/rtmgr_client"
- "gerrit.o-ran-sc.org/r/ric-plt/submgr/pkg/xapptweaks"
"gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/models"
"gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
httptransport "github.com/go-openapi/runtime/client"
var e2tRecvMsgTimeout time.Duration = 5 * time.Second
type Control struct {
- xapptweaks.XappWrapper
+ *xapp.RMRClient
e2ap *E2ap
registry *Registry
tracker *Tracker
//subscriber *xapp.Subscriber
+ CntRecvMsg uint64
}
type RMRMeid struct {
tracker: tracker,
//subscriber: subscriber,
}
- c.XappWrapper.Init("")
- go xapp.Subscription.Listen(c.SubscriptionHandler, c.QueryHandler)
+ go xapp.Subscription.Listen(c.SubscriptionHandler, c.QueryHandler, c.SubscriptionDeleteHandler)
//go c.subscriber.Listen(c.SubscriptionHandler, c.QueryHandler)
return c
}
func (c *Control) ReadyCB(data interface{}) {
- if c.Rmr == nil {
- c.Rmr = xapp.Rmr
+ if c.RMRClient == nil {
+ c.RMRClient = xapp.Rmr
}
}
//-------------------------------------------------------------------
//
//-------------------------------------------------------------------
-func (c *Control) SubscriptionHandler(stype models.SubscriptionType, params interface{}) (models.SubscriptionResult, error) {
+func (c *Control) SubscriptionHandler(stype models.SubscriptionType, params interface{}) (*models.SubscriptionResponse, error) {
/*
switch p := params.(type) {
case *models.ReportParams:
case *models.PolicyParams:
}
*/
- return models.SubscriptionResult{}, fmt.Errorf("Subscription rest interface not implemented")
+ return &models.SubscriptionResponse{}, fmt.Errorf("Subscription rest interface not implemented")
+}
+
+func (c *Control) SubscriptionDeleteHandler(string) error {
+ return fmt.Errorf("Subscription rest interface not implemented")
}
func (c *Control) QueryHandler() (models.SubscriptionList, error) {
//-------------------------------------------------------------------
func (c *Control) rmrSendToE2T(desc string, subs *Subscription, trans *TransactionSubs) (err error) {
- params := xapptweaks.NewParams(nil)
+ params := &xapp.RMRParams{}
params.Mtype = trans.GetMtype()
- params.SubId = int(subs.GetReqId().Seq)
+ params.SubId = int(subs.GetReqId().InstanceId)
params.Xid = ""
params.Meid = subs.GetMeid()
params.Src = ""
params.Payload = trans.Payload.Buf
params.Mbuf = nil
xapp.Logger.Info("MSG to E2T: %s %s %s", desc, trans.String(), params.String())
- return c.RmrSend(params)
+ return c.SendWithRetry(params, false, 5)
}
func (c *Control) rmrSendToXapp(desc string, subs *Subscription, trans *TransactionXapp) (err error) {
- params := xapptweaks.NewParams(nil)
+ params := &xapp.RMRParams{}
params.Mtype = trans.GetMtype()
- params.SubId = int(subs.GetReqId().Seq)
+ params.SubId = int(subs.GetReqId().InstanceId)
params.Xid = trans.GetXid()
params.Meid = trans.GetMeid()
params.Src = ""
params.Payload = trans.Payload.Buf
params.Mbuf = nil
xapp.Logger.Info("MSG to XAPP: %s %s %s", desc, trans.String(), params.String())
- return c.RmrSend(params)
+ return c.SendWithRetry(params, false, 5)
}
-func (c *Control) Consume(params *xapp.RMRParams) (err error) {
- msg := xapptweaks.NewParams(params)
- if c.Rmr == nil {
+func (c *Control) Consume(msg *xapp.RMRParams) (err error) {
+ if c.RMRClient == nil {
err = fmt.Errorf("Rmr object nil can handle %s", msg.String())
xapp.Logger.Error("%s", err.Error())
return
}
c.CntRecvMsg++
- defer c.Rmr.Free(msg.Mbuf)
+ defer c.RMRClient.Free(msg.Mbuf)
+
+ // xapp-frame might use direct access to c buffer and
+ // when msg.Mbuf is freed, someone might take it into use
+ // and payload data might be invalid inside message handle function
+ //
+ // subscriptions won't load system a lot so there is no
+ // real performance hit by cloning buffer into new go byte slice
+ cPay := append(msg.Payload[:0:0], msg.Payload...)
+ msg.Payload = cPay
+ msg.PayloadLen = len(cPay)
switch msg.Mtype {
case xapp.RIC_SUB_REQ:
//-------------------------------------------------------------------
// handle from XAPP Subscription Request
//------------------------------------------------------------------
-func (c *Control) handleXAPPSubscriptionRequest(params *xapptweaks.RMRParams) {
+func (c *Control) handleXAPPSubscriptionRequest(params *xapp.RMRParams) {
xapp.Logger.Info("MSG from XAPP: %s", params.String())
subReqMsg, err := c.e2ap.UnpackSubscriptionRequest(params.Payload)
return
}
- trans := c.tracker.NewXappTransaction(NewRmrEndpoint(params.Src), params.Xid, subReqMsg.RequestId.Seq, params.Meid)
+ trans := c.tracker.NewXappTransaction(xapp.NewRmrEndpoint(params.Src), params.Xid, subReqMsg.RequestId.InstanceId, params.Meid)
if trans == nil {
xapp.Logger.Error("XAPP-SubReq: %s", idstring(fmt.Errorf("transaction not created"), params))
return
return
}
+ //TODO handle subscription toward e2term inside AssignToSubscription / hide handleSubscriptionCreate in it?
subs, err := c.registry.AssignToSubscription(trans, subReqMsg)
if err != nil {
xapp.Logger.Error("XAPP-SubReq: %s", idstring(err, trans))
}
}
xapp.Logger.Info("XAPP-SubReq: failed %s", idstring(err, trans, subs))
- c.registry.RemoveFromSubscription(subs, trans, 5*time.Second)
+ //c.registry.RemoveFromSubscription(subs, trans, 5*time.Second)
}
//-------------------------------------------------------------------
// handle from XAPP Subscription Delete Request
//------------------------------------------------------------------
-func (c *Control) handleXAPPSubscriptionDeleteRequest(params *xapptweaks.RMRParams) {
+func (c *Control) handleXAPPSubscriptionDeleteRequest(params *xapp.RMRParams) {
xapp.Logger.Info("MSG from XAPP: %s", params.String())
subDelReqMsg, err := c.e2ap.UnpackSubscriptionDeleteRequest(params.Payload)
return
}
- trans := c.tracker.NewXappTransaction(NewRmrEndpoint(params.Src), params.Xid, subDelReqMsg.RequestId.Seq, params.Meid)
+ trans := c.tracker.NewXappTransaction(xapp.NewRmrEndpoint(params.Src), params.Xid, subDelReqMsg.RequestId.InstanceId, params.Meid)
if trans == nil {
xapp.Logger.Error("XAPP-SubDelReq: %s", idstring(fmt.Errorf("transaction not created"), params))
return
c.rmrSendToXapp("", subs, trans)
}
- c.registry.RemoveFromSubscription(subs, trans, 5*time.Second)
+ //TODO handle subscription toward e2term insiged RemoveFromSubscription / hide handleSubscriptionDelete in it?
+ //c.registry.RemoveFromSubscription(subs, trans, 5*time.Second)
}
//-------------------------------------------------------------------
subRfMsg, valid := subs.GetCachedResponse()
if subRfMsg == nil && valid == true {
- event := c.sendE2TSubscriptionRequest(subs, trans, parentTrans)
- switch event.(type) {
- case *e2ap.E2APSubscriptionResponse:
- subRfMsg, valid = subs.SetCachedResponse(event, true)
- case *e2ap.E2APSubscriptionFailure:
- subRfMsg, valid = subs.SetCachedResponse(event, false)
- default:
- xapp.Logger.Info("SUBS-SubReq: internal delete due event(%s) %s", typeofSubsMessage(event), idstring(nil, trans, subs, parentTrans))
- subRfMsg, valid = subs.SetCachedResponse(nil, false)
- c.sendE2TSubscriptionDeleteRequest(subs, trans, parentTrans)
+
+ //
+ // In case of failure
+ // - make internal delete
+ // - in case duplicate cause, retry (currently max 1 retry)
+ //
+ maxRetries := uint64(1)
+ doRetry := true
+ for retries := uint64(0); retries <= maxRetries && doRetry; retries++ {
+ doRetry = false
+
+ event := c.sendE2TSubscriptionRequest(subs, trans, parentTrans)
+ switch themsg := event.(type) {
+ case *e2ap.E2APSubscriptionResponse:
+ subRfMsg, valid = subs.SetCachedResponse(event, true)
+ case *e2ap.E2APSubscriptionFailure:
+ subRfMsg, valid = subs.SetCachedResponse(event, false)
+ doRetry = true
+ for _, item := range themsg.ActionNotAdmittedList.Items {
+ if item.Cause.Content != e2ap.E2AP_CauseContent_Ric || (item.Cause.Value != e2ap.E2AP_CauseValue_Ric_duplicate_action && item.Cause.Value != e2ap.E2AP_CauseValue_Ric_duplicate_event) {
+ doRetry = false
+ break
+ }
+ }
+ xapp.Logger.Info("SUBS-SubReq: internal delete and possible retry due event(%s) retry(%t,%d/%d) %s", typeofSubsMessage(event), doRetry, retries, maxRetries, idstring(nil, trans, subs, parentTrans))
+ c.sendE2TSubscriptionDeleteRequest(subs, trans, parentTrans)
+ default:
+ xapp.Logger.Info("SUBS-SubReq: internal delete due event(%s) %s", typeofSubsMessage(event), idstring(nil, trans, subs, parentTrans))
+ subRfMsg, valid = subs.SetCachedResponse(nil, false)
+ c.sendE2TSubscriptionDeleteRequest(subs, trans, parentTrans)
+ }
}
+
xapp.Logger.Debug("SUBS-SubReq: Handling (e2t response %s) %s", typeofSubsMessage(subRfMsg), idstring(nil, trans, subs, parentTrans))
} else {
xapp.Logger.Debug("SUBS-SubReq: Handling (cached response %s) %s", typeofSubsMessage(subRfMsg), idstring(nil, trans, subs, parentTrans))
}
+ //Now RemoveFromSubscription in here to avoid race conditions (mostly concerns delete)
+ if valid == false {
+ c.registry.RemoveFromSubscription(subs, parentTrans, 5*time.Second)
+ }
parentTrans.SendEvent(subRfMsg, 0)
}
} else {
subs.mutex.Unlock()
}
-
+ //Now RemoveFromSubscription in here to avoid race conditions (mostly concerns delete)
+ // If parallel deletes ongoing both might pass earlier sendE2TSubscriptionDeleteRequest(...) if
+ // RemoveFromSubscription locates in caller side (now in handleXAPPSubscriptionDeleteRequest(...))
+ c.registry.RemoveFromSubscription(subs, parentTrans, 5*time.Second)
parentTrans.SendEvent(nil, 0)
}
//-------------------------------------------------------------------
// handle from E2T Subscription Reponse
//-------------------------------------------------------------------
-func (c *Control) handleE2TSubscriptionResponse(params *xapptweaks.RMRParams) {
+func (c *Control) handleE2TSubscriptionResponse(params *xapp.RMRParams) {
xapp.Logger.Info("MSG from E2T: %s", params.String())
subRespMsg, err := c.e2ap.UnpackSubscriptionResponse(params.Payload)
if err != nil {
xapp.Logger.Error("MSG-SubResp %s", idstring(err, params))
return
}
- subs, err := c.registry.GetSubscriptionFirstMatch([]uint32{subRespMsg.RequestId.Seq})
+ subs, err := c.registry.GetSubscriptionFirstMatch([]uint32{subRespMsg.RequestId.InstanceId})
if err != nil {
xapp.Logger.Error("MSG-SubResp: %s", idstring(err, params))
return
//-------------------------------------------------------------------
// handle from E2T Subscription Failure
//-------------------------------------------------------------------
-func (c *Control) handleE2TSubscriptionFailure(params *xapptweaks.RMRParams) {
+func (c *Control) handleE2TSubscriptionFailure(params *xapp.RMRParams) {
xapp.Logger.Info("MSG from E2T: %s", params.String())
subFailMsg, err := c.e2ap.UnpackSubscriptionFailure(params.Payload)
if err != nil {
xapp.Logger.Error("MSG-SubFail %s", idstring(err, params))
return
}
- subs, err := c.registry.GetSubscriptionFirstMatch([]uint32{subFailMsg.RequestId.Seq})
+ subs, err := c.registry.GetSubscriptionFirstMatch([]uint32{subFailMsg.RequestId.InstanceId})
if err != nil {
xapp.Logger.Error("MSG-SubFail: %s", idstring(err, params))
return
//-------------------------------------------------------------------
// handle from E2T Subscription Delete Response
//-------------------------------------------------------------------
-func (c *Control) handleE2TSubscriptionDeleteResponse(params *xapptweaks.RMRParams) (err error) {
+func (c *Control) handleE2TSubscriptionDeleteResponse(params *xapp.RMRParams) (err error) {
xapp.Logger.Info("MSG from E2T: %s", params.String())
subDelRespMsg, err := c.e2ap.UnpackSubscriptionDeleteResponse(params.Payload)
if err != nil {
xapp.Logger.Error("MSG-SubDelResp: %s", idstring(err, params))
return
}
- subs, err := c.registry.GetSubscriptionFirstMatch([]uint32{subDelRespMsg.RequestId.Seq})
+ subs, err := c.registry.GetSubscriptionFirstMatch([]uint32{subDelRespMsg.RequestId.InstanceId})
if err != nil {
xapp.Logger.Error("MSG-SubDelResp: %s", idstring(err, params))
return
//-------------------------------------------------------------------
// handle from E2T Subscription Delete Failure
//-------------------------------------------------------------------
-func (c *Control) handleE2TSubscriptionDeleteFailure(params *xapptweaks.RMRParams) {
+func (c *Control) handleE2TSubscriptionDeleteFailure(params *xapp.RMRParams) {
xapp.Logger.Info("MSG from E2T: %s", params.String())
subDelFailMsg, err := c.e2ap.UnpackSubscriptionDeleteFailure(params.Payload)
if err != nil {
xapp.Logger.Error("MSG-SubDelFail: %s", idstring(err, params))
return
}
- subs, err := c.registry.GetSubscriptionFirstMatch([]uint32{subDelFailMsg.RequestId.Seq})
+ subs, err := c.registry.GetSubscriptionFirstMatch([]uint32{subDelFailMsg.RequestId.InstanceId})
if err != nil {
xapp.Logger.Error("MSG-SubDelFail: %s", idstring(err, params))
return
Code Review / ric-plt / submgr.git / blobdiff