E2Manager/managers/e2t_instances_manager.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
  18 package managers
  19
  20 import (
  21         "e2mgr/e2managererrors"
  22         "e2mgr/logger"
  23         "e2mgr/services"
  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         "math"
  27         "sync"
  28 )
  29
  30 type E2TInstancesManager struct {
  31         rnibDataService services.RNibDataService
  32         logger          *logger.Logger
  33         mux             sync.Mutex
  34 }
  35
  36 type IE2TInstancesManager interface {
  37         GetE2TInstance(e2tAddress string) (*entities.E2TInstance, error)
  38         GetE2TInstances() ([]*entities.E2TInstance, error)
  39         AddE2TInstance(e2tAddress string) error
  40         RemoveE2TInstance(e2tInstance *entities.E2TInstance) error
  41         SelectE2TInstance() (string, error)
  42         AssociateRan(ranName string, e2tAddress string) error
  43         DissociateRan(ranName string, e2tAddress string) error
  44 }
  45
  46 func NewE2TInstancesManager(rnibDataService services.RNibDataService, logger *logger.Logger) *E2TInstancesManager {
  47         return &E2TInstancesManager{
  48                 rnibDataService: rnibDataService,
  49                 logger:          logger,
  50         }
  51 }
  52
  53 func (m *E2TInstancesManager) GetE2TInstance(e2tAddress string) (*entities.E2TInstance, error) {
  54         e2tInstance, err := m.rnibDataService.GetE2TInstance(e2tAddress)
  55
  56         if err != nil {
  57                 m.logger.Errorf("#GetE2TInstance - E2T Instance address: %s - Failed retrieving E2TInstance. error: %s", e2tAddress, err)
  58         }
  59
  60         return e2tInstance, err
  61 }
  62
  63 func (m *E2TInstancesManager) GetE2TInstances() ([]*entities.E2TInstance, error) {
  64         e2tAddresses, err := m.rnibDataService.GetE2TAddresses()
  65
  66         if err != nil {
  67                 m.logger.Errorf("#E2TInstancesManager.GetE2TInstances - Failed retrieving E2T addresses. error: %s", err)
  68                 return nil, err
  69         }
  70
  71         if len(e2tAddresses) == 0 {
  72                 m.logger.Warnf("#E2TInstancesManager.GetE2TInstances - Empty E2T addresses list")
  73                 return []*entities.E2TInstance{}, nil
  74         }
  75
  76         e2tInstances, err := m.rnibDataService.GetE2TInstances(e2tAddresses)
  77
  78         if err != nil {
  79                 m.logger.Errorf("#E2TInstancesManager.GetE2TInstances - Failed retrieving E2T instances list. error: %s", err)
  80                 return e2tInstances, err
  81         }
  82
  83         if len(e2tInstances) == 0 {
  84                 m.logger.Warnf("#E2TInstancesManager.GetE2TInstances - Empty E2T instances list")
  85                 return e2tInstances, nil
  86         }
  87
  88         return e2tInstances, nil
  89 }
  90
  91 func findActiveE2TInstanceWithMinimumAssociatedRans(e2tInstances []*entities.E2TInstance) *entities.E2TInstance {
  92         var minInstance *entities.E2TInstance
  93         minAssociatedRanCount := math.MaxInt32
  94
  95         for _, v := range e2tInstances {
  96                 if v.State == entities.Active && len(v.AssociatedRanList) < minAssociatedRanCount {
  97                         minAssociatedRanCount = len(v.AssociatedRanList)
  98                         minInstance = v
  99                 }
 100         }
 101
 102         return minInstance
 103 }
 104
 105 func (m *E2TInstancesManager) AddE2TInstance(e2tAddress string) error {
 106
 107         e2tInstance := entities.NewE2TInstance(e2tAddress)
 108         err := m.rnibDataService.SaveE2TInstance(e2tInstance)
 109
 110         if err != nil {
 111                 m.logger.Errorf("#AddE2TInstance - E2T Instance address: %s - Failed saving E2T instance. error: %s", e2tInstance.Address, err)
 112                 return err
 113         }
 114
 115         m.mux.Lock()
 116         defer m.mux.Unlock()
 117
 118         e2tAddresses, err := m.rnibDataService.GetE2TAddresses()
 119
 120         if err != nil {
 121
 122                 _, ok := err.(*common.ResourceNotFoundError)
 123
 124                 if !ok {
 125                         m.logger.Errorf("#AddE2TInstance - E2T Instance address: %s - Failed retrieving E2T addresses list. error: %s", e2tInstance.Address, err)
 126                         return err
 127                 }
 128         }
 129
 130         e2tAddresses = append(e2tAddresses, e2tInstance.Address)
 131
 132         err = m.rnibDataService.SaveE2TAddresses(e2tAddresses)
 133
 134         if err != nil {
 135                 m.logger.Errorf("#AddE2TInstance - E2T Instance address: %s - Failed saving E2T addresses list. error: %s", e2tInstance.Address, err)
 136                 return err
 137         }
 138
 139         m.logger.Infof("#AddE2TInstance - E2T Instance address: %s - successfully completed", e2tInstance.Address)
 140         return nil
 141 }
 142
 143 func (m *E2TInstancesManager) DissociateRan(ranName string, e2tAddress string) error {
 144
 145         m.mux.Lock()
 146         defer m.mux.Unlock()
 147
 148         e2tInstance, err := m.rnibDataService.GetE2TInstance(e2tAddress)
 149
 150         if err != nil {
 151                 m.logger.Errorf("#DissociateRan - E2T Instance address: %s - Failed retrieving E2TInstance. error: %s", e2tAddress, err)
 152                 return err
 153         }
 154
 155         i := 0 // output index
 156         for _, v := range e2tInstance.AssociatedRanList {
 157                 if v != ranName {
 158                         // copy and increment index
 159                         e2tInstance.AssociatedRanList[i] = v
 160                         i++
 161                 }
 162         }
 163
 164         e2tInstance.AssociatedRanList = e2tInstance.AssociatedRanList[:i]
 165
 166         err = m.rnibDataService.SaveE2TInstance(e2tInstance)
 167
 168         if err != nil {
 169                 m.logger.Errorf("#DissociateRan - E2T Instance address: %s - Failed saving E2TInstance. error: %s", e2tAddress, err)
 170                 return err
 171         }
 172
 173         return nil
 174 }
 175
 176 func (m *E2TInstancesManager) RemoveE2TInstance(e2tInstance *entities.E2TInstance) error {
 177         return nil
 178 }
 179 func (m *E2TInstancesManager) SelectE2TInstance() (string, error) {
 180
 181         e2tInstances, err := m.GetE2TInstances()
 182
 183         if err != nil {
 184                 m.logger.Errorf("#E2TInstancesManager.SelectE2TInstance - failed retrieving E2T instances. error: %s", err)
 185                 return "", e2managererrors.NewRnibDbError()
 186         }
 187
 188         if len(e2tInstances) == 0 {
 189                 m.logger.Errorf("#E2TInstancesManager.SelectE2TInstance - No E2T instance found")
 190                 return "", e2managererrors.NewE2TInstanceAbsenceError()
 191         }
 192
 193         min := findActiveE2TInstanceWithMinimumAssociatedRans(e2tInstances)
 194
 195         if min == nil {
 196                 m.logger.Errorf("#SelectE2TInstance - No active E2T instance found")
 197                 return "", e2managererrors.NewE2TInstanceAbsenceError()
 198         }
 199
 200         return min.Address, nil
 201 }
 202
 203 func (m *E2TInstancesManager) AssociateRan(ranName string, e2tAddress string) error {
 204
 205         m.mux.Lock()
 206         defer m.mux.Unlock()
 207
 208         e2tInstance, err := m.rnibDataService.GetE2TInstance(e2tAddress)
 209
 210         if err != nil {
 211                 m.logger.Errorf("#AssociateRan - E2T Instance address: %s - Failed retrieving E2TInstance. error: %s", e2tAddress, err)
 212                 return e2managererrors.NewRnibDbError()
 213         }
 214
 215         e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, ranName)
 216
 217         err = m.rnibDataService.SaveE2TInstance(e2tInstance)
 218
 219         if err != nil {
 220                 m.logger.Errorf("#AssociateRan - E2T Instance address: %s - Failed saving E2TInstance. error: %s", e2tAddress, err)
 221                 return e2managererrors.NewRnibDbError()
 222         }
 223
 224         return nil
 225 }