[RICPLT-2523] Improvements...
[ric-plt/e2mgr.git] / E2Manager / rNibWriter / rNibWriter.go
1 //
2 // Copyright 2019 AT&T Intellectual Property
3 // Copyright 2019 Nokia
4 //
5 // Licensed under the Apache License, Version 2.0 (the "License");
6 // you may not use this file except in compliance with the License.
7 // You may obtain a copy of the License at
8 //
9 //      http://www.apache.org/licenses/LICENSE-2.0
10 //
11 // Unless required by applicable law or agreed to in writing, software
12 // distributed under the License is distributed on an "AS IS" BASIS,
13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 // See the License for the specific language governing permissions and
15 // limitations under the License.
16 //
17
18 package rNibWriter
19
20 import (
21         "encoding/json"
22         "fmt"
23         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
24         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
25         "github.com/golang/protobuf/proto"
26 )
27
28 const E2TAddressesKey = "E2TAddresses"
29
30 type rNibWriterInstance struct {
31         sdl common.ISdlInstance
32 }
33
34 /*
35 RNibWriter interface allows saving data to the redis DB
36 */
37 type RNibWriter interface {
38         SaveNodeb(nbIdentity *entities.NbIdentity, nb *entities.NodebInfo) error
39         UpdateNodebInfo(nodebInfo *entities.NodebInfo) error
40         SaveRanLoadInformation(inventoryName string, ranLoadInformation *entities.RanLoadInformation) error
41         SaveE2TInstance(e2tInstance *entities.E2TInstance) error
42         SaveE2TAddresses(addresses []string) error
43 }
44
45 /*
46 GetRNibWriter returns reference to RNibWriter
47 */
48
49 func GetRNibWriter(sdl common.ISdlInstance) RNibWriter {
50         return &rNibWriterInstance{sdl: sdl}
51 }
52
53 /*
54 SaveNodeb saves nodeB entity data in the redis DB according to the specified data model
55 */
56 func (w *rNibWriterInstance) SaveNodeb(nbIdentity *entities.NbIdentity, entity *entities.NodebInfo) error {
57         isNotEmptyIdentity := isNotEmpty(nbIdentity)
58
59         if isNotEmptyIdentity && entity.GetNodeType() == entities.Node_UNKNOWN {
60                 return common.NewValidationError(fmt.Sprintf("#rNibWriter.saveNodeB - Unknown responding node type, entity: %v", entity))
61         }
62         data, err := proto.Marshal(entity)
63         if err != nil {
64                 return common.NewInternalError(err)
65         }
66         var pairs []interface{}
67         key, rNibErr := common.ValidateAndBuildNodeBNameKey(nbIdentity.InventoryName)
68         if rNibErr != nil {
69                 return rNibErr
70         }
71         pairs = append(pairs, key, data)
72
73         if isNotEmptyIdentity {
74                 key, rNibErr = common.ValidateAndBuildNodeBIdKey(entity.GetNodeType().String(), nbIdentity.GlobalNbId.GetPlmnId(), nbIdentity.GlobalNbId.GetNbId())
75                 if rNibErr != nil {
76                         return rNibErr
77                 }
78                 pairs = append(pairs, key, data)
79         }
80
81         if entity.GetEnb() != nil {
82                 pairs, rNibErr = appendEnbCells(nbIdentity, entity.GetEnb().GetServedCells(), pairs)
83                 if rNibErr != nil {
84                         return rNibErr
85                 }
86         }
87         if entity.GetGnb() != nil {
88                 pairs, rNibErr = appendGnbCells(nbIdentity, entity.GetGnb().GetServedNrCells(), pairs)
89                 if rNibErr != nil {
90                         return rNibErr
91                 }
92         }
93         err = w.sdl.Set(pairs)
94         if err != nil {
95                 return common.NewInternalError(err)
96         }
97
98         ranNameIdentity := &entities.NbIdentity{InventoryName: nbIdentity.InventoryName}
99
100         if isNotEmptyIdentity {
101                 nbIdData, err := proto.Marshal(ranNameIdentity)
102                 if err != nil {
103                         return common.NewInternalError(err)
104                 }
105                 err = w.sdl.RemoveMember(entities.Node_UNKNOWN.String(), nbIdData)
106                 if err != nil {
107                         return common.NewInternalError(err)
108                 }
109         } else {
110                 nbIdentity = ranNameIdentity
111         }
112
113         nbIdData, err := proto.Marshal(nbIdentity)
114         if err != nil {
115                 return common.NewInternalError(err)
116         }
117         err = w.sdl.AddMember(entity.GetNodeType().String(), nbIdData)
118         if err != nil {
119                 return common.NewInternalError(err)
120         }
121         return nil
122 }
123
124 /*
125 UpdateNodebInfo...
126 */
127 func (w *rNibWriterInstance) UpdateNodebInfo(nodebInfo *entities.NodebInfo) error {
128
129         nodebNameKey, rNibErr := common.ValidateAndBuildNodeBNameKey(nodebInfo.GetRanName())
130
131         if rNibErr != nil {
132                 return rNibErr
133         }
134
135         nodebIdKey, buildNodebIdKeyError := common.ValidateAndBuildNodeBIdKey(nodebInfo.GetNodeType().String(), nodebInfo.GlobalNbId.GetPlmnId(), nodebInfo.GlobalNbId.GetNbId())
136
137         data, err := proto.Marshal(nodebInfo)
138
139         if err != nil {
140                 return common.NewInternalError(err)
141         }
142
143         var pairs []interface{}
144         pairs = append(pairs, nodebNameKey, data)
145
146         if buildNodebIdKeyError == nil {
147                 pairs = append(pairs, nodebIdKey, data)
148         }
149
150         err = w.sdl.Set(pairs)
151
152         if err != nil {
153                 return common.NewInternalError(err)
154         }
155
156         return nil
157 }
158
159 /*
160 SaveRanLoadInformation stores ran load information for the provided ran
161 */
162 func (w *rNibWriterInstance) SaveRanLoadInformation(inventoryName string, ranLoadInformation *entities.RanLoadInformation) error {
163
164         key, rnibErr := common.ValidateAndBuildRanLoadInformationKey(inventoryName)
165
166         if rnibErr != nil {
167                 return rnibErr
168         }
169
170         data, err := proto.Marshal(ranLoadInformation)
171
172         if err != nil {
173                 return common.NewInternalError(err)
174         }
175
176         var pairs []interface{}
177         pairs = append(pairs, key, data)
178
179         err = w.sdl.Set(pairs)
180
181         if err != nil {
182                 return common.NewInternalError(err)
183         }
184
185         return nil
186 }
187
188 func (w *rNibWriterInstance) SaveE2TInstance(e2tInstance *entities.E2TInstance) error {
189
190         key, rnibErr := common.ValidateAndBuildE2TInstanceKey(e2tInstance.Address)
191
192         if rnibErr != nil {
193                 return rnibErr
194         }
195
196         data, err := json.Marshal(e2tInstance)
197
198         if err != nil {
199                 return common.NewInternalError(err)
200         }
201
202         var pairs []interface{}
203         pairs = append(pairs, key, data)
204
205         err = w.sdl.Set(pairs)
206
207         if err != nil {
208                 return common.NewInternalError(err)
209         }
210
211         return nil
212 }
213
214 func (w *rNibWriterInstance) SaveE2TAddresses(addresses []string) error {
215
216         data, err := json.Marshal(addresses)
217
218         if err != nil {
219                 return common.NewInternalError(err)
220         }
221
222         var pairs []interface{}
223         pairs = append(pairs, E2TAddressesKey, data)
224
225         err = w.sdl.Set(pairs)
226
227         if err != nil {
228                 return common.NewInternalError(err)
229         }
230
231         return nil
232 }
233
234 /*
235 Close the writer
236 */
237 func Close() {
238         //Nothing to do
239 }
240
241 func appendEnbCells(nbIdentity *entities.NbIdentity, cells []*entities.ServedCellInfo, pairs []interface{}) ([]interface{}, error) {
242         for _, cell := range cells {
243                 cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: cell}}
244                 cellData, err := proto.Marshal(&cellEntity)
245                 if err != nil {
246                         return pairs, common.NewInternalError(err)
247                 }
248                 key, rNibErr := common.ValidateAndBuildCellIdKey(cell.GetCellId())
249                 if rNibErr != nil {
250                         return pairs, rNibErr
251                 }
252                 pairs = append(pairs, key, cellData)
253                 key, rNibErr = common.ValidateAndBuildCellNamePciKey(nbIdentity.InventoryName, cell.GetPci())
254                 if rNibErr != nil {
255                         return pairs, rNibErr
256                 }
257                 pairs = append(pairs, key, cellData)
258         }
259         return pairs, nil
260 }
261
262 func appendGnbCells(nbIdentity *entities.NbIdentity, cells []*entities.ServedNRCell, pairs []interface{}) ([]interface{}, error) {
263         for _, cell := range cells {
264                 cellEntity := entities.Cell{Type: entities.Cell_NR_CELL, Cell: &entities.Cell_ServedNrCell{ServedNrCell: cell}}
265                 cellData, err := proto.Marshal(&cellEntity)
266                 if err != nil {
267                         return pairs, common.NewInternalError(err)
268                 }
269                 key, rNibErr := common.ValidateAndBuildNrCellIdKey(cell.GetServedNrCellInformation().GetCellId())
270                 if rNibErr != nil {
271                         return pairs, rNibErr
272                 }
273                 pairs = append(pairs, key, cellData)
274                 key, rNibErr = common.ValidateAndBuildCellNamePciKey(nbIdentity.InventoryName, cell.GetServedNrCellInformation().GetNrPci())
275                 if rNibErr != nil {
276                         return pairs, rNibErr
277                 }
278                 pairs = append(pairs, key, cellData)
279         }
280         return pairs, nil
281 }
282
283 func isNotEmpty(nbIdentity *entities.NbIdentity) bool {
284         return nbIdentity.GlobalNbId != nil && nbIdentity.GlobalNbId.PlmnId != "" && nbIdentity.GlobalNbId.NbId != ""
285 }