E2Manager/handlers/httpmsghandlers/add_enb_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 type AddEnbRequestHandler struct {
  33         logger          *logger.Logger
  34         rNibDataService services.RNibDataService
  35 }
  36
  37 func NewAddEnbRequestHandler(logger *logger.Logger, rNibDataService services.RNibDataService) *AddEnbRequestHandler {
  38         return &AddEnbRequestHandler{
  39                 logger:          logger,
  40                 rNibDataService: rNibDataService,
  41         }
  42 }
  43
  44 func (h *AddEnbRequestHandler) Handle(request models.Request) (models.IResponse, error) {
  45
  46         addEnbRequest := request.(*models.AddEnbRequest)
  47
  48         h.logger.Infof("#AddEnbRequestHandler.Handle - Ran name: %s", addEnbRequest.RanName)
  49
  50         err := h.validateRequestBody(addEnbRequest)
  51
  52         if err != nil {
  53                 h.logger.Errorf("#AddEnbRequestHandler.Handle - validation failure: %s is a mandatory field and cannot be empty", err)
  54                 return nil, e2managererrors.NewRequestValidationError()
  55         }
  56
  57         _, err = h.rNibDataService.GetNodeb(addEnbRequest.RanName)
  58
  59         if err == nil {
  60                 h.logger.Errorf("#AddEnbRequestHandler.Handle - RAN name: %s - RAN already exists. quit", addEnbRequest.RanName)
  61                 return nil, e2managererrors.NewNodebExistsError()
  62         }
  63
  64         _, ok := err.(*common.ResourceNotFoundError)
  65         if !ok {
  66                 h.logger.Errorf("#AddEnbRequestHandler.Handle - RAN name: %s - failed to get nodeb entity from RNIB. Error: %s", addEnbRequest.RanName, err)
  67                 return nil, e2managererrors.NewRnibDbError()
  68         }
  69
  70         nbIdentity := h.createNbIdentity(addEnbRequest)
  71         nodebInfo := h.createNodebInfo(addEnbRequest)
  72
  73         err = h.rNibDataService.SaveNodeb(nbIdentity, nodebInfo)
  74
  75         if err != nil {
  76                 h.logger.Errorf("#AddEnbRequestHandler.Handle - RAN name: %s - failed to save nodeb entity in RNIB. Error: %s", addEnbRequest.RanName, err)
  77                 return nil, e2managererrors.NewRnibDbError()
  78         }
  79
  80         return models.NewAddEnbResponse(nodebInfo), nil
  81 }
  82
  83 func (h *AddEnbRequestHandler) createNodebInfo(addEnbRequest *models.AddEnbRequest) *entities.NodebInfo {
  84         nodebInfo := entities.NodebInfo{
  85                 RanName:          addEnbRequest.RanName,
  86                 Ip:               addEnbRequest.Ip,
  87                 Port:             addEnbRequest.Port,
  88                 GlobalNbId:       addEnbRequest.GlobalNbId,
  89                 Configuration:    &entities.NodebInfo_Enb{Enb: addEnbRequest.Enb},
  90                 ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,
  91         }
  92
  93         return &nodebInfo
  94 }
  95
  96 func (h *AddEnbRequestHandler) createNbIdentity(addEnbRequest *models.AddEnbRequest) *entities.NbIdentity {
  97         nbIdentity := entities.NbIdentity{
  98                 GlobalNbId:    addEnbRequest.GlobalNbId,
  99                 InventoryName: addEnbRequest.RanName,
 100         }
 101
 102         return &nbIdentity
 103 }
 104
 105 func (h *AddEnbRequestHandler) validateRequestBody(addEnbRequest *models.AddEnbRequest) error {
 106
 107         if addEnbRequest.RanName == "" {
 108                 return errors.New("ranName")
 109         }
 110
 111         if addEnbRequest.GlobalNbId == nil {
 112                 return errors.New("globalNbId")
 113         }
 114
 115         if err := isGlobalNbIdValid(addEnbRequest.GlobalNbId); err != nil {
 116                 return err
 117         }
 118
 119         if addEnbRequest.Enb == nil {
 120                 return errors.New("enb")
 121         }
 122
 123         if err := isEnbValid(addEnbRequest.Enb); err != nil {
 124                 return err
 125         }
 126
 127         return nil
 128 }
 129
 130 func isGlobalNbIdValid(globalNbId *entities.GlobalNbId) error {
 131         if globalNbId.PlmnId == "" {
 132                 return errors.New("globalNbId.plmnId")
 133         }
 134
 135         if globalNbId.NbId == "" {
 136                 return errors.New("globalNbId.nbId")
 137         }
 138
 139         return nil
 140 }
 141
 142 func isEnbValid(enb *entities.Enb) error {
 143         if enb.EnbType == entities.EnbType_UNKNOWN_ENB_TYPE {
 144                 return errors.New("enb.enbType")
 145         }
 146
 147         if enb.ServedCells == nil || len(enb.ServedCells) == 0 {
 148                 return errors.New("enb.servedCells")
 149         }
 150
 151         for _, servedCell := range enb.ServedCells {
 152                 err := isServedCellValid(servedCell)
 153
 154                 if err != nil {
 155                         return err
 156                 }
 157         }
 158
 159         return nil
 160 }
 161
 162 func isServedCellValid(servedCell *entities.ServedCellInfo) error {
 163
 164         if servedCell.CellId == "" {
 165                 return errors.New("servedCell.cellId")
 166         }
 167
 168         if servedCell.EutraMode == entities.Eutra_UNKNOWN {
 169                 return errors.New("servedCell.eutraMode")
 170         }
 171
 172         if servedCell.Tac == "" {
 173                 return errors.New("servedCell.tac")
 174         }
 175
 176         if servedCell.BroadcastPlmns == nil || len(servedCell.BroadcastPlmns) == 0 {
 177                 return errors.New("servedCell.broadcastPlmns")
 178         }
 179
 180         if servedCell.ChoiceEutraMode == nil {
 181                 return errors.New("servedCell.choiceEutraMode")
 182         }
 183
 184         return isChoiceEutraModeValid(servedCell.ChoiceEutraMode)
 185 }
 186
 187 func isChoiceEutraModeValid(choiceEutraMode *entities.ChoiceEUTRAMode) error {
 188         if choiceEutraMode.Fdd != nil {
 189                 return isFddInfoValid(choiceEutraMode.Fdd)
 190         }
 191
 192         if choiceEutraMode.Tdd != nil {
 193                 return isTddInfoValid(choiceEutraMode.Tdd)
 194         }
 195
 196         return errors.New("servedCell.fdd / servedCell.tdd")
 197 }
 198
 199 func isTddInfoValid(tdd *entities.TddInfo) error {
 200         return nil
 201 }
 202
 203 func isFddInfoValid(fdd *entities.FddInfo) error {
 204         return nil
 205 }