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