J release: Release container Image
[ric-plt/submgr.git] / control / subscription.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         "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
24         "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
25
26         "sync"
27 )
28
29 //-----------------------------------------------------------------------------
30 //
31 //-----------------------------------------------------------------------------
32 type Subscription struct {
33         mutex            sync.Mutex                    // Lock
34         valid            bool                          // valid
35         registry         *Registry                     // Registry
36         ReqId            RequestId                     // ReqId (Requestor Id + Seq Nro a.k.a subsid)
37         Meid             *xapp.RMRMeid                 // Meid/RanName
38         EpList           xapp.RmrEndpointList          // Endpoints
39         RMRRouteCreated  bool                          // Does subscription have RMR route
40         TransLock        sync.Mutex                    // Lock transactions, only one executed per time for subs
41         TheTrans         TransactionIf                 // Ongoing transaction
42         SubReqMsg        *e2ap.E2APSubscriptionRequest // Subscription information
43         SubRFMsg         interface{}                   // Subscription information
44         OngoingReqCount  int                           // Subscription create process is ongoing. In merge case it can ongoing for more than one endpoint
45         OngoingDelCount  int                           // Subscription delete process is ongoing. In merge case it can ongoing for more than one endpoint
46         PolicyUpdate     bool                          // This is true when policy subscrition is being updated. Used not to send delete for update after timeout or restart
47         RetryFromXapp    bool                          // Retry form xApp for subscription that already exist
48         SubRespRcvd      bool                          // Subscription response received
49         DeleteFromDb     bool                          // Delete subscription from db
50         NoRespToXapp     bool                          // Send no response for subscription delete to xApp after restart
51         DoNotWaitSubResp bool                          // Test flag. Response is not waited for Subscription Request
52 }
53
54 func (s *Subscription) String() string {
55         meidstr := "N/A"
56         if s.Meid != nil {
57                 meidstr = s.Meid.String()
58         }
59         return "subs(" + s.ReqId.String() + "/" + meidstr + "/" + s.EpList.String() + ")"
60 }
61
62 func (s *Subscription) GetCachedResponse() (interface{}, bool) {
63         s.mutex.Lock()
64         defer s.mutex.Unlock()
65         return s.SubRFMsg, s.valid
66 }
67
68 func (s *Subscription) SetCachedResponse(subRFMsg interface{}, valid bool) (interface{}, bool) {
69         s.mutex.Lock()
70         defer s.mutex.Unlock()
71         s.SubRFMsg = subRFMsg
72         s.valid = valid
73         return s.SubRFMsg, s.valid
74 }
75
76 func (s *Subscription) GetReqId() *RequestId {
77         s.mutex.Lock()
78         defer s.mutex.Unlock()
79         return &s.ReqId
80 }
81
82 func (s *Subscription) GetMeid() *xapp.RMRMeid {
83         s.mutex.Lock()
84         defer s.mutex.Unlock()
85         return s.Meid
86 }
87
88 func (s *Subscription) GetTransaction() TransactionIf {
89         s.mutex.Lock()
90         defer s.mutex.Unlock()
91         return s.TheTrans
92 }
93
94 func (s *Subscription) WaitTransactionTurn(trans TransactionIf) {
95         s.TransLock.Lock()
96         s.mutex.Lock()
97         s.TheTrans = trans
98         s.mutex.Unlock()
99 }
100
101 func (s *Subscription) ReleaseTransactionTurn(trans TransactionIf) {
102         s.mutex.Lock()
103         if trans != nil && trans == s.TheTrans {
104                 s.TheTrans = nil
105         }
106         s.mutex.Unlock()
107         s.TransLock.Unlock()
108 }
109
110 func (s *Subscription) IsMergeable(trans *TransactionXapp, subReqMsg *e2ap.E2APSubscriptionRequest) bool {
111         s.mutex.Lock()
112         defer s.mutex.Unlock()
113
114         if s.valid == false {
115                 return false
116         }
117
118         if s.SubReqMsg == nil {
119                 return false
120         }
121
122         if s.Meid.RanName != trans.Meid.RanName {
123                 return false
124         }
125
126         // EventTrigger check
127         if s.SubReqMsg.EventTriggerDefinition.Data.Length != subReqMsg.EventTriggerDefinition.Data.Length {
128                 return false
129         }
130         for i := uint64(0); i < s.SubReqMsg.EventTriggerDefinition.Data.Length; i++ {
131                 if s.SubReqMsg.EventTriggerDefinition.Data.Data[i] != subReqMsg.EventTriggerDefinition.Data.Data[i] {
132                         return false
133                 }
134         }
135
136         // Actions check
137         if len(s.SubReqMsg.ActionSetups) != len(subReqMsg.ActionSetups) {
138                 return false
139         }
140
141         for _, acts := range s.SubReqMsg.ActionSetups {
142                 for _, actt := range subReqMsg.ActionSetups {
143                         if acts.ActionId != actt.ActionId {
144                                 return false
145                         }
146                         if acts.ActionType != actt.ActionType {
147                                 return false
148                         }
149
150                         if acts.ActionType != e2ap.E2AP_ActionTypeReport {
151                                 return false
152                         }
153
154                         if acts.RicActionDefinitionPresent != actt.RicActionDefinitionPresent {
155                                 return false
156                         }
157
158                         if acts.ActionDefinitionChoice.Data.Length != actt.ActionDefinitionChoice.Data.Length {
159                                 return false
160                         }
161                         for i := uint64(0); i < acts.ActionDefinitionChoice.Data.Length; i++ {
162                                 if acts.ActionDefinitionChoice.Data.Data[i] != actt.ActionDefinitionChoice.Data.Data[i] {
163                                         return false
164                                 }
165                         }
166                         if acts.SubsequentAction.Present != actt.SubsequentAction.Present ||
167                                 acts.SubsequentAction.Type != actt.SubsequentAction.Type ||
168                                 acts.SubsequentAction.TimetoWait != actt.SubsequentAction.TimetoWait {
169                                 return false
170                         }
171                 }
172         }
173         return true
174 }