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         ranName:= nodebInfo.RanName
  72         gnb := nodebInfo.GetGnb()
  73
  74         if gnb == nil {
  75                 h.logger.Errorf("#UpdateGnbRequestHandler.Handle - RAN name: %s - nodeb missing gnb configuration", ranName)
  76                 return nil, e2managererrors.NewInternalError()
  77         }
  78
  79         gnb.ServedNrCells = updateGnbRequest.ServedNrCells
  80
  81         err = h.rNibDataService.UpdateGnbCells(nodebInfo, updateGnbRequest.ServedNrCells)
  82
  83         if err != nil {
  84                 h.logger.Errorf("#UpdateGnbRequestHandler.Handle - RAN name: %s - Failed updating GNB cells. Error: %s", ranName, err)
  85                 return nil, e2managererrors.NewRnibDbError()
  86         }
  87
  88         return models.NewUpdateGnbResponse(nodebInfo), nil
  89 }
  90
  91 func (h *UpdateGnbRequestHandler) validateRequestBody(updateGnbRequest models.UpdateGnbRequest) (error) {
  92
  93         if len(updateGnbRequest.ServedNrCells) == 0 {
  94                 h.logger.Errorf(VALIDATION_FAILURE_MESSAGE+" and cannot be empty", "servedCells")
  95                 return e2managererrors.NewRequestValidationError()
  96         }
  97
  98         for _, servedNrCell := range updateGnbRequest.ServedNrCells {
  99                 if servedNrCell.ServedNrCellInformation == nil {
 100                         h.logger.Errorf(VALIDATION_FAILURE_MESSAGE+" and cannot be empty", "servedNrCellInformation")
 101                         return e2managererrors.NewRequestValidationError()
 102                 }
 103
 104                 err := isServedNrCellInformationValid(servedNrCell.ServedNrCellInformation)
 105
 106                 if err != nil {
 107                         h.logger.Errorf(VALIDATION_FAILURE_MESSAGE, err)
 108                         return e2managererrors.NewRequestValidationError()
 109                 }
 110
 111                 if len(servedNrCell.NrNeighbourInfos) == 0 {
 112                         continue
 113                 }
 114
 115                 for _, nrNeighbourInformation := range servedNrCell.NrNeighbourInfos {
 116
 117                         err := isNrNeighbourInformationValid(nrNeighbourInformation)
 118
 119                         if err != nil {
 120                                 h.logger.Errorf(VALIDATION_FAILURE_MESSAGE, err)
 121                                 return e2managererrors.NewRequestValidationError()
 122                         }
 123
 124                 }
 125         }
 126
 127         return nil
 128 }
 129
 130 func isServedNrCellInformationValid(servedNrCellInformation *entities.ServedNRCellInformation) error {
 131         if servedNrCellInformation.CellId == "" {
 132                 return errors.New("cellId");
 133         }
 134
 135         if servedNrCellInformation.ChoiceNrMode == nil {
 136                 return errors.New("choiceNrMode");
 137         }
 138
 139         if servedNrCellInformation.NrMode == entities.Nr_UNKNOWN {
 140                 return errors.New("nrMode");
 141         }
 142
 143         if servedNrCellInformation.NrPci == 0 {
 144                 return errors.New("nrPci");
 145         }
 146
 147         if len(servedNrCellInformation.ServedPlmns) == 0 {
 148                 return errors.New("servedPlmns");
 149         }
 150
 151         return isServedNrCellInfoChoiceNrModeValid(servedNrCellInformation.ChoiceNrMode)
 152 }
 153
 154 func isServedNrCellInfoChoiceNrModeValid(choiceNrMode *entities.ServedNRCellInformation_ChoiceNRMode) error {
 155         if choiceNrMode.Fdd != nil {
 156                 return isServedNrCellInfoFddValid(choiceNrMode.Fdd)
 157         }
 158
 159         if choiceNrMode.Tdd != nil {
 160                 return isServedNrCellInfoTddValid(choiceNrMode.Tdd)
 161         }
 162
 163         return errors.New("served nr cell fdd / tdd")
 164 }
 165
 166 func isServedNrCellInfoTddValid(tdd *entities.ServedNRCellInformation_ChoiceNRMode_TddInfo) error {
 167         return nil
 168 }
 169
 170 func isServedNrCellInfoFddValid(fdd *entities.ServedNRCellInformation_ChoiceNRMode_FddInfo) error {
 171         return nil
 172 }
 173
 174 func isNrNeighbourInformationValid(nrNeighbourInformation *entities.NrNeighbourInformation) error {
 175         if nrNeighbourInformation.NrCgi == "" {
 176                 return errors.New("nrCgi")
 177         }
 178
 179         if nrNeighbourInformation.ChoiceNrMode == nil {
 180                 return errors.New("choiceNrMode")
 181         }
 182
 183         if nrNeighbourInformation.NrMode == entities.Nr_UNKNOWN {
 184                 return errors.New("nrMode")
 185         }
 186
 187         if nrNeighbourInformation.NrPci == 0 {
 188                 return errors.New("nrPci")
 189         }
 190
 191         return isNrNeighbourInfoChoiceNrModeValid(nrNeighbourInformation.ChoiceNrMode)
 192 }
 193
 194 func isNrNeighbourInfoChoiceNrModeValid(choiceNrMode *entities.NrNeighbourInformation_ChoiceNRMode) error {
 195         if choiceNrMode.Fdd != nil {
 196                 return isNrNeighbourInfoFddValid(choiceNrMode.Fdd)
 197         }
 198
 199         if choiceNrMode.Tdd != nil {
 200                 return isNrNeighbourInfoTddValid(choiceNrMode.Tdd)
 201         }
 202
 203         return errors.New("nr neighbour fdd / tdd")
 204 }
 205
 206 func isNrNeighbourInfoTddValid(tdd *entities.NrNeighbourInformation_ChoiceNRMode_TddInfo) error {
 207         return nil
 208 }
 209
 210 func isNrNeighbourInfoFddValid(fdd *entities.NrNeighbourInformation_ChoiceNRMode_FddInfo) error {
 211         return nil
 212 }