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