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