[VOL-4292] OpenOLT Adapter changes for gRPC migration
Change-Id: I5af2125f2c2f53ffc78c474a94314bba408f8bae
diff --git a/internal/pkg/core/openolt.go b/internal/pkg/core/openolt.go
index db7da95..f84910d 100644
--- a/internal/pkg/core/openolt.go
+++ b/internal/pkg/core/openolt.go
@@ -19,30 +19,29 @@
import (
"context"
+ "errors"
"sync"
"time"
- "github.com/opencord/voltha-lib-go/v6/pkg/adapters/adapterif"
- conf "github.com/opencord/voltha-lib-go/v6/pkg/config"
- "github.com/opencord/voltha-lib-go/v6/pkg/events/eventif"
- "github.com/opencord/voltha-lib-go/v6/pkg/kafka"
- "github.com/opencord/voltha-lib-go/v6/pkg/log"
+ "github.com/golang/protobuf/ptypes/empty"
+ conf "github.com/opencord/voltha-lib-go/v7/pkg/config"
+ "github.com/opencord/voltha-lib-go/v7/pkg/events/eventif"
+ vgrpc "github.com/opencord/voltha-lib-go/v7/pkg/grpc"
+ "github.com/opencord/voltha-lib-go/v7/pkg/log"
"github.com/opencord/voltha-openolt-adapter/internal/pkg/config"
"github.com/opencord/voltha-openolt-adapter/internal/pkg/olterrors"
- "github.com/opencord/voltha-protos/v4/go/extension"
- ic "github.com/opencord/voltha-protos/v4/go/inter_container"
- "github.com/opencord/voltha-protos/v4/go/openflow_13"
- "github.com/opencord/voltha-protos/v4/go/voltha"
+ "github.com/opencord/voltha-protos/v5/go/common"
+ "github.com/opencord/voltha-protos/v5/go/extension"
+ ic "github.com/opencord/voltha-protos/v5/go/inter_container"
+ "github.com/opencord/voltha-protos/v5/go/voltha"
)
//OpenOLT structure holds the OLT information
type OpenOLT struct {
configManager *conf.ConfigManager
deviceHandlers map[string]*DeviceHandler
- coreProxy adapterif.CoreProxy
- adapterProxy adapterif.AdapterProxy
+ coreClient *vgrpc.Client
eventProxy eventif.EventProxy
- kafkaICProxy kafka.InterContainerProxy
config *config.AdapterFlags
numOnus int
KVStoreAddress string
@@ -54,20 +53,19 @@
lockDeviceHandlersMap sync.RWMutex
enableONUStats bool
enableGemStats bool
+ rpcTimeout time.Duration
}
//NewOpenOLT returns a new instance of OpenOLT
-func NewOpenOLT(ctx context.Context, kafkaICProxy kafka.InterContainerProxy,
- coreProxy adapterif.CoreProxy, adapterProxy adapterif.AdapterProxy,
+func NewOpenOLT(ctx context.Context,
+ coreClient *vgrpc.Client,
eventProxy eventif.EventProxy, cfg *config.AdapterFlags, cm *conf.ConfigManager) *OpenOLT {
var openOLT OpenOLT
openOLT.exitChannel = make(chan int, 1)
openOLT.deviceHandlers = make(map[string]*DeviceHandler)
- openOLT.kafkaICProxy = kafkaICProxy
openOLT.config = cfg
openOLT.numOnus = cfg.OnuNumber
- openOLT.coreProxy = coreProxy
- openOLT.adapterProxy = adapterProxy
+ openOLT.coreClient = coreClient
openOLT.eventProxy = eventProxy
openOLT.KVStoreAddress = cfg.KVStoreAddress
openOLT.KVStoreType = cfg.KVStoreType
@@ -78,6 +76,7 @@
openOLT.configManager = cm
openOLT.enableONUStats = cfg.EnableONUStats
openOLT.enableGemStats = cfg.EnableGEMStats
+ openOLT.rpcTimeout = cfg.RPCTimeout
return &openOLT
}
@@ -119,260 +118,169 @@
return nil
}
-// Adopt_device creates a new device handler if not present already and then adopts the device
-func (oo *OpenOLT) Adopt_device(ctx context.Context, device *voltha.Device) error {
+// GetHealthStatus is used as a service readiness validation as a grpc connection
+func (oo *OpenOLT) GetHealthStatus(ctx context.Context, empty *empty.Empty) (*voltha.HealthStatus, error) {
+ return &voltha.HealthStatus{State: voltha.HealthStatus_HEALTHY}, nil
+}
+
+// AdoptDevice creates a new device handler if not present already and then adopts the device
+func (oo *OpenOLT) AdoptDevice(ctx context.Context, device *voltha.Device) (*empty.Empty, error) {
if device == nil {
- return olterrors.NewErrInvalidValue(log.Fields{"device": nil}, nil).Log()
+ return nil, olterrors.NewErrInvalidValue(log.Fields{"device": nil}, nil).Log()
}
logger.Infow(ctx, "adopt-device", log.Fields{"device-id": device.Id})
var handler *DeviceHandler
if handler = oo.getDeviceHandler(device.Id); handler == nil {
- handler := NewDeviceHandler(oo.coreProxy, oo.adapterProxy, oo.eventProxy, device, oo, oo.configManager)
+ handler := NewDeviceHandler(oo.coreClient, oo.eventProxy, device, oo, oo.configManager, oo.config)
oo.addDeviceHandlerToMap(handler)
- go handler.AdoptDevice(ctx, device)
- // Launch the creation of the device topic
- // go oo.createDeviceTopic(device)
+ go handler.AdoptDevice(log.WithSpanFromContext(context.Background(), ctx), device)
}
- return nil
+ return &empty.Empty{}, nil
}
-//Get_ofp_device_info returns OFP information for the given device
-func (oo *OpenOLT) Get_ofp_device_info(ctx context.Context, device *voltha.Device) (*ic.SwitchCapability, error) {
- logger.Infow(ctx, "Get_ofp_device_info", log.Fields{"device-id": device.Id})
+//GetOfpDeviceInfo returns OFP information for the given device
+func (oo *OpenOLT) GetOfpDeviceInfo(ctx context.Context, device *voltha.Device) (*ic.SwitchCapability, error) {
+ logger.Infow(ctx, "get_ofp_device_info", log.Fields{"device-id": device.Id})
if handler := oo.getDeviceHandler(device.Id); handler != nil {
return handler.GetOfpDeviceInfo(device)
}
return nil, olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": device.Id}, nil)
}
-//Process_inter_adapter_message sends messages to a target device (between adapters)
-func (oo *OpenOLT) Process_inter_adapter_message(ctx context.Context, msg *ic.InterAdapterMessage) error {
- logger.Debugw(ctx, "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 := oo.getDeviceHandler(targetDevice); handler != nil {
- return handler.ProcessInterAdapterMessage(ctx, msg)
- }
- return olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": targetDevice}, nil)
-}
-
-//Process_tech_profile_instance_request processes tech profile request message from onu adapter
-func (oo *OpenOLT) Process_tech_profile_instance_request(ctx context.Context, msg *ic.InterAdapterTechProfileInstanceRequestMessage) *ic.InterAdapterTechProfileDownloadMessage {
- logger.Debugw(ctx, "Process_tech_profile_instance_request", log.Fields{"tpPath": msg.TpInstancePath})
- targetDeviceID := msg.ParentDeviceId // Request?
- if targetDeviceID == "" {
- logger.Error(ctx, "device-id-nil")
- return nil
- }
- if handler := oo.getDeviceHandler(targetDeviceID); handler != nil {
- return handler.GetInterAdapterTechProfileDownloadMessage(ctx, msg.TpInstancePath, msg.ParentPonPort, msg.OnuId, msg.UniId)
- }
- return nil
-}
-
-//Adapter_descriptor not implemented
-func (oo *OpenOLT) Adapter_descriptor(ctx context.Context) error {
- return olterrors.ErrNotImplemented
-}
-
-//Device_types unimplemented
-func (oo *OpenOLT) Device_types(ctx context.Context) (*voltha.DeviceTypes, error) {
- return nil, olterrors.ErrNotImplemented
-}
-
-//Health returns unimplemented
-func (oo *OpenOLT) Health(ctx context.Context) (*voltha.HealthStatus, error) {
- return nil, olterrors.ErrNotImplemented
-}
-
-//Reconcile_device unimplemented
-func (oo *OpenOLT) Reconcile_device(ctx context.Context, device *voltha.Device) error {
+//ReconcileDevice unimplemented
+func (oo *OpenOLT) ReconcileDevice(ctx context.Context, device *voltha.Device) (*empty.Empty, error) {
if device == nil {
- return olterrors.NewErrInvalidValue(log.Fields{"device": nil}, nil)
+ return nil, olterrors.NewErrInvalidValue(log.Fields{"device": nil}, nil)
}
logger.Infow(ctx, "reconcile-device", log.Fields{"device-id": device.Id})
var handler *DeviceHandler
if handler = oo.getDeviceHandler(device.Id); handler == nil {
- handler := NewDeviceHandler(oo.coreProxy, oo.adapterProxy, oo.eventProxy, device, oo, oo.configManager)
+ handler := NewDeviceHandler(oo.coreClient, oo.eventProxy, device, oo, oo.configManager, oo.config)
handler.adapterPreviouslyConnected = true
oo.addDeviceHandlerToMap(handler)
handler.transitionMap = NewTransitionMap(handler)
+
//Setting state to RECONCILING
- err := handler.coreProxy.DeviceStateUpdate(ctx, device.Id, device.ConnectStatus, voltha.OperStatus_RECONCILING)
+ cgClient, err := oo.coreClient.GetCoreServiceClient()
if err != nil {
- return err
+ return nil, err
}
- handler.transitionMap.Handle(ctx, DeviceInit)
+ subCtx, cancel := context.WithTimeout(log.WithSpanFromContext(context.Background(), ctx), oo.rpcTimeout)
+ defer cancel()
+ if _, err := cgClient.DeviceStateUpdate(subCtx, &ic.DeviceStateFilter{
+ DeviceId: device.Id,
+ OperStatus: voltha.OperStatus_RECONCILING,
+ ConnStatus: device.ConnectStatus,
+ }); err != nil {
+ return nil, olterrors.NewErrAdapter("device-update-failed", log.Fields{"device-id": device.Id}, err)
+ }
+
+ handler.transitionMap.Handle(log.WithSpanFromContext(context.Background(), ctx), DeviceInit)
}
- return nil
+ return &empty.Empty{}, nil
}
-//Abandon_device unimplemented
-func (oo *OpenOLT) Abandon_device(ctx context.Context, device *voltha.Device) error {
- return olterrors.ErrNotImplemented
-}
-
-//Disable_device disables the given device
-func (oo *OpenOLT) Disable_device(ctx context.Context, device *voltha.Device) error {
+//DisableDevice disables the given device
+func (oo *OpenOLT) DisableDevice(ctx context.Context, device *voltha.Device) (*empty.Empty, error) {
logger.Infow(ctx, "disable-device", log.Fields{"device-id": device.Id})
if handler := oo.getDeviceHandler(device.Id); handler != nil {
- return handler.DisableDevice(ctx, device)
+ if err := handler.DisableDevice(log.WithSpanFromContext(context.Background(), ctx), device); err != nil {
+ return nil, err
+ }
+ return &empty.Empty{}, nil
}
- return olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": device.Id}, nil)
+ return nil, olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": device.Id}, nil)
}
-//Reenable_device enables the olt device after disable
-func (oo *OpenOLT) Reenable_device(ctx context.Context, device *voltha.Device) error {
+//ReEnableDevice enables the olt device after disable
+func (oo *OpenOLT) ReEnableDevice(ctx context.Context, device *voltha.Device) (*empty.Empty, error) {
logger.Infow(ctx, "reenable-device", log.Fields{"device-id": device.Id})
if handler := oo.getDeviceHandler(device.Id); handler != nil {
- return handler.ReenableDevice(ctx, device)
+ if err := handler.ReenableDevice(log.WithSpanFromContext(context.Background(), ctx), device); err != nil {
+ return nil, err
+ }
+ return &empty.Empty{}, nil
}
- return olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": device.Id}, nil)
+ return nil, olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": device.Id}, nil)
}
-//Reboot_device reboots the given device
-func (oo *OpenOLT) Reboot_device(ctx context.Context, device *voltha.Device) error {
+//RebootDevice reboots the given device
+func (oo *OpenOLT) RebootDevice(ctx context.Context, device *voltha.Device) (*empty.Empty, error) {
logger.Infow(ctx, "reboot-device", log.Fields{"device-id": device.Id})
if handler := oo.getDeviceHandler(device.Id); handler != nil {
- return handler.RebootDevice(ctx, device)
+ if err := handler.RebootDevice(log.WithSpanFromContext(context.Background(), ctx), device); err != nil {
+ return nil, err
+ }
+ return &empty.Empty{}, nil
}
- return olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": device.Id}, nil)
+ return nil, olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": device.Id}, nil)
+
}
-//Self_test_device unimplented
-func (oo *OpenOLT) Self_test_device(ctx context.Context, device *voltha.Device) error {
- return olterrors.ErrNotImplemented
-}
-
-//Delete_device unimplemented
-func (oo *OpenOLT) Delete_device(ctx context.Context, device *voltha.Device) error {
+//DeleteDevice deletes a device
+func (oo *OpenOLT) DeleteDevice(ctx context.Context, device *voltha.Device) (*empty.Empty, error) {
logger.Infow(ctx, "delete-device", log.Fields{"device-id": device.Id})
if handler := oo.getDeviceHandler(device.Id); handler != nil {
- if err := handler.DeleteDevice(ctx, device); err != nil {
+ if err := handler.DeleteDevice(log.WithSpanFromContext(context.Background(), ctx), device); err != nil {
logger.Errorw(ctx, "failed-to-handle-delete-device", log.Fields{"device-id": device.Id})
}
oo.deleteDeviceHandlerToMap(handler)
- return nil
+ return &empty.Empty{}, nil
}
- return olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": device.Id}, nil)
+ return nil, olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": device.Id}, nil)
}
-//Get_device_details unimplemented
-func (oo *OpenOLT) Get_device_details(ctx context.Context, device *voltha.Device) error {
- return olterrors.ErrNotImplemented
-}
-
-//Update_flows_bulk returns
-func (oo *OpenOLT) Update_flows_bulk(ctx context.Context, device *voltha.Device, flows *voltha.Flows, groups *voltha.FlowGroups, flowMetadata *voltha.FlowMetadata) error {
- return olterrors.ErrNotImplemented
-}
-
-//Update_flows_incrementally updates (add/remove) the flows on a given device
-func (oo *OpenOLT) Update_flows_incrementally(ctx context.Context, device *voltha.Device, flows *openflow_13.FlowChanges, groups *openflow_13.FlowGroupChanges, flowMetadata *voltha.FlowMetadata) error {
- logger.Infow(ctx, "Update_flows_incrementally", log.Fields{"device-id": device.Id, "flows": flows, "flowMetadata": flowMetadata})
- if handler := oo.getDeviceHandler(device.Id); handler != nil {
- return handler.UpdateFlowsIncrementally(ctx, device, flows, groups, flowMetadata)
+//UpdateFlowsIncrementally updates (add/remove) the flows on a given device
+func (oo *OpenOLT) UpdateFlowsIncrementally(ctx context.Context, incrFlows *ic.IncrementalFlows) (*empty.Empty, error) {
+ logger.Infow(ctx, "update_flows_incrementally", log.Fields{"device-id": incrFlows.Device.Id, "flows": incrFlows.Flows, "flowMetadata": incrFlows.FlowMetadata})
+ if handler := oo.getDeviceHandler(incrFlows.Device.Id); handler != nil {
+ if err := handler.UpdateFlowsIncrementally(log.WithSpanFromContext(context.Background(), ctx), incrFlows.Device, incrFlows.Flows, incrFlows.Groups, incrFlows.FlowMetadata); err != nil {
+ return nil, err
+ }
+ return &empty.Empty{}, nil
}
- return olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": device.Id}, nil)
+ return nil, olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": incrFlows.Device.Id}, nil)
}
-//Update_pm_config returns PmConfigs nil or error
-func (oo *OpenOLT) Update_pm_config(ctx context.Context, device *voltha.Device, pmConfigs *voltha.PmConfigs) error {
- logger.Debugw(ctx, "Update_pm_config", log.Fields{"device-id": device.Id, "pm-configs": pmConfigs})
- if handler := oo.getDeviceHandler(device.Id); handler != nil {
- handler.UpdatePmConfig(ctx, pmConfigs)
- return nil
+//UpdatePmConfig returns PmConfigs nil or error
+func (oo *OpenOLT) UpdatePmConfig(ctx context.Context, configs *ic.PmConfigsInfo) (*empty.Empty, error) {
+ logger.Debugw(ctx, "update_pm_config", log.Fields{"device-id": configs.DeviceId, "pm-configs": configs.PmConfigs})
+ if handler := oo.getDeviceHandler(configs.DeviceId); handler != nil {
+ handler.UpdatePmConfig(log.WithSpanFromContext(context.Background(), ctx), configs.PmConfigs)
+ return &empty.Empty{}, nil
}
- return olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": device.Id}, nil)
+ return nil, olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": configs.DeviceId}, nil)
}
-//Receive_packet_out sends packet out to the device
-func (oo *OpenOLT) Receive_packet_out(ctx context.Context, deviceID string, egressPortNo int, packet *openflow_13.OfpPacketOut) error {
- logger.Debugw(ctx, "Receive_packet_out", log.Fields{"device-id": deviceID, "egress_port_no": egressPortNo, "pkt": packet})
- if handler := oo.getDeviceHandler(deviceID); handler != nil {
- return handler.PacketOut(ctx, egressPortNo, packet)
+//SendPacketOut sends packet out to the device
+func (oo *OpenOLT) SendPacketOut(ctx context.Context, packet *ic.PacketOut) (*empty.Empty, error) {
+ logger.Debugw(ctx, "send_packet_out", log.Fields{"device-id": packet.DeviceId, "egress_port_no": packet.EgressPortNo, "pkt": packet.Packet})
+ if handler := oo.getDeviceHandler(packet.DeviceId); handler != nil {
+ if err := handler.PacketOut(log.WithSpanFromContext(context.Background(), ctx), packet.EgressPortNo, packet.Packet); err != nil {
+ return nil, err
+ }
+ return &empty.Empty{}, nil
}
- return olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": deviceID}, nil)
+ return nil, olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": packet.DeviceId}, nil)
+
}
-//Suppress_event unimplemented
-func (oo *OpenOLT) Suppress_event(ctx context.Context, filter *voltha.EventFilter) error {
- return olterrors.ErrNotImplemented
+// EnablePort to Enable PON/NNI interface
+func (oo *OpenOLT) EnablePort(ctx context.Context, port *voltha.Port) (*empty.Empty, error) {
+ logger.Infow(ctx, "enable_port", log.Fields{"device-id": port.DeviceId, "port": port})
+ if err := oo.enableDisablePort(log.WithSpanFromContext(context.Background(), ctx), port.DeviceId, port, true); err != nil {
+ return nil, err
+ }
+ return &empty.Empty{}, nil
}
-//Unsuppress_event unimplemented
-func (oo *OpenOLT) Unsuppress_event(ctx context.Context, filter *voltha.EventFilter) error {
- return olterrors.ErrNotImplemented
-}
-
-//Download_image unimplemented
-func (oo *OpenOLT) Download_image(ctx context.Context, device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
- return nil, olterrors.ErrNotImplemented
-}
-
-//Get_image_download_status unimplemented
-func (oo *OpenOLT) Get_image_download_status(ctx context.Context, device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
- return nil, olterrors.ErrNotImplemented
-}
-
-//Cancel_image_download unimplemented
-func (oo *OpenOLT) Cancel_image_download(ctx context.Context, device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
- return nil, olterrors.ErrNotImplemented
-}
-
-//Activate_image_update unimplemented
-func (oo *OpenOLT) Activate_image_update(ctx context.Context, device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
- return nil, olterrors.ErrNotImplemented
-}
-
-//Revert_image_update unimplemented
-func (oo *OpenOLT) Revert_image_update(ctx context.Context, device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
- return nil, olterrors.ErrNotImplemented
-}
-
-//Download_onu_image unimplemented
-func (oo *OpenOLT) Download_onu_image(ctx context.Context, request *voltha.DeviceImageDownloadRequest) (*voltha.DeviceImageResponse, error) {
- return nil, olterrors.ErrNotImplemented
-}
-
-//Get_onu_image_status unimplemented
-func (oo *OpenOLT) Get_onu_image_status(ctx context.Context, in *voltha.DeviceImageRequest) (*voltha.DeviceImageResponse, error) {
- return nil, olterrors.ErrNotImplemented
-}
-
-//Abort_onu_image_upgrade unimplemented
-func (oo *OpenOLT) Abort_onu_image_upgrade(ctx context.Context, in *voltha.DeviceImageRequest) (*voltha.DeviceImageResponse, error) {
- return nil, olterrors.ErrNotImplemented
-}
-
-//Get_onu_images unimplemented
-func (oo *OpenOLT) Get_onu_images(ctx context.Context, deviceID string) (*voltha.OnuImages, error) {
- return nil, olterrors.ErrNotImplemented
-}
-
-//Activate_onu_image unimplemented
-func (oo *OpenOLT) Activate_onu_image(ctx context.Context, in *voltha.DeviceImageRequest) (*voltha.DeviceImageResponse, error) {
- return nil, olterrors.ErrNotImplemented
-}
-
-//Commit_onu_image unimplemented
-func (oo *OpenOLT) Commit_onu_image(ctx context.Context, in *voltha.DeviceImageRequest) (*voltha.DeviceImageResponse, error) {
- return nil, olterrors.ErrNotImplemented
-}
-
-// Enable_port to Enable PON/NNI interface
-func (oo *OpenOLT) Enable_port(ctx context.Context, deviceID string, port *voltha.Port) error {
- logger.Infow(ctx, "Enable_port", log.Fields{"device-id": deviceID, "port": port})
- return oo.enableDisablePort(ctx, deviceID, port, true)
-}
-
-// Disable_port to Disable pon/nni interface
-func (oo *OpenOLT) Disable_port(ctx context.Context, deviceID string, port *voltha.Port) error {
- logger.Infow(ctx, "Disable_port", log.Fields{"device-id": deviceID, "port": port})
- return oo.enableDisablePort(ctx, deviceID, port, false)
+// DisablePort to Disable pon/nni interface
+func (oo *OpenOLT) DisablePort(ctx context.Context, port *voltha.Port) (*empty.Empty, error) {
+ logger.Infow(ctx, "disable_port", log.Fields{"device-id": port.DeviceId, "port": port})
+ if err := oo.enableDisablePort(log.WithSpanFromContext(context.Background(), ctx), port.DeviceId, port, false); err != nil {
+ return nil, err
+ }
+ return &empty.Empty{}, nil
}
// enableDisablePort to Disable pon or Enable PON interface
@@ -399,38 +307,36 @@
return nil
}
-//Child_device_lost deletes the ONU and its references from PONResources
-func (oo *OpenOLT) Child_device_lost(ctx context.Context, childDevice *voltha.Device) error {
+//ChildDeviceLost deletes the ONU and its references from PONResources
+func (oo *OpenOLT) ChildDeviceLost(ctx context.Context, childDevice *voltha.Device) (*empty.Empty, error) {
logger.Infow(ctx, "Child-device-lost", log.Fields{"parent-device-id": childDevice.ParentId, "child-device-id": childDevice.Id})
if handler := oo.getDeviceHandler(childDevice.ParentId); handler != nil {
- return handler.ChildDeviceLost(ctx, childDevice.ParentPortNo, childDevice.ProxyAddress.OnuId, childDevice.SerialNumber)
+ if err := handler.ChildDeviceLost(log.WithSpanFromContext(context.Background(), ctx), childDevice.ParentPortNo, childDevice.ProxyAddress.OnuId, childDevice.SerialNumber); err != nil {
+ return nil, err
+ }
+ return &empty.Empty{}, nil
}
- return olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": childDevice.ParentId}, nil).Log()
+ return nil, olterrors.NewErrNotFound("device-handler", log.Fields{"parent-device-id": childDevice.ParentId}, nil).Log()
}
-//Start_omci_test not implemented
-func (oo *OpenOLT) Start_omci_test(ctx context.Context, device *voltha.Device, request *voltha.OmciTestRequest) (*voltha.TestResponse, error) {
- return nil, olterrors.ErrNotImplemented
-}
-
-//Get_ext_value retrieves a value on a particular ONU
-func (oo *OpenOLT) Get_ext_value(ctx context.Context, deviceID string, device *voltha.Device, valueparam voltha.ValueType_Type) (*voltha.ReturnValues, error) {
+// GetExtValue retrieves a value on a particular ONU
+func (oo *OpenOLT) GetExtValue(ctx context.Context, extInfo *ic.GetExtValueMessage) (*voltha.ReturnValues, error) {
var err error
resp := new(voltha.ReturnValues)
- logger.Infow(ctx, "Get_ext_value", log.Fields{"device-id": deviceID, "onu-id": device.Id})
- if handler := oo.getDeviceHandler(deviceID); handler != nil {
- if resp, err = handler.getExtValue(ctx, device, valueparam); err != nil {
- logger.Errorw(ctx, "error-occurred-during-get-ext-value", log.Fields{"device-id": deviceID, "onu-id": device.Id,
- "err": err})
+ logger.Infow(ctx, "get_ext_value", log.Fields{"parent-device-id": extInfo.ParentDevice.Id, "onu-id": extInfo.ChildDevice.Id})
+ if handler := oo.getDeviceHandler(extInfo.ParentDevice.Id); handler != nil {
+ if resp, err = handler.getExtValue(ctx, extInfo.ChildDevice, extInfo.ValueType); err != nil {
+ logger.Errorw(ctx, "error-occurred-during-get-ext-value",
+ log.Fields{"parent-device-id": extInfo.ParentDevice.Id, "onu-id": extInfo.ChildDevice.Id, "error": err})
return nil, err
}
}
return resp, nil
}
-//Single_get_value_request handles get uni status on ONU and ondemand metric on OLT
-func (oo *OpenOLT) Single_get_value_request(ctx context.Context, request extension.SingleGetValueRequest) (*extension.SingleGetValueResponse, error) {
- logger.Infow(ctx, "Single_get_value_request", log.Fields{"request": request})
+//GetSingleValue handles get uni status on ONU and ondemand metric on OLT
+func (oo *OpenOLT) GetSingleValue(ctx context.Context, request *extension.SingleGetValueRequest) (*extension.SingleGetValueResponse, error) {
+ logger.Infow(ctx, "single_get_value_request", log.Fields{"request": request})
errResp := func(status extension.GetValueResponse_Status,
reason extension.GetValueResponse_ErrorReason) *extension.SingleGetValueResponse {
@@ -457,3 +363,136 @@
logger.Infow(ctx, "Single_get_value_request failed ", log.Fields{"request": request})
return errResp(extension.GetValueResponse_ERROR, extension.GetValueResponse_INVALID_DEVICE_ID), nil
}
+
+/*
+ * OLT Inter-adapter service
+ */
+
+// ProxyOmciRequest proxies an OMCI request from the child adapter
+func (oo *OpenOLT) ProxyOmciRequest(ctx context.Context, request *ic.OmciMessage) (*empty.Empty, error) {
+ logger.Debugw(ctx, "proxy-omci-request", log.Fields{"request": request})
+
+ if handler := oo.getDeviceHandler(request.ParentDeviceId); handler != nil {
+ if err := handler.ProxyOmciMessage(ctx, request); err != nil {
+ return nil, errors.New(err.Error())
+ }
+ return &empty.Empty{}, nil
+ }
+ return nil, olterrors.NewErrNotFound("no-device-handler", log.Fields{"parent-device-id": request.ParentDeviceId, "child-device-id": request.ChildDeviceId}, nil).Log()
+}
+
+// GetTechProfileInstance returns an instance of a tech profile
+func (oo *OpenOLT) GetTechProfileInstance(ctx context.Context, request *ic.TechProfileInstanceRequestMessage) (*ic.TechProfileDownloadMessage, error) {
+ logger.Debugw(ctx, "getting-tech-profile-request", log.Fields{"request": request})
+
+ targetDeviceID := request.ParentDeviceId
+ if targetDeviceID == "" {
+ return nil, olterrors.NewErrNotFound("parent-id-empty", log.Fields{"parent-device-id": request.ParentDeviceId, "child-device-id": request.DeviceId}, nil).Log()
+ }
+ if handler := oo.getDeviceHandler(targetDeviceID); handler != nil {
+ return handler.GetTechProfileDownloadMessage(ctx, request)
+ }
+ return nil, olterrors.NewErrNotFound("no-device-handler", log.Fields{"parent-device-id": request.ParentDeviceId, "child-device-id": request.DeviceId}, nil).Log()
+
+}
+
+/*
+ *
+ * Unimplemented APIs
+ *
+ */
+
+//SimulateAlarm is unimplemented
+func (oo *OpenOLT) SimulateAlarm(context.Context, *ic.SimulateAlarmMessage) (*voltha.OperationResp, error) {
+ return nil, olterrors.ErrNotImplemented
+}
+
+//SetExtValue is unimplemented
+func (oo *OpenOLT) SetExtValue(context.Context, *ic.SetExtValueMessage) (*empty.Empty, error) {
+ return nil, olterrors.ErrNotImplemented
+}
+
+//SetSingleValue is unimplemented
+func (oo *OpenOLT) SetSingleValue(context.Context, *extension.SingleSetValueRequest) (*extension.SingleSetValueResponse, error) {
+ return nil, olterrors.ErrNotImplemented
+}
+
+//StartOmciTest not implemented
+func (oo *OpenOLT) StartOmciTest(ctx context.Context, test *ic.OMCITest) (*voltha.TestResponse, error) {
+ return nil, olterrors.ErrNotImplemented
+}
+
+//SuppressEvent unimplemented
+func (oo *OpenOLT) SuppressEvent(ctx context.Context, filter *voltha.EventFilter) (*empty.Empty, error) {
+ return nil, olterrors.ErrNotImplemented
+}
+
+//UnSuppressEvent unimplemented
+func (oo *OpenOLT) UnSuppressEvent(ctx context.Context, filter *voltha.EventFilter) (*empty.Empty, error) {
+ return nil, olterrors.ErrNotImplemented
+}
+
+//DownloadImage is unimplemented
+func (oo *OpenOLT) DownloadImage(ctx context.Context, imageInfo *ic.ImageDownloadMessage) (*voltha.ImageDownload, error) {
+ return nil, olterrors.ErrNotImplemented
+}
+
+//GetImageDownloadStatus is unimplemented
+func (oo *OpenOLT) GetImageDownloadStatus(ctx context.Context, imageInfo *ic.ImageDownloadMessage) (*voltha.ImageDownload, error) {
+ return nil, olterrors.ErrNotImplemented
+}
+
+//CancelImageDownload is unimplemented
+func (oo *OpenOLT) CancelImageDownload(ctx context.Context, imageInfo *ic.ImageDownloadMessage) (*voltha.ImageDownload, error) {
+ return nil, olterrors.ErrNotImplemented
+}
+
+//ActivateImageUpdate is unimplemented
+func (oo *OpenOLT) ActivateImageUpdate(ctx context.Context, imageInfo *ic.ImageDownloadMessage) (*voltha.ImageDownload, error) {
+ return nil, olterrors.ErrNotImplemented
+}
+
+//RevertImageUpdate is unimplemented
+func (oo *OpenOLT) RevertImageUpdate(ctx context.Context, imageInfo *ic.ImageDownloadMessage) (*voltha.ImageDownload, error) {
+ return nil, olterrors.ErrNotImplemented
+}
+
+//DownloadOnuImage unimplemented
+func (oo *OpenOLT) DownloadOnuImage(ctx context.Context, request *voltha.DeviceImageDownloadRequest) (*voltha.DeviceImageResponse, error) {
+ return nil, olterrors.ErrNotImplemented
+}
+
+//GetOnuImageStatus unimplemented
+func (oo *OpenOLT) GetOnuImageStatus(ctx context.Context, in *voltha.DeviceImageRequest) (*voltha.DeviceImageResponse, error) {
+ return nil, olterrors.ErrNotImplemented
+}
+
+//AbortOnuImageUpgrade unimplemented
+func (oo *OpenOLT) AbortOnuImageUpgrade(ctx context.Context, in *voltha.DeviceImageRequest) (*voltha.DeviceImageResponse, error) {
+ return nil, olterrors.ErrNotImplemented
+}
+
+//GetOnuImages unimplemented
+func (oo *OpenOLT) GetOnuImages(ctx context.Context, deviceID *common.ID) (*voltha.OnuImages, error) {
+ return nil, olterrors.ErrNotImplemented
+}
+
+//ActivateOnuImage unimplemented
+func (oo *OpenOLT) ActivateOnuImage(ctx context.Context, in *voltha.DeviceImageRequest) (*voltha.DeviceImageResponse, error) {
+ return nil, olterrors.ErrNotImplemented
+}
+
+//CommitOnuImage unimplemented
+func (oo *OpenOLT) CommitOnuImage(ctx context.Context, in *voltha.DeviceImageRequest) (*voltha.DeviceImageResponse, error) {
+ return nil, olterrors.ErrNotImplemented
+}
+
+// UpdateFlowsBulk is unimplemented
+func (oo *OpenOLT) UpdateFlowsBulk(ctx context.Context, flows *ic.BulkFlows) (*empty.Empty, error) {
+ return nil, olterrors.ErrNotImplemented
+}
+
+//SelfTestDevice unimplemented
+func (oo *OpenOLT) SelfTestDevice(ctx context.Context, device *voltha.Device) (*empty.Empty, error) {
+ return nil, olterrors.ErrNotImplemented
+}