8e8dcca19d8d4b03b60879b3bb1f6ed66b2fa7ce
[ric-plt/nodeb-rnib.git] / reader / rNibReader.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 package reader
21
22 import (
23         "encoding/json"
24         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
25         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
26         "github.com/golang/protobuf/proto"
27         "reflect"
28 )
29
30 const E2TInfoListKey = "E2TInfoList"
31
32 type rNibReaderInstance struct {
33         sdl common.ISdlInstance
34 }
35
36 /*
37 RNibReader interface allows retrieving data from redis BD by various keys
38 */
39 type RNibReader interface {
40         // GetNodeb retrieves responding nodeb entity from redis DB by nodeb inventory name
41         GetNodeb(inventoryName string) (*entities.NodebInfo, error)
42         // GetNodebByGlobalNbId retrieves responding nodeb entity from redis DB by nodeb global Id
43         GetNodebByGlobalNbId(nodeType entities.Node_Type, globalNbId *entities.GlobalNbId) (*entities.NodebInfo, error)
44         // GetCellList retrieves the list of cell entities belonging to responding nodeb entity from redis DB by nodeb inventory name
45         GetCellList(inventoryName string) (*entities.Cells, error)
46         // GetListGnbIds retrieves the list of gNodeb identity entities
47         GetListGnbIds() ([]*entities.NbIdentity, error)
48         // GetListEnbIds retrieves the list of eNodeb identity entities
49         GetListEnbIds() ([]*entities.NbIdentity, error)
50         // Close closes reader's pool
51         GetCountGnbList() (int, error)
52         // GetCell retrieves the cell entity belonging to responding nodeb from redis DB by nodeb inventory name and cell pci
53         GetCell(inventoryName string, pci uint32) (*entities.Cell, error)
54         // GetCellById retrieves the cell entity from redis DB by cell type and cell Id
55         GetCellById(cellType entities.Cell_Type, cellId string) (*entities.Cell, error)
56         // GetListNodebIds returns the full list of Nodeb identity entities
57         GetListNodebIds() ([]*entities.NbIdentity, error)
58         // GetRanLoadInformation retrieves nodeb load information entity from redis DB by nodeb inventory name
59         GetRanLoadInformation(inventoryName string) (*entities.RanLoadInformation, error)
60
61         GetE2TInstance(address string) (*entities.E2TInstance, error)
62
63         GetE2TInfoList() ([]*entities.E2TInstanceInfo, error)
64
65 }
66
67 /*
68 GetRNibReader returns reference to RNibReader
69 */
70 func GetRNibReader(sdl common.ISdlInstance) RNibReader {
71         return &rNibReaderInstance{sdl: sdl}
72 }
73
74 func (w *rNibReaderInstance) GetNodeb(inventoryName string) (*entities.NodebInfo, error) {
75         key, rNibErr := common.ValidateAndBuildNodeBNameKey(inventoryName)
76         if rNibErr != nil {
77                 return nil, rNibErr
78         }
79         nbInfo := &entities.NodebInfo{}
80         err := w.getByKeyAndUnmarshal(key, nbInfo)
81         if err != nil {
82                 return nil, err
83         }
84         return nbInfo, nil
85 }
86
87 func (w *rNibReaderInstance) GetNodebByGlobalNbId(nodeType entities.Node_Type, globalNbId *entities.GlobalNbId) (*entities.NodebInfo, error) {
88         key, rNibErr := common.ValidateAndBuildNodeBIdKey(nodeType.String(), globalNbId.GetPlmnId(), globalNbId.GetNbId())
89         if rNibErr != nil {
90                 return nil, rNibErr
91         }
92         nbInfo := &entities.NodebInfo{}
93         err := w.getByKeyAndUnmarshal(key, nbInfo)
94         if err != nil {
95                 return nil, err
96         }
97         return nbInfo, nil
98 }
99
100 func (w *rNibReaderInstance) GetCellList(inventoryName string) (*entities.Cells, error) {
101         cells := &entities.Cells{}
102         nb, err := w.GetNodeb(inventoryName)
103         if err != nil {
104                 return nil, err
105         }
106         if nb.GetEnb() != nil && len(nb.GetEnb().GetServedCells()) > 0 {
107                 cells.Type = entities.Cell_LTE_CELL
108                 cells.List = &entities.Cells_ServedCellInfos{ServedCellInfos: &entities.ServedCellInfoList{ServedCells: nb.GetEnb().GetServedCells()}}
109                 return cells, nil
110         }
111         if nb.GetGnb() != nil && len(nb.GetGnb().GetServedNrCells()) > 0 {
112                 cells.Type = entities.Cell_NR_CELL
113                 cells.List = &entities.Cells_ServedNrCells{ServedNrCells: &entities.ServedNRCellList{ServedCells: nb.GetGnb().GetServedNrCells()}}
114                 return cells, nil
115         }
116         return nil, common.NewResourceNotFoundErrorf("#rNibReader.GetCellList - served cells not found. Responding node RAN name: %s.", inventoryName)
117 }
118
119 func (w *rNibReaderInstance) GetListGnbIds() ([]*entities.NbIdentity, error) {
120         return w.getListNodebIdsByType(entities.Node_GNB.String())
121 }
122
123 func (w *rNibReaderInstance) GetListEnbIds() ([]*entities.NbIdentity, error) {
124         return w.getListNodebIdsByType(entities.Node_ENB.String())
125 }
126
127 func (w *rNibReaderInstance) GetCountGnbList() (int, error) {
128         size, err := w.sdl.GroupSize(entities.Node_GNB.String())
129         if err != nil {
130                 return 0, common.NewInternalError(err)
131         }
132         return int(size), nil
133 }
134
135 func (w *rNibReaderInstance) GetCell(inventoryName string, pci uint32) (*entities.Cell, error) {
136         key, rNibErr := common.ValidateAndBuildCellNamePciKey(inventoryName, pci)
137         if rNibErr != nil {
138                 return nil, rNibErr
139         }
140         cell := &entities.Cell{}
141         err := w.getByKeyAndUnmarshal(key, cell)
142         if err != nil {
143                 return nil, err
144         }
145         return cell, err
146 }
147
148 func (w *rNibReaderInstance) GetCellById(cellType entities.Cell_Type, cellId string) (*entities.Cell, error) {
149         var key string
150         var rNibErr error
151         if cellType == entities.Cell_LTE_CELL {
152                 key, rNibErr = common.ValidateAndBuildCellIdKey(cellId)
153         } else if cellType == entities.Cell_NR_CELL {
154                 key, rNibErr = common.ValidateAndBuildNrCellIdKey(cellId)
155         } else {
156                 return nil, common.NewValidationErrorf("#rNibReader.GetCellById - invalid cell type: %v", cellType)
157         }
158         if rNibErr != nil {
159                 return nil, rNibErr
160         }
161         cell := &entities.Cell{}
162         err := w.getByKeyAndUnmarshal(key, cell)
163         if err != nil {
164                 return nil, err
165         }
166         return cell, err
167 }
168
169 func (w *rNibReaderInstance) GetListNodebIds() ([]*entities.NbIdentity, error) {
170         dataEnb, err := w.sdl.GetMembers(entities.Node_ENB.String())
171         if err != nil {
172                 return nil, common.NewInternalError(err)
173         }
174         dataGnb, err := w.sdl.GetMembers(entities.Node_GNB.String())
175         if err != nil {
176                 return nil, common.NewInternalError(err)
177         }
178         dataUnknown, err := w.sdl.GetMembers(entities.Node_UNKNOWN.String())
179         if err != nil {
180                 return nil, common.NewInternalError(err)
181         }
182         allIds := append(dataEnb, dataGnb...)
183         allIds = append(allIds, dataUnknown...)
184         data, rnibErr := w.unmarshalIdentityList(allIds)
185         return data, rnibErr
186 }
187
188 func (w *rNibReaderInstance) GetRanLoadInformation(inventoryName string) (*entities.RanLoadInformation, error) {
189         key, rNibErr := common.ValidateAndBuildRanLoadInformationKey(inventoryName)
190         if rNibErr != nil {
191                 return nil, rNibErr
192         }
193         loadInfo := &entities.RanLoadInformation{}
194         err := w.getByKeyAndUnmarshal(key, loadInfo)
195         if err != nil {
196                 return nil, err
197         }
198         return loadInfo, err
199 }
200
201 func (w *rNibReaderInstance) GetE2TInstance(address string) (*entities.E2TInstance, error) {
202         key, rNibErr := common.ValidateAndBuildE2TInstanceKey(address)
203         if rNibErr != nil {
204                 return nil, rNibErr
205         }
206         e2tInstance := &entities.E2TInstance{}
207         err := w.getByKeyAndUnmarshalJson(key, e2tInstance)
208         if err != nil {
209                 return nil, err
210         }
211         return e2tInstance, err
212 }
213
214 func (w *rNibReaderInstance) GetE2TInfoList() ([]*entities.E2TInstanceInfo, error) {
215         e2tInfoList := []*entities.E2TInstanceInfo{}
216         err := w.getByKeyAndUnmarshalJson(E2TInfoListKey, &e2tInfoList)
217         if err != nil {
218                 return nil, err
219         }
220         return e2tInfoList, err
221 }
222
223 func (w *rNibReaderInstance) getByKeyAndUnmarshalJson(key string, entity interface{}) error {
224         data, err := w.sdl.Get([]string{key})
225
226         if err != nil {
227                 return common.NewInternalError(err)
228         }
229
230         if data != nil && data[key] != nil {
231                 err = json.Unmarshal([]byte(data[key].(string)), entity)
232                 if err != nil {
233                         return common.NewInternalError(err)
234                 }
235                 return nil
236         }
237         return common.NewResourceNotFoundErrorf("#rNibReader.getByKeyAndUnmarshalJson - entity of type %s not found. Key: %s", reflect.TypeOf(entity).String(), key)
238 }
239
240 func (w *rNibReaderInstance) getByKeyAndUnmarshal(key string, entity proto.Message) error {
241         data, err := w.sdl.Get([]string{key})
242         if err != nil {
243                 return common.NewInternalError(err)
244         }
245         if data != nil && data[key] != nil {
246                 err = proto.Unmarshal([]byte(data[key].(string)), entity)
247                 if err != nil {
248                         return common.NewInternalError(err)
249                 }
250                 return nil
251         }
252         return common.NewResourceNotFoundErrorf("#rNibReader.getByKeyAndUnmarshal - entity of type %s not found. Key: %s", reflect.TypeOf(entity).String(), key)
253 }
254
255 func (w *rNibReaderInstance) getListNodebIdsByType(nbType string) ([]*entities.NbIdentity, error) {
256         data, err := w.sdl.GetMembers(nbType)
257         if err != nil {
258                 return nil, common.NewInternalError(err)
259         }
260         return w.unmarshalIdentityList(data)
261 }
262
263 func (w *rNibReaderInstance) unmarshalIdentityList(data []string) ([]*entities.NbIdentity, error) {
264         var members []*entities.NbIdentity
265         for _, d := range data {
266                 member := entities.NbIdentity{}
267                 err := proto.Unmarshal([]byte(d), &member)
268                 if err != nil {
269                         return nil, common.NewInternalError(err)
270                 }
271                 members = append(members, &member)
272         }
273         return members, nil
274 }
275
276 //Close the reader
277 func Close() {
278         // Nothing to do
279 }