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