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