blob: 0e6c1418efa0b74449009dc64744087d180f35b1 [file] [log] [blame]
Girish Gowdru0c588b22019-04-23 23:24:56 -04001/*
2 * Copyright 2018-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 */
Girish Gowdru6a80bbd2019-07-02 07:36:09 -070016
17//Package adaptercore provides the utility for olt devices, flows and statistics
Girish Gowdru0c588b22019-04-23 23:24:56 -040018package adaptercore
19
20import (
21 "context"
22 "errors"
23 "fmt"
24 "sync"
25
Scott Baker51290152019-10-24 14:23:20 -070026 "github.com/opencord/voltha-lib-go/v2/pkg/adapters/adapterif"
27 "github.com/opencord/voltha-lib-go/v2/pkg/kafka"
28 "github.com/opencord/voltha-lib-go/v2/pkg/log"
Girish Gowdru0c588b22019-04-23 23:24:56 -040029 ic "github.com/opencord/voltha-protos/go/inter_container"
30 "github.com/opencord/voltha-protos/go/openflow_13"
31 "github.com/opencord/voltha-protos/go/voltha"
32)
33
Girish Gowdru6a80bbd2019-07-02 07:36:09 -070034//OpenOLT structure holds the OLT information
Girish Gowdru0c588b22019-04-23 23:24:56 -040035type OpenOLT struct {
36 deviceHandlers map[string]*DeviceHandler
kdarapu381c6902019-07-31 18:23:16 +053037 coreProxy adapterif.CoreProxy
38 adapterProxy adapterif.AdapterProxy
39 eventProxy adapterif.EventProxy
Girish Gowdru0c588b22019-04-23 23:24:56 -040040 kafkaICProxy *kafka.InterContainerProxy
41 numOnus int
42 KVStoreHost string
43 KVStorePort int
44 KVStoreType string
45 exitChannel chan int
46 lockDeviceHandlersMap sync.RWMutex
47}
48
Girish Gowdru6a80bbd2019-07-02 07:36:09 -070049//NewOpenOLT returns a new instance of OpenOLT
kdarapu381c6902019-07-31 18:23:16 +053050func NewOpenOLT(ctx context.Context, kafkaICProxy *kafka.InterContainerProxy,
51 coreProxy adapterif.CoreProxy, adapterProxy adapterif.AdapterProxy,
52 eventProxy adapterif.EventProxy, onuNumber int, kvStoreHost string,
53 kvStorePort int, KVStoreType string) *OpenOLT {
Girish Gowdru0c588b22019-04-23 23:24:56 -040054 var openOLT OpenOLT
55 openOLT.exitChannel = make(chan int, 1)
56 openOLT.deviceHandlers = make(map[string]*DeviceHandler)
57 openOLT.kafkaICProxy = kafkaICProxy
58 openOLT.numOnus = onuNumber
59 openOLT.coreProxy = coreProxy
60 openOLT.adapterProxy = adapterProxy
Devmalya Paulfb990a52019-07-09 10:01:49 -040061 openOLT.eventProxy = eventProxy
Girish Gowdru0c588b22019-04-23 23:24:56 -040062 openOLT.KVStoreHost = kvStoreHost
63 openOLT.KVStorePort = kvStorePort
64 openOLT.KVStoreType = KVStoreType
65 openOLT.lockDeviceHandlersMap = sync.RWMutex{}
66 return &openOLT
67}
68
Girish Gowdru6a80bbd2019-07-02 07:36:09 -070069//Start starts (logs) the device manager
Girish Gowdru0c588b22019-04-23 23:24:56 -040070func (oo *OpenOLT) Start(ctx context.Context) error {
71 log.Info("starting-device-manager")
72 log.Info("device-manager-started")
73 return nil
74}
75
Girish Gowdru6a80bbd2019-07-02 07:36:09 -070076//Stop terminates the session
Girish Gowdru0c588b22019-04-23 23:24:56 -040077func (oo *OpenOLT) Stop(ctx context.Context) error {
78 log.Info("stopping-device-manager")
79 oo.exitChannel <- 1
80 log.Info("device-manager-stopped")
81 return nil
82}
83
84func sendResponse(ctx context.Context, ch chan interface{}, result interface{}) {
85 if ctx.Err() == nil {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -070086 // Returned response only of the ctx has not been canceled/timeout/etc
Girish Gowdru0c588b22019-04-23 23:24:56 -040087 // Channel is automatically closed when a context is Done
88 ch <- result
89 log.Debugw("sendResponse", log.Fields{"result": result})
90 } else {
91 // Should the transaction be reverted back?
92 log.Debugw("sendResponse-context-error", log.Fields{"context-error": ctx.Err()})
93 }
94}
95
96func (oo *OpenOLT) addDeviceHandlerToMap(agent *DeviceHandler) {
97 oo.lockDeviceHandlersMap.Lock()
98 defer oo.lockDeviceHandlersMap.Unlock()
Girish Gowdru6a80bbd2019-07-02 07:36:09 -070099 if _, exist := oo.deviceHandlers[agent.deviceID]; !exist {
100 oo.deviceHandlers[agent.deviceID] = agent
Girish Gowdru0c588b22019-04-23 23:24:56 -0400101 }
102}
103
104func (oo *OpenOLT) deleteDeviceHandlerToMap(agent *DeviceHandler) {
105 oo.lockDeviceHandlersMap.Lock()
106 defer oo.lockDeviceHandlersMap.Unlock()
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700107 delete(oo.deviceHandlers, agent.deviceID)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400108}
109
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700110func (oo *OpenOLT) getDeviceHandler(deviceID string) *DeviceHandler {
Girish Gowdru0c588b22019-04-23 23:24:56 -0400111 oo.lockDeviceHandlersMap.Lock()
112 defer oo.lockDeviceHandlersMap.Unlock()
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700113 if agent, ok := oo.deviceHandlers[deviceID]; ok {
Girish Gowdru0c588b22019-04-23 23:24:56 -0400114 return agent
115 }
116 return nil
117}
118
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700119//createDeviceTopic returns
Girish Gowdru0c588b22019-04-23 23:24:56 -0400120func (oo *OpenOLT) createDeviceTopic(device *voltha.Device) error {
121 log.Infow("create-device-topic", log.Fields{"deviceId": device.Id})
122 deviceTopic := kafka.Topic{Name: oo.kafkaICProxy.DefaultTopic.Name + "_" + device.Id}
123 // TODO for the offset
124 if err := oo.kafkaICProxy.SubscribeWithDefaultRequestHandler(deviceTopic, 0); err != nil {
125 log.Infow("create-device-topic-failed", log.Fields{"deviceId": device.Id, "error": err})
126 return err
127 }
128 return nil
129}
130
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700131// Adopt_device creates a new device handler if not present already and then adopts the device
Girish Gowdru0c588b22019-04-23 23:24:56 -0400132func (oo *OpenOLT) Adopt_device(device *voltha.Device) error {
133 if device == nil {
134 log.Warn("device-is-nil")
135 return errors.New("nil-device")
136 }
137 log.Infow("adopt-device", log.Fields{"deviceId": device.Id})
138 var handler *DeviceHandler
139 if handler = oo.getDeviceHandler(device.Id); handler == nil {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400140 handler := NewDeviceHandler(oo.coreProxy, oo.adapterProxy, oo.eventProxy, device, oo)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400141 oo.addDeviceHandlerToMap(handler)
142 go handler.AdoptDevice(device)
143 // Launch the creation of the device topic
144 // go oo.createDeviceTopic(device)
145 }
146 return nil
147}
148
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700149//Get_ofp_device_info returns OFP information for the given device
Girish Gowdru0c588b22019-04-23 23:24:56 -0400150func (oo *OpenOLT) Get_ofp_device_info(device *voltha.Device) (*ic.SwitchCapability, error) {
151 log.Infow("Get_ofp_device_info", log.Fields{"deviceId": device.Id})
152 if handler := oo.getDeviceHandler(device.Id); handler != nil {
153 return handler.GetOfpDeviceInfo(device)
154 }
155 log.Errorw("device-handler-not-set", log.Fields{"deviceId": device.Id})
156 return nil, errors.New("device-handler-not-set")
157}
158
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700159//Get_ofp_port_info returns OFP port information for the given device
160func (oo *OpenOLT) Get_ofp_port_info(device *voltha.Device, portNo int64) (*ic.PortCapability, error) {
Girish Gowdru0c588b22019-04-23 23:24:56 -0400161 log.Infow("Get_ofp_port_info", log.Fields{"deviceId": device.Id})
162 if handler := oo.getDeviceHandler(device.Id); handler != nil {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700163 return handler.GetOfpPortInfo(device, portNo)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400164 }
165 log.Errorw("device-handler-not-set", log.Fields{"deviceId": device.Id})
166 return nil, errors.New("device-handler-not-set")
167}
168
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700169//Process_inter_adapter_message sends messages to a target device (between adapters)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400170func (oo *OpenOLT) Process_inter_adapter_message(msg *ic.InterAdapterMessage) error {
171 log.Infow("Process_inter_adapter_message", log.Fields{"msgId": msg.Header.Id})
172 targetDevice := msg.Header.ProxyDeviceId // Request?
173 if targetDevice == "" && msg.Header.ToDeviceId != "" {
174 // Typical response
175 targetDevice = msg.Header.ToDeviceId
176 }
177 if handler := oo.getDeviceHandler(targetDevice); handler != nil {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700178 return handler.ProcessInterAdapterMessage(msg)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400179 }
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700180 return fmt.Errorf(fmt.Sprintf("handler-not-found-%s", targetDevice))
Girish Gowdru0c588b22019-04-23 23:24:56 -0400181}
182
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700183//Adapter_descriptor not implemented
Girish Gowdru0c588b22019-04-23 23:24:56 -0400184func (oo *OpenOLT) Adapter_descriptor() error {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700185 return errors.New("unImplemented")
Girish Gowdru0c588b22019-04-23 23:24:56 -0400186}
187
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700188//Device_types unimplemented
Girish Gowdru0c588b22019-04-23 23:24:56 -0400189func (oo *OpenOLT) Device_types() (*voltha.DeviceTypes, error) {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700190 return nil, errors.New("unImplemented")
Girish Gowdru0c588b22019-04-23 23:24:56 -0400191}
192
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700193//Health returns unimplemented
Girish Gowdru0c588b22019-04-23 23:24:56 -0400194func (oo *OpenOLT) Health() (*voltha.HealthStatus, error) {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700195 return nil, errors.New("unImplemented")
Girish Gowdru0c588b22019-04-23 23:24:56 -0400196}
197
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700198//Reconcile_device unimplemented
Girish Gowdru0c588b22019-04-23 23:24:56 -0400199func (oo *OpenOLT) Reconcile_device(device *voltha.Device) error {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700200 return errors.New("unImplemented")
Girish Gowdru0c588b22019-04-23 23:24:56 -0400201}
202
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700203//Abandon_device unimplemented
Girish Gowdru0c588b22019-04-23 23:24:56 -0400204func (oo *OpenOLT) Abandon_device(device *voltha.Device) error {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700205 return errors.New("unImplemented")
Girish Gowdru0c588b22019-04-23 23:24:56 -0400206}
207
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700208//Disable_device disables the given device
Girish Gowdru0c588b22019-04-23 23:24:56 -0400209func (oo *OpenOLT) Disable_device(device *voltha.Device) error {
Girish Gowdru5ba46c92019-04-25 05:00:05 -0400210 log.Infow("disable-device", log.Fields{"deviceId": device.Id})
211 if handler := oo.getDeviceHandler(device.Id); handler != nil {
212 return handler.DisableDevice(device)
213 }
214 log.Errorw("device-handler-not-set", log.Fields{"deviceId": device.Id})
215 return errors.New("device-handler-not-found")
Girish Gowdru0c588b22019-04-23 23:24:56 -0400216}
217
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700218//Reenable_device enables the olt device after disable
Girish Gowdru0c588b22019-04-23 23:24:56 -0400219func (oo *OpenOLT) Reenable_device(device *voltha.Device) error {
Girish Gowdru5ba46c92019-04-25 05:00:05 -0400220 log.Infow("reenable-device", log.Fields{"deviceId": device.Id})
221 if handler := oo.getDeviceHandler(device.Id); handler != nil {
222 return handler.ReenableDevice(device)
223 }
224 log.Errorw("device-handler-not-set", log.Fields{"deviceId": device.Id})
225 return errors.New("device-handler-not-found")
Girish Gowdru0c588b22019-04-23 23:24:56 -0400226}
227
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700228//Reboot_device reboots the given device
Girish Gowdru0c588b22019-04-23 23:24:56 -0400229func (oo *OpenOLT) Reboot_device(device *voltha.Device) error {
Girish Gowdru0fe5f7e2019-05-28 05:12:27 -0400230 log.Infow("reboot-device", log.Fields{"deviceId": device.Id})
231 if handler := oo.getDeviceHandler(device.Id); handler != nil {
232 return handler.RebootDevice(device)
233 }
234 log.Errorw("device-handler-not-set", log.Fields{"deviceId": device.Id})
235 return errors.New("device-handler-not-found")
236
Girish Gowdru0c588b22019-04-23 23:24:56 -0400237}
238
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700239//Self_test_device unimplented
Girish Gowdru0c588b22019-04-23 23:24:56 -0400240func (oo *OpenOLT) Self_test_device(device *voltha.Device) error {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700241 return errors.New("unImplemented")
Girish Gowdru0c588b22019-04-23 23:24:56 -0400242}
243
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700244//Delete_device unimplemented
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400245func (oo *OpenOLT) Delete_device(device *voltha.Device) error {
Devmalya Paul495b94a2019-08-27 19:42:00 -0400246 log.Infow("delete-device", log.Fields{"deviceId": device.Id})
247 if handler := oo.getDeviceHandler(device.Id); handler != nil {
248 if err := handler.DeleteDevice(device); err != nil {
249 log.Errorw("failed-to-handle-delete-device", log.Fields{"device-id": device.Id})
250 }
251 oo.deleteDeviceHandlerToMap(handler)
252 return nil
253 }
254 log.Errorw("device-handler-not-set", log.Fields{"deviceId": device.Id})
255 return errors.New("device-handler-not-found")
Girish Gowdru0c588b22019-04-23 23:24:56 -0400256}
257
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700258//Get_device_details unimplemented
Girish Gowdru0c588b22019-04-23 23:24:56 -0400259func (oo *OpenOLT) Get_device_details(device *voltha.Device) error {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700260 return errors.New("unImplemented")
Girish Gowdru0c588b22019-04-23 23:24:56 -0400261}
262
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700263//Update_flows_bulk returns
Manikkaraj kb1d51442019-07-23 10:41:02 -0400264func (oo *OpenOLT) Update_flows_bulk(device *voltha.Device, flows *voltha.Flows, groups *voltha.FlowGroups, flowMetadata *voltha.FlowMetadata) error {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700265 return errors.New("unImplemented")
Girish Gowdru0c588b22019-04-23 23:24:56 -0400266}
267
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700268//Update_flows_incrementally updates (add/remove) the flows on a given device
Manikkaraj kb1d51442019-07-23 10:41:02 -0400269func (oo *OpenOLT) Update_flows_incrementally(device *voltha.Device, flows *openflow_13.FlowChanges, groups *openflow_13.FlowGroupChanges, flowMetadata *voltha.FlowMetadata) error {
270 log.Debugw("Update_flows_incrementally", log.Fields{"deviceId": device.Id, "flows": flows, "flowMetadata": flowMetadata})
Girish Gowdru0c588b22019-04-23 23:24:56 -0400271 if handler := oo.getDeviceHandler(device.Id); handler != nil {
Manikkaraj kb1d51442019-07-23 10:41:02 -0400272 return handler.UpdateFlowsIncrementally(device, flows, groups, flowMetadata)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400273 }
274 log.Errorw("Update_flows_incrementally failed-device-handler-not-set", log.Fields{"deviceId": device.Id})
275 return errors.New("device-handler-not-set")
276}
277
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700278//Update_pm_config returns PmConfigs nil or error
279func (oo *OpenOLT) Update_pm_config(device *voltha.Device, pmConfigs *voltha.PmConfigs) error {
280 return errors.New("unImplemented")
Girish Gowdru0c588b22019-04-23 23:24:56 -0400281}
282
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700283//Receive_packet_out sends packet out to the device
284func (oo *OpenOLT) Receive_packet_out(deviceID string, egressPortNo int, packet *openflow_13.OfpPacketOut) error {
285 log.Debugw("Receive_packet_out", log.Fields{"deviceId": deviceID, "egress_port_no": egressPortNo, "pkt": packet})
286 if handler := oo.getDeviceHandler(deviceID); handler != nil {
287 return handler.PacketOut(egressPortNo, packet)
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400288 }
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700289 log.Errorw("Receive_packet_out failed-device-handler-not-set", log.Fields{"deviceId": deviceID, "egressport": egressPortNo, "packet": packet})
manikkaraj k9eb6cac2019-05-09 12:32:03 -0400290 return errors.New("device-handler-not-set")
Girish Gowdru0c588b22019-04-23 23:24:56 -0400291}
292
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700293//Suppress_alarm unimplemented
Girish Gowdru0c588b22019-04-23 23:24:56 -0400294func (oo *OpenOLT) Suppress_alarm(filter *voltha.AlarmFilter) error {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700295 return errors.New("unImplemented")
Girish Gowdru0c588b22019-04-23 23:24:56 -0400296}
297
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700298//Unsuppress_alarm unimplemented
Girish Gowdru0c588b22019-04-23 23:24:56 -0400299func (oo *OpenOLT) Unsuppress_alarm(filter *voltha.AlarmFilter) error {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700300 return errors.New("unImplemented")
Girish Gowdru0c588b22019-04-23 23:24:56 -0400301}
302
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700303//Download_image unimplemented
Girish Gowdru0c588b22019-04-23 23:24:56 -0400304func (oo *OpenOLT) Download_image(device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700305 return nil, errors.New("unImplemented")
Girish Gowdru0c588b22019-04-23 23:24:56 -0400306}
307
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700308//Get_image_download_status unimplemented
Girish Gowdru0c588b22019-04-23 23:24:56 -0400309func (oo *OpenOLT) Get_image_download_status(device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700310 return nil, errors.New("unImplemented")
Girish Gowdru0c588b22019-04-23 23:24:56 -0400311}
312
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700313//Cancel_image_download unimplemented
Girish Gowdru0c588b22019-04-23 23:24:56 -0400314func (oo *OpenOLT) Cancel_image_download(device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700315 return nil, errors.New("unImplemented")
Girish Gowdru0c588b22019-04-23 23:24:56 -0400316}
317
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700318//Activate_image_update unimplemented
Girish Gowdru0c588b22019-04-23 23:24:56 -0400319func (oo *OpenOLT) Activate_image_update(device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700320 return nil, errors.New("unImplemented")
Girish Gowdru0c588b22019-04-23 23:24:56 -0400321}
322
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700323//Revert_image_update unimplemented
Girish Gowdru0c588b22019-04-23 23:24:56 -0400324func (oo *OpenOLT) Revert_image_update(device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700325 return nil, errors.New("unImplemented")
Girish Gowdru0c588b22019-04-23 23:24:56 -0400326}