diff --git a/Makefile b/Makefile
index 206becd..1f2a5ae 100644
--- a/Makefile
+++ b/Makefile
@@ -82,6 +82,7 @@
 	@echo "lint-sanity          : Verify that 'go vet' doesn't report any issues"
 	@echo "lint-mod             : Verify the integrity of the 'mod' files"
 	@echo "lint                 : Shorthand for lint-style & lint-sanity"
+	@echo "sca                  : Runs various SCA through golangci-lint tool"
 	@echo "test                 : Generate reports for all go tests"
 	@echo
 
@@ -237,7 +238,7 @@
 sca: golangci_lint_tool_install
 	rm -rf ./sca-report
 	@mkdir -p ./sca-report
-	$(GOLANGCI_LINT_TOOL) run -E golint -D structcheck --out-format junit-xml ./cli/... ./rw_core/...  2>&1 | tee ./sca-report/sca-report.xml
+	$(GOLANGCI_LINT_TOOL) run -E golint -D structcheck --out-format junit-xml ./cli/... ./rw_core/... ./ro_core/... ./tests/... 2>&1 | tee ./sca-report/sca-report.xml
 
 test: go_junit_install gocover_cobertura_install local-lib-go
 	@mkdir -p ./tests/results
diff --git a/ro_core/config/config.go b/ro_core/config/config.go
index 03dedf2..5084130 100644
--- a/ro_core/config/config.go
+++ b/ro_core/config/config.go
@@ -13,44 +13,46 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package config
 
 import (
 	"flag"
 	"fmt"
-	"github.com/opencord/voltha-lib-go/v2/pkg/log"
 	"os"
 	"time"
+
+	"github.com/opencord/voltha-lib-go/v2/pkg/log"
 )
 
 // RO Core service default constants
 const (
-	ConsulStoreName                 = "consul"
-	EtcdStoreName                   = "etcd"
-	default_InstanceID              = "rocore001"
-	default_GrpcPort                = 50057
-	default_GrpcHost                = ""
-	default_KVStoreType             = EtcdStoreName
-	default_KVStoreTimeout          = 5 //in seconds
-	default_KVStoreHost             = "127.0.0.1"
-	default_KVStorePort             = 2379 // Consul = 8500; Etcd = 2379
-	default_KVTxnKeyDelTime         = 60
-	default_LogLevel                = 0
-	default_Banner                  = false
-	default_DisplayVersionOnly      = false
-	default_CoreTopic               = "rocore"
-	default_ROCoreEndpoint          = "rocore"
-	default_ROCoreKey               = "pki/voltha.key"
-	default_ROCoreCert              = "pki/voltha.crt"
-	default_ROCoreCA                = "pki/voltha-CA.pem"
-	default_Affinity_Router_Topic   = "affinityRouter"
-	default_ProbeHost               = ""
-	default_ProbePort               = 8080
-	default_LiveProbeInterval       = 60 * time.Second
-	default_NotLiveProbeInterval    = 5 * time.Second // Probe more frequently to detect Recovery early
-	default_CoreTimeout             = 59 * time.Second
-	default_MaxConnectionRetries    = -1              // retries forever
-	default_ConnectionRetryInterval = 2 * time.Second // in seconds
+	ConsulStoreName                = "consul"
+	EtcdStoreName                  = "etcd"
+	defaultInstanceID              = "rocore001"
+	defaultGrpcPort                = 50057
+	defaultGrpcHost                = ""
+	defaultKVStoreType             = EtcdStoreName
+	defaultKVStoreTimeout          = 5 //in seconds
+	defaultKVStoreHost             = "127.0.0.1"
+	defaultKVStorePort             = 2379 // Consul = 8500; Etcd = 2379
+	defaultKVTxnKeyDelTime         = 60
+	defaultLogLevel                = 0
+	defaultBanner                  = false
+	defaultDisplayVersionOnly      = false
+	defaultCoreTopic               = "rocore"
+	defaultROCoreEndpoint          = "rocore"
+	defaultROCoreKey               = "pki/voltha.key"
+	defaultROCoreCert              = "pki/voltha.crt"
+	defaultROCoreCA                = "pki/voltha-CA.pem"
+	defaultAffinityRouterTopic     = "affinityRouter"
+	defaultProbeHost               = ""
+	defaultProbePort               = 8080
+	defaultLiveProbeInterval       = 60 * time.Second
+	defaultNotLiveProbeInterval    = 5 * time.Second // Probe more frequently to detect Recovery early
+	defaultCoreTimeout             = 59 * time.Second
+	defaultMaxConnectionRetries    = -1              // retries forever
+	defaultConnectionRetryInterval = 2 * time.Second // in seconds
 )
 
 // ROCoreFlags represents the set of configurations used by the read-only core service
@@ -83,36 +85,39 @@
 }
 
 func init() {
-	log.AddPackage(log.JSON, log.WarnLevel, nil)
+	_, err := log.AddPackage(log.JSON, log.WarnLevel, nil)
+	if err != nil {
+		log.Errorw("unable-to-register-package-to-the-log-map", log.Fields{"error": err})
+	}
 }
 
 // NewROCoreFlags returns a new ROCore config
 func NewROCoreFlags() *ROCoreFlags {
 	var roCoreFlag = ROCoreFlags{ // Default values
-		InstanceID:              default_InstanceID,
-		ROCoreEndpoint:          default_ROCoreEndpoint,
-		GrpcHost:                default_GrpcHost,
-		GrpcPort:                default_GrpcPort,
-		KVStoreType:             default_KVStoreType,
-		KVStoreTimeout:          default_KVStoreTimeout,
-		KVStoreHost:             default_KVStoreHost,
-		KVStorePort:             default_KVStorePort,
-		KVTxnKeyDelTime:         default_KVTxnKeyDelTime,
-		CoreTopic:               default_CoreTopic,
-		LogLevel:                default_LogLevel,
-		Banner:                  default_Banner,
-		DisplayVersionOnly:      default_DisplayVersionOnly,
-		ROCoreKey:               default_ROCoreKey,
-		ROCoreCert:              default_ROCoreCert,
-		ROCoreCA:                default_ROCoreCA,
-		AffinityRouterTopic:     default_Affinity_Router_Topic,
-		ProbeHost:               default_ProbeHost,
-		ProbePort:               default_ProbePort,
-		LiveProbeInterval:       default_LiveProbeInterval,
-		NotLiveProbeInterval:    default_NotLiveProbeInterval,
-		CoreTimeout:             default_CoreTimeout,
-		MaxConnectionRetries:    default_MaxConnectionRetries,
-		ConnectionRetryInterval: default_ConnectionRetryInterval,
+		InstanceID:              defaultInstanceID,
+		ROCoreEndpoint:          defaultROCoreEndpoint,
+		GrpcHost:                defaultGrpcHost,
+		GrpcPort:                defaultGrpcPort,
+		KVStoreType:             defaultKVStoreType,
+		KVStoreTimeout:          defaultKVStoreTimeout,
+		KVStoreHost:             defaultKVStoreHost,
+		KVStorePort:             defaultKVStorePort,
+		KVTxnKeyDelTime:         defaultKVTxnKeyDelTime,
+		CoreTopic:               defaultCoreTopic,
+		LogLevel:                defaultLogLevel,
+		Banner:                  defaultBanner,
+		DisplayVersionOnly:      defaultDisplayVersionOnly,
+		ROCoreKey:               defaultROCoreKey,
+		ROCoreCert:              defaultROCoreCert,
+		ROCoreCA:                defaultROCoreCA,
+		AffinityRouterTopic:     defaultAffinityRouterTopic,
+		ProbeHost:               defaultProbeHost,
+		ProbePort:               defaultProbePort,
+		LiveProbeInterval:       defaultLiveProbeInterval,
+		NotLiveProbeInterval:    defaultNotLiveProbeInterval,
+		CoreTimeout:             defaultCoreTimeout,
+		MaxConnectionRetries:    defaultMaxConnectionRetries,
+		ConnectionRetryInterval: defaultConnectionRetryInterval,
 	}
 	return &roCoreFlag
 }
