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