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