blob: e9809f2c677c9b8b110402693ec271e37f262756 [file] [log] [blame]
Abhilash S.L7f17e402019-03-15 17:40:41 +05301/*
2 * Copyright 2019-present Open Networking Foundation
3
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7
8 * http://www.apache.org/licenses/LICENSE-2.0
9
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Girish Gowdru6a80bbd2019-07-02 07:36:09 -070017//Package resourcemanager provides the utility for managing resources
manikkaraj kbf256be2019-03-25 00:13:48 +053018package resourcemanager
Abhilash S.L7f17e402019-03-15 17:40:41 +053019
20import (
npujarec5762e2020-01-01 14:08:48 +053021 "context"
Girish Gowdru0c588b22019-04-23 23:24:56 -040022 "encoding/json"
23 "errors"
24 "fmt"
Girish Gowdraa09aeab2020-09-14 16:30:52 -070025 "strings"
Girish Gowdra38d533d2020-03-30 20:38:51 -070026 "sync"
Neha Sharmacc656962020-04-14 14:26:11 +000027 "time"
Abhilash S.L7f17e402019-03-15 17:40:41 +053028
khenaidoo106c61a2021-08-11 18:05:46 -040029 tp "github.com/opencord/voltha-lib-go/v7/pkg/techprofile"
30
31 "github.com/opencord/voltha-lib-go/v7/pkg/db"
32 "github.com/opencord/voltha-lib-go/v7/pkg/db/kvstore"
33 "github.com/opencord/voltha-lib-go/v7/pkg/log"
34 ponrmgr "github.com/opencord/voltha-lib-go/v7/pkg/ponresourcemanager"
35 ofp "github.com/opencord/voltha-protos/v5/go/openflow_13"
36 "github.com/opencord/voltha-protos/v5/go/openolt"
Abhilash S.L7f17e402019-03-15 17:40:41 +053037)
38
salmansiddiqui7ac62132019-08-22 03:58:50 +000039const (
40 // KvstoreTimeout specifies the time out for KV Store Connection
Neha Sharmacc656962020-04-14 14:26:11 +000041 KvstoreTimeout = 5 * time.Second
Matteo Scandolodfa7a972020-11-06 13:03:40 -080042 // BasePathKvStore - <pathPrefix>/openolt/<device_id>
43 BasePathKvStore = "%s/openolt/{%s}"
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -070044 // tpIDPathSuffix - <(pon_id, onu_id, uni_id)>/tp_id
45 tpIDPathSuffix = "{%d,%d,%d}/tp_id"
Gamze Abakafee36392019-10-03 11:17:24 +000046 //MeterIDPathSuffix - <(pon_id, onu_id, uni_id)>/<tp_id>/meter_id/<direction>
47 MeterIDPathSuffix = "{%d,%d,%d}/{%d}/meter_id/{%s}"
Girish Gowdra950326e2021-11-05 12:43:24 -070048
49 // OnuPacketInPathPrefix - path prefix where ONU packet-in vlanID/PCP is stored
Girish Gowdraa09aeab2020-09-14 16:30:52 -070050 //format: onu_packetin/{<intfid>,<onuid>,<logicalport>}
Girish Gowdra950326e2021-11-05 12:43:24 -070051 OnuPacketInPathPrefix = "onu_packetin/{%d,%d,%d}"
52 // OnuPacketInPath path on the kvstore to store packetin gemport,which will be used for packetin, packetout
Girish Gowdraa09aeab2020-09-14 16:30:52 -070053 //format: onu_packetin/{<intfid>,<onuid>,<logicalport>}/{<vlanId>,<priority>}
Girish Gowdra950326e2021-11-05 12:43:24 -070054 OnuPacketInPath = OnuPacketInPathPrefix + "/{%d,%d}"
55
56 //FlowIDsForGemPathPrefix format: flowids_for_gem/<intfid>
57 FlowIDsForGemPathPrefix = "flowids_per_gem/{%d}"
58 //FlowIDsForGem flowids_for_gem/<intfid>/<gemport-id>
59 FlowIDsForGem = FlowIDsForGemPathPrefix + "/{%d}"
60
Esin Karamanccb714b2019-11-29 15:02:06 +000061 //McastQueuesForIntf multicast queues for pon interfaces
62 McastQueuesForIntf = "mcast_qs_for_int"
63 //FlowGroup flow_groups/<flow_group_id>
64 // A group is stored under this path on the KV store after it has been installed to the device.
65 // It should also be deleted after it has been removed from the device accordingly.
66 FlowGroup = "flow_groups/{%d}"
67 //FlowGroupCached flow_groups_cached/<flow_group_id>
68 // When a group add request received, we create the group without setting any members to it since we cannot
69 // set any members to a group until it is associated with a multicast flow. It is a BAL limitation.
70 // When the related multicast flow has been created we perform set members operation for the group.
71 // That is why we need to keep the members of a group until the multicast flow creation request comes.
72 // We preserve the groups under "FlowGroupsCached" directory in the KV store temporarily. Having set members,
73 // we remove the group from the cached group store.
74 FlowGroupCached = "flow_groups_cached/{%d}"
Girish Gowdraa09aeab2020-09-14 16:30:52 -070075
76 //FlowIDPath - Path on the KV store for storing list of Flow IDs for a given subscriber
77 //Format: BasePathKvStore/<(pon_intf_id, onu_id, uni_id)>/flow_ids
78 FlowIDPath = "{%s}/flow_ids"
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -070079
Girish Gowdra950326e2021-11-05 12:43:24 -070080 //OnuGemInfoPathPathPrefix format: onu_gem_info/<intfid>
81 OnuGemInfoPathPathPrefix = "onu_gem_info/{%d}"
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -070082 //OnuGemInfoPath is path on the kvstore to store onugem info map
Girish Gowdra950326e2021-11-05 12:43:24 -070083 //format: onu_gem_info/<intfid>/<onu_id>
84 OnuGemInfoPath = OnuGemInfoPathPathPrefix + "/{%d}"
salmansiddiqui7ac62132019-08-22 03:58:50 +000085)
Abhilash S.L7f17e402019-03-15 17:40:41 +053086
Girish Gowdru6a80bbd2019-07-02 07:36:09 -070087// FlowInfo holds the flow information
Abhilash S.L8ee90712019-04-29 16:24:22 +053088type FlowInfo struct {
Girish Gowdraa09aeab2020-09-14 16:30:52 -070089 Flow *openolt.Flow
90 IsSymmtricFlow bool
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +053091}
92
93// OnuGemInfo holds onu information along with gem port list and uni port list
94type OnuGemInfo struct {
95 OnuID uint32
96 SerialNumber string
97 IntfID uint32
98 GemPorts []uint32
99 UniPorts []uint32
100}
101
102// PacketInInfoKey is the key for packet in gemport
103type PacketInInfoKey struct {
104 IntfID uint32
105 OnuID uint32
106 LogicalPort uint32
Esin Karaman7fb80c22020-07-16 14:23:33 +0000107 VlanID uint16
108 Priority uint8
Abhilash S.L8ee90712019-04-29 16:24:22 +0530109}
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700110
Esin Karamanccb714b2019-11-29 15:02:06 +0000111// GroupInfo holds group information
112type GroupInfo struct {
113 GroupID uint32
114 OutPorts []uint32
115}
116
Girish Gowdraa482f272021-03-24 23:04:19 -0700117// MeterInfo store meter information at path <(pon_id, onu_id, uni_id)>/<tp_id>/meter_id/<direction>
118type MeterInfo struct {
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700119 RefCnt uint8 // number of flow references for this meter. When RefCnt is 0, the MeterInfo should be deleted.
120 MeterID uint32
Girish Gowdraa482f272021-03-24 23:04:19 -0700121}
122
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700123// OpenOltResourceMgr holds resource related information as provided below for each field
Abhilash S.L7f17e402019-03-15 17:40:41 +0530124type OpenOltResourceMgr struct {
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700125 PonIntfID uint32
Neha Sharma3f221ae2020-04-29 19:02:12 +0000126 DeviceID string // OLT device id
127 Address string // Host and port of the kv store to connect to
128 Args string // args
129 KVStore *db.Backend // backend kv store connection handle
130 DeviceType string
131 DevInfo *openolt.DeviceInfo // device information
Girish Gowdru0c588b22019-04-23 23:24:56 -0400132 // array of pon resource managers per interface technology
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700133 PonRsrMgr *ponrmgr.PONResourceManager
Girish Gowdra38d533d2020-03-30 20:38:51 -0700134
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700135 // Local maps used for write-through-cache - start
136 flowIDsForOnu map[string][]uint64
137 flowIDsForOnuLock sync.RWMutex
138
139 allocIDsForOnu map[string][]uint32
140 allocIDsForOnuLock sync.RWMutex
141
142 gemPortIDsForOnu map[string][]uint32
143 gemPortIDsForOnuLock sync.RWMutex
144
145 techProfileIDsForOnu map[string][]uint32
146 techProfileIDsForOnuLock sync.RWMutex
147
148 meterInfoForOnu map[string]*MeterInfo
149 meterInfoForOnuLock sync.RWMutex
150
151 onuGemInfo map[string]*OnuGemInfo
152 onuGemInfoLock sync.RWMutex
153
154 gemPortForPacketInInfo map[string]uint32
155 gemPortForPacketInInfoLock sync.RWMutex
156
157 flowIDsForGem map[uint32][]uint64
158 flowIDsForGemLock sync.RWMutex
159
160 mcastQueueForIntf map[uint32][]uint32
161 mcastQueueForIntfLock sync.RWMutex
162 mcastQueueForIntfLoadedFromKvStore bool
163
164 groupInfo map[string]*GroupInfo
165 groupInfoLock sync.RWMutex
166 // Local maps used for write-through-cache - end
Girish Gowdra4c3d4602021-07-22 16:33:37 -0700167
Girish Gowdra76a1b092021-07-28 10:07:04 -0700168 TechprofileRef tp.TechProfileIf
Abhilash S.L7f17e402019-03-15 17:40:41 +0530169}
170
Neha Sharma96b7bf22020-06-15 10:37:32 +0000171func newKVClient(ctx context.Context, storeType string, address string, timeout time.Duration) (kvstore.Client, error) {
172 logger.Infow(ctx, "kv-store-type", log.Fields{"store": storeType})
Girish Gowdru0c588b22019-04-23 23:24:56 -0400173 switch storeType {
Girish Gowdru0c588b22019-04-23 23:24:56 -0400174 case "etcd":
Neha Sharma96b7bf22020-06-15 10:37:32 +0000175 return kvstore.NewEtcdClient(ctx, address, timeout, log.FatalLevel)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400176 }
177 return nil, errors.New("unsupported-kv-store")
Abhilash S.L7f17e402019-03-15 17:40:41 +0530178}
179
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700180// SetKVClient sets the KV client and return a kv backend
Matteo Scandolodfa7a972020-11-06 13:03:40 -0800181func SetKVClient(ctx context.Context, backend string, addr string, DeviceID string, basePathKvStore string) *db.Backend {
Girish Gowdru0c588b22019-04-23 23:24:56 -0400182 // TODO : Make sure direct call to NewBackend is working fine with backend , currently there is some
183 // issue between kv store and backend , core is not calling NewBackend directly
Neha Sharma96b7bf22020-06-15 10:37:32 +0000184 kvClient, err := newKVClient(ctx, backend, addr, KvstoreTimeout)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400185 if err != nil {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000186 logger.Fatalw(ctx, "Failed to init KV client\n", log.Fields{"err": err})
Girish Gowdru0c588b22019-04-23 23:24:56 -0400187 return nil
188 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700189 // return db.NewBackend(ctx, backend, addr, KvstoreTimeout, fmt.Sprintf(BasePathKvStore, basePathKvStore, DeviceID))
Matteo Scandolod625b4c2020-04-02 16:16:01 -0700190
sbarbaria8910ba2019-11-05 10:12:23 -0500191 kvbackend := &db.Backend{
Girish Gowdru0c588b22019-04-23 23:24:56 -0400192 Client: kvClient,
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700193 StoreType: backend,
Neha Sharma3f221ae2020-04-29 19:02:12 +0000194 Address: addr,
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700195 Timeout: KvstoreTimeout,
Matteo Scandolodfa7a972020-11-06 13:03:40 -0800196 PathPrefix: fmt.Sprintf(BasePathKvStore, basePathKvStore, DeviceID)}
Abhilash S.L7f17e402019-03-15 17:40:41 +0530197
Girish Gowdru0c588b22019-04-23 23:24:56 -0400198 return kvbackend
Abhilash S.L7f17e402019-03-15 17:40:41 +0530199}
200
Gamze Abakafee36392019-10-03 11:17:24 +0000201// NewResourceMgr init a New resource manager instance which in turn instantiates pon resource manager
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700202// instances according to technology. Initializes the default resource ranges for all
203// the resources.
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700204func NewResourceMgr(ctx context.Context, PonIntfID uint32, deviceID string, KVStoreAddress string, kvStoreType string, deviceType string, devInfo *openolt.DeviceInfo, basePathKvStore string) *OpenOltResourceMgr {
Girish Gowdru0c588b22019-04-23 23:24:56 -0400205 var ResourceMgr OpenOltResourceMgr
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700206 logger.Debugf(ctx, "Init new resource manager , ponIf: %v, address: %s, device-id: %s", PonIntfID, KVStoreAddress, deviceID)
207 ResourceMgr.PonIntfID = PonIntfID
Girish Gowdraa09aeab2020-09-14 16:30:52 -0700208 ResourceMgr.DeviceID = deviceID
Neha Sharma3f221ae2020-04-29 19:02:12 +0000209 ResourceMgr.Address = KVStoreAddress
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700210 ResourceMgr.DeviceType = deviceType
211 ResourceMgr.DevInfo = devInfo
Abhilash S.L7f17e402019-03-15 17:40:41 +0530212
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700213 Backend := kvStoreType
Matteo Scandolodfa7a972020-11-06 13:03:40 -0800214 ResourceMgr.KVStore = SetKVClient(ctx, Backend, ResourceMgr.Address, deviceID, basePathKvStore)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400215 if ResourceMgr.KVStore == nil {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000216 logger.Error(ctx, "Failed to setup KV store")
Girish Gowdru0c588b22019-04-23 23:24:56 -0400217 }
Girish Gowdra38d533d2020-03-30 20:38:51 -0700218
Girish Gowdru0c588b22019-04-23 23:24:56 -0400219 // TODO self.args = registry('main').get_args()
Abhilash S.L7f17e402019-03-15 17:40:41 +0530220
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700221 // Create a separate Resource Manager instance for each range. This assumes that
Girish Gowdru0c588b22019-04-23 23:24:56 -0400222 // each technology is represented by only a single range
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700223 for _, TechRange := range devInfo.Ranges {
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700224 for _, intfID := range TechRange.IntfIds {
225 if intfID == PonIntfID {
226 technology := TechRange.Technology
227 logger.Debugf(ctx, "Device info technology %s, intf-id %v", technology, PonIntfID)
Neha Sharma96b7bf22020-06-15 10:37:32 +0000228
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700229 rsrMgr, err := ponrmgr.NewPONResourceManager(ctx, technology, deviceType, deviceID,
230 Backend, ResourceMgr.Address, basePathKvStore)
231 if err != nil {
232 logger.Errorf(ctx, "Failed to create pon resource manager instance for technology %s", technology)
233 return nil
234 }
235 ResourceMgr.PonRsrMgr = rsrMgr
236 // self.initialize_device_resource_range_and_pool(resource_mgr, global_resource_mgr, arange)
237 InitializeDeviceResourceRangeAndPool(ctx, rsrMgr, TechRange, devInfo)
238 if err := ResourceMgr.PonRsrMgr.InitDeviceResourcePoolForIntf(ctx, intfID); err != nil {
239 logger.Fatal(ctx, "failed-to-initialize-device-resource-pool-intf-id-%v-device-id", ResourceMgr.PonIntfID, ResourceMgr.DeviceID)
240 return nil
241 }
242 }
Girish Gowdru0c588b22019-04-23 23:24:56 -0400243 }
Girish Gowdru0c588b22019-04-23 23:24:56 -0400244 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700245
246 ResourceMgr.InitLocalCache()
247
Neha Sharma96b7bf22020-06-15 10:37:32 +0000248 logger.Info(ctx, "Initialization of resource manager success!")
Girish Gowdru0c588b22019-04-23 23:24:56 -0400249 return &ResourceMgr
Abhilash S.L7f17e402019-03-15 17:40:41 +0530250}
251
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700252//InitLocalCache initializes local maps used for write-through-cache
253func (rsrcMgr *OpenOltResourceMgr) InitLocalCache() {
254 rsrcMgr.flowIDsForOnu = make(map[string][]uint64)
255 rsrcMgr.allocIDsForOnu = make(map[string][]uint32)
256 rsrcMgr.gemPortIDsForOnu = make(map[string][]uint32)
257 rsrcMgr.techProfileIDsForOnu = make(map[string][]uint32)
258 rsrcMgr.meterInfoForOnu = make(map[string]*MeterInfo)
259 rsrcMgr.onuGemInfo = make(map[string]*OnuGemInfo)
260 rsrcMgr.gemPortForPacketInInfo = make(map[string]uint32)
261 rsrcMgr.flowIDsForGem = make(map[uint32][]uint64)
262 rsrcMgr.mcastQueueForIntf = make(map[uint32][]uint32)
263 rsrcMgr.groupInfo = make(map[string]*GroupInfo)
264}
265
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700266// InitializeDeviceResourceRangeAndPool initializes the resource range pool according to the sharing type, then apply
267// device specific information. If KV doesn't exist
268// or is broader than the device, the device's information will
269// dictate the range limits
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700270func InitializeDeviceResourceRangeAndPool(ctx context.Context, ponRMgr *ponrmgr.PONResourceManager,
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700271 techRange *openolt.DeviceInfo_DeviceResourceRanges, devInfo *openolt.DeviceInfo) {
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700272 // var ONUIDShared, AllocIDShared, GEMPortIDShared openolt.DeviceInfo_DeviceResourceRanges_Pool_SharingType
273 var ONUIDStart, ONUIDEnd, AllocIDStart, AllocIDEnd, GEMPortIDStart, GEMPortIDEnd uint32
274 var ONUIDShared, AllocIDShared, GEMPortIDShared, FlowIDShared uint32
275
276 // The below variables are just dummy and needed to pass as arguments to InitDefaultPONResourceRanges function.
277 // The openolt adapter does not need flowIDs to be managed as it is managed on the OLT device
278 // The UNI IDs are dynamically generated by openonu adapter for every discovered UNI.
279 var flowIDDummyStart, flowIDDummyEnd uint32 = 1, 2
280 var uniIDDummyStart, uniIDDummyEnd uint32 = 0, 1
Abhilash S.L7f17e402019-03-15 17:40:41 +0530281
Girish Gowdru0c588b22019-04-23 23:24:56 -0400282 // init the resource range pool according to the sharing type
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700283 logger.Debugw(ctx, "Device info init", log.Fields{"technology": techRange.Technology,
284 "onu_id_start": ONUIDStart, "onu_id_end": ONUIDEnd,
285 "alloc_id_start": AllocIDStart, "alloc_id_end": AllocIDEnd,
286 "gemport_id_start": GEMPortIDStart, "gemport_id_end": GEMPortIDEnd,
287 "intf_ids": techRange.IntfIds,
288 })
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700289 for _, RangePool := range techRange.Pools {
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700290 // FIXME: Remove hardcoding
Girish Gowdru0c588b22019-04-23 23:24:56 -0400291 if RangePool.Type == openolt.DeviceInfo_DeviceResourceRanges_Pool_ONU_ID {
292 ONUIDStart = RangePool.Start
293 ONUIDEnd = RangePool.End
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700294 ONUIDShared = uint32(RangePool.Sharing)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400295 } else if RangePool.Type == openolt.DeviceInfo_DeviceResourceRanges_Pool_ALLOC_ID {
296 AllocIDStart = RangePool.Start
297 AllocIDEnd = RangePool.End
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700298 AllocIDShared = uint32(RangePool.Sharing)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400299 } else if RangePool.Type == openolt.DeviceInfo_DeviceResourceRanges_Pool_GEMPORT_ID {
300 GEMPortIDStart = RangePool.Start
301 GEMPortIDEnd = RangePool.End
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700302 GEMPortIDShared = uint32(RangePool.Sharing)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400303 }
304 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530305
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700306 ponRMgr.InitDefaultPONResourceRanges(ctx, ONUIDStart, ONUIDEnd, ONUIDShared,
307 AllocIDStart, AllocIDEnd, AllocIDShared,
308 GEMPortIDStart, GEMPortIDEnd, GEMPortIDShared,
309 flowIDDummyStart, flowIDDummyEnd, FlowIDShared, uniIDDummyStart, uniIDDummyEnd,
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700310 devInfo.PonPorts, techRange.IntfIds)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530311
Abhilash S.L7f17e402019-03-15 17:40:41 +0530312}
313
Devmalya Paul495b94a2019-08-27 19:42:00 -0400314// Delete clears used resources for the particular olt device being deleted
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700315func (rsrcMgr *OpenOltResourceMgr) Delete(ctx context.Context, intfID uint32) error {
316 if err := rsrcMgr.PonRsrMgr.ClearDeviceResourcePoolForIntf(ctx, intfID); err != nil {
317 logger.Debug(ctx, "Failed to clear device resource pool")
318 return err
Devmalya Paul495b94a2019-08-27 19:42:00 -0400319 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000320 logger.Debug(ctx, "Cleared device resource pool")
Devmalya Paul495b94a2019-08-27 19:42:00 -0400321 return nil
322}
Abhilash S.L7f17e402019-03-15 17:40:41 +0530323
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700324// GetONUID returns the available onuID for the given pon-port
325func (rsrcMgr *OpenOltResourceMgr) GetONUID(ctx context.Context, PonIntfID uint32) (uint32, error) {
Girish Gowdru0c588b22019-04-23 23:24:56 -0400326 // Get ONU id for a provided pon interface ID.
Girish Gowdra76a1b092021-07-28 10:07:04 -0700327 onuID, err := rsrcMgr.TechprofileRef.GetResourceID(ctx, PonIntfID,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400328 ponrmgr.ONU_ID, 1)
329 if err != nil {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000330 logger.Errorf(ctx, "Failed to get resource for interface %d for type %s",
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700331 PonIntfID, ponrmgr.ONU_ID)
cbabuabf02352019-10-15 13:14:56 +0200332 return 0, err
Girish Gowdru0c588b22019-04-23 23:24:56 -0400333 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700334 if len(onuID) > 0 {
Girish Gowdraa09aeab2020-09-14 16:30:52 -0700335 return onuID[0], err
Girish Gowdru0c588b22019-04-23 23:24:56 -0400336 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530337
Girish Gowdra950326e2021-11-05 12:43:24 -0700338 return 0, fmt.Errorf("no-onu-id-allocated")
Abhilash S.L8ee90712019-04-29 16:24:22 +0530339}
340
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700341// GetCurrentFlowIDsForOnu fetches flow ID from the resource manager
342// Note: For flows which trap from the NNI and not really associated with any particular
343// ONU (like LLDP), the onu_id and uni_id is set as -1. The intf_id is the NNI intf_id.
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700344func (rsrcMgr *OpenOltResourceMgr) GetCurrentFlowIDsForOnu(ctx context.Context, PonIntfID uint32, onuID int32, uniID int32) ([]uint64, error) {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700345
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700346 subs := fmt.Sprintf("%d,%d,%d", PonIntfID, onuID, uniID)
Girish Gowdraa09aeab2020-09-14 16:30:52 -0700347 path := fmt.Sprintf(FlowIDPath, subs)
348
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700349 // fetch from cache
350 rsrcMgr.flowIDsForOnuLock.RLock()
351 flowIDsForOnu, ok := rsrcMgr.flowIDsForOnu[path]
352 rsrcMgr.flowIDsForOnuLock.RUnlock()
353
354 if ok {
355 return flowIDsForOnu, nil
356 }
357
Girish Gowdraa09aeab2020-09-14 16:30:52 -0700358 var data []uint64
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700359 value, err := rsrcMgr.KVStore.Get(ctx, path)
Girish Gowdraa09aeab2020-09-14 16:30:52 -0700360 if err == nil {
361 if value != nil {
362 Val, _ := toByte(value.Value)
363 if err = json.Unmarshal(Val, &data); err != nil {
364 logger.Error(ctx, "Failed to unmarshal")
365 return nil, err
366 }
367 }
Serkant Uluderya89ff40c2019-10-17 16:02:25 -0700368 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700369 // update cache
370 rsrcMgr.flowIDsForOnuLock.Lock()
371 rsrcMgr.flowIDsForOnu[path] = data
372 rsrcMgr.flowIDsForOnuLock.Unlock()
373
Girish Gowdraa09aeab2020-09-14 16:30:52 -0700374 return data, nil
Abhilash S.L8ee90712019-04-29 16:24:22 +0530375}
376
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700377// UpdateAllocIdsForOnu updates alloc ids in kv store for a given pon interface id, onu id and uni id
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700378func (rsrcMgr *OpenOltResourceMgr) UpdateAllocIdsForOnu(ctx context.Context, ponPort uint32, onuID uint32, uniID uint32, allocIDs []uint32) error {
Abhilash S.L7f17e402019-03-15 17:40:41 +0530379
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700380 intfOnuIDuniID := fmt.Sprintf("%d,%d,%d", ponPort, onuID, uniID)
Gamze Abaka745ccb72021-11-18 11:29:58 +0000381
382 // Note: in case the write to DB fails there could be inconsistent data between cache and db.
383 // Although this is highly unlikely with DB retries in place, this is something we have to deal with in the next release
384 if err := rsrcMgr.PonRsrMgr.UpdateAllocIdsForOnu(ctx, intfOnuIDuniID, allocIDs); err != nil {
385 logger.Errorw(ctx, "Failed to update alloc ids for onu", log.Fields{"err": err})
386 return err
387 }
388
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700389 // update cache
390 rsrcMgr.allocIDsForOnuLock.Lock()
391 rsrcMgr.allocIDsForOnu[intfOnuIDuniID] = allocIDs
392 rsrcMgr.allocIDsForOnuLock.Unlock()
Gamze Abaka745ccb72021-11-18 11:29:58 +0000393 return nil
Abhilash S.L7f17e402019-03-15 17:40:41 +0530394}
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700395
396// GetCurrentGEMPortIDsForOnu returns gem ports for given pon interface , onu id and uni id
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700397func (rsrcMgr *OpenOltResourceMgr) GetCurrentGEMPortIDsForOnu(ctx context.Context, intfID uint32, onuID uint32,
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700398 uniID uint32) []uint32 {
Abhilash S.L7f17e402019-03-15 17:40:41 +0530399
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700400 intfOnuIDuniID := fmt.Sprintf("%d,%d,%d", intfID, onuID, uniID)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530401
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700402 // fetch from cache
403 rsrcMgr.gemPortIDsForOnuLock.RLock()
404 gemIDs, ok := rsrcMgr.gemPortIDsForOnu[intfOnuIDuniID]
405 rsrcMgr.gemPortIDsForOnuLock.RUnlock()
406 if ok {
407 return gemIDs
408 }
409 /* Get gem ports for given pon interface , onu id and uni id. */
410 gemIDs = rsrcMgr.PonRsrMgr.GetCurrentGEMPortIDsForOnu(ctx, intfOnuIDuniID)
411
412 // update cache
413 rsrcMgr.gemPortIDsForOnuLock.Lock()
414 rsrcMgr.gemPortIDsForOnu[intfOnuIDuniID] = gemIDs
415 rsrcMgr.gemPortIDsForOnuLock.Unlock()
416
417 return gemIDs
Abhilash S.L7f17e402019-03-15 17:40:41 +0530418}
419
Gamze Abakafee36392019-10-03 11:17:24 +0000420// GetCurrentAllocIDsForOnu returns alloc ids for given pon interface and onu id
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700421func (rsrcMgr *OpenOltResourceMgr) GetCurrentAllocIDsForOnu(ctx context.Context, intfID uint32, onuID uint32, uniID uint32) []uint32 {
Abhilash S.L7f17e402019-03-15 17:40:41 +0530422
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700423 intfOnuIDuniID := fmt.Sprintf("%d,%d,%d", intfID, onuID, uniID)
424 // fetch from cache
425 rsrcMgr.allocIDsForOnuLock.RLock()
426 allocIDs, ok := rsrcMgr.allocIDsForOnu[intfOnuIDuniID]
427 rsrcMgr.allocIDsForOnuLock.RUnlock()
428 if ok {
429 return allocIDs
Girish Gowdru0c588b22019-04-23 23:24:56 -0400430 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700431 allocIDs = rsrcMgr.PonRsrMgr.GetCurrentAllocIDForOnu(ctx, intfOnuIDuniID)
432
433 // update cache
434 rsrcMgr.allocIDsForOnuLock.Lock()
435 rsrcMgr.allocIDsForOnu[intfOnuIDuniID] = allocIDs
436 rsrcMgr.allocIDsForOnuLock.Unlock()
437
438 return allocIDs
Gamze Abakafee36392019-10-03 11:17:24 +0000439}
440
441// RemoveAllocIDForOnu removes the alloc id for given pon interface, onu id, uni id and alloc id
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700442func (rsrcMgr *OpenOltResourceMgr) RemoveAllocIDForOnu(ctx context.Context, intfID uint32, onuID uint32, uniID uint32, allocID uint32) {
443 allocIDs := rsrcMgr.GetCurrentAllocIDsForOnu(ctx, intfID, onuID, uniID)
Gamze Abakafee36392019-10-03 11:17:24 +0000444 for i := 0; i < len(allocIDs); i++ {
445 if allocIDs[i] == allocID {
446 allocIDs = append(allocIDs[:i], allocIDs[i+1:]...)
447 break
448 }
449 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700450 err := rsrcMgr.UpdateAllocIdsForOnu(ctx, intfID, onuID, uniID, allocIDs)
Gamze Abakafee36392019-10-03 11:17:24 +0000451 if err != nil {
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700452 logger.Errorf(ctx, "Failed to Remove Alloc Id For Onu. intfID %d onuID %d uniID %d allocID %d",
Gamze Abakafee36392019-10-03 11:17:24 +0000453 intfID, onuID, uniID, allocID)
454 }
455}
456
457// RemoveGemPortIDForOnu removes the gem port id for given pon interface, onu id, uni id and gem port id
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700458func (rsrcMgr *OpenOltResourceMgr) RemoveGemPortIDForOnu(ctx context.Context, intfID uint32, onuID uint32, uniID uint32, gemPortID uint32) {
459 gemPortIDs := rsrcMgr.GetCurrentGEMPortIDsForOnu(ctx, intfID, onuID, uniID)
Gamze Abakafee36392019-10-03 11:17:24 +0000460 for i := 0; i < len(gemPortIDs); i++ {
461 if gemPortIDs[i] == gemPortID {
462 gemPortIDs = append(gemPortIDs[:i], gemPortIDs[i+1:]...)
463 break
464 }
465 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700466 err := rsrcMgr.UpdateGEMPortIDsForOnu(ctx, intfID, onuID, uniID, gemPortIDs)
Gamze Abakafee36392019-10-03 11:17:24 +0000467 if err != nil {
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700468 logger.Errorf(ctx, "Failed to Remove Gem Id For Onu. intfID %d onuID %d uniID %d gemPortId %d",
Gamze Abakafee36392019-10-03 11:17:24 +0000469 intfID, onuID, uniID, gemPortID)
470 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530471}
472
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700473// UpdateGEMPortIDsForOnu updates gemport ids on to the kv store for a given pon port, onu id and uni id
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700474func (rsrcMgr *OpenOltResourceMgr) UpdateGEMPortIDsForOnu(ctx context.Context, ponPort uint32, onuID uint32,
475 uniID uint32, gemIDs []uint32) error {
476 intfOnuIDuniID := fmt.Sprintf("%d,%d,%d", ponPort, onuID, uniID)
Gamze Abaka745ccb72021-11-18 11:29:58 +0000477
478 if err := rsrcMgr.PonRsrMgr.UpdateGEMPortIDsForOnu(ctx, intfOnuIDuniID, gemIDs); err != nil {
479 logger.Errorw(ctx, "Failed to update gem port ids for onu", log.Fields{"err": err})
480 return err
481 }
482
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700483 // update cache
484 rsrcMgr.gemPortIDsForOnuLock.Lock()
485 rsrcMgr.gemPortIDsForOnu[intfOnuIDuniID] = gemIDs
486 rsrcMgr.gemPortIDsForOnuLock.Unlock()
Gamze Abaka745ccb72021-11-18 11:29:58 +0000487 return nil
Abhilash S.L7f17e402019-03-15 17:40:41 +0530488}
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700489
490// FreeonuID releases(make free) onu id for a particular pon-port
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700491func (rsrcMgr *OpenOltResourceMgr) FreeonuID(ctx context.Context, intfID uint32, onuID []uint32) {
Girish Gowdrab8f1b5a2021-06-27 20:42:40 -0700492 if len(onuID) == 0 {
493 logger.Info(ctx, "onu id slice is nil, nothing to free")
494 return
495 }
Girish Gowdra76a1b092021-07-28 10:07:04 -0700496 if err := rsrcMgr.TechprofileRef.FreeResourceID(ctx, intfID, ponrmgr.ONU_ID, onuID); err != nil {
Matteo Scandolo84585372021-03-18 14:21:22 -0700497 logger.Errorw(ctx, "error-while-freeing-onu-id", log.Fields{
498 "intf-id": intfID,
499 "onu-id": onuID,
500 "err": err.Error(),
501 })
Girish Gowdrab8f1b5a2021-06-27 20:42:40 -0700502 } else {
503 logger.Infow(ctx, "freed onu id", log.Fields{"intfID": intfID, "onuID": onuID})
Matteo Scandolo84585372021-03-18 14:21:22 -0700504 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530505}
506
Gamze Abakafee36392019-10-03 11:17:24 +0000507// FreeAllocID frees AllocID on the PON resource pool and also frees the allocID association
508// for the given OLT device.
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700509// The caller should ensure that this is a blocking call and this operation is serialized for
510// the ONU so as not cause resource corruption since there are no mutexes used here.
511func (rsrcMgr *OpenOltResourceMgr) FreeAllocID(ctx context.Context, intfID uint32, onuID uint32,
Andrea Campanella8a0d0502022-01-31 15:31:59 +0100512 uniID uint32, allocID uint32) {
Girish Gowdrab77ded92020-04-08 11:45:05 -0700513
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700514 rsrcMgr.RemoveAllocIDForOnu(ctx, intfID, onuID, uniID, allocID)
Andrea Campanella8a0d0502022-01-31 15:31:59 +0100515 allocIDs := make([]uint32, 0)
516 allocIDs = append(allocIDs, allocID)
517 if err := rsrcMgr.TechprofileRef.FreeResourceID(ctx, intfID, ponrmgr.ALLOC_ID, allocIDs); err != nil {
518 logger.Errorw(ctx, "error-while-freeing-alloc-id", log.Fields{
519 "intf-id": intfID,
520 "onu-id": onuID,
521 "err": err.Error(),
522 })
Matteo Scandolo84585372021-03-18 14:21:22 -0700523 }
Gamze Abakafee36392019-10-03 11:17:24 +0000524}
525
526// FreeGemPortID frees GemPortID on the PON resource pool and also frees the gemPortID association
527// for the given OLT device.
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700528// The caller should ensure that this is a blocking call and this operation is serialized for
529// the ONU so as not cause resource corruption since there are no mutexes used here.
530func (rsrcMgr *OpenOltResourceMgr) FreeGemPortID(ctx context.Context, intfID uint32, onuID uint32,
Gamze Abakafee36392019-10-03 11:17:24 +0000531 uniID uint32, gemPortID uint32) {
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700532 rsrcMgr.RemoveGemPortIDForOnu(ctx, intfID, onuID, uniID, gemPortID)
Girish Gowdrab77ded92020-04-08 11:45:05 -0700533
Gamze Abakafee36392019-10-03 11:17:24 +0000534 gemPortIDs := make([]uint32, 0)
535 gemPortIDs = append(gemPortIDs, gemPortID)
Girish Gowdra76a1b092021-07-28 10:07:04 -0700536 if err := rsrcMgr.TechprofileRef.FreeResourceID(ctx, intfID, ponrmgr.GEMPORT_ID, gemPortIDs); err != nil {
Matteo Scandolo84585372021-03-18 14:21:22 -0700537 logger.Errorw(ctx, "error-while-freeing-gem-port-id", log.Fields{
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700538 "intf-id": intfID,
Matteo Scandolo84585372021-03-18 14:21:22 -0700539 "onu-id": onuID,
540 "err": err.Error(),
541 })
542 }
Gamze Abakafee36392019-10-03 11:17:24 +0000543}
544
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700545// FreePONResourcesForONU make the pon resources free for a given pon interface and onu id
546func (rsrcMgr *OpenOltResourceMgr) FreePONResourcesForONU(ctx context.Context, intfID uint32, onuID uint32, uniID uint32) {
Abhilash S.L7f17e402019-03-15 17:40:41 +0530547
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700548 intfOnuIDuniID := fmt.Sprintf("%d,%d,%d", intfID, onuID, uniID)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530549
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700550 AllocIDs := rsrcMgr.PonRsrMgr.GetCurrentAllocIDForOnu(ctx, intfOnuIDuniID)
Matteo Scandolod625b4c2020-04-02 16:16:01 -0700551
Girish Gowdra76a1b092021-07-28 10:07:04 -0700552 if err := rsrcMgr.TechprofileRef.FreeResourceID(ctx, intfID,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400553 ponrmgr.ALLOC_ID,
Matteo Scandolo84585372021-03-18 14:21:22 -0700554 AllocIDs); err != nil {
555 logger.Errorw(ctx, "error-while-freeing-all-alloc-ids-for-onu", log.Fields{
556 "intf-id": intfID,
557 "onu-id": onuID,
558 "err": err.Error(),
559 })
560 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530561
Gamze Abaka745ccb72021-11-18 11:29:58 +0000562 //update cache
563 rsrcMgr.allocIDsForOnuLock.Lock()
564 delete(rsrcMgr.allocIDsForOnu, intfOnuIDuniID)
565 rsrcMgr.allocIDsForOnuLock.Unlock()
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700566
Gamze Abaka745ccb72021-11-18 11:29:58 +0000567 GEMPortIDs := rsrcMgr.PonRsrMgr.GetCurrentGEMPortIDsForOnu(ctx, intfOnuIDuniID)
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700568
Girish Gowdra76a1b092021-07-28 10:07:04 -0700569 if err := rsrcMgr.TechprofileRef.FreeResourceID(ctx, intfID,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400570 ponrmgr.GEMPORT_ID,
Matteo Scandolo84585372021-03-18 14:21:22 -0700571 GEMPortIDs); err != nil {
572 logger.Errorw(ctx, "error-while-freeing-all-gem-port-ids-for-onu", log.Fields{
573 "intf-id": intfID,
574 "onu-id": onuID,
575 "err": err.Error(),
576 })
577 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530578
Gamze Abaka745ccb72021-11-18 11:29:58 +0000579 // update cache
580 rsrcMgr.gemPortIDsForOnuLock.Lock()
581 delete(rsrcMgr.gemPortIDsForOnu, intfOnuIDuniID)
582 rsrcMgr.gemPortIDsForOnuLock.Unlock()
583
Girish Gowdru0c588b22019-04-23 23:24:56 -0400584 // Clear resource map associated with (pon_intf_id, gemport_id) tuple.
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700585 rsrcMgr.PonRsrMgr.RemoveResourceMap(ctx, intfOnuIDuniID)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530586}
587
Girish Gowdraa09aeab2020-09-14 16:30:52 -0700588// IsFlowOnKvStore checks if the given flowID is present on the kv store
589// Returns true if the flowID is found, otherwise it returns false
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700590func (rsrcMgr *OpenOltResourceMgr) IsFlowOnKvStore(ctx context.Context, intfID uint32, onuID int32, uniID int32,
Girish Gowdraa09aeab2020-09-14 16:30:52 -0700591 flowID uint64) bool {
Abhilash S.L7f17e402019-03-15 17:40:41 +0530592
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700593 FlowIDs, err := rsrcMgr.GetCurrentFlowIDsForOnu(ctx, intfID, onuID, uniID)
Girish Gowdraa09aeab2020-09-14 16:30:52 -0700594 if err != nil {
595 // error logged in the called function
596 return false
597 }
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400598 if FlowIDs != nil {
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700599 logger.Debugw(ctx, "Found flowId(s) for this ONU", log.Fields{"pon": intfID, "onuID": onuID, "uniID": uniID})
Girish Gowdraa09aeab2020-09-14 16:30:52 -0700600 for _, id := range FlowIDs {
601 if flowID == id {
602 return true
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400603 }
604 }
605 }
606 return false
607}
Manikkaraj kb1d51442019-07-23 10:41:02 -0400608
salmansiddiqui7ac62132019-08-22 03:58:50 +0000609// GetTechProfileIDForOnu fetches Tech-Profile-ID from the KV-Store for the given onu based on the path
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700610// This path is formed as the following: {intfID, onuID, uniID}/tp_id
611func (rsrcMgr *OpenOltResourceMgr) GetTechProfileIDForOnu(ctx context.Context, intfID uint32, onuID uint32, uniID uint32) []uint32 {
612 Path := fmt.Sprintf(tpIDPathSuffix, intfID, onuID, uniID)
613 // fetch from cache
614 rsrcMgr.techProfileIDsForOnuLock.RLock()
615 tpIDs, ok := rsrcMgr.techProfileIDsForOnu[Path]
616 rsrcMgr.techProfileIDsForOnuLock.RUnlock()
617 if ok {
618 return tpIDs
619 }
620 Value, err := rsrcMgr.KVStore.Get(ctx, Path)
Manikkaraj kb1d51442019-07-23 10:41:02 -0400621 if err == nil {
622 if Value != nil {
623 Val, err := kvstore.ToByte(Value.Value)
624 if err != nil {
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700625 logger.Errorw(ctx, "Failed to convert into byte array", log.Fields{"err": err})
626 return tpIDs
Manikkaraj kb1d51442019-07-23 10:41:02 -0400627 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700628 if err = json.Unmarshal(Val, &tpIDs); err != nil {
629 logger.Error(ctx, "Failed to unmarshal", log.Fields{"err": err})
630 return tpIDs
Manikkaraj kb1d51442019-07-23 10:41:02 -0400631 }
632 }
633 } else {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000634 logger.Errorf(ctx, "Failed to get TP id from kvstore for path %s", Path)
Manikkaraj kb1d51442019-07-23 10:41:02 -0400635 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700636 logger.Debugf(ctx, "Getting TP id %d from path %s", tpIDs, Path)
637
638 // update cache
639 rsrcMgr.techProfileIDsForOnuLock.Lock()
640 rsrcMgr.techProfileIDsForOnu[Path] = tpIDs
641 rsrcMgr.techProfileIDsForOnuLock.Unlock()
642
643 return tpIDs
Manikkaraj kb1d51442019-07-23 10:41:02 -0400644
645}
646
Gamze Abakafee36392019-10-03 11:17:24 +0000647// RemoveTechProfileIDsForOnu deletes all tech profile ids from the KV-Store for the given onu based on the path
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700648// This path is formed as the following: {intfID, onuID, uniID}/tp_id
649func (rsrcMgr *OpenOltResourceMgr) RemoveTechProfileIDsForOnu(ctx context.Context, intfID uint32, onuID uint32, uniID uint32) error {
650 intfOnuUniID := fmt.Sprintf(tpIDPathSuffix, intfID, onuID, uniID)
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700651
652 if err := rsrcMgr.KVStore.Delete(ctx, intfOnuUniID); err != nil {
653 logger.Errorw(ctx, "Failed to delete techprofile id resource in KV store", log.Fields{"path": intfOnuUniID})
Manikkaraj kb1d51442019-07-23 10:41:02 -0400654 return err
655 }
Gamze Abaka745ccb72021-11-18 11:29:58 +0000656
657 // update cache
658 rsrcMgr.techProfileIDsForOnuLock.Lock()
659 delete(rsrcMgr.techProfileIDsForOnu, intfOnuUniID)
660 rsrcMgr.techProfileIDsForOnuLock.Unlock()
Manikkaraj kb1d51442019-07-23 10:41:02 -0400661 return nil
662}
663
Gamze Abakafee36392019-10-03 11:17:24 +0000664// RemoveTechProfileIDForOnu deletes a specific tech profile id from the KV-Store for the given onu based on the path
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700665// This path is formed as the following: {intfID, onuID, uniID}/tp_id
666func (rsrcMgr *OpenOltResourceMgr) RemoveTechProfileIDForOnu(ctx context.Context, intfID uint32, onuID uint32, uniID uint32, tpID uint32) error {
667 tpIDList := rsrcMgr.GetTechProfileIDForOnu(ctx, intfID, onuID, uniID)
Gamze Abakafee36392019-10-03 11:17:24 +0000668 for i, tpIDInList := range tpIDList {
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700669 if tpIDInList == tpID {
Gamze Abakafee36392019-10-03 11:17:24 +0000670 tpIDList = append(tpIDList[:i], tpIDList[i+1:]...)
671 }
672 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700673 intfOnuUniID := fmt.Sprintf(tpIDPathSuffix, intfID, onuID, uniID)
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700674
Gamze Abakafee36392019-10-03 11:17:24 +0000675 Value, err := json.Marshal(tpIDList)
676 if err != nil {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000677 logger.Error(ctx, "failed to Marshal")
Gamze Abakafee36392019-10-03 11:17:24 +0000678 return err
679 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700680 if err = rsrcMgr.KVStore.Put(ctx, intfOnuUniID, Value); err != nil {
681 logger.Errorf(ctx, "Failed to update resource %s", intfOnuUniID)
Gamze Abakafee36392019-10-03 11:17:24 +0000682 return err
683 }
Gamze Abaka745ccb72021-11-18 11:29:58 +0000684
685 // update cache
686 rsrcMgr.techProfileIDsForOnuLock.Lock()
687 rsrcMgr.techProfileIDsForOnu[intfOnuUniID] = tpIDList
688 rsrcMgr.techProfileIDsForOnuLock.Unlock()
Gamze Abakafee36392019-10-03 11:17:24 +0000689 return err
690}
691
692// UpdateTechProfileIDForOnu updates (put) already present tech-profile-id for the given onu based on the path
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700693// This path is formed as the following: {intfID, onuID, uniID}/tp_id
694func (rsrcMgr *OpenOltResourceMgr) UpdateTechProfileIDForOnu(ctx context.Context, intfID uint32, onuID uint32,
695 uniID uint32, tpID uint32) error {
Manikkaraj kb1d51442019-07-23 10:41:02 -0400696 var Value []byte
697 var err error
698
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700699 intfOnuUniID := fmt.Sprintf(tpIDPathSuffix, intfID, onuID, uniID)
Gamze Abakafee36392019-10-03 11:17:24 +0000700
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700701 tpIDList := rsrcMgr.GetTechProfileIDForOnu(ctx, intfID, onuID, uniID)
Gamze Abakafee36392019-10-03 11:17:24 +0000702 for _, value := range tpIDList {
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700703 if value == tpID {
704 logger.Debugf(ctx, "tpID %d is already in tpIdList for the path %s", tpID, intfOnuUniID)
Gamze Abakafee36392019-10-03 11:17:24 +0000705 return err
706 }
707 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700708 logger.Debugf(ctx, "updating tp id %d on path %s", tpID, intfOnuUniID)
709 tpIDList = append(tpIDList, tpID)
710
Gamze Abakafee36392019-10-03 11:17:24 +0000711 Value, err = json.Marshal(tpIDList)
Manikkaraj kb1d51442019-07-23 10:41:02 -0400712 if err != nil {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000713 logger.Error(ctx, "failed to Marshal")
Manikkaraj kb1d51442019-07-23 10:41:02 -0400714 return err
715 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700716 if err = rsrcMgr.KVStore.Put(ctx, intfOnuUniID, Value); err != nil {
717 logger.Errorf(ctx, "Failed to update resource %s", intfOnuUniID)
Manikkaraj kb1d51442019-07-23 10:41:02 -0400718 return err
719 }
Gamze Abaka745ccb72021-11-18 11:29:58 +0000720
721 // update cache
722 rsrcMgr.techProfileIDsForOnuLock.Lock()
723 rsrcMgr.techProfileIDsForOnu[intfOnuUniID] = tpIDList
724 rsrcMgr.techProfileIDsForOnuLock.Unlock()
Manikkaraj kb1d51442019-07-23 10:41:02 -0400725 return err
726}
727
Girish Gowdraa482f272021-03-24 23:04:19 -0700728// StoreMeterInfoForOnu updates the meter id in the KV-Store for the given onu based on the path
Gamze Abakafee36392019-10-03 11:17:24 +0000729// This path is formed as the following: <(pon_id, onu_id, uni_id)>/<tp_id>/meter_id/<direction>
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700730func (rsrcMgr *OpenOltResourceMgr) StoreMeterInfoForOnu(ctx context.Context, Direction string, intfID uint32, onuID uint32,
731 uniID uint32, tpID uint32, meterInfo *MeterInfo) error {
Manikkaraj kb1d51442019-07-23 10:41:02 -0400732 var Value []byte
733 var err error
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700734 intfOnuUniID := fmt.Sprintf(MeterIDPathSuffix, intfID, onuID, uniID, tpID, Direction)
735
Girish Gowdraa482f272021-03-24 23:04:19 -0700736 Value, err = json.Marshal(*meterInfo)
Manikkaraj kb1d51442019-07-23 10:41:02 -0400737 if err != nil {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000738 logger.Error(ctx, "failed to Marshal meter config")
Manikkaraj kb1d51442019-07-23 10:41:02 -0400739 return err
740 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700741 if err = rsrcMgr.KVStore.Put(ctx, intfOnuUniID, Value); err != nil {
742 logger.Errorf(ctx, "Failed to store meter into KV store %s", intfOnuUniID)
Manikkaraj kb1d51442019-07-23 10:41:02 -0400743 return err
744 }
Gamze Abaka745ccb72021-11-18 11:29:58 +0000745
746 // update cache
747 rsrcMgr.meterInfoForOnuLock.Lock()
748 rsrcMgr.meterInfoForOnu[intfOnuUniID] = meterInfo
749 rsrcMgr.meterInfoForOnuLock.Unlock()
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700750 logger.Debugw(ctx, "meter info updated successfully", log.Fields{"path": intfOnuUniID, "meter-info": meterInfo})
Manikkaraj kb1d51442019-07-23 10:41:02 -0400751 return err
752}
753
Girish Gowdraa482f272021-03-24 23:04:19 -0700754// GetMeterInfoForOnu fetches the meter id from the kv store for the given onu based on the path
Gamze Abakafee36392019-10-03 11:17:24 +0000755// This path is formed as the following: <(pon_id, onu_id, uni_id)>/<tp_id>/meter_id/<direction>
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700756func (rsrcMgr *OpenOltResourceMgr) GetMeterInfoForOnu(ctx context.Context, Direction string, intfID uint32, onuID uint32,
757 uniID uint32, tpID uint32) (*MeterInfo, error) {
758 Path := fmt.Sprintf(MeterIDPathSuffix, intfID, onuID, uniID, tpID, Direction)
759
760 // get from cache
761 rsrcMgr.meterInfoForOnuLock.RLock()
762 val, ok := rsrcMgr.meterInfoForOnu[Path]
763 rsrcMgr.meterInfoForOnuLock.RUnlock()
764 if ok {
765 return val, nil
766 }
767
Girish Gowdraa482f272021-03-24 23:04:19 -0700768 var meterInfo MeterInfo
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700769 Value, err := rsrcMgr.KVStore.Get(ctx, Path)
Manikkaraj kb1d51442019-07-23 10:41:02 -0400770 if err == nil {
771 if Value != nil {
Girish Gowdraa482f272021-03-24 23:04:19 -0700772 logger.Debug(ctx, "Found meter info in KV store", log.Fields{"Direction": Direction})
salmansiddiqui7ac62132019-08-22 03:58:50 +0000773 Val, er := kvstore.ToByte(Value.Value)
774 if er != nil {
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700775 logger.Errorw(ctx, "Failed to convert into byte array", log.Fields{"err": er})
salmansiddiqui7ac62132019-08-22 03:58:50 +0000776 return nil, er
Manikkaraj kb1d51442019-07-23 10:41:02 -0400777 }
Girish Gowdraa482f272021-03-24 23:04:19 -0700778 if er = json.Unmarshal(Val, &meterInfo); er != nil {
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700779 logger.Error(ctx, "Failed to unmarshal meter info", log.Fields{"err": er})
salmansiddiqui7ac62132019-08-22 03:58:50 +0000780 return nil, er
Manikkaraj kb1d51442019-07-23 10:41:02 -0400781 }
782 } else {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000783 logger.Debug(ctx, "meter-does-not-exists-in-KVStore")
Manikkaraj kb1d51442019-07-23 10:41:02 -0400784 return nil, err
785 }
786 } else {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000787 logger.Errorf(ctx, "Failed to get Meter config from kvstore for path %s", Path)
Manikkaraj kb1d51442019-07-23 10:41:02 -0400788
789 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700790 // update cache
791 rsrcMgr.meterInfoForOnuLock.Lock()
792 rsrcMgr.meterInfoForOnu[Path] = &meterInfo
793 rsrcMgr.meterInfoForOnuLock.Unlock()
794
Girish Gowdraa482f272021-03-24 23:04:19 -0700795 return &meterInfo, err
Manikkaraj kb1d51442019-07-23 10:41:02 -0400796}
797
Girish Gowdraa482f272021-03-24 23:04:19 -0700798// HandleMeterInfoRefCntUpdate increments or decrements the reference counter for a given meter.
799// When reference count becomes 0, it clears the meter information from the kv store
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700800func (rsrcMgr *OpenOltResourceMgr) HandleMeterInfoRefCntUpdate(ctx context.Context, Direction string,
801 intfID uint32, onuID uint32, uniID uint32, tpID uint32, increment bool) error {
802 meterInfo, err := rsrcMgr.GetMeterInfoForOnu(ctx, Direction, intfID, onuID, uniID, tpID)
Girish Gowdra82c80982021-03-26 16:22:02 -0700803 if err != nil {
804 return err
805 } else if meterInfo == nil {
806 // If we are increasing the reference count, we expect the meter information to be present on KV store.
807 // But if decrementing the reference count, the meter is possibly already cleared from KV store. Just log warn but do not return error.
808 if increment {
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700809 logger.Errorf(ctx, "error-fetching-meter-info-for-intf-%d-onu-%d-uni-%d-tp-id-%d-direction-%s", intfID, onuID, uniID, tpID, Direction)
810 return fmt.Errorf("error-fetching-meter-info-for-intf-%d-onu-%d-uni-%d-tp-id-%d-direction-%s", intfID, onuID, uniID, tpID, Direction)
Girish Gowdra82c80982021-03-26 16:22:02 -0700811 }
812 logger.Warnw(ctx, "meter is already cleared",
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700813 log.Fields{"intfID": intfID, "onuID": onuID, "uniID": uniID, "direction": Direction, "increment": increment})
Girish Gowdra82c80982021-03-26 16:22:02 -0700814 return nil
Girish Gowdraa482f272021-03-24 23:04:19 -0700815 }
Girish Gowdra82c80982021-03-26 16:22:02 -0700816
Girish Gowdraa482f272021-03-24 23:04:19 -0700817 if increment {
818 meterInfo.RefCnt++
819 } else {
820 meterInfo.RefCnt--
Girish Gowdraa482f272021-03-24 23:04:19 -0700821 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700822 if err := rsrcMgr.StoreMeterInfoForOnu(ctx, Direction, intfID, onuID, uniID, tpID, meterInfo); err != nil {
Girish Gowdraa482f272021-03-24 23:04:19 -0700823 return err
824 }
825 return nil
826}
827
828// RemoveMeterInfoForOnu deletes the meter id from the kV-Store for the given onu based on the path
Gamze Abakafee36392019-10-03 11:17:24 +0000829// This path is formed as the following: <(pon_id, onu_id, uni_id)>/<tp_id>/meter_id/<direction>
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700830func (rsrcMgr *OpenOltResourceMgr) RemoveMeterInfoForOnu(ctx context.Context, Direction string, intfID uint32, onuID uint32,
831 uniID uint32, tpID uint32) error {
832 Path := fmt.Sprintf(MeterIDPathSuffix, intfID, onuID, uniID, tpID, Direction)
833
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700834 if err := rsrcMgr.KVStore.Delete(ctx, Path); err != nil {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000835 logger.Errorf(ctx, "Failed to delete meter id %s from kvstore ", Path)
Manikkaraj kb1d51442019-07-23 10:41:02 -0400836 return err
837 }
Gamze Abaka745ccb72021-11-18 11:29:58 +0000838
839 // update cache
840 rsrcMgr.meterInfoForOnuLock.Lock()
841 delete(rsrcMgr.meterInfoForOnu, Path)
842 rsrcMgr.meterInfoForOnuLock.Unlock()
Manikkaraj kb1d51442019-07-23 10:41:02 -0400843 return nil
844}
salmansiddiqui7ac62132019-08-22 03:58:50 +0000845
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700846//AddGemToOnuGemInfo adds gemport to onugem info kvstore and also local cache
847func (rsrcMgr *OpenOltResourceMgr) AddGemToOnuGemInfo(ctx context.Context, intfID uint32, onuID uint32, gemPort uint32) error {
848 onugem, err := rsrcMgr.GetOnuGemInfo(ctx, intfID, onuID)
849 if err != nil || onugem == nil || onugem.SerialNumber == "" {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000850 logger.Errorf(ctx, "failed to get onuifo for intfid %d", intfID)
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +0530851 return err
852 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700853 if onugem.OnuID == onuID {
854 for _, gem := range onugem.GemPorts {
855 if gem == gemPort {
856 logger.Debugw(ctx, "Gem already present in onugem info, skpping addition", log.Fields{"gem": gem})
857 return nil
858 }
859 }
860 logger.Debugw(ctx, "Added gem to onugem info", log.Fields{"gem": gemPort})
861 onugem.GemPorts = append(onugem.GemPorts, gemPort)
862 } else {
863 logger.Errorw(ctx, "onu id in OnuGemInfo does not match", log.Fields{"onuID": onuID, "ponIf": intfID, "onuGemInfoOnuID": onugem.OnuID})
864 return fmt.Errorf("onu-id-in-OnuGemInfo-does-not-match-%v", onuID)
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +0530865 }
866
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700867 err = rsrcMgr.AddOnuGemInfo(ctx, intfID, onuID, *onugem)
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +0530868 if err != nil {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000869 logger.Error(ctx, "Failed to add onugem to kv store")
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +0530870 return err
871 }
872 return err
873}
874
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700875//RemoveGemFromOnuGemInfo removes gemport from onugem info on kvstore and also local cache
876func (rsrcMgr *OpenOltResourceMgr) RemoveGemFromOnuGemInfo(ctx context.Context, intfID uint32, onuID uint32, gemPort uint32) error {
877 onugem, err := rsrcMgr.GetOnuGemInfo(ctx, intfID, onuID)
878 if err != nil || onugem == nil || onugem.SerialNumber == "" {
879 logger.Errorf(ctx, "failed to get onuifo for intfid %d", intfID)
880 return err
881 }
882 updated := false
883 if onugem.OnuID == onuID {
884 for i, gem := range onugem.GemPorts {
885 if gem == gemPort {
886 logger.Debugw(ctx, "Gem found, removing from onu gem info", log.Fields{"gem": gem})
887 onugem.GemPorts = append(onugem.GemPorts[:i], onugem.GemPorts[i+1:]...)
888 updated = true
889 break
890 }
891 }
892 } else {
893 logger.Errorw(ctx, "onu id in OnuGemInfo does not match", log.Fields{"onuID": onuID, "ponIf": intfID, "onuGemInfoOnuID": onugem.OnuID})
894 return fmt.Errorf("onu-id-in-OnuGemInfo-does-not-match-%v", onuID)
895 }
896 if updated {
897 err = rsrcMgr.AddOnuGemInfo(ctx, intfID, onuID, *onugem)
898 if err != nil {
899 logger.Error(ctx, "Failed to add onugem to kv store")
900 return err
901 }
902 } else {
903 logger.Debugw(ctx, "Gem port not found in onu gem info", log.Fields{"gem": gemPort})
904 }
905 return nil
906}
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +0530907
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700908//GetOnuGemInfo gets onu gem info from the kvstore per interface
909func (rsrcMgr *OpenOltResourceMgr) GetOnuGemInfo(ctx context.Context, intfID uint32, onuID uint32) (*OnuGemInfo, error) {
910 var err error
911 var Val []byte
912 var onugem OnuGemInfo
913
914 path := fmt.Sprintf(OnuGemInfoPath, intfID, onuID)
915
916 rsrcMgr.onuGemInfoLock.RLock()
917 val, ok := rsrcMgr.onuGemInfo[path]
918 rsrcMgr.onuGemInfoLock.RUnlock()
919 if ok {
920 return val, nil
921 }
922 value, err := rsrcMgr.KVStore.Get(ctx, path)
923 if err != nil {
924 logger.Errorw(ctx, "Failed to get from kv store", log.Fields{"path": path})
925 return nil, err
926 } else if value == nil {
927 logger.Debug(ctx, "No onuinfo for path", log.Fields{"path": path})
928 return nil, nil // returning nil as this could happen if there are no onus for the interface yet
929 }
930 if Val, err = kvstore.ToByte(value.Value); err != nil {
931 logger.Error(ctx, "Failed to convert to byte array")
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +0530932 return nil, err
933 }
934
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700935 if err = json.Unmarshal(Val, &onugem); err != nil {
936 logger.Error(ctx, "Failed to unmarshall")
937 return nil, err
938 }
939 logger.Debugw(ctx, "found onugem info from path", log.Fields{"path": path, "onuGemInfo": onugem})
940 rsrcMgr.onuGemInfoLock.Lock()
941 rsrcMgr.onuGemInfo[path] = &onugem
942 rsrcMgr.onuGemInfoLock.Unlock()
943
944 return &onugem, nil
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +0530945}
946
Chaitrashree G S1a55b882020-02-04 17:35:35 -0500947// AddOnuGemInfo adds onu info on to the kvstore per interface
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700948func (rsrcMgr *OpenOltResourceMgr) AddOnuGemInfo(ctx context.Context, intfID uint32, onuID uint32, onuGem OnuGemInfo) error {
949
950 var Value []byte
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +0530951 var err error
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700952 Path := fmt.Sprintf(OnuGemInfoPath, intfID, onuID)
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +0530953
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700954 Value, err = json.Marshal(onuGem)
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +0530955 if err != nil {
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700956 logger.Error(ctx, "failed to Marshal")
957 return err
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +0530958 }
959
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700960 if err = rsrcMgr.KVStore.Put(ctx, Path, Value); err != nil {
961 logger.Errorf(ctx, "Failed to update resource %s", Path)
962 return err
963 }
Girish Gowdrabcf98af2021-07-01 08:24:42 -0700964 logger.Debugw(ctx, "added onu gem info to store", log.Fields{"onuGemInfo": onuGem})
Gamze Abaka745ccb72021-11-18 11:29:58 +0000965
966 //update cache
967 rsrcMgr.onuGemInfoLock.Lock()
968 rsrcMgr.onuGemInfo[Path] = &onuGem
969 rsrcMgr.onuGemInfoLock.Unlock()
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700970 return err
971}
972
973// DelOnuGemInfo deletes the onugem info from kvstore per ONU
974func (rsrcMgr *OpenOltResourceMgr) DelOnuGemInfo(ctx context.Context, intfID uint32, onuID uint32) error {
975 path := fmt.Sprintf(OnuGemInfoPath, intfID, onuID)
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700976
977 if err := rsrcMgr.KVStore.Delete(ctx, path); err != nil {
978 logger.Errorf(ctx, "failed to remove resource %s", path)
979 return err
980 }
Gamze Abaka745ccb72021-11-18 11:29:58 +0000981
982 //update cache
983 rsrcMgr.onuGemInfoLock.Lock()
984 logger.Debugw(ctx, "removing onu gem info", log.Fields{"onuGemInfo": rsrcMgr.onuGemInfo[path]})
985 delete(rsrcMgr.onuGemInfo, path)
986 rsrcMgr.onuGemInfoLock.Unlock()
Andrea Campanellab83b39d2020-03-30 11:41:16 +0200987 return nil
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +0530988}
989
Girish Gowdra950326e2021-11-05 12:43:24 -0700990//DeleteAllOnuGemInfoForIntf deletes all the all onu gem info on the given pon interface
991func (rsrcMgr *OpenOltResourceMgr) DeleteAllOnuGemInfoForIntf(ctx context.Context, intfID uint32) error {
992
993 path := fmt.Sprintf(OnuGemInfoPathPathPrefix, intfID)
994
995 logger.Debugw(ctx, "delete-all-onu-gem-info-for-pon-intf", log.Fields{"intfID": intfID})
996 if err := rsrcMgr.KVStore.DeleteWithPrefix(ctx, path); err != nil {
997 logger.Errorf(ctx, "failed-to-remove-resource-%s", path)
998 return err
999 }
1000
1001 // Reset cache. Normally not necessary as the entire device is getting deleted when this API is invoked.
1002 rsrcMgr.onuGemInfoLock.Lock()
1003 rsrcMgr.onuGemInfo = make(map[string]*OnuGemInfo)
1004 rsrcMgr.onuGemInfoLock.Unlock()
1005 return nil
1006}
1007
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301008// AddUniPortToOnuInfo adds uni port to the onuinfo kvstore. check if the uni is already present if not update the kv store.
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001009func (rsrcMgr *OpenOltResourceMgr) AddUniPortToOnuInfo(ctx context.Context, intfID uint32, onuID uint32, portNo uint32) {
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301010
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001011 onugem, err := rsrcMgr.GetOnuGemInfo(ctx, intfID, onuID)
1012 if err != nil || onugem == nil || onugem.SerialNumber == "" {
1013 logger.Warnf(ctx, "failed to get onuifo for intfid %d", intfID)
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301014 return
1015 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001016
1017 if onugem.OnuID == onuID {
1018 for _, uni := range onugem.UniPorts {
1019 if uni == portNo {
1020 logger.Debugw(ctx, "uni already present in onugem info", log.Fields{"uni": portNo})
1021 return
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301022 }
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301023 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001024 onugem.UniPorts = append(onugem.UniPorts, portNo)
1025 } else {
1026 logger.Warnw(ctx, "onu id mismatch in onu gem info", log.Fields{"intfID": intfID, "onuID": onuID})
1027 return
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301028 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001029 err = rsrcMgr.AddOnuGemInfo(ctx, intfID, onuID, *onugem)
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301030 if err != nil {
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001031 logger.Errorw(ctx, "Failed to add uni port in onugem to kv store", log.Fields{"uni": portNo})
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301032 return
1033 }
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301034}
1035
Esin Karaman7fb80c22020-07-16 14:23:33 +00001036//UpdateGemPortForPktIn updates gemport for pkt in path to kvstore, path being intfid, onuid, portno, vlan id, priority bit
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001037func (rsrcMgr *OpenOltResourceMgr) UpdateGemPortForPktIn(ctx context.Context, pktIn PacketInInfoKey, gemPort uint32) {
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301038
Girish Gowdra950326e2021-11-05 12:43:24 -07001039 path := fmt.Sprintf(OnuPacketInPath, pktIn.IntfID, pktIn.OnuID, pktIn.LogicalPort, pktIn.VlanID, pktIn.Priority)
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001040
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301041 Value, err := json.Marshal(gemPort)
1042 if err != nil {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001043 logger.Error(ctx, "Failed to marshal data")
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301044 return
1045 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001046 if err = rsrcMgr.KVStore.Put(ctx, path, Value); err != nil {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001047 logger.Errorw(ctx, "Failed to put to kvstore", log.Fields{"path": path, "value": gemPort})
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301048 return
1049 }
Gamze Abaka745ccb72021-11-18 11:29:58 +00001050
1051 // update cache
1052 rsrcMgr.gemPortForPacketInInfoLock.Lock()
1053 rsrcMgr.gemPortForPacketInInfo[path] = gemPort
1054 rsrcMgr.gemPortForPacketInInfoLock.Unlock()
Neha Sharma96b7bf22020-06-15 10:37:32 +00001055 logger.Debugw(ctx, "added gem packet in successfully", log.Fields{"path": path, "gem": gemPort})
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301056}
1057
Esin Karaman7fb80c22020-07-16 14:23:33 +00001058// GetGemPortFromOnuPktIn gets the gem port from onu pkt in path, path being intfid, onuid, portno, vlan id, priority bit
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001059func (rsrcMgr *OpenOltResourceMgr) GetGemPortFromOnuPktIn(ctx context.Context, packetInInfoKey PacketInInfoKey) (uint32, error) {
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301060
1061 var Val []byte
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301062
Girish Gowdra950326e2021-11-05 12:43:24 -07001063 path := fmt.Sprintf(OnuPacketInPath, packetInInfoKey.IntfID, packetInInfoKey.OnuID, packetInInfoKey.LogicalPort,
Esin Karaman7fb80c22020-07-16 14:23:33 +00001064 packetInInfoKey.VlanID, packetInInfoKey.Priority)
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001065 // get from cache
1066 rsrcMgr.gemPortForPacketInInfoLock.RLock()
1067 gemPort, ok := rsrcMgr.gemPortForPacketInInfo[path]
1068 rsrcMgr.gemPortForPacketInInfoLock.RUnlock()
1069 if ok {
1070 logger.Debugw(ctx, "found packein gemport from path", log.Fields{"path": path, "gem": gemPort})
1071 return gemPort, nil
1072 }
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301073
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001074 value, err := rsrcMgr.KVStore.Get(ctx, path)
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301075 if err != nil {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001076 logger.Errorw(ctx, "Failed to get from kv store", log.Fields{"path": path})
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301077 return uint32(0), err
1078 } else if value == nil {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001079 logger.Debugw(ctx, "No pkt in gem found", log.Fields{"path": path})
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301080 return uint32(0), nil
1081 }
1082
1083 if Val, err = kvstore.ToByte(value.Value); err != nil {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001084 logger.Error(ctx, "Failed to convert to byte array")
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301085 return uint32(0), err
1086 }
1087 if err = json.Unmarshal(Val, &gemPort); err != nil {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001088 logger.Error(ctx, "Failed to unmarshall")
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301089 return uint32(0), err
1090 }
Neha Sharma96b7bf22020-06-15 10:37:32 +00001091 logger.Debugw(ctx, "found packein gemport from path", log.Fields{"path": path, "gem": gemPort})
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001092 // update cache
1093 rsrcMgr.gemPortForPacketInInfoLock.Lock()
1094 rsrcMgr.gemPortForPacketInInfo[path] = gemPort
1095 rsrcMgr.gemPortForPacketInInfoLock.Unlock()
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301096
1097 return gemPort, nil
1098}
1099
Girish Gowdraa09aeab2020-09-14 16:30:52 -07001100//DeletePacketInGemPortForOnu deletes the packet-in gemport for ONU
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001101func (rsrcMgr *OpenOltResourceMgr) DeletePacketInGemPortForOnu(ctx context.Context, intfID uint32, onuID uint32, logicalPort uint32) error {
Girish Gowdra950326e2021-11-05 12:43:24 -07001102 path := fmt.Sprintf(OnuPacketInPathPrefix, intfID, onuID, logicalPort)
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001103 value, err := rsrcMgr.KVStore.List(ctx, path)
Esin Karaman7fb80c22020-07-16 14:23:33 +00001104 if err != nil {
Girish Gowdraa09aeab2020-09-14 16:30:52 -07001105 logger.Errorf(ctx, "failed-to-read-value-from-path-%s", path)
1106 return errors.New("failed-to-read-value-from-path-" + path)
Esin Karaman7fb80c22020-07-16 14:23:33 +00001107 }
Esin Karaman7fb80c22020-07-16 14:23:33 +00001108
Gamze Abaka745ccb72021-11-18 11:29:58 +00001109 logger.Debugw(ctx, "delete-packetin-gem-port", log.Fields{"realPath": path})
1110 if err := rsrcMgr.KVStore.DeleteWithPrefix(ctx, path); err != nil {
1111 logger.Errorf(ctx, "failed-to-remove-resource-%s", path)
1112 return err
1113 }
1114
Esin Karaman7fb80c22020-07-16 14:23:33 +00001115 //remove them one by one
Girish Gowdraa09aeab2020-09-14 16:30:52 -07001116 for key := range value {
serkant.uluderya4f5ed592020-12-17 20:57:59 +03001117 // Remove the PathPrefix from the path on KV key.
Girish Gowdra950326e2021-11-05 12:43:24 -07001118 // gemPortForPacketInInfo cache uses OnuPacketInPath as the key
serkant.uluderya4f5ed592020-12-17 20:57:59 +03001119 stringToBeReplaced := rsrcMgr.KVStore.PathPrefix + "/"
Girish Gowdraa09aeab2020-09-14 16:30:52 -07001120 replacedWith := ""
1121 key = strings.Replace(key, stringToBeReplaced, replacedWith, 1)
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001122 // update cache
1123 rsrcMgr.gemPortForPacketInInfoLock.Lock()
1124 delete(rsrcMgr.gemPortForPacketInInfo, key)
1125 rsrcMgr.gemPortForPacketInInfoLock.Unlock()
Girish Gowdraa09aeab2020-09-14 16:30:52 -07001126
serkant.uluderya4f5ed592020-12-17 20:57:59 +03001127 logger.Debugw(ctx, "removed-key-from-packetin-gem-port-cache", log.Fields{"key": key, "cache-len": len(rsrcMgr.gemPortForPacketInInfo)})
1128 }
1129
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301130 return nil
1131}
1132
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001133//GetFlowIDsForGem gets the list of FlowIDs for the given gemport
1134func (rsrcMgr *OpenOltResourceMgr) GetFlowIDsForGem(ctx context.Context, intf uint32, gem uint32) ([]uint64, error) {
1135 path := fmt.Sprintf(FlowIDsForGem, intf, gem)
1136
1137 // get from cache
1138 rsrcMgr.flowIDsForGemLock.RLock()
1139 flowIDs, ok := rsrcMgr.flowIDsForGem[gem]
1140 rsrcMgr.flowIDsForGemLock.RUnlock()
1141 if ok {
1142 return flowIDs, nil
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301143 }
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301144
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001145 value, err := rsrcMgr.KVStore.Get(ctx, path)
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301146 if err != nil {
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001147 logger.Errorw(ctx, "Failed to get from kv store", log.Fields{"path": path})
1148 return nil, err
1149 } else if value == nil {
1150 logger.Debug(ctx, "no flow-ids found", log.Fields{"path": path})
1151 return nil, nil
1152 }
1153 Val, err := kvstore.ToByte(value.Value)
1154 if err != nil {
1155 logger.Error(ctx, "Failed to convert to byte array")
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301156 return nil, err
1157 }
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301158
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001159 if err = json.Unmarshal(Val, &flowIDs); err != nil {
1160 logger.Error(ctx, "Failed to unmarshall")
1161 return nil, err
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301162 }
1163
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001164 // update cache
1165 rsrcMgr.flowIDsForGemLock.Lock()
1166 rsrcMgr.flowIDsForGem[gem] = flowIDs
1167 rsrcMgr.flowIDsForGemLock.Unlock()
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301168
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001169 return flowIDs, nil
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301170}
Abhilash Laxmeshwar275c0742019-11-25 16:47:02 +05301171
1172//UpdateFlowIDsForGem updates flow id per gemport
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001173func (rsrcMgr *OpenOltResourceMgr) UpdateFlowIDsForGem(ctx context.Context, intf uint32, gem uint32, flowIDs []uint64) error {
Abhilash Laxmeshwar275c0742019-11-25 16:47:02 +05301174 var val []byte
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001175 path := fmt.Sprintf(FlowIDsForGem, intf, gem)
Abhilash Laxmeshwar275c0742019-11-25 16:47:02 +05301176
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001177 if flowIDs == nil {
Girish Gowdra950326e2021-11-05 12:43:24 -07001178 if err := rsrcMgr.KVStore.Delete(ctx, path); err != nil {
1179 logger.Errorw(ctx, "Failed to delete from kvstore", log.Fields{"err": err, "path": path})
1180 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001181 return nil
Abhilash Laxmeshwar275c0742019-11-25 16:47:02 +05301182 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001183 val, err := json.Marshal(flowIDs)
Abhilash Laxmeshwar275c0742019-11-25 16:47:02 +05301184 if err != nil {
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001185 logger.Error(ctx, "Failed to marshal data", log.Fields{"err": err})
Abhilash Laxmeshwar275c0742019-11-25 16:47:02 +05301186 return err
1187 }
Girish Gowdrab77ded92020-04-08 11:45:05 -07001188
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001189 if err = rsrcMgr.KVStore.Put(ctx, path, val); err != nil {
1190 logger.Errorw(ctx, "Failed to put to kvstore", log.Fields{"err": err, "path": path, "value": val})
Abhilash Laxmeshwar275c0742019-11-25 16:47:02 +05301191 return err
1192 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001193 logger.Debugw(ctx, "added flowid list for gem to kv successfully", log.Fields{"path": path, "flowidlist": flowIDs})
Gamze Abaka745ccb72021-11-18 11:29:58 +00001194
1195 // update cache
1196 rsrcMgr.flowIDsForGemLock.Lock()
1197 rsrcMgr.flowIDsForGem[gem] = flowIDs
1198 rsrcMgr.flowIDsForGemLock.Unlock()
Abhilash Laxmeshwar275c0742019-11-25 16:47:02 +05301199 return nil
1200}
1201
1202//DeleteFlowIDsForGem deletes the flowID list entry per gem from kvstore.
Gamze Abaka745ccb72021-11-18 11:29:58 +00001203func (rsrcMgr *OpenOltResourceMgr) DeleteFlowIDsForGem(ctx context.Context, intf uint32, gem uint32) error {
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001204 path := fmt.Sprintf(FlowIDsForGem, intf, gem)
Gamze Abaka745ccb72021-11-18 11:29:58 +00001205 if err := rsrcMgr.KVStore.Delete(ctx, path); err != nil {
1206 logger.Errorw(ctx, "Failed to delete from kvstore", log.Fields{"err": err, "path": path})
1207 return err
1208 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001209 // update cache
1210 rsrcMgr.flowIDsForGemLock.Lock()
1211 delete(rsrcMgr.flowIDsForGem, gem)
1212 rsrcMgr.flowIDsForGemLock.Unlock()
Gamze Abaka745ccb72021-11-18 11:29:58 +00001213 return nil
Abhilash Laxmeshwar6d1acb92020-01-17 15:43:03 +05301214}
Esin Karamanccb714b2019-11-29 15:02:06 +00001215
Girish Gowdra950326e2021-11-05 12:43:24 -07001216//DeleteAllFlowIDsForGemForIntf deletes all the flow ids associated for all the gems on the given pon interface
1217func (rsrcMgr *OpenOltResourceMgr) DeleteAllFlowIDsForGemForIntf(ctx context.Context, intfID uint32) error {
1218
1219 path := fmt.Sprintf(FlowIDsForGemPathPrefix, intfID)
1220
1221 logger.Debugw(ctx, "delete-flow-ids-for-gem-for-pon-intf", log.Fields{"intfID": intfID})
1222 if err := rsrcMgr.KVStore.DeleteWithPrefix(ctx, path); err != nil {
1223 logger.Errorf(ctx, "failed-to-remove-resource-%s", path)
1224 return err
1225 }
1226
1227 // Reset cache. Normally not necessary as the entire device is getting deleted when this API is invoked.
1228 rsrcMgr.flowIDsForGemLock.Lock()
1229 rsrcMgr.flowIDsForGem = make(map[uint32][]uint64)
1230 rsrcMgr.flowIDsForGemLock.Unlock()
1231 return nil
1232}
1233
Esin Karamanccb714b2019-11-29 15:02:06 +00001234//GetMcastQueuePerInterfaceMap gets multicast queue info per pon interface
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001235func (rsrcMgr *OpenOltResourceMgr) GetMcastQueuePerInterfaceMap(ctx context.Context) (map[uint32][]uint32, error) {
Kent Hagermane6ff1012020-07-14 15:07:53 -04001236 path := McastQueuesForIntf
Esin Karamanccb714b2019-11-29 15:02:06 +00001237 var val []byte
1238
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001239 rsrcMgr.mcastQueueForIntfLock.RLock()
1240 if rsrcMgr.mcastQueueForIntfLoadedFromKvStore {
1241 rsrcMgr.mcastQueueForIntfLock.RUnlock()
1242 return rsrcMgr.mcastQueueForIntf, nil
1243 }
1244 rsrcMgr.mcastQueueForIntfLock.RUnlock()
1245
1246 kvPair, err := rsrcMgr.KVStore.Get(ctx, path)
Esin Karamanccb714b2019-11-29 15:02:06 +00001247 if err != nil {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001248 logger.Error(ctx, "failed to get data from kv store")
Esin Karamanccb714b2019-11-29 15:02:06 +00001249 return nil, err
1250 }
1251 if kvPair != nil && kvPair.Value != nil {
1252 if val, err = kvstore.ToByte(kvPair.Value); err != nil {
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001253 logger.Error(ctx, "Failed to convert to byte array ", log.Fields{"err": err})
Esin Karamanccb714b2019-11-29 15:02:06 +00001254 return nil, err
1255 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001256 rsrcMgr.mcastQueueForIntfLock.Lock()
1257 defer rsrcMgr.mcastQueueForIntfLock.Unlock()
1258 if err = json.Unmarshal(val, &rsrcMgr.mcastQueueForIntf); err != nil {
1259 logger.Error(ctx, "Failed to unmarshall ", log.Fields{"err": err})
Esin Karamanccb714b2019-11-29 15:02:06 +00001260 return nil, err
1261 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001262 rsrcMgr.mcastQueueForIntfLoadedFromKvStore = true
Esin Karamanccb714b2019-11-29 15:02:06 +00001263 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001264 return rsrcMgr.mcastQueueForIntf, nil
Esin Karamanccb714b2019-11-29 15:02:06 +00001265}
1266
1267//AddMcastQueueForIntf adds multicast queue for pon interface
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001268func (rsrcMgr *OpenOltResourceMgr) AddMcastQueueForIntf(ctx context.Context, intf uint32, gem uint32, servicePriority uint32) error {
Esin Karamanccb714b2019-11-29 15:02:06 +00001269 var val []byte
Kent Hagermane6ff1012020-07-14 15:07:53 -04001270 path := McastQueuesForIntf
Esin Karamanccb714b2019-11-29 15:02:06 +00001271
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001272 // Load local cache from kv store the first time
1273 rsrcMgr.mcastQueueForIntfLock.RLock()
1274 if !rsrcMgr.mcastQueueForIntfLoadedFromKvStore {
1275 rsrcMgr.mcastQueueForIntfLock.RUnlock()
1276 _, err := rsrcMgr.GetMcastQueuePerInterfaceMap(ctx)
1277 if err != nil {
1278 logger.Errorw(ctx, "Failed to get multicast queue info for interface", log.Fields{"err": err, "intf": intf})
1279 return err
1280 }
1281 } else {
1282 rsrcMgr.mcastQueueForIntfLock.RUnlock()
1283 }
1284
1285 // Update KV store
1286 rsrcMgr.mcastQueueForIntfLock.Lock()
1287 rsrcMgr.mcastQueueForIntf[intf] = []uint32{gem, servicePriority}
1288 val, err := json.Marshal(rsrcMgr.mcastQueueForIntf)
Esin Karamanccb714b2019-11-29 15:02:06 +00001289 if err != nil {
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001290 rsrcMgr.mcastQueueForIntfLock.Unlock()
1291 logger.Errorw(ctx, "Failed to marshal data", log.Fields{"err": err})
Esin Karamanccb714b2019-11-29 15:02:06 +00001292 return err
1293 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001294 rsrcMgr.mcastQueueForIntfLock.Unlock()
1295
1296 if err = rsrcMgr.KVStore.Put(ctx, path, val); err != nil {
1297 logger.Errorw(ctx, "Failed to put to kvstore", log.Fields{"err": err, "path": path, "value": val})
Esin Karamanccb714b2019-11-29 15:02:06 +00001298 return err
1299 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001300 logger.Debugw(ctx, "added multicast queue info to KV store successfully", log.Fields{"path": path, "interfaceId": intf, "gem": gem, "svcPrior": servicePriority})
Esin Karamanccb714b2019-11-29 15:02:06 +00001301 return nil
1302}
1303
1304//AddFlowGroupToKVStore adds flow group into KV store
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001305func (rsrcMgr *OpenOltResourceMgr) AddFlowGroupToKVStore(ctx context.Context, groupEntry *ofp.OfpGroupEntry, cached bool) error {
Esin Karamanccb714b2019-11-29 15:02:06 +00001306 var Value []byte
1307 var err error
1308 var path string
1309 if cached {
1310 path = fmt.Sprintf(FlowGroupCached, groupEntry.Desc.GroupId)
1311 } else {
1312 path = fmt.Sprintf(FlowGroup, groupEntry.Desc.GroupId)
1313 }
1314 //build group info object
1315 var outPorts []uint32
1316 for _, ofBucket := range groupEntry.Desc.Buckets {
1317 for _, ofAction := range ofBucket.Actions {
1318 if ofAction.Type == ofp.OfpActionType_OFPAT_OUTPUT {
1319 outPorts = append(outPorts, ofAction.GetOutput().Port)
1320 }
1321 }
1322 }
1323 groupInfo := GroupInfo{
1324 GroupID: groupEntry.Desc.GroupId,
1325 OutPorts: outPorts,
1326 }
1327
1328 Value, err = json.Marshal(groupInfo)
1329
1330 if err != nil {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001331 logger.Error(ctx, "failed to Marshal flow group object")
Esin Karamanccb714b2019-11-29 15:02:06 +00001332 return err
1333 }
1334
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001335 if err = rsrcMgr.KVStore.Put(ctx, path, Value); err != nil {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001336 logger.Errorf(ctx, "Failed to update resource %s", path)
Esin Karamanccb714b2019-11-29 15:02:06 +00001337 return err
1338 }
Gamze Abaka745ccb72021-11-18 11:29:58 +00001339
1340 // update cache
1341 rsrcMgr.groupInfoLock.Lock()
1342 rsrcMgr.groupInfo[path] = &groupInfo
1343 rsrcMgr.groupInfoLock.Unlock()
Esin Karamanccb714b2019-11-29 15:02:06 +00001344 return nil
1345}
1346
1347//RemoveFlowGroupFromKVStore removes flow group from KV store
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001348func (rsrcMgr *OpenOltResourceMgr) RemoveFlowGroupFromKVStore(ctx context.Context, groupID uint32, cached bool) error {
Esin Karamanccb714b2019-11-29 15:02:06 +00001349 var path string
1350 if cached {
1351 path = fmt.Sprintf(FlowGroupCached, groupID)
1352 } else {
1353 path = fmt.Sprintf(FlowGroup, groupID)
1354 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001355
1356 if err := rsrcMgr.KVStore.Delete(ctx, path); err != nil {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001357 logger.Errorf(ctx, "Failed to remove resource %s due to %s", path, err)
Esin Karamand519bbf2020-07-01 11:16:03 +00001358 return err
Esin Karamanccb714b2019-11-29 15:02:06 +00001359 }
Gamze Abaka745ccb72021-11-18 11:29:58 +00001360
1361 // update cache
1362 rsrcMgr.groupInfoLock.Lock()
1363 delete(rsrcMgr.groupInfo, path)
1364 rsrcMgr.groupInfoLock.Unlock()
Esin Karamand519bbf2020-07-01 11:16:03 +00001365 return nil
Esin Karamanccb714b2019-11-29 15:02:06 +00001366}
1367
1368//GetFlowGroupFromKVStore fetches flow group from the KV store. Returns (false, {} error) if any problem occurs during
1369//fetching the data. Returns (true, groupInfo, nil) if the group is fetched successfully.
1370// Returns (false, {}, nil) if the group does not exists in the KV store.
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001371func (rsrcMgr *OpenOltResourceMgr) GetFlowGroupFromKVStore(ctx context.Context, groupID uint32, cached bool) (bool, GroupInfo, error) {
Esin Karamanccb714b2019-11-29 15:02:06 +00001372 var groupInfo GroupInfo
1373 var path string
1374 if cached {
1375 path = fmt.Sprintf(FlowGroupCached, groupID)
1376 } else {
1377 path = fmt.Sprintf(FlowGroup, groupID)
1378 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001379
1380 // read from cache
1381 rsrcMgr.groupInfoLock.RLock()
1382 gi, ok := rsrcMgr.groupInfo[path]
1383 rsrcMgr.groupInfoLock.RUnlock()
1384 if ok {
1385 return true, *gi, nil
1386 }
1387
1388 kvPair, err := rsrcMgr.KVStore.Get(ctx, path)
Esin Karamanccb714b2019-11-29 15:02:06 +00001389 if err != nil {
1390 return false, groupInfo, err
1391 }
1392 if kvPair != nil && kvPair.Value != nil {
1393 Val, err := kvstore.ToByte(kvPair.Value)
1394 if err != nil {
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001395 logger.Errorw(ctx, "Failed to convert flow group into byte array", log.Fields{"err": err})
Esin Karamanccb714b2019-11-29 15:02:06 +00001396 return false, groupInfo, err
1397 }
1398 if err = json.Unmarshal(Val, &groupInfo); err != nil {
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001399 logger.Errorw(ctx, "Failed to unmarshal", log.Fields{"err": err})
Esin Karamanccb714b2019-11-29 15:02:06 +00001400 return false, groupInfo, err
1401 }
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -07001402 // update cache
1403 rsrcMgr.groupInfoLock.Lock()
1404 rsrcMgr.groupInfo[path] = &groupInfo
1405 rsrcMgr.groupInfoLock.Unlock()
1406
Esin Karamanccb714b2019-11-29 15:02:06 +00001407 return true, groupInfo, nil
1408 }
1409 return false, groupInfo, nil
1410}
Girish Gowdraa09aeab2020-09-14 16:30:52 -07001411
1412// toByte converts an interface value to a []byte. The interface should either be of
1413// a string type or []byte. Otherwise, an error is returned.
1414func toByte(value interface{}) ([]byte, error) {
1415 switch t := value.(type) {
1416 case []byte:
1417 return value.([]byte), nil
1418 case string:
1419 return []byte(value.(string)), nil
1420 default:
1421 return nil, fmt.Errorf("unexpected-type-%T", t)
1422 }
1423}