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