VOL-1900 lint warning fixes rw_core
Change-Id: Icaa84d7ce24163da90c91ff2babcbb78ff4e9141
diff --git a/rw_core/core/logical_device_manager.go b/rw_core/core/logical_device_manager.go
index ebe72b3..8c326a8 100644
--- a/rw_core/core/logical_device_manager.go
+++ b/rw_core/core/logical_device_manager.go
@@ -13,11 +13,15 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
+
package core
import (
"context"
"errors"
+ "strings"
+ "sync"
+
"github.com/opencord/voltha-go/db/model"
"github.com/opencord/voltha-lib-go/v2/pkg/kafka"
"github.com/opencord/voltha-lib-go/v2/pkg/log"
@@ -26,16 +30,14 @@
"github.com/opencord/voltha-protos/v2/go/voltha"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
- "strings"
- "sync"
)
+// LogicalDeviceManager represent logical device manager attributes
type LogicalDeviceManager struct {
logicalDeviceAgents sync.Map
core *Core
deviceMgr *DeviceManager
grpcNbiHdlr *APIHandler
- adapterProxy *AdapterProxy
kafkaICProxy *kafka.InterContainerProxy
clusterDataProxy *model.Proxy
exitChannel chan int
@@ -87,34 +89,29 @@
}
func (ldMgr *LogicalDeviceManager) addLogicalDeviceAgentToMap(agent *LogicalDeviceAgent) {
- if _, exist := ldMgr.logicalDeviceAgents.Load(agent.logicalDeviceId); !exist {
- ldMgr.logicalDeviceAgents.Store(agent.logicalDeviceId, agent)
+ if _, exist := ldMgr.logicalDeviceAgents.Load(agent.logicalDeviceID); !exist {
+ ldMgr.logicalDeviceAgents.Store(agent.logicalDeviceID, agent)
}
}
-func (ldMgr *LogicalDeviceManager) isLogicalDeviceInCache(logicalDeviceId string) bool {
- _, inCache := ldMgr.logicalDeviceAgents.Load(logicalDeviceId)
- return inCache
-}
-
// getLogicalDeviceAgent returns the logical device agent. If the device is not in memory then the device will
// be loaded from dB and a logical device agent created to managed it.
-func (ldMgr *LogicalDeviceManager) getLogicalDeviceAgent(logicalDeviceId string) *LogicalDeviceAgent {
- if agent, ok := ldMgr.logicalDeviceAgents.Load(logicalDeviceId); ok {
+func (ldMgr *LogicalDeviceManager) getLogicalDeviceAgent(logicalDeviceID string) *LogicalDeviceAgent {
+ agent, ok := ldMgr.logicalDeviceAgents.Load(logicalDeviceID)
+ if ok {
return agent.(*LogicalDeviceAgent)
- } else {
- // Try to load into memory - loading will also create the logical device agent
- if err := ldMgr.load(logicalDeviceId); err == nil {
- if agent, ok = ldMgr.logicalDeviceAgents.Load(logicalDeviceId); ok {
- return agent.(*LogicalDeviceAgent)
- }
+ }
+ // Try to load into memory - loading will also create the logical device agent
+ if err := ldMgr.load(logicalDeviceID); err == nil {
+ if agent, ok = ldMgr.logicalDeviceAgents.Load(logicalDeviceID); ok {
+ return agent.(*LogicalDeviceAgent)
}
}
return nil
}
-func (ldMgr *LogicalDeviceManager) deleteLogicalDeviceAgent(logicalDeviceId string) {
- ldMgr.logicalDeviceAgents.Delete(logicalDeviceId)
+func (ldMgr *LogicalDeviceManager) deleteLogicalDeviceAgent(logicalDeviceID string) {
+ ldMgr.logicalDeviceAgents.Delete(logicalDeviceID)
}
// GetLogicalDevice provides a cloned most up to date logical device. If device is not in memory
@@ -176,12 +173,17 @@
ldMgr.addLogicalDeviceAgentToMap(agent)
// Update the root device with the logical device Id reference
- if err := ldMgr.deviceMgr.setParentId(device, id); err != nil {
+ if err := ldMgr.deviceMgr.setParentID(device, id); err != nil {
log.Errorw("failed-setting-parent-id", log.Fields{"logicalDeviceId": id, "deviceId": device.Id})
return nil, err
}
- go agent.start(ctx, false)
+ go func() {
+ err := agent.start(ctx, false)
+ if err != nil {
+ log.Errorw("unable-to-create-the-logical-device", log.Fields{"error": err})
+ }
+ }()
log.Debug("creating-logical-device-ends")
return &id, nil
@@ -190,62 +192,62 @@
// stopManagingLogicalDeviceWithDeviceId stops the management of the logical device. This implies removal of any
// reference of this logical device in cache. The device Id is passed as param because the logical device may already
// have been removed from the model. This function returns the logical device Id if found
-func (ldMgr *LogicalDeviceManager) stopManagingLogicalDeviceWithDeviceId(id string) string {
+func (ldMgr *LogicalDeviceManager) stopManagingLogicalDeviceWithDeviceID(id string) string {
log.Infow("stop-managing-logical-device", log.Fields{"deviceId": id})
// Go over the list of logical device agents to find the one which has rootDeviceId as id
- var ldId = ""
+ var ldID = ""
ldMgr.logicalDeviceAgents.Range(func(key, value interface{}) bool {
ldAgent := value.(*LogicalDeviceAgent)
- if ldAgent.rootDeviceId == id {
+ if ldAgent.rootDeviceID == id {
log.Infow("stopping-logical-device-agent", log.Fields{"lDeviceId": key})
- ldAgent.stop(nil)
- ldId = key.(string)
- ldMgr.logicalDeviceAgents.Delete(ldId)
+ ldAgent.stop(context.TODO())
+ ldID = key.(string)
+ ldMgr.logicalDeviceAgents.Delete(ldID)
}
return true
})
- return ldId
+ return ldID
}
//getLogicalDeviceFromModel retrieves the logical device data from the model.
-func (ldMgr *LogicalDeviceManager) getLogicalDeviceFromModel(lDeviceId string) (*voltha.LogicalDevice, error) {
- if logicalDevice := ldMgr.clusterDataProxy.Get(context.Background(), "/logical_devices/"+lDeviceId, 0, false, ""); logicalDevice != nil {
+func (ldMgr *LogicalDeviceManager) getLogicalDeviceFromModel(lDeviceID string) (*voltha.LogicalDevice, error) {
+ if logicalDevice := ldMgr.clusterDataProxy.Get(context.Background(), "/logical_devices/"+lDeviceID, 0, false, ""); logicalDevice != nil {
if lDevice, ok := logicalDevice.(*voltha.LogicalDevice); ok {
return lDevice, nil
}
}
- return nil, status.Error(codes.NotFound, lDeviceId)
+ return nil, status.Error(codes.NotFound, lDeviceID)
}
// load loads a logical device manager in memory
-func (ldMgr *LogicalDeviceManager) load(lDeviceId string) error {
- if lDeviceId == "" {
+func (ldMgr *LogicalDeviceManager) load(lDeviceID string) error {
+ if lDeviceID == "" {
return nil
}
// Add a lock to prevent two concurrent calls from loading the same device twice
ldMgr.logicalDevicesLoadingLock.Lock()
- if _, exist := ldMgr.logicalDeviceLoadingInProgress[lDeviceId]; !exist {
- if ldAgent, _ := ldMgr.logicalDeviceAgents.Load(lDeviceId); ldAgent == nil {
- ldMgr.logicalDeviceLoadingInProgress[lDeviceId] = []chan int{make(chan int, 1)}
+ if _, exist := ldMgr.logicalDeviceLoadingInProgress[lDeviceID]; !exist {
+ if ldAgent, _ := ldMgr.logicalDeviceAgents.Load(lDeviceID); ldAgent == nil {
+ ldMgr.logicalDeviceLoadingInProgress[lDeviceID] = []chan int{make(chan int, 1)}
ldMgr.logicalDevicesLoadingLock.Unlock()
- if _, err := ldMgr.getLogicalDeviceFromModel(lDeviceId); err == nil {
- log.Debugw("loading-logical-device", log.Fields{"lDeviceId": lDeviceId})
- agent := newLogicalDeviceAgent(lDeviceId, "", ldMgr, ldMgr.deviceMgr, ldMgr.clusterDataProxy, ldMgr.defaultTimeout)
- if err := agent.start(nil, true); err != nil {
- agent.stop(nil)
+ if _, err := ldMgr.getLogicalDeviceFromModel(lDeviceID); err == nil {
+ log.Debugw("loading-logical-device", log.Fields{"lDeviceId": lDeviceID})
+ agent := newLogicalDeviceAgent(lDeviceID, "", ldMgr, ldMgr.deviceMgr, ldMgr.clusterDataProxy, ldMgr.defaultTimeout)
+ if err := agent.start(context.TODO(), true); err != nil {
+ agent.stop(context.TODO())
} else {
- ldMgr.logicalDeviceAgents.Store(agent.logicalDeviceId, agent)
+ ldMgr.logicalDeviceAgents.Store(agent.logicalDeviceID, agent)
}
} else {
- log.Debugw("logicalDevice not in model", log.Fields{"lDeviceId": lDeviceId})
+ log.Debugw("logicalDevice not in model", log.Fields{"lDeviceId": lDeviceID})
}
// announce completion of task to any number of waiting channels
ldMgr.logicalDevicesLoadingLock.Lock()
- if v, ok := ldMgr.logicalDeviceLoadingInProgress[lDeviceId]; ok {
+ if v, ok := ldMgr.logicalDeviceLoadingInProgress[lDeviceID]; ok {
for _, ch := range v {
close(ch)
}
- delete(ldMgr.logicalDeviceLoadingInProgress, lDeviceId)
+ delete(ldMgr.logicalDeviceLoadingInProgress, lDeviceID)
}
ldMgr.logicalDevicesLoadingLock.Unlock()
} else {
@@ -253,15 +255,15 @@
}
} else {
ch := make(chan int, 1)
- ldMgr.logicalDeviceLoadingInProgress[lDeviceId] = append(ldMgr.logicalDeviceLoadingInProgress[lDeviceId], ch)
+ ldMgr.logicalDeviceLoadingInProgress[lDeviceID] = append(ldMgr.logicalDeviceLoadingInProgress[lDeviceID], ch)
ldMgr.logicalDevicesLoadingLock.Unlock()
// Wait for the channel to be closed, implying the process loading this device is done.
<-ch
}
- if _, exist := ldMgr.logicalDeviceAgents.Load(lDeviceId); exist {
+ if _, exist := ldMgr.logicalDeviceAgents.Load(lDeviceID); exist {
return nil
}
- return status.Errorf(codes.Aborted, "Error loading logical device %s", lDeviceId)
+ return status.Errorf(codes.Aborted, "Error loading logical device %s", lDeviceID)
}
func (ldMgr *LogicalDeviceManager) deleteLogicalDevice(ctx context.Context, device *voltha.Device) error {
@@ -270,20 +272,23 @@
if !device.Root {
return errors.New("device-not-root")
}
- logDeviceId := device.ParentId
- if agent := ldMgr.getLogicalDeviceAgent(logDeviceId); agent != nil {
+ logDeviceID := device.ParentId
+ if agent := ldMgr.getLogicalDeviceAgent(logDeviceID); agent != nil {
// Stop the logical device agent
agent.stop(ctx)
//Remove the logical device agent from the Map
- ldMgr.deleteLogicalDeviceAgent(logDeviceId)
- ldMgr.core.deviceOwnership.AbandonDevice(logDeviceId)
+ ldMgr.deleteLogicalDeviceAgent(logDeviceID)
+ err := ldMgr.core.deviceOwnership.AbandonDevice(logDeviceID)
+ if err != nil {
+ log.Errorw("unable-to-abandon-the-device", log.Fields{"error": err})
+ }
}
log.Debug("deleting-logical-device-ends")
return nil
}
-func (ldMgr *LogicalDeviceManager) getLogicalDeviceId(device *voltha.Device) (*string, error) {
+func (ldMgr *LogicalDeviceManager) getLogicalDeviceID(device *voltha.Device) (*string, error) {
// Device can either be a parent or a child device
if device.Root {
// Parent device. The ID of a parent device is the logical device ID
@@ -297,36 +302,37 @@
return nil, status.Errorf(codes.NotFound, "%s", device.Id)
}
-func (ldMgr *LogicalDeviceManager) getLogicalDeviceIdFromDeviceId(deviceId string) (*string, error) {
+func (ldMgr *LogicalDeviceManager) getLogicalDeviceIDFromDeviceID(deviceID string) (*string, error) {
// Get the device
var device *voltha.Device
var err error
- if device, err = ldMgr.deviceMgr.GetDevice(deviceId); err != nil {
+ if device, err = ldMgr.deviceMgr.GetDevice(deviceID); err != nil {
return nil, err
}
- return ldMgr.getLogicalDeviceId(device)
+ return ldMgr.getLogicalDeviceID(device)
}
-func (ldMgr *LogicalDeviceManager) getLogicalPortId(device *voltha.Device) (*voltha.LogicalPortId, error) {
+func (ldMgr *LogicalDeviceManager) getLogicalPortID(device *voltha.Device) (*voltha.LogicalPortId, error) {
// Get the logical device where this device is attached
- var lDeviceId *string
+ var lDeviceID *string
var err error
- if lDeviceId, err = ldMgr.getLogicalDeviceId(device); err != nil {
+ if lDeviceID, err = ldMgr.getLogicalDeviceID(device); err != nil {
return nil, err
}
var lDevice *voltha.LogicalDevice
- if lDevice, err = ldMgr.getLogicalDevice(*lDeviceId); err != nil {
+ if lDevice, err = ldMgr.getLogicalDevice(*lDeviceID); err != nil {
return nil, err
}
// Go over list of ports
for _, port := range lDevice.Ports {
if port.DeviceId == device.Id {
- return &voltha.LogicalPortId{Id: *lDeviceId, PortId: port.Id}, nil
+ return &voltha.LogicalPortId{Id: *lDeviceID, PortId: port.Id}, nil
}
}
return nil, status.Errorf(codes.NotFound, "%s", device.Id)
}
+// ListLogicalDeviceFlows returns the flows of logical device
func (ldMgr *LogicalDeviceManager) ListLogicalDeviceFlows(ctx context.Context, id string) (*openflow_13.Flows, error) {
log.Debugw("ListLogicalDeviceFlows", log.Fields{"logicaldeviceid": id})
if agent := ldMgr.getLogicalDeviceAgent(id); agent != nil {
@@ -335,6 +341,7 @@
return nil, status.Errorf(codes.NotFound, "%s", id)
}
+// ListLogicalDeviceFlowGroups returns logical device flow groups
func (ldMgr *LogicalDeviceManager) ListLogicalDeviceFlowGroups(ctx context.Context, id string) (*openflow_13.FlowGroups, error) {
log.Debugw("ListLogicalDeviceFlowGroups", log.Fields{"logicaldeviceid": id})
if agent := ldMgr.getLogicalDeviceAgent(id); agent != nil {
@@ -343,6 +350,7 @@
return nil, status.Errorf(codes.NotFound, "%s", id)
}
+// ListLogicalDevicePorts returns logical device ports
func (ldMgr *LogicalDeviceManager) ListLogicalDevicePorts(ctx context.Context, id string) (*voltha.LogicalPorts, error) {
log.Debugw("ListLogicalDevicePorts", log.Fields{"logicaldeviceid": id})
if agent := ldMgr.getLogicalDeviceAgent(id); agent != nil {
@@ -351,73 +359,56 @@
return nil, status.Errorf(codes.NotFound, "%s", id)
}
-func (ldMgr *LogicalDeviceManager) getLogicalPort(lPortId *voltha.LogicalPortId) (*voltha.LogicalPort, error) {
+func (ldMgr *LogicalDeviceManager) getLogicalPort(lPortID *voltha.LogicalPortId) (*voltha.LogicalPort, error) {
// Get the logical device where this device is attached
var err error
var lDevice *voltha.LogicalDevice
- if lDevice, err = ldMgr.getLogicalDevice(lPortId.Id); err != nil {
+ if lDevice, err = ldMgr.getLogicalDevice(lPortID.Id); err != nil {
return nil, err
}
// Go over list of ports
for _, port := range lDevice.Ports {
- if port.Id == lPortId.PortId {
+ if port.Id == lPortID.PortId {
return port, nil
}
}
- return nil, status.Errorf(codes.NotFound, "%s-%s", lPortId.Id, lPortId.PortId)
+ return nil, status.Errorf(codes.NotFound, "%s-%s", lPortID.Id, lPortID.PortId)
}
// updateLogicalPort sets up a logical port on the logical device based on the device port
// information, if needed
func (ldMgr *LogicalDeviceManager) updateLogicalPort(device *voltha.Device, port *voltha.Port) error {
- if ldID, err := ldMgr.getLogicalDeviceId(device); err != nil || *ldID == "" {
+ ldID, err := ldMgr.getLogicalDeviceID(device)
+ if err != nil || *ldID == "" {
// This is not an error as the logical device may not have been created at this time. In such a case,
// the ports will be created when the logical device is ready.
return nil
- } else {
- if agent := ldMgr.getLogicalDeviceAgent(*ldID); agent != nil {
- if err := agent.updateLogicalPort(device, port); err != nil {
- return err
- }
- }
}
- return nil
-}
-
-// addLogicalPort sets up a logical port on the logical device based on the device port
-// information.
-func (ldMgr *LogicalDeviceManager) addLogicalPort(device *voltha.Device, port *voltha.Port) error {
- if ldID, err := ldMgr.getLogicalDeviceId(device); err != nil || *ldID == "" {
- // This is not an error as the logical device may not have been created at this time. In such a case,
- // the ports will be created when the logical device is ready.
- return nil
- } else {
- if agent := ldMgr.getLogicalDeviceAgent(*ldID); agent != nil {
- if err := agent.addLogicalPort(device, port); err != nil {
- return err
- }
+ if agent := ldMgr.getLogicalDeviceAgent(*ldID); agent != nil {
+ if err := agent.updateLogicalPort(device, port); err != nil {
+ return err
}
}
return nil
}
// deleteLogicalPort removes the logical port associated with a device
-func (ldMgr *LogicalDeviceManager) deleteLogicalPort(ctx context.Context, lPortId *voltha.LogicalPortId) error {
- log.Debugw("deleting-logical-port", log.Fields{"LDeviceId": lPortId.Id})
+func (ldMgr *LogicalDeviceManager) deleteLogicalPort(ctx context.Context, lPortID *voltha.LogicalPortId) error {
+ log.Debugw("deleting-logical-port", log.Fields{"LDeviceId": lPortID.Id})
// Get logical port
var logicalPort *voltha.LogicalPort
var err error
- if logicalPort, err = ldMgr.getLogicalPort(lPortId); err != nil {
- log.Debugw("no-logical-device-port-present", log.Fields{"logicalPortId": lPortId.PortId})
+ if logicalPort, err = ldMgr.getLogicalPort(lPortID); err != nil {
+ log.Debugw("no-logical-device-port-present", log.Fields{"logicalPortId": lPortID.PortId})
return err
}
// Sanity check
if logicalPort.RootPort {
return errors.New("device-root")
}
- if agent := ldMgr.getLogicalDeviceAgent(lPortId.Id); agent != nil {
+ if agent := ldMgr.getLogicalDeviceAgent(lPortID.Id); agent != nil {
if err := agent.deleteLogicalPort(logicalPort); err != nil {
- log.Warnw("deleting-logicalport-failed", log.Fields{"LDeviceId": lPortId.Id, "error": err})
+ log.Warnw("deleting-logicalport-failed", log.Fields{"LDeviceId": lPortID.Id, "error": err})
}
}
@@ -426,17 +417,17 @@
}
// deleteLogicalPort removes the logical port associated with a child device
-func (ldMgr *LogicalDeviceManager) deleteLogicalPorts(deviceId string) error {
- log.Debugw("deleting-logical-ports", log.Fields{"deviceId": deviceId})
+func (ldMgr *LogicalDeviceManager) deleteLogicalPorts(deviceID string) error {
+ log.Debugw("deleting-logical-ports", log.Fields{"deviceId": deviceID})
// Get logical port
- if ldId, err := ldMgr.getLogicalDeviceIdFromDeviceId(deviceId); err != nil {
+ ldID, err := ldMgr.getLogicalDeviceIDFromDeviceID(deviceID)
+ if err != nil {
return err
- } else {
- if agent := ldMgr.getLogicalDeviceAgent(*ldId); agent != nil {
- if err = agent.deleteLogicalPorts(deviceId); err != nil {
- log.Warnw("deleteLogicalPorts-failed", log.Fields{"ldeviceId": *ldId})
- return err
- }
+ }
+ if agent := ldMgr.getLogicalDeviceAgent(*ldID); agent != nil {
+ if err = agent.deleteLogicalPorts(deviceID); err != nil {
+ log.Warnw("deleteLogicalPorts-failed", log.Fields{"ldeviceId": *ldID})
+ return err
}
}
log.Debug("deleting-logical-port-ends")
@@ -451,16 +442,16 @@
}
// Get the logical device id parent device
- parentId := childDevice.ParentId
- logDeviceId := ldMgr.deviceMgr.GetParentDeviceId(parentId)
+ parentID := childDevice.ParentId
+ logDeviceID := ldMgr.deviceMgr.GetParentDeviceID(parentID)
- log.Debugw("setupUNILogicalPorts", log.Fields{"logDeviceId": logDeviceId, "parentId": parentId})
+ log.Debugw("setupUNILogicalPorts", log.Fields{"logDeviceId": logDeviceID, "parentId": parentID})
- if parentId == "" || logDeviceId == "" {
+ if parentID == "" || logDeviceID == "" {
return errors.New("device-in-invalid-state")
}
- if agent := ldMgr.getLogicalDeviceAgent(logDeviceId); agent != nil {
+ if agent := ldMgr.getLogicalDeviceAgent(logDeviceID); agent != nil {
if err := agent.setupUNILogicalPorts(ctx, childDevice); err != nil {
return err
}
@@ -471,32 +462,32 @@
func (ldMgr *LogicalDeviceManager) deleteAllLogicalPorts(device *voltha.Device) error {
log.Debugw("deleteAllLogicalPorts", log.Fields{"deviceId": device.Id})
- var ldId *string
+ var ldID *string
var err error
//Get the logical device Id for this device
- if ldId, err = ldMgr.getLogicalDeviceId(device); err != nil {
+ if ldID, err = ldMgr.getLogicalDeviceID(device); err != nil {
log.Warnw("no-logical-device-found", log.Fields{"deviceId": device.Id, "error": err})
return err
}
- if agent := ldMgr.getLogicalDeviceAgent(*ldId); agent != nil {
+ if agent := ldMgr.getLogicalDeviceAgent(*ldID); agent != nil {
if err := agent.deleteAllLogicalPorts(device); err != nil {
return err
}
}
return nil
}
-func (ldMgr *LogicalDeviceManager) updatePortState(deviceId string, portNo uint32, state voltha.OperStatus_OperStatus) error {
- log.Debugw("updatePortState", log.Fields{"deviceId": deviceId, "state": state, "portNo": portNo})
+func (ldMgr *LogicalDeviceManager) updatePortState(deviceID string, portNo uint32, state voltha.OperStatus_OperStatus) error {
+ log.Debugw("updatePortState", log.Fields{"deviceId": deviceID, "state": state, "portNo": portNo})
- var ldId *string
+ var ldID *string
var err error
//Get the logical device Id for this device
- if ldId, err = ldMgr.getLogicalDeviceIdFromDeviceId(deviceId); err != nil {
- log.Warnw("no-logical-device-found", log.Fields{"deviceId": deviceId, "error": err})
+ if ldID, err = ldMgr.getLogicalDeviceIDFromDeviceID(deviceID); err != nil {
+ log.Warnw("no-logical-device-found", log.Fields{"deviceId": deviceID, "error": err})
return err
}
- if agent := ldMgr.getLogicalDeviceAgent(*ldId); agent != nil {
- if err := agent.updatePortState(deviceId, portNo, state); err != nil {
+ if agent := ldMgr.getLogicalDeviceAgent(*ldID); agent != nil {
+ if err := agent.updatePortState(deviceID, portNo, state); err != nil {
return err
}
}
@@ -506,14 +497,14 @@
func (ldMgr *LogicalDeviceManager) updatePortsState(device *voltha.Device, state voltha.AdminState_AdminState) error {
log.Debugw("updatePortsState", log.Fields{"deviceId": device.Id, "state": state, "current-data": device})
- var ldId *string
+ var ldID *string
var err error
//Get the logical device Id for this device
- if ldId, err = ldMgr.getLogicalDeviceId(device); err != nil {
+ if ldID, err = ldMgr.getLogicalDeviceID(device); err != nil {
log.Warnw("no-logical-device-found", log.Fields{"deviceId": device.Id, "error": err})
return err
}
- if agent := ldMgr.getLogicalDeviceAgent(*ldId); agent != nil {
+ if agent := ldMgr.getLogicalDeviceAgent(*ldID); agent != nil {
if err := agent.updatePortsState(device, state); err != nil {
return err
}
@@ -545,6 +536,7 @@
sendAPIResponse(ctx, ch, res)
}
+// ListLogicalDeviceMeters returns logical device meters
func (ldMgr *LogicalDeviceManager) ListLogicalDeviceMeters(ctx context.Context, id string) (*openflow_13.Meters, error) {
log.Debugw("ListLogicalDeviceMeters", log.Fields{"logicalDeviceId": id})
if agent := ldMgr.getLogicalDeviceAgent(id); agent != nil {
@@ -567,7 +559,6 @@
func (ldMgr *LogicalDeviceManager) enableLogicalPort(ctx context.Context, id *voltha.LogicalPortId, ch chan interface{}) {
log.Debugw("enableLogicalPort", log.Fields{"logicalDeviceId": id})
var res interface{}
-
if agent := ldMgr.getLogicalDeviceAgent(id.Id); agent != nil {
res = agent.enableLogicalPort(id.PortId)
log.Debugw("enableLogicalPort-result", log.Fields{"result": res})
@@ -580,7 +571,6 @@
func (ldMgr *LogicalDeviceManager) disableLogicalPort(ctx context.Context, id *voltha.LogicalPortId, ch chan interface{}) {
log.Debugw("disableLogicalPort", log.Fields{"logicalDeviceId": id})
var res interface{}
-
if agent := ldMgr.getLogicalDeviceAgent(id.Id); agent != nil {
res = agent.disableLogicalPort(id.PortId)
log.Debugw("disableLogicalPort-result", log.Fields{"result": res})
@@ -590,21 +580,12 @@
sendAPIResponse(ctx, ch, res)
}
-func (ldMgr *LogicalDeviceManager) packetOut(packetOut *openflow_13.PacketOut) {
- log.Debugw("packetOut", log.Fields{"logicalDeviceId": packetOut.Id})
- if agent := ldMgr.getLogicalDeviceAgent(packetOut.Id); agent != nil {
- agent.packetOut(packetOut.PacketOut)
+func (ldMgr *LogicalDeviceManager) packetIn(logicalDeviceID string, port uint32, transactionID string, packet []byte) error {
+ log.Debugw("packetIn", log.Fields{"logicalDeviceId": logicalDeviceID, "port": port})
+ if agent := ldMgr.getLogicalDeviceAgent(logicalDeviceID); agent != nil {
+ agent.packetIn(port, transactionID, packet)
} else {
- log.Error("logical-device-not-exist", log.Fields{"logicalDeviceId": packetOut.Id})
- }
-}
-
-func (ldMgr *LogicalDeviceManager) packetIn(logicalDeviceId string, port uint32, transactionId string, packet []byte) error {
- log.Debugw("packetIn", log.Fields{"logicalDeviceId": logicalDeviceId, "port": port})
- if agent := ldMgr.getLogicalDeviceAgent(logicalDeviceId); agent != nil {
- agent.packetIn(port, transactionId, packet)
- } else {
- log.Error("logical-device-not-exist", log.Fields{"logicalDeviceId": logicalDeviceId})
+ log.Error("logical-device-not-exist", log.Fields{"logicalDeviceId": logicalDeviceID})
}
return nil
}