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