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