E2Manager/handlers/httpmsghandlers/delete_all_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 "C"
  23 import (
  24         "e2mgr/clients"
  25         "e2mgr/configuration"
  26         "e2mgr/e2managererrors"
  27         "e2mgr/logger"
  28         "e2mgr/managers"
  29         "e2mgr/models"
  30         "e2mgr/rmrCgo"
  31         "e2mgr/services"
  32         "e2mgr/services/rmrsender"
  33         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  34         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  35         "time"
  36 )
  37
  38 type DeleteAllRequestHandler struct {
  39         rnibDataService               services.RNibDataService
  40         rmrSender                     *rmrsender.RmrSender
  41         config                        *configuration.Configuration
  42         logger                        *logger.Logger
  43         e2tInstancesManager           managers.IE2TInstancesManager
  44         rmClient                      clients.IRoutingManagerClient
  45         ranConnectStatusChangeManager managers.IRanConnectStatusChangeManager
  46         ranListManager                managers.RanListManager
  47 }
  48
  49 const PartialSuccessDueToRmErrorMessage = "Operation succeeded except for routing manager outbound call"
  50
  51 func NewDeleteAllRequestHandler(logger *logger.Logger, rmrSender *rmrsender.RmrSender, config *configuration.Configuration, rnibDataService services.RNibDataService, e2tInstancesManager managers.IE2TInstancesManager, rmClient clients.IRoutingManagerClient, ranConnectStatusChangeManager managers.IRanConnectStatusChangeManager, ranListManager managers.RanListManager) *DeleteAllRequestHandler {
  52         return &DeleteAllRequestHandler{
  53                 logger:                        logger,
  54                 rnibDataService:               rnibDataService,
  55                 rmrSender:                     rmrSender,
  56                 config:                        config,
  57                 e2tInstancesManager:           e2tInstancesManager,
  58                 rmClient:                      rmClient,
  59                 ranConnectStatusChangeManager: ranConnectStatusChangeManager,
  60                 ranListManager:                ranListManager,
  61         }
  62 }
  63
  64 func (h *DeleteAllRequestHandler) Handle(request models.Request) (models.IResponse, error) {
  65         h.logger.Infof("#DeleteAllRequestHandler.Handle - handling shutdown request")
  66
  67         e2tAddresses, err := h.e2tInstancesManager.GetE2TAddresses()
  68
  69         if err != nil {
  70                 return nil, err
  71         }
  72
  73         if len(e2tAddresses) == 0 {
  74                 err, _ = h.updateNodebs(h.updateNodebInfoForceShutdown)
  75                 return nil, err
  76         }
  77
  78         dissocErr := h.rmClient.DissociateAllRans(e2tAddresses)
  79
  80         if dissocErr != nil {
  81                 h.logger.Warnf("#DeleteAllRequestHandler.Handle - routing manager failure. continue flow.")
  82         }
  83
  84         err, updatedAtLeastOnce := h.updateNodebs(h.updateNodebInfoShuttingDown)
  85
  86         if err != nil {
  87                 return nil, err
  88         }
  89
  90         err = h.e2tInstancesManager.ClearRansOfAllE2TInstances()
  91
  92         if err != nil {
  93                 return nil, err
  94         }
  95
  96         rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
  97
  98         err = h.rmrSender.Send(&rmrMessage)
  99
 100         if err != nil {
 101                 h.logger.Errorf("#DeleteAllRequestHandler.Handle - failed to send sctp clear all message to RMR: %s", err)
 102                 return nil, e2managererrors.NewRmrError()
 103         }
 104
 105         if !updatedAtLeastOnce {
 106                 h.logger.Infof("#DeleteAllRequestHandler.Handle - DB wasn't updated, not activating timer")
 107
 108                 if dissocErr != nil {
 109                         return models.NewRedButtonPartialSuccessResponseModel(PartialSuccessDueToRmErrorMessage), nil
 110                 }
 111
 112                 return nil, nil
 113         }
 114
 115         time.Sleep(time.Duration(h.config.BigRedButtonTimeoutSec) * time.Second)
 116         h.logger.Infof("#DeleteAllRequestHandler.Handle - timer expired")
 117
 118         err, _ = h.updateNodebs(h.updateNodebInfoShutDown)
 119
 120         if err != nil {
 121                 return nil, err
 122         }
 123
 124         if dissocErr != nil {
 125                 return models.NewRedButtonPartialSuccessResponseModel(PartialSuccessDueToRmErrorMessage), nil
 126         }
 127
 128         return nil, nil
 129 }
 130
 131 func (h *DeleteAllRequestHandler) updateNodebs(updateCb func(node *entities.NodebInfo) (error, bool)) (error, bool) {
 132         nbIdentityList := h.ranListManager.GetNbIdentityList()
 133         updatedAtLeastOnce := false
 134
 135         for _, nbIdentity := range nbIdentityList {
 136                 node, err := h.rnibDataService.GetNodeb(nbIdentity.InventoryName)
 137
 138                 if err != nil {
 139                         _, ok := err.(*common.ResourceNotFoundError)
 140
 141                         if !ok {
 142                                 h.logger.Errorf("#DeleteAllRequestHandler.updateNodebs - failed to get nodeB entity for ran name: %s from rNib. error: %s", nbIdentity.InventoryName, err)
 143                                 return e2managererrors.NewRnibDbError(), false
 144                         }
 145                         continue
 146                 }
 147
 148                 err, updated := updateCb(node)
 149
 150                 if err != nil {
 151                         return err, false
 152                 }
 153
 154                 if updated {
 155                         updatedAtLeastOnce = true
 156                 }
 157         }
 158
 159         return nil, updatedAtLeastOnce
 160 }
 161
 162 func (h *DeleteAllRequestHandler) updateNodebInfoForceShutdown(node *entities.NodebInfo) (error, bool) {
 163         err := h.updateNodebInfo(node, entities.ConnectionStatus_SHUT_DOWN, true)
 164
 165         if err != nil {
 166                 return err, false
 167         }
 168
 169         return nil, true
 170 }
 171
 172 func (h *DeleteAllRequestHandler) updateNodebInfoShuttingDown(node *entities.NodebInfo) (error, bool) {
 173         if node.ConnectionStatus == entities.ConnectionStatus_SHUT_DOWN {
 174                 return nil, false
 175         }
 176
 177         err := h.updateNodebInfo(node, entities.ConnectionStatus_SHUTTING_DOWN, true)
 178
 179         if err != nil {
 180                 return err, false
 181         }
 182
 183         return nil, true
 184 }
 185
 186 func (h *DeleteAllRequestHandler) updateNodebInfoShutDown(node *entities.NodebInfo) (error, bool) {
 187         if node.ConnectionStatus == entities.ConnectionStatus_SHUT_DOWN {
 188                 return nil, false
 189         }
 190
 191         if node.ConnectionStatus != entities.ConnectionStatus_SHUTTING_DOWN {
 192                 h.logger.Warnf("#DeleteAllRequestHandler.updateNodebInfoShutDown - RAN name: %s - ignore, status is not Shutting Down", node.RanName)
 193                 return nil, false
 194         }
 195
 196         err := h.updateNodebInfo(node, entities.ConnectionStatus_SHUT_DOWN, false)
 197
 198         if err != nil {
 199                 return err, false
 200         }
 201
 202         return nil, true
 203 }
 204
 205 func (h *DeleteAllRequestHandler) updateNodebInfo(node *entities.NodebInfo, connectionStatus entities.ConnectionStatus, resetAssociatedE2TAddress bool) error {
 206
 207         _, err := h.ranConnectStatusChangeManager.ChangeStatus(node, connectionStatus)
 208         if err != nil {
 209                 return e2managererrors.NewRnibDbError()
 210         }
 211
 212         if resetAssociatedE2TAddress {
 213                 node.AssociatedE2TInstanceAddress = ""
 214
 215                 err = h.rnibDataService.UpdateNodebInfo(node)
 216                 if err != nil {
 217                         h.logger.Errorf("#DeleteAllRequestHandler.updateNodebInfo - RAN name: %s - failed updating nodeB entity in rNib. error: %s", node.RanName, err)
 218                         return e2managererrors.NewRnibDbError()
 219                 }
 220         }
 221         h.logger.Infof("#DeleteAllRequestHandler.updateNodebInfo - RAN name: %s, connection status: %s", node.RanName, connectionStatus)
 222         return nil
 223
 224 }