Releasing current master branch
[ric-plt/submgr.git] / pkg / 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         //"reflect"
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         TransLock sync.Mutex                    // Lock transactions, only one executed per time for subs
40         TheTrans  TransactionIf                 // Ongoing transaction
41         SubReqMsg *e2ap.E2APSubscriptionRequest // Subscription information
42         SubRFMsg  interface{}                   // Subscription information
43 }
44
45 func (s *Subscription) String() string {
46         meidstr := "N/A"
47         if s.Meid != nil {
48                 meidstr = s.Meid.String()
49         }
50         return "subs(" + s.ReqId.String() + "/" + meidstr + "/" + s.EpList.String() + ")"
51 }
52
53 func (s *Subscription) GetCachedResponse() (interface{}, bool) {
54         s.mutex.Lock()
55         defer s.mutex.Unlock()
56         return s.SubRFMsg, s.valid
57 }
58
59 func (s *Subscription) SetCachedResponse(subRFMsg interface{}, valid bool) (interface{}, bool) {
60         s.mutex.Lock()
61         defer s.mutex.Unlock()
62         s.SubRFMsg = subRFMsg
63         s.valid = valid
64         return s.SubRFMsg, s.valid
65 }
66
67 func (s *Subscription) GetReqId() *RequestId {
68         s.mutex.Lock()
69         defer s.mutex.Unlock()
70         return &s.ReqId
71 }
72
73 func (s *Subscription) GetMeid() *xapp.RMRMeid {
74         s.mutex.Lock()
75         defer s.mutex.Unlock()
76         if s.Meid != nil {
77                 return s.Meid
78         }
79         return nil
80 }
81
82 func (s *Subscription) GetTransaction() TransactionIf {
83         s.mutex.Lock()
84         defer s.mutex.Unlock()
85         return s.TheTrans
86 }
87
88 func (s *Subscription) WaitTransactionTurn(trans TransactionIf) {
89         s.TransLock.Lock()
90         s.mutex.Lock()
91         s.TheTrans = trans
92         s.mutex.Unlock()
93 }
94
95 func (s *Subscription) ReleaseTransactionTurn(trans TransactionIf) {
96         s.mutex.Lock()
97         if trans != nil && trans == s.TheTrans {
98                 s.TheTrans = nil
99         }
100         s.mutex.Unlock()
101         s.TransLock.Unlock()
102 }
103
104 func (s *Subscription) IsMergeable(trans *TransactionXapp, subReqMsg *e2ap.E2APSubscriptionRequest) bool {
105         s.mutex.Lock()
106         defer s.mutex.Unlock()
107
108         if s.valid == false {
109                 return false
110         }
111
112         if s.SubReqMsg == nil {
113                 return false
114         }
115
116         if s.Meid.RanName != trans.Meid.RanName {
117                 return false
118         }
119
120         // EventTrigger check
121         if s.SubReqMsg.EventTriggerDefinition.Data.Length != subReqMsg.EventTriggerDefinition.Data.Length {
122                 return false
123         }
124         for i := uint64(0); i < s.SubReqMsg.EventTriggerDefinition.Data.Length; i++ {
125                 if s.SubReqMsg.EventTriggerDefinition.Data.Data[i] != subReqMsg.EventTriggerDefinition.Data.Data[i] {
126                         return false
127                 }
128         }
129
130         // Actions check
131         if len(s.SubReqMsg.ActionSetups) != len(subReqMsg.ActionSetups) {
132                 return false
133         }
134
135         for _, acts := range s.SubReqMsg.ActionSetups {
136                 for _, actt := range subReqMsg.ActionSetups {
137                         if acts.ActionId != actt.ActionId {
138                                 return false
139                         }
140                         if acts.ActionType != actt.ActionType {
141                                 return false
142                         }
143
144                         if acts.ActionType != e2ap.E2AP_ActionTypeReport {
145                                 return false
146                         }
147
148                         if acts.RicActionDefinitionPresent != actt.RicActionDefinitionPresent {
149                                 return false
150                         }
151
152                         if acts.ActionDefinitionChoice.Data.Length != actt.ActionDefinitionChoice.Data.Length {
153                                 return false
154                         }
155                         for i := uint64(0); i < acts.ActionDefinitionChoice.Data.Length; i++ {
156                                 if acts.ActionDefinitionChoice.Data.Data[i] != actt.ActionDefinitionChoice.Data.Data[i] {
157                                         return false
158                                 }
159                         }
160                         //reflect.DeepEqual(acts.ActionDefinitionChoice, actt.ActionDefinitionChoice)
161
162                         if acts.SubsequentAction.Present != actt.SubsequentAction.Present ||
163                                 acts.SubsequentAction.Type != actt.SubsequentAction.Type ||
164                                 acts.SubsequentAction.TimetoWait != actt.SubsequentAction.TimetoWait {
165                                 return false
166                         }
167                 }
168         }
169
170         return true
171 }