blob: 78b8eb569fac9a5fd432da028a8331c84a892c12 [file] [log] [blame]
Scott Baker2c1c4822019-10-16 11:02:41 -07001/*
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 */
16package common
17
18import (
19 "errors"
serkant.uluderyab38671c2019-11-01 09:35:38 -070020
Scott Baker2c1c4822019-10-16 11:02:41 -070021 "github.com/golang/protobuf/ptypes"
22 "github.com/golang/protobuf/ptypes/empty"
serkant.uluderyab38671c2019-11-01 09:35:38 -070023 "github.com/opencord/voltha-lib-go/v3/pkg/adapters"
24 "github.com/opencord/voltha-lib-go/v3/pkg/adapters/adapterif"
25 "github.com/opencord/voltha-lib-go/v3/pkg/kafka"
26 "github.com/opencord/voltha-lib-go/v3/pkg/log"
27 ic "github.com/opencord/voltha-protos/v3/go/inter_container"
28 "github.com/opencord/voltha-protos/v3/go/openflow_13"
29 "github.com/opencord/voltha-protos/v3/go/voltha"
Scott Baker2c1c4822019-10-16 11:02:41 -070030 "google.golang.org/grpc/codes"
31 "google.golang.org/grpc/status"
32)
33
34type RequestHandlerProxy struct {
35 TestMode bool
36 coreInstanceId string
37 adapter adapters.IAdapter
38 coreProxy adapterif.CoreProxy
39}
40
41func NewRequestHandlerProxy(coreInstanceId string, iadapter adapters.IAdapter, cProxy adapterif.CoreProxy) *RequestHandlerProxy {
42 var proxy RequestHandlerProxy
43 proxy.coreInstanceId = coreInstanceId
44 proxy.adapter = iadapter
45 proxy.coreProxy = cProxy
46 return &proxy
47}
48
49func (rhp *RequestHandlerProxy) Adapter_descriptor() (*empty.Empty, error) {
50 return new(empty.Empty), nil
51}
52
53func (rhp *RequestHandlerProxy) Device_types() (*voltha.DeviceTypes, error) {
54 return nil, nil
55}
56
57func (rhp *RequestHandlerProxy) Health() (*voltha.HealthStatus, error) {
58 return nil, nil
59}
60
61func (rhp *RequestHandlerProxy) Adopt_device(args []*ic.Argument) (*empty.Empty, error) {
62 if len(args) < 3 {
khenaidoob332f9b2020-01-16 16:25:26 -050063 logger.Warn("invalid-number-of-args", log.Fields{"args": args})
Scott Baker2c1c4822019-10-16 11:02:41 -070064 err := errors.New("invalid-number-of-args")
65 return nil, err
66 }
67 device := &voltha.Device{}
68 transactionID := &ic.StrType{}
69 fromTopic := &ic.StrType{}
70 for _, arg := range args {
71 switch arg.Key {
72 case "device":
73 if err := ptypes.UnmarshalAny(arg.Value, device); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -050074 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -070075 return nil, err
76 }
77 case kafka.TransactionKey:
78 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -050079 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -070080 return nil, err
81 }
82 case kafka.FromTopic:
83 if err := ptypes.UnmarshalAny(arg.Value, fromTopic); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -050084 logger.Warnw("cannot-unmarshal-from-topic", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -070085 return nil, err
86 }
87 }
88 }
89
khenaidoob332f9b2020-01-16 16:25:26 -050090 logger.Debugw("Adopt_device", log.Fields{"deviceId": device.Id})
Scott Baker2c1c4822019-10-16 11:02:41 -070091
92 //Update the core reference for that device
93 rhp.coreProxy.UpdateCoreReference(device.Id, fromTopic.Val)
94
95 //Invoke the adopt device on the adapter
96 if err := rhp.adapter.Adopt_device(device); err != nil {
97 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
98 }
99
100 return new(empty.Empty), nil
101}
102
103func (rhp *RequestHandlerProxy) Reconcile_device(args []*ic.Argument) (*empty.Empty, error) {
104 if len(args) < 3 {
khenaidoob332f9b2020-01-16 16:25:26 -0500105 logger.Warn("invalid-number-of-args", log.Fields{"args": args})
Scott Baker2c1c4822019-10-16 11:02:41 -0700106 err := errors.New("invalid-number-of-args")
107 return nil, err
108 }
109
110 device := &voltha.Device{}
111 transactionID := &ic.StrType{}
112 fromTopic := &ic.StrType{}
113 for _, arg := range args {
114 switch arg.Key {
115 case "device":
116 if err := ptypes.UnmarshalAny(arg.Value, device); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500117 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700118 return nil, err
119 }
120 case kafka.TransactionKey:
121 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500122 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700123 return nil, err
124 }
125 case kafka.FromTopic:
126 if err := ptypes.UnmarshalAny(arg.Value, fromTopic); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500127 logger.Warnw("cannot-unmarshal-from-topic", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700128 return nil, err
129 }
130 }
131 }
132 //Update the core reference for that device
133 rhp.coreProxy.UpdateCoreReference(device.Id, fromTopic.Val)
134
135 //Invoke the reconcile device API on the adapter
136 if err := rhp.adapter.Reconcile_device(device); err != nil {
137 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
138 }
139 return new(empty.Empty), nil
140}
141
142func (rhp *RequestHandlerProxy) Abandon_device(args []*ic.Argument) (*empty.Empty, error) {
143 return new(empty.Empty), nil
144}
145
146func (rhp *RequestHandlerProxy) Disable_device(args []*ic.Argument) (*empty.Empty, error) {
147 if len(args) < 3 {
khenaidoob332f9b2020-01-16 16:25:26 -0500148 logger.Warn("invalid-number-of-args", log.Fields{"args": args})
Scott Baker2c1c4822019-10-16 11:02:41 -0700149 err := errors.New("invalid-number-of-args")
150 return nil, err
151 }
152
153 device := &voltha.Device{}
154 transactionID := &ic.StrType{}
155 fromTopic := &ic.StrType{}
156 for _, arg := range args {
157 switch arg.Key {
158 case "device":
159 if err := ptypes.UnmarshalAny(arg.Value, device); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500160 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700161 return nil, err
162 }
163 case kafka.TransactionKey:
164 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500165 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700166 return nil, err
167 }
168 case kafka.FromTopic:
169 if err := ptypes.UnmarshalAny(arg.Value, fromTopic); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500170 logger.Warnw("cannot-unmarshal-from-topic", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700171 return nil, err
172 }
173 }
174 }
175 //Update the core reference for that device
176 rhp.coreProxy.UpdateCoreReference(device.Id, fromTopic.Val)
177 //Invoke the Disable_device API on the adapter
178 if err := rhp.adapter.Disable_device(device); err != nil {
179 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
180 }
181 return new(empty.Empty), nil
182}
183
184func (rhp *RequestHandlerProxy) Reenable_device(args []*ic.Argument) (*empty.Empty, error) {
185 if len(args) < 3 {
khenaidoob332f9b2020-01-16 16:25:26 -0500186 logger.Warn("invalid-number-of-args", log.Fields{"args": args})
Scott Baker2c1c4822019-10-16 11:02:41 -0700187 err := errors.New("invalid-number-of-args")
188 return nil, err
189 }
190
191 device := &voltha.Device{}
192 transactionID := &ic.StrType{}
193 fromTopic := &ic.StrType{}
194 for _, arg := range args {
195 switch arg.Key {
196 case "device":
197 if err := ptypes.UnmarshalAny(arg.Value, device); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500198 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700199 return nil, err
200 }
201 case kafka.TransactionKey:
202 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500203 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700204 return nil, err
205 }
206 case kafka.FromTopic:
207 if err := ptypes.UnmarshalAny(arg.Value, fromTopic); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500208 logger.Warnw("cannot-unmarshal-from-topic", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700209 return nil, err
210 }
211 }
212 }
213 //Update the core reference for that device
214 rhp.coreProxy.UpdateCoreReference(device.Id, fromTopic.Val)
215 //Invoke the Reenable_device API on the adapter
216 if err := rhp.adapter.Reenable_device(device); err != nil {
217 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
218 }
219 return new(empty.Empty), nil
220}
221
222func (rhp *RequestHandlerProxy) Reboot_device(args []*ic.Argument) (*empty.Empty, error) {
223 if len(args) < 3 {
khenaidoob332f9b2020-01-16 16:25:26 -0500224 logger.Warn("invalid-number-of-args", log.Fields{"args": args})
Scott Baker2c1c4822019-10-16 11:02:41 -0700225 err := errors.New("invalid-number-of-args")
226 return nil, err
227 }
228
229 device := &voltha.Device{}
230 transactionID := &ic.StrType{}
231 fromTopic := &ic.StrType{}
232 for _, arg := range args {
233 switch arg.Key {
234 case "device":
235 if err := ptypes.UnmarshalAny(arg.Value, device); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500236 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700237 return nil, err
238 }
239 case kafka.TransactionKey:
240 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500241 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700242 return nil, err
243 }
244 case kafka.FromTopic:
245 if err := ptypes.UnmarshalAny(arg.Value, fromTopic); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500246 logger.Warnw("cannot-unmarshal-from-topic", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700247 return nil, err
248 }
249 }
250 }
251 //Update the core reference for that device
252 rhp.coreProxy.UpdateCoreReference(device.Id, fromTopic.Val)
253 //Invoke the Reboot_device API on the adapter
254 if err := rhp.adapter.Reboot_device(device); err != nil {
255 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
256 }
257 return new(empty.Empty), nil
258
259}
260
261func (rhp *RequestHandlerProxy) Self_test_device(args []*ic.Argument) (*empty.Empty, error) {
262 return new(empty.Empty), nil
263}
264
265func (rhp *RequestHandlerProxy) Delete_device(args []*ic.Argument) (*empty.Empty, error) {
266 if len(args) < 3 {
khenaidoob332f9b2020-01-16 16:25:26 -0500267 logger.Warn("invalid-number-of-args", log.Fields{"args": args})
Scott Baker2c1c4822019-10-16 11:02:41 -0700268 err := errors.New("invalid-number-of-args")
269 return nil, err
270 }
271
272 device := &voltha.Device{}
273 transactionID := &ic.StrType{}
274 fromTopic := &ic.StrType{}
275 for _, arg := range args {
276 switch arg.Key {
277 case "device":
278 if err := ptypes.UnmarshalAny(arg.Value, device); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500279 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700280 return nil, err
281 }
282 case kafka.TransactionKey:
283 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500284 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700285 return nil, err
286 }
287 case kafka.FromTopic:
288 if err := ptypes.UnmarshalAny(arg.Value, fromTopic); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500289 logger.Warnw("cannot-unmarshal-from-topic", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700290 return nil, err
291 }
292 }
293 }
294 //Update the core reference for that device
295 rhp.coreProxy.UpdateCoreReference(device.Id, fromTopic.Val)
296 //Invoke the delete_device API on the adapter
297 if err := rhp.adapter.Delete_device(device); err != nil {
298 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
299 }
300 return new(empty.Empty), nil
301}
302
303func (rhp *RequestHandlerProxy) Get_device_details(args []*ic.Argument) (*empty.Empty, error) {
304 return new(empty.Empty), nil
305}
306
307func (rhp *RequestHandlerProxy) Update_flows_bulk(args []*ic.Argument) (*empty.Empty, error) {
khenaidoob332f9b2020-01-16 16:25:26 -0500308 logger.Debug("Update_flows_bulk")
Scott Baker2c1c4822019-10-16 11:02:41 -0700309 if len(args) < 5 {
khenaidoob332f9b2020-01-16 16:25:26 -0500310 logger.Warn("Update_flows_bulk-invalid-number-of-args", log.Fields{"args": args})
Scott Baker2c1c4822019-10-16 11:02:41 -0700311 err := errors.New("invalid-number-of-args")
312 return nil, err
313 }
314 device := &voltha.Device{}
315 transactionID := &ic.StrType{}
316 flows := &voltha.Flows{}
317 flowMetadata := &voltha.FlowMetadata{}
318 groups := &voltha.FlowGroups{}
319 for _, arg := range args {
320 switch arg.Key {
321 case "device":
322 if err := ptypes.UnmarshalAny(arg.Value, device); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500323 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700324 return nil, err
325 }
326 case "flows":
327 if err := ptypes.UnmarshalAny(arg.Value, flows); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500328 logger.Warnw("cannot-unmarshal-flows", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700329 return nil, err
330 }
331 case "groups":
332 if err := ptypes.UnmarshalAny(arg.Value, groups); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500333 logger.Warnw("cannot-unmarshal-groups", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700334 return nil, err
335 }
336 case "flow_metadata":
337 if err := ptypes.UnmarshalAny(arg.Value, flowMetadata); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500338 logger.Warnw("cannot-unmarshal-metadata", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700339 return nil, err
340 }
341 case kafka.TransactionKey:
342 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500343 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700344 return nil, err
345 }
346 }
347 }
khenaidoob332f9b2020-01-16 16:25:26 -0500348 logger.Debugw("Update_flows_bulk", log.Fields{"flows": flows, "groups": groups})
Scott Baker2c1c4822019-10-16 11:02:41 -0700349 //Invoke the bulk flow update API of the adapter
350 if err := rhp.adapter.Update_flows_bulk(device, flows, groups, flowMetadata); err != nil {
351 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
352 }
353 return new(empty.Empty), nil
354}
355
356func (rhp *RequestHandlerProxy) Update_flows_incrementally(args []*ic.Argument) (*empty.Empty, error) {
khenaidoob332f9b2020-01-16 16:25:26 -0500357 logger.Debug("Update_flows_incrementally")
Scott Baker2c1c4822019-10-16 11:02:41 -0700358 if len(args) < 5 {
khenaidoob332f9b2020-01-16 16:25:26 -0500359 logger.Warn("Update_flows_incrementally-invalid-number-of-args", log.Fields{"args": args})
Scott Baker2c1c4822019-10-16 11:02:41 -0700360 err := errors.New("invalid-number-of-args")
361 return nil, err
362 }
363 device := &voltha.Device{}
364 transactionID := &ic.StrType{}
365 flows := &openflow_13.FlowChanges{}
366 flowMetadata := &voltha.FlowMetadata{}
367 groups := &openflow_13.FlowGroupChanges{}
368 for _, arg := range args {
369 switch arg.Key {
370 case "device":
371 if err := ptypes.UnmarshalAny(arg.Value, device); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500372 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700373 return nil, err
374 }
375 case "flow_changes":
376 if err := ptypes.UnmarshalAny(arg.Value, flows); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500377 logger.Warnw("cannot-unmarshal-flows", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700378 return nil, err
379 }
380 case "group_changes":
381 if err := ptypes.UnmarshalAny(arg.Value, groups); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500382 logger.Warnw("cannot-unmarshal-groups", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700383 return nil, err
384 }
385 case "flow_metadata":
386 if err := ptypes.UnmarshalAny(arg.Value, flowMetadata); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500387 logger.Warnw("cannot-unmarshal-metadata", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700388 return nil, err
389 }
390 case kafka.TransactionKey:
391 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500392 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700393 return nil, err
394 }
395 }
396 }
khenaidoob332f9b2020-01-16 16:25:26 -0500397 logger.Debugw("Update_flows_incrementally", log.Fields{"flows": flows, "groups": groups})
Scott Baker2c1c4822019-10-16 11:02:41 -0700398 //Invoke the incremental flow update API of the adapter
399 if err := rhp.adapter.Update_flows_incrementally(device, flows, groups, flowMetadata); err != nil {
400 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
401 }
402 return new(empty.Empty), nil
403}
404
405func (rhp *RequestHandlerProxy) Update_pm_config(args []*ic.Argument) (*empty.Empty, error) {
khenaidoob332f9b2020-01-16 16:25:26 -0500406 logger.Debug("Update_pm_config")
Scott Baker2c1c4822019-10-16 11:02:41 -0700407 if len(args) < 2 {
khenaidoob332f9b2020-01-16 16:25:26 -0500408 logger.Warn("Update_pm_config-invalid-number-of-args", log.Fields{"args": args})
Scott Baker2c1c4822019-10-16 11:02:41 -0700409 err := errors.New("invalid-number-of-args")
410 return nil, err
411 }
412 device := &voltha.Device{}
413 transactionID := &ic.StrType{}
414 pmConfigs := &voltha.PmConfigs{}
415 for _, arg := range args {
416 switch arg.Key {
417 case "device":
418 if err := ptypes.UnmarshalAny(arg.Value, device); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500419 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700420 return nil, err
421 }
422 case "pm_configs":
423 if err := ptypes.UnmarshalAny(arg.Value, pmConfigs); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500424 logger.Warnw("cannot-unmarshal-pm-configs", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700425 return nil, err
426 }
427 case kafka.TransactionKey:
428 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500429 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700430 return nil, err
431 }
432 }
433 }
khenaidoob332f9b2020-01-16 16:25:26 -0500434 logger.Debugw("Update_pm_config", log.Fields{"deviceId": device.Id, "pmConfigs": pmConfigs})
Scott Baker2c1c4822019-10-16 11:02:41 -0700435 //Invoke the pm config update API of the adapter
436 if err := rhp.adapter.Update_pm_config(device, pmConfigs); err != nil {
437 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
438 }
439 return new(empty.Empty), nil
440}
441
442func (rhp *RequestHandlerProxy) Receive_packet_out(args []*ic.Argument) (*empty.Empty, error) {
khenaidoob332f9b2020-01-16 16:25:26 -0500443 logger.Debugw("Receive_packet_out", log.Fields{"args": args})
Scott Baker2c1c4822019-10-16 11:02:41 -0700444 if len(args) < 3 {
khenaidoob332f9b2020-01-16 16:25:26 -0500445 logger.Warn("Receive_packet_out-invalid-number-of-args", log.Fields{"args": args})
Scott Baker2c1c4822019-10-16 11:02:41 -0700446 err := errors.New("invalid-number-of-args")
447 return nil, err
448 }
449 deviceId := &ic.StrType{}
450 egressPort := &ic.IntType{}
451 packet := &openflow_13.OfpPacketOut{}
452 transactionID := &ic.StrType{}
453 for _, arg := range args {
454 switch arg.Key {
455 case "deviceId":
456 if err := ptypes.UnmarshalAny(arg.Value, deviceId); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500457 logger.Warnw("cannot-unmarshal-deviceId", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700458 return nil, err
459 }
460 case "outPort":
461 if err := ptypes.UnmarshalAny(arg.Value, egressPort); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500462 logger.Warnw("cannot-unmarshal-egressPort", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700463 return nil, err
464 }
465 case "packet":
466 if err := ptypes.UnmarshalAny(arg.Value, packet); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500467 logger.Warnw("cannot-unmarshal-packet", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700468 return nil, err
469 }
470 case kafka.TransactionKey:
471 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500472 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700473 return nil, err
474 }
475 }
476 }
khenaidoob332f9b2020-01-16 16:25:26 -0500477 logger.Debugw("Receive_packet_out", log.Fields{"deviceId": deviceId.Val, "outPort": egressPort, "packet": packet})
Scott Baker2c1c4822019-10-16 11:02:41 -0700478 //Invoke the adopt device on the adapter
479 if err := rhp.adapter.Receive_packet_out(deviceId.Val, int(egressPort.Val), packet); err != nil {
480 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
481 }
482 return new(empty.Empty), nil
483}
484
485func (rhp *RequestHandlerProxy) Suppress_alarm(args []*ic.Argument) (*empty.Empty, error) {
486 return new(empty.Empty), nil
487}
488
489func (rhp *RequestHandlerProxy) Unsuppress_alarm(args []*ic.Argument) (*empty.Empty, error) {
490 return new(empty.Empty), nil
491}
492
493func (rhp *RequestHandlerProxy) Get_ofp_device_info(args []*ic.Argument) (*ic.SwitchCapability, error) {
494 if len(args) < 2 {
khenaidoob332f9b2020-01-16 16:25:26 -0500495 logger.Warn("invalid-number-of-args", log.Fields{"args": args})
Scott Baker2c1c4822019-10-16 11:02:41 -0700496 err := errors.New("invalid-number-of-args")
497 return nil, err
498 }
499 device := &voltha.Device{}
500 transactionID := &ic.StrType{}
501 for _, arg := range args {
502 switch arg.Key {
503 case "device":
504 if err := ptypes.UnmarshalAny(arg.Value, device); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500505 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700506 return nil, err
507 }
508 case kafka.TransactionKey:
509 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500510 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700511 return nil, err
512 }
513 }
514 }
515
khenaidoob332f9b2020-01-16 16:25:26 -0500516 logger.Debugw("Get_ofp_device_info", log.Fields{"deviceId": device.Id})
Scott Baker2c1c4822019-10-16 11:02:41 -0700517
518 var cap *ic.SwitchCapability
519 var err error
520 if cap, err = rhp.adapter.Get_ofp_device_info(device); err != nil {
521 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
522 }
khenaidoob332f9b2020-01-16 16:25:26 -0500523 logger.Debugw("Get_ofp_device_info", log.Fields{"cap": cap})
Scott Baker2c1c4822019-10-16 11:02:41 -0700524 return cap, nil
525}
526
527func (rhp *RequestHandlerProxy) Get_ofp_port_info(args []*ic.Argument) (*ic.PortCapability, error) {
528 if len(args) < 3 {
khenaidoob332f9b2020-01-16 16:25:26 -0500529 logger.Warn("invalid-number-of-args", log.Fields{"args": args})
Scott Baker2c1c4822019-10-16 11:02:41 -0700530 err := errors.New("invalid-number-of-args")
531 return nil, err
532 }
533 device := &voltha.Device{}
534 pNo := &ic.IntType{}
535 transactionID := &ic.StrType{}
536 for _, arg := range args {
537 switch arg.Key {
538 case "device":
539 if err := ptypes.UnmarshalAny(arg.Value, device); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500540 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700541 return nil, err
542 }
543 case "port_no":
544 if err := ptypes.UnmarshalAny(arg.Value, pNo); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500545 logger.Warnw("cannot-unmarshal-port-no", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700546 return nil, err
547 }
548 case kafka.TransactionKey:
549 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500550 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700551 return nil, err
552 }
553 }
554 }
khenaidoob332f9b2020-01-16 16:25:26 -0500555 logger.Debugw("Get_ofp_port_info", log.Fields{"deviceId": device.Id, "portNo": pNo.Val})
Scott Baker2c1c4822019-10-16 11:02:41 -0700556 var cap *ic.PortCapability
557 var err error
558 if cap, err = rhp.adapter.Get_ofp_port_info(device, pNo.Val); err != nil {
559 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
560 }
561 return cap, nil
562}
563
564func (rhp *RequestHandlerProxy) Process_inter_adapter_message(args []*ic.Argument) (*empty.Empty, error) {
565 if len(args) < 2 {
khenaidoob332f9b2020-01-16 16:25:26 -0500566 logger.Warn("invalid-number-of-args", log.Fields{"args": args})
Scott Baker2c1c4822019-10-16 11:02:41 -0700567 err := errors.New("invalid-number-of-args")
568 return nil, err
569 }
570 iaMsg := &ic.InterAdapterMessage{}
571 transactionID := &ic.StrType{}
572 for _, arg := range args {
573 switch arg.Key {
574 case "msg":
575 if err := ptypes.UnmarshalAny(arg.Value, iaMsg); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500576 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700577 return nil, err
578 }
579 case kafka.TransactionKey:
580 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
khenaidoob332f9b2020-01-16 16:25:26 -0500581 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700582 return nil, err
583 }
584 }
585 }
586
khenaidoob332f9b2020-01-16 16:25:26 -0500587 logger.Debugw("Process_inter_adapter_message", log.Fields{"msgId": iaMsg.Header.Id})
Scott Baker2c1c4822019-10-16 11:02:41 -0700588
589 //Invoke the inter adapter API on the handler
590 if err := rhp.adapter.Process_inter_adapter_message(iaMsg); err != nil {
591 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
592 }
593
594 return new(empty.Empty), nil
595}
596
597func (rhp *RequestHandlerProxy) Download_image(args []*ic.Argument) (*voltha.ImageDownload, error) {
598 return &voltha.ImageDownload{}, nil
599}
600
601func (rhp *RequestHandlerProxy) Get_image_download_status(args []*ic.Argument) (*voltha.ImageDownload, error) {
602 return &voltha.ImageDownload{}, nil
603}
604
605func (rhp *RequestHandlerProxy) Cancel_image_download(args []*ic.Argument) (*voltha.ImageDownload, error) {
606 return &voltha.ImageDownload{}, nil
607}
608
609func (rhp *RequestHandlerProxy) Activate_image_update(args []*ic.Argument) (*voltha.ImageDownload, error) {
610 return &voltha.ImageDownload{}, nil
611}
612
613func (rhp *RequestHandlerProxy) Revert_image_update(args []*ic.Argument) (*voltha.ImageDownload, error) {
614 return &voltha.ImageDownload{}, nil
615}
kesavandf17f7922020-02-03 17:00:27 -0500616
617func (rhp *RequestHandlerProxy) Enable_port(args []*ic.Argument) error {
618 logger.Debugw("enable_port", log.Fields{"args": args})
619 deviceId, port, err := rhp.getEnableDisableParams(args)
620 if err != nil {
621 logger.Warnw("enable_port", log.Fields{"args": args, "deviceId": deviceId, "port": port})
622 return err
623 }
624 return rhp.adapter.Enable_port(deviceId, port)
625}
626
627func (rhp *RequestHandlerProxy) Disable_port(args []*ic.Argument) error {
628 logger.Debugw("disable_port", log.Fields{"args": args})
629 deviceId, port, err := rhp.getEnableDisableParams(args)
630 if err != nil {
631 logger.Warnw("disable_port", log.Fields{"args": args, "deviceId": deviceId, "port": port})
632 return err
633 }
634 return rhp.adapter.Disable_port(deviceId, port)
635}
636
637func (rhp *RequestHandlerProxy) getEnableDisableParams(args []*ic.Argument) (string, *voltha.Port, error) {
638 logger.Debugw("getEnableDisableParams", log.Fields{"args": args})
639 if len(args) < 3 {
640 logger.Warn("invalid-number-of-args", log.Fields{"args": args})
641 return "", nil, errors.New("invalid-number-of-args")
642 }
643 deviceId := &ic.StrType{}
644 port := &voltha.Port{}
645 for _, arg := range args {
646 switch arg.Key {
647 case "deviceId":
648 if err := ptypes.UnmarshalAny(arg.Value, deviceId); err != nil {
649 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
650 return "", nil, err
651 }
652 case "port":
653 if err := ptypes.UnmarshalAny(arg.Value, port); err != nil {
654 logger.Warnw("cannot-unmarshal-port", log.Fields{"error": err})
655 return "", nil, err
656 }
657 }
658 }
659 return deviceId.Val, port, nil
660}