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                 return
 168         }
 169
 170         srcAddr, srcPort, err := c.rtmgrClient.SplitSource(params.Src)
 171         if err != nil {
 172                 xapp.Logger.Error("SubReq: Failed to update routing-manager. Dropping this msg. Err: %s, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 173                 return
 174         }
 175
 176         /* Create transatcion records for every subscription request */
 177         xactKey := TransactionKey{newSubId, CREATE}
 178         xactValue := Transaction{*srcAddr, *srcPort, params}
 179         err = c.tracker.TrackTransaction(xactKey, xactValue)
 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                 return
 183         }
 184
 185         /* Update routing manager about the new subscription*/
 186         subRouteAction := SubRouteInfo{CREATE, *srcAddr, *srcPort, newSubId}
 187         xapp.Logger.Info("SubReq: Starting routing manager update. SubId: %v, Xid: %s", params.SubId, params.Xid)
 188
 189         err = c.rtmgrClient.SubscriptionRequestUpdate(subRouteAction)
 190         if err != nil {
 191                 xapp.Logger.Error("SubReq: Failed to update routing manager. Dropping this SubReq msg. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 192                 return
 193         }
 194
 195         // Setting new subscription ID in the RMR header
 196         params.SubId = int(newSubId)
 197         xapp.Logger.Info("Forwarding SubReq to E2T: Mtype: %v, SubId: %v, Xid %s, Meid %v", params.Mtype, params.SubId, params.Xid, params.Meid)
 198         err = c.rmrSend(params)
 199         if err != nil {
 200                 xapp.Logger.Error("SubReq: Failed to send request to E2T %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 201         } else {
 202                 c.timerMap.StartTimer("RIC_SUB_REQ", int(newSubId), subReqTime, c.handleSubscriptionRequestTimer)
 203         }
 204         xapp.Logger.Debug("SubReq: Debugging transaction table = %v", c.tracker.transactionTable)
 205         return
 206 }
 207
 208 func (c *Control) handleSubscriptionResponse(params *xapp.RMRParams) {
 209         xapp.Logger.Info("SubResp received from Src: %s, Mtype: %v, SubId: %v, Meid: %v", params.Src, params.Mtype, params.SubId, params.Meid)
 210         xapp.Rmr.Free(params.Mbuf)
 211         params.Mbuf = nil
 212
 213         payloadSeqNum, err := c.e2ap.GetSubscriptionResponseSequenceNumber(params.Payload)
 214         if err != nil {
 215                 xapp.Logger.Error("SubResp: Unable to get Sequence Number from Payload. Dropping this msg. Err: %v, SubId: %v", err, params.SubId)
 216                 return
 217         }
 218         xapp.Logger.Info("SubResp: Received payloadSeqNum: %v", payloadSeqNum)
 219
 220         if !c.registry.IsValidSequenceNumber(payloadSeqNum) {
 221                 xapp.Logger.Error("SubResp: Unknown payloadSeqNum. Dropping this msg. PayloadSeqNum: %v, SubId: %v", payloadSeqNum, params.SubId)
 222                 return
 223         }
 224
 225         c.timerMap.StopTimer("RIC_SUB_REQ", int(payloadSeqNum))
 226
 227         c.registry.setSubscriptionToConfirmed(payloadSeqNum)
 228         var transaction Transaction
 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.XappInstanceAddress, transaction.XappPort)
 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.XappInstanceAddress, transaction.XappPort)
 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         var transaction Transaction
 269         transaction, err = c.tracker.RetriveTransaction(payloadSeqNum, CREATE)
 270         if err != nil {
 271                 xapp.Logger.Error("SubFail: Failed to retrive transaction record. Dropping this msg. Err: %v, SubId: %v", err, params.SubId)
 272                 return
 273         }
 274         xapp.Logger.Info("SubFail: SubId: %v, from address: %v:%v. Forwarding response to xApp", int(payloadSeqNum), transaction.XappInstanceAddress, transaction.XappPort)
 275
 276         params.SubId = int(payloadSeqNum)
 277         params.Xid = transaction.OrigParams.Xid
 278
 279         xapp.Logger.Info("Forwarding SubFail to xApp: Mtype: %v, SubId: %v, Xid: %v, Meid: %v", params.Mtype, params.SubId, params.Xid, params.Meid)
 280         err = c.rmrReplyToSender(params)
 281         if err != nil {
 282                 xapp.Logger.Error("Failed to send response to xApp. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 283         }
 284
 285         time.Sleep(3 * time.Second)
 286
 287         xapp.Logger.Info("SubFail: Starting routing manager update. SubId: %v, Xid: %s", params.SubId, params.Xid)
 288         subRouteAction := SubRouteInfo{CREATE, transaction.XappInstanceAddress, transaction.XappPort, payloadSeqNum}
 289         err = c.rtmgrClient.SubscriptionRequestUpdate(subRouteAction)
 290         if err != nil {
 291                 xapp.Logger.Error("SubFail: Failed to update routing manager. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 292         }
 293
 294         xapp.Logger.Info("SubFail: Deleting transaction record. SubId: %v, Xid: %s", params.SubId, params.Xid)
 295         if c.registry.releaseSequenceNumber(payloadSeqNum) {
 296                 transaction, err = c.tracker.completeTransaction(payloadSeqNum, CREATE)
 297                 if err != nil {
 298                         xapp.Logger.Error("SubFail: Failed to delete transaction record. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 299                         return
 300                 }
 301         } else {
 302                 xapp.Logger.Error("SubFail: Failed to release sequency number. SubId: %v, Xid: %s", params.SubId, params.Xid)
 303                 return
 304         }
 305         return
 306 }
 307
 308 func (c *Control) handleSubscriptionRequestTimer(strId string, nbrId int) {
 309         newSubId := uint16(nbrId)
 310         xapp.Logger.Info("SubReq timer expired. newSubId: %v", newSubId)
 311         //      var causeContent uint8 = 1  // just some random cause. To be checked later. Should be no respose or something
 312         //      var causeVal uint8 = 1  // just some random val. To be checked later. Should be no respose or something
 313         //      c.sendSubscriptionFailure(newSubId, causeContent, causeVal)
 314 }
 315
 316 /*
 317 func (c *Control) sendSubscriptionFailure(subId uint16, causeContent uint8, causeVal uint8) {
 318
 319         transaction, err := c.tracker.completeTransaction(subId, CREATE)
 320         if err != nil {
 321                 xapp.Logger.Error("SendSubFail: Failed to delete transaction record. Err:%v. SubId: %v", err, subId)
 322                 return
 323         }
 324         xapp.Logger.Info("SendSubFail: SubId: %v, Xid %v, Meid: %v", subId, transaction.OrigParams.Xid, transaction.OrigParams.Meid)
 325
 326         var params xapp.RMRParams
 327         params.Mtype = 12012 //xapp.RICMessageTypes["RIC_SUB_FAILURE"]
 328         params.SubId = int(subId)
 329         params.Meid = transaction.OrigParams.Meid
 330         params.Xid = transaction.OrigParams.Xid
 331
 332 //      newPayload, packErr := c.e2ap.PackSubscriptionFailure(transaction.OrigParams.Payload, subId, causeContent, causeVal)
 333 //      if packErr != nil {
 334 //              xapp.Logger.Error("SendSubFail: PackSubscriptionFailure() due to %v", packErr)
 335 //              return
 336 //      }
 337
 338         newPayload := []byte("40CA4018000003EA7E00050000010016EA6300020021EA74000200C0")  // Temporary solution
 339
 340         params.PayloadLen = len(newPayload)
 341         params.Payload = newPayload
 342
 343         xapp.Logger.Info("SendSubFail: Forwarding failure to xApp: Mtype: %v, SubId: %v, Xid: %s, Meid: %v",params.Mtype, params.SubId, params.Xid, params.Meid)
 344         err = c.rmrReplyToSender(&params)
 345         if err != nil {
 346                 xapp.Logger.Error("SendSubFail: Failed to send response to xApp. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 347         }
 348
 349         time.Sleep(3 * time.Second)
 350
 351         xapp.Logger.Info("SendSubFail: SubId: %v, from address: %v:%v. Deleting transaction record", int(subId), transaction.XappInstanceAddress, transaction.XappPort)
 352
 353         xapp.Logger.Info("SubReqTimer: Starting routing manager update. SubId: %v, Xid: %s", params.SubId, params.Xid)
 354         subRouteAction := SubRouteInfo{DELETE, transaction.XappInstanceAddress, transaction.XappPort, subId}
 355         err = c.rtmgrClient.SubscriptionRequestUpdate(subRouteAction)
 356         if err != nil {
 357                 xapp.Logger.Error("SendSubFail: Failed to update routing manager %v. SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 358                 return
 359         }
 360
 361         xapp.Logger.Info("SendSubFail: Deleting transaction record. SubId: %v, Xid: %s", params.SubId, params.Xid)
 362         if c.registry.releaseSequenceNumber(subId) {
 363                 transaction, err = c.tracker.completeTransaction(subId, CREATE)
 364                 if err != nil {
 365                         xapp.Logger.Error("SendSubFail: Failed to delete transaction record. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 366                         return
 367                 }
 368         } else {
 369                 xapp.Logger.Error("SendSubFail: Failed to release sequency number. SubId: %v, Xid: %s", params.SubId, params.Xid)
 370         }
 371         return
 372 }
 373 */
 374
 375 func (act Action) String() string {
 376         actions := [...]string{
 377                 "CREATE",
 378                 "MERGE",
 379                 "NONE",
 380                 "DELETE",
 381         }
 382
 383         if act < CREATE || act > DELETE {
 384                 return "Unknown"
 385         }
 386         return actions[act]
 387 }
 388
 389 func (act Action) valid() bool {
 390         switch act {
 391         case CREATE, MERGE, DELETE:
 392                 return true
 393         default:
 394                 return false
 395         }
 396 }
 397
 398 func (c *Control) handleSubscriptionDeleteRequest(params *xapp.RMRParams) {
 399         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)
 400         xapp.Rmr.Free(params.Mbuf)
 401         params.Mbuf = nil
 402
 403         payloadSeqNum, err := c.e2ap.GetSubscriptionDeleteRequestSequenceNumber(params.Payload)
 404         if err != nil {
 405                 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)
 406                 return
 407         }
 408         xapp.Logger.Info("SubDelReq: Received payloadSeqNum: %v", payloadSeqNum)
 409
 410         if c.registry.IsValidSequenceNumber(payloadSeqNum) {
 411                 c.registry.deleteSubscription(payloadSeqNum)
 412                 err = c.trackDeleteTransaction(params, payloadSeqNum)
 413                 if err != nil {
 414                         xapp.Logger.Error("SubDelReq: Failed to create transaction record. Dropping this msg. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 415                         return
 416                 }
 417         } else {
 418                 xapp.Logger.Error("SubDelReq: Not valid sequence number. Dropping this msg. SubId: %v, Xid: %s", params.SubId, params.Xid)
 419                 return
 420         }
 421
 422         xapp.Logger.Info("SubDelReq: Forwarding Request to E2T. Mtype: %v, SubId: %v, Xid: %s, Meid: %v", params.Mtype, params.SubId, params.Xid, params.Meid)
 423         c.rmrSend(params)
 424         if err != nil {
 425                 xapp.Logger.Error("SubDelReq: Failed to send request to E2T. Err %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 426         } else {
 427                 c.timerMap.StartTimer("RIC_SUB_DEL_REQ", int(payloadSeqNum), subReqTime, c.handleSubscriptionDeleteRequestTimer)
 428         }
 429         return
 430 }
 431
 432 func (c *Control) trackDeleteTransaction(params *xapp.RMRParams, payloadSeqNum uint16) (err error) {
 433         srcAddr, srcPort, err := c.rtmgrClient.SplitSource(params.Src)
 434         if err != nil {
 435                 xapp.Logger.Error("SubDelReq: Failed to update routing-manager. Err: %s, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 436         }
 437         xactKey := TransactionKey{payloadSeqNum, DELETE}
 438         xactValue := Transaction{*srcAddr, *srcPort, params}
 439         err = c.tracker.TrackTransaction(xactKey, xactValue)
 440         return
 441 }
 442
 443 func (c *Control) handleSubscriptionDeleteResponse(params *xapp.RMRParams) (err error) {
 444         xapp.Logger.Info("SubDelResp received from Src: %s, Mtype: %v, SubId: %v, Meid: %v", params.Src, params.Mtype, params.SubId, params.Meid)
 445         xapp.Rmr.Free(params.Mbuf)
 446         params.Mbuf = nil
 447
 448         payloadSeqNum, err := c.e2ap.GetSubscriptionDeleteResponseSequenceNumber(params.Payload)
 449         if err != nil {
 450                 xapp.Logger.Error("SubDelResp: Unable to get Sequence Number from Payload. Dropping this msg. Err: %v, SubId: %v", err, params.SubId)
 451                 return
 452         }
 453         xapp.Logger.Info("SubDelResp: Received payloadSeqNum: %v", payloadSeqNum)
 454
 455         c.timerMap.StopTimer("RIC_SUB_DEL_REQ", int(payloadSeqNum))
 456
 457         var transaction Transaction
 458         transaction, err = c.tracker.RetriveTransaction(payloadSeqNum, DELETE)
 459         if err != nil {
 460                 xapp.Logger.Error("SubDelResp: Failed to retrive transaction record. Dropping this msg. Err: %v, SubId: %v", err, params.SubId)
 461                 return
 462         }
 463         xapp.Logger.Info("SubDelResp: SubId: %v, from address: %v:%v. Forwarding response to xApp", int(payloadSeqNum), transaction.XappInstanceAddress, transaction.XappPort)
 464
 465         params.SubId = int(payloadSeqNum)
 466         params.Xid = transaction.OrigParams.Xid
 467         xapp.Logger.Info("Forwarding SubDelResp to xApp: Mtype: %v, SubId: %v, Xid: %v, Meid: %v", params.Mtype, params.SubId, params.Xid, params.Meid)
 468         err = c.rmrReplyToSender(params)
 469         if err != nil {
 470                 xapp.Logger.Error("SubDelResp: Failed to send response to xApp. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 471                 //              return
 472         }
 473
 474         time.Sleep(3 * time.Second)
 475
 476         xapp.Logger.Info("SubDelResp: Starting routing manager update. SubId: %v, Xid: %s", params.SubId, params.Xid)
 477         subRouteAction := SubRouteInfo{DELETE, transaction.XappInstanceAddress, transaction.XappPort, payloadSeqNum}
 478         err = c.rtmgrClient.SubscriptionRequestUpdate(subRouteAction)
 479         if err != nil {
 480                 xapp.Logger.Error("SubDelResp: Failed to update routing manager. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 481                 return
 482         }
 483
 484         xapp.Logger.Info("SubDelResp: Deleting transaction record. SubId: %v, Xid: %s", params.SubId, params.Xid)
 485         if c.registry.releaseSequenceNumber(payloadSeqNum) {
 486                 transaction, err = c.tracker.completeTransaction(payloadSeqNum, DELETE)
 487                 if err != nil {
 488                         xapp.Logger.Error("SubDelResp: Failed to delete transaction record. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 489                         return
 490                 }
 491         } else {
 492                 xapp.Logger.Error("SubDelResp: Failed to release sequency number. SubId: %v, Xid: %s", params.SubId, params.Xid)
 493                 return
 494         }
 495         return
 496 }
 497
 498 func (c *Control) handleSubscriptionDeleteFailure(params *xapp.RMRParams) {
 499         xapp.Logger.Info("SubDelFail received from Src: %s, Mtype: %v, SubId: %v, Meid: %v", params.Src, params.Mtype, params.SubId, params.Meid)
 500         xapp.Rmr.Free(params.Mbuf)
 501         params.Mbuf = nil
 502
 503         payloadSeqNum, err := c.e2ap.GetSubscriptionDeleteFailureSequenceNumber(params.Payload)
 504         if err != nil {
 505                 xapp.Logger.Error("SubDelFail: Unable to get Sequence Number from Payload. Dropping this msg. Err: %v, SubId: %v", err, params.SubId)
 506                 return
 507         }
 508         xapp.Logger.Info("SubDelFail: Received payloadSeqNum: %v", payloadSeqNum)
 509
 510         c.timerMap.StopTimer("RIC_SUB_DEL_REQ", int(payloadSeqNum))
 511
 512         var transaction Transaction
 513         transaction, err = c.tracker.RetriveTransaction(payloadSeqNum, DELETE)
 514         if err != nil {
 515                 xapp.Logger.Error("SubDelFail: Failed to retrive transaction record. Dropping msg. Err %v, SubId: %v", err, params.SubId)
 516                 return
 517         }
 518         xapp.Logger.Info("SubDelFail: SubId: %v, from address: %v:%v. Forwarding response to xApp", int(payloadSeqNum), transaction.XappInstanceAddress, transaction.XappPort)
 519
 520         params.SubId = int(payloadSeqNum)
 521         params.Xid = transaction.OrigParams.Xid
 522         xapp.Logger.Info("Forwarding SubDelFail to xApp: Mtype: %v, SubId: %v, Xid: %v, Meid: %v", params.Mtype, params.SubId, params.Xid, params.Meid)
 523         err = c.rmrReplyToSender(params)
 524         if err != nil {
 525                 xapp.Logger.Error("Failed to send SubDelFail to xApp. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 526                 //              return
 527         }
 528
 529         time.Sleep(3 * time.Second)
 530
 531         xapp.Logger.Info("SubDelFail: Starting routing manager update. SubId: %v, Xid: %s", params.SubId, params.Xid)
 532         subRouteAction := SubRouteInfo{DELETE, transaction.XappInstanceAddress, transaction.XappPort, payloadSeqNum}
 533         c.rtmgrClient.SubscriptionRequestUpdate(subRouteAction)
 534         if err != nil {
 535                 xapp.Logger.Error("SubDelFail: Failed to update routing manager. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 536                 return
 537         }
 538
 539         xapp.Logger.Info("SubDelFail: Deleting transaction record. SubId: %v, Xid: %s", params.SubId, params.Xid)
 540         if c.registry.releaseSequenceNumber(payloadSeqNum) {
 541                 transaction, err = c.tracker.completeTransaction(payloadSeqNum, DELETE)
 542                 if err != nil {
 543                         xapp.Logger.Error("SubDelFail: Failed to delete transaction record. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 544                         return
 545                 }
 546         } else {
 547                 xapp.Logger.Error("SubDelFail: Failed to release sequency number. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 548                 return
 549         }
 550         return
 551 }
 552
 553 func (c *Control) handleSubscriptionDeleteRequestTimer(strId string, nbrId int) {
 554         newSubId := uint16(nbrId)
 555         xapp.Logger.Info("SubDelReq timer expired. newSubId: %v", newSubId)
 556         //      var causeContent uint8 = 1  // just some random cause. To be checked later. Should be no respose or something
 557         //      var causeVal uint8 = 1  // just some random val. To be checked later. Should be no respose or something
 558         //      c.sendSubscriptionDeleteFailure(newSubId, causeContent, causeVal)
 559 }
 560
 561 /*
 562 func (c *Control) sendSubscriptionDeleteFailure(subId uint16, causeContent uint8, causeVal uint8) {
 563         transaction, err := c.tracker.completeTransaction(subId, DELETE)
 564         if err != nil {
 565                 xapp.Logger.Error("SendSubDelFail: Failed to delete transaction record. Err: %v, newSubId: %v", err, subId)
 566                 return
 567         }
 568         xapp.Logger.Info("SendSubDelFail: SubId: %v, Xid %v, Meid: %v",subId, transaction.OrigParams.Xid, transaction.OrigParams.Meid)
 569
 570         var params xapp.RMRParams
 571         params.Mtype = 12022 //xapp.RICMessageTypes["RIC_SUB_DEL_FAILURE"]
 572         params.SubId = int(subId)
 573         params.Meid = transaction.OrigParams.Meid
 574         params.Xid = transaction.OrigParams.Xid
 575
 576 //      newPayload, packErr := c.e2ap.PackSubscriptionDeleteFailure(transaction.OrigParams.Payload, subId, causeContent, causeVal)
 577 //      if packErr != nil {
 578 //              xapp.Logger.Error("SendSubDelFail: PackSubscriptionDeleteFailure(). Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid))
 579 //              return
 580 //      }
 581
 582         newPayload := []byte("40CA4018000003EA7E00050000010016EA6300020021EA74000200C0")  // Temporary solution
 583
 584         params.PayloadLen = len(newPayload)
 585         params.Payload = newPayload
 586
 587         xapp.Logger.Info("SendSubDelFail: Forwarding failure to xApp: Mtype: %v, SubId: %v, Xid: %s, Meid: %v",params.Mtype, params.SubId, params.Xid, params.Meid)
 588         err = c.rmrReplyToSender(&params)
 589         if err != nil {
 590                 xapp.Logger.Error("SendSubDelFail: Failed to send response to xApp: Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 591         }
 592
 593         time.Sleep(3 * time.Second)
 594
 595         xapp.Logger.Info("SendSubDelFail: SubId: %v, from address: %v:%v. Deleting transaction record", int(subId), transaction.XappInstanceAddress, transaction.XappPort)
 596
 597         xapp.Logger.Info("SendSubDelFail: Starting routing manager update. SubId: %v, Xid: %s", params.SubId, params.Xid)
 598         subRouteAction := SubRouteInfo{DELETE, transaction.XappInstanceAddress, transaction.XappPort, subId}
 599         err = c.rtmgrClient.SubscriptionRequestUpdate(subRouteAction)
 600         if err != nil {
 601                 xapp.Logger.Error("SendSubDelFail: Failed to update routing manager. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 602                 return
 603         }
 604
 605         xapp.Logger.Info("SendSubDelFail: Deleting transaction record. SubId: %v, Xid: %s", params.SubId, params.Xid)
 606         if c.registry.releaseSequenceNumber(subId) {
 607                 transaction, err = c.tracker.completeTransaction(subId, DELETE)
 608                 if err != nil {
 609                         xapp.Logger.Error("SendSubDelFail: Failed to delete transaction record. Err: %v, SubId: %v, Xid: %s", err, params.SubId, params.Xid)
 610                         return
 611                 }
 612         } else {
 613                 xapp.Logger.Error("SendSubDelFail: Failed to release sequency number. SubId: %v, Xid: %s", params.SubId, params.Xid)
 614         }
 615         return
 616 }
 617 */