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