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 E2TAddressesKey = "E2TAddresses"
  31
  32 type rNibReaderInstance struct {
  33         sdl        common.ISdlInstance //Deprecated: Will be removed in a future release and replaced by sdlStorage
  34         sdlStorage common.ISdlSyncStorage
  35         ns         string
  36 }
  37
  38 /*
  39 RNibReader interface allows retrieving data from redis BD by various keys
  40 */
  41 type RNibReader interface {
  42         // GetNodeb retrieves responding nodeb entity from redis DB by nodeb inventory name
  43         GetNodeb(inventoryName string) (*entities.NodebInfo, error)
  44         // GetNodebByGlobalNbId retrieves responding nodeb entity from redis DB by nodeb global Id
  45         GetNodebByGlobalNbId(nodeType entities.Node_Type, globalNbId *entities.GlobalNbId) (*entities.NodebInfo, error)
  46         // GetCellList retrieves the list of cell entities belonging to responding nodeb entity from redis DB by nodeb inventory name
  47         GetCellList(inventoryName string) (*entities.Cells, error)
  48         // GetListGnbIds retrieves the list of gNodeb identity entities
  49         GetListGnbIds() ([]*entities.NbIdentity, error)
  50         // GetListEnbIds retrieves the list of eNodeb identity entities
  51         GetListEnbIds() ([]*entities.NbIdentity, error)
  52         // Close closes reader's pool
  53         GetCountGnbList() (int, error)
  54         // GetCell retrieves the cell entity belonging to responding nodeb from redis DB by nodeb inventory name and cell pci
  55         GetCell(inventoryName string, pci uint32) (*entities.Cell, error)
  56         // GetCellById retrieves the cell entity from redis DB by cell type and cell Id
  57         GetCellById(cellType entities.Cell_Type, cellId string) (*entities.Cell, error)
  58         // GetListNodebIds returns the full list of Nodeb identity entities
  59         GetListNodebIds() ([]*entities.NbIdentity, error)
  60         // GetRanLoadInformation retrieves nodeb load information entity from redis DB by nodeb inventory name
  61         GetRanLoadInformation(inventoryName string) (*entities.RanLoadInformation, error)
  62
  63         GetE2TInstance(address string) (*entities.E2TInstance, error)
  64
  65         GetE2TInstances(addresses []string) ([]*entities.E2TInstance, error)
  66
  67         GetE2TAddresses() ([]string, error)
  68
  69         GetGeneralConfiguration() (*entities.GeneralConfiguration, error)
  70
  71         GetRanFunctionDefinition(inventoryName string, Oid string) ([]string, error)
  72 }
  73
  74 //GetNewRNibReader returns reference to RNibReader
  75 func GetNewRNibReader(storage common.ISdlSyncStorage) RNibReader {
  76         return &rNibReaderInstance{
  77                 sdl: nil,
  78                 sdlStorage: storage,
  79                 ns:         common.GetRNibNamespace(),
  80         }
  81 }
  82
  83 //GetRanFunctionDefinition from the OID
  84 func (w *rNibReaderInstance) GetRanFunctionDefinition(inventoryName string, oid string) ([]string, error){
  85     nb, err := w.GetNodeb (inventoryName)
  86     if (nb.GetGnb() != nil) {
  87         ranFunction := nb.GetGnb().RanFunctions
  88         functionDefinitionList := make([]string, 0)
  89         for _, ranFunction := range ranFunction {
  90             if (oid == ranFunction.RanFunctionOid) {
  91                 functionDefinitionList = append(functionDefinitionList ,ranFunction.RanFunctionDefinition)
  92                 }
  93         }
  94         return functionDefinitionList, err
  95     }
  96     return nil, common.NewResourceNotFoundErrorf("#rNibReader.GetCellList - served cells not found. Responding node RAN name: %    s.", inventoryName)
  97 }
  98
  99 //GetRNibReader returns reference to RNibReader
 100 //Deprecated: Will be removed in a future release, please use GetNewRNibReader instead.
 101 func GetRNibReader(sdl common.ISdlInstance) RNibReader {
 102         return &rNibReaderInstance{
 103                 sdl:        sdl,
 104                 sdlStorage: nil,
 105                 ns:         "",
 106         }
 107 }
 108
 109 func (w *rNibReaderInstance) GetNodeb(inventoryName string) (*entities.NodebInfo, error) {
 110         key, rNibErr := common.ValidateAndBuildNodeBNameKey(inventoryName)
 111         if rNibErr != nil {
 112                 return nil, rNibErr
 113         }
 114         nbInfo := &entities.NodebInfo{}
 115         err := w.getByKeyAndUnmarshal(key, nbInfo)
 116         if err != nil {
 117                 return nil, err
 118         }
 119         return nbInfo, nil
 120 }
 121
 122 func (w *rNibReaderInstance) GetNodebByGlobalNbId(nodeType entities.Node_Type, globalNbId *entities.GlobalNbId) (*entities.NodebInfo, error) {
 123         key, rNibErr := common.ValidateAndBuildNodeBIdKey(nodeType.String(), globalNbId.GetPlmnId(), globalNbId.GetNbId())
 124         if rNibErr != nil {
 125                 return nil, rNibErr
 126         }
 127         nbInfo := &entities.NodebInfo{}
 128         err := w.getByKeyAndUnmarshal(key, nbInfo)
 129         if err != nil {
 130                 return nil, err
 131         }
 132         return nbInfo, nil
 133 }
 134
 135 func (w *rNibReaderInstance) GetCellList(inventoryName string) (*entities.Cells, error) {
 136         cells := &entities.Cells{}
 137         nb, err := w.GetNodeb(inventoryName)
 138         if err != nil {
 139                 return nil, err
 140         }
 141         if nb.GetEnb() != nil && len(nb.GetEnb().GetServedCells()) > 0 {
 142                 cells.Type = entities.Cell_LTE_CELL
 143                 cells.List = &entities.Cells_ServedCellInfos{ServedCellInfos: &entities.ServedCellInfoList{ServedCells: nb.GetEnb().GetServedCells()}}
 144                 return cells, nil
 145         }
 146         if nb.GetGnb() != nil && len(nb.GetGnb().GetServedNrCells()) > 0 {
 147                 cells.Type = entities.Cell_NR_CELL
 148                 cells.List = &entities.Cells_ServedNrCells{ServedNrCells: &entities.ServedNRCellList{ServedCells: nb.GetGnb().GetServedNrCells()}}
 149                 return cells, nil
 150         }
 151         return nil, common.NewResourceNotFoundErrorf("#rNibReader.GetCellList - served cells not found. Responding node RAN name: %s.", inventoryName)
 152 }
 153
 154 func (w *rNibReaderInstance) GetListGnbIds() ([]*entities.NbIdentity, error) {
 155         return w.getListNodebIdsByType(entities.Node_GNB.String())
 156 }
 157
 158 func (w *rNibReaderInstance) GetListEnbIds() ([]*entities.NbIdentity, error) {
 159         return w.getListNodebIdsByType(entities.Node_ENB.String())
 160 }
 161
 162 func (w *rNibReaderInstance) GetCountGnbList() (int, error) {
 163         var size int64
 164         var err error
 165         if w.sdlStorage != nil {
 166                 size, err = w.sdlStorage.GroupSize(w.ns, entities.Node_GNB.String())
 167         } else {
 168                 size, err = w.sdl.GroupSize(entities.Node_GNB.String())
 169         }
 170         if err != nil {
 171                 return 0, common.NewInternalError(err)
 172         }
 173         return int(size), nil
 174 }
 175
 176 func (w *rNibReaderInstance) GetCell(inventoryName string, pci uint32) (*entities.Cell, error) {
 177         key, rNibErr := common.ValidateAndBuildCellNamePciKey(inventoryName, pci)
 178         if rNibErr != nil {
 179                 return nil, rNibErr
 180         }
 181         cell := &entities.Cell{}
 182         err := w.getByKeyAndUnmarshal(key, cell)
 183         if err != nil {
 184                 return nil, err
 185         }
 186         return cell, err
 187 }
 188
 189 func (w *rNibReaderInstance) GetCellById(cellType entities.Cell_Type, cellId string) (*entities.Cell, error) {
 190         var key string
 191         var rNibErr error
 192         if cellType == entities.Cell_LTE_CELL {
 193                 key, rNibErr = common.ValidateAndBuildCellIdKey(cellId)
 194         } else if cellType == entities.Cell_NR_CELL {
 195                 key, rNibErr = common.ValidateAndBuildNrCellIdKey(cellId)
 196         } else {
 197                 return nil, common.NewValidationErrorf("#rNibReader.GetCellById - invalid cell type: %v", cellType)
 198         }
 199         if rNibErr != nil {
 200                 return nil, rNibErr
 201         }
 202         cell := &entities.Cell{}
 203         err := w.getByKeyAndUnmarshal(key, cell)
 204         if err != nil {
 205                 return nil, err
 206         }
 207         return cell, err
 208 }
 209
 210 func (w *rNibReaderInstance) GetListNodebIds() ([]*entities.NbIdentity, error) {
 211         var dataEnb, dataGnb []string
 212         var err error
 213         if w.sdlStorage != nil {
 214                 dataEnb, err = w.sdlStorage.GetMembers(w.ns, entities.Node_ENB.String())
 215         } else {
 216                 dataEnb, err = w.sdl.GetMembers(entities.Node_ENB.String())
 217         }
 218         if err != nil {
 219                 return nil, common.NewInternalError(err)
 220         }
 221         if w.sdlStorage != nil {
 222                 dataGnb, err = w.sdlStorage.GetMembers(w.ns, entities.Node_GNB.String())
 223         } else {
 224                 dataGnb, err = w.sdl.GetMembers(entities.Node_GNB.String())
 225         }
 226         if err != nil {
 227                 return nil, common.NewInternalError(err)
 228         }
 229         allIds := append(dataEnb, dataGnb...)
 230         data, rnibErr := w.unmarshalIdentityList(allIds)
 231         return data, rnibErr
 232 }
 233
 234 func (w *rNibReaderInstance) GetRanLoadInformation(inventoryName string) (*entities.RanLoadInformation, error) {
 235         key, rNibErr := common.ValidateAndBuildRanLoadInformationKey(inventoryName)
 236         if rNibErr != nil {
 237                 return nil, rNibErr
 238         }
 239         loadInfo := &entities.RanLoadInformation{}
 240         err := w.getByKeyAndUnmarshal(key, loadInfo)
 241         if err != nil {
 242                 return nil, err
 243         }
 244         return loadInfo, err
 245 }
 246
 247 func (w *rNibReaderInstance) GetE2TInstance(address string) (*entities.E2TInstance, error) {
 248         key, rNibErr := common.ValidateAndBuildE2TInstanceKey(address)
 249         if rNibErr != nil {
 250                 return nil, rNibErr
 251         }
 252         e2tInstance := &entities.E2TInstance{}
 253         err := w.getByKeyAndUnmarshalJson(key, e2tInstance)
 254         if err != nil {
 255                 return nil, err
 256         }
 257         return e2tInstance, err
 258 }
 259
 260 func (w *rNibReaderInstance) GetE2TInstances(addresses []string) ([]*entities.E2TInstance, error) {
 261         var data map[string]interface{}
 262         var err error
 263
 264         keys := common.MapE2TAddressesToKeys(addresses)
 265
 266         e2tInstances := []*entities.E2TInstance{}
 267
 268         if w.sdlStorage != nil {
 269                 data, err = w.sdlStorage.Get(w.ns, keys)
 270         } else {
 271                 data, err = w.sdl.Get(keys)
 272         }
 273
 274         if err != nil {
 275                 return []*entities.E2TInstance{}, common.NewInternalError(err)
 276         }
 277
 278         if len(data) == 0 {
 279                 return []*entities.E2TInstance{}, common.NewResourceNotFoundErrorf("#rNibReader.GetE2TInstances - e2t instances not found")
 280         }
 281
 282         for _, v := range keys {
 283
 284                 if data[v] != nil {
 285                         var e2tInstance entities.E2TInstance
 286                         err = json.Unmarshal([]byte(data[v].(string)), &e2tInstance)
 287                         if err != nil {
 288                                 continue
 289                         }
 290
 291                         e2tInstances = append(e2tInstances, &e2tInstance)
 292                 }
 293         }
 294
 295         return e2tInstances, nil
 296 }
 297
 298 func (w *rNibReaderInstance) GetE2TAddresses() ([]string, error) {
 299         var e2tAddresses []string
 300         err := w.getByKeyAndUnmarshalJson(E2TAddressesKey, &e2tAddresses)
 301         if err != nil {
 302                 return nil, err
 303         }
 304         return e2tAddresses, err
 305 }
 306
 307 func (w *rNibReaderInstance) GetGeneralConfiguration() (*entities.GeneralConfiguration, error) {
 308         config := &entities.GeneralConfiguration{}
 309         key := common.BuildGeneralConfigurationKey()
 310
 311         err := w.getByKeyAndUnmarshalJson(key, config)
 312
 313         return config, err
 314 }
 315
 316 func (w *rNibReaderInstance) getByKeyAndUnmarshalJson(key string, entity interface{}) error {
 317         var data map[string]interface{}
 318         var err error
 319         if w.sdlStorage != nil {
 320                 data, err = w.sdlStorage.Get(w.ns, []string{key})
 321         } else {
 322                 data, err = w.sdl.Get([]string{key})
 323         }
 324
 325         if err != nil {
 326                 return common.NewInternalError(err)
 327         }
 328
 329         if data != nil && data[key] != nil {
 330                 err = json.Unmarshal([]byte(data[key].(string)), entity)
 331                 if err != nil {
 332                         return common.NewInternalError(err)
 333                 }
 334                 return nil
 335         }
 336         return common.NewResourceNotFoundErrorf("#rNibReader.getByKeyAndUnmarshalJson - entity of type %s not found. Key: %s", reflect.TypeOf(entity).String(), key)
 337 }
 338
 339 func (w *rNibReaderInstance) getByKeyAndUnmarshal(key string, entity proto.Message) error {
 340         var data map[string]interface{}
 341         var err error
 342         if w.sdlStorage != nil {
 343                 data, err = w.sdlStorage.Get(w.ns, []string{key})
 344         } else {
 345                 data, err = w.sdl.Get([]string{key})
 346         }
 347
 348         if err != nil {
 349                 return common.NewInternalError(err)
 350         }
 351         if data != nil && data[key] != nil {
 352                 err = proto.Unmarshal([]byte(data[key].(string)), entity)
 353                 if err != nil {
 354                         return common.NewInternalError(err)
 355                 }
 356                 return nil
 357         }
 358         return common.NewResourceNotFoundErrorf("#rNibReader.getByKeyAndUnmarshal - entity of type %s not found. Key: %s", reflect.TypeOf(entity).String(), key)
 359 }
 360
 361 func (w *rNibReaderInstance) getListNodebIdsByType(nbType string) ([]*entities.NbIdentity, error) {
 362         var data []string
 363         var err error
 364         if w.sdlStorage != nil {
 365                 data, err = w.sdlStorage.GetMembers(w.ns, nbType)
 366         } else {
 367                 data, err = w.sdl.GetMembers(nbType)
 368         }
 369         if err != nil {
 370                 return nil, common.NewInternalError(err)
 371         }
 372         return w.unmarshalIdentityList(data)
 373 }
 374
 375 func (w *rNibReaderInstance) unmarshalIdentityList(data []string) ([]*entities.NbIdentity, error) {
 376         var members []*entities.NbIdentity
 377         for _, d := range data {
 378                 member := entities.NbIdentity{}
 379                 err := proto.Unmarshal([]byte(d), &member)
 380                 if err != nil {
 381                         return nil, common.NewInternalError(err)
 382                 }
 383                 members = append(members, &member)
 384         }
 385         return members, nil
 386 }
 387
 388 //Close the reader
 389 func Close() {
 390         // Nothing to do
 391 }