diff --git a/Makefile b/Makefile
index f03ff01..edd5ef1 100644
--- a/Makefile
+++ b/Makefile
@@ -34,8 +34,6 @@
 AFROUTER_IMAGENAME         := ${DOCKER_REGISTRY}${DOCKER_REPOSITORY}voltha-afrouter
 AFROUTERTEST_IMAGENAME     := ${DOCKER_REGISTRY}${DOCKER_REPOSITORY}voltha-afroutertest
 AFROUTERD_IMAGENAME        := ${DOCKER_REGISTRY}${DOCKER_REPOSITORY}voltha-afrouterd
-SIMULATEDOLT_IMAGENAME     := ${DOCKER_REGISTRY}${DOCKER_REPOSITORY}voltha-adapter-simulated-olt
-SIMULATEDONU_IMAGENAME     := ${DOCKER_REGISTRY}${DOCKER_REPOSITORY}voltha-adapter-simulated-onu
 OFAGENT_IMAGENAME          := ${DOCKER_REGISTRY}${DOCKER_REPOSITORY}voltha-ofagent
 CLI_IMAGENAME              := ${DOCKER_REGISTRY}${DOCKER_REPOSITORY}voltha-cli
 PONSIMOLT_IMAGENAME        := ${DOCKER_REGISTRY}${DOCKER_REPOSITORY}voltha-adapter-ponsim-olt
@@ -60,7 +58,7 @@
 	--build-arg LOCAL_PYVOLTHA=${LOCAL_PYVOLTHA} \
 	--build-arg LOCAL_PROTOS=${LOCAL_PROTOS}
 
-.PHONY: rw_core ro_core simulated_olt simulated_onu afrouter afrouterd local-protos local-pyvoltha
+.PHONY: rw_core ro_core afrouter afrouterd local-protos local-pyvoltha
 
 # This should to be the first and default target in this Makefile
 help:
@@ -74,8 +72,6 @@
 	@echo "afrouter             : Build the afrouter docker image"
 	@echo "afrouterTest         : Build the afrouterTest docker image"
 	@echo "afrouterd            : Build the afrouterd docker image"
-	@echo "simulated_olt        : Build the simulated_olt docker image"
-	@echo "simulated_onu        : Build the simulated_onu docker image"
 	@echo "ofagent              : Build the openflow agent docker image"
 	@echo "cli                  : Build the voltha CLI docker image"
 	@echo "adapter_ponsim_olt   : Build the ponsim olt adapter docker image"
@@ -133,7 +129,7 @@
 
 build: docker-build
 
-docker-build: rw_core ro_core simulated_olt simulated_onu afrouter afrouterd ofagent cli adapter_ponsim_olt adapter_ponsim_onu
+docker-build: rw_core ro_core afrouter afrouterd ofagent cli adapter_ponsim_olt adapter_ponsim_onu
 
 afrouter: local-protos
 	docker build $(DOCKER_BUILD_ARGS) -t ${AFROUTER_IMAGENAME}:${DOCKER_TAG} -t ${AFROUTER_IMAGENAME}:latest -f docker/Dockerfile.afrouter .
@@ -150,12 +146,6 @@
 ro_core: local-protos
 	docker build $(DOCKER_BUILD_ARGS) -t ${ROCORE_IMAGENAME}:${DOCKER_TAG} -t ${ROCORE_IMAGENAME}:latest -f docker/Dockerfile.ro_core .
 
-simulated_olt: local-protos
-	docker build $(DOCKER_BUILD_ARGS) -t ${SIMULATEDOLT_IMAGENAME}:${DOCKER_TAG} -t ${SIMULATEDOLT_IMAGENAME}:latest -f docker/Dockerfile.simulated_olt .
-
-simulated_onu: local-protos
-	docker build $(DOCKER_BUILD_ARGS) -t ${SIMULATEDONU_IMAGENAME}:${DOCKER_TAG} -t ${SIMULATEDONU_IMAGENAME}:latest -f docker/Dockerfile.simulated_onu .
-
 ofagent: local-protos local-pyvoltha
 	docker build $(DOCKER_BUILD_ARGS_LOCAL) -t ${OFAGENT_IMAGENAME}:${DOCKER_TAG} -t ${OFAGENT_IMAGENAME}:latest -f python/docker/Dockerfile.ofagent python
 
@@ -173,8 +163,6 @@
 	docker push ${AFROUTERD_IMAGENAME}:${DOCKER_TAG}
 	docker push ${RWCORE_IMAGENAME}:${DOCKER_TAG}
 	docker push ${ROCORE_IMAGENAME}:${DOCKER_TAG}
-	docker push ${SIMULATEDOLT_IMAGENAME}:${DOCKER_TAG}
-	docker push ${SIMULATEDONU_IMAGENAME}:${DOCKER_TAG}
 	docker push ${OFAGENT_IMAGENAME}:${DOCKER_TAG}
 	docker push ${CLI_IMAGENAME}:${DOCKER_TAG}
 	docker push ${PONSIMOLT_IMAGENAME}:${DOCKER_TAG}
