E2Manager/services/rnib_data_service.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 services
  21
  22 import (
  23         "e2mgr/configuration"
  24         "e2mgr/logger"
  25         "e2mgr/rNibWriter"
  26         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  27         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  28         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader"
  29         "net"
  30         "time"
  31 )
  32
  33 type RNibDataService interface {
  34         SaveNodeb(nbIdentity *entities.NbIdentity, nb *entities.NodebInfo) error
  35         UpdateNodebInfo(nodebInfo *entities.NodebInfo) error
  36         SaveRanLoadInformation(inventoryName string, ranLoadInformation *entities.RanLoadInformation) error
  37         GetNodeb(ranName string) (*entities.NodebInfo, error)
  38         GetListNodebIds() ([]*entities.NbIdentity, error)
  39         PingRnib() bool
  40         GetE2TInstance(address string) (*entities.E2TInstance, error)
  41         GetE2TInstances(addresses []string) ([]*entities.E2TInstance, error)
  42         GetE2TAddresses() ([]string, error)
  43         SaveE2TInstance(e2tInstance *entities.E2TInstance) error
  44         SaveE2TAddresses(addresses []string) error
  45         GetE2TInstanceNoLogs(address string) (*entities.E2TInstance, error)
  46         GetE2TInstancesNoLogs(addresses []string) ([]*entities.E2TInstance, error)
  47         SaveE2TInstanceNoLogs(e2tInstance *entities.E2TInstance) error
  48         GetE2TAddressesNoLogs() ([]string, error)
  49         RemoveE2TInstance(e2tAddress string) error
  50         UpdateGnbCells(nodebInfo *entities.NodebInfo, servedNrCells []*entities.ServedNRCell) error
  51         RemoveServedNrCells(inventoryName string, servedNrCells []*entities.ServedNRCell) error
  52         GetGeneralConfiguration() (*entities.GeneralConfiguration, error)
  53         UpdateNodebInfoOnConnectionStatusInversion(nodebInfo *entities.NodebInfo, event string) error
  54         SaveGeneralConfiguration(config *entities.GeneralConfiguration) error
  55         RemoveEnb(nodebInfo *entities.NodebInfo) error
  56         RemoveServedCells(inventoryName string, servedCells []*entities.ServedCellInfo) error
  57         UpdateEnb(nodebInfo *entities.NodebInfo, servedCells []*entities.ServedCellInfo) error
  58 }
  59
  60 type rNibDataService struct {
  61         logger           *logger.Logger
  62         rnibReader       reader.RNibReader
  63         rnibWriter       rNibWriter.RNibWriter
  64         maxAttempts      int
  65         retryInterval    time.Duration
  66 }
  67
  68 func NewRnibDataService(logger *logger.Logger, config *configuration.Configuration, rnibReader reader.RNibReader, rnibWriter rNibWriter.RNibWriter) *rNibDataService {
  69         return &rNibDataService{
  70                 logger:           logger,
  71                 rnibReader:       rnibReader,
  72                 rnibWriter:       rnibWriter,
  73                 maxAttempts:      config.MaxRnibConnectionAttempts,
  74                 retryInterval:    time.Duration(config.RnibRetryIntervalMs) * time.Millisecond,
  75         }
  76 }
  77
  78 func (w *rNibDataService) RemoveServedNrCells(inventoryName string, servedNrCells []*entities.ServedNRCell) error {
  79         err := w.retry("RemoveServedNrCells", func() (err error) {
  80                 err = w.rnibWriter.RemoveServedNrCells(inventoryName, servedNrCells)
  81                 return
  82         })
  83
  84         return err
  85 }
  86
  87 func (w *rNibDataService) RemoveEnb(nodebInfo *entities.NodebInfo) error {
  88         w.logger.Infof("#RnibDataService.RemoveEnb - nodebInfo: %s", nodebInfo)
  89
  90         err := w.retry("RemoveEnb", func() (err error) {
  91                 err = w.rnibWriter.RemoveEnb(nodebInfo)
  92                 return
  93         })
  94
  95         return err
  96 }
  97
  98 func (w *rNibDataService) UpdateGnbCells(nodebInfo *entities.NodebInfo, servedNrCells []*entities.ServedNRCell) error {
  99         w.logger.Infof("#RnibDataService.UpdateGnbCells - nodebInfo: %s, servedNrCells: %s", nodebInfo, servedNrCells)
 100
 101         err := w.retry("UpdateGnbCells", func() (err error) {
 102                 err = w.rnibWriter.UpdateGnbCells(nodebInfo, servedNrCells)
 103                 return
 104         })
 105
 106         return err
 107 }
 108
 109 func (w *rNibDataService) UpdateNodebInfo(nodebInfo *entities.NodebInfo) error {
 110         w.logger.Infof("#RnibDataService.UpdateNodebInfo - nodebInfo: %s", nodebInfo)
 111
 112         err := w.retry("UpdateNodebInfo", func() (err error) {
 113                 err = w.rnibWriter.UpdateNodebInfo(nodebInfo)
 114                 return
 115         })
 116
 117         return err
 118 }
 119
 120 func (w *rNibDataService) SaveNodeb(nbIdentity *entities.NbIdentity, nb *entities.NodebInfo) error {
 121         w.logger.Infof("#RnibDataService.SaveNodeb - nbIdentity: %s, nodebInfo: %s", nbIdentity, nb)
 122
 123         err := w.retry("SaveNodeb", func() (err error) {
 124                 err = w.rnibWriter.SaveNodeb(nbIdentity, nb)
 125                 return
 126         })
 127
 128         return err
 129 }
 130
 131 func (w *rNibDataService) SaveRanLoadInformation(inventoryName string, ranLoadInformation *entities.RanLoadInformation) error {
 132         w.logger.Infof("#RnibDataService.SaveRanLoadInformation - inventoryName: %s, ranLoadInformation: %s", inventoryName, ranLoadInformation)
 133
 134         err := w.retry("SaveRanLoadInformation", func() (err error) {
 135                 err = w.rnibWriter.SaveRanLoadInformation(inventoryName, ranLoadInformation)
 136                 return
 137         })
 138
 139         return err
 140 }
 141
 142 func (w *rNibDataService) GetNodeb(ranName string) (*entities.NodebInfo, error) {
 143
 144         var nodeb *entities.NodebInfo = nil
 145
 146         err := w.retry("GetNodeb", func() (err error) {
 147                 nodeb, err = w.rnibReader.GetNodeb(ranName)
 148                 return
 149         })
 150
 151         if err == nil {
 152                 w.logger.Infof("#RnibDataService.GetNodeb - RAN name: %s, connection status: %s, associated E2T: %s", nodeb.RanName, nodeb.ConnectionStatus, nodeb.AssociatedE2TInstanceAddress)
 153         }
 154
 155         return nodeb, err
 156 }
 157
 158 func (w *rNibDataService) GetListNodebIds() ([]*entities.NbIdentity, error) {
 159         var nodeIds []*entities.NbIdentity = nil
 160
 161         err := w.retry("GetListNodebIds", func() (err error) {
 162                 nodeIds, err = w.rnibReader.GetListNodebIds()
 163                 return
 164         })
 165
 166         if err == nil {
 167                 w.logger.Infof("#RnibDataService.GetListNodebIds - RANs count: %d", len(nodeIds))
 168         }
 169
 170         return nodeIds, err
 171 }
 172
 173 func (w *rNibDataService) GetE2TInstance(address string) (*entities.E2TInstance, error) {
 174         var e2tInstance *entities.E2TInstance = nil
 175
 176         err := w.retry("GetE2TInstance", func() (err error) {
 177                 e2tInstance, err = w.rnibReader.GetE2TInstance(address)
 178                 return
 179         })
 180
 181         if err == nil {
 182                 w.logger.Infof("#RnibDataService.GetE2TInstance - E2T instance address: %s, state: %s, associated RANs count: %d, keep Alive ts: %d", e2tInstance.Address, e2tInstance.State, len(e2tInstance.AssociatedRanList), e2tInstance.KeepAliveTimestamp)
 183         }
 184
 185         return e2tInstance, err
 186 }
 187
 188 func (w *rNibDataService) GetE2TInstanceNoLogs(address string) (*entities.E2TInstance, error) {
 189         var e2tInstance *entities.E2TInstance = nil
 190
 191         err := w.retry("GetE2TInstance", func() (err error) {
 192                 e2tInstance, err = w.rnibReader.GetE2TInstance(address)
 193                 return
 194         })
 195
 196         return e2tInstance, err
 197 }
 198
 199 func (w *rNibDataService) GetE2TInstances(addresses []string) ([]*entities.E2TInstance, error) {
 200         w.logger.Infof("#RnibDataService.GetE2TInstances - addresses: %s", addresses)
 201         var e2tInstances []*entities.E2TInstance = nil
 202
 203         err := w.retry("GetE2TInstance", func() (err error) {
 204                 e2tInstances, err = w.rnibReader.GetE2TInstances(addresses)
 205                 return
 206         })
 207
 208         return e2tInstances, err
 209 }
 210
 211 func (w *rNibDataService) GetE2TInstancesNoLogs(addresses []string) ([]*entities.E2TInstance, error) {
 212
 213         var e2tInstances []*entities.E2TInstance = nil
 214
 215         err := w.retry("GetE2TInstance", func() (err error) {
 216                 e2tInstances, err = w.rnibReader.GetE2TInstances(addresses)
 217                 return
 218         })
 219
 220         return e2tInstances, err
 221 }
 222
 223 func (w *rNibDataService) GetE2TAddresses() ([]string, error) {
 224
 225         var e2tAddresses []string = nil
 226
 227         err := w.retry("GetE2TAddresses", func() (err error) {
 228                 e2tAddresses, err = w.rnibReader.GetE2TAddresses()
 229                 return
 230         })
 231
 232         if err == nil {
 233                 w.logger.Infof("#RnibDataService.GetE2TAddresses - addresses: %s", e2tAddresses)
 234         }
 235
 236         return e2tAddresses, err
 237 }
 238
 239 func (w *rNibDataService) GetE2TAddressesNoLogs() ([]string, error) {
 240
 241         var e2tAddresses []string = nil
 242
 243         err := w.retry("GetE2TAddresses", func() (err error) {
 244                 e2tAddresses, err = w.rnibReader.GetE2TAddresses()
 245                 return
 246         })
 247
 248         return e2tAddresses, err
 249 }
 250
 251 func (w *rNibDataService) SaveE2TInstance(e2tInstance *entities.E2TInstance) error {
 252         w.logger.Infof("#RnibDataService.SaveE2TInstance - E2T instance address: %s, podName: %s, state: %s, associated RANs count: %d, keep Alive ts: %d", e2tInstance.Address, e2tInstance.PodName, e2tInstance.State, len(e2tInstance.AssociatedRanList), e2tInstance.KeepAliveTimestamp)
 253
 254         return w.SaveE2TInstanceNoLogs(e2tInstance)
 255 }
 256
 257 func (w *rNibDataService) SaveE2TInstanceNoLogs(e2tInstance *entities.E2TInstance) error {
 258
 259         err := w.retry("SaveE2TInstance", func() (err error) {
 260                 err = w.rnibWriter.SaveE2TInstance(e2tInstance)
 261                 return
 262         })
 263
 264         return err
 265 }
 266
 267 func (w *rNibDataService) SaveE2TAddresses(addresses []string) error {
 268         w.logger.Infof("#RnibDataService.SaveE2TAddresses - addresses: %s", addresses)
 269
 270         err := w.retry("SaveE2TAddresses", func() (err error) {
 271                 err = w.rnibWriter.SaveE2TAddresses(addresses)
 272                 return
 273         })
 274
 275         return err
 276 }
 277
 278 func (w *rNibDataService) RemoveE2TInstance(e2tAddress string) error {
 279         w.logger.Infof("#RnibDataService.RemoveE2TInstance - e2tAddress: %s", e2tAddress)
 280
 281         err := w.retry("RemoveE2TInstance", func() (err error) {
 282                 err = w.rnibWriter.RemoveE2TInstance(e2tAddress)
 283                 return
 284         })
 285
 286         return err
 287 }
 288
 289 func (w *rNibDataService) GetGeneralConfiguration() (*entities.GeneralConfiguration, error) {
 290         var generalConfiguration *entities.GeneralConfiguration = nil
 291
 292         err := w.retry("GetGeneralConfiguration", func() (err error) {
 293                 generalConfiguration, err = w.rnibReader.GetGeneralConfiguration()
 294                 return
 295         })
 296
 297         return generalConfiguration, err
 298 }
 299
 300 func (w *rNibDataService) SaveGeneralConfiguration(config *entities.GeneralConfiguration) error {
 301         err := w.retry("SaveGeneralConfiguration", func() (err error) {
 302                 err = w.rnibWriter.SaveGeneralConfiguration(config)
 303                 return
 304         })
 305
 306         return err
 307 }
 308
 309 func (w *rNibDataService) RemoveServedCells(inventoryName string, servedCells []*entities.ServedCellInfo) error {
 310         err := w.retry("RemoveServedCells", func() (err error) {
 311                 err = w.rnibWriter.RemoveServedCells(inventoryName, servedCells)
 312                 return
 313         })
 314
 315         return err
 316 }
 317
 318 func (w *rNibDataService) UpdateEnb(nodebInfo *entities.NodebInfo, servedCells []*entities.ServedCellInfo) error {
 319         err := w.retry("UpdateEnb", func() (err error) {
 320                 err = w.rnibWriter.UpdateEnb(nodebInfo, servedCells)
 321                 return
 322         })
 323
 324         return err
 325 }
 326
 327 func (w *rNibDataService) PingRnib() bool {
 328         err := w.retry("GetListNodebIds", func() (err error) {
 329                 _, err = w.rnibReader.GetListNodebIds()
 330                 return
 331         })
 332
 333         return !isRnibConnectionError(err)
 334 }
 335
 336 func (w *rNibDataService) UpdateNodebInfoOnConnectionStatusInversion(nodebInfo *entities.NodebInfo, event string) error {
 337         w.logger.Infof("#RnibDataService.UpdateNodebInfoOnConnectionStatusInversion - event: %s, nodebInfo: %s", event, nodebInfo)
 338
 339         err := w.retry("UpdateNodebInfoOnConnectionStatusInversion", func() (err error) {
 340                 err = w.rnibWriter.UpdateNodebInfoOnConnectionStatusInversion(nodebInfo, event)
 341                 return
 342         })
 343
 344         return err
 345 }
 346
 347 func (w *rNibDataService) retry(rnibFunc string, f func() error) (err error) {
 348         attempts := w.maxAttempts
 349
 350         for i := 1; ; i++ {
 351                 err = f()
 352                 if err == nil {
 353                         return
 354                 }
 355                 if !isRnibConnectionError(err) {
 356                         return err
 357                 }
 358                 if i >= attempts {
 359                         w.logger.Errorf("#RnibDataService.retry - after %d attempts of %s, last error: %s", attempts, rnibFunc, err)
 360                         return err
 361                 }
 362                 time.Sleep(w.retryInterval)
 363
 364                 w.logger.Infof("#RnibDataService.retry - retrying %d %s after error: %s", i, rnibFunc, err)
 365         }
 366 }
 367
 368 func isRnibConnectionError(err error) bool {
 369         internalErr, ok := err.(*common.InternalError)
 370         if !ok {
 371                 return false
 372         }
 373         _, ok = internalErr.Err.(*net.OpError)
 374
 375         return ok
 376 }