pkg/control/control.go

   1 /*
   2 ==================================================================================
   3   Copyright (c) 2019 AT&T Intellectual Property.
   4   Copyright (c) 2019 Nokia
   5
   6    Licensed under the Apache License, Version 2.0 (the "License");
   7    you may not use this file except in compliance with the License.
   8    You may obtain a copy of the License at
   9
  10        http://www.apache.org/licenses/LICENSE-2.0
  11
  12    Unless required by applicable law or agreed to in writing, software
  13    distributed under the License is distributed on an "AS IS" BASIS,
  14    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15    See the License for the specific language governing permissions and
  16    limitations under the License.
  17 ==================================================================================
  18 */
  19
  20 package control
  21
  22 import (
  23         "fmt"
  24         "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
  25         rtmgrclient "gerrit.o-ran-sc.org/r/ric-plt/submgr/pkg/rtmgr_client"
  26         rtmgrhandle "gerrit.o-ran-sc.org/r/ric-plt/submgr/pkg/rtmgr_client/handle"
  27         "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
  28         httptransport "github.com/go-openapi/runtime/client"
  29         "github.com/go-openapi/strfmt"
  30         "github.com/spf13/viper"
  31         "math/rand"
  32         "sync"
  33         "time"
  34 )
  35
  36 //-----------------------------------------------------------------------------
  37 //
  38 //-----------------------------------------------------------------------------
  39
  40 var subReqTime time.Duration = 5 * time.Second
  41 var subDelReqTime time.Duration = 5 * time.Second
  42 var maxSubReqTryCount uint64 = 2    // Initial try + retry
  43 var maxSubDelReqTryCount uint64 = 2 // Initial try + retry
  44
  45 type Control struct {
  46         e2ap         *E2ap
  47         registry     *Registry
  48         rtmgrClient  *RtmgrClient
  49         tracker      *Tracker
  50         timerMap     *TimerMap
  51         rmrSendMutex sync.Mutex
  52         msgCounter   uint64
  53 }
  54
  55 type RMRMeid struct {
  56         PlmnID  string
  57         EnbID   string
  58         RanName string
  59 }
  60
  61 var seedSN uint16
  62
  63 const (
  64         CREATE Action = 0
  65         MERGE  Action = 1
  66         NONE   Action = 2
  67         DELETE Action = 3
  68 )
  69
  70 func init() {
  71         xapp.Logger.Info("SUBMGR")
  72         viper.AutomaticEnv()
  73         viper.SetEnvPrefix("submgr")
  74         viper.AllowEmptyEnv(true)
  75         seedSN = uint16(viper.GetInt("seed_sn"))
  76         if seedSN == 0 {
  77                 rand.Seed(time.Now().UnixNano())
  78                 seedSN = uint16(rand.Intn(65535))
  79         }
  80         if seedSN > 65535 {
  81                 seedSN = 0
  82         }
  83         xapp.Logger.Info("SUBMGR: Initial Sequence Number: %v", seedSN)
  84 }
  85
  86 func NewControl() *Control {
  87
  88         registry := new(Registry)
  89         registry.Initialize(seedSN)
  90
  91         tracker := new(Tracker)
  92         tracker.Init()
  93
  94         timerMap := new(TimerMap)
  95         timerMap.Init()
  96
  97         transport := httptransport.New(viper.GetString("rtmgr.HostAddr")+":"+viper.GetString("rtmgr.port"), viper.GetString("rtmgr.baseUrl"), []string{"http"})
  98         client := rtmgrclient.New(transport, strfmt.Default)
  99         handle := rtmgrhandle.NewProvideXappSubscriptionHandleParamsWithTimeout(10 * time.Second)
 100         deleteHandle := rtmgrhandle.NewDeleteXappSubscriptionHandleParamsWithTimeout(10 * time.Second)
 101         rtmgrClient := RtmgrClient{client, handle, deleteHandle}
 102
 103         rtmgrClientPtr := &rtmgrClient
 104
 105         //TODO: to make this better. Now it is just a hack.
 106         registry.rtmgrClient = rtmgrClientPtr
 107
 108         return &Control{e2ap: new(E2ap),
 109                 registry:    registry,
 110                 rtmgrClient: rtmgrClientPtr,
 111                 tracker:     tracker,
 112                 timerMap:    timerMap,
 113                 msgCounter:  0,
 114         }
 115 }
 116
 117 func (c *Control) Run() {
 118         xapp.Run(c)
 119 }
 120
 121 func (c *Control) rmrSendRaw(desc string, params *RMRParams) (err error) {
 122
 123         xapp.Logger.Info("%s: %s", desc, params.String())
 124         status := false
 125         i := 1
 126         for ; i <= 10 && status == false; i++ {
 127                 c.rmrSendMutex.Lock()
 128                 status = xapp.Rmr.Send(params.RMRParams, false)
 129                 c.rmrSendMutex.Unlock()
 130                 if status == false {
 131                         xapp.Logger.Info("rmr.Send() failed. Retry count %d, %s", i, params.String())
 132                         time.Sleep(500 * time.Millisecond)
 133                 }
 134         }
 135         if status == false {
 136                 err = fmt.Errorf("rmr.Send() failed. Retry count %d, %s", i, params.String())
 137                 xapp.Logger.Error("%s: %s", desc, err.Error())
 138                 xapp.Rmr.Free(params.Mbuf)
 139         }
 140         return
 141 }
 142
 143 func (c *Control) rmrSend(desc string, subs *Subscription, trans *Transaction, payload []byte, payloadLen int) (err error) {
 144         params := &RMRParams{&xapp.RMRParams{}}
 145         params.Mtype = trans.GetMtype()
 146         params.SubId = int(subs.GetSubId())
 147         params.Xid = ""
 148         params.Meid = subs.GetMeid()
 149         params.Src = ""
 150         params.PayloadLen = payloadLen
 151         params.Payload = payload
 152         params.Mbuf = nil
 153
 154         return c.rmrSendRaw(desc, params)
 155 }
 156
 157 func (c *Control) rmrReplyToSender(desc string, subs *Subscription, trans *Transaction, mType int, payload []byte, payloadLen int) (err error) {
 158         params := &RMRParams{&xapp.RMRParams{}}
 159         params.Mtype = mType
 160         params.SubId = int(subs.GetSubId())
 161         params.Xid = trans.GetXid()
 162         params.Meid = trans.GetMeid()
 163         params.Src = ""
 164         params.PayloadLen = payloadLen
 165         params.Payload = payload
 166         params.Mbuf = nil
 167
 168         return c.rmrSendRaw(desc, params)
 169 }
 170
 171 func (c *Control) Consume(params *xapp.RMRParams) (err error) {
 172         xapp.Rmr.Free(params.Mbuf)
 173         params.Mbuf = nil
 174         msg := &RMRParams{params}
 175         c.msgCounter++
 176         switch msg.Mtype {
 177         case xapp.RICMessageTypes["RIC_SUB_REQ"]:
 178                 go c.handleSubscriptionRequest(msg)
 179         case xapp.RICMessageTypes["RIC_SUB_RESP"]:
 180                 go c.handleSubscriptionResponse(msg)
 181         case xapp.RICMessageTypes["RIC_SUB_FAILURE"]:
 182                 go c.handleSubscriptionFailure(msg)
 183         case xapp.RICMessageTypes["RIC_SUB_DEL_REQ"]:
 184                 go c.handleSubscriptionDeleteRequest(msg)
 185         case xapp.RICMessageTypes["RIC_SUB_DEL_RESP"]:
 186                 go c.handleSubscriptionDeleteResponse(msg)
 187         case xapp.RICMessageTypes["RIC_SUB_DEL_FAILURE"]:
 188                 go c.handleSubscriptionDeleteFailure(msg)
 189         default:
 190                 xapp.Logger.Info("Unknown Message Type '%d', discarding", msg.Mtype)
 191         }
 192
 193         return nil
 194 }
 195
 196 func (c *Control) handleSubscriptionRequest(params *RMRParams) {
 197         xapp.Logger.Info("SubReq from xapp: %s", params.String())
 198
 199         //
 200         //
 201         //
 202         trans, err := c.tracker.TrackTransaction(NewRmrEndpoint(params.Src),
 203                 params.Mtype,
 204                 params.Xid,
 205                 params.Meid,
 206                 false,
 207                 true)
 208
 209         if err != nil {
 210                 xapp.Logger.Error("SubReq: %s, Dropping this msg. %s", err.Error(), params.String())
 211                 return
 212         }
 213
 214         //
 215         //
 216         //
 217         trans.SubReqMsg, err = c.e2ap.UnpackSubscriptionRequest(params.Payload)
 218         if err != nil {
 219                 xapp.Logger.Error("SubReq: %s Dropping this msg. %s", err.Error(), trans)
 220                 trans.Release()
 221                 return
 222         }
 223
 224         //
 225         //
 226         //
 227         subs, err := c.registry.ReserveSubscription(&trans.RmrEndpoint, trans.Meid)
 228         if err != nil {
 229                 xapp.Logger.Error("SubReq: %s, Dropping this msg. %s", err.Error(), trans)
 230                 trans.Release()
 231                 return
 232         }
 233
 234         err = subs.SetTransaction(trans)
 235         if err != nil {
 236                 xapp.Logger.Error("SubReq: %s, Dropping this msg. %s", err.Error(), trans)
 237                 c.registry.DelSubscription(subs.Seq)
 238                 trans.Release()
 239                 return
 240         }
 241
 242         trans.SubReqMsg.RequestId.Seq = uint32(subs.GetSubId())
 243
 244         //
 245         // TODO: subscription create is in fact owned by subscription and not transaction.
 246         //       Transaction is toward xapp while Subscription is toward ran.
 247         //       In merge several xapps may wake transactions, while only one subscription
 248         //       toward ran occurs -> subscription owns subscription creation toward ran
 249         //
 250         //       This is intermediate solution while improving message handling
 251         //
 252         packedData, err := c.e2ap.PackSubscriptionRequest(trans.SubReqMsg)
 253         if err != nil {
 254                 xapp.Logger.Error("SubReq: %s for trans %s", err.Error(), trans)
 255                 c.registry.DelSubscription(subs.Seq)
 256                 trans.Release()
 257                 return
 258         }
 259
 260         //Optimize and store packed message to be sent (for retransmission). Again owned by subscription?
 261         trans.Payload = packedData.Buf
 262         trans.PayloadLen = len(packedData.Buf)
 263
 264         c.rmrSend("SubReq to E2T", subs, trans, packedData.Buf, len(packedData.Buf))
 265
 266         c.timerMap.StartTimer("RIC_SUB_REQ", int(subs.Seq), subReqTime, FirstTry, c.handleSubscriptionRequestTimer)
 267         xapp.Logger.Debug("SubReq: Debugging trans table = %v", c.tracker.transactionXappTable)
 268         return
 269 }
 270
 271 func (c *Control) handleSubscriptionResponse(params *RMRParams) {
 272         xapp.Logger.Info("SubResp from E2T: %s", params.String())
 273
 274         payloadSeqNum, err := c.e2ap.GetSubscriptionResponseSequenceNumber(params.Payload)
 275         if err != nil {
 276                 xapp.Logger.Error("SubResp: 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)
 277                 return
 278         }
 279         xapp.Logger.Info("SubResp: Received payloadSeqNum: %v", payloadSeqNum)
 280
 281         subs := c.registry.GetSubscription(payloadSeqNum)
 282         if subs == nil {
 283                 xapp.Logger.Error("SubResp: Unknown payloadSeqNum. Dropping this msg. PayloadSeqNum: %v, SubId: %v", payloadSeqNum, params.SubId)
 284                 return
 285         }
 286
 287         trans := subs.GetTransaction()
 288
 289         c.timerMap.StopTimer("RIC_SUB_REQ", int(payloadSeqNum))
 290
 291         responseReceived := trans.CheckResponseReceived()
 292         if responseReceived == true {
 293                 // Subscription timer already received
 294                 return
 295         }
 296
 297         subs.Confirmed()
 298         trans.Release()
 299         c.rmrReplyToSender("SubResp to xapp", subs, trans, params.Mtype, params.Payload, params.PayloadLen)
 300         xapp.Logger.Info("SubResp: SubId: %v, from address: %s. Deleting trans record", payloadSeqNum, trans.RmrEndpoint)
 301         return
 302 }
 303
 304 func (c *Control) handleSubscriptionFailure(params *RMRParams) {
 305         xapp.Logger.Info("SubFail from E2T: %s", params.String())
 306
 307         payloadSeqNum, err := c.e2ap.GetSubscriptionFailureSequenceNumber(params.Payload)
 308         if err != nil {
 309                 xapp.Logger.Error("SubFail: 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)
 310                 return
 311         }
 312         xapp.Logger.Info("SubFail: Received payloadSeqNum: %v", payloadSeqNum)
 313
 314         subs := c.registry.GetSubscription(payloadSeqNum)
 315         if subs == nil {
 316                 xapp.Logger.Error("SubFail: Unknown payloadSeqNum. Dropping this msg. PayloadSeqNum: %v, SubId: %v", payloadSeqNum, params.SubId)
 317                 return
 318         }
 319
 320         trans := subs.GetTransaction()
 321         if trans == nil {
 322                 xapp.Logger.Error("SubFail: Unknown trans. Dropping this msg. PayloadSeqNum: %v, SubId: %v", payloadSeqNum, params.SubId)
 323                 return
 324         }
 325
 326         c.timerMap.StopTimer("RIC_SUB_REQ", int(payloadSeqNum))
 327
 328         responseReceived := trans.CheckResponseReceived()
 329         if err != nil {
 330                 xapp.Logger.Info("SubFail: Dropping this msg. Err: %v SubId: %v", err, payloadSeqNum)
 331                 return
 332         }
 333
 334         if responseReceived == true {
 335                 // Subscription timer already received
 336                 return
 337         }
 338         xapp.Logger.Info("SubFail: SubId: %v, from address: %s. Forwarding response to xApp", payloadSeqNum, trans.RmrEndpoint)
 339
 340         c.rmrReplyToSender("SubFail to xapp", subs, trans, params.Mtype, params.Payload, params.PayloadLen)
 341
 342         time.Sleep(3 * time.Second)
 343
 344         xapp.Logger.Info("SubFail: Deleting trans record. SubId: %v, Xid: %s", params.SubId, params.Xid)
 345         trans.Release()
 346         if !c.registry.DelSubscription(payloadSeqNum) {
 347                 xapp.Logger.Error("SubFail: Failed to release sequency number. SubId: %v, Xid: %s", params.SubId, params.Xid)
 348         }
 349         return
 350 }
 351
 352 func (c *Control) handleSubscriptionRequestTimer(strId string, nbrId int, tryCount uint64) {
 353         xapp.Logger.Info("SubReq timeout: subId: %v,  tryCount: %v", nbrId, tryCount)
 354
 355         subs := c.registry.GetSubscription(uint16(nbrId))
 356         if subs == nil {
 357                 xapp.Logger.Error("SubReq timeout: Unknown payloadSeqNum. Dropping this msg. SubId: %v", nbrId)
 358                 return
 359         }
 360
 361         trans := subs.GetTransaction()
 362         if trans == nil {
 363                 xapp.Logger.Error("SubReq timeout: Unknown trans. Dropping this msg. SubId: %v", subs.GetSubId())
 364                 return
 365         }
 366
 367         responseReceived := trans.CheckResponseReceived()
 368
 369         if responseReceived == true {
 370                 // Subscription Response or Failure already received
 371                 return
 372         }
 373
 374         if tryCount < maxSubReqTryCount {
 375                 xapp.Logger.Info("SubReq timeout: Resending SubReq to E2T: Mtype: %v, SubId: %v, Xid %s, Meid %v", trans.GetMtype(), subs.GetSubId(), trans.GetXid(), trans.GetMeid())
 376
 377                 trans.RetryTransaction()
 378
 379                 c.rmrSend("SubReq(SubReq timer) to E2T", subs, trans, trans.Payload, trans.PayloadLen)
 380
 381                 tryCount++
 382                 c.timerMap.StartTimer("RIC_SUB_REQ", int(subs.GetSubId()), subReqTime, tryCount, c.handleSubscriptionRequestTimer)
 383                 return
 384         }
 385
 386         // Delete CREATE transaction
 387         trans.Release()
 388
 389         // Create DELETE transaction (internal and no messages toward xapp)
 390         deltrans, err := c.tracker.TrackTransaction(&trans.RmrEndpoint,
 391                 12020, // RIC SUBSCRIPTION DELETE
 392                 trans.GetXid(),
 393                 trans.GetMeid(),
 394                 false,
 395                 false)
 396
 397         if err != nil {
 398                 xapp.Logger.Error("SubReq timeout: %s, Dropping this msg.", err.Error())
 399                 //TODO improve error handling. Important at least in merge
 400                 c.registry.DelSubscription(subs.GetSubId())
 401                 return
 402         }
 403
 404         deltrans.SubDelReqMsg = &e2ap.E2APSubscriptionDeleteRequest{}
 405         deltrans.SubDelReqMsg.RequestId.Id = trans.SubReqMsg.RequestId.Id
 406         deltrans.SubDelReqMsg.RequestId.Seq = uint32(subs.GetSubId())
 407         deltrans.SubDelReqMsg.FunctionId = trans.SubReqMsg.FunctionId
 408         packedData, err := c.e2ap.PackSubscriptionDeleteRequest(deltrans.SubDelReqMsg)
 409         if err != nil {
 410                 xapp.Logger.Error("SubReq timeout: Packing SubDelReq failed. Err: %v", err)
 411                 //TODO improve error handling. Important at least in merge
 412                 deltrans.Release()
 413                 c.registry.DelSubscription(subs.GetSubId())
 414                 return
 415         }
 416         deltrans.PayloadLen = len(packedData.Buf)
 417         deltrans.Payload = packedData.Buf
 418
 419         err = subs.SetTransaction(deltrans)
 420         if err != nil {
 421                 xapp.Logger.Error("SubReq timeout: %s, Dropping this msg.", err.Error())
 422                 //TODO improve error handling. Important at least in merge
 423                 deltrans.Release()
 424                 return
 425         }
 426
 427         c.rmrSend("SubDelReq(SubReq timer) to E2T", subs, deltrans, deltrans.Payload, deltrans.PayloadLen)
 428
 429         c.timerMap.StartTimer("RIC_SUB_DEL_REQ", int(subs.GetSubId()), subDelReqTime, FirstTry, c.handleSubscriptionDeleteRequestTimer)
 430         return
 431 }
 432
 433 func (c *Control) handleSubscriptionDeleteRequest(params *RMRParams) {
 434         var subs *Subscription
 435
 436         xapp.Logger.Info("SubDelReq from xapp: %s", params.String())
 437
 438         trans, err := c.tracker.TrackTransaction(NewRmrEndpoint(params.Src),
 439                 params.Mtype,
 440                 params.Xid,
 441                 params.Meid,
 442                 false,
 443                 true)
 444
 445         if err != nil {
 446                 xapp.Logger.Error("SubDelReq: %s, Dropping this msg. %s", err.Error(), params.String())
 447                 return
 448         }
 449
 450         payloadSeqNum, err := c.e2ap.GetSubscriptionDeleteRequestSequenceNumber(params.Payload)
 451         if err == nil {
 452                 subs = c.registry.GetSubscription(payloadSeqNum)
 453         }
 454         if subs == nil && params.SubId > 0 {
 455                 subs = c.registry.GetSubscription(uint16(params.SubId))
 456         }
 457
 458         if subs == nil {
 459                 xapp.Logger.Error("SubDelReq: Not valid subscription found payloadSeqNum: %d. Dropping this msg. %s", payloadSeqNum, trans)
 460                 trans.Release()
 461                 return
 462         }
 463         xapp.Logger.Info("SubDelReq: subscription found payloadSeqNum: %d. %s", payloadSeqNum, trans)
 464
 465         trans.PayloadLen = params.PayloadLen
 466         trans.Payload = params.Payload
 467
 468         err = subs.SetTransaction(trans)
 469         if err != nil {
 470                 xapp.Logger.Error("SubDelReq: %s, Dropping this msg. %s", err.Error(), trans)
 471                 trans.Release()
 472                 return
 473         }
 474
 475         subs.UnConfirmed()
 476
 477         c.rmrSend("SubDelReq to E2T", subs, trans, trans.Payload, trans.PayloadLen)
 478
 479         c.timerMap.StartTimer("RIC_SUB_DEL_REQ", int(subs.GetSubId()), subDelReqTime, FirstTry, c.handleSubscriptionDeleteRequestTimer)
 480         return
 481 }
 482
 483 func (c *Control) handleSubscriptionDeleteResponse(params *RMRParams) (err error) {
 484         xapp.Logger.Info("SubDelResp from E2T:%s", params.String())
 485
 486         payloadSeqNum, err := c.e2ap.GetSubscriptionDeleteResponseSequenceNumber(params.Payload)
 487         if err != nil {
 488                 xapp.Logger.Error("SubDelResp: 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)
 489                 return
 490         }
 491         xapp.Logger.Info("SubDelResp: Received payloadSeqNum: %v", payloadSeqNum)
 492
 493         subs := c.registry.GetSubscription(payloadSeqNum)
 494         if subs == nil {
 495                 xapp.Logger.Error("SubDelResp: Unknown payloadSeqNum. Dropping this msg. PayloadSeqNum: %v, SubId: %v", payloadSeqNum, params.SubId)
 496                 return
 497         }
 498
 499         trans := subs.GetTransaction()
 500         if trans == nil {
 501                 xapp.Logger.Error("SubDelResp: Unknown trans. Dropping this msg. PayloadSeqNum: %v, SubId: %v", subs.GetSubId(), params.SubId)
 502                 return
 503         }
 504
 505         c.timerMap.StopTimer("RIC_SUB_DEL_REQ", int(subs.GetSubId()))
 506
 507         responseReceived := trans.CheckResponseReceived()
 508         if responseReceived == true {
 509                 // Subscription Delete timer already received
 510                 return
 511         }
 512
 513         trans.Release()
 514
 515         if trans.ForwardRespToXapp == true {
 516                 c.rmrReplyToSender("SubDelResp to xapp", subs, trans, params.Mtype, params.Payload, params.PayloadLen)
 517                 time.Sleep(3 * time.Second)
 518         }
 519
 520         xapp.Logger.Info("SubDelResp: Deleting trans record. SubId: %v, Xid: %s", subs.GetSubId(), trans.GetXid())
 521         if !c.registry.DelSubscription(subs.GetSubId()) {
 522                 xapp.Logger.Error("SubDelResp: Failed to release sequency number. SubId: %v, Xid: %s", subs.GetSubId(), trans.GetXid())
 523                 return
 524         }
 525         return
 526 }
 527
 528 func (c *Control) handleSubscriptionDeleteFailure(params *RMRParams) {
 529         xapp.Logger.Info("SubDelFail from E2T:%s", params.String())
 530
 531         payloadSeqNum, err := c.e2ap.GetSubscriptionDeleteFailureSequenceNumber(params.Payload)
 532         if err != nil {
 533                 xapp.Logger.Error("SubDelFail: Unable to get Sequence Number from Payload. Dropping this msg. Err: %v, %s", err, params.String())
 534                 return
 535         }
 536         xapp.Logger.Info("SubDelFail: Received payloadSeqNum: %v", payloadSeqNum)
 537
 538         subs := c.registry.GetSubscription(payloadSeqNum)
 539         if subs == nil {
 540                 xapp.Logger.Error("SubDelFail: Unknown payloadSeqNum. Dropping this msg. PayloadSeqNum: %v, SubId: %v", payloadSeqNum, params.SubId)
 541                 return
 542         }
 543
 544         trans := subs.GetTransaction()
 545         if trans == nil {
 546                 xapp.Logger.Error("SubDelFail: Unknown trans. Dropping this msg. PayloadSeqNum: %v, SubId: %v", subs.GetSubId(), params.SubId)
 547                 return
 548         }
 549
 550         c.timerMap.StopTimer("RIC_SUB_DEL_REQ", int(subs.GetSubId()))
 551
 552         responseReceived := trans.CheckResponseReceived()
 553         if responseReceived == true {
 554                 // Subscription Delete timer already received
 555                 return
 556         }
 557         if trans.ForwardRespToXapp == true {
 558                 var subDelRespPayload []byte
 559                 subDelRespPayload, err = c.e2ap.PackSubscriptionDeleteResponseFromSubDelReq(trans.Payload, subs.GetSubId())
 560                 if err != nil {
 561                         xapp.Logger.Error("SubDelFail:Packing SubDelResp failed. Err: %v", err)
 562                         return
 563                 }
 564
 565                 // RIC SUBSCRIPTION DELETE RESPONSE
 566                 c.rmrReplyToSender("SubDelFail to xapp", subs, trans, 12021, subDelRespPayload, len(subDelRespPayload))
 567                 time.Sleep(3 * time.Second)
 568         }
 569
 570         xapp.Logger.Info("SubDelFail: Deleting trans record. SubId: %v, Xid: %s", subs.GetSubId(), trans.GetXid())
 571         trans.Release()
 572         if !c.registry.DelSubscription(subs.GetSubId()) {
 573                 xapp.Logger.Error("SubDelFail: Failed to release sequency number. Err: %v, SubId: %v, Xid: %s", err, subs.GetSubId(), trans.GetXid())
 574                 return
 575         }
 576         return
 577 }
 578
 579 func (c *Control) handleSubscriptionDeleteRequestTimer(strId string, nbrId int, tryCount uint64) {
 580         xapp.Logger.Info("SubDelReq timeout: subId: %v, tryCount: %v", nbrId, tryCount)
 581
 582         subs := c.registry.GetSubscription(uint16(nbrId))
 583         if subs == nil {
 584                 xapp.Logger.Error("SubDelReq timeout: Unknown payloadSeqNum. Dropping this msg. SubId: %v", nbrId)
 585                 return
 586         }
 587
 588         trans := subs.GetTransaction()
 589         if trans == nil {
 590                 xapp.Logger.Error("SubDelReq timeout: Unknown trans. Dropping this msg. SubId: %v", subs.GetSubId())
 591                 return
 592         }
 593
 594         responseReceived := trans.CheckResponseReceived()
 595         if responseReceived == true {
 596                 // Subscription Delete Response or Failure already received
 597                 return
 598         }
 599
 600         if tryCount < maxSubDelReqTryCount {
 601                 xapp.Logger.Info("SubDelReq timeout: Resending SubDelReq to E2T: Mtype: %v, SubId: %v, Xid %s, Meid %v", trans.GetMtype(), subs.GetSubId(), trans.GetXid(), trans.GetMeid())
 602                 // Set possible to handle new response for the subId
 603
 604                 trans.RetryTransaction()
 605
 606                 c.rmrSend("SubDelReq(SubDelReq timer) to E2T", subs, trans, trans.Payload, trans.PayloadLen)
 607
 608                 tryCount++
 609                 c.timerMap.StartTimer("RIC_SUB_DEL_REQ", int(subs.GetSubId()), subReqTime, tryCount, c.handleSubscriptionDeleteRequestTimer)
 610                 return
 611         }
 612
 613         if trans.ForwardRespToXapp == true {
 614                 var subDelRespPayload []byte
 615                 subDelRespPayload, err := c.e2ap.PackSubscriptionDeleteResponseFromSubDelReq(trans.Payload, subs.GetSubId())
 616                 if err != nil {
 617                         xapp.Logger.Error("SubDelReq timeout: Unable to pack payload. Dropping this this msg. Err: %v, SubId: %v, Xid: %s, Payload %x", err, subs.GetSubId(), trans.GetXid(), trans.Payload)
 618                         return
 619                 }
 620
 621                 // RIC SUBSCRIPTION DELETE RESPONSE
 622                 c.rmrReplyToSender("SubDelResp(SubDelReq timer) to xapp", subs, trans, 12021, subDelRespPayload, len(subDelRespPayload))
 623
 624                 time.Sleep(3 * time.Second)
 625
 626         }
 627
 628         xapp.Logger.Info("SubDelReq timeout: Deleting trans record. SubId: %v, Xid: %s", subs.GetSubId(), trans.GetXid())
 629         trans.Release()
 630         if !c.registry.DelSubscription(subs.GetSubId()) {
 631                 xapp.Logger.Error("SubDelReq timeout: Failed to release sequency number. SubId: %v, Xid: %s", subs.GetSubId(), trans.GetXid())
 632         }
 633         return
 634 }