change tag version
[ric-plt/e2mgr.git] / E2Manager / rNibWriter / rNibWriter.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 rNibWriter
22
23 import (
24         "fmt"
25         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
26         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
27         "gerrit.o-ran-sc.org/r/ric-plt/sdlgo"
28         "github.com/golang/protobuf/proto"
29 )
30
31 var writerPool *common.Pool
32
33 type rNibWriterInstance struct {
34         sdl       *common.ISdlInstance
35         namespace string
36 }
37
38 /*
39 RNibWriter interface allows saving data to the redis DB
40 */
41 type RNibWriter interface {
42         SaveNodeb(nbIdentity *entities.NbIdentity, nb *entities.NodebInfo) error
43         UpdateNodebInfo(nodebInfo *entities.NodebInfo) error
44         SaveRanLoadInformation(inventoryName string, ranLoadInformation *entities.RanLoadInformation) error
45 }
46
47 /*
48 Init initializes the infrastructure required for the RNibWriter instance
49 */
50 func Init(namespace string, poolSize int) {
51         initPool(poolSize,
52                 func() interface{} {
53                         var sdlI common.ISdlInstance = sdlgo.NewSdlInstance(namespace, sdlgo.NewDatabase())
54                         return &rNibWriterInstance{sdl: &sdlI, namespace: namespace}
55                 },
56                 func(obj interface{}) {
57                         (*obj.(*rNibWriterInstance).sdl).Close()
58                 })
59 }
60
61 /*
62 InitPool initializes the writer's instances pool
63 */
64 func initPool(poolSize int, newObj func() interface{}, destroyObj func(interface{})) {
65         writerPool = common.NewPool(poolSize, newObj, destroyObj)
66 }
67 /*
68 GetRNibWriter returns reference to RNibWriter
69 */
70 func GetRNibWriter() RNibWriter {
71         return &rNibWriterInstance{}
72 }
73 /*
74 SaveNodeb saves nodeB entity data in the redis DB according to the specified data model
75 */
76 func (*rNibWriterInstance) SaveNodeb(nbIdentity *entities.NbIdentity, entity *entities.NodebInfo) error {
77         w := writerPool.Get().(*rNibWriterInstance)
78         isNotEmptyIdentity := isNotEmpty(nbIdentity)
79
80         if isNotEmptyIdentity && entity.GetNodeType() == entities.Node_UNKNOWN {
81                 return common.NewValidationError(fmt.Sprintf("#rNibWriter.saveNodeB - Unknown responding node type, entity: %v", entity))
82         }
83         defer writerPool.Put(w)
84         data, err := proto.Marshal(entity)
85         if err != nil {
86                 return common.NewInternalError(err)
87         }
88         var pairs []interface{}
89         key, rNibErr := common.ValidateAndBuildNodeBNameKey(nbIdentity.InventoryName)
90         if rNibErr != nil {
91                 return rNibErr
92         }
93         pairs = append(pairs, key, data)
94
95         if isNotEmptyIdentity {
96                 key, rNibErr = common.ValidateAndBuildNodeBIdKey(entity.GetNodeType().String(), nbIdentity.GlobalNbId.GetPlmnId(), nbIdentity.GlobalNbId.GetNbId())
97                 if rNibErr != nil {
98                         return rNibErr
99                 }
100                 pairs = append(pairs, key, data)
101         }
102
103         if entity.GetEnb() != nil {
104                 pairs, rNibErr = appendEnbCells(nbIdentity, entity.GetEnb().GetServedCells(), pairs)
105                 if rNibErr != nil {
106                         return rNibErr
107                 }
108         }
109         if entity.GetGnb() != nil {
110                 pairs, rNibErr = appendGnbCells(nbIdentity, entity.GetGnb().GetServedNrCells(), pairs)
111                 if rNibErr != nil {
112                         return rNibErr
113                 }
114         }
115         err = (*w.sdl).Set(pairs)
116         if err != nil {
117                 return common.NewInternalError(err)
118         }
119
120         ranNameIdentity := &entities.NbIdentity{InventoryName: nbIdentity.InventoryName}
121
122         if isNotEmptyIdentity {
123                 nbIdData, err := proto.Marshal(ranNameIdentity)
124                 if err != nil {
125                         return common.NewInternalError(err)
126                 }
127                 err = (*w.sdl).RemoveMember(entities.Node_UNKNOWN.String(), nbIdData)
128                 if err != nil {
129                         return common.NewInternalError(err)
130                 }
131         } else {
132                 nbIdentity = ranNameIdentity
133         }
134
135         nbIdData, err := proto.Marshal(nbIdentity)
136         if err != nil {
137                 return common.NewInternalError(err)
138         }
139         err = (*w.sdl).AddMember(entity.GetNodeType().String(), nbIdData)
140         if err != nil {
141                 return common.NewInternalError(err)
142         }
143         return nil
144 }
145
146 /*
147 UpdateNodebInfo...
148 */
149 func (*rNibWriterInstance) UpdateNodebInfo(nodebInfo *entities.NodebInfo) error {
150         w := writerPool.Get().(*rNibWriterInstance)
151         defer writerPool.Put(w)
152
153         nodebNameKey, rNibErr := common.ValidateAndBuildNodeBNameKey(nodebInfo.GetRanName())
154
155         if rNibErr != nil {
156                 return rNibErr
157         }
158
159         nodebIdKey, buildNodebIdKeyError := common.ValidateAndBuildNodeBIdKey(nodebInfo.GetNodeType().String(), nodebInfo.GlobalNbId.GetPlmnId(), nodebInfo.GlobalNbId.GetNbId())
160
161         data, err := proto.Marshal(nodebInfo)
162
163         if err != nil {
164                 return common.NewInternalError(err)
165         }
166
167         var pairs []interface{}
168         pairs = append(pairs, nodebNameKey, data)
169
170         if buildNodebIdKeyError == nil {
171                 pairs = append(pairs, nodebIdKey, data)
172         }
173
174         err = (*w.sdl).Set(pairs)
175
176         if err != nil {
177                 return common.NewInternalError(err)
178         }
179
180         return nil
181 }
182
183 /*
184 SaveRanLoadInformation stores ran load information for the provided ran
185 */
186 func (*rNibWriterInstance) SaveRanLoadInformation(inventoryName string, ranLoadInformation *entities.RanLoadInformation) error {
187         w := writerPool.Get().(*rNibWriterInstance)
188         defer writerPool.Put(w)
189
190         key, rnibErr := common.ValidateAndBuildRanLoadInformationKey(inventoryName)
191
192         if rnibErr != nil {
193                 return rnibErr
194         }
195
196         data, err := proto.Marshal(ranLoadInformation)
197
198         if err != nil {
199                 return common.NewInternalError(err)
200         }
201
202         var pairs []interface{}
203         pairs = append(pairs, key, data)
204
205         err = (*w.sdl).Set(pairs)
206
207         if err != nil {
208                 return common.NewInternalError(err)
209         }
210
211         return nil
212 }
213
214 /*
215 Close closes writer's pool
216 */
217 func Close() {
218         writerPool.Close()
219 }
220
221 func appendEnbCells(nbIdentity *entities.NbIdentity, cells []*entities.ServedCellInfo, pairs []interface{}) ([]interface{}, error) {
222         for _, cell := range cells {
223                 cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: cell}}
224                 cellData, err := proto.Marshal(&cellEntity)
225                 if err != nil {
226                         return pairs, common.NewInternalError(err)
227                 }
228                 key, rNibErr := common.ValidateAndBuildCellIdKey(cell.GetCellId())
229                 if rNibErr != nil {
230                         return pairs, rNibErr
231                 }
232                 pairs = append(pairs, key, cellData)
233                 key, rNibErr = common.ValidateAndBuildCellNamePciKey(nbIdentity.InventoryName, cell.GetPci())
234                 if rNibErr != nil {
235                         return pairs, rNibErr
236                 }
237                 pairs = append(pairs, key, cellData)
238         }
239         return pairs, nil
240 }
241
242 func appendGnbCells(nbIdentity *entities.NbIdentity, cells []*entities.ServedNRCell, pairs []interface{}) ([]interface{}, error) {
243         for _, cell := range cells {
244                 cellEntity := entities.Cell{Type: entities.Cell_NR_CELL, Cell: &entities.Cell_ServedNrCell{ServedNrCell: cell}}
245                 cellData, err := proto.Marshal(&cellEntity)
246                 if err != nil {
247                         return pairs, common.NewInternalError(err)
248                 }
249                 key, rNibErr := common.ValidateAndBuildNrCellIdKey(cell.GetServedNrCellInformation().GetCellId())
250                 if rNibErr != nil {
251                         return pairs, rNibErr
252                 }
253                 pairs = append(pairs, key, cellData)
254                 key, rNibErr = common.ValidateAndBuildCellNamePciKey(nbIdentity.InventoryName, cell.GetServedNrCellInformation().GetNrPci())
255                 if rNibErr != nil {
256                         return pairs, rNibErr
257                 }
258                 pairs = append(pairs, key, cellData)
259         }
260         return pairs, nil
261 }
262
263 func isNotEmpty(nbIdentity *entities.NbIdentity) bool {
264         return nbIdentity.GlobalNbId != nil && nbIdentity.GlobalNbId.PlmnId != "" && nbIdentity.GlobalNbId.NbId != ""
265 }