blob: 290f1916f88c529561bdd4d299c3f18c45f99883 [file] [log] [blame]
kdarapu3248f9a2019-10-03 13:54:52 +05301/*
2 * Copyright 2018-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
17//Package mocks provides the mocks for openolt-adapter.
18package mocks
19
20import (
npujarec5762e2020-01-01 14:08:48 +053021 "context"
kdarapu3248f9a2019-10-03 13:54:52 +053022 "encoding/json"
23 "errors"
24 "strconv"
25 "strings"
npujarec5762e2020-01-01 14:08:48 +053026 "time"
kdarapu3248f9a2019-10-03 13:54:52 +053027
Girish Gowdraa09aeab2020-09-14 16:30:52 -070028 "github.com/opencord/voltha-lib-go/v4/pkg/log"
Scott Bakerdbd960e2020-02-28 08:57:51 -080029 "github.com/opencord/voltha-openolt-adapter/internal/pkg/resourcemanager"
kdarapub26b4502019-10-05 03:02:33 +053030
Girish Gowdraa09aeab2020-09-14 16:30:52 -070031 "github.com/opencord/voltha-lib-go/v4/pkg/db/kvstore"
32 ofp "github.com/opencord/voltha-protos/v4/go/openflow_13"
33 openolt "github.com/opencord/voltha-protos/v4/go/openolt"
kdarapu3248f9a2019-10-03 13:54:52 +053034)
35
36const (
37 // MeterConfig meter to extarct meter
38 MeterConfig = "meter_id"
39 // TpIDPathSuffix to extract Techprofile
40 TpIDPathSuffix = "tp_id"
kdarapub26b4502019-10-05 03:02:33 +053041 // FlowIDpool to extract Flow ids
42 FlowIDpool = "flow_id_pool"
43 // FlowIDs to extract flow_ids
44 FlowIDs = "flow_ids"
45 // FlowIDInfo to extract flowId info
46 FlowIDInfo = "flow_id_info"
47 // GemportIDs to gemport_ids
48 GemportIDs = "gemport_ids"
49 // AllocIDs to extract alloc_ids
50 AllocIDs = "alloc_ids"
Esin Karamanccb714b2019-11-29 15:02:06 +000051 //FlowGroup flow_groups/<flow_group_id>
52 FlowGroup = "flow_groups"
53 //FlowGroupCached flow_groups_cached/<flow_group_id>
54 FlowGroupCached = "flow_groups_cached"
Esin Karaman7fb80c22020-07-16 14:23:33 +000055 //OnuPacketIn to extract gem port from packet-in
56 OnuPacketIn = "onu_packetin"
Girish Gowdrafb3d6102020-10-16 16:32:36 -070057 // OnuGemInfoPath has path on the kvstore to store OnuGemInfo info per PON interface
58 OnuGemInfoPath = "onu_gem_info"
kdarapu3248f9a2019-10-03 13:54:52 +053059)
60
61// MockKVClient mocks the AdapterProxy interface.
62type MockKVClient struct {
63}
64
65// List mock function implementation for KVClient
npujarec5762e2020-01-01 14:08:48 +053066func (kvclient *MockKVClient) List(ctx context.Context, key string) (map[string]*kvstore.KVPair, error) {
kdarapu3248f9a2019-10-03 13:54:52 +053067 if key != "" {
68 maps := make(map[string]*kvstore.KVPair)
69 maps[key] = &kvstore.KVPair{Key: key}
70 return maps, nil
71 }
72 return nil, errors.New("key didn't find")
73}
74
75// Get mock function implementation for KVClient
Girish Gowdrafb3d6102020-10-16 16:32:36 -070076// nolint: gocyclo
npujarec5762e2020-01-01 14:08:48 +053077func (kvclient *MockKVClient) Get(ctx context.Context, key string) (*kvstore.KVPair, error) {
Girish Gowdraa09aeab2020-09-14 16:30:52 -070078 logger.Debugw(ctx, "Get of MockKVClient called", log.Fields{"key": key})
kdarapu3248f9a2019-10-03 13:54:52 +053079 if key != "" {
kdarapub26b4502019-10-05 03:02:33 +053080 if strings.Contains(key, "meter_id/{0,62,8}/{upstream}") {
81 meterConfig := ofp.OfpMeterConfig{
82 Flags: 0,
83 MeterId: 1,
84 }
85 str, _ := json.Marshal(meterConfig)
86 return kvstore.NewKVPair(key, string(str), "mock", 3000, 1), nil
87 }
kdarapu3248f9a2019-10-03 13:54:52 +053088 if strings.Contains(key, MeterConfig) {
89 var bands []*ofp.OfpMeterBandHeader
90 bands = append(bands, &ofp.OfpMeterBandHeader{Type: ofp.OfpMeterBandType_OFPMBT_DSCP_REMARK,
91 Rate: 1024, Data: &ofp.OfpMeterBandHeader_DscpRemark{DscpRemark: &ofp.OfpMeterBandDscpRemark{PrecLevel: 2}}})
92
93 bands = append(bands, &ofp.OfpMeterBandHeader{Type: ofp.OfpMeterBandType_OFPMBT_DSCP_REMARK,
94 Rate: 1024, Data: &ofp.OfpMeterBandHeader_DscpRemark{DscpRemark: &ofp.OfpMeterBandDscpRemark{PrecLevel: 3}}})
95
Gamze Abakafee36392019-10-03 11:17:24 +000096 sep := strings.Split(key, "/")[1]
kdarapu3248f9a2019-10-03 13:54:52 +053097 val, _ := strconv.ParseInt(strings.Split(sep, ",")[1], 10, 32)
98 if uint32(val) > 1 {
99 meterConfig := &ofp.OfpMeterConfig{MeterId: uint32(val), Bands: bands}
100 str, _ := json.Marshal(meterConfig)
kdarapub26b4502019-10-05 03:02:33 +0530101
102 return kvstore.NewKVPair(key, str, "mock", 3000, 1), nil
103 }
104
105 if strings.Contains(key, "meter_id/{1,1,1}/{downstream}") {
106
107 band1 := &ofp.OfpMeterBandHeader{Type: ofp.OfpMeterBandType_OFPMBT_DROP, Rate: 1000, BurstSize: 5000}
108 band2 := &ofp.OfpMeterBandHeader{Type: ofp.OfpMeterBandType_OFPMBT_DROP, Rate: 2000, BurstSize: 5000}
109 bands := []*ofp.OfpMeterBandHeader{band1, band2}
110 ofpMeterConfig := &ofp.OfpMeterConfig{Flags: 1, MeterId: 1, Bands: bands}
111 str, _ := json.Marshal(ofpMeterConfig)
112 return kvstore.NewKVPair(key, str, "mock", 3000, 1), nil
kdarapu3248f9a2019-10-03 13:54:52 +0530113 }
114 if uint32(val) == 1 {
115 return nil, nil
116 }
117 return nil, errors.New("invalid meter")
118 }
119 if strings.Contains(key, TpIDPathSuffix) {
Girish Gowdrafb3d6102020-10-16 16:32:36 -0700120 data := []uint32{64}
121 str, _ := json.Marshal(data)
kdarapub26b4502019-10-05 03:02:33 +0530122 return kvstore.NewKVPair(key, str, "mock", 3000, 1), nil
123 }
124 if strings.Contains(key, FlowIDpool) {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000125 logger.Debug(ctx, "Error Error Error Key:", FlowIDpool)
kdarapub26b4502019-10-05 03:02:33 +0530126 data := make(map[string]interface{})
127 data["pool"] = "1024"
128 data["start_idx"] = 1
129 data["end_idx"] = 1024
130 str, _ := json.Marshal(data)
131 return kvstore.NewKVPair(key, str, "mock", 3000, 1), nil
132 }
133 if strings.Contains(key, FlowIDs) {
134 data := []uint32{1, 2}
Neha Sharma96b7bf22020-06-15 10:37:32 +0000135 logger.Debug(ctx, "Error Error Error Key:", FlowIDs)
kdarapub26b4502019-10-05 03:02:33 +0530136 str, _ := json.Marshal(data)
137 return kvstore.NewKVPair(key, str, "mock", 3000, 1), nil
138 }
Esin Karamand519bbf2020-07-01 11:16:03 +0000139 if strings.Contains(key, "/{olt}/{0,-1,-1}/flow_id_info/") {
140 //multicast flow
Girish Gowdraa09aeab2020-09-14 16:30:52 -0700141 data := resourcemanager.FlowInfo{
142 Flow: &openolt.Flow{FlowId: 1, OnuId: 0, UniId: 0, GemportId: 4000},
Esin Karamand519bbf2020-07-01 11:16:03 +0000143 }
144 logger.Debug(ctx, "Error Error Error Key:", FlowIDs)
145 str, _ := json.Marshal(data)
146 return kvstore.NewKVPair(key, str, "mock", 3000, 1), nil
147 }
148
kdarapub26b4502019-10-05 03:02:33 +0530149 if strings.Contains(key, FlowIDInfo) {
Girish Gowdraa09aeab2020-09-14 16:30:52 -0700150 data := resourcemanager.FlowInfo{
151 Flow: &openolt.Flow{FlowId: 1, OnuId: 1, UniId: 1, GemportId: 1},
kdarapub26b4502019-10-05 03:02:33 +0530152 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000153 logger.Debug(ctx, "Error Error Error Key:", FlowIDs)
kdarapub26b4502019-10-05 03:02:33 +0530154 str, _ := json.Marshal(data)
155 return kvstore.NewKVPair(key, str, "mock", 3000, 1), nil
156 }
157 if strings.Contains(key, GemportIDs) {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000158 logger.Debug(ctx, "Error Error Error Key:", GemportIDs)
Girish Gowdrafb3d6102020-10-16 16:32:36 -0700159 data := []uint32{1}
160 str, _ := json.Marshal(data)
kdarapub26b4502019-10-05 03:02:33 +0530161 return kvstore.NewKVPair(key, str, "mock", 3000, 1), nil
162 }
163 if strings.Contains(key, AllocIDs) {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000164 logger.Debug(ctx, "Error Error Error Key:", AllocIDs)
Girish Gowdrafb3d6102020-10-16 16:32:36 -0700165 data := []uint32{1}
166 str, _ := json.Marshal(data)
kdarapu3248f9a2019-10-03 13:54:52 +0530167 return kvstore.NewKVPair(key, str, "mock", 3000, 1), nil
168 }
Esin Karamanccb714b2019-11-29 15:02:06 +0000169 if strings.Contains(key, FlowGroup) || strings.Contains(key, FlowGroupCached) {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000170 logger.Debug(ctx, "Error Error Error Key:", FlowGroup)
Esin Karamanccb714b2019-11-29 15:02:06 +0000171 groupInfo := resourcemanager.GroupInfo{
172 GroupID: 2,
173 OutPorts: []uint32{1},
174 }
175 str, _ := json.Marshal(&groupInfo)
176 return kvstore.NewKVPair(key, str, "mock", 3000, 1), nil
177 }
Esin Karaman7fb80c22020-07-16 14:23:33 +0000178 if strings.Contains(key, OnuPacketIn) {
179 return getPacketInGemPort(key)
180 }
Girish Gowdrafb3d6102020-10-16 16:32:36 -0700181 if strings.Contains(key, OnuGemInfoPath) {
182 var data []resourcemanager.OnuGemInfo
183 str, _ := json.Marshal(data)
184 return kvstore.NewKVPair(key, str, "mock", 3000, 1), nil
185 }
Esin Karamandf392e12020-12-16 13:33:09 +0000186 //Interface, GEM port path
187 if strings.Contains(key, "0,255") {
188 //return onuID, uniID associated with the given interface and GEM port
189 data := []uint32{1, 0}
190 str, _ := json.Marshal(data)
191 return kvstore.NewKVPair(key, str, "mock", 3000, 1), nil
192 }
193 //Interface, GEM port path
194 if strings.Contains(key, "0,257") {
195 //return onuID, uniID associated with the given interface and GEM port
196 data := []uint32{1, 0}
197 str, _ := json.Marshal(data)
198 return kvstore.NewKVPair(key, str, "mock", 3000, 1), nil
199 }
Esin Karaman7fb80c22020-07-16 14:23:33 +0000200
kdarapu3248f9a2019-10-03 13:54:52 +0530201 maps := make(map[string]*kvstore.KVPair)
202 maps[key] = &kvstore.KVPair{Key: key}
203 return maps[key], nil
204 }
205 return nil, errors.New("key didn't find")
206}
207
Esin Karaman7fb80c22020-07-16 14:23:33 +0000208//getPacketInGemPort returns the GEM port associated with the given key
209func getPacketInGemPort(key string) (*kvstore.KVPair, error) {
210 //parse interface, onu, uni, vlan, priority values
211 arr := getParamsFromPacketInKey(key)
212
213 if len(arr) < 5 {
214 return nil, errors.New("key didn't find")
215 }
216 if arr[0] == "1" && arr[1] == "1" && arr[2] == "3" && arr[3] == "0" && arr[4] == "0" {
217 str, _ := json.Marshal(3)
218 return kvstore.NewKVPair(key, str, "mock", 3000, 1), nil
219 }
220 if arr[0] == "2" && arr[1] == "2" && arr[2] == "4" && arr[3] == "549" && arr[4] == "0" {
221 str, _ := json.Marshal(4)
222 return kvstore.NewKVPair(key, str, "mock", 3000, 1), nil
223 }
224 if arr[0] == "1" && arr[1] == "2" && arr[2] == "2" && arr[3] == "48" && arr[4] == "7" {
225 str, _ := json.Marshal(2)
226 return kvstore.NewKVPair(key, str, "mock", 3000, 1), nil
227 }
228 return nil, errors.New("key didn't find")
229}
230
231//getParamsFromPacketInKey parse packetIn key that is in the format of "onu_packetin/{1,1,1,1,2}"
232func getParamsFromPacketInKey(key string) []string {
233 //return intfID, onuID, uniID, vlanID, priority
234 firstIndex := strings.Index(key, "{")
235 lastIndex := strings.Index(key, "}")
236 if firstIndex == -1 && lastIndex == -1 {
237 return []string{}
238 }
239 arr := strings.Split(key[firstIndex+1:lastIndex], ",")
240 if len(arr) < 5 {
241 return []string{}
242 }
243 return arr
244}
245
kdarapu3248f9a2019-10-03 13:54:52 +0530246// Put mock function implementation for KVClient
npujarec5762e2020-01-01 14:08:48 +0530247func (kvclient *MockKVClient) Put(ctx context.Context, key string, value interface{}) error {
kdarapu3248f9a2019-10-03 13:54:52 +0530248 if key != "" {
kdarapu3248f9a2019-10-03 13:54:52 +0530249 return nil
250 }
251 return errors.New("key didn't find")
252}
253
254// Delete mock function implementation for KVClient
npujarec5762e2020-01-01 14:08:48 +0530255func (kvclient *MockKVClient) Delete(ctx context.Context, key string) error {
kdarapu3248f9a2019-10-03 13:54:52 +0530256 if key == "" {
257 return errors.New("key didn't find")
258 }
259 return nil
260}
261
262// Reserve mock function implementation for KVClient
Neha Sharmacc656962020-04-14 14:26:11 +0000263func (kvclient *MockKVClient) Reserve(ctx context.Context, key string, value interface{}, ttl time.Duration) (interface{}, error) {
kdarapu3248f9a2019-10-03 13:54:52 +0530264 if key != "" {
265 maps := make(map[string]*kvstore.KVPair)
266 maps[key] = &kvstore.KVPair{Key: key}
267 return maps[key], nil
268 }
269 return nil, errors.New("key didn't find")
270}
271
272// ReleaseReservation mock function implementation for KVClient
npujarec5762e2020-01-01 14:08:48 +0530273func (kvclient *MockKVClient) ReleaseReservation(ctx context.Context, key string) error {
kdarapu3248f9a2019-10-03 13:54:52 +0530274 // return nil
275 if key == "" {
276 return errors.New("key didn't find")
277 }
278 return nil
279}
280
281// ReleaseAllReservations mock function implementation for KVClient
npujarec5762e2020-01-01 14:08:48 +0530282func (kvclient *MockKVClient) ReleaseAllReservations(ctx context.Context) error {
kdarapu3248f9a2019-10-03 13:54:52 +0530283 return nil
284}
285
286// RenewReservation mock function implementation for KVClient
npujarec5762e2020-01-01 14:08:48 +0530287func (kvclient *MockKVClient) RenewReservation(ctx context.Context, key string) error {
kdarapu3248f9a2019-10-03 13:54:52 +0530288 // return nil
289 if key == "" {
290 return errors.New("key didn't find")
291 }
292 return nil
293}
294
295// Watch mock function implementation for KVClient
Scott Bakere701b862020-02-20 16:19:16 -0800296func (kvclient *MockKVClient) Watch(ctx context.Context, key string, withPrefix bool) chan *kvstore.Event {
kdarapu3248f9a2019-10-03 13:54:52 +0530297 return nil
298 // if key == "" {
299 // return nil
300 // }
301 // return &kvstore.Event{EventType: 1, Key: key}
302}
303
304// AcquireLock mock function implementation for KVClient
Neha Sharmacc656962020-04-14 14:26:11 +0000305func (kvclient *MockKVClient) AcquireLock(ctx context.Context, lockName string, timeout time.Duration) error {
kdarapu3248f9a2019-10-03 13:54:52 +0530306 return nil
307}
308
309// ReleaseLock mock function implementation for KVClient
310func (kvclient *MockKVClient) ReleaseLock(lockName string) error {
311 return nil
312}
313
314// IsConnectionUp mock function implementation for KVClient
Matteo Scandolo945e4012019-12-12 14:16:11 -0800315func (kvclient *MockKVClient) IsConnectionUp(ctx context.Context) bool {
316 // timeout in second
npujarec5762e2020-01-01 14:08:48 +0530317 t, _ := ctx.Deadline()
Kent Hagermane6ff1012020-07-14 15:07:53 -0400318 return t.Second()-time.Now().Second() >= 1
kdarapu3248f9a2019-10-03 13:54:52 +0530319}
320
321// CloseWatch mock function implementation for KVClient
Neha Sharma96b7bf22020-06-15 10:37:32 +0000322func (kvclient *MockKVClient) CloseWatch(ctx context.Context, key string, ch chan *kvstore.Event) {
kdarapu3248f9a2019-10-03 13:54:52 +0530323}
324
325// Close mock function implementation for KVClient
Neha Sharma96b7bf22020-06-15 10:37:32 +0000326func (kvclient *MockKVClient) Close(ctx context.Context) {
kdarapu3248f9a2019-10-03 13:54:52 +0530327}