blob: ce33c8ede7409e4087eb0493c9453b1db268048f [file] [log] [blame]
Holger Hildebrandtfa074992020-03-27 15:42:06 +00001/*
2 * Copyright 2020-present Open Networking Foundation
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +000017//Package adaptercoreonu provides the utility for onu devices, flows and statistics
18package adaptercoreonu
Holger Hildebrandtfa074992020-03-27 15:42:06 +000019
20import (
21 "context"
22 "errors"
23 "fmt"
24 "sync"
25 "time"
26
27 "github.com/opencord/voltha-lib-go/v3/pkg/adapters/adapterif"
mpagenkoaf801632020-07-03 10:00:42 +000028 "github.com/opencord/voltha-lib-go/v3/pkg/db/kvstore"
Holger Hildebrandtfa074992020-03-27 15:42:06 +000029 "github.com/opencord/voltha-lib-go/v3/pkg/kafka"
30 "github.com/opencord/voltha-lib-go/v3/pkg/log"
31 ic "github.com/opencord/voltha-protos/v3/go/inter_container"
32 "github.com/opencord/voltha-protos/v3/go/openflow_13"
33 "github.com/opencord/voltha-protos/v3/go/voltha"
34
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +000035 "test.internal/openadapter/internal/pkg/config"
Holger Hildebrandtfa074992020-03-27 15:42:06 +000036)
37
38//OpenONUAC structure holds the ONU core information
39type OpenONUAC struct {
Himani Chawla6d2ae152020-09-02 13:11:20 +053040 deviceHandlers map[string]*deviceHandler
Holger Hildebrandtfa074992020-03-27 15:42:06 +000041 coreProxy adapterif.CoreProxy
42 adapterProxy adapterif.AdapterProxy
43 eventProxy adapterif.EventProxy
44 kafkaICProxy kafka.InterContainerProxy
mpagenkoaf801632020-07-03 10:00:42 +000045 kvClient kvstore.Client
Holger Hildebrandtfa074992020-03-27 15:42:06 +000046 config *config.AdapterFlags
47 numOnus int
48 KVStoreHost string
49 KVStorePort int
50 KVStoreType string
mpagenkoaf801632020-07-03 10:00:42 +000051 KVStoreTimeout time.Duration
Holger Hildebrandtfa074992020-03-27 15:42:06 +000052 exitChannel chan int
53 HeartbeatCheckInterval time.Duration
54 HeartbeatFailReportInterval time.Duration
mpagenkodff5dda2020-08-28 11:52:01 +000055 AcceptIncrementalEvto bool
Holger Hildebrandtfa074992020-03-27 15:42:06 +000056 //GrpcTimeoutInterval time.Duration
Himani Chawlad96df182020-09-28 11:12:02 +053057 lockDeviceHandlersMap sync.RWMutex
58 pSupportedFsms *OmciDeviceFsms
59 maxTimeoutInterAdapterComm time.Duration
Holger Hildebrandtfa074992020-03-27 15:42:06 +000060}
61
62//NewOpenONUAC returns a new instance of OpenONU_AC
63func NewOpenONUAC(ctx context.Context, kafkaICProxy kafka.InterContainerProxy,
64 coreProxy adapterif.CoreProxy, adapterProxy adapterif.AdapterProxy,
mpagenkoaf801632020-07-03 10:00:42 +000065 eventProxy adapterif.EventProxy, kvClient kvstore.Client, cfg *config.AdapterFlags) *OpenONUAC {
Holger Hildebrandtfa074992020-03-27 15:42:06 +000066 var openOnuAc OpenONUAC
67 openOnuAc.exitChannel = make(chan int, 1)
Himani Chawla6d2ae152020-09-02 13:11:20 +053068 openOnuAc.deviceHandlers = make(map[string]*deviceHandler)
Holger Hildebrandtfa074992020-03-27 15:42:06 +000069 openOnuAc.kafkaICProxy = kafkaICProxy
70 openOnuAc.config = cfg
71 openOnuAc.numOnus = cfg.OnuNumber
72 openOnuAc.coreProxy = coreProxy
73 openOnuAc.adapterProxy = adapterProxy
74 openOnuAc.eventProxy = eventProxy
mpagenkoaf801632020-07-03 10:00:42 +000075 openOnuAc.kvClient = kvClient
Holger Hildebrandtfa074992020-03-27 15:42:06 +000076 openOnuAc.KVStoreHost = cfg.KVStoreHost
77 openOnuAc.KVStorePort = cfg.KVStorePort
78 openOnuAc.KVStoreType = cfg.KVStoreType
mpagenkoaf801632020-07-03 10:00:42 +000079 openOnuAc.KVStoreTimeout = cfg.KVStoreTimeout
Holger Hildebrandtfa074992020-03-27 15:42:06 +000080 openOnuAc.HeartbeatCheckInterval = cfg.HeartbeatCheckInterval
81 openOnuAc.HeartbeatFailReportInterval = cfg.HeartbeatFailReportInterval
mpagenkodff5dda2020-08-28 11:52:01 +000082 openOnuAc.AcceptIncrementalEvto = cfg.AccIncrEvto
Himani Chawlad96df182020-09-28 11:12:02 +053083 openOnuAc.maxTimeoutInterAdapterComm = cfg.MaxTimeoutInterAdapterComm
Holger Hildebrandtfa074992020-03-27 15:42:06 +000084 //openOnuAc.GrpcTimeoutInterval = cfg.GrpcTimeoutInterval
85 openOnuAc.lockDeviceHandlersMap = sync.RWMutex{}
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +000086
87 openOnuAc.pSupportedFsms = &OmciDeviceFsms{
88 "mib-synchronizer": {
89 //mibSyncFsm, // Implements the MIB synchronization state machine
Himani Chawla6d2ae152020-09-02 13:11:20 +053090 mibDbVolatileDictImpl, // Implements volatile ME MIB database
Himani Chawla4d908332020-08-31 12:30:20 +053091 //true, // Advertise events on OpenOMCI event bus
92 cMibAuditDelayImpl, // Time to wait between MIB audits. 0 to disable audits.
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +000093 // map[string]func() error{
94 // "mib-upload": onuDeviceEntry.MibUploadTask,
95 // "mib-template": onuDeviceEntry.MibTemplateTask,
96 // "get-mds": onuDeviceEntry.GetMdsTask,
97 // "mib-audit": onuDeviceEntry.GetMdsTask,
98 // "mib-resync": onuDeviceEntry.MibResyncTask,
99 // "mib-reconcile": onuDeviceEntry.MibReconcileTask,
100 // },
101 },
102 }
103
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000104 return &openOnuAc
105}
106
107//Start starts (logs) the adapter
108func (oo *OpenONUAC) Start(ctx context.Context) error {
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000109 logger.Info("starting-openonu-adapter")
110 logger.Info("openonu-adapter-started")
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000111 return nil
112}
113
Himani Chawla6d2ae152020-09-02 13:11:20 +0530114/*
115//stop terminates the session
116func (oo *OpenONUAC) stop(ctx context.Context) error {
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000117 logger.Info("stopping-device-manager")
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000118 oo.exitChannel <- 1
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000119 logger.Info("device-manager-stopped")
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000120 return nil
121}
Himani Chawla6d2ae152020-09-02 13:11:20 +0530122*/
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000123
Himani Chawla6d2ae152020-09-02 13:11:20 +0530124func (oo *OpenONUAC) addDeviceHandlerToMap(ctx context.Context, agent *deviceHandler) {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000125 oo.lockDeviceHandlersMap.Lock()
126 defer oo.lockDeviceHandlersMap.Unlock()
127 if _, exist := oo.deviceHandlers[agent.deviceID]; !exist {
128 oo.deviceHandlers[agent.deviceID] = agent
Himani Chawla6d2ae152020-09-02 13:11:20 +0530129 oo.deviceHandlers[agent.deviceID].start(ctx)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000130 }
131}
132
Himani Chawla4d908332020-08-31 12:30:20 +0530133/*
Himani Chawla6d2ae152020-09-02 13:11:20 +0530134func (oo *OpenONUAC) deleteDeviceHandlerToMap(agent *deviceHandler) {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000135 oo.lockDeviceHandlersMap.Lock()
136 defer oo.lockDeviceHandlersMap.Unlock()
137 delete(oo.deviceHandlers, agent.deviceID)
138}
Himani Chawla4d908332020-08-31 12:30:20 +0530139*/
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000140
Himani Chawla6d2ae152020-09-02 13:11:20 +0530141func (oo *OpenONUAC) getDeviceHandler(deviceID string) *deviceHandler {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000142 oo.lockDeviceHandlersMap.Lock()
143 defer oo.lockDeviceHandlersMap.Unlock()
144 if agent, ok := oo.deviceHandlers[deviceID]; ok {
145 return agent
146 }
147 return nil
148}
149
150// Adapter interface required methods ############## begin #########
151// #################################################################
152
153// for original content compare: (needs according deviceHandler methods)
154// /voltha-openolt-adapter/adaptercore/openolt.go
155
156// Adopt_device creates a new device handler if not present already and then adopts the device
157func (oo *OpenONUAC) Adopt_device(device *voltha.Device) error {
158 if device == nil {
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000159 logger.Warn("voltha-device-is-nil")
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000160 return errors.New("nil-device")
161 }
162 ctx := context.Background()
divyadesai4d299552020-08-18 07:13:49 +0000163 logger.Infow("adopt-device", log.Fields{"device-id": device.Id})
Himani Chawla6d2ae152020-09-02 13:11:20 +0530164 var handler *deviceHandler
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000165 if handler = oo.getDeviceHandler(device.Id); handler == nil {
Himani Chawla6d2ae152020-09-02 13:11:20 +0530166 handler := newDeviceHandler(oo.coreProxy, oo.adapterProxy, oo.eventProxy, device, oo)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000167 oo.addDeviceHandlerToMap(ctx, handler)
Himani Chawla6d2ae152020-09-02 13:11:20 +0530168 go handler.adoptOrReconcileDevice(ctx, device)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000169 // Launch the creation of the device topic
170 // go oo.createDeviceTopic(device)
171 }
172 return nil
173}
174
175//Get_ofp_device_info returns OFP information for the given device
176func (oo *OpenONUAC) Get_ofp_device_info(device *voltha.Device) (*ic.SwitchCapability, error) {
divyadesai4d299552020-08-18 07:13:49 +0000177 logger.Errorw("device-handler-not-set", log.Fields{"device-id": device.Id})
Andrea Campanella6515c582020-10-05 11:25:00 +0200178 return nil, fmt.Errorf("device-handler-not-set %s", device.Id)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000179}
180
181//Get_ofp_port_info returns OFP port information for the given device
mpagenkoaf801632020-07-03 10:00:42 +0000182//200630: method removed as per [VOL-3202]: OF port info is now to be delivered within UniPort create
183// cmp changes in onu_uni_port.go::CreateVolthaPort()
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000184
185//Process_inter_adapter_message sends messages to a target device (between adapters)
186func (oo *OpenONUAC) Process_inter_adapter_message(msg *ic.InterAdapterMessage) error {
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000187 logger.Debugw("Process_inter_adapter_message", log.Fields{"msgId": msg.Header.Id,
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000188 "msgProxyDeviceId": msg.Header.ProxyDeviceId, "msgToDeviceId": msg.Header.ToDeviceId})
189
190 targetDevice := msg.Header.ToDeviceId
191 //ToDeviceId should address an DeviceHandler instance
192 if handler := oo.getDeviceHandler(targetDevice); handler != nil {
mpagenko1cc3cb42020-07-27 15:24:38 +0000193 /* 200724: modification towards synchronous implementation - possible errors within processing shall be
194 * in the accordingly delayed response, some timing effect might result in Techprofile processing for multiple UNI's
195 */
Himani Chawla6d2ae152020-09-02 13:11:20 +0530196 return handler.processInterAdapterMessage(msg)
mpagenko1cc3cb42020-07-27 15:24:38 +0000197 /* so far the processing has been in background with according commented error treatment restrictions:
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000198 go handler.ProcessInterAdapterMessage(msg)
199 // error treatment might be more sophisticated
200 // by now let's just accept the message on 'communication layer'
201 // message content problems have to be evaluated then in the handler
202 // and are by now not reported to the calling party (to force what reaction there?)
203 return nil
mpagenko1cc3cb42020-07-27 15:24:38 +0000204 */
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000205 }
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000206 logger.Warnw("no handler found for received Inter-Proxy-message", log.Fields{
207 "msgToDeviceId": targetDevice})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000208 return fmt.Errorf(fmt.Sprintf("handler-not-found-%s", targetDevice))
209}
210
211//Adapter_descriptor not implemented
212func (oo *OpenONUAC) Adapter_descriptor() error {
213 return errors.New("unImplemented")
214}
215
216//Device_types unimplemented
217func (oo *OpenONUAC) Device_types() (*voltha.DeviceTypes, error) {
218 return nil, errors.New("unImplemented")
219}
220
221//Health returns unimplemented
222func (oo *OpenONUAC) Health() (*voltha.HealthStatus, error) {
223 return nil, errors.New("unImplemented")
224}
225
Holger Hildebrandt9ca8b132020-08-07 14:45:03 +0000226//Reconcile_device is called once when the adapter needs to re-create device - usually on core restart
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000227func (oo *OpenONUAC) Reconcile_device(device *voltha.Device) error {
Holger Hildebrandtf41a1602020-08-19 09:52:50 +0000228 if device == nil {
229 logger.Warn("voltha-device-is-nil")
230 return errors.New("nil-device")
231 }
232 ctx := context.Background()
233 logger.Infow("Reconcile_device", log.Fields{"device-id": device.Id})
Himani Chawla6d2ae152020-09-02 13:11:20 +0530234 var handler *deviceHandler
Holger Hildebrandtf41a1602020-08-19 09:52:50 +0000235 if handler = oo.getDeviceHandler(device.Id); handler == nil {
Himani Chawla6d2ae152020-09-02 13:11:20 +0530236 handler := newDeviceHandler(oo.coreProxy, oo.adapterProxy, oo.eventProxy, device, oo)
Holger Hildebrandtf41a1602020-08-19 09:52:50 +0000237 oo.addDeviceHandlerToMap(ctx, handler)
238 handler.device = device
239 handler.reconciling = true
Himani Chawla6d2ae152020-09-02 13:11:20 +0530240 go handler.adoptOrReconcileDevice(ctx, handler.device)
Holger Hildebrandtf41a1602020-08-19 09:52:50 +0000241 // reconcilement will be continued after onu-device entry is added
Holger Hildebrandt9ca8b132020-08-07 14:45:03 +0000242 } else {
Holger Hildebrandtf41a1602020-08-19 09:52:50 +0000243 return fmt.Errorf(fmt.Sprintf("device-already-reconciled-or-active-%s", device.Id))
Holger Hildebrandt9ca8b132020-08-07 14:45:03 +0000244 }
245 return nil
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000246}
247
248//Abandon_device unimplemented
249func (oo *OpenONUAC) Abandon_device(device *voltha.Device) error {
250 return errors.New("unImplemented")
251}
252
253//Disable_device disables the given device
254func (oo *OpenONUAC) Disable_device(device *voltha.Device) error {
divyadesai4d299552020-08-18 07:13:49 +0000255 logger.Debugw("Disable_device", log.Fields{"device-id": device.Id})
ozgecanetsiafce57b12020-05-25 14:39:35 +0300256 if handler := oo.getDeviceHandler(device.Id); handler != nil {
Himani Chawla6d2ae152020-09-02 13:11:20 +0530257 go handler.disableDevice(device)
ozgecanetsiafce57b12020-05-25 14:39:35 +0300258 return nil
259 }
divyadesai4d299552020-08-18 07:13:49 +0000260 logger.Warnw("no handler found for device-disable", log.Fields{"device-id": device.Id})
ozgecanetsiafce57b12020-05-25 14:39:35 +0300261 return fmt.Errorf(fmt.Sprintf("handler-not-found-%s", device.Id))
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000262}
263
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000264//Reenable_device enables the onu device after disable
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000265func (oo *OpenONUAC) Reenable_device(device *voltha.Device) error {
divyadesai4d299552020-08-18 07:13:49 +0000266 logger.Debugw("Reenable_device", log.Fields{"device-id": device.Id})
ozgecanetsiafce57b12020-05-25 14:39:35 +0300267 if handler := oo.getDeviceHandler(device.Id); handler != nil {
Himani Chawla6d2ae152020-09-02 13:11:20 +0530268 go handler.reEnableDevice(device)
ozgecanetsiafce57b12020-05-25 14:39:35 +0300269 return nil
270 }
divyadesai4d299552020-08-18 07:13:49 +0000271 logger.Warnw("no handler found for device-reenable", log.Fields{"device-id": device.Id})
ozgecanetsiafce57b12020-05-25 14:39:35 +0300272 return fmt.Errorf(fmt.Sprintf("handler-not-found-%s", device.Id))
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000273}
274
275//Reboot_device reboots the given device
276func (oo *OpenONUAC) Reboot_device(device *voltha.Device) error {
divyadesai4d299552020-08-18 07:13:49 +0000277 logger.Debugw("Reboot-device", log.Fields{"device-id": device.Id})
ozgecanetsiae11479f2020-07-06 09:44:47 +0300278 if handler := oo.getDeviceHandler(device.Id); handler != nil {
Himani Chawla6d2ae152020-09-02 13:11:20 +0530279 go handler.rebootDevice(device)
ozgecanetsiae11479f2020-07-06 09:44:47 +0300280 return nil
281 }
divyadesai4d299552020-08-18 07:13:49 +0000282 logger.Warnw("no handler found for device-reboot", log.Fields{"device-id": device.Id})
ozgecanetsiae11479f2020-07-06 09:44:47 +0300283 return fmt.Errorf(fmt.Sprintf("handler-not-found-#{device.Id}"))
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000284}
285
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000286//Self_test_device unimplemented
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000287func (oo *OpenONUAC) Self_test_device(device *voltha.Device) error {
288 return errors.New("unImplemented")
289}
290
Himani Chawla6d2ae152020-09-02 13:11:20 +0530291// Delete_device deletes the given device
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000292func (oo *OpenONUAC) Delete_device(device *voltha.Device) error {
divyadesai4d299552020-08-18 07:13:49 +0000293 logger.Debugw("Delete_device", log.Fields{"device-id": device.Id})
Holger Hildebrandt9ca8b132020-08-07 14:45:03 +0000294 if handler := oo.getDeviceHandler(device.Id); handler != nil {
Himani Chawla6d2ae152020-09-02 13:11:20 +0530295 if err := handler.deleteDevice(device); err != nil {
Holger Hildebrandt9ca8b132020-08-07 14:45:03 +0000296 return err
297 }
298 } else {
divyadesai4d299552020-08-18 07:13:49 +0000299 logger.Warnw("no handler found for device-reconcilement", log.Fields{"device-id": device.Id})
Holger Hildebrandt9ca8b132020-08-07 14:45:03 +0000300 return fmt.Errorf(fmt.Sprintf("handler-not-found-%s", device.Id))
301 }
302 return nil
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000303}
304
305//Get_device_details unimplemented
306func (oo *OpenONUAC) Get_device_details(device *voltha.Device) error {
307 return errors.New("unImplemented")
308}
309
310//Update_flows_bulk returns
311func (oo *OpenONUAC) Update_flows_bulk(device *voltha.Device, flows *voltha.Flows, groups *voltha.FlowGroups, flowMetadata *voltha.FlowMetadata) error {
312 return errors.New("unImplemented")
313}
314
315//Update_flows_incrementally updates (add/remove) the flows on a given device
mpagenkodff5dda2020-08-28 11:52:01 +0000316func (oo *OpenONUAC) Update_flows_incrementally(device *voltha.Device,
317 flows *openflow_13.FlowChanges, groups *openflow_13.FlowGroupChanges, flowMetadata *voltha.FlowMetadata) error {
318 // no point in pushing omci flows if the device isn't reachable
319 if device.ConnectStatus != voltha.ConnectStatus_REACHABLE ||
320 device.AdminState != voltha.AdminState_ENABLED {
Holger Hildebrandt8165eda2020-09-24 09:39:24 +0000321 logger.Warnw("device disabled or offline - skipping flow-update", log.Fields{"ConnectStatus": device.ConnectStatus,
322 "AdminState": device.AdminState, "deviceId": device.Id})
323 return fmt.Errorf("non-matching device state: %s", device.Id)
mpagenkodff5dda2020-08-28 11:52:01 +0000324 }
325
326 // For now, there is no support for group changes (as in the actual Py-adapter code)
327 if groups.ToAdd != nil && groups.ToAdd.Items != nil {
328 logger.Debugw("Update-flow-incr: group add not supported (ignored)", log.Fields{"deviceId": device.Id})
329 }
330 if groups.ToRemove != nil && groups.ToRemove.Items != nil {
331 logger.Debugw("Update-flow-incr: group remove not supported (ignored)", log.Fields{"deviceId": device.Id})
332 }
333 if groups.ToUpdate != nil && groups.ToUpdate.Items != nil {
334 logger.Debugw("Update-flow-incr: group update not supported (ignored)", log.Fields{"deviceId": device.Id})
335 }
336
337 if handler := oo.getDeviceHandler(device.Id); handler != nil {
338 err := handler.FlowUpdateIncremental(flows, groups, flowMetadata)
339 return err
340 }
341 logger.Warnw("no handler found for incremental flow update", log.Fields{"deviceId": device.Id})
342 return fmt.Errorf(fmt.Sprintf("handler-not-found-%s", device.Id))
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000343}
344
345//Update_pm_config returns PmConfigs nil or error
346func (oo *OpenONUAC) Update_pm_config(device *voltha.Device, pmConfigs *voltha.PmConfigs) error {
347 return errors.New("unImplemented")
348}
349
350//Receive_packet_out sends packet out to the device
351func (oo *OpenONUAC) Receive_packet_out(deviceID string, egressPortNo int, packet *openflow_13.OfpPacketOut) error {
352 return errors.New("unImplemented")
353}
354
355//Suppress_event unimplemented
356func (oo *OpenONUAC) Suppress_event(filter *voltha.EventFilter) error {
357 return errors.New("unImplemented")
358}
359
360//Unsuppress_event unimplemented
361func (oo *OpenONUAC) Unsuppress_event(filter *voltha.EventFilter) error {
362 return errors.New("unImplemented")
363}
364
365//Download_image unimplemented
366func (oo *OpenONUAC) Download_image(device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
367 return nil, errors.New("unImplemented")
368}
369
370//Get_image_download_status unimplemented
371func (oo *OpenONUAC) Get_image_download_status(device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
372 return nil, errors.New("unImplemented")
373}
374
375//Cancel_image_download unimplemented
376func (oo *OpenONUAC) Cancel_image_download(device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
377 return nil, errors.New("unImplemented")
378}
379
380//Activate_image_update unimplemented
381func (oo *OpenONUAC) Activate_image_update(device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
382 return nil, errors.New("unImplemented")
383}
384
385//Revert_image_update unimplemented
386func (oo *OpenONUAC) Revert_image_update(device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
387 return nil, errors.New("unImplemented")
388}
389
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000390// Enable_port to Enable PON/NNI interface - seems not to be used/required according to python code
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000391func (oo *OpenONUAC) Enable_port(deviceID string, port *voltha.Port) error {
392 return errors.New("unImplemented")
393}
394
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000395// Disable_port to Disable pon/nni interface - seems not to be used/required according to python code
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000396func (oo *OpenONUAC) Disable_port(deviceID string, port *voltha.Port) error {
397 return errors.New("unImplemented")
398}
399
Himani Chawla6d2ae152020-09-02 13:11:20 +0530400//Child_device_lost - unimplemented
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000401//needed for if update >= 3.1.x
Matteo Scandolo2e6f1e32020-04-15 11:28:45 -0700402func (oo *OpenONUAC) Child_device_lost(deviceID string, pPortNo uint32, onuID uint32) error {
403 return errors.New("unImplemented")
404}
405
Himani Chawla6d2ae152020-09-02 13:11:20 +0530406// Start_omci_test unimplemented
Matteo Scandolo2e6f1e32020-04-15 11:28:45 -0700407func (oo *OpenONUAC) Start_omci_test(device *voltha.Device, request *voltha.OmciTestRequest) (*voltha.TestResponse, error) {
408 return nil, errors.New("unImplemented")
409}
410
Himani Chawla6d2ae152020-09-02 13:11:20 +0530411// Get_ext_value - unimplemented
Matteo Scandolod132c0e2020-04-24 17:06:25 -0700412func (oo *OpenONUAC) Get_ext_value(deviceID string, device *voltha.Device, valueparam voltha.ValueType_Type) (*voltha.ReturnValues, error) {
413 return nil, errors.New("unImplemented")
414}
415
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000416// Adapter interface required methods ################ end #########
417// #################################################################