E2Manager/rNibWriter/rNibWriter.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
  21 package rNibWriter
  22
  23 import (
  24         "encoding/json"
  25         "fmt"
  26         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  27         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  28         "github.com/golang/protobuf/proto"
  29 )
  30
  31 const E2TAddressesKey = "E2TAddresses"
  32
  33 type rNibWriterInstance struct {
  34         sdl common.ISdlInstance
  35 }
  36
  37 /*
  38 RNibWriter interface allows saving data to the redis DB
  39 */
  40 type RNibWriter interface {
  41         SaveNodeb(nbIdentity *entities.NbIdentity, nb *entities.NodebInfo) error
  42         UpdateNodebInfo(nodebInfo *entities.NodebInfo) error
  43         SaveRanLoadInformation(inventoryName string, ranLoadInformation *entities.RanLoadInformation) error
  44         SaveE2TInstance(e2tInstance *entities.E2TInstance) error
  45         SaveE2TAddresses(addresses []string) error
  46 }
  47
  48 /*
  49 GetRNibWriter returns reference to RNibWriter
  50 */
  51
  52 func GetRNibWriter(sdl common.ISdlInstance) RNibWriter {
  53         return &rNibWriterInstance{sdl: sdl}
  54 }
  55
  56 /*
  57 SaveNodeb saves nodeB entity data in the redis DB according to the specified data model
  58 */
  59 func (w *rNibWriterInstance) SaveNodeb(nbIdentity *entities.NbIdentity, entity *entities.NodebInfo) error {
  60         isNotEmptyIdentity := isNotEmpty(nbIdentity)
  61
  62         if isNotEmptyIdentity && entity.GetNodeType() == entities.Node_UNKNOWN {
  63                 return common.NewValidationError(fmt.Sprintf("#rNibWriter.saveNodeB - Unknown responding node type, entity: %v", entity))
  64         }
  65         data, err := proto.Marshal(entity)
  66         if err != nil {
  67                 return common.NewInternalError(err)
  68         }
  69         var pairs []interface{}
  70         key, rNibErr := common.ValidateAndBuildNodeBNameKey(nbIdentity.InventoryName)
  71         if rNibErr != nil {
  72                 return rNibErr
  73         }
  74         pairs = append(pairs, key, data)
  75
  76         if isNotEmptyIdentity {
  77                 key, rNibErr = common.ValidateAndBuildNodeBIdKey(entity.GetNodeType().String(), nbIdentity.GlobalNbId.GetPlmnId(), nbIdentity.GlobalNbId.GetNbId())
  78                 if rNibErr != nil {
  79                         return rNibErr
  80                 }
  81                 pairs = append(pairs, key, data)
  82         }
  83
  84         if entity.GetEnb() != nil {
  85                 pairs, rNibErr = appendEnbCells(nbIdentity, entity.GetEnb().GetServedCells(), pairs)
  86                 if rNibErr != nil {
  87                         return rNibErr
  88                 }
  89         }
  90         if entity.GetGnb() != nil {
  91                 pairs, rNibErr = appendGnbCells(nbIdentity, entity.GetGnb().GetServedNrCells(), pairs)
  92                 if rNibErr != nil {
  93                         return rNibErr
  94                 }
  95         }
  96         err = w.sdl.Set(pairs)
  97         if err != nil {
  98                 return common.NewInternalError(err)
  99         }
 100
 101         ranNameIdentity := &entities.NbIdentity{InventoryName: nbIdentity.InventoryName}
 102
 103         if isNotEmptyIdentity {
 104                 nbIdData, err := proto.Marshal(ranNameIdentity)
 105                 if err != nil {
 106                         return common.NewInternalError(err)
 107                 }
 108                 err = w.sdl.RemoveMember(entities.Node_UNKNOWN.String(), nbIdData)
 109                 if err != nil {
 110                         return common.NewInternalError(err)
 111                 }
 112         } else {
 113                 nbIdentity = ranNameIdentity
 114         }
 115
 116         nbIdData, err := proto.Marshal(nbIdentity)
 117         if err != nil {
 118                 return common.NewInternalError(err)
 119         }
 120         err = w.sdl.AddMember(entity.GetNodeType().String(), nbIdData)
 121         if err != nil {
 122                 return common.NewInternalError(err)
 123         }
 124         return nil
 125 }
 126
 127 /*
 128 UpdateNodebInfo...
 129 */
 130 func (w *rNibWriterInstance) UpdateNodebInfo(nodebInfo *entities.NodebInfo) error {
 131
 132         nodebNameKey, rNibErr := common.ValidateAndBuildNodeBNameKey(nodebInfo.GetRanName())
 133
 134         if rNibErr != nil {
 135                 return rNibErr
 136         }
 137
 138         nodebIdKey, buildNodebIdKeyError := common.ValidateAndBuildNodeBIdKey(nodebInfo.GetNodeType().String(), nodebInfo.GlobalNbId.GetPlmnId(), nodebInfo.GlobalNbId.GetNbId())
 139
 140         data, err := proto.Marshal(nodebInfo)
 141
 142         if err != nil {
 143                 return common.NewInternalError(err)
 144         }
 145
 146         var pairs []interface{}
 147         pairs = append(pairs, nodebNameKey, data)
 148
 149         if buildNodebIdKeyError == nil {
 150                 pairs = append(pairs, nodebIdKey, data)
 151         }
 152
 153         err = w.sdl.Set(pairs)
 154
 155         if err != nil {
 156                 return common.NewInternalError(err)
 157         }
 158
 159         return nil
 160 }
 161
 162 /*
 163 SaveRanLoadInformation stores ran load information for the provided ran
 164 */
 165 func (w *rNibWriterInstance) SaveRanLoadInformation(inventoryName string, ranLoadInformation *entities.RanLoadInformation) error {
 166
 167         key, rnibErr := common.ValidateAndBuildRanLoadInformationKey(inventoryName)
 168
 169         if rnibErr != nil {
 170                 return rnibErr
 171         }
 172
 173         data, err := proto.Marshal(ranLoadInformation)
 174
 175         if err != nil {
 176                 return common.NewInternalError(err)
 177         }
 178
 179         var pairs []interface{}
 180         pairs = append(pairs, key, data)
 181
 182         err = w.sdl.Set(pairs)
 183
 184         if err != nil {
 185                 return common.NewInternalError(err)
 186         }
 187
 188         return nil
 189 }
 190
 191 func (w *rNibWriterInstance) SaveE2TInstance(e2tInstance *entities.E2TInstance) error {
 192
 193         key, rnibErr := common.ValidateAndBuildE2TInstanceKey(e2tInstance.Address)
 194
 195         if rnibErr != nil {
 196                 return rnibErr
 197         }
 198
 199         data, err := json.Marshal(e2tInstance)
 200
 201         if err != nil {
 202                 return common.NewInternalError(err)
 203         }
 204
 205         var pairs []interface{}
 206         pairs = append(pairs, key, data)
 207
 208         err = w.sdl.Set(pairs)
 209
 210         if err != nil {
 211                 return common.NewInternalError(err)
 212         }
 213
 214         return nil
 215 }
 216
 217 func (w *rNibWriterInstance) SaveE2TAddresses(addresses []string) error {
 218
 219         data, err := json.Marshal(addresses)
 220
 221         if err != nil {
 222                 return common.NewInternalError(err)
 223         }
 224
 225         var pairs []interface{}
 226         pairs = append(pairs, E2TAddressesKey, data)
 227
 228         err = w.sdl.Set(pairs)
 229
 230         if err != nil {
 231                 return common.NewInternalError(err)
 232         }
 233
 234         return nil
 235 }
 236
 237 /*
 238 Close the writer
 239 */
 240 func Close() {
 241         //Nothing to do
 242 }
 243
 244 func appendEnbCells(nbIdentity *entities.NbIdentity, cells []*entities.ServedCellInfo, pairs []interface{}) ([]interface{}, error) {
 245         for _, cell := range cells {
 246                 cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: cell}}
 247                 cellData, err := proto.Marshal(&cellEntity)
 248                 if err != nil {
 249                         return pairs, common.NewInternalError(err)
 250                 }
 251                 key, rNibErr := common.ValidateAndBuildCellIdKey(cell.GetCellId())
 252                 if rNibErr != nil {
 253                         return pairs, rNibErr
 254                 }
 255                 pairs = append(pairs, key, cellData)
 256                 key, rNibErr = common.ValidateAndBuildCellNamePciKey(nbIdentity.InventoryName, cell.GetPci())
 257                 if rNibErr != nil {
 258                         return pairs, rNibErr
 259                 }
 260                 pairs = append(pairs, key, cellData)
 261         }
 262         return pairs, nil
 263 }
 264
 265 func appendGnbCells(nbIdentity *entities.NbIdentity, cells []*entities.ServedNRCell, pairs []interface{}) ([]interface{}, error) {
 266         for _, cell := range cells {
 267                 cellEntity := entities.Cell{Type: entities.Cell_NR_CELL, Cell: &entities.Cell_ServedNrCell{ServedNrCell: cell}}
 268                 cellData, err := proto.Marshal(&cellEntity)
 269                 if err != nil {
 270                         return pairs, common.NewInternalError(err)
 271                 }
 272                 key, rNibErr := common.ValidateAndBuildNrCellIdKey(cell.GetServedNrCellInformation().GetCellId())
 273                 if rNibErr != nil {
 274                         return pairs, rNibErr
 275                 }
 276                 pairs = append(pairs, key, cellData)
 277                 key, rNibErr = common.ValidateAndBuildCellNamePciKey(nbIdentity.InventoryName, cell.GetServedNrCellInformation().GetNrPci())
 278                 if rNibErr != nil {
 279                         return pairs, rNibErr
 280                 }
 281                 pairs = append(pairs, key, cellData)
 282         }
 283         return pairs, nil
 284 }
 285
 286 func isNotEmpty(nbIdentity *entities.NbIdentity) bool {
 287         return nbIdentity.GlobalNbId != nil && nbIdentity.GlobalNbId.PlmnId != "" && nbIdentity.GlobalNbId.NbId != ""
 288 }