Delete all subscriptions when Ran is under reset.
[ric-plt/submgr.git] / pkg / control / transaction.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 (
23         "strconv"
24         "sync"
25         "time"
26
27         "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
28         "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
29 )
30
31 //-----------------------------------------------------------------------------
32 //
33 //-----------------------------------------------------------------------------
34 type TransactionIf interface {
35         String() string
36         Release()
37         SendEvent(interface{}, time.Duration) (bool, bool)
38         WaitEvent(time.Duration) (interface{}, bool)
39 }
40
41 //-----------------------------------------------------------------------------
42 //
43 //-----------------------------------------------------------------------------
44
45 type Transaction struct {
46         mutex     sync.Mutex       //
47         Seq       uint64           //transaction sequence
48         tracker   *Tracker         //tracker instance
49         Meid      *xapp.RMRMeid    //meid transaction related
50         Mtype     int              //Encoded message type to be send
51         Payload   *e2ap.PackedData //Encoded message to be send
52         EventChan chan interface{}
53 }
54
55 func (t *Transaction) String() string {
56         meidstr := "N/A"
57         if t.Meid != nil {
58                 meidstr = t.Meid.String()
59         }
60         return "trans(" + strconv.FormatUint(uint64(t.Seq), 10) + "/" + meidstr + ")"
61 }
62
63 func (t *Transaction) SendEvent(event interface{}, waittime time.Duration) (bool, bool) {
64         if waittime > 0 {
65                 select {
66                 case t.EventChan <- event:
67                         return true, false
68                 case <-time.After(waittime):
69                         return false, true
70                 }
71                 return false, false
72         }
73         t.EventChan <- event
74         return true, false
75 }
76
77 func (t *Transaction) WaitEvent(waittime time.Duration) (interface{}, bool) {
78         if waittime > 0 {
79                 select {
80                 case event := <-t.EventChan:
81                         return event, false
82                 case <-time.After(waittime):
83                         return nil, true
84                 }
85         }
86         event := <-t.EventChan
87         return event, false
88 }
89
90 func (t *Transaction) GetMtype() int {
91         t.mutex.Lock()
92         defer t.mutex.Unlock()
93         return t.Mtype
94 }
95
96 func (t *Transaction) GetMeid() *xapp.RMRMeid {
97         t.mutex.Lock()
98         defer t.mutex.Unlock()
99         if t.Meid != nil {
100                 return t.Meid
101         }
102         return nil
103 }
104
105 /*  // This function is not used. Commented out to get better test coverage result
106 func (t *Transaction) GetPayload() *e2ap.PackedData {
107         t.mutex.Lock()
108         defer t.mutex.Unlock()
109         return t.Payload
110 }
111 */
112 //-----------------------------------------------------------------------------
113 //
114 //-----------------------------------------------------------------------------
115 type TransactionSubs struct {
116         Transaction //
117 }
118
119 func (t *TransactionSubs) String() string {
120         return "transsubs(" + t.Transaction.String() + ")"
121 }
122
123 func (t *TransactionSubs) Release() {
124         t.mutex.Lock()
125         xapp.Logger.Debug("RELEASE %s", t.String())
126         t.tracker = nil
127         t.mutex.Unlock()
128 }
129
130 //-----------------------------------------------------------------------------
131 //
132 //-----------------------------------------------------------------------------
133 type TransactionXappKey struct {
134         InstanceID uint32
135         xapp.RmrEndpoint
136         Xid string // xapp xid in req
137 }
138
139 func (key *TransactionXappKey) String() string {
140         return "transkey(" + key.RmrEndpoint.String() + "/" + key.Xid + ")"
141 }
142
143 //-----------------------------------------------------------------------------
144 //
145 //-----------------------------------------------------------------------------
146 type TransactionXapp struct {
147         Transaction
148         XappKey   *TransactionXappKey
149         RequestId e2ap.RequestId
150 }
151
152 func (t *TransactionXapp) String() string {
153         var transkey string = "transkey(N/A)"
154         if t.XappKey != nil {
155                 transkey = t.XappKey.String()
156         }
157         return "transxapp(" + t.Transaction.String() + "/" + transkey + "/" + strconv.FormatUint(uint64(t.RequestId.InstanceId), 10) + ")"
158 }
159
160 func (t *TransactionXapp) GetEndpoint() *xapp.RmrEndpoint {
161         t.mutex.Lock()
162         defer t.mutex.Unlock()
163         if t.XappKey != nil {
164                 return &t.XappKey.RmrEndpoint
165         }
166         return nil
167 }
168
169 func (t *TransactionXapp) GetXid() string {
170         t.mutex.Lock()
171         defer t.mutex.Unlock()
172         if t.XappKey != nil {
173                 return t.XappKey.Xid
174         }
175         return ""
176 }
177
178 /*  // This function is not used. Commented out to get better test coverage result
179 func (t *TransactionXapp) GetSrc() string {
180         t.mutex.Lock()
181         defer t.mutex.Unlock()
182         if t.XappKey != nil {
183                 return t.XappKey.RmrEndpoint.String()
184         }
185         return ""
186 }
187 */
188 func (t *TransactionXapp) GetSubId() uint32 {
189         t.mutex.Lock()
190         defer t.mutex.Unlock()
191         return t.RequestId.InstanceId
192 }
193
194 func (t *TransactionXapp) Release() {
195         t.mutex.Lock()
196         xapp.Logger.Debug("RELEASE %s", t.String())
197         tracker := t.tracker
198         xappkey := t.XappKey
199         t.tracker = nil
200         t.mutex.Unlock()
201
202         if tracker != nil && xappkey != nil {
203                 _, err := tracker.UnTrackTransaction(*xappkey)
204                 if err != nil {
205                         xapp.Logger.Error("tracker.UnTrackTransaction() failed:%s", err.Error())
206                 }
207         }
208 }