VOL-1900 lint warning fixes rw_core
Change-Id: Icaa84d7ce24163da90c91ff2babcbb78ff4e9141
diff --git a/rw_core/core/device_manager.go b/rw_core/core/device_manager.go
index ce7ecd9..9e4956e 100755
--- a/rw_core/core/device_manager.go
+++ b/rw_core/core/device_manager.go
@@ -13,11 +13,16 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
+
package core
import (
"context"
"errors"
+ "reflect"
+ "runtime"
+ "sync"
+
"github.com/opencord/voltha-go/db/model"
"github.com/opencord/voltha-go/rw_core/utils"
"github.com/opencord/voltha-lib-go/v2/pkg/kafka"
@@ -28,11 +33,9 @@
"github.com/opencord/voltha-protos/v2/go/voltha"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
- "reflect"
- "runtime"
- "sync"
)
+// DeviceManager represent device manager attributes
type DeviceManager struct {
deviceAgents sync.Map
rootDevices map[string]bool
@@ -44,7 +47,7 @@
kafkaICProxy *kafka.InterContainerProxy
stateTransitions *TransitionMap
clusterDataProxy *model.Proxy
- coreInstanceId string
+ coreInstanceID string
exitChannel chan int
defaultTimeout int64
devicesLoadingLock sync.RWMutex
@@ -58,7 +61,7 @@
deviceMgr.rootDevices = make(map[string]bool)
deviceMgr.kafkaICProxy = core.kmp
deviceMgr.adapterProxy = NewAdapterProxy(core.kmp, core.config.CorePairTopic)
- deviceMgr.coreInstanceId = core.instanceId
+ deviceMgr.coreInstanceID = core.instanceID
deviceMgr.clusterDataProxy = core.clusterDataProxy
deviceMgr.adapterMgr = core.adapterMgr
deviceMgr.lockRootDeviceMap = sync.RWMutex{}
@@ -96,41 +99,46 @@
}
func (dMgr *DeviceManager) addDeviceAgentToMap(agent *DeviceAgent) {
- if _, exist := dMgr.deviceAgents.Load(agent.deviceId); !exist {
- dMgr.deviceAgents.Store(agent.deviceId, agent)
+ if _, exist := dMgr.deviceAgents.Load(agent.deviceID); !exist {
+ dMgr.deviceAgents.Store(agent.deviceID, agent)
}
dMgr.lockRootDeviceMap.Lock()
defer dMgr.lockRootDeviceMap.Unlock()
- dMgr.rootDevices[agent.deviceId] = agent.isRootdevice
+ dMgr.rootDevices[agent.deviceID] = agent.isRootdevice
}
func (dMgr *DeviceManager) deleteDeviceAgentFromMap(agent *DeviceAgent) {
- dMgr.deviceAgents.Delete(agent.deviceId)
+ dMgr.deviceAgents.Delete(agent.deviceID)
dMgr.lockRootDeviceMap.Lock()
defer dMgr.lockRootDeviceMap.Unlock()
- delete(dMgr.rootDevices, agent.deviceId)
+ delete(dMgr.rootDevices, agent.deviceID)
}
// getDeviceAgent returns the agent managing the device. If the device is not in memory, it will loads it, if it exists
-func (dMgr *DeviceManager) getDeviceAgent(deviceId string) *DeviceAgent {
- if agent, ok := dMgr.deviceAgents.Load(deviceId); ok {
+func (dMgr *DeviceManager) getDeviceAgent(deviceID string) *DeviceAgent {
+ agent, ok := dMgr.deviceAgents.Load(deviceID)
+ if ok {
return agent.(*DeviceAgent)
- } else {
- // Try to load into memory - loading will also create the device agent and set the device ownership
- if err := dMgr.load(deviceId); err == nil {
- if agent, ok = dMgr.deviceAgents.Load(deviceId); !ok {
- return nil
- } else {
- // Register this device for ownership tracking
- go dMgr.core.deviceOwnership.OwnedByMe(&utils.DeviceID{Id: deviceId})
- return agent.(*DeviceAgent)
- }
- } else {
- //TODO: Change the return params to return an error as well
- log.Errorw("loading-device-failed", log.Fields{"deviceId": deviceId, "error": err})
- }
}
+ // Try to load into memory - loading will also create the device agent and set the device ownership
+ err := dMgr.load(deviceID)
+ if err == nil {
+ agent, ok = dMgr.deviceAgents.Load(deviceID)
+ if !ok {
+ return nil
+ }
+ // Register this device for ownership tracking
+ go func() {
+ _, err = dMgr.core.deviceOwnership.OwnedByMe(&utils.DeviceID{ID: deviceID})
+ if err != nil {
+ log.Errorw("unable-to-find-core-instance-active-owns-this-device", log.Fields{"error": err})
+ }
+ }()
+ return agent.(*DeviceAgent)
+ }
+ //TODO: Change the return params to return an error as well
+ log.Errorw("loading-device-failed", log.Fields{"deviceId": deviceID, "error": err})
return nil
}
@@ -223,27 +231,34 @@
func (dMgr *DeviceManager) stopManagingDevice(id string) {
log.Infow("stopManagingDevice", log.Fields{"deviceId": id})
if dMgr.IsDeviceInCache(id) { // Proceed only if an agent is present for this device
- if root, _ := dMgr.IsRootDevice(id); root == true {
+ if root, _ := dMgr.IsRootDevice(id); root {
// stop managing the logical device
- ldeviceId := dMgr.logicalDeviceMgr.stopManagingLogicalDeviceWithDeviceId(id)
- if ldeviceId != "" { // Can happen if logical device agent was already stopped
- dMgr.core.deviceOwnership.AbandonDevice(ldeviceId)
+ ldeviceID := dMgr.logicalDeviceMgr.stopManagingLogicalDeviceWithDeviceID(id)
+ if ldeviceID != "" { // Can happen if logical device agent was already stopped
+ err := dMgr.core.deviceOwnership.AbandonDevice(ldeviceID)
+ if err != nil {
+ log.Errorw("unable-to-abandon-the-device", log.Fields{"error": err})
+ }
}
// stop managing the child devices
- childDeviceIds := dMgr.getAllDeviceIdsWithDeviceParentId(id)
- for _, cId := range childDeviceIds {
- dMgr.stopManagingDevice(cId)
+ childDeviceIds := dMgr.getAllDeviceIdsWithDeviceParentID(id)
+ for _, cID := range childDeviceIds {
+ dMgr.stopManagingDevice(cID)
}
}
if agent := dMgr.getDeviceAgent(id); agent != nil {
- agent.stop(nil)
+ agent.stop(context.TODO())
dMgr.deleteDeviceAgentFromMap(agent)
// Abandon the device ownership
- dMgr.core.deviceOwnership.AbandonDevice(id)
+ err := dMgr.core.deviceOwnership.AbandonDevice(id)
+ if err != nil {
+ log.Errorw("unable-to-abandon-device", log.Fields{"error": err})
+ }
}
}
}
+// RunPostDeviceDelete removes any reference of this device
func (dMgr *DeviceManager) RunPostDeviceDelete(cDevice *voltha.Device) error {
log.Infow("RunPostDeviceDelete", log.Fields{"deviceId": cDevice.Id})
dMgr.stopManagingDevice(cDevice.Id)
@@ -259,13 +274,14 @@
return nil, status.Errorf(codes.NotFound, "%s", id)
}
-func (dMgr *DeviceManager) GetChildDevice(parentDeviceId string, serialNumber string, onuId int64, parentPortNo int64) (*voltha.Device, error) {
- log.Debugw("GetChildDevice", log.Fields{"parentDeviceid": parentDeviceId, "serialNumber": serialNumber,
- "parentPortNo": parentPortNo, "onuId": onuId})
+// GetChildDevice will return a device, either from memory or from the dB, if present
+func (dMgr *DeviceManager) GetChildDevice(parentDeviceID string, serialNumber string, onuID int64, parentPortNo int64) (*voltha.Device, error) {
+ log.Debugw("GetChildDevice", log.Fields{"parentDeviceid": parentDeviceID, "serialNumber": serialNumber,
+ "parentPortNo": parentPortNo, "onuId": onuID})
var parentDevice *voltha.Device
var err error
- if parentDevice, err = dMgr.GetDevice(parentDeviceId); err != nil {
+ if parentDevice, err = dMgr.GetDevice(parentDeviceID); err != nil {
return nil, status.Errorf(codes.Aborted, "%s", err.Error())
}
var childDeviceIds []string
@@ -273,20 +289,20 @@
return nil, status.Errorf(codes.Aborted, "%s", err.Error())
}
if len(childDeviceIds) == 0 {
- log.Debugw("no-child-devices", log.Fields{"parentDeviceId": parentDevice.Id, "serialNumber": serialNumber, "onuId": onuId})
- return nil, status.Errorf(codes.NotFound, "%s", parentDeviceId)
+ log.Debugw("no-child-devices", log.Fields{"parentDeviceId": parentDevice.Id, "serialNumber": serialNumber, "onuId": onuID})
+ return nil, status.Errorf(codes.NotFound, "%s", parentDeviceID)
}
var foundChildDevice *voltha.Device
- for _, childDeviceId := range childDeviceIds {
- found := false
- if searchDevice, err := dMgr.GetDevice(childDeviceId); err == nil {
+ for _, childDeviceID := range childDeviceIds {
+ var found bool
+ if searchDevice, err := dMgr.GetDevice(childDeviceID); err == nil {
- foundOnuId := false
- if searchDevice.ProxyAddress.OnuId == uint32(onuId) {
+ foundOnuID := false
+ if searchDevice.ProxyAddress.OnuId == uint32(onuID) {
if searchDevice.ParentPortNo == uint32(parentPortNo) {
- log.Debugw("found-child-by-onuid", log.Fields{"parentDeviceId": parentDevice.Id, "onuId": onuId})
- foundOnuId = true
+ log.Debugw("found-child-by-onuid", log.Fields{"parentDeviceId": parentDevice.Id, "onuId": onuID})
+ foundOnuID = true
}
}
@@ -298,13 +314,13 @@
// if both onuId and serialNumber are provided both must be true for the device to be found
// otherwise whichever one found a match is good enough
- if onuId > 0 && serialNumber != "" {
- found = foundOnuId && foundSerialNumber
+ if onuID > 0 && serialNumber != "" {
+ found = foundOnuID && foundSerialNumber
} else {
- found = foundOnuId || foundSerialNumber
+ found = foundOnuID || foundSerialNumber
}
- if found == true {
+ if found {
foundChildDevice = searchDevice
break
}
@@ -317,10 +333,11 @@
}
log.Warnw("child-device-not-found", log.Fields{"parentDeviceId": parentDevice.Id,
- "serialNumber": serialNumber, "onuId": onuId, "parentPortNo": parentPortNo})
- return nil, status.Errorf(codes.NotFound, "%s", parentDeviceId)
+ "serialNumber": serialNumber, "onuId": onuID, "parentPortNo": parentPortNo})
+ return nil, status.Errorf(codes.NotFound, "%s", parentDeviceID)
}
+// GetChildDeviceWithProxyAddress will return a device based on proxy address
func (dMgr *DeviceManager) GetChildDeviceWithProxyAddress(proxyAddress *voltha.Device_ProxyAddress) (*voltha.Device, error) {
log.Debugw("GetChildDeviceWithProxyAddress", log.Fields{"proxyAddress": proxyAddress})
@@ -339,8 +356,8 @@
}
var foundChildDevice *voltha.Device
- for _, childDeviceId := range childDeviceIds {
- if searchDevice, err := dMgr.GetDevice(childDeviceId); err == nil {
+ for _, childDeviceID := range childDeviceIds {
+ if searchDevice, err := dMgr.GetDevice(childDeviceID); err == nil {
if searchDevice.ProxyAddress == proxyAddress {
foundChildDevice = searchDevice
break
@@ -357,11 +374,13 @@
return nil, status.Errorf(codes.NotFound, "%s", proxyAddress)
}
+// IsDeviceInCache returns true if device is found in the map
func (dMgr *DeviceManager) IsDeviceInCache(id string) bool {
_, exist := dMgr.deviceAgents.Load(id)
return exist
}
+// IsRootDevice returns true if root device is found in the map
func (dMgr *DeviceManager) IsRootDevice(id string) (bool, error) {
dMgr.lockRootDeviceMap.RLock()
defer dMgr.lockRootDeviceMap.RUnlock()
@@ -381,9 +400,9 @@
if !dMgr.IsDeviceInCache(device.(*voltha.Device).Id) {
log.Debugw("loading-device-from-Model", log.Fields{"id": device.(*voltha.Device).Id})
agent := newDeviceAgent(dMgr.adapterProxy, device.(*voltha.Device), dMgr, dMgr.clusterDataProxy, dMgr.defaultTimeout)
- if _, err := agent.start(nil, nil); err != nil {
+ if _, err := agent.start(context.TODO(), nil); err != nil {
log.Warnw("failure-starting-agent", log.Fields{"deviceId": device.(*voltha.Device).Id})
- agent.stop(nil)
+ agent.stop(context.TODO())
} else {
dMgr.addDeviceAgentToMap(agent)
}
@@ -415,47 +434,47 @@
}
//getDeviceFromModelretrieves the device data from the model.
-func (dMgr *DeviceManager) getDeviceFromModel(deviceId string) (*voltha.Device, error) {
- if device := dMgr.clusterDataProxy.Get(context.Background(), "/devices/"+deviceId, 0, false, ""); device != nil {
+func (dMgr *DeviceManager) getDeviceFromModel(deviceID string) (*voltha.Device, error) {
+ if device := dMgr.clusterDataProxy.Get(context.Background(), "/devices/"+deviceID, 0, false, ""); device != nil {
if d, ok := device.(*voltha.Device); ok {
return d, nil
}
}
- return nil, status.Error(codes.NotFound, deviceId)
+ return nil, status.Error(codes.NotFound, deviceID)
}
-// loadDevice loads the deviceId in memory, if not present
-func (dMgr *DeviceManager) loadDevice(deviceId string) (*DeviceAgent, error) {
- if deviceId == "" {
+// loadDevice loads the deviceID in memory, if not present
+func (dMgr *DeviceManager) loadDevice(deviceID string) (*DeviceAgent, error) {
+ if deviceID == "" {
return nil, status.Error(codes.InvalidArgument, "deviceId empty")
}
var err error
var device *voltha.Device
dMgr.devicesLoadingLock.Lock()
- if _, exist := dMgr.deviceLoadingInProgress[deviceId]; !exist {
- if !dMgr.IsDeviceInCache(deviceId) {
- dMgr.deviceLoadingInProgress[deviceId] = []chan int{make(chan int, 1)}
+ if _, exist := dMgr.deviceLoadingInProgress[deviceID]; !exist {
+ if !dMgr.IsDeviceInCache(deviceID) {
+ dMgr.deviceLoadingInProgress[deviceID] = []chan int{make(chan int, 1)}
dMgr.devicesLoadingLock.Unlock()
// Proceed with the loading only if the device exist in the Model (could have been deleted)
- if device, err = dMgr.getDeviceFromModel(deviceId); err == nil {
- log.Debugw("loading-device", log.Fields{"deviceId": deviceId})
+ if device, err = dMgr.getDeviceFromModel(deviceID); err == nil {
+ log.Debugw("loading-device", log.Fields{"deviceId": deviceID})
agent := newDeviceAgent(dMgr.adapterProxy, device, dMgr, dMgr.clusterDataProxy, dMgr.defaultTimeout)
- if _, err = agent.start(nil, nil); err != nil {
- log.Warnw("Failure loading device", log.Fields{"deviceId": deviceId, "error": err})
- agent.stop(nil)
+ if _, err = agent.start(context.TODO(), nil); err != nil {
+ log.Warnw("Failure loading device", log.Fields{"deviceId": deviceID, "error": err})
+ agent.stop(context.TODO())
} else {
dMgr.addDeviceAgentToMap(agent)
}
} else {
- log.Debugw("Device not in model", log.Fields{"deviceId": deviceId})
+ log.Debugw("Device not in model", log.Fields{"deviceId": deviceID})
}
// announce completion of task to any number of waiting channels
dMgr.devicesLoadingLock.Lock()
- if v, ok := dMgr.deviceLoadingInProgress[deviceId]; ok {
+ if v, ok := dMgr.deviceLoadingInProgress[deviceID]; ok {
for _, ch := range v {
close(ch)
}
- delete(dMgr.deviceLoadingInProgress, deviceId)
+ delete(dMgr.deviceLoadingInProgress, deviceID)
}
dMgr.devicesLoadingLock.Unlock()
} else {
@@ -463,15 +482,15 @@
}
} else {
ch := make(chan int, 1)
- dMgr.deviceLoadingInProgress[deviceId] = append(dMgr.deviceLoadingInProgress[deviceId], ch)
+ dMgr.deviceLoadingInProgress[deviceID] = append(dMgr.deviceLoadingInProgress[deviceID], ch)
dMgr.devicesLoadingLock.Unlock()
// Wait for the channel to be closed, implying the process loading this device is done.
<-ch
}
- if agent, ok := dMgr.deviceAgents.Load(deviceId); ok {
+ if agent, ok := dMgr.deviceAgents.Load(deviceID); ok {
return agent.(*DeviceAgent), nil
}
- return nil, status.Errorf(codes.Aborted, "Error loading device %s", deviceId)
+ return nil, status.Errorf(codes.Aborted, "Error loading device %s", deviceID)
}
// loadRootDeviceParentAndChildren loads the children and parents of a root device in memory
@@ -489,9 +508,9 @@
}
// Load all child devices, if needed
if childDeviceIds, err := dMgr.getAllChildDeviceIds(device); err == nil {
- for _, childDeviceId := range childDeviceIds {
- if _, err := dMgr.loadDevice(childDeviceId); err != nil {
- log.Warnw("failure-loading-device", log.Fields{"deviceId": childDeviceId, "error": err})
+ for _, childDeviceID := range childDeviceIds {
+ if _, err := dMgr.loadDevice(childDeviceID); err != nil {
+ log.Warnw("failure-loading-device", log.Fields{"deviceId": childDeviceID, "error": err})
return err
}
}
@@ -507,12 +526,12 @@
// in memory is for improved performance. It is not imperative that a device needs to be in memory when a request
// acting on the device is received by the core. In such a scenario, the Core will load the device in memory first
// and the proceed with the request.
-func (dMgr *DeviceManager) load(deviceId string) error {
+func (dMgr *DeviceManager) load(deviceID string) error {
log.Debug("load...")
// First load the device - this may fail in case the device was deleted intentionally by the other core
var dAgent *DeviceAgent
var err error
- if dAgent, err = dMgr.loadDevice(deviceId); err != nil {
+ if dAgent, err = dMgr.loadDevice(deviceID); err != nil {
return err
}
// Get the loaded device details
@@ -530,10 +549,10 @@
if device.Root {
// Load all children as well as the parent of this device (logical_device)
if err := dMgr.loadRootDeviceParentAndChildren(device); err != nil {
- log.Warnw("failure-loading-device-parent-and-children", log.Fields{"deviceId": deviceId})
+ log.Warnw("failure-loading-device-parent-and-children", log.Fields{"deviceId": deviceID})
return err
}
- log.Debugw("successfully-loaded-parent-and-children", log.Fields{"deviceId": deviceId})
+ log.Debugw("successfully-loaded-parent-and-children", log.Fields{"deviceId": deviceID})
} else {
// Scenario B - use the parentId of that device (root device) to trigger the loading
if device.ParentId != "" {
@@ -563,7 +582,7 @@
if err = dMgr.load(id.Id); err != nil {
log.Warnw("failure-reconciling-device", log.Fields{"deviceId": id.Id, "error": err})
} else {
- reconciled += 1
+ reconciled++
}
}
if toReconcile != reconciled {
@@ -595,8 +614,8 @@
}
responses := make([]utils.Response, 0)
- for _, rootDeviceId := range rootDeviceIds {
- if rootDevice, _ := dMgr.getDeviceFromModel(rootDeviceId); rootDevice != nil {
+ for _, rootDeviceID := range rootDeviceIds {
+ if rootDevice, _ := dMgr.getDeviceFromModel(rootDeviceID); rootDevice != nil {
if rootDevice.Adapter == adapter.Id {
if isOkToReconcile(rootDevice) {
log.Debugw("reconciling-root-device", log.Fields{"rootId": rootDevice.Id})
@@ -641,7 +660,7 @@
func (dMgr *DeviceManager) sendReconcileDeviceRequest(device *voltha.Device) utils.Response {
// Send a reconcile request to the adapter. Since this Core may not be managing this device then there is no
// point of creating a device agent (if the device is not being managed by this Core) before sending the request
- // to the adapter. We will therefore bypass the adapter adapter and send the request directly to teh adapter via
+ // to the adapter. We will therefore bypass the adapter adapter and send the request directly to the adapter via
// the adapter_proxy.
response := utils.NewResponse()
go func(device *voltha.Device) {
@@ -655,8 +674,8 @@
return response
}
-func (dMgr *DeviceManager) reconcileChildDevices(parentDeviceId string) error {
- if parentDevice, _ := dMgr.getDeviceFromModel(parentDeviceId); parentDevice != nil {
+func (dMgr *DeviceManager) reconcileChildDevices(parentDeviceID string) error {
+ if parentDevice, _ := dMgr.getDeviceFromModel(parentDeviceID); parentDevice != nil {
responses := make([]utils.Response, 0)
for _, port := range parentDevice.Ports {
for _, peer := range port.Peers {
@@ -681,13 +700,14 @@
return status.Errorf(codes.NotFound, "%s", device.Id)
}
-func (dMgr *DeviceManager) addPort(deviceId string, port *voltha.Port) error {
- if agent := dMgr.getDeviceAgent(deviceId); agent != nil {
+func (dMgr *DeviceManager) addPort(deviceID string, port *voltha.Port) error {
+ agent := dMgr.getDeviceAgent(deviceID)
+ if agent != nil {
if err := agent.addPort(port); err != nil {
return err
}
// Setup peer ports
- meAsPeer := &voltha.Port_PeerPort{DeviceId: deviceId, PortNo: port.PortNo}
+ meAsPeer := &voltha.Port_PeerPort{DeviceId: deviceID, PortNo: port.PortNo}
for _, peerPort := range port.Peers {
if agent := dMgr.getDeviceAgent(peerPort.DeviceId); agent != nil {
if err := agent.addPeerPort(meAsPeer); err != nil {
@@ -699,48 +719,52 @@
// Notify the logical device manager to setup a logical port, if needed. If the added port is an NNI or UNI
// then a logical port will be added to the logical device and the device graph generated. If the port is a
// PON port then only the device graph will be generated.
- if device, err := dMgr.GetDevice(deviceId); err == nil {
- go dMgr.logicalDeviceMgr.updateLogicalPort(device, port)
+ if device, err := dMgr.GetDevice(deviceID); err == nil {
+ go func() {
+ err = dMgr.logicalDeviceMgr.updateLogicalPort(device, port)
+ if err != nil {
+ log.Errorw("unable-to-update-logical-port", log.Fields{"error": err})
+ }
+ }()
} else {
- log.Errorw("failed-to-retrieve-device", log.Fields{"deviceId": deviceId})
+ log.Errorw("failed-to-retrieve-device", log.Fields{"deviceId": deviceID})
return err
}
return nil
- } else {
- return status.Errorf(codes.NotFound, "%s", deviceId)
}
+ return status.Errorf(codes.NotFound, "%s", deviceID)
}
-func (dMgr *DeviceManager) deletePeerPorts(fromDeviceId string, deviceId string) error {
- log.Debugw("deletePeerPorts", log.Fields{"fromDeviceId": fromDeviceId, "deviceid": deviceId})
- if agent := dMgr.getDeviceAgent(fromDeviceId); agent != nil {
- return agent.deletePeerPorts(deviceId)
+func (dMgr *DeviceManager) deletePeerPorts(fromDeviceID string, deviceID string) error {
+ log.Debugw("deletePeerPorts", log.Fields{"fromDeviceId": fromDeviceID, "deviceid": deviceID})
+ if agent := dMgr.getDeviceAgent(fromDeviceID); agent != nil {
+ return agent.deletePeerPorts(deviceID)
}
- return status.Errorf(codes.NotFound, "%s", deviceId)
+ return status.Errorf(codes.NotFound, "%s", deviceID)
}
-func (dMgr *DeviceManager) addFlowsAndGroups(deviceId string, flows []*ofp.OfpFlowStats, groups []*ofp.OfpGroupEntry, flowMetadata *voltha.FlowMetadata) error {
- log.Debugw("addFlowsAndGroups", log.Fields{"deviceid": deviceId, "flowMetadata": flowMetadata})
- if agent := dMgr.getDeviceAgent(deviceId); agent != nil {
+func (dMgr *DeviceManager) addFlowsAndGroups(deviceID string, flows []*ofp.OfpFlowStats, groups []*ofp.OfpGroupEntry, flowMetadata *voltha.FlowMetadata) error {
+ log.Debugw("addFlowsAndGroups", log.Fields{"deviceid": deviceID, "flowMetadata": flowMetadata})
+ if agent := dMgr.getDeviceAgent(deviceID); agent != nil {
return agent.addFlowsAndGroups(flows, groups, flowMetadata)
}
- return status.Errorf(codes.NotFound, "%s", deviceId)
+ return status.Errorf(codes.NotFound, "%s", deviceID)
}
-func (dMgr *DeviceManager) deleteFlowsAndGroups(deviceId string, flows []*ofp.OfpFlowStats, groups []*ofp.OfpGroupEntry, flowMetadata *voltha.FlowMetadata) error {
- log.Debugw("deleteFlowsAndGroups", log.Fields{"deviceid": deviceId})
- if agent := dMgr.getDeviceAgent(deviceId); agent != nil {
+func (dMgr *DeviceManager) deleteFlowsAndGroups(deviceID string, flows []*ofp.OfpFlowStats, groups []*ofp.OfpGroupEntry, flowMetadata *voltha.FlowMetadata) error {
+ log.Debugw("deleteFlowsAndGroups", log.Fields{"deviceid": deviceID})
+ if agent := dMgr.getDeviceAgent(deviceID); agent != nil {
return agent.deleteFlowsAndGroups(flows, groups, flowMetadata)
}
- return status.Errorf(codes.NotFound, "%s", deviceId)
+ return status.Errorf(codes.NotFound, "%s", deviceID)
}
-func (dMgr *DeviceManager) updateFlowsAndGroups(deviceId string, flows []*ofp.OfpFlowStats, groups []*ofp.OfpGroupEntry, flowMetadata *voltha.FlowMetadata) error {
- log.Debugw("updateFlowsAndGroups", log.Fields{"deviceid": deviceId})
- if agent := dMgr.getDeviceAgent(deviceId); agent != nil {
+func (dMgr *DeviceManager) updateFlowsAndGroups(deviceID string, flows []*ofp.OfpFlowStats, groups []*ofp.OfpGroupEntry, flowMetadata *voltha.FlowMetadata) error {
+ log.Debugw("updateFlowsAndGroups", log.Fields{"deviceid": deviceID})
+ if agent := dMgr.getDeviceAgent(deviceID); agent != nil {
return agent.updateFlowsAndGroups(flows, groups, flowMetadata)
}
- return status.Errorf(codes.NotFound, "%s", deviceId)
+ return status.Errorf(codes.NotFound, "%s", deviceID)
}
// updatePmConfigs updates the PM configs. This is executed when the northbound gRPC API is invoked, typically
@@ -758,60 +782,60 @@
}
// initPmConfigs initialize the pm configs as defined by the adapter.
-func (dMgr *DeviceManager) initPmConfigs(deviceId string, pmConfigs *voltha.PmConfigs) error {
+func (dMgr *DeviceManager) initPmConfigs(deviceID string, pmConfigs *voltha.PmConfigs) error {
if pmConfigs.Id == "" {
return status.Errorf(codes.FailedPrecondition, "invalid-device-Id")
}
- if agent := dMgr.getDeviceAgent(deviceId); agent != nil {
+ if agent := dMgr.getDeviceAgent(deviceID); agent != nil {
return agent.initPmConfigs(pmConfigs)
}
- return status.Errorf(codes.NotFound, "%s", deviceId)
+ return status.Errorf(codes.NotFound, "%s", deviceID)
}
-func (dMgr *DeviceManager) listPmConfigs(ctx context.Context, deviceId string) (*voltha.PmConfigs, error) {
- if agent := dMgr.getDeviceAgent(deviceId); agent != nil {
+func (dMgr *DeviceManager) listPmConfigs(ctx context.Context, deviceID string) (*voltha.PmConfigs, error) {
+ if agent := dMgr.getDeviceAgent(deviceID); agent != nil {
return agent.listPmConfigs(ctx)
}
- return nil, status.Errorf(codes.NotFound, "%s", deviceId)
+ return nil, status.Errorf(codes.NotFound, "%s", deviceID)
}
-func (dMgr *DeviceManager) getSwitchCapability(ctx context.Context, deviceId string) (*ic.SwitchCapability, error) {
- log.Debugw("getSwitchCapability", log.Fields{"deviceid": deviceId})
- if agent := dMgr.getDeviceAgent(deviceId); agent != nil {
+func (dMgr *DeviceManager) getSwitchCapability(ctx context.Context, deviceID string) (*ic.SwitchCapability, error) {
+ log.Debugw("getSwitchCapability", log.Fields{"deviceid": deviceID})
+ if agent := dMgr.getDeviceAgent(deviceID); agent != nil {
return agent.getSwitchCapability(ctx)
}
- return nil, status.Errorf(codes.NotFound, "%s", deviceId)
+ return nil, status.Errorf(codes.NotFound, "%s", deviceID)
}
-func (dMgr *DeviceManager) getPorts(ctx context.Context, deviceId string, portType voltha.Port_PortType) (*voltha.Ports, error) {
- log.Debugw("getPorts", log.Fields{"deviceid": deviceId, "portType": portType})
- if agent := dMgr.getDeviceAgent(deviceId); agent != nil {
+func (dMgr *DeviceManager) getPorts(ctx context.Context, deviceID string, portType voltha.Port_PortType) (*voltha.Ports, error) {
+ log.Debugw("getPorts", log.Fields{"deviceid": deviceID, "portType": portType})
+ if agent := dMgr.getDeviceAgent(deviceID); agent != nil {
return agent.getPorts(ctx, portType), nil
}
- return nil, status.Errorf(codes.NotFound, "%s", deviceId)
+ return nil, status.Errorf(codes.NotFound, "%s", deviceID)
}
-func (dMgr *DeviceManager) getPortCapability(ctx context.Context, deviceId string, portNo uint32) (*ic.PortCapability, error) {
- log.Debugw("getPortCapability", log.Fields{"deviceid": deviceId})
- if agent := dMgr.getDeviceAgent(deviceId); agent != nil {
+func (dMgr *DeviceManager) getPortCapability(ctx context.Context, deviceID string, portNo uint32) (*ic.PortCapability, error) {
+ log.Debugw("getPortCapability", log.Fields{"deviceid": deviceID})
+ if agent := dMgr.getDeviceAgent(deviceID); agent != nil {
return agent.getPortCapability(ctx, portNo)
}
- return nil, status.Errorf(codes.NotFound, "%s", deviceId)
+ return nil, status.Errorf(codes.NotFound, "%s", deviceID)
}
-func (dMgr *DeviceManager) updateDeviceStatus(deviceId string, operStatus voltha.OperStatus_OperStatus, connStatus voltha.ConnectStatus_ConnectStatus) error {
- log.Debugw("updateDeviceStatus", log.Fields{"deviceid": deviceId, "operStatus": operStatus, "connStatus": connStatus})
- if agent := dMgr.getDeviceAgent(deviceId); agent != nil {
+func (dMgr *DeviceManager) updateDeviceStatus(deviceID string, operStatus voltha.OperStatus_OperStatus, connStatus voltha.ConnectStatus_ConnectStatus) error {
+ log.Debugw("updateDeviceStatus", log.Fields{"deviceid": deviceID, "operStatus": operStatus, "connStatus": connStatus})
+ if agent := dMgr.getDeviceAgent(deviceID); agent != nil {
return agent.updateDeviceStatus(operStatus, connStatus)
}
- return status.Errorf(codes.NotFound, "%s", deviceId)
+ return status.Errorf(codes.NotFound, "%s", deviceID)
}
-func (dMgr *DeviceManager) updateChildrenStatus(deviceId string, operStatus voltha.OperStatus_OperStatus, connStatus voltha.ConnectStatus_ConnectStatus) error {
- log.Debugw("updateChildrenStatus", log.Fields{"parentDeviceid": deviceId, "operStatus": operStatus, "connStatus": connStatus})
+func (dMgr *DeviceManager) updateChildrenStatus(deviceID string, operStatus voltha.OperStatus_OperStatus, connStatus voltha.ConnectStatus_ConnectStatus) error {
+ log.Debugw("updateChildrenStatus", log.Fields{"parentDeviceid": deviceID, "operStatus": operStatus, "connStatus": connStatus})
var parentDevice *voltha.Device
var err error
- if parentDevice, err = dMgr.GetDevice(deviceId); err != nil {
+ if parentDevice, err = dMgr.GetDevice(deviceID); err != nil {
return status.Errorf(codes.Aborted, "%s", err.Error())
}
var childDeviceIds []string
@@ -821,98 +845,108 @@
if len(childDeviceIds) == 0 {
log.Debugw("no-child-device", log.Fields{"parentDeviceId": parentDevice.Id})
}
- for _, childDeviceId := range childDeviceIds {
- if agent := dMgr.getDeviceAgent(childDeviceId); agent != nil {
+ for _, childDeviceID := range childDeviceIds {
+ if agent := dMgr.getDeviceAgent(childDeviceID); agent != nil {
if err = agent.updateDeviceStatus(operStatus, connStatus); err != nil {
- return status.Errorf(codes.Aborted, "childDevice:%s, error:%s", childDeviceId, err.Error())
+ return status.Errorf(codes.Aborted, "childDevice:%s, error:%s", childDeviceID, err.Error())
}
}
}
return nil
}
-func (dMgr *DeviceManager) updatePortState(deviceId string, portType voltha.Port_PortType, portNo uint32, operStatus voltha.OperStatus_OperStatus) error {
- log.Debugw("updatePortState", log.Fields{"deviceid": deviceId, "portType": portType, "portNo": portNo, "operStatus": operStatus})
- if agent := dMgr.getDeviceAgent(deviceId); agent != nil {
+func (dMgr *DeviceManager) updatePortState(deviceID string, portType voltha.Port_PortType, portNo uint32, operStatus voltha.OperStatus_OperStatus) error {
+ log.Debugw("updatePortState", log.Fields{"deviceid": deviceID, "portType": portType, "portNo": portNo, "operStatus": operStatus})
+ if agent := dMgr.getDeviceAgent(deviceID); agent != nil {
if err := agent.updatePortState(portType, portNo, operStatus); err != nil {
- log.Errorw("updating-port-state-failed", log.Fields{"deviceid": deviceId, "portNo": portNo, "error": err})
+ log.Errorw("updating-port-state-failed", log.Fields{"deviceid": deviceID, "portNo": portNo, "error": err})
return err
}
// Notify the logical device manager to change the port state
- go dMgr.logicalDeviceMgr.updatePortState(deviceId, portNo, operStatus)
+ go func() {
+ err := dMgr.logicalDeviceMgr.updatePortState(deviceID, portNo, operStatus)
+ if err != nil {
+ log.Errorw("unable-to-update-port-state", log.Fields{"error": err})
+ }
+ }()
}
- return status.Errorf(codes.NotFound, "%s", deviceId)
+ return status.Errorf(codes.NotFound, "%s", deviceID)
}
-func (dMgr *DeviceManager) deleteAllPorts(deviceId string) error {
- log.Debugw("DeleteAllPorts", log.Fields{"deviceid": deviceId})
- if agent := dMgr.getDeviceAgent(deviceId); agent != nil {
+func (dMgr *DeviceManager) deleteAllPorts(deviceID string) error {
+ log.Debugw("DeleteAllPorts", log.Fields{"deviceid": deviceID})
+ if agent := dMgr.getDeviceAgent(deviceID); agent != nil {
if err := agent.deleteAllPorts(); err != nil {
return err
}
// Notify the logical device manager to remove all logical ports, if needed.
// At this stage the device itself may gave been deleted already at a deleteAllPorts
// typically is part of a device deletion phase.
- if device, err := dMgr.GetDevice(deviceId); err == nil {
- go dMgr.logicalDeviceMgr.deleteAllLogicalPorts(device)
+ if device, err := dMgr.GetDevice(deviceID); err == nil {
+ go func() {
+ err = dMgr.logicalDeviceMgr.deleteAllLogicalPorts(device)
+ if err != nil {
+ log.Errorw("unable-to-delete-logical-ports", log.Fields{"error": err})
+ }
+ }()
} else {
- log.Warnw("failed-to-retrieve-device", log.Fields{"deviceId": deviceId})
+ log.Warnw("failed-to-retrieve-device", log.Fields{"deviceId": deviceID})
return err
}
return nil
}
- return status.Errorf(codes.NotFound, "%s", deviceId)
+ return status.Errorf(codes.NotFound, "%s", deviceID)
}
//updatePortsState updates all ports on the device
-func (dMgr *DeviceManager) updatePortsState(deviceId string, state voltha.OperStatus_OperStatus) error {
- log.Debugw("updatePortsState", log.Fields{"deviceid": deviceId})
+func (dMgr *DeviceManager) updatePortsState(deviceID string, state voltha.OperStatus_OperStatus) error {
+ log.Debugw("updatePortsState", log.Fields{"deviceid": deviceID})
var adminState voltha.AdminState_AdminState
- if agent := dMgr.getDeviceAgent(deviceId); agent != nil {
+ if agent := dMgr.getDeviceAgent(deviceID); agent != nil {
switch state {
case voltha.OperStatus_ACTIVE:
adminState = voltha.AdminState_ENABLED
if err := agent.enablePorts(); err != nil {
- log.Warnw("enable-all-ports-failed", log.Fields{"deviceId": deviceId, "error": err})
+ log.Warnw("enable-all-ports-failed", log.Fields{"deviceId": deviceID, "error": err})
return err
}
case voltha.OperStatus_UNKNOWN:
adminState = voltha.AdminState_DISABLED
if err := agent.disablePorts(); err != nil {
- log.Warnw("disable-all-ports-failed", log.Fields{"deviceId": deviceId, "error": err})
+ log.Warnw("disable-all-ports-failed", log.Fields{"deviceId": deviceID, "error": err})
return err
}
default:
return status.Error(codes.Unimplemented, "state-change-not-implemented")
}
// Notify the logical device about the state change
- if device, err := dMgr.GetDevice(deviceId); err != nil {
- log.Warnw("non-existent-device", log.Fields{"deviceId": deviceId, "error": err})
+ device, err := dMgr.GetDevice(deviceID)
+ if err != nil {
+ log.Warnw("non-existent-device", log.Fields{"deviceId": deviceID, "error": err})
return err
- } else {
- if err := dMgr.logicalDeviceMgr.updatePortsState(device, adminState); err != nil {
- log.Warnw("failed-updating-ports-state", log.Fields{"deviceId": deviceId, "error": err})
- return err
- }
- return nil
}
+ if err := dMgr.logicalDeviceMgr.updatePortsState(device, adminState); err != nil {
+ log.Warnw("failed-updating-ports-state", log.Fields{"deviceId": deviceID, "error": err})
+ return err
+ }
+ return nil
}
- return status.Errorf(codes.NotFound, "%s", deviceId)
+ return status.Errorf(codes.NotFound, "%s", deviceID)
}
-func (dMgr *DeviceManager) childDeviceDetected(parentDeviceId string, parentPortNo int64, deviceType string,
- channelId int64, vendorId string, serialNumber string, onuId int64) (*voltha.Device, error) {
- log.Debugw("childDeviceDetected", log.Fields{"parentDeviceId": parentDeviceId, "parentPortNo": parentPortNo, "deviceType": deviceType, "channelId": channelId, "vendorId": vendorId, "serialNumber": serialNumber, "onuId": onuId})
+func (dMgr *DeviceManager) childDeviceDetected(parentDeviceID string, parentPortNo int64, deviceType string,
+ channelID int64, vendorID string, serialNumber string, onuID int64) (*voltha.Device, error) {
+ log.Debugw("childDeviceDetected", log.Fields{"parentDeviceId": parentDeviceID, "parentPortNo": parentPortNo, "deviceType": deviceType, "channelId": channelID, "vendorId": vendorID, "serialNumber": serialNumber, "onuId": onuID})
- if deviceType == "" && vendorId != "" {
+ if deviceType == "" && vendorID != "" {
log.Debug("device-type-is-nil-fetching-device-type")
if deviceTypesIf := dMgr.adapterMgr.clusterDataProxy.List(context.Background(), "/device_types", 0, false, ""); deviceTypesIf != nil {
OLoop:
for _, deviceTypeIf := range deviceTypesIf.([]interface{}) {
if dType, ok := deviceTypeIf.(*voltha.DeviceType); ok {
for _, v := range dType.VendorIds {
- if v == vendorId {
+ if v == vendorID {
deviceType = dType.Adapter
break OLoop
}
@@ -923,37 +957,37 @@
}
//if no match found for the vendorid,report adapter with the custom error message
if deviceType == "" {
- log.Errorw("failed-to-fetch-adapter-name ", log.Fields{"vendorId": vendorId})
- return nil, status.Errorf(codes.NotFound, "%s", vendorId)
+ log.Errorw("failed-to-fetch-adapter-name ", log.Fields{"vendorId": vendorID})
+ return nil, status.Errorf(codes.NotFound, "%s", vendorID)
}
// Create the ONU device
childDevice := &voltha.Device{}
childDevice.Type = deviceType
- childDevice.ParentId = parentDeviceId
+ childDevice.ParentId = parentDeviceID
childDevice.ParentPortNo = uint32(parentPortNo)
- childDevice.VendorId = vendorId
+ childDevice.VendorId = vendorID
childDevice.SerialNumber = serialNumber
childDevice.Root = false
//Get parent device type
- parent, err := dMgr.GetDevice(parentDeviceId)
+ parent, err := dMgr.GetDevice(parentDeviceID)
if err != nil {
- log.Error("no-parent-found", log.Fields{"parentId": parentDeviceId})
- return nil, status.Errorf(codes.NotFound, "%s", parentDeviceId)
+ log.Error("no-parent-found", log.Fields{"parentId": parentDeviceID})
+ return nil, status.Errorf(codes.NotFound, "%s", parentDeviceID)
}
- if device, err := dMgr.GetChildDevice(parentDeviceId, serialNumber, onuId, parentPortNo); err == nil {
- log.Warnw("child-device-exists", log.Fields{"parentId": parentDeviceId, "serialNumber": serialNumber})
+ if device, err := dMgr.GetChildDevice(parentDeviceID, serialNumber, onuID, parentPortNo); err == nil {
+ log.Warnw("child-device-exists", log.Fields{"parentId": parentDeviceID, "serialNumber": serialNumber})
return device, status.Errorf(codes.AlreadyExists, "%s", serialNumber)
}
- childDevice.ProxyAddress = &voltha.Device_ProxyAddress{DeviceId: parentDeviceId, DeviceType: parent.Type, ChannelId: uint32(channelId), OnuId: uint32(onuId)}
+ childDevice.ProxyAddress = &voltha.Device_ProxyAddress{DeviceId: parentDeviceID, DeviceType: parent.Type, ChannelId: uint32(channelID), OnuId: uint32(onuID)}
// Create and start a device agent for that device
agent := newDeviceAgent(dMgr.adapterProxy, childDevice, dMgr, dMgr.clusterDataProxy, dMgr.defaultTimeout)
dMgr.addDeviceAgentToMap(agent)
- childDevice, err = agent.start(nil, childDevice)
+ childDevice, err = agent.start(context.TODO(), childDevice)
if err != nil {
log.Error("error-starting-child")
return nil, err
@@ -961,15 +995,28 @@
// Since this Core has handled this request then it therefore owns this child device. Set the
// ownership of this device to this Core
- dMgr.core.deviceOwnership.OwnedByMe(&utils.DeviceID{Id: agent.deviceId})
+ _, err = dMgr.core.deviceOwnership.OwnedByMe(&utils.DeviceID{ID: agent.deviceID})
+ if err != nil {
+ log.Errorw("unable-to-find-core-instance-active-owns-this-device", log.Fields{"error": err})
+ }
// Activate the child device
- if agent := dMgr.getDeviceAgent(agent.deviceId); agent != nil {
- go agent.enableDevice(nil)
+ if agent = dMgr.getDeviceAgent(agent.deviceID); agent != nil {
+ go func() {
+ err := agent.enableDevice(context.TODO())
+ if err != nil {
+ log.Errorw("unable-to-enable-device", log.Fields{"error": err})
+ }
+ }()
}
// Publish on the messaging bus that we have discovered new devices
- go dMgr.kafkaICProxy.DeviceDiscovered(agent.deviceId, deviceType, parentDeviceId, dMgr.coreInstanceId)
+ go func() {
+ err := dMgr.kafkaICProxy.DeviceDiscovered(agent.deviceID, deviceType, parentDeviceID, dMgr.coreInstanceID)
+ if err != nil {
+ log.Errorw("unable-to-discover-the-device", log.Fields{"error": err})
+ }
+ }()
return childDevice, nil
}
@@ -992,42 +1039,44 @@
return nil
}
-func (dMgr *DeviceManager) packetOut(deviceId string, outPort uint32, packet *ofp.OfpPacketOut) error {
- log.Debugw("packetOut", log.Fields{"deviceId": deviceId, "outPort": outPort})
- if agent := dMgr.getDeviceAgent(deviceId); agent != nil {
+func (dMgr *DeviceManager) packetOut(deviceID string, outPort uint32, packet *ofp.OfpPacketOut) error {
+ log.Debugw("packetOut", log.Fields{"deviceId": deviceID, "outPort": outPort})
+ if agent := dMgr.getDeviceAgent(deviceID); agent != nil {
return agent.packetOut(outPort, packet)
}
- return status.Errorf(codes.NotFound, "%s", deviceId)
+ return status.Errorf(codes.NotFound, "%s", deviceID)
}
-func (dMgr *DeviceManager) PacketIn(deviceId string, port uint32, transactionId string, packet []byte) error {
- log.Debugw("PacketIn", log.Fields{"deviceId": deviceId, "port": port})
+// PacketIn receives packet from adapter
+func (dMgr *DeviceManager) PacketIn(deviceID string, port uint32, transactionID string, packet []byte) error {
+ log.Debugw("PacketIn", log.Fields{"deviceId": deviceID, "port": port})
// Get the logical device Id based on the deviceId
var device *voltha.Device
var err error
- if device, err = dMgr.GetDevice(deviceId); err != nil {
- log.Errorw("device-not-found", log.Fields{"deviceId": deviceId})
+ if device, err = dMgr.GetDevice(deviceID); err != nil {
+ log.Errorw("device-not-found", log.Fields{"deviceId": deviceID})
return err
}
if !device.Root {
- log.Errorw("device-not-root", log.Fields{"deviceId": deviceId})
- return status.Errorf(codes.FailedPrecondition, "%s", deviceId)
+ log.Errorw("device-not-root", log.Fields{"deviceId": deviceID})
+ return status.Errorf(codes.FailedPrecondition, "%s", deviceID)
}
- if err := dMgr.logicalDeviceMgr.packetIn(device.ParentId, port, transactionId, packet); err != nil {
+ if err := dMgr.logicalDeviceMgr.packetIn(device.ParentId, port, transactionID, packet); err != nil {
return err
}
return nil
}
-func (dMgr *DeviceManager) setParentId(device *voltha.Device, parentId string) error {
- log.Debugw("setParentId", log.Fields{"deviceId": device.Id, "parentId": parentId})
+func (dMgr *DeviceManager) setParentID(device *voltha.Device, parentID string) error {
+ log.Debugw("setParentId", log.Fields{"deviceId": device.Id, "parentId": parentID})
if agent := dMgr.getDeviceAgent(device.Id); agent != nil {
- return agent.setParentId(device, parentId)
+ return agent.setParentID(device, parentID)
}
return status.Errorf(codes.NotFound, "%s", device.Id)
}
+// CreateLogicalDevice creates logical device in core
func (dMgr *DeviceManager) CreateLogicalDevice(cDevice *voltha.Device) error {
log.Info("CreateLogicalDevice")
// Verify whether the logical device has already been created
@@ -1036,42 +1085,45 @@
return nil
}
var err error
- if _, err = dMgr.logicalDeviceMgr.createLogicalDevice(nil, cDevice); err != nil {
+ if _, err = dMgr.logicalDeviceMgr.createLogicalDevice(context.TODO(), cDevice); err != nil {
log.Warnw("createlogical-device-error", log.Fields{"device": cDevice})
return err
}
return nil
}
+// DeleteLogicalDevice deletes logical device from core
func (dMgr *DeviceManager) DeleteLogicalDevice(cDevice *voltha.Device) error {
log.Info("DeleteLogicalDevice")
var err error
- if err = dMgr.logicalDeviceMgr.deleteLogicalDevice(nil, cDevice); err != nil {
+ if err = dMgr.logicalDeviceMgr.deleteLogicalDevice(context.TODO(), cDevice); err != nil {
log.Warnw("deleteLogical-device-error", log.Fields{"deviceId": cDevice.Id})
return err
}
// Remove the logical device Id from the parent device
- logicalId := ""
- dMgr.UpdateDeviceAttribute(cDevice.Id, "ParentId", logicalId)
+ logicalID := ""
+ dMgr.UpdateDeviceAttribute(cDevice.Id, "ParentId", logicalID)
return nil
}
+// DeleteLogicalPort removes the logical port associated with a device
func (dMgr *DeviceManager) DeleteLogicalPort(device *voltha.Device) error {
log.Info("deleteLogicalPort")
var err error
// Get the logical port associated with this device
- var lPortId *voltha.LogicalPortId
- if lPortId, err = dMgr.logicalDeviceMgr.getLogicalPortId(device); err != nil {
+ var lPortID *voltha.LogicalPortId
+ if lPortID, err = dMgr.logicalDeviceMgr.getLogicalPortID(device); err != nil {
log.Warnw("getLogical-port-error", log.Fields{"deviceId": device.Id, "error": err})
return err
}
- if err = dMgr.logicalDeviceMgr.deleteLogicalPort(nil, lPortId); err != nil {
+ if err = dMgr.logicalDeviceMgr.deleteLogicalPort(context.TODO(), lPortID); err != nil {
log.Warnw("deleteLogical-port-error", log.Fields{"deviceId": device.Id})
return err
}
return nil
}
+// DeleteLogicalPorts removes the logical ports associated with that deviceId
func (dMgr *DeviceManager) DeleteLogicalPorts(device *voltha.Device) error {
log.Info("deleteLogicalPorts")
if err := dMgr.logicalDeviceMgr.deleteLogicalPorts(device.Id); err != nil {
@@ -1093,12 +1145,12 @@
//childDevicesLost is invoked by an adapter to indicate that a parent device is in a state (Disabled) where it
//cannot manage the child devices. This will trigger the Core to disable all the child devices.
-func (dMgr *DeviceManager) childDevicesLost(parentDeviceId string) error {
+func (dMgr *DeviceManager) childDevicesLost(parentDeviceID string) error {
log.Debug("childDevicesLost")
var err error
var parentDevice *voltha.Device
- if parentDevice, err = dMgr.GetDevice(parentDeviceId); err != nil {
- log.Warnw("failed-getting-device", log.Fields{"deviceId": parentDeviceId, "error": err})
+ if parentDevice, err = dMgr.GetDevice(parentDeviceID); err != nil {
+ log.Warnw("failed-getting-device", log.Fields{"deviceId": parentDeviceID, "error": err})
return err
}
return dMgr.DisableAllChildDevices(parentDevice)
@@ -1106,14 +1158,14 @@
//childDevicesDetected is invoked by an adapter when child devices are found, typically after after a
// disable/enable sequence. This will trigger the Core to Enable all the child devices of that parent.
-func (dMgr *DeviceManager) childDevicesDetected(parentDeviceId string) error {
+func (dMgr *DeviceManager) childDevicesDetected(parentDeviceID string) error {
log.Debug("childDevicesDetected")
var err error
var parentDevice *voltha.Device
var childDeviceIds []string
- if parentDevice, err = dMgr.GetDevice(parentDeviceId); err != nil {
- log.Warnw("failed-getting-device", log.Fields{"deviceId": parentDeviceId, "error": err})
+ if parentDevice, err = dMgr.GetDevice(parentDeviceID); err != nil {
+ log.Warnw("failed-getting-device", log.Fields{"deviceId": parentDeviceID, "error": err})
return err
}
@@ -1124,13 +1176,18 @@
log.Debugw("no-child-device", log.Fields{"parentDeviceId": parentDevice.Id})
}
allChildEnableRequestSent := true
- for _, childDeviceId := range childDeviceIds {
- if agent := dMgr.getDeviceAgent(childDeviceId); agent != nil {
+ for _, childDeviceID := range childDeviceIds {
+ if agent := dMgr.getDeviceAgent(childDeviceID); agent != nil {
// Run the children re-registration in its own routine
- go agent.enableDevice(nil)
+ go func() {
+ err = agent.enableDevice(context.TODO())
+ if err != nil {
+ log.Errorw("unable-to-enable-device", log.Fields{"error": err})
+ }
+ }()
} else {
- err = status.Errorf(codes.Unavailable, "no agent for child device %s", childDeviceId)
- log.Errorw("no-child-device-agent", log.Fields{"parentDeviceId": parentDevice.Id, "childId": childDeviceId})
+ err = status.Errorf(codes.Unavailable, "no agent for child device %s", childDeviceID)
+ log.Errorw("no-child-device-agent", log.Fields{"parentDeviceId": parentDevice.Id, "childId": childDeviceID})
allChildEnableRequestSent = false
}
}
@@ -1157,10 +1214,10 @@
log.Debugw("no-child-device", log.Fields{"parentDeviceId": parentDevice.Id})
}
allChildDisable := true
- for _, childDeviceId := range childDeviceIds {
- if agent := dMgr.getDeviceAgent(childDeviceId); agent != nil {
- if err = agent.disableDevice(nil); err != nil {
- log.Errorw("failure-disable-device", log.Fields{"deviceId": childDeviceId, "error": err.Error()})
+ for _, childDeviceID := range childDeviceIds {
+ if agent := dMgr.getDeviceAgent(childDeviceID); agent != nil {
+ if err = agent.disableDevice(context.TODO()); err != nil {
+ log.Errorw("failure-disable-device", log.Fields{"deviceId": childDeviceID, "error": err.Error()})
allChildDisable = false
}
}
@@ -1183,13 +1240,13 @@
log.Debugw("no-child-device", log.Fields{"parentDeviceId": parentDevice.Id})
}
allChildDeleted := true
- for _, childDeviceId := range childDeviceIds {
- if agent := dMgr.getDeviceAgent(childDeviceId); agent != nil {
- if err = agent.deleteDevice(nil); err != nil {
- log.Errorw("failure-delete-device", log.Fields{"deviceId": childDeviceId, "error": err.Error()})
+ for _, childDeviceID := range childDeviceIds {
+ if agent := dMgr.getDeviceAgent(childDeviceID); agent != nil {
+ if err = agent.deleteDevice(context.TODO()); err != nil {
+ log.Errorw("failure-delete-device", log.Fields{"deviceId": childDeviceID, "error": err.Error()})
allChildDeleted = false
} else {
- agent.stop(nil)
+ agent.stop(context.TODO())
dMgr.deleteDeviceAgentFromMap(agent)
}
}
@@ -1203,12 +1260,12 @@
//getAllDeviceIdsWithDeviceParentId returns the list of device Ids which has id as parent Id. This function uses the
// data from the agent instead of using the data from the parent device as that data would disappear from a parent
// device during a delete device operation.
-func (dMgr *DeviceManager) getAllDeviceIdsWithDeviceParentId(id string) []string {
+func (dMgr *DeviceManager) getAllDeviceIdsWithDeviceParentID(id string) []string {
log.Debugw("getAllAgentsWithDeviceParentId", log.Fields{"parentDeviceId": id})
deviceIds := make([]string, 0)
dMgr.deviceAgents.Range(func(key, value interface{}) bool {
agent := value.(*DeviceAgent)
- if agent.parentId == id {
+ if agent.parentID == id {
deviceIds = append(deviceIds, key.(string))
}
return true
@@ -1232,25 +1289,26 @@
}
//getAllChildDevices is a helper method to get all the child device IDs from the device passed as parameter
-func (dMgr *DeviceManager) getAllChildDevices(parentDeviceId string) (*voltha.Devices, error) {
- log.Debugw("getAllChildDevices", log.Fields{"parentDeviceId": parentDeviceId})
- if parentDevice, err := dMgr.GetDevice(parentDeviceId); err == nil {
+func (dMgr *DeviceManager) getAllChildDevices(parentDeviceID string) (*voltha.Devices, error) {
+ log.Debugw("getAllChildDevices", log.Fields{"parentDeviceId": parentDeviceID})
+ if parentDevice, err := dMgr.GetDevice(parentDeviceID); err == nil {
childDevices := make([]*voltha.Device, 0)
if childDeviceIds, er := dMgr.getAllChildDeviceIds(parentDevice); er == nil {
- for _, deviceId := range childDeviceIds {
- if d, e := dMgr.GetDevice(deviceId); e == nil && d != nil {
+ for _, deviceID := range childDeviceIds {
+ if d, e := dMgr.GetDevice(deviceID); e == nil && d != nil {
childDevices = append(childDevices, d)
}
}
}
return &voltha.Devices{Items: childDevices}, nil
}
- return nil, status.Errorf(codes.NotFound, "%s", parentDeviceId)
+ return nil, status.Errorf(codes.NotFound, "%s", parentDeviceID)
}
+// SetupUNILogicalPorts creates UNI ports on the logical device that represents a child UNI interface
func (dMgr *DeviceManager) SetupUNILogicalPorts(cDevice *voltha.Device) error {
log.Info("addUNILogicalPort")
- if err := dMgr.logicalDeviceMgr.setupUNILogicalPorts(nil, cDevice); err != nil {
+ if err := dMgr.logicalDeviceMgr.setupUNILogicalPorts(context.TODO(), cDevice); err != nil {
log.Warnw("addUNILogicalPort-error", log.Fields{"device": cDevice, "err": err})
return err
}
@@ -1332,9 +1390,9 @@
sendResponse(ctx, ch, res)
}
-func (dMgr *DeviceManager) updateImageDownload(deviceId string, img *voltha.ImageDownload) error {
+func (dMgr *DeviceManager) updateImageDownload(deviceID string, img *voltha.ImageDownload) error {
log.Debugw("updateImageDownload", log.Fields{"deviceid": img.Id, "imageName": img.Name})
- if agent := dMgr.getDeviceAgent(deviceId); agent != nil {
+ if agent := dMgr.getDeviceAgent(deviceID); agent != nil {
if err := agent.updateImageDownload(img); err != nil {
log.Debugw("updateImageDownload-failed", log.Fields{"err": err, "imageName": img.Name})
return err
@@ -1353,14 +1411,15 @@
return nil, status.Errorf(codes.NotFound, "%s", img.Id)
}
-func (dMgr *DeviceManager) listImageDownloads(ctx context.Context, deviceId string) (*voltha.ImageDownloads, error) {
- log.Debugw("listImageDownloads", log.Fields{"deviceId": deviceId})
- if agent := dMgr.getDeviceAgent(deviceId); agent != nil {
- return agent.listImageDownloads(ctx, deviceId)
+func (dMgr *DeviceManager) listImageDownloads(ctx context.Context, deviceID string) (*voltha.ImageDownloads, error) {
+ log.Debugw("listImageDownloads", log.Fields{"deviceID": deviceID})
+ if agent := dMgr.getDeviceAgent(deviceID); agent != nil {
+ return agent.listImageDownloads(ctx, deviceID)
}
- return nil, status.Errorf(codes.NotFound, "%s", deviceId)
+ return nil, status.Errorf(codes.NotFound, "%s", deviceID)
}
+// SetAdminStateToEnable sets admin state of device to enabled
func (dMgr *DeviceManager) SetAdminStateToEnable(cDevice *voltha.Device) error {
log.Info("SetAdminStateToEnable")
if agent := dMgr.getDeviceAgent(cDevice.Id); agent != nil {
@@ -1369,36 +1428,7 @@
return status.Errorf(codes.NotFound, "%s", cDevice.Id)
}
-func (dMgr *DeviceManager) activateDevice(cDevice *voltha.Device) error {
- log.Info("activateDevice")
- return nil
-}
-
-func (dMgr *DeviceManager) disableDeviceHandler(cDevice *voltha.Device) error {
- log.Info("disableDevice-donothing")
- return nil
-}
-
-func (dMgr *DeviceManager) abandonDevice(cDevice *voltha.Device) error {
- log.Info("abandonDevice")
- return nil
-}
-
-func (dMgr *DeviceManager) reEnableDevice(cDevice *voltha.Device) error {
- log.Info("reEnableDevice")
- return nil
-}
-
-func (dMgr *DeviceManager) noOp(cDevice *voltha.Device) error {
- log.Info("noOp")
- return nil
-}
-
-func (dMgr *DeviceManager) notAllowed(pcDevice *voltha.Device) error {
- log.Info("notAllowed")
- return errors.New("transition-not-allowed")
-}
-
+// NotifyInvalidTransition notifies about invalid transition
func (dMgr *DeviceManager) NotifyInvalidTransition(pcDevice *voltha.Device) error {
log.Errorw("NotifyInvalidTransition", log.Fields{
"device": pcDevice.Id,
@@ -1416,14 +1446,16 @@
return rf.Name()
}
-func (dMgr *DeviceManager) UpdateDeviceAttribute(deviceId string, attribute string, value interface{}) {
- if agent, ok := dMgr.deviceAgents.Load(deviceId); ok {
+// UpdateDeviceAttribute updates value of particular device attribute
+func (dMgr *DeviceManager) UpdateDeviceAttribute(deviceID string, attribute string, value interface{}) {
+ if agent, ok := dMgr.deviceAgents.Load(deviceID); ok {
agent.(*DeviceAgent).updateDeviceAttribute(attribute, value)
}
}
-func (dMgr *DeviceManager) GetParentDeviceId(deviceId string) string {
- if device, _ := dMgr.GetDevice(deviceId); device != nil {
+// GetParentDeviceID returns parent device id, either from memory or from the dB, if present
+func (dMgr *DeviceManager) GetParentDeviceID(deviceID string) string {
+ if device, _ := dMgr.GetDevice(deviceID); device != nil {
log.Infow("GetParentDeviceId", log.Fields{"deviceId": device.Id, "parentId": device.ParentId})
return device.ParentId
}
@@ -1443,10 +1475,10 @@
sendResponse(ctx, ch, res)
}
-func (dMgr *DeviceManager) updateDeviceReason(deviceId string, reason string) error {
- log.Debugw("updateDeviceReason", log.Fields{"deviceid": deviceId, "reason": reason})
- if agent := dMgr.getDeviceAgent(deviceId); agent != nil {
+func (dMgr *DeviceManager) updateDeviceReason(deviceID string, reason string) error {
+ log.Debugw("updateDeviceReason", log.Fields{"deviceid": deviceID, "reason": reason})
+ if agent := dMgr.getDeviceAgent(deviceID); agent != nil {
return agent.updateDeviceReason(reason)
}
- return status.Errorf(codes.NotFound, "%s", deviceId)
+ return status.Errorf(codes.NotFound, "%s", deviceID)
}