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         h.logger.Infof("#E2SetupRequestNotificationHandler.Handle - RAN name: %s - received E2_SETUP_REQUEST. Payload: %x", ranName, request.Payload)
  94
  95         generalConfiguration, err := h.rNibDataService.GetGeneralConfiguration()
  96
  97         if err != nil {
  98                 h.logger.Errorf("#E2SetupRequestNotificationHandler.Handle - Failed retrieving e2m general configuration - quitting e2 setup flow. error: %s", err)
  99                 return
 100         }
 101
 102         setupRequest, e2tIpAddress, err := h.parseSetupRequest(request.Payload)
 103         if err != nil {
 104                 h.logger.Errorf(err.Error())
 105                 return
 106         }
 107
 108         h.logger.Infof("#E2SetupRequestNotificationHandler.Handle - E2T Address: %s - handling E2_SETUP_REQUEST", e2tIpAddress)
 109         h.logger.Debugf("#E2SetupRequestNotificationHandler.Handle - E2_SETUP_REQUEST has been parsed successfully %+v", setupRequest)
 110
 111         h.logger.Infof("#E2SetupRequestNotificationHandler.Handle - got general configuration from rnib - enableRic: %t", generalConfiguration.EnableRic)
 112
 113         if !generalConfiguration.EnableRic {
 114                 cause := models.Cause{Misc: &models.CauseMisc{OmIntervention: &struct{}{}}}
 115                 h.handleUnsuccessfulResponse(ranName, request, cause, setupRequest)
 116                 return
 117         }
 118
 119         _, err = h.e2tInstancesManager.GetE2TInstance(e2tIpAddress)
 120
 121         if err != nil {
 122                 h.logger.Errorf("#E2TermInitNotificationHandler.Handle - Failed retrieving E2TInstance. error: %s", err)
 123                 return
 124         }
 125
 126         nodebInfo, err := h.rNibDataService.GetNodeb(ranName)
 127
 128         var functionsModified bool
 129
 130         if err != nil {
 131
 132                 if _, ok := err.(*common.ResourceNotFoundError); !ok {
 133                         h.logger.Errorf("#E2SetupRequestNotificationHandler.Handle - RAN name: %s - failed to retrieve nodebInfo entity. Error: %s", ranName, err)
 134                         return
 135                 }
 136
 137                 if nodebInfo, err = h.handleNewRan(ranName, e2tIpAddress, setupRequest); err != nil {
 138                         if _, ok := err.(*e2managererrors.UnknownSetupRequestRanNameError); ok {
 139                                 cause := models.Cause{RicRequest: &models.CauseRic{RequestIdUnknown: &struct{}{}}}
 140                                 h.handleUnsuccessfulResponse(ranName, request, cause, setupRequest)
 141                         }
 142                         return
 143                 }
 144
 145         } else {
 146
 147                 functionsModified, err = h.handleExistingRan(ranName, nodebInfo, setupRequest)
 148
 149                 if err != nil {
 150                         h.fillCauseAndSendUnsuccessfulResponse(nodebInfo, request, setupRequest)
 151                         return
 152                 }
 153         }
 154
 155         ranStatusChangePublished, err := h.e2tAssociationManager.AssociateRan(e2tIpAddress, nodebInfo)
 156
 157         if err != nil {
 158
 159                 h.logger.Errorf("#E2SetupRequestNotificationHandler.Handle - RAN name: %s - failed to associate E2T to nodeB entity. Error: %s", ranName, err)
 160                 if _, ok := err.(*e2managererrors.RoutingManagerError); ok {
 161
 162                         if err = h.handleUpdateAndPublishNodebInfo(functionsModified, ranStatusChangePublished, nodebInfo); err != nil {
 163                                 return
 164                         }
 165
 166                         cause := models.Cause{Transport: &models.CauseTransport{TransportResourceUnavailable: &struct{}{}}}
 167                         h.handleUnsuccessfulResponse(nodebInfo.RanName, request, cause, setupRequest)
 168                 }
 169                 return
 170         }
 171
 172         if err = h.handleUpdateAndPublishNodebInfo(functionsModified, ranStatusChangePublished, nodebInfo); err != nil {
 173                 return
 174         }
 175
 176         h.handleSuccessfulResponse(ranName, request, setupRequest)
 177 }
 178
 179 func (h *E2SetupRequestNotificationHandler) handleUpdateAndPublishNodebInfo(functionsModified bool, ranStatusChangePublished bool, nodebInfo *entities.NodebInfo) error {
 180
 181         if ranStatusChangePublished || !functionsModified {
 182                 return nil
 183         }
 184
 185         err := h.rNibDataService.UpdateNodebInfoAndPublish(nodebInfo)
 186
 187         if err != nil {
 188                 h.logger.Errorf("#E2SetupRequestNotificationHandler.handleUpdateAndPublishNodebInfo - RAN name: %s - Failed at UpdateNodebInfoAndPublish. error: %s", nodebInfo.RanName, err)
 189                 return err
 190         }
 191
 192         h.logger.Infof("#E2SetupRequestNotificationHandler.handleUpdateAndPublishNodebInfo - RAN name: %s - Successfully executed UpdateNodebInfoAndPublish", nodebInfo.RanName)
 193         return nil
 194
 195 }
 196
 197 func (h *E2SetupRequestNotificationHandler) handleNewRan(ranName string, e2tIpAddress string, setupRequest *models.E2SetupRequestMessage) (*entities.NodebInfo, error) {
 198
 199         nodebInfo, err := h.buildNodebInfo(ranName, e2tIpAddress, setupRequest)
 200         if err != nil {
 201                 h.logger.Errorf("#E2SetupRequestNotificationHandler.handleNewRan - RAN name: %s - failed building nodebInfo. Error: %s", ranName, err)
 202                 return nil, err
 203         }
 204
 205         err = h.rNibDataService.SaveNodeb(nodebInfo)
 206         if err != nil {
 207                 h.logger.Errorf("#E2SetupRequestNotificationHandler.handleNewRan - RAN name: %s - failed saving nodebInfo. Error: %s", ranName, err)
 208                 return nil, err
 209         }
 210
 211         nbIdentity := h.buildNbIdentity(ranName, setupRequest)
 212
 213         err = h.ranListManager.AddNbIdentity(nodebInfo.GetNodeType(), nbIdentity)
 214
 215         if err != nil {
 216                 return nil, err
 217         }
 218
 219         return nodebInfo, nil
 220 }
 221
 222 func (h *E2SetupRequestNotificationHandler) handleExistingRan(ranName string, nodebInfo *entities.NodebInfo, setupRequest *models.E2SetupRequestMessage) (bool, error) {
 223         if nodebInfo.GetConnectionStatus() == entities.ConnectionStatus_DISCONNECTED {
 224                 delta_in_nano := uint64(time.Now().UnixNano()) - nodebInfo.StatusUpdateTimeStamp
 225                 //The duration from last Disconnection for which a new request is to be rejected (currently 10 sec)
 226                 if delta_in_nano < cleanUpDurationNanoSec {
 227                         h.logger.Errorf("#E2SetupRequestNotificationHandler.Handle - RAN name: %s, connection status: %s - nodeB entity disconnection in progress", ranName, nodebInfo.ConnectionStatus)
 228                         return false, errors.New("nodeB entity disconnection in progress")
 229                 }
 230                 h.logger.Infof("#E2SetupRequestNotificationHandler.Handle - RAN name: %s, connection status: %s - nodeB entity in disconnected state", ranName, nodebInfo.ConnectionStatus)
 231         } else if nodebInfo.GetConnectionStatus() == entities.ConnectionStatus_SHUTTING_DOWN {
 232                 h.logger.Errorf("#E2SetupRequestNotificationHandler.Handle - RAN name: %s, connection status: %s - nodeB entity in incorrect state", ranName, nodebInfo.ConnectionStatus)
 233                 return false, errors.New("nodeB entity in incorrect state")
 234         }
 235
 236         nodebInfo.SetupFromNetwork = true
 237
 238         e2NodeConfig := setupRequest.ExtractE2NodeConfigList()
 239         if e2NodeConfig == nil {
 240                 return false, errors.New("Empty E2nodeComponentConfigAddition-List")
 241         }
 242
 243         if nodebInfo.NodeType == entities.Node_ENB {
 244                 if len(e2NodeConfig) == 0 && len(nodebInfo.GetEnb().GetNodeConfigs()) == 0 {
 245                         return false, errors.New("Empty E2nodeComponentConfigAddition-List")
 246                 }
 247                 nodebInfo.GetEnb().NodeConfigs = e2NodeConfig
 248
 249                 return false, nil
 250         }
 251
 252         if len(e2NodeConfig) == 0 && len(nodebInfo.GetGnb().GetNodeConfigs()) == 0 {
 253                 return false, errors.New("Empty E2nodeComponentConfigAddition-List")
 254         }
 255         nodebInfo.GetGnb().NodeConfigs = e2NodeConfig
 256
 257         setupMessageRanFuncs := setupRequest.ExtractRanFunctionsList()
 258
 259         if setupMessageRanFuncs == nil || (len(setupMessageRanFuncs) == 0 && len(nodebInfo.GetGnb().RanFunctions) == 0) {
 260                 return false, nil
 261         }
 262
 263         nodebInfo.GetGnb().RanFunctions = setupMessageRanFuncs
 264         return true, nil
 265 }
 266
 267 func (h *E2SetupRequestNotificationHandler) handleUnsuccessfulResponse(ranName string, req *models.NotificationRequest, cause models.Cause, setupRequest *models.E2SetupRequestMessage) {
 268         failureResponse := models.NewE2SetupFailureResponseMessage(models.TimeToWaitEnum.V60s, cause, setupRequest)
 269         h.logger.Debugf("#E2SetupRequestNotificationHandler.handleUnsuccessfulResponse - E2_SETUP_RESPONSE has been built successfully %+v", failureResponse)
 270
 271         responsePayload, err := xml.Marshal(&failureResponse.E2APPDU)
 272         if err != nil {
 273                 h.logger.Warnf("#E2SetupRequestNotificationHandler.handleUnsuccessfulResponse - RAN name: %s - Error marshalling RIC_E2_SETUP_RESP. Payload: %s", ranName, responsePayload)
 274         }
 275
 276         responsePayload = utils.ReplaceEmptyTagsWithSelfClosing(responsePayload, emptyTagsToReplaceToSelfClosingTags)
 277
 278         h.logger.Infof("#E2SetupRequestNotificationHandler.handleUnsuccessfulResponse - payload: %s", responsePayload)
 279         msg := models.NewRmrMessage(rmrCgo.RIC_E2_SETUP_FAILURE, ranName, responsePayload, req.TransactionId, req.GetMsgSrc())
 280         h.logger.Infof("#E2SetupRequestNotificationHandler.handleUnsuccessfulResponse - RAN name: %s - RIC_E2_SETUP_RESP message has been built successfully. Message: %x", ranName, msg)
 281         _ = h.rmrSender.WhSend(msg)
 282
 283 }
 284
 285 func (h *E2SetupRequestNotificationHandler) handleSuccessfulResponse(ranName string, req *models.NotificationRequest, setupRequest *models.E2SetupRequestMessage) {
 286
 287         plmnId := buildPlmnId(h.config.GlobalRicId.Mcc, h.config.GlobalRicId.Mnc)
 288
 289         ricNearRtId, err := convertTo20BitString(h.config.GlobalRicId.RicId)
 290         if err != nil {
 291                 return
 292         }
 293         successResponse := models.NewE2SetupSuccessResponseMessage(plmnId, ricNearRtId, setupRequest)
 294         h.logger.Debugf("#E2SetupRequestNotificationHandler.handleSuccessfulResponse - E2_SETUP_RESPONSE has been built successfully %+v", successResponse)
 295
 296         responsePayload, err := xml.Marshal(&successResponse.E2APPDU)
 297         if err != nil {
 298                 h.logger.Warnf("#E2SetupRequestNotificationHandler.handleSuccessfulResponse - RAN name: %s - Error marshalling RIC_E2_SETUP_RESP. Payload: %s", ranName, responsePayload)
 299         }
 300
 301         responsePayload = utils.ReplaceEmptyTagsWithSelfClosing(responsePayload, emptyTagsToReplaceToSelfClosingTags)
 302
 303         h.logger.Infof("#E2SetupRequestNotificationHandler.handleSuccessfulResponse - payload: %s", responsePayload)
 304
 305         msg := models.NewRmrMessage(rmrCgo.RIC_E2_SETUP_RESP, ranName, responsePayload, req.TransactionId, req.GetMsgSrc())
 306         h.logger.Infof("#E2SetupRequestNotificationHandler.handleSuccessfulResponse - RAN name: %s - RIC_E2_SETUP_RESP message has been built successfully. Message: %x", ranName, msg)
 307         _ = h.rmrSender.Send(msg)
 308 }
 309
 310 func buildPlmnId(mmc string, mnc string) string {
 311         var b strings.Builder
 312
 313         b.WriteByte(mmc[1])
 314         b.WriteByte(mmc[0])
 315         if len(mnc) == 2 {
 316                 b.WriteString("F")
 317         } else {
 318                 b.WriteByte(mnc[2])
 319         }
 320         b.WriteByte(mmc[2])
 321         b.WriteByte(mnc[1])
 322         b.WriteByte(mnc[0])
 323
 324         return b.String()
 325 }
 326
 327 func convertTo20BitString(ricNearRtId string) (string, error) {
 328         r, err := strconv.ParseUint(ricNearRtId, 16, 32)
 329         if err != nil {
 330                 return "", err
 331         }
 332         return fmt.Sprintf("%020b", r)[:20], nil
 333 }
 334
 335 func (h *E2SetupRequestNotificationHandler) parseSetupRequest(payload []byte) (*models.E2SetupRequestMessage, string, error) {
 336
 337         pipInd := bytes.IndexByte(payload, '|')
 338         if pipInd < 0 {
 339                 return nil, "", errors.New("#E2SetupRequestNotificationHandler.parseSetupRequest - Error parsing E2 Setup Request failed extract Payload: no | separator found")
 340         }
 341
 342         e2tIpAddress := string(payload[:pipInd])
 343         if len(e2tIpAddress) == 0 {
 344                 return nil, "", errors.New("#E2SetupRequestNotificationHandler.parseSetupRequest - Empty E2T Address received")
 345         }
 346
 347         h.logger.Infof("#E2SetupRequestNotificationHandler.parseSetupRequest - payload: %s", payload[pipInd+1:])
 348
 349         setupRequest := &models.E2SetupRequestMessage{}
 350         err := xml.Unmarshal(utils.NormalizeXml(payload[pipInd+1:]), &setupRequest.E2APPDU)
 351         if err != nil {
 352                 return nil, "", errors.New(fmt.Sprintf("#E2SetupRequestNotificationHandler.parseSetupRequest - Error unmarshalling E2 Setup Request payload: %x", payload))
 353         }
 354
 355         return setupRequest, e2tIpAddress, nil
 356 }
 357
 358 func (h *E2SetupRequestNotificationHandler) buildNodebInfo(ranName string, e2tAddress string, request *models.E2SetupRequestMessage) (*entities.NodebInfo, error) {
 359         nodebInfo := &entities.NodebInfo{
 360                 AssociatedE2TInstanceAddress: e2tAddress,
 361                 RanName:                      ranName,
 362                 GlobalNbId:                   h.buildGlobalNbId(request),
 363                 SetupFromNetwork:             true,
 364         }
 365         err := h.setNodeTypeAndConfiguration(nodebInfo)
 366         if err != nil {
 367                 return nil, err
 368         }
 369
 370         e2NodeConfig := request.ExtractE2NodeConfigList()
 371         if e2NodeConfig == nil {
 372                 return nil, errors.New("Empty E2nodeComponentConfigAddition-List")
 373         }
 374
 375         if nodebInfo.NodeType == entities.Node_ENB {
 376                 if len(e2NodeConfig) == 0 && len(nodebInfo.GetEnb().GetNodeConfigs()) == 0 {
 377                         return nil, errors.New("Empty E2nodeComponentConfigAddition-List")
 378                 }
 379                 nodebInfo.GetEnb().NodeConfigs = e2NodeConfig
 380
 381                 return nodebInfo, nil
 382         }
 383
 384         if len(e2NodeConfig) == 0 && len(nodebInfo.GetGnb().GetNodeConfigs()) == 0 {
 385                 return nil, errors.New("Empty E2nodeComponentConfigAddition-List")
 386         }
 387         nodebInfo.GetGnb().NodeConfigs = e2NodeConfig
 388
 389         if nodebInfo.NodeType == entities.Node_GNB {
 390                 h.logger.Debugf("#E2SetupRequestNotificationHandler buildNodebInfo - entities.Node_GNB %d", entities.Node_GNB)
 391
 392                 gnbNodetype := h.setGnbNodeType(request)
 393                 h.logger.Debugf("#E2SetupRequestNotificationHandler buildNodebInfo -gnbNodetype %s", gnbNodetype)
 394                 nodebInfo.GnbNodeType = gnbNodetype
 395                 nodebInfo.CuUpId = request.GetCuupId()
 396                 nodebInfo.DuId = request.GetDuId()
 397                 h.logger.Debugf("#E2SetupRequestNotificationHandler buildNodebInfo -cuupid%s", request.GetCuupId())
 398                 h.logger.Debugf("#E2SetupRequestNotificationHandler buildNodebInfo -duid %s", request.GetDuId())
 399         }
 400
 401         ranFuncs := request.ExtractRanFunctionsList()
 402
 403         if ranFuncs != nil {
 404                 nodebInfo.GetGnb().RanFunctions = ranFuncs
 405         }
 406
 407         return nodebInfo, nil
 408 }
 409
 410
 411 func (h *E2SetupRequestNotificationHandler) setGnbNodeType(setupRequest *models.E2SetupRequestMessage) string {
 412         gnbNodetype := "gNB"
 413           /*Note: Deployment where CU-UP and DU are combined
 414           (but do not include the CP-CP) and have a single E2 connection
 415            is not supported. The combination of CU-CP, CU-UP, and DU will be
 416            treated as a single gNB and expect it to have only the
 417            global gNB ID in its E2 Setup ID*/
 418         if setupRequest.GetCuupId() != "" && setupRequest.GetDuId() != "" {
 419                 gnbNodetype = "gNB"
 420         } else if setupRequest.GetCuupId() != "" {
 421                 gnbNodetype = "gNB_CU_UP"
 422         } else if setupRequest.GetDuId() != "" {
 423                 gnbNodetype = "gNB_DU"
 424         }
 425         return gnbNodetype
 426 }
 427
 428 func (h *E2SetupRequestNotificationHandler) setNodeTypeAndConfiguration(nodebInfo *entities.NodebInfo) error {
 429         for k, v := range gnbTypesMap {
 430                 if strings.HasPrefix(nodebInfo.RanName, k) {
 431                         nodebInfo.NodeType = entities.Node_GNB
 432                         nodebInfo.Configuration = &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{GnbType: v}}
 433                         return nil
 434                 }
 435         }
 436         for k, v := range enbTypesMap {
 437                 if strings.HasPrefix(nodebInfo.RanName, k) {
 438                         nodebInfo.NodeType = entities.Node_ENB
 439                         nodebInfo.Configuration = &entities.NodebInfo_Enb{Enb: &entities.Enb{EnbType: v}}
 440                         return nil
 441                 }
 442         }
 443
 444         return e2managererrors.NewUnknownSetupRequestRanNameError(nodebInfo.RanName)
 445 }
 446
 447 func (h *E2SetupRequestNotificationHandler) buildGlobalNbId(setupRequest *models.E2SetupRequestMessage) *entities.GlobalNbId {
 448         return &entities.GlobalNbId{
 449                 PlmnId: setupRequest.GetPlmnId(),
 450                 NbId:   setupRequest.GetNbId(),
 451         }
 452 }
 453
 454 func (h *E2SetupRequestNotificationHandler) buildNbIdentity(ranName string, setupRequest *models.E2SetupRequestMessage) *entities.NbIdentity {
 455         return &entities.NbIdentity{
 456                 InventoryName: ranName,
 457                 GlobalNbId:    h.buildGlobalNbId(setupRequest),
 458         }
 459 }
 460
 461 func (h *E2SetupRequestNotificationHandler) fillCauseAndSendUnsuccessfulResponse(nodebInfo *entities.NodebInfo, request *models.NotificationRequest, setupRequest *models.E2SetupRequestMessage) {
 462         if nodebInfo.GetConnectionStatus() == entities.ConnectionStatus_DISCONNECTED {
 463                 cause := models.Cause{Misc: &models.CauseMisc{ControlProcessingOverload: &struct{}{}}}
 464                 h.handleUnsuccessfulResponse(nodebInfo.RanName, request, cause, setupRequest)
 465         }
 466 }