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