Phaneendra Manda | 4c62c80 | 2019-03-06 21:37:49 +0530 | [diff] [blame] | 1 | /*
|
| 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 | */
|
| 16 | package adaptercore
|
| 17 |
|
| 18 | import (
|
cuilin2018 | 7b2a8c3 | 2019-03-26 19:52:28 -0700 | [diff] [blame] | 19 | "context"
|
| 20 | "errors"
|
| 21 | "fmt"
|
| 22 | "sync"
|
Phaneendra Manda | 4c62c80 | 2019-03-06 21:37:49 +0530 | [diff] [blame] | 23 |
|
cuilin2018 | 7b2a8c3 | 2019-03-26 19:52:28 -0700 | [diff] [blame] | 24 | com "github.com/opencord/voltha-go/adapters/common"
|
| 25 | "github.com/opencord/voltha-go/common/log"
|
| 26 | "github.com/opencord/voltha-go/kafka"
|
| 27 | ic "github.com/opencord/voltha-go/protos/inter_container"
|
| 28 | "github.com/opencord/voltha-go/protos/openflow_13"
|
| 29 | "github.com/opencord/voltha-go/protos/voltha"
|
Phaneendra Manda | 4c62c80 | 2019-03-06 21:37:49 +0530 | [diff] [blame] | 30 | )
|
| 31 |
|
| 32 | type OpenOLT struct {
|
cuilin2018 | 7b2a8c3 | 2019-03-26 19:52:28 -0700 | [diff] [blame] | 33 | deviceHandlers map[string]*DeviceHandler
|
| 34 | coreProxy *com.CoreProxy
|
| 35 | adapterProxy *com.AdapterProxy
|
| 36 | kafkaICProxy *kafka.InterContainerProxy
|
| 37 | numOnus int
|
| 38 | exitChannel chan int
|
| 39 | lockDeviceHandlersMap sync.RWMutex
|
Phaneendra Manda | 4c62c80 | 2019-03-06 21:37:49 +0530 | [diff] [blame] | 40 | }
|
| 41 |
|
cuilin2018 | 7b2a8c3 | 2019-03-26 19:52:28 -0700 | [diff] [blame] | 42 | func NewOpenOLT(ctx context.Context, kafkaICProxy *kafka.InterContainerProxy, coreProxy *com.CoreProxy, adapterProxy *com.AdapterProxy, onuNumber int) *OpenOLT {
|
| 43 | var openOLT OpenOLT
|
| 44 | openOLT.exitChannel = make(chan int, 1)
|
| 45 | openOLT.deviceHandlers = make(map[string]*DeviceHandler)
|
| 46 | openOLT.kafkaICProxy = kafkaICProxy
|
| 47 | openOLT.numOnus = onuNumber
|
| 48 | openOLT.coreProxy = coreProxy
|
| 49 | openOLT.adapterProxy = adapterProxy
|
| 50 | openOLT.lockDeviceHandlersMap = sync.RWMutex{}
|
| 51 | return &openOLT
|
Phaneendra Manda | 4c62c80 | 2019-03-06 21:37:49 +0530 | [diff] [blame] | 52 | }
|
| 53 |
|
| 54 | func (oo *OpenOLT) Start(ctx context.Context) error {
|
cuilin2018 | 7b2a8c3 | 2019-03-26 19:52:28 -0700 | [diff] [blame] | 55 | log.Info("starting-device-manager")
|
| 56 | log.Info("device-manager-started")
|
| 57 | return nil
|
Phaneendra Manda | 4c62c80 | 2019-03-06 21:37:49 +0530 | [diff] [blame] | 58 | }
|
| 59 |
|
| 60 | func (oo *OpenOLT) Stop(ctx context.Context) error {
|
cuilin2018 | 7b2a8c3 | 2019-03-26 19:52:28 -0700 | [diff] [blame] | 61 | log.Info("stopping-device-manager")
|
| 62 | oo.exitChannel <- 1
|
| 63 | log.Info("device-manager-stopped")
|
| 64 | return nil
|
Phaneendra Manda | 4c62c80 | 2019-03-06 21:37:49 +0530 | [diff] [blame] | 65 | }
|
| 66 |
|
| 67 | func sendResponse(ctx context.Context, ch chan interface{}, result interface{}) {
|
cuilin2018 | 7b2a8c3 | 2019-03-26 19:52:28 -0700 | [diff] [blame] | 68 | if ctx.Err() == nil {
|
| 69 | // Returned response only of the ctx has not been cancelled/timeout/etc
|
| 70 | // Channel is automatically closed when a context is Done
|
| 71 | ch <- result
|
| 72 | log.Debugw("sendResponse", log.Fields{"result": result})
|
| 73 | } else {
|
| 74 | // Should the transaction be reverted back?
|
| 75 | log.Debugw("sendResponse-context-error", log.Fields{"context-error": ctx.Err()})
|
| 76 | }
|
Phaneendra Manda | 4c62c80 | 2019-03-06 21:37:49 +0530 | [diff] [blame] | 77 | }
|
| 78 |
|
| 79 | func (oo *OpenOLT) addDeviceHandlerToMap(agent *DeviceHandler) {
|
cuilin2018 | 7b2a8c3 | 2019-03-26 19:52:28 -0700 | [diff] [blame] | 80 | oo.lockDeviceHandlersMap.Lock()
|
| 81 | defer oo.lockDeviceHandlersMap.Unlock()
|
| 82 | if _, exist := oo.deviceHandlers[agent.deviceId]; !exist {
|
| 83 | oo.deviceHandlers[agent.deviceId] = agent
|
| 84 | }
|
Phaneendra Manda | 4c62c80 | 2019-03-06 21:37:49 +0530 | [diff] [blame] | 85 | }
|
| 86 |
|
| 87 | func (oo *OpenOLT) deleteDeviceHandlerToMap(agent *DeviceHandler) {
|
cuilin2018 | 7b2a8c3 | 2019-03-26 19:52:28 -0700 | [diff] [blame] | 88 | oo.lockDeviceHandlersMap.Lock()
|
| 89 | defer oo.lockDeviceHandlersMap.Unlock()
|
| 90 | delete(oo.deviceHandlers, agent.deviceId)
|
Phaneendra Manda | 4c62c80 | 2019-03-06 21:37:49 +0530 | [diff] [blame] | 91 | }
|
| 92 |
|
| 93 | func (oo *OpenOLT) getDeviceHandler(deviceId string) *DeviceHandler {
|
cuilin2018 | 7b2a8c3 | 2019-03-26 19:52:28 -0700 | [diff] [blame] | 94 | oo.lockDeviceHandlersMap.Lock()
|
| 95 | defer oo.lockDeviceHandlersMap.Unlock()
|
| 96 | if agent, ok := oo.deviceHandlers[deviceId]; ok {
|
| 97 | return agent
|
| 98 | }
|
| 99 | return nil
|
Phaneendra Manda | 4c62c80 | 2019-03-06 21:37:49 +0530 | [diff] [blame] | 100 | }
|
| 101 |
|
| 102 | func (oo *OpenOLT) createDeviceTopic(device *voltha.Device) error {
|
cuilin2018 | 7b2a8c3 | 2019-03-26 19:52:28 -0700 | [diff] [blame] | 103 | log.Infow("create-device-topic", log.Fields{"deviceId": device.Id})
|
| 104 | deviceTopic := kafka.Topic{Name: oo.kafkaICProxy.DefaultTopic.Name + "_" + device.Id}
|
| 105 | // TODO for the offset
|
| 106 | if err := oo.kafkaICProxy.SubscribeWithDefaultRequestHandler(deviceTopic, 0); err != nil {
|
| 107 | log.Infow("create-device-topic-failed", log.Fields{"deviceId": device.Id, "error": err})
|
| 108 | return err
|
| 109 | }
|
| 110 | return nil
|
Phaneendra Manda | 4c62c80 | 2019-03-06 21:37:49 +0530 | [diff] [blame] | 111 | }
|
| 112 |
|
| 113 | func (oo *OpenOLT) Adopt_device(device *voltha.Device) error {
|
cuilin2018 | 7b2a8c3 | 2019-03-26 19:52:28 -0700 | [diff] [blame] | 114 | if device == nil {
|
| 115 | log.Warn("device-is-nil")
|
| 116 | return errors.New("nil-device")
|
| 117 | }
|
| 118 | log.Infow("adopt-device", log.Fields{"deviceId": device.Id})
|
| 119 | var handler *DeviceHandler
|
| 120 | if handler = oo.getDeviceHandler(device.Id); handler == nil {
|
| 121 | handler := NewDeviceHandler(oo.coreProxy, oo.adapterProxy, device, oo)
|
| 122 | oo.addDeviceHandlerToMap(handler)
|
| 123 | go handler.AdoptDevice(device)
|
| 124 | // Launch the creation of the device topic
|
| 125 | // go oo.createDeviceTopic(device)
|
| 126 | }
|
| 127 | return nil
|
Phaneendra Manda | 4c62c80 | 2019-03-06 21:37:49 +0530 | [diff] [blame] | 128 | }
|
| 129 |
|
| 130 | func (oo *OpenOLT) Get_ofp_device_info(device *voltha.Device) (*ic.SwitchCapability, error) {
|
cuilin2018 | 7b2a8c3 | 2019-03-26 19:52:28 -0700 | [diff] [blame] | 131 | log.Infow("Get_ofp_device_info", log.Fields{"deviceId": device.Id})
|
| 132 | if handler := oo.getDeviceHandler(device.Id); handler != nil {
|
| 133 | return handler.GetOfpDeviceInfo(device)
|
| 134 | }
|
| 135 | log.Errorw("device-handler-not-set", log.Fields{"deviceId": device.Id})
|
| 136 | return nil, errors.New("device-handler-not-set")
|
Phaneendra Manda | 4c62c80 | 2019-03-06 21:37:49 +0530 | [diff] [blame] | 137 | }
|
| 138 |
|
| 139 | func (oo *OpenOLT) Get_ofp_port_info(device *voltha.Device, port_no int64) (*ic.PortCapability, error) {
|
cuilin2018 | 7b2a8c3 | 2019-03-26 19:52:28 -0700 | [diff] [blame] | 140 | log.Infow("Get_ofp_port_info", log.Fields{"deviceId": device.Id})
|
| 141 | if handler := oo.getDeviceHandler(device.Id); handler != nil {
|
| 142 | return handler.GetOfpPortInfo(device, port_no)
|
| 143 | }
|
| 144 | log.Errorw("device-handler-not-set", log.Fields{"deviceId": device.Id})
|
| 145 | return nil, errors.New("device-handler-not-set")
|
Phaneendra Manda | 4c62c80 | 2019-03-06 21:37:49 +0530 | [diff] [blame] | 146 | }
|
| 147 |
|
| 148 | func (oo *OpenOLT) Process_inter_adapter_message(msg *ic.InterAdapterMessage) error {
|
cuilin2018 | 7b2a8c3 | 2019-03-26 19:52:28 -0700 | [diff] [blame] | 149 | log.Infow("Process_inter_adapter_message", log.Fields{"msgId": msg.Header.Id})
|
| 150 | targetDevice := msg.Header.ProxyDeviceId // Request?
|
| 151 | if targetDevice == "" && msg.Header.ToDeviceId != "" {
|
| 152 | // Typical response
|
| 153 | targetDevice = msg.Header.ToDeviceId
|
| 154 | }
|
| 155 | if handler := oo.getDeviceHandler(targetDevice); handler != nil {
|
| 156 | return handler.Process_inter_adapter_message(msg)
|
| 157 | }
|
| 158 | return errors.New(fmt.Sprintf("handler-not-found-%s", targetDevice))
|
Phaneendra Manda | 4c62c80 | 2019-03-06 21:37:49 +0530 | [diff] [blame] | 159 | }
|
| 160 |
|
| 161 | func (oo *OpenOLT) Adapter_descriptor() error {
|
| 162 | return errors.New("UnImplemented")
|
| 163 | }
|
| 164 |
|
| 165 | func (oo *OpenOLT) Device_types() (*voltha.DeviceTypes, error) {
|
| 166 | return nil, errors.New("UnImplemented")
|
| 167 | }
|
| 168 |
|
| 169 | func (oo *OpenOLT) Health() (*voltha.HealthStatus, error) {
|
| 170 | return nil, errors.New("UnImplemented")
|
| 171 | }
|
| 172 |
|
| 173 | func (oo *OpenOLT) Reconcile_device(device *voltha.Device) error {
|
| 174 | return errors.New("UnImplemented")
|
| 175 | }
|
| 176 |
|
| 177 | func (oo *OpenOLT) Abandon_device(device *voltha.Device) error {
|
| 178 | return errors.New("UnImplemented")
|
| 179 | }
|
| 180 |
|
| 181 | func (oo *OpenOLT) Disable_device(device *voltha.Device) error {
|
| 182 | return errors.New("UnImplemented")
|
| 183 | }
|
| 184 |
|
| 185 | func (oo *OpenOLT) Reenable_device(device *voltha.Device) error {
|
| 186 | return errors.New("UnImplemented")
|
| 187 | }
|
| 188 |
|
| 189 | func (oo *OpenOLT) Reboot_device(device *voltha.Device) error {
|
| 190 | return errors.New("UnImplemented")
|
| 191 | }
|
| 192 |
|
| 193 | func (oo *OpenOLT) Self_test_device(device *voltha.Device) error {
|
| 194 | return errors.New("UnImplemented")
|
| 195 | }
|
| 196 |
|
| 197 | func (oo *OpenOLT) Gelete_device(device *voltha.Device) error {
|
| 198 | return errors.New("UnImplemented")
|
| 199 | }
|
| 200 |
|
| 201 | func (oo *OpenOLT) Get_device_details(device *voltha.Device) error {
|
| 202 | return errors.New("UnImplemented")
|
| 203 | }
|
| 204 |
|
| 205 | func (oo *OpenOLT) Update_flows_bulk(device *voltha.Device, flows *voltha.Flows, groups *voltha.FlowGroups) error {
|
| 206 | return errors.New("UnImplemented")
|
| 207 | }
|
| 208 |
|
| 209 | func (oo *OpenOLT) Update_flows_incrementally(device *voltha.Device, flows *openflow_13.FlowChanges, groups *openflow_13.FlowGroupChanges) error {
|
| 210 | return errors.New("UnImplemented")
|
| 211 | }
|
| 212 |
|
| 213 | func (oo *OpenOLT) Update_pm_config(device *voltha.Device, pm_configs *voltha.PmConfigs) error {
|
| 214 | return errors.New("UnImplemented")
|
| 215 | }
|
| 216 |
|
| 217 | func (oo *OpenOLT) Receive_packet_out(device *voltha.Device, egress_port_no int, msg openflow_13.PacketOut) error {
|
| 218 | return errors.New("UnImplemented")
|
| 219 | }
|
| 220 |
|
| 221 | func (oo *OpenOLT) Suppress_alarm(filter *voltha.AlarmFilter) error {
|
| 222 | return errors.New("UnImplemented")
|
| 223 | }
|
| 224 |
|
| 225 | func (oo *OpenOLT) Unsuppress_alarm(filter *voltha.AlarmFilter) error {
|
| 226 | return errors.New("UnImplemented")
|
| 227 | }
|
| 228 |
|
| 229 | func (oo *OpenOLT) Download_image(device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
|
| 230 | return nil, errors.New("UnImplemented")
|
| 231 | }
|
| 232 |
|
| 233 | func (oo *OpenOLT) Get_image_download_status(device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
|
| 234 | return nil, errors.New("UnImplemented")
|
| 235 | }
|
| 236 |
|
| 237 | func (oo *OpenOLT) Cancel_image_download(device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
|
| 238 | return nil, errors.New("UnImplemented")
|
| 239 | }
|
| 240 |
|
| 241 | func (oo *OpenOLT) Activate_image_update(device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
|
| 242 | return nil, errors.New("UnImplemented")
|
| 243 | }
|
| 244 |
|
| 245 | func (oo *OpenOLT) Revert_image_update(device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
|
| 246 | return nil, errors.New("UnImplemented")
|
| 247 | }
|