blob: b7d7737bfdf57273bd66340cc7222e63ba2e9fb9 [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 (
Girish Gowdru0c588b22019-04-23 23:24:56 -040021 "encoding/json"
22 "errors"
23 "fmt"
24 "strconv"
25 "strings"
Abhilash S.L7f17e402019-03-15 17:40:41 +053026
Girish Gowdru0c588b22019-04-23 23:24:56 -040027 "github.com/opencord/voltha-go/common/log"
28 ponrmgr "github.com/opencord/voltha-go/common/ponresourcemanager"
29 "github.com/opencord/voltha-go/db/kvstore"
30 "github.com/opencord/voltha-go/db/model"
31 "github.com/opencord/voltha-protos/go/openolt"
Abhilash S.L7f17e402019-03-15 17:40:41 +053032)
33
Girish Gowdru6a80bbd2019-07-02 07:36:09 -070034// KvstoreTimeout specifies the time out for KV Store Connection
35const KvstoreTimeout = 5
Abhilash S.L7f17e402019-03-15 17:40:41 +053036
Girish Gowdru6a80bbd2019-07-02 07:36:09 -070037// BasePathKvStore - service/voltha/openolt/<device_id>
38const BasePathKvStore = "service/voltha/openolt/{%s}"
39
40// FlowInfo holds the flow information
Abhilash S.L8ee90712019-04-29 16:24:22 +053041type FlowInfo struct {
42 Flow *openolt.Flow
43 FlowStoreCookie uint64
44 FlowCategory string
45}
Girish Gowdru6a80bbd2019-07-02 07:36:09 -070046
47// OpenOltResourceMgr holds resource related information as provided below for each field
Abhilash S.L7f17e402019-03-15 17:40:41 +053048type OpenOltResourceMgr struct {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -070049 DeviceID string // OLT device id
Girish Gowdru0c588b22019-04-23 23:24:56 -040050 HostAndPort string // Host and port of the kv store to connect to
51 Args string // args
52 KVStore *model.Backend // backend kv store connection handle
53 DeviceType string
54 Host string // Host ip of the kv store
55 Port int // port of the kv store
56 DevInfo *openolt.DeviceInfo // device information
57 // array of pon resource managers per interface technology
58 ResourceMgrs map[uint32]*ponrmgr.PONResourceManager
Abhilash S.L7f17e402019-03-15 17:40:41 +053059}
60
Girish Gowdru6a80bbd2019-07-02 07:36:09 -070061func newKVClient(storeType, address string, timeout uint32) (kvstore.Client, error) {
Girish Gowdru0c588b22019-04-23 23:24:56 -040062 log.Infow("kv-store-type", log.Fields{"store": storeType})
63 switch storeType {
64 case "consul":
65 return kvstore.NewConsulClient(address, int(timeout))
66 case "etcd":
67 return kvstore.NewEtcdClient(address, int(timeout))
68 }
69 return nil, errors.New("unsupported-kv-store")
Abhilash S.L7f17e402019-03-15 17:40:41 +053070}
71
Girish Gowdru6a80bbd2019-07-02 07:36:09 -070072// SetKVClient sets the KV client and return a kv backend
73func SetKVClient(backend string, Host string, Port int, DeviceID string) *model.Backend {
Girish Gowdru0c588b22019-04-23 23:24:56 -040074 addr := Host + ":" + strconv.Itoa(Port)
75 // TODO : Make sure direct call to NewBackend is working fine with backend , currently there is some
76 // issue between kv store and backend , core is not calling NewBackend directly
Girish Gowdru6a80bbd2019-07-02 07:36:09 -070077 kvClient, err := newKVClient(backend, addr, KvstoreTimeout)
Girish Gowdru0c588b22019-04-23 23:24:56 -040078 if err != nil {
79 log.Fatalw("Failed to init KV client\n", log.Fields{"err": err})
80 return nil
81 }
82 kvbackend := &model.Backend{
83 Client: kvClient,
Girish Gowdru6a80bbd2019-07-02 07:36:09 -070084 StoreType: backend,
Girish Gowdru0c588b22019-04-23 23:24:56 -040085 Host: Host,
86 Port: Port,
Girish Gowdru6a80bbd2019-07-02 07:36:09 -070087 Timeout: KvstoreTimeout,
88 PathPrefix: fmt.Sprintf(BasePathKvStore, DeviceID)}
Abhilash S.L7f17e402019-03-15 17:40:41 +053089
Girish Gowdru0c588b22019-04-23 23:24:56 -040090 return kvbackend
Abhilash S.L7f17e402019-03-15 17:40:41 +053091}
92
Girish Gowdru6a80bbd2019-07-02 07:36:09 -070093// NewResourceMgr init a New resource maanger instance which in turn instantiates pon resource manager
94// instances according to technology. Initializes the default resource ranges for all
95// the resources.
96func NewResourceMgr(deviceID string, KVStoreHostPort string, kvStoreType string, deviceType string, devInfo *openolt.DeviceInfo) *OpenOltResourceMgr {
Girish Gowdru0c588b22019-04-23 23:24:56 -040097 var ResourceMgr OpenOltResourceMgr
Girish Gowdru6a80bbd2019-07-02 07:36:09 -070098 log.Debugf("Init new resource manager , host_port: %s, deviceid: %s", KVStoreHostPort, deviceID)
Abhilash S.L8ee90712019-04-29 16:24:22 +053099 ResourceMgr.HostAndPort = KVStoreHostPort
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700100 ResourceMgr.DeviceType = deviceType
101 ResourceMgr.DevInfo = devInfo
102 IPPort := strings.Split(KVStoreHostPort, ":")
103 ResourceMgr.Host = IPPort[0]
104 ResourceMgr.Port, _ = strconv.Atoi(IPPort[1])
Abhilash S.L7f17e402019-03-15 17:40:41 +0530105
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700106 Backend := kvStoreType
Girish Gowdru0c588b22019-04-23 23:24:56 -0400107 ResourceMgr.KVStore = SetKVClient(Backend, ResourceMgr.Host,
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700108 ResourceMgr.Port, deviceID)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400109 if ResourceMgr.KVStore == nil {
110 log.Error("Failed to setup KV store")
111 }
112 Ranges := make(map[string]*openolt.DeviceInfo_DeviceResourceRanges)
113 RsrcMgrsByTech := make(map[string]*ponrmgr.PONResourceManager)
114 ResourceMgr.ResourceMgrs = make(map[uint32]*ponrmgr.PONResourceManager)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530115
Girish Gowdru0c588b22019-04-23 23:24:56 -0400116 // TODO self.args = registry('main').get_args()
Abhilash S.L7f17e402019-03-15 17:40:41 +0530117
Girish Gowdru0c588b22019-04-23 23:24:56 -0400118 /*
119 If a legacy driver returns protobuf without any ranges,s synthesize one from
120 the legacy global per-device informaiton. This, in theory, is temporary until
121 the legacy drivers are upgrade to support pool ranges.
122 */
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700123 if devInfo.Ranges == nil {
Girish Gowdru0c588b22019-04-23 23:24:56 -0400124 var ranges openolt.DeviceInfo_DeviceResourceRanges
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700125 ranges.Technology = devInfo.GetTechnology()
Abhilash S.L7f17e402019-03-15 17:40:41 +0530126
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700127 NumPONPorts := devInfo.GetPonPorts()
Girish Gowdru0c588b22019-04-23 23:24:56 -0400128 var index uint32
129 for index = 0; index < NumPONPorts; index++ {
130 ranges.IntfIds = append(ranges.IntfIds, index)
131 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530132
Abhilash S.L8ee90712019-04-29 16:24:22 +0530133 var Pool openolt.DeviceInfo_DeviceResourceRanges_Pool
Girish Gowdru0c588b22019-04-23 23:24:56 -0400134 Pool.Type = openolt.DeviceInfo_DeviceResourceRanges_Pool_ONU_ID
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700135 Pool.Start = devInfo.OnuIdStart
136 Pool.End = devInfo.OnuIdEnd
Girish Gowdru0c588b22019-04-23 23:24:56 -0400137 Pool.Sharing = openolt.DeviceInfo_DeviceResourceRanges_Pool_DEDICATED_PER_INTF
Abhilash S.L8ee90712019-04-29 16:24:22 +0530138 ranges.Pools = append(ranges.Pools, &Pool)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530139
Girish Gowdru0c588b22019-04-23 23:24:56 -0400140 Pool.Type = openolt.DeviceInfo_DeviceResourceRanges_Pool_ALLOC_ID
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700141 Pool.Start = devInfo.AllocIdStart
142 Pool.End = devInfo.AllocIdEnd
Girish Gowdru0c588b22019-04-23 23:24:56 -0400143 Pool.Sharing = openolt.DeviceInfo_DeviceResourceRanges_Pool_SHARED_BY_ALL_INTF_ALL_TECH
Abhilash S.L8ee90712019-04-29 16:24:22 +0530144 ranges.Pools = append(ranges.Pools, &Pool)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530145
Girish Gowdru0c588b22019-04-23 23:24:56 -0400146 Pool.Type = openolt.DeviceInfo_DeviceResourceRanges_Pool_GEMPORT_ID
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700147 Pool.Start = devInfo.GemportIdStart
148 Pool.End = devInfo.GemportIdEnd
Girish Gowdru0c588b22019-04-23 23:24:56 -0400149 Pool.Sharing = openolt.DeviceInfo_DeviceResourceRanges_Pool_SHARED_BY_ALL_INTF_ALL_TECH
Abhilash S.L8ee90712019-04-29 16:24:22 +0530150 ranges.Pools = append(ranges.Pools, &Pool)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530151
Girish Gowdru0c588b22019-04-23 23:24:56 -0400152 Pool.Type = openolt.DeviceInfo_DeviceResourceRanges_Pool_FLOW_ID
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700153 Pool.Start = devInfo.FlowIdStart
154 Pool.End = devInfo.FlowIdEnd
Girish Gowdru0c588b22019-04-23 23:24:56 -0400155 Pool.Sharing = openolt.DeviceInfo_DeviceResourceRanges_Pool_SHARED_BY_ALL_INTF_ALL_TECH
Abhilash S.L8ee90712019-04-29 16:24:22 +0530156 ranges.Pools = append(ranges.Pools, &Pool)
157 // Add to device info
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700158 devInfo.Ranges = append(devInfo.Ranges, &ranges)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400159 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530160
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700161 // Create a separate Resource Manager instance for each range. This assumes that
Girish Gowdru0c588b22019-04-23 23:24:56 -0400162 // each technology is represented by only a single range
163 var GlobalPONRsrcMgr *ponrmgr.PONResourceManager
164 var err error
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700165 for _, TechRange := range devInfo.Ranges {
Girish Gowdru0c588b22019-04-23 23:24:56 -0400166 technology := TechRange.Technology
167 log.Debugf("Device info technology %s", technology)
168 Ranges[technology] = TechRange
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700169 RsrcMgrsByTech[technology], err = ponrmgr.NewPONResourceManager(technology, deviceType, deviceID,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400170 Backend, ResourceMgr.Host, ResourceMgr.Port)
171 if err != nil {
172 log.Errorf("Failed to create pon resource manager instacnce for technology %s", technology)
173 return nil
174 }
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700175 // resource_mgrs_by_tech[technology] = resource_mgr
Girish Gowdru0c588b22019-04-23 23:24:56 -0400176 if GlobalPONRsrcMgr == nil {
177 GlobalPONRsrcMgr = RsrcMgrsByTech[technology]
178 }
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700179 for _, IntfID := range TechRange.IntfIds {
180 ResourceMgr.ResourceMgrs[uint32(IntfID)] = RsrcMgrsByTech[technology]
Girish Gowdru0c588b22019-04-23 23:24:56 -0400181 }
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700182 // self.initialize_device_resource_range_and_pool(resource_mgr, global_resource_mgr, arange)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400183 InitializeDeviceResourceRangeAndPool(RsrcMgrsByTech[technology], GlobalPONRsrcMgr,
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700184 TechRange, devInfo)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400185 }
186 // After we have initialized resource ranges, initialize the
187 // resource pools accordingly.
188 for _, PONRMgr := range RsrcMgrsByTech {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700189 _ = PONRMgr.InitDeviceResourcePool()
Girish Gowdru0c588b22019-04-23 23:24:56 -0400190 }
Abhilash S.L8ee90712019-04-29 16:24:22 +0530191 log.Info("Initialization of resource manager success!")
Girish Gowdru0c588b22019-04-23 23:24:56 -0400192 return &ResourceMgr
Abhilash S.L7f17e402019-03-15 17:40:41 +0530193}
194
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700195// InitializeDeviceResourceRangeAndPool initializes the resource range pool according to the sharing type, then apply
196// device specific information. If KV doesn't exist
197// or is broader than the device, the device's information will
198// dictate the range limits
199func InitializeDeviceResourceRangeAndPool(ponRMgr *ponrmgr.PONResourceManager, globalPONRMgr *ponrmgr.PONResourceManager,
200 techRange *openolt.DeviceInfo_DeviceResourceRanges, devInfo *openolt.DeviceInfo) {
Abhilash S.L7f17e402019-03-15 17:40:41 +0530201
Girish Gowdru0c588b22019-04-23 23:24:56 -0400202 // init the resource range pool according to the sharing type
Abhilash S.L7f17e402019-03-15 17:40:41 +0530203
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700204 log.Debugf("Resource range pool init for technology %s", ponRMgr.Technology)
205 // first load from KV profiles
206 status := ponRMgr.InitResourceRangesFromKVStore()
207 if !status {
208 log.Debugf("Failed to load resource ranges from KV store for tech %s", ponRMgr.Technology)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400209 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530210
Girish Gowdru0c588b22019-04-23 23:24:56 -0400211 /*
212 Then apply device specific information. If KV doesn't exist
213 or is broader than the device, the device's informationw ill
214 dictate the range limits
215 */
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700216 log.Debugf("Using device info to init pon resource ranges for tech", ponRMgr.Technology)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530217
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700218 ONUIDStart := devInfo.OnuIdStart
219 ONUIDEnd := devInfo.OnuIdEnd
Girish Gowdru0c588b22019-04-23 23:24:56 -0400220 ONUIDShared := openolt.DeviceInfo_DeviceResourceRanges_Pool_DEDICATED_PER_INTF
221 ONUIDSharedPoolID := uint32(0)
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700222 AllocIDStart := devInfo.AllocIdStart
223 AllocIDEnd := devInfo.AllocIdEnd
Girish Gowdru0c588b22019-04-23 23:24:56 -0400224 AllocIDShared := openolt.DeviceInfo_DeviceResourceRanges_Pool_SHARED_BY_ALL_INTF_ALL_TECH // TODO EdgeCore/BAL limitation
225 AllocIDSharedPoolID := uint32(0)
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700226 GEMPortIDStart := devInfo.GemportIdStart
227 GEMPortIDEnd := devInfo.GemportIdEnd
Girish Gowdru0c588b22019-04-23 23:24:56 -0400228 GEMPortIDShared := openolt.DeviceInfo_DeviceResourceRanges_Pool_SHARED_BY_ALL_INTF_ALL_TECH // TODO EdgeCore/BAL limitation
229 GEMPortIDSharedPoolID := uint32(0)
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700230 FlowIDStart := devInfo.FlowIdStart
231 FlowIDEnd := devInfo.FlowIdEnd
Girish Gowdru0c588b22019-04-23 23:24:56 -0400232 FlowIDShared := openolt.DeviceInfo_DeviceResourceRanges_Pool_SHARED_BY_ALL_INTF_ALL_TECH // TODO EdgeCore/BAL limitation
233 FlowIDSharedPoolID := uint32(0)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530234
Girish Gowdru0c588b22019-04-23 23:24:56 -0400235 var FirstIntfPoolID uint32
236 var SharedPoolID uint32
Abhilash S.L7f17e402019-03-15 17:40:41 +0530237
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400238 /*
239 * As a zero check is made against SharedPoolID to check whether the resources are shared across all intfs
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700240 * if resources are shared across interfaces then SharedPoolID is given a positive number.
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400241 */
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700242 for _, FirstIntfPoolID = range techRange.IntfIds {
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400243 // skip the intf id 0
244 if FirstIntfPoolID == 0 {
245 continue
246 }
Girish Gowdru0c588b22019-04-23 23:24:56 -0400247 break
248 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530249
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700250 for _, RangePool := range techRange.Pools {
Girish Gowdru0c588b22019-04-23 23:24:56 -0400251 if RangePool.Sharing == openolt.DeviceInfo_DeviceResourceRanges_Pool_SHARED_BY_ALL_INTF_ALL_TECH {
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400252 SharedPoolID = FirstIntfPoolID
Girish Gowdru0c588b22019-04-23 23:24:56 -0400253 } else if RangePool.Sharing == openolt.DeviceInfo_DeviceResourceRanges_Pool_SHARED_BY_ALL_INTF_SAME_TECH {
254 SharedPoolID = FirstIntfPoolID
255 } else {
256 SharedPoolID = 0
257 }
258 if RangePool.Type == openolt.DeviceInfo_DeviceResourceRanges_Pool_ONU_ID {
259 ONUIDStart = RangePool.Start
260 ONUIDEnd = RangePool.End
261 ONUIDShared = RangePool.Sharing
262 ONUIDSharedPoolID = SharedPoolID
263 } else if RangePool.Type == openolt.DeviceInfo_DeviceResourceRanges_Pool_ALLOC_ID {
264 AllocIDStart = RangePool.Start
265 AllocIDEnd = RangePool.End
266 AllocIDShared = RangePool.Sharing
267 AllocIDSharedPoolID = SharedPoolID
268 } else if RangePool.Type == openolt.DeviceInfo_DeviceResourceRanges_Pool_GEMPORT_ID {
269 GEMPortIDStart = RangePool.Start
270 GEMPortIDEnd = RangePool.End
271 GEMPortIDShared = RangePool.Sharing
272 GEMPortIDSharedPoolID = SharedPoolID
273 } else if RangePool.Type == openolt.DeviceInfo_DeviceResourceRanges_Pool_FLOW_ID {
274 FlowIDStart = RangePool.Start
275 FlowIDEnd = RangePool.End
276 FlowIDShared = RangePool.Sharing
277 FlowIDSharedPoolID = SharedPoolID
278 }
279 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530280
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700281 log.Debugw("Device info init", log.Fields{"technology": techRange.Technology,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400282 "onu_id_start": ONUIDStart, "onu_id_end": ONUIDEnd, "onu_id_shared_pool_id": ONUIDSharedPoolID,
283 "alloc_id_start": AllocIDStart, "alloc_id_end": AllocIDEnd,
284 "alloc_id_shared_pool_id": AllocIDSharedPoolID,
285 "gemport_id_start": GEMPortIDStart, "gemport_id_end": GEMPortIDEnd,
286 "gemport_id_shared_pool_id": GEMPortIDSharedPoolID,
287 "flow_id_start": FlowIDStart,
288 "flow_id_end_idx": FlowIDEnd,
289 "flow_id_shared_pool_id": FlowIDSharedPoolID,
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700290 "intf_ids": techRange.IntfIds,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400291 "uni_id_start": 0,
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700292 "uni_id_end_idx": 1, /*MaxUNIIDperONU()*/
293 })
Abhilash S.L7f17e402019-03-15 17:40:41 +0530294
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700295 ponRMgr.InitDefaultPONResourceRanges(ONUIDStart, ONUIDEnd, ONUIDSharedPoolID,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400296 AllocIDStart, AllocIDEnd, AllocIDSharedPoolID,
297 GEMPortIDStart, GEMPortIDEnd, GEMPortIDSharedPoolID,
298 FlowIDStart, FlowIDEnd, FlowIDSharedPoolID, 0, 1,
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700299 devInfo.PonPorts, techRange.IntfIds)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530300
Girish Gowdru0c588b22019-04-23 23:24:56 -0400301 // For global sharing, make sure to refresh both local and global resource manager instances' range
Abhilash S.L7f17e402019-03-15 17:40:41 +0530302
Girish Gowdru0c588b22019-04-23 23:24:56 -0400303 if ONUIDShared == openolt.DeviceInfo_DeviceResourceRanges_Pool_SHARED_BY_ALL_INTF_ALL_TECH {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700304 globalPONRMgr.UpdateRanges(ponrmgr.ONU_ID_START_IDX, ONUIDStart, ponrmgr.ONU_ID_END_IDX, ONUIDEnd,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400305 "", 0, nil)
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700306 ponRMgr.UpdateRanges(ponrmgr.ONU_ID_START_IDX, ONUIDStart, ponrmgr.ONU_ID_END_IDX, ONUIDEnd,
307 "", 0, globalPONRMgr)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400308 }
309 if AllocIDShared == openolt.DeviceInfo_DeviceResourceRanges_Pool_SHARED_BY_ALL_INTF_ALL_TECH {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700310 globalPONRMgr.UpdateRanges(ponrmgr.ALLOC_ID_START_IDX, AllocIDStart, ponrmgr.ALLOC_ID_END_IDX, AllocIDEnd,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400311 "", 0, nil)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530312
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700313 ponRMgr.UpdateRanges(ponrmgr.ALLOC_ID_START_IDX, AllocIDStart, ponrmgr.ALLOC_ID_END_IDX, AllocIDEnd,
314 "", 0, globalPONRMgr)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400315 }
316 if GEMPortIDShared == openolt.DeviceInfo_DeviceResourceRanges_Pool_SHARED_BY_ALL_INTF_ALL_TECH {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700317 globalPONRMgr.UpdateRanges(ponrmgr.GEMPORT_ID_START_IDX, GEMPortIDStart, ponrmgr.GEMPORT_ID_END_IDX, GEMPortIDEnd,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400318 "", 0, nil)
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700319 ponRMgr.UpdateRanges(ponrmgr.GEMPORT_ID_START_IDX, GEMPortIDStart, ponrmgr.GEMPORT_ID_END_IDX, GEMPortIDEnd,
320 "", 0, globalPONRMgr)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400321 }
322 if FlowIDShared == openolt.DeviceInfo_DeviceResourceRanges_Pool_SHARED_BY_ALL_INTF_ALL_TECH {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700323 globalPONRMgr.UpdateRanges(ponrmgr.FLOW_ID_START_IDX, FlowIDStart, ponrmgr.FLOW_ID_END_IDX, FlowIDEnd,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400324 "", 0, nil)
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700325 ponRMgr.UpdateRanges(ponrmgr.FLOW_ID_START_IDX, FlowIDStart, ponrmgr.FLOW_ID_END_IDX, FlowIDEnd,
326 "", 0, globalPONRMgr)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400327 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530328
Girish Gowdru0c588b22019-04-23 23:24:56 -0400329 // Make sure loaded range fits the platform bit encoding ranges
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700330 ponRMgr.UpdateRanges(ponrmgr.UNI_ID_START_IDX, 0, ponrmgr.UNI_ID_END_IDX /* TODO =OpenOltPlatform.MAX_UNIS_PER_ONU-1*/, 1, "", 0, nil)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530331}
332
333/* TODO
334def __del__(self):
335 self.log.info("clearing-device-resource-pool")
336 for key, resource_mgr in self.resource_mgrs.iteritems():
337 resource_mgr.clear_device_resource_pool()
338
339 def assert_pon_id_limit(self, pon_intf_id):
340 assert pon_intf_id in self.resource_mgrs
341
342 def assert_onu_id_limit(self, pon_intf_id, onu_id):
343 self.assert_pon_id_limit(pon_intf_id)
344 self.resource_mgrs[pon_intf_id].assert_resource_limits(onu_id, PONResourceManager.ONU_ID)
345
346 @property
347 def max_uni_id_per_onu(self):
348 return 0 #OpenOltPlatform.MAX_UNIS_PER_ONU-1, zero-based indexing Uncomment or override to make default multi-uni
349
350 def assert_uni_id_limit(self, pon_intf_id, onu_id, uni_id):
351 self.assert_onu_id_limit(pon_intf_id, onu_id)
352 self.resource_mgrs[pon_intf_id].assert_resource_limits(uni_id, PONResourceManager.UNI_ID)
353*/
354
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700355// GetONUID returns the available OnuID for the given pon-port
356func (RsrcMgr *OpenOltResourceMgr) GetONUID(ponIntfID uint32) (uint32, error) {
salmansiddiqui352a45c2019-08-19 10:15:36 +0000357 // Check if Pon Interface ID is present in Resource-manager-map
358 if _, ok := RsrcMgr.ResourceMgrs[ponIntfID]; !ok {
359 err := errors.New("invalid-pon-interface-" + strconv.Itoa(int(ponIntfID)))
360 return 0, err
361 }
Girish Gowdru0c588b22019-04-23 23:24:56 -0400362 // Get ONU id for a provided pon interface ID.
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700363 ONUID, err := RsrcMgr.ResourceMgrs[ponIntfID].GetResourceID(ponIntfID,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400364 ponrmgr.ONU_ID, 1)
365 if err != nil {
366 log.Errorf("Failed to get resource for interface %d for type %s",
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700367 ponIntfID, ponrmgr.ONU_ID)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400368 return ONUID[0], err
369 }
370 if ONUID != nil {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700371 RsrcMgr.ResourceMgrs[ponIntfID].InitResourceMap(fmt.Sprintf("%d,%d", ponIntfID, ONUID))
372 return ONUID[0], err
Girish Gowdru0c588b22019-04-23 23:24:56 -0400373 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530374
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700375 return 0, err // return OnuID 0 on error
Abhilash S.L7f17e402019-03-15 17:40:41 +0530376}
377
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700378// GetFlowIDInfo returns the slice of flow info of the given pon-port
379// Note: For flows which trap from the NNI and not really associated with any particular
380// ONU (like LLDP), the onu_id and uni_id is set as -1. The intf_id is the NNI intf_id.
381func (RsrcMgr *OpenOltResourceMgr) GetFlowIDInfo(ponIntfID uint32, onuID uint32, uniID uint32, flowID uint32) *[]FlowInfo {
Abhilash S.L8ee90712019-04-29 16:24:22 +0530382 var flows []FlowInfo
383
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700384 FlowPath := fmt.Sprintf("%d,%d,%d", ponIntfID, onuID, uniID)
385 if err := RsrcMgr.ResourceMgrs[ponIntfID].GetFlowIDInfo(FlowPath, flowID, &flows); err != nil {
386 log.Errorw("Error while getting flows from KV store", log.Fields{"flowId": flowID})
Abhilash S.L8ee90712019-04-29 16:24:22 +0530387 return nil
388 }
389 if len(flows) == 0 {
390 log.Debugw("No flowInfo found in KV store", log.Fields{"flowPath": FlowPath})
391 return nil
392 }
393 return &flows
394}
395
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700396// GetCurrentFlowIDsForOnu fetches flow ID from the resource manager
397// Note: For flows which trap from the NNI and not really associated with any particular
398// ONU (like LLDP), the onu_id and uni_id is set as -1. The intf_id is the NNI intf_id.
Abhilash S.L8ee90712019-04-29 16:24:22 +0530399func (RsrcMgr *OpenOltResourceMgr) GetCurrentFlowIDsForOnu(PONIntfID uint32, ONUID uint32, UNIID uint32) []uint32 {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700400
Abhilash S.L8ee90712019-04-29 16:24:22 +0530401 FlowPath := fmt.Sprintf("%d,%d,%d", PONIntfID, ONUID, UNIID)
402 return RsrcMgr.ResourceMgrs[PONIntfID].GetCurrentFlowIDsForOnu(FlowPath)
403}
404
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700405// UpdateFlowIDInfo updates flow info for the given pon interface, onu id, and uni id
406// Note: For flows which trap from the NNI and not really associated with any particular
407// ONU (like LLDP), the onu_id and uni_id is set as -1. The intf_id is the NNI intf_id.
408func (RsrcMgr *OpenOltResourceMgr) UpdateFlowIDInfo(ponIntfID int32, onuID int32, uniID int32,
409 flowID uint32, flowData *[]FlowInfo) error {
410 FlowPath := fmt.Sprintf("%d,%d,%d", ponIntfID, onuID, uniID)
411 return RsrcMgr.ResourceMgrs[uint32(ponIntfID)].UpdateFlowIDInfoForOnu(FlowPath, flowID, *flowData)
Abhilash S.L8ee90712019-04-29 16:24:22 +0530412}
413
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700414// GetFlowID return flow ID for a given pon interface id, onu id and uni id
415func (RsrcMgr *OpenOltResourceMgr) GetFlowID(ponIntfID uint32, ONUID uint32, uniID uint32,
416 flowStoreCookie uint64,
417 flowCategory string) (uint32, error) {
Abhilash S.L7f17e402019-03-15 17:40:41 +0530418
Girish Gowdru0c588b22019-04-23 23:24:56 -0400419 var err error
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700420 FlowPath := fmt.Sprintf("%d,%d,%d", ponIntfID, ONUID, uniID)
421 FlowIDs := RsrcMgr.ResourceMgrs[ponIntfID].GetCurrentFlowIDsForOnu(FlowPath)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400422 if FlowIDs != nil {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700423 log.Debugw("Found flowId(s) for this ONU", log.Fields{"pon": ponIntfID, "ONUID": ONUID, "uniID": uniID, "KVpath": FlowPath})
424 for _, flowID := range FlowIDs {
425 FlowInfo := RsrcMgr.GetFlowIDInfo(ponIntfID, ONUID, uniID, uint32(flowID))
Abhilash S.L8ee90712019-04-29 16:24:22 +0530426 if FlowInfo != nil {
Abhilash S.L8ee90712019-04-29 16:24:22 +0530427 for _, Info := range *FlowInfo {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700428 if flowCategory != "" && Info.FlowCategory == flowCategory {
429 log.Debug("Found flow matching with flow category", log.Fields{"flowId": flowID, "flowCategory": flowCategory})
430 return flowID, nil
Abhilash S.L8ee90712019-04-29 16:24:22 +0530431 }
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700432 if flowStoreCookie != 0 && Info.FlowStoreCookie == flowStoreCookie {
433 log.Debug("Found flow matching with flowStore cookie", log.Fields{"flowId": flowID, "flowStoreCookie": flowStoreCookie})
434 return flowID, nil
Abhilash S.L8ee90712019-04-29 16:24:22 +0530435 }
436 }
437 }
438 }
Girish Gowdru0c588b22019-04-23 23:24:56 -0400439 }
Abhilash S.L8ee90712019-04-29 16:24:22 +0530440 log.Debug("No matching flows with flow cookie or flow category, allocating new flowid")
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700441 FlowIDs, err = RsrcMgr.ResourceMgrs[ponIntfID].GetResourceID(ponIntfID,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400442 ponrmgr.FLOW_ID, 1)
443 if err != nil {
444 log.Errorf("Failed to get resource for interface %d for type %s",
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700445 ponIntfID, ponrmgr.FLOW_ID)
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400446 return uint32(0), err
Girish Gowdru0c588b22019-04-23 23:24:56 -0400447 }
448 if FlowIDs != nil {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700449 _ = RsrcMgr.ResourceMgrs[ponIntfID].UpdateFlowIDForOnu(FlowPath, FlowIDs[0], true)
450 return FlowIDs[0], err
Girish Gowdru0c588b22019-04-23 23:24:56 -0400451 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530452
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700453 return 0, err
Abhilash S.L7f17e402019-03-15 17:40:41 +0530454}
455
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700456// GetAllocID return the first Alloc ID for a given pon interface id and onu id and then update the resource map on
457// the KV store with the list of alloc_ids allocated for the pon_intf_onu_id tuple
458// Currently of all the alloc_ids available, it returns the first alloc_id in the list for tha given ONU
459func (RsrcMgr *OpenOltResourceMgr) GetAllocID(intfID uint32, onuID uint32, uniID uint32) uint32 {
Abhilash S.L7f17e402019-03-15 17:40:41 +0530460
Girish Gowdru0c588b22019-04-23 23:24:56 -0400461 var err error
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700462 IntfOnuIDUniID := fmt.Sprintf("%d,%d,%d", intfID, onuID, uniID)
463 AllocID := RsrcMgr.ResourceMgrs[intfID].GetCurrentAllocIDForOnu(IntfOnuIDUniID)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400464 if AllocID != nil {
465 // Since we support only one alloc_id for the ONU at the moment,
466 // return the first alloc_id in the list, if available, for that
467 // ONU.
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700468 log.Debugw("Retrieved alloc ID from pon resource mgr", log.Fields{"AllocID": AllocID})
Girish Gowdru0c588b22019-04-23 23:24:56 -0400469 return AllocID[0]
470 }
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700471 AllocID, err = RsrcMgr.ResourceMgrs[intfID].GetResourceID(intfID,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400472 ponrmgr.ALLOC_ID, 1)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530473
Girish Gowdru0c588b22019-04-23 23:24:56 -0400474 if AllocID == nil || err != nil {
475 log.Error("Failed to allocate alloc id")
476 return 0
477 }
478 // update the resource map on KV store with the list of alloc_id
479 // allocated for the pon_intf_onu_id tuple
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700480 err = RsrcMgr.ResourceMgrs[intfID].UpdateAllocIdsForOnu(IntfOnuIDUniID, AllocID)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400481 if err != nil {
482 log.Error("Failed to update Alloc ID")
483 return 0
484 }
Abhilash S.L8ee90712019-04-29 16:24:22 +0530485 log.Debugw("Allocated new Tcont from pon resource mgr", log.Fields{"AllocID": AllocID})
Girish Gowdru0c588b22019-04-23 23:24:56 -0400486 return AllocID[0]
Abhilash S.L7f17e402019-03-15 17:40:41 +0530487}
488
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700489// UpdateAllocIdsForOnu updates alloc ids in kv store for a given pon interface id, onu id and uni id
490func (RsrcMgr *OpenOltResourceMgr) UpdateAllocIdsForOnu(ponPort uint32, onuID uint32, uniID uint32, allocID []uint32) error {
Abhilash S.L7f17e402019-03-15 17:40:41 +0530491
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700492 IntfOnuIDUniID := fmt.Sprintf("%d,%d,%d", ponPort, onuID, uniID)
493 return RsrcMgr.ResourceMgrs[ponPort].UpdateAllocIdsForOnu(IntfOnuIDUniID,
494 allocID)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530495}
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700496
497// GetCurrentGEMPortIDsForOnu returns gem ports for given pon interface , onu id and uni id
498func (RsrcMgr *OpenOltResourceMgr) GetCurrentGEMPortIDsForOnu(intfID uint32, onuID uint32,
499 uniID uint32) []uint32 {
Abhilash S.L7f17e402019-03-15 17:40:41 +0530500
Girish Gowdru0c588b22019-04-23 23:24:56 -0400501 /* Get gem ports for given pon interface , onu id and uni id. */
Abhilash S.L7f17e402019-03-15 17:40:41 +0530502
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700503 IntfOnuIDUniID := fmt.Sprintf("%d,%d,%d", intfID, onuID, uniID)
504 return RsrcMgr.ResourceMgrs[intfID].GetCurrentGEMPortIDsForOnu(IntfOnuIDUniID)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530505}
506
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700507// GetCurrentAllocIDForOnu returns alloc ids for given pon interface and onu id
508// Currently of all the alloc_ids available, it returns the first alloc_id in the list for tha given ONU
509func (RsrcMgr *OpenOltResourceMgr) GetCurrentAllocIDForOnu(intfID uint32, onuID uint32, uniID uint32) uint32 {
Abhilash S.L7f17e402019-03-15 17:40:41 +0530510
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700511 IntfOnuIDUniID := fmt.Sprintf("%d,%d,%d", intfID, onuID, uniID)
512 AllocID := RsrcMgr.ResourceMgrs[intfID].GetCurrentAllocIDForOnu(IntfOnuIDUniID)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400513 if AllocID != nil {
514 // Since we support only one alloc_id for the ONU at the moment,
515 // return the first alloc_id in the list, if available, for that
516 // ONU.
517 return AllocID[0]
518 }
519 return 0
Abhilash S.L7f17e402019-03-15 17:40:41 +0530520}
521
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700522// UpdateGEMportsPonportToOnuMapOnKVStore updates onu and uni id associated with the gem port to the kv store
523// This stored information is used when packet_indication is received and we need to derive the ONU Id for which
524// the packet arrived based on the pon_intf and gemport available in the packet_indication
525func (RsrcMgr *OpenOltResourceMgr) UpdateGEMportsPonportToOnuMapOnKVStore(gemPorts []uint32, PonPort uint32,
526 onuID uint32, uniID uint32) error {
Abhilash S.L7f17e402019-03-15 17:40:41 +0530527
Girish Gowdru0c588b22019-04-23 23:24:56 -0400528 /* Update onu and uni id associated with the gem port to the kv store. */
529 var IntfGEMPortPath string
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700530 Data := fmt.Sprintf("%d %d", onuID, uniID)
531 for _, GEM := range gemPorts {
Girish Gowdru0c588b22019-04-23 23:24:56 -0400532 IntfGEMPortPath = fmt.Sprintf("%d,%d", PonPort, GEM)
533 Val, err := json.Marshal(Data)
534 if err != nil {
535 log.Error("failed to Marshal")
536 return err
537 }
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700538
Girish Gowdru0c588b22019-04-23 23:24:56 -0400539 if err = RsrcMgr.KVStore.Put(IntfGEMPortPath, Val); err != nil {
540 log.Errorf("Failed to update resource %s", IntfGEMPortPath)
541 return err
542 }
543 }
544 return nil
Abhilash S.L7f17e402019-03-15 17:40:41 +0530545}
546
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700547// GetGEMPortID gets gem port id for a particular pon port, onu id and uni id and then update the resource map on
548// the KV store with the list of gemport_id allocated for the pon_intf_onu_id tuple
549func (RsrcMgr *OpenOltResourceMgr) GetGEMPortID(ponPort uint32, onuID uint32,
550 uniID uint32, NumOfPorts uint32) ([]uint32, error) {
Abhilash S.L7f17e402019-03-15 17:40:41 +0530551
Girish Gowdru0c588b22019-04-23 23:24:56 -0400552 /* Get gem port id for a particular pon port, onu id
553 and uni id.
554 */
Abhilash S.L7f17e402019-03-15 17:40:41 +0530555
Girish Gowdru0c588b22019-04-23 23:24:56 -0400556 var err error
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700557 IntfOnuIDUniID := fmt.Sprintf("%d,%d,%d", ponPort, onuID, uniID)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530558
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700559 GEMPortList := RsrcMgr.ResourceMgrs[ponPort].GetCurrentGEMPortIDsForOnu(IntfOnuIDUniID)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400560 if GEMPortList != nil {
561 return GEMPortList, nil
562 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530563
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700564 GEMPortList, err = RsrcMgr.ResourceMgrs[ponPort].GetResourceID(ponPort,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400565 ponrmgr.GEMPORT_ID, NumOfPorts)
566 if err != nil && GEMPortList == nil {
Abhilash S.L8ee90712019-04-29 16:24:22 +0530567 log.Errorf("Failed to get gem port id for %s", IntfOnuIDUniID)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400568 return nil, err
569 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530570
Girish Gowdru0c588b22019-04-23 23:24:56 -0400571 // update the resource map on KV store with the list of gemport_id
572 // allocated for the pon_intf_onu_id tuple
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700573 err = RsrcMgr.ResourceMgrs[ponPort].UpdateGEMPortIDsForOnu(IntfOnuIDUniID,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400574 GEMPortList)
575 if err != nil {
Abhilash S.L8ee90712019-04-29 16:24:22 +0530576 log.Errorf("Failed to update GEM ports to kv store for %s", IntfOnuIDUniID)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400577 return nil, err
578 }
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700579 _ = RsrcMgr.UpdateGEMportsPonportToOnuMapOnKVStore(GEMPortList, ponPort,
580 onuID, uniID)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400581 return GEMPortList, err
Abhilash S.L7f17e402019-03-15 17:40:41 +0530582}
583
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700584// UpdateGEMPortIDsForOnu updates gemport ids on to the kv store for a given pon port, onu id and uni id
585func (RsrcMgr *OpenOltResourceMgr) UpdateGEMPortIDsForOnu(ponPort uint32, onuID uint32,
586 uniID uint32, GEMPortList []uint32) error {
587 IntfOnuIDUniID := fmt.Sprintf("%d,%d,%d", ponPort, onuID, uniID)
588 return RsrcMgr.ResourceMgrs[ponPort].UpdateGEMPortIDsForOnu(IntfOnuIDUniID,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400589 GEMPortList)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530590
591}
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700592
593// FreeonuID releases(make free) onu id for a particular pon-port
594func (RsrcMgr *OpenOltResourceMgr) FreeonuID(intfID uint32, onuID []uint32) {
595
596 RsrcMgr.ResourceMgrs[intfID].FreeResourceID(intfID, ponrmgr.ONU_ID, onuID)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530597
Girish Gowdru0c588b22019-04-23 23:24:56 -0400598 /* Free onu id for a particular interface.*/
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700599 var IntfonuID string
600 for _, onu := range onuID {
601 IntfonuID = fmt.Sprintf("%d,%d", intfID, onu)
602 RsrcMgr.ResourceMgrs[intfID].RemoveResourceMap(IntfonuID)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400603 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530604}
605
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700606// FreeFlowID returns the free flow id for a given interface, onu id and uni id
607func (RsrcMgr *OpenOltResourceMgr) FreeFlowID(IntfID uint32, onuID uint32,
608 uniID uint32, FlowID uint32) {
Manjunath Vanarajulu28c3e822019-05-16 11:14:28 -0400609 var IntfONUID string
610 var err error
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700611 IntfONUID = fmt.Sprintf("%d,%d,%d", IntfID, onuID, uniID)
612 err = RsrcMgr.ResourceMgrs[IntfID].UpdateFlowIDForOnu(IntfONUID, FlowID, false)
Manjunath Vanarajulu28c3e822019-05-16 11:14:28 -0400613 if err != nil {
614 log.Error("Failed to Update flow id infor for %s", IntfONUID)
615 }
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700616 RsrcMgr.ResourceMgrs[IntfID].RemoveFlowIDInfo(IntfONUID, FlowID)
Manjunath Vanarajulu28c3e822019-05-16 11:14:28 -0400617}
618
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700619// FreeFlowIDs releases the flow Ids
620func (RsrcMgr *OpenOltResourceMgr) FreeFlowIDs(IntfID uint32, onuID uint32,
621 uniID uint32, FlowID []uint32) {
Abhilash S.L7f17e402019-03-15 17:40:41 +0530622
Girish Gowdru0c588b22019-04-23 23:24:56 -0400623 RsrcMgr.ResourceMgrs[IntfID].FreeResourceID(IntfID, ponrmgr.FLOW_ID, FlowID)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530624
Abhilash S.L8ee90712019-04-29 16:24:22 +0530625 var IntfOnuIDUniID string
Girish Gowdru0c588b22019-04-23 23:24:56 -0400626 var err error
627 for _, flow := range FlowID {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700628 IntfOnuIDUniID = fmt.Sprintf("%d,%d,%d", IntfID, onuID, uniID)
Abhilash S.L8ee90712019-04-29 16:24:22 +0530629 err = RsrcMgr.ResourceMgrs[IntfID].UpdateFlowIDForOnu(IntfOnuIDUniID, flow, false)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400630 if err != nil {
Abhilash S.L8ee90712019-04-29 16:24:22 +0530631 log.Error("Failed to Update flow id infor for %s", IntfOnuIDUniID)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400632 }
Abhilash S.L8ee90712019-04-29 16:24:22 +0530633 RsrcMgr.ResourceMgrs[IntfID].RemoveFlowIDInfo(IntfOnuIDUniID, flow)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400634 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530635}
636
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700637// FreePONResourcesForONU make the pon resources free for a given pon interface and onu id, and the clears the
638// resource map and the onuID associated with (pon_intf_id, gemport_id) tuple,
639func (RsrcMgr *OpenOltResourceMgr) FreePONResourcesForONU(intfID uint32, onuID uint32, uniID uint32) {
Abhilash S.L7f17e402019-03-15 17:40:41 +0530640
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700641 var onuIDs []uint32
642 onuIDs = append(onuIDs, onuID)
643 IntfOnuIDUniID := fmt.Sprintf("%d,%d,%d", intfID, onuID, uniID)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530644
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700645 AllocIDs := RsrcMgr.ResourceMgrs[intfID].GetCurrentAllocIDForOnu(IntfOnuIDUniID)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530646
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700647 RsrcMgr.ResourceMgrs[intfID].FreeResourceID(intfID,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400648 ponrmgr.ALLOC_ID,
649 AllocIDs)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530650
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700651 GEMPortIDs := RsrcMgr.ResourceMgrs[intfID].GetCurrentGEMPortIDsForOnu(IntfOnuIDUniID)
652 RsrcMgr.ResourceMgrs[intfID].FreeResourceID(intfID,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400653 ponrmgr.GEMPORT_ID,
654 GEMPortIDs)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530655
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700656 FlowIDs := RsrcMgr.ResourceMgrs[intfID].GetCurrentFlowIDsForOnu(IntfOnuIDUniID)
657 RsrcMgr.ResourceMgrs[intfID].FreeResourceID(intfID,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400658 ponrmgr.FLOW_ID,
659 FlowIDs)
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700660 RsrcMgr.ResourceMgrs[intfID].FreeResourceID(intfID,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400661 ponrmgr.ONU_ID,
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700662 onuIDs)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530663
Girish Gowdru0c588b22019-04-23 23:24:56 -0400664 // Clear resource map associated with (pon_intf_id, gemport_id) tuple.
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700665 RsrcMgr.ResourceMgrs[intfID].RemoveResourceMap(IntfOnuIDUniID)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530666
Girish Gowdru0c588b22019-04-23 23:24:56 -0400667 // Clear the ONU Id associated with the (pon_intf_id, gemport_id) tuple.
668 for _, GEM := range GEMPortIDs {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700669 _ = RsrcMgr.KVStore.Delete(fmt.Sprintf("%d,%d", intfID, GEM))
Girish Gowdru0c588b22019-04-23 23:24:56 -0400670 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530671}
672
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700673// IsFlowCookieOnKVStore checks if the given flow cookie is present on the kv store
674// Returns true if the flow cookie is found, otherwise it returns false
675func (RsrcMgr *OpenOltResourceMgr) IsFlowCookieOnKVStore(ponIntfID uint32, onuID uint32, uniID uint32,
676 flowStoreCookie uint64) bool {
Abhilash S.L7f17e402019-03-15 17:40:41 +0530677
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700678 FlowPath := fmt.Sprintf("%d,%d,%d", ponIntfID, onuID, uniID)
679 FlowIDs := RsrcMgr.ResourceMgrs[ponIntfID].GetCurrentFlowIDsForOnu(FlowPath)
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400680 if FlowIDs != nil {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700681 log.Debugw("Found flowId(s) for this ONU", log.Fields{"pon": ponIntfID, "onuID": onuID, "uniID": uniID, "KVpath": FlowPath})
682 for _, flowID := range FlowIDs {
683 FlowInfo := RsrcMgr.GetFlowIDInfo(ponIntfID, onuID, uniID, uint32(flowID))
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400684 if FlowInfo != nil {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700685 log.Debugw("Found flows", log.Fields{"flows": *FlowInfo, "flowId": flowID})
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400686 for _, Info := range *FlowInfo {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700687 if Info.FlowStoreCookie == flowStoreCookie {
688 log.Debug("Found flow matching with flowStore cookie", log.Fields{"flowId": flowID, "flowStoreCookie": flowStoreCookie})
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400689 return true
690 }
691 }
692 }
693 }
694 }
695 return false
696}