E2Manager/managers/nodeb_validator.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 managers
  21
  22 import (
  23         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  24         "github.com/pkg/errors"
  25 )
  26
  27 type NodebValidator struct {
  28 }
  29
  30 func NewNodebValidator() *NodebValidator {
  31         return &NodebValidator{}
  32 }
  33
  34 func (h *NodebValidator) IsGnbValid(gnb *entities.Gnb) error {
  35         if len(gnb.ServedNrCells) == 0 {
  36                 return errors.New("gnb.servedNrCells")
  37         }
  38
  39         for _, servedNrCell := range gnb.ServedNrCells {
  40                 if servedNrCell.ServedNrCellInformation == nil {
  41                         return errors.New("gnb.servedNrCellInformation")
  42                 }
  43
  44                 err := isServedNrCellInformationValid(servedNrCell.ServedNrCellInformation)
  45
  46                 if err != nil {
  47                         return err
  48                 }
  49
  50                 if len(servedNrCell.NrNeighbourInfos) == 0 {
  51                         continue
  52                 }
  53
  54                 for _, nrNeighbourInformation := range servedNrCell.NrNeighbourInfos {
  55
  56                         err := isNrNeighbourInformationValid(nrNeighbourInformation)
  57
  58                         if err != nil {
  59                                 return err
  60                         }
  61
  62                 }
  63         }
  64
  65         return nil
  66 }
  67
  68 func isServedNrCellInformationValid(servedNrCellInformation *entities.ServedNRCellInformation) error {
  69         if servedNrCellInformation.CellId == "" {
  70                 return errors.New("servedNrCellInformation.cellId")
  71         }
  72
  73         if servedNrCellInformation.ChoiceNrMode == nil {
  74                 return errors.New("servedNrCellInformation.choiceNrMode")
  75         }
  76
  77         if servedNrCellInformation.NrMode == entities.Nr_UNKNOWN {
  78                 return errors.New("servedNrCellInformation.nrMode")
  79         }
  80
  81         if len(servedNrCellInformation.ServedPlmns) == 0 {
  82                 return errors.New("servedNrCellInformation.servedPlmns")
  83         }
  84
  85         return isServedNrCellInfoChoiceNrModeValid(servedNrCellInformation.ChoiceNrMode)
  86 }
  87
  88 func isServedNrCellInfoChoiceNrModeValid(choiceNrMode *entities.ServedNRCellInformation_ChoiceNRMode) error {
  89         if choiceNrMode.Fdd != nil {
  90                 return isServedNrCellInfoFddValid(choiceNrMode.Fdd)
  91         }
  92
  93         if choiceNrMode.Tdd != nil {
  94                 return isServedNrCellInfoTddValid(choiceNrMode.Tdd)
  95         }
  96
  97         return errors.New("servedNrCellInformation.choiceNrMode.fdd / servedNrCellInformation.choiceNrMode.tdd")
  98 }
  99
 100 func isServedNrCellInfoTddValid(tdd *entities.ServedNRCellInformation_ChoiceNRMode_TddInfo) error {
 101         return nil
 102 }
 103
 104 func isServedNrCellInfoFddValid(fdd *entities.ServedNRCellInformation_ChoiceNRMode_FddInfo) error {
 105         return nil
 106 }
 107
 108 func isNrNeighbourInformationValid(nrNeighbourInformation *entities.NrNeighbourInformation) error {
 109         if nrNeighbourInformation.NrCgi == "" {
 110                 return errors.New("nrNeighbourInformation.nrCgi")
 111         }
 112
 113         if nrNeighbourInformation.ChoiceNrMode == nil {
 114                 return errors.New("nrNeighbourInformation.choiceNrMode")
 115         }
 116
 117         if nrNeighbourInformation.NrMode == entities.Nr_UNKNOWN {
 118                 return errors.New("nrNeighbourInformation.nrMode")
 119         }
 120
 121         return isNrNeighbourInfoChoiceNrModeValid(nrNeighbourInformation.ChoiceNrMode)
 122 }
 123
 124 func isNrNeighbourInfoChoiceNrModeValid(choiceNrMode *entities.NrNeighbourInformation_ChoiceNRMode) error {
 125         if choiceNrMode.Fdd != nil {
 126                 return isNrNeighbourInfoFddValid(choiceNrMode.Fdd)
 127         }
 128
 129         if choiceNrMode.Tdd != nil {
 130                 return isNrNeighbourInfoTddValid(choiceNrMode.Tdd)
 131         }
 132
 133         return errors.New("nrNeighbourInformation.choiceNrMode.fdd / nrNeighbourInformation.choiceNrMode.tdd")
 134 }
 135
 136 func isNrNeighbourInfoTddValid(tdd *entities.NrNeighbourInformation_ChoiceNRMode_TddInfo) error {
 137         return nil
 138 }
 139
 140 func isNrNeighbourInfoFddValid(fdd *entities.NrNeighbourInformation_ChoiceNRMode_FddInfo) error {
 141         return nil
 142 }
 143
 144 func (h *NodebValidator) IsEnbValid(enb *entities.Enb) error {
 145         if enb.EnbType == entities.EnbType_UNKNOWN_ENB_TYPE {
 146                 return errors.New("enb.enbType")
 147         }
 148
 149         if enb.ServedCells == nil || len(enb.ServedCells) == 0 {
 150                 return errors.New("enb.servedCells")
 151         }
 152
 153         for _, servedCell := range enb.ServedCells {
 154                 err := isServedCellValid(servedCell)
 155
 156                 if err != nil {
 157                         return err
 158                 }
 159         }
 160
 161         return nil
 162 }
 163
 164 func (h *NodebValidator) IsNgEnbType(enbType entities.EnbType) bool {
 165         return enbType == entities.EnbType_LONG_MACRO_NG_ENB ||
 166                 enbType == entities.EnbType_MACRO_NG_ENB ||
 167                 enbType == entities.EnbType_SHORT_MACRO_NG_ENB
 168 }
 169
 170 func isServedCellValid(servedCell *entities.ServedCellInfo) error {
 171
 172         if servedCell.CellId == "" {
 173                 return errors.New("servedCell.cellId")
 174         }
 175
 176         if servedCell.EutraMode == entities.Eutra_UNKNOWN {
 177                 return errors.New("servedCell.eutraMode")
 178         }
 179
 180         if servedCell.Tac == "" {
 181                 return errors.New("servedCell.tac")
 182         }
 183
 184         if servedCell.BroadcastPlmns == nil || len(servedCell.BroadcastPlmns) == 0 {
 185                 return errors.New("servedCell.broadcastPlmns")
 186         }
 187
 188         if servedCell.ChoiceEutraMode == nil {
 189                 return errors.New("servedCell.choiceEutraMode")
 190         }
 191
 192         return isChoiceEutraModeValid(servedCell.ChoiceEutraMode)
 193 }
 194
 195 func isChoiceEutraModeValid(choiceEutraMode *entities.ChoiceEUTRAMode) error {
 196         if choiceEutraMode.Fdd != nil {
 197                 return isFddInfoValid(choiceEutraMode.Fdd)
 198         }
 199
 200         if choiceEutraMode.Tdd != nil {
 201                 return isTddInfoValid(choiceEutraMode.Tdd)
 202         }
 203
 204         return errors.New("servedCell.fdd / servedCell.tdd")
 205 }
 206
 207 func isTddInfoValid(tdd *entities.TddInfo) error {
 208         return nil
 209 }
 210
 211 func isFddInfoValid(fdd *entities.FddInfo) error {
 212         return nil
 213 }