blob: 5b0088757fa6037230c191fd6f26175a6dcc0513 [file] [log] [blame]
William Kurkianea869482019-04-09 15:16:11 -04001/*
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"
Esin Karamanccb714b2019-11-29 15:02:06 +000020
William Kurkianea869482019-04-09 15:16:11 -040021 "github.com/golang/protobuf/ptypes"
22 "github.com/golang/protobuf/ptypes/empty"
Esin Karamanccb714b2019-11-29 15:02:06 +000023 "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"
William Kurkianea869482019-04-09 15:16:11 -040030 "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
Devmalya Paul495b94a2019-08-27 19:42:00 -040038 coreProxy adapterif.CoreProxy
William Kurkianea869482019-04-09 15:16:11 -040039}
40
Devmalya Paul495b94a2019-08-27 19:42:00 -040041func NewRequestHandlerProxy(coreInstanceId string, iadapter adapters.IAdapter, cProxy adapterif.CoreProxy) *RequestHandlerProxy {
William Kurkianea869482019-04-09 15:16:11 -040042 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 {
Esin Karamanccb714b2019-11-29 15:02:06 +000063 logger.Warn("invalid-number-of-args", log.Fields{"args": args})
William Kurkianea869482019-04-09 15:16:11 -040064 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 {
Esin Karamanccb714b2019-11-29 15:02:06 +000074 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
William Kurkianea869482019-04-09 15:16:11 -040075 return nil, err
76 }
77 case kafka.TransactionKey:
78 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
Esin Karamanccb714b2019-11-29 15:02:06 +000079 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
William Kurkianea869482019-04-09 15:16:11 -040080 return nil, err
81 }
82 case kafka.FromTopic:
83 if err := ptypes.UnmarshalAny(arg.Value, fromTopic); err != nil {
Esin Karamanccb714b2019-11-29 15:02:06 +000084 logger.Warnw("cannot-unmarshal-from-topic", log.Fields{"error": err})
William Kurkianea869482019-04-09 15:16:11 -040085 return nil, err
86 }
87 }
88 }
89
Esin Karamanccb714b2019-11-29 15:02:06 +000090 logger.Debugw("Adopt_device", log.Fields{"deviceId": device.Id})
William Kurkianea869482019-04-09 15:16:11 -040091
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) {
Manikkaraj kb1d51442019-07-23 10:41:02 -0400104 if len(args) < 3 {
Esin Karamanccb714b2019-11-29 15:02:06 +0000105 logger.Warn("invalid-number-of-args", log.Fields{"args": args})
Manikkaraj kb1d51442019-07-23 10:41:02 -0400106 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 {
Esin Karamanccb714b2019-11-29 15:02:06 +0000117 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
Manikkaraj kb1d51442019-07-23 10:41:02 -0400118 return nil, err
119 }
120 case kafka.TransactionKey:
121 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
Esin Karamanccb714b2019-11-29 15:02:06 +0000122 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Manikkaraj kb1d51442019-07-23 10:41:02 -0400123 return nil, err
124 }
125 case kafka.FromTopic:
126 if err := ptypes.UnmarshalAny(arg.Value, fromTopic); err != nil {
Esin Karamanccb714b2019-11-29 15:02:06 +0000127 logger.Warnw("cannot-unmarshal-from-topic", log.Fields{"error": err})
Manikkaraj kb1d51442019-07-23 10:41:02 -0400128 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 }
William Kurkianea869482019-04-09 15:16:11 -0400139 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) {
Matt Jeanneret384d8c92019-05-06 14:27:31 -0400147 if len(args) < 3 {
Esin Karamanccb714b2019-11-29 15:02:06 +0000148 logger.Warn("invalid-number-of-args", log.Fields{"args": args})
Matt Jeanneret384d8c92019-05-06 14:27:31 -0400149 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 {
Esin Karamanccb714b2019-11-29 15:02:06 +0000160 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
Matt Jeanneret384d8c92019-05-06 14:27:31 -0400161 return nil, err
162 }
163 case kafka.TransactionKey:
164 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
Esin Karamanccb714b2019-11-29 15:02:06 +0000165 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Matt Jeanneret384d8c92019-05-06 14:27:31 -0400166 return nil, err
167 }
168 case kafka.FromTopic:
169 if err := ptypes.UnmarshalAny(arg.Value, fromTopic); err != nil {
Esin Karamanccb714b2019-11-29 15:02:06 +0000170 logger.Warnw("cannot-unmarshal-from-topic", log.Fields{"error": err})
Matt Jeanneret384d8c92019-05-06 14:27:31 -0400171 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 }
William Kurkianea869482019-04-09 15:16:11 -0400181 return new(empty.Empty), nil
182}
183
184func (rhp *RequestHandlerProxy) Reenable_device(args []*ic.Argument) (*empty.Empty, error) {
Matt Jeanneret384d8c92019-05-06 14:27:31 -0400185 if len(args) < 3 {
Esin Karamanccb714b2019-11-29 15:02:06 +0000186 logger.Warn("invalid-number-of-args", log.Fields{"args": args})
Matt Jeanneret384d8c92019-05-06 14:27:31 -0400187 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 {
Esin Karamanccb714b2019-11-29 15:02:06 +0000198 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
Matt Jeanneret384d8c92019-05-06 14:27:31 -0400199 return nil, err
200 }
201 case kafka.TransactionKey:
202 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
Esin Karamanccb714b2019-11-29 15:02:06 +0000203 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Matt Jeanneret384d8c92019-05-06 14:27:31 -0400204 return nil, err
205 }
206 case kafka.FromTopic:
207 if err := ptypes.UnmarshalAny(arg.Value, fromTopic); err != nil {
Esin Karamanccb714b2019-11-29 15:02:06 +0000208 logger.Warnw("cannot-unmarshal-from-topic", log.Fields{"error": err})
Matt Jeanneret384d8c92019-05-06 14:27:31 -0400209 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 }
William Kurkianea869482019-04-09 15:16:11 -0400219 return new(empty.Empty), nil
220}
221
222func (rhp *RequestHandlerProxy) Reboot_device(args []*ic.Argument) (*empty.Empty, error) {
Mahir Gunyele77977b2019-06-27 05:36:22 -0700223 if len(args) < 3 {
Esin Karamanccb714b2019-11-29 15:02:06 +0000224 logger.Warn("invalid-number-of-args", log.Fields{"args": args})
Mahir Gunyele77977b2019-06-27 05:36:22 -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 {
Esin Karamanccb714b2019-11-29 15:02:06 +0000236 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
Mahir Gunyele77977b2019-06-27 05:36:22 -0700237 return nil, err
238 }
239 case kafka.TransactionKey:
240 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
Esin Karamanccb714b2019-11-29 15:02:06 +0000241 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Mahir Gunyele77977b2019-06-27 05:36:22 -0700242 return nil, err
243 }
244 case kafka.FromTopic:
245 if err := ptypes.UnmarshalAny(arg.Value, fromTopic); err != nil {
Esin Karamanccb714b2019-11-29 15:02:06 +0000246 logger.Warnw("cannot-unmarshal-from-topic", log.Fields{"error": err})
Mahir Gunyele77977b2019-06-27 05:36:22 -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 }
William Kurkianea869482019-04-09 15:16:11 -0400257 return new(empty.Empty), nil
Mahir Gunyele77977b2019-06-27 05:36:22 -0700258
William Kurkianea869482019-04-09 15:16:11 -0400259}
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) {
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400266 if len(args) < 3 {
Esin Karamanccb714b2019-11-29 15:02:06 +0000267 logger.Warn("invalid-number-of-args", log.Fields{"args": args})
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400268 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 {
Esin Karamanccb714b2019-11-29 15:02:06 +0000279 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400280 return nil, err
281 }
282 case kafka.TransactionKey:
283 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
Esin Karamanccb714b2019-11-29 15:02:06 +0000284 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400285 return nil, err
286 }
287 case kafka.FromTopic:
288 if err := ptypes.UnmarshalAny(arg.Value, fromTopic); err != nil {
Esin Karamanccb714b2019-11-29 15:02:06 +0000289 logger.Warnw("cannot-unmarshal-from-topic", log.Fields{"error": err})
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400290 return nil, err
291 }
292 }
293 }
294 //Update the core reference for that device
295 rhp.coreProxy.UpdateCoreReference(device.Id, fromTopic.Val)
Manikkaraj kb1d51442019-07-23 10:41:02 -0400296 //Invoke the delete_device API on the adapter
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400297 if err := rhp.adapter.Delete_device(device); err != nil {
298 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
299 }
William Kurkianea869482019-04-09 15:16:11 -0400300 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) {
Esin Karamanccb714b2019-11-29 15:02:06 +0000308 logger.Debug("Update_flows_bulk")
Manikkaraj kb1d51442019-07-23 10:41:02 -0400309 if len(args) < 5 {
Esin Karamanccb714b2019-11-29 15:02:06 +0000310 logger.Warn("Update_flows_bulk-invalid-number-of-args", log.Fields{"args": args})
Mahir Gunyele77977b2019-06-27 05:36:22 -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{}
Manikkaraj kb1d51442019-07-23 10:41:02 -0400317 flowMetadata := &voltha.FlowMetadata{}
Mahir Gunyele77977b2019-06-27 05:36:22 -0700318 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 {
Esin Karamanccb714b2019-11-29 15:02:06 +0000323 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
Mahir Gunyele77977b2019-06-27 05:36:22 -0700324 return nil, err
325 }
326 case "flows":
327 if err := ptypes.UnmarshalAny(arg.Value, flows); err != nil {
Esin Karamanccb714b2019-11-29 15:02:06 +0000328 logger.Warnw("cannot-unmarshal-flows", log.Fields{"error": err})
Mahir Gunyele77977b2019-06-27 05:36:22 -0700329 return nil, err
330 }
331 case "groups":
332 if err := ptypes.UnmarshalAny(arg.Value, groups); err != nil {
Esin Karamanccb714b2019-11-29 15:02:06 +0000333 logger.Warnw("cannot-unmarshal-groups", log.Fields{"error": err})
Mahir Gunyele77977b2019-06-27 05:36:22 -0700334 return nil, err
335 }
Manikkaraj kb1d51442019-07-23 10:41:02 -0400336 case "flow_metadata":
337 if err := ptypes.UnmarshalAny(arg.Value, flowMetadata); err != nil {
Esin Karamanccb714b2019-11-29 15:02:06 +0000338 logger.Warnw("cannot-unmarshal-metadata", log.Fields{"error": err})
Manikkaraj kb1d51442019-07-23 10:41:02 -0400339 return nil, err
340 }
Mahir Gunyele77977b2019-06-27 05:36:22 -0700341 case kafka.TransactionKey:
342 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
Esin Karamanccb714b2019-11-29 15:02:06 +0000343 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Mahir Gunyele77977b2019-06-27 05:36:22 -0700344 return nil, err
345 }
346 }
347 }
Esin Karamanccb714b2019-11-29 15:02:06 +0000348 logger.Debugw("Update_flows_bulk", log.Fields{"flows": flows, "groups": groups})
Manikkaraj kb1d51442019-07-23 10:41:02 -0400349 //Invoke the bulk flow update API of the adapter
350 if err := rhp.adapter.Update_flows_bulk(device, flows, groups, flowMetadata); err != nil {
Mahir Gunyele77977b2019-06-27 05:36:22 -0700351 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
352 }
William Kurkianea869482019-04-09 15:16:11 -0400353 return new(empty.Empty), nil
354}
355
356func (rhp *RequestHandlerProxy) Update_flows_incrementally(args []*ic.Argument) (*empty.Empty, error) {
Esin Karamanccb714b2019-11-29 15:02:06 +0000357 logger.Debug("Update_flows_incrementally")
Manikkaraj kb1d51442019-07-23 10:41:02 -0400358 if len(args) < 5 {
Esin Karamanccb714b2019-11-29 15:02:06 +0000359 logger.Warn("Update_flows_incrementally-invalid-number-of-args", log.Fields{"args": args})
Matt Jeanneretcab955f2019-04-10 15:45:57 -0400360 err := errors.New("invalid-number-of-args")
361 return nil, err
362 }
363 device := &voltha.Device{}
364 transactionID := &ic.StrType{}
Matt Jeanneret384d8c92019-05-06 14:27:31 -0400365 flows := &openflow_13.FlowChanges{}
Manikkaraj kb1d51442019-07-23 10:41:02 -0400366 flowMetadata := &voltha.FlowMetadata{}
Matt Jeanneret384d8c92019-05-06 14:27:31 -0400367 groups := &openflow_13.FlowGroupChanges{}
Matt Jeanneretcab955f2019-04-10 15:45:57 -0400368 for _, arg := range args {
369 switch arg.Key {
370 case "device":
371 if err := ptypes.UnmarshalAny(arg.Value, device); err != nil {
Esin Karamanccb714b2019-11-29 15:02:06 +0000372 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
Matt Jeanneretcab955f2019-04-10 15:45:57 -0400373 return nil, err
374 }
375 case "flow_changes":
376 if err := ptypes.UnmarshalAny(arg.Value, flows); err != nil {
Esin Karamanccb714b2019-11-29 15:02:06 +0000377 logger.Warnw("cannot-unmarshal-flows", log.Fields{"error": err})
Matt Jeanneretcab955f2019-04-10 15:45:57 -0400378 return nil, err
379 }
380 case "group_changes":
381 if err := ptypes.UnmarshalAny(arg.Value, groups); err != nil {
Esin Karamanccb714b2019-11-29 15:02:06 +0000382 logger.Warnw("cannot-unmarshal-groups", log.Fields{"error": err})
Matt Jeanneretcab955f2019-04-10 15:45:57 -0400383 return nil, err
384 }
Manikkaraj kb1d51442019-07-23 10:41:02 -0400385 case "flow_metadata":
386 if err := ptypes.UnmarshalAny(arg.Value, flowMetadata); err != nil {
Esin Karamanccb714b2019-11-29 15:02:06 +0000387 logger.Warnw("cannot-unmarshal-metadata", log.Fields{"error": err})
Manikkaraj kb1d51442019-07-23 10:41:02 -0400388 return nil, err
389 }
Matt Jeanneretcab955f2019-04-10 15:45:57 -0400390 case kafka.TransactionKey:
391 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
Esin Karamanccb714b2019-11-29 15:02:06 +0000392 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Matt Jeanneretcab955f2019-04-10 15:45:57 -0400393 return nil, err
394 }
395 }
396 }
Esin Karamanccb714b2019-11-29 15:02:06 +0000397 logger.Debugw("Update_flows_incrementally", log.Fields{"flows": flows, "groups": groups})
Manikkaraj kb1d51442019-07-23 10:41:02 -0400398 //Invoke the incremental flow update API of the adapter
399 if err := rhp.adapter.Update_flows_incrementally(device, flows, groups, flowMetadata); err != nil {
Matt Jeanneret384d8c92019-05-06 14:27:31 -0400400 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
401 }
William Kurkianea869482019-04-09 15:16:11 -0400402 return new(empty.Empty), nil
403}
404
405func (rhp *RequestHandlerProxy) Update_pm_config(args []*ic.Argument) (*empty.Empty, error) {
Esin Karamanccb714b2019-11-29 15:02:06 +0000406 logger.Debug("Update_pm_config")
Manikkaraj kb1d51442019-07-23 10:41:02 -0400407 if len(args) < 2 {
Esin Karamanccb714b2019-11-29 15:02:06 +0000408 logger.Warn("Update_pm_config-invalid-number-of-args", log.Fields{"args": args})
Manikkaraj kb1d51442019-07-23 10:41:02 -0400409 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 {
Esin Karamanccb714b2019-11-29 15:02:06 +0000419 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
Manikkaraj kb1d51442019-07-23 10:41:02 -0400420 return nil, err
421 }
422 case "pm_configs":
423 if err := ptypes.UnmarshalAny(arg.Value, pmConfigs); err != nil {
Esin Karamanccb714b2019-11-29 15:02:06 +0000424 logger.Warnw("cannot-unmarshal-pm-configs", log.Fields{"error": err})
Manikkaraj kb1d51442019-07-23 10:41:02 -0400425 return nil, err
426 }
427 case kafka.TransactionKey:
428 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
Esin Karamanccb714b2019-11-29 15:02:06 +0000429 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Manikkaraj kb1d51442019-07-23 10:41:02 -0400430 return nil, err
431 }
432 }
433 }
Esin Karamanccb714b2019-11-29 15:02:06 +0000434 logger.Debugw("Update_pm_config", log.Fields{"deviceId": device.Id, "pmConfigs": pmConfigs})
Manikkaraj kb1d51442019-07-23 10:41:02 -0400435 //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 }
William Kurkianea869482019-04-09 15:16:11 -0400439 return new(empty.Empty), nil
440}
441
442func (rhp *RequestHandlerProxy) Receive_packet_out(args []*ic.Argument) (*empty.Empty, error) {
Esin Karamanccb714b2019-11-29 15:02:06 +0000443 logger.Debugw("Receive_packet_out", log.Fields{"args": args})
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400444 if len(args) < 3 {
Esin Karamanccb714b2019-11-29 15:02:06 +0000445 logger.Warn("Receive_packet_out-invalid-number-of-args", log.Fields{"args": args})
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400446 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 {
Esin Karamanccb714b2019-11-29 15:02:06 +0000457 logger.Warnw("cannot-unmarshal-deviceId", log.Fields{"error": err})
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400458 return nil, err
459 }
460 case "outPort":
461 if err := ptypes.UnmarshalAny(arg.Value, egressPort); err != nil {
Esin Karamanccb714b2019-11-29 15:02:06 +0000462 logger.Warnw("cannot-unmarshal-egressPort", log.Fields{"error": err})
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400463 return nil, err
464 }
465 case "packet":
466 if err := ptypes.UnmarshalAny(arg.Value, packet); err != nil {
Esin Karamanccb714b2019-11-29 15:02:06 +0000467 logger.Warnw("cannot-unmarshal-packet", log.Fields{"error": err})
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400468 return nil, err
469 }
470 case kafka.TransactionKey:
471 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
Esin Karamanccb714b2019-11-29 15:02:06 +0000472 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400473 return nil, err
474 }
475 }
476 }
Esin Karamanccb714b2019-11-29 15:02:06 +0000477 logger.Debugw("Receive_packet_out", log.Fields{"deviceId": deviceId.Val, "outPort": egressPort, "packet": packet})
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400478 //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 }
William Kurkianea869482019-04-09 15:16:11 -0400482 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 {
Esin Karamanccb714b2019-11-29 15:02:06 +0000495 logger.Warn("invalid-number-of-args", log.Fields{"args": args})
William Kurkianea869482019-04-09 15:16:11 -0400496 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 {
Esin Karamanccb714b2019-11-29 15:02:06 +0000505 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
William Kurkianea869482019-04-09 15:16:11 -0400506 return nil, err
507 }
508 case kafka.TransactionKey:
509 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
Esin Karamanccb714b2019-11-29 15:02:06 +0000510 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
William Kurkianea869482019-04-09 15:16:11 -0400511 return nil, err
512 }
513 }
514 }
515
Esin Karamanccb714b2019-11-29 15:02:06 +0000516 logger.Debugw("Get_ofp_device_info", log.Fields{"deviceId": device.Id})
William Kurkianea869482019-04-09 15:16:11 -0400517
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 }
Esin Karamanccb714b2019-11-29 15:02:06 +0000523 logger.Debugw("Get_ofp_device_info", log.Fields{"cap": cap})
William Kurkianea869482019-04-09 15:16:11 -0400524 return cap, nil
525}
526
527func (rhp *RequestHandlerProxy) Get_ofp_port_info(args []*ic.Argument) (*ic.PortCapability, error) {
528 if len(args) < 3 {
Esin Karamanccb714b2019-11-29 15:02:06 +0000529 logger.Warn("invalid-number-of-args", log.Fields{"args": args})
William Kurkianea869482019-04-09 15:16:11 -0400530 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 {
Esin Karamanccb714b2019-11-29 15:02:06 +0000540 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
William Kurkianea869482019-04-09 15:16:11 -0400541 return nil, err
542 }
543 case "port_no":
544 if err := ptypes.UnmarshalAny(arg.Value, pNo); err != nil {
Esin Karamanccb714b2019-11-29 15:02:06 +0000545 logger.Warnw("cannot-unmarshal-port-no", log.Fields{"error": err})
William Kurkianea869482019-04-09 15:16:11 -0400546 return nil, err
547 }
548 case kafka.TransactionKey:
549 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
Esin Karamanccb714b2019-11-29 15:02:06 +0000550 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
William Kurkianea869482019-04-09 15:16:11 -0400551 return nil, err
552 }
553 }
554 }
Esin Karamanccb714b2019-11-29 15:02:06 +0000555 logger.Debugw("Get_ofp_port_info", log.Fields{"deviceId": device.Id, "portNo": pNo.Val})
William Kurkianea869482019-04-09 15:16:11 -0400556 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 {
Esin Karamanccb714b2019-11-29 15:02:06 +0000566 logger.Warn("invalid-number-of-args", log.Fields{"args": args})
William Kurkianea869482019-04-09 15:16:11 -0400567 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 {
Esin Karamanccb714b2019-11-29 15:02:06 +0000576 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
William Kurkianea869482019-04-09 15:16:11 -0400577 return nil, err
578 }
579 case kafka.TransactionKey:
580 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
Esin Karamanccb714b2019-11-29 15:02:06 +0000581 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
William Kurkianea869482019-04-09 15:16:11 -0400582 return nil, err
583 }
584 }
585 }
586
Esin Karamanccb714b2019-11-29 15:02:06 +0000587 logger.Debugw("Process_inter_adapter_message", log.Fields{"msgId": iaMsg.Header.Id})
William Kurkianea869482019-04-09 15:16:11 -0400588
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}
kesavandd6184722020-02-05 17:13:35 -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}
Chaitrashree G S1a55b882020-02-04 17:35:35 -0500661
662func (rhp *RequestHandlerProxy) Child_device_lost(args []*ic.Argument) error {
663 if len(args) < 4 {
664 logger.Warn("invalid-number-of-args", log.Fields{"args": args})
665 return errors.New("invalid-number-of-args")
666 }
667
668 pDeviceId := &ic.StrType{}
669 pPortNo := &ic.IntType{}
670 onuID := &ic.IntType{}
671 fromTopic := &ic.StrType{}
672 for _, arg := range args {
673 switch arg.Key {
674 case "pDeviceId":
675 if err := ptypes.UnmarshalAny(arg.Value, pDeviceId); err != nil {
676 logger.Warnw("cannot-unmarshal-parent-deviceId", log.Fields{"error": err})
677 return err
678 }
679 case "pPortNo":
680 if err := ptypes.UnmarshalAny(arg.Value, pPortNo); err != nil {
681 logger.Warnw("cannot-unmarshal-port", log.Fields{"error": err})
682 return err
683 }
684 case "onuID":
685 if err := ptypes.UnmarshalAny(arg.Value, onuID); err != nil {
686 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
687 return err
688 }
689 case kafka.FromTopic:
690 if err := ptypes.UnmarshalAny(arg.Value, fromTopic); err != nil {
691 logger.Warnw("cannot-unmarshal-from-topic", log.Fields{"error": err})
692 return err
693 }
694 }
695 }
696 //Update the core reference for that device
697 rhp.coreProxy.UpdateCoreReference(pDeviceId.Val, fromTopic.Val)
698 //Invoke the Child_device_lost API on the adapter
699 if err := rhp.adapter.Child_device_lost(pDeviceId.Val, uint32(pPortNo.Val), uint32(onuID.Val)); err != nil {
700 return status.Errorf(codes.NotFound, "%s", err.Error())
701 }
702 return nil
703}