E2Manager/handlers/httpmsghandlers/update_gnb_request_handler.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 httpmsghandlers
  21
  22 import (
  23         "e2mgr/e2managererrors"
  24         "e2mgr/logger"
  25         "e2mgr/models"
  26         "e2mgr/services"
  27         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  28         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  29         "github.com/pkg/errors"
  30 )
  31
  32 const VALIDATION_FAILURE_MESSAGE = "#UpdateGnbRequestHandler.Handle - validation failure: %s is a mandatory field"
  33
  34 type UpdateGnbRequestHandler struct {
  35         logger          *logger.Logger
  36         rNibDataService services.RNibDataService
  37 }
  38
  39 func NewUpdateGnbRequestHandler(logger *logger.Logger, rNibDataService services.RNibDataService) *UpdateGnbRequestHandler {
  40         return &UpdateGnbRequestHandler{
  41                 logger:          logger,
  42                 rNibDataService: rNibDataService,
  43         }
  44 }
  45
  46 func (h *UpdateGnbRequestHandler) Handle(request models.Request) (models.IResponse, error) {
  47
  48         updateGnbRequest := request.(models.UpdateGnbRequest)
  49
  50         h.logger.Infof("#UpdateGnbRequestHandler.Handle - Ran name: %s", updateGnbRequest.RanName)
  51
  52         err := h.validateRequestBody(updateGnbRequest)
  53
  54         if err != nil {
  55                 return nil, err
  56         }
  57
  58         nodebInfo, err := h.rNibDataService.GetNodeb(updateGnbRequest.RanName)
  59
  60         if err != nil {
  61                 _, ok := err.(*common.ResourceNotFoundError)
  62                 if !ok {
  63                         h.logger.Errorf("#UpdateGnbRequestHandler.Handle - RAN name: %s - failed to get nodeb entity from RNIB. Error: %s", updateGnbRequest.RanName, err)
  64                         return nil, e2managererrors.NewRnibDbError()
  65                 }
  66
  67                 h.logger.Errorf("#UpdateGnbRequestHandler.Handle - RAN name: %s - RAN not found on RNIB. Error: %s", updateGnbRequest.RanName, err)
  68                 return nil, e2managererrors.NewResourceNotFoundError()
  69         }
  70
  71         err = h.updateGnbCells(nodebInfo, updateGnbRequest)
  72
  73         if err != nil {
  74                 return nil, err
  75         }
  76
  77         return models.NewNodebResponse(nodebInfo), nil
  78 }
  79
  80 func (h *UpdateGnbRequestHandler) updateGnbCells(nodebInfo *entities.NodebInfo, updateGnbRequest models.UpdateGnbRequest) error {
  81
  82         ranName := nodebInfo.RanName
  83         gnb := nodebInfo.GetGnb()
  84
  85         if gnb == nil {
  86                 h.logger.Errorf("#UpdateGnbRequestHandler.updateGnbCells - RAN name: %s - nodeb missing gnb configuration", ranName)
  87                 return e2managererrors.NewInternalError()
  88         }
  89
  90         if len(gnb.ServedNrCells) != 0 {
  91                 err := h.rNibDataService.RemoveServedNrCells(ranName, gnb.ServedNrCells)
  92
  93                 if err != nil {
  94                         h.logger.Errorf("#UpdateGnbRequestHandler.updateGnbCells - RAN name: %s - Failed removing served nr cells", ranName)
  95                         return e2managererrors.NewRnibDbError()
  96                 }
  97         }
  98
  99         gnb.ServedNrCells = updateGnbRequest.ServedNrCells
 100
 101         err := h.rNibDataService.UpdateGnbCells(nodebInfo, updateGnbRequest.ServedNrCells)
 102
 103         if err != nil {
 104                 h.logger.Errorf("#UpdateGnbRequestHandler.updateGnbCells - RAN name: %s - Failed updating GNB cells. Error: %s", ranName, err)
 105                 return e2managererrors.NewRnibDbError()
 106         }
 107
 108         h.logger.Infof("#UpdateGnbRequestHandler.updateGnbCells - RAN name: %s - Successfully updated GNB cells", ranName)
 109         return nil
 110 }
 111
 112 func (h *UpdateGnbRequestHandler) validateRequestBody(updateGnbRequest models.UpdateGnbRequest) error {
 113
 114         if len(updateGnbRequest.ServedNrCells) == 0 {
 115                 h.logger.Errorf(VALIDATION_FAILURE_MESSAGE+" and cannot be empty", "servedCells")
 116                 return e2managererrors.NewRequestValidationError()
 117         }
 118
 119         for _, servedNrCell := range updateGnbRequest.ServedNrCells {
 120                 if servedNrCell.ServedNrCellInformation == nil {
 121                         h.logger.Errorf(VALIDATION_FAILURE_MESSAGE+" and cannot be empty", "servedNrCellInformation")
 122                         return e2managererrors.NewRequestValidationError()
 123                 }
 124
 125                 err := isServedNrCellInformationValid(servedNrCell.ServedNrCellInformation)
 126
 127                 if err != nil {
 128                         h.logger.Errorf(VALIDATION_FAILURE_MESSAGE, err)
 129                         return e2managererrors.NewRequestValidationError()
 130                 }
 131
 132                 if len(servedNrCell.NrNeighbourInfos) == 0 {
 133                         continue
 134                 }
 135
 136                 for _, nrNeighbourInformation := range servedNrCell.NrNeighbourInfos {
 137
 138                         err := isNrNeighbourInformationValid(nrNeighbourInformation)
 139
 140                         if err != nil {
 141                                 h.logger.Errorf(VALIDATION_FAILURE_MESSAGE, err)
 142                                 return e2managererrors.NewRequestValidationError()
 143                         }
 144
 145                 }
 146         }
 147
 148         return nil
 149 }
 150
 151 func isServedNrCellInformationValid(servedNrCellInformation *entities.ServedNRCellInformation) error {
 152         if servedNrCellInformation.CellId == "" {
 153                 return errors.New("cellId")
 154         }
 155
 156         if servedNrCellInformation.ChoiceNrMode == nil {
 157                 return errors.New("choiceNrMode")
 158         }
 159
 160         if servedNrCellInformation.NrMode == entities.Nr_UNKNOWN {
 161                 return errors.New("nrMode")
 162         }
 163
 164         if len(servedNrCellInformation.ServedPlmns) == 0 {
 165                 return errors.New("servedPlmns")
 166         }
 167
 168         return isServedNrCellInfoChoiceNrModeValid(servedNrCellInformation.ChoiceNrMode)
 169 }
 170
 171 func isServedNrCellInfoChoiceNrModeValid(choiceNrMode *entities.ServedNRCellInformation_ChoiceNRMode) error {
 172         if choiceNrMode.Fdd != nil {
 173                 return isServedNrCellInfoFddValid(choiceNrMode.Fdd)
 174         }
 175
 176         if choiceNrMode.Tdd != nil {
 177                 return isServedNrCellInfoTddValid(choiceNrMode.Tdd)
 178         }
 179
 180         return errors.New("served nr cell fdd / tdd")
 181 }
 182
 183 func isServedNrCellInfoTddValid(tdd *entities.ServedNRCellInformation_ChoiceNRMode_TddInfo) error {
 184         return nil
 185 }
 186
 187 func isServedNrCellInfoFddValid(fdd *entities.ServedNRCellInformation_ChoiceNRMode_FddInfo) error {
 188         return nil
 189 }
 190
 191 func isNrNeighbourInformationValid(nrNeighbourInformation *entities.NrNeighbourInformation) error {
 192         if nrNeighbourInformation.NrCgi == "" {
 193                 return errors.New("nrCgi")
 194         }
 195
 196         if nrNeighbourInformation.ChoiceNrMode == nil {
 197                 return errors.New("choiceNrMode")
 198         }
 199
 200         if nrNeighbourInformation.NrMode == entities.Nr_UNKNOWN {
 201                 return errors.New("nrMode")
 202         }
 203
 204         return isNrNeighbourInfoChoiceNrModeValid(nrNeighbourInformation.ChoiceNrMode)
 205 }
 206
 207 func isNrNeighbourInfoChoiceNrModeValid(choiceNrMode *entities.NrNeighbourInformation_ChoiceNRMode) error {
 208         if choiceNrMode.Fdd != nil {
 209                 return isNrNeighbourInfoFddValid(choiceNrMode.Fdd)
 210         }
 211
 212         if choiceNrMode.Tdd != nil {
 213                 return isNrNeighbourInfoTddValid(choiceNrMode.Tdd)
 214         }
 215
 216         return errors.New("nr neighbour fdd / tdd")
 217 }
 218
 219 func isNrNeighbourInfoTddValid(tdd *entities.NrNeighbourInformation_ChoiceNRMode_TddInfo) error {
 220         return nil
 221 }
 222
 223 func isNrNeighbourInfoFddValid(fdd *entities.NrNeighbourInformation_ChoiceNRMode_FddInfo) error {
 224         return nil
 225 }