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