blob: 020e7999c6b0c396e4946b9fbb92e6f7e468c3de [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 (
Neha Sharma94f16a92020-06-26 04:17:55 +000019 "context"
Scott Baker2c1c4822019-10-16 11:02:41 -070020 "errors"
serkant.uluderyab38671c2019-11-01 09:35:38 -070021
Scott Baker2c1c4822019-10-16 11:02:41 -070022 "github.com/golang/protobuf/ptypes"
23 "github.com/golang/protobuf/ptypes/empty"
Girish Gowdra89c985b2020-10-14 15:02:09 -070024 "github.com/opencord/voltha-lib-go/v4/pkg/adapters"
25 "github.com/opencord/voltha-lib-go/v4/pkg/adapters/adapterif"
26 "github.com/opencord/voltha-lib-go/v4/pkg/kafka"
27 "github.com/opencord/voltha-lib-go/v4/pkg/log"
kesavand46a9f012021-01-04 16:40:36 +053028 "github.com/opencord/voltha-protos/v4/go/extension"
Girish Gowdra89c985b2020-10-14 15:02:09 -070029 ic "github.com/opencord/voltha-protos/v4/go/inter_container"
30 "github.com/opencord/voltha-protos/v4/go/openflow_13"
31 "github.com/opencord/voltha-protos/v4/go/voltha"
Scott Baker2c1c4822019-10-16 11:02:41 -070032 "google.golang.org/grpc/codes"
33 "google.golang.org/grpc/status"
34)
35
36type RequestHandlerProxy struct {
37 TestMode bool
38 coreInstanceId string
39 adapter adapters.IAdapter
40 coreProxy adapterif.CoreProxy
41}
42
43func NewRequestHandlerProxy(coreInstanceId string, iadapter adapters.IAdapter, cProxy adapterif.CoreProxy) *RequestHandlerProxy {
44 var proxy RequestHandlerProxy
45 proxy.coreInstanceId = coreInstanceId
46 proxy.adapter = iadapter
47 proxy.coreProxy = cProxy
48 return &proxy
49}
50
51func (rhp *RequestHandlerProxy) Adapter_descriptor() (*empty.Empty, error) {
52 return new(empty.Empty), nil
53}
54
55func (rhp *RequestHandlerProxy) Device_types() (*voltha.DeviceTypes, error) {
56 return nil, nil
57}
58
59func (rhp *RequestHandlerProxy) Health() (*voltha.HealthStatus, error) {
60 return nil, nil
61}
62
Neha Sharma94f16a92020-06-26 04:17:55 +000063func (rhp *RequestHandlerProxy) Adopt_device(ctx context.Context, args []*ic.Argument) (*empty.Empty, error) {
Scott Baker2c1c4822019-10-16 11:02:41 -070064 if len(args) < 3 {
Neha Sharma94f16a92020-06-26 04:17:55 +000065 logger.Warn(ctx, "invalid-number-of-args", log.Fields{"args": args})
Scott Baker2c1c4822019-10-16 11:02:41 -070066 err := errors.New("invalid-number-of-args")
67 return nil, err
68 }
69 device := &voltha.Device{}
70 transactionID := &ic.StrType{}
71 fromTopic := &ic.StrType{}
72 for _, arg := range args {
73 switch arg.Key {
74 case "device":
75 if err := ptypes.UnmarshalAny(arg.Value, device); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +000076 logger.Warnw(ctx, "cannot-unmarshal-device", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -070077 return nil, err
78 }
79 case kafka.TransactionKey:
80 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +000081 logger.Warnw(ctx, "cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -070082 return nil, err
83 }
84 case kafka.FromTopic:
85 if err := ptypes.UnmarshalAny(arg.Value, fromTopic); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +000086 logger.Warnw(ctx, "cannot-unmarshal-from-topic", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -070087 return nil, err
88 }
89 }
90 }
91
Neha Sharma94f16a92020-06-26 04:17:55 +000092 logger.Debugw(ctx, "Adopt_device", log.Fields{"deviceId": device.Id})
Scott Baker2c1c4822019-10-16 11:02:41 -070093
94 //Update the core reference for that device
95 rhp.coreProxy.UpdateCoreReference(device.Id, fromTopic.Val)
96
97 //Invoke the adopt device on the adapter
Neha Sharma94f16a92020-06-26 04:17:55 +000098 if err := rhp.adapter.Adopt_device(ctx, device); err != nil {
Scott Baker2c1c4822019-10-16 11:02:41 -070099 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
100 }
101
102 return new(empty.Empty), nil
103}
104
Neha Sharma94f16a92020-06-26 04:17:55 +0000105func (rhp *RequestHandlerProxy) Reconcile_device(ctx context.Context, args []*ic.Argument) (*empty.Empty, error) {
Scott Baker2c1c4822019-10-16 11:02:41 -0700106 if len(args) < 3 {
Neha Sharma94f16a92020-06-26 04:17:55 +0000107 logger.Warn(ctx, "invalid-number-of-args", log.Fields{"args": args})
Scott Baker2c1c4822019-10-16 11:02:41 -0700108 err := errors.New("invalid-number-of-args")
109 return nil, err
110 }
111
112 device := &voltha.Device{}
113 transactionID := &ic.StrType{}
114 fromTopic := &ic.StrType{}
115 for _, arg := range args {
116 switch arg.Key {
117 case "device":
118 if err := ptypes.UnmarshalAny(arg.Value, device); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000119 logger.Warnw(ctx, "cannot-unmarshal-device", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700120 return nil, err
121 }
122 case kafka.TransactionKey:
123 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000124 logger.Warnw(ctx, "cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700125 return nil, err
126 }
127 case kafka.FromTopic:
128 if err := ptypes.UnmarshalAny(arg.Value, fromTopic); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000129 logger.Warnw(ctx, "cannot-unmarshal-from-topic", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700130 return nil, err
131 }
132 }
133 }
134 //Update the core reference for that device
135 rhp.coreProxy.UpdateCoreReference(device.Id, fromTopic.Val)
136
137 //Invoke the reconcile device API on the adapter
Neha Sharma94f16a92020-06-26 04:17:55 +0000138 if err := rhp.adapter.Reconcile_device(ctx, device); err != nil {
Scott Baker2c1c4822019-10-16 11:02:41 -0700139 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
140 }
141 return new(empty.Empty), nil
142}
143
144func (rhp *RequestHandlerProxy) Abandon_device(args []*ic.Argument) (*empty.Empty, error) {
145 return new(empty.Empty), nil
146}
147
Neha Sharma94f16a92020-06-26 04:17:55 +0000148func (rhp *RequestHandlerProxy) Disable_device(ctx context.Context, args []*ic.Argument) (*empty.Empty, error) {
Scott Baker2c1c4822019-10-16 11:02:41 -0700149 if len(args) < 3 {
Neha Sharma94f16a92020-06-26 04:17:55 +0000150 logger.Warn(ctx, "invalid-number-of-args", log.Fields{"args": args})
Scott Baker2c1c4822019-10-16 11:02:41 -0700151 err := errors.New("invalid-number-of-args")
152 return nil, err
153 }
154
155 device := &voltha.Device{}
156 transactionID := &ic.StrType{}
157 fromTopic := &ic.StrType{}
158 for _, arg := range args {
159 switch arg.Key {
160 case "device":
161 if err := ptypes.UnmarshalAny(arg.Value, device); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000162 logger.Warnw(ctx, "cannot-unmarshal-device", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700163 return nil, err
164 }
165 case kafka.TransactionKey:
166 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000167 logger.Warnw(ctx, "cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700168 return nil, err
169 }
170 case kafka.FromTopic:
171 if err := ptypes.UnmarshalAny(arg.Value, fromTopic); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000172 logger.Warnw(ctx, "cannot-unmarshal-from-topic", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700173 return nil, err
174 }
175 }
176 }
177 //Update the core reference for that device
178 rhp.coreProxy.UpdateCoreReference(device.Id, fromTopic.Val)
179 //Invoke the Disable_device API on the adapter
Neha Sharma94f16a92020-06-26 04:17:55 +0000180 if err := rhp.adapter.Disable_device(ctx, device); err != nil {
Scott Baker2c1c4822019-10-16 11:02:41 -0700181 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
182 }
183 return new(empty.Empty), nil
184}
185
Neha Sharma94f16a92020-06-26 04:17:55 +0000186func (rhp *RequestHandlerProxy) Reenable_device(ctx context.Context, args []*ic.Argument) (*empty.Empty, error) {
Scott Baker2c1c4822019-10-16 11:02:41 -0700187 if len(args) < 3 {
Neha Sharma94f16a92020-06-26 04:17:55 +0000188 logger.Warn(ctx, "invalid-number-of-args", log.Fields{"args": args})
Scott Baker2c1c4822019-10-16 11:02:41 -0700189 err := errors.New("invalid-number-of-args")
190 return nil, err
191 }
192
193 device := &voltha.Device{}
194 transactionID := &ic.StrType{}
195 fromTopic := &ic.StrType{}
196 for _, arg := range args {
197 switch arg.Key {
198 case "device":
199 if err := ptypes.UnmarshalAny(arg.Value, device); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000200 logger.Warnw(ctx, "cannot-unmarshal-device", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700201 return nil, err
202 }
203 case kafka.TransactionKey:
204 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000205 logger.Warnw(ctx, "cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700206 return nil, err
207 }
208 case kafka.FromTopic:
209 if err := ptypes.UnmarshalAny(arg.Value, fromTopic); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000210 logger.Warnw(ctx, "cannot-unmarshal-from-topic", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700211 return nil, err
212 }
213 }
214 }
215 //Update the core reference for that device
216 rhp.coreProxy.UpdateCoreReference(device.Id, fromTopic.Val)
217 //Invoke the Reenable_device API on the adapter
Neha Sharma94f16a92020-06-26 04:17:55 +0000218 if err := rhp.adapter.Reenable_device(ctx, device); err != nil {
Scott Baker2c1c4822019-10-16 11:02:41 -0700219 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
220 }
221 return new(empty.Empty), nil
222}
223
Neha Sharma94f16a92020-06-26 04:17:55 +0000224func (rhp *RequestHandlerProxy) Reboot_device(ctx context.Context, args []*ic.Argument) (*empty.Empty, error) {
Scott Baker2c1c4822019-10-16 11:02:41 -0700225 if len(args) < 3 {
Neha Sharma94f16a92020-06-26 04:17:55 +0000226 logger.Warn(ctx, "invalid-number-of-args", log.Fields{"args": args})
Scott Baker2c1c4822019-10-16 11:02:41 -0700227 err := errors.New("invalid-number-of-args")
228 return nil, err
229 }
230
231 device := &voltha.Device{}
232 transactionID := &ic.StrType{}
233 fromTopic := &ic.StrType{}
234 for _, arg := range args {
235 switch arg.Key {
236 case "device":
237 if err := ptypes.UnmarshalAny(arg.Value, device); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000238 logger.Warnw(ctx, "cannot-unmarshal-device", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700239 return nil, err
240 }
241 case kafka.TransactionKey:
242 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000243 logger.Warnw(ctx, "cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700244 return nil, err
245 }
246 case kafka.FromTopic:
247 if err := ptypes.UnmarshalAny(arg.Value, fromTopic); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000248 logger.Warnw(ctx, "cannot-unmarshal-from-topic", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700249 return nil, err
250 }
251 }
252 }
253 //Update the core reference for that device
254 rhp.coreProxy.UpdateCoreReference(device.Id, fromTopic.Val)
255 //Invoke the Reboot_device API on the adapter
Neha Sharma94f16a92020-06-26 04:17:55 +0000256 if err := rhp.adapter.Reboot_device(ctx, device); err != nil {
Scott Baker2c1c4822019-10-16 11:02:41 -0700257 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
258 }
259 return new(empty.Empty), nil
260
261}
262
263func (rhp *RequestHandlerProxy) Self_test_device(args []*ic.Argument) (*empty.Empty, error) {
264 return new(empty.Empty), nil
265}
266
Neha Sharma94f16a92020-06-26 04:17:55 +0000267func (rhp *RequestHandlerProxy) Delete_device(ctx context.Context, args []*ic.Argument) (*empty.Empty, error) {
Scott Baker2c1c4822019-10-16 11:02:41 -0700268 if len(args) < 3 {
Neha Sharma94f16a92020-06-26 04:17:55 +0000269 logger.Warn(ctx, "invalid-number-of-args", log.Fields{"args": args})
Scott Baker2c1c4822019-10-16 11:02:41 -0700270 err := errors.New("invalid-number-of-args")
271 return nil, err
272 }
273
274 device := &voltha.Device{}
275 transactionID := &ic.StrType{}
276 fromTopic := &ic.StrType{}
277 for _, arg := range args {
278 switch arg.Key {
279 case "device":
280 if err := ptypes.UnmarshalAny(arg.Value, device); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000281 logger.Warnw(ctx, "cannot-unmarshal-device", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700282 return nil, err
283 }
284 case kafka.TransactionKey:
285 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000286 logger.Warnw(ctx, "cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700287 return nil, err
288 }
289 case kafka.FromTopic:
290 if err := ptypes.UnmarshalAny(arg.Value, fromTopic); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000291 logger.Warnw(ctx, "cannot-unmarshal-from-topic", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700292 return nil, err
293 }
294 }
295 }
296 //Update the core reference for that device
297 rhp.coreProxy.UpdateCoreReference(device.Id, fromTopic.Val)
298 //Invoke the delete_device API on the adapter
Neha Sharma94f16a92020-06-26 04:17:55 +0000299 if err := rhp.adapter.Delete_device(ctx, device); err != nil {
Scott Baker2c1c4822019-10-16 11:02:41 -0700300 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
301 }
302 return new(empty.Empty), nil
303}
304
305func (rhp *RequestHandlerProxy) Get_device_details(args []*ic.Argument) (*empty.Empty, error) {
306 return new(empty.Empty), nil
307}
308
Neha Sharma94f16a92020-06-26 04:17:55 +0000309func (rhp *RequestHandlerProxy) Update_flows_bulk(ctx context.Context, args []*ic.Argument) (*empty.Empty, error) {
310 logger.Debug(ctx, "Update_flows_bulk")
Scott Baker2c1c4822019-10-16 11:02:41 -0700311 if len(args) < 5 {
Neha Sharma94f16a92020-06-26 04:17:55 +0000312 logger.Warn(ctx, "Update_flows_bulk-invalid-number-of-args", log.Fields{"args": args})
Scott Baker2c1c4822019-10-16 11:02:41 -0700313 err := errors.New("invalid-number-of-args")
314 return nil, err
315 }
316 device := &voltha.Device{}
317 transactionID := &ic.StrType{}
318 flows := &voltha.Flows{}
319 flowMetadata := &voltha.FlowMetadata{}
320 groups := &voltha.FlowGroups{}
321 for _, arg := range args {
322 switch arg.Key {
323 case "device":
324 if err := ptypes.UnmarshalAny(arg.Value, device); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000325 logger.Warnw(ctx, "cannot-unmarshal-device", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700326 return nil, err
327 }
328 case "flows":
329 if err := ptypes.UnmarshalAny(arg.Value, flows); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000330 logger.Warnw(ctx, "cannot-unmarshal-flows", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700331 return nil, err
332 }
333 case "groups":
334 if err := ptypes.UnmarshalAny(arg.Value, groups); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000335 logger.Warnw(ctx, "cannot-unmarshal-groups", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700336 return nil, err
337 }
338 case "flow_metadata":
339 if err := ptypes.UnmarshalAny(arg.Value, flowMetadata); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000340 logger.Warnw(ctx, "cannot-unmarshal-metadata", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700341 return nil, err
342 }
343 case kafka.TransactionKey:
344 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000345 logger.Warnw(ctx, "cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700346 return nil, err
347 }
348 }
349 }
Neha Sharma94f16a92020-06-26 04:17:55 +0000350 logger.Debugw(ctx, "Update_flows_bulk", log.Fields{"flows": flows, "groups": groups})
Scott Baker2c1c4822019-10-16 11:02:41 -0700351 //Invoke the bulk flow update API of the adapter
Neha Sharma94f16a92020-06-26 04:17:55 +0000352 if err := rhp.adapter.Update_flows_bulk(ctx, device, flows, groups, flowMetadata); err != nil {
Scott Baker2c1c4822019-10-16 11:02:41 -0700353 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
354 }
355 return new(empty.Empty), nil
356}
357
Neha Sharma94f16a92020-06-26 04:17:55 +0000358func (rhp *RequestHandlerProxy) Update_flows_incrementally(ctx context.Context, args []*ic.Argument) (*empty.Empty, error) {
359 logger.Debug(ctx, "Update_flows_incrementally")
Scott Baker2c1c4822019-10-16 11:02:41 -0700360 if len(args) < 5 {
Neha Sharma94f16a92020-06-26 04:17:55 +0000361 logger.Warn(ctx, "Update_flows_incrementally-invalid-number-of-args", log.Fields{"args": args})
Scott Baker2c1c4822019-10-16 11:02:41 -0700362 err := errors.New("invalid-number-of-args")
363 return nil, err
364 }
365 device := &voltha.Device{}
366 transactionID := &ic.StrType{}
367 flows := &openflow_13.FlowChanges{}
368 flowMetadata := &voltha.FlowMetadata{}
369 groups := &openflow_13.FlowGroupChanges{}
370 for _, arg := range args {
371 switch arg.Key {
372 case "device":
373 if err := ptypes.UnmarshalAny(arg.Value, device); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000374 logger.Warnw(ctx, "cannot-unmarshal-device", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700375 return nil, err
376 }
377 case "flow_changes":
378 if err := ptypes.UnmarshalAny(arg.Value, flows); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000379 logger.Warnw(ctx, "cannot-unmarshal-flows", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700380 return nil, err
381 }
382 case "group_changes":
383 if err := ptypes.UnmarshalAny(arg.Value, groups); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000384 logger.Warnw(ctx, "cannot-unmarshal-groups", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700385 return nil, err
386 }
387 case "flow_metadata":
388 if err := ptypes.UnmarshalAny(arg.Value, flowMetadata); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000389 logger.Warnw(ctx, "cannot-unmarshal-metadata", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700390 return nil, err
391 }
392 case kafka.TransactionKey:
393 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000394 logger.Warnw(ctx, "cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700395 return nil, err
396 }
397 }
398 }
Neha Sharma94f16a92020-06-26 04:17:55 +0000399 logger.Debugw(ctx, "Update_flows_incrementally", log.Fields{"flows": flows, "groups": groups})
Scott Baker2c1c4822019-10-16 11:02:41 -0700400 //Invoke the incremental flow update API of the adapter
Neha Sharma94f16a92020-06-26 04:17:55 +0000401 if err := rhp.adapter.Update_flows_incrementally(ctx, device, flows, groups, flowMetadata); err != nil {
Scott Baker2c1c4822019-10-16 11:02:41 -0700402 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
403 }
404 return new(empty.Empty), nil
405}
406
Neha Sharma94f16a92020-06-26 04:17:55 +0000407func (rhp *RequestHandlerProxy) Update_pm_config(ctx context.Context, args []*ic.Argument) (*empty.Empty, error) {
408 logger.Debug(ctx, "Update_pm_config")
Scott Baker2c1c4822019-10-16 11:02:41 -0700409 if len(args) < 2 {
Neha Sharma94f16a92020-06-26 04:17:55 +0000410 logger.Warn(ctx, "Update_pm_config-invalid-number-of-args", log.Fields{"args": args})
Scott Baker2c1c4822019-10-16 11:02:41 -0700411 err := errors.New("invalid-number-of-args")
412 return nil, err
413 }
414 device := &voltha.Device{}
415 transactionID := &ic.StrType{}
416 pmConfigs := &voltha.PmConfigs{}
417 for _, arg := range args {
418 switch arg.Key {
419 case "device":
420 if err := ptypes.UnmarshalAny(arg.Value, device); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000421 logger.Warnw(ctx, "cannot-unmarshal-device", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700422 return nil, err
423 }
424 case "pm_configs":
425 if err := ptypes.UnmarshalAny(arg.Value, pmConfigs); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000426 logger.Warnw(ctx, "cannot-unmarshal-pm-configs", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700427 return nil, err
428 }
429 case kafka.TransactionKey:
430 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000431 logger.Warnw(ctx, "cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700432 return nil, err
433 }
434 }
435 }
divyadesai5d8836b2020-08-18 07:40:59 +0000436 logger.Debugw(ctx, "Update_pm_config", log.Fields{"device-id": device.Id, "pmConfigs": pmConfigs})
Scott Baker2c1c4822019-10-16 11:02:41 -0700437 //Invoke the pm config update API of the adapter
Neha Sharma94f16a92020-06-26 04:17:55 +0000438 if err := rhp.adapter.Update_pm_config(ctx, device, pmConfigs); err != nil {
Scott Baker2c1c4822019-10-16 11:02:41 -0700439 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
440 }
441 return new(empty.Empty), nil
442}
443
Neha Sharma94f16a92020-06-26 04:17:55 +0000444func (rhp *RequestHandlerProxy) Receive_packet_out(ctx context.Context, args []*ic.Argument) (*empty.Empty, error) {
445 logger.Debugw(ctx, "Receive_packet_out", log.Fields{"args": args})
Scott Baker2c1c4822019-10-16 11:02:41 -0700446 if len(args) < 3 {
Neha Sharma94f16a92020-06-26 04:17:55 +0000447 logger.Warn(ctx, "Receive_packet_out-invalid-number-of-args", log.Fields{"args": args})
Scott Baker2c1c4822019-10-16 11:02:41 -0700448 err := errors.New("invalid-number-of-args")
449 return nil, err
450 }
451 deviceId := &ic.StrType{}
452 egressPort := &ic.IntType{}
453 packet := &openflow_13.OfpPacketOut{}
454 transactionID := &ic.StrType{}
455 for _, arg := range args {
456 switch arg.Key {
457 case "deviceId":
458 if err := ptypes.UnmarshalAny(arg.Value, deviceId); err != nil {
divyadesai5d8836b2020-08-18 07:40:59 +0000459 logger.Warnw(ctx, "cannot-unmarshal-device-id", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700460 return nil, err
461 }
462 case "outPort":
463 if err := ptypes.UnmarshalAny(arg.Value, egressPort); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000464 logger.Warnw(ctx, "cannot-unmarshal-egressPort", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700465 return nil, err
466 }
467 case "packet":
468 if err := ptypes.UnmarshalAny(arg.Value, packet); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000469 logger.Warnw(ctx, "cannot-unmarshal-packet", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700470 return nil, err
471 }
472 case kafka.TransactionKey:
473 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000474 logger.Warnw(ctx, "cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700475 return nil, err
476 }
477 }
478 }
divyadesai5d8836b2020-08-18 07:40:59 +0000479 logger.Debugw(ctx, "Receive_packet_out", log.Fields{"device-id": deviceId.Val, "outPort": egressPort, "packet": packet})
Scott Baker2c1c4822019-10-16 11:02:41 -0700480 //Invoke the adopt device on the adapter
Neha Sharma94f16a92020-06-26 04:17:55 +0000481 if err := rhp.adapter.Receive_packet_out(ctx, deviceId.Val, int(egressPort.Val), packet); err != nil {
Scott Baker2c1c4822019-10-16 11:02:41 -0700482 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
483 }
484 return new(empty.Empty), nil
485}
486
487func (rhp *RequestHandlerProxy) Suppress_alarm(args []*ic.Argument) (*empty.Empty, error) {
488 return new(empty.Empty), nil
489}
490
491func (rhp *RequestHandlerProxy) Unsuppress_alarm(args []*ic.Argument) (*empty.Empty, error) {
492 return new(empty.Empty), nil
493}
494
Neha Sharma94f16a92020-06-26 04:17:55 +0000495func (rhp *RequestHandlerProxy) Get_ofp_device_info(ctx context.Context, args []*ic.Argument) (*ic.SwitchCapability, error) {
Scott Baker2c1c4822019-10-16 11:02:41 -0700496 if len(args) < 2 {
Neha Sharma94f16a92020-06-26 04:17:55 +0000497 logger.Warn(ctx, "invalid-number-of-args", log.Fields{"args": args})
Scott Baker2c1c4822019-10-16 11:02:41 -0700498 err := errors.New("invalid-number-of-args")
499 return nil, err
500 }
501 device := &voltha.Device{}
502 transactionID := &ic.StrType{}
503 for _, arg := range args {
504 switch arg.Key {
505 case "device":
506 if err := ptypes.UnmarshalAny(arg.Value, device); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000507 logger.Warnw(ctx, "cannot-unmarshal-device", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700508 return nil, err
509 }
510 case kafka.TransactionKey:
511 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000512 logger.Warnw(ctx, "cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700513 return nil, err
514 }
515 }
516 }
517
divyadesai5d8836b2020-08-18 07:40:59 +0000518 logger.Debugw(ctx, "Get_ofp_device_info", log.Fields{"device-id": device.Id})
Scott Baker2c1c4822019-10-16 11:02:41 -0700519
520 var cap *ic.SwitchCapability
521 var err error
Neha Sharma94f16a92020-06-26 04:17:55 +0000522 if cap, err = rhp.adapter.Get_ofp_device_info(ctx, device); err != nil {
Scott Baker2c1c4822019-10-16 11:02:41 -0700523 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
524 }
Neha Sharma94f16a92020-06-26 04:17:55 +0000525 logger.Debugw(ctx, "Get_ofp_device_info", log.Fields{"cap": cap})
Scott Baker2c1c4822019-10-16 11:02:41 -0700526 return cap, nil
527}
528
Neha Sharma94f16a92020-06-26 04:17:55 +0000529func (rhp *RequestHandlerProxy) Process_inter_adapter_message(ctx context.Context, args []*ic.Argument) (*empty.Empty, error) {
Scott Baker2c1c4822019-10-16 11:02:41 -0700530 if len(args) < 2 {
Neha Sharma94f16a92020-06-26 04:17:55 +0000531 logger.Warn(ctx, "invalid-number-of-args", log.Fields{"args": args})
Scott Baker2c1c4822019-10-16 11:02:41 -0700532 err := errors.New("invalid-number-of-args")
533 return nil, err
534 }
535 iaMsg := &ic.InterAdapterMessage{}
536 transactionID := &ic.StrType{}
537 for _, arg := range args {
538 switch arg.Key {
539 case "msg":
540 if err := ptypes.UnmarshalAny(arg.Value, iaMsg); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000541 logger.Warnw(ctx, "cannot-unmarshal-device", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700542 return nil, err
543 }
544 case kafka.TransactionKey:
545 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000546 logger.Warnw(ctx, "cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Scott Baker2c1c4822019-10-16 11:02:41 -0700547 return nil, err
548 }
549 }
550 }
551
Neha Sharma94f16a92020-06-26 04:17:55 +0000552 logger.Debugw(ctx, "Process_inter_adapter_message", log.Fields{"msgId": iaMsg.Header.Id})
Scott Baker2c1c4822019-10-16 11:02:41 -0700553
554 //Invoke the inter adapter API on the handler
Neha Sharma94f16a92020-06-26 04:17:55 +0000555 if err := rhp.adapter.Process_inter_adapter_message(ctx, iaMsg); err != nil {
Scott Baker2c1c4822019-10-16 11:02:41 -0700556 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
557 }
558
559 return new(empty.Empty), nil
560}
561
Andrea Campanella26ccc882021-01-14 11:47:35 +0100562func (rhp *RequestHandlerProxy) Download_image(ctx context.Context, args []*ic.Argument) (*voltha.ImageDownload, error) {
563 device, image, err := unMarshalImageDowload(args, ctx)
564 if err != nil {
565 return nil, err
566 }
567
568 imageDownload, err := rhp.adapter.Download_image(ctx, device, image)
569 if err != nil {
570 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
571 }
572 return imageDownload, nil
Scott Baker2c1c4822019-10-16 11:02:41 -0700573}
574
Andrea Campanella26ccc882021-01-14 11:47:35 +0100575func (rhp *RequestHandlerProxy) Get_image_download_status(ctx context.Context, args []*ic.Argument) (*voltha.ImageDownload, error) {
576 device, image, err := unMarshalImageDowload(args, ctx)
577 if err != nil {
578 return nil, err
579 }
580
581 imageDownload, err := rhp.adapter.Get_image_download_status(ctx, device, image)
582 if err != nil {
583 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
584 }
585 return imageDownload, nil
Scott Baker2c1c4822019-10-16 11:02:41 -0700586}
587
Andrea Campanella26ccc882021-01-14 11:47:35 +0100588func (rhp *RequestHandlerProxy) Cancel_image_download(ctx context.Context, args []*ic.Argument) (*voltha.ImageDownload, error) {
589 device, image, err := unMarshalImageDowload(args, ctx)
590 if err != nil {
591 return nil, err
592 }
593
594 imageDownload, err := rhp.adapter.Cancel_image_download(ctx, device, image)
595 if err != nil {
596 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
597 }
598 return imageDownload, nil
Scott Baker2c1c4822019-10-16 11:02:41 -0700599}
600
Andrea Campanella26ccc882021-01-14 11:47:35 +0100601func (rhp *RequestHandlerProxy) Activate_image_update(ctx context.Context, args []*ic.Argument) (*voltha.ImageDownload, error) {
602
603 device, image, err := unMarshalImageDowload(args, ctx)
604 if err != nil {
605 return nil, err
606 }
607
608 imageDownload, err := rhp.adapter.Activate_image_update(ctx, device, image)
609 if err != nil {
610 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
611 }
612 return imageDownload, nil
Scott Baker2c1c4822019-10-16 11:02:41 -0700613}
614
Andrea Campanella26ccc882021-01-14 11:47:35 +0100615func (rhp *RequestHandlerProxy) Revert_image_update(ctx context.Context, args []*ic.Argument) (*voltha.ImageDownload, error) {
616 device, image, err := unMarshalImageDowload(args, ctx)
617 if err != nil {
618 return nil, err
619 }
620
621 imageDownload, err := rhp.adapter.Revert_image_update(ctx, device, image)
622 if err != nil {
623 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
624 }
625 return imageDownload, nil
626}
627
628func unMarshalImageDowload(args []*ic.Argument, ctx context.Context) (*voltha.Device, *voltha.ImageDownload, error) {
629 if len(args) < 4 {
630 logger.Warn(ctx, "invalid-number-of-args", log.Fields{"args": args})
631 err := errors.New("invalid-number-of-args")
632 return nil, nil, err
633 }
634 device := &voltha.Device{}
635 image := &voltha.ImageDownload{}
636 transactionID := &ic.StrType{}
637 fromTopic := &ic.StrType{}
638 for _, arg := range args {
639 switch arg.Key {
640 case "device":
641 if err := ptypes.UnmarshalAny(arg.Value, device); err != nil {
642 logger.Warnw(ctx, "cannot-unmarshal-device", log.Fields{"error": err})
643 return nil, nil, err
644 }
645 case "request":
646 if err := ptypes.UnmarshalAny(arg.Value, image); err != nil {
647 logger.Warnw(ctx, "cannot-unmarshal-image", log.Fields{"error": err})
648 return nil, nil, err
649 }
650 case kafka.TransactionKey:
651 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
652 logger.Warnw(ctx, "cannot-unmarshal-transaction-ID", log.Fields{"error": err})
653 return nil, nil, err
654 }
655 case kafka.FromTopic:
656 if err := ptypes.UnmarshalAny(arg.Value, fromTopic); err != nil {
657 logger.Warnw(ctx, "cannot-unmarshal-from-topic", log.Fields{"error": err})
658 return nil, nil, err
659 }
660 }
661 }
662 return device, image, nil
Scott Baker2c1c4822019-10-16 11:02:41 -0700663}
kesavandf17f7922020-02-03 17:00:27 -0500664
Neha Sharma94f16a92020-06-26 04:17:55 +0000665func (rhp *RequestHandlerProxy) Enable_port(ctx context.Context, args []*ic.Argument) error {
666 logger.Debugw(ctx, "enable_port", log.Fields{"args": args})
667 deviceId, port, err := rhp.getEnableDisableParams(ctx, args)
kesavandf17f7922020-02-03 17:00:27 -0500668 if err != nil {
divyadesai5d8836b2020-08-18 07:40:59 +0000669 logger.Warnw(ctx, "enable_port", log.Fields{"args": args, "device-id": deviceId, "port": port})
kesavandf17f7922020-02-03 17:00:27 -0500670 return err
671 }
Neha Sharma94f16a92020-06-26 04:17:55 +0000672 return rhp.adapter.Enable_port(ctx, deviceId, port)
kesavandf17f7922020-02-03 17:00:27 -0500673}
674
Neha Sharma94f16a92020-06-26 04:17:55 +0000675func (rhp *RequestHandlerProxy) Disable_port(ctx context.Context, args []*ic.Argument) error {
676 logger.Debugw(ctx, "disable_port", log.Fields{"args": args})
677 deviceId, port, err := rhp.getEnableDisableParams(ctx, args)
kesavandf17f7922020-02-03 17:00:27 -0500678 if err != nil {
divyadesai5d8836b2020-08-18 07:40:59 +0000679 logger.Warnw(ctx, "disable_port", log.Fields{"args": args, "device-id": deviceId, "port": port})
kesavandf17f7922020-02-03 17:00:27 -0500680 return err
681 }
Neha Sharma94f16a92020-06-26 04:17:55 +0000682 return rhp.adapter.Disable_port(ctx, deviceId, port)
kesavandf17f7922020-02-03 17:00:27 -0500683}
684
Neha Sharma94f16a92020-06-26 04:17:55 +0000685func (rhp *RequestHandlerProxy) getEnableDisableParams(ctx context.Context, args []*ic.Argument) (string, *voltha.Port, error) {
686 logger.Debugw(ctx, "getEnableDisableParams", log.Fields{"args": args})
kesavandf17f7922020-02-03 17:00:27 -0500687 if len(args) < 3 {
Neha Sharma94f16a92020-06-26 04:17:55 +0000688 logger.Warn(ctx, "invalid-number-of-args", log.Fields{"args": args})
kesavandf17f7922020-02-03 17:00:27 -0500689 return "", nil, errors.New("invalid-number-of-args")
690 }
691 deviceId := &ic.StrType{}
692 port := &voltha.Port{}
693 for _, arg := range args {
694 switch arg.Key {
695 case "deviceId":
696 if err := ptypes.UnmarshalAny(arg.Value, deviceId); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000697 logger.Warnw(ctx, "cannot-unmarshal-device", log.Fields{"error": err})
kesavandf17f7922020-02-03 17:00:27 -0500698 return "", nil, err
699 }
700 case "port":
701 if err := ptypes.UnmarshalAny(arg.Value, port); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000702 logger.Warnw(ctx, "cannot-unmarshal-port", log.Fields{"error": err})
kesavandf17f7922020-02-03 17:00:27 -0500703 return "", nil, err
704 }
705 }
706 }
707 return deviceId.Val, port, nil
708}
Chaitrashree G Sc4a5c072020-02-04 17:08:40 -0500709
Neha Sharma94f16a92020-06-26 04:17:55 +0000710func (rhp *RequestHandlerProxy) Child_device_lost(ctx context.Context, args []*ic.Argument) error {
Girish Gowdra2d99f242021-03-11 14:35:39 -0800711 if len(args) < 2 {
Neha Sharma94f16a92020-06-26 04:17:55 +0000712 logger.Warn(ctx, "invalid-number-of-args", log.Fields{"args": args})
Chaitrashree G Sc4a5c072020-02-04 17:08:40 -0500713 return errors.New("invalid-number-of-args")
714 }
Girish Gowdra2d99f242021-03-11 14:35:39 -0800715 childDevice := &voltha.Device{}
Chaitrashree G Sc4a5c072020-02-04 17:08:40 -0500716 fromTopic := &ic.StrType{}
717 for _, arg := range args {
718 switch arg.Key {
Girish Gowdra2d99f242021-03-11 14:35:39 -0800719 case "childDevice":
720 if err := ptypes.UnmarshalAny(arg.Value, childDevice); err != nil {
721 logger.Warnw(ctx, "cannot-unmarshal-child-device", log.Fields{"error": err})
Chaitrashree G Sc4a5c072020-02-04 17:08:40 -0500722 return err
723 }
724 case kafka.FromTopic:
725 if err := ptypes.UnmarshalAny(arg.Value, fromTopic); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000726 logger.Warnw(ctx, "cannot-unmarshal-from-topic", log.Fields{"error": err})
Chaitrashree G Sc4a5c072020-02-04 17:08:40 -0500727 return err
728 }
729 }
730 }
731 //Update the core reference for that device
Girish Gowdra2d99f242021-03-11 14:35:39 -0800732 rhp.coreProxy.UpdateCoreReference(childDevice.ParentId, fromTopic.Val)
Chaitrashree G Sc4a5c072020-02-04 17:08:40 -0500733 //Invoke the Child_device_lost API on the adapter
Girish Gowdra2d99f242021-03-11 14:35:39 -0800734 if err := rhp.adapter.Child_device_lost(ctx, childDevice); err != nil {
Chaitrashree G Sc4a5c072020-02-04 17:08:40 -0500735 return status.Errorf(codes.NotFound, "%s", err.Error())
736 }
737 return nil
738}
Scott Baker04cb5da2020-03-26 15:52:22 -0700739
Neha Sharma94f16a92020-06-26 04:17:55 +0000740func (rhp *RequestHandlerProxy) Start_omci_test(ctx context.Context, args []*ic.Argument) (*ic.TestResponse, error) {
Scott Baker04cb5da2020-03-26 15:52:22 -0700741 if len(args) < 2 {
Neha Sharma94f16a92020-06-26 04:17:55 +0000742 logger.Warn(ctx, "invalid-number-of-args", log.Fields{"args": args})
Scott Baker04cb5da2020-03-26 15:52:22 -0700743 err := errors.New("invalid-number-of-args")
744 return nil, err
745 }
746
747 // TODO: See related comment in voltha-go:adapter_proxy_go:startOmciTest()
748 // Second argument should perhaps be uuid instead of omcitestrequest
749
750 device := &voltha.Device{}
751 request := &voltha.OmciTestRequest{}
752 for _, arg := range args {
753 switch arg.Key {
754 case "device":
755 if err := ptypes.UnmarshalAny(arg.Value, device); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000756 logger.Warnw(ctx, "cannot-unmarshal-device", log.Fields{"error": err})
Scott Baker04cb5da2020-03-26 15:52:22 -0700757 return nil, err
758 }
759 case "omcitestrequest":
760 if err := ptypes.UnmarshalAny(arg.Value, request); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000761 logger.Warnw(ctx, "cannot-unmarshal-omcitestrequest", log.Fields{"error": err})
Scott Baker04cb5da2020-03-26 15:52:22 -0700762 return nil, err
763 }
764 }
765 }
Neha Sharma94f16a92020-06-26 04:17:55 +0000766 logger.Debugw(ctx, "Start_omci_test", log.Fields{"device-id": device.Id, "req": request})
767 result, err := rhp.adapter.Start_omci_test(ctx, device, request)
Scott Baker04cb5da2020-03-26 15:52:22 -0700768 if err != nil {
769 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
770 }
771 return result, nil
772}
Neha Sharma94f16a92020-06-26 04:17:55 +0000773func (rhp *RequestHandlerProxy) Get_ext_value(ctx context.Context, args []*ic.Argument) (*voltha.ReturnValues, error) {
Dinesh Belwalkar4c89a1d2020-02-28 16:05:32 -0800774 if len(args) < 3 {
Neha Sharma94f16a92020-06-26 04:17:55 +0000775 logger.Warn(ctx, "invalid-number-of-args", log.Fields{"args": args})
Dinesh Belwalkar4c89a1d2020-02-28 16:05:32 -0800776 return nil, errors.New("invalid-number-of-args")
777 }
778
779 pDeviceId := &ic.StrType{}
780 device := &voltha.Device{}
781 valuetype := &ic.IntType{}
782 for _, arg := range args {
783 switch arg.Key {
784 case "device":
785 if err := ptypes.UnmarshalAny(arg.Value, device); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000786 logger.Warnw(ctx, "cannot-unmarshal-device", log.Fields{"error": err})
Dinesh Belwalkar4c89a1d2020-02-28 16:05:32 -0800787 return nil, err
788 }
789 case "pDeviceId":
790 if err := ptypes.UnmarshalAny(arg.Value, pDeviceId); err != nil {
divyadesai5d8836b2020-08-18 07:40:59 +0000791 logger.Warnw(ctx, "cannot-unmarshal-parent-device-id", log.Fields{"error": err})
Dinesh Belwalkar4c89a1d2020-02-28 16:05:32 -0800792 return nil, err
793 }
794 case "valuetype":
795 if err := ptypes.UnmarshalAny(arg.Value, valuetype); err != nil {
Neha Sharma94f16a92020-06-26 04:17:55 +0000796 logger.Warnw(ctx, "cannot-unmarshal-valuetype", log.Fields{"error": err})
Dinesh Belwalkar4c89a1d2020-02-28 16:05:32 -0800797 return nil, err
798 }
799 default:
Neha Sharma94f16a92020-06-26 04:17:55 +0000800 logger.Warnw(ctx, "key-not-found", log.Fields{"arg.Key": arg.Key})
Dinesh Belwalkar4c89a1d2020-02-28 16:05:32 -0800801 }
802 }
803
804 //Invoke the Get_value API on the adapter
Neha Sharma94f16a92020-06-26 04:17:55 +0000805 return rhp.adapter.Get_ext_value(ctx, pDeviceId.Val, device, voltha.ValueType_Type(valuetype.Val))
Dinesh Belwalkar4c89a1d2020-02-28 16:05:32 -0800806}
kesavand46a9f012021-01-04 16:40:36 +0530807
808func (rhp *RequestHandlerProxy) Single_get_value_request(ctx context.Context, args []*ic.Argument) (*extension.SingleGetValueResponse, error) {
809 logger.Debugw(ctx, "req handler Single_get_value_request", log.Fields{"no of args": len(args), "args": args})
810
811 if len(args) < 1 {
812 logger.Warn(ctx, "invalid-number-of-args", log.Fields{"args": args})
813 return nil, errors.New("invalid-number-of-args")
814 }
815 singleGetvalueReq := extension.SingleGetValueRequest{}
816 errResp := func(status extension.GetValueResponse_Status, reason extension.GetValueResponse_ErrorReason) *extension.SingleGetValueResponse {
817 return &extension.SingleGetValueResponse{
818 Response: &extension.GetValueResponse{
819 Status: status,
820 ErrReason: reason,
821 },
822 }
823 }
824 for _, arg := range args {
825 switch arg.Key {
826 case "request":
827 if err := ptypes.UnmarshalAny(arg.Value, &singleGetvalueReq); err != nil {
828 logger.Warnw(ctx, "cannot-unmarshal-singleGetvalueReq", log.Fields{"error": err})
829 return errResp(extension.GetValueResponse_ERROR, extension.GetValueResponse_REASON_UNDEFINED), nil
830 }
831 default:
832 logger.Warnw(ctx, "key-not-found", log.Fields{"arg.Key": arg.Key})
833 }
834 }
835 logger.Debugw(ctx, "invoke rhp.adapter.Single_get_value_request ", log.Fields{"singleGetvalueReq": singleGetvalueReq})
836 return rhp.adapter.Single_get_value_request(ctx, singleGetvalueReq)
837}
kesavand652ef482021-04-19 09:26:39 +0530838
839func (rhp *RequestHandlerProxy) getDeviceDownloadImageRequest(ctx context.Context, args []*ic.Argument) (*voltha.DeviceImageDownloadRequest, error) {
840 logger.Debugw(ctx, "getDeviceDownloadImageRequest", log.Fields{"args": args})
841 if len(args) < 1 {
842 logger.Warn(ctx, "invalid-number-of-args", log.Fields{"args": args})
843 return nil, errors.New("invalid-number-of-args")
844 }
845
846 deviceDownloadImageReq := ic.DeviceImageDownloadRequest{}
847
848 for _, arg := range args {
849 switch arg.Key {
850 case "deviceImageDownloadReq":
851 if err := ptypes.UnmarshalAny(arg.Value, &deviceDownloadImageReq); err != nil {
852 logger.Warnw(ctx, "cannot-unmarshal-device", log.Fields{"error": err})
853 return nil, err
854 }
855 default:
856 return nil, errors.New("invalid argument")
857 }
858 }
859 return &deviceDownloadImageReq, nil
860}
861
862func (rhp *RequestHandlerProxy) getDeviceImageRequest(ctx context.Context, args []*ic.Argument) (*voltha.DeviceImageRequest, error) {
863 logger.Debugw(ctx, "getDeviceImageRequest", log.Fields{"args": args})
864 if len(args) < 1 {
865 logger.Warn(ctx, "invalid-number-of-args", log.Fields{"args": args})
866 return nil, errors.New("invalid-number-of-args")
867 }
868
869 deviceImageReq := ic.DeviceImageRequest{}
870
871 for _, arg := range args {
872 switch arg.Key {
873 case "deviceImageReq":
874 if err := ptypes.UnmarshalAny(arg.Value, &deviceImageReq); err != nil {
875 logger.Warnw(ctx, "cannot-unmarshal-device", log.Fields{"error": err})
876 return nil, err
877 }
878 default:
879 return nil, errors.New("invalid argument")
880 }
881 }
882 return &deviceImageReq, nil
883}
884
885func (rhp *RequestHandlerProxy) getDeviceID(ctx context.Context, args []*ic.Argument) (string, error) {
886 logger.Debugw(ctx, "getDeviceID", log.Fields{"args": args})
887
888 deviceId := &ic.StrType{}
889
890 for _, arg := range args {
891 switch arg.Key {
892 case "deviceId":
893 if err := ptypes.UnmarshalAny(arg.Value, deviceId); err != nil {
894 logger.Warnw(ctx, "cannot-unmarshal-device", log.Fields{"error": err})
895 return "", err
896 }
897 default:
898 return "", errors.New("invalid argument")
899 }
900 }
901 return deviceId.Val, nil
902}
903
904func (rhp *RequestHandlerProxy) Download_onu_image(ctx context.Context, args []*ic.Argument) (*voltha.DeviceImageResponse, error) {
905 imageDownloadReq, err := rhp.getDeviceDownloadImageRequest(ctx, args)
906 if err != nil {
907 return nil, err
908 }
909
910 imageDownloadRsp, err := rhp.adapter.Download_onu_image(ctx, imageDownloadReq)
911 if err != nil {
912 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
913 }
914 return imageDownloadRsp, nil
915}
916
917func (rhp *RequestHandlerProxy) Get_onu_image_status(ctx context.Context, args []*ic.Argument) (*voltha.DeviceImageResponse, error) {
918 imageStatusReq, err := rhp.getDeviceImageRequest(ctx, args)
919 if err != nil {
920 return nil, err
921 }
922
923 imageStatus, err := rhp.adapter.Get_onu_image_status(ctx, imageStatusReq)
924 if err != nil {
925 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
926 }
927 return imageStatus, nil
928}
929
930func (rhp *RequestHandlerProxy) Abort_onu_image_upgrade(ctx context.Context, args []*ic.Argument) (*voltha.DeviceImageResponse, error) {
931 imageAbortReq, err := rhp.getDeviceImageRequest(ctx, args)
932 if err != nil {
933 return nil, err
934 }
935
936 imageAbortRsp, err := rhp.adapter.Abort_onu_image_upgrade(ctx, imageAbortReq)
937 if err != nil {
938 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
939 }
940 return imageAbortRsp, nil
941}
942
943func (rhp *RequestHandlerProxy) Activate_onu_image(ctx context.Context, args []*ic.Argument) (*voltha.DeviceImageResponse, error) {
944 imageActivateReq, err := rhp.getDeviceImageRequest(ctx, args)
945 if err != nil {
946 return nil, err
947 }
948
949 imageActivateRsp, err := rhp.adapter.Activate_onu_image(ctx, imageActivateReq)
950 if err != nil {
951 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
952 }
953 return imageActivateRsp, nil
954}
955
956func (rhp *RequestHandlerProxy) Commit_onu_image(ctx context.Context, args []*ic.Argument) (*voltha.DeviceImageResponse, error) {
957 imageCommitReq, err := rhp.getDeviceImageRequest(ctx, args)
958 if err != nil {
959 return nil, err
960 }
961
962 imageCommitRsp, err := rhp.adapter.Commit_onu_image(ctx, imageCommitReq)
963 if err != nil {
964 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
965 }
966
967 return imageCommitRsp, nil
968}
969
970func (rhp *RequestHandlerProxy) Get_onu_images(ctx context.Context, args []*ic.Argument) (*voltha.OnuImages, error) {
971 deviceID, err := rhp.getDeviceID(ctx, args)
972 if err != nil {
973 return nil, err
974 }
975
976 onuImages, err := rhp.adapter.Get_onu_images(ctx, deviceID)
977 if err != nil {
978 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
979 }
980 return onuImages, nil
981}