[VOL-2694] Use package specific logger instance in all log statements
Change-Id: Icf1cb5ade42e42179aed7731b767af2f52481e3d
diff --git a/rw_core/core/adapter_request_handler.go b/rw_core/core/adapter_request_handler.go
index 85af539..3c1c5d0 100644
--- a/rw_core/core/adapter_request_handler.go
+++ b/rw_core/core/adapter_request_handler.go
@@ -78,7 +78,7 @@
if devID != "" {
var ownedByMe bool
if ownedByMe, err = rhp.core.deviceOwnership.OwnedByMe(ctx, &utils.DeviceID{ID: devID}); err != nil {
- log.Warnw("getting-ownership-failed", log.Fields{"deviceId": devID, "error": err})
+ logger.Warnw("getting-ownership-failed", log.Fields{"deviceId": devID, "error": err})
return nil, kafka.ErrorTransactionInvalidId
}
acquired, err = txn.Acquired(ctx, timeout, ownedByMe)
@@ -86,10 +86,10 @@
acquired, err = txn.Acquired(ctx, timeout)
}
if err == nil && acquired {
- log.Debugw("transaction-acquired", log.Fields{"transactionId": txn.txnID})
+ logger.Debugw("transaction-acquired", log.Fields{"transactionId": txn.txnID})
return txn, nil
}
- log.Debugw("transaction-not-acquired", log.Fields{"transactionId": txn.txnID, "error": err})
+ logger.Debugw("transaction-not-acquired", log.Fields{"transactionId": txn.txnID, "error": err})
return nil, kafka.ErrorTransactionNotAcquired
}
@@ -102,7 +102,7 @@
// Register registers the adapter
func (rhp *AdapterRequestHandlerProxy) Register(args []*ic.Argument) (*voltha.CoreInstance, error) {
if len(args) < 3 {
- log.Warn("invalid-number-of-args", log.Fields{"args": args})
+ logger.Warn("invalid-number-of-args", log.Fields{"args": args})
err := errors.New("invalid-number-of-args")
return nil, err
}
@@ -113,29 +113,29 @@
switch arg.Key {
case "adapter":
if err := ptypes.UnmarshalAny(arg.Value, adapter); err != nil {
- log.Warnw("cannot-unmarshal-adapter", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-adapter", log.Fields{"error": err})
return nil, err
}
case "deviceTypes":
if err := ptypes.UnmarshalAny(arg.Value, deviceTypes); err != nil {
- log.Warnw("cannot-unmarshal-device-types", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-device-types", log.Fields{"error": err})
return nil, err
}
case kafka.TransactionKey:
if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
- log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
return nil, err
}
}
}
- log.Debugw("Register", log.Fields{"adapter": *adapter, "device-types": deviceTypes, "transaction-id": transactionID.Val, "core-id": rhp.coreInstanceID})
+ logger.Debugw("Register", log.Fields{"adapter": *adapter, "device-types": deviceTypes, "transaction-id": transactionID.Val, "core-id": rhp.coreInstanceID})
// Try to grab the transaction as this core may be competing with another Core
if rhp.competeForTransaction() {
txn, err := rhp.takeRequestOwnership(context.TODO(), transactionID.Val, "")
if err != nil {
if err.Error() == kafka.ErrorTransactionNotAcquired.Error() {
- log.Debugw("Another core handled the request", log.Fields{"transactionId": transactionID})
+ logger.Debugw("Another core handled the request", log.Fields{"transactionId": transactionID})
// Update our adapters in memory
go rhp.adapterMgr.updateAdaptersAndDevicetypesInMemory(context.TODO(), adapter)
}
@@ -149,7 +149,7 @@
// GetDevice returns device info
func (rhp *AdapterRequestHandlerProxy) GetDevice(args []*ic.Argument) (*voltha.Device, error) {
if len(args) < 2 {
- log.Warn("invalid-number-of-args", log.Fields{"args": args})
+ logger.Warn("invalid-number-of-args", log.Fields{"args": args})
err := errors.New("invalid-number-of-args")
return nil, err
}
@@ -160,23 +160,23 @@
switch arg.Key {
case "device_id":
if err := ptypes.UnmarshalAny(arg.Value, pID); err != nil {
- log.Warnw("cannot-unmarshal-ID", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-ID", log.Fields{"error": err})
return nil, err
}
case kafka.TransactionKey:
if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
- log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
return nil, err
}
}
}
- log.Debugw("GetDevice", log.Fields{"deviceID": pID.Id, "transactionID": transactionID.Val})
+ logger.Debugw("GetDevice", log.Fields{"deviceID": pID.Id, "transactionID": transactionID.Val})
// Try to grab the transaction as this core may be competing with another Core
if rhp.competeForTransaction() {
txn, err := rhp.takeRequestOwnership(context.TODO(), transactionID.Val, pID.Id)
if err != nil {
- log.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
+ logger.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
return nil, err
}
defer txn.Close(context.TODO())
@@ -185,7 +185,7 @@
// Get the device via the device manager
device, err := rhp.deviceMgr.GetDevice(context.TODO(), pID.Id)
if err != nil {
- log.Debugw("get-device-failed", log.Fields{"deviceID": pID.Id, "error": err})
+ logger.Debugw("get-device-failed", log.Fields{"deviceID": pID.Id, "error": err})
}
return device, err
}
@@ -193,7 +193,7 @@
// DeviceUpdate updates device using adapter data
func (rhp *AdapterRequestHandlerProxy) DeviceUpdate(args []*ic.Argument) (*empty.Empty, error) {
if len(args) < 2 {
- log.Warn("invalid-number-of-args", log.Fields{"args": args})
+ logger.Warn("invalid-number-of-args", log.Fields{"args": args})
err := errors.New("invalid-number-of-args")
return nil, err
}
@@ -204,32 +204,32 @@
switch arg.Key {
case "device":
if err := ptypes.UnmarshalAny(arg.Value, device); err != nil {
- log.Warnw("cannot-unmarshal-ID", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-ID", log.Fields{"error": err})
return nil, err
}
case kafka.TransactionKey:
if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
- log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
return nil, err
}
}
}
- log.Debugw("DeviceUpdate", log.Fields{"deviceID": device.Id, "transactionID": transactionID.Val})
+ logger.Debugw("DeviceUpdate", log.Fields{"deviceID": device.Id, "transactionID": transactionID.Val})
// Try to grab the transaction as this core may be competing with another Core
if rhp.competeForTransaction() {
txn, err := rhp.takeRequestOwnership(context.TODO(), transactionID.Val, device.Id)
if err != nil {
- log.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
+ logger.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
return nil, err
}
defer txn.Close(context.TODO())
}
- log.Debugw("DeviceUpdate got txn", log.Fields{"deviceID": device.Id, "transactionID": transactionID.Val})
+ logger.Debugw("DeviceUpdate got txn", log.Fields{"deviceID": device.Id, "transactionID": transactionID.Val})
if err := rhp.deviceMgr.updateDeviceUsingAdapterData(context.TODO(), device); err != nil {
- log.Debugw("unable-to-update-device-using-adapter-data", log.Fields{"error": err})
+ logger.Debugw("unable-to-update-device-using-adapter-data", log.Fields{"error": err})
return nil, err
}
return &empty.Empty{}, nil
@@ -238,7 +238,7 @@
// GetChildDevice returns details of child device
func (rhp *AdapterRequestHandlerProxy) GetChildDevice(args []*ic.Argument) (*voltha.Device, error) {
if len(args) < 3 {
- log.Warn("invalid-number-of-args", log.Fields{"args": args})
+ logger.Warn("invalid-number-of-args", log.Fields{"args": args})
err := errors.New("invalid-number-of-args")
return nil, err
}
@@ -252,38 +252,38 @@
switch arg.Key {
case "device_id":
if err := ptypes.UnmarshalAny(arg.Value, pID); err != nil {
- log.Warnw("cannot-unmarshal-ID", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-ID", log.Fields{"error": err})
return nil, err
}
case "serial_number":
if err := ptypes.UnmarshalAny(arg.Value, serialNumber); err != nil {
- log.Warnw("cannot-unmarshal-ID", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-ID", log.Fields{"error": err})
return nil, err
}
case "onu_id":
if err := ptypes.UnmarshalAny(arg.Value, onuID); err != nil {
- log.Warnw("cannot-unmarshal-ID", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-ID", log.Fields{"error": err})
return nil, err
}
case "parent_port_no":
if err := ptypes.UnmarshalAny(arg.Value, parentPortNo); err != nil {
- log.Warnw("cannot-unmarshal-ID", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-ID", log.Fields{"error": err})
return nil, err
}
case kafka.TransactionKey:
if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
- log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
return nil, err
}
}
}
- log.Debugw("GetChildDevice", log.Fields{"parentDeviceID": pID.Id, "args": args, "transactionID": transactionID.Val})
+ logger.Debugw("GetChildDevice", log.Fields{"parentDeviceID": pID.Id, "args": args, "transactionID": transactionID.Val})
// Try to grab the transaction as this core may be competing with another Core
if rhp.competeForTransaction() {
txn, err := rhp.takeRequestOwnership(context.TODO(), transactionID.Val, pID.Id)
if err != nil {
- log.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
+ logger.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
return nil, err
}
defer txn.Close(context.TODO())
@@ -295,7 +295,7 @@
// GetChildDeviceWithProxyAddress returns details of child device with proxy address
func (rhp *AdapterRequestHandlerProxy) GetChildDeviceWithProxyAddress(args []*ic.Argument) (*voltha.Device, error) {
if len(args) < 2 {
- log.Warn("invalid-number-of-args", log.Fields{"args": args})
+ logger.Warn("invalid-number-of-args", log.Fields{"args": args})
err := errors.New("invalid-number-of-args")
return nil, err
}
@@ -306,23 +306,23 @@
switch arg.Key {
case "proxy_address":
if err := ptypes.UnmarshalAny(arg.Value, proxyAddress); err != nil {
- log.Warnw("cannot-unmarshal-proxy-address", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-proxy-address", log.Fields{"error": err})
return nil, err
}
case kafka.TransactionKey:
if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
- log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
return nil, err
}
}
}
- log.Debugw("GetChildDeviceWithProxyAddress", log.Fields{"proxyAddress": proxyAddress, "transactionID": transactionID.Val})
+ logger.Debugw("GetChildDeviceWithProxyAddress", log.Fields{"proxyAddress": proxyAddress, "transactionID": transactionID.Val})
// Try to grab the transaction as this core may be competing with another Core
if rhp.competeForTransaction() {
txn, err := rhp.takeRequestOwnership(context.TODO(), transactionID.Val, proxyAddress.DeviceId)
if err != nil {
- log.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
+ logger.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
return nil, err
}
defer txn.Close(context.TODO())
@@ -334,7 +334,7 @@
// GetPorts returns the ports information of the device based on the port type.
func (rhp *AdapterRequestHandlerProxy) GetPorts(args []*ic.Argument) (*voltha.Ports, error) {
if len(args) < 3 {
- log.Warn("invalid-number-of-args", log.Fields{"args": args})
+ logger.Warn("invalid-number-of-args", log.Fields{"args": args})
err := errors.New("invalid-number-of-args")
return nil, err
}
@@ -345,28 +345,28 @@
switch arg.Key {
case "device_id":
if err := ptypes.UnmarshalAny(arg.Value, deviceID); err != nil {
- log.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
return nil, err
}
case "port_type":
if err := ptypes.UnmarshalAny(arg.Value, pt); err != nil {
- log.Warnw("cannot-unmarshal-porttype", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-porttype", log.Fields{"error": err})
return nil, err
}
case kafka.TransactionKey:
if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
- log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
return nil, err
}
}
}
- log.Debugw("GetPorts", log.Fields{"deviceID": deviceID.Id, "portype": pt.Val, "transactionID": transactionID.Val})
+ logger.Debugw("GetPorts", log.Fields{"deviceID": deviceID.Id, "portype": pt.Val, "transactionID": transactionID.Val})
// Try to grab the transaction as this core may be competing with another Core
if rhp.competeForTransaction() {
txn, err := rhp.takeRequestOwnership(context.TODO(), transactionID.Val, deviceID.Id)
if err != nil {
- log.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
+ logger.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
return nil, err
}
defer txn.Close(context.TODO())
@@ -378,7 +378,7 @@
// GetChildDevices gets all the child device IDs from the device passed as parameter
func (rhp *AdapterRequestHandlerProxy) GetChildDevices(args []*ic.Argument) (*voltha.Devices, error) {
if len(args) < 2 {
- log.Warn("invalid-number-of-args", log.Fields{"args": args})
+ logger.Warn("invalid-number-of-args", log.Fields{"args": args})
err := errors.New("invalid-number-of-args")
return nil, err
}
@@ -389,23 +389,23 @@
switch arg.Key {
case "device_id":
if err := ptypes.UnmarshalAny(arg.Value, pID); err != nil {
- log.Warnw("cannot-unmarshal-ID", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-ID", log.Fields{"error": err})
return nil, err
}
case kafka.TransactionKey:
if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
- log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
return nil, err
}
}
}
- log.Debugw("GetChildDevices", log.Fields{"deviceID": pID.Id, "transactionID": transactionID.Val})
+ logger.Debugw("GetChildDevices", log.Fields{"deviceID": pID.Id, "transactionID": transactionID.Val})
// Try to grab the transaction as this core may be competing with another Core
if rhp.competeForTransaction() {
txn, err := rhp.takeRequestOwnership(context.TODO(), transactionID.Val, pID.Id)
if err != nil {
- log.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
+ logger.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
return nil, err
}
defer txn.Close(context.TODO())
@@ -418,7 +418,7 @@
// {parent_device_id, parent_port_no, child_device_type, channel_id, vendor_id, serial_number)
func (rhp *AdapterRequestHandlerProxy) ChildDeviceDetected(args []*ic.Argument) (*voltha.Device, error) {
if len(args) < 5 {
- log.Warn("invalid-number-of-args", log.Fields{"args": args})
+ logger.Warn("invalid-number-of-args", log.Fields{"args": args})
err := errors.New("invalid-number-of-args")
return nil, err
}
@@ -435,47 +435,47 @@
switch arg.Key {
case "parent_device_id":
if err := ptypes.UnmarshalAny(arg.Value, pID); err != nil {
- log.Warnw("cannot-unmarshal-parent-device-id", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-parent-device-id", log.Fields{"error": err})
return nil, err
}
case "parent_port_no":
if err := ptypes.UnmarshalAny(arg.Value, portNo); err != nil {
- log.Warnw("cannot-unmarshal-parent-port", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-parent-port", log.Fields{"error": err})
return nil, err
}
case "child_device_type":
if err := ptypes.UnmarshalAny(arg.Value, dt); err != nil {
- log.Warnw("cannot-unmarshal-child-device-type", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-child-device-type", log.Fields{"error": err})
return nil, err
}
case "channel_id":
if err := ptypes.UnmarshalAny(arg.Value, chnlID); err != nil {
- log.Warnw("cannot-unmarshal-channel-id", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-channel-id", log.Fields{"error": err})
return nil, err
}
case "vendor_id":
if err := ptypes.UnmarshalAny(arg.Value, vendorID); err != nil {
- log.Warnw("cannot-unmarshal-vendor-id", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-vendor-id", log.Fields{"error": err})
return nil, err
}
case "serial_number":
if err := ptypes.UnmarshalAny(arg.Value, serialNumber); err != nil {
- log.Warnw("cannot-unmarshal-serial-number", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-serial-number", log.Fields{"error": err})
return nil, err
}
case "onu_id":
if err := ptypes.UnmarshalAny(arg.Value, onuID); err != nil {
- log.Warnw("cannot-unmarshal-onu-id", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-onu-id", log.Fields{"error": err})
return nil, err
}
case kafka.TransactionKey:
if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
- log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
return nil, err
}
}
}
- log.Debugw("ChildDeviceDetected", log.Fields{"parentDeviceID": pID.Id, "parentPortNo": portNo.Val,
+ logger.Debugw("ChildDeviceDetected", log.Fields{"parentDeviceID": pID.Id, "parentPortNo": portNo.Val,
"deviceType": dt.Val, "channelID": chnlID.Val, "serialNumber": serialNumber.Val,
"vendorID": vendorID.Val, "onuID": onuID.Val, "transactionID": transactionID.Val})
@@ -483,7 +483,7 @@
if rhp.competeForTransaction() {
txn, err := rhp.takeRequestOwnership(context.TODO(), transactionID.Val, pID.Id)
if err != nil {
- log.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
+ logger.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
return nil, err
}
defer txn.Close(context.TODO())
@@ -491,7 +491,7 @@
device, err := rhp.deviceMgr.childDeviceDetected(context.TODO(), pID.Id, portNo.Val, dt.Val, chnlID.Val, vendorID.Val, serialNumber.Val, onuID.Val)
if err != nil {
- log.Debugw("child-detection-failed", log.Fields{"parentID": pID.Id, "onuID": onuID.Val, "error": err})
+ logger.Debugw("child-detection-failed", log.Fields{"parentID": pID.Id, "onuID": onuID.Val, "error": err})
}
return device, err
}
@@ -499,7 +499,7 @@
// DeviceStateUpdate updates device status
func (rhp *AdapterRequestHandlerProxy) DeviceStateUpdate(args []*ic.Argument) (*empty.Empty, error) {
if len(args) < 3 {
- log.Warn("invalid-number-of-args", log.Fields{"args": args})
+ logger.Warn("invalid-number-of-args", log.Fields{"args": args})
err := errors.New("invalid-number-of-args")
return nil, err
}
@@ -511,34 +511,34 @@
switch arg.Key {
case "device_id":
if err := ptypes.UnmarshalAny(arg.Value, deviceID); err != nil {
- log.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
return nil, err
}
case "oper_status":
if err := ptypes.UnmarshalAny(arg.Value, operStatus); err != nil {
- log.Warnw("cannot-unmarshal-operStatus", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-operStatus", log.Fields{"error": err})
return nil, err
}
case "connect_status":
if err := ptypes.UnmarshalAny(arg.Value, connStatus); err != nil {
- log.Warnw("cannot-unmarshal-connStatus", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-connStatus", log.Fields{"error": err})
return nil, err
}
case kafka.TransactionKey:
if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
- log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
return nil, err
}
}
}
- log.Debugw("DeviceStateUpdate", log.Fields{"deviceID": deviceID.Id, "oper-status": operStatus,
+ logger.Debugw("DeviceStateUpdate", log.Fields{"deviceID": deviceID.Id, "oper-status": operStatus,
"conn-status": connStatus, "transactionID": transactionID.Val})
// Try to grab the transaction as this core may be competing with another Core
if rhp.competeForTransaction() {
txn, err := rhp.takeRequestOwnership(context.TODO(), transactionID.Val, deviceID.Id)
if err != nil {
- log.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
+ logger.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
return nil, err
}
defer txn.Close(context.TODO())
@@ -546,7 +546,7 @@
if err := rhp.deviceMgr.updateDeviceStatus(context.TODO(), deviceID.Id, voltha.OperStatus_Types(operStatus.Val),
voltha.ConnectStatus_Types(connStatus.Val)); err != nil {
- log.Debugw("unable-to-update-device-status", log.Fields{"error": err})
+ logger.Debugw("unable-to-update-device-status", log.Fields{"error": err})
return nil, err
}
return &empty.Empty{}, nil
@@ -555,7 +555,7 @@
// ChildrenStateUpdate updates child device status
func (rhp *AdapterRequestHandlerProxy) ChildrenStateUpdate(args []*ic.Argument) (*empty.Empty, error) {
if len(args) < 3 {
- log.Warn("invalid-number-of-args", log.Fields{"args": args})
+ logger.Warn("invalid-number-of-args", log.Fields{"args": args})
err := errors.New("invalid-number-of-args")
return nil, err
}
@@ -567,34 +567,34 @@
switch arg.Key {
case "device_id":
if err := ptypes.UnmarshalAny(arg.Value, deviceID); err != nil {
- log.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
return nil, err
}
case "oper_status":
if err := ptypes.UnmarshalAny(arg.Value, operStatus); err != nil {
- log.Warnw("cannot-unmarshal-operStatus", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-operStatus", log.Fields{"error": err})
return nil, err
}
case "connect_status":
if err := ptypes.UnmarshalAny(arg.Value, connStatus); err != nil {
- log.Warnw("cannot-unmarshal-connStatus", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-connStatus", log.Fields{"error": err})
return nil, err
}
case kafka.TransactionKey:
if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
- log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
return nil, err
}
}
}
- log.Debugw("ChildrenStateUpdate", log.Fields{"deviceID": deviceID.Id, "oper-status": operStatus,
+ logger.Debugw("ChildrenStateUpdate", log.Fields{"deviceID": deviceID.Id, "oper-status": operStatus,
"conn-status": connStatus, "transactionID": transactionID.Val})
// Try to grab the transaction as this core may be competing with another Core
if rhp.competeForTransaction() {
txn, err := rhp.takeRequestOwnership(context.TODO(), transactionID.Val, deviceID.Id)
if err != nil {
- log.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
+ logger.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
return nil, err
}
defer txn.Close(context.TODO())
@@ -603,7 +603,7 @@
// When the enum is not set (i.e. -1), Go still convert to the Enum type with the value being -1
if err := rhp.deviceMgr.updateChildrenStatus(context.TODO(), deviceID.Id, voltha.OperStatus_Types(operStatus.Val),
voltha.ConnectStatus_Types(connStatus.Val)); err != nil {
- log.Debugw("unable-to-update-children-status", log.Fields{"error": err})
+ logger.Debugw("unable-to-update-children-status", log.Fields{"error": err})
return nil, err
}
return &empty.Empty{}, nil
@@ -612,7 +612,7 @@
// PortsStateUpdate updates the ports state related to the device
func (rhp *AdapterRequestHandlerProxy) PortsStateUpdate(args []*ic.Argument) (*empty.Empty, error) {
if len(args) < 2 {
- log.Warn("invalid-number-of-args", log.Fields{"args": args})
+ logger.Warn("invalid-number-of-args", log.Fields{"args": args})
err := errors.New("invalid-number-of-args")
return nil, err
}
@@ -623,35 +623,35 @@
switch arg.Key {
case "device_id":
if err := ptypes.UnmarshalAny(arg.Value, deviceID); err != nil {
- log.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
return nil, err
}
case "oper_status":
if err := ptypes.UnmarshalAny(arg.Value, operStatus); err != nil {
- log.Warnw("cannot-unmarshal-operStatus", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-operStatus", log.Fields{"error": err})
return nil, err
}
case kafka.TransactionKey:
if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
- log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
return nil, err
}
}
}
- log.Debugw("PortsStateUpdate", log.Fields{"deviceID": deviceID.Id, "operStatus": operStatus, "transactionID": transactionID.Val})
+ logger.Debugw("PortsStateUpdate", log.Fields{"deviceID": deviceID.Id, "operStatus": operStatus, "transactionID": transactionID.Val})
// Try to grab the transaction as this core may be competing with another Core
if rhp.competeForTransaction() {
txn, err := rhp.takeRequestOwnership(context.TODO(), transactionID.Val, deviceID.Id)
if err != nil {
- log.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
+ logger.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
return nil, err
}
defer txn.Close(context.TODO())
}
if err := rhp.deviceMgr.updatePortsState(context.TODO(), deviceID.Id, voltha.OperStatus_Types(operStatus.Val)); err != nil {
- log.Debugw("unable-to-update-ports-state", log.Fields{"error": err})
+ logger.Debugw("unable-to-update-ports-state", log.Fields{"error": err})
return nil, err
}
return &empty.Empty{}, nil
@@ -660,7 +660,7 @@
// PortStateUpdate updates the port state of the device
func (rhp *AdapterRequestHandlerProxy) PortStateUpdate(args []*ic.Argument) (*empty.Empty, error) {
if len(args) < 3 {
- log.Warn("invalid-number-of-args", log.Fields{"args": args})
+ logger.Warn("invalid-number-of-args", log.Fields{"args": args})
err := errors.New("invalid-number-of-args")
return nil, err
}
@@ -673,39 +673,39 @@
switch arg.Key {
case "device_id":
if err := ptypes.UnmarshalAny(arg.Value, deviceID); err != nil {
- log.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
return nil, err
}
case "oper_status":
if err := ptypes.UnmarshalAny(arg.Value, operStatus); err != nil {
- log.Warnw("cannot-unmarshal-operStatus", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-operStatus", log.Fields{"error": err})
return nil, err
}
case "port_type":
if err := ptypes.UnmarshalAny(arg.Value, portType); err != nil {
- log.Warnw("cannot-unmarshal-porttype", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-porttype", log.Fields{"error": err})
return nil, err
}
case "port_no":
if err := ptypes.UnmarshalAny(arg.Value, portNo); err != nil {
- log.Warnw("cannot-unmarshal-portno", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-portno", log.Fields{"error": err})
return nil, err
}
case kafka.TransactionKey:
if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
- log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
return nil, err
}
}
}
- log.Debugw("PortStateUpdate", log.Fields{"deviceID": deviceID.Id, "operStatus": operStatus,
+ logger.Debugw("PortStateUpdate", log.Fields{"deviceID": deviceID.Id, "operStatus": operStatus,
"portType": portType, "portNo": portNo, "transactionID": transactionID.Val})
// Try to grab the transaction as this core may be competing with another Core
if rhp.competeForTransaction() {
txn, err := rhp.takeRequestOwnership(context.TODO(), transactionID.Val, deviceID.Id)
if err != nil {
- log.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
+ logger.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
return nil, err
}
defer txn.Close(context.TODO())
@@ -716,7 +716,7 @@
// If the error doesn't change behavior and is essentially ignored, it is not an error, it is a
// warning.
// TODO: VOL-2707
- log.Debugw("unable-to-update-port-state", log.Fields{"error": err})
+ logger.Debugw("unable-to-update-port-state", log.Fields{"error": err})
return nil, err
}
return &empty.Empty{}, nil
@@ -725,7 +725,7 @@
// DeleteAllPorts deletes all ports of device
func (rhp *AdapterRequestHandlerProxy) DeleteAllPorts(args []*ic.Argument) (*empty.Empty, error) {
if len(args) < 3 {
- log.Warn("invalid-number-of-args", log.Fields{"args": args})
+ logger.Warn("invalid-number-of-args", log.Fields{"args": args})
err := errors.New("invalid-number-of-args")
return nil, err
}
@@ -735,30 +735,30 @@
switch arg.Key {
case "device_id":
if err := ptypes.UnmarshalAny(arg.Value, deviceID); err != nil {
- log.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
return nil, err
}
case kafka.TransactionKey:
if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
- log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
return nil, err
}
}
}
- log.Debugw("DeleteAllPorts", log.Fields{"deviceID": deviceID.Id, "transactionID": transactionID.Val})
+ logger.Debugw("DeleteAllPorts", log.Fields{"deviceID": deviceID.Id, "transactionID": transactionID.Val})
// Try to grab the transaction as this core may be competing with another Core
if rhp.competeForTransaction() {
txn, err := rhp.takeRequestOwnership(context.TODO(), transactionID.Val, deviceID.Id)
if err != nil {
- log.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
+ logger.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
return nil, err
}
defer txn.Close(context.TODO())
}
if err := rhp.deviceMgr.deleteAllPorts(context.TODO(), deviceID.Id); err != nil {
- log.Debugw("unable-to-delete-ports", log.Fields{"error": err})
+ logger.Debugw("unable-to-delete-ports", log.Fields{"error": err})
return nil, err
}
return &empty.Empty{}, nil
@@ -768,7 +768,7 @@
// This will trigger the Core to disable all the child devices.
func (rhp *AdapterRequestHandlerProxy) ChildDevicesLost(args []*ic.Argument) (*empty.Empty, error) {
if len(args) < 2 {
- log.Warn("invalid-number-of-args", log.Fields{"args": args})
+ logger.Warn("invalid-number-of-args", log.Fields{"args": args})
err := errors.New("invalid-number-of-args")
return nil, err
}
@@ -778,30 +778,30 @@
switch arg.Key {
case "parent_device_id":
if err := ptypes.UnmarshalAny(arg.Value, parentDeviceID); err != nil {
- log.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
return nil, err
}
case kafka.TransactionKey:
if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
- log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
return nil, err
}
}
}
- log.Debugw("ChildDevicesLost", log.Fields{"deviceID": parentDeviceID.Id, "transactionID": transactionID.Val})
+ logger.Debugw("ChildDevicesLost", log.Fields{"deviceID": parentDeviceID.Id, "transactionID": transactionID.Val})
// Try to grab the transaction as this core may be competing with another Core
if rhp.competeForTransaction() {
txn, err := rhp.takeRequestOwnership(context.TODO(), transactionID.Val, parentDeviceID.Id)
if err != nil {
- log.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
+ logger.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
return nil, err
}
defer txn.Close(context.TODO())
}
if err := rhp.deviceMgr.childDevicesLost(context.TODO(), parentDeviceID.Id); err != nil {
- log.Debugw("unable-to-disable-child-devices", log.Fields{"error": err})
+ logger.Debugw("unable-to-disable-child-devices", log.Fields{"error": err})
return nil, err
}
return &empty.Empty{}, nil
@@ -811,7 +811,7 @@
// This will trigger the Core to Enable all the child devices of that parent.
func (rhp *AdapterRequestHandlerProxy) ChildDevicesDetected(args []*ic.Argument) (*empty.Empty, error) {
if len(args) < 2 {
- log.Warn("invalid-number-of-args", log.Fields{"args": args})
+ logger.Warn("invalid-number-of-args", log.Fields{"args": args})
err := errors.New("invalid-number-of-args")
return nil, err
}
@@ -821,30 +821,30 @@
switch arg.Key {
case "parent_device_id":
if err := ptypes.UnmarshalAny(arg.Value, parentDeviceID); err != nil {
- log.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
return nil, err
}
case kafka.TransactionKey:
if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
- log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
return nil, err
}
}
}
- log.Debugw("ChildDevicesDetected", log.Fields{"deviceID": parentDeviceID.Id, "transactionID": transactionID.Val})
+ logger.Debugw("ChildDevicesDetected", log.Fields{"deviceID": parentDeviceID.Id, "transactionID": transactionID.Val})
// Try to grab the transaction as this core may be competing with another Core
if rhp.competeForTransaction() {
txn, err := rhp.takeRequestOwnership(context.TODO(), transactionID.Val, parentDeviceID.Id)
if err != nil {
- log.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
+ logger.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
return nil, err
}
defer txn.Close(context.TODO())
}
if err := rhp.deviceMgr.childDevicesDetected(context.TODO(), parentDeviceID.Id); err != nil {
- log.Debugw("child-devices-detection-failed", log.Fields{"parentID": parentDeviceID.Id, "error": err})
+ logger.Debugw("child-devices-detection-failed", log.Fields{"parentID": parentDeviceID.Id, "error": err})
return nil, err
}
return &empty.Empty{}, nil
@@ -853,7 +853,7 @@
// PortCreated adds port to device
func (rhp *AdapterRequestHandlerProxy) PortCreated(args []*ic.Argument) (*empty.Empty, error) {
if len(args) < 3 {
- log.Warn("invalid-number-of-args", log.Fields{"args": args})
+ logger.Warn("invalid-number-of-args", log.Fields{"args": args})
err := errors.New("invalid-number-of-args")
return nil, err
}
@@ -864,35 +864,35 @@
switch arg.Key {
case "device_id":
if err := ptypes.UnmarshalAny(arg.Value, deviceID); err != nil {
- log.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
return nil, err
}
case "port":
if err := ptypes.UnmarshalAny(arg.Value, port); err != nil {
- log.Warnw("cannot-unmarshal-port", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-port", log.Fields{"error": err})
return nil, err
}
case kafka.TransactionKey:
if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
- log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
return nil, err
}
}
}
- log.Debugw("PortCreated", log.Fields{"deviceID": deviceID.Id, "port": port, "transactionID": transactionID.Val})
+ logger.Debugw("PortCreated", log.Fields{"deviceID": deviceID.Id, "port": port, "transactionID": transactionID.Val})
// Try to grab the transaction as this core may be competing with another Core
if rhp.competeForTransaction() {
txn, err := rhp.takeRequestOwnership(context.TODO(), transactionID.Val, deviceID.Id)
if err != nil {
- log.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
+ logger.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
return nil, err
}
defer txn.Close(context.TODO())
}
if err := rhp.deviceMgr.addPort(context.TODO(), deviceID.Id, port); err != nil {
- log.Debugw("unable-to-add-port", log.Fields{"error": err})
+ logger.Debugw("unable-to-add-port", log.Fields{"error": err})
return nil, err
}
return &empty.Empty{}, nil
@@ -901,7 +901,7 @@
// DevicePMConfigUpdate initializes the pm configs as defined by the adapter.
func (rhp *AdapterRequestHandlerProxy) DevicePMConfigUpdate(args []*ic.Argument) (*empty.Empty, error) {
if len(args) < 2 {
- log.Warn("invalid-number-of-args", log.Fields{"args": args})
+ logger.Warn("invalid-number-of-args", log.Fields{"args": args})
err := errors.New("invalid-number-of-args")
return nil, err
}
@@ -911,31 +911,31 @@
switch arg.Key {
case "device_pm_config":
if err := ptypes.UnmarshalAny(arg.Value, pmConfigs); err != nil {
- log.Warnw("cannot-unmarshal-pm-config", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-pm-config", log.Fields{"error": err})
return nil, err
}
case kafka.TransactionKey:
if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
- log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
return nil, err
}
}
}
- log.Debugw("DevicePMConfigUpdate", log.Fields{"deviceID": pmConfigs.Id, "configs": pmConfigs,
+ logger.Debugw("DevicePMConfigUpdate", log.Fields{"deviceID": pmConfigs.Id, "configs": pmConfigs,
"transactionID": transactionID.Val})
// Try to grab the transaction as this core may be competing with another Core
if rhp.competeForTransaction() {
txn, err := rhp.takeRequestOwnership(context.TODO(), transactionID.Val, pmConfigs.Id)
if err != nil {
- log.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
+ logger.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
return nil, err
}
defer txn.Close(context.TODO())
}
if err := rhp.deviceMgr.initPmConfigs(context.TODO(), pmConfigs.Id, pmConfigs); err != nil {
- log.Debugw("unable-to-initialize-pm-configs", log.Fields{"error": err})
+ logger.Debugw("unable-to-initialize-pm-configs", log.Fields{"error": err})
return nil, err
}
return &empty.Empty{}, nil
@@ -944,7 +944,7 @@
// PacketIn sends the incoming packet of device
func (rhp *AdapterRequestHandlerProxy) PacketIn(args []*ic.Argument) (*empty.Empty, error) {
if len(args) < 4 {
- log.Warn("invalid-number-of-args", log.Fields{"args": args})
+ logger.Warn("invalid-number-of-args", log.Fields{"args": args})
err := errors.New("invalid-number-of-args")
return nil, err
}
@@ -956,27 +956,27 @@
switch arg.Key {
case "device_id":
if err := ptypes.UnmarshalAny(arg.Value, deviceID); err != nil {
- log.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
return nil, err
}
case "port":
if err := ptypes.UnmarshalAny(arg.Value, portNo); err != nil {
- log.Warnw("cannot-unmarshal-port-no", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-port-no", log.Fields{"error": err})
return nil, err
}
case "packet":
if err := ptypes.UnmarshalAny(arg.Value, packet); err != nil {
- log.Warnw("cannot-unmarshal-packet", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-packet", log.Fields{"error": err})
return nil, err
}
case kafka.TransactionKey:
if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
- log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
return nil, err
}
}
}
- log.Debugw("PacketIn", log.Fields{"deviceID": deviceID.Id, "port": portNo.Val, "packet": packet,
+ logger.Debugw("PacketIn", log.Fields{"deviceID": deviceID.Id, "port": portNo.Val, "packet": packet,
"transactionID": transactionID.Val})
// Try to grab the transaction as this core may be competing with another Core
@@ -985,14 +985,14 @@
if rhp.competeForTransaction() {
txn, err := rhp.takeRequestOwnership(context.TODO(), transactionID.Val, deviceID.Id)
if err != nil {
- log.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
+ logger.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
return nil, err
}
defer txn.Close(context.TODO())
}
if err := rhp.deviceMgr.PacketIn(context.TODO(), deviceID.Id, uint32(portNo.Val), transactionID.Val, packet.Payload); err != nil {
- log.Debugw("unable-to-receive-packet-from-adapter", log.Fields{"error": err})
+ logger.Debugw("unable-to-receive-packet-from-adapter", log.Fields{"error": err})
return nil, err
}
@@ -1002,7 +1002,7 @@
// UpdateImageDownload updates image download
func (rhp *AdapterRequestHandlerProxy) UpdateImageDownload(args []*ic.Argument) (*empty.Empty, error) {
if len(args) < 2 {
- log.Warn("invalid-number-of-args", log.Fields{"args": args})
+ logger.Warn("invalid-number-of-args", log.Fields{"args": args})
err := errors.New("invalid-number-of-args")
return nil, err
}
@@ -1013,36 +1013,36 @@
switch arg.Key {
case "device_id":
if err := ptypes.UnmarshalAny(arg.Value, deviceID); err != nil {
- log.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
return nil, err
}
case "image_download":
if err := ptypes.UnmarshalAny(arg.Value, img); err != nil {
- log.Warnw("cannot-unmarshal-imgaeDownload", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-imgaeDownload", log.Fields{"error": err})
return nil, err
}
case kafka.TransactionKey:
if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
- log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
return nil, err
}
}
}
- log.Debugw("UpdateImageDownload", log.Fields{"deviceID": deviceID.Id, "image-download": img,
+ logger.Debugw("UpdateImageDownload", log.Fields{"deviceID": deviceID.Id, "image-download": img,
"transactionID": transactionID.Val})
// Try to grab the transaction as this core may be competing with another Core
if rhp.competeForTransaction() {
txn, err := rhp.takeRequestOwnership(context.TODO(), transactionID.Val, deviceID.Id)
if err != nil {
- log.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
+ logger.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
return nil, err
}
defer txn.Close(context.TODO())
}
if err := rhp.deviceMgr.updateImageDownload(context.TODO(), deviceID.Id, img); err != nil {
- log.Debugw("unable-to-update-image-download", log.Fields{"error": err})
+ logger.Debugw("unable-to-update-image-download", log.Fields{"error": err})
return nil, err
}
return &empty.Empty{}, nil
@@ -1051,7 +1051,7 @@
// ReconcileChildDevices reconciles child devices
func (rhp *AdapterRequestHandlerProxy) ReconcileChildDevices(args []*ic.Argument) (*empty.Empty, error) {
if len(args) < 2 {
- log.Warn("invalid-number-of-args", log.Fields{"args": args})
+ logger.Warn("invalid-number-of-args", log.Fields{"args": args})
err := errors.New("invalid-number-of-args")
return nil, err
}
@@ -1061,30 +1061,30 @@
switch arg.Key {
case "parent_device_id":
if err := ptypes.UnmarshalAny(arg.Value, parentDeviceID); err != nil {
- log.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
return nil, err
}
case kafka.TransactionKey:
if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
- log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
return nil, err
}
}
}
- log.Debugw("ReconcileChildDevices", log.Fields{"deviceID": parentDeviceID.Id, "transactionID": transactionID.Val})
+ logger.Debugw("ReconcileChildDevices", log.Fields{"deviceID": parentDeviceID.Id, "transactionID": transactionID.Val})
// Try to grab the transaction as this core may be competing with another Core
if rhp.competeForTransaction() {
txn, err := rhp.takeRequestOwnership(context.TODO(), transactionID.Val, parentDeviceID.Id)
if err != nil {
- log.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
+ logger.Debugw("Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
return nil, err
}
defer txn.Close(context.TODO())
}
if err := rhp.deviceMgr.reconcileChildDevices(context.TODO(), parentDeviceID.Id); err != nil {
- log.Debugw("unable-to-reconcile-child-devices", log.Fields{"error": err})
+ logger.Debugw("unable-to-reconcile-child-devices", log.Fields{"error": err})
return nil, err
}
return &empty.Empty{}, nil
@@ -1093,7 +1093,7 @@
// DeviceReasonUpdate updates device reason
func (rhp *AdapterRequestHandlerProxy) DeviceReasonUpdate(args []*ic.Argument) (*empty.Empty, error) {
if len(args) < 2 {
- log.Warn("DeviceReasonUpdate: invalid-number-of-args", log.Fields{"args": args})
+ logger.Warn("DeviceReasonUpdate: invalid-number-of-args", log.Fields{"args": args})
err := errors.New("DeviceReasonUpdate: invalid-number-of-args")
return nil, err
}
@@ -1104,36 +1104,36 @@
switch arg.Key {
case "device_id":
if err := ptypes.UnmarshalAny(arg.Value, deviceID); err != nil {
- log.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-device-id", log.Fields{"error": err})
return nil, err
}
case "device_reason":
if err := ptypes.UnmarshalAny(arg.Value, reason); err != nil {
- log.Warnw("cannot-unmarshal-reason", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-reason", log.Fields{"error": err})
return nil, err
}
case kafka.TransactionKey:
if err := ptypes.UnmarshalAny(arg.Value, transactionID); err != nil {
- log.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
+ logger.Warnw("cannot-unmarshal-transaction-ID", log.Fields{"error": err})
return nil, err
}
}
}
- log.Debugw("DeviceReasonUpdate", log.Fields{"deviceId": deviceID.Id, "reason": reason.Val,
+ logger.Debugw("DeviceReasonUpdate", log.Fields{"deviceId": deviceID.Id, "reason": reason.Val,
"transactionID": transactionID.Val})
// Try to grab the transaction as this core may be competing with another Core
if rhp.competeForTransaction() {
txn, err := rhp.takeRequestOwnership(context.TODO(), transactionID.Val, deviceID.Id)
if err != nil {
- log.Debugw("DeviceReasonUpdate: Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
+ logger.Debugw("DeviceReasonUpdate: Core did not process request", log.Fields{"transactionID": transactionID, "error": err})
return nil, err
}
defer txn.Close(context.TODO())
}
if err := rhp.deviceMgr.updateDeviceReason(context.TODO(), deviceID.Id, reason.Val); err != nil {
- log.Debugw("unable-to-update-device-reason", log.Fields{"error": err})
+ logger.Debugw("unable-to-update-device-reason", log.Fields{"error": err})
return nil, err
}