blob: 78b8eb569fac9a5fd432da028a8331c84a892c12 [file] [log] [blame]
khenaidood2b6df92018-12-13 16:37:20 -05001/*
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.uluderya2ae470f2020-01-21 11:13:09 -080020
khenaidood2b6df92018-12-13 16:37:20 -050021 "github.com/golang/protobuf/ptypes"
22 "github.com/golang/protobuf/ptypes/empty"
serkant.uluderya2ae470f2020-01-21 11:13:09 -080023 "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"
khenaidood2b6df92018-12-13 16:37:20 -050030 "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
kdarapu283d1542019-07-31 17:21:11 +053038 coreProxy adapterif.CoreProxy
khenaidood2b6df92018-12-13 16:37:20 -050039}
40
kdarapu283d1542019-07-31 17:21:11 +053041func NewRequestHandlerProxy(coreInstanceId string, iadapter adapters.IAdapter, cProxy adapterif.CoreProxy) *RequestHandlerProxy {
khenaidood2b6df92018-12-13 16:37:20 -050042 var proxy RequestHandlerProxy
43 proxy.coreInstanceId = coreInstanceId
44 proxy.adapter = iadapter
khenaidoo54e0ddf2019-02-27 16:21:33 -050045 proxy.coreProxy = cProxy
khenaidood2b6df92018-12-13 16:37:20 -050046 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) {
khenaidoo54e0ddf2019-02-27 16:21:33 -050062 if len(args) < 3 {
serkant.uluderya2ae470f2020-01-21 11:13:09 -080063 logger.Warn("invalid-number-of-args", log.Fields{"args": args})
khenaidood2b6df92018-12-13 16:37:20 -050064 err := errors.New("invalid-number-of-args")
65 return nil, err
66 }
67 device := &voltha.Device{}
khenaidoo6d055132019-02-12 16:51:19 -050068 transactionID := &ic.StrType{}
khenaidoo54e0ddf2019-02-27 16:21:33 -050069 fromTopic := &ic.StrType{}
khenaidoo6d055132019-02-12 16:51:19 -050070 for _, arg := range args {
71 switch arg.Key {
72 case "device":
73 if err := ptypes.UnmarshalAny(arg.Value, device); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -080074 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
khenaidoo6d055132019-02-12 16:51:19 -050075 return nil, err
76 }
77 case kafka.TransactionKey:
78 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -080079 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
khenaidoo6d055132019-02-12 16:51:19 -050080 return nil, err
81 }
khenaidoo54e0ddf2019-02-27 16:21:33 -050082 case kafka.FromTopic:
83 if err := ptypes.UnmarshalAny(arg.Value, fromTopic); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -080084 logger.Warnw("cannot-unmarshal-from-topic", log.Fields{"error": err})
khenaidoo54e0ddf2019-02-27 16:21:33 -050085 return nil, err
86 }
khenaidoo6d055132019-02-12 16:51:19 -050087 }
khenaidood2b6df92018-12-13 16:37:20 -050088 }
khenaidoo6d055132019-02-12 16:51:19 -050089
serkant.uluderya2ae470f2020-01-21 11:13:09 -080090 logger.Debugw("Adopt_device", log.Fields{"deviceId": device.Id})
khenaidood2b6df92018-12-13 16:37:20 -050091
khenaidoo54e0ddf2019-02-27 16:21:33 -050092 //Update the core reference for that device
93 rhp.coreProxy.UpdateCoreReference(device.Id, fromTopic.Val)
94
khenaidood2b6df92018-12-13 16:37:20 -050095 //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) {
khenaidooba6b6c42019-08-02 09:11:56 -0400104 if len(args) < 3 {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800105 logger.Warn("invalid-number-of-args", log.Fields{"args": args})
khenaidooba6b6c42019-08-02 09:11:56 -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 {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800117 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
khenaidooba6b6c42019-08-02 09:11:56 -0400118 return nil, err
119 }
120 case kafka.TransactionKey:
121 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800122 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
khenaidooba6b6c42019-08-02 09:11:56 -0400123 return nil, err
124 }
125 case kafka.FromTopic:
126 if err := ptypes.UnmarshalAny(arg.Value, fromTopic); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800127 logger.Warnw("cannot-unmarshal-from-topic", log.Fields{"error": err})
khenaidooba6b6c42019-08-02 09:11:56 -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 }
khenaidood2b6df92018-12-13 16:37:20 -0500139 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) {
khenaidoo3ab34882019-05-02 21:33:30 -0400147 if len(args) < 3 {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800148 logger.Warn("invalid-number-of-args", log.Fields{"args": args})
khenaidoo3ab34882019-05-02 21:33:30 -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 {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800160 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
khenaidoo3ab34882019-05-02 21:33:30 -0400161 return nil, err
162 }
163 case kafka.TransactionKey:
164 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800165 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
khenaidoo3ab34882019-05-02 21:33:30 -0400166 return nil, err
167 }
168 case kafka.FromTopic:
169 if err := ptypes.UnmarshalAny(arg.Value, fromTopic); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800170 logger.Warnw("cannot-unmarshal-from-topic", log.Fields{"error": err})
khenaidoo3ab34882019-05-02 21:33:30 -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 }
khenaidood2b6df92018-12-13 16:37:20 -0500181 return new(empty.Empty), nil
182}
183
184func (rhp *RequestHandlerProxy) Reenable_device(args []*ic.Argument) (*empty.Empty, error) {
khenaidoo3ab34882019-05-02 21:33:30 -0400185 if len(args) < 3 {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800186 logger.Warn("invalid-number-of-args", log.Fields{"args": args})
khenaidoo3ab34882019-05-02 21:33:30 -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 {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800198 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
khenaidoo3ab34882019-05-02 21:33:30 -0400199 return nil, err
200 }
201 case kafka.TransactionKey:
202 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800203 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
khenaidoo3ab34882019-05-02 21:33:30 -0400204 return nil, err
205 }
206 case kafka.FromTopic:
207 if err := ptypes.UnmarshalAny(arg.Value, fromTopic); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800208 logger.Warnw("cannot-unmarshal-from-topic", log.Fields{"error": err})
khenaidoo3ab34882019-05-02 21:33:30 -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 }
khenaidood2b6df92018-12-13 16:37:20 -0500219 return new(empty.Empty), nil
220}
221
222func (rhp *RequestHandlerProxy) Reboot_device(args []*ic.Argument) (*empty.Empty, error) {
Girish Gowdru894d97d2019-05-28 05:07:18 -0400223 if len(args) < 3 {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800224 logger.Warn("invalid-number-of-args", log.Fields{"args": args})
Girish Gowdru894d97d2019-05-28 05:07:18 -0400225 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 {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800236 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
Girish Gowdru894d97d2019-05-28 05:07:18 -0400237 return nil, err
238 }
239 case kafka.TransactionKey:
240 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800241 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
Girish Gowdru894d97d2019-05-28 05:07:18 -0400242 return nil, err
243 }
244 case kafka.FromTopic:
245 if err := ptypes.UnmarshalAny(arg.Value, fromTopic); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800246 logger.Warnw("cannot-unmarshal-from-topic", log.Fields{"error": err})
Girish Gowdru894d97d2019-05-28 05:07:18 -0400247 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 }
khenaidood2b6df92018-12-13 16:37:20 -0500257 return new(empty.Empty), nil
Girish Gowdru894d97d2019-05-28 05:07:18 -0400258
khenaidood2b6df92018-12-13 16:37:20 -0500259}
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) {
khenaidoo0a822f92019-05-08 15:15:57 -0400266 if len(args) < 3 {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800267 logger.Warn("invalid-number-of-args", log.Fields{"args": args})
khenaidoo0a822f92019-05-08 15:15:57 -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 {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800279 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
khenaidoo0a822f92019-05-08 15:15:57 -0400280 return nil, err
281 }
282 case kafka.TransactionKey:
283 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800284 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
khenaidoo0a822f92019-05-08 15:15:57 -0400285 return nil, err
286 }
287 case kafka.FromTopic:
288 if err := ptypes.UnmarshalAny(arg.Value, fromTopic); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800289 logger.Warnw("cannot-unmarshal-from-topic", log.Fields{"error": err})
khenaidoo0a822f92019-05-08 15:15:57 -0400290 return nil, err
291 }
292 }
293 }
294 //Update the core reference for that device
295 rhp.coreProxy.UpdateCoreReference(device.Id, fromTopic.Val)
khenaidoob3127472019-07-24 21:04:55 -0400296 //Invoke the delete_device API on the adapter
khenaidoo0a822f92019-05-08 15:15:57 -0400297 if err := rhp.adapter.Delete_device(device); err != nil {
298 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
299 }
khenaidood2b6df92018-12-13 16:37:20 -0500300 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) {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800308 logger.Debug("Update_flows_bulk")
Manikkaraj kb1a10922019-07-29 12:10:34 -0400309 if len(args) < 5 {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800310 logger.Warn("Update_flows_bulk-invalid-number-of-args", log.Fields{"args": args})
khenaidoo0458db62019-06-20 08:50:36 -0400311 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 kb1a10922019-07-29 12:10:34 -0400317 flowMetadata := &voltha.FlowMetadata{}
khenaidoo0458db62019-06-20 08:50:36 -0400318 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 {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800323 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
khenaidoo0458db62019-06-20 08:50:36 -0400324 return nil, err
325 }
326 case "flows":
327 if err := ptypes.UnmarshalAny(arg.Value, flows); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800328 logger.Warnw("cannot-unmarshal-flows", log.Fields{"error": err})
khenaidoo0458db62019-06-20 08:50:36 -0400329 return nil, err
330 }
331 case "groups":
332 if err := ptypes.UnmarshalAny(arg.Value, groups); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800333 logger.Warnw("cannot-unmarshal-groups", log.Fields{"error": err})
khenaidoo0458db62019-06-20 08:50:36 -0400334 return nil, err
335 }
Manikkaraj kb1a10922019-07-29 12:10:34 -0400336 case "flow_metadata":
337 if err := ptypes.UnmarshalAny(arg.Value, flowMetadata); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800338 logger.Warnw("cannot-unmarshal-metadata", log.Fields{"error": err})
Manikkaraj kb1a10922019-07-29 12:10:34 -0400339 return nil, err
340 }
khenaidoo0458db62019-06-20 08:50:36 -0400341 case kafka.TransactionKey:
342 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800343 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
khenaidoo0458db62019-06-20 08:50:36 -0400344 return nil, err
345 }
346 }
347 }
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800348 logger.Debugw("Update_flows_bulk", log.Fields{"flows": flows, "groups": groups})
khenaidoob3127472019-07-24 21:04:55 -0400349 //Invoke the bulk flow update API of the adapter
Manikkaraj kb1a10922019-07-29 12:10:34 -0400350 if err := rhp.adapter.Update_flows_bulk(device, flows, groups, flowMetadata); err != nil {
khenaidoo0458db62019-06-20 08:50:36 -0400351 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
352 }
khenaidood2b6df92018-12-13 16:37:20 -0500353 return new(empty.Empty), nil
354}
355
356func (rhp *RequestHandlerProxy) Update_flows_incrementally(args []*ic.Argument) (*empty.Empty, error) {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800357 logger.Debug("Update_flows_incrementally")
Manikkaraj kb1a10922019-07-29 12:10:34 -0400358 if len(args) < 5 {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800359 logger.Warn("Update_flows_incrementally-invalid-number-of-args", log.Fields{"args": args})
mkoodali252f7672019-03-25 12:13:12 +0530360 err := errors.New("invalid-number-of-args")
361 return nil, err
362 }
363 device := &voltha.Device{}
364 transactionID := &ic.StrType{}
khenaidoo2c6a0992019-04-29 13:46:56 -0400365 flows := &openflow_13.FlowChanges{}
Manikkaraj kb1a10922019-07-29 12:10:34 -0400366 flowMetadata := &voltha.FlowMetadata{}
khenaidoo2c6a0992019-04-29 13:46:56 -0400367 groups := &openflow_13.FlowGroupChanges{}
mkoodali252f7672019-03-25 12:13:12 +0530368 for _, arg := range args {
369 switch arg.Key {
370 case "device":
371 if err := ptypes.UnmarshalAny(arg.Value, device); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800372 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
mkoodali252f7672019-03-25 12:13:12 +0530373 return nil, err
374 }
375 case "flow_changes":
376 if err := ptypes.UnmarshalAny(arg.Value, flows); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800377 logger.Warnw("cannot-unmarshal-flows", log.Fields{"error": err})
mkoodali252f7672019-03-25 12:13:12 +0530378 return nil, err
379 }
380 case "group_changes":
381 if err := ptypes.UnmarshalAny(arg.Value, groups); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800382 logger.Warnw("cannot-unmarshal-groups", log.Fields{"error": err})
mkoodali252f7672019-03-25 12:13:12 +0530383 return nil, err
384 }
Manikkaraj kb1a10922019-07-29 12:10:34 -0400385 case "flow_metadata":
386 if err := ptypes.UnmarshalAny(arg.Value, flowMetadata); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800387 logger.Warnw("cannot-unmarshal-metadata", log.Fields{"error": err})
Manikkaraj kb1a10922019-07-29 12:10:34 -0400388 return nil, err
389 }
mkoodali252f7672019-03-25 12:13:12 +0530390 case kafka.TransactionKey:
391 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800392 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
mkoodali252f7672019-03-25 12:13:12 +0530393 return nil, err
394 }
395 }
396 }
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800397 logger.Debugw("Update_flows_incrementally", log.Fields{"flows": flows, "groups": groups})
khenaidoob3127472019-07-24 21:04:55 -0400398 //Invoke the incremental flow update API of the adapter
Manikkaraj kb1a10922019-07-29 12:10:34 -0400399 if err := rhp.adapter.Update_flows_incrementally(device, flows, groups, flowMetadata); err != nil {
khenaidoo2c6a0992019-04-29 13:46:56 -0400400 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
401 }
khenaidood2b6df92018-12-13 16:37:20 -0500402 return new(empty.Empty), nil
403}
404
405func (rhp *RequestHandlerProxy) Update_pm_config(args []*ic.Argument) (*empty.Empty, error) {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800406 logger.Debug("Update_pm_config")
khenaidoob3127472019-07-24 21:04:55 -0400407 if len(args) < 2 {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800408 logger.Warn("Update_pm_config-invalid-number-of-args", log.Fields{"args": args})
khenaidoob3127472019-07-24 21:04:55 -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 {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800419 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
khenaidoob3127472019-07-24 21:04:55 -0400420 return nil, err
421 }
422 case "pm_configs":
423 if err := ptypes.UnmarshalAny(arg.Value, pmConfigs); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800424 logger.Warnw("cannot-unmarshal-pm-configs", log.Fields{"error": err})
khenaidoob3127472019-07-24 21:04:55 -0400425 return nil, err
426 }
427 case kafka.TransactionKey:
428 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800429 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
khenaidoob3127472019-07-24 21:04:55 -0400430 return nil, err
431 }
432 }
433 }
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800434 logger.Debugw("Update_pm_config", log.Fields{"deviceId": device.Id, "pmConfigs": pmConfigs})
khenaidoob3127472019-07-24 21:04:55 -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 }
khenaidood2b6df92018-12-13 16:37:20 -0500439 return new(empty.Empty), nil
440}
441
442func (rhp *RequestHandlerProxy) Receive_packet_out(args []*ic.Argument) (*empty.Empty, error) {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800443 logger.Debugw("Receive_packet_out", log.Fields{"args": args})
manikkaraj k6c9689d2019-05-09 12:59:52 -0400444 if len(args) < 3 {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800445 logger.Warn("Receive_packet_out-invalid-number-of-args", log.Fields{"args": args})
manikkaraj k6c9689d2019-05-09 12:59:52 -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 {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800457 logger.Warnw("cannot-unmarshal-deviceId", log.Fields{"error": err})
manikkaraj k6c9689d2019-05-09 12:59:52 -0400458 return nil, err
459 }
460 case "outPort":
461 if err := ptypes.UnmarshalAny(arg.Value, egressPort); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800462 logger.Warnw("cannot-unmarshal-egressPort", log.Fields{"error": err})
manikkaraj k6c9689d2019-05-09 12:59:52 -0400463 return nil, err
464 }
465 case "packet":
466 if err := ptypes.UnmarshalAny(arg.Value, packet); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800467 logger.Warnw("cannot-unmarshal-packet", log.Fields{"error": err})
manikkaraj k6c9689d2019-05-09 12:59:52 -0400468 return nil, err
469 }
470 case kafka.TransactionKey:
471 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800472 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
manikkaraj k6c9689d2019-05-09 12:59:52 -0400473 return nil, err
474 }
475 }
476 }
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800477 logger.Debugw("Receive_packet_out", log.Fields{"deviceId": deviceId.Val, "outPort": egressPort, "packet": packet})
manikkaraj k6c9689d2019-05-09 12:59:52 -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 }
khenaidood2b6df92018-12-13 16:37:20 -0500482 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) {
khenaidoo54e0ddf2019-02-27 16:21:33 -0500494 if len(args) < 2 {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800495 logger.Warn("invalid-number-of-args", log.Fields{"args": args})
khenaidood2b6df92018-12-13 16:37:20 -0500496 err := errors.New("invalid-number-of-args")
497 return nil, err
498 }
499 device := &voltha.Device{}
khenaidoo6d055132019-02-12 16:51:19 -0500500 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 {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800505 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
khenaidoo6d055132019-02-12 16:51:19 -0500506 return nil, err
507 }
508 case kafka.TransactionKey:
509 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800510 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
khenaidoo6d055132019-02-12 16:51:19 -0500511 return nil, err
512 }
513 }
khenaidood2b6df92018-12-13 16:37:20 -0500514 }
khenaidoo6d055132019-02-12 16:51:19 -0500515
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800516 logger.Debugw("Get_ofp_device_info", log.Fields{"deviceId": device.Id})
khenaidood2b6df92018-12-13 16:37:20 -0500517
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 }
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800523 logger.Debugw("Get_ofp_device_info", log.Fields{"cap": cap})
khenaidood2b6df92018-12-13 16:37:20 -0500524 return cap, nil
525}
526
527func (rhp *RequestHandlerProxy) Get_ofp_port_info(args []*ic.Argument) (*ic.PortCapability, error) {
khenaidoo54e0ddf2019-02-27 16:21:33 -0500528 if len(args) < 3 {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800529 logger.Warn("invalid-number-of-args", log.Fields{"args": args})
khenaidood2b6df92018-12-13 16:37:20 -0500530 err := errors.New("invalid-number-of-args")
531 return nil, err
532 }
533 device := &voltha.Device{}
534 pNo := &ic.IntType{}
khenaidoo6d055132019-02-12 16:51:19 -0500535 transactionID := &ic.StrType{}
khenaidood2b6df92018-12-13 16:37:20 -0500536 for _, arg := range args {
537 switch arg.Key {
538 case "device":
539 if err := ptypes.UnmarshalAny(arg.Value, device); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800540 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
khenaidood2b6df92018-12-13 16:37:20 -0500541 return nil, err
542 }
543 case "port_no":
544 if err := ptypes.UnmarshalAny(arg.Value, pNo); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800545 logger.Warnw("cannot-unmarshal-port-no", log.Fields{"error": err})
khenaidood2b6df92018-12-13 16:37:20 -0500546 return nil, err
547 }
khenaidoo6d055132019-02-12 16:51:19 -0500548 case kafka.TransactionKey:
549 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800550 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
khenaidoo6d055132019-02-12 16:51:19 -0500551 return nil, err
552 }
khenaidood2b6df92018-12-13 16:37:20 -0500553 }
554 }
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800555 logger.Debugw("Get_ofp_port_info", log.Fields{"deviceId": device.Id, "portNo": pNo.Val})
khenaidood2b6df92018-12-13 16:37:20 -0500556 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) {
khenaidoo54e0ddf2019-02-27 16:21:33 -0500565 if len(args) < 2 {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800566 logger.Warn("invalid-number-of-args", log.Fields{"args": args})
khenaidood2b6df92018-12-13 16:37:20 -0500567 err := errors.New("invalid-number-of-args")
568 return nil, err
569 }
570 iaMsg := &ic.InterAdapterMessage{}
khenaidoo6d055132019-02-12 16:51:19 -0500571 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 {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800576 logger.Warnw("cannot-unmarshal-device", log.Fields{"error": err})
khenaidoo6d055132019-02-12 16:51:19 -0500577 return nil, err
578 }
579 case kafka.TransactionKey:
580 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800581 logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
khenaidoo6d055132019-02-12 16:51:19 -0500582 return nil, err
583 }
584 }
khenaidood2b6df92018-12-13 16:37:20 -0500585 }
586
serkant.uluderya2ae470f2020-01-21 11:13:09 -0800587 logger.Debugw("Process_inter_adapter_message", log.Fields{"msgId": iaMsg.Header.Id})
khenaidood2b6df92018-12-13 16:37:20 -0500588
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
khenaidoof5a5bfa2019-01-23 22:20:29 -0500597func (rhp *RequestHandlerProxy) Download_image(args []*ic.Argument) (*voltha.ImageDownload, error) {
598 return &voltha.ImageDownload{}, nil
khenaidood2b6df92018-12-13 16:37:20 -0500599}
600
khenaidoof5a5bfa2019-01-23 22:20:29 -0500601func (rhp *RequestHandlerProxy) Get_image_download_status(args []*ic.Argument) (*voltha.ImageDownload, error) {
602 return &voltha.ImageDownload{}, nil
khenaidood2b6df92018-12-13 16:37:20 -0500603}
604
khenaidoof5a5bfa2019-01-23 22:20:29 -0500605func (rhp *RequestHandlerProxy) Cancel_image_download(args []*ic.Argument) (*voltha.ImageDownload, error) {
606 return &voltha.ImageDownload{}, nil
khenaidood2b6df92018-12-13 16:37:20 -0500607}
608
khenaidoof5a5bfa2019-01-23 22:20:29 -0500609func (rhp *RequestHandlerProxy) Activate_image_update(args []*ic.Argument) (*voltha.ImageDownload, error) {
610 return &voltha.ImageDownload{}, nil
khenaidood2b6df92018-12-13 16:37:20 -0500611}
612
khenaidoof5a5bfa2019-01-23 22:20:29 -0500613func (rhp *RequestHandlerProxy) Revert_image_update(args []*ic.Argument) (*voltha.ImageDownload, error) {
614 return &voltha.ImageDownload{}, nil
khenaidood2b6df92018-12-13 16:37:20 -0500615}
kesavandbc2d1622020-01-21 00:42:01 -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}