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 "C"
  23
  24 import (
  25         "errors"
  26         rtmgrclient "gerrit.o-ran-sc.org/r/ric-plt/submgr/pkg/rtmgr_client"
  27         rtmgrhandle "gerrit.o-ran-sc.org/r/ric-plt/submgr/pkg/rtmgr_client/handle"
  28         "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
  29         httptransport "github.com/go-openapi/runtime/client"
  30         "github.com/go-openapi/strfmt"
  31         "github.com/spf13/viper"
  32         "math/rand"
  33         "sync"
  34         "time"
  35 )
  36
  37 var subReqTime time.Duration = 5 * time.Second
  38 var SubDelReqTime time.Duration = 5 * time.Second
  39
  40 type Control struct {
  41         e2ap            *E2ap
  42         registry        *Registry
  43         rtmgrClient     *RtmgrClient
  44         tracker         *Tracker
  45         timerMap        *TimerMap
  46         rmrSendMutex    sync.Mutex
  47         skipRouteUpdate bool // temp solution to skip routeupdate in unittests
  48 }
  49
  50 type RMRMeid struct {
  51         PlmnID  string
  52         EnbID   string
  53         RanName string
  54 }
  55
  56 var seedSN uint16
  57
  58 const (
  59         CREATE Action = 0
  60         MERGE  Action = 1
  61         NONE   Action = 2
  62         DELETE Action = 3
  63 )
  64
  65 func init() {
  66         xapp.Logger.Info("SUBMGR /ric-plt-submgr:r3-test-v4")
  67         viper.AutomaticEnv()
  68         viper.SetEnvPrefix("submgr")
  69         viper.AllowEmptyEnv(true)
  70         seedSN = uint16(viper.GetInt("seed_sn"))
  71         if seedSN == 0 {
  72                 rand.Seed(time.Now().UnixNano())
  73                 seedSN = uint16(rand.Intn(65535))
  74         }
  75         if seedSN > 65535 {
  76                 seedSN = 0
  77         }
  78         xapp.Logger.Info("SUBMGR: Initial Sequence Number: %v", seedSN)
  79 }
  80
  81 func NewControl() *Control {
  82         registry := new(Registry)
  83         registry.Initialize(seedSN)
  84
  85         tracker := new(Tracker)
  86         tracker.Init()
  87
  88         timerMap := new(TimerMap)
  89         timerMap.Init()
  90
  91         transport := httptransport.New(viper.GetString("rtmgr.HostAddr")+":"+viper.GetString("rtmgr.port"), viper.GetString("rtmgr.baseUrl"), []string{"http"})
  92         client := rtmgrclient.New(transport, strfmt.Default)
  93         handle := rtmgrhandle.NewProvideXappSubscriptionHandleParamsWithTimeout(10 * time.Second)
  94         deleteHandle := rtmgrhandle.NewDeleteXappSubscriptionHandleParamsWithTimeout(10 * time.Second)
  95         rtmgrClient := RtmgrClient{client, handle, deleteHandle}
  96
  97         return &Control{e2ap: new(E2ap),
  98                 registry:        registry,
  99                 rtmgrClient:     &rtmgrClient,
 100                 tracker:         tracker,
 101                 timerMap:        timerMap,
 102                 skipRouteUpdate: false,
 103         }
 104 }
 105
 106 func (c *Control) Run() {
 107         xapp.Run(c)
 108 }
 109
 110 func (c *Control) rmrSend(params *xapp.RMRParams) (err error) {
 111         status := false
 112         i := 1
 113         for ; i <= 10 && status == false; i++ {
 114                 c.rmrSendMutex.Lock()
 115                 status = xapp.Rmr.Send(params, false)
 116                 c.rmrSendMutex.Unlock()
 117                 if status == false {
 118                         xapp.Logger.Info("rmr.Send() failed. Retry count %v, Mtype: %v, SubId: %v, Xid %s", i, params.Mtype, params.SubId, params.Xid)
 119                         time.Sleep(500 * time.Millisecond)
 120                 }
 121         }
 122         if status == false {
 123                 err = errors.New("rmr.Send() failed")
 124                 xapp.Rmr.Free(params.Mbuf)
 125         }
 126         return
 127 }
 128
 129 func (c *Control) rmrReplyToSender(params *xapp.RMRParams) (err error) {
 130         c.rmrSend(params)
 131         return
 132 }
 133
 134 func (c *Control) Consume(msg *xapp.RMRParams) (err error) {
 135         switch msg.Mtype {
 136         case xapp.RICMessageTypes["RIC_SUB_REQ"]:
 137                 go c.handleSubscriptionRequest(msg)
 138         case xapp.RICMessageTypes["RIC_SUB_RESP"]:
 139                 go c.handleSubscriptionResponse(msg)
 140         case xapp.RICMessageTypes["RIC_SUB_FAILURE"]:
 141                 go c.handleSubscriptionFailure(msg)
 142         case xapp.RICMessageTypes["RIC_SUB_DEL_REQ"]:
 143                 go c.handleSubscriptionDeleteRequest(msg)
 144         case xapp.RICMessageTypes["RIC_SUB_DEL_RESP"]:
 145                 go c.handleSubscriptionDeleteResponse(msg)
 146         case xapp.RICMessageTypes["RIC_SUB_DEL_FAILURE"]:
 147                 go c.handleSubscriptionDeleteFailure(msg)
 148         default:
 149                 xapp.Logger.Info("Unknown Message Type '%d', discarding", msg.Mtype)
 150         }
 151         return nil
 152 }
 153
 154 func (c *Control) handleSubscriptionRequest(params *xapp.RMRParams) {
 155         xapp.Logger.Info("SubReq received from Src: %s, Mtype: %v, SubId: %v, Xid: %s, Meid: %v", params.Src, params.Mtype, params.SubId, params.Xid, params.Meid)
 156         xapp.Rmr.Free(params.Mbuf)
 157         params.Mbuf = nil
 158
 159         /* Reserve a sequence number and set it in the payload */
 160         newSubId, isIdValid := c.registry.ReserveSequenceNumber()
 161         if isIdValid != true {
 162                 xapp.Logger.Error("SubReq: Failed to reserve sequence number. Dropping this msg. SubId: %v, Xid: %s", params.SubId, params.Xid)
 163                 return
 164         }
 165
 166         err := c.e2ap.SetSubscriptionRequestSequenceNumber(params.Payload, newSubId)
 167         if err != nil {
 168                 xapp.Logger.Error("SubReq: Unable to set Sequence Number in Payload. Dropping this msg. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 169                 return
 170         }
 171
 172         srcAddr, srcPort, err := c.rtmgrClient.SplitSource(params.Src)
 173         if err != nil {
 174                 xapp.Logger.Error("SubReq: Failed to update routing-manager. Dropping this msg. Err: %s, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 175                 return
 176         }
 177
 178         /* Create transatcion records for every subscription request */
 179         xactKey := TransactionKey{newSubId, CREATE}
 180         xactValue := Transaction{*srcAddr, *srcPort, params}
 181         err = c.tracker.TrackTransaction(xactKey, xactValue)
 182         if err != nil {
 183                 xapp.Logger.Error("SubReq: Failed to create transaction record. Dropping this msg. Err: %v SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 184                 return
 185         }
 186
 187         /* Update routing manager about the new subscription*/
 188         subRouteAction := SubRouteInfo{CREATE, *srcAddr, *srcPort, newSubId}
 189         xapp.Logger.Info("SubReq: Starting routing manager update. SubId: %v, Xid: %s", params.SubId, params.Xid)
 190
 191         if c.skipRouteUpdate == false {
 192                 err = c.rtmgrClient.SubscriptionRequestUpdate(subRouteAction)
 193                 if err != nil {
 194                         xapp.Logger.Error("SubReq: Failed to update routing manager. Dropping this SubReq msg. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 195                         return
 196                 }
 197         }
 198
 199         // Setting new subscription ID in the RMR header
 200         params.SubId = int(newSubId)
 201         xapp.Logger.Info("Forwarding SubReq to E2T: Mtype: %v, SubId: %v, Xid %s, Meid %v", params.Mtype, params.SubId, params.Xid, params.Meid)
 202         err = c.rmrSend(params)
 203         if err != nil {
 204                 xapp.Logger.Error("SubReq: Failed to send request to E2T %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 205         } else {
 206                 c.timerMap.StartTimer("RIC_SUB_REQ", int(newSubId), subReqTime, c.handleSubscriptionRequestTimer)
 207         }
 208         xapp.Logger.Debug("SubReq: Debugging transaction table = %v", c.tracker.transactionTable)
 209         return
 210 }
 211
 212 func (c *Control) handleSubscriptionResponse(params *xapp.RMRParams) {
 213         xapp.Logger.Info("SubResp received from Src: %s, Mtype: %v, SubId: %v, Meid: %v", params.Src, params.Mtype, params.SubId, params.Meid)
 214         xapp.Rmr.Free(params.Mbuf)
 215         params.Mbuf = nil
 216
 217         payloadSeqNum, err := c.e2ap.GetSubscriptionResponseSequenceNumber(params.Payload)
 218         if err != nil {
 219                 xapp.Logger.Error("SubResp: Unable to get Sequence Number from Payload. Dropping this msg. Err: %v, SubId: %v", err, params.SubId)
 220                 return
 221         }
 222         xapp.Logger.Info("SubResp: Received payloadSeqNum: %v", payloadSeqNum)
 223
 224         if !c.registry.IsValidSequenceNumber(payloadSeqNum) {
 225                 xapp.Logger.Error("SubResp: Unknown payloadSeqNum. Dropping this msg. PayloadSeqNum: %v, SubId: %v", payloadSeqNum, params.SubId)
 226                 return
 227         }
 228
 229         c.timerMap.StopTimer("RIC_SUB_REQ", int(payloadSeqNum))
 230
 231         c.registry.setSubscriptionToConfirmed(payloadSeqNum)
 232         var transaction Transaction
 233         transaction, err = c.tracker.RetriveTransaction(payloadSeqNum, CREATE)
 234         if err != nil {
 235                 xapp.Logger.Error("SubResp: Failed to retrive transaction record. Dropping this msg. Err: %v, SubId: %v", err, params.SubId)
 236                 return
 237         }
 238         xapp.Logger.Info("SubResp: SubId: %v, from address: %v:%v. Retrieved old subId", int(payloadSeqNum), transaction.XappInstanceAddress, transaction.XappPort)
 239
 240         params.SubId = int(payloadSeqNum)
 241         params.Xid = transaction.OrigParams.Xid
 242
 243         xapp.Logger.Info("SubResp: Forwarding Subscription Response to xApp Mtype: %v, SubId: %v, Meid: %v", params.Mtype, params.SubId, params.Meid)
 244         err = c.rmrReplyToSender(params)
 245         if err != nil {
 246                 xapp.Logger.Error("SubResp: Failed to send response to xApp. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 247         }
 248
 249         xapp.Logger.Info("SubResp: SubId: %v, from address: %v:%v. Deleting transaction record", int(payloadSeqNum), transaction.XappInstanceAddress, transaction.XappPort)
 250         transaction, err = c.tracker.completeTransaction(payloadSeqNum, CREATE)
 251         if err != nil {
 252                 xapp.Logger.Error("SubResp: Failed to delete transaction record. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 253                 return
 254         }
 255         return
 256 }
 257
 258 func (c *Control) handleSubscriptionFailure(params *xapp.RMRParams) {
 259         xapp.Logger.Info("SubFail received from Src: %s, Mtype: %v, SubId: %v, Meid: %v", params.Src, params.Mtype, params.SubId, params.Meid)
 260         xapp.Rmr.Free(params.Mbuf)
 261         params.Mbuf = nil
 262
 263         payloadSeqNum, err := c.e2ap.GetSubscriptionFailureSequenceNumber(params.Payload)
 264         if err != nil {
 265                 xapp.Logger.Error("SubFail: Unable to get Sequence Number from Payload. Dropping this msg. Err: %v, SubId: %v", err, params.SubId)
 266                 return
 267         }
 268         xapp.Logger.Info("SubFail: Received payloadSeqNum: %v", payloadSeqNum)
 269
 270         c.timerMap.StopTimer("RIC_SUB_REQ", int(payloadSeqNum))
 271
 272         var transaction Transaction
 273         transaction, err = c.tracker.RetriveTransaction(payloadSeqNum, CREATE)
 274         if err != nil {
 275                 xapp.Logger.Error("SubFail: Failed to retrive transaction record. Dropping this msg. Err: %v, SubId: %v", err, params.SubId)
 276                 return
 277         }
 278         xapp.Logger.Info("SubFail: SubId: %v, from address: %v:%v. Forwarding response to xApp", int(payloadSeqNum), transaction.XappInstanceAddress, transaction.XappPort)
 279
 280         params.SubId = int(payloadSeqNum)
 281         params.Xid = transaction.OrigParams.Xid
 282
 283         xapp.Logger.Info("Forwarding SubFail to xApp: Mtype: %v, SubId: %v, Xid: %v, Meid: %v", params.Mtype, params.SubId, params.Xid, params.Meid)
 284         err = c.rmrReplyToSender(params)
 285         if err != nil {
 286                 xapp.Logger.Error("Failed to send response to xApp. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 287         }
 288
 289         time.Sleep(3 * time.Second)
 290
 291         if c.skipRouteUpdate == false {
 292                 xapp.Logger.Info("SubFail: Starting routing manager update. SubId: %v, Xid: %s", params.SubId, params.Xid)
 293                 subRouteAction := SubRouteInfo{CREATE, transaction.XappInstanceAddress, transaction.XappPort, payloadSeqNum}
 294                 err = c.rtmgrClient.SubscriptionRequestUpdate(subRouteAction)
 295                 if err != nil {
 296                         xapp.Logger.Error("SubFail: Failed to update routing manager. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 297                 }
 298         }
 299
 300         xapp.Logger.Info("SubFail: Deleting transaction record. SubId: %v, Xid: %s", params.SubId, params.Xid)
 301         if c.registry.releaseSequenceNumber(payloadSeqNum) {
 302                 transaction, err = c.tracker.completeTransaction(payloadSeqNum, CREATE)
 303                 if err != nil {
 304                         xapp.Logger.Error("SubFail: Failed to delete transaction record. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 305                         return
 306                 }
 307         } else {
 308                 xapp.Logger.Error("SubFail: Failed to release sequency number. SubId: %v, Xid: %s", params.SubId, params.Xid)
 309                 return
 310         }
 311         return
 312 }
 313
 314 func (c *Control) handleSubscriptionRequestTimer(strId string, nbrId int) {
 315         newSubId := uint16(nbrId)
 316         xapp.Logger.Info("SubReq timer expired. newSubId: %v", newSubId)
 317         //      var causeContent uint8 = 1  // just some random cause. To be checked later. Should be no respose or something
 318         //      var causeVal uint8 = 1  // just some random val. To be checked later. Should be no respose or something
 319         //      c.sendSubscriptionFailure(newSubId, causeContent, causeVal)
 320 }
 321
 322 /*
 323 func (c *Control) sendSubscriptionFailure(subId uint16, causeContent uint8, causeVal uint8) {
 324
 325         transaction, err := c.tracker.completeTransaction(subId, CREATE)
 326         if err != nil {
 327                 xapp.Logger.Error("SendSubFail: Failed to delete transaction record. Err:%v. SubId: %v", err, subId)
 328                 return
 329         }
 330         xapp.Logger.Info("SendSubFail: SubId: %v, Xid %v, Meid: %v", subId, transaction.OrigParams.Xid, transaction.OrigParams.Meid)
 331
 332         var params xapp.RMRParams
 333         params.Mtype = 12012 //xapp.RICMessageTypes["RIC_SUB_FAILURE"]
 334         params.SubId = int(subId)
 335         params.Meid = transaction.OrigParams.Meid
 336         params.Xid = transaction.OrigParams.Xid
 337
 338 //      newPayload, packErr := c.e2ap.PackSubscriptionFailure(transaction.OrigParams.Payload, subId, causeContent, causeVal)
 339 //      if packErr != nil {
 340 //              xapp.Logger.Error("SendSubFail: PackSubscriptionFailure() due to %v", packErr)
 341 //              return
 342 //      }
 343
 344         newPayload := []byte("40CA4018000003EA7E00050000010016EA6300020021EA74000200C0")  // Temporary solution
 345
 346         params.PayloadLen = len(newPayload)
 347         params.Payload = newPayload
 348
 349         xapp.Logger.Info("SendSubFail: Forwarding failure to xApp: Mtype: %v, SubId: %v, Xid: %s, Meid: %v",params.Mtype, params.SubId, params.Xid, params.Meid)
 350         err = c.rmrReplyToSender(&params)
 351         if err != nil {
 352                 xapp.Logger.Error("SendSubFail: Failed to send response to xApp. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 353         }
 354
 355         time.Sleep(3 * time.Second)
 356
 357         xapp.Logger.Info("SendSubFail: SubId: %v, from address: %v:%v. Deleting transaction record", int(subId), transaction.XappInstanceAddress, transaction.XappPort)
 358
 359         xapp.Logger.Info("SubReqTimer: Starting routing manager update. SubId: %v, Xid: %s", params.SubId, params.Xid)
 360         subRouteAction := SubRouteInfo{DELETE, transaction.XappInstanceAddress, transaction.XappPort, subId}
 361         err = c.rtmgrClient.SubscriptionRequestUpdate(subRouteAction)
 362         if err != nil {
 363                 xapp.Logger.Error("SendSubFail: Failed to update routing manager %v. SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 364                 return
 365         }
 366
 367         xapp.Logger.Info("SendSubFail: Deleting transaction record. SubId: %v, Xid: %s", params.SubId, params.Xid)
 368         if c.registry.releaseSequenceNumber(subId) {
 369                 transaction, err = c.tracker.completeTransaction(subId, CREATE)
 370                 if err != nil {
 371                         xapp.Logger.Error("SendSubFail: Failed to delete transaction record. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 372                         return
 373                 }
 374         } else {
 375                 xapp.Logger.Error("SendSubFail: Failed to release sequency number. SubId: %v, Xid: %s", params.SubId, params.Xid)
 376         }
 377         return
 378 }
 379 */
 380
 381 func (act Action) String() string {
 382         actions := [...]string{
 383                 "CREATE",
 384                 "MERGE",
 385                 "NONE",
 386                 "DELETE",
 387         }
 388
 389         if act < CREATE || act > DELETE {
 390                 return "Unknown"
 391         }
 392         return actions[act]
 393 }
 394
 395 func (act Action) valid() bool {
 396         switch act {
 397         case CREATE, MERGE, DELETE:
 398                 return true
 399         default:
 400                 return false
 401         }
 402 }
 403
 404 func (c *Control) handleSubscriptionDeleteRequest(params *xapp.RMRParams) {
 405         xapp.Logger.Info("SubDelReq received from Src: %s, Mtype: %v, SubId: %v, Xid: %s, Meid: %v", params.Src, params.Mtype, params.SubId, params.Xid, params.Meid)
 406         xapp.Rmr.Free(params.Mbuf)
 407         params.Mbuf = nil
 408
 409         payloadSeqNum, err := c.e2ap.GetSubscriptionDeleteRequestSequenceNumber(params.Payload)
 410         if err != nil {
 411                 xapp.Logger.Error("SubDelReq: Unable to get Sequence Number from Payload. Dropping this msg. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 412                 return
 413         }
 414         xapp.Logger.Info("SubDelReq: Received payloadSeqNum: %v", payloadSeqNum)
 415
 416         if c.registry.IsValidSequenceNumber(payloadSeqNum) {
 417                 c.registry.deleteSubscription(payloadSeqNum)
 418                 err = c.trackDeleteTransaction(params, payloadSeqNum)
 419                 if err != nil {
 420                         xapp.Logger.Error("SubDelReq: Failed to create transaction record. Dropping this msg. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 421                         return
 422                 }
 423         } else {
 424                 xapp.Logger.Error("SubDelReq: Not valid sequence number. Dropping this msg. SubId: %v, Xid: %s", params.SubId, params.Xid)
 425                 return
 426         }
 427
 428         xapp.Logger.Info("SubDelReq: Forwarding Request to E2T. Mtype: %v, SubId: %v, Xid: %s, Meid: %v", params.Mtype, params.SubId, params.Xid, params.Meid)
 429         c.rmrSend(params)
 430         if err != nil {
 431                 xapp.Logger.Error("SubDelReq: Failed to send request to E2T. Err %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 432         } else {
 433                 c.timerMap.StartTimer("RIC_SUB_DEL_REQ", int(payloadSeqNum), subReqTime, c.handleSubscriptionDeleteRequestTimer)
 434         }
 435         return
 436 }
 437
 438 func (c *Control) trackDeleteTransaction(params *xapp.RMRParams, payloadSeqNum uint16) (err error) {
 439         srcAddr, srcPort, err := c.rtmgrClient.SplitSource(params.Src)
 440         if err != nil {
 441                 xapp.Logger.Error("SubDelReq: Failed to update routing-manager. Err: %s, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 442         }
 443         xactKey := TransactionKey{payloadSeqNum, DELETE}
 444         xactValue := Transaction{*srcAddr, *srcPort, params}
 445         err = c.tracker.TrackTransaction(xactKey, xactValue)
 446         return
 447 }
 448
 449 func (c *Control) handleSubscriptionDeleteResponse(params *xapp.RMRParams) (err error) {
 450         xapp.Logger.Info("SubDelResp received from Src: %s, Mtype: %v, SubId: %v, Meid: %v", params.Src, params.Mtype, params.SubId, params.Meid)
 451         xapp.Rmr.Free(params.Mbuf)
 452         params.Mbuf = nil
 453
 454         payloadSeqNum, err := c.e2ap.GetSubscriptionDeleteResponseSequenceNumber(params.Payload)
 455         if err != nil {
 456                 xapp.Logger.Error("SubDelResp: Unable to get Sequence Number from Payload. Dropping this msg. Err: %v, SubId: %v", err, params.SubId)
 457                 return
 458         }
 459         xapp.Logger.Info("SubDelResp: Received payloadSeqNum: %v", payloadSeqNum)
 460
 461         c.timerMap.StopTimer("RIC_SUB_DEL_REQ", int(payloadSeqNum))
 462
 463         var transaction Transaction
 464         transaction, err = c.tracker.RetriveTransaction(payloadSeqNum, DELETE)
 465         if err != nil {
 466                 xapp.Logger.Error("SubDelResp: Failed to retrive transaction record. Dropping this msg. Err: %v, SubId: %v", err, params.SubId)
 467                 return
 468         }
 469         xapp.Logger.Info("SubDelResp: SubId: %v, from address: %v:%v. Forwarding response to xApp", int(payloadSeqNum), transaction.XappInstanceAddress, transaction.XappPort)
 470
 471         params.SubId = int(payloadSeqNum)
 472         params.Xid = transaction.OrigParams.Xid
 473         xapp.Logger.Info("Forwarding SubDelResp to xApp: Mtype: %v, SubId: %v, Xid: %v, Meid: %v", params.Mtype, params.SubId, params.Xid, params.Meid)
 474         err = c.rmrReplyToSender(params)
 475         if err != nil {
 476                 xapp.Logger.Error("SubDelResp: Failed to send response to xApp. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 477                 //              return
 478         }
 479
 480         time.Sleep(3 * time.Second)
 481
 482         if c.skipRouteUpdate == false {
 483                 xapp.Logger.Info("SubDelResp: Starting routing manager update. SubId: %v, Xid: %s", params.SubId, params.Xid)
 484                 subRouteAction := SubRouteInfo{DELETE, transaction.XappInstanceAddress, transaction.XappPort, payloadSeqNum}
 485                 err = c.rtmgrClient.SubscriptionRequestUpdate(subRouteAction)
 486                 if err != nil {
 487                         xapp.Logger.Error("SubDelResp: Failed to update routing manager. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 488                         return
 489                 }
 490         }
 491
 492         xapp.Logger.Info("SubDelResp: Deleting transaction record. SubId: %v, Xid: %s", params.SubId, params.Xid)
 493         if c.registry.releaseSequenceNumber(payloadSeqNum) {
 494                 transaction, err = c.tracker.completeTransaction(payloadSeqNum, DELETE)
 495                 if err != nil {
 496                         xapp.Logger.Error("SubDelResp: Failed to delete transaction record. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 497                         return
 498                 }
 499         } else {
 500                 xapp.Logger.Error("SubDelResp: Failed to release sequency number. SubId: %v, Xid: %s", params.SubId, params.Xid)
 501                 return
 502         }
 503         return
 504 }
 505
 506 func (c *Control) handleSubscriptionDeleteFailure(params *xapp.RMRParams) {
 507         xapp.Logger.Info("SubDelFail received from Src: %s, Mtype: %v, SubId: %v, Meid: %v", params.Src, params.Mtype, params.SubId, params.Meid)
 508         xapp.Rmr.Free(params.Mbuf)
 509         params.Mbuf = nil
 510
 511         payloadSeqNum, err := c.e2ap.GetSubscriptionDeleteFailureSequenceNumber(params.Payload)
 512         if err != nil {
 513                 xapp.Logger.Error("SubDelFail: Unable to get Sequence Number from Payload. Dropping this msg. Err: %v, SubId: %v", err, params.SubId)
 514                 return
 515         }
 516         xapp.Logger.Info("SubDelFail: Received payloadSeqNum: %v", payloadSeqNum)
 517
 518         c.timerMap.StopTimer("RIC_SUB_DEL_REQ", int(payloadSeqNum))
 519
 520         var transaction Transaction
 521         transaction, err = c.tracker.RetriveTransaction(payloadSeqNum, DELETE)
 522         if err != nil {
 523                 xapp.Logger.Error("SubDelFail: Failed to retrive transaction record. Dropping msg. Err %v, SubId: %v", err, params.SubId)
 524                 return
 525         }
 526         xapp.Logger.Info("SubDelFail: SubId: %v, from address: %v:%v. Forwarding response to xApp", int(payloadSeqNum), transaction.XappInstanceAddress, transaction.XappPort)
 527
 528         params.SubId = int(payloadSeqNum)
 529         params.Xid = transaction.OrigParams.Xid
 530         xapp.Logger.Info("Forwarding SubDelFail to xApp: Mtype: %v, SubId: %v, Xid: %v, Meid: %v", params.Mtype, params.SubId, params.Xid, params.Meid)
 531         err = c.rmrReplyToSender(params)
 532         if err != nil {
 533                 xapp.Logger.Error("Failed to send SubDelFail to xApp. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 534                 //              return
 535         }
 536
 537         time.Sleep(3 * time.Second)
 538
 539         if c.skipRouteUpdate == false {
 540                 xapp.Logger.Info("SubDelFail: Starting routing manager update. SubId: %v, Xid: %s", params.SubId, params.Xid)
 541                 subRouteAction := SubRouteInfo{DELETE, transaction.XappInstanceAddress, transaction.XappPort, payloadSeqNum}
 542                 c.rtmgrClient.SubscriptionRequestUpdate(subRouteAction)
 543                 if err != nil {
 544                         xapp.Logger.Error("SubDelFail: Failed to update routing manager. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 545                         return
 546                 }
 547         }
 548
 549         xapp.Logger.Info("SubDelFail: Deleting transaction record. SubId: %v, Xid: %s", params.SubId, params.Xid)
 550         if c.registry.releaseSequenceNumber(payloadSeqNum) {
 551                 transaction, err = c.tracker.completeTransaction(payloadSeqNum, DELETE)
 552                 if err != nil {
 553                         xapp.Logger.Error("SubDelFail: Failed to delete transaction record. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 554                         return
 555                 }
 556         } else {
 557                 xapp.Logger.Error("SubDelFail: Failed to release sequency number. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 558                 return
 559         }
 560         return
 561 }
 562
 563 func (c *Control) handleSubscriptionDeleteRequestTimer(strId string, nbrId int) {
 564         newSubId := uint16(nbrId)
 565         xapp.Logger.Info("SubDelReq timer expired. newSubId: %v", newSubId)
 566         //      var causeContent uint8 = 1  // just some random cause. To be checked later. Should be no respose or something
 567         //      var causeVal uint8 = 1  // just some random val. To be checked later. Should be no respose or something
 568         //      c.sendSubscriptionDeleteFailure(newSubId, causeContent, causeVal)
 569 }
 570
 571 /*
 572 func (c *Control) sendSubscriptionDeleteFailure(subId uint16, causeContent uint8, causeVal uint8) {
 573         transaction, err := c.tracker.completeTransaction(subId, DELETE)
 574         if err != nil {
 575                 xapp.Logger.Error("SendSubDelFail: Failed to delete transaction record. Err: %v, newSubId: %v", err, subId)
 576                 return
 577         }
 578         xapp.Logger.Info("SendSubDelFail: SubId: %v, Xid %v, Meid: %v",subId, transaction.OrigParams.Xid, transaction.OrigParams.Meid)
 579
 580         var params xapp.RMRParams
 581         params.Mtype = 12022 //xapp.RICMessageTypes["RIC_SUB_DEL_FAILURE"]
 582         params.SubId = int(subId)
 583         params.Meid = transaction.OrigParams.Meid
 584         params.Xid = transaction.OrigParams.Xid
 585
 586 //      newPayload, packErr := c.e2ap.PackSubscriptionDeleteFailure(transaction.OrigParams.Payload, subId, causeContent, causeVal)
 587 //      if packErr != nil {
 588 //              xapp.Logger.Error("SendSubDelFail: PackSubscriptionDeleteFailure(). Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid))
 589 //              return
 590 //      }
 591
 592         newPayload := []byte("40CA4018000003EA7E00050000010016EA6300020021EA74000200C0")  // Temporary solution
 593
 594         params.PayloadLen = len(newPayload)
 595         params.Payload = newPayload
 596
 597         xapp.Logger.Info("SendSubDelFail: Forwarding failure to xApp: Mtype: %v, SubId: %v, Xid: %s, Meid: %v",params.Mtype, params.SubId, params.Xid, params.Meid)
 598         err = c.rmrReplyToSender(&params)
 599         if err != nil {
 600                 xapp.Logger.Error("SendSubDelFail: Failed to send response to xApp: Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 601         }
 602
 603         time.Sleep(3 * time.Second)
 604
 605         xapp.Logger.Info("SendSubDelFail: SubId: %v, from address: %v:%v. Deleting transaction record", int(subId), transaction.XappInstanceAddress, transaction.XappPort)
 606
 607         xapp.Logger.Info("SendSubDelFail: Starting routing manager update. SubId: %v, Xid: %s", params.SubId, params.Xid)
 608         subRouteAction := SubRouteInfo{DELETE, transaction.XappInstanceAddress, transaction.XappPort, subId}
 609         err = c.rtmgrClient.SubscriptionRequestUpdate(subRouteAction)
 610         if err != nil {
 611                 xapp.Logger.Error("SendSubDelFail: Failed to update routing manager. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 612                 return
 613         }
 614
 615         xapp.Logger.Info("SendSubDelFail: Deleting transaction record. SubId: %v, Xid: %s", params.SubId, params.Xid)
 616         if c.registry.releaseSequenceNumber(subId) {
 617                 transaction, err = c.tracker.completeTransaction(subId, DELETE)
 618                 if err != nil {
 619                         xapp.Logger.Error("SendSubDelFail: Failed to delete transaction record. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 620                         return
 621                 }
 622         } else {
 623                 xapp.Logger.Error("SendSubDelFail: Failed to release sequency number. SubId: %v, Xid: %s", params.SubId, params.Xid)
 624         }
 625         return
 626 }
 627 */