RSM/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
  21 package services
  22
  23 import (
  24         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  25         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  26         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader"
  27         "net"
  28         "rsm/configuration"
  29         "rsm/logger"
  30         "rsm/models"
  31         "rsm/rsmdb"
  32         "time"
  33 )
  34
  35 type RNibDataService interface {
  36         GetRsmGeneralConfiguration() (*models.RsmGeneralConfiguration, error)
  37         SaveRsmGeneralConfiguration(config *models.RsmGeneralConfiguration) error
  38         GetRsmRanInfo(ranName string) (*models.RsmRanInfo, error)
  39         SaveRsmRanInfo(rsmData *models.RsmRanInfo) error
  40         GetNodeb(ranName string) (*entities.NodebInfo, error)
  41         GetListNodebIds() ([]*entities.NbIdentity, error)
  42         GetListEnbIds() ([]*entities.NbIdentity, error)
  43         PingRnib() bool
  44 }
  45
  46 type rNibDataService struct {
  47         logger        *logger.Logger
  48         rnibReader    reader.RNibReader
  49         rsmReader     rsmdb.RsmReader
  50         rsmWriter     rsmdb.RsmWriter
  51         maxAttempts   int
  52         retryInterval time.Duration
  53 }
  54
  55 func NewRnibDataService(logger *logger.Logger, config *configuration.Configuration, rnibReader reader.RNibReader, rsmReader rsmdb.RsmReader, rsmWriter rsmdb.RsmWriter) *rNibDataService {
  56         return &rNibDataService{
  57                 logger:        logger,
  58                 rnibReader:    rnibReader,
  59                 rsmReader:     rsmReader,
  60                 rsmWriter:     rsmWriter,
  61                 maxAttempts:   config.Rnib.MaxRnibConnectionAttempts,
  62                 retryInterval: time.Duration(config.Rnib.RnibRetryIntervalMs) * time.Millisecond,
  63         }
  64 }
  65
  66 func (w *rNibDataService) GetRsmGeneralConfiguration() (*models.RsmGeneralConfiguration, error) {
  67         var rsmGeneralConfiguration *models.RsmGeneralConfiguration = nil
  68
  69         err := w.retry("GetRsmGeneralConfiguration", func() (err error) {
  70                 rsmGeneralConfiguration, err = w.rsmReader.GetRsmGeneralConfiguration()
  71                 return
  72         })
  73
  74         if err == nil {
  75                 w.logger.Infof("#RnibDataService.GetRsmGeneralConfiguration - configuration: %+v", *rsmGeneralConfiguration)
  76         }
  77
  78         return rsmGeneralConfiguration, err
  79 }
  80
  81 func (w *rNibDataService) SaveRsmGeneralConfiguration(config *models.RsmGeneralConfiguration) error {
  82         w.logger.Infof("#RnibDataService.SaveRsmGeneralConfiguration - configuration: %+v", *config)
  83
  84         err := w.retry("SaveRsmGeneralConfiguration", func() (err error) {
  85                 err = w.rsmWriter.SaveRsmGeneralConfiguration(config)
  86                 return
  87         })
  88
  89         return err
  90 }
  91
  92 func (w *rNibDataService) GetRsmRanInfo(ranName string) (*models.RsmRanInfo, error) {
  93         var rsmRanInfo *models.RsmRanInfo = nil
  94
  95         err := w.retry("GetRsmRanInfo", func() (err error) {
  96                 rsmRanInfo, err = w.rsmReader.GetRsmRanInfo(ranName)
  97                 return
  98         })
  99
 100         if err == nil {
 101                 w.logger.Infof("#RnibDataService.GetRsmRanInfo - RAN name: %s, RsmRanInfo: %+v", ranName, *rsmRanInfo)
 102         }
 103
 104         return rsmRanInfo, err
 105 }
 106
 107 func (w *rNibDataService) SaveRsmRanInfo(rsmRanInfo *models.RsmRanInfo) error {
 108         err := w.retry("SaveRsmRanInfo", func() (err error) {
 109                 err = w.rsmWriter.SaveRsmRanInfo(rsmRanInfo)
 110                 return
 111         })
 112
 113         if err == nil {
 114                 w.logger.Infof("#RnibDataService.SaveRsmRanInfo - RAN name: %s, RsmRanInfo: %+v", rsmRanInfo.RanName, *rsmRanInfo)
 115         }
 116
 117         return err
 118 }
 119
 120 func (w *rNibDataService) GetNodeb(ranName string) (*entities.NodebInfo, error) {
 121         var nodeb *entities.NodebInfo = nil
 122
 123         err := w.retry("GetNodeb", func() (err error) {
 124                 nodeb, err = w.rnibReader.GetNodeb(ranName)
 125                 return
 126         })
 127
 128         return nodeb, err
 129 }
 130
 131 func (w *rNibDataService) GetListEnbIds() ([]*entities.NbIdentity, error) {
 132         w.logger.Infof("#RnibDataService.GetListEnbIds")
 133
 134         var nodeIds []*entities.NbIdentity = nil
 135
 136         err := w.retry("GetListEnbIds", func() (err error) {
 137                 nodeIds, err = w.rnibReader.GetListEnbIds()
 138                 return
 139         })
 140
 141         return nodeIds, err
 142 }
 143
 144 func (w *rNibDataService) GetListNodebIds() ([]*entities.NbIdentity, error) {
 145         w.logger.Infof("#RnibDataService.GetListNodebIds")
 146
 147         var nodeIds []*entities.NbIdentity = nil
 148
 149         err := w.retry("GetListNodebIds", func() (err error) {
 150                 nodeIds, err = w.rnibReader.GetListNodebIds()
 151                 return
 152         })
 153
 154         return nodeIds, err
 155 }
 156
 157 func (w *rNibDataService) PingRnib() bool {
 158         err := w.retry("GetListNodebIds", func() (err error) {
 159                 _, err = w.rnibReader.GetListNodebIds()
 160                 return
 161         })
 162
 163         return !isRnibConnectionError(err)
 164 }
 165
 166 func (w *rNibDataService) retry(rnibFunc string, f func() error) (err error) {
 167         attempts := w.maxAttempts
 168
 169         for i := 1; ; i++ {
 170                 err = f()
 171                 if err == nil {
 172                         return
 173                 }
 174                 if !isRnibConnectionError(err) {
 175                         w.logger.Errorf("#RnibDataService - error in %s: %s", rnibFunc, err)
 176                         return err
 177                 }
 178                 if i >= attempts {
 179                         w.logger.Errorf("#RnibDataService.retry - after %d attempts of %s, last error: %s", attempts, rnibFunc, err)
 180                         return err
 181                 }
 182                 time.Sleep(w.retryInterval)
 183
 184                 w.logger.Infof("#RnibDataService.retry - retrying %d %s after error: %s", i, rnibFunc, err)
 185         }
 186 }
 187
 188 func isRnibConnectionError(err error) bool {
 189         internalErr, ok := err.(*common.InternalError)
 190         if !ok {
 191                 return false
 192         }
 193         _, ok = internalErr.Err.(*net.OpError)
 194
 195         return ok
 196 }