2 // Copyright 2019 AT&T Intellectual Property
3 // Copyright 2019 Nokia
4 // Copyright 2023 Capgemini
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
10 // http://www.apache.org/licenses/LICENSE-2.0
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.
18 // This source code is part of the near-RT RIC (RAN Intelligent Controller)
19 // platform project (RICP).
25 "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
26 "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
27 "github.com/golang/protobuf/proto"
31 const E2TAddressesKey = "E2TAddresses"
33 type rNibReaderInstance struct {
34 sdl common.ISdlInstance //Deprecated: Will be removed in a future release and replaced by sdlStorage
35 sdlStorage common.ISdlSyncStorage
40 RNibReader interface allows retrieving data from redis BD by various keys
42 type RNibReader interface {
43 // GetNodeb retrieves responding nodeb entity from redis DB by nodeb inventory name
44 GetNodeb(inventoryName string) (*entities.NodebInfo, error)
45 // GetNodebByGlobalNbId retrieves responding nodeb entity from redis DB by nodeb global Id
46 GetNodebByGlobalNbId(nodeType entities.Node_Type, globalNbId *entities.GlobalNbId, cuupId string,duid string) (*entities.NodebInfo, error)
47 // GetCellList retrieves the list of cell entities belonging to responding nodeb entity from redis DB by nodeb inventory name
48 GetCellList(inventoryName string) (*entities.Cells, error)
49 // GetListGnbIds retrieves the list of gNodeb identity entities
50 GetListGnbIds() ([]*entities.NbIdentity, error)
51 // GetListEnbIds retrieves the list of eNodeb identity entities
52 GetListEnbIds() ([]*entities.NbIdentity, error)
53 // Close closes reader's pool
54 GetCountGnbList() (int, error)
55 // GetCell retrieves the cell entity belonging to responding nodeb from redis DB by nodeb inventory name and cell pci
56 GetCell(inventoryName string, pci uint32) (*entities.Cell, error)
57 // GetCellById retrieves the cell entity from redis DB by cell type and cell Id
58 GetCellById(cellType entities.Cell_Type, cellId string) (*entities.Cell, error)
59 // GetListNodebIds returns the full list of Nodeb identity entities
60 GetListNodebIds() ([]*entities.NbIdentity, error)
61 // GetRanLoadInformation retrieves nodeb load information entity from redis DB by nodeb inventory name
62 GetRanLoadInformation(inventoryName string) (*entities.RanLoadInformation, error)
64 GetE2TInstance(address string) (*entities.E2TInstance, error)
66 GetE2TInstances(addresses []string) ([]*entities.E2TInstance, error)
68 GetE2TAddresses() ([]string, error)
70 GetGeneralConfiguration() (*entities.GeneralConfiguration, error)
72 GetRanFunctionDefinition(inventoryName string, Oid string) ([]string, error)
75 //GetNewRNibReader returns reference to RNibReader
76 func GetNewRNibReader(storage common.ISdlSyncStorage) RNibReader {
77 return &rNibReaderInstance{
80 ns: common.GetRNibNamespace(),
84 //GetRanFunctionDefinition from the OID
85 func (w *rNibReaderInstance) GetRanFunctionDefinition(inventoryName string, oid string) ([]string, error){
86 nb, err := w.GetNodeb (inventoryName)
87 if (nb.GetGnb() != nil) {
88 ranFunction := nb.GetGnb().RanFunctions
89 functionDefinitionList := make([]string, 0)
90 for _, ranFunction := range ranFunction {
91 if (oid == ranFunction.RanFunctionOid) {
92 functionDefinitionList = append(functionDefinitionList ,ranFunction.RanFunctionDefinition)
95 return functionDefinitionList, err
97 return nil, common.NewResourceNotFoundErrorf("#rNibReader.GetCellList - served cells not found. Responding node RAN name: % s.", inventoryName)
100 //GetRNibReader returns reference to RNibReader
101 //Deprecated: Will be removed in a future release, please use GetNewRNibReader instead.
102 func GetRNibReader(sdl common.ISdlInstance) RNibReader {
103 return &rNibReaderInstance{
110 func (w *rNibReaderInstance) GetNodeb(inventoryName string) (*entities.NodebInfo, error) {
111 key, rNibErr := common.ValidateAndBuildNodeBNameKey(inventoryName)
115 nbInfo := &entities.NodebInfo{}
116 err := w.getByKeyAndUnmarshal(key, nbInfo)
123 func (w *rNibReaderInstance) GetNodebByGlobalNbId(nodeType entities.Node_Type, globalNbId *entities.GlobalNbId, cuupid string, duid string) (*entities.NodebInfo, error) {
124 key, rNibErr := common.ValidateAndBuildNodeBIdKey(nodeType.String(), globalNbId.GetPlmnId(), globalNbId.GetNbId(), cuupid, duid)
128 nbInfo := &entities.NodebInfo{}
129 err := w.getByKeyAndUnmarshal(key, nbInfo)
136 func (w *rNibReaderInstance) GetCellList(inventoryName string) (*entities.Cells, error) {
137 cells := &entities.Cells{}
138 nb, err := w.GetNodeb(inventoryName)
142 if nb.GetEnb() != nil && len(nb.GetEnb().GetServedCells()) > 0 {
143 cells.Type = entities.Cell_LTE_CELL
144 cells.List = &entities.Cells_ServedCellInfos{ServedCellInfos: &entities.ServedCellInfoList{ServedCells: nb.GetEnb().GetServedCells()}}
147 if nb.GetGnb() != nil && len(nb.GetGnb().GetServedNrCells()) > 0 {
148 cells.Type = entities.Cell_NR_CELL
149 cells.List = &entities.Cells_ServedNrCells{ServedNrCells: &entities.ServedNRCellList{ServedCells: nb.GetGnb().GetServedNrCells()}}
152 return nil, common.NewResourceNotFoundErrorf("#rNibReader.GetCellList - served cells not found. Responding node RAN name: %s.", inventoryName)
155 func (w *rNibReaderInstance) GetListGnbIds() ([]*entities.NbIdentity, error) {
156 return w.getListNodebIdsByType(entities.Node_GNB.String())
159 func (w *rNibReaderInstance) GetListEnbIds() ([]*entities.NbIdentity, error) {
160 return w.getListNodebIdsByType(entities.Node_ENB.String())
163 func (w *rNibReaderInstance) GetCountGnbList() (int, error) {
166 if w.sdlStorage != nil {
167 size, err = w.sdlStorage.GroupSize(w.ns, entities.Node_GNB.String())
169 size, err = w.sdl.GroupSize(entities.Node_GNB.String())
172 return 0, common.NewInternalError(err)
174 return int(size), nil
177 func (w *rNibReaderInstance) GetCell(inventoryName string, pci uint32) (*entities.Cell, error) {
178 key, rNibErr := common.ValidateAndBuildCellNamePciKey(inventoryName, pci)
182 cell := &entities.Cell{}
183 err := w.getByKeyAndUnmarshal(key, cell)
190 func (w *rNibReaderInstance) GetCellById(cellType entities.Cell_Type, cellId string) (*entities.Cell, error) {
193 if cellType == entities.Cell_LTE_CELL {
194 key, rNibErr = common.ValidateAndBuildCellIdKey(cellId)
195 } else if cellType == entities.Cell_NR_CELL {
196 key, rNibErr = common.ValidateAndBuildNrCellIdKey(cellId)
198 return nil, common.NewValidationErrorf("#rNibReader.GetCellById - invalid cell type: %v", cellType)
203 cell := &entities.Cell{}
204 err := w.getByKeyAndUnmarshal(key, cell)
211 func (w *rNibReaderInstance) GetListNodebIds() ([]*entities.NbIdentity, error) {
212 var dataEnb, dataGnb []string
214 if w.sdlStorage != nil {
215 dataEnb, err = w.sdlStorage.GetMembers(w.ns, entities.Node_ENB.String())
217 dataEnb, err = w.sdl.GetMembers(entities.Node_ENB.String())
220 return nil, common.NewInternalError(err)
222 if w.sdlStorage != nil {
223 dataGnb, err = w.sdlStorage.GetMembers(w.ns, entities.Node_GNB.String())
225 dataGnb, err = w.sdl.GetMembers(entities.Node_GNB.String())
228 return nil, common.NewInternalError(err)
230 allIds := append(dataEnb, dataGnb...)
231 data, rnibErr := w.unmarshalIdentityList(allIds)
235 func (w *rNibReaderInstance) GetRanLoadInformation(inventoryName string) (*entities.RanLoadInformation, error) {
236 key, rNibErr := common.ValidateAndBuildRanLoadInformationKey(inventoryName)
240 loadInfo := &entities.RanLoadInformation{}
241 err := w.getByKeyAndUnmarshal(key, loadInfo)
248 func (w *rNibReaderInstance) GetE2TInstance(address string) (*entities.E2TInstance, error) {
249 key, rNibErr := common.ValidateAndBuildE2TInstanceKey(address)
253 e2tInstance := &entities.E2TInstance{}
254 err := w.getByKeyAndUnmarshalJson(key, e2tInstance)
258 return e2tInstance, err
261 func (w *rNibReaderInstance) GetE2TInstances(addresses []string) ([]*entities.E2TInstance, error) {
262 var data map[string]interface{}
265 keys := common.MapE2TAddressesToKeys(addresses)
267 e2tInstances := []*entities.E2TInstance{}
269 if w.sdlStorage != nil {
270 data, err = w.sdlStorage.Get(w.ns, keys)
272 data, err = w.sdl.Get(keys)
276 return []*entities.E2TInstance{}, common.NewInternalError(err)
280 return []*entities.E2TInstance{}, common.NewResourceNotFoundErrorf("#rNibReader.GetE2TInstances - e2t instances not found")
283 for _, v := range keys {
286 var e2tInstance entities.E2TInstance
287 err = json.Unmarshal([]byte(data[v].(string)), &e2tInstance)
292 e2tInstances = append(e2tInstances, &e2tInstance)
296 return e2tInstances, nil
299 func (w *rNibReaderInstance) GetE2TAddresses() ([]string, error) {
300 var e2tAddresses []string
301 err := w.getByKeyAndUnmarshalJson(E2TAddressesKey, &e2tAddresses)
305 return e2tAddresses, err
308 func (w *rNibReaderInstance) GetGeneralConfiguration() (*entities.GeneralConfiguration, error) {
309 config := &entities.GeneralConfiguration{}
310 key := common.BuildGeneralConfigurationKey()
312 err := w.getByKeyAndUnmarshalJson(key, config)
317 func (w *rNibReaderInstance) getByKeyAndUnmarshalJson(key string, entity interface{}) error {
318 var data map[string]interface{}
320 if w.sdlStorage != nil {
321 data, err = w.sdlStorage.Get(w.ns, []string{key})
323 data, err = w.sdl.Get([]string{key})
327 return common.NewInternalError(err)
330 if data != nil && data[key] != nil {
331 err = json.Unmarshal([]byte(data[key].(string)), entity)
333 return common.NewInternalError(err)
337 return common.NewResourceNotFoundErrorf("#rNibReader.getByKeyAndUnmarshalJson - entity of type %s not found. Key: %s", reflect.TypeOf(entity).String(), key)
340 func (w *rNibReaderInstance) getByKeyAndUnmarshal(key string, entity proto.Message) error {
341 var data map[string]interface{}
343 if w.sdlStorage != nil {
344 data, err = w.sdlStorage.Get(w.ns, []string{key})
346 data, err = w.sdl.Get([]string{key})
350 return common.NewInternalError(err)
352 if data != nil && data[key] != nil {
353 err = proto.Unmarshal([]byte(data[key].(string)), entity)
355 return common.NewInternalError(err)
359 return common.NewResourceNotFoundErrorf("#rNibReader.getByKeyAndUnmarshal - entity of type %s not found. Key: %s", reflect.TypeOf(entity).String(), key)
362 func (w *rNibReaderInstance) getListNodebIdsByType(nbType string) ([]*entities.NbIdentity, error) {
365 if w.sdlStorage != nil {
366 data, err = w.sdlStorage.GetMembers(w.ns, nbType)
368 data, err = w.sdl.GetMembers(nbType)
371 return nil, common.NewInternalError(err)
373 return w.unmarshalIdentityList(data)
376 func (w *rNibReaderInstance) unmarshalIdentityList(data []string) ([]*entities.NbIdentity, error) {
377 var members []*entities.NbIdentity
378 for _, d := range data {
379 member := entities.NbIdentity{}
380 err := proto.Unmarshal([]byte(d), &member)
382 return nil, common.NewInternalError(err)
384 members = append(members, &member)