RICPLT-2803 Test Subscription Failure message handling, RICPLT-2804 Test Subscription...

[ric-plt/submgr.git] / pkg / control / control.go

diff --git a/pkg/control/control.go b/pkg/control/control.go
index d5a92b6..a1b2328 100755 (executable)
--- a/pkg/control/control.go
+++ b/pkg/control/control.go
@@ -44,6 +44,7 @@ type Control struct {
        tracker      *Tracker
        timerMap     *TimerMap
        rmrSendMutex sync.Mutex
+       msgCounter   uint64
 }
 
 type RMRMeid struct {
@@ -78,6 +79,7 @@ func init() {
 }
 
 func NewControl() *Control {
+
        registry := new(Registry)
        registry.Initialize(seedSN)
 
@@ -93,11 +95,17 @@ func NewControl() *Control {
        deleteHandle := rtmgrhandle.NewDeleteXappSubscriptionHandleParamsWithTimeout(10 * time.Second)
        rtmgrClient := RtmgrClient{client, handle, deleteHandle}
 
+       rtmgrClientPtr := &rtmgrClient
+
+       //TODO: to make this better. Now it is just a hack.
+       registry.rtmgrClient = rtmgrClientPtr
+
        return &Control{e2ap: new(E2ap),
                registry:    registry,
-               rtmgrClient: &rtmgrClient,
+               rtmgrClient: rtmgrClientPtr,
                tracker:     tracker,
                timerMap:    timerMap,
+               msgCounter:  0,
        }
 }
 
@@ -130,6 +138,7 @@ func (c *Control) rmrReplyToSender(params *xapp.RMRParams) (err error) {
 }
 
 func (c *Control) Consume(msg *xapp.RMRParams) (err error) {
+       c.msgCounter++
        switch msg.Mtype {
        case xapp.RICMessageTypes["RIC_SUB_REQ"]:
                go c.handleSubscriptionRequest(msg)
@@ -154,47 +163,33 @@ func (c *Control) handleSubscriptionRequest(params *xapp.RMRParams) {
        xapp.Rmr.Free(params.Mbuf)
        params.Mbuf = nil
 
-       /* Reserve a sequence number and set it in the payload */
-       newSubId, isIdValid := c.registry.ReserveSequenceNumber()
-       if isIdValid != true {
-               xapp.Logger.Error("SubReq: Failed to reserve sequence number. Dropping this msg. SubId: %v, Xid: %s", params.SubId, params.Xid)
-               c.registry.releaseSequenceNumber(newSubId)
+       srcAddr, srcPort, err := c.rtmgrClient.SplitSource(params.Src)
+       if err != nil {
+               xapp.Logger.Error("SubReq: Failed to update routing-manager. Dropping this msg. Err: %s, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
                return
        }
 
-       params.SubId = int(newSubId)
-       err := c.e2ap.SetSubscriptionRequestSequenceNumber(params.Payload, newSubId)
+       subs, err := c.registry.ReserveSubscription(RmrEndpoint{*srcAddr, *srcPort}, params.Meid)
        if err != nil {
-               xapp.Logger.Error("SubReq: Unable to get Sequence Number from Payload. Dropping this msg. Err: %v, SubId: %v, Xid: %s, Payload %X", err, params.SubId, params.Xid, params.Payload)
-               c.registry.releaseSequenceNumber(newSubId)
+               xapp.Logger.Error("SubReq: %s, Dropping this msg.", err.Error())
                return
        }
 
-       srcAddr, srcPort, err := c.rtmgrClient.SplitSource(params.Src)
+       params.SubId = int(subs.Seq)
+       err = c.e2ap.SetSubscriptionRequestSequenceNumber(params.Payload, subs.Seq)
        if err != nil {
-               xapp.Logger.Error("SubReq: Failed to update routing-manager. Dropping this msg. Err: %s, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
-               c.registry.releaseSequenceNumber(newSubId)
+               xapp.Logger.Error("SubReq: Unable to get Sequence Number from Payload. Dropping this msg. Err: %v, SubId: %v, Xid: %s, Payload %X", err, params.SubId, params.Xid, params.Payload)
+               c.registry.DelSubscription(subs.Seq)
                return
        }
 
        // Create transatcion record for every subscription request
        var forwardRespToXapp bool = true
        var responseReceived bool = false
-       transaction, err := c.tracker.TrackTransaction(newSubId, CREATE, *srcAddr, *srcPort, params, responseReceived, forwardRespToXapp)
+       _, err = c.tracker.TrackTransaction(subs, RmrEndpoint{*srcAddr, *srcPort}, params, responseReceived, forwardRespToXapp)
        if err != nil {
-               xapp.Logger.Error("SubReq: Failed to create transaction record. Dropping this msg. Err: %v SubId: %v, Xid: %s", err, params.SubId, params.Xid)
-               c.registry.releaseSequenceNumber(newSubId)
-               return
-       }
-
-       // Update routing manager about the new subscription
-       subRouteAction := transaction.SubRouteInfo()
-       xapp.Logger.Info("SubReq: Starting routing manager update. SubId: %v, Xid: %s", params.SubId, params.Xid)
-
-       err = c.rtmgrClient.SubscriptionRequestUpdate(subRouteAction)
-       if err != nil {
-               xapp.Logger.Error("SubReq: Failed to update routing manager. Dropping this msg. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
-               c.registry.releaseSequenceNumber(newSubId)
+               xapp.Logger.Error("SubReq: %s, Dropping this msg.", err.Error())
+               c.registry.DelSubscription(subs.Seq)
                return
        }
 
@@ -204,8 +199,8 @@ func (c *Control) handleSubscriptionRequest(params *xapp.RMRParams) {
        if err != nil {
                xapp.Logger.Error("SubReq: Failed to send request to E2T %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
        }
-       c.timerMap.StartTimer("RIC_SUB_REQ", int(newSubId), subReqTime, FirstTry, c.handleSubscriptionRequestTimer)
-       xapp.Logger.Debug("SubReq: Debugging transaction table = %v", c.tracker.transactionTable)
+       c.timerMap.StartTimer("RIC_SUB_REQ", int(subs.Seq), subReqTime, FirstTry, c.handleSubscriptionRequestTimer)
+       xapp.Logger.Debug("SubReq: Debugging transaction table = %v", c.tracker.transactionXappTable)
        return
 }
 
@@ -221,26 +216,25 @@ func (c *Control) handleSubscriptionResponse(params *xapp.RMRParams) {
        }
        xapp.Logger.Info("SubResp: Received payloadSeqNum: %v", payloadSeqNum)
 
-       if !c.registry.IsValidSequenceNumber(payloadSeqNum) {
+       subs := c.registry.GetSubscription(payloadSeqNum)
+       if subs == nil {
                xapp.Logger.Error("SubResp: Unknown payloadSeqNum. Dropping this msg. PayloadSeqNum: %v, SubId: %v", payloadSeqNum, params.SubId)
                return
        }
 
-       c.timerMap.StopTimer("RIC_SUB_REQ", int(payloadSeqNum))
+       transaction := subs.GetTransaction()
 
-       transaction, responseReceived, err := c.tracker.CheckResponseReceived(payloadSeqNum, CREATE)
-       if err != nil {
-               xapp.Logger.Info("SubResp: Dropping this msg. Err: %v SubId: %v", err, payloadSeqNum)
-               return
-       }
+       c.timerMap.StopTimer("RIC_SUB_REQ", int(payloadSeqNum))
 
+       responseReceived := transaction.CheckResponseReceived()
        if responseReceived == true {
                // Subscription timer already received
                return
        }
-       xapp.Logger.Info("SubResp: SubId: %v, from address: %v:%v.", payloadSeqNum, transaction.Xappkey.Addr, transaction.Xappkey.Port)
+       xapp.Logger.Info("SubResp: SubId: %v, from address: %s.", payloadSeqNum, transaction.RmrEndpoint)
 
-       c.registry.setSubscriptionToConfirmed(payloadSeqNum)
+       subs.Confirmed()
+       transaction.Release()
 
        params.SubId = int(payloadSeqNum)
        params.Xid = transaction.OrigParams.Xid
@@ -251,12 +245,7 @@ func (c *Control) handleSubscriptionResponse(params *xapp.RMRParams) {
                xapp.Logger.Error("SubResp: Failed to send response to xApp. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
        }
 
-       xapp.Logger.Info("SubResp: SubId: %v, from address: %v:%v. Deleting transaction record", payloadSeqNum, transaction.Xappkey.Addr, transaction.Xappkey.Port)
-       _, err = c.tracker.completeTransaction(payloadSeqNum, CREATE)
-       if err != nil {
-               xapp.Logger.Error("SubResp: Failed to delete transaction record. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
-               return
-       }
+       xapp.Logger.Info("SubResp: SubId: %v, from address: %s. Deleting transaction record", payloadSeqNum, transaction.RmrEndpoint)
        return
 }
 
@@ -272,9 +261,21 @@ func (c *Control) handleSubscriptionFailure(params *xapp.RMRParams) {
        }
        xapp.Logger.Info("SubFail: Received payloadSeqNum: %v", payloadSeqNum)
 
+       subs := c.registry.GetSubscription(payloadSeqNum)
+       if subs == nil {
+               xapp.Logger.Error("SubFail: Unknown payloadSeqNum. Dropping this msg. PayloadSeqNum: %v, SubId: %v", payloadSeqNum, params.SubId)
+               return
+       }
+
+       transaction := subs.GetTransaction()
+       if transaction == nil {
+               xapp.Logger.Error("SubFail: Unknown transaction. Dropping this msg. PayloadSeqNum: %v, SubId: %v", payloadSeqNum, params.SubId)
+               return
+       }
+
        c.timerMap.StopTimer("RIC_SUB_REQ", int(payloadSeqNum))
 
-       transaction, responseReceived, err := c.tracker.CheckResponseReceived(payloadSeqNum, CREATE)
+       responseReceived := transaction.CheckResponseReceived()
        if err != nil {
                xapp.Logger.Info("SubFail: Dropping this msg. Err: %v SubId: %v", err, payloadSeqNum)
                return
@@ -284,27 +285,23 @@ func (c *Control) handleSubscriptionFailure(params *xapp.RMRParams) {
                // Subscription timer already received
                return
        }
-       xapp.Logger.Info("SubFail: SubId: %v, from address: %v:%v. Forwarding response to xApp", payloadSeqNum, transaction.Xappkey.Addr, transaction.Xappkey.Port)
+       xapp.Logger.Info("SubFail: SubId: %v, from address: %s. Forwarding response to xApp", payloadSeqNum, transaction.RmrEndpoint)
 
-       time.Sleep(3 * time.Second)
+       params.SubId = int(payloadSeqNum)
+       params.Xid = transaction.OrigParams.Xid
 
-       xapp.Logger.Info("SubFail: Starting routing manager update. SubId: %v, Xid: %s", params.SubId, params.Xid)
-       subRouteAction := transaction.SubRouteInfo()
-       err = c.rtmgrClient.SubscriptionRequestUpdate(subRouteAction)
+       xapp.Logger.Info("SubFail: Forwarding SubFail to xApp: Mtype: %v, SubId: %v, Xid: %v, Meid: %v", params.Mtype, params.SubId, params.Xid, params.Meid)
+       err = c.rmrReplyToSender(params)
        if err != nil {
-               xapp.Logger.Error("SubFail: Failed to update routing manager. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
+               xapp.Logger.Error("SubFail: Failed to send response to xApp. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
        }
 
+       time.Sleep(3 * time.Second)
+
        xapp.Logger.Info("SubFail: Deleting transaction record. SubId: %v, Xid: %s", params.SubId, params.Xid)
-       if c.registry.releaseSequenceNumber(payloadSeqNum) {
-               _, err = c.tracker.completeTransaction(payloadSeqNum, CREATE)
-               if err != nil {
-                       xapp.Logger.Error("SubFail: Failed to delete transaction record. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
-                       return
-               }
-       } else {
+       transaction.Release()
+       if !c.registry.DelSubscription(payloadSeqNum) {
                xapp.Logger.Error("SubFail: Failed to release sequency number. SubId: %v, Xid: %s", params.SubId, params.Xid)
-               return
        }
        return
 }
@@ -313,12 +310,20 @@ func (c *Control) handleSubscriptionRequestTimer(strId string, nbrId int, tryCou
        subId := uint16(nbrId)
        xapp.Logger.Info("handleSubTimer: SubReq timer expired. subId: %v,  tryCount: %v", subId, tryCount)
 
-       transaction, responseReceived, err := c.tracker.CheckResponseReceived(subId, CREATE)
-       if err != nil {
-               xapp.Logger.Info("handleSubTimer: Dropping this timer action. Err: %v SubId: %v", err, subId)
+       subs := c.registry.GetSubscription(subId)
+       if subs == nil {
+               xapp.Logger.Error("SubFail: Unknown payloadSeqNum. Dropping this msg. SubId: %v", subId)
+               return
+       }
+
+       transaction := subs.GetTransaction()
+       if transaction == nil {
+               xapp.Logger.Error("SubFail: Unknown transaction. Dropping this msg. SubId: %v", subId)
                return
        }
 
+       responseReceived := transaction.CheckResponseReceived()
+
        if responseReceived == true {
                // Subscription Response or Failure already received
                return
@@ -326,14 +331,10 @@ func (c *Control) handleSubscriptionRequestTimer(strId string, nbrId int, tryCou
 
        if tryCount < maxSubReqTryCount {
                xapp.Logger.Info("handleSubTimer: Resending SubReq to E2T: Mtype: %v, SubId: %v, Xid %s, Meid %v", transaction.OrigParams.Mtype, transaction.OrigParams.SubId, transaction.OrigParams.Xid, transaction.OrigParams.Meid)
-               // Set possible to handle new response for the subId
-               err = c.tracker.RetryTransaction(subId, CREATE)
-               if err != nil {
-                       xapp.Logger.Error("handleSubDelTimer: Failed to retry transaction record. Dropping timer action. Err %v, SubId: %v", err, transaction.OrigParams.SubId)
-                       return
-               }
 
-               err = c.rmrSend(transaction.OrigParams)
+               transaction.RetryTransaction()
+
+               err := c.rmrSend(transaction.OrigParams)
                if err != nil {
                        xapp.Logger.Error("handleSubTimer: Failed to send request to E2T %v, SubId: %v, Xid: %s", err, transaction.OrigParams.SubId, transaction.OrigParams.Xid)
                }
@@ -344,7 +345,7 @@ func (c *Control) handleSubscriptionRequestTimer(strId string, nbrId int, tryCou
        }
 
        var subDelReqPayload []byte
-       subDelReqPayload, err = c.e2ap.PackSubscriptionDeleteRequest(transaction.OrigParams.Payload, subId)
+       subDelReqPayload, err := c.e2ap.PackSubscriptionDeleteRequest(transaction.OrigParams.Payload, subId)
        if err != nil {
                xapp.Logger.Error("handleSubTimer: Packing SubDelReq failed. Err: %v", err)
                return
@@ -362,17 +363,12 @@ func (c *Control) handleSubscriptionRequestTimer(strId string, nbrId int, tryCou
        params.Mbuf = nil
 
        // Delete CREATE transaction
-       _, err = c.tracker.completeTransaction(subId, CREATE)
-       if err != nil {
-               xapp.Logger.Error("handleSubTimer: Failed to delete create transaction record. Dropping this timer action. Err: %v, SubId: %v, Xid: %s", err, subId, params.Xid)
-               return
-       }
+       transaction.Release()
 
        // Create DELETE transaction
-       var forwardRespToXapp bool = false
-       _, err = c.trackDeleteTransaction(&params, subId, forwardRespToXapp)
+       _, err = c.trackDeleteTransaction(subs, &params, subId, false)
        if err != nil {
-               xapp.Logger.Error("handleSubTimer: Failed to create delete transaction record. Dropping this timer action. Err: %v, SubId: %v, Xid: %s", err, subId, params.Xid)
+               xapp.Logger.Error("handleSubTimer: %s, Dropping this msg.", err.Error())
                return
        }
 
@@ -420,14 +416,15 @@ func (c *Control) handleSubscriptionDeleteRequest(params *xapp.RMRParams) {
        }
        xapp.Logger.Info("SubDelReq: Received payloadSeqNum: %v", payloadSeqNum)
 
-       if c.registry.IsValidSequenceNumber(payloadSeqNum) {
-               c.registry.deleteSubscription(payloadSeqNum)
+       subs := c.registry.GetSubscription(payloadSeqNum)
+       if subs != nil {
                var forwardRespToXapp bool = true
-               _, err = c.trackDeleteTransaction(params, payloadSeqNum, forwardRespToXapp)
+               _, err = c.trackDeleteTransaction(subs, params, payloadSeqNum, forwardRespToXapp)
                if err != nil {
-                       xapp.Logger.Error("SubDelReq: Failed to create transaction record. Dropping this msg. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
+                       xapp.Logger.Error("SubDelReq: %s, Dropping this msg.", err.Error())
                        return
                }
+               subs.UnConfirmed()
        } else {
                xapp.Logger.Error("SubDelReq: Not valid sequence number. Dropping this msg. SubId: %v, Xid: %s", params.SubId, params.Xid)
                return
@@ -442,13 +439,13 @@ func (c *Control) handleSubscriptionDeleteRequest(params *xapp.RMRParams) {
        return
 }
 
-func (c *Control) trackDeleteTransaction(params *xapp.RMRParams, payloadSeqNum uint16, forwardRespToXapp bool) (transaction *Transaction, err error) {
+func (c *Control) trackDeleteTransaction(subs *Subscription, params *xapp.RMRParams, payloadSeqNum uint16, forwardRespToXapp bool) (transaction *Transaction, err error) {
        srcAddr, srcPort, err := c.rtmgrClient.SplitSource(params.Src)
        if err != nil {
                xapp.Logger.Error("Failed to split source address. Err: %s, SubId: %v, Xid: %s", err, payloadSeqNum, params.Xid)
        }
        var respReceived bool = false
-       transaction, err = c.tracker.TrackTransaction(payloadSeqNum, DELETE, *srcAddr, *srcPort, params, respReceived, forwardRespToXapp)
+       transaction, err = c.tracker.TrackTransaction(subs, RmrEndpoint{*srcAddr, *srcPort}, params, respReceived, forwardRespToXapp)
        return
 }
 
@@ -464,20 +461,29 @@ func (c *Control) handleSubscriptionDeleteResponse(params *xapp.RMRParams) (err
        }
        xapp.Logger.Info("SubDelResp: Received payloadSeqNum: %v", payloadSeqNum)
 
-       c.timerMap.StopTimer("RIC_SUB_DEL_REQ", int(payloadSeqNum))
+       subs := c.registry.GetSubscription(payloadSeqNum)
+       if subs == nil {
+               xapp.Logger.Error("SubDelResp: Unknown payloadSeqNum. Dropping this msg. PayloadSeqNum: %v, SubId: %v", payloadSeqNum, params.SubId)
+               return
+       }
 
-       transaction, responseReceived, err := c.tracker.CheckResponseReceived(payloadSeqNum, DELETE)
-       if err != nil {
-               xapp.Logger.Info("SubDelResp: Dropping this msg. Err: %v SubId: %v", err, payloadSeqNum)
+       transaction := subs.GetTransaction()
+       if transaction == nil {
+               xapp.Logger.Error("SubDelResp: Unknown transaction. Dropping this msg. PayloadSeqNum: %v, SubId: %v", payloadSeqNum, params.SubId)
                return
        }
 
+       c.timerMap.StopTimer("RIC_SUB_DEL_REQ", int(payloadSeqNum))
+
+       responseReceived := transaction.CheckResponseReceived()
        if responseReceived == true {
                // Subscription Delete timer already received
                return
        }
-       xapp.Logger.Info("SubDelResp: SubId: %v, from address: %v:%v. Forwarding response to xApp", payloadSeqNum, transaction.Xappkey.Addr, transaction.Xappkey.Port)
 
+       transaction.Release()
+
+       xapp.Logger.Info("SubDelResp: SubId: %v, from address: %s. Forwarding response to xApp", payloadSeqNum, transaction.RmrEndpoint)
        if transaction.ForwardRespToXapp == true {
                params.SubId = int(payloadSeqNum)
                params.Xid = transaction.OrigParams.Xid
@@ -490,22 +496,8 @@ func (c *Control) handleSubscriptionDeleteResponse(params *xapp.RMRParams) (err
                time.Sleep(3 * time.Second)
        }
 
-       xapp.Logger.Info("SubDelResp: Starting routing manager update. SubId: %v, Xid: %s", params.SubId, params.Xid)
-       subRouteAction := SubRouteInfo{DELETE, transaction.Xappkey.Addr, transaction.Xappkey.Port, payloadSeqNum}
-       err = c.rtmgrClient.SubscriptionRequestUpdate(subRouteAction)
-       if err != nil {
-               xapp.Logger.Error("SubDelResp: Failed to update routing manager. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
-               return
-       }
-
        xapp.Logger.Info("SubDelResp: Deleting transaction record. SubId: %v, Xid: %s", params.SubId, params.Xid)
-       if c.registry.releaseSequenceNumber(payloadSeqNum) {
-               _, err = c.tracker.completeTransaction(payloadSeqNum, DELETE)
-               if err != nil {
-                       xapp.Logger.Error("SubDelResp: Failed to delete transaction record. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
-                       return
-               }
-       } else {
+       if !c.registry.DelSubscription(payloadSeqNum) {
                xapp.Logger.Error("SubDelResp: Failed to release sequency number. SubId: %v, Xid: %s", params.SubId, params.Xid)
                return
        }
@@ -524,19 +516,26 @@ func (c *Control) handleSubscriptionDeleteFailure(params *xapp.RMRParams) {
        }
        xapp.Logger.Info("SubDelFail: Received payloadSeqNum: %v", payloadSeqNum)
 
-       c.timerMap.StopTimer("RIC_SUB_DEL_REQ", int(payloadSeqNum))
+       subs := c.registry.GetSubscription(payloadSeqNum)
+       if subs == nil {
+               xapp.Logger.Error("SubDelFail: Unknown payloadSeqNum. Dropping this msg. PayloadSeqNum: %v, SubId: %v", payloadSeqNum, params.SubId)
+               return
+       }
 
-       transaction, responseReceived, err := c.tracker.CheckResponseReceived(payloadSeqNum, DELETE)
-       if err != nil {
-               xapp.Logger.Info("SubDelFail: Dropping this msg. Err: %v SubId: %v", err, payloadSeqNum)
+       transaction := subs.GetTransaction()
+       if transaction == nil {
+               xapp.Logger.Error("SubDelFail: Unknown transaction. Dropping this msg. PayloadSeqNum: %v, SubId: %v", payloadSeqNum, params.SubId)
                return
        }
 
+       c.timerMap.StopTimer("RIC_SUB_DEL_REQ", int(payloadSeqNum))
+
+       responseReceived := transaction.CheckResponseReceived()
        if responseReceived == true {
                // Subscription Delete timer already received
                return
        }
-       xapp.Logger.Info("SubDelFail: SubId: %v, from address: %v:%v. Forwarding response to xApp", payloadSeqNum, transaction.Xappkey.Addr, transaction.Xappkey.Port)
+       xapp.Logger.Info("SubDelFail: SubId: %v, from address: %s. Forwarding response to xApp", payloadSeqNum, transaction.RmrEndpoint)
 
        if transaction.ForwardRespToXapp == true {
                var subDelRespPayload []byte
@@ -554,31 +553,18 @@ func (c *Control) handleSubscriptionDeleteFailure(params *xapp.RMRParams) {
                params.PayloadLen = len(subDelRespPayload)
                params.Payload = subDelRespPayload
                params.Mbuf = nil
-               xapp.Logger.Info("SubDelFail: Forwarding SubDelFail to xApp: Mtype: %v, SubId: %v, Xid: %v, Meid: %v", params.Mtype, params.SubId, params.Xid, params.Meid)
+               xapp.Logger.Info("SubDelFail: Forwarding SubDelResp to xApp: Mtype: %v, SubId: %v, Xid: %v, Meid: %v", params.Mtype, params.SubId, params.Xid, params.Meid)
                err = c.rmrReplyToSender(params)
                if err != nil {
-                       xapp.Logger.Error("SubDelFail: Failed to send SubDelFail to xApp. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
+                       xapp.Logger.Error("SubDelFail: Failed to send SubDelResp to xApp. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
                }
 
                time.Sleep(3 * time.Second)
        }
 
-       xapp.Logger.Info("SubDelFail: Starting routing manager update. SubId: %v, Xid: %s", params.SubId, params.Xid)
-       subRouteAction := SubRouteInfo{DELETE, transaction.Xappkey.Addr, transaction.Xappkey.Port, payloadSeqNum}
-       err = c.rtmgrClient.SubscriptionRequestUpdate(subRouteAction)
-       if err != nil {
-               xapp.Logger.Error("SubDelFail: Failed to update routing manager. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
-               return
-       }
-
        xapp.Logger.Info("SubDelFail: Deleting transaction record. SubId: %v, Xid: %s", params.SubId, params.Xid)
-       if c.registry.releaseSequenceNumber(payloadSeqNum) {
-               _, err = c.tracker.completeTransaction(payloadSeqNum, DELETE)
-               if err != nil {
-                       xapp.Logger.Error("SubDelFail: Failed to delete transaction record. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
-                       return
-               }
-       } else {
+       transaction.Release()
+       if !c.registry.DelSubscription(payloadSeqNum) {
                xapp.Logger.Error("SubDelFail: Failed to release sequency number. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
                return
        }
@@ -589,12 +575,19 @@ func (c *Control) handleSubscriptionDeleteRequestTimer(strId string, nbrId int,
        subId := uint16(nbrId)
        xapp.Logger.Info("handleSubDelTimer: SubDelReq timer expired. subId: %v, tryCount: %v", subId, tryCount)
 
-       transaction, responseReceived, err := c.tracker.CheckResponseReceived(subId, DELETE)
-       if err != nil {
-               xapp.Logger.Info("handleSubTimer: Dropping this timer action. Err: %v SubId: %v", err, subId)
+       subs := c.registry.GetSubscription(subId)
+       if subs == nil {
+               xapp.Logger.Error("handleSubDelTimer: Unknown payloadSeqNum. Dropping this msg. SubId: %v", subId)
+               return
+       }
+
+       transaction := subs.GetTransaction()
+       if transaction == nil {
+               xapp.Logger.Error("handleSubDelTimer: Unknown transaction. Dropping this msg. SubId: %v", subId)
                return
        }
 
+       responseReceived := transaction.CheckResponseReceived()
        if responseReceived == true {
                // Subscription Delete Response or Failure already received
                return
@@ -603,13 +596,10 @@ func (c *Control) handleSubscriptionDeleteRequestTimer(strId string, nbrId int,
        if tryCount < maxSubDelReqTryCount {
                xapp.Logger.Info("handleSubDelTimer: Resending SubDelReq to E2T: Mtype: %v, SubId: %v, Xid %s, Meid %v", transaction.OrigParams.Mtype, transaction.OrigParams.SubId, transaction.OrigParams.Xid, transaction.OrigParams.Meid)
                // Set possible to handle new response for the subId
-               err = c.tracker.RetryTransaction(subId, DELETE)
-               if err != nil {
-                       xapp.Logger.Error("handleSubDelTimer: Failed to retry transaction record. Dropping  timer action. Err %v, SubId: %v", err, transaction.OrigParams.SubId)
-                       return
-               }
 
-               err = c.rmrSend(transaction.OrigParams)
+               transaction.RetryTransaction()
+
+               err := c.rmrSend(transaction.OrigParams)
                if err != nil {
                        xapp.Logger.Error("handleSubDelTimer: Failed to send request to E2T %v, SubId: %v, Xid: %s", err, transaction.OrigParams.SubId, transaction.OrigParams.Xid)
                }
@@ -622,9 +612,9 @@ func (c *Control) handleSubscriptionDeleteRequestTimer(strId string, nbrId int,
        var params xapp.RMRParams
        if transaction.ForwardRespToXapp == true {
                var subDelRespPayload []byte
-               subDelRespPayload, err = c.e2ap.PackSubscriptionDeleteResponse(transaction.OrigParams.Payload, subId)
+               subDelRespPayload, err := c.e2ap.PackSubscriptionDeleteResponse(transaction.OrigParams.Payload, subId)
                if err != nil {
-                       xapp.Logger.Error("handleSubDelTimer: Unable to pack payload. Dropping this timer action. Err: %v, SubId: %v, Xid: %s, Payload %x", err, subId, transaction.OrigParams.Xid, transaction.OrigParams.Payload)
+                       xapp.Logger.Error("handleSubDelTimer: Unable to pack payload. Dropping this this msg. Err: %v, SubId: %v, Xid: %s, Payload %x", err, subId, transaction.OrigParams.Xid, transaction.OrigParams.Payload)
                        return
                }
 
@@ -646,22 +636,9 @@ func (c *Control) handleSubscriptionDeleteRequestTimer(strId string, nbrId int,
                time.Sleep(3 * time.Second)
        }
 
-       xapp.Logger.Info("handleSubDelTimer: Starting routing manager update. SubId: %v, Xid: %s", subId, params.Xid)
-       subRouteAction := SubRouteInfo{DELETE, transaction.Xappkey.Addr, transaction.Xappkey.Port, subId}
-       err = c.rtmgrClient.SubscriptionRequestUpdate(subRouteAction)
-       if err != nil {
-               xapp.Logger.Error("handleSubDelTimer: Failed to update routing manager. Err: %v, SubId: %v, Xid: %s", err, subId, params.Xid)
-               return
-       }
-
        xapp.Logger.Info("handleSubDelTimer: Deleting transaction record. SubId: %v, Xid: %s", subId, params.Xid)
-       if c.registry.releaseSequenceNumber(subId) {
-               _, err = c.tracker.completeTransaction(subId, DELETE)
-               if err != nil {
-                       xapp.Logger.Error("handleSubDelTimer: Failed to delete transaction record. Err: %v, SubId: %v, Xid: %s", err, subId, params.Xid)
-                       return
-               }
-       } else {
+       transaction.Release()
+       if !c.registry.DelSubscription(subId) {
                xapp.Logger.Error("handleSubDelTimer: Failed to release sequency number. SubId: %v, Xid: %s", subId, params.Xid)
        }
        return