E2Manager/handlers/rmrmsghandlers/e2_setup_request_notification_handler.go

   1 //
   2 // Copyright 2019 AT&T Intellectual Property
   3 // Copyright 2019 Nokia
   4 // Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved.
   5 // Copyright 2023 Capgemini
   6 //
   7 // Licensed under the Apache License, Version 2.0 (the "License");
   8 // you may not use this file except in compliance with the License.
   9 // You may obtain a copy of the License at
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 // Unless required by applicable law or agreed to in writing, software
  14 // distributed under the License is distributed on an "AS IS" BASIS,
  15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 // See the License for the specific language governing permissions and
  17 // limitations under the License.
  18
  19 //  This source code is part of the near-RT RIC (RAN Intelligent Controller)
  20 //  platform project (RICP).
  21
  22 package rmrmsghandlers
  23
  24 import (
  25         "bytes"
  26         "e2mgr/configuration"
  27         "e2mgr/e2managererrors"
  28         "e2mgr/logger"
  29         "e2mgr/managers"
  30         "e2mgr/models"
  31         "e2mgr/rmrCgo"
  32         "e2mgr/services"
  33         "e2mgr/services/rmrsender"
  34         "e2mgr/utils"
  35         "encoding/xml"
  36         "errors"
  37         "fmt"
  38         "strconv"
  39         "strings"
  40         "time"
  41
  42         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  43         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  44 )
  45
  46 const cleanUpDurationNanoSec uint64 = 10000000000 // cleanUpDuration = 10sec (value in nanoSecond=10000000000)
  47
  48 var (
  49         emptyTagsToReplaceToSelfClosingTags = []string{"reject", "ignore", "transport-resource-unavailable", "om-intervention", "request-id-unknown",
  50                 "unspecified", "message-not-compatible-with-receiver-state", "control-processing-overload",
  51                 "v60s", "v20s", "v10s", "v5s", "v2s", "v1s", "ng", "xn", "e1", "f1", "w1", "s1", "x2", "success", "failure"}
  52         gnbTypesMap = map[string]entities.GnbType{
  53                 "gnb":    entities.GnbType_GNB,
  54                 "en_gnb": entities.GnbType_EN_GNB,
  55         }
  56         enbTypesMap = map[string]entities.EnbType{
  57                 "enB_macro":         entities.EnbType_MACRO_ENB,
  58                 "enB_home":          entities.EnbType_HOME_ENB,
  59                 "enB_shortmacro":    entities.EnbType_SHORT_MACRO_ENB,
  60                 "enB_longmacro":     entities.EnbType_LONG_MACRO_ENB,
  61                 "ng_enB_macro":      entities.EnbType_MACRO_NG_ENB,
  62                 "ng_enB_shortmacro": entities.EnbType_SHORT_MACRO_NG_ENB,
  63                 "ng_enB_longmacro":  entities.EnbType_LONG_MACRO_NG_ENB,
  64         }
  65 )
  66
  67 type E2SetupRequestNotificationHandler struct {
  68         logger                        *logger.Logger
  69         config                        *configuration.Configuration
  70         e2tInstancesManager           managers.IE2TInstancesManager
  71         rmrSender                     *rmrsender.RmrSender
  72         rNibDataService               services.RNibDataService
  73         e2tAssociationManager         *managers.E2TAssociationManager
  74         ranConnectStatusChangeManager managers.IRanConnectStatusChangeManager
  75         ranListManager                managers.RanListManager
  76 }
  77
  78 func NewE2SetupRequestNotificationHandler(logger *logger.Logger, config *configuration.Configuration, e2tInstancesManager managers.IE2TInstancesManager, rmrSender *rmrsender.RmrSender, rNibDataService services.RNibDataService, e2tAssociationManager *managers.E2TAssociationManager, ranConnectStatusChangeManager managers.IRanConnectStatusChangeManager, ranListManager managers.RanListManager) *E2SetupRequestNotificationHandler {
  79         return &E2SetupRequestNotificationHandler{
  80                 logger:                        logger,
  81                 config:                        config,
  82                 e2tInstancesManager:           e2tInstancesManager,
  83                 rmrSender:                     rmrSender,
  84                 rNibDataService:               rNibDataService,
  85                 e2tAssociationManager:         e2tAssociationManager,
  86                 ranConnectStatusChangeManager: ranConnectStatusChangeManager,
  87                 ranListManager:                ranListManager,
  88         }
  89 }
  90
  91 func (h *E2SetupRequestNotificationHandler) Handle(request *models.NotificationRequest) {
  92         ranName := request.RanName
  93         models.UpdateProcedureType(ranName, models.E2SetupProcedureNotInitiated)
  94         h.logger.Infof("#E2SetupRequestNotificationHandler.Handle - RAN name: %s - received E2_SETUP_REQUEST. Payload: %x", ranName, request.Payload)
  95
  96         generalConfiguration, err := h.rNibDataService.GetGeneralConfiguration()
  97
  98         if err != nil {
  99                 h.logger.Errorf("#E2SetupRequestNotificationHandler.Handle - Failed retrieving e2m general configuration - quitting e2 setup flow. error: %s", err)
 100                 return
 101         }
 102
 103         setupRequest, e2tIpAddress, err := h.parseSetupRequest(request.Payload)
 104         if err != nil {
 105                 h.logger.Errorf(err.Error())
 106                 return
 107         }
 108
 109         h.logger.Infof("#E2SetupRequestNotificationHandler.Handle - E2T Address: %s - handling E2_SETUP_REQUEST", e2tIpAddress)
 110         h.logger.Debugf("#E2SetupRequestNotificationHandler.Handle - E2_SETUP_REQUEST has been parsed successfully %+v", setupRequest)
 111
 112         h.logger.Infof("#E2SetupRequestNotificationHandler.Handle - got general configuration from rnib - enableRic: %t", generalConfiguration.EnableRic)
 113
 114         if !generalConfiguration.EnableRic {
 115                 cause := models.Cause{Misc: &models.CauseMisc{OmIntervention: &struct{}{}}}
 116                 h.handleUnsuccessfulResponse(ranName, request, cause, setupRequest)
 117                 models.UpdateProcedureType(ranName, models.E2SetupProcedureFailure)
 118                 return
 119         }
 120
 121         _, err = h.e2tInstancesManager.GetE2TInstance(e2tIpAddress)
 122
 123         if err != nil {
 124                 h.logger.Errorf("#E2TermInitNotificationHandler.Handle - Failed retrieving E2TInstance. error: %s", err)
 125                 return
 126         }
 127
 128         nodebInfo, err := h.rNibDataService.GetNodeb(ranName)
 129
 130         var functionsModified bool
 131
 132         if err != nil {
 133
 134                 if _, ok := err.(*common.ResourceNotFoundError); !ok {
 135                         h.logger.Errorf("#E2SetupRequestNotificationHandler.Handle - RAN name: %s - failed to retrieve nodebInfo entity. Error: %s", ranName, err)
 136                         return
 137                 }
 138
 139                 if nodebInfo, err = h.handleNewRan(ranName, e2tIpAddress, setupRequest); err != nil {
 140                         if _, ok := err.(*e2managererrors.UnknownSetupRequestRanNameError); ok {
 141                                 cause := models.Cause{RicRequest: &models.CauseRic{RequestIdUnknown: &struct{}{}}}
 142                                 h.handleUnsuccessfulResponse(ranName, request, cause, setupRequest)
 143                                 models.UpdateProcedureType(ranName, models.E2SetupProcedureFailure)
 144                         }
 145                         return
 146                 }
 147
 148         } else {
 149
 150                 functionsModified, err = h.handleExistingRan(ranName, nodebInfo, setupRequest)
 151
 152                 if err != nil {
 153                         h.fillCauseAndSendUnsuccessfulResponse(nodebInfo, request, setupRequest)
 154                         models.UpdateProcedureType(ranName, models.E2SetupProcedureFailure)
 155                         return
 156                 }
 157         }
 158         models.UpdateProcedureType(ranName, models.E2SetupProcedureOngoing)
 159
 160         ranStatusChangePublished, err := h.e2tAssociationManager.AssociateRan(e2tIpAddress, nodebInfo)
 161
 162         if err != nil {
 163
 164                 h.logger.Errorf("#E2SetupRequestNotificationHandler.Handle - RAN name: %s - failed to associate E2T to nodeB entity. Error: %s", ranName, err)
 165                 if _, ok := err.(*e2managererrors.RoutingManagerError); ok {
 166
 167                         if err = h.handleUpdateAndPublishNodebInfo(functionsModified, ranStatusChangePublished, nodebInfo); err != nil {
 168                                 return
 169                         }
 170
 171                         cause := models.Cause{Transport: &models.CauseTransport{TransportResourceUnavailable: &struct{}{}}}
 172                         h.handleUnsuccessfulResponse(nodebInfo.RanName, request, cause, setupRequest)
 173                         models.UpdateProcedureType(ranName, models.E2SetupProcedureFailure)
 174                 }
 175                 return
 176         }
 177
 178         if err = h.handleUpdateAndPublishNodebInfo(functionsModified, ranStatusChangePublished, nodebInfo); err != nil {
 179                 return
 180         }
 181
 182         h.handleSuccessfulResponse(ranName, request, setupRequest)
 183         models.UpdateProcedureType(ranName, models.E2SetupProcedureCompleted)
 184         h.logger.Debugf("#E2SetupRequestNotificationHandler.Handle - updating the enum value to e2setup request completed")
 185 }
 186
 187 func (h *E2SetupRequestNotificationHandler) handleUpdateAndPublishNodebInfo(functionsModified bool, ranStatusChangePublished bool, nodebInfo *entities.NodebInfo) error {
 188
 189         if ranStatusChangePublished || !functionsModified {
 190                 return nil
 191         }
 192
 193         err := h.rNibDataService.UpdateNodebInfoAndPublish(nodebInfo)
 194
 195         if err != nil {
 196                 h.logger.Errorf("#E2SetupRequestNotificationHandler.handleUpdateAndPublishNodebInfo - RAN name: %s - Failed at UpdateNodebInfoAndPublish. error: %s", nodebInfo.RanName, err)
 197                 return err
 198         }
 199
 200         h.logger.Infof("#E2SetupRequestNotificationHandler.handleUpdateAndPublishNodebInfo - RAN name: %s - Successfully executed UpdateNodebInfoAndPublish", nodebInfo.RanName)
 201         return nil
 202
 203 }
 204
 205 func (h *E2SetupRequestNotificationHandler) handleNewRan(ranName string, e2tIpAddress string, setupRequest *models.E2SetupRequestMessage) (*entities.NodebInfo, error) {
 206
 207         nodebInfo, err := h.buildNodebInfo(ranName, e2tIpAddress, setupRequest)
 208         if err != nil {
 209                 h.logger.Errorf("#E2SetupRequestNotificationHandler.handleNewRan - RAN name: %s - failed building nodebInfo. Error: %s", ranName, err)
 210                 return nil, err
 211         }
 212
 213         err = h.rNibDataService.SaveNodeb(nodebInfo)
 214         if err != nil {
 215                 h.logger.Errorf("#E2SetupRequestNotificationHandler.handleNewRan - RAN name: %s - failed saving nodebInfo. Error: %s", ranName, err)
 216                 return nil, err
 217         }
 218
 219         nbIdentity := h.buildNbIdentity(ranName, setupRequest)
 220
 221         err = h.ranListManager.AddNbIdentity(nodebInfo.GetNodeType(), nbIdentity)
 222
 223         if err != nil {
 224                 return nil, err
 225         }
 226
 227         return nodebInfo, nil
 228 }
 229
 230 func (h *E2SetupRequestNotificationHandler) handleExistingRan(ranName string, nodebInfo *entities.NodebInfo, setupRequest *models.E2SetupRequestMessage) (bool, error) {
 231         if nodebInfo.GetConnectionStatus() == entities.ConnectionStatus_DISCONNECTED {
 232                 delta_in_nano := uint64(time.Now().UnixNano()) - nodebInfo.StatusUpdateTimeStamp
 233                 //The duration from last Disconnection for which a new request is to be rejected (currently 10 sec)
 234                 if delta_in_nano < cleanUpDurationNanoSec {
 235                         h.logger.Errorf("#E2SetupRequestNotificationHandler.Handle - RAN name: %s, connection status: %s - nodeB entity disconnection in progress", ranName, nodebInfo.ConnectionStatus)
 236                         return false, errors.New("nodeB entity disconnection in progress")
 237                 }
 238                 h.logger.Infof("#E2SetupRequestNotificationHandler.Handle - RAN name: %s, connection status: %s - nodeB entity in disconnected state", ranName, nodebInfo.ConnectionStatus)
 239         } else if nodebInfo.GetConnectionStatus() == entities.ConnectionStatus_SHUTTING_DOWN {
 240                 h.logger.Errorf("#E2SetupRequestNotificationHandler.Handle - RAN name: %s, connection status: %s - nodeB entity in incorrect state", ranName, nodebInfo.ConnectionStatus)
 241                 return false, errors.New("nodeB entity in incorrect state")
 242         }
 243
 244         nodebInfo.SetupFromNetwork = true
 245
 246         e2NodeConfig := setupRequest.ExtractE2NodeConfigList()
 247         if e2NodeConfig == nil {
 248                 return false, errors.New("Empty E2nodeComponentConfigAddition-List")
 249         }
 250
 251         if nodebInfo.NodeType == entities.Node_ENB {
 252                 if len(e2NodeConfig) == 0 && len(nodebInfo.GetEnb().GetNodeConfigs()) == 0 {
 253                         return false, errors.New("Empty E2nodeComponentConfigAddition-List")
 254                 }
 255                 nodebInfo.GetEnb().NodeConfigs = e2NodeConfig
 256
 257                 return false, nil
 258         }
 259
 260         if len(e2NodeConfig) == 0 && len(nodebInfo.GetGnb().GetNodeConfigs()) == 0 {
 261                 return false, errors.New("Empty E2nodeComponentConfigAddition-List")
 262         }
 263         nodebInfo.GetGnb().NodeConfigs = e2NodeConfig
 264
 265         setupMessageRanFuncs := setupRequest.ExtractRanFunctionsList()
 266
 267         if setupMessageRanFuncs == nil || (len(setupMessageRanFuncs) == 0 && len(nodebInfo.GetGnb().RanFunctions) == 0) {
 268                 return false, nil
 269         }
 270
 271         nodebInfo.GetGnb().RanFunctions = setupMessageRanFuncs
 272         return true, nil
 273 }
 274
 275 func (h *E2SetupRequestNotificationHandler) handleUnsuccessfulResponse(ranName string, req *models.NotificationRequest, cause models.Cause, setupRequest *models.E2SetupRequestMessage) {
 276         failureResponse := models.NewE2SetupFailureResponseMessage(models.TimeToWaitEnum.V60s, cause, setupRequest)
 277         h.logger.Debugf("#E2SetupRequestNotificationHandler.handleUnsuccessfulResponse - E2_SETUP_RESPONSE has been built successfully %+v", failureResponse)
 278
 279         responsePayload, err := xml.Marshal(&failureResponse.E2APPDU)
 280         if err != nil {
 281                 h.logger.Warnf("#E2SetupRequestNotificationHandler.handleUnsuccessfulResponse - RAN name: %s - Error marshalling RIC_E2_SETUP_RESP. Payload: %s", ranName, responsePayload)
 282         }
 283
 284         responsePayload = utils.ReplaceEmptyTagsWithSelfClosing(responsePayload, emptyTagsToReplaceToSelfClosingTags)
 285
 286         h.logger.Infof("#E2SetupRequestNotificationHandler.handleUnsuccessfulResponse - payload: %s", responsePayload)
 287         msg := models.NewRmrMessage(rmrCgo.RIC_E2_SETUP_FAILURE, ranName, responsePayload, req.TransactionId, req.GetMsgSrc())
 288         h.logger.Infof("#E2SetupRequestNotificationHandler.handleUnsuccessfulResponse - RAN name: %s - RIC_E2_SETUP_RESP message has been built successfully. Message: %x", ranName, msg)
 289         _ = h.rmrSender.WhSend(msg)
 290
 291 }
 292
 293 func (h *E2SetupRequestNotificationHandler) handleSuccessfulResponse(ranName string, req *models.NotificationRequest, setupRequest *models.E2SetupRequestMessage) {
 294
 295         plmnId := buildPlmnId(h.config.GlobalRicId.Mcc, h.config.GlobalRicId.Mnc)
 296
 297         ricNearRtId, err := convertTo20BitString(h.config.GlobalRicId.RicId)
 298         if err != nil {
 299                 return
 300         }
 301         successResponse := models.NewE2SetupSuccessResponseMessage(plmnId, ricNearRtId, setupRequest)
 302         h.logger.Debugf("#E2SetupRequestNotificationHandler.handleSuccessfulResponse - E2_SETUP_RESPONSE has been built successfully %+v", successResponse)
 303
 304         responsePayload, err := xml.Marshal(&successResponse.E2APPDU)
 305         if err != nil {
 306                 h.logger.Warnf("#E2SetupRequestNotificationHandler.handleSuccessfulResponse - RAN name: %s - Error marshalling RIC_E2_SETUP_RESP. Payload: %s", ranName, responsePayload)
 307         }
 308
 309         responsePayload = utils.ReplaceEmptyTagsWithSelfClosing(responsePayload, emptyTagsToReplaceToSelfClosingTags)
 310
 311         h.logger.Infof("#E2SetupRequestNotificationHandler.handleSuccessfulResponse - payload: %s", responsePayload)
 312
 313         msg := models.NewRmrMessage(rmrCgo.RIC_E2_SETUP_RESP, ranName, responsePayload, req.TransactionId, req.GetMsgSrc())
 314         h.logger.Infof("#E2SetupRequestNotificationHandler.handleSuccessfulResponse - RAN name: %s - RIC_E2_SETUP_RESP message has been built successfully. Message: %x", ranName, msg)
 315         _ = h.rmrSender.Send(msg)
 316 }
 317
 318 func buildPlmnId(mmc string, mnc string) string {
 319         var b strings.Builder
 320
 321         b.WriteByte(mmc[1])
 322         b.WriteByte(mmc[0])
 323         if len(mnc) == 2 {
 324                 b.WriteString("F")
 325         } else {
 326                 b.WriteByte(mnc[2])
 327         }
 328         b.WriteByte(mmc[2])
 329         b.WriteByte(mnc[1])
 330         b.WriteByte(mnc[0])
 331
 332         return b.String()
 333 }
 334
 335 func convertTo20BitString(ricNearRtId string) (string, error) {
 336         r, err := strconv.ParseUint(ricNearRtId, 16, 32)
 337         if err != nil {
 338                 return "", err
 339         }
 340         return fmt.Sprintf("%020b", r)[:20], nil
 341 }
 342
 343 func (h *E2SetupRequestNotificationHandler) parseSetupRequest(payload []byte) (*models.E2SetupRequestMessage, string, error) {
 344
 345         pipInd := bytes.IndexByte(payload, '|')
 346         if pipInd < 0 {
 347                 return nil, "", errors.New("#E2SetupRequestNotificationHandler.parseSetupRequest - Error parsing E2 Setup Request failed extract Payload: no | separator found")
 348         }
 349
 350         e2tIpAddress := string(payload[:pipInd])
 351         if len(e2tIpAddress) == 0 {
 352                 return nil, "", errors.New("#E2SetupRequestNotificationHandler.parseSetupRequest - Empty E2T Address received")
 353         }
 354
 355         h.logger.Infof("#E2SetupRequestNotificationHandler.parseSetupRequest - payload: %s", payload[pipInd+1:])
 356
 357         setupRequest := &models.E2SetupRequestMessage{}
 358         err := xml.Unmarshal(utils.NormalizeXml(payload[pipInd+1:]), &setupRequest.E2APPDU)
 359         if err != nil {
 360                 return nil, "", errors.New(fmt.Sprintf("#E2SetupRequestNotificationHandler.parseSetupRequest - Error unmarshalling E2 Setup Request payload: %x", payload))
 361         }
 362
 363         return setupRequest, e2tIpAddress, nil
 364 }
 365
 366 func (h *E2SetupRequestNotificationHandler) buildNodebInfo(ranName string, e2tAddress string, request *models.E2SetupRequestMessage) (*entities.NodebInfo, error) {
 367         nodebInfo := &entities.NodebInfo{
 368                 AssociatedE2TInstanceAddress: e2tAddress,
 369                 RanName:                      ranName,
 370                 GlobalNbId:                   h.buildGlobalNbId(request),
 371                 SetupFromNetwork:             true,
 372         }
 373         err := h.setNodeTypeAndConfiguration(nodebInfo)
 374         if err != nil {
 375                 return nil, err
 376         }
 377
 378         e2NodeConfig := request.ExtractE2NodeConfigList()
 379         if e2NodeConfig == nil {
 380                 return nil, errors.New("Empty E2nodeComponentConfigAddition-List")
 381         }
 382
 383         if nodebInfo.NodeType == entities.Node_ENB {
 384                 if len(e2NodeConfig) == 0 && len(nodebInfo.GetEnb().GetNodeConfigs()) == 0 {
 385                         return nil, errors.New("Empty E2nodeComponentConfigAddition-List")
 386                 }
 387                 nodebInfo.GetEnb().NodeConfigs = e2NodeConfig
 388
 389                 return nodebInfo, nil
 390         }
 391
 392         if len(e2NodeConfig) == 0 && len(nodebInfo.GetGnb().GetNodeConfigs()) == 0 {
 393                 return nil, errors.New("Empty E2nodeComponentConfigAddition-List")
 394         }
 395         nodebInfo.GetGnb().NodeConfigs = e2NodeConfig
 396
 397         if nodebInfo.NodeType == entities.Node_GNB {
 398                 h.logger.Debugf("#E2SetupRequestNotificationHandler buildNodebInfo - entities.Node_GNB %d", entities.Node_GNB)
 399
 400                 gnbNodetype := h.setGnbNodeType(request)
 401                 h.logger.Debugf("#E2SetupRequestNotificationHandler buildNodebInfo -gnbNodetype %s", gnbNodetype)
 402                 nodebInfo.GnbNodeType = gnbNodetype
 403                 nodebInfo.CuUpId = request.GetCuupId()
 404                 nodebInfo.DuId = request.GetDuId()
 405                 h.logger.Debugf("#E2SetupRequestNotificationHandler buildNodebInfo -cuupid%s", request.GetCuupId())
 406                 h.logger.Debugf("#E2SetupRequestNotificationHandler buildNodebInfo -duid %s", request.GetDuId())
 407         }
 408
 409         ranFuncs := request.ExtractRanFunctionsList()
 410
 411         if ranFuncs != nil {
 412                 nodebInfo.GetGnb().RanFunctions = ranFuncs
 413         }
 414
 415         return nodebInfo, nil
 416 }
 417
 418
 419 func (h *E2SetupRequestNotificationHandler) setGnbNodeType(setupRequest *models.E2SetupRequestMessage) string {
 420         gnbNodetype := "gNB"
 421           /*Note: Deployment where CU-UP and DU are combined
 422           (but do not include the CP-CP) and have a single E2 connection
 423            is not supported. The combination of CU-CP, CU-UP, and DU will be
 424            treated as a single gNB and expect it to have only the
 425            global gNB ID in its E2 Setup ID*/
 426         if setupRequest.GetCuupId() != "" && setupRequest.GetDuId() != "" {
 427                 gnbNodetype = "gNB"
 428         } else if setupRequest.GetCuupId() != "" {
 429                 gnbNodetype = "gNB_CU_UP"
 430         } else if setupRequest.GetDuId() != "" {
 431                 gnbNodetype = "gNB_DU"
 432         }
 433         return gnbNodetype
 434 }
 435
 436 func (h *E2SetupRequestNotificationHandler) setNodeTypeAndConfiguration(nodebInfo *entities.NodebInfo) error {
 437         for k, v := range gnbTypesMap {
 438                 if strings.HasPrefix(nodebInfo.RanName, k) {
 439                         nodebInfo.NodeType = entities.Node_GNB
 440                         nodebInfo.Configuration = &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{GnbType: v}}
 441                         return nil
 442                 }
 443         }
 444         for k, v := range enbTypesMap {
 445                 if strings.HasPrefix(nodebInfo.RanName, k) {
 446                         nodebInfo.NodeType = entities.Node_ENB
 447                         nodebInfo.Configuration = &entities.NodebInfo_Enb{Enb: &entities.Enb{EnbType: v}}
 448                         return nil
 449                 }
 450         }
 451
 452         return e2managererrors.NewUnknownSetupRequestRanNameError(nodebInfo.RanName)
 453 }
 454
 455 func (h *E2SetupRequestNotificationHandler) buildGlobalNbId(setupRequest *models.E2SetupRequestMessage) *entities.GlobalNbId {
 456         return &entities.GlobalNbId{
 457                 PlmnId: setupRequest.GetPlmnId(),
 458                 NbId:   setupRequest.GetNbId(),
 459         }
 460 }
 461
 462 func (h *E2SetupRequestNotificationHandler) buildNbIdentity(ranName string, setupRequest *models.E2SetupRequestMessage) *entities.NbIdentity {
 463         return &entities.NbIdentity{
 464                 InventoryName: ranName,
 465                 GlobalNbId:    h.buildGlobalNbId(setupRequest),
 466         }
 467 }
 468
 469 func (h *E2SetupRequestNotificationHandler) fillCauseAndSendUnsuccessfulResponse(nodebInfo *entities.NodebInfo, request *models.NotificationRequest, setupRequest *models.E2SetupRequestMessage) {
 470         ranName := request.RanName
 471         if nodebInfo.GetConnectionStatus() == entities.ConnectionStatus_DISCONNECTED {
 472                 cause := models.Cause{Misc: &models.CauseMisc{ControlProcessingOverload: &struct{}{}}}
 473                 h.handleUnsuccessfulResponse(nodebInfo.RanName, request, cause, setupRequest)
 474                 models.UpdateProcedureType(ranName, models.E2SetupProcedureFailure)
 475         }
 476 }