blob: caedb795e8449fba70692f50eff1681c6d70d320 [file] [log] [blame]
khenaidoob9203542018-09-17 22:56:37 -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 core
17
18import (
19 "errors"
khenaidoo19d7b632018-10-30 10:49:50 -040020 "github.com/gogo/protobuf/proto"
khenaidoob9203542018-09-17 22:56:37 -040021 "github.com/golang/protobuf/ptypes"
22 "github.com/golang/protobuf/ptypes/empty"
23 "github.com/opencord/voltha-go/common/log"
24 "github.com/opencord/voltha-go/db/model"
khenaidoo297cd252019-02-07 22:10:23 -050025 "github.com/opencord/voltha-go/kafka"
khenaidoo1ce37ad2019-03-24 22:07:24 -040026 "github.com/opencord/voltha-go/rw_core/utils"
William Kurkiandaa6bb22019-03-07 12:26:28 -050027 ic "github.com/opencord/voltha-protos/go/inter_container"
28 "github.com/opencord/voltha-protos/go/voltha"
khenaidoob9203542018-09-17 22:56:37 -040029 "google.golang.org/grpc/codes"
30 "google.golang.org/grpc/status"
31)
32
33type AdapterRequestHandlerProxy struct {
khenaidoode93b462019-02-13 22:17:21 -050034 TestMode bool
35 coreInstanceId string
36 deviceMgr *DeviceManager
37 lDeviceMgr *LogicalDeviceManager
38 adapterMgr *AdapterManager
39 localDataProxy *model.Proxy
40 clusterDataProxy *model.Proxy
41 defaultRequestTimeout int64
khenaidoo297cd252019-02-07 22:10:23 -050042 longRunningRequestTimeout int64
khenaidoode93b462019-02-13 22:17:21 -050043 coreInCompetingMode bool
Richard Jankowski199fd862019-03-18 14:49:51 -040044 core *Core
khenaidoob9203542018-09-17 22:56:37 -040045}
46
Richard Jankowski199fd862019-03-18 14:49:51 -040047func NewAdapterRequestHandlerProxy(core *Core, coreInstanceId string, dMgr *DeviceManager, ldMgr *LogicalDeviceManager,
khenaidoo297cd252019-02-07 22:10:23 -050048 aMgr *AdapterManager, cdProxy *model.Proxy, ldProxy *model.Proxy, incompetingMode bool, longRunningRequestTimeout int64,
49 defaultRequestTimeout int64) *AdapterRequestHandlerProxy {
khenaidoob9203542018-09-17 22:56:37 -040050 var proxy AdapterRequestHandlerProxy
Richard Jankowski199fd862019-03-18 14:49:51 -040051 proxy.core = core
khenaidoo91ecfd62018-11-04 17:13:42 -050052 proxy.coreInstanceId = coreInstanceId
khenaidoob9203542018-09-17 22:56:37 -040053 proxy.deviceMgr = dMgr
54 proxy.lDeviceMgr = ldMgr
55 proxy.clusterDataProxy = cdProxy
56 proxy.localDataProxy = ldProxy
khenaidoo21d51152019-02-01 13:48:37 -050057 proxy.adapterMgr = aMgr
khenaidoo297cd252019-02-07 22:10:23 -050058 proxy.coreInCompetingMode = incompetingMode
59 proxy.defaultRequestTimeout = defaultRequestTimeout
60 proxy.longRunningRequestTimeout = longRunningRequestTimeout
khenaidoob9203542018-09-17 22:56:37 -040061 return &proxy
62}
63
Richard Jankowski199fd862019-03-18 14:49:51 -040064func (rhp *AdapterRequestHandlerProxy) acquireRequest(transactionId string, maxTimeout ...int64) (*KVTransaction, error) {
khenaidoo297cd252019-02-07 22:10:23 -050065 timeout := rhp.defaultRequestTimeout
66 if len(maxTimeout) > 0 {
67 timeout = maxTimeout[0]
68 }
khenaidoo297cd252019-02-07 22:10:23 -050069 txn := NewKVTransaction(transactionId)
70 if txn == nil {
khenaidoode93b462019-02-13 22:17:21 -050071 return nil, errors.New("fail-to-create-transaction")
khenaidoo297cd252019-02-07 22:10:23 -050072 } else if txn.Acquired(timeout) {
khenaidoo1ce37ad2019-03-24 22:07:24 -040073 log.Debugw("acquired-request", log.Fields{"xtrnsId": transactionId})
khenaidoo297cd252019-02-07 22:10:23 -050074 return txn, nil
75 } else {
76 return nil, errors.New("failed-to-seize-request")
77 }
78}
79
Richard Jankowski199fd862019-03-18 14:49:51 -040080// This is a helper function that attempts to acquire the request by using the device ownership model
81func (rhp *AdapterRequestHandlerProxy) takeRequestOwnership(transactionId string, devId string, maxTimeout ...int64) (*KVTransaction, error) {
82 timeout := rhp.defaultRequestTimeout
83 if len(maxTimeout) > 0 {
84 timeout = maxTimeout[0]
85 }
Richard Jankowski199fd862019-03-18 14:49:51 -040086 txn := NewKVTransaction(transactionId)
87 if txn == nil {
88 return nil, errors.New("fail-to-create-transaction")
89 }
90
khenaidoo2c6a0992019-04-29 13:46:56 -040091 if rhp.core.deviceOwnership.OwnedByMe(&utils.DeviceID{Id: devId}) {
khenaidoo1ce37ad2019-03-24 22:07:24 -040092 log.Debugw("owned-by-me", log.Fields{"Id": devId})
Richard Jankowski199fd862019-03-18 14:49:51 -040093 if txn.Acquired(timeout) {
khenaidoo1ce37ad2019-03-24 22:07:24 -040094 log.Debugw("processing-request", log.Fields{"Id": devId})
Richard Jankowski199fd862019-03-18 14:49:51 -040095 return txn, nil
96 } else {
97 return nil, errors.New("failed-to-seize-request")
98 }
99 } else {
khenaidoo1ce37ad2019-03-24 22:07:24 -0400100 log.Debugw("not-owned-by-me", log.Fields{"Id": devId})
Richard Jankowski199fd862019-03-18 14:49:51 -0400101 if txn.Monitor(timeout) {
khenaidoo1ce37ad2019-03-24 22:07:24 -0400102 log.Debugw("timeout-processing-request", log.Fields{"Id": devId})
Richard Jankowski199fd862019-03-18 14:49:51 -0400103 return txn, nil
104 } else {
105 return nil, errors.New("device-not-owned")
106 }
107 }
108}
109
khenaidoo297cd252019-02-07 22:10:23 -0500110// competeForTransaction is a helper function to determine whether every request needs to compete with another
111// Core to execute the request
112func (rhp *AdapterRequestHandlerProxy) competeForTransaction() bool {
113 return rhp.coreInCompetingMode
114}
115
khenaidoo79232702018-12-04 11:00:41 -0500116func (rhp *AdapterRequestHandlerProxy) Register(args []*ic.Argument) (*voltha.CoreInstance, error) {
khenaidoo54e0ddf2019-02-27 16:21:33 -0500117 if len(args) < 3 {
khenaidoob9203542018-09-17 22:56:37 -0400118 log.Warn("invalid-number-of-args", log.Fields{"args": args})
119 err := errors.New("invalid-number-of-args")
120 return nil, err
121 }
122 adapter := &voltha.Adapter{}
khenaidoo91ecfd62018-11-04 17:13:42 -0500123 deviceTypes := &voltha.DeviceTypes{}
khenaidoo297cd252019-02-07 22:10:23 -0500124 transactionID := &ic.StrType{}
khenaidoo91ecfd62018-11-04 17:13:42 -0500125 for _, arg := range args {
126 switch arg.Key {
127 case "adapter":
128 if err := ptypes.UnmarshalAny(arg.Value, adapter); err != nil {
129 log.Warnw("cannot-unmarshal-adapter", log.Fields{"error": err})
130 return nil, err
131 }
132 case "deviceTypes":
133 if err := ptypes.UnmarshalAny(arg.Value, deviceTypes); err != nil {
134 log.Warnw("cannot-unmarshal-device-types", log.Fields{"error": err})
135 return nil, err
136 }
khenaidoo297cd252019-02-07 22:10:23 -0500137 case kafka.TransactionKey:
138 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
139 log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
140 return nil, err
141 }
khenaidoo91ecfd62018-11-04 17:13:42 -0500142 }
khenaidoob9203542018-09-17 22:56:37 -0400143 }
khenaidoo297cd252019-02-07 22:10:23 -0500144 log.Debugw("Register", log.Fields{"Adapter": *adapter, "DeviceTypes": deviceTypes, "transactionID": transactionID.Val, "coreId": rhp.coreInstanceId})
145
146 // Try to grab the transaction as this core may be competing with another Core
147 if rhp.competeForTransaction() {
Richard Jankowski199fd862019-03-18 14:49:51 -0400148 if txn, err := rhp.acquireRequest(transactionID.Val); err != nil {
khenaidoo297cd252019-02-07 22:10:23 -0500149 log.Debugw("Another core handled the request", log.Fields{"transactionID": transactionID})
150 // Update our adapters in memory
151 go rhp.adapterMgr.updateAdaptersAndDevicetypesInMemory()
152 // returning nil, nil instructs the callee to ignore this request
153 return nil, nil
154 } else {
155 defer txn.Close()
156 }
157 }
khenaidoob9203542018-09-17 22:56:37 -0400158
159 if rhp.TestMode { // Execute only for test cases
160 return &voltha.CoreInstance{InstanceId: "CoreInstance"}, nil
161 }
khenaidoo21d51152019-02-01 13:48:37 -0500162 return rhp.adapterMgr.registerAdapter(adapter, deviceTypes), nil
khenaidoob9203542018-09-17 22:56:37 -0400163}
164
khenaidoo79232702018-12-04 11:00:41 -0500165func (rhp *AdapterRequestHandlerProxy) GetDevice(args []*ic.Argument) (*voltha.Device, error) {
khenaidoo54e0ddf2019-02-27 16:21:33 -0500166 if len(args) < 2 {
khenaidoob9203542018-09-17 22:56:37 -0400167 log.Warn("invalid-number-of-args", log.Fields{"args": args})
168 err := errors.New("invalid-number-of-args")
169 return nil, err
170 }
khenaidoo297cd252019-02-07 22:10:23 -0500171
khenaidoob9203542018-09-17 22:56:37 -0400172 pID := &voltha.ID{}
khenaidoo297cd252019-02-07 22:10:23 -0500173 transactionID := &ic.StrType{}
174 for _, arg := range args {
175 switch arg.Key {
176 case "device_id":
177 if err := ptypes.UnmarshalAny(arg.Value, pID); err != nil {
178 log.Warnw("cannot-unmarshal-ID", log.Fields{"error": err})
179 return nil, err
180 }
181 case kafka.TransactionKey:
182 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
183 log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
184 return nil, err
185 }
186 }
khenaidoob9203542018-09-17 22:56:37 -0400187 }
khenaidoo297cd252019-02-07 22:10:23 -0500188 log.Debugw("GetDevice", log.Fields{"deviceId": pID.Id, "transactionID": transactionID.Val})
189
190 // Try to grab the transaction as this core may be competing with another Core
191 if rhp.competeForTransaction() {
Richard Jankowski199fd862019-03-18 14:49:51 -0400192 if txn, err := rhp.takeRequestOwnership(transactionID.Val, pID.Id); err != nil {
khenaidoo297cd252019-02-07 22:10:23 -0500193 log.Debugw("Another core handled the request", log.Fields{"transactionID": transactionID})
194 // returning nil, nil instructs the callee to ignore this request
195 return nil, nil
196 } else {
197 defer txn.Close()
198 }
199 }
khenaidoob9203542018-09-17 22:56:37 -0400200
201 if rhp.TestMode { // Execute only for test cases
202 return &voltha.Device{Id: pID.Id}, nil
203 }
204
205 // Get the device via the device manager
khenaidoo19d7b632018-10-30 10:49:50 -0400206 if device, err := rhp.deviceMgr.GetDevice(pID.Id); err != nil {
khenaidoob9203542018-09-17 22:56:37 -0400207 return nil, status.Errorf(codes.NotFound, "%s", err.Error())
208 } else {
khenaidoo79232702018-12-04 11:00:41 -0500209 log.Debugw("GetDevice-response", log.Fields{"deviceId": pID.Id})
khenaidoob9203542018-09-17 22:56:37 -0400210 return device, nil
211 }
212}
213
khenaidoo92e62c52018-10-03 14:02:54 -0400214// updatePartialDeviceData updates a subset of a device that an Adapter can update.
215// TODO: May need a specific proto to handle only a subset of a device that can be changed by an adapter
216func (rhp *AdapterRequestHandlerProxy) mergeDeviceInfoFromAdapter(device *voltha.Device) (*voltha.Device, error) {
217 // First retrieve the most up to date device info
218 var currentDevice *voltha.Device
219 var err error
khenaidoo19d7b632018-10-30 10:49:50 -0400220 if currentDevice, err = rhp.deviceMgr.GetDevice(device.Id); err != nil {
khenaidoo92e62c52018-10-03 14:02:54 -0400221 return nil, err
222 }
khenaidoo19d7b632018-10-30 10:49:50 -0400223 cloned := proto.Clone(currentDevice).(*voltha.Device)
khenaidoo92e62c52018-10-03 14:02:54 -0400224 cloned.Root = device.Root
225 cloned.Vendor = device.Vendor
226 cloned.Model = device.Model
227 cloned.SerialNumber = device.SerialNumber
228 cloned.MacAddress = device.MacAddress
khenaidoo19d7b632018-10-30 10:49:50 -0400229 cloned.Vlan = device.Vlan
Matt Jeanneret5f0aa182019-05-01 11:57:05 -0400230 cloned.Reason = device.Reason
khenaidoo19d7b632018-10-30 10:49:50 -0400231 return cloned, nil
khenaidoo92e62c52018-10-03 14:02:54 -0400232}
233
khenaidoo79232702018-12-04 11:00:41 -0500234func (rhp *AdapterRequestHandlerProxy) DeviceUpdate(args []*ic.Argument) (*empty.Empty, error) {
khenaidoo54e0ddf2019-02-27 16:21:33 -0500235 if len(args) < 2 {
khenaidoob9203542018-09-17 22:56:37 -0400236 log.Warn("invalid-number-of-args", log.Fields{"args": args})
237 err := errors.New("invalid-number-of-args")
238 return nil, err
239 }
khenaidoo297cd252019-02-07 22:10:23 -0500240
khenaidoob9203542018-09-17 22:56:37 -0400241 device := &voltha.Device{}
khenaidoo297cd252019-02-07 22:10:23 -0500242 transactionID := &ic.StrType{}
243 for _, arg := range args {
244 switch arg.Key {
245 case "device":
246 if err := ptypes.UnmarshalAny(arg.Value, device); err != nil {
247 log.Warnw("cannot-unmarshal-ID", log.Fields{"error": err})
248 return nil, err
249 }
250 case kafka.TransactionKey:
251 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
252 log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
253 return nil, err
254 }
255 }
khenaidoob9203542018-09-17 22:56:37 -0400256 }
khenaidoo297cd252019-02-07 22:10:23 -0500257 log.Debugw("DeviceUpdate", log.Fields{"deviceId": device.Id, "transactionID": transactionID.Val})
258
259 // Try to grab the transaction as this core may be competing with another Core
260 if rhp.competeForTransaction() {
Richard Jankowski199fd862019-03-18 14:49:51 -0400261 if txn, err := rhp.takeRequestOwnership(transactionID.Val, device.Id); err != nil {
khenaidoo297cd252019-02-07 22:10:23 -0500262 log.Debugw("Another core handled the request", log.Fields{"transactionID": transactionID})
263 // returning nil, nil instructs the callee to ignore this request
264 return nil, nil
265 } else {
266 defer txn.Close()
267 }
268 }
khenaidoob9203542018-09-17 22:56:37 -0400269
270 if rhp.TestMode { // Execute only for test cases
271 return new(empty.Empty), nil
272 }
khenaidoo92e62c52018-10-03 14:02:54 -0400273
274 //Merge the adapter device info (only the ones an adapter can change) with the latest device data
275 if updatedDevice, err := rhp.mergeDeviceInfoFromAdapter(device); err != nil {
khenaidoob9203542018-09-17 22:56:37 -0400276 return nil, status.Errorf(codes.Internal, "%s", err.Error())
khenaidoo92e62c52018-10-03 14:02:54 -0400277 } else {
khenaidoo1ce37ad2019-03-24 22:07:24 -0400278 go rhp.deviceMgr.updateDevice(updatedDevice)
279 //if err := rhp.deviceMgr.updateDevice(updatedDevice); err != nil {
280 // return nil, err
281 //}
khenaidoob9203542018-09-17 22:56:37 -0400282 }
khenaidoo92e62c52018-10-03 14:02:54 -0400283
khenaidoob9203542018-09-17 22:56:37 -0400284 return new(empty.Empty), nil
285}
286
khenaidoo79232702018-12-04 11:00:41 -0500287func (rhp *AdapterRequestHandlerProxy) GetChildDevice(args []*ic.Argument) (*voltha.Device, error) {
Matt Jeanneret4e241952019-02-28 11:16:04 -0500288 if len(args) < 3 {
khenaidoob9203542018-09-17 22:56:37 -0400289 log.Warn("invalid-number-of-args", log.Fields{"args": args})
290 err := errors.New("invalid-number-of-args")
291 return nil, err
292 }
khenaidoo297cd252019-02-07 22:10:23 -0500293
khenaidoo2c6f1672018-09-20 23:14:41 -0400294 pID := &voltha.ID{}
khenaidoo297cd252019-02-07 22:10:23 -0500295 transactionID := &ic.StrType{}
Matt Jeanneret4e241952019-02-28 11:16:04 -0500296 serialNumber := &ic.StrType{}
297 onuId := &ic.IntType{}
298 parentPortNo := &ic.IntType{}
khenaidoo297cd252019-02-07 22:10:23 -0500299 for _, arg := range args {
300 switch arg.Key {
301 case "device_id":
302 if err := ptypes.UnmarshalAny(arg.Value, pID); err != nil {
303 log.Warnw("cannot-unmarshal-ID", log.Fields{"error": err})
304 return nil, err
305 }
Matt Jeanneret4e241952019-02-28 11:16:04 -0500306 case "serial_number":
307 if err := ptypes.UnmarshalAny(arg.Value, serialNumber); err != nil {
308 log.Warnw("cannot-unmarshal-ID", log.Fields{"error": err})
309 return nil, err
310 }
311 case "onu_id":
312 if err := ptypes.UnmarshalAny(arg.Value, onuId); err != nil {
313 log.Warnw("cannot-unmarshal-ID", log.Fields{"error": err})
314 return nil, err
315 }
316 case "parent_port_no":
317 if err := ptypes.UnmarshalAny(arg.Value, parentPortNo); err != nil {
318 log.Warnw("cannot-unmarshal-ID", log.Fields{"error": err})
319 return nil, err
320 }
khenaidoo297cd252019-02-07 22:10:23 -0500321 case kafka.TransactionKey:
322 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
323 log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
324 return nil, err
325 }
326 }
khenaidoob9203542018-09-17 22:56:37 -0400327 }
Matt Jeanneret4e241952019-02-28 11:16:04 -0500328 log.Debugw("GetChildDevice", log.Fields{"parentDeviceId": pID.Id, "args": args, "transactionID": transactionID.Val})
khenaidoo297cd252019-02-07 22:10:23 -0500329
330 // Try to grab the transaction as this core may be competing with another Core
331 if rhp.competeForTransaction() {
Richard Jankowski199fd862019-03-18 14:49:51 -0400332 if txn, err := rhp.takeRequestOwnership(transactionID.Val, pID.Id); err != nil {
khenaidoo297cd252019-02-07 22:10:23 -0500333 log.Debugw("Another core handled the request", log.Fields{"transactionID": transactionID})
334 // returning nil, nil instructs the callee to ignore this request
335 return nil, nil
336 } else {
337 defer txn.Close()
338 }
339 }
khenaidoob9203542018-09-17 22:56:37 -0400340
341 if rhp.TestMode { // Execute only for test cases
khenaidoo2c6f1672018-09-20 23:14:41 -0400342 return &voltha.Device{Id: pID.Id}, nil
khenaidoob9203542018-09-17 22:56:37 -0400343 }
Matt Jeanneret4e241952019-02-28 11:16:04 -0500344 return rhp.deviceMgr.GetChildDevice(pID.Id, serialNumber.Val, onuId.Val, parentPortNo.Val)
khenaidoob9203542018-09-17 22:56:37 -0400345}
346
Matt Jeanneret2a20aaa2019-03-05 21:04:02 -0500347func (rhp *AdapterRequestHandlerProxy) GetChildDeviceWithProxyAddress(args []*ic.Argument) (*voltha.Device, error) {
348 if len(args) < 2 {
349 log.Warn("invalid-number-of-args", log.Fields{"args": args})
350 err := errors.New("invalid-number-of-args")
351 return nil, err
352 }
353
354 proxyAddress := &voltha.Device_ProxyAddress{}
355 transactionID := &ic.StrType{}
356 for _, arg := range args {
357 switch arg.Key {
358 case "proxy_address":
359 if err := ptypes.UnmarshalAny(arg.Value, proxyAddress); err != nil {
360 log.Warnw("cannot-unmarshal-proxy-address", log.Fields{"error": err})
361 return nil, err
362 }
363 case kafka.TransactionKey:
364 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
365 log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
366 return nil, err
367 }
368 }
369 }
370 log.Debugw("GetChildDeviceWithProxyAddress", log.Fields{"proxyAddress": proxyAddress, "transactionID": transactionID.Val})
371
372 // Try to grab the transaction as this core may be competing with another Core
373 if rhp.competeForTransaction() {
khenaidoo1ce37ad2019-03-24 22:07:24 -0400374 if txn, err := rhp.takeRequestOwnership(transactionID.Val, proxyAddress.DeviceId); err != nil {
Matt Jeanneret2a20aaa2019-03-05 21:04:02 -0500375 log.Debugw("Another core handled the request", log.Fields{"transactionID": transactionID})
Matt Jeanneret2a20aaa2019-03-05 21:04:02 -0500376 return nil, nil
377 } else {
378 defer txn.Close()
379 }
380 }
381
382 if rhp.TestMode { // Execute only for test cases
383 return &voltha.Device{Id: proxyAddress.DeviceId}, nil
384 }
385 return rhp.deviceMgr.GetChildDeviceWithProxyAddress(proxyAddress)
386}
387
khenaidoo79232702018-12-04 11:00:41 -0500388func (rhp *AdapterRequestHandlerProxy) GetPorts(args []*ic.Argument) (*voltha.Ports, error) {
khenaidoo54e0ddf2019-02-27 16:21:33 -0500389 if len(args) < 3 {
khenaidoob9203542018-09-17 22:56:37 -0400390 log.Warn("invalid-number-of-args", log.Fields{"args": args})
391 err := errors.New("invalid-number-of-args")
392 return nil, err
393 }
khenaidoo92e62c52018-10-03 14:02:54 -0400394 deviceId := &voltha.ID{}
khenaidoo79232702018-12-04 11:00:41 -0500395 pt := &ic.IntType{}
khenaidoo297cd252019-02-07 22:10:23 -0500396 transactionID := &ic.StrType{}
khenaidoo92e62c52018-10-03 14:02:54 -0400397 for _, arg := range args {
398 switch arg.Key {
399 case "device_id":
400 if err := ptypes.UnmarshalAny(arg.Value, deviceId); err != nil {
401 log.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
402 return nil, err
403 }
404 case "port_type":
405 if err := ptypes.UnmarshalAny(arg.Value, pt); err != nil {
406 log.Warnw("cannot-unmarshal-porttype", log.Fields{"error": err})
407 return nil, err
408 }
khenaidoo297cd252019-02-07 22:10:23 -0500409 case kafka.TransactionKey:
410 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
411 log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
412 return nil, err
413 }
khenaidoo92e62c52018-10-03 14:02:54 -0400414 }
khenaidoob9203542018-09-17 22:56:37 -0400415 }
khenaidoo297cd252019-02-07 22:10:23 -0500416 log.Debugw("GetPorts", log.Fields{"deviceID": deviceId.Id, "portype": pt.Val, "transactionID": transactionID.Val})
khenaidoob9203542018-09-17 22:56:37 -0400417 if rhp.TestMode { // Execute only for test cases
418 aPort := &voltha.Port{Label: "test_port"}
419 allPorts := &voltha.Ports{}
420 allPorts.Items = append(allPorts.Items, aPort)
421 return allPorts, nil
422 }
khenaidoo92e62c52018-10-03 14:02:54 -0400423 return rhp.deviceMgr.getPorts(nil, deviceId.Id, voltha.Port_PortType(pt.Val))
khenaidoob9203542018-09-17 22:56:37 -0400424}
425
khenaidoo297cd252019-02-07 22:10:23 -0500426func (rhp *AdapterRequestHandlerProxy) GetChildDevices(args []*ic.Argument) (*voltha.Devices, error) {
khenaidoo54e0ddf2019-02-27 16:21:33 -0500427 if len(args) < 2 {
khenaidoob9203542018-09-17 22:56:37 -0400428 log.Warn("invalid-number-of-args", log.Fields{"args": args})
429 err := errors.New("invalid-number-of-args")
430 return nil, err
431 }
khenaidoo297cd252019-02-07 22:10:23 -0500432
khenaidoo2c6f1672018-09-20 23:14:41 -0400433 pID := &voltha.ID{}
khenaidoo297cd252019-02-07 22:10:23 -0500434 transactionID := &ic.StrType{}
435 for _, arg := range args {
436 switch arg.Key {
437 case "device_id":
438 if err := ptypes.UnmarshalAny(arg.Value, pID); err != nil {
439 log.Warnw("cannot-unmarshal-ID", log.Fields{"error": err})
440 return nil, err
441 }
442 case kafka.TransactionKey:
443 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
444 log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
445 return nil, err
446 }
447 }
khenaidoob9203542018-09-17 22:56:37 -0400448 }
khenaidoo297cd252019-02-07 22:10:23 -0500449 log.Debugw("GetChildDevices", log.Fields{"deviceId": pID.Id, "transactionID": transactionID.Val})
450
451 // Try to grab the transaction as this core may be competing with another Core
452 if rhp.competeForTransaction() {
Richard Jankowski199fd862019-03-18 14:49:51 -0400453 if txn, err := rhp.takeRequestOwnership(transactionID.Val, pID.Id); err != nil {
khenaidoo297cd252019-02-07 22:10:23 -0500454 log.Debugw("Another core handled the request", log.Fields{"transactionID": transactionID})
455 // returning nil, nil instructs the callee to ignore this request
456 return nil, nil
457 } else {
458 defer txn.Close()
459 }
460 }
khenaidoob9203542018-09-17 22:56:37 -0400461
462 if rhp.TestMode { // Execute only for test cases
khenaidoode93b462019-02-13 22:17:21 -0500463 return &voltha.Devices{Items: nil}, nil
khenaidoob9203542018-09-17 22:56:37 -0400464 }
khenaidoo297cd252019-02-07 22:10:23 -0500465
466 return rhp.deviceMgr.getAllChildDevices(pID.Id)
khenaidoob9203542018-09-17 22:56:37 -0400467}
468
469// ChildDeviceDetected is invoked when a child device is detected. The following
470// parameters are expected:
Matt Jeanneret4e241952019-02-28 11:16:04 -0500471// {parent_device_id, parent_port_no, child_device_type, channel_id, vendor_id, serial_number)
khenaidoo79232702018-12-04 11:00:41 -0500472func (rhp *AdapterRequestHandlerProxy) ChildDeviceDetected(args []*ic.Argument) (*empty.Empty, error) {
khenaidoo297cd252019-02-07 22:10:23 -0500473 if len(args) < 5 {
khenaidoob9203542018-09-17 22:56:37 -0400474 log.Warn("invalid-number-of-args", log.Fields{"args": args})
475 err := errors.New("invalid-number-of-args")
476 return nil, err
477 }
478
479 pID := &voltha.ID{}
khenaidoo79232702018-12-04 11:00:41 -0500480 portNo := &ic.IntType{}
481 dt := &ic.StrType{}
482 chnlId := &ic.IntType{}
khenaidoo297cd252019-02-07 22:10:23 -0500483 transactionID := &ic.StrType{}
Matt Jeanneret4e241952019-02-28 11:16:04 -0500484 serialNumber := &ic.StrType{}
485 vendorId := &ic.StrType{}
486 onuId := &ic.IntType{}
khenaidoob9203542018-09-17 22:56:37 -0400487 for _, arg := range args {
488 switch arg.Key {
489 case "parent_device_id":
490 if err := ptypes.UnmarshalAny(arg.Value, pID); err != nil {
491 log.Warnw("cannot-unmarshal-parent-device-id", log.Fields{"error": err})
492 return nil, err
493 }
494 case "parent_port_no":
495 if err := ptypes.UnmarshalAny(arg.Value, portNo); err != nil {
496 log.Warnw("cannot-unmarshal-parent-port", log.Fields{"error": err})
497 return nil, err
498 }
499 case "child_device_type":
500 if err := ptypes.UnmarshalAny(arg.Value, dt); err != nil {
501 log.Warnw("cannot-unmarshal-child-device-type", log.Fields{"error": err})
502 return nil, err
503 }
504 case "channel_id":
505 if err := ptypes.UnmarshalAny(arg.Value, chnlId); err != nil {
506 log.Warnw("cannot-unmarshal-channel-id", log.Fields{"error": err})
507 return nil, err
508 }
Matt Jeanneret4e241952019-02-28 11:16:04 -0500509 case "vendor_id":
510 if err := ptypes.UnmarshalAny(arg.Value, vendorId); err != nil {
511 log.Warnw("cannot-unmarshal-vendor-id", log.Fields{"error": err})
512 return nil, err
513 }
514 case "serial_number":
515 if err := ptypes.UnmarshalAny(arg.Value, serialNumber); err != nil {
516 log.Warnw("cannot-unmarshal-serial-number", log.Fields{"error": err})
517 return nil, err
518 }
519 case "onu_id":
520 if err := ptypes.UnmarshalAny(arg.Value, onuId); err != nil {
521 log.Warnw("cannot-unmarshal-onu-id", log.Fields{"error": err})
522 return nil, err
523 }
khenaidoo297cd252019-02-07 22:10:23 -0500524 case kafka.TransactionKey:
525 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
526 log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
527 return nil, err
528 }
khenaidoob9203542018-09-17 22:56:37 -0400529 }
530 }
khenaidoob9203542018-09-17 22:56:37 -0400531 log.Debugw("ChildDeviceDetected", log.Fields{"parentDeviceId": pID.Id, "parentPortNo": portNo.Val,
Matt Jeanneret4e241952019-02-28 11:16:04 -0500532 "deviceType": dt.Val, "channelId": chnlId.Val, "serialNumber": serialNumber.Val,
533 "vendorId": vendorId.Val, "onuId": onuId.Val, "transactionID": transactionID.Val})
khenaidoo297cd252019-02-07 22:10:23 -0500534
535 // Try to grab the transaction as this core may be competing with another Core
536 if rhp.competeForTransaction() {
Richard Jankowski199fd862019-03-18 14:49:51 -0400537 if txn, err := rhp.takeRequestOwnership(transactionID.Val, pID.Id); err != nil {
khenaidoo297cd252019-02-07 22:10:23 -0500538 log.Debugw("Another core handled the request", log.Fields{"transactionID": transactionID})
539 // returning nil, nil instructs the callee to ignore this request
540 return nil, nil
541 } else {
542 defer txn.Close()
543 }
544 }
khenaidoob9203542018-09-17 22:56:37 -0400545
546 if rhp.TestMode { // Execute only for test cases
547 return nil, nil
548 }
khenaidoo59ef7be2019-06-21 12:40:28 -0400549 if err := rhp.deviceMgr.childDeviceDetected(pID.Id, portNo.Val, dt.Val, chnlId.Val, vendorId.Val, serialNumber.Val, onuId.Val); err != nil {
550 log.Errorw("child-detection-failed", log.Fields{"parentId": pID.Id, "onuId": onuId.Val, "error": err})
551 return nil, err
552 }
khenaidoob9203542018-09-17 22:56:37 -0400553
554 return new(empty.Empty), nil
555}
556
khenaidoo79232702018-12-04 11:00:41 -0500557func (rhp *AdapterRequestHandlerProxy) DeviceStateUpdate(args []*ic.Argument) (*empty.Empty, error) {
khenaidoo297cd252019-02-07 22:10:23 -0500558 if len(args) < 3 {
khenaidoob9203542018-09-17 22:56:37 -0400559 log.Warn("invalid-number-of-args", log.Fields{"args": args})
560 err := errors.New("invalid-number-of-args")
561 return nil, err
562 }
563 deviceId := &voltha.ID{}
khenaidoo79232702018-12-04 11:00:41 -0500564 operStatus := &ic.IntType{}
565 connStatus := &ic.IntType{}
khenaidoo297cd252019-02-07 22:10:23 -0500566 transactionID := &ic.StrType{}
khenaidoob9203542018-09-17 22:56:37 -0400567 for _, arg := range args {
568 switch arg.Key {
569 case "device_id":
570 if err := ptypes.UnmarshalAny(arg.Value, deviceId); err != nil {
571 log.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
572 return nil, err
573 }
574 case "oper_status":
575 if err := ptypes.UnmarshalAny(arg.Value, operStatus); err != nil {
576 log.Warnw("cannot-unmarshal-operStatus", log.Fields{"error": err})
577 return nil, err
578 }
khenaidoob9203542018-09-17 22:56:37 -0400579 case "connect_status":
580 if err := ptypes.UnmarshalAny(arg.Value, connStatus); err != nil {
581 log.Warnw("cannot-unmarshal-connStatus", log.Fields{"error": err})
582 return nil, err
583 }
khenaidoo297cd252019-02-07 22:10:23 -0500584 case kafka.TransactionKey:
585 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
586 log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
587 return nil, err
588 }
khenaidoob9203542018-09-17 22:56:37 -0400589 }
590 }
khenaidoo297cd252019-02-07 22:10:23 -0500591 log.Debugw("DeviceStateUpdate", log.Fields{"deviceId": deviceId.Id, "oper-status": operStatus,
592 "conn-status": connStatus, "transactionID": transactionID.Val})
593
594 // Try to grab the transaction as this core may be competing with another Core
595 if rhp.competeForTransaction() {
Richard Jankowski199fd862019-03-18 14:49:51 -0400596 if txn, err := rhp.takeRequestOwnership(transactionID.Val, deviceId.Id); err != nil {
khenaidoo297cd252019-02-07 22:10:23 -0500597 log.Debugw("Another core handled the request", log.Fields{"transactionID": transactionID})
598 // returning nil, nil instructs the callee to ignore this request
599 return nil, nil
600 } else {
601 defer txn.Close()
602 }
603 }
604
khenaidoob9203542018-09-17 22:56:37 -0400605 if rhp.TestMode { // Execute only for test cases
606 return nil, nil
607 }
khenaidoo92e62c52018-10-03 14:02:54 -0400608 // When the enum is not set (i.e. -1), Go still convert to the Enum type with the value being -1
khenaidoo1ce37ad2019-03-24 22:07:24 -0400609 go rhp.deviceMgr.updateDeviceStatus(deviceId.Id, voltha.OperStatus_OperStatus(operStatus.Val),
610 voltha.ConnectStatus_ConnectStatus(connStatus.Val))
611
612 //if err := rhp.deviceMgr.updateDeviceStatus(deviceId.Id, voltha.OperStatus_OperStatus(operStatus.Val),
613 // voltha.ConnectStatus_ConnectStatus(connStatus.Val)); err != nil {
614 // return nil, err
615 //}
khenaidoo92e62c52018-10-03 14:02:54 -0400616 return new(empty.Empty), nil
617}
618
khenaidoo79232702018-12-04 11:00:41 -0500619func (rhp *AdapterRequestHandlerProxy) ChildrenStateUpdate(args []*ic.Argument) (*empty.Empty, error) {
khenaidoo297cd252019-02-07 22:10:23 -0500620 if len(args) < 3 {
khenaidoo4d4802d2018-10-04 21:59:49 -0400621 log.Warn("invalid-number-of-args", log.Fields{"args": args})
622 err := errors.New("invalid-number-of-args")
623 return nil, err
624 }
625 deviceId := &voltha.ID{}
khenaidoo79232702018-12-04 11:00:41 -0500626 operStatus := &ic.IntType{}
627 connStatus := &ic.IntType{}
khenaidoo297cd252019-02-07 22:10:23 -0500628 transactionID := &ic.StrType{}
khenaidoo4d4802d2018-10-04 21:59:49 -0400629 for _, arg := range args {
630 switch arg.Key {
631 case "device_id":
632 if err := ptypes.UnmarshalAny(arg.Value, deviceId); err != nil {
633 log.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
634 return nil, err
635 }
636 case "oper_status":
637 if err := ptypes.UnmarshalAny(arg.Value, operStatus); err != nil {
638 log.Warnw("cannot-unmarshal-operStatus", log.Fields{"error": err})
639 return nil, err
640 }
641 case "connect_status":
642 if err := ptypes.UnmarshalAny(arg.Value, connStatus); err != nil {
643 log.Warnw("cannot-unmarshal-connStatus", log.Fields{"error": err})
644 return nil, err
645 }
khenaidoo297cd252019-02-07 22:10:23 -0500646 case kafka.TransactionKey:
647 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
648 log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
649 return nil, err
650 }
khenaidoo4d4802d2018-10-04 21:59:49 -0400651 }
652 }
khenaidoo297cd252019-02-07 22:10:23 -0500653 log.Debugw("ChildrenStateUpdate", log.Fields{"deviceId": deviceId.Id, "oper-status": operStatus,
654 "conn-status": connStatus, "transactionID": transactionID.Val})
655
656 // Try to grab the transaction as this core may be competing with another Core
657 if rhp.competeForTransaction() {
Richard Jankowski199fd862019-03-18 14:49:51 -0400658 if txn, err := rhp.takeRequestOwnership(transactionID.Val, deviceId.Id); err != nil {
khenaidoo297cd252019-02-07 22:10:23 -0500659 log.Debugw("Another core handled the request", log.Fields{"transactionID": transactionID})
660 // returning nil, nil instructs the callee to ignore this request
661 return nil, nil
662 } else {
663 defer txn.Close()
664 }
665 }
666
khenaidoo4d4802d2018-10-04 21:59:49 -0400667 if rhp.TestMode { // Execute only for test cases
668 return nil, nil
669 }
670
671 // When the enum is not set (i.e. -1), Go still convert to the Enum type with the value being -1
khenaidoo1ce37ad2019-03-24 22:07:24 -0400672 go rhp.deviceMgr.updateChildrenStatus(deviceId.Id, voltha.OperStatus_OperStatus(operStatus.Val),
673 voltha.ConnectStatus_ConnectStatus(connStatus.Val))
674
675 //if err := rhp.deviceMgr.updateChildrenStatus(deviceId.Id, voltha.OperStatus_OperStatus(operStatus.Val),
676 // voltha.ConnectStatus_ConnectStatus(connStatus.Val)); err != nil {
677 // return nil, err
678 //}
khenaidoo4d4802d2018-10-04 21:59:49 -0400679 return new(empty.Empty), nil
680}
681
khenaidoo3ab34882019-05-02 21:33:30 -0400682func (rhp *AdapterRequestHandlerProxy) PortsStateUpdate(args []*ic.Argument) (*empty.Empty, error) {
683 if len(args) < 2 {
684 log.Warn("invalid-number-of-args", log.Fields{"args": args})
685 err := errors.New("invalid-number-of-args")
686 return nil, err
687 }
688 deviceId := &voltha.ID{}
689 operStatus := &ic.IntType{}
690 transactionID := &ic.StrType{}
691 for _, arg := range args {
692 switch arg.Key {
693 case "device_id":
694 if err := ptypes.UnmarshalAny(arg.Value, deviceId); err != nil {
695 log.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
696 return nil, err
697 }
698 case "oper_status":
699 if err := ptypes.UnmarshalAny(arg.Value, operStatus); err != nil {
700 log.Warnw("cannot-unmarshal-operStatus", log.Fields{"error": err})
701 return nil, err
702 }
703 case kafka.TransactionKey:
704 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
705 log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
706 return nil, err
707 }
708 }
709 }
710 log.Debugw("PortsStateUpdate", log.Fields{"deviceId": deviceId.Id, "operStatus": operStatus, "transactionID": transactionID.Val})
711
712 // Try to grab the transaction as this core may be competing with another Core
713 if rhp.competeForTransaction() {
714 if txn, err := rhp.takeRequestOwnership(transactionID.Val, deviceId.Id); err != nil {
715 log.Debugw("Another core handled the request", log.Fields{"transactionID": transactionID})
716 // returning nil, nil instructs the callee to ignore this request
717 return nil, nil
718 } else {
719 defer txn.Close()
720 }
721 }
722
723 if rhp.TestMode { // Execute only for test cases
724 return nil, nil
725 }
726
727 go rhp.deviceMgr.updatePortsState(deviceId.Id, voltha.OperStatus_OperStatus(operStatus.Val))
728
729 return new(empty.Empty), nil
730}
731
khenaidoo79232702018-12-04 11:00:41 -0500732func (rhp *AdapterRequestHandlerProxy) PortStateUpdate(args []*ic.Argument) (*empty.Empty, error) {
khenaidoo297cd252019-02-07 22:10:23 -0500733 if len(args) < 3 {
khenaidoo92e62c52018-10-03 14:02:54 -0400734 log.Warn("invalid-number-of-args", log.Fields{"args": args})
735 err := errors.New("invalid-number-of-args")
736 return nil, err
khenaidoob9203542018-09-17 22:56:37 -0400737 }
khenaidoo92e62c52018-10-03 14:02:54 -0400738 deviceId := &voltha.ID{}
khenaidoo79232702018-12-04 11:00:41 -0500739 portType := &ic.IntType{}
740 portNo := &ic.IntType{}
741 operStatus := &ic.IntType{}
khenaidoo297cd252019-02-07 22:10:23 -0500742 transactionID := &ic.StrType{}
khenaidoo92e62c52018-10-03 14:02:54 -0400743 for _, arg := range args {
744 switch arg.Key {
745 case "device_id":
746 if err := ptypes.UnmarshalAny(arg.Value, deviceId); err != nil {
747 log.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
748 return nil, err
749 }
750 case "oper_status":
751 if err := ptypes.UnmarshalAny(arg.Value, operStatus); err != nil {
752 log.Warnw("cannot-unmarshal-operStatus", log.Fields{"error": err})
753 return nil, err
754 }
755 case "port_type":
756 if err := ptypes.UnmarshalAny(arg.Value, portType); err != nil {
757 log.Warnw("cannot-unmarshal-porttype", log.Fields{"error": err})
758 return nil, err
759 }
760 case "port_no":
761 if err := ptypes.UnmarshalAny(arg.Value, portNo); err != nil {
762 log.Warnw("cannot-unmarshal-portno", log.Fields{"error": err})
763 return nil, err
764 }
khenaidoo297cd252019-02-07 22:10:23 -0500765 case kafka.TransactionKey:
766 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
767 log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
768 return nil, err
769 }
khenaidoo92e62c52018-10-03 14:02:54 -0400770 }
771 }
khenaidoo297cd252019-02-07 22:10:23 -0500772 log.Debugw("PortStateUpdate", log.Fields{"deviceId": deviceId.Id, "operStatus": operStatus,
773 "portType": portType, "portNo": portNo, "transactionID": transactionID.Val})
774
775 // Try to grab the transaction as this core may be competing with another Core
776 if rhp.competeForTransaction() {
Richard Jankowski199fd862019-03-18 14:49:51 -0400777 if txn, err := rhp.takeRequestOwnership(transactionID.Val, deviceId.Id); err != nil {
khenaidoo297cd252019-02-07 22:10:23 -0500778 log.Debugw("Another core handled the request", log.Fields{"transactionID": transactionID})
779 // returning nil, nil instructs the callee to ignore this request
780 return nil, nil
781 } else {
782 defer txn.Close()
783 }
784 }
785
khenaidoo92e62c52018-10-03 14:02:54 -0400786 if rhp.TestMode { // Execute only for test cases
787 return nil, nil
788 }
khenaidoo1ce37ad2019-03-24 22:07:24 -0400789
790 go rhp.deviceMgr.updatePortState(deviceId.Id, voltha.Port_PortType(portType.Val), uint32(portNo.Val),
791 voltha.OperStatus_OperStatus(operStatus.Val))
792
793 //if err := rhp.deviceMgr.updatePortState(deviceId.Id, voltha.Port_PortType(portType.Val), uint32(portNo.Val),
794 // voltha.OperStatus_OperStatus(operStatus.Val)); err != nil {
795 // return nil, err
796 //}
khenaidoob9203542018-09-17 22:56:37 -0400797 return new(empty.Empty), nil
798}
799
khenaidoo0a822f92019-05-08 15:15:57 -0400800func (rhp *AdapterRequestHandlerProxy) DeleteAllPorts(args []*ic.Argument) (*empty.Empty, error) {
801 if len(args) < 3 {
802 log.Warn("invalid-number-of-args", log.Fields{"args": args})
803 err := errors.New("invalid-number-of-args")
804 return nil, err
805 }
806 deviceId := &voltha.ID{}
807 transactionID := &ic.StrType{}
808 for _, arg := range args {
809 switch arg.Key {
810 case "device_id":
811 if err := ptypes.UnmarshalAny(arg.Value, deviceId); err != nil {
812 log.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
813 return nil, err
814 }
815 case kafka.TransactionKey:
816 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
817 log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
818 return nil, err
819 }
820 }
821 }
822 log.Debugw("DeleteAllPorts", log.Fields{"deviceId": deviceId.Id, "transactionID": transactionID.Val})
823
824 // Try to grab the transaction as this core may be competing with another Core
825 if rhp.competeForTransaction() {
826 if txn, err := rhp.takeRequestOwnership(transactionID.Val, deviceId.Id); err != nil {
827 log.Debugw("Another core handled the request", log.Fields{"transactionID": transactionID})
828 // returning nil, nil instructs the callee to ignore this request
829 return nil, nil
830 } else {
831 defer txn.Close()
832 }
833 }
834
835 if rhp.TestMode { // Execute only for test cases
836 return nil, nil
837 }
838
839 go rhp.deviceMgr.deleteAllPorts(deviceId.Id)
840
841 return new(empty.Empty), nil
842}
843
844func (rhp *AdapterRequestHandlerProxy) ChildDevicesLost(args []*ic.Argument) (*empty.Empty, error) {
845 if len(args) < 2 {
846 log.Warn("invalid-number-of-args", log.Fields{"args": args})
847 err := errors.New("invalid-number-of-args")
848 return nil, err
849 }
850 parentDeviceId := &voltha.ID{}
851 transactionID := &ic.StrType{}
852 for _, arg := range args {
853 switch arg.Key {
854 case "parent_device_id":
855 if err := ptypes.UnmarshalAny(arg.Value, parentDeviceId); err != nil {
856 log.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
857 return nil, err
858 }
859 case kafka.TransactionKey:
860 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
861 log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
862 return nil, err
863 }
864 }
865 }
866 log.Debugw("ChildDevicesLost", log.Fields{"deviceId": parentDeviceId.Id, "transactionID": transactionID.Val})
867
868 // Try to grab the transaction as this core may be competing with another Core
869 if rhp.competeForTransaction() {
870 if txn, err := rhp.takeRequestOwnership(transactionID.Val, parentDeviceId.Id); err != nil {
871 log.Debugw("Another core handled the request", log.Fields{"transactionID": transactionID})
872 // returning nil, nil instructs the callee to ignore this request
873 return nil, nil
874 } else {
875 defer txn.Close()
876 }
877 }
878
879 if rhp.TestMode { // Execute only for test cases
880 return nil, nil
881 }
882
883 go rhp.deviceMgr.childDevicesLost(parentDeviceId.Id)
884
885 return new(empty.Empty), nil
886}
887
888func (rhp *AdapterRequestHandlerProxy) ChildDevicesDetected(args []*ic.Argument) (*empty.Empty, error) {
889 if len(args) < 2 {
890 log.Warn("invalid-number-of-args", log.Fields{"args": args})
891 err := errors.New("invalid-number-of-args")
892 return nil, err
893 }
894 parentDeviceId := &voltha.ID{}
895 transactionID := &ic.StrType{}
896 for _, arg := range args {
897 switch arg.Key {
898 case "parent_device_id":
899 if err := ptypes.UnmarshalAny(arg.Value, parentDeviceId); err != nil {
900 log.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
901 return nil, err
902 }
903 case kafka.TransactionKey:
904 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
905 log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
906 return nil, err
907 }
908 }
909 }
910 log.Debugw("ChildDevicesDetected", log.Fields{"deviceId": parentDeviceId.Id, "transactionID": transactionID.Val})
911
912 // Try to grab the transaction as this core may be competing with another Core
913 if rhp.competeForTransaction() {
914 if txn, err := rhp.takeRequestOwnership(transactionID.Val, parentDeviceId.Id); err != nil {
915 log.Debugw("Another core handled the request", log.Fields{"transactionID": transactionID})
916 // returning nil, nil instructs the callee to ignore this request
917 return nil, nil
918 } else {
919 defer txn.Close()
920 }
921 }
922
923 if rhp.TestMode { // Execute only for test cases
924 return nil, nil
925 }
926
khenaidoo59ef7be2019-06-21 12:40:28 -0400927 if err := rhp.deviceMgr.childDevicesDetected(parentDeviceId.Id); err != nil {
928 log.Errorw("child-devices-dection-failed", log.Fields{"parentId": parentDeviceId.Id, "error": err})
929 return nil, err
930 }
khenaidoo0a822f92019-05-08 15:15:57 -0400931
932 return new(empty.Empty), nil
933}
934
khenaidoo79232702018-12-04 11:00:41 -0500935func (rhp *AdapterRequestHandlerProxy) PortCreated(args []*ic.Argument) (*empty.Empty, error) {
khenaidoo54e0ddf2019-02-27 16:21:33 -0500936 if len(args) < 3 {
khenaidoob9203542018-09-17 22:56:37 -0400937 log.Warn("invalid-number-of-args", log.Fields{"args": args})
938 err := errors.New("invalid-number-of-args")
939 return nil, err
940 }
941 deviceId := &voltha.ID{}
942 port := &voltha.Port{}
khenaidoo297cd252019-02-07 22:10:23 -0500943 transactionID := &ic.StrType{}
khenaidoob9203542018-09-17 22:56:37 -0400944 for _, arg := range args {
945 switch arg.Key {
946 case "device_id":
947 if err := ptypes.UnmarshalAny(arg.Value, deviceId); err != nil {
948 log.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
949 return nil, err
950 }
951 case "port":
952 if err := ptypes.UnmarshalAny(arg.Value, port); err != nil {
953 log.Warnw("cannot-unmarshal-port", log.Fields{"error": err})
954 return nil, err
955 }
khenaidoo297cd252019-02-07 22:10:23 -0500956 case kafka.TransactionKey:
957 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
958 log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
959 return nil, err
960 }
khenaidoob9203542018-09-17 22:56:37 -0400961 }
962 }
khenaidoo297cd252019-02-07 22:10:23 -0500963 log.Debugw("PortCreated", log.Fields{"deviceId": deviceId.Id, "port": port, "transactionID": transactionID.Val})
964
965 // Try to grab the transaction as this core may be competing with another Core
966 if rhp.competeForTransaction() {
Richard Jankowski199fd862019-03-18 14:49:51 -0400967 if txn, err := rhp.takeRequestOwnership(transactionID.Val, deviceId.Id); err != nil {
khenaidoo297cd252019-02-07 22:10:23 -0500968 log.Debugw("Another core handled the request", log.Fields{"transactionID": transactionID})
969 // returning nil, nil instructs the callee to ignore this request
970 return nil, nil
971 } else {
972 defer txn.Close()
973 }
974 }
khenaidoob9203542018-09-17 22:56:37 -0400975
976 if rhp.TestMode { // Execute only for test cases
977 return nil, nil
978 }
khenaidoo1ce37ad2019-03-24 22:07:24 -0400979 go rhp.deviceMgr.addPort(deviceId.Id, port)
khenaidoo92e62c52018-10-03 14:02:54 -0400980
khenaidoob9203542018-09-17 22:56:37 -0400981 return new(empty.Empty), nil
982}
983
khenaidoo79232702018-12-04 11:00:41 -0500984func (rhp *AdapterRequestHandlerProxy) DevicePMConfigUpdate(args []*ic.Argument) (*empty.Empty, error) {
khenaidoo54e0ddf2019-02-27 16:21:33 -0500985 if len(args) < 3 {
khenaidoob9203542018-09-17 22:56:37 -0400986 log.Warn("invalid-number-of-args", log.Fields{"args": args})
987 err := errors.New("invalid-number-of-args")
988 return nil, err
989 }
990 pmConfigs := &voltha.PmConfigs{}
khenaidoo79232702018-12-04 11:00:41 -0500991 init := &ic.BoolType{}
khenaidoo297cd252019-02-07 22:10:23 -0500992 transactionID := &ic.StrType{}
khenaidoob9203542018-09-17 22:56:37 -0400993 for _, arg := range args {
994 switch arg.Key {
995 case "device_pm_config":
996 if err := ptypes.UnmarshalAny(arg.Value, pmConfigs); err != nil {
997 log.Warnw("cannot-unmarshal-pm-config", log.Fields{"error": err})
998 return nil, err
999 }
1000 case "init":
1001 if err := ptypes.UnmarshalAny(arg.Value, init); err != nil {
1002 log.Warnw("cannot-unmarshal-boolean", log.Fields{"error": err})
1003 return nil, err
1004 }
khenaidoo297cd252019-02-07 22:10:23 -05001005 case kafka.TransactionKey:
1006 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
1007 log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
1008 return nil, err
1009 }
khenaidoob9203542018-09-17 22:56:37 -04001010 }
1011 }
khenaidoob9203542018-09-17 22:56:37 -04001012 log.Debugw("DevicePMConfigUpdate", log.Fields{"deviceId": pmConfigs.Id, "configs": pmConfigs,
khenaidoode93b462019-02-13 22:17:21 -05001013 "init": init, "transactionID": transactionID.Val})
khenaidoo297cd252019-02-07 22:10:23 -05001014
1015 // Try to grab the transaction as this core may be competing with another Core
1016 if rhp.competeForTransaction() {
Richard Jankowski199fd862019-03-18 14:49:51 -04001017 if txn, err := rhp.takeRequestOwnership(transactionID.Val, pmConfigs.Id); err != nil {
khenaidoo297cd252019-02-07 22:10:23 -05001018 log.Debugw("Another core handled the request", log.Fields{"transactionID": transactionID})
1019 // returning nil, nil instructs the callee to ignore this request
1020 return nil, nil
1021 } else {
1022 defer txn.Close()
1023 }
1024 }
khenaidoob9203542018-09-17 22:56:37 -04001025
1026 if rhp.TestMode { // Execute only for test cases
1027 return nil, nil
1028 }
1029
khenaidoo1ce37ad2019-03-24 22:07:24 -04001030 go rhp.deviceMgr.updatePmConfigs(pmConfigs.Id, pmConfigs)
1031 //if err := rhp.deviceMgr.updatePmConfigs(pmConfigs.Id, pmConfigs); err != nil {
1032 // return nil, err
1033 //}
khenaidoo92e62c52018-10-03 14:02:54 -04001034
khenaidoob9203542018-09-17 22:56:37 -04001035 return new(empty.Empty), nil
khenaidoob9203542018-09-17 22:56:37 -04001036}
khenaidoofdbad6e2018-11-06 22:26:38 -05001037
khenaidoo79232702018-12-04 11:00:41 -05001038func (rhp *AdapterRequestHandlerProxy) PacketIn(args []*ic.Argument) (*empty.Empty, error) {
khenaidoo297cd252019-02-07 22:10:23 -05001039 if len(args) < 4 {
khenaidoofdbad6e2018-11-06 22:26:38 -05001040 log.Warn("invalid-number-of-args", log.Fields{"args": args})
1041 err := errors.New("invalid-number-of-args")
1042 return nil, err
1043 }
1044 deviceId := &voltha.ID{}
khenaidoo79232702018-12-04 11:00:41 -05001045 portNo := &ic.IntType{}
1046 packet := &ic.Packet{}
khenaidoo297cd252019-02-07 22:10:23 -05001047 transactionID := &ic.StrType{}
khenaidoofdbad6e2018-11-06 22:26:38 -05001048 for _, arg := range args {
1049 switch arg.Key {
1050 case "device_id":
1051 if err := ptypes.UnmarshalAny(arg.Value, deviceId); err != nil {
1052 log.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
1053 return nil, err
1054 }
1055 case "port":
1056 if err := ptypes.UnmarshalAny(arg.Value, portNo); err != nil {
1057 log.Warnw("cannot-unmarshal-port-no", log.Fields{"error": err})
1058 return nil, err
1059 }
1060 case "packet":
1061 if err := ptypes.UnmarshalAny(arg.Value, packet); err != nil {
1062 log.Warnw("cannot-unmarshal-packet", log.Fields{"error": err})
1063 return nil, err
1064 }
khenaidoo297cd252019-02-07 22:10:23 -05001065 case kafka.TransactionKey:
1066 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
1067 log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
1068 return nil, err
1069 }
khenaidoofdbad6e2018-11-06 22:26:38 -05001070 }
1071 }
khenaidoo297cd252019-02-07 22:10:23 -05001072 log.Debugw("PacketIn", log.Fields{"deviceId": deviceId.Id, "port": portNo.Val, "packet": packet,
1073 "transactionID": transactionID.Val})
1074
khenaidoo3d3b8c22019-05-22 18:10:39 -04001075 // Try to grab the transaction as this core may be competing with another Core
1076 // TODO: If this adds too much latencies then needs to remove transaction and let OFAgent filter out
1077 // duplicates.
1078 if rhp.competeForTransaction() {
1079 if txn, err := rhp.takeRequestOwnership(transactionID.Val, deviceId.Id); err != nil {
1080 log.Debugw("Another core handled the request", log.Fields{"transactionID": transactionID})
1081 return nil, nil
1082 } else {
1083 defer txn.Close()
1084 }
1085 }
khenaidoofdbad6e2018-11-06 22:26:38 -05001086 if rhp.TestMode { // Execute only for test cases
1087 return nil, nil
1088 }
khenaidoo1ce37ad2019-03-24 22:07:24 -04001089 go rhp.deviceMgr.PacketIn(deviceId.Id, uint32(portNo.Val), transactionID.Val, packet.Payload)
khenaidoo3d3b8c22019-05-22 18:10:39 -04001090
khenaidoofdbad6e2018-11-06 22:26:38 -05001091 return new(empty.Empty), nil
1092}
khenaidoof5a5bfa2019-01-23 22:20:29 -05001093
khenaidoof5a5bfa2019-01-23 22:20:29 -05001094func (rhp *AdapterRequestHandlerProxy) UpdateImageDownload(args []*ic.Argument) (*empty.Empty, error) {
1095 if len(args) < 2 {
1096 log.Warn("invalid-number-of-args", log.Fields{"args": args})
1097 err := errors.New("invalid-number-of-args")
1098 return nil, err
1099 }
1100 deviceId := &voltha.ID{}
1101 img := &voltha.ImageDownload{}
khenaidoo297cd252019-02-07 22:10:23 -05001102 transactionID := &ic.StrType{}
khenaidoof5a5bfa2019-01-23 22:20:29 -05001103 for _, arg := range args {
1104 switch arg.Key {
1105 case "device_id":
1106 if err := ptypes.UnmarshalAny(arg.Value, deviceId); err != nil {
1107 log.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
1108 return nil, err
1109 }
1110 case "image_download":
1111 if err := ptypes.UnmarshalAny(arg.Value, img); err != nil {
1112 log.Warnw("cannot-unmarshal-imgaeDownload", log.Fields{"error": err})
1113 return nil, err
1114 }
khenaidoo297cd252019-02-07 22:10:23 -05001115 case kafka.TransactionKey:
1116 if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
1117 log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
1118 return nil, err
1119 }
khenaidoof5a5bfa2019-01-23 22:20:29 -05001120 }
1121 }
khenaidoo297cd252019-02-07 22:10:23 -05001122 log.Debugw("UpdateImageDownload", log.Fields{"deviceId": deviceId.Id, "image-download": img,
1123 "transactionID": transactionID.Val})
1124
1125 // Try to grab the transaction as this core may be competing with another Core
1126 if rhp.competeForTransaction() {
Richard Jankowski199fd862019-03-18 14:49:51 -04001127 if txn, err := rhp.takeRequestOwnership(transactionID.Val, deviceId.Id); err != nil {
khenaidoo297cd252019-02-07 22:10:23 -05001128 log.Debugw("Another core handled the request", log.Fields{"transactionID": transactionID})
1129 // returning nil, nil instructs the callee to ignore this request
1130 return nil, nil
1131 } else {
1132 defer txn.Close()
1133 }
1134 }
1135
khenaidoof5a5bfa2019-01-23 22:20:29 -05001136 if rhp.TestMode { // Execute only for test cases
1137 return nil, nil
1138 }
khenaidoo1ce37ad2019-03-24 22:07:24 -04001139 go rhp.deviceMgr.updateImageDownload(deviceId.Id, img)
1140 //if err := rhp.deviceMgr.updateImageDownload(deviceId.Id, img); err != nil {
1141 // return nil, err
1142 //}
khenaidoof5a5bfa2019-01-23 22:20:29 -05001143 return new(empty.Empty), nil
1144}