blob: 4b0220b748038e54867b8c840e8e2c393a560376 [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"
Manikkaraj kb1d51442019-07-23 10:41:02 -040031 ofp "github.com/opencord/voltha-protos/go/openflow_13"
Girish Gowdru0c588b22019-04-23 23:24:56 -040032 "github.com/opencord/voltha-protos/go/openolt"
Abhilash S.L7f17e402019-03-15 17:40:41 +053033)
34
salmansiddiqui598eb8e2019-08-22 03:58:50 +000035const (
36 // KvstoreTimeout specifies the time out for KV Store Connection
37 KvstoreTimeout = 5
38 // BasePathKvStore - service/voltha/openolt/<device_id>
39 BasePathKvStore = "service/voltha/openolt/{%s}"
40 // TpIDPathSuffix - tp_id/<(pon_id, onu_id, uni_id)>
41 TpIDPathSuffix = "tp_id/{%d,%d,%d}"
42 //MeterIDPathSuffix - meter_id/<(pon_id, onu_id, uni_id)>/<direction>
43 MeterIDPathSuffix = "meter_id/{%d,%d,%d}/{%s}"
44)
Abhilash S.L7f17e402019-03-15 17:40:41 +053045
Girish Gowdru6a80bbd2019-07-02 07:36:09 -070046// FlowInfo holds the flow information
Abhilash S.L8ee90712019-04-29 16:24:22 +053047type FlowInfo struct {
48 Flow *openolt.Flow
49 FlowStoreCookie uint64
50 FlowCategory string
51}
Girish Gowdru6a80bbd2019-07-02 07:36:09 -070052
53// OpenOltResourceMgr holds resource related information as provided below for each field
Abhilash S.L7f17e402019-03-15 17:40:41 +053054type OpenOltResourceMgr struct {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -070055 DeviceID string // OLT device id
Girish Gowdru0c588b22019-04-23 23:24:56 -040056 HostAndPort string // Host and port of the kv store to connect to
57 Args string // args
58 KVStore *model.Backend // backend kv store connection handle
59 DeviceType string
60 Host string // Host ip of the kv store
61 Port int // port of the kv store
62 DevInfo *openolt.DeviceInfo // device information
63 // array of pon resource managers per interface technology
64 ResourceMgrs map[uint32]*ponrmgr.PONResourceManager
Abhilash S.L7f17e402019-03-15 17:40:41 +053065}
66
Manikkaraj kb1d51442019-07-23 10:41:02 -040067func newKVClient(storeType string, address string, timeout uint32) (kvstore.Client, error) {
Girish Gowdru0c588b22019-04-23 23:24:56 -040068 log.Infow("kv-store-type", log.Fields{"store": storeType})
69 switch storeType {
70 case "consul":
71 return kvstore.NewConsulClient(address, int(timeout))
72 case "etcd":
73 return kvstore.NewEtcdClient(address, int(timeout))
74 }
75 return nil, errors.New("unsupported-kv-store")
Abhilash S.L7f17e402019-03-15 17:40:41 +053076}
77
Girish Gowdru6a80bbd2019-07-02 07:36:09 -070078// SetKVClient sets the KV client and return a kv backend
79func SetKVClient(backend string, Host string, Port int, DeviceID string) *model.Backend {
Girish Gowdru0c588b22019-04-23 23:24:56 -040080 addr := Host + ":" + strconv.Itoa(Port)
81 // TODO : Make sure direct call to NewBackend is working fine with backend , currently there is some
82 // issue between kv store and backend , core is not calling NewBackend directly
Girish Gowdru6a80bbd2019-07-02 07:36:09 -070083 kvClient, err := newKVClient(backend, addr, KvstoreTimeout)
Girish Gowdru0c588b22019-04-23 23:24:56 -040084 if err != nil {
85 log.Fatalw("Failed to init KV client\n", log.Fields{"err": err})
86 return nil
87 }
88 kvbackend := &model.Backend{
89 Client: kvClient,
Girish Gowdru6a80bbd2019-07-02 07:36:09 -070090 StoreType: backend,
Girish Gowdru0c588b22019-04-23 23:24:56 -040091 Host: Host,
92 Port: Port,
Girish Gowdru6a80bbd2019-07-02 07:36:09 -070093 Timeout: KvstoreTimeout,
94 PathPrefix: fmt.Sprintf(BasePathKvStore, DeviceID)}
Abhilash S.L7f17e402019-03-15 17:40:41 +053095
Girish Gowdru0c588b22019-04-23 23:24:56 -040096 return kvbackend
Abhilash S.L7f17e402019-03-15 17:40:41 +053097}
98
Girish Gowdru6a80bbd2019-07-02 07:36:09 -070099// NewResourceMgr init a New resource maanger instance which in turn instantiates pon resource manager
100// instances according to technology. Initializes the default resource ranges for all
101// the resources.
102func NewResourceMgr(deviceID string, KVStoreHostPort string, kvStoreType string, deviceType string, devInfo *openolt.DeviceInfo) *OpenOltResourceMgr {
Girish Gowdru0c588b22019-04-23 23:24:56 -0400103 var ResourceMgr OpenOltResourceMgr
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700104 log.Debugf("Init new resource manager , host_port: %s, deviceid: %s", KVStoreHostPort, deviceID)
Abhilash S.L8ee90712019-04-29 16:24:22 +0530105 ResourceMgr.HostAndPort = KVStoreHostPort
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700106 ResourceMgr.DeviceType = deviceType
107 ResourceMgr.DevInfo = devInfo
108 IPPort := strings.Split(KVStoreHostPort, ":")
109 ResourceMgr.Host = IPPort[0]
110 ResourceMgr.Port, _ = strconv.Atoi(IPPort[1])
Abhilash S.L7f17e402019-03-15 17:40:41 +0530111
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700112 Backend := kvStoreType
Girish Gowdru0c588b22019-04-23 23:24:56 -0400113 ResourceMgr.KVStore = SetKVClient(Backend, ResourceMgr.Host,
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700114 ResourceMgr.Port, deviceID)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400115 if ResourceMgr.KVStore == nil {
116 log.Error("Failed to setup KV store")
117 }
118 Ranges := make(map[string]*openolt.DeviceInfo_DeviceResourceRanges)
119 RsrcMgrsByTech := make(map[string]*ponrmgr.PONResourceManager)
120 ResourceMgr.ResourceMgrs = make(map[uint32]*ponrmgr.PONResourceManager)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530121
Girish Gowdru0c588b22019-04-23 23:24:56 -0400122 // TODO self.args = registry('main').get_args()
Abhilash S.L7f17e402019-03-15 17:40:41 +0530123
Girish Gowdru0c588b22019-04-23 23:24:56 -0400124 /*
125 If a legacy driver returns protobuf without any ranges,s synthesize one from
126 the legacy global per-device informaiton. This, in theory, is temporary until
127 the legacy drivers are upgrade to support pool ranges.
128 */
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700129 if devInfo.Ranges == nil {
Girish Gowdru0c588b22019-04-23 23:24:56 -0400130 var ranges openolt.DeviceInfo_DeviceResourceRanges
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700131 ranges.Technology = devInfo.GetTechnology()
Abhilash S.L7f17e402019-03-15 17:40:41 +0530132
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700133 NumPONPorts := devInfo.GetPonPorts()
Girish Gowdru0c588b22019-04-23 23:24:56 -0400134 var index uint32
135 for index = 0; index < NumPONPorts; index++ {
136 ranges.IntfIds = append(ranges.IntfIds, index)
137 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530138
Abhilash S.L8ee90712019-04-29 16:24:22 +0530139 var Pool openolt.DeviceInfo_DeviceResourceRanges_Pool
Girish Gowdru0c588b22019-04-23 23:24:56 -0400140 Pool.Type = openolt.DeviceInfo_DeviceResourceRanges_Pool_ONU_ID
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700141 Pool.Start = devInfo.OnuIdStart
142 Pool.End = devInfo.OnuIdEnd
Girish Gowdru0c588b22019-04-23 23:24:56 -0400143 Pool.Sharing = openolt.DeviceInfo_DeviceResourceRanges_Pool_DEDICATED_PER_INTF
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_ALLOC_ID
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700147 Pool.Start = devInfo.AllocIdStart
148 Pool.End = devInfo.AllocIdEnd
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_GEMPORT_ID
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700153 Pool.Start = devInfo.GemportIdStart
154 Pool.End = devInfo.GemportIdEnd
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)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530157
Girish Gowdru0c588b22019-04-23 23:24:56 -0400158 Pool.Type = openolt.DeviceInfo_DeviceResourceRanges_Pool_FLOW_ID
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700159 Pool.Start = devInfo.FlowIdStart
160 Pool.End = devInfo.FlowIdEnd
Girish Gowdru0c588b22019-04-23 23:24:56 -0400161 Pool.Sharing = openolt.DeviceInfo_DeviceResourceRanges_Pool_SHARED_BY_ALL_INTF_ALL_TECH
Abhilash S.L8ee90712019-04-29 16:24:22 +0530162 ranges.Pools = append(ranges.Pools, &Pool)
163 // Add to device info
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700164 devInfo.Ranges = append(devInfo.Ranges, &ranges)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400165 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530166
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700167 // Create a separate Resource Manager instance for each range. This assumes that
Girish Gowdru0c588b22019-04-23 23:24:56 -0400168 // each technology is represented by only a single range
169 var GlobalPONRsrcMgr *ponrmgr.PONResourceManager
170 var err error
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700171 for _, TechRange := range devInfo.Ranges {
Girish Gowdru0c588b22019-04-23 23:24:56 -0400172 technology := TechRange.Technology
173 log.Debugf("Device info technology %s", technology)
174 Ranges[technology] = TechRange
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700175 RsrcMgrsByTech[technology], err = ponrmgr.NewPONResourceManager(technology, deviceType, deviceID,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400176 Backend, ResourceMgr.Host, ResourceMgr.Port)
177 if err != nil {
178 log.Errorf("Failed to create pon resource manager instacnce for technology %s", technology)
179 return nil
180 }
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700181 // resource_mgrs_by_tech[technology] = resource_mgr
Girish Gowdru0c588b22019-04-23 23:24:56 -0400182 if GlobalPONRsrcMgr == nil {
183 GlobalPONRsrcMgr = RsrcMgrsByTech[technology]
184 }
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700185 for _, IntfID := range TechRange.IntfIds {
186 ResourceMgr.ResourceMgrs[uint32(IntfID)] = RsrcMgrsByTech[technology]
Girish Gowdru0c588b22019-04-23 23:24:56 -0400187 }
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700188 // self.initialize_device_resource_range_and_pool(resource_mgr, global_resource_mgr, arange)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400189 InitializeDeviceResourceRangeAndPool(RsrcMgrsByTech[technology], GlobalPONRsrcMgr,
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700190 TechRange, devInfo)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400191 }
192 // After we have initialized resource ranges, initialize the
193 // resource pools accordingly.
194 for _, PONRMgr := range RsrcMgrsByTech {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700195 _ = PONRMgr.InitDeviceResourcePool()
Girish Gowdru0c588b22019-04-23 23:24:56 -0400196 }
Abhilash S.L8ee90712019-04-29 16:24:22 +0530197 log.Info("Initialization of resource manager success!")
Girish Gowdru0c588b22019-04-23 23:24:56 -0400198 return &ResourceMgr
Abhilash S.L7f17e402019-03-15 17:40:41 +0530199}
200
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700201// InitializeDeviceResourceRangeAndPool initializes the resource range pool according to the sharing type, then apply
202// device specific information. If KV doesn't exist
203// or is broader than the device, the device's information will
204// dictate the range limits
205func InitializeDeviceResourceRangeAndPool(ponRMgr *ponrmgr.PONResourceManager, globalPONRMgr *ponrmgr.PONResourceManager,
206 techRange *openolt.DeviceInfo_DeviceResourceRanges, devInfo *openolt.DeviceInfo) {
Abhilash S.L7f17e402019-03-15 17:40:41 +0530207
Girish Gowdru0c588b22019-04-23 23:24:56 -0400208 // init the resource range pool according to the sharing type
Abhilash S.L7f17e402019-03-15 17:40:41 +0530209
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700210 log.Debugf("Resource range pool init for technology %s", ponRMgr.Technology)
211 // first load from KV profiles
212 status := ponRMgr.InitResourceRangesFromKVStore()
213 if !status {
214 log.Debugf("Failed to load resource ranges from KV store for tech %s", ponRMgr.Technology)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400215 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530216
Girish Gowdru0c588b22019-04-23 23:24:56 -0400217 /*
218 Then apply device specific information. If KV doesn't exist
219 or is broader than the device, the device's informationw ill
220 dictate the range limits
221 */
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700222 log.Debugf("Using device info to init pon resource ranges for tech", ponRMgr.Technology)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530223
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700224 ONUIDStart := devInfo.OnuIdStart
225 ONUIDEnd := devInfo.OnuIdEnd
Girish Gowdru0c588b22019-04-23 23:24:56 -0400226 ONUIDShared := openolt.DeviceInfo_DeviceResourceRanges_Pool_DEDICATED_PER_INTF
227 ONUIDSharedPoolID := uint32(0)
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700228 AllocIDStart := devInfo.AllocIdStart
229 AllocIDEnd := devInfo.AllocIdEnd
Girish Gowdru0c588b22019-04-23 23:24:56 -0400230 AllocIDShared := openolt.DeviceInfo_DeviceResourceRanges_Pool_SHARED_BY_ALL_INTF_ALL_TECH // TODO EdgeCore/BAL limitation
231 AllocIDSharedPoolID := uint32(0)
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700232 GEMPortIDStart := devInfo.GemportIdStart
233 GEMPortIDEnd := devInfo.GemportIdEnd
Girish Gowdru0c588b22019-04-23 23:24:56 -0400234 GEMPortIDShared := openolt.DeviceInfo_DeviceResourceRanges_Pool_SHARED_BY_ALL_INTF_ALL_TECH // TODO EdgeCore/BAL limitation
235 GEMPortIDSharedPoolID := uint32(0)
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700236 FlowIDStart := devInfo.FlowIdStart
237 FlowIDEnd := devInfo.FlowIdEnd
Girish Gowdru0c588b22019-04-23 23:24:56 -0400238 FlowIDShared := openolt.DeviceInfo_DeviceResourceRanges_Pool_SHARED_BY_ALL_INTF_ALL_TECH // TODO EdgeCore/BAL limitation
239 FlowIDSharedPoolID := uint32(0)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530240
Girish Gowdru0c588b22019-04-23 23:24:56 -0400241 var FirstIntfPoolID uint32
242 var SharedPoolID uint32
Abhilash S.L7f17e402019-03-15 17:40:41 +0530243
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400244 /*
245 * 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 -0700246 * if resources are shared across interfaces then SharedPoolID is given a positive number.
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400247 */
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700248 for _, FirstIntfPoolID = range techRange.IntfIds {
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400249 // skip the intf id 0
250 if FirstIntfPoolID == 0 {
251 continue
252 }
Girish Gowdru0c588b22019-04-23 23:24:56 -0400253 break
254 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530255
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700256 for _, RangePool := range techRange.Pools {
Girish Gowdru0c588b22019-04-23 23:24:56 -0400257 if RangePool.Sharing == openolt.DeviceInfo_DeviceResourceRanges_Pool_SHARED_BY_ALL_INTF_ALL_TECH {
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400258 SharedPoolID = FirstIntfPoolID
Girish Gowdru0c588b22019-04-23 23:24:56 -0400259 } else if RangePool.Sharing == openolt.DeviceInfo_DeviceResourceRanges_Pool_SHARED_BY_ALL_INTF_SAME_TECH {
260 SharedPoolID = FirstIntfPoolID
261 } else {
262 SharedPoolID = 0
263 }
264 if RangePool.Type == openolt.DeviceInfo_DeviceResourceRanges_Pool_ONU_ID {
265 ONUIDStart = RangePool.Start
266 ONUIDEnd = RangePool.End
267 ONUIDShared = RangePool.Sharing
268 ONUIDSharedPoolID = SharedPoolID
269 } else if RangePool.Type == openolt.DeviceInfo_DeviceResourceRanges_Pool_ALLOC_ID {
270 AllocIDStart = RangePool.Start
271 AllocIDEnd = RangePool.End
272 AllocIDShared = RangePool.Sharing
273 AllocIDSharedPoolID = SharedPoolID
274 } else if RangePool.Type == openolt.DeviceInfo_DeviceResourceRanges_Pool_GEMPORT_ID {
275 GEMPortIDStart = RangePool.Start
276 GEMPortIDEnd = RangePool.End
277 GEMPortIDShared = RangePool.Sharing
278 GEMPortIDSharedPoolID = SharedPoolID
279 } else if RangePool.Type == openolt.DeviceInfo_DeviceResourceRanges_Pool_FLOW_ID {
280 FlowIDStart = RangePool.Start
281 FlowIDEnd = RangePool.End
282 FlowIDShared = RangePool.Sharing
283 FlowIDSharedPoolID = SharedPoolID
284 }
285 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530286
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700287 log.Debugw("Device info init", log.Fields{"technology": techRange.Technology,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400288 "onu_id_start": ONUIDStart, "onu_id_end": ONUIDEnd, "onu_id_shared_pool_id": ONUIDSharedPoolID,
289 "alloc_id_start": AllocIDStart, "alloc_id_end": AllocIDEnd,
290 "alloc_id_shared_pool_id": AllocIDSharedPoolID,
291 "gemport_id_start": GEMPortIDStart, "gemport_id_end": GEMPortIDEnd,
292 "gemport_id_shared_pool_id": GEMPortIDSharedPoolID,
293 "flow_id_start": FlowIDStart,
294 "flow_id_end_idx": FlowIDEnd,
295 "flow_id_shared_pool_id": FlowIDSharedPoolID,
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700296 "intf_ids": techRange.IntfIds,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400297 "uni_id_start": 0,
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700298 "uni_id_end_idx": 1, /*MaxUNIIDperONU()*/
299 })
Abhilash S.L7f17e402019-03-15 17:40:41 +0530300
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700301 ponRMgr.InitDefaultPONResourceRanges(ONUIDStart, ONUIDEnd, ONUIDSharedPoolID,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400302 AllocIDStart, AllocIDEnd, AllocIDSharedPoolID,
303 GEMPortIDStart, GEMPortIDEnd, GEMPortIDSharedPoolID,
304 FlowIDStart, FlowIDEnd, FlowIDSharedPoolID, 0, 1,
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700305 devInfo.PonPorts, techRange.IntfIds)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530306
Girish Gowdru0c588b22019-04-23 23:24:56 -0400307 // For global sharing, make sure to refresh both local and global resource manager instances' range
Abhilash S.L7f17e402019-03-15 17:40:41 +0530308
Girish Gowdru0c588b22019-04-23 23:24:56 -0400309 if ONUIDShared == openolt.DeviceInfo_DeviceResourceRanges_Pool_SHARED_BY_ALL_INTF_ALL_TECH {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700310 globalPONRMgr.UpdateRanges(ponrmgr.ONU_ID_START_IDX, ONUIDStart, ponrmgr.ONU_ID_END_IDX, ONUIDEnd,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400311 "", 0, nil)
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700312 ponRMgr.UpdateRanges(ponrmgr.ONU_ID_START_IDX, ONUIDStart, ponrmgr.ONU_ID_END_IDX, ONUIDEnd,
313 "", 0, globalPONRMgr)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400314 }
315 if AllocIDShared == openolt.DeviceInfo_DeviceResourceRanges_Pool_SHARED_BY_ALL_INTF_ALL_TECH {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700316 globalPONRMgr.UpdateRanges(ponrmgr.ALLOC_ID_START_IDX, AllocIDStart, ponrmgr.ALLOC_ID_END_IDX, AllocIDEnd,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400317 "", 0, nil)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530318
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700319 ponRMgr.UpdateRanges(ponrmgr.ALLOC_ID_START_IDX, AllocIDStart, ponrmgr.ALLOC_ID_END_IDX, AllocIDEnd,
320 "", 0, globalPONRMgr)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400321 }
322 if GEMPortIDShared == openolt.DeviceInfo_DeviceResourceRanges_Pool_SHARED_BY_ALL_INTF_ALL_TECH {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700323 globalPONRMgr.UpdateRanges(ponrmgr.GEMPORT_ID_START_IDX, GEMPortIDStart, ponrmgr.GEMPORT_ID_END_IDX, GEMPortIDEnd,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400324 "", 0, nil)
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700325 ponRMgr.UpdateRanges(ponrmgr.GEMPORT_ID_START_IDX, GEMPortIDStart, ponrmgr.GEMPORT_ID_END_IDX, GEMPortIDEnd,
326 "", 0, globalPONRMgr)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400327 }
328 if FlowIDShared == openolt.DeviceInfo_DeviceResourceRanges_Pool_SHARED_BY_ALL_INTF_ALL_TECH {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700329 globalPONRMgr.UpdateRanges(ponrmgr.FLOW_ID_START_IDX, FlowIDStart, ponrmgr.FLOW_ID_END_IDX, FlowIDEnd,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400330 "", 0, nil)
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700331 ponRMgr.UpdateRanges(ponrmgr.FLOW_ID_START_IDX, FlowIDStart, ponrmgr.FLOW_ID_END_IDX, FlowIDEnd,
332 "", 0, globalPONRMgr)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400333 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530334
Girish Gowdru0c588b22019-04-23 23:24:56 -0400335 // Make sure loaded range fits the platform bit encoding ranges
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700336 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 +0530337}
338
Devmalya Pauleb2e9552019-08-27 19:42:00 -0400339// Delete clears used resources for the particular olt device being deleted
340func (RsrcMgr *OpenOltResourceMgr) Delete() error {
341 /* TODO
342 def __del__(self):
343 self.log.info("clearing-device-resource-pool")
344 for key, resource_mgr in self.resource_mgrs.iteritems():
345 resource_mgr.clear_device_resource_pool()
Abhilash S.L7f17e402019-03-15 17:40:41 +0530346
Devmalya Pauleb2e9552019-08-27 19:42:00 -0400347 def assert_pon_id_limit(self, pon_intf_id):
348 assert pon_intf_id in self.resource_mgrs
Abhilash S.L7f17e402019-03-15 17:40:41 +0530349
Devmalya Pauleb2e9552019-08-27 19:42:00 -0400350 def assert_onu_id_limit(self, pon_intf_id, onu_id):
351 self.assert_pon_id_limit(pon_intf_id)
352 self.resource_mgrs[pon_intf_id].assert_resource_limits(onu_id, PONResourceManager.ONU_ID)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530353
Devmalya Pauleb2e9552019-08-27 19:42:00 -0400354 @property
355 def max_uni_id_per_onu(self):
356 return 0 #OpenOltPlatform.MAX_UNIS_PER_ONU-1, zero-based indexing Uncomment or override to make default multi-uni
Abhilash S.L7f17e402019-03-15 17:40:41 +0530357
Devmalya Pauleb2e9552019-08-27 19:42:00 -0400358 def assert_uni_id_limit(self, pon_intf_id, onu_id, uni_id):
359 self.assert_onu_id_limit(pon_intf_id, onu_id)
360 self.resource_mgrs[pon_intf_id].assert_resource_limits(uni_id, PONResourceManager.UNI_ID)
361 */
362 for _, rsrcMgr := range RsrcMgr.ResourceMgrs {
363 if err := rsrcMgr.ClearDeviceResourcePool(); err != nil {
364 log.Debug("Failed to clear device resource pool")
365 return err
366 }
367 }
368 log.Debug("Cleared device resource pool")
369 return nil
370}
Abhilash S.L7f17e402019-03-15 17:40:41 +0530371
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700372// GetONUID returns the available OnuID for the given pon-port
373func (RsrcMgr *OpenOltResourceMgr) GetONUID(ponIntfID uint32) (uint32, error) {
salmansiddiqui352a45c2019-08-19 10:15:36 +0000374 // Check if Pon Interface ID is present in Resource-manager-map
375 if _, ok := RsrcMgr.ResourceMgrs[ponIntfID]; !ok {
376 err := errors.New("invalid-pon-interface-" + strconv.Itoa(int(ponIntfID)))
377 return 0, err
378 }
Girish Gowdru0c588b22019-04-23 23:24:56 -0400379 // Get ONU id for a provided pon interface ID.
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700380 ONUID, err := RsrcMgr.ResourceMgrs[ponIntfID].GetResourceID(ponIntfID,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400381 ponrmgr.ONU_ID, 1)
382 if err != nil {
383 log.Errorf("Failed to get resource for interface %d for type %s",
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700384 ponIntfID, ponrmgr.ONU_ID)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400385 return ONUID[0], err
386 }
387 if ONUID != nil {
Devmalya Pauleb2e9552019-08-27 19:42:00 -0400388 RsrcMgr.ResourceMgrs[ponIntfID].InitResourceMap(fmt.Sprintf("%d,%d", ponIntfID, ONUID[0]))
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700389 return ONUID[0], err
Girish Gowdru0c588b22019-04-23 23:24:56 -0400390 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530391
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700392 return 0, err // return OnuID 0 on error
Abhilash S.L7f17e402019-03-15 17:40:41 +0530393}
394
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700395// GetFlowIDInfo returns the slice of flow info of the given pon-port
396// Note: For flows which trap from the NNI and not really associated with any particular
397// ONU (like LLDP), the onu_id and uni_id is set as -1. The intf_id is the NNI intf_id.
398func (RsrcMgr *OpenOltResourceMgr) GetFlowIDInfo(ponIntfID uint32, onuID uint32, uniID uint32, flowID uint32) *[]FlowInfo {
Abhilash S.L8ee90712019-04-29 16:24:22 +0530399 var flows []FlowInfo
400
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700401 FlowPath := fmt.Sprintf("%d,%d,%d", ponIntfID, onuID, uniID)
402 if err := RsrcMgr.ResourceMgrs[ponIntfID].GetFlowIDInfo(FlowPath, flowID, &flows); err != nil {
403 log.Errorw("Error while getting flows from KV store", log.Fields{"flowId": flowID})
Abhilash S.L8ee90712019-04-29 16:24:22 +0530404 return nil
405 }
406 if len(flows) == 0 {
407 log.Debugw("No flowInfo found in KV store", log.Fields{"flowPath": FlowPath})
408 return nil
409 }
410 return &flows
411}
412
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700413// GetCurrentFlowIDsForOnu fetches flow ID from the resource manager
414// Note: For flows which trap from the NNI and not really associated with any particular
415// 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 +0530416func (RsrcMgr *OpenOltResourceMgr) GetCurrentFlowIDsForOnu(PONIntfID uint32, ONUID uint32, UNIID uint32) []uint32 {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700417
Abhilash S.L8ee90712019-04-29 16:24:22 +0530418 FlowPath := fmt.Sprintf("%d,%d,%d", PONIntfID, ONUID, UNIID)
419 return RsrcMgr.ResourceMgrs[PONIntfID].GetCurrentFlowIDsForOnu(FlowPath)
420}
421
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700422// UpdateFlowIDInfo updates flow info for the given pon interface, onu id, and uni id
423// Note: For flows which trap from the NNI and not really associated with any particular
424// ONU (like LLDP), the onu_id and uni_id is set as -1. The intf_id is the NNI intf_id.
425func (RsrcMgr *OpenOltResourceMgr) UpdateFlowIDInfo(ponIntfID int32, onuID int32, uniID int32,
426 flowID uint32, flowData *[]FlowInfo) error {
427 FlowPath := fmt.Sprintf("%d,%d,%d", ponIntfID, onuID, uniID)
428 return RsrcMgr.ResourceMgrs[uint32(ponIntfID)].UpdateFlowIDInfoForOnu(FlowPath, flowID, *flowData)
Abhilash S.L8ee90712019-04-29 16:24:22 +0530429}
430
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700431// GetFlowID return flow ID for a given pon interface id, onu id and uni id
432func (RsrcMgr *OpenOltResourceMgr) GetFlowID(ponIntfID uint32, ONUID uint32, uniID uint32,
Manikkaraj kb1d51442019-07-23 10:41:02 -0400433 gemportID uint32,
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700434 flowStoreCookie uint64,
Manikkaraj kb1d51442019-07-23 10:41:02 -0400435 flowCategory string, vlanPcp ...uint32) (uint32, error) {
Abhilash S.L7f17e402019-03-15 17:40:41 +0530436
Girish Gowdru0c588b22019-04-23 23:24:56 -0400437 var err error
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700438 FlowPath := fmt.Sprintf("%d,%d,%d", ponIntfID, ONUID, uniID)
439 FlowIDs := RsrcMgr.ResourceMgrs[ponIntfID].GetCurrentFlowIDsForOnu(FlowPath)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400440 if FlowIDs != nil {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700441 log.Debugw("Found flowId(s) for this ONU", log.Fields{"pon": ponIntfID, "ONUID": ONUID, "uniID": uniID, "KVpath": FlowPath})
442 for _, flowID := range FlowIDs {
443 FlowInfo := RsrcMgr.GetFlowIDInfo(ponIntfID, ONUID, uniID, uint32(flowID))
salmansiddiqui598eb8e2019-08-22 03:58:50 +0000444 er := getFlowIDFromFlowInfo(FlowInfo, flowID, gemportID, flowStoreCookie, flowCategory, vlanPcp...)
445 if er == nil {
446 return flowID, er
Abhilash S.L8ee90712019-04-29 16:24:22 +0530447 }
448 }
Girish Gowdru0c588b22019-04-23 23:24:56 -0400449 }
Abhilash S.L8ee90712019-04-29 16:24:22 +0530450 log.Debug("No matching flows with flow cookie or flow category, allocating new flowid")
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700451 FlowIDs, err = RsrcMgr.ResourceMgrs[ponIntfID].GetResourceID(ponIntfID,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400452 ponrmgr.FLOW_ID, 1)
453 if err != nil {
454 log.Errorf("Failed to get resource for interface %d for type %s",
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700455 ponIntfID, ponrmgr.FLOW_ID)
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400456 return uint32(0), err
Girish Gowdru0c588b22019-04-23 23:24:56 -0400457 }
458 if FlowIDs != nil {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700459 _ = RsrcMgr.ResourceMgrs[ponIntfID].UpdateFlowIDForOnu(FlowPath, FlowIDs[0], true)
460 return FlowIDs[0], err
Girish Gowdru0c588b22019-04-23 23:24:56 -0400461 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530462
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700463 return 0, err
Abhilash S.L7f17e402019-03-15 17:40:41 +0530464}
465
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700466// GetAllocID return the first Alloc ID for a given pon interface id and onu id and then update the resource map on
467// the KV store with the list of alloc_ids allocated for the pon_intf_onu_id tuple
468// Currently of all the alloc_ids available, it returns the first alloc_id in the list for tha given ONU
469func (RsrcMgr *OpenOltResourceMgr) GetAllocID(intfID uint32, onuID uint32, uniID uint32) uint32 {
Abhilash S.L7f17e402019-03-15 17:40:41 +0530470
Girish Gowdru0c588b22019-04-23 23:24:56 -0400471 var err error
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700472 IntfOnuIDUniID := fmt.Sprintf("%d,%d,%d", intfID, onuID, uniID)
473 AllocID := RsrcMgr.ResourceMgrs[intfID].GetCurrentAllocIDForOnu(IntfOnuIDUniID)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400474 if AllocID != nil {
475 // Since we support only one alloc_id for the ONU at the moment,
476 // return the first alloc_id in the list, if available, for that
477 // ONU.
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700478 log.Debugw("Retrieved alloc ID from pon resource mgr", log.Fields{"AllocID": AllocID})
Girish Gowdru0c588b22019-04-23 23:24:56 -0400479 return AllocID[0]
480 }
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700481 AllocID, err = RsrcMgr.ResourceMgrs[intfID].GetResourceID(intfID,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400482 ponrmgr.ALLOC_ID, 1)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530483
Girish Gowdru0c588b22019-04-23 23:24:56 -0400484 if AllocID == nil || err != nil {
485 log.Error("Failed to allocate alloc id")
486 return 0
487 }
488 // update the resource map on KV store with the list of alloc_id
489 // allocated for the pon_intf_onu_id tuple
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700490 err = RsrcMgr.ResourceMgrs[intfID].UpdateAllocIdsForOnu(IntfOnuIDUniID, AllocID)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400491 if err != nil {
492 log.Error("Failed to update Alloc ID")
493 return 0
494 }
Abhilash S.L8ee90712019-04-29 16:24:22 +0530495 log.Debugw("Allocated new Tcont from pon resource mgr", log.Fields{"AllocID": AllocID})
Girish Gowdru0c588b22019-04-23 23:24:56 -0400496 return AllocID[0]
Abhilash S.L7f17e402019-03-15 17:40:41 +0530497}
498
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700499// UpdateAllocIdsForOnu updates alloc ids in kv store for a given pon interface id, onu id and uni id
500func (RsrcMgr *OpenOltResourceMgr) UpdateAllocIdsForOnu(ponPort uint32, onuID uint32, uniID uint32, allocID []uint32) error {
Abhilash S.L7f17e402019-03-15 17:40:41 +0530501
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700502 IntfOnuIDUniID := fmt.Sprintf("%d,%d,%d", ponPort, onuID, uniID)
503 return RsrcMgr.ResourceMgrs[ponPort].UpdateAllocIdsForOnu(IntfOnuIDUniID,
504 allocID)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530505}
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700506
507// GetCurrentGEMPortIDsForOnu returns gem ports for given pon interface , onu id and uni id
508func (RsrcMgr *OpenOltResourceMgr) GetCurrentGEMPortIDsForOnu(intfID uint32, onuID uint32,
509 uniID uint32) []uint32 {
Abhilash S.L7f17e402019-03-15 17:40:41 +0530510
Girish Gowdru0c588b22019-04-23 23:24:56 -0400511 /* Get gem ports for given pon interface , onu id and uni id. */
Abhilash S.L7f17e402019-03-15 17:40:41 +0530512
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700513 IntfOnuIDUniID := fmt.Sprintf("%d,%d,%d", intfID, onuID, uniID)
514 return RsrcMgr.ResourceMgrs[intfID].GetCurrentGEMPortIDsForOnu(IntfOnuIDUniID)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530515}
516
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700517// GetCurrentAllocIDForOnu returns alloc ids for given pon interface and onu id
518// Currently of all the alloc_ids available, it returns the first alloc_id in the list for tha given ONU
519func (RsrcMgr *OpenOltResourceMgr) GetCurrentAllocIDForOnu(intfID uint32, onuID uint32, uniID uint32) uint32 {
Abhilash S.L7f17e402019-03-15 17:40:41 +0530520
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700521 IntfOnuIDUniID := fmt.Sprintf("%d,%d,%d", intfID, onuID, uniID)
522 AllocID := RsrcMgr.ResourceMgrs[intfID].GetCurrentAllocIDForOnu(IntfOnuIDUniID)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400523 if AllocID != nil {
524 // Since we support only one alloc_id for the ONU at the moment,
525 // return the first alloc_id in the list, if available, for that
526 // ONU.
527 return AllocID[0]
528 }
529 return 0
Abhilash S.L7f17e402019-03-15 17:40:41 +0530530}
531
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700532// UpdateGEMportsPonportToOnuMapOnKVStore updates onu and uni id associated with the gem port to the kv store
533// This stored information is used when packet_indication is received and we need to derive the ONU Id for which
534// the packet arrived based on the pon_intf and gemport available in the packet_indication
535func (RsrcMgr *OpenOltResourceMgr) UpdateGEMportsPonportToOnuMapOnKVStore(gemPorts []uint32, PonPort uint32,
536 onuID uint32, uniID uint32) error {
Abhilash S.L7f17e402019-03-15 17:40:41 +0530537
Girish Gowdru0c588b22019-04-23 23:24:56 -0400538 /* Update onu and uni id associated with the gem port to the kv store. */
539 var IntfGEMPortPath string
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700540 Data := fmt.Sprintf("%d %d", onuID, uniID)
541 for _, GEM := range gemPorts {
Girish Gowdru0c588b22019-04-23 23:24:56 -0400542 IntfGEMPortPath = fmt.Sprintf("%d,%d", PonPort, GEM)
543 Val, err := json.Marshal(Data)
544 if err != nil {
545 log.Error("failed to Marshal")
546 return err
547 }
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700548
Girish Gowdru0c588b22019-04-23 23:24:56 -0400549 if err = RsrcMgr.KVStore.Put(IntfGEMPortPath, Val); err != nil {
550 log.Errorf("Failed to update resource %s", IntfGEMPortPath)
551 return err
552 }
553 }
554 return nil
Abhilash S.L7f17e402019-03-15 17:40:41 +0530555}
556
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700557// GetGEMPortID gets gem port id for a particular pon port, onu id and uni id and then update the resource map on
558// the KV store with the list of gemport_id allocated for the pon_intf_onu_id tuple
559func (RsrcMgr *OpenOltResourceMgr) GetGEMPortID(ponPort uint32, onuID uint32,
560 uniID uint32, NumOfPorts uint32) ([]uint32, error) {
Abhilash S.L7f17e402019-03-15 17:40:41 +0530561
Girish Gowdru0c588b22019-04-23 23:24:56 -0400562 /* Get gem port id for a particular pon port, onu id
563 and uni id.
564 */
Abhilash S.L7f17e402019-03-15 17:40:41 +0530565
Girish Gowdru0c588b22019-04-23 23:24:56 -0400566 var err error
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700567 IntfOnuIDUniID := fmt.Sprintf("%d,%d,%d", ponPort, onuID, uniID)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530568
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700569 GEMPortList := RsrcMgr.ResourceMgrs[ponPort].GetCurrentGEMPortIDsForOnu(IntfOnuIDUniID)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400570 if GEMPortList != nil {
571 return GEMPortList, nil
572 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530573
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700574 GEMPortList, err = RsrcMgr.ResourceMgrs[ponPort].GetResourceID(ponPort,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400575 ponrmgr.GEMPORT_ID, NumOfPorts)
576 if err != nil && GEMPortList == nil {
Abhilash S.L8ee90712019-04-29 16:24:22 +0530577 log.Errorf("Failed to get gem port id for %s", IntfOnuIDUniID)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400578 return nil, err
579 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530580
Girish Gowdru0c588b22019-04-23 23:24:56 -0400581 // update the resource map on KV store with the list of gemport_id
582 // allocated for the pon_intf_onu_id tuple
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700583 err = RsrcMgr.ResourceMgrs[ponPort].UpdateGEMPortIDsForOnu(IntfOnuIDUniID,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400584 GEMPortList)
585 if err != nil {
Abhilash S.L8ee90712019-04-29 16:24:22 +0530586 log.Errorf("Failed to update GEM ports to kv store for %s", IntfOnuIDUniID)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400587 return nil, err
588 }
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700589 _ = RsrcMgr.UpdateGEMportsPonportToOnuMapOnKVStore(GEMPortList, ponPort,
590 onuID, uniID)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400591 return GEMPortList, err
Abhilash S.L7f17e402019-03-15 17:40:41 +0530592}
593
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700594// UpdateGEMPortIDsForOnu updates gemport ids on to the kv store for a given pon port, onu id and uni id
595func (RsrcMgr *OpenOltResourceMgr) UpdateGEMPortIDsForOnu(ponPort uint32, onuID uint32,
596 uniID uint32, GEMPortList []uint32) error {
597 IntfOnuIDUniID := fmt.Sprintf("%d,%d,%d", ponPort, onuID, uniID)
598 return RsrcMgr.ResourceMgrs[ponPort].UpdateGEMPortIDsForOnu(IntfOnuIDUniID,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400599 GEMPortList)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530600
601}
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700602
603// FreeonuID releases(make free) onu id for a particular pon-port
604func (RsrcMgr *OpenOltResourceMgr) FreeonuID(intfID uint32, onuID []uint32) {
605
606 RsrcMgr.ResourceMgrs[intfID].FreeResourceID(intfID, ponrmgr.ONU_ID, onuID)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530607
Girish Gowdru0c588b22019-04-23 23:24:56 -0400608 /* Free onu id for a particular interface.*/
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700609 var IntfonuID string
610 for _, onu := range onuID {
611 IntfonuID = fmt.Sprintf("%d,%d", intfID, onu)
612 RsrcMgr.ResourceMgrs[intfID].RemoveResourceMap(IntfonuID)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400613 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530614}
615
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700616// FreeFlowID returns the free flow id for a given interface, onu id and uni id
Devmalya Pauleb2e9552019-08-27 19:42:00 -0400617func (RsrcMgr *OpenOltResourceMgr) FreeFlowID(IntfID uint32, onuID int32,
618 uniID int32, FlowID uint32) {
Manjunath Vanarajulu28c3e822019-05-16 11:14:28 -0400619 var IntfONUID string
620 var err error
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700621 IntfONUID = fmt.Sprintf("%d,%d,%d", IntfID, onuID, uniID)
622 err = RsrcMgr.ResourceMgrs[IntfID].UpdateFlowIDForOnu(IntfONUID, FlowID, false)
Manjunath Vanarajulu28c3e822019-05-16 11:14:28 -0400623 if err != nil {
624 log.Error("Failed to Update flow id infor for %s", IntfONUID)
625 }
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700626 RsrcMgr.ResourceMgrs[IntfID].RemoveFlowIDInfo(IntfONUID, FlowID)
Manjunath Vanarajulu28c3e822019-05-16 11:14:28 -0400627}
628
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700629// FreeFlowIDs releases the flow Ids
630func (RsrcMgr *OpenOltResourceMgr) FreeFlowIDs(IntfID uint32, onuID uint32,
631 uniID uint32, FlowID []uint32) {
Abhilash S.L7f17e402019-03-15 17:40:41 +0530632
Girish Gowdru0c588b22019-04-23 23:24:56 -0400633 RsrcMgr.ResourceMgrs[IntfID].FreeResourceID(IntfID, ponrmgr.FLOW_ID, FlowID)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530634
Abhilash S.L8ee90712019-04-29 16:24:22 +0530635 var IntfOnuIDUniID string
Girish Gowdru0c588b22019-04-23 23:24:56 -0400636 var err error
637 for _, flow := range FlowID {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700638 IntfOnuIDUniID = fmt.Sprintf("%d,%d,%d", IntfID, onuID, uniID)
Abhilash S.L8ee90712019-04-29 16:24:22 +0530639 err = RsrcMgr.ResourceMgrs[IntfID].UpdateFlowIDForOnu(IntfOnuIDUniID, flow, false)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400640 if err != nil {
Abhilash S.L8ee90712019-04-29 16:24:22 +0530641 log.Error("Failed to Update flow id infor for %s", IntfOnuIDUniID)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400642 }
Abhilash S.L8ee90712019-04-29 16:24:22 +0530643 RsrcMgr.ResourceMgrs[IntfID].RemoveFlowIDInfo(IntfOnuIDUniID, flow)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400644 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530645}
646
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700647// FreePONResourcesForONU make the pon resources free for a given pon interface and onu id, and the clears the
648// resource map and the onuID associated with (pon_intf_id, gemport_id) tuple,
649func (RsrcMgr *OpenOltResourceMgr) FreePONResourcesForONU(intfID uint32, onuID uint32, uniID uint32) {
Abhilash S.L7f17e402019-03-15 17:40:41 +0530650
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700651 var onuIDs []uint32
652 onuIDs = append(onuIDs, onuID)
653 IntfOnuIDUniID := fmt.Sprintf("%d,%d,%d", intfID, onuID, uniID)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530654
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700655 AllocIDs := RsrcMgr.ResourceMgrs[intfID].GetCurrentAllocIDForOnu(IntfOnuIDUniID)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530656
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700657 RsrcMgr.ResourceMgrs[intfID].FreeResourceID(intfID,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400658 ponrmgr.ALLOC_ID,
659 AllocIDs)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530660
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700661 GEMPortIDs := RsrcMgr.ResourceMgrs[intfID].GetCurrentGEMPortIDsForOnu(IntfOnuIDUniID)
662 RsrcMgr.ResourceMgrs[intfID].FreeResourceID(intfID,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400663 ponrmgr.GEMPORT_ID,
664 GEMPortIDs)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530665
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700666 FlowIDs := RsrcMgr.ResourceMgrs[intfID].GetCurrentFlowIDsForOnu(IntfOnuIDUniID)
667 RsrcMgr.ResourceMgrs[intfID].FreeResourceID(intfID,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400668 ponrmgr.FLOW_ID,
669 FlowIDs)
Devmalya Pauleb2e9552019-08-27 19:42:00 -0400670 if int32(onuID) >= 0 {
671 RsrcMgr.ResourceMgrs[intfID].FreeResourceID(intfID,
672 ponrmgr.ONU_ID,
673 onuIDs)
674 }
Girish Gowdru0c588b22019-04-23 23:24:56 -0400675 // Clear resource map associated with (pon_intf_id, gemport_id) tuple.
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700676 RsrcMgr.ResourceMgrs[intfID].RemoveResourceMap(IntfOnuIDUniID)
Abhilash S.L7f17e402019-03-15 17:40:41 +0530677
Girish Gowdru0c588b22019-04-23 23:24:56 -0400678 // Clear the ONU Id associated with the (pon_intf_id, gemport_id) tuple.
679 for _, GEM := range GEMPortIDs {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700680 _ = RsrcMgr.KVStore.Delete(fmt.Sprintf("%d,%d", intfID, GEM))
Girish Gowdru0c588b22019-04-23 23:24:56 -0400681 }
Abhilash S.L7f17e402019-03-15 17:40:41 +0530682}
683
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700684// IsFlowCookieOnKVStore checks if the given flow cookie is present on the kv store
685// Returns true if the flow cookie is found, otherwise it returns false
686func (RsrcMgr *OpenOltResourceMgr) IsFlowCookieOnKVStore(ponIntfID uint32, onuID uint32, uniID uint32,
687 flowStoreCookie uint64) bool {
Abhilash S.L7f17e402019-03-15 17:40:41 +0530688
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700689 FlowPath := fmt.Sprintf("%d,%d,%d", ponIntfID, onuID, uniID)
690 FlowIDs := RsrcMgr.ResourceMgrs[ponIntfID].GetCurrentFlowIDsForOnu(FlowPath)
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400691 if FlowIDs != nil {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700692 log.Debugw("Found flowId(s) for this ONU", log.Fields{"pon": ponIntfID, "onuID": onuID, "uniID": uniID, "KVpath": FlowPath})
693 for _, flowID := range FlowIDs {
694 FlowInfo := RsrcMgr.GetFlowIDInfo(ponIntfID, onuID, uniID, uint32(flowID))
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400695 if FlowInfo != nil {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700696 log.Debugw("Found flows", log.Fields{"flows": *FlowInfo, "flowId": flowID})
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400697 for _, Info := range *FlowInfo {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700698 if Info.FlowStoreCookie == flowStoreCookie {
699 log.Debug("Found flow matching with flowStore cookie", log.Fields{"flowId": flowID, "flowStoreCookie": flowStoreCookie})
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400700 return true
701 }
702 }
703 }
704 }
705 }
706 return false
707}
Manikkaraj kb1d51442019-07-23 10:41:02 -0400708
salmansiddiqui598eb8e2019-08-22 03:58:50 +0000709// GetTechProfileIDForOnu fetches Tech-Profile-ID from the KV-Store for the given onu based on the path
710// This path is formed as the following: tp_id/{IntfID, OnuID, UniID}
711func (RsrcMgr *OpenOltResourceMgr) GetTechProfileIDForOnu(IntfID uint32, OnuID uint32, UniID uint32) uint32 {
712 Path := fmt.Sprintf(TpIDPathSuffix, IntfID, OnuID, UniID)
Manikkaraj kb1d51442019-07-23 10:41:02 -0400713 var Data uint32
salmansiddiqui598eb8e2019-08-22 03:58:50 +0000714 Value, err := RsrcMgr.KVStore.Get(Path)
Manikkaraj kb1d51442019-07-23 10:41:02 -0400715 if err == nil {
716 if Value != nil {
717 Val, err := kvstore.ToByte(Value.Value)
718 if err != nil {
719 log.Errorw("Failed to convert into byte array", log.Fields{"error": err})
720 return Data
721 }
722 if err = json.Unmarshal(Val, &Data); err != nil {
723 log.Error("Failed to unmarshal", log.Fields{"error": err})
724 return Data
725 }
726 }
727 } else {
728 log.Errorf("Failed to get TP id from kvstore for path %s", Path)
729 }
730 log.Debugf("Getting TP id %d from path %s", Data, Path)
731 return Data
732
733}
734
salmansiddiqui598eb8e2019-08-22 03:58:50 +0000735// RemoveTechProfileIDForOnu deletes the tech-profile-id from the KV-Store for the given onu based on the path
736// This path is formed as the following: tp_id/{IntfID, OnuID, UniID}
737func (RsrcMgr *OpenOltResourceMgr) RemoveTechProfileIDForOnu(IntfID uint32, OnuID uint32, UniID uint32) error {
738 IntfOnuUniID := fmt.Sprintf(TpIDPathSuffix, IntfID, OnuID, UniID)
739 if err := RsrcMgr.KVStore.Delete(IntfOnuUniID); err != nil {
740 log.Error("Failed to delete techprofile id resource %s in KV store", IntfOnuUniID)
Manikkaraj kb1d51442019-07-23 10:41:02 -0400741 return err
742 }
743 return nil
744}
745
salmansiddiqui598eb8e2019-08-22 03:58:50 +0000746//UpdateTechProfileIDForOnu updates (put) already present tech-profile-id for the given onu based on the path
747// This path is formed as the following: tp_id/{IntfID, OnuID, UniID}
748func (RsrcMgr *OpenOltResourceMgr) UpdateTechProfileIDForOnu(IntfID uint32, OnuID uint32,
749 UniID uint32, TpID uint32) error {
Manikkaraj kb1d51442019-07-23 10:41:02 -0400750 var Value []byte
751 var err error
752
salmansiddiqui598eb8e2019-08-22 03:58:50 +0000753 IntfOnuUniID := fmt.Sprintf(TpIDPathSuffix, IntfID, OnuID, UniID)
754 log.Debugf("updating tp id %d on path %s", TpID, IntfOnuUniID)
755 Value, err = json.Marshal(TpID)
Manikkaraj kb1d51442019-07-23 10:41:02 -0400756 if err != nil {
757 log.Error("failed to Marshal")
758 return err
759 }
salmansiddiqui598eb8e2019-08-22 03:58:50 +0000760 if err = RsrcMgr.KVStore.Put(IntfOnuUniID, Value); err != nil {
761 log.Errorf("Failed to update resource %s", IntfOnuUniID)
Manikkaraj kb1d51442019-07-23 10:41:02 -0400762 return err
763 }
764 return err
765}
766
salmansiddiqui598eb8e2019-08-22 03:58:50 +0000767// UpdateMeterIDForOnu updates the meter id in the KV-Store for the given onu based on the path
768// This path is formed as the following: tp_id/{IntfID, OnuID, UniID}/direction
769func (RsrcMgr *OpenOltResourceMgr) UpdateMeterIDForOnu(Direction string, IntfID uint32, OnuID uint32,
770 UniID uint32, MeterConfig *ofp.OfpMeterConfig) error {
Manikkaraj kb1d51442019-07-23 10:41:02 -0400771 var Value []byte
772 var err error
773
salmansiddiqui598eb8e2019-08-22 03:58:50 +0000774 IntfOnuUniID := fmt.Sprintf(MeterIDPathSuffix, IntfID, OnuID, UniID, Direction)
Manikkaraj kb1d51442019-07-23 10:41:02 -0400775 Value, err = json.Marshal(*MeterConfig)
776 if err != nil {
777 log.Error("failed to Marshal meter config")
778 return err
779 }
salmansiddiqui598eb8e2019-08-22 03:58:50 +0000780 if err = RsrcMgr.KVStore.Put(IntfOnuUniID, Value); err != nil {
781 log.Errorf("Failed to store meter into KV store %s", IntfOnuUniID)
Manikkaraj kb1d51442019-07-23 10:41:02 -0400782 return err
783 }
784 return err
785}
786
salmansiddiqui598eb8e2019-08-22 03:58:50 +0000787// GetMeterIDForOnu fetches the meter-id fromthe kv store for the given onu based on the path
788// This path is formed as the following: tp_id/{IntfID, OnuID, UniID}/direction
789func (RsrcMgr *OpenOltResourceMgr) GetMeterIDForOnu(Direction string, IntfID uint32, OnuID uint32, UniID uint32) (*ofp.OfpMeterConfig, error) {
790 Path := fmt.Sprintf(MeterIDPathSuffix, IntfID, OnuID, UniID, Direction)
Manikkaraj kb1d51442019-07-23 10:41:02 -0400791 var meterConfig ofp.OfpMeterConfig
salmansiddiqui598eb8e2019-08-22 03:58:50 +0000792 Value, err := RsrcMgr.KVStore.Get(Path)
Manikkaraj kb1d51442019-07-23 10:41:02 -0400793 if err == nil {
794 if Value != nil {
795 log.Debug("Found meter in KV store", log.Fields{"Direction": Direction})
salmansiddiqui598eb8e2019-08-22 03:58:50 +0000796 Val, er := kvstore.ToByte(Value.Value)
797 if er != nil {
798 log.Errorw("Failed to convert into byte array", log.Fields{"error": er})
799 return nil, er
Manikkaraj kb1d51442019-07-23 10:41:02 -0400800 }
salmansiddiqui598eb8e2019-08-22 03:58:50 +0000801 if er = json.Unmarshal(Val, &meterConfig); er != nil {
802 log.Error("Failed to unmarshal meterconfig", log.Fields{"error": er})
803 return nil, er
Manikkaraj kb1d51442019-07-23 10:41:02 -0400804 }
805 } else {
806 log.Debug("meter-does-not-exists-in-KVStore")
807 return nil, err
808 }
809 } else {
810 log.Errorf("Failed to get Meter config from kvstore for path %s", Path)
811
812 }
813 return &meterConfig, err
814}
815
salmansiddiqui598eb8e2019-08-22 03:58:50 +0000816// RemoveMeterIDForOnu deletes the meter-id from the kV-Store for the given onu based on the path
817// This path is formed as the following: tp_id/{IntfID, OnuID, UniID}/direction
818func (RsrcMgr *OpenOltResourceMgr) RemoveMeterIDForOnu(Direction string, IntfID uint32, OnuID uint32, UniID uint32) error {
819 Path := fmt.Sprintf(MeterIDPathSuffix, IntfID, OnuID, UniID, Direction)
820 if err := RsrcMgr.KVStore.Delete(Path); err != nil {
Manikkaraj kb1d51442019-07-23 10:41:02 -0400821 log.Errorf("Failed to delete meter id %s from kvstore ", Path)
822 return err
823 }
824 return nil
825}
salmansiddiqui598eb8e2019-08-22 03:58:50 +0000826
827func getFlowIDFromFlowInfo(FlowInfo *[]FlowInfo, flowID, gemportID uint32, flowStoreCookie uint64, flowCategory string, vlanPcp ...uint32) error {
828 if FlowInfo != nil {
829 for _, Info := range *FlowInfo {
830 if int32(gemportID) == Info.Flow.GemportId && flowCategory != "" && Info.FlowCategory == flowCategory {
831 log.Debug("Found flow matching with flow category", log.Fields{"flowId": flowID, "FlowCategory": flowCategory})
832 if Info.FlowCategory == "HSIA_FLOW" && Info.Flow.Classifier.OPbits == vlanPcp[0] {
833 log.Debug("Found matching vlan pcp ", log.Fields{"flowId": flowID, "Vlanpcp": vlanPcp[0]})
834 return nil
835 }
836 }
837 if int32(gemportID) == Info.Flow.GemportId && flowStoreCookie != 0 && Info.FlowStoreCookie == flowStoreCookie {
838 if flowCategory != "" && Info.FlowCategory == flowCategory {
839 log.Debug("Found flow matching with flow category", log.Fields{"flowId": flowID, "FlowCategory": flowCategory})
840 return nil
841 }
842 }
843 }
844 }
845 log.Errorw("invalid flow-info", log.Fields{"flow_info": FlowInfo})
846 return errors.New("invalid flow-info")
847}