diff --git a/adapters/simulated_olt/adaptercore/device_handler.go b/adapters/simulated_olt/adaptercore/device_handler.go
deleted file mode 100644
index 628e2e5..0000000
--- a/adapters/simulated_olt/adaptercore/device_handler.go
+++ /dev/null
@@ -1,335 +0,0 @@
-/*
- * Copyright 2018-present Open Networking Foundation
-
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
-
- * http://www.apache.org/licenses/LICENSE-2.0
-
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package adaptercore
-
-import (
-	"context"
-	"fmt"
-	"github.com/gogo/protobuf/proto"
-	com "github.com/opencord/voltha-go/adapters/common"
-	"github.com/opencord/voltha-go/common/log"
-	ic "github.com/opencord/voltha-protos/go/inter_container"
-	of "github.com/opencord/voltha-protos/go/openflow_13"
-	"github.com/opencord/voltha-protos/go/voltha"
-	"strconv"
-	"strings"
-	"sync"
-)
-
-// A set of pm names to create the initial pm config.  This is used only for testing in this simulated adapter
-var pmNames = []string{
-	"tx_64_pkts",
-	"tx_65_127_pkts",
-	"tx_128_255_pkts",
-	"tx_256_511_pkts",
-	"tx_512_1023_pkts",
-	"tx_1024_1518_pkts",
-	"tx_1519_9k_pkts",
-	"rx_64_pkts",
-	"rx_65_127_pkts",
-	"rx_128_255_pkts",
-	"rx_256_511_pkts",
-	"rx_512_1023_pkts",
-	"rx_1024_1518_pkts",
-	"rx_1519_9k_pkts",
-}
-
-//DeviceHandler follows the same patterns as ponsim_olt.  The only difference is that it does not
-// interact with an OLT device.
-type DeviceHandler struct {
-	deviceId     string
-	deviceType   string
-	device       *voltha.Device
-	coreProxy    *com.CoreProxy
-	simulatedOLT *SimulatedOLT
-	nniPort      *voltha.Port
-	ponPort      *voltha.Port
-	exitChannel  chan int
-	lockDevice   sync.RWMutex
-	metrics      *com.PmMetrics
-}
-
-//NewDeviceHandler creates a new device handler
-func NewDeviceHandler(cp *com.CoreProxy, device *voltha.Device, adapter *SimulatedOLT) *DeviceHandler {
-	var dh DeviceHandler
-	dh.coreProxy = cp
-	cloned := (proto.Clone(device)).(*voltha.Device)
-	dh.deviceId = cloned.Id
-	dh.deviceType = cloned.Type
-	dh.device = cloned
-	dh.simulatedOLT = adapter
-	dh.exitChannel = make(chan int, 1)
-	dh.lockDevice = sync.RWMutex{}
-	// Set up PON metrics
-	dh.metrics = com.NewPmMetrics(
-		cloned.Id,
-		com.Frequency(150),
-		com.Grouped(false),
-		com.FrequencyOverride(false),
-		com.Metrics(pmNames),
-	)
-	return &dh
-}
-
-// start save the device to the data model
-func (dh *DeviceHandler) start(ctx context.Context) {
-	dh.lockDevice.Lock()
-	defer dh.lockDevice.Unlock()
-	log.Debugw("starting-device-agent", log.Fields{"device": dh.device})
-	// Add the initial device to the local model
-	log.Debug("device-agent-started")
-}
-
-// stop stops the device dh.  Not much to do for now
-func (dh *DeviceHandler) stop(ctx context.Context) {
-	dh.lockDevice.Lock()
-	defer dh.lockDevice.Unlock()
-	log.Debug("stopping-device-agent")
-	dh.exitChannel <- 1
-	log.Debug("device-agent-stopped")
-}
-
-func macAddressToUint32Array(mac string) []uint32 {
-	slist := strings.Split(mac, ":")
-	result := make([]uint32, len(slist))
-	var err error
-	var tmp int64
-	for index, val := range slist {
-		if tmp, err = strconv.ParseInt(val, 16, 32); err != nil {
-			return []uint32{1, 2, 3, 4, 5, 6}
-		}
-		result[index] = uint32(tmp)
-	}
-	return result
-}
-
-func (dh *DeviceHandler) AdoptDevice(device *voltha.Device) {
-	log.Debugw("AdoptDevice", log.Fields{"deviceId": device.Id})
-
-	//	Update the device info
-	cloned := proto.Clone(device).(*voltha.Device)
-	cloned.Root = true
-	cloned.Vendor = "simulators"
-	cloned.Model = "go-simulators"
-	cloned.SerialNumber = com.GetRandomSerialNumber()
-	cloned.MacAddress = strings.ToUpper(com.GetRandomMacAddress())
-
-	// Synchronous call to update device - this method is run in its own go routine
-	if err := dh.coreProxy.DeviceUpdate(nil, cloned); err != nil {
-		log.Errorw("error-updating-device", log.Fields{"deviceId": device.Id, "error": err})
-	}
-
-	// Now, set the initial PM configuration for that device
-	if err := dh.coreProxy.DevicePMConfigUpdate(nil, dh.metrics.ToPmConfigs()); err != nil {
-		log.Errorw("error-updating-PMs", log.Fields{"deviceId": device.Id, "error": err})
-	}
-
-	//	Now create the NNI Port
-	dh.nniPort = &voltha.Port{
-		PortNo:     2,
-		Label:      fmt.Sprintf("nni-%d", 2),
-		Type:       voltha.Port_ETHERNET_NNI,
-		OperStatus: voltha.OperStatus_ACTIVE,
-	}
-
-	// Synchronous call to update device - this method is run in its own go routine
-	if err := dh.coreProxy.PortCreated(nil, cloned.Id, dh.nniPort); err != nil {
-		log.Errorw("error-creating-nni-port", log.Fields{"deviceId": device.Id, "error": err})
-	}
-
-	//	Now create the PON Port
-	dh.ponPort = &voltha.Port{
-		PortNo:     1,
-		Label:      fmt.Sprintf("pon-%d", 1),
-		Type:       voltha.Port_PON_OLT,
-		OperStatus: voltha.OperStatus_ACTIVE,
-	}
-
-	// Synchronous call to update device - this method is run in its own go routine
-	if err := dh.coreProxy.PortCreated(nil, cloned.Id, dh.ponPort); err != nil {
-		log.Errorw("error-creating-nni-port", log.Fields{"deviceId": device.Id, "error": err})
-	}
-
-	cloned.ConnectStatus = voltha.ConnectStatus_REACHABLE
-	cloned.OperStatus = voltha.OperStatus_ACTIVE
-
-	dh.device = cloned
-	//dh.device.SerialNumber = cloned.SerialNumber
-
-	//	Update the device state
-	if err := dh.coreProxy.DeviceStateUpdate(nil, cloned.Id, cloned.ConnectStatus, cloned.OperStatus); err != nil {
-		log.Errorw("error-creating-nni-port", log.Fields{"deviceId": device.Id, "error": err})
-	}
-
-	//	Register Child device
-	initialUniPortNo := 100
-	log.Debugw("registering-onus", log.Fields{"total": dh.simulatedOLT.numOnus})
-	for i := 0; i < dh.simulatedOLT.numOnus; i++ {
-		go dh.coreProxy.ChildDeviceDetected(
-			nil,
-			cloned.Id,
-			1,
-			"simulated_onu",
-			initialUniPortNo+i,
-			"simulated_onu",
-			com.GetRandomSerialNumber(),
-			int64(i))
-	}
-}
-
-func (dh *DeviceHandler) GetOfpDeviceInfo(device *voltha.Device) (*ic.SwitchCapability, error) {
-	return &ic.SwitchCapability{
-		Desc: &of.OfpDesc{
-			HwDesc:    "simulated_pon",
-			SwDesc:    "simulated_pon",
-			SerialNum: dh.device.SerialNumber,
-		},
-		SwitchFeatures: &of.OfpSwitchFeatures{
-			NBuffers: 256,
-			NTables:  2,
-			Capabilities: uint32(of.OfpCapabilities_OFPC_FLOW_STATS |
-				of.OfpCapabilities_OFPC_TABLE_STATS |
-				of.OfpCapabilities_OFPC_PORT_STATS |
-				of.OfpCapabilities_OFPC_GROUP_STATS),
-		},
-	}, nil
-}
-
-func (dh *DeviceHandler) GetOfpPortInfo(device *voltha.Device, portNo int64) (*ic.PortCapability, error) {
-	cap := uint32(of.OfpPortFeatures_OFPPF_1GB_FD | of.OfpPortFeatures_OFPPF_FIBER)
-	return &ic.PortCapability{
-		Port: &voltha.LogicalPort{
-			OfpPort: &of.OfpPort{
-				HwAddr:     macAddressToUint32Array(dh.device.MacAddress),
-				Config:     0,
-				State:      uint32(of.OfpPortState_OFPPS_LIVE),
-				Curr:       cap,
-				Advertised: cap,
-				Peer:       cap,
-				CurrSpeed:  uint32(of.OfpPortFeatures_OFPPF_1GB_FD),
-				MaxSpeed:   uint32(of.OfpPortFeatures_OFPPF_1GB_FD),
-			},
-			DeviceId:     dh.device.Id,
-			DevicePortNo: uint32(portNo),
-		},
-	}, nil
-}
-
-func (dh *DeviceHandler) Process_inter_adapter_message(msg *ic.InterAdapterMessage) error {
-	log.Debugw("Process_inter_adapter_message", log.Fields{"msgId": msg.Header.Id})
-	return nil
-}
-
-func (dh *DeviceHandler) DisableDevice(device *voltha.Device) {
-	cloned := proto.Clone(device).(*voltha.Device)
-	// Update the all ports state on that device to disable
-	if err := dh.coreProxy.PortsStateUpdate(nil, cloned.Id, voltha.OperStatus_UNKNOWN); err != nil {
-		log.Errorw("updating-ports-failed", log.Fields{"deviceId": device.Id, "error": err})
-		return
-	}
-
-	//Update the device state
-	cloned.ConnectStatus = voltha.ConnectStatus_UNREACHABLE
-	cloned.OperStatus = voltha.OperStatus_UNKNOWN
-	dh.device = cloned
-
-	if err := dh.coreProxy.DeviceStateUpdate(nil, cloned.Id, cloned.ConnectStatus, cloned.OperStatus); err != nil {
-		log.Errorw("device-state-update-failed", log.Fields{"deviceId": device.Id, "error": err})
-		return
-	}
-
-	// Tell the Core that all child devices have been disabled (by default it's an action already taken by the Core
-	if err := dh.coreProxy.ChildDevicesLost(nil, cloned.Id); err != nil {
-		log.Errorw("lost-notif-of-child-devices-failed", log.Fields{"deviceId": device.Id, "error": err})
-		return
-	}
-
-	log.Debugw("DisableDevice-end", log.Fields{"deviceId": device.Id})
-}
-
-func (dh *DeviceHandler) ReEnableDevice(device *voltha.Device) {
-
-	cloned := proto.Clone(device).(*voltha.Device)
-	// Update the all ports state on that device to enable
-	if err := dh.coreProxy.PortsStateUpdate(nil, cloned.Id, voltha.OperStatus_ACTIVE); err != nil {
-		log.Errorw("updating-ports-failed", log.Fields{"deviceId": device.Id, "error": err})
-		return
-	}
-
-	//Update the device state
-	cloned.ConnectStatus = voltha.ConnectStatus_REACHABLE
-	cloned.OperStatus = voltha.OperStatus_ACTIVE
-	dh.device = cloned
-
-	if err := dh.coreProxy.DeviceStateUpdate(nil, cloned.Id, cloned.ConnectStatus, cloned.OperStatus); err != nil {
-		log.Errorw("device-state-update-failed", log.Fields{"deviceId": device.Id, "error": err})
-		return
-	}
-
-	// Tell the Core that all child devices have been enabled
-	if err := dh.coreProxy.ChildDevicesDetected(nil, cloned.Id); err != nil {
-		log.Errorw("detection-notif-of-child-devices-failed", log.Fields{"deviceId": device.Id, "error": err})
-		return
-	}
-
-	log.Debugw("ReEnableDevice-end", log.Fields{"deviceId": device.Id})
-}
-
-func (dh *DeviceHandler) DeleteDevice(device *voltha.Device) {
-	cloned := proto.Clone(device).(*voltha.Device)
-	// Update the all ports state on that device to disable
-	if err := dh.coreProxy.DeleteAllPorts(nil, cloned.Id); err != nil {
-		log.Errorw("delete-ports-failed", log.Fields{"deviceId": device.Id, "error": err})
-		return
-	}
-
-	log.Debugw("DeleteDevice-end", log.Fields{"deviceId": device.Id})
-}
-
-func (dh *DeviceHandler) UpdateFlowsBulk(device *voltha.Device, flows *voltha.Flows, groups *voltha.FlowGroups, metadata *voltha.FlowMetadata) {
-	log.Debugw("UpdateFlowsBulk", log.Fields{"deviceId": device.Id, "flows": flows, "groups": groups})
-	// For now we do nothing with it
-	return
-}
-
-func (dh *DeviceHandler) UpdateFlowsIncremental(device *voltha.Device, flowChanges *of.FlowChanges, groupChanges *of.FlowGroupChanges, metadata *voltha.FlowMetadata) {
-	log.Debugw("UpdateFlowsIncremental", log.Fields{"deviceId": device.Id, "flowChanges": flowChanges, "groupChanges": groupChanges})
-	// For now we do nothing with it
-	return
-}
-
-func (dh *DeviceHandler) UpdatePmConfigs(device *voltha.Device, pmConfigs *voltha.PmConfigs) {
-	log.Debugw("UpdatePmConfigs", log.Fields{"deviceId": device.Id, "pmConfigs": pmConfigs})
-	// For now we do nothing with it
-	return
-}
-
-func (dh *DeviceHandler) ReconcileDevice(device *voltha.Device) {
-	// Update the device info
-	cloned := proto.Clone(device).(*voltha.Device)
-	cloned.ConnectStatus = voltha.ConnectStatus_REACHABLE
-	cloned.OperStatus = voltha.OperStatus_ACTIVE
-
-	dh.device = cloned
-
-	// Update the device state
-	if err := dh.coreProxy.DeviceStateUpdate(nil, cloned.Id, cloned.ConnectStatus, cloned.OperStatus); err != nil {
-		log.Errorw("error-creating-nni-port", log.Fields{"deviceId": device.Id, "error": err})
-	}
-
-	// Since we don't know how long we were down, let's reconcile the child devices
-	go dh.coreProxy.ReconcileChildDevices(nil, cloned.Id)
-}
diff --git a/adapters/simulated_olt/adaptercore/simulated_olt.go b/adapters/simulated_olt/adaptercore/simulated_olt.go
deleted file mode 100644
index 29785c4..0000000
--- a/adapters/simulated_olt/adaptercore/simulated_olt.go
+++ /dev/null
@@ -1,300 +0,0 @@
-/*
- * Copyright 2018-present Open Networking Foundation
-
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
-
- * http://www.apache.org/licenses/LICENSE-2.0
-
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package adaptercore
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	com "github.com/opencord/voltha-go/adapters/common"
-	"github.com/opencord/voltha-go/common/log"
-	"github.com/opencord/voltha-go/kafka"
-	ic "github.com/opencord/voltha-protos/go/inter_container"
-	"github.com/opencord/voltha-protos/go/openflow_13"
-	"github.com/opencord/voltha-protos/go/voltha"
-	"sync"
-)
-
-type SimulatedOLT struct {
-	deviceHandlers        map[string]*DeviceHandler
-	coreProxy             *com.CoreProxy
-	kafkaICProxy          *kafka.InterContainerProxy
-	numOnus               int
-	exitChannel           chan int
-	lockDeviceHandlersMap sync.RWMutex
-}
-
-func NewSimulatedOLT(ctx context.Context, kafkaICProxy *kafka.InterContainerProxy, coreProxy *com.CoreProxy, onuNumber int) *SimulatedOLT {
-	var simulatedOLT SimulatedOLT
-	simulatedOLT.exitChannel = make(chan int, 1)
-	simulatedOLT.deviceHandlers = make(map[string]*DeviceHandler)
-	simulatedOLT.kafkaICProxy = kafkaICProxy
-	simulatedOLT.numOnus = onuNumber
-	simulatedOLT.coreProxy = coreProxy
-	simulatedOLT.lockDeviceHandlersMap = sync.RWMutex{}
-	return &simulatedOLT
-}
-
-func (so *SimulatedOLT) Start(ctx context.Context) error {
-	log.Info("starting-device-manager")
-	log.Info("device-manager-started")
-	return nil
-}
-
-func (so *SimulatedOLT) Stop(ctx context.Context) error {
-	log.Info("stopping-device-manager")
-	so.exitChannel <- 1
-	log.Info("device-manager-stopped")
-	return nil
-}
-
-func sendResponse(ctx context.Context, ch chan interface{}, result interface{}) {
-	if ctx.Err() == nil {
-		// Returned response only of the ctx has not been cancelled/timeout/etc
-		// Channel is automatically closed when a context is Done
-		ch <- result
-		log.Debugw("sendResponse", log.Fields{"result": result})
-	} else {
-		// Should the transaction be reverted back?
-		log.Debugw("sendResponse-context-error", log.Fields{"context-error": ctx.Err()})
-	}
-}
-
-func (so *SimulatedOLT) addDeviceHandlerToMap(agent *DeviceHandler) {
-	so.lockDeviceHandlersMap.Lock()
-	defer so.lockDeviceHandlersMap.Unlock()
-	if _, exist := so.deviceHandlers[agent.deviceId]; !exist {
-		so.deviceHandlers[agent.deviceId] = agent
-	}
-}
-
-func (so *SimulatedOLT) deleteDeviceHandlerToMap(agent *DeviceHandler) {
-	so.lockDeviceHandlersMap.Lock()
-	defer so.lockDeviceHandlersMap.Unlock()
-	delete(so.deviceHandlers, agent.deviceId)
-}
-
-func (so *SimulatedOLT) getDeviceHandler(deviceId string) *DeviceHandler {
-	so.lockDeviceHandlersMap.Lock()
-	defer so.lockDeviceHandlersMap.Unlock()
-	if agent, ok := so.deviceHandlers[deviceId]; ok {
-		return agent
-	}
-	return nil
-}
-
-func (so *SimulatedOLT) Adopt_device(device *voltha.Device) error {
-	if device == nil {
-		log.Warn("device-is-nil")
-		return errors.New("nil-device")
-	}
-	log.Infow("adopt-device", log.Fields{"deviceId": device.Id})
-	var handler *DeviceHandler
-	if handler = so.getDeviceHandler(device.Id); handler == nil {
-		handler := NewDeviceHandler(so.coreProxy, device, so)
-		so.addDeviceHandlerToMap(handler)
-		go handler.AdoptDevice(device)
-	}
-	return nil
-}
-
-func (so *SimulatedOLT) Get_ofp_device_info(device *voltha.Device) (*ic.SwitchCapability, error) {
-	log.Infow("Get_ofp_device_info", log.Fields{"deviceId": device.Id})
-	if handler := so.getDeviceHandler(device.Id); handler != nil {
-		info, err := handler.GetOfpDeviceInfo(device)
-		log.Infow("Get_ofp_device_info-resp", log.Fields{"switch": info})
-		return info, err
-	}
-	log.Errorw("device-handler-not-set", log.Fields{"deviceId": device.Id})
-	return nil, errors.New("device-handler-not-set")
-}
-
-func (so *SimulatedOLT) Get_ofp_port_info(device *voltha.Device, port_no int64) (*ic.PortCapability, error) {
-	log.Infow("Get_ofp_port_info", log.Fields{"deviceId": device.Id})
-	if handler := so.getDeviceHandler(device.Id); handler != nil {
-		return handler.GetOfpPortInfo(device, port_no)
-	}
-	log.Errorw("device-handler-not-set", log.Fields{"deviceId": device.Id})
-	return nil, errors.New("device-handler-not-set")
-}
-
-func (so *SimulatedOLT) Process_inter_adapter_message(msg *ic.InterAdapterMessage) error {
-	log.Infow("Process_inter_adapter_message", log.Fields{"msgId": msg.Header.Id})
-	targetDevice := msg.Header.ProxyDeviceId // Request?
-	if targetDevice == "" && msg.Header.ToDeviceId != "" {
-		// Typical response
-		targetDevice = msg.Header.ToDeviceId
-	}
-	if handler := so.getDeviceHandler(targetDevice); handler != nil {
-		return handler.Process_inter_adapter_message(msg)
-	}
-	return errors.New(fmt.Sprintf("handler-not-found-%s", targetDevice))
-}
-
-func (so *SimulatedOLT) Adapter_descriptor() error {
-	return errors.New("UnImplemented")
-}
-
-func (so *SimulatedOLT) Device_types() (*voltha.DeviceTypes, error) {
-	return nil, errors.New("UnImplemented")
-}
-
-func (so *SimulatedOLT) Health() (*voltha.HealthStatus, error) {
-	return nil, errors.New("UnImplemented")
-}
-
-func (so *SimulatedOLT) Reconcile_device(device *voltha.Device) error {
-	if device == nil {
-		log.Warn("device-is-nil")
-		return errors.New("nil-device")
-	}
-	log.Infow("reconcile-device", log.Fields{"deviceId": device.Id})
-	var handler *DeviceHandler
-	handler = so.getDeviceHandler(device.Id)
-	if handler == nil {
-		//	Adapter has restarted
-		handler = NewDeviceHandler(so.coreProxy, device, so)
-		so.addDeviceHandlerToMap(handler)
-	}
-	go handler.ReconcileDevice(device)
-	return nil
-}
-
-func (so *SimulatedOLT) Abandon_device(device *voltha.Device) error {
-	return errors.New("UnImplemented")
-}
-
-func (so *SimulatedOLT) Disable_device(device *voltha.Device) error {
-	if device == nil {
-		log.Warn("device-is-nil")
-		return errors.New("nil-device")
-	}
-	log.Infow("disable-device", log.Fields{"deviceId": device.Id})
-	var handler *DeviceHandler
-	if handler = so.getDeviceHandler(device.Id); handler != nil {
-		go handler.DisableDevice(device)
-	}
-	return nil
-}
-
-func (so *SimulatedOLT) Reenable_device(device *voltha.Device) error {
-	if device == nil {
-		log.Warn("device-is-nil")
-		return errors.New("nil-device")
-	}
-	log.Infow("reenable-device", log.Fields{"deviceId": device.Id})
-	var handler *DeviceHandler
-	if handler = so.getDeviceHandler(device.Id); handler != nil {
-		go handler.ReEnableDevice(device)
-	}
-	return nil
-}
-
-func (so *SimulatedOLT) Reboot_device(device *voltha.Device) error {
-	return errors.New("UnImplemented")
-}
-
-func (so *SimulatedOLT) Self_test_device(device *voltha.Device) error {
-	return errors.New("UnImplemented")
-}
-
-func (so *SimulatedOLT) Delete_device(device *voltha.Device) error {
-	if device == nil {
-		log.Warn("device-is-nil")
-		return errors.New("nil-device")
-	}
-	log.Infow("delete-device", log.Fields{"deviceId": device.Id})
-	var handler *DeviceHandler
-	if handler = so.getDeviceHandler(device.Id); handler != nil {
-		go handler.DeleteDevice(device)
-	}
-	return nil
-}
-
-func (so *SimulatedOLT) Get_device_details(device *voltha.Device) error {
-	return errors.New("UnImplemented")
-}
-
-func (so *SimulatedOLT) Update_flows_bulk(device *voltha.Device, flows *voltha.Flows, groups *voltha.FlowGroups, metadata *voltha.FlowMetadata) error {
-	if device == nil {
-		log.Warn("device-is-nil")
-		return errors.New("nil-device")
-	}
-	log.Debugw("bulk-flow-updates", log.Fields{"deviceId": device.Id, "flows": flows, "groups": groups})
-	var handler *DeviceHandler
-	if handler = so.getDeviceHandler(device.Id); handler != nil {
-		go handler.UpdateFlowsBulk(device, flows, groups, metadata)
-	}
-	return nil
-}
-
-func (so *SimulatedOLT) Update_flows_incrementally(device *voltha.Device, flowChanges *openflow_13.FlowChanges, groupChanges *openflow_13.FlowGroupChanges, metadata *voltha.FlowMetadata) error {
-	if device == nil {
-		log.Warn("device-is-nil")
-		return errors.New("nil-device")
-	}
-	log.Debugw("incremental-flow-update", log.Fields{"deviceId": device.Id, "flowChanges": flowChanges, "groupChanges": groupChanges})
-	var handler *DeviceHandler
-	if handler = so.getDeviceHandler(device.Id); handler != nil {
-		go handler.UpdateFlowsIncremental(device, flowChanges, groupChanges, metadata)
-	}
-	return nil
-}
-
-func (so *SimulatedOLT) Update_pm_config(device *voltha.Device, pmConfigs *voltha.PmConfigs) error {
-	if device == nil {
-		log.Warn("device-is-nil")
-		return errors.New("nil-device")
-	}
-	log.Debugw("update_pm_config", log.Fields{"deviceId": device.Id, "pmConfigs": pmConfigs})
-	var handler *DeviceHandler
-	if handler = so.getDeviceHandler(device.Id); handler != nil {
-		go handler.UpdatePmConfigs(device, pmConfigs)
-	}
-	return nil
-}
-
-func (so *SimulatedOLT) Receive_packet_out(deviceId string, egress_port_no int, msg *openflow_13.OfpPacketOut) error {
-	return errors.New("UnImplemented")
-}
-
-func (so *SimulatedOLT) Suppress_alarm(filter *voltha.AlarmFilter) error {
-	return errors.New("UnImplemented")
-}
-
-func (so *SimulatedOLT) Unsuppress_alarm(filter *voltha.AlarmFilter) error {
-	return errors.New("UnImplemented")
-}
-
-func (so *SimulatedOLT) Download_image(device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
-	return nil, errors.New("UnImplemented")
-}
-
-func (so *SimulatedOLT) Get_image_download_status(device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
-	return nil, errors.New("UnImplemented")
-}
-
-func (so *SimulatedOLT) Cancel_image_download(device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
-	return nil, errors.New("UnImplemented")
-}
-
-func (so *SimulatedOLT) Activate_image_update(device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
-	return nil, errors.New("UnImplemented")
-}
-
-func (so *SimulatedOLT) Revert_image_update(device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
-	return nil, errors.New("UnImplemented")
-}
diff --git a/adapters/simulated_olt/config/config.go b/adapters/simulated_olt/config/config.go
deleted file mode 100644
index 5cf0dc0..0000000
--- a/adapters/simulated_olt/config/config.go
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
- * Copyright 2018-present Open Networking Foundation
-
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
-
- * http://www.apache.org/licenses/LICENSE-2.0
-
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package config
-
-import (
-	"flag"
-	"fmt"
-	"github.com/opencord/voltha-go/common/log"
-	"os"
-)
-
-// Simulated OLT default constants
-const (
-	EtcdStoreName            = "etcd"
-	default_InstanceID       = "simulatedOlt001"
-	default_KafkaAdapterHost = "127.0.0.1"
-	default_KafkaAdapterPort = 9092
-	default_KafkaClusterHost = "127.0.0.1"
-	default_KafkaClusterPort = 9094
-	default_KVStoreType      = EtcdStoreName
-	default_KVStoreTimeout   = 5 //in seconds
-	default_KVStoreHost      = "127.0.0.1"
-	default_KVStorePort      = 2379 // Consul = 8500; Etcd = 2379
-	default_LogLevel         = 0
-	default_Banner           = false
-	default_Topic            = "simulated_olt"
-	default_CoreTopic        = "rwcore"
-	default_OnuNumber        = 1
-)
-
-// AdapterFlags represents the set of configurations used by the read-write adaptercore service
-type AdapterFlags struct {
-	// Command line parameters
-	InstanceID       string
-	KafkaAdapterHost string
-	KafkaAdapterPort int
-	KafkaClusterHost string
-	KafkaClusterPort int
-	KVStoreType      string
-	KVStoreTimeout   int // in seconds
-	KVStoreHost      string
-	KVStorePort      int
-	Topic            string
-	CoreTopic        string
-	LogLevel         int
-	OnuNumber        int
-	Banner           bool
-}
-
-func init() {
-	log.AddPackage(log.JSON, log.WarnLevel, nil)
-}
-
-// NewRWCoreFlags returns a new RWCore config
-func NewAdapterFlags() *AdapterFlags {
-	var adapterFlags = AdapterFlags{ // Default values
-		InstanceID:       default_InstanceID,
-		KafkaAdapterHost: default_KafkaAdapterHost,
-		KafkaAdapterPort: default_KafkaAdapterPort,
-		KafkaClusterHost: default_KafkaClusterHost,
-		KafkaClusterPort: default_KafkaClusterPort,
-		KVStoreType:      default_KVStoreType,
-		KVStoreTimeout:   default_KVStoreTimeout,
-		KVStoreHost:      default_KVStoreHost,
-		KVStorePort:      default_KVStorePort,
-		Topic:            default_Topic,
-		CoreTopic:        default_CoreTopic,
-		LogLevel:         default_LogLevel,
-		OnuNumber:        default_OnuNumber,
-		Banner:           default_Banner,
-	}
-	return &adapterFlags
-}
-
-// ParseCommandArguments parses the arguments when running read-write adaptercore service
-func (so *AdapterFlags) ParseCommandArguments() {
-
-	var help string
-
-	help = fmt.Sprintf("Kafka - Adapter messaging host")
-	flag.StringVar(&(so.KafkaAdapterHost), "kafka_adapter_host", default_KafkaAdapterHost, help)
-
-	help = fmt.Sprintf("Kafka - Adapter messaging port")
-	flag.IntVar(&(so.KafkaAdapterPort), "kafka_adapter_port", default_KafkaAdapterPort, help)
-
-	help = fmt.Sprintf("Kafka - Cluster messaging host")
-	flag.StringVar(&(so.KafkaClusterHost), "kafka_cluster_host", default_KafkaClusterHost, help)
-
-	help = fmt.Sprintf("Kafka - Cluster messaging port")
-	flag.IntVar(&(so.KafkaClusterPort), "kafka_cluster_port", default_KafkaClusterPort, help)
-
-	help = fmt.Sprintf("Simulated OLT topic")
-	flag.StringVar(&(so.Topic), "simulator_topic", default_Topic, help)
-
-	help = fmt.Sprintf("Core topic")
-	flag.StringVar(&(so.CoreTopic), "core_topic", default_CoreTopic, help)
-
-	help = fmt.Sprintf("KV store type")
-	flag.StringVar(&(so.KVStoreType), "kv_store_type", default_KVStoreType, help)
-
-	help = fmt.Sprintf("The default timeout when making a kv store request")
-	flag.IntVar(&(so.KVStoreTimeout), "kv_store_request_timeout", default_KVStoreTimeout, help)
-
-	help = fmt.Sprintf("KV store host")
-	flag.StringVar(&(so.KVStoreHost), "kv_store_host", default_KVStoreHost, help)
-
-	help = fmt.Sprintf("KV store port")
-	flag.IntVar(&(so.KVStorePort), "kv_store_port", default_KVStorePort, help)
-
-	help = fmt.Sprintf("Log level")
-	flag.IntVar(&(so.LogLevel), "log_level", default_LogLevel, help)
-
-	help = fmt.Sprintf("Number of ONUs")
-	flag.IntVar(&(so.OnuNumber), "onu_number", default_OnuNumber, help)
-
-	help = fmt.Sprintf("Show startup banner log lines")
-	flag.BoolVar(&so.Banner, "banner", default_Banner, help)
-
-	flag.Parse()
-
-	containerName := getContainerInfo()
-	if len(containerName) > 0 {
-		so.InstanceID = containerName
-	}
-
-}
-
-func getContainerInfo() string {
-	return os.Getenv("HOSTNAME")
-}
diff --git a/adapters/simulated_olt/main.go b/adapters/simulated_olt/main.go
deleted file mode 100644
index ba9b9ed..0000000
--- a/adapters/simulated_olt/main.go
+++ /dev/null
@@ -1,337 +0,0 @@
-/*
- * Copyright 2018-present Open Networking Foundation
-
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
-
- * http://www.apache.org/licenses/LICENSE-2.0
-
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * 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/adapters"
-	com "github.com/opencord/voltha-go/adapters/common"
-	ac "github.com/opencord/voltha-go/adapters/simulated_olt/adaptercore"
-	"github.com/opencord/voltha-go/adapters/simulated_olt/config"
-	"github.com/opencord/voltha-go/common/log"
-	"github.com/opencord/voltha-go/db/kvstore"
-	"github.com/opencord/voltha-go/kafka"
-	ic "github.com/opencord/voltha-protos/go/inter_container"
-	"github.com/opencord/voltha-protos/go/voltha"
-	"os"
-	"os/signal"
-	"strconv"
-	"syscall"
-	"time"
-)
-
-type adapter struct {
-	instanceId       string
-	config           *config.AdapterFlags
-	iAdapter         adapters.IAdapter
-	kafkaClient      kafka.Client
-	kvClient         kvstore.Client
-	kip              *kafka.InterContainerProxy
-	coreProxy        *com.CoreProxy
-	halted           bool
-	exitChannel      chan int
-	receiverChannels []<-chan *ic.InterContainerMessage
-}
-
-func init() {
-	log.AddPackage(log.JSON, log.DebugLevel, nil)
-}
-
-func newAdapter(cf *config.AdapterFlags) *adapter {
-	var a adapter
-	a.instanceId = cf.InstanceID
-	a.config = cf
-	a.halted = false
-	a.exitChannel = make(chan int, 1)
-	a.receiverChannels = make([]<-chan *ic.InterContainerMessage, 0)
-	return &a
-}
-
-func (a *adapter) start(ctx context.Context) {
-	log.Info("Starting Core Adapter components")
-	var err error
-
-	// Setup KV Client
-	log.Debugw("create-kv-client", log.Fields{"kvstore": a.config.KVStoreType})
-	if err := a.setKVClient(); err != nil {
-		log.Fatal("error-setting-kv-client")
-	}
-
-	// Setup Kafka Client
-	if a.kafkaClient, err = newKafkaClient("sarama", a.config.KafkaAdapterHost, a.config.KafkaAdapterPort); err != nil {
-		log.Fatal("Unsupported-common-client")
-	}
-
-	// Start the common InterContainer Proxy - retries indefinitely
-	if a.kip, err = a.startInterContainerProxy(-1); err != nil {
-		log.Fatal("error-starting-inter-container-proxy")
-	}
-
-	// Create the core proxy to handle requests to the Core
-	a.coreProxy = com.NewCoreProxy(a.kip, a.config.Topic, a.config.CoreTopic)
-
-	// Create the simulated OLT adapter
-	if a.iAdapter, err = a.startSimulatedOLT(ctx, a.kip, a.coreProxy, a.config.OnuNumber); err != nil {
-		log.Fatal("error-starting-inter-container-proxy")
-	}
-
-	// Register the core request handler
-	if err = a.setupRequestHandler(a.instanceId, a.iAdapter, a.coreProxy); err != nil {
-		log.Fatal("error-setting-core-request-handler")
-	}
-
-	//	Register this adapter to the Core - retries indefinitely
-	if err = a.registerWithCore(-1); err != nil {
-		log.Fatal("error-registering-with-core")
-	}
-}
-
-func (rw *adapter) stop() {
-	// Stop leadership tracking
-	rw.halted = true
-
-	// send exit signal
-	rw.exitChannel <- 0
-
-	// Cleanup - applies only if we had a kvClient
-	if rw.kvClient != nil {
-		// Release all reservations
-		if err := rw.kvClient.ReleaseAllReservations(); err != nil {
-			log.Infow("fail-to-release-all-reservations", log.Fields{"error": err})
-		}
-		// Close the DB connection
-		rw.kvClient.Close()
-	}
-
-	// TODO:  More cleanup
-}
-
-func newKVClient(storeType string, address string, timeout int) (kvstore.Client, error) {
-
-	log.Infow("kv-store-type", log.Fields{"store": storeType})
-	switch storeType {
-	case "consul":
-		return kvstore.NewConsulClient(address, timeout)
-	case "etcd":
-		return kvstore.NewEtcdClient(address, timeout)
-	}
-	return nil, errors.New("unsupported-kv-store")
-}
-
-func newKafkaClient(clientType string, host string, port int) (kafka.Client, error) {
-
-	log.Infow("common-client-type", log.Fields{"client": clientType})
-	switch clientType {
-	case "sarama":
-		return kafka.NewSaramaClient(
-			kafka.Host(host),
-			kafka.Port(port),
-			kafka.ProducerReturnOnErrors(true),
-			kafka.ProducerReturnOnSuccess(true),
-			kafka.ProducerMaxRetries(6),
-			kafka.ProducerRetryBackoff(time.Millisecond*30)), nil
-	}
-	return nil, errors.New("unsupported-client-type")
-}
-
-func (a *adapter) setKVClient() error {
-	addr := a.config.KVStoreHost + ":" + strconv.Itoa(a.config.KVStorePort)
-	client, err := newKVClient(a.config.KVStoreType, addr, a.config.KVStoreTimeout)
-	if err != nil {
-		a.kvClient = nil
-		log.Error(err)
-		return err
-	}
-	a.kvClient = client
-	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 (a *adapter) startInterContainerProxy(retries int) (*kafka.InterContainerProxy, error) {
-	log.Infow("starting-intercontainer-messaging-proxy", log.Fields{"host": a.config.KafkaAdapterHost,
-		"port": a.config.KafkaAdapterPort, "topic": a.config.Topic})
-	var err error
-	var kip *kafka.InterContainerProxy
-	if kip, err = kafka.NewInterContainerProxy(
-		kafka.InterContainerHost(a.config.KafkaAdapterHost),
-		kafka.InterContainerPort(a.config.KafkaAdapterPort),
-		kafka.MsgClient(a.kafkaClient),
-		kafka.DefaultTopic(&kafka.Topic{Name: a.config.Topic})); err != nil {
-		log.Errorw("fail-to-create-common-proxy", log.Fields{"error": err})
-		return nil, err
-	}
-	count := 0
-	for {
-		if err = kip.Start(); err != nil {
-			log.Warnw("error-starting-messaging-proxy", log.Fields{"error": err})
-			if retries == count {
-				return nil, err
-			}
-			count = +1
-			//	Take a nap before retrying
-			time.Sleep(2 * time.Second)
-		} else {
-			break
-		}
-	}
-
-	log.Info("common-messaging-proxy-created")
-	return kip, nil
-}
-
-func (a *adapter) startSimulatedOLT(ctx context.Context, kip *kafka.InterContainerProxy, cp *com.CoreProxy, onuNumber int) (*ac.SimulatedOLT, error) {
-	log.Info("starting-simulated-olt")
-	var err error
-	sOLT := ac.NewSimulatedOLT(ctx, a.kip, cp, onuNumber)
-
-	if err = sOLT.Start(ctx); err != nil {
-		log.Fatalw("error-starting-messaging-proxy", log.Fields{"error": err})
-		return nil, err
-	}
-
-	log.Info("simulated-olt-started")
-	return sOLT, nil
-}
-
-func (a *adapter) setupRequestHandler(coreInstanceId string, iadapter adapters.IAdapter, coreProxy *com.CoreProxy) error {
-	log.Info("setting-request-handler")
-	requestProxy := com.NewRequestHandlerProxy(coreInstanceId, iadapter, coreProxy)
-	if err := a.kip.SubscribeWithRequestHandlerInterface(kafka.Topic{Name: a.config.Topic}, requestProxy); err != nil {
-		log.Errorw("request-handler-setup-failed", log.Fields{"error": err})
-		return err
-
-	}
-	log.Info("request-handler-setup-done")
-	return nil
-}
-
-func (a *adapter) registerWithCore(retries int) error {
-	log.Info("registering-with-core")
-	adapterDescription := &voltha.Adapter{Id: "simulated_olt", Vendor: "simulation Enterprise Inc"}
-	types := []*voltha.DeviceType{{Id: "simulated_olt", Adapter: "simulated_olt", AcceptsAddRemoveFlowUpdates: true}}
-	deviceTypes := &voltha.DeviceTypes{Items: types}
-	count := 0
-	for {
-		if err := a.coreProxy.RegisterAdapter(nil, adapterDescription, deviceTypes); err != nil {
-			log.Warnw("registering-with-core-failed", log.Fields{"error": err})
-			if retries == count {
-				return err
-			}
-			count += 1
-			//	Take a nap before retrying
-			time.Sleep(2 * time.Second)
-		} else {
-			break
-		}
-	}
-	log.Info("registered-with-core")
-	return nil
-}
-
-func waitForExit() int {
-	signalChannel := make(chan os.Signal, 1)
-	signal.Notify(signalChannel,
-		syscall.SIGHUP,
-		syscall.SIGINT,
-		syscall.SIGTERM,
-		syscall.SIGQUIT)
-
-	exitChannel := make(chan int)
-
-	go func() {
-		s := <-signalChannel
-		switch s {
-		case syscall.SIGHUP,
-			syscall.SIGINT,
-			syscall.SIGTERM,
-			syscall.SIGQUIT:
-			log.Infow("closing-signal-received", log.Fields{"signal": s})
-			exitChannel <- 0
-		default:
-			log.Infow("unexpected-signal-received", log.Fields{"signal": s})
-			exitChannel <- 1
-		}
-	}()
-
-	code := <-exitChannel
-	return code
-}
-
-func printBanner() {
-	fmt.Println(" ____  _                 _       _           _  ___  _   _____		")
-	fmt.Println("/ ___|(_)_ __ ___  _   _| | __ _| |_ ___  __| |/ _ \\| | |_   _|	")
-	fmt.Println("\\___ \\| | '_ ` _ \\| | | | |/ _` | __/ _ \\/ _` | | | | |   | |	")
-	fmt.Println(" ___) | | | | | | | |_| | | (_| | ||  __/ (_| | |_| | |___| |		")
-	fmt.Println("|____/|_|_| |_| |_|\\__,_|_|\\__,_|\\__\\___|\\__,_|\\___/|_____|_|	")
-	fmt.Println("																	")
-}
-
-func main() {
-	start := time.Now()
-
-	cf := config.NewAdapterFlags()
-	cf.ParseCommandArguments()
-
-	//// 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 {
-		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 {
-		log.With(log.Fields{"error": err}).Fatal("Cannot setup logging")
-	}
-
-	log.SetPackageLogLevel("github.com/opencord/voltha-go/adapters/common", log.DebugLevel)
-
-	defer log.CleanUp()
-
-	// Print banner if specified
-	if cf.Banner {
-		printBanner()
-	}
-
-	log.Infow("config", log.Fields{"config": *cf})
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	ad := newAdapter(cf)
-	go ad.start(ctx)
-
-	code := waitForExit()
-	log.Infow("received-a-closing-signal", log.Fields{"code": code})
-
-	// Cleanup before leaving
-	ad.stop()
-
-	elapsed := time.Since(start)
-	log.Infow("run-time", log.Fields{"instanceId": ad.config.InstanceID, "time": elapsed / time.Second})
-}
diff --git a/adapters/simulated_onu/adaptercore/device_handler.go b/adapters/simulated_onu/adaptercore/device_handler.go
deleted file mode 100644
index fa41136..0000000
--- a/adapters/simulated_onu/adaptercore/device_handler.go
+++ /dev/null
@@ -1,318 +0,0 @@
-/*
- * Copyright 2018-present Open Networking Foundation
-
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
-
- * http://www.apache.org/licenses/LICENSE-2.0
-
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package adaptercore
-
-import (
-	"context"
-	"fmt"
-	"github.com/gogo/protobuf/proto"
-	com "github.com/opencord/voltha-go/adapters/common"
-	"github.com/opencord/voltha-go/common/log"
-	ic "github.com/opencord/voltha-protos/go/inter_container"
-	of "github.com/opencord/voltha-protos/go/openflow_13"
-	"github.com/opencord/voltha-protos/go/voltha"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-)
-
-// A set of pm names to create the initial pm config.  This is used only for testing in this simulated adapter
-var pmNames = []string{
-	"tx_64_pkts",
-	"tx_65_127_pkts",
-	"tx_128_255_pkts",
-	"tx_1024_1518_pkts",
-	"tx_1519_9k_pkts",
-	"rx_64_pkts",
-	"rx_64_pkts",
-	"rx_65_127_pkts",
-	"rx_128_255_pkts",
-	"rx_1024_1518_pkts",
-	"rx_1519_9k_pkts",
-}
-
-//DeviceHandler follows the same patterns as ponsim_olt.  The only difference is that it does not
-// interact with an OLT device.
-type DeviceHandler struct {
-	deviceId     string
-	deviceType   string
-	device       *voltha.Device
-	coreProxy    *com.CoreProxy
-	simulatedOLT *SimulatedONU
-	uniPort      *voltha.Port
-	ponPort      *voltha.Port
-	exitChannel  chan int
-	lockDevice   sync.RWMutex
-	metrics      *com.PmMetrics
-}
-
-//NewDeviceHandler creates a new device handler
-func NewDeviceHandler(cp *com.CoreProxy, device *voltha.Device, adapter *SimulatedONU) *DeviceHandler {
-	var dh DeviceHandler
-	dh.coreProxy = cp
-	cloned := (proto.Clone(device)).(*voltha.Device)
-	dh.deviceId = cloned.Id
-	dh.deviceType = cloned.Type
-	dh.device = cloned
-	dh.simulatedOLT = adapter
-	dh.exitChannel = make(chan int, 1)
-	dh.lockDevice = sync.RWMutex{}
-	dh.metrics = com.NewPmMetrics(
-		cloned.Id,
-		com.Frequency(150),
-		com.Grouped(false),
-		com.FrequencyOverride(false),
-		com.Metrics(pmNames),
-	)
-	return &dh
-}
-
-// start save the device to the data model
-func (dh *DeviceHandler) start(ctx context.Context) {
-	dh.lockDevice.Lock()
-	defer dh.lockDevice.Unlock()
-	log.Debugw("starting-device-agent", log.Fields{"device": dh.device})
-	// Add the initial device to the local model
-	log.Debug("device-agent-started")
-}
-
-// stop stops the device dh.  Not much to do for now
-func (dh *DeviceHandler) stop(ctx context.Context) {
-	dh.lockDevice.Lock()
-	defer dh.lockDevice.Unlock()
-	log.Debug("stopping-device-agent")
-	dh.exitChannel <- 1
-	log.Debug("device-agent-stopped")
-}
-
-func macAddressToUint32Array(mac string) []uint32 {
-	slist := strings.Split(mac, ":")
-	result := make([]uint32, len(slist))
-	var err error
-	var tmp int64
-	for index, val := range slist {
-		if tmp, err = strconv.ParseInt(val, 16, 32); err != nil {
-			return []uint32{1, 2, 3, 4, 5, 6}
-		}
-		result[index] = uint32(tmp)
-	}
-	return result
-}
-
-func (dh *DeviceHandler) AdoptDevice(device *voltha.Device) {
-	log.Debugw("AdoptDevice", log.Fields{"deviceId": device.Id})
-
-	//	Update the device info
-	cloned := proto.Clone(device).(*voltha.Device)
-	cloned.Root = false
-	cloned.Vendor = "simulators"
-	cloned.Model = "go-simulators"
-	//cloned.SerialNumber = com.GetRandomSerialNumber()
-	cloned.MacAddress = strings.ToUpper(com.GetRandomMacAddress())
-
-	// Synchronous call to update device - this method is run in its own go routine
-	if err := dh.coreProxy.DeviceUpdate(nil, cloned); err != nil {
-		log.Errorw("error-updating-device", log.Fields{"deviceId": device.Id, "error": err})
-	}
-
-	//	Update the device state to DISCOVERED
-	cloned.ConnectStatus = voltha.ConnectStatus_REACHABLE
-	cloned.OperStatus = voltha.OperStatus_DISCOVERED
-	if err := dh.coreProxy.DeviceStateUpdate(nil, cloned.Id, cloned.ConnectStatus, cloned.OperStatus); err != nil {
-		log.Errorw("error-creating-nni-port", log.Fields{"deviceId": device.Id, "error": err})
-	}
-
-	// Now, set the initial PM configuration for that device
-	if err := dh.coreProxy.DevicePMConfigUpdate(nil, dh.metrics.ToPmConfigs()); err != nil {
-		log.Errorw("error-updating-PMs", log.Fields{"deviceId": device.Id, "error": err})
-	}
-
-	// Sleep to mimic the omci management channel creation with the OLT
-	time.Sleep(10 * time.Millisecond)
-
-	//	Update the device state to ACTIVATING
-	cloned.ConnectStatus = voltha.ConnectStatus_REACHABLE
-	cloned.OperStatus = voltha.OperStatus_ACTIVATING
-	if err := dh.coreProxy.DeviceStateUpdate(nil, cloned.Id, cloned.ConnectStatus, cloned.OperStatus); err != nil {
-		log.Errorw("error-creating-nni-port", log.Fields{"deviceId": device.Id, "error": err})
-	}
-
-	// Sleep to mimic the omci discovery ( usually takes a few seconds but for ease of simulated environment we are
-	// setting it to 100ms only.
-	time.Sleep(100 * time.Millisecond)
-
-	// Use the channel Id, assigned by the parent device to me, as the port number
-	uni_port := uint32(2)
-	if device.ProxyAddress != nil {
-		if device.ProxyAddress.ChannelId != 0 {
-			uni_port = device.ProxyAddress.ChannelId
-		}
-	}
-
-	//	Now create the UNI Port
-	dh.uniPort = &voltha.Port{
-		PortNo:     uni_port,
-		Label:      fmt.Sprintf("uni-%d", uni_port),
-		Type:       voltha.Port_ETHERNET_UNI,
-		AdminState: voltha.AdminState_ENABLED,
-		OperStatus: voltha.OperStatus_ACTIVE,
-	}
-
-	// Synchronous call to update device - this method is run in its own go routine
-	if err := dh.coreProxy.PortCreated(nil, cloned.Id, dh.uniPort); err != nil {
-		log.Errorw("error-creating-nni-port", log.Fields{"deviceId": device.Id, "error": err})
-	}
-	// use Pon port number on which this ONU has been detected
-	ponPortNo := uint32(1)
-	if device.ParentPortNo != 0 {
-		ponPortNo = device.ParentPortNo
-	}
-	//	Now create the PON Port
-	dh.ponPort = &voltha.Port{
-		PortNo:     ponPortNo,
-		Label:      fmt.Sprintf("pon-%d", ponPortNo),
-		Type:       voltha.Port_PON_ONU,
-		AdminState: voltha.AdminState_ENABLED,
-		OperStatus: voltha.OperStatus_ACTIVE,
-		Peers: []*voltha.Port_PeerPort{{DeviceId: cloned.ParentId, // Peer device  is OLT
-			PortNo: uni_port}}, // Peer port is UNI port
-	}
-
-	// Synchronous call to update device - this method is run in its own go routine
-	if err := dh.coreProxy.PortCreated(nil, cloned.Id, dh.ponPort); err != nil {
-		log.Errorw("error-creating-nni-port", log.Fields{"deviceId": device.Id, "error": err})
-	}
-
-	cloned.ConnectStatus = voltha.ConnectStatus_REACHABLE
-	cloned.OperStatus = voltha.OperStatus_ACTIVE
-
-	//	Update the device state
-	if err := dh.coreProxy.DeviceStateUpdate(nil, cloned.Id, cloned.ConnectStatus, cloned.OperStatus); err != nil {
-		log.Errorw("error-creating-nni-port", log.Fields{"deviceId": device.Id, "error": err})
-	}
-
-	dh.device = cloned
-}
-
-func (dh *DeviceHandler) GetOfpPortInfo(device *voltha.Device, portNo int64) (*ic.PortCapability, error) {
-	cap := uint32(of.OfpPortFeatures_OFPPF_1GB_FD | of.OfpPortFeatures_OFPPF_FIBER)
-	return &ic.PortCapability{
-		Port: &voltha.LogicalPort{
-			OfpPort: &of.OfpPort{
-				HwAddr:     macAddressToUint32Array(dh.device.MacAddress),
-				Config:     0,
-				State:      uint32(of.OfpPortState_OFPPS_LIVE),
-				Curr:       cap,
-				Advertised: cap,
-				Peer:       cap,
-				CurrSpeed:  uint32(of.OfpPortFeatures_OFPPF_1GB_FD),
-				MaxSpeed:   uint32(of.OfpPortFeatures_OFPPF_1GB_FD),
-			},
-			DeviceId:     dh.device.Id,
-			DevicePortNo: uint32(portNo),
-		},
-	}, nil
-}
-
-func (dh *DeviceHandler) Process_inter_adapter_message(msg *ic.InterAdapterMessage) error {
-	log.Debugw("Process_inter_adapter_message", log.Fields{"msgId": msg.Header.Id})
-	return nil
-}
-
-func (dh *DeviceHandler) DisableDevice(device *voltha.Device) {
-	cloned := proto.Clone(device).(*voltha.Device)
-	// Update the all ports state on that device to disable
-	if err := dh.coreProxy.PortsStateUpdate(nil, cloned.Id, voltha.OperStatus_UNKNOWN); err != nil {
-		log.Errorw("updating-ports-failed", log.Fields{"deviceId": device.Id, "error": err})
-		return
-	}
-
-	//Update the device state
-	cloned.ConnectStatus = voltha.ConnectStatus_UNREACHABLE
-	cloned.OperStatus = voltha.OperStatus_UNKNOWN
-	dh.device = cloned
-
-	if err := dh.coreProxy.DeviceStateUpdate(nil, cloned.Id, cloned.ConnectStatus, cloned.OperStatus); err != nil {
-		log.Errorw("device-state-update-failed", log.Fields{"deviceId": device.Id, "error": err})
-		return
-	}
-	log.Debugw("DisableDevice-end", log.Fields{"deviceId": device.Id})
-}
-
-func (dh *DeviceHandler) ReEnableDevice(device *voltha.Device) {
-
-	cloned := proto.Clone(device).(*voltha.Device)
-	// Update the all ports state on that device to enable
-	if err := dh.coreProxy.PortsStateUpdate(nil, cloned.Id, voltha.OperStatus_ACTIVE); err != nil {
-		log.Errorw("updating-ports-failed", log.Fields{"deviceId": device.Id, "error": err})
-		return
-	}
-
-	//Update the device state
-	cloned.ConnectStatus = voltha.ConnectStatus_REACHABLE
-	cloned.OperStatus = voltha.OperStatus_ACTIVE
-	dh.device = cloned
-
-	if err := dh.coreProxy.DeviceStateUpdate(nil, cloned.Id, cloned.ConnectStatus, cloned.OperStatus); err != nil {
-		log.Errorw("device-state-update-failed", log.Fields{"deviceId": device.Id, "error": err})
-		return
-	}
-	log.Debugw("ReEnableDevice-end", log.Fields{"deviceId": device.Id})
-}
-
-func (dh *DeviceHandler) DeleteDevice(device *voltha.Device) {
-	cloned := proto.Clone(device).(*voltha.Device)
-	// Update the all ports state on that device to disable
-	if err := dh.coreProxy.DeleteAllPorts(nil, cloned.Id); err != nil {
-		log.Errorw("delete-ports-failed", log.Fields{"deviceId": device.Id, "error": err})
-		return
-	}
-
-	log.Debugw("DeleteDevice-end", log.Fields{"deviceId": device.Id})
-}
-
-func (dh *DeviceHandler) UpdateFlowsBulk(device *voltha.Device, flows *voltha.Flows, groups *voltha.FlowGroups, metadata *voltha.FlowMetadata) {
-	log.Debugw("UpdateFlowsBulk", log.Fields{"deviceId": device.Id, "flows": flows, "groups": groups})
-	// For now we do nothing with it
-	return
-}
-
-func (dh *DeviceHandler) UpdateFlowsIncremental(device *voltha.Device, flowChanges *of.FlowChanges, groupChanges *of.FlowGroupChanges, metadata *voltha.FlowMetadata) {
-	log.Debugw("UpdateFlowsIncremental", log.Fields{"deviceId": device.Id, "flowChanges": flowChanges, "groupChanges": groupChanges})
-	// For now we do nothing with it
-	return
-}
-
-func (dh *DeviceHandler) UpdatePmConfigs(device *voltha.Device, pmConfigs *voltha.PmConfigs) {
-	log.Debugw("UpdatePmConfigs", log.Fields{"deviceId": device.Id, "pmConfigs": pmConfigs})
-	// For now we do nothing with it
-	return
-}
-
-func (dh *DeviceHandler) ReconcileDevice(device *voltha.Device) {
-	// Update the device info
-	cloned := proto.Clone(device).(*voltha.Device)
-	cloned.ConnectStatus = voltha.ConnectStatus_REACHABLE
-	cloned.OperStatus = voltha.OperStatus_ACTIVE
-
-	dh.device = cloned
-
-	// Update the device state
-	if err := dh.coreProxy.DeviceStateUpdate(nil, cloned.Id, cloned.ConnectStatus, cloned.OperStatus); err != nil {
-		log.Errorw("error-creating-nni-port", log.Fields{"deviceId": device.Id, "error": err})
-	}
-}
diff --git a/adapters/simulated_onu/adaptercore/simulated_onu.go b/adapters/simulated_onu/adaptercore/simulated_onu.go
deleted file mode 100644
index bb23acf..0000000
--- a/adapters/simulated_onu/adaptercore/simulated_onu.go
+++ /dev/null
@@ -1,293 +0,0 @@
-/*
- * Copyright 2018-present Open Networking Foundation
-
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
-
- * http://www.apache.org/licenses/LICENSE-2.0
-
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package adaptercore
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	com "github.com/opencord/voltha-go/adapters/common"
-	"github.com/opencord/voltha-go/common/log"
-	"github.com/opencord/voltha-go/kafka"
-	ic "github.com/opencord/voltha-protos/go/inter_container"
-	"github.com/opencord/voltha-protos/go/openflow_13"
-	"github.com/opencord/voltha-protos/go/voltha"
-	"sync"
-)
-
-type SimulatedONU struct {
-	deviceHandlers        map[string]*DeviceHandler
-	coreProxy             *com.CoreProxy
-	kafkaICProxy          *kafka.InterContainerProxy
-	exitChannel           chan int
-	lockDeviceHandlersMap sync.RWMutex
-}
-
-func NewSimulatedONU(ctx context.Context, kafkaICProxy *kafka.InterContainerProxy, coreProxy *com.CoreProxy) *SimulatedONU {
-	var simulatedOLT SimulatedONU
-	simulatedOLT.exitChannel = make(chan int, 1)
-	simulatedOLT.deviceHandlers = make(map[string]*DeviceHandler)
-	simulatedOLT.kafkaICProxy = kafkaICProxy
-	simulatedOLT.coreProxy = coreProxy
-	simulatedOLT.lockDeviceHandlersMap = sync.RWMutex{}
-	return &simulatedOLT
-}
-
-func (so *SimulatedONU) Start(ctx context.Context) error {
-	log.Info("starting-device-manager")
-	log.Info("device-manager-started")
-	return nil
-}
-
-func (so *SimulatedONU) Stop(ctx context.Context) error {
-	log.Info("stopping-device-manager")
-	so.exitChannel <- 1
-	log.Info("device-manager-stopped")
-	return nil
-}
-
-func sendResponse(ctx context.Context, ch chan interface{}, result interface{}) {
-	if ctx.Err() == nil {
-		// Returned response only of the ctx has not been cancelled/timeout/etc
-		// Channel is automatically closed when a context is Done
-		ch <- result
-		log.Debugw("sendResponse", log.Fields{"result": result})
-	} else {
-		// Should the transaction be reverted back?
-		log.Debugw("sendResponse-context-error", log.Fields{"context-error": ctx.Err()})
-	}
-}
-
-func (so *SimulatedONU) addDeviceHandlerToMap(agent *DeviceHandler) {
-	so.lockDeviceHandlersMap.Lock()
-	defer so.lockDeviceHandlersMap.Unlock()
-	if _, exist := so.deviceHandlers[agent.deviceId]; !exist {
-		so.deviceHandlers[agent.deviceId] = agent
-	}
-}
-
-func (so *SimulatedONU) deleteDeviceHandlerToMap(agent *DeviceHandler) {
-	so.lockDeviceHandlersMap.Lock()
-	defer so.lockDeviceHandlersMap.Unlock()
-	delete(so.deviceHandlers, agent.deviceId)
-}
-
-func (so *SimulatedONU) getDeviceHandler(deviceId string) *DeviceHandler {
-	so.lockDeviceHandlersMap.Lock()
-	defer so.lockDeviceHandlersMap.Unlock()
-	if agent, ok := so.deviceHandlers[deviceId]; ok {
-		return agent
-	}
-	return nil
-}
-
-func (so *SimulatedONU) Adopt_device(device *voltha.Device) error {
-	if device == nil {
-		log.Warn("device-is-nil")
-		return errors.New("nil-device")
-	}
-	log.Infow("adopt-device", log.Fields{"deviceId": device.Id})
-	var handler *DeviceHandler
-	if handler = so.getDeviceHandler(device.Id); handler == nil {
-		handler := NewDeviceHandler(so.coreProxy, device, so)
-		so.addDeviceHandlerToMap(handler)
-		go handler.AdoptDevice(device)
-	}
-	return nil
-}
-
-func (so *SimulatedONU) Get_ofp_device_info(device *voltha.Device) (*ic.SwitchCapability, error) {
-	log.Infow("not-implemented-for-onu", log.Fields{"deviceId": device.Id})
-	return nil, nil
-}
-
-func (so *SimulatedONU) Get_ofp_port_info(device *voltha.Device, port_no int64) (*ic.PortCapability, error) {
-	log.Infow("Get_ofp_port_info", log.Fields{"deviceId": device.Id})
-	if handler := so.getDeviceHandler(device.Id); handler != nil {
-		return handler.GetOfpPortInfo(device, port_no)
-	}
-	log.Errorw("device-handler-not-set", log.Fields{"deviceId": device.Id})
-	return nil, errors.New("device-handler-not-set")
-}
-
-func (so *SimulatedONU) Process_inter_adapter_message(msg *ic.InterAdapterMessage) error {
-	log.Infow("Process_inter_adapter_message", log.Fields{"msgId": msg.Header.Id})
-	targetDevice := msg.Header.ProxyDeviceId // Request?
-	if targetDevice == "" && msg.Header.ToDeviceId != "" {
-		// Typical response
-		targetDevice = msg.Header.ToDeviceId
-	}
-	if handler := so.getDeviceHandler(targetDevice); handler != nil {
-		return handler.Process_inter_adapter_message(msg)
-	}
-	return errors.New(fmt.Sprintf("handler-not-found-%s", targetDevice))
-}
-
-func (so *SimulatedONU) Adapter_descriptor() error {
-	return errors.New("UnImplemented")
-}
-
-func (so *SimulatedONU) Device_types() (*voltha.DeviceTypes, error) {
-	return nil, errors.New("UnImplemented")
-}
-
-func (so *SimulatedONU) Health() (*voltha.HealthStatus, error) {
-	return nil, errors.New("UnImplemented")
-}
-
-func (so *SimulatedONU) Reconcile_device(device *voltha.Device) error {
-	if device == nil {
-		log.Warn("device-is-nil")
-		return errors.New("nil-device")
-	}
-	log.Infow("reconcile-device", log.Fields{"deviceId": device.Id})
-	var handler *DeviceHandler
-	handler = so.getDeviceHandler(device.Id)
-	if handler == nil {
-		//	Adapter has restarted
-		handler = NewDeviceHandler(so.coreProxy, device, so)
-		so.addDeviceHandlerToMap(handler)
-	}
-	go handler.ReconcileDevice(device)
-
-	return nil
-}
-
-func (so *SimulatedONU) Abandon_device(device *voltha.Device) error {
-	return errors.New("UnImplemented")
-}
-
-func (so *SimulatedONU) Disable_device(device *voltha.Device) error {
-	if device == nil {
-		log.Warn("device-is-nil")
-		return errors.New("nil-device")
-	}
-	log.Infow("disable-device", log.Fields{"deviceId": device.Id})
-	var handler *DeviceHandler
-	if handler = so.getDeviceHandler(device.Id); handler != nil {
-		go handler.DisableDevice(device)
-	}
-	return nil
-}
-
-func (so *SimulatedONU) Reenable_device(device *voltha.Device) error {
-	if device == nil {
-		log.Warn("device-is-nil")
-		return errors.New("nil-device")
-	}
-	log.Infow("reenable-device", log.Fields{"deviceId": device.Id})
-	var handler *DeviceHandler
-	if handler = so.getDeviceHandler(device.Id); handler != nil {
-		go handler.ReEnableDevice(device)
-	}
-	return nil
-}
-
-func (so *SimulatedONU) Reboot_device(device *voltha.Device) error {
-	return errors.New("UnImplemented")
-}
-
-func (so *SimulatedONU) Self_test_device(device *voltha.Device) error {
-	return errors.New("UnImplemented")
-}
-
-func (so *SimulatedONU) Delete_device(device *voltha.Device) error {
-	if device == nil {
-		log.Warn("device-is-nil")
-		return errors.New("nil-device")
-	}
-	log.Infow("delete-device", log.Fields{"deviceId": device.Id})
-	var handler *DeviceHandler
-	if handler = so.getDeviceHandler(device.Id); handler != nil {
-		go handler.DeleteDevice(device)
-	}
-	return nil
-}
-
-func (so *SimulatedONU) Get_device_details(device *voltha.Device) error {
-	return errors.New("UnImplemented")
-}
-
-func (so *SimulatedONU) Update_flows_bulk(device *voltha.Device, flows *voltha.Flows, groups *voltha.FlowGroups, metadata *voltha.FlowMetadata) error {
-	if device == nil {
-		log.Warn("device-is-nil")
-		return errors.New("nil-device")
-	}
-	log.Debugw("bulk-flow-updates", log.Fields{"deviceId": device.Id, "flows": flows, "groups": groups})
-	var handler *DeviceHandler
-	if handler = so.getDeviceHandler(device.Id); handler != nil {
-		go handler.UpdateFlowsBulk(device, flows, groups, metadata)
-	}
-	return nil
-}
-
-func (so *SimulatedONU) Update_flows_incrementally(device *voltha.Device, flowChanges *openflow_13.FlowChanges, groupChanges *openflow_13.FlowGroupChanges, metadata *voltha.FlowMetadata) error {
-	if device == nil {
-		log.Warn("device-is-nil")
-		return errors.New("nil-device")
-	}
-	log.Debugw("incremental-flow-update", log.Fields{"deviceId": device.Id, "flowChanges": flowChanges, "groupChanges": groupChanges})
-	var handler *DeviceHandler
-	if handler = so.getDeviceHandler(device.Id); handler != nil {
-		go handler.UpdateFlowsIncremental(device, flowChanges, groupChanges, metadata)
-	}
-	return nil
-}
-
-func (so *SimulatedONU) Update_pm_config(device *voltha.Device, pmConfigs *voltha.PmConfigs) error {
-	if device == nil {
-		log.Warn("device-is-nil")
-		return errors.New("nil-device")
-	}
-	log.Debugw("update_pm_config", log.Fields{"deviceId": device.Id, "pmConfigs": pmConfigs})
-	var handler *DeviceHandler
-	if handler = so.getDeviceHandler(device.Id); handler != nil {
-		go handler.UpdatePmConfigs(device, pmConfigs)
-	}
-	return nil
-}
-
-func (so *SimulatedONU) Receive_packet_out(deviceId string, egress_port_no int, msg *openflow_13.OfpPacketOut) error {
-	return errors.New("UnImplemented")
-}
-
-func (so *SimulatedONU) Suppress_alarm(filter *voltha.AlarmFilter) error {
-	return errors.New("UnImplemented")
-}
-
-func (so *SimulatedONU) Unsuppress_alarm(filter *voltha.AlarmFilter) error {
-	return errors.New("UnImplemented")
-}
-
-func (so *SimulatedONU) Download_image(device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
-	return nil, errors.New("UnImplemented")
-}
-
-func (so *SimulatedONU) Get_image_download_status(device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
-	return nil, errors.New("UnImplemented")
-}
-
-func (so *SimulatedONU) Cancel_image_download(device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
-	return nil, errors.New("UnImplemented")
-}
-
-func (so *SimulatedONU) Activate_image_update(device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
-	return nil, errors.New("UnImplemented")
-}
-
-func (so *SimulatedONU) Revert_image_update(device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
-	return nil, errors.New("UnImplemented")
-}
diff --git a/adapters/simulated_onu/config/config.go b/adapters/simulated_onu/config/config.go
deleted file mode 100644
index 2971169..0000000
--- a/adapters/simulated_onu/config/config.go
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
- * Copyright 2018-present Open Networking Foundation
-
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
-
- * http://www.apache.org/licenses/LICENSE-2.0
-
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package config
-
-import (
-	"flag"
-	"fmt"
-	"github.com/opencord/voltha-go/common/log"
-	"os"
-)
-
-// Simulated OLT default constants
-const (
-	EtcdStoreName            = "etcd"
-	default_InstanceID       = "simulatedOnu001"
-	default_KafkaAdapterHost = "127.0.0.1"
-	default_KafkaAdapterPort = 9092
-	default_KafkaClusterHost = "127.0.0.1"
-	default_KafkaClusterPort = 9094
-	default_KVStoreType      = EtcdStoreName
-	default_KVStoreTimeout   = 5 //in seconds
-	default_KVStoreHost      = "127.0.0.1"
-	default_KVStorePort      = 2379 // Consul = 8500; Etcd = 2379
-	default_LogLevel         = 0
-	default_Banner           = false
-	default_Topic            = "simulated_onu"
-	default_CoreTopic        = "rwcore"
-)
-
-// AdapterFlags represents the set of configurations used by the read-write adaptercore service
-type AdapterFlags struct {
-	// Command line parameters
-	InstanceID       string
-	KafkaAdapterHost string
-	KafkaAdapterPort int
-	KafkaClusterHost string
-	KafkaClusterPort int
-	KVStoreType      string
-	KVStoreTimeout   int // in seconds
-	KVStoreHost      string
-	KVStorePort      int
-	Topic            string
-	CoreTopic        string
-	LogLevel         int
-	Banner           bool
-}
-
-func init() {
-	log.AddPackage(log.JSON, log.WarnLevel, nil)
-}
-
-// NewRWCoreFlags returns a new RWCore config
-func NewAdapterFlags() *AdapterFlags {
-	var adapterFlags = AdapterFlags{ // Default values
-		InstanceID:       default_InstanceID,
-		KafkaAdapterHost: default_KafkaAdapterHost,
-		KafkaAdapterPort: default_KafkaAdapterPort,
-		KafkaClusterHost: default_KafkaClusterHost,
-		KafkaClusterPort: default_KafkaClusterPort,
-		KVStoreType:      default_KVStoreType,
-		KVStoreTimeout:   default_KVStoreTimeout,
-		KVStoreHost:      default_KVStoreHost,
-		KVStorePort:      default_KVStorePort,
-		Topic:            default_Topic,
-		CoreTopic:        default_CoreTopic,
-		LogLevel:         default_LogLevel,
-		Banner:           default_Banner,
-	}
-	return &adapterFlags
-}
-
-// ParseCommandArguments parses the arguments when running read-write adaptercore service
-func (so *AdapterFlags) ParseCommandArguments() {
-
-	var help string
-
-	help = fmt.Sprintf("Kafka - Adapter messaging host")
-	flag.StringVar(&(so.KafkaAdapterHost), "kafka_adapter_host", default_KafkaAdapterHost, help)
-
-	help = fmt.Sprintf("Kafka - Adapter messaging port")
-	flag.IntVar(&(so.KafkaAdapterPort), "kafka_adapter_port", default_KafkaAdapterPort, help)
-
-	help = fmt.Sprintf("Kafka - Cluster messaging host")
-	flag.StringVar(&(so.KafkaClusterHost), "kafka_cluster_host", default_KafkaClusterHost, help)
-
-	help = fmt.Sprintf("Kafka - Cluster messaging port")
-	flag.IntVar(&(so.KafkaClusterPort), "kafka_cluster_port", default_KafkaClusterPort, help)
-
-	help = fmt.Sprintf("Simulated ONU topic")
-	flag.StringVar(&(so.Topic), "simulator_topic", default_Topic, help)
-
-	help = fmt.Sprintf("Core topic")
-	flag.StringVar(&(so.CoreTopic), "core_topic", default_CoreTopic, help)
-
-	help = fmt.Sprintf("KV store type")
-	flag.StringVar(&(so.KVStoreType), "kv_store_type", default_KVStoreType, help)
-
-	help = fmt.Sprintf("The default timeout when making a kv store request")
-	flag.IntVar(&(so.KVStoreTimeout), "kv_store_request_timeout", default_KVStoreTimeout, help)
-
-	help = fmt.Sprintf("KV store host")
-	flag.StringVar(&(so.KVStoreHost), "kv_store_host", default_KVStoreHost, help)
-
-	help = fmt.Sprintf("KV store port")
-	flag.IntVar(&(so.KVStorePort), "kv_store_port", default_KVStorePort, help)
-
-	help = fmt.Sprintf("Log level")
-	flag.IntVar(&(so.LogLevel), "log_level", default_LogLevel, help)
-
-	help = fmt.Sprintf("Show startup banner log lines")
-	flag.BoolVar(&so.Banner, "banner", default_Banner, help)
-
-	flag.Parse()
-
-	containerName := getContainerInfo()
-	if len(containerName) > 0 {
-		so.InstanceID = containerName
-	}
-
-}
-
-func getContainerInfo() string {
-	return os.Getenv("HOSTNAME")
-}
diff --git a/adapters/simulated_onu/main.go b/adapters/simulated_onu/main.go
deleted file mode 100644
index 7ea1430..0000000
--- a/adapters/simulated_onu/main.go
+++ /dev/null
@@ -1,337 +0,0 @@
-/*
- * Copyright 2018-present Open Networking Foundation
-
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
-
- * http://www.apache.org/licenses/LICENSE-2.0
-
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * 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/adapters"
-	com "github.com/opencord/voltha-go/adapters/common"
-	ac "github.com/opencord/voltha-go/adapters/simulated_onu/adaptercore"
-	"github.com/opencord/voltha-go/adapters/simulated_onu/config"
-	"github.com/opencord/voltha-go/common/log"
-	"github.com/opencord/voltha-go/db/kvstore"
-	"github.com/opencord/voltha-go/kafka"
-	ic "github.com/opencord/voltha-protos/go/inter_container"
-	"github.com/opencord/voltha-protos/go/voltha"
-	"os"
-	"os/signal"
-	"strconv"
-	"syscall"
-	"time"
-)
-
-type adapter struct {
-	instanceId       string
-	config           *config.AdapterFlags
-	iAdapter         adapters.IAdapter
-	kafkaClient      kafka.Client
-	kvClient         kvstore.Client
-	kip              *kafka.InterContainerProxy
-	coreProxy        *com.CoreProxy
-	halted           bool
-	exitChannel      chan int
-	receiverChannels []<-chan *ic.InterContainerMessage
-}
-
-func init() {
-	log.AddPackage(log.JSON, log.DebugLevel, nil)
-}
-
-func newAdapter(cf *config.AdapterFlags) *adapter {
-	var a adapter
-	a.instanceId = cf.InstanceID
-	a.config = cf
-	a.halted = false
-	a.exitChannel = make(chan int, 1)
-	a.receiverChannels = make([]<-chan *ic.InterContainerMessage, 0)
-	return &a
-}
-
-func (a *adapter) start(ctx context.Context) {
-	log.Info("Starting Core Adapter components")
-	var err error
-
-	// Setup KV Client
-	log.Debugw("create-kv-client", log.Fields{"kvstore": a.config.KVStoreType})
-	if err := a.setKVClient(); err != nil {
-		log.Fatal("error-setting-kv-client")
-	}
-
-	// Setup Kafka Client
-	if a.kafkaClient, err = newKafkaClient("sarama", a.config.KafkaAdapterHost, a.config.KafkaAdapterPort); err != nil {
-		log.Fatal("Unsupported-common-client")
-	}
-
-	// Start the common InterContainer Proxy - retry indefinitely
-	if a.kip, err = a.startInterContainerProxy(-1); err != nil {
-		log.Fatal("error-starting-inter-container-proxy")
-	}
-
-	// Create the core proxy to handle requests to the Core
-	a.coreProxy = com.NewCoreProxy(a.kip, a.config.Topic, a.config.CoreTopic)
-
-	// Create the simulated OLT adapter
-	if a.iAdapter, err = a.startSimulatedONU(ctx, a.kip, a.coreProxy); err != nil {
-		log.Fatal("error-starting-inter-container-proxy")
-	}
-
-	// Register the core request handler
-	if err = a.setupRequestHandler(a.instanceId, a.iAdapter, a.coreProxy); err != nil {
-		log.Fatal("error-setting-core-request-handler")
-	}
-
-	//	Register this adapter to the Core - retry indefinitely
-	if err = a.registerWithCore(-1); err != nil {
-		log.Fatal("error-registering-with-core")
-	}
-}
-
-func (rw *adapter) stop() {
-	// Stop leadership tracking
-	rw.halted = true
-
-	// send exit signal
-	rw.exitChannel <- 0
-
-	// Cleanup - applies only if we had a kvClient
-	if rw.kvClient != nil {
-		// Release all reservations
-		if err := rw.kvClient.ReleaseAllReservations(); err != nil {
-			log.Infow("fail-to-release-all-reservations", log.Fields{"error": err})
-		}
-		// Close the DB connection
-		rw.kvClient.Close()
-	}
-
-	// TODO:  More cleanup
-}
-
-func newKVClient(storeType string, address string, timeout int) (kvstore.Client, error) {
-
-	log.Infow("kv-store-type", log.Fields{"store": storeType})
-	switch storeType {
-	case "consul":
-		return kvstore.NewConsulClient(address, timeout)
-	case "etcd":
-		return kvstore.NewEtcdClient(address, timeout)
-	}
-	return nil, errors.New("unsupported-kv-store")
-}
-
-func newKafkaClient(clientType string, host string, port int) (kafka.Client, error) {
-
-	log.Infow("common-client-type", log.Fields{"client": clientType})
-	switch clientType {
-	case "sarama":
-		return kafka.NewSaramaClient(
-			kafka.Host(host),
-			kafka.Port(port),
-			kafka.ProducerReturnOnErrors(true),
-			kafka.ProducerReturnOnSuccess(true),
-			kafka.ProducerMaxRetries(6),
-			kafka.ProducerRetryBackoff(time.Millisecond*30)), nil
-	}
-	return nil, errors.New("unsupported-client-type")
-}
-
-func (a *adapter) setKVClient() error {
-	addr := a.config.KVStoreHost + ":" + strconv.Itoa(a.config.KVStorePort)
-	client, err := newKVClient(a.config.KVStoreType, addr, a.config.KVStoreTimeout)
-	if err != nil {
-		a.kvClient = nil
-		log.Error(err)
-		return err
-	}
-	a.kvClient = client
-	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 (a *adapter) startInterContainerProxy(retries int) (*kafka.InterContainerProxy, error) {
-	log.Infow("starting-intercontainer-messaging-proxy", log.Fields{"host": a.config.KafkaAdapterHost,
-		"port": a.config.KafkaAdapterPort, "topic": a.config.Topic})
-	var err error
-	var kip *kafka.InterContainerProxy
-	if kip, err = kafka.NewInterContainerProxy(
-		kafka.InterContainerHost(a.config.KafkaAdapterHost),
-		kafka.InterContainerPort(a.config.KafkaAdapterPort),
-		kafka.MsgClient(a.kafkaClient),
-		kafka.DefaultTopic(&kafka.Topic{Name: a.config.Topic})); err != nil {
-		log.Errorw("fail-to-create-common-proxy", log.Fields{"error": err})
-		return nil, err
-	}
-	count := 0
-	for {
-		if err = kip.Start(); err != nil {
-			log.Warnw("error-starting-messaging-proxy", log.Fields{"error": err})
-			if retries == count {
-				return nil, err
-			}
-			count = +1
-			//	Take a nap before retrying
-			time.Sleep(2 * time.Second)
-		} else {
-			break
-		}
-	}
-
-	log.Info("common-messaging-proxy-created")
-	return kip, nil
-}
-
-func (a *adapter) startSimulatedONU(ctx context.Context, kip *kafka.InterContainerProxy, cp *com.CoreProxy) (*ac.SimulatedONU, error) {
-	log.Info("starting-simulated-onu")
-	var err error
-	sOLT := ac.NewSimulatedONU(ctx, a.kip, cp)
-
-	if err = sOLT.Start(ctx); err != nil {
-		log.Fatalw("error-starting-messaging-proxy", log.Fields{"error": err})
-		return nil, err
-	}
-
-	log.Info("simulated-olt-started")
-	return sOLT, nil
-}
-
-func (a *adapter) setupRequestHandler(coreInstanceId string, iadapter adapters.IAdapter, coreProxy *com.CoreProxy) error {
-	log.Info("setting-request-handler")
-	requestProxy := com.NewRequestHandlerProxy(coreInstanceId, iadapter, coreProxy)
-	if err := a.kip.SubscribeWithRequestHandlerInterface(kafka.Topic{Name: a.config.Topic}, requestProxy); err != nil {
-		log.Errorw("adaptercore-request-handler-setup-failed", log.Fields{"error": err})
-		return err
-
-	}
-	log.Info("request-handler-setup-done")
-	return nil
-}
-func (a *adapter) registerWithCore(retries int) error {
-	log.Info("registering-with-core")
-	adapterDescription := &voltha.Adapter{Id: "simulated_onu", Vendor: "simulation Enterprise Inc"}
-	types := []*voltha.DeviceType{{Id: "simulated_onu", Adapter: "simulated_onu"}}
-	deviceTypes := &voltha.DeviceTypes{Items: types}
-	count := 0
-	for {
-		if err := a.coreProxy.RegisterAdapter(nil, adapterDescription, deviceTypes); err != nil {
-			log.Warnw("registering-with-core-failed", log.Fields{"error": err})
-			if retries == count {
-				return err
-			}
-			count += 1
-			//	Take a nap before retrying
-			time.Sleep(2 * time.Second)
-		} else {
-			break
-		}
-	}
-	log.Info("registered-with-core")
-	return nil
-}
-
-func waitForExit() int {
-	signalChannel := make(chan os.Signal, 1)
-	signal.Notify(signalChannel,
-		syscall.SIGHUP,
-		syscall.SIGINT,
-		syscall.SIGTERM,
-		syscall.SIGQUIT)
-
-	exitChannel := make(chan int)
-
-	go func() {
-		s := <-signalChannel
-		switch s {
-		case syscall.SIGHUP,
-			syscall.SIGINT,
-			syscall.SIGTERM,
-			syscall.SIGQUIT:
-			log.Infow("closing-signal-received", log.Fields{"signal": s})
-			exitChannel <- 0
-		default:
-			log.Infow("unexpected-signal-received", log.Fields{"signal": s})
-			exitChannel <- 1
-		}
-	}()
-
-	code := <-exitChannel
-	return code
-}
-
-func printBanner() {
-	fmt.Println("	 _                 _       _           _								")
-	fmt.Println(" ___(_)_ __ ___  _   _| | __ _| |_ ___  __| |    ___  _ __  _   _			")
-	fmt.Println("/ __| | '_ ` _ \\| | | | |/ _` | __/ _ \\/ _` |   / _ \\| '_ \\| | | |		")
-	fmt.Println("\\__ \\ | | | | | | |_| | | (_| | ||  __/ (_| |  | (_) | | | | |_| |		")
-	fmt.Println("|___/_|_| |_| |_|\\__,_|_|\\__,_|\\__\\___|\\__,_|___\\___/|_| |_|\\__,_|	")
-	fmt.Println("                                           |_____|							")
-	fmt.Println("																			")
-}
-
-func main() {
-	start := time.Now()
-
-	cf := config.NewAdapterFlags()
-	cf.ParseCommandArguments()
-
-	//// 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 {
-		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 {
-		log.With(log.Fields{"error": err}).Fatal("Cannot setup logging")
-	}
-
-	log.SetPackageLogLevel("github.com/opencord/voltha-go/adapters/common", log.DebugLevel)
-
-	defer log.CleanUp()
-
-	// Print banner if specified
-	if cf.Banner {
-		printBanner()
-	}
-
-	log.Infow("config", log.Fields{"config": *cf})
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	ad := newAdapter(cf)
-	go ad.start(ctx)
-
-	code := waitForExit()
-	log.Infow("received-a-closing-signal", log.Fields{"code": code})
-
-	// Cleanup before leaving
-	ad.stop()
-
-	elapsed := time.Since(start)
-	log.Infow("runtime", log.Fields{"instanceId": ad.config.InstanceID, "time": elapsed / time.Second})
-}
diff --git a/docker/Dockerfile.simulated_olt b/docker/Dockerfile.simulated_olt
deleted file mode 100644
index 9805ac6..0000000
--- a/docker/Dockerfile.simulated_olt
+++ /dev/null
@@ -1,94 +0,0 @@
-# Copyright 2016 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# -------------
-# Build stage
-
-FROM golang:1.12-alpine3.9 AS build-env
-
-# Install required packages
-RUN apk add --no-cache \
-        wget=1.20.3-r0 \
-        git=2.20.1-r0 \
-        make=4.2.1-r2 \
-        build-base=0.5-r1 \
-        protobuf=3.6.1-r1 \
-        protobuf-dev=3.6.1-r1
-
-# Prepare directory structure
-RUN mkdir -p /build \
-        "$GOPATH/src/" "$GOPATH/pkg" "$GOPATH/bin" \
-        "$GOPATH/src/github.com/opencord" \
-        "$GOPATH/src/github.com/opencord/voltha-go"
-
-WORKDIR $GOPATH/src/github.com/opencord/voltha-go
-
-# Copy common files.
-COPY common ./common
-COPY db ./db
-COPY kafka ./kafka
-COPY vendor ./vendor
-
-# Copy files
-COPY adapters/adapterif ./adapters/adapterif
-COPY adapters/simulated_olt ./adapters/simulated_olt
-COPY adapters/common ./adapters/common
-COPY adapters/*.go ./adapters/
-
-ARG org_label_schema_version=unknown
-ARG org_label_schema_vcs_url=unknown
-ARG org_label_schema_vcs_ref=unknown
-ARG org_label_schema_build_date=unknown
-ARG org_opencord_vcs_commit_date=unknown
-ARG org_opencord_vcs_dirty=unknown
-
-# Build
-WORKDIR $GOPATH/src/github.com/opencord/voltha-go/adapters/simulated_olt
-SHELL ["/bin/ash", "-o", "pipefail", "-c"]
-RUN go build -o /build/simulated_olt \
-	-ldflags \
-	"-X github.com/opencord/voltha-go/common/version.version=$org_label_schema_version \
-	 -X github.com/opencord/voltha-go/common/version.vcsRef=$org_label_schema_vcs_ref  \
-	 -X github.com/opencord/voltha-go/common/version.vcsDirty=$org_opencord_vcs_dirty \
-	 -X github.com/opencord/voltha-go/common/version.goVersion=$(go version 2>&1 | sed -E  's/.*go([0-9]+\.[0-9]+\.[0-9]+).*/\1/g') \
-	 -X github.com/opencord/voltha-go/common/version.os=$(go env GOHOSTOS) \
-	 -X github.com/opencord/voltha-go/common/version.arch=$(go env GOHOSTARCH) \
-	 -X github.com/opencord/voltha-go/common/version.buildTime=$org_label_schema_build_date"
-
-# -------------
-# Image creation stage
-
-FROM alpine:3.9.4 
-# Set the working directory
-WORKDIR /app
-
-# Copy required files
-COPY --from=build-env /build/simulated_olt /app/
-
-# Label image
-ARG org_label_schema_version=unknown
-ARG org_label_schema_vcs_url=unknown
-ARG org_label_schema_vcs_ref=unknown
-ARG org_label_schema_build_date=unknown
-ARG org_opencord_vcs_commit_date=unknown
-ARG org_opencord_vcs_dirty=unknown
-
-LABEL org.label-schema.schema-version=1.0 \
-      org.label-schema.name=voltha-adapter-simulated-olt \
-      org.label-schema.version=$org_label_schema_version \
-      org.label-schema.vcs-url=$org_label_schema_vcs_url \
-      org.label-schema.vcs-ref=$org_label_schema_vcs_ref \
-      org.label-schema.build-date=$org_label_schema_build_date \
-      org.opencord.vcs-commit-date=$org_opencord_vcs_commit_date \
-      org.opencord.vcs-dirty=$org_opencord_vcs_dirty
diff --git a/docker/Dockerfile.simulated_onu b/docker/Dockerfile.simulated_onu
deleted file mode 100644
index 4f4b95d..0000000
--- a/docker/Dockerfile.simulated_onu
+++ /dev/null
@@ -1,95 +0,0 @@
-# Copyright 2016 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# -------------
-# Build stage
-
-FROM golang:1.12-alpine3.9 AS build-env
-
-# Install required packages
-RUN apk add --no-cache \
-        wget=1.20.3-r0 \
-        git=2.20.1-r0 \
-        make=4.2.1-r2 \
-        build-base=0.5-r1 \
-        protobuf=3.6.1-r1 \
-        protobuf-dev=3.6.1-r1
-
-# Prepare directory structure
-RUN mkdir -p /build \
-        "$GOPATH/src/" "$GOPATH/pkg" "$GOPATH/bin" \
-        "$GOPATH/src/github.com/opencord" \
-        "$GOPATH/src/github.com/opencord/voltha-go"
-
-WORKDIR $GOPATH/src/github.com/opencord/voltha-go
-
-# Copy common files.
-COPY common ./common
-COPY db ./db
-COPY kafka ./kafka
-COPY vendor ./vendor
-
-# Copy files
-COPY adapters/simulated_onu ./adapters/simulated_onu
-COPY adapters/common ./adapters/common
-COPY adapters/*.go ./adapters/
-COPY adapters/adapterif ./adapters/adapterif
-
-ARG org_label_schema_version=unknown
-ARG org_label_schema_vcs_url=unknown
-ARG org_label_schema_vcs_ref=unknown
-ARG org_label_schema_build_date=unknown
-ARG org_opencord_vcs_commit_date=unknown
-ARG org_opencord_vcs_dirty=unknown
-
-# Build
-WORKDIR $GOPATH/src/github.com/opencord/voltha-go/adapters/simulated_onu
-SHELL ["/bin/ash", "-o", "pipefail", "-c"]
-RUN go build -o /build/simulated_onu \
-	-ldflags \
-	"-X github.com/opencord/voltha-go/common/version.version=$org_label_schema_version \
-	 -X github.com/opencord/voltha-go/common/version.vcsRef=$org_label_schema_vcs_ref  \
-	 -X github.com/opencord/voltha-go/common/version.vcsDirty=$org_opencord_vcs_dirty \
-	 -X github.com/opencord/voltha-go/common/version.goVersion=$(go version 2>&1 | sed -E  's/.*go([0-9]+\.[0-9]+\.[0-9]+).*/\1/g') \
-	 -X github.com/opencord/voltha-go/common/version.os=$(go env GOHOSTOS) \
-	 -X github.com/opencord/voltha-go/common/version.arch=$(go env GOHOSTARCH) \
-	 -X github.com/opencord/voltha-go/common/version.buildTime=$org_label_schema_build_date"
-
-# -------------
-# Image creation stage
-
-FROM alpine:3.9.4
-
-# Set the working directory
-WORKDIR /app
-
-# Copy required files
-COPY --from=build-env /build/simulated_onu /app/
-
-# Label image
-ARG org_label_schema_version=unknown
-ARG org_label_schema_vcs_url=unknown
-ARG org_label_schema_vcs_ref=unknown
-ARG org_label_schema_build_date=unknown
-ARG org_opencord_vcs_commit_date=unknown
-ARG org_opencord_vcs_dirty=unknown
-
-LABEL org.label-schema.schema-version=1.0 \
-      org.label-schema.name=voltha-adapter-simulated-onu \
-      org.label-schema.version=$org_label_schema_version \
-      org.label-schema.vcs-url=$org_label_schema_vcs_url \
-      org.label-schema.vcs-ref=$org_label_schema_vcs_ref \
-      org.label-schema.build-date=$org_label_schema_build_date \
-      org.opencord.vcs-commit-date=$org_opencord_vcs_commit_date \
-      org.opencord.vcs-dirty=$org_opencord_vcs_dirty