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