Move to Ubuntu 18 image
[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 //  This source code is part of the near-RT RIC (RAN Intelligent Controller)
18 //  platform project (RICP).
19
20
21 package rNibWriter
22
23 import (
24         "encoding/json"
25         "fmt"
26         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
27         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
28         "github.com/golang/protobuf/proto"
29 )
30
31 const E2TAddressesKey = "E2TAddresses"
32
33 type rNibWriterInstance struct {
34         sdl common.ISdlInstance
35 }
36
37 /*
38 RNibWriter interface allows saving data to the redis DB
39 */
40 type RNibWriter interface {
41         SaveNodeb(nbIdentity *entities.NbIdentity, nb *entities.NodebInfo) error
42         UpdateNodebInfo(nodebInfo *entities.NodebInfo) error
43         SaveRanLoadInformation(inventoryName string, ranLoadInformation *entities.RanLoadInformation) error
44         SaveE2TInstance(e2tInstance *entities.E2TInstance) error
45         SaveE2TAddresses(addresses []string) error
46         RemoveE2TInstance(e2tAddress string) error
47 }
48
49 /*
50 GetRNibWriter returns reference to RNibWriter
51 */
52
53 func GetRNibWriter(sdl common.ISdlInstance) RNibWriter {
54         return &rNibWriterInstance{sdl: sdl}
55 }
56
57 /*
58 SaveNodeb saves nodeB entity data in the redis DB according to the specified data model
59 */
60 func (w *rNibWriterInstance) SaveNodeb(nbIdentity *entities.NbIdentity, entity *entities.NodebInfo) error {
61         isNotEmptyIdentity := isNotEmpty(nbIdentity)
62
63         if isNotEmptyIdentity && entity.GetNodeType() == entities.Node_UNKNOWN {
64                 return common.NewValidationError(fmt.Sprintf("#rNibWriter.saveNodeB - Unknown responding node type, entity: %v", entity))
65         }
66         data, err := proto.Marshal(entity)
67         if err != nil {
68                 return common.NewInternalError(err)
69         }
70         var pairs []interface{}
71         key, rNibErr := common.ValidateAndBuildNodeBNameKey(nbIdentity.InventoryName)
72         if rNibErr != nil {
73                 return rNibErr
74         }
75         pairs = append(pairs, key, data)
76
77         if isNotEmptyIdentity {
78                 key, rNibErr = common.ValidateAndBuildNodeBIdKey(entity.GetNodeType().String(), nbIdentity.GlobalNbId.GetPlmnId(), nbIdentity.GlobalNbId.GetNbId())
79                 if rNibErr != nil {
80                         return rNibErr
81                 }
82                 pairs = append(pairs, key, data)
83         }
84
85         if entity.GetEnb() != nil {
86                 pairs, rNibErr = appendEnbCells(nbIdentity, entity.GetEnb().GetServedCells(), pairs)
87                 if rNibErr != nil {
88                         return rNibErr
89                 }
90         }
91         if entity.GetGnb() != nil {
92                 pairs, rNibErr = appendGnbCells(nbIdentity, entity.GetGnb().GetServedNrCells(), pairs)
93                 if rNibErr != nil {
94                         return rNibErr
95                 }
96         }
97         err = w.sdl.Set(pairs)
98         if err != nil {
99                 return common.NewInternalError(err)
100         }
101
102         ranNameIdentity := &entities.NbIdentity{InventoryName: nbIdentity.InventoryName}
103
104         if isNotEmptyIdentity {
105                 nbIdData, err := proto.Marshal(ranNameIdentity)
106                 if err != nil {
107                         return common.NewInternalError(err)
108                 }
109                 err = w.sdl.RemoveMember(entities.Node_UNKNOWN.String(), nbIdData)
110                 if err != nil {
111                         return common.NewInternalError(err)
112                 }
113         } else {
114                 nbIdentity = ranNameIdentity
115         }
116
117         nbIdData, err := proto.Marshal(nbIdentity)
118         if err != nil {
119                 return common.NewInternalError(err)
120         }
121         err = w.sdl.AddMember(entity.GetNodeType().String(), nbIdData)
122         if err != nil {
123                 return common.NewInternalError(err)
124         }
125         return nil
126 }
127
128 /*
129 UpdateNodebInfo...
130 */
131 func (w *rNibWriterInstance) UpdateNodebInfo(nodebInfo *entities.NodebInfo) error {
132
133         nodebNameKey, rNibErr := common.ValidateAndBuildNodeBNameKey(nodebInfo.GetRanName())
134
135         if rNibErr != nil {
136                 return rNibErr
137         }
138
139         nodebIdKey, buildNodebIdKeyError := common.ValidateAndBuildNodeBIdKey(nodebInfo.GetNodeType().String(), nodebInfo.GlobalNbId.GetPlmnId(), nodebInfo.GlobalNbId.GetNbId())
140
141         data, err := proto.Marshal(nodebInfo)
142
143         if err != nil {
144                 return common.NewInternalError(err)
145         }
146
147         var pairs []interface{}
148         pairs = append(pairs, nodebNameKey, data)
149
150         if buildNodebIdKeyError == nil {
151                 pairs = append(pairs, nodebIdKey, data)
152         }
153
154         err = w.sdl.Set(pairs)
155
156         if err != nil {
157                 return common.NewInternalError(err)
158         }
159
160         return nil
161 }
162
163 /*
164 SaveRanLoadInformation stores ran load information for the provided ran
165 */
166 func (w *rNibWriterInstance) SaveRanLoadInformation(inventoryName string, ranLoadInformation *entities.RanLoadInformation) error {
167
168         key, rnibErr := common.ValidateAndBuildRanLoadInformationKey(inventoryName)
169
170         if rnibErr != nil {
171                 return rnibErr
172         }
173
174         data, err := proto.Marshal(ranLoadInformation)
175
176         if err != nil {
177                 return common.NewInternalError(err)
178         }
179
180         var pairs []interface{}
181         pairs = append(pairs, key, data)
182
183         err = w.sdl.Set(pairs)
184
185         if err != nil {
186                 return common.NewInternalError(err)
187         }
188
189         return nil
190 }
191
192 func (w *rNibWriterInstance) SaveE2TInstance(e2tInstance *entities.E2TInstance) error {
193
194         key, rnibErr := common.ValidateAndBuildE2TInstanceKey(e2tInstance.Address)
195
196         if rnibErr != nil {
197                 return rnibErr
198         }
199
200         data, err := json.Marshal(e2tInstance)
201
202         if err != nil {
203                 return common.NewInternalError(err)
204         }
205
206         var pairs []interface{}
207         pairs = append(pairs, key, data)
208
209         err = w.sdl.Set(pairs)
210
211         if err != nil {
212                 return common.NewInternalError(err)
213         }
214
215         return nil
216 }
217
218 func (w *rNibWriterInstance) SaveE2TAddresses(addresses []string) error {
219
220         data, err := json.Marshal(addresses)
221
222         if err != nil {
223                 return common.NewInternalError(err)
224         }
225
226         var pairs []interface{}
227         pairs = append(pairs, E2TAddressesKey, data)
228
229         err = w.sdl.Set(pairs)
230
231         if err != nil {
232                 return common.NewInternalError(err)
233         }
234
235         return nil
236 }
237
238
239 func (w *rNibWriterInstance) RemoveE2TInstance(address string) error {
240         key, rNibErr := common.ValidateAndBuildE2TInstanceKey(address)
241         if rNibErr != nil {
242                 return rNibErr
243         }
244         err := w.sdl.Remove([]string{key})
245
246         if err != nil {
247                 return common.NewInternalError(err)
248         }
249         return nil
250 }
251
252 /*
253 Close the writer
254 */
255 func Close() {
256         //Nothing to do
257 }
258
259 func appendEnbCells(nbIdentity *entities.NbIdentity, cells []*entities.ServedCellInfo, pairs []interface{}) ([]interface{}, error) {
260         for _, cell := range cells {
261                 cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: cell}}
262                 cellData, err := proto.Marshal(&cellEntity)
263                 if err != nil {
264                         return pairs, common.NewInternalError(err)
265                 }
266                 key, rNibErr := common.ValidateAndBuildCellIdKey(cell.GetCellId())
267                 if rNibErr != nil {
268                         return pairs, rNibErr
269                 }
270                 pairs = append(pairs, key, cellData)
271                 key, rNibErr = common.ValidateAndBuildCellNamePciKey(nbIdentity.InventoryName, cell.GetPci())
272                 if rNibErr != nil {
273                         return pairs, rNibErr
274                 }
275                 pairs = append(pairs, key, cellData)
276         }
277         return pairs, nil
278 }
279
280 func appendGnbCells(nbIdentity *entities.NbIdentity, cells []*entities.ServedNRCell, pairs []interface{}) ([]interface{}, error) {
281         for _, cell := range cells {
282                 cellEntity := entities.Cell{Type: entities.Cell_NR_CELL, Cell: &entities.Cell_ServedNrCell{ServedNrCell: cell}}
283                 cellData, err := proto.Marshal(&cellEntity)
284                 if err != nil {
285                         return pairs, common.NewInternalError(err)
286                 }
287                 key, rNibErr := common.ValidateAndBuildNrCellIdKey(cell.GetServedNrCellInformation().GetCellId())
288                 if rNibErr != nil {
289                         return pairs, rNibErr
290                 }
291                 pairs = append(pairs, key, cellData)
292                 key, rNibErr = common.ValidateAndBuildCellNamePciKey(nbIdentity.InventoryName, cell.GetServedNrCellInformation().GetNrPci())
293                 if rNibErr != nil {
294                         return pairs, rNibErr
295                 }
296                 pairs = append(pairs, key, cellData)
297         }
298         return pairs, nil
299 }
300
301 func isNotEmpty(nbIdentity *entities.NbIdentity) bool {
302         return nbIdentity.GlobalNbId != nil && nbIdentity.GlobalNbId.PlmnId != "" && nbIdentity.GlobalNbId.NbId != ""
303 }