@@ -120,67 +125,65 @@
 // ParseCommandArguments parses the arguments when running read-only core service
 func (cf *ROCoreFlags) ParseCommandArguments() {
 
-	var help string
-
-	help = fmt.Sprintf("RO core endpoint address")
-	flag.StringVar(&(cf.ROCoreEndpoint), "vcore-endpoint", default_ROCoreEndpoint, help)
+	help := fmt.Sprintf("RO core endpoint address")
+	flag.StringVar(&(cf.ROCoreEndpoint), "vcore-endpoint", defaultROCoreEndpoint, help)
 
 	help = fmt.Sprintf("GRPC server - host")
-	flag.StringVar(&(cf.GrpcHost), "grpc_host", default_GrpcHost, help)
+	flag.StringVar(&(cf.GrpcHost), "grpc_host", defaultGrpcHost, help)
 
 	help = fmt.Sprintf("GRPC server - port")
-	flag.IntVar(&(cf.GrpcPort), "grpc_port", default_GrpcPort, help)
+	flag.IntVar(&(cf.GrpcPort), "grpc_port", defaultGrpcPort, help)
 
 	help = fmt.Sprintf("RO Core topic")
-	flag.StringVar(&(cf.CoreTopic), "ro_core_topic", default_CoreTopic, help)
+	flag.StringVar(&(cf.CoreTopic), "ro_core_topic", defaultCoreTopic, help)
 
 	help = fmt.Sprintf("Affinity Router topic")
-	flag.StringVar(&(cf.AffinityRouterTopic), "affinity_router_topic", default_Affinity_Router_Topic, help)
+	flag.StringVar(&(cf.AffinityRouterTopic), "affinity_router_topic", defaultAffinityRouterTopic, help)
 
 	help = fmt.Sprintf("KV store type")
-	flag.StringVar(&(cf.KVStoreType), "kv_store_type", default_KVStoreType, help)
+	flag.StringVar(&(cf.KVStoreType), "kv_store_type", defaultKVStoreType, help)
 
 	help = fmt.Sprintf("The default timeout when making a kv store request")
-	flag.IntVar(&(cf.KVStoreTimeout), "kv_store_request_timeout", default_KVStoreTimeout, help)
+	flag.IntVar(&(cf.KVStoreTimeout), "kv_store_request_timeout", defaultKVStoreTimeout, help)
 
 	help = fmt.Sprintf("KV store host")
-	flag.StringVar(&(cf.KVStoreHost), "kv_store_host", default_KVStoreHost, help)
+	flag.StringVar(&(cf.KVStoreHost), "kv_store_host", defaultKVStoreHost, help)
 
 	help = fmt.Sprintf("KV store port")
-	flag.IntVar(&(cf.KVStorePort), "kv_store_port", default_KVStorePort, help)
+	flag.IntVar(&(cf.KVStorePort), "kv_store_port", defaultKVStorePort, help)
 
 	help = fmt.Sprintf("The time to wait before deleting a completed transaction key")
-	flag.IntVar(&(cf.KVTxnKeyDelTime), "kv_txn_delete_time", default_KVTxnKeyDelTime, help)
+	flag.IntVar(&(cf.KVTxnKeyDelTime), "kv_txn_delete_time", defaultKVTxnKeyDelTime, help)
 
 	help = fmt.Sprintf("Log level")
-	flag.IntVar(&(cf.LogLevel), "log_level", default_LogLevel, help)
+	flag.IntVar(&(cf.LogLevel), "log_level", defaultLogLevel, help)
 
 	help = fmt.Sprintf("Show startup banner log lines")
-	flag.BoolVar(&cf.Banner, "banner", default_Banner, help)
+	flag.BoolVar(&cf.Banner, "banner", defaultBanner, help)
 
 	help = fmt.Sprintf("Show version information and exit")
-	flag.BoolVar(&cf.DisplayVersionOnly, "version", default_DisplayVersionOnly, help)
+	flag.BoolVar(&cf.DisplayVersionOnly, "version", defaultDisplayVersionOnly, help)
 
 	help = fmt.Sprintf("The address on which to listen to answer liveness and readiness probe queries over HTTP.")
-	flag.StringVar(&(cf.ProbeHost), "probe_host", default_ProbeHost, help)
+	flag.StringVar(&(cf.ProbeHost), "probe_host", defaultProbeHost, help)
 
 	help = fmt.Sprintf("The port on which to listen to answer liveness and readiness probe queries over HTTP.")
-	flag.IntVar(&(cf.ProbePort), "probe_port", default_ProbePort, help)
+	flag.IntVar(&(cf.ProbePort), "probe_port", defaultProbePort, help)
 
 	help = fmt.Sprintf("Time interval between liveness probes while in a live state")
-	flag.DurationVar(&(cf.LiveProbeInterval), "live_probe_interval", default_LiveProbeInterval, help)
+	flag.DurationVar(&(cf.LiveProbeInterval), "live_probe_interval", defaultLiveProbeInterval, help)
 
 	help = fmt.Sprintf("Time interval between liveness probes while in a not live state")
-	flag.DurationVar(&(cf.NotLiveProbeInterval), "not_live_probe_interval", default_NotLiveProbeInterval, help)
+	flag.DurationVar(&(cf.NotLiveProbeInterval), "not_live_probe_interval", defaultNotLiveProbeInterval, help)
 
 	help = fmt.Sprintf("The maximum time the core will wait while attempting to connect to a dependent component duration")
-	flag.DurationVar(&(cf.CoreTimeout), "core_timeout", default_CoreTimeout, help)
+	flag.DurationVar(&(cf.CoreTimeout), "core_timeout", defaultCoreTimeout, help)
 
 	help = fmt.Sprintf("The number of retries to connect to a dependent component")
-	flag.IntVar(&(cf.MaxConnectionRetries), "max_connection_retries", default_MaxConnectionRetries, help)
+	flag.IntVar(&(cf.MaxConnectionRetries), "max_connection_retries", defaultMaxConnectionRetries, help)
 
 	help = fmt.Sprintf("The duration between each connection retry attempt ")
-	flag.DurationVar(&(cf.ConnectionRetryInterval), "connection_retry_interval", default_ConnectionRetryInterval, help)
+	flag.DurationVar(&(cf.ConnectionRetryInterval), "connection_retry_interval", defaultConnectionRetryInterval, help)
 
 	flag.Parse()
 
diff --git a/ro_core/config/config_test.go b/ro_core/config/config_test.go
index c1dbc9a..2ebcfbb 100644
--- a/ro_core/config/config_test.go
+++ b/ro_core/config/config_test.go
@@ -33,13 +33,13 @@
 	 * useful.
 	 */
 
-	VOLTHA_LOGLEVEL = log.FatalLevel
+	VOLTHALogLevel = log.FatalLevel
 )
 
 func localInit() {
 
 	// Logger must be configured or bad things happen
-	_, err := log.SetDefaultLogger(log.JSON, VOLTHA_LOGLEVEL, log.Fields{"instanceId": 1})
+	_, err := log.SetDefaultLogger(log.JSON, VOLTHALogLevel, log.Fields{"instanceId": 1})
 	if err != nil {
 		panic(err)
 	}
@@ -47,59 +47,59 @@
 
 func checkConfigFlags(t *testing.T, cf *ROCoreFlags) {
 
-	if cf.ROCoreEndpoint != default_ROCoreEndpoint {
-		t.Errorf("ROCoreEndpoint want %s, got %s", default_ROCoreEndpoint, cf.ROCoreEndpoint)
+	if cf.ROCoreEndpoint != defaultROCoreEndpoint {
+		t.Errorf("ROCoreEndpoint want %s, got %s", defaultROCoreEndpoint, cf.ROCoreEndpoint)
 	}
-	if cf.GrpcHost != default_GrpcHost {
-		t.Errorf("GrpcHost want %s, got %s", default_GrpcHost, cf.GrpcHost)
+	if cf.GrpcHost != defaultGrpcHost {
+		t.Errorf("GrpcHost want %s, got %s", defaultGrpcHost, cf.GrpcHost)
 	}
-	if cf.GrpcPort != default_GrpcPort {
-		t.Errorf("GrpcPort want %d, got %d", default_GrpcPort, cf.GrpcPort)
+	if cf.GrpcPort != defaultGrpcPort {
+		t.Errorf("GrpcPort want %d, got %d", defaultGrpcPort, cf.GrpcPort)
 	}
-	if cf.KVStoreType != default_KVStoreType {
-		t.Errorf("KVStoreType want %s, got %s", default_KVStoreType, cf.KVStoreType)
+	if cf.KVStoreType != defaultKVStoreType {
+		t.Errorf("KVStoreType want %s, got %s", defaultKVStoreType, cf.KVStoreType)
 	}
-	if cf.KVStoreTimeout != default_KVStoreTimeout {
-		t.Errorf("KVStoreTimeout want %d, got %d", default_KVStoreTimeout, cf.KVStoreTimeout)
+	if cf.KVStoreTimeout != defaultKVStoreTimeout {
+		t.Errorf("KVStoreTimeout want %d, got %d", defaultKVStoreTimeout, cf.KVStoreTimeout)
 	}
-	if cf.KVStoreHost != default_KVStoreHost {
-		t.Errorf("KVStoreHost want %s, got %s", default_KVStoreHost, cf.KVStoreHost)
+	if cf.KVStoreHost != defaultKVStoreHost {
+		t.Errorf("KVStoreHost want %s, got %s", defaultKVStoreHost, cf.KVStoreHost)
 	}
-	if cf.KVStorePort != default_KVStorePort {
-		t.Errorf("KVStorePort want %d, got %d", default_KVStorePort, cf.KVStorePort)
+	if cf.KVStorePort != defaultKVStorePort {
+		t.Errorf("KVStorePort want %d, got %d", defaultKVStorePort, cf.KVStorePort)
 	}
-	if cf.KVTxnKeyDelTime != default_KVTxnKeyDelTime {
-		t.Errorf("KVTxnKeyDelTime want %d, got %d", default_KVTxnKeyDelTime, cf.KVTxnKeyDelTime)
+	if cf.KVTxnKeyDelTime != defaultKVTxnKeyDelTime {
+		t.Errorf("KVTxnKeyDelTime want %d, got %d", defaultKVTxnKeyDelTime, cf.KVTxnKeyDelTime)
 	}
-	if cf.CoreTopic != default_CoreTopic {
-		t.Errorf("CoreTopic want %s, got %s", default_CoreTopic, cf.CoreTopic)
+	if cf.CoreTopic != defaultCoreTopic {
+		t.Errorf("CoreTopic want %s, got %s", defaultCoreTopic, cf.CoreTopic)
 	}
-	if cf.LogLevel != default_LogLevel {
-		t.Errorf("LogLevel want %d, got %d", default_LogLevel, cf.LogLevel)
+	if cf.LogLevel != defaultLogLevel {
+		t.Errorf("LogLevel want %d, got %d", defaultLogLevel, cf.LogLevel)
 	}
-	if cf.Banner != default_Banner {
-		t.Errorf("Banner want %v, got %v", default_Banner, cf.Banner)
+	if cf.Banner != defaultBanner {
+		t.Errorf("Banner want %v, got %v", defaultBanner, cf.Banner)
 	}
-	if cf.DisplayVersionOnly != default_DisplayVersionOnly {
-		t.Errorf("DisplayVersionOnly want %v, got %v", default_DisplayVersionOnly, cf.DisplayVersionOnly)
+	if cf.DisplayVersionOnly != defaultDisplayVersionOnly {
+		t.Errorf("DisplayVersionOnly want %v, got %v", defaultDisplayVersionOnly, cf.DisplayVersionOnly)
 	}
-	if cf.ROCoreKey != default_ROCoreKey {
-		t.Errorf("ROCoreKey want %s, got %s", default_ROCoreKey, cf.ROCoreKey)
+	if cf.ROCoreKey != defaultROCoreKey {
+		t.Errorf("ROCoreKey want %s, got %s", defaultROCoreKey, cf.ROCoreKey)
 	}
-	if cf.ROCoreCert != default_ROCoreCert {
-		t.Errorf("ROCoreCert want %s, got %s", default_ROCoreCert, cf.ROCoreCert)
+	if cf.ROCoreCert != defaultROCoreCert {
+		t.Errorf("ROCoreCert want %s, got %s", defaultROCoreCert, cf.ROCoreCert)
 	}
-	if cf.ROCoreCA != default_ROCoreCA {
-		t.Errorf("ROCoreCA want %s, got %s", default_ROCoreCA, cf.ROCoreCA)
+	if cf.ROCoreCA != defaultROCoreCA {
+		t.Errorf("ROCoreCA want %s, got %s", defaultROCoreCA, cf.ROCoreCA)
 	}
-	if cf.AffinityRouterTopic != default_Affinity_Router_Topic {
-		t.Errorf("AffinityRouterTopic want %s, got %s", default_Affinity_Router_Topic, cf.AffinityRouterTopic)
+	if cf.AffinityRouterTopic != defaultAffinityRouterTopic {
+		t.Errorf("AffinityRouterTopic want %s, got %s", defaultAffinityRouterTopic, cf.AffinityRouterTopic)
 	}
-	if cf.ProbeHost != default_ProbeHost {
-		t.Errorf("ProbeHost want %s, got %s", default_ProbeHost, cf.ProbeHost)
+	if cf.ProbeHost != defaultProbeHost {
+		t.Errorf("ProbeHost want %s, got %s", defaultProbeHost, cf.ProbeHost)
 	}
-	if cf.ProbePort != default_ProbePort {
-		t.Errorf("ProbePort want %d, got %d", default_ProbePort, cf.ProbePort)
+	if cf.ProbePort != defaultProbePort {
+		t.Errorf("ProbePort want %d, got %d", defaultProbePort, cf.ProbePort)
 	}
 }
 
diff --git a/ro_core/core/common_test.go b/ro_core/core/common_test.go
index 9bef64f..bf7c7c1 100644
--- a/ro_core/core/common_test.go
+++ b/ro_core/core/common_test.go
@@ -30,14 +30,14 @@
 	 * useful.
 	 */
 
-	VOLTHA_LOGLEVEL = log.FatalLevel
+	VolthaLogLevel = log.FatalLevel
 )
 
 // Unit test initialization. This init() function handles all unit tests in
 // the current directory.
 func init() {
 	// Logger must be configured or bad things happen
-	_, err := log.SetDefaultLogger(log.JSON, VOLTHA_LOGLEVEL, log.Fields{"instanceId": 1})
+	_, err := log.SetDefaultLogger(log.JSON, VolthaLogLevel, log.Fields{"instanceID": 1})
 	if err != nil {
 		panic(err)
 	}
diff --git a/ro_core/core/core.go b/ro_core/core/core.go
index 797c05a..da9fead 100644
--- a/ro_core/core/core.go
+++ b/ro_core/core/core.go
@@ -13,10 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package core
 
 import (
 	"context"
+
+	"time"
+
 	"github.com/opencord/voltha-go/db/model"
 	"github.com/opencord/voltha-go/ro_core/config"
 	"github.com/opencord/voltha-lib-go/v2/pkg/db"
@@ -28,11 +32,11 @@
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
-	"time"
 )
 
+// Core holds all information of read only core service
 type Core struct {
-	instanceId        string
+	instanceID        string
 	genericMgr        *ModelProxyManager
 	deviceMgr         *DeviceManager
 	logicalDeviceMgr  *LogicalDeviceManager
@@ -49,12 +53,16 @@
 }
 
 func init() {
-	log.AddPackage(log.JSON, log.DebugLevel, nil)
+	_, err := log.AddPackage(log.JSON, log.DebugLevel, nil)
+	if err != nil {
+		log.Errorw("unable-to-register-package-to-the-log-map", log.Fields{"error": err})
+	}
 }
 
+// NewCore instantiates core service parameters
 func NewCore(id string, cf *config.ROCoreFlags, kvClient kvstore.Client) *Core {
 	var core Core
-	core.instanceId = id
+	core.instanceID = id
 	core.exitChannel = make(chan int, 1)
 	core.config = cf
 	core.kvClient = kvClient
@@ -101,7 +109,7 @@
 					return status.Error(codes.Unavailable, "kv store unreachable")
 				}
 			}
-			count += 1
+			count++
 			//      Take a nap before retrying
 			time.Sleep(retryInterval)
 			log.Infow("retry-KV-store-connectivity", log.Fields{"retryCount": count, "maxRetries": maxRetries, "retryInterval": retryInterval})
@@ -114,8 +122,9 @@
 	return nil
 }
 
+// Start will start core adapter services
 func (core *Core) Start(ctx context.Context) {
-	log.Info("starting-adaptercore", log.Fields{"coreId": core.instanceId})
+	log.Info("starting-adaptercore", log.Fields{"coreId": core.instanceID})
 
 	// Wait until connection to KV Store is up
 	if err := core.waitUntilKVStoreReachableOrMaxTries(ctx, core.config.MaxConnectionRetries, core.config.ConnectionRetryInterval); err != nil {
@@ -125,7 +134,7 @@
 	probe.UpdateStatusFromContext(ctx, "kv-store", probe.ServiceStatusRunning)
 
 	core.genericMgr = newModelProxyManager(core.clusterDataProxy)
-	core.deviceMgr = newDeviceManager(core.clusterDataProxy, core.instanceId)
+	core.deviceMgr = newDeviceManager(core.clusterDataProxy, core.instanceID)
 	core.logicalDeviceMgr = newLogicalDeviceManager(core.deviceMgr, core.clusterDataProxy)
 	go core.startDeviceManager(ctx)
 	go core.startLogicalDeviceManager(ctx)
@@ -135,6 +144,7 @@
 	log.Info("adaptercore-started")
 }
 
+// Stop will stop core services
 func (core *Core) Stop(ctx context.Context) {
 	log.Info("stopping-adaptercore")
 	if core.exitChannel != nil {
diff --git a/ro_core/core/core_test.go b/ro_core/core/core_test.go
index 88bd561..d88a7de 100644
--- a/ro_core/core/core_test.go
+++ b/ro_core/core/core_test.go
@@ -19,15 +19,15 @@
 	"context"
 	"errors"
 	"fmt"
+	"testing"
+
 	"github.com/opencord/voltha-go/ro_core/config"
 	"github.com/opencord/voltha-lib-go/v2/pkg/db/kvstore"
-	grpcserver "github.com/opencord/voltha-lib-go/v2/pkg/grpc"
 	"github.com/opencord/voltha-lib-go/v2/pkg/log"
 	"github.com/opencord/voltha-lib-go/v2/pkg/mocks"
 	ic "github.com/opencord/voltha-protos/v2/go/inter_container"
 	"github.com/phayes/freeport"
 	"github.com/stretchr/testify/assert"
-	"testing"
 )
 
 type roCore struct {
@@ -35,8 +35,6 @@
 	config      *config.ROCoreFlags
 	halted      bool
 	exitChannel chan int
-	grpcServer  *grpcserver.GrpcServer
-	core        *Core
 	//For test
 	receiverChannels []<-chan *ic.InterContainerMessage
 }
@@ -62,7 +60,7 @@
 	return nil, errors.New("unsupported-kv-store")
 }
 
-func MakeTestNewCore() (*config.ROCoreFlags, *roCore) {
+func makeTestNewCore() (*config.ROCoreFlags, *roCore) {
 
 	clientPort, err := freeport.GetFreePort()
 	if err == nil {
@@ -84,11 +82,8 @@
 				roC.kvClient = cli
 				return roCoreFlgs, roC
 			}
-			if err != nil {
-				etcdServer.Stop()
-				log.Fatal("Failed to create an Etcd client")
-			}
-
+			etcdServer.Stop()
+			log.Fatal("Failed to create an Etcd client")
 		}
 	}
 	return nil, nil
@@ -96,7 +91,7 @@
 
 func TestNewCore(t *testing.T) {
 
-	roCoreFlgs, roC := MakeTestNewCore()
+	roCoreFlgs, roC := makeTestNewCore()
 	assert.NotNil(t, roCoreFlgs)
 	assert.NotNil(t, roC)
 	core := NewCore("ro_core", roCoreFlgs, roC.kvClient)
@@ -107,7 +102,7 @@
 
 	var ctx context.Context
 
-	roCoreFlgs, roC := MakeTestNewCore()
+	roCoreFlgs, roC := makeTestNewCore()
 	assert.NotNil(t, roCoreFlgs)
 	assert.NotNil(t, roC)
 	core := NewCore("ro_core", roCoreFlgs, roC.kvClient)
diff --git a/ro_core/core/device_agent.go b/ro_core/core/device_agent.go
index 63af020..345e424 100644
--- a/ro_core/core/device_agent.go
+++ b/ro_core/core/device_agent.go
@@ -13,21 +13,24 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package core
 
 import (
 	"context"
+	"sync"
+
 	"github.com/gogo/protobuf/proto"
 	"github.com/opencord/voltha-go/db/model"
 	"github.com/opencord/voltha-lib-go/v2/pkg/log"
 	"github.com/opencord/voltha-protos/v2/go/voltha"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
-	"sync"
 )
 
+// DeviceAgent holds device specific information
 type DeviceAgent struct {
-	deviceId         string
+	deviceID         string
 	deviceType       string
 	lastData         *voltha.Device
 	deviceMgr        *DeviceManager
@@ -40,7 +43,7 @@
 //preprovisioning
 func newDeviceAgent(device *voltha.Device, deviceMgr *DeviceManager, cdProxy *model.Proxy) *DeviceAgent {
 	var agent DeviceAgent
-	agent.deviceId = device.Id
+	agent.deviceID = device.Id
 	agent.deviceType = device.Type
 	agent.lastData = device
 	agent.deviceMgr = deviceMgr
@@ -56,13 +59,13 @@
 	defer agent.lockDevice.Unlock()
 	log.Debugw("starting-device-agent", log.Fields{"device": agent.lastData})
 	if loadFromDb {
-		if device := agent.clusterDataProxy.Get(ctx, "/devices/"+agent.deviceId, 0, false, ""); device != nil {
+		if device := agent.clusterDataProxy.Get(ctx, "/devices/"+agent.deviceID, 0, false, ""); device != nil {
 			if d, ok := device.(*voltha.Device); ok {
 				agent.lastData = proto.Clone(d).(*voltha.Device)
 			}
 		} else {
-			log.Errorw("failed-to-load-device", log.Fields{"deviceId": agent.deviceId})
-			return status.Errorf(codes.NotFound, "device-%s", agent.deviceId)
+			log.Errorw("failed-to-load-device", log.Fields{"deviceID": agent.deviceID})
+			return status.Errorf(codes.NotFound, "device-%s", agent.deviceID)
 		}
 		log.Debugw("device-loaded-from-dB", log.Fields{"device": agent.lastData})
 	}
@@ -83,123 +86,95 @@
 func (agent *DeviceAgent) getDevice() (*voltha.Device, error) {
 	agent.lockDevice.Lock()
 	defer agent.lockDevice.Unlock()
-	if device := agent.clusterDataProxy.Get(context.Background(), "/devices/"+agent.deviceId, 0, false, ""); device != nil {
+	if device := agent.clusterDataProxy.Get(context.Background(), "/devices/"+agent.deviceID, 0, false, ""); device != nil {
 		if d, ok := device.(*voltha.Device); ok {
 			cloned := proto.Clone(d).(*voltha.Device)
 			return cloned, nil
 		}
 	}
-	return nil, status.Errorf(codes.NotFound, "device-%s", agent.deviceId)
-}
-
-// getDeviceWithoutLock is a helper function to be used ONLY by any device agent function AFTER it has acquired the device lock.
-// This function is meant so that we do not have duplicate code all over the device agent functions
-func (agent *DeviceAgent) getDeviceWithoutLock() (*voltha.Device, error) {
-	if device := agent.clusterDataProxy.Get(context.Background(), "/devices/"+agent.deviceId, 0, false, ""); device != nil {
-		if d, ok := device.(*voltha.Device); ok {
-			cloned := proto.Clone(d).(*voltha.Device)
-			return cloned, nil
-		}
-	}
-	return nil, status.Errorf(codes.NotFound, "device-%s", agent.deviceId)
-}
-
-// getPorts retrieves the ports information of the device based on the port type.
-func (agent *DeviceAgent) getPorts(ctx context.Context, portType voltha.Port_PortType) *voltha.Ports {
-	log.Debugw("getPorts", log.Fields{"id": agent.deviceId, "portType": portType})
-	ports := &voltha.Ports{}
-	if device, _ := agent.deviceMgr.GetDevice(agent.deviceId); device != nil {
-		for _, port := range device.Ports {
-			if port.Type == portType {
-				ports.Items = append(ports.Items, port)
-			}
-		}
-	}
-	return ports
+	return nil, status.Errorf(codes.NotFound, "device-%s", agent.deviceID)
 }
 
 // ListDevicePorts retrieves the ports information for a particular device.
 func (agent *DeviceAgent) ListDevicePorts(ctx context.Context) (*voltha.Ports, error) {
-	log.Debugw("ListDevicePorts", log.Fields{"id": agent.deviceId})
+	log.Debugw("ListDevicePorts", log.Fields{"id": agent.deviceID})
 	ports := &voltha.Ports{}
-	if device, _ := agent.deviceMgr.GetDevice(agent.deviceId); device != nil {
-		for _, entry := range device.GetPorts() {
-			ports.Items = append(ports.Items, entry)
-		}
+	if device, _ := agent.deviceMgr.GetDevice(agent.deviceID); device != nil {
+		ports.Items = append(ports.Items, device.GetPorts()...)
 		return ports, nil
 	}
-	return nil, status.Errorf(codes.NotFound, "device-%s", agent.deviceId)
+	return nil, status.Errorf(codes.NotFound, "device-%s", agent.deviceID)
 }
 
 // ListDevicePmConfigs retrieves the ports information for a particular device.
 func (agent *DeviceAgent) ListDevicePmConfigs(ctx context.Context) (*voltha.PmConfigs, error) {
-	log.Debugw("ListDevicePmConfigs", log.Fields{"id": agent.deviceId})
-	if device, _ := agent.deviceMgr.GetDevice(agent.deviceId); device != nil {
+	log.Debugw("ListDevicePmConfigs", log.Fields{"id": agent.deviceID})
+	if device, _ := agent.deviceMgr.GetDevice(agent.deviceID); device != nil {
 		return device.GetPmConfigs(), nil
 	}
-	return nil, status.Errorf(codes.NotFound, "device-%s", agent.deviceId)
+	return nil, status.Errorf(codes.NotFound, "device-%s", agent.deviceID)
 }
 
 // ListDeviceFlows retrieves the ports information for a particular device.
 func (agent *DeviceAgent) ListDeviceFlows(ctx context.Context) (*voltha.Flows, error) {
-	log.Debugw("ListDeviceFlows", log.Fields{"id": agent.deviceId})
-	if device, _ := agent.deviceMgr.GetDevice(agent.deviceId); device != nil {
+	log.Debugw("ListDeviceFlows", log.Fields{"id": agent.deviceID})
+	if device, _ := agent.deviceMgr.GetDevice(agent.deviceID); device != nil {
 		return device.GetFlows(), nil
 	}
-	return nil, status.Errorf(codes.NotFound, "device-%s", agent.deviceId)
+	return nil, status.Errorf(codes.NotFound, "device-%s", agent.deviceID)
 }
 
-// ListDeviceFlows retrieves the ports information for a particular device.
+// ListDeviceFlowGroups retrieves the ports information for a particular device.
 func (agent *DeviceAgent) ListDeviceFlowGroups(ctx context.Context) (*voltha.FlowGroups, error) {
-	log.Debugw("ListDeviceFlowGroups", log.Fields{"id": agent.deviceId})
-	if device, _ := agent.deviceMgr.GetDevice(agent.deviceId); device != nil {
+	log.Debugw("ListDeviceFlowGroups", log.Fields{"id": agent.deviceID})
+	if device, _ := agent.deviceMgr.GetDevice(agent.deviceID); device != nil {
 		return device.GetFlowGroups(), nil
 	}
-	return nil, status.Errorf(codes.NotFound, "device-%s", agent.deviceId)
+	return nil, status.Errorf(codes.NotFound, "device-%s", agent.deviceID)
 }
 
 // GetImageDownloadStatus retrieves the download status of an image of a particular device.
 func (agent *DeviceAgent) GetImageDownloadStatus(ctx context.Context, imageName string) (*voltha.ImageDownload, error) {
-	log.Debugw("GetImageDownloadStatus", log.Fields{"id": agent.deviceId})
-	if device, _ := agent.deviceMgr.GetDevice(agent.deviceId); device != nil {
+	log.Debugw("GetImageDownloadStatus", log.Fields{"id": agent.deviceID})
+	if device, _ := agent.deviceMgr.GetDevice(agent.deviceID); device != nil {
 		for _, img := range device.GetImageDownloads() {
 			if img.GetName() == imageName {
 				return img, nil
 			}
 		}
-		return nil, status.Errorf(codes.NotFound, "device-%s, image-%s", agent.deviceId, imageName)
+		return nil, status.Errorf(codes.NotFound, "device-%s, image-%s", agent.deviceID, imageName)
 	}
-	return nil, status.Errorf(codes.NotFound, "device-%s", agent.deviceId)
+	return nil, status.Errorf(codes.NotFound, "device-%s", agent.deviceID)
 }
 
 // GetImageDownload retrieves the image download for a particular device.
 func (agent *DeviceAgent) GetImageDownload(ctx context.Context, imageName string) (*voltha.ImageDownload, error) {
-	log.Debugw("GetImageDownload", log.Fields{"id": agent.deviceId})
-	if device, _ := agent.deviceMgr.GetDevice(agent.deviceId); device != nil {
+	log.Debugw("GetImageDownload", log.Fields{"id": agent.deviceID})
+	if device, _ := agent.deviceMgr.GetDevice(agent.deviceID); device != nil {
 		for _, img := range device.GetImageDownloads() {
 			if img.GetName() == imageName {
 				return img, nil
 			}
 		}
-		return nil, status.Errorf(codes.NotFound, "device-%s, image-%s", agent.deviceId, imageName)
+		return nil, status.Errorf(codes.NotFound, "device-%s, image-%s", agent.deviceID, imageName)
 	}
-	return nil, status.Errorf(codes.NotFound, "device-%s", agent.deviceId)
+	return nil, status.Errorf(codes.NotFound, "device-%s", agent.deviceID)
 }
 
 // ListImageDownloads retrieves the image downloads for a particular device.
 func (agent *DeviceAgent) ListImageDownloads(ctx context.Context) (*voltha.ImageDownloads, error) {
-	log.Debugw("ListImageDownloads", log.Fields{"id": agent.deviceId})
-	if device, _ := agent.deviceMgr.GetDevice(agent.deviceId); device != nil {
+	log.Debugw("ListImageDownloads", log.Fields{"id": agent.deviceID})
+	if device, _ := agent.deviceMgr.GetDevice(agent.deviceID); device != nil {
 		return &voltha.ImageDownloads{Items: device.GetImageDownloads()}, nil
 	}
-	return nil, status.Errorf(codes.NotFound, "device-%s", agent.deviceId)
+	return nil, status.Errorf(codes.NotFound, "device-%s", agent.deviceID)
 }
 
 // GetImages retrieves the list of images for a particular device.
 func (agent *DeviceAgent) GetImages(ctx context.Context) (*voltha.Images, error) {
-	log.Debugw("GetImages", log.Fields{"id": agent.deviceId})
-	if device, _ := agent.deviceMgr.GetDevice(agent.deviceId); device != nil {
+	log.Debugw("GetImages", log.Fields{"id": agent.deviceID})
+	if device, _ := agent.deviceMgr.GetDevice(agent.deviceID); device != nil {
 		return device.GetImages(), nil
 	}
-	return nil, status.Errorf(codes.NotFound, "device-%s", agent.deviceId)
+	return nil, status.Errorf(codes.NotFound, "device-%s", agent.deviceID)
 }
diff --git a/ro_core/core/device_agent_test.go b/ro_core/core/device_agent_test.go
index bb87fac..246737f 100644
--- a/ro_core/core/device_agent_test.go
+++ b/ro_core/core/device_agent_test.go
@@ -16,18 +16,19 @@
 package core
 
 import (
+	"testing"
+
 	"github.com/opencord/voltha-go/db/model"
 	"github.com/opencord/voltha-go/ro_core/config"
 	"github.com/opencord/voltha-lib-go/v2/pkg/db"
 	"github.com/opencord/voltha-protos/v2/go/voltha"
 	"github.com/stretchr/testify/assert"
-	"testing"
 )
 
 func TestNewDeviceAgent(t *testing.T) {
 
 	var core Core
-	core.instanceId = "ro_core"
+	core.instanceID = "ro_core"
 	core.config = config.NewROCoreFlags()
 	backend := db.Backend{
 		Client:     core.kvClient,
@@ -38,7 +39,7 @@
 		PathPrefix: "service/voltha"}
 	core.clusterDataRoot = model.NewRoot(&voltha.Voltha{}, &backend)
 	core.genericMgr = newModelProxyManager(core.clusterDataProxy)
-	core.deviceMgr = newDeviceManager(core.clusterDataProxy, core.instanceId)
+	core.deviceMgr = newDeviceManager(core.clusterDataProxy, core.instanceID)
 
 	devAgent := newDeviceAgent(&voltha.Device{Id: "new_device"}, core.deviceMgr, core.clusterDataProxy)
 	assert.NotNil(t, devAgent)
diff --git a/ro_core/core/device_manager.go b/ro_core/core/device_manager.go
index fd69705..634566c 100644
--- a/ro_core/core/device_manager.go
+++ b/ro_core/core/device_manager.go
@@ -13,31 +13,34 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package core
 
 import (
 	"context"
+	"sync"
+
 	"github.com/opencord/voltha-go/db/model"
 	"github.com/opencord/voltha-lib-go/v2/pkg/log"
 	"github.com/opencord/voltha-lib-go/v2/pkg/probe"
 	"github.com/opencord/voltha-protos/v2/go/voltha"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
-	"sync"
 )
 
+// DeviceManager represents device manager related information
 type DeviceManager struct {
 	deviceAgents     sync.Map
 	logicalDeviceMgr *LogicalDeviceManager
 	clusterDataProxy *model.Proxy
-	coreInstanceId   string
+	coreInstanceID   string
 	exitChannel      chan int
 }
 
-func newDeviceManager(cdProxy *model.Proxy, coreInstanceId string) *DeviceManager {
+func newDeviceManager(cdProxy *model.Proxy, coreInstanceID string) *DeviceManager {
 	var deviceMgr DeviceManager
 	deviceMgr.exitChannel = make(chan int, 1)
-	deviceMgr.coreInstanceId = coreInstanceId
+	deviceMgr.coreInstanceID = coreInstanceID
 	deviceMgr.clusterDataProxy = cdProxy
 	return &deviceMgr
 }
@@ -69,31 +72,30 @@
 }
 
 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)
 	}
 }
 
 func (dMgr *DeviceManager) deleteDeviceAgentToMap(agent *DeviceAgent) {
-	dMgr.deviceAgents.Delete(agent.deviceId)
+	dMgr.deviceAgents.Delete(agent.deviceID)
 }
 
-func (dMgr *DeviceManager) getDeviceAgent(deviceId string) *DeviceAgent {
-	if agent, ok := dMgr.deviceAgents.Load(deviceId); ok {
+func (dMgr *DeviceManager) getDeviceAgent(deviceID string) *DeviceAgent {
+	if agent, ok := dMgr.deviceAgents.Load(deviceID); ok {
 		return agent.(*DeviceAgent)
-	} else {
-		//	Try to load into memory - loading will also create the device agent
-		if err := dMgr.load(deviceId); err == nil {
-			if agent, ok = dMgr.deviceAgents.Load(deviceId); ok {
-				return agent.(*DeviceAgent)
-			}
+	}
+	//	Try to load into memory - loading will also create the device agent
+	if err := dMgr.load(deviceID); err == nil {
+		if agent, ok := dMgr.deviceAgents.Load(deviceID); ok {
+			return agent.(*DeviceAgent)
 		}
 	}
 	return nil
 }
 
-// listDeviceIdsFromMap returns the list of device IDs that are in memory
-func (dMgr *DeviceManager) listDeviceIdsFromMap() *voltha.IDs {
+// listDeviceIDsFromMap returns the list of device IDs that are in memory
+func (dMgr *DeviceManager) listDeviceIDsFromMap() *voltha.IDs {
 	result := &voltha.IDs{Items: make([]*voltha.ID, 0)}
 	dMgr.deviceAgents.Range(func(key, value interface{}) bool {
 		result.Items = append(result.Items, &voltha.ID{Id: key.(string)})
@@ -111,11 +113,13 @@
 	return nil, status.Errorf(codes.NotFound, "%s", id)
 }
 
+// IsDeviceInCache returns true if device exists in cache
 func (dMgr *DeviceManager) IsDeviceInCache(id string) bool {
 	_, exist := dMgr.deviceAgents.Load(id)
 	return exist
 }
 
+// IsRootDevice returns true if root device is present in either memory or db
 func (dMgr *DeviceManager) IsRootDevice(id string) (bool, error) {
 	device, err := dMgr.GetDevice(id)
 	if err != nil {
@@ -133,9 +137,9 @@
 			// If device is not in memory then set it up
 			if !dMgr.IsDeviceInCache(device.(*voltha.Device).Id) {
 				agent := newDeviceAgent(device.(*voltha.Device), dMgr, dMgr.clusterDataProxy)
-				if err := agent.start(nil, true); err != nil {
-					log.Warnw("failure-starting-agent", log.Fields{"deviceId": device.(*voltha.Device).Id})
-					agent.stop(nil)
+				if err := agent.start(context.TODO(), true); err != nil {
+					log.Warnw("failure-starting-agent", log.Fields{"deviceID": device.(*voltha.Device).Id})
+					agent.stop(context.TODO())
 				} else {
 					dMgr.addDeviceAgentToMap(agent)
 				}
@@ -146,67 +150,67 @@
 	return result, nil
 }
 
-// loadDevice loads the deviceId in memory, if not present
-func (dMgr *DeviceManager) loadDevice(deviceId string) (*DeviceAgent, error) {
-	log.Debugw("loading-device", log.Fields{"deviceId": deviceId})
+// loadDevice loads the deviceID in memory, if not present
+func (dMgr *DeviceManager) loadDevice(deviceID string) (*DeviceAgent, error) {
+	log.Debugw("loading-device", log.Fields{"deviceID": deviceID})
 	// Sanity check
-	if deviceId == "" {
-		return nil, status.Error(codes.InvalidArgument, "deviceId empty")
+	if deviceID == "" {
+		return nil, status.Error(codes.InvalidArgument, "deviceID empty")
 	}
-	if !dMgr.IsDeviceInCache(deviceId) {
-		agent := newDeviceAgent(&voltha.Device{Id: deviceId}, dMgr, dMgr.clusterDataProxy)
-		if err := agent.start(nil, true); err != nil {
-			agent.stop(nil)
+	if !dMgr.IsDeviceInCache(deviceID) {
+		agent := newDeviceAgent(&voltha.Device{Id: deviceID}, dMgr, dMgr.clusterDataProxy)
+		if err := agent.start(context.TODO(), true); err != nil {
+			agent.stop(context.TODO())
 			return nil, err
 		}
 		dMgr.addDeviceAgentToMap(agent)
 	}
-	if agent := dMgr.getDeviceAgent(deviceId); agent != nil {
+	if agent := dMgr.getDeviceAgent(deviceID); agent != nil {
 		return agent, nil
 	}
-	return nil, status.Error(codes.NotFound, deviceId) // This should nto happen
+	return nil, status.Error(codes.NotFound, deviceID) // This should nto happen
 }
 
 // loadRootDeviceParentAndChildren loads the children and parents of a root device in memory
 func (dMgr *DeviceManager) loadRootDeviceParentAndChildren(device *voltha.Device) error {
-	log.Debugw("loading-parent-and-children", log.Fields{"deviceId": device.Id})
+	log.Debugw("loading-parent-and-children", log.Fields{"deviceID": device.Id})
 	if device.Root {
 		// Scenario A
 		if device.ParentId != "" {
 			//	 Load logical device if needed.
 			if err := dMgr.logicalDeviceMgr.load(device.ParentId); err != nil {
-				log.Warnw("failure-loading-logical-device", log.Fields{"lDeviceId": device.ParentId})
+				log.Warnw("failure-loading-logical-device", log.Fields{"lDeviceID": device.ParentId})
 			}
 		} else {
-			log.Debugw("no-parent-to-load", log.Fields{"deviceId": device.Id})
+			log.Debugw("no-parent-to-load", log.Fields{"deviceID": device.Id})
 		}
 		//	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})
+		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})
 					return err
 				}
 			}
-			log.Debugw("loaded-children", log.Fields{"deviceId": device.Id, "numChildren": len(childDeviceIds)})
+			log.Debugw("loaded-children", log.Fields{"deviceID": device.Id, "numChildren": len(childDeviceIDs)})
 		} else {
-			log.Debugw("no-child-to-load", log.Fields{"deviceId": device.Id})
+			log.Debugw("no-child-to-load", log.Fields{"deviceID": device.Id})
 		}
 	}
 	return nil
 }
 
-// load loads the deviceId in memory, if not present, and also loads its accompanying parents and children.  Loading
+// load loads the deviceID in memory, if not present, and also loads its accompanying parents and children.  Loading
 // 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 {
-		log.Warnw("failure-loading-device", log.Fields{"deviceId": deviceId})
+	if dAgent, err = dMgr.loadDevice(deviceID); err != nil {
+		log.Warnw("failure-loading-device", log.Fields{"deviceID": deviceID})
 		return err
 	}
 	// Get the loaded device details
@@ -224,12 +228,12 @@
 	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
+		//	Scenario B - use the parentID of that device (root device) to trigger the loading
 		if device.ParentId != "" {
 			return dMgr.load(device.ParentId)
 		}
@@ -237,11 +241,11 @@
 	return nil
 }
 
-// ListDeviceIds retrieves the latest device IDs information from the data model (memory data only)
-func (dMgr *DeviceManager) ListDeviceIds() (*voltha.IDs, error) {
+// ListDeviceIDs retrieves the latest device IDs information from the data model (memory data only)
+func (dMgr *DeviceManager) ListDeviceIDs() (*voltha.IDs, error) {
 	log.Debug("ListDeviceIDs")
 	// Report only device IDs that are in the device agent map
-	return dMgr.listDeviceIdsFromMap(), nil
+	return dMgr.listDeviceIDsFromMap(), nil
 }
 
 //ReconcileDevices is a request to a voltha core to managed a list of devices based on their IDs
@@ -254,19 +258,19 @@
 		for _, id := range ids.Items {
 			//	 Act on the device only if its not present in the agent map
 			if !dMgr.IsDeviceInCache(id.Id) {
-				//	Device Id not in memory
+				//	Device ID not in memory
 				log.Debugw("reconciling-device", log.Fields{"id": id.Id})
 				// Load device from dB
 				agent := newDeviceAgent(&voltha.Device{Id: id.Id}, dMgr, dMgr.clusterDataProxy)
-				if err := agent.start(nil, true); err != nil {
-					log.Warnw("failure-loading-device", log.Fields{"deviceId": id.Id})
-					agent.stop(nil)
+				if err := agent.start(context.TODO(), true); err != nil {
+					log.Warnw("failure-loading-device", log.Fields{"deviceID": id.Id})
+					agent.stop(context.TODO())
 				} else {
 					dMgr.addDeviceAgentToMap(agent)
-					reconciled += 1
+					reconciled++
 				}
 			} else {
-				reconciled += 1
+				reconciled++
 			}
 		}
 		if toReconcile != reconciled {
@@ -278,83 +282,82 @@
 	sendResponse(ctx, ch, res)
 }
 
-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)
-
-}
-
-func (dMgr *DeviceManager) ListDevicePorts(ctx context.Context, deviceId string) (*voltha.Ports, error) {
-	log.Debugw("ListDevicePorts", log.Fields{"deviceid": deviceId})
-	if agent := dMgr.getDeviceAgent(deviceId); agent != nil {
+// ListDevicePorts returns ports details for a specific device
+func (dMgr *DeviceManager) ListDevicePorts(ctx context.Context, deviceID string) (*voltha.Ports, error) {
+	log.Debugw("ListDevicePorts", log.Fields{"deviceid": deviceID})
+	if agent := dMgr.getDeviceAgent(deviceID); agent != nil {
 		return agent.ListDevicePorts(ctx)
 	}
-	return nil, status.Errorf(codes.NotFound, "%s", deviceId)
+	return nil, status.Errorf(codes.NotFound, "%s", deviceID)
 
 }
 
-func (dMgr *DeviceManager) ListDevicePmConfigs(ctx context.Context, deviceId string) (*voltha.PmConfigs, error) {
-	log.Debugw("ListDevicePmConfigs", log.Fields{"deviceid": deviceId})
-	if agent := dMgr.getDeviceAgent(deviceId); agent != nil {
+// ListDevicePmConfigs returns PM config details for a specific device
+func (dMgr *DeviceManager) ListDevicePmConfigs(ctx context.Context, deviceID string) (*voltha.PmConfigs, error) {
+	log.Debugw("ListDevicePmConfigs", log.Fields{"deviceid": deviceID})
+	if agent := dMgr.getDeviceAgent(deviceID); agent != nil {
 		return agent.ListDevicePmConfigs(ctx)
 	}
-	return nil, status.Errorf(codes.NotFound, "%s", deviceId)
+	return nil, status.Errorf(codes.NotFound, "%s", deviceID)
 
 }
 
-func (dMgr *DeviceManager) ListDeviceFlows(ctx context.Context, deviceId string) (*voltha.Flows, error) {
-	log.Debugw("ListDeviceFlows", log.Fields{"deviceid": deviceId})
-	if agent := dMgr.getDeviceAgent(deviceId); agent != nil {
+// ListDeviceFlows returns flow details for a specific device
+func (dMgr *DeviceManager) ListDeviceFlows(ctx context.Context, deviceID string) (*voltha.Flows, error) {
+	log.Debugw("ListDeviceFlows", log.Fields{"deviceid": deviceID})
+	if agent := dMgr.getDeviceAgent(deviceID); agent != nil {
 		return agent.ListDeviceFlows(ctx)
 	}
-	return nil, status.Errorf(codes.NotFound, "%s", deviceId)
+	return nil, status.Errorf(codes.NotFound, "%s", deviceID)
 }
 
-func (dMgr *DeviceManager) ListDeviceFlowGroups(ctx context.Context, deviceId string) (*voltha.FlowGroups, error) {
-	log.Debugw("ListDeviceFlowGroups", log.Fields{"deviceid": deviceId})
-	if agent := dMgr.getDeviceAgent(deviceId); agent != nil {
+// ListDeviceFlowGroups returns flow group details for a specific device
+func (dMgr *DeviceManager) ListDeviceFlowGroups(ctx context.Context, deviceID string) (*voltha.FlowGroups, error) {
+	log.Debugw("ListDeviceFlowGroups", log.Fields{"deviceid": deviceID})
+	if agent := dMgr.getDeviceAgent(deviceID); agent != nil {
 		return agent.ListDeviceFlowGroups(ctx)
 	}
-	return nil, status.Errorf(codes.NotFound, "%s", deviceId)
+	return nil, status.Errorf(codes.NotFound, "%s", deviceID)
 
 }
 
-func (dMgr *DeviceManager) GetImageDownloadStatus(ctx context.Context, deviceId string, imageName string) (*voltha.ImageDownload, error) {
-	log.Debugw("GetImageDownloadStatus", log.Fields{"deviceid": deviceId, "imagename": imageName})
-	if agent := dMgr.getDeviceAgent(deviceId); agent != nil {
+// GetImageDownloadStatus returns the download status of an image of a particular device
+func (dMgr *DeviceManager) GetImageDownloadStatus(ctx context.Context, deviceID string, imageName string) (*voltha.ImageDownload, error) {
+	log.Debugw("GetImageDownloadStatus", log.Fields{"deviceid": deviceID, "imagename": imageName})
+	if agent := dMgr.getDeviceAgent(deviceID); agent != nil {
 		return agent.GetImageDownloadStatus(ctx, imageName)
 	}
-	return nil, status.Errorf(codes.NotFound, "%s", deviceId)
+	return nil, status.Errorf(codes.NotFound, "%s", deviceID)
 
 }
 
-func (dMgr *DeviceManager) GetImageDownload(ctx context.Context, deviceId string, imageName string) (*voltha.ImageDownload, error) {
-	log.Debugw("GetImageDownload", log.Fields{"deviceid": deviceId, "imagename": imageName})
-	if agent := dMgr.getDeviceAgent(deviceId); agent != nil {
+// GetImageDownload return the download details for a specific image entry
+func (dMgr *DeviceManager) GetImageDownload(ctx context.Context, deviceID string, imageName string) (*voltha.ImageDownload, error) {
+	log.Debugw("GetImageDownload", log.Fields{"deviceid": deviceID, "imagename": imageName})
+	if agent := dMgr.getDeviceAgent(deviceID); agent != nil {
 		return agent.GetImageDownload(ctx, imageName)
 	}
-	return nil, status.Errorf(codes.NotFound, "%s", deviceId)
+	return nil, status.Errorf(codes.NotFound, "%s", 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 {
+// ListImageDownloads returns all image downloads known to the system
+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)
 	}
-	return nil, status.Errorf(codes.NotFound, "%s", deviceId)
+	return nil, status.Errorf(codes.NotFound, "%s", deviceID)
 
 }
 
-func (dMgr *DeviceManager) GetImages(ctx context.Context, deviceId string) (*voltha.Images, error) {
-	log.Debugw("GetImages", log.Fields{"deviceid": deviceId})
-	if agent := dMgr.getDeviceAgent(deviceId); agent != nil {
+// GetImages returns all images for a specific device entry
+func (dMgr *DeviceManager) GetImages(ctx context.Context, deviceID string) (*voltha.Images, error) {
+	log.Debugw("GetImages", log.Fields{"deviceid": deviceID})
+	if agent := dMgr.getDeviceAgent(deviceID); agent != nil {
 		return agent.GetImages(ctx)
 	}
-	return nil, status.Errorf(codes.NotFound, "%s", deviceId)
+	return nil, status.Errorf(codes.NotFound, "%s", deviceID)
 
 }
 
@@ -368,16 +371,16 @@
 	return parentDevice
 }
 
-//getAllChildDeviceIds is a helper method to get all the child device IDs from the device passed as parameter
-func (dMgr *DeviceManager) getAllChildDeviceIds(parentDevice *voltha.Device) ([]string, error) {
-	log.Debugw("getAllChildDeviceIds", log.Fields{"parentDeviceId": parentDevice.Id})
-	childDeviceIds := make([]string, 0)
+//getAllChildDeviceIDs is a helper method to get all the child device IDs from the device passed as parameter
+func (dMgr *DeviceManager) getAllChildDeviceIDs(parentDevice *voltha.Device) ([]string, error) {
+	log.Debugw("getAllChildDeviceIDs", log.Fields{"parentDeviceID": parentDevice.Id})
+	childDeviceIDs := make([]string, 0)
 	if parentDevice != nil {
 		for _, port := range parentDevice.Ports {
 			for _, peer := range port.Peers {
-				childDeviceIds = append(childDeviceIds, peer.DeviceId)
+				childDeviceIDs = append(childDeviceIDs, peer.DeviceId)
 			}
 		}
 	}
-	return childDeviceIds, nil
+	return childDeviceIDs, nil
 }
diff --git a/ro_core/core/device_manager_test.go b/ro_core/core/device_manager_test.go
index cef848c..da58e67 100644
--- a/ro_core/core/device_manager_test.go
+++ b/ro_core/core/device_manager_test.go
@@ -16,17 +16,18 @@
 package core
 
 import (
+	"testing"
+
 	"github.com/opencord/voltha-go/db/model"
 	"github.com/opencord/voltha-go/ro_core/config"
 	"github.com/opencord/voltha-lib-go/v2/pkg/db"
 	"github.com/opencord/voltha-protos/v2/go/voltha"
 	"github.com/stretchr/testify/assert"
-	"testing"
 )
 
 func MakeTestDevManagerConfig() (*Core, error) {
 	var core Core
-	core.instanceId = "ro_core"
+	core.instanceID = "ro_core"
 	core.config = config.NewROCoreFlags()
 	backend := db.Backend{
 		Client:     core.kvClient,
@@ -44,7 +45,7 @@
 
 	core, _ := MakeTestDevManagerConfig()
 
-	core.deviceMgr = newDeviceManager(core.clusterDataProxy, core.instanceId)
+	core.deviceMgr = newDeviceManager(core.clusterDataProxy, core.instanceID)
 	assert.NotNil(t, core.deviceMgr)
 }
 
@@ -52,10 +53,10 @@
 
 	core, _ := MakeTestDevManagerConfig()
 
-	core.deviceMgr = newDeviceManager(core.clusterDataProxy, core.instanceId)
+	core.deviceMgr = newDeviceManager(core.clusterDataProxy, core.instanceID)
 	assert.NotNil(t, core.deviceMgr)
 
-	myIds, _ := core.deviceMgr.ListDeviceIds()
+	myIds, _ := core.deviceMgr.ListDeviceIDs()
 	assert.NotNil(t, myIds)
 }
 
@@ -67,7 +68,7 @@
 
 	core, _ := MakeTestDevManagerConfig()
 
-	core.deviceMgr = newDeviceManager(core.clusterDataProxy, core.instanceId)
+	core.deviceMgr = newDeviceManager(core.clusterDataProxy, core.instanceID)
 	assert.NotNil(t, core.deviceMgr)
 
 	devAgent := newDeviceAgent(&voltha.Device{Id: "new_device"}, core.deviceMgr, core.clusterDataProxy)
@@ -77,11 +78,11 @@
 	core.deviceMgr.addDeviceAgentToMap(devAgent)
 
 	// listDeviceIdsFromMap
-	myIDs := core.deviceMgr.listDeviceIdsFromMap()
+	myIDs := core.deviceMgr.listDeviceIDsFromMap()
 	assert.NotNil(t, myIDs)
 
 	// getDeviceAgent
-	myDevAgent := core.deviceMgr.getDeviceAgent(devAgent.deviceId)
+	myDevAgent := core.deviceMgr.getDeviceAgent(devAgent.deviceID)
 	assert.NotNil(t, myDevAgent)
 
 	// deleteDeviceAgentToMap
@@ -92,7 +93,7 @@
 
 	core, _ := MakeTestDevManagerConfig()
 
-	core.deviceMgr = newDeviceManager(core.clusterDataProxy, core.instanceId)
+	core.deviceMgr = newDeviceManager(core.clusterDataProxy, core.instanceID)
 	assert.NotNil(t, core.deviceMgr)
 
 	devAgent := newDeviceAgent(&voltha.Device{Id: "new_device"}, core.deviceMgr, core.clusterDataProxy)
@@ -114,7 +115,7 @@
 
 	core, _ := MakeTestDevManagerConfig()
 
-	core.deviceMgr = newDeviceManager(core.clusterDataProxy, core.instanceId)
+	core.deviceMgr = newDeviceManager(core.clusterDataProxy, core.instanceID)
 	assert.NotNil(t, core.deviceMgr)
 
 	devAgent := newDeviceAgent(&voltha.Device{Id: "new_device"}, core.deviceMgr, core.clusterDataProxy)
@@ -123,13 +124,13 @@
 	// addDeviceAgentToMap
 	core.deviceMgr.addDeviceAgentToMap(devAgent)
 
-	isInCache := core.deviceMgr.IsDeviceInCache(devAgent.deviceId)
+	isInCache := core.deviceMgr.IsDeviceInCache(devAgent.deviceID)
 	assert.True(t, isInCache)
 
 	// deleteDeviceAgentToMap
 	core.deviceMgr.deleteDeviceAgentToMap(devAgent)
 
-	isInCacheDel := core.deviceMgr.IsDeviceInCache(devAgent.deviceId)
+	isInCacheDel := core.deviceMgr.IsDeviceInCache(devAgent.deviceID)
 	assert.False(t, isInCacheDel)
 }
 
@@ -137,7 +138,7 @@
 
 	core, _ := MakeTestDevManagerConfig()
 
-	core.deviceMgr = newDeviceManager(core.clusterDataProxy, core.instanceId)
+	core.deviceMgr = newDeviceManager(core.clusterDataProxy, core.instanceID)
 	assert.NotNil(t, core.deviceMgr)
 
 	devAgent := newDeviceAgent(&voltha.Device{Id: "new_device"}, core.deviceMgr, core.clusterDataProxy)
@@ -154,7 +155,7 @@
 
 	core, _ := MakeTestDevManagerConfig()
 
-	core.deviceMgr = newDeviceManager(core.clusterDataProxy, core.instanceId)
+	core.deviceMgr = newDeviceManager(core.clusterDataProxy, core.instanceID)
 	assert.NotNil(t, core.deviceMgr)
 
 	devAgent := newDeviceAgent(&voltha.Device{Id: "new_device"}, core.deviceMgr, core.clusterDataProxy)
@@ -171,7 +172,7 @@
 
 	core, _ := MakeTestDevManagerConfig()
 
-	core.deviceMgr = newDeviceManager(core.clusterDataProxy, core.instanceId)
+	core.deviceMgr = newDeviceManager(core.clusterDataProxy, core.instanceID)
 	assert.NotNil(t, core.deviceMgr)
 
 	devAgent := newDeviceAgent(&voltha.Device{Id: "new_device"}, core.deviceMgr, core.clusterDataProxy)
@@ -180,7 +181,7 @@
 	// addDeviceAgentToMap
 	core.deviceMgr.addDeviceAgentToMap(devAgent)
 
-	myIds, err := core.deviceMgr.getAllChildDeviceIds(devAgent.lastData)
+	myIds, err := core.deviceMgr.getAllChildDeviceIDs(devAgent.lastData)
 	assert.NotNil(t, myIds)
 	assert.Nil(t, err)
 }
diff --git a/ro_core/core/grpc_nbi_api_handler.go b/ro_core/core/grpc_nbi_api_handler.go
index 335623d..ee8d736 100644
--- a/ro_core/core/grpc_nbi_api_handler.go
+++ b/ro_core/core/grpc_nbi_api_handler.go
@@ -13,11 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package core
 
 import (
 	"context"
 	"errors"
+
 	"github.com/golang/protobuf/ptypes/empty"
 	da "github.com/opencord/voltha-go/common/core/northbound/grpc"
 	"github.com/opencord/voltha-lib-go/v2/pkg/log"
@@ -30,6 +32,7 @@
 	"google.golang.org/grpc/status"
 )
 
+// APIHandler represents API handler related information
 type APIHandler struct {
 	commonMgr        *ModelProxyManager
 	deviceMgr        *DeviceManager
@@ -37,6 +40,7 @@
 	da.DefaultAPIHandler
 }
 
+// NewAPIHandler creates API handler
 func NewAPIHandler(generalMgr *ModelProxyManager, deviceMgr *DeviceManager, lDeviceMgr *LogicalDeviceManager) *APIHandler {
 	handler := &APIHandler{
 		commonMgr:        generalMgr,
@@ -73,7 +77,8 @@
 	}
 }
 
-func (handler *APIHandler) UpdateLogLevel(ctx context.Context, logging *voltha.Logging) (*empty.Empty, error) {
+// UpdateLogLevel updates log level to the requested level in specific packaged if mentioned
+func (*APIHandler) UpdateLogLevel(ctx context.Context, logging *voltha.Logging) (*empty.Empty, error) {
 	log.Debugw("UpdateLogLevel-request", log.Fields{"package": logging.PackageName, "intval": int(logging.Level)})
 	out := new(empty.Empty)
 	if logging.PackageName == "" {
@@ -88,7 +93,8 @@
 	return out, nil
 }
 
-func (aa APIHandler) GetLogLevels(ctx context.Context, in *voltha.LoggingComponent) (*voltha.Loggings, error) {
+// GetLogLevels returns log levels for requested packages
+func (APIHandler) GetLogLevels(ctx context.Context, in *voltha.LoggingComponent) (*voltha.Loggings, error) {
 	logLevels := &voltha.Loggings{}
 
 	// do the per-package log levels
@@ -157,7 +163,7 @@
 		out := &voltha.IDs{Items: make([]*voltha.ID, 0)}
 		return out, nil
 	}
-	return handler.deviceMgr.ListDeviceIds()
+	return handler.deviceMgr.ListDeviceIDs()
 }
 
 // ListDevicePorts returns the ports details for a specific device entry
@@ -287,6 +293,7 @@
 	return handler.logicalDeviceMgr.ListLogicalDeviceFlowGroups(ctx, id.Id)
 }
 
+// SelfTest - TODO
 func (handler *APIHandler) SelfTest(ctx context.Context, id *voltha.ID) (*voltha.SelfTestResponse, error) {
 	log.Debugw("SelfTest-request", log.Fields{"id": id})
 	if isTestMode(ctx) {
@@ -296,7 +303,7 @@
 	return nil, errors.New("UnImplemented")
 }
 
-//@TODO useless stub, what should this actually do?
+// GetAlarmDeviceData - @TODO useless stub, what should this actually do?
 func (handler *APIHandler) GetAlarmDeviceData(
 	ctx context.Context,
 	in *common.ID,
@@ -305,7 +312,7 @@
 	return nil, nil
 }
 
-//@TODO useless stub, what should this actually do?
+// GetMeterStatsOfLogicalDevice - @TODO useless stub, what should this actually do?
 func (handler *APIHandler) GetMeterStatsOfLogicalDevice(
 	ctx context.Context,
 	in *common.ID,
@@ -314,7 +321,7 @@
 	return nil, nil
 }
 
-//@TODO useless stub, what should this actually do?
+// GetMibDeviceData - @TODO useless stub, what should this actually do?
 func (handler *APIHandler) GetMibDeviceData(
 	ctx context.Context,
 	in *common.ID,
@@ -323,7 +330,7 @@
 	return nil, nil
 }
 
-//@TODO useless stub, what should this actually do?
+// SimulateAlarm - @TODO useless stub, what should this actually do?
 func (handler *APIHandler) SimulateAlarm(
 	ctx context.Context,
 	in *voltha.SimulateAlarmRequest,
diff --git a/ro_core/core/grpc_nbi_api_handler_test.go b/ro_core/core/grpc_nbi_api_handler_test.go
index bc40ce8..3244fd3 100644
--- a/ro_core/core/grpc_nbi_api_handler_test.go
+++ b/ro_core/core/grpc_nbi_api_handler_test.go
@@ -17,14 +17,15 @@
 
 import (
 	"context"
+	"strconv"
+	"testing"
+
 	"github.com/opencord/voltha-go/ro_core/config"
 	"github.com/opencord/voltha-lib-go/v2/pkg/log"
 	"github.com/opencord/voltha-protos/v2/go/common"
 	"github.com/opencord/voltha-protos/v2/go/voltha"
 	"github.com/phayes/freeport"
 	"github.com/stretchr/testify/assert"
-	"strconv"
-	"testing"
 )
 
 func MakeTestGrpcNbiConfig() *Core {
@@ -77,7 +78,7 @@
 		ComponentName: "testing",
 		PackageName:   "testing",
 		Level:         voltha.LogLevel_LogLevel(log.GetDefaultLogLevel())}
-	testLog_3 := &voltha.Logging{
+	testLog3 := &voltha.Logging{
 		ComponentName: "testing",
 		PackageName:   "github.com/opencord/voltha-go/ro_core/core",
 		Level:         3 /*voltha.LogLevel_LogLevel(log.GetDefaultLogLevel())*/}
@@ -97,7 +98,7 @@
 		{"TestUpdateLogLevel-1", ahndl, args{testCtx, testLogDef}, 0, nil},
 		{"TestUpdateLogLevel-2", ahndl, args{testCtx, testLogEmpty}, 5, nil},
 		{"TestUpdateLogLevel-3", ahndl, args{testCtx, testLog}, 5, nil},
-		{"TestUpdateLogLevel-4", ahndl, args{testCtx, testLog_3}, 3, nil},
+		{"TestUpdateLogLevel-4", ahndl, args{testCtx, testLog3}, 3, nil},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
diff --git a/ro_core/core/logical_device_agent.go b/ro_core/core/logical_device_agent.go
index 635379a..829aa6b 100644
--- a/ro_core/core/logical_device_agent.go
+++ b/ro_core/core/logical_device_agent.go
@@ -13,23 +13,26 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package core
 
 import (
 	"context"
+	"sync"
+
 	"github.com/gogo/protobuf/proto"
 	"github.com/opencord/voltha-go/db/model"
 	"github.com/opencord/voltha-lib-go/v2/pkg/log"
 	"github.com/opencord/voltha-protos/v2/go/voltha"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
-	"sync"
 )
 
+// LogicalDeviceAgent represents logical device agent related information
 type LogicalDeviceAgent struct {
-	logicalDeviceId   string
+	logicalDeviceID   string
 	lastData          *voltha.LogicalDevice
-	rootDeviceId      string
+	rootDeviceID      string
 	deviceMgr         *DeviceManager
 	ldeviceMgr        *LogicalDeviceManager
 	clusterDataProxy  *model.Proxy
@@ -37,11 +40,11 @@
 	lockLogicalDevice sync.RWMutex
 }
 
-func newLogicalDeviceAgent(id string, deviceId string, ldeviceMgr *LogicalDeviceManager, deviceMgr *DeviceManager, cdProxy *model.Proxy) *LogicalDeviceAgent {
+func newLogicalDeviceAgent(id string, deviceID string, ldeviceMgr *LogicalDeviceManager, deviceMgr *DeviceManager, cdProxy *model.Proxy) *LogicalDeviceAgent {
 	var agent LogicalDeviceAgent
 	agent.exitChannel = make(chan int, 1)
-	agent.logicalDeviceId = id
-	agent.rootDeviceId = deviceId
+	agent.logicalDeviceID = id
+	agent.rootDeviceID = deviceID
 	agent.deviceMgr = deviceMgr
 	agent.clusterDataProxy = cdProxy
 	agent.ldeviceMgr = ldeviceMgr
@@ -51,19 +54,19 @@
 
 // start creates the logical device and add it to the data model
 func (agent *LogicalDeviceAgent) start(ctx context.Context, loadFromDb bool) error {
-	log.Infow("starting-logical_device-agent", log.Fields{"logicaldeviceId": agent.logicalDeviceId, "loadFromdB": loadFromDb})
+	log.Infow("starting-logical_device-agent", log.Fields{"logicaldeviceID": agent.logicalDeviceID, "loadFromdB": loadFromDb})
 	agent.lockLogicalDevice.Lock()
 	defer agent.lockLogicalDevice.Unlock()
 	if loadFromDb {
 		//	load from dB - the logical may not exist at this time.  On error, just return and the calling function
 		// will destroy this agent.
-		if logicalDevice := agent.clusterDataProxy.Get(ctx, "/logical_devices/"+agent.logicalDeviceId, 0, false, ""); logicalDevice != nil {
+		if logicalDevice := agent.clusterDataProxy.Get(ctx, "/logical_devices/"+agent.logicalDeviceID, 0, false, ""); logicalDevice != nil {
 			if lDevice, ok := logicalDevice.(*voltha.LogicalDevice); ok {
 				agent.lastData = proto.Clone(lDevice).(*voltha.LogicalDevice)
 			}
 		} else {
-			log.Errorw("failed-to-load-device", log.Fields{"logicaldeviceId": agent.logicalDeviceId})
-			return status.Errorf(codes.NotFound, "logicaldeviceId-%s", agent.logicalDeviceId)
+			log.Errorw("failed-to-load-device", log.Fields{"logicaldeviceID": agent.logicalDeviceID})
+			return status.Errorf(codes.NotFound, "logicaldeviceID-%s", agent.logicalDeviceID)
 		}
 	}
 	log.Info("logical_device-agent-started")
@@ -85,40 +88,39 @@
 	log.Debug("GetLogicalDevice")
 	agent.lockLogicalDevice.Lock()
 	defer agent.lockLogicalDevice.Unlock()
-	if logicalDevice := agent.clusterDataProxy.Get(context.Background(), "/logical_devices/"+agent.logicalDeviceId, 0, false, ""); logicalDevice != nil {
+	if logicalDevice := agent.clusterDataProxy.Get(context.Background(), "/logical_devices/"+agent.logicalDeviceID, 0, false, ""); logicalDevice != nil {
 		if lDevice, ok := logicalDevice.(*voltha.LogicalDevice); ok {
 			return lDevice, nil
 		}
 	}
-	return nil, status.Errorf(codes.NotFound, "logical_device-%s", agent.logicalDeviceId)
+	return nil, status.Errorf(codes.NotFound, "logical_device-%s", agent.logicalDeviceID)
 }
 
+// ListLogicalDevicePorts returns all logical device ports details
 func (agent *LogicalDeviceAgent) ListLogicalDevicePorts() (*voltha.LogicalPorts, error) {
 	log.Debug("ListLogicalDevicePorts")
-	if logicalDevice, _ := agent.ldeviceMgr.getLogicalDevice(agent.logicalDeviceId); logicalDevice != nil {
+	if logicalDevice, _ := agent.ldeviceMgr.getLogicalDevice(agent.logicalDeviceID); logicalDevice != nil {
 		lPorts := make([]*voltha.LogicalPort, 0)
-		for _, port := range logicalDevice.Ports {
-			lPorts = append(lPorts, port)
-		}
+		lPorts = append(lPorts, logicalDevice.Ports...)
 		return &voltha.LogicalPorts{Items: lPorts}, nil
 	}
-	return nil, status.Errorf(codes.NotFound, "logical_device-%s", agent.logicalDeviceId)
+	return nil, status.Errorf(codes.NotFound, "logical_device-%s", agent.logicalDeviceID)
 }
 
-// listFlows locks the logical device model and then retrieves the latest flow information
+// ListLogicalDeviceFlows - listFlows locks the logical device model and then retrieves the latest flow information
 func (agent *LogicalDeviceAgent) ListLogicalDeviceFlows() (*voltha.Flows, error) {
 	log.Debug("ListLogicalDeviceFlows")
-	if logicalDevice, _ := agent.ldeviceMgr.getLogicalDevice(agent.logicalDeviceId); logicalDevice != nil {
+	if logicalDevice, _ := agent.ldeviceMgr.getLogicalDevice(agent.logicalDeviceID); logicalDevice != nil {
 		return logicalDevice.GetFlows(), nil
 	}
-	return nil, status.Errorf(codes.NotFound, "logical_device-%s", agent.logicalDeviceId)
+	return nil, status.Errorf(codes.NotFound, "logical_device-%s", agent.logicalDeviceID)
 }
 
-// listFlowGroups locks the logical device model and then retrieves the latest flow groups information
+// ListLogicalDeviceFlowGroups - listFlowGroups locks the logical device model and then retrieves the latest flow groups information
 func (agent *LogicalDeviceAgent) ListLogicalDeviceFlowGroups() (*voltha.FlowGroups, error) {
 	log.Debug("ListLogicalDeviceFlowGroups")
-	if logicalDevice, _ := agent.ldeviceMgr.getLogicalDevice(agent.logicalDeviceId); logicalDevice != nil {
+	if logicalDevice, _ := agent.ldeviceMgr.getLogicalDevice(agent.logicalDeviceID); logicalDevice != nil {
 		return logicalDevice.GetFlowGroups(), nil
 	}
-	return nil, status.Errorf(codes.NotFound, "logical_device-%s", agent.logicalDeviceId)
+	return nil, status.Errorf(codes.NotFound, "logical_device-%s", agent.logicalDeviceID)
 }
diff --git a/ro_core/core/logical_device_manager.go b/ro_core/core/logical_device_manager.go
index d12c2a5..97bc603 100644
--- a/ro_core/core/logical_device_manager.go
+++ b/ro_core/core/logical_device_manager.go
@@ -13,19 +13,22 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package core
 
 import (
 	"context"
+	"sync"
+
 	"github.com/opencord/voltha-go/db/model"
 	"github.com/opencord/voltha-lib-go/v2/pkg/log"
 	"github.com/opencord/voltha-lib-go/v2/pkg/probe"
 	"github.com/opencord/voltha-protos/v2/go/voltha"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
-	"sync"
 )
 
+// LogicalDeviceManager represents logical device manager related information
 type LogicalDeviceManager struct {
 	logicalDeviceAgents        sync.Map
 	deviceMgr                  *DeviceManager
@@ -62,29 +65,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)
 	}
 }
 
 // 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
@@ -109,24 +112,24 @@
 }
 
 // load loads a logical device manager in memory
-func (ldMgr *LogicalDeviceManager) load(lDeviceId string) error {
-	log.Debugw("loading-logical-device", log.Fields{"lDeviceId": lDeviceId})
+func (ldMgr *LogicalDeviceManager) load(lDeviceID string) error {
+	log.Debugw("loading-logical-device", log.Fields{"lDeviceID": lDeviceID})
 	// To prevent a race condition, let's hold the logical device agent map lock.  This will prevent a loading and
 	// a create logical device callback from occurring at the same time.
-	if ldAgent, _ := ldMgr.logicalDeviceAgents.Load(lDeviceId); ldAgent == nil {
+	if ldAgent, _ := ldMgr.logicalDeviceAgents.Load(lDeviceID); ldAgent == nil {
 		// Logical device not in memory - create a temp logical device Agent and let it load from memory
-		agent := newLogicalDeviceAgent(lDeviceId, "", ldMgr, ldMgr.deviceMgr, ldMgr.clusterDataProxy)
-		if err := agent.start(nil, true); err != nil {
-			agent.stop(nil)
+		agent := newLogicalDeviceAgent(lDeviceID, "", ldMgr, ldMgr.deviceMgr, ldMgr.clusterDataProxy)
+		if err := agent.start(context.TODO(), true); err != nil {
+			agent.stop(context.TODO())
 			return err
 		}
-		ldMgr.logicalDeviceAgents.Store(agent.logicalDeviceId, agent)
+		ldMgr.logicalDeviceAgents.Store(agent.logicalDeviceID, agent)
 	}
 	// TODO: load the child device
 	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
@@ -140,26 +143,27 @@
 	return nil, status.Errorf(codes.NotFound, "%s", device.Id)
 }
 
-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)
 }
 
+// ListLogicalDevicePorts returns port details for a specific logical device entry
 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 {
@@ -169,6 +173,7 @@
 
 }
 
+// ListLogicalDeviceFlows returns flow details for a specific logical device entry
 func (ldMgr *LogicalDeviceManager) ListLogicalDeviceFlows(ctx context.Context, id string) (*voltha.Flows, error) {
 	log.Debugw("ListLogicalDeviceFlows", log.Fields{"logicaldeviceid": id})
 	if agent := ldMgr.getLogicalDeviceAgent(id); agent != nil {
@@ -178,6 +183,7 @@
 
 }
 
+// ListLogicalDeviceFlowGroups returns flow group details for a specific logical device entry
 func (ldMgr *LogicalDeviceManager) ListLogicalDeviceFlowGroups(ctx context.Context, id string) (*voltha.FlowGroups, error) {
 	log.Debugw("ListLogicalDeviceFlowGroups", log.Fields{"logicaldeviceid": id})
 	if agent := ldMgr.getLogicalDeviceAgent(id); agent != nil {
@@ -187,18 +193,18 @@
 
 }
 
-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)
 }
diff --git a/ro_core/core/logical_device_manager_test.go b/ro_core/core/logical_device_manager_test.go
index b9fb2a1..e7b33bc 100644
--- a/ro_core/core/logical_device_manager_test.go
+++ b/ro_core/core/logical_device_manager_test.go
@@ -17,23 +17,24 @@
 
 import (
 	"context"
+	"reflect"
+	"testing"
+
 	"github.com/opencord/voltha-go/db/model"
 	"github.com/opencord/voltha-go/ro_core/config"
 	"github.com/opencord/voltha-protos/v2/go/openflow_13"
 	"github.com/opencord/voltha-protos/v2/go/voltha"
 	"github.com/stretchr/testify/assert"
-	"reflect"
-	"testing"
 )
 
 func MakeTestNewCoreConfig() *Core {
 	var core Core
-	core.instanceId = "ro_core"
+	core.instanceID = "ro_core"
 	core.config = config.NewROCoreFlags()
 	core.clusterDataRoot = model.NewRoot(&voltha.Voltha{}, nil)
 	core.clusterDataProxy = core.clusterDataRoot.CreateProxy(context.Background(), "/", false)
 	core.genericMgr = newModelProxyManager(core.clusterDataProxy)
-	core.deviceMgr = newDeviceManager(core.clusterDataProxy, core.instanceId)
+	core.deviceMgr = newDeviceManager(core.clusterDataProxy, core.instanceID)
 
 	return &core
 }
@@ -62,7 +63,7 @@
 	// Verify ADD is successful
 	ldAgentNotNil := ldMgr.getLogicalDeviceAgent("id")
 	assert.NotNil(t, ldAgentNotNil)
-	assert.Equal(t, "id", ldAgentNotNil.logicalDeviceId)
+	assert.Equal(t, "id", ldAgentNotNil.logicalDeviceID)
 }
 
 func TestGetLogicalDeviceAgent(t *testing.T) {
@@ -80,7 +81,7 @@
 	ldMgr.addLogicalDeviceAgentToMap(ldAgent)
 	ldAgentNotNil := ldMgr.getLogicalDeviceAgent("id")
 	assert.NotNil(t, ldAgentNotNil)
-	assert.Equal(t, "id", ldAgentNotNil.logicalDeviceId)
+	assert.Equal(t, "id", ldAgentNotNil.logicalDeviceID)
 }
 
 func TestDeleteLogicalDeviceAgent(t *testing.T) {
@@ -102,7 +103,7 @@
 	// Verify ADD is successful
 	ldAgentNotNil := ldMgr.getLogicalDeviceAgent("id")
 	assert.NotNil(t, ldAgentNotNil)
-	assert.Equal(t, "id", ldAgentNotNil.logicalDeviceId)
+	assert.Equal(t, "id", ldAgentNotNil.logicalDeviceID)
 
 	// Method under Test
 	ldMgr.deleteLogicalDeviceAgent("id")
@@ -142,7 +143,7 @@
 	// Verify Add is successful
 	ldAgentNotNil := ldMgr.getLogicalDeviceAgent("id")
 	assert.NotNil(t, ldAgentNotNil)
-	assert.Equal(t, "id", ldAgentNotNil.logicalDeviceId)
+	assert.Equal(t, "id", ldAgentNotNil.logicalDeviceID)
 
 	// Verify getLogicalDevice() is NOT NIL
 	logicalDevNotNil, errNil := ldMgr.getLogicalDevice("id")
@@ -187,12 +188,12 @@
 	assert.NotNil(t, ldMgr)
 
 	/*** Case: Logical Device Id Found ***/
-	result0, error0 := ldMgr.getLogicalDeviceId(&voltha.Device{Id: "id", Root: true, ParentId: "parent_id"})
+	result0, error0 := ldMgr.getLogicalDeviceID(&voltha.Device{Id: "id", Root: true, ParentId: "parent_id"})
 	assert.NotNil(t, result0)
 	assert.Nil(t, error0)
 
 	/*** Case: Logical Device Id Not Found ***/
-	result1, error1 := ldMgr.getLogicalDeviceId(&voltha.Device{Id: "id", ParentId: "parent_id"})
+	result1, error1 := ldMgr.getLogicalDeviceID(&voltha.Device{Id: "id", ParentId: "parent_id"})
 	assert.Nil(t, result1)
 	assert.NotNil(t, error1)
 }
@@ -205,12 +206,12 @@
 	assert.NotNil(t, ldMgr)
 
 	/*** Case: Logical Port Id Not Found: getLogicalDeviceId() Error ***/
-	result0, error0 := ldMgr.getLogicalPortId(&voltha.Device{Id: "id", ParentId: "parent_id"})
+	result0, error0 := ldMgr.getLogicalPortID(&voltha.Device{Id: "id", ParentId: "parent_id"})
 	assert.Nil(t, result0)
 	assert.NotNil(t, error0)
 
 	/*** Case: Logical Port Id Not Found: getLogicalDevice() Error ***/
-	result1, error1 := ldMgr.getLogicalPortId(&voltha.Device{Id: "id", Root: true, ParentId: "parent_id"})
+	result1, error1 := ldMgr.getLogicalPortID(&voltha.Device{Id: "id", Root: true, ParentId: "parent_id"})
 	assert.Nil(t, result1)
 	assert.NotNil(t, error1)
 
@@ -240,10 +241,10 @@
 	// Verify Add is successful
 	ldAgentNotNil := ldMgr.getLogicalDeviceAgent("parent_id")
 	assert.NotNil(t, ldAgentNotNil)
-	assert.Equal(t, "parent_id", ldAgentNotNil.logicalDeviceId)
+	assert.Equal(t, "parent_id", ldAgentNotNil.logicalDeviceID)
 
 	// Verify getLogicalPortId() is Success
-	result2, error2 := ldMgr.getLogicalPortId(device)
+	result2, error2 := ldMgr.getLogicalPortID(device)
 	assert.NotNil(t, result2)
 	assert.Nil(t, error2)
 	if reflect.TypeOf(result2) != reflect.TypeOf(wantResult) {
@@ -292,7 +293,7 @@
 	// Verify Add is successful
 	ldAgentNotNil := ldMgr.getLogicalDeviceAgent("id")
 	assert.NotNil(t, ldAgentNotNil)
-	assert.Equal(t, "id", ldAgentNotNil.logicalDeviceId)
+	assert.Equal(t, "id", ldAgentNotNil.logicalDeviceID)
 
 	// Verify ListLogicalDevicePorts() is Success
 	result1, error1 := ldMgr.ListLogicalDevicePorts(context.Background(), "id")
@@ -340,7 +341,7 @@
 	// Verify Add is successful
 	ldAgentNotNil := ldMgr.getLogicalDeviceAgent("id")
 	assert.NotNil(t, ldAgentNotNil)
-	assert.Equal(t, "id", ldAgentNotNil.logicalDeviceId)
+	assert.Equal(t, "id", ldAgentNotNil.logicalDeviceID)
 
 	// Verify ListLogicalDeviceFlows() is Success
 	result1, error1 := ldMgr.ListLogicalDeviceFlows(context.Background(), "id")
@@ -390,7 +391,7 @@
 	// Verify Add is successful
 	ldAgentNotNil := ldMgr.getLogicalDeviceAgent("id")
 	assert.NotNil(t, ldAgentNotNil)
-	assert.Equal(t, "id", ldAgentNotNil.logicalDeviceId)
+	assert.Equal(t, "id", ldAgentNotNil.logicalDeviceID)
 
 	// Verify ListLogicalDeviceFlowGroups() is Success
 	result1, error1 := ldMgr.ListLogicalDeviceFlowGroups(context.Background(), "id")
@@ -436,7 +437,7 @@
 	// Verify Add is successful
 	ldAgentNotNil := ldMgr.getLogicalDeviceAgent("id")
 	assert.NotNil(t, ldAgentNotNil)
-	assert.Equal(t, "id", ldAgentNotNil.logicalDeviceId)
+	assert.Equal(t, "id", ldAgentNotNil.logicalDeviceID)
 
 	// Verify getLogicalPort() is Success
 	result1, error1 := ldMgr.getLogicalPort(&voltha.LogicalPortId{Id: "id", PortId: "123"})
diff --git a/ro_core/core/model_proxy.go b/ro_core/core/model_proxy.go
index 7f78a5d..eb93e44 100644
--- a/ro_core/core/model_proxy.go
+++ b/ro_core/core/model_proxy.go
@@ -13,16 +13,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package core
 
 import (
 	"context"
+	"strings"
+	"sync"
+
 	"github.com/opencord/voltha-go/db/model"
 	"github.com/opencord/voltha-lib-go/v2/pkg/log"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
-	"strings"
-	"sync"
 )
 
 // ModelProxy controls requests made to the data model
diff --git a/ro_core/core/model_proxy_manager.go b/ro_core/core/model_proxy_manager.go
index fcf1c78..d3b278d 100644
--- a/ro_core/core/model_proxy_manager.go
+++ b/ro_core/core/model_proxy_manager.go
@@ -13,11 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package core
 
 import (
 	"context"
 	"encoding/json"
+
 	"github.com/opencord/voltha-go/db/model"
 	"github.com/opencord/voltha-lib-go/v2/pkg/log"
 	"github.com/opencord/voltha-lib-go/v2/pkg/version"
@@ -26,7 +28,7 @@
 	"google.golang.org/grpc/status"
 )
 
-// Enumerated type to keep track of miscellaneous data path agents
+// DataModelType - Enumerated type to keep track of miscellaneous data path agents
 type DataModelType int
 
 // Enumerated list of data path agents
@@ -39,7 +41,8 @@
 	Voltha
 )
 
-const SENTINEL_ADAPTER_ID = "adapter_sentinel"
+// SentinelAdapterID is used to watch adapters in kv
+const SentinelAdapterID = "adapter_sentinel"
 
 // String equivalent for data path agents
 var commonTypes = []string{
@@ -56,6 +59,7 @@
 	return commonTypes[t-1]
 }
 
+// MultipleValuesMsg represents multiple values message
 const MultipleValuesMsg = "Expected a single value for KV query for an instance (%s) of type '%s', but received multiple values"
 
 // ModelProxyManager controls requests made to the miscellaneous data path agents
@@ -71,7 +75,7 @@
 	return &mgr
 }
 
-// GetDeviceType returns the device type associated to the provided id
+// GetVoltha - GetDeviceType returns the device type associated to the provided id
 func (mpMgr *ModelProxyManager) GetVoltha(ctx context.Context) (*voltha.Voltha, error) {
 	log.Debug("GetVoltha")
 
@@ -135,7 +139,7 @@
 		}
 		for _, item := range list {
 			adapter = item.(*voltha.Adapter)
-			if adapter.Id != SENTINEL_ADAPTER_ID { // don't report the sentinel
+			if adapter.Id != SentinelAdapterID { // don't report the sentinel
 				adapters.Items = append(adapters.Items, adapter)
 			}
 		}
diff --git a/ro_core/core/model_proxy_test.go b/ro_core/core/model_proxy_test.go
index 8215fb8..a9caa00 100644
--- a/ro_core/core/model_proxy_test.go
+++ b/ro_core/core/model_proxy_test.go
@@ -17,12 +17,13 @@
 
 import (
 	"context"
+	"reflect"
+	"testing"
+
 	"github.com/opencord/voltha-go/db/model"
 	"github.com/opencord/voltha-protos/v2/go/voltha"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
-	"reflect"
-	"testing"
 )
 
 type fields struct {
@@ -33,9 +34,9 @@
 func getModelProxyPathNotFound() *fields {
 	var modelProxy fields
 
-	TestProxy_Root := model.NewRoot(&voltha.Voltha{}, nil)
-	TestProxy_Root_Proxy := TestProxy_Root.CreateProxy(context.Background(), "/", false)
-	modelProxy.rootProxy = TestProxy_Root_Proxy
+	TestProxyRoot := model.NewRoot(&voltha.Voltha{}, nil)
+	TestProxyRootProxy := TestProxyRoot.CreateProxy(context.Background(), "/", false)
+	modelProxy.rootProxy = TestProxyRootProxy
 	modelProxy.basePath = "base_path"
 
 	return &modelProxy
@@ -44,9 +45,9 @@
 func getModelProxyPathFound() *fields {
 	var modelProxy fields
 
-	TestProxy_Root := model.NewRoot(&voltha.Voltha{}, nil)
-	TestProxy_Root_Proxy := TestProxy_Root.CreateProxy(context.Background(), "/", false)
-	modelProxy.rootProxy = TestProxy_Root_Proxy
+	TestProxyRoot := model.NewRoot(&voltha.Voltha{}, nil)
+	TestProxyRootProxy := TestProxyRoot.CreateProxy(context.Background(), "/", false)
+	modelProxy.rootProxy = TestProxyRootProxy
 	modelProxy.basePath = "devices"
 
 	return &modelProxy
diff --git a/ro_core/main.go b/ro_core/main.go
index f1e00d2..dc78302 100644
--- a/ro_core/main.go
+++ b/ro_core/main.go
@@ -13,25 +13,26 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package main
 
 import (
 	"context"
 	"errors"
 	"fmt"
-	"github.com/opencord/voltha-go/ro_core/config"
-	c "github.com/opencord/voltha-go/ro_core/core"
-	"github.com/opencord/voltha-lib-go/v2/pkg/db/kvstore"
-	grpcserver "github.com/opencord/voltha-lib-go/v2/pkg/grpc"
-	"github.com/opencord/voltha-lib-go/v2/pkg/log"
-	"github.com/opencord/voltha-lib-go/v2/pkg/probe"
-	"github.com/opencord/voltha-lib-go/v2/pkg/version"
-	ic "github.com/opencord/voltha-protos/v2/go/inter_container"
 	"os"
 	"os/signal"
 	"strconv"
 	"syscall"
 	"time"
+
+	"github.com/opencord/voltha-go/ro_core/config"
+	c "github.com/opencord/voltha-go/ro_core/core"
+	"github.com/opencord/voltha-lib-go/v2/pkg/db/kvstore"
+	"github.com/opencord/voltha-lib-go/v2/pkg/log"
+	"github.com/opencord/voltha-lib-go/v2/pkg/probe"
+	"github.com/opencord/voltha-lib-go/v2/pkg/version"
+	ic "github.com/opencord/voltha-protos/v2/go/inter_container"
 )
 
 type roCore struct {
@@ -39,14 +40,16 @@
 	config      *config.ROCoreFlags
 	halted      bool
 	exitChannel chan int
-	grpcServer  *grpcserver.GrpcServer
 	core        *c.Core
 	//For test
 	receiverChannels []<-chan *ic.InterContainerMessage
 }
 
 func init() {
-	log.AddPackage(log.JSON, log.DebugLevel, nil)
+	_, err := log.AddPackage(log.JSON, log.DebugLevel, nil)
+	if err != nil {
+		log.Errorw("unable-to-register-package-to-the-log-map", log.Fields{"error": err})
+	}
 }
 
 func newKVClient(storeType string, address string, timeout int) (kvstore.Client, error) {
@@ -82,17 +85,6 @@
 	return nil
 }
 
-func toString(value interface{}) (string, error) {
-	switch t := value.(type) {
-	case []byte:
-		return string(value.([]byte)), nil
-	case string:
-		return value.(string), nil
-	default:
-		return "", fmt.Errorf("unexpected-type-%T", t)
-	}
-}
-
 func (ro *roCore) start(ctx context.Context) {
 	log.Info("Starting RW Core components")
 
@@ -203,18 +195,23 @@
 	//// Setup logging
 
 	//Setup default logger - applies for packages that do not have specific logger set
-	if _, err := log.SetDefaultLogger(log.JSON, cf.LogLevel, log.Fields{"instanceId": cf.InstanceID}); err != nil {
+	if _, err := log.SetDefaultLogger(log.JSON, cf.LogLevel, log.Fields{"instanceID": cf.InstanceID}); err != nil {
 		log.With(log.Fields{"error": err}).Fatal("Cannot setup logging")
 	}
 
 	// Update all loggers (provisionned via init) with a common field
-	if err := log.UpdateAllLoggers(log.Fields{"instanceId": cf.InstanceID}); err != nil {
+	if err := log.UpdateAllLoggers(log.Fields{"instanceID": cf.InstanceID}); err != nil {
 		log.With(log.Fields{"error": err}).Fatal("Cannot setup logging")
 	}
 
 	log.SetPackageLogLevel("github.com/opencord/voltha-go/ro_core/core", log.DebugLevel)
 
-	defer log.CleanUp()
+	defer func() {
+		err := log.CleanUp()
+		if err != nil {
+			log.Errorw("unable-to-flush-any-buffered-log-entries", log.Fields{"error": err})
+		}
+	}()
 
 	// Print verison / build information and exit
 	if cf.DisplayVersionOnly {
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 594cd27..bc7fe97 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -104,9 +104,9 @@
 github.com/opencord/voltha-lib-go/v2/pkg/log
 github.com/opencord/voltha-lib-go/v2/pkg/db
 github.com/opencord/voltha-lib-go/v2/pkg/db/kvstore
-github.com/opencord/voltha-lib-go/v2/pkg/grpc
 github.com/opencord/voltha-lib-go/v2/pkg/probe
 github.com/opencord/voltha-lib-go/v2/pkg/version
+github.com/opencord/voltha-lib-go/v2/pkg/grpc
 github.com/opencord/voltha-lib-go/v2/pkg/kafka
 github.com/opencord/voltha-lib-go/v2/pkg/flows
 github.com/opencord/voltha-lib-go/v2/pkg/adapters/adapterif