blob: ac4a5e2febd5d13e6d73c96b26fc17816ae01e00 [file] [log] [blame]
khenaidoob9203542018-09-17 22:56:37 -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 */
16package core
17
18import (
19 "context"
20 "errors"
Scott Baker807addd2019-10-24 15:16:21 -070021 "github.com/opencord/voltha-lib-go/v2/pkg/db/model"
22 "github.com/opencord/voltha-lib-go/v2/pkg/kafka"
23 "github.com/opencord/voltha-lib-go/v2/pkg/log"
24 "github.com/opencord/voltha-lib-go/v2/pkg/probe"
William Kurkiandaa6bb22019-03-07 12:26:28 -050025 "github.com/opencord/voltha-protos/go/openflow_13"
26 "github.com/opencord/voltha-protos/go/voltha"
khenaidoob9203542018-09-17 22:56:37 -040027 "google.golang.org/grpc/codes"
28 "google.golang.org/grpc/status"
khenaidoob9203542018-09-17 22:56:37 -040029 "strings"
30 "sync"
31)
32
33type LogicalDeviceManager struct {
khenaidoo4c9e5592019-09-09 16:20:41 -040034 logicalDeviceAgents sync.Map
35 core *Core
36 deviceMgr *DeviceManager
37 grpcNbiHdlr *APIHandler
38 adapterProxy *AdapterProxy
39 kafkaICProxy *kafka.InterContainerProxy
40 clusterDataProxy *model.Proxy
41 exitChannel chan int
42 defaultTimeout int64
43 logicalDevicesLoadingLock sync.RWMutex
44 logicalDeviceLoadingInProgress map[string][]chan int
khenaidoob9203542018-09-17 22:56:37 -040045}
46
khenaidoo2c6a0992019-04-29 13:46:56 -040047func newLogicalDeviceManager(core *Core, deviceMgr *DeviceManager, kafkaICProxy *kafka.InterContainerProxy, cdProxy *model.Proxy, timeout int64) *LogicalDeviceManager {
khenaidoob9203542018-09-17 22:56:37 -040048 var logicalDeviceMgr LogicalDeviceManager
Richard Jankowski199fd862019-03-18 14:49:51 -040049 logicalDeviceMgr.core = core
khenaidoob9203542018-09-17 22:56:37 -040050 logicalDeviceMgr.exitChannel = make(chan int, 1)
khenaidoob9203542018-09-17 22:56:37 -040051 logicalDeviceMgr.deviceMgr = deviceMgr
khenaidoo43c82122018-11-22 18:38:28 -050052 logicalDeviceMgr.kafkaICProxy = kafkaICProxy
khenaidoo9a468962018-09-19 15:33:13 -040053 logicalDeviceMgr.clusterDataProxy = cdProxy
khenaidoo2c6a0992019-04-29 13:46:56 -040054 logicalDeviceMgr.defaultTimeout = timeout
khenaidoo4c9e5592019-09-09 16:20:41 -040055 logicalDeviceMgr.logicalDevicesLoadingLock = sync.RWMutex{}
56 logicalDeviceMgr.logicalDeviceLoadingInProgress = make(map[string][]chan int)
khenaidoob9203542018-09-17 22:56:37 -040057 return &logicalDeviceMgr
58}
59
Richard Jankowskidbab94a2018-12-06 16:20:25 -050060func (ldMgr *LogicalDeviceManager) setGrpcNbiHandler(grpcNbiHandler *APIHandler) {
61 ldMgr.grpcNbiHdlr = grpcNbiHandler
62}
63
khenaidoo4d4802d2018-10-04 21:59:49 -040064func (ldMgr *LogicalDeviceManager) start(ctx context.Context) {
khenaidoob9203542018-09-17 22:56:37 -040065 log.Info("starting-logical-device-manager")
David K. Bainbridgeb4a9ab02019-09-20 15:12:16 -070066 probe.UpdateStatusFromContext(ctx, "logical-device-manager", probe.ServiceStatusRunning)
khenaidoob9203542018-09-17 22:56:37 -040067 log.Info("logical-device-manager-started")
68}
69
khenaidoo4d4802d2018-10-04 21:59:49 -040070func (ldMgr *LogicalDeviceManager) stop(ctx context.Context) {
khenaidoob9203542018-09-17 22:56:37 -040071 log.Info("stopping-logical-device-manager")
72 ldMgr.exitChannel <- 1
David K. Bainbridgeb4a9ab02019-09-20 15:12:16 -070073 probe.UpdateStatusFromContext(ctx, "logical-device-manager", probe.ServiceStatusStopped)
khenaidoob9203542018-09-17 22:56:37 -040074 log.Info("logical-device-manager-stopped")
75}
76
khenaidoo19d7b632018-10-30 10:49:50 -040077func sendAPIResponse(ctx context.Context, ch chan interface{}, result interface{}) {
78 if ctx.Err() == nil {
79 // Returned response only of the ctx has not been cancelled/timeout/etc
80 // Channel is automatically closed when a context is Done
81 ch <- result
82 log.Debugw("sendResponse", log.Fields{"result": result})
83 } else {
84 // Should the transaction be reverted back?
85 log.Debugw("sendResponse-context-error", log.Fields{"context-error": ctx.Err()})
86 }
87}
88
khenaidoob9203542018-09-17 22:56:37 -040089func (ldMgr *LogicalDeviceManager) addLogicalDeviceAgentToMap(agent *LogicalDeviceAgent) {
Stephane Barbarieef6650d2019-07-18 12:15:09 -040090 if _, exist := ldMgr.logicalDeviceAgents.Load(agent.logicalDeviceId); !exist {
91 ldMgr.logicalDeviceAgents.Store(agent.logicalDeviceId, agent)
khenaidoob9203542018-09-17 22:56:37 -040092 }
93}
94
khenaidoo6d62c002019-05-15 21:57:03 -040095func (ldMgr *LogicalDeviceManager) isLogicalDeviceInCache(logicalDeviceId string) bool {
Stephane Barbarieef6650d2019-07-18 12:15:09 -040096 _, inCache := ldMgr.logicalDeviceAgents.Load(logicalDeviceId)
khenaidoo6d62c002019-05-15 21:57:03 -040097 return inCache
98}
99
khenaidoo8c3303d2019-02-13 14:59:39 -0500100// getLogicalDeviceAgent returns the logical device agent. If the device is not in memory then the device will
101// be loaded from dB and a logical device agent created to managed it.
khenaidoob9203542018-09-17 22:56:37 -0400102func (ldMgr *LogicalDeviceManager) getLogicalDeviceAgent(logicalDeviceId string) *LogicalDeviceAgent {
Stephane Barbarieef6650d2019-07-18 12:15:09 -0400103 if agent, ok := ldMgr.logicalDeviceAgents.Load(logicalDeviceId); ok {
104 return agent.(*LogicalDeviceAgent)
khenaidoo8c3303d2019-02-13 14:59:39 -0500105 } else {
106 // Try to load into memory - loading will also create the logical device agent
khenaidoo8c3303d2019-02-13 14:59:39 -0500107 if err := ldMgr.load(logicalDeviceId); err == nil {
Stephane Barbarieef6650d2019-07-18 12:15:09 -0400108 if agent, ok = ldMgr.logicalDeviceAgents.Load(logicalDeviceId); ok {
109 return agent.(*LogicalDeviceAgent)
khenaidoo8c3303d2019-02-13 14:59:39 -0500110 }
111 }
khenaidoob9203542018-09-17 22:56:37 -0400112 }
113 return nil
114}
115
khenaidoo92e62c52018-10-03 14:02:54 -0400116func (ldMgr *LogicalDeviceManager) deleteLogicalDeviceAgent(logicalDeviceId string) {
Stephane Barbarieef6650d2019-07-18 12:15:09 -0400117 ldMgr.logicalDeviceAgents.Delete(logicalDeviceId)
khenaidoo92e62c52018-10-03 14:02:54 -0400118}
119
khenaidoo8c3303d2019-02-13 14:59:39 -0500120// GetLogicalDevice provides a cloned most up to date logical device. If device is not in memory
121// it will be fetched from the dB
khenaidoob9203542018-09-17 22:56:37 -0400122func (ldMgr *LogicalDeviceManager) getLogicalDevice(id string) (*voltha.LogicalDevice, error) {
khenaidoo92e62c52018-10-03 14:02:54 -0400123 log.Debugw("getlogicalDevice", log.Fields{"logicaldeviceid": id})
124 if agent := ldMgr.getLogicalDeviceAgent(id); agent != nil {
khenaidoo19d7b632018-10-30 10:49:50 -0400125 return agent.GetLogicalDevice()
khenaidoob9203542018-09-17 22:56:37 -0400126 }
127 return nil, status.Errorf(codes.NotFound, "%s", id)
128}
129
khenaidoo43aa6bd2019-05-29 13:35:13 -0400130func (ldMgr *LogicalDeviceManager) listManagedLogicalDevices() (*voltha.LogicalDevices, error) {
131 log.Debug("listManagedLogicalDevices")
132 result := &voltha.LogicalDevices{}
Stephane Barbarieef6650d2019-07-18 12:15:09 -0400133 ldMgr.logicalDeviceAgents.Range(func(key, value interface{}) bool {
134 agent := value.(*LogicalDeviceAgent)
khenaidoo43aa6bd2019-05-29 13:35:13 -0400135 if ld, _ := agent.GetLogicalDevice(); ld != nil {
136 result.Items = append(result.Items, ld)
137 }
Stephane Barbarieef6650d2019-07-18 12:15:09 -0400138 return true
139 })
140
khenaidoo43aa6bd2019-05-29 13:35:13 -0400141 return result, nil
142}
143
khenaidooba6b6c42019-08-02 09:11:56 -0400144//listLogicalDevices returns the list of all logical devices
khenaidoob9203542018-09-17 22:56:37 -0400145func (ldMgr *LogicalDeviceManager) listLogicalDevices() (*voltha.LogicalDevices, error) {
Stephane Barbarie1ab43272018-12-08 21:42:13 -0500146 log.Debug("ListAllLogicalDevices")
khenaidoob9203542018-09-17 22:56:37 -0400147 result := &voltha.LogicalDevices{}
Stephane Barbarieef6650d2019-07-18 12:15:09 -0400148 if logicalDevices := ldMgr.clusterDataProxy.List(context.Background(), "/logical_devices", 0, false, ""); logicalDevices != nil {
Stephane Barbarie1ab43272018-12-08 21:42:13 -0500149 for _, logicalDevice := range logicalDevices.([]interface{}) {
Stephane Barbarie1ab43272018-12-08 21:42:13 -0500150 result.Items = append(result.Items, logicalDevice.(*voltha.LogicalDevice))
khenaidoob9203542018-09-17 22:56:37 -0400151 }
152 }
153 return result, nil
154}
155
khenaidoo4d4802d2018-10-04 21:59:49 -0400156func (ldMgr *LogicalDeviceManager) createLogicalDevice(ctx context.Context, device *voltha.Device) (*string, error) {
khenaidoo92e62c52018-10-03 14:02:54 -0400157 log.Debugw("creating-logical-device", log.Fields{"deviceId": device.Id})
khenaidoob9203542018-09-17 22:56:37 -0400158 // Sanity check
159 if !device.Root {
khenaidoo2c6a0992019-04-29 13:46:56 -0400160 return nil, errors.New("device-not-root")
khenaidoob9203542018-09-17 22:56:37 -0400161 }
162
163 // Create a logical device agent - the logical device Id is based on the mac address of the device
164 // For now use the serial number - it may contain any combination of alphabetic characters and numbers,
165 // with length varying from eight characters to a maximum of 14 characters. Mac Address is part of oneof
166 // in the Device model. May need to be moved out.
167 macAddress := device.MacAddress
168 id := strings.Replace(macAddress, ":", "", -1)
khenaidoo92e62c52018-10-03 14:02:54 -0400169 if id == "" {
170 log.Errorw("mac-address-not-set", log.Fields{"deviceId": device.Id})
171 return nil, errors.New("mac-address-not-set")
172 }
173 log.Debugw("logical-device-id", log.Fields{"logicaldeviceId": id})
khenaidoob9203542018-09-17 22:56:37 -0400174
khenaidoo2c6a0992019-04-29 13:46:56 -0400175 agent := newLogicalDeviceAgent(id, device.Id, ldMgr, ldMgr.deviceMgr, ldMgr.clusterDataProxy, ldMgr.defaultTimeout)
khenaidoob9203542018-09-17 22:56:37 -0400176 ldMgr.addLogicalDeviceAgentToMap(agent)
khenaidooad06fd72019-10-28 12:26:05 -0400177
178 // Update the root device with the logical device Id reference
179 if err := ldMgr.deviceMgr.setParentId(device, id); err != nil {
180 log.Errorw("failed-setting-parent-id", log.Fields{"logicalDeviceId": id, "deviceId": device.Id})
181 return nil, err
182 }
183
khenaidoo297cd252019-02-07 22:10:23 -0500184 go agent.start(ctx, false)
khenaidoob9203542018-09-17 22:56:37 -0400185
khenaidoo92e62c52018-10-03 14:02:54 -0400186 log.Debug("creating-logical-device-ends")
khenaidoob9203542018-09-17 22:56:37 -0400187 return &id, nil
188}
189
khenaidoo6d62c002019-05-15 21:57:03 -0400190// stopManagingLogicalDeviceWithDeviceId stops the management of the logical device. This implies removal of any
191// reference of this logical device in cache. The device Id is passed as param because the logical device may already
192// have been removed from the model. This function returns the logical device Id if found
193func (ldMgr *LogicalDeviceManager) stopManagingLogicalDeviceWithDeviceId(id string) string {
194 log.Infow("stop-managing-logical-device", log.Fields{"deviceId": id})
195 // Go over the list of logical device agents to find the one which has rootDeviceId as id
Stephane Barbarieef6650d2019-07-18 12:15:09 -0400196 var ldId = ""
197 ldMgr.logicalDeviceAgents.Range(func(key, value interface{}) bool {
198 ldAgent := value.(*LogicalDeviceAgent)
khenaidoo6d62c002019-05-15 21:57:03 -0400199 if ldAgent.rootDeviceId == id {
Stephane Barbarieef6650d2019-07-18 12:15:09 -0400200 log.Infow("stopping-logical-device-agent", log.Fields{"lDeviceId": key})
khenaidoo6d62c002019-05-15 21:57:03 -0400201 ldAgent.stop(nil)
Stephane Barbarieef6650d2019-07-18 12:15:09 -0400202 ldId = key.(string)
Stephane Barbarieeb336052019-10-24 15:40:59 -0400203 ldMgr.logicalDeviceAgents.Delete(ldId)
khenaidoo6d62c002019-05-15 21:57:03 -0400204 }
Stephane Barbarieef6650d2019-07-18 12:15:09 -0400205 return true
206 })
207 return ldId
khenaidoo6d62c002019-05-15 21:57:03 -0400208}
209
210//getLogicalDeviceFromModel retrieves the logical device data from the model.
211func (ldMgr *LogicalDeviceManager) getLogicalDeviceFromModel(lDeviceId string) (*voltha.LogicalDevice, error) {
Stephane Barbarieef6650d2019-07-18 12:15:09 -0400212 if logicalDevice := ldMgr.clusterDataProxy.Get(context.Background(), "/logical_devices/"+lDeviceId, 0, false, ""); logicalDevice != nil {
khenaidoo6d62c002019-05-15 21:57:03 -0400213 if lDevice, ok := logicalDevice.(*voltha.LogicalDevice); ok {
214 return lDevice, nil
215 }
216 }
217 return nil, status.Error(codes.NotFound, lDeviceId)
218}
219
khenaidoo297cd252019-02-07 22:10:23 -0500220// load loads a logical device manager in memory
221func (ldMgr *LogicalDeviceManager) load(lDeviceId string) error {
khenaidoo4c9e5592019-09-09 16:20:41 -0400222 if lDeviceId == "" {
223 return nil
khenaidoo297cd252019-02-07 22:10:23 -0500224 }
khenaidoo4c9e5592019-09-09 16:20:41 -0400225 // Add a lock to prevent two concurrent calls from loading the same device twice
226 ldMgr.logicalDevicesLoadingLock.Lock()
227 if _, exist := ldMgr.logicalDeviceLoadingInProgress[lDeviceId]; !exist {
228 if ldAgent, _ := ldMgr.logicalDeviceAgents.Load(lDeviceId); ldAgent == nil {
229 ldMgr.logicalDeviceLoadingInProgress[lDeviceId] = []chan int{make(chan int, 1)}
230 ldMgr.logicalDevicesLoadingLock.Unlock()
231 if _, err := ldMgr.getLogicalDeviceFromModel(lDeviceId); err == nil {
232 log.Debugw("loading-logical-device", log.Fields{"lDeviceId": lDeviceId})
233 agent := newLogicalDeviceAgent(lDeviceId, "", ldMgr, ldMgr.deviceMgr, ldMgr.clusterDataProxy, ldMgr.defaultTimeout)
234 if err := agent.start(nil, true); err != nil {
235 agent.stop(nil)
236 } else {
237 ldMgr.logicalDeviceAgents.Store(agent.logicalDeviceId, agent)
238 }
239 } else {
240 log.Debugw("logicalDevice not in model", log.Fields{"lDeviceId": lDeviceId})
241 }
242 // announce completion of task to any number of waiting channels
243 ldMgr.logicalDevicesLoadingLock.Lock()
244 if v, ok := ldMgr.logicalDeviceLoadingInProgress[lDeviceId]; ok {
245 for _, ch := range v {
246 close(ch)
247 }
248 delete(ldMgr.logicalDeviceLoadingInProgress, lDeviceId)
249 }
250 ldMgr.logicalDevicesLoadingLock.Unlock()
251 } else {
252 ldMgr.logicalDevicesLoadingLock.Unlock()
253 }
254 } else {
255 ch := make(chan int, 1)
256 ldMgr.logicalDeviceLoadingInProgress[lDeviceId] = append(ldMgr.logicalDeviceLoadingInProgress[lDeviceId], ch)
257 ldMgr.logicalDevicesLoadingLock.Unlock()
258 // Wait for the channel to be closed, implying the process loading this device is done.
259 <-ch
260 }
261 if _, exist := ldMgr.logicalDeviceAgents.Load(lDeviceId); exist {
262 return nil
263 }
264 return status.Errorf(codes.Aborted, "Error loading logical device %s", lDeviceId)
khenaidoo297cd252019-02-07 22:10:23 -0500265}
266
khenaidoo4d4802d2018-10-04 21:59:49 -0400267func (ldMgr *LogicalDeviceManager) deleteLogicalDevice(ctx context.Context, device *voltha.Device) error {
khenaidoo92e62c52018-10-03 14:02:54 -0400268 log.Debugw("deleting-logical-device", log.Fields{"deviceId": device.Id})
269 // Sanity check
270 if !device.Root {
khenaidoo2c6a0992019-04-29 13:46:56 -0400271 return errors.New("device-not-root")
khenaidoo92e62c52018-10-03 14:02:54 -0400272 }
273 logDeviceId := device.ParentId
274 if agent := ldMgr.getLogicalDeviceAgent(logDeviceId); agent != nil {
275 // Stop the logical device agent
khenaidoo4d4802d2018-10-04 21:59:49 -0400276 agent.stop(ctx)
khenaidoo92e62c52018-10-03 14:02:54 -0400277 //Remove the logical device agent from the Map
278 ldMgr.deleteLogicalDeviceAgent(logDeviceId)
Richard Jankowski199fd862019-03-18 14:49:51 -0400279 ldMgr.core.deviceOwnership.AbandonDevice(logDeviceId)
khenaidoo92e62c52018-10-03 14:02:54 -0400280 }
281
282 log.Debug("deleting-logical-device-ends")
283 return nil
284}
285
286func (ldMgr *LogicalDeviceManager) getLogicalDeviceId(device *voltha.Device) (*string, error) {
287 // Device can either be a parent or a child device
288 if device.Root {
289 // Parent device. The ID of a parent device is the logical device ID
290 return &device.ParentId, nil
291 }
292 // Device is child device
293 // retrieve parent device using child device ID
294 if parentDevice := ldMgr.deviceMgr.getParentDevice(device); parentDevice != nil {
295 return &parentDevice.ParentId, nil
296 }
297 return nil, status.Errorf(codes.NotFound, "%s", device.Id)
298}
299
khenaidoo3ab34882019-05-02 21:33:30 -0400300func (ldMgr *LogicalDeviceManager) getLogicalDeviceIdFromDeviceId(deviceId string) (*string, error) {
301 // Get the device
302 var device *voltha.Device
303 var err error
304 if device, err = ldMgr.deviceMgr.GetDevice(deviceId); err != nil {
305 return nil, err
306 }
307 return ldMgr.getLogicalDeviceId(device)
308}
309
khenaidoo19d7b632018-10-30 10:49:50 -0400310func (ldMgr *LogicalDeviceManager) getLogicalPortId(device *voltha.Device) (*voltha.LogicalPortId, error) {
311 // Get the logical device where this device is attached
312 var lDeviceId *string
313 var err error
314 if lDeviceId, err = ldMgr.getLogicalDeviceId(device); err != nil {
315 return nil, err
316 }
317 var lDevice *voltha.LogicalDevice
318 if lDevice, err = ldMgr.getLogicalDevice(*lDeviceId); err != nil {
319 return nil, err
320 }
321 // Go over list of ports
322 for _, port := range lDevice.Ports {
323 if port.DeviceId == device.Id {
324 return &voltha.LogicalPortId{Id: *lDeviceId, PortId: port.Id}, nil
325 }
326 }
327 return nil, status.Errorf(codes.NotFound, "%s", device.Id)
328}
329
khenaidoodd237172019-05-27 16:37:17 -0400330func (ldMgr *LogicalDeviceManager) ListLogicalDeviceFlows(ctx context.Context, id string) (*openflow_13.Flows, error) {
331 log.Debugw("ListLogicalDeviceFlows", log.Fields{"logicaldeviceid": id})
332 if agent := ldMgr.getLogicalDeviceAgent(id); agent != nil {
333 return agent.ListLogicalDeviceFlows()
334 }
335 return nil, status.Errorf(codes.NotFound, "%s", id)
336}
337
338func (ldMgr *LogicalDeviceManager) ListLogicalDeviceFlowGroups(ctx context.Context, id string) (*openflow_13.FlowGroups, error) {
339 log.Debugw("ListLogicalDeviceFlowGroups", log.Fields{"logicaldeviceid": id})
340 if agent := ldMgr.getLogicalDeviceAgent(id); agent != nil {
341 return agent.ListLogicalDeviceFlowGroups()
342 }
343 return nil, status.Errorf(codes.NotFound, "%s", id)
344}
345
khenaidoo19d7b632018-10-30 10:49:50 -0400346func (ldMgr *LogicalDeviceManager) ListLogicalDevicePorts(ctx context.Context, id string) (*voltha.LogicalPorts, error) {
347 log.Debugw("ListLogicalDevicePorts", log.Fields{"logicaldeviceid": id})
348 if agent := ldMgr.getLogicalDeviceAgent(id); agent != nil {
349 return agent.ListLogicalDevicePorts()
350 }
351 return nil, status.Errorf(codes.NotFound, "%s", id)
khenaidoo19d7b632018-10-30 10:49:50 -0400352}
353
354func (ldMgr *LogicalDeviceManager) getLogicalPort(lPortId *voltha.LogicalPortId) (*voltha.LogicalPort, error) {
355 // Get the logical device where this device is attached
356 var err error
357 var lDevice *voltha.LogicalDevice
358 if lDevice, err = ldMgr.getLogicalDevice(lPortId.Id); err != nil {
359 return nil, err
360 }
361 // Go over list of ports
362 for _, port := range lDevice.Ports {
363 if port.Id == lPortId.PortId {
364 return port, nil
365 }
366 }
Kent Hagerman0ab4cb22019-04-24 13:13:35 -0400367 return nil, status.Errorf(codes.NotFound, "%s-%s", lPortId.Id, lPortId.PortId)
khenaidoo19d7b632018-10-30 10:49:50 -0400368}
369
khenaidoo2c6a0992019-04-29 13:46:56 -0400370// updateLogicalPort sets up a logical port on the logical device based on the device port
371// information, if needed
372func (ldMgr *LogicalDeviceManager) updateLogicalPort(device *voltha.Device, port *voltha.Port) error {
373 if ldID, err := ldMgr.getLogicalDeviceId(device); err != nil || *ldID == "" {
374 // This is not an error as the logical device may not have been created at this time. In such a case,
375 // the ports will be created when the logical device is ready.
376 return nil
377 } else {
378 if agent := ldMgr.getLogicalDeviceAgent(*ldID); agent != nil {
379 if err := agent.updateLogicalPort(device, port); err != nil {
380 return err
381 }
382 }
383 }
384 return nil
385}
386
khenaidoofc1314d2019-03-14 09:34:21 -0400387// addLogicalPort sets up a logical port on the logical device based on the device port
388// information.
389func (ldMgr *LogicalDeviceManager) addLogicalPort(device *voltha.Device, port *voltha.Port) error {
Stephane Barbarie40fd3b22019-04-23 21:50:47 -0400390 if ldID, err := ldMgr.getLogicalDeviceId(device); err != nil || *ldID == "" {
khenaidoofc1314d2019-03-14 09:34:21 -0400391 // This is not an error as the logical device may not have been created at this time. In such a case,
392 // the ports will be created when the logical device is ready.
393 return nil
394 } else {
395 if agent := ldMgr.getLogicalDeviceAgent(*ldID); agent != nil {
396 if err := agent.addLogicalPort(device, port); err != nil {
397 return err
398 }
399 }
400 }
401 return nil
402}
403
khenaidoo0a822f92019-05-08 15:15:57 -0400404// deleteLogicalPort removes the logical port associated with a device
khenaidoo19d7b632018-10-30 10:49:50 -0400405func (ldMgr *LogicalDeviceManager) deleteLogicalPort(ctx context.Context, lPortId *voltha.LogicalPortId) error {
406 log.Debugw("deleting-logical-port", log.Fields{"LDeviceId": lPortId.Id})
407 // Get logical port
408 var logicalPort *voltha.LogicalPort
409 var err error
410 if logicalPort, err = ldMgr.getLogicalPort(lPortId); err != nil {
411 log.Debugw("no-logical-device-port-present", log.Fields{"logicalPortId": lPortId.PortId})
412 return err
413 }
khenaidoo92e62c52018-10-03 14:02:54 -0400414 // Sanity check
khenaidoo19d7b632018-10-30 10:49:50 -0400415 if logicalPort.RootPort {
khenaidoo2c6a0992019-04-29 13:46:56 -0400416 return errors.New("device-root")
khenaidoo92e62c52018-10-03 14:02:54 -0400417 }
khenaidoo19d7b632018-10-30 10:49:50 -0400418 if agent := ldMgr.getLogicalDeviceAgent(lPortId.Id); agent != nil {
khenaidoo0a822f92019-05-08 15:15:57 -0400419 if err := agent.deleteLogicalPort(logicalPort); err != nil {
420 log.Warnw("deleting-logicalport-failed", log.Fields{"LDeviceId": lPortId.Id, "error": err})
421 }
khenaidoo92e62c52018-10-03 14:02:54 -0400422 }
423
424 log.Debug("deleting-logical-port-ends")
425 return nil
426}
427
khenaidoo0a822f92019-05-08 15:15:57 -0400428// deleteLogicalPort removes the logical port associated with a child device
429func (ldMgr *LogicalDeviceManager) deleteLogicalPorts(deviceId string) error {
430 log.Debugw("deleting-logical-ports", log.Fields{"deviceId": deviceId})
431 // Get logical port
432 if ldId, err := ldMgr.getLogicalDeviceIdFromDeviceId(deviceId); err != nil {
khenaidoo0a822f92019-05-08 15:15:57 -0400433 return err
434 } else {
435 if agent := ldMgr.getLogicalDeviceAgent(*ldId); agent != nil {
436 if err = agent.deleteLogicalPorts(deviceId); err != nil {
437 log.Warnw("deleteLogicalPorts-failed", log.Fields{"ldeviceId": *ldId})
438 return err
439 }
440 }
441 }
442 log.Debug("deleting-logical-port-ends")
443 return nil
444}
445
khenaidoofc1314d2019-03-14 09:34:21 -0400446func (ldMgr *LogicalDeviceManager) setupUNILogicalPorts(ctx context.Context, childDevice *voltha.Device) error {
Stephane Barbarieef6650d2019-07-18 12:15:09 -0400447 log.Debugw("setupUNILogicalPorts", log.Fields{"childDeviceId": childDevice.Id, "parentDeviceId": childDevice.ParentId, "current-data": childDevice})
khenaidoob9203542018-09-17 22:56:37 -0400448 // Sanity check
449 if childDevice.Root {
450 return errors.New("Device-root")
451 }
452
453 // Get the logical device id parent device
454 parentId := childDevice.ParentId
455 logDeviceId := ldMgr.deviceMgr.GetParentDeviceId(parentId)
456
khenaidoofc1314d2019-03-14 09:34:21 -0400457 log.Debugw("setupUNILogicalPorts", log.Fields{"logDeviceId": logDeviceId, "parentId": parentId})
khenaidoob9203542018-09-17 22:56:37 -0400458
khenaidoo4c9e5592019-09-09 16:20:41 -0400459 if parentId == "" || logDeviceId == "" {
khenaidoo2c6a0992019-04-29 13:46:56 -0400460 return errors.New("device-in-invalid-state")
khenaidoo5e677ae2019-02-28 17:26:29 -0500461 }
462
khenaidoo4c9e5592019-09-09 16:20:41 -0400463 if agent := ldMgr.getLogicalDeviceAgent(logDeviceId); agent != nil {
khenaidoofc1314d2019-03-14 09:34:21 -0400464 if err := agent.setupUNILogicalPorts(ctx, childDevice); err != nil {
khenaidoobcf205b2019-01-25 22:21:14 -0500465 return err
466 }
khenaidoob9203542018-09-17 22:56:37 -0400467 }
khenaidoo21d51152019-02-01 13:48:37 -0500468 return nil
khenaidoob9203542018-09-17 22:56:37 -0400469}
khenaidoo19d7b632018-10-30 10:49:50 -0400470
khenaidoo0a822f92019-05-08 15:15:57 -0400471func (ldMgr *LogicalDeviceManager) deleteAllLogicalPorts(device *voltha.Device) error {
472 log.Debugw("deleteAllLogicalPorts", log.Fields{"deviceId": device.Id})
473
474 var ldId *string
475 var err error
476 //Get the logical device Id for this device
477 if ldId, err = ldMgr.getLogicalDeviceId(device); err != nil {
478 log.Warnw("no-logical-device-found", log.Fields{"deviceId": device.Id, "error": err})
479 return err
480 }
481 if agent := ldMgr.getLogicalDeviceAgent(*ldId); agent != nil {
482 if err := agent.deleteAllLogicalPorts(device); err != nil {
483 return err
484 }
485 }
486 return nil
487}
488
khenaidoo3ab34882019-05-02 21:33:30 -0400489func (ldMgr *LogicalDeviceManager) updatePortsState(device *voltha.Device, state voltha.AdminState_AdminState) error {
Stephane Barbarieef6650d2019-07-18 12:15:09 -0400490 log.Debugw("updatePortsState", log.Fields{"deviceId": device.Id, "state": state, "current-data": device})
khenaidoo3ab34882019-05-02 21:33:30 -0400491
492 var ldId *string
493 var err error
494 //Get the logical device Id for this device
495 if ldId, err = ldMgr.getLogicalDeviceId(device); err != nil {
496 log.Warnw("no-logical-device-found", log.Fields{"deviceId": device.Id, "error": err})
497 return err
498 }
499 if agent := ldMgr.getLogicalDeviceAgent(*ldId); agent != nil {
500 if err := agent.updatePortsState(device, state); err != nil {
501 return err
502 }
503 }
504 return nil
505}
506
khenaidoo19d7b632018-10-30 10:49:50 -0400507func (ldMgr *LogicalDeviceManager) updateFlowTable(ctx context.Context, id string, flow *openflow_13.OfpFlowMod, ch chan interface{}) {
508 log.Debugw("updateFlowTable", log.Fields{"logicalDeviceId": id})
509 var res interface{}
510 if agent := ldMgr.getLogicalDeviceAgent(id); agent != nil {
511 res = agent.updateFlowTable(ctx, flow)
512 log.Debugw("updateFlowTable-result", log.Fields{"result": res})
513 } else {
514 res = status.Errorf(codes.NotFound, "%s", id)
515 }
516 sendAPIResponse(ctx, ch, res)
517}
518
Manikkaraj kb1a10922019-07-29 12:10:34 -0400519func (ldMgr *LogicalDeviceManager) updateMeterTable(ctx context.Context, id string, meter *openflow_13.OfpMeterMod, ch chan interface{}) {
520 log.Debugw("updateMeterTable", log.Fields{"logicalDeviceId": id})
521 var res interface{}
522 if agent := ldMgr.getLogicalDeviceAgent(id); agent != nil {
523 res = agent.updateMeterTable(ctx, meter)
524 log.Debugw("updateMeterTable-result", log.Fields{"result": res})
525 } else {
526 res = status.Errorf(codes.NotFound, "%s", id)
527 }
528 sendAPIResponse(ctx, ch, res)
529}
530
531func (ldMgr *LogicalDeviceManager) ListLogicalDeviceMeters(ctx context.Context, id string) (*openflow_13.Meters, error) {
532 log.Debugw("ListLogicalDeviceMeters", log.Fields{"logicalDeviceId": id})
533 if agent := ldMgr.getLogicalDeviceAgent(id); agent != nil {
534 return agent.ListLogicalDeviceMeters()
535 }
536 return nil, status.Errorf(codes.NotFound, "%s", id)
537}
khenaidoo19d7b632018-10-30 10:49:50 -0400538func (ldMgr *LogicalDeviceManager) updateGroupTable(ctx context.Context, id string, groupMod *openflow_13.OfpGroupMod, ch chan interface{}) {
539 log.Debugw("updateGroupTable", log.Fields{"logicalDeviceId": id})
540 var res interface{}
541 if agent := ldMgr.getLogicalDeviceAgent(id); agent != nil {
542 res = agent.updateGroupTable(ctx, groupMod)
543 log.Debugw("updateGroupTable-result", log.Fields{"result": res})
544 } else {
545 res = status.Errorf(codes.NotFound, "%s", id)
546 }
547 sendAPIResponse(ctx, ch, res)
548}
549
550func (ldMgr *LogicalDeviceManager) enableLogicalPort(ctx context.Context, id *voltha.LogicalPortId, ch chan interface{}) {
551 log.Debugw("enableLogicalPort", log.Fields{"logicalDeviceId": id})
552 var res interface{}
553 // Get logical port
554 var logicalPort *voltha.LogicalPort
555 var err error
556 if logicalPort, err = ldMgr.getLogicalPort(id); err != nil {
557 log.Debugw("no-logical-device-port-present", log.Fields{"logicalPortId": id.PortId})
558 res = err
559 }
560 if agent := ldMgr.getLogicalDeviceAgent(id.Id); agent != nil {
561 res = agent.enableLogicalPort(logicalPort)
562 log.Debugw("enableLogicalPort-result", log.Fields{"result": res})
563 } else {
564 res = status.Errorf(codes.NotFound, "%s", id.Id)
565 }
566 sendAPIResponse(ctx, ch, res)
567}
568
569func (ldMgr *LogicalDeviceManager) disableLogicalPort(ctx context.Context, id *voltha.LogicalPortId, ch chan interface{}) {
570 log.Debugw("disableLogicalPort", log.Fields{"logicalDeviceId": id})
571 var res interface{}
572 // Get logical port
573 var logicalPort *voltha.LogicalPort
574 var err error
575 if logicalPort, err = ldMgr.getLogicalPort(id); err != nil {
576 log.Debugw("no-logical-device-port-present", log.Fields{"logicalPortId": id.PortId})
577 res = err
578 }
579 if agent := ldMgr.getLogicalDeviceAgent(id.Id); agent != nil {
580 res = agent.disableLogicalPort(logicalPort)
581 log.Debugw("disableLogicalPort-result", log.Fields{"result": res})
582 } else {
583 res = status.Errorf(codes.NotFound, "%s", id.Id)
584 }
585 sendAPIResponse(ctx, ch, res)
586}
khenaidoofdbad6e2018-11-06 22:26:38 -0500587
khenaidoo43c82122018-11-22 18:38:28 -0500588func (ldMgr *LogicalDeviceManager) packetOut(packetOut *openflow_13.PacketOut) {
khenaidoofdbad6e2018-11-06 22:26:38 -0500589 log.Debugw("packetOut", log.Fields{"logicalDeviceId": packetOut.Id})
590 if agent := ldMgr.getLogicalDeviceAgent(packetOut.Id); agent != nil {
591 agent.packetOut(packetOut.PacketOut)
592 } else {
593 log.Error("logical-device-not-exist", log.Fields{"logicalDeviceId": packetOut.Id})
594 }
595}
596
khenaidoo297cd252019-02-07 22:10:23 -0500597func (ldMgr *LogicalDeviceManager) packetIn(logicalDeviceId string, port uint32, transactionId string, packet []byte) error {
khenaidoofdbad6e2018-11-06 22:26:38 -0500598 log.Debugw("packetIn", log.Fields{"logicalDeviceId": logicalDeviceId, "port": port})
599 if agent := ldMgr.getLogicalDeviceAgent(logicalDeviceId); agent != nil {
khenaidoo297cd252019-02-07 22:10:23 -0500600 agent.packetIn(port, transactionId, packet)
khenaidoofdbad6e2018-11-06 22:26:38 -0500601 } else {
602 log.Error("logical-device-not-exist", log.Fields{"logicalDeviceId": logicalDeviceId})
603 }
604 return nil
605}