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/entities"
  34         "time"
  35 )
  36
  37 type DeleteAllRequestHandler struct {
  38         rnibDataService     services.RNibDataService
  39         rmrSender           *rmrsender.RmrSender
  40         config              *configuration.Configuration
  41         logger              *logger.Logger
  42         e2tInstancesManager managers.IE2TInstancesManager
  43         rmClient            clients.IRoutingManagerClient
  44 }
  45
  46 func NewDeleteAllRequestHandler(logger *logger.Logger, rmrSender *rmrsender.RmrSender, config *configuration.Configuration, rnibDataService services.RNibDataService, e2tInstancesManager managers.IE2TInstancesManager, rmClient clients.IRoutingManagerClient) *DeleteAllRequestHandler {
  47         return &DeleteAllRequestHandler{
  48                 logger:              logger,
  49                 rnibDataService:     rnibDataService,
  50                 rmrSender:           rmrSender,
  51                 config:              config,
  52                 e2tInstancesManager: e2tInstancesManager,
  53                 rmClient:            rmClient,
  54         }
  55 }
  56
  57 func (h *DeleteAllRequestHandler) Handle(request models.Request) (models.IResponse, error) {
  58
  59         e2tAddresses, err := h.e2tInstancesManager.GetE2TAddresses()
  60
  61         if err != nil {
  62                 return nil, err
  63         }
  64
  65         if len(e2tAddresses) == 0 {
  66                 err, _ = h.updateNodebs(h.updateNodebInfoForceShutdown)
  67                 return nil, err
  68         }
  69
  70         err = h.rmClient.DissociateAllRans(e2tAddresses)
  71
  72         if err != nil {
  73                 h.logger.Warnf("#DeleteAllRequestHandler.Handle - routing manager failure. continue flow.")
  74         }
  75
  76         err, allRansAreShutDown := h.updateNodebs(h.updateNodebInfoShuttingDown)
  77
  78         if err != nil {
  79                 return nil, err
  80         }
  81
  82         err = h.e2tInstancesManager.ClearRansOfAllE2TInstances()
  83
  84         if err != nil {
  85                 return nil, err
  86         }
  87
  88         rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
  89
  90         err = h.rmrSender.Send(&rmrMessage)
  91
  92         if err != nil {
  93                 h.logger.Errorf("#DeleteAllRequestHandler.Handle - failed to send sctp clear all message to RMR: %s", err)
  94                 return nil, e2managererrors.NewRmrError()
  95         }
  96
  97         if allRansAreShutDown {
  98                 return nil, nil
  99         }
 100
 101         time.Sleep(time.Duration(h.config.BigRedButtonTimeoutSec) * time.Second)
 102         h.logger.Infof("#DeleteAllRequestHandler.Handle - timer expired")
 103
 104         err, _ = h.updateNodebs(h.updateNodebInfoShutDown)
 105         return nil, err
 106 }
 107
 108 func (h *DeleteAllRequestHandler) updateNodebs(updateCb func(node *entities.NodebInfo) error) (error, bool) {
 109         nbIdentityList, err := h.rnibDataService.GetListNodebIds()
 110
 111         if err != nil {
 112                 h.logger.Errorf("#DeleteAllRequestHandler.updateNodebs - failed to get nodes list from rNib. Error: %s", err)
 113                 return e2managererrors.NewRnibDbError(), false
 114         }
 115
 116         allRansAreShutdown := true
 117
 118         for _, nbIdentity := range nbIdentityList {
 119                 node, err := h.rnibDataService.GetNodeb(nbIdentity.InventoryName)
 120
 121                 if err != nil {
 122                         h.logger.Errorf("#DeleteAllRequestHandler.updateNodebs - failed to get nodeB entity for ran name: %s from rNib. error: %s", nbIdentity.InventoryName, err)
 123                         continue
 124                 }
 125
 126                 if node.ConnectionStatus != entities.ConnectionStatus_SHUT_DOWN {
 127                         allRansAreShutdown = false
 128                 }
 129
 130                 _ = updateCb(node)
 131         }
 132
 133         return nil, allRansAreShutdown
 134
 135 }
 136
 137 func (h *DeleteAllRequestHandler) updateNodebInfoForceShutdown(node *entities.NodebInfo) error {
 138         return h.updateNodebInfo(node, entities.ConnectionStatus_SHUT_DOWN, true)
 139 }
 140
 141 func (h *DeleteAllRequestHandler) updateNodebInfoShuttingDown(node *entities.NodebInfo) error {
 142         if node.ConnectionStatus == entities.ConnectionStatus_SHUT_DOWN {
 143                 return nil
 144         }
 145
 146         return h.updateNodebInfo(node, entities.ConnectionStatus_SHUTTING_DOWN, true)
 147 }
 148
 149 func (h *DeleteAllRequestHandler) updateNodebInfoShutDown(node *entities.NodebInfo) error {
 150         if node.ConnectionStatus == entities.ConnectionStatus_SHUT_DOWN {
 151                 return nil
 152         }
 153
 154         if node.ConnectionStatus != entities.ConnectionStatus_SHUTTING_DOWN {
 155                 h.logger.Warnf("#DeleteAllRequestHandler.updateNodebInfoShutDown - RAN name: %s - ignore, status is not Shutting Down", node.RanName)
 156                 return nil
 157         }
 158
 159         return h.updateNodebInfo(node, entities.ConnectionStatus_SHUT_DOWN, false)
 160 }
 161
 162 func (h *DeleteAllRequestHandler) updateNodebInfo(node *entities.NodebInfo, connectionStatus entities.ConnectionStatus, resetAssociatedE2TAddress bool) error {
 163         node.ConnectionStatus = connectionStatus
 164
 165         if resetAssociatedE2TAddress {
 166                 node.AssociatedE2TInstanceAddress = ""
 167         }
 168
 169         err := h.rnibDataService.UpdateNodebInfo(node)
 170
 171         if err != nil {
 172                 h.logger.Errorf("#DeleteAllRequestHandler.updateNodebInfo - RAN name: %s - failed saving nodeB entity to rNib. error: %s", node.RanName, err)
 173                 return err
 174         }
 175
 176         h.logger.Infof("#DeleteAllRequestHandler.updateNodebInfo - RAN name: %s, connection status: %s", node.RanName, connectionStatus)
 177         return nil
 178
 179 }