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 package reader
  18
  19 import (
  20         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  21         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  22         "github.com/golang/protobuf/proto"
  23         "reflect"
  24 )
  25
  26 type rNibReaderInstance struct {
  27         sdl common.ISdlInstance
  28 }
  29
  30 /*
  31 RNibReader interface allows retrieving data from redis BD by various keys
  32 */
  33 type RNibReader interface {
  34         // GetNodeb retrieves responding nodeb entity from redis DB by nodeb inventory name
  35         GetNodeb(inventoryName string) (*entities.NodebInfo, error)
  36         // GetNodebByGlobalNbId retrieves responding nodeb entity from redis DB by nodeb global Id
  37         GetNodebByGlobalNbId(nodeType entities.Node_Type, globalNbId *entities.GlobalNbId) (*entities.NodebInfo, error)
  38         // GetCellList retrieves the list of cell entities belonging to responding nodeb entity from redis DB by nodeb inventory name
  39         GetCellList(inventoryName string) (*entities.Cells, error)
  40         // GetListGnbIds retrieves the list of gNodeb identity entities
  41         GetListGnbIds() ([]*entities.NbIdentity, error)
  42         // GetListEnbIds retrieves the list of eNodeb identity entities
  43         GetListEnbIds() ([]*entities.NbIdentity, error)
  44         // Close closes reader's pool
  45         GetCountGnbList() (int, error)
  46         // GetCell retrieves the cell entity belonging to responding nodeb from redis DB by nodeb inventory name and cell pci
  47         GetCell(inventoryName string, pci uint32) (*entities.Cell, error)
  48         // GetCellById retrieves the cell entity from redis DB by cell type and cell Id
  49         GetCellById(cellType entities.Cell_Type, cellId string) (*entities.Cell, error)
  50         // GetListNodebIds returns the full list of Nodeb identity entities
  51         GetListNodebIds() ([]*entities.NbIdentity, error)
  52         // GetRanLoadInformation retrieves nodeb load information entity from redis DB by nodeb inventory name
  53         GetRanLoadInformation(inventoryName string) (*entities.RanLoadInformation, error)
  54 }
  55
  56 /*
  57 GetRNibReader returns reference to RNibReader
  58 */
  59 func GetRNibReader(sdl common.ISdlInstance) RNibReader {
  60         return &rNibReaderInstance{sdl: sdl}
  61 }
  62
  63 func (w *rNibReaderInstance) GetNodeb(inventoryName string) (*entities.NodebInfo, error) {
  64         key, rNibErr := common.ValidateAndBuildNodeBNameKey(inventoryName)
  65         if rNibErr != nil {
  66                 return nil, rNibErr
  67         }
  68         nbInfo := &entities.NodebInfo{}
  69         err := w.getByKeyAndUnmarshal(key, nbInfo)
  70         if err != nil {
  71                 return nil, err
  72         }
  73         return nbInfo, nil
  74 }
  75
  76 func (w *rNibReaderInstance) GetNodebByGlobalNbId(nodeType entities.Node_Type, globalNbId *entities.GlobalNbId) (*entities.NodebInfo, error) {
  77         key, rNibErr := common.ValidateAndBuildNodeBIdKey(nodeType.String(), globalNbId.GetPlmnId(), globalNbId.GetNbId())
  78         if rNibErr != nil {
  79                 return nil, rNibErr
  80         }
  81         nbInfo := &entities.NodebInfo{}
  82         err := w.getByKeyAndUnmarshal(key, nbInfo)
  83         if err != nil {
  84                 return nil, err
  85         }
  86         return nbInfo, nil
  87 }
  88
  89 func (w *rNibReaderInstance) GetCellList(inventoryName string) (*entities.Cells, error) {
  90         cells := &entities.Cells{}
  91         nb, err := w.GetNodeb(inventoryName)
  92         if err != nil {
  93                 return nil, err
  94         }
  95         if nb.GetEnb() != nil && len(nb.GetEnb().GetServedCells()) > 0 {
  96                 cells.Type = entities.Cell_LTE_CELL
  97                 cells.List = &entities.Cells_ServedCellInfos{ServedCellInfos: &entities.ServedCellInfoList{ServedCells: nb.GetEnb().GetServedCells()}}
  98                 return cells, nil
  99         }
 100         if nb.GetGnb() != nil && len(nb.GetGnb().GetServedNrCells()) > 0 {
 101                 cells.Type = entities.Cell_NR_CELL
 102                 cells.List = &entities.Cells_ServedNrCells{ServedNrCells: &entities.ServedNRCellList{ServedCells: nb.GetGnb().GetServedNrCells()}}
 103                 return cells, nil
 104         }
 105         return nil, common.NewResourceNotFoundErrorf("#rNibReader.GetCellList - served cells not found. Responding node RAN name: %s.", inventoryName)
 106 }
 107
 108 func (w *rNibReaderInstance) GetListGnbIds() ([]*entities.NbIdentity, error) {
 109         return w.getListNodebIdsByType(entities.Node_GNB.String())
 110 }
 111
 112 func (w *rNibReaderInstance) GetListEnbIds() ([]*entities.NbIdentity, error) {
 113         return w.getListNodebIdsByType(entities.Node_ENB.String())
 114 }
 115
 116 func (w *rNibReaderInstance) GetCountGnbList() (int, error) {
 117         size, err := w.sdl.GroupSize(entities.Node_GNB.String())
 118         if err != nil {
 119                 return 0, common.NewInternalError(err)
 120         }
 121         return int(size), nil
 122 }
 123
 124 func (w *rNibReaderInstance) GetCell(inventoryName string, pci uint32) (*entities.Cell, error) {
 125         key, rNibErr := common.ValidateAndBuildCellNamePciKey(inventoryName, pci)
 126         if rNibErr != nil {
 127                 return nil, rNibErr
 128         }
 129         cell := &entities.Cell{}
 130         err := w.getByKeyAndUnmarshal(key, cell)
 131         if err != nil {
 132                 return nil, err
 133         }
 134         return cell, err
 135 }
 136
 137 func (w *rNibReaderInstance) GetCellById(cellType entities.Cell_Type, cellId string) (*entities.Cell, error) {
 138         var key string
 139         var rNibErr error
 140         if cellType == entities.Cell_LTE_CELL {
 141                 key, rNibErr = common.ValidateAndBuildCellIdKey(cellId)
 142         } else if cellType == entities.Cell_NR_CELL {
 143                 key, rNibErr = common.ValidateAndBuildNrCellIdKey(cellId)
 144         } else {
 145                 return nil, common.NewValidationErrorf("#rNibReader.GetCellById - invalid cell type: %v", cellType)
 146         }
 147         if rNibErr != nil {
 148                 return nil, rNibErr
 149         }
 150         cell := &entities.Cell{}
 151         err := w.getByKeyAndUnmarshal(key, cell)
 152         if err != nil {
 153                 return nil, err
 154         }
 155         return cell, err
 156 }
 157
 158 func (w *rNibReaderInstance) GetListNodebIds() ([]*entities.NbIdentity, error) {
 159         dataEnb, err := w.sdl.GetMembers(entities.Node_ENB.String())
 160         if err != nil {
 161                 return nil, common.NewInternalError(err)
 162         }
 163         dataGnb, err := w.sdl.GetMembers(entities.Node_GNB.String())
 164         if err != nil {
 165                 return nil, common.NewInternalError(err)
 166         }
 167         dataUnknown, err := w.sdl.GetMembers(entities.Node_UNKNOWN.String())
 168         if err != nil {
 169                 return nil, common.NewInternalError(err)
 170         }
 171         allIds := append(dataEnb, dataGnb...)
 172         allIds = append(allIds, dataUnknown...)
 173         data, rnibErr := w.unmarshalIdentityList(allIds)
 174         return data, rnibErr
 175 }
 176
 177 func (w *rNibReaderInstance) GetRanLoadInformation(inventoryName string) (*entities.RanLoadInformation, error) {
 178         key, rNibErr := common.ValidateAndBuildRanLoadInformationKey(inventoryName)
 179         if rNibErr != nil {
 180                 return nil, rNibErr
 181         }
 182         loadInfo := &entities.RanLoadInformation{}
 183         err := w.getByKeyAndUnmarshal(key, loadInfo)
 184         if err != nil {
 185                 return nil, err
 186         }
 187         return loadInfo, err
 188 }
 189
 190 func (w *rNibReaderInstance) getByKeyAndUnmarshal(key string, entity proto.Message) error {
 191         data, err := w.sdl.Get([]string{key})
 192         if err != nil {
 193                 return common.NewInternalError(err)
 194         }
 195         if data != nil && data[key] != nil {
 196                 err = proto.Unmarshal([]byte(data[key].(string)), entity)
 197                 if err != nil {
 198                         return common.NewInternalError(err)
 199                 }
 200                 return nil
 201         }
 202         return common.NewResourceNotFoundErrorf("#rNibReader.getByKeyAndUnmarshal - entity of type %s not found. Key: %s", reflect.TypeOf(entity).String(), key)
 203 }
 204
 205 func (w *rNibReaderInstance) getListNodebIdsByType(nbType string) ([]*entities.NbIdentity, error) {
 206         data, err := w.sdl.GetMembers(nbType)
 207         if err != nil {
 208                 return nil, common.NewInternalError(err)
 209         }
 210         return w.unmarshalIdentityList(data)
 211 }
 212
 213 func (w *rNibReaderInstance) unmarshalIdentityList(data []string) ([]*entities.NbIdentity, error) {
 214         var members []*entities.NbIdentity
 215         for _, d := range data {
 216                 member := entities.NbIdentity{}
 217                 err := proto.Unmarshal([]byte(d), &member)
 218                 if err != nil {
 219                         return nil, common.NewInternalError(err)
 220                 }
 221                 members = append(members, &member)
 222         }
 223         return members, nil
 224 }
 225
 226 //Close the reader
 227 func Close() {
 228         // Nothing to do
 229 }