blob: 7e35b04dfacdf406ea593ec119a4f2403cf962a2 [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"
khenaidoo19d7b632018-10-30 10:49:50 -040020 "errors"
21 "fmt"
khenaidoob9203542018-09-17 22:56:37 -040022 "github.com/gogo/protobuf/proto"
khenaidoo89b0e942018-10-21 21:11:33 -040023 fd "github.com/opencord/voltha-go/rw_core/flow_decomposition"
24 "github.com/opencord/voltha-go/rw_core/graph"
Scott Bakerb671a862019-10-24 10:53:40 -070025 coreutils "github.com/opencord/voltha-go/rw_core/utils"
Scott Baker807addd2019-10-24 15:16:21 -070026 "github.com/opencord/voltha-lib-go/v2/pkg/db/model"
27 fu "github.com/opencord/voltha-lib-go/v2/pkg/flows"
28 "github.com/opencord/voltha-lib-go/v2/pkg/log"
khenaidoo8f474192019-04-03 17:20:44 -040029 ic "github.com/opencord/voltha-protos/go/inter_container"
30 ofp "github.com/opencord/voltha-protos/go/openflow_13"
31 "github.com/opencord/voltha-protos/go/voltha"
khenaidoob9203542018-09-17 22:56:37 -040032 "google.golang.org/grpc/codes"
33 "google.golang.org/grpc/status"
khenaidoo19d7b632018-10-30 10:49:50 -040034 "reflect"
khenaidoo92e62c52018-10-03 14:02:54 -040035 "sync"
Stephane Barbarieef6650d2019-07-18 12:15:09 -040036 "time"
khenaidoob9203542018-09-17 22:56:37 -040037)
38
39type LogicalDeviceAgent struct {
khenaidoo3306c992019-05-24 16:57:35 -040040 logicalDeviceId string
41 rootDeviceId string
42 deviceMgr *DeviceManager
43 ldeviceMgr *LogicalDeviceManager
44 clusterDataProxy *model.Proxy
45 exitChannel chan int
46 deviceGraph *graph.DeviceGraph
47 flowProxy *model.Proxy
48 groupProxy *model.Proxy
Manikkaraj kb1a10922019-07-29 12:10:34 -040049 meterProxy *model.Proxy
khenaidoo3306c992019-05-24 16:57:35 -040050 ldProxy *model.Proxy
51 portProxies map[string]*model.Proxy
52 portProxiesLock sync.RWMutex
53 lockLogicalDevice sync.RWMutex
khenaidoo4c9e5592019-09-09 16:20:41 -040054 lockDeviceGraph sync.RWMutex
khenaidoo3306c992019-05-24 16:57:35 -040055 logicalPortsNo map[uint32]bool //value is true for NNI port
56 lockLogicalPortsNo sync.RWMutex
57 flowDecomposer *fd.FlowDecomposer
58 defaultTimeout int64
khenaidoob9203542018-09-17 22:56:37 -040059}
60
Stephane Barbarie1ab43272018-12-08 21:42:13 -050061func newLogicalDeviceAgent(id string, deviceId string, ldeviceMgr *LogicalDeviceManager,
62 deviceMgr *DeviceManager,
khenaidoo2c6a0992019-04-29 13:46:56 -040063 cdProxy *model.Proxy, timeout int64) *LogicalDeviceAgent {
khenaidoob9203542018-09-17 22:56:37 -040064 var agent LogicalDeviceAgent
65 agent.exitChannel = make(chan int, 1)
66 agent.logicalDeviceId = id
Stephane Barbarie1ab43272018-12-08 21:42:13 -050067 agent.rootDeviceId = deviceId
khenaidoob9203542018-09-17 22:56:37 -040068 agent.deviceMgr = deviceMgr
khenaidoo9a468962018-09-19 15:33:13 -040069 agent.clusterDataProxy = cdProxy
khenaidoob9203542018-09-17 22:56:37 -040070 agent.ldeviceMgr = ldeviceMgr
khenaidoo19d7b632018-10-30 10:49:50 -040071 agent.flowDecomposer = fd.NewFlowDecomposer(agent.deviceMgr)
khenaidoo92e62c52018-10-03 14:02:54 -040072 agent.lockLogicalDevice = sync.RWMutex{}
khenaidoofc1314d2019-03-14 09:34:21 -040073 agent.portProxies = make(map[string]*model.Proxy)
74 agent.portProxiesLock = sync.RWMutex{}
khenaidoo2c6a0992019-04-29 13:46:56 -040075 agent.lockLogicalPortsNo = sync.RWMutex{}
khenaidoo4c9e5592019-09-09 16:20:41 -040076 agent.lockDeviceGraph = sync.RWMutex{}
khenaidoo2c6a0992019-04-29 13:46:56 -040077 agent.logicalPortsNo = make(map[uint32]bool)
khenaidoo2c6a0992019-04-29 13:46:56 -040078 agent.defaultTimeout = timeout
khenaidoob9203542018-09-17 22:56:37 -040079 return &agent
80}
81
khenaidoo4d4802d2018-10-04 21:59:49 -040082// start creates the logical device and add it to the data model
khenaidoo297cd252019-02-07 22:10:23 -050083func (agent *LogicalDeviceAgent) start(ctx context.Context, loadFromdB bool) error {
84 log.Infow("starting-logical_device-agent", log.Fields{"logicaldeviceId": agent.logicalDeviceId, "loadFromdB": loadFromdB})
85 var ld *voltha.LogicalDevice
86 if !loadFromdB {
khenaidoo7e3d8f12019-08-02 16:06:30 -040087 //Build the logical device based on information retrieved from the device adapter
88 var switchCap *ic.SwitchCapability
khenaidoo297cd252019-02-07 22:10:23 -050089 var err error
khenaidoo7e3d8f12019-08-02 16:06:30 -040090 if switchCap, err = agent.deviceMgr.getSwitchCapability(ctx, agent.rootDeviceId); err != nil {
91 log.Errorw("error-creating-logical-device", log.Fields{"error": err})
92 return err
93 }
khenaidoo297cd252019-02-07 22:10:23 -050094 ld = &voltha.LogicalDevice{Id: agent.logicalDeviceId, RootDeviceId: agent.rootDeviceId}
95
96 // Create the datapath ID (uint64) using the logical device ID (based on the MAC Address)
97 var datapathID uint64
98 if datapathID, err = CreateDataPathId(agent.logicalDeviceId); err != nil {
99 log.Errorw("error-creating-datapath-id", log.Fields{"error": err})
100 return err
101 }
102 ld.DatapathId = datapathID
khenaidoo7e3d8f12019-08-02 16:06:30 -0400103 ld.Desc = (proto.Clone(switchCap.Desc)).(*ofp.OfpDesc)
104 log.Debugw("Switch-capability", log.Fields{"Desc": ld.Desc, "fromAd": switchCap.Desc})
105 ld.SwitchFeatures = (proto.Clone(switchCap.SwitchFeatures)).(*ofp.OfpSwitchFeatures)
khenaidoo297cd252019-02-07 22:10:23 -0500106 ld.Flows = &ofp.Flows{Items: nil}
107 ld.FlowGroups = &ofp.FlowGroups{Items: nil}
108
khenaidoo297cd252019-02-07 22:10:23 -0500109 agent.lockLogicalDevice.Lock()
khenaidoo297cd252019-02-07 22:10:23 -0500110 // Save the logical device
Stephane Barbarieef6650d2019-07-18 12:15:09 -0400111 if added := agent.clusterDataProxy.AddWithID(ctx, "/logical_devices", ld.Id, ld, ""); added == nil {
khenaidoo297cd252019-02-07 22:10:23 -0500112 log.Errorw("failed-to-add-logical-device", log.Fields{"logicaldeviceId": agent.logicalDeviceId})
113 } else {
114 log.Debugw("logicaldevice-created", log.Fields{"logicaldeviceId": agent.logicalDeviceId})
115 }
116 agent.lockLogicalDevice.Unlock()
khenaidoofc1314d2019-03-14 09:34:21 -0400117
khenaidoo3d3b8c22019-05-22 18:10:39 -0400118 // TODO: Set the logical ports in a separate call once the port update issue is fixed.
119 go agent.setupLogicalPorts(ctx)
120
khenaidoo297cd252019-02-07 22:10:23 -0500121 } else {
122 // load from dB - the logical may not exist at this time. On error, just return and the calling function
123 // will destroy this agent.
124 var err error
125 if ld, err = agent.GetLogicalDevice(); err != nil {
126 log.Warnw("failed-to-load-logical-device", log.Fields{"logicaldeviceId": agent.logicalDeviceId})
127 return err
128 }
khenaidoo3d3b8c22019-05-22 18:10:39 -0400129
khenaidoo8c3303d2019-02-13 14:59:39 -0500130 // Update the root device Id
131 agent.rootDeviceId = ld.RootDeviceId
khenaidoo3d3b8c22019-05-22 18:10:39 -0400132
133 // Setup the local list of logical ports
134 agent.addLogicalPortsToMap(ld.Ports)
135
khenaidoob9203542018-09-17 22:56:37 -0400136 }
khenaidoo92e62c52018-10-03 14:02:54 -0400137 agent.lockLogicalDevice.Lock()
khenaidoo3d3b8c22019-05-22 18:10:39 -0400138 defer agent.lockLogicalDevice.Unlock()
khenaidoofc1314d2019-03-14 09:34:21 -0400139
Stephane Barbarie40fd3b22019-04-23 21:50:47 -0400140 agent.flowProxy = agent.clusterDataProxy.CreateProxy(
Stephane Barbarieef6650d2019-07-18 12:15:09 -0400141 ctx,
khenaidoo19d7b632018-10-30 10:49:50 -0400142 fmt.Sprintf("/logical_devices/%s/flows", agent.logicalDeviceId),
143 false)
Manikkaraj kb1a10922019-07-29 12:10:34 -0400144 agent.meterProxy = agent.clusterDataProxy.CreateProxy(
145 ctx,
146 fmt.Sprintf("/logical_devices/%s/meters", agent.logicalDeviceId),
147 false)
Stephane Barbarie40fd3b22019-04-23 21:50:47 -0400148 agent.groupProxy = agent.clusterDataProxy.CreateProxy(
Stephane Barbarieef6650d2019-07-18 12:15:09 -0400149 ctx,
khenaidoo19d7b632018-10-30 10:49:50 -0400150 fmt.Sprintf("/logical_devices/%s/flow_groups", agent.logicalDeviceId),
151 false)
Stephane Barbarie40fd3b22019-04-23 21:50:47 -0400152 agent.ldProxy = agent.clusterDataProxy.CreateProxy(
Stephane Barbarieef6650d2019-07-18 12:15:09 -0400153 ctx,
khenaidoofc1314d2019-03-14 09:34:21 -0400154 fmt.Sprintf("/logical_devices/%s", agent.logicalDeviceId),
155 false)
khenaidoo19d7b632018-10-30 10:49:50 -0400156
khenaidoofc1314d2019-03-14 09:34:21 -0400157 // TODO: Use a port proxy once the POST_ADD is fixed
khenaidoo3d3b8c22019-05-22 18:10:39 -0400158 if agent.ldProxy != nil {
159 agent.ldProxy.RegisterCallback(model.POST_UPDATE, agent.portUpdated)
160 } else {
161 log.Errorw("logical-device-proxy-null", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
162 return status.Error(codes.Internal, "logical-device-proxy-null")
163 }
khenaidoobcf205b2019-01-25 22:21:14 -0500164
khenaidoo4c9e5592019-09-09 16:20:41 -0400165 // Setup the device graph - run it in its own routine
166 if loadFromdB {
167 go agent.generateDeviceGraph()
168 }
khenaidoob9203542018-09-17 22:56:37 -0400169 return nil
170}
171
khenaidoo4d4802d2018-10-04 21:59:49 -0400172// stop stops the logical devuce agent. This removes the logical device from the data model.
173func (agent *LogicalDeviceAgent) stop(ctx context.Context) {
174 log.Info("stopping-logical_device-agent")
175 agent.lockLogicalDevice.Lock()
176 defer agent.lockLogicalDevice.Unlock()
khenaidoo8c3303d2019-02-13 14:59:39 -0500177
khenaidoo4d4802d2018-10-04 21:59:49 -0400178 //Remove the logical device from the model
Stephane Barbarieef6650d2019-07-18 12:15:09 -0400179 if removed := agent.clusterDataProxy.Remove(ctx, "/logical_devices/"+agent.logicalDeviceId, ""); removed == nil {
khenaidoo4d4802d2018-10-04 21:59:49 -0400180 log.Errorw("failed-to-remove-logical-device", log.Fields{"logicaldeviceId": agent.logicalDeviceId})
181 } else {
182 log.Debugw("logicaldevice-removed", log.Fields{"logicaldeviceId": agent.logicalDeviceId})
183 }
184 agent.exitChannel <- 1
185 log.Info("logical_device-agent-stopped")
186}
187
khenaidoo19d7b632018-10-30 10:49:50 -0400188// GetLogicalDevice locks the logical device model and then retrieves the latest logical device information
189func (agent *LogicalDeviceAgent) GetLogicalDevice() (*voltha.LogicalDevice, error) {
190 log.Debug("GetLogicalDevice")
khenaidoo1ce37ad2019-03-24 22:07:24 -0400191 agent.lockLogicalDevice.RLock()
192 defer agent.lockLogicalDevice.RUnlock()
Stephane Barbarieef6650d2019-07-18 12:15:09 -0400193 logicalDevice := agent.clusterDataProxy.Get(context.Background(), "/logical_devices/"+agent.logicalDeviceId, 0, false, "")
khenaidoo92e62c52018-10-03 14:02:54 -0400194 if lDevice, ok := logicalDevice.(*voltha.LogicalDevice); ok {
Stephane Barbarie1ab43272018-12-08 21:42:13 -0500195 return lDevice, nil
khenaidoo92e62c52018-10-03 14:02:54 -0400196 }
197 return nil, status.Errorf(codes.NotFound, "logical_device-%s", agent.logicalDeviceId)
198}
199
khenaidoodd237172019-05-27 16:37:17 -0400200func (agent *LogicalDeviceAgent) ListLogicalDeviceFlows() (*ofp.Flows, error) {
201 log.Debug("ListLogicalDeviceFlows")
202 agent.lockLogicalDevice.RLock()
203 defer agent.lockLogicalDevice.RUnlock()
Stephane Barbarieef6650d2019-07-18 12:15:09 -0400204 logicalDevice := agent.clusterDataProxy.Get(context.Background(), "/logical_devices/"+agent.logicalDeviceId, 0, false, "")
khenaidoodd237172019-05-27 16:37:17 -0400205 if lDevice, ok := logicalDevice.(*voltha.LogicalDevice); ok {
206 cFlows := (proto.Clone(lDevice.Flows)).(*ofp.Flows)
207 return cFlows, nil
208 }
209 return nil, status.Errorf(codes.NotFound, "logical_device-%s", agent.logicalDeviceId)
210}
211
Manikkaraj kb1a10922019-07-29 12:10:34 -0400212func (agent *LogicalDeviceAgent) ListLogicalDeviceMeters() (*ofp.Meters, error) {
213 log.Debug("ListLogicalDeviceMeters")
214 agent.lockLogicalDevice.RLock()
215 defer agent.lockLogicalDevice.RUnlock()
216 logicalDevice := agent.clusterDataProxy.Get(context.Background(), "/logical_devices/"+agent.logicalDeviceId, 0, false, "")
217 if lDevice, ok := logicalDevice.(*voltha.LogicalDevice); ok {
Gamze Abaka6e4ac162019-10-21 11:10:10 +0000218 if lDevice.Meters == nil {
219 return &ofp.Meters{}, nil
220 }
Manikkaraj kb1a10922019-07-29 12:10:34 -0400221 cMeters := (proto.Clone(lDevice.Meters)).(*ofp.Meters)
222 return cMeters, nil
223 }
224 return nil, status.Errorf(codes.NotFound, "logical_device-%s", agent.logicalDeviceId)
225}
226
khenaidoodd237172019-05-27 16:37:17 -0400227func (agent *LogicalDeviceAgent) ListLogicalDeviceFlowGroups() (*ofp.FlowGroups, error) {
228 log.Debug("ListLogicalDeviceFlowGroups")
229 agent.lockLogicalDevice.RLock()
230 defer agent.lockLogicalDevice.RUnlock()
Stephane Barbarieef6650d2019-07-18 12:15:09 -0400231 logicalDevice := agent.clusterDataProxy.Get(context.Background(), "/logical_devices/"+agent.logicalDeviceId, 0, false, "")
khenaidoodd237172019-05-27 16:37:17 -0400232 if lDevice, ok := logicalDevice.(*voltha.LogicalDevice); ok {
233 cFlowGroups := (proto.Clone(lDevice.FlowGroups)).(*ofp.FlowGroups)
234 return cFlowGroups, nil
235 }
236 return nil, status.Errorf(codes.NotFound, "logical_device-%s", agent.logicalDeviceId)
237}
238
khenaidoo19d7b632018-10-30 10:49:50 -0400239func (agent *LogicalDeviceAgent) ListLogicalDevicePorts() (*voltha.LogicalPorts, error) {
khenaidoo1ce37ad2019-03-24 22:07:24 -0400240 log.Debug("ListLogicalDevicePorts")
241 agent.lockLogicalDevice.RLock()
242 defer agent.lockLogicalDevice.RUnlock()
Stephane Barbarieef6650d2019-07-18 12:15:09 -0400243 logicalDevice := agent.clusterDataProxy.Get(context.Background(), "/logical_devices/"+agent.logicalDeviceId, 0, false, "")
khenaidoo19d7b632018-10-30 10:49:50 -0400244 if lDevice, ok := logicalDevice.(*voltha.LogicalDevice); ok {
245 lPorts := make([]*voltha.LogicalPort, 0)
246 for _, port := range lDevice.Ports {
Stephane Barbarie1ab43272018-12-08 21:42:13 -0500247 lPorts = append(lPorts, port)
khenaidoo19d7b632018-10-30 10:49:50 -0400248 }
249 return &voltha.LogicalPorts{Items: lPorts}, nil
250 }
251 return nil, status.Errorf(codes.NotFound, "logical_device-%s", agent.logicalDeviceId)
252}
253
254// listFlows locks the logical device model and then retrieves the latest flow information
255func (agent *LogicalDeviceAgent) listFlows() []*ofp.OfpFlowStats {
256 log.Debug("listFlows")
khenaidoo1ce37ad2019-03-24 22:07:24 -0400257 agent.lockLogicalDevice.RLock()
258 defer agent.lockLogicalDevice.RUnlock()
Stephane Barbarieef6650d2019-07-18 12:15:09 -0400259 logicalDevice := agent.clusterDataProxy.Get(context.Background(), "/logical_devices/"+agent.logicalDeviceId, 0, false, "")
khenaidoo19d7b632018-10-30 10:49:50 -0400260 if lDevice, ok := logicalDevice.(*voltha.LogicalDevice); ok {
261 return lDevice.Flows.Items
262 }
263 return nil
264}
265
266// listFlowGroups locks the logical device model and then retrieves the latest flow groups information
267func (agent *LogicalDeviceAgent) listFlowGroups() []*ofp.OfpGroupEntry {
268 log.Debug("listFlowGroups")
khenaidoo1ce37ad2019-03-24 22:07:24 -0400269 agent.lockLogicalDevice.RLock()
270 defer agent.lockLogicalDevice.RUnlock()
Stephane Barbarieef6650d2019-07-18 12:15:09 -0400271 logicalDevice := agent.clusterDataProxy.Get(context.Background(), "/logical_devices/"+agent.logicalDeviceId, 0, false, "")
khenaidoo19d7b632018-10-30 10:49:50 -0400272 if lDevice, ok := logicalDevice.(*voltha.LogicalDevice); ok {
273 return lDevice.FlowGroups.Items
274 }
275 return nil
276}
277
khenaidoo4c9e5592019-09-09 16:20:41 -0400278//updateLogicalDeviceFlowsWithoutLock updates the logical device with the latest flows in the model.
khenaidoo43c82122018-11-22 18:38:28 -0500279func (agent *LogicalDeviceAgent) updateLogicalDeviceFlowsWithoutLock(flows *ofp.Flows) error {
khenaidoo4c9e5592019-09-09 16:20:41 -0400280 ld, err := agent.getLogicalDeviceWithoutLock()
281 if err != nil {
282 return status.Errorf(codes.Internal, "logical-device-absent:%s", agent.logicalDeviceId)
283 }
284 log.Debugw("logical-device-before", log.Fields{"lports": len(ld.Ports)})
285 cloned := (proto.Clone(ld)).(*voltha.LogicalDevice)
286 cloned.Flows = flows
287
288 if err = agent.updateLogicalDeviceWithoutLock(cloned); err != nil {
289 log.Errorw("error-updating-logical-device-with-flows", log.Fields{"error": err})
290 return err
khenaidoo43c82122018-11-22 18:38:28 -0500291 }
khenaidoo43c82122018-11-22 18:38:28 -0500292 return nil
293}
294
khenaidoo4c9e5592019-09-09 16:20:41 -0400295//updateLogicalDeviceMetersWithoutLock updates the logical device with the meters info
Manikkaraj kb1a10922019-07-29 12:10:34 -0400296func (agent *LogicalDeviceAgent) updateLogicalDeviceMetersWithoutLock(meters *ofp.Meters) error {
khenaidoo4c9e5592019-09-09 16:20:41 -0400297 ld, err := agent.getLogicalDeviceWithoutLock()
298 if err != nil {
299 return status.Errorf(codes.Internal, "logical-device-absent:%s", agent.logicalDeviceId)
300 }
301 log.Debugw("logical-device-before", log.Fields{"lports": len(ld.Ports)})
302 cloned := (proto.Clone(ld)).(*voltha.LogicalDevice)
303 cloned.Meters = meters
304
305 if err = agent.updateLogicalDeviceWithoutLock(cloned); err != nil {
306 log.Errorw("error-updating-logical-device-with-meters", log.Fields{"error": err})
307 return err
Manikkaraj kb1a10922019-07-29 12:10:34 -0400308 }
309 return nil
310}
311
khenaidoo4c9e5592019-09-09 16:20:41 -0400312//updateLogicalDeviceFlowGroupsWithoutLock updates the logical device with the flow groups
khenaidoo43c82122018-11-22 18:38:28 -0500313func (agent *LogicalDeviceAgent) updateLogicalDeviceFlowGroupsWithoutLock(flowGroups *ofp.FlowGroups) error {
khenaidoo4c9e5592019-09-09 16:20:41 -0400314 ld, err := agent.getLogicalDeviceWithoutLock()
315 if err != nil {
316 return status.Errorf(codes.Internal, "logical-device-absent:%s", agent.logicalDeviceId)
317 }
318 log.Debugw("logical-device-before", log.Fields{"lports": len(ld.Ports)})
319 cloned := (proto.Clone(ld)).(*voltha.LogicalDevice)
320 cloned.FlowGroups = flowGroups
321
322 if err = agent.updateLogicalDeviceWithoutLock(cloned); err != nil {
323 log.Errorw("error-updating-logical-device-with-flowgroups", log.Fields{"error": err})
324 return err
khenaidoo43c82122018-11-22 18:38:28 -0500325 }
khenaidoo43c82122018-11-22 18:38:28 -0500326 return nil
327}
328
khenaidoo4d4802d2018-10-04 21:59:49 -0400329// getLogicalDeviceWithoutLock retrieves a logical device from the model without locking it. This is used only by
330// functions that have already acquired the logical device lock to the model
khenaidoo92e62c52018-10-03 14:02:54 -0400331func (agent *LogicalDeviceAgent) getLogicalDeviceWithoutLock() (*voltha.LogicalDevice, error) {
332 log.Debug("getLogicalDeviceWithoutLock")
Stephane Barbarieef6650d2019-07-18 12:15:09 -0400333 logicalDevice := agent.clusterDataProxy.Get(context.Background(), "/logical_devices/"+agent.logicalDeviceId, 0, false, "")
khenaidoo92e62c52018-10-03 14:02:54 -0400334 if lDevice, ok := logicalDevice.(*voltha.LogicalDevice); ok {
khenaidoo1ce37ad2019-03-24 22:07:24 -0400335 //log.Debug("getLogicalDeviceWithoutLock", log.Fields{"ldevice": lDevice})
Stephane Barbarie1ab43272018-12-08 21:42:13 -0500336 return lDevice, nil
khenaidoo92e62c52018-10-03 14:02:54 -0400337 }
338 return nil, status.Errorf(codes.NotFound, "logical_device-%s", agent.logicalDeviceId)
339}
340
khenaidoo2c6a0992019-04-29 13:46:56 -0400341func (agent *LogicalDeviceAgent) updateLogicalPort(device *voltha.Device, port *voltha.Port) error {
342 log.Debugw("updateLogicalPort", log.Fields{"deviceId": device.Id, "port": port})
343 var err error
344 if port.Type == voltha.Port_ETHERNET_NNI {
345 if _, err = agent.addNNILogicalPort(device, port); err != nil {
346 return err
347 }
348 agent.addLogicalPortToMap(port.PortNo, true)
349 } else if port.Type == voltha.Port_ETHERNET_UNI {
350 if _, err = agent.addUNILogicalPort(device, port); err != nil {
351 return err
352 }
353 agent.addLogicalPortToMap(port.PortNo, false)
354 } else {
355 // Update the device graph to ensure all routes on the logical device have been calculated
356 if err = agent.updateRoutes(device, port); err != nil {
357 log.Errorw("failed-to-update-routes", log.Fields{"deviceId": device.Id, "port": port, "error": err})
358 return err
359 }
360 }
361 return nil
362}
363
khenaidoo910204f2019-04-08 17:56:40 -0400364func (agent *LogicalDeviceAgent) addLogicalPort(device *voltha.Device, port *voltha.Port) error {
khenaidoo8f474192019-04-03 17:20:44 -0400365 log.Debugw("addLogicalPort", log.Fields{"deviceId": device.Id, "port": port})
khenaidoo8f474192019-04-03 17:20:44 -0400366 var err error
khenaidoofc1314d2019-03-14 09:34:21 -0400367 if port.Type == voltha.Port_ETHERNET_NNI {
khenaidoo910204f2019-04-08 17:56:40 -0400368 if _, err = agent.addNNILogicalPort(device, port); err != nil {
khenaidoofc1314d2019-03-14 09:34:21 -0400369 return err
370 }
khenaidoo2c6a0992019-04-29 13:46:56 -0400371 agent.addLogicalPortToMap(port.PortNo, true)
khenaidoofc1314d2019-03-14 09:34:21 -0400372 } else if port.Type == voltha.Port_ETHERNET_UNI {
khenaidoo910204f2019-04-08 17:56:40 -0400373 if _, err = agent.addUNILogicalPort(device, port); err != nil {
khenaidoofc1314d2019-03-14 09:34:21 -0400374 return err
375 }
khenaidoo2c6a0992019-04-29 13:46:56 -0400376 agent.addLogicalPortToMap(port.PortNo, false)
khenaidoofc1314d2019-03-14 09:34:21 -0400377 } else {
378 log.Debugw("invalid-port-type", log.Fields{"deviceId": device.Id, "port": port})
379 return nil
380 }
khenaidoofc1314d2019-03-14 09:34:21 -0400381 return nil
382}
383
khenaidoo3d3b8c22019-05-22 18:10:39 -0400384// setupLogicalPorts is invoked once the logical device has been created and is ready to get ports
385// added to it. While the logical device was being created we could have received requests to add
386// NNI and UNI ports which were discarded. Now is the time to add them if needed
387func (agent *LogicalDeviceAgent) setupLogicalPorts(ctx context.Context) error {
388 log.Infow("setupLogicalPorts", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
389 // First add any NNI ports which could have been missing
390 if err := agent.setupNNILogicalPorts(nil, agent.rootDeviceId); err != nil {
391 log.Errorw("error-setting-up-NNI-ports", log.Fields{"error": err, "deviceId": agent.rootDeviceId})
392 return err
393 }
394
395 // Now, set up the UNI ports if needed.
396 if children, err := agent.deviceMgr.getAllChildDevices(agent.rootDeviceId); err != nil {
397 log.Errorw("error-getting-child-devices", log.Fields{"error": err, "deviceId": agent.rootDeviceId})
398 return err
399 } else {
400 chnlsList := make([]chan interface{}, 0)
401 for _, child := range children.Items {
402 ch := make(chan interface{})
403 chnlsList = append(chnlsList, ch)
404 go func(device *voltha.Device, ch chan interface{}) {
405 if err = agent.setupUNILogicalPorts(nil, device); err != nil {
406 log.Error("setting-up-UNI-ports-failed", log.Fields{"deviceID": device.Id})
407 ch <- status.Errorf(codes.Internal, "UNI-ports-setup-failed: %s", device.Id)
408 }
409 ch <- nil
410 }(child, ch)
411 }
412 // Wait for completion
Scott Bakerb671a862019-10-24 10:53:40 -0700413 if res := coreutils.WaitForNilOrErrorResponses(agent.defaultTimeout, chnlsList...); res != nil {
khenaidoo3d3b8c22019-05-22 18:10:39 -0400414 return status.Errorf(codes.Aborted, "errors-%s", res)
415 }
416 }
417 return nil
418}
419
khenaidoofc1314d2019-03-14 09:34:21 -0400420// setupNNILogicalPorts creates an NNI port on the logical device that represents an NNI interface on a root device
421func (agent *LogicalDeviceAgent) setupNNILogicalPorts(ctx context.Context, deviceId string) error {
422 log.Infow("setupNNILogicalPorts-start", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
khenaidoob9203542018-09-17 22:56:37 -0400423 // Build the logical device based on information retrieved from the device adapter
khenaidoofc1314d2019-03-14 09:34:21 -0400424 var err error
425
426 var device *voltha.Device
427 if device, err = agent.deviceMgr.GetDevice(deviceId); err != nil {
khenaidoo2c6a0992019-04-29 13:46:56 -0400428 log.Errorw("error-retrieving-device", log.Fields{"error": err, "deviceId": deviceId})
khenaidoofc1314d2019-03-14 09:34:21 -0400429 return err
430 }
431
432 //Get UNI port number
khenaidoofc1314d2019-03-14 09:34:21 -0400433 for _, port := range device.Ports {
434 if port.Type == voltha.Port_ETHERNET_NNI {
khenaidoo910204f2019-04-08 17:56:40 -0400435 if _, err = agent.addNNILogicalPort(device, port); err != nil {
khenaidoofc1314d2019-03-14 09:34:21 -0400436 log.Errorw("error-adding-UNI-port", log.Fields{"error": err})
khenaidoofc1314d2019-03-14 09:34:21 -0400437 }
khenaidoo2c6a0992019-04-29 13:46:56 -0400438 agent.addLogicalPortToMap(port.PortNo, true)
khenaidoofc1314d2019-03-14 09:34:21 -0400439 }
440 }
khenaidoofc1314d2019-03-14 09:34:21 -0400441 return err
442}
443
khenaidoo3ab34882019-05-02 21:33:30 -0400444// updatePortsState updates the ports state related to the device
445func (agent *LogicalDeviceAgent) updatePortsState(device *voltha.Device, state voltha.AdminState_AdminState) error {
446 log.Infow("updatePortsState-start", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
447 agent.lockLogicalDevice.Lock()
448 defer agent.lockLogicalDevice.Unlock()
449 // Get the latest logical device info
450 if ld, err := agent.getLogicalDeviceWithoutLock(); err != nil {
451 log.Warnw("logical-device-unknown", log.Fields{"ldeviceId": agent.logicalDeviceId, "error": err})
452 return err
453 } else {
454 cloned := (proto.Clone(ld)).(*voltha.LogicalDevice)
455 for _, lport := range cloned.Ports {
456 if lport.DeviceId == device.Id {
457 switch state {
458 case voltha.AdminState_ENABLED:
459 lport.OfpPort.Config = lport.OfpPort.Config & ^uint32(ofp.OfpPortConfig_OFPPC_PORT_DOWN)
khenaidoo0a822f92019-05-08 15:15:57 -0400460 lport.OfpPort.State = uint32(ofp.OfpPortState_OFPPS_LIVE)
khenaidoo3ab34882019-05-02 21:33:30 -0400461 case voltha.AdminState_DISABLED:
462 lport.OfpPort.Config = lport.OfpPort.Config | uint32(ofp.OfpPortConfig_OFPPC_PORT_DOWN)
khenaidoo0a822f92019-05-08 15:15:57 -0400463 lport.OfpPort.State = uint32(ofp.OfpPortState_OFPPS_LINK_DOWN)
khenaidoo3ab34882019-05-02 21:33:30 -0400464 default:
465 log.Warnw("unsupported-state-change", log.Fields{"deviceId": device.Id, "state": state})
466 }
467 }
468 }
469 // Updating the logical device will trigger the poprt change events to be populated to the controller
470 if err := agent.updateLogicalDeviceWithoutLock(cloned); err != nil {
471 log.Warnw("logical-device-update-failed", log.Fields{"ldeviceId": agent.logicalDeviceId, "error": err})
472 return err
473 }
474 }
475 return nil
476}
477
khenaidoofc1314d2019-03-14 09:34:21 -0400478// setupUNILogicalPorts creates a UNI port on the logical device that represents a child UNI interface
479func (agent *LogicalDeviceAgent) setupUNILogicalPorts(ctx context.Context, childDevice *voltha.Device) error {
khenaidoo3d3b8c22019-05-22 18:10:39 -0400480 log.Infow("setupUNILogicalPort", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
khenaidoofc1314d2019-03-14 09:34:21 -0400481 // Build the logical device based on information retrieved from the device adapter
khenaidoob9203542018-09-17 22:56:37 -0400482 var err error
khenaidoo59ef7be2019-06-21 12:40:28 -0400483 var added bool
khenaidoo19d7b632018-10-30 10:49:50 -0400484 //Get UNI port number
khenaidoo19d7b632018-10-30 10:49:50 -0400485 for _, port := range childDevice.Ports {
486 if port.Type == voltha.Port_ETHERNET_UNI {
khenaidoo59ef7be2019-06-21 12:40:28 -0400487 if added, err = agent.addUNILogicalPort(childDevice, port); err != nil {
khenaidoofc1314d2019-03-14 09:34:21 -0400488 log.Errorw("error-adding-UNI-port", log.Fields{"error": err})
khenaidoofc1314d2019-03-14 09:34:21 -0400489 }
khenaidoo59ef7be2019-06-21 12:40:28 -0400490 if added {
491 agent.addLogicalPortToMap(port.PortNo, false)
492 }
khenaidoo19d7b632018-10-30 10:49:50 -0400493 }
494 }
khenaidoofc1314d2019-03-14 09:34:21 -0400495 return err
khenaidoo92e62c52018-10-03 14:02:54 -0400496}
497
khenaidoo0a822f92019-05-08 15:15:57 -0400498// deleteAllLogicalPorts deletes all logical ports associated with this device
499func (agent *LogicalDeviceAgent) deleteAllLogicalPorts(device *voltha.Device) error {
500 log.Infow("updatePortsState-start", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
501 agent.lockLogicalDevice.Lock()
502 defer agent.lockLogicalDevice.Unlock()
503 // Get the latest logical device info
504 if ld, err := agent.getLogicalDeviceWithoutLock(); err != nil {
505 log.Warnw("logical-device-unknown", log.Fields{"ldeviceId": agent.logicalDeviceId, "error": err})
506 return err
507 } else {
508 cloned := (proto.Clone(ld)).(*voltha.LogicalDevice)
509 updateLogicalPorts := []*voltha.LogicalPort{}
510 for _, lport := range cloned.Ports {
511 if lport.DeviceId != device.Id {
512 updateLogicalPorts = append(updateLogicalPorts, lport)
513 }
514 }
515 if len(updateLogicalPorts) < len(cloned.Ports) {
516 cloned.Ports = updateLogicalPorts
517 // Updating the logical device will trigger the poprt change events to be populated to the controller
518 if err := agent.updateLogicalDeviceWithoutLock(cloned); err != nil {
519 log.Warnw("logical-device-update-failed", log.Fields{"ldeviceId": agent.logicalDeviceId, "error": err})
520 return err
521 }
522 } else {
523 log.Debugw("no-change-required", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
524 }
525 }
526 return nil
527}
528
khenaidoo92e62c52018-10-03 14:02:54 -0400529//updateLogicalDeviceWithoutLock updates the model with the logical device. It clones the logicaldevice before saving it
530func (agent *LogicalDeviceAgent) updateLogicalDeviceWithoutLock(logicalDevice *voltha.LogicalDevice) error {
Stephane Barbarieef6650d2019-07-18 12:15:09 -0400531 updateCtx := context.WithValue(context.Background(), model.RequestTimestamp, time.Now().UnixNano())
532 afterUpdate := agent.clusterDataProxy.Update(updateCtx, "/logical_devices/"+agent.logicalDeviceId, logicalDevice, false, "")
khenaidoo92e62c52018-10-03 14:02:54 -0400533 if afterUpdate == nil {
534 return status.Errorf(codes.Internal, "failed-updating-logical-device:%s", agent.logicalDeviceId)
535 }
536 return nil
537}
538
khenaidoo4c9e5592019-09-09 16:20:41 -0400539//generateDeviceGraphIfNeeded generates the device graph if the logical device has been updated since the last time
540//that device graph was generated.
541func (agent *LogicalDeviceAgent) generateDeviceGraphIfNeeded() error {
542 if ld, err := agent.GetLogicalDevice(); err != nil {
543 log.Errorw("get-logical-device-error", log.Fields{"error": err})
544 return err
545 } else {
546 agent.lockDeviceGraph.Lock()
547 defer agent.lockDeviceGraph.Unlock()
548 if agent.deviceGraph != nil && agent.deviceGraph.IsUpToDate(ld) {
549 return nil
550 }
551 log.Debug("Generation of device graph required")
552 agent.generateDeviceGraph()
553 }
554 return nil
555}
556
khenaidoo19d7b632018-10-30 10:49:50 -0400557//updateFlowTable updates the flow table of that logical device
558func (agent *LogicalDeviceAgent) updateFlowTable(ctx context.Context, flow *ofp.OfpFlowMod) error {
559 log.Debug("updateFlowTable")
560 if flow == nil {
561 return nil
562 }
khenaidoo4c9e5592019-09-09 16:20:41 -0400563 if err := agent.generateDeviceGraphIfNeeded(); err != nil {
564 return err
565 }
khenaidoo19d7b632018-10-30 10:49:50 -0400566 switch flow.GetCommand() {
567 case ofp.OfpFlowModCommand_OFPFC_ADD:
568 return agent.flowAdd(flow)
569 case ofp.OfpFlowModCommand_OFPFC_DELETE:
570 return agent.flowDelete(flow)
571 case ofp.OfpFlowModCommand_OFPFC_DELETE_STRICT:
572 return agent.flowDeleteStrict(flow)
573 case ofp.OfpFlowModCommand_OFPFC_MODIFY:
574 return agent.flowModify(flow)
575 case ofp.OfpFlowModCommand_OFPFC_MODIFY_STRICT:
576 return agent.flowModifyStrict(flow)
577 }
578 return status.Errorf(codes.Internal,
579 "unhandled-command: lDeviceId:%s, command:%s", agent.logicalDeviceId, flow.GetCommand())
580}
581
582//updateGroupTable updates the group table of that logical device
583func (agent *LogicalDeviceAgent) updateGroupTable(ctx context.Context, groupMod *ofp.OfpGroupMod) error {
584 log.Debug("updateGroupTable")
585 if groupMod == nil {
586 return nil
587 }
khenaidoo4c9e5592019-09-09 16:20:41 -0400588 if err := agent.generateDeviceGraphIfNeeded(); err != nil {
589 return err
590 }
khenaidoo19d7b632018-10-30 10:49:50 -0400591 switch groupMod.GetCommand() {
592 case ofp.OfpGroupModCommand_OFPGC_ADD:
593 return agent.groupAdd(groupMod)
594 case ofp.OfpGroupModCommand_OFPGC_DELETE:
595 return agent.groupDelete(groupMod)
596 case ofp.OfpGroupModCommand_OFPGC_MODIFY:
597 return agent.groupModify(groupMod)
598 }
599 return status.Errorf(codes.Internal,
600 "unhandled-command: lDeviceId:%s, command:%s", agent.logicalDeviceId, groupMod.GetCommand())
601}
602
Manikkaraj kb1a10922019-07-29 12:10:34 -0400603// updateMeterTable updates the meter table of that logical device
604func (agent *LogicalDeviceAgent) updateMeterTable(ctx context.Context, meterMod *ofp.OfpMeterMod) error {
605 log.Debug("updateMeterTable")
606 if meterMod == nil {
607 return nil
608 }
khenaidoo4c9e5592019-09-09 16:20:41 -0400609 if err := agent.generateDeviceGraphIfNeeded(); err != nil {
610 return err
611 }
Manikkaraj kb1a10922019-07-29 12:10:34 -0400612 switch meterMod.GetCommand() {
613 case ofp.OfpMeterModCommand_OFPMC_ADD:
614 return agent.meterAdd(meterMod)
615 case ofp.OfpMeterModCommand_OFPMC_DELETE:
616 return agent.meterDelete(meterMod)
617 case ofp.OfpMeterModCommand_OFPMC_MODIFY:
618 return agent.meterModify(meterMod)
619 }
620 return status.Errorf(codes.Internal,
621 "unhandled-command: lDeviceId:%s, command:%s", agent.logicalDeviceId, meterMod.GetCommand())
622
623}
624
625func (agent *LogicalDeviceAgent) meterAdd(meterMod *ofp.OfpMeterMod) error {
626 log.Debugw("meterAdd", log.Fields{"metermod": *meterMod})
627 if meterMod == nil {
628 return nil
629 }
630 log.Debug("Waiting for logical device lock!!")
631 agent.lockLogicalDevice.Lock()
632 defer agent.lockLogicalDevice.Unlock()
633 log.Debug("Acquired logical device lock")
634 var lDevice *voltha.LogicalDevice
635 var err error
636 if lDevice, err = agent.getLogicalDeviceWithoutLock(); err != nil {
637 log.Errorw("no-logical-device-present", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
638 return errors.New(fmt.Sprintf("no-logical-device-present:%s", agent.logicalDeviceId))
639 }
640
641 var meters []*ofp.OfpMeterEntry
642 if lDevice.Meters != nil && lDevice.Meters.Items != nil {
643 meters = lDevice.Meters.Items
644 }
645 log.Debugw("Available meters", log.Fields{"meters": meters})
646
647 for _, meter := range meters {
648 if meterMod.MeterId == meter.Config.MeterId {
649 log.Infow("Meter-already-exists", log.Fields{"meter": *meterMod})
650 return nil
651 }
652 }
653
654 meterEntry := fu.MeterEntryFromMeterMod(meterMod)
655 meters = append(meters, meterEntry)
656 //Update model
657 if err := agent.updateLogicalDeviceMetersWithoutLock(&ofp.Meters{Items: meters}); err != nil {
658 log.Errorw("db-meter-update-failed", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
659 return err
660 }
661 log.Debugw("Meter-added-successfully", log.Fields{"Added-meter": meterEntry, "updated-meters": lDevice.Meters})
662 return nil
663}
664
665func (agent *LogicalDeviceAgent) meterDelete(meterMod *ofp.OfpMeterMod) error {
666 log.Debug("meterDelete", log.Fields{"meterMod": *meterMod})
667 if meterMod == nil {
668 return nil
669 }
670 agent.lockLogicalDevice.Lock()
671 defer agent.lockLogicalDevice.Unlock()
672
673 var lDevice *voltha.LogicalDevice
674 var err error
675 if lDevice, err = agent.getLogicalDeviceWithoutLock(); err != nil {
676 log.Errorw("no-logical-device-present", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
677 return errors.New(fmt.Sprintf("no-logical-device-present:%s", agent.logicalDeviceId))
678 }
679
680 var meters []*ofp.OfpMeterEntry
681 var flows []*ofp.OfpFlowStats
682 updatedFlows := make([]*ofp.OfpFlowStats, 0)
683 if lDevice.Meters != nil && lDevice.Meters.Items != nil {
684 meters = lDevice.Meters.Items
685 }
686 if lDevice.Flows != nil && lDevice.Flows.Items != nil {
687 flows = lDevice.Flows.Items
688 }
689
690 changedMeter := false
691 changedFow := false
692 log.Debugw("Available meters", log.Fields{"meters": meters})
693 for index, meter := range meters {
694 if meterMod.MeterId == meter.Config.MeterId {
695 flows = lDevice.Flows.Items
696 changedFow, updatedFlows = agent.getUpdatedFlowsAfterDeletebyMeterId(flows, meterMod.MeterId)
697 meters = append(meters[:index], meters[index+1:]...)
698 log.Debugw("Meter has been deleted", log.Fields{"meter": meter, "index": index})
699 changedMeter = true
700 break
701 }
702 }
703 if changedMeter {
704 //Update model
705 metersToUpdate := &ofp.Meters{}
706 if lDevice.Meters != nil {
707 metersToUpdate = &ofp.Meters{Items: meters}
708 }
709 if err := agent.updateLogicalDeviceMetersWithoutLock(metersToUpdate); err != nil {
710 log.Errorw("db-meter-update-failed", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
711 return err
712 }
713 log.Debug("Meter-deleted-from-DB-successfully", log.Fields{"updatedMeters": metersToUpdate, "no-of-meter": len(metersToUpdate.Items)})
714
715 }
716 if changedFow {
717 //Update model
718 if err := agent.updateLogicalDeviceFlowsWithoutLock(&ofp.Flows{Items: updatedFlows}); err != nil {
719 log.Errorw("db-flow-update-failed", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
720 return err
721 }
722 log.Debug("Flows-associated-with-meter-deleted-from-DB-successfully",
723 log.Fields{"updated-no-of-flows": len(updatedFlows), "meter": meterMod.MeterId})
724 }
725 log.Debugw("meterDelete success", log.Fields{"meterID": meterMod.MeterId})
726 return nil
727}
728
729func (agent *LogicalDeviceAgent) meterModify(meterMod *ofp.OfpMeterMod) error {
730 log.Debug("meterModify")
731 if meterMod == nil {
732 return nil
733 }
734 agent.lockLogicalDevice.Lock()
735 defer agent.lockLogicalDevice.Unlock()
736
737 var lDevice *voltha.LogicalDevice
738 var err error
739 if lDevice, err = agent.getLogicalDeviceWithoutLock(); err != nil {
740 log.Errorw("no-logical-device-present", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
741 return errors.New(fmt.Sprintf("no-logical-device-present:%s", agent.logicalDeviceId))
742 }
743
744 var meters []*ofp.OfpMeterEntry
745 if lDevice.Meters != nil && lDevice.Meters.Items != nil {
746 meters = lDevice.Meters.Items
747 }
748 changedMeter := false
749 for index, meter := range meters {
750 if meterMod.MeterId == meter.Config.MeterId {
751 newmeterEntry := fu.MeterEntryFromMeterMod(meterMod)
752 newmeterEntry.Stats.FlowCount = meter.Stats.FlowCount
753 meters[index] = newmeterEntry
754 changedMeter = true
755 log.Debugw("Found meter, replaced with new meter", log.Fields{"old meter": meter, "new meter": newmeterEntry})
756 break
757 }
758 }
759 if changedMeter {
760 //Update model
761 metersToUpdate := &ofp.Meters{}
762 if lDevice.Meters != nil {
763 metersToUpdate = &ofp.Meters{Items: meters}
764 }
765 if err := agent.updateLogicalDeviceMetersWithoutLock(metersToUpdate); err != nil {
766 log.Errorw("db-meter-update-failed", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
767 return err
768 }
769 log.Debugw("meter-updated-in-DB-successfully", log.Fields{"updated_meters": meters})
770 return nil
771 }
772
773 log.Errorw("Meter not found ", log.Fields{"meter": meterMod})
774 return errors.New(fmt.Sprintf("no-logical-device-present:%d", meterMod.MeterId))
775
776}
777
778func (agent *LogicalDeviceAgent) getUpdatedFlowsAfterDeletebyMeterId(flows []*ofp.OfpFlowStats, meterId uint32) (bool, []*ofp.OfpFlowStats) {
779 log.Infow("Delete flows matching meter", log.Fields{"meter": meterId})
780 changed := false
781 //updatedFlows := make([]*ofp.OfpFlowStats, 0)
782 for index := len(flows) - 1; index >= 0; index-- {
783 if mId := fu.GetMeterIdFromFlow(flows[index]); mId != 0 && mId == meterId {
784 log.Debugw("Flow to be deleted", log.Fields{"flow": flows[index], "index": index})
785 flows = append(flows[:index], flows[index+1:]...)
786 changed = true
787 }
788 }
789 return changed, flows
790}
791
792func (agent *LogicalDeviceAgent) updateFlowCountOfMeterStats(modCommand *ofp.OfpFlowMod, meters []*ofp.OfpMeterEntry, flow *ofp.OfpFlowStats) bool {
793
794 flowCommand := modCommand.GetCommand()
795 meterId := fu.GetMeterIdFromFlow(flow)
796 log.Debugw("Meter-id-in-flow-mod", log.Fields{"meterId": meterId})
797 if meterId == 0 {
798 log.Debugw("No meter present in the flow", log.Fields{"flow": *flow})
799 return false
800 }
801 if meters == nil {
802 log.Debug("No meters present in logical device")
803 return false
804 }
805 changedMeter := false
806 for _, meter := range meters {
807 if meterId == meter.Config.MeterId { // Found meter in Logicaldevice
808 if flowCommand == ofp.OfpFlowModCommand_OFPFC_ADD {
809 meter.Stats.FlowCount += 1
810 changedMeter = true
811 } else if flowCommand == ofp.OfpFlowModCommand_OFPFC_DELETE_STRICT {
812 meter.Stats.FlowCount -= 1
813 changedMeter = true
814 }
815 log.Debugw("Found meter, updated meter flow stats", log.Fields{" meterId": meterId})
816 break
817 }
818 }
819 return changedMeter
820}
821
khenaidoo19d7b632018-10-30 10:49:50 -0400822//flowAdd adds a flow to the flow table of that logical device
823func (agent *LogicalDeviceAgent) flowAdd(mod *ofp.OfpFlowMod) error {
khenaidoo4c9e5592019-09-09 16:20:41 -0400824 log.Debugw("flowAdd", log.Fields{"flow": mod})
khenaidoo19d7b632018-10-30 10:49:50 -0400825 if mod == nil {
826 return nil
827 }
khenaidoo92e62c52018-10-03 14:02:54 -0400828 agent.lockLogicalDevice.Lock()
829 defer agent.lockLogicalDevice.Unlock()
khenaidoo19d7b632018-10-30 10:49:50 -0400830
831 var lDevice *voltha.LogicalDevice
832 var err error
833 if lDevice, err = agent.getLogicalDeviceWithoutLock(); err != nil {
834 log.Errorw("no-logical-device-present", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
835 return errors.New(fmt.Sprintf("no-logical-device-present:%s", agent.logicalDeviceId))
836 }
837
838 var flows []*ofp.OfpFlowStats
Manikkaraj kb1a10922019-07-29 12:10:34 -0400839 var meters []*ofp.OfpMeterEntry
840 var flow *ofp.OfpFlowStats
841
khenaidoo19d7b632018-10-30 10:49:50 -0400842 if lDevice.Flows != nil && lDevice.Flows.Items != nil {
843 flows = lDevice.Flows.Items
844 }
845
Manikkaraj kb1a10922019-07-29 12:10:34 -0400846 if lDevice.Meters != nil && lDevice.Meters.Items != nil {
847 meters = lDevice.Meters.Items
848 }
khenaidoo2c6a0992019-04-29 13:46:56 -0400849 updatedFlows := make([]*ofp.OfpFlowStats, 0)
khenaidoo19d7b632018-10-30 10:49:50 -0400850 changed := false
Manikkaraj kb1a10922019-07-29 12:10:34 -0400851 updated := false
khenaidoo19d7b632018-10-30 10:49:50 -0400852 checkOverlap := (mod.Flags & uint32(ofp.OfpFlowModFlags_OFPFF_CHECK_OVERLAP)) != 0
853 if checkOverlap {
854 if overlapped := fu.FindOverlappingFlows(flows, mod); len(overlapped) != 0 {
855 // TODO: should this error be notified other than being logged?
856 log.Warnw("overlapped-flows", log.Fields{"logicaldeviceId": agent.logicalDeviceId})
857 } else {
Manikkaraj k33f779a2019-08-23 01:38:00 -0400858 // Add new flow
Manikkaraj kb1a10922019-07-29 12:10:34 -0400859 flow = fu.FlowStatsEntryFromFlowModMessage(mod)
khenaidoo19d7b632018-10-30 10:49:50 -0400860 flows = append(flows, flow)
khenaidoo2c6a0992019-04-29 13:46:56 -0400861 updatedFlows = append(updatedFlows, flow)
khenaidoo19d7b632018-10-30 10:49:50 -0400862 changed = true
863 }
864 } else {
Manikkaraj kb1a10922019-07-29 12:10:34 -0400865 flow = fu.FlowStatsEntryFromFlowModMessage(mod)
khenaidoo19d7b632018-10-30 10:49:50 -0400866 idx := fu.FindFlows(flows, flow)
867 if idx >= 0 {
868 oldFlow := flows[idx]
869 if (mod.Flags & uint32(ofp.OfpFlowModFlags_OFPFF_RESET_COUNTS)) != 0 {
870 flow.ByteCount = oldFlow.ByteCount
871 flow.PacketCount = oldFlow.PacketCount
872 }
Manikkaraj k33f779a2019-08-23 01:38:00 -0400873 // OF-1.3.1: If a flow entry with identical match fields and priority already resides , clear old flow and add new flow
874 flows[idx] = flow
875 updatedFlows = append(updatedFlows, flow)
876 changed = true
877 updated = true
878 } else { // Add new flow
khenaidoo19d7b632018-10-30 10:49:50 -0400879 flows = append(flows, flow)
khenaidoo2c6a0992019-04-29 13:46:56 -0400880 updatedFlows = append(updatedFlows, flow)
881 changed = true
khenaidoo19d7b632018-10-30 10:49:50 -0400882 }
khenaidoo19d7b632018-10-30 10:49:50 -0400883 }
khenaidoo4c9e5592019-09-09 16:20:41 -0400884 log.Debugw("flowAdd-changed", log.Fields{"changed": changed})
885
khenaidoo19d7b632018-10-30 10:49:50 -0400886 if changed {
Manikkaraj kb1a10922019-07-29 12:10:34 -0400887 var flowMetadata voltha.FlowMetadata
888 if err := agent.GetMeterConfig(updatedFlows, meters, &flowMetadata); err != nil { // This should never happen,meters should be installed before flow arrives
889 log.Error("Meter-referred-in-flows-not-present")
890 return err
891 }
khenaidoo0458db62019-06-20 08:50:36 -0400892 deviceRules := agent.flowDecomposer.DecomposeRules(agent, ofp.Flows{Items: updatedFlows}, *lDevice.FlowGroups)
893 log.Debugw("rules", log.Fields{"rules": deviceRules.String()})
894
Manikkaraj kb1a10922019-07-29 12:10:34 -0400895 if err := agent.addDeviceFlowsAndGroups(deviceRules, &flowMetadata); err != nil {
khenaidoo0458db62019-06-20 08:50:36 -0400896 log.Errorw("failure-updating-device-flows", log.Fields{"logicalDeviceId": agent.logicalDeviceId, "error": err})
khenaidoo2c6a0992019-04-29 13:46:56 -0400897 return err
898 }
899
khenaidoo19d7b632018-10-30 10:49:50 -0400900 // Update model
khenaidoo0458db62019-06-20 08:50:36 -0400901 if err := agent.updateLogicalDeviceFlowsWithoutLock(&ofp.Flows{Items: flows}); err != nil {
khenaidoo2c6a0992019-04-29 13:46:56 -0400902 log.Errorw("db-flow-update-failed", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
khenaidoo19d7b632018-10-30 10:49:50 -0400903 return err
904 }
Manikkaraj k33f779a2019-08-23 01:38:00 -0400905 if !updated { // Newly added
Manikkaraj kb1a10922019-07-29 12:10:34 -0400906 changedMeterStats := agent.updateFlowCountOfMeterStats(mod, meters, flow)
907 metersToUpdate := &ofp.Meters{}
908 if lDevice.Meters != nil {
909 metersToUpdate = &ofp.Meters{Items: meters}
910 }
911 if changedMeterStats {
912 //Update model
913 if err := agent.updateLogicalDeviceMetersWithoutLock(metersToUpdate); err != nil {
914 log.Errorw("db-meter-update-failed", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
915 return err
916 }
917 log.Debugw("meter-stats-updated-in-DB-successfully", log.Fields{"updated_meters": meters})
918
919 }
920 }
921
khenaidoo19d7b632018-10-30 10:49:50 -0400922 }
khenaidoo19d7b632018-10-30 10:49:50 -0400923 return nil
924}
925
Manikkaraj kb1a10922019-07-29 12:10:34 -0400926func (agent *LogicalDeviceAgent) GetMeterConfig(flows []*ofp.OfpFlowStats, meters []*ofp.OfpMeterEntry, metadata *voltha.FlowMetadata) error {
927 m := make(map[uint32]bool)
928 for _, flow := range flows {
929 if flowMeterID := fu.GetMeterIdFromFlow(flow); flowMeterID != 0 && m[flowMeterID] == false {
930 foundMeter := false
931 // Meter is present in the flow , Get from logical device
932 for _, meter := range meters {
933 if flowMeterID == meter.Config.MeterId {
934 metadata.Meters = append(metadata.Meters, meter.Config)
935 log.Debugw("Found meter in logical device",
936 log.Fields{"meterID": flowMeterID, "meter-band": meter.Config})
937 m[flowMeterID] = true
938 foundMeter = true
939 break
940 }
941 }
942 if !foundMeter {
943 log.Errorw("Meter-referred-by-flow-is-not-found-in-logicaldevice",
944 log.Fields{"meterID": flowMeterID, "Avaliable-meters": meters, "flow": *flow})
945 return errors.New("Meter-referred-by-flow-is-not-found-in-logicaldevice")
946 }
947 }
948 }
949 log.Debugw("meter-bands-for-flows", log.Fields{"flows": len(flows), "metadata": metadata})
950 return nil
951
952}
953
khenaidoo19d7b632018-10-30 10:49:50 -0400954//flowDelete deletes a flow from the flow table of that logical device
955func (agent *LogicalDeviceAgent) flowDelete(mod *ofp.OfpFlowMod) error {
956 log.Debug("flowDelete")
957 if mod == nil {
958 return nil
959 }
960 agent.lockLogicalDevice.Lock()
961 defer agent.lockLogicalDevice.Unlock()
962
963 var lDevice *voltha.LogicalDevice
964 var err error
965 if lDevice, err = agent.getLogicalDeviceWithoutLock(); err != nil {
966 log.Errorw("no-logical-device-present", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
967 return errors.New(fmt.Sprintf("no-logical-device-present:%s", agent.logicalDeviceId))
968 }
khenaidoo19d7b632018-10-30 10:49:50 -0400969
Manikkaraj kb1a10922019-07-29 12:10:34 -0400970 var meters []*ofp.OfpMeterEntry
971 var flows []*ofp.OfpFlowStats
972
973 if lDevice.Flows != nil && lDevice.Flows.Items != nil {
974 flows = lDevice.Flows.Items
975 }
976
977 if lDevice.Meters != nil && lDevice.Meters.Items != nil {
978 meters = lDevice.Meters.Items
979 }
khenaidoo19d7b632018-10-30 10:49:50 -0400980 //build a list of what to keep vs what to delete
981 toKeep := make([]*ofp.OfpFlowStats, 0)
khenaidoo0458db62019-06-20 08:50:36 -0400982 toDelete := make([]*ofp.OfpFlowStats, 0)
khenaidoo19d7b632018-10-30 10:49:50 -0400983 for _, f := range flows {
khenaidoo0458db62019-06-20 08:50:36 -0400984 // Check whether the flow and the flowmod matches
985 if fu.FlowMatch(f, fu.FlowStatsEntryFromFlowModMessage(mod)) {
986 toDelete = append(toDelete, f)
987 continue
988 }
989 // Check wild card match
khenaidoo19d7b632018-10-30 10:49:50 -0400990 if !fu.FlowMatchesMod(f, mod) {
991 toKeep = append(toKeep, f)
khenaidoo0458db62019-06-20 08:50:36 -0400992 } else {
993 toDelete = append(toDelete, f)
khenaidoo19d7b632018-10-30 10:49:50 -0400994 }
995 }
996
khenaidoo0458db62019-06-20 08:50:36 -0400997 log.Debugw("flowDelete", log.Fields{"logicalDeviceId": agent.logicalDeviceId, "toKeep": len(toKeep), "toDelete": toDelete})
998
khenaidoo19d7b632018-10-30 10:49:50 -0400999 //Update flows
khenaidoo0458db62019-06-20 08:50:36 -04001000 if len(toDelete) > 0 {
Manikkaraj kb1a10922019-07-29 12:10:34 -04001001 var flowMetadata voltha.FlowMetadata
1002 if err := agent.GetMeterConfig(toDelete, meters, &flowMetadata); err != nil { // This should never happen
1003 log.Error("Meter-referred-in-flows-not-present")
1004 return errors.New("Meter-referred-in-flows-not-present")
1005 }
khenaidoo0458db62019-06-20 08:50:36 -04001006 deviceRules := agent.flowDecomposer.DecomposeRules(agent, ofp.Flows{Items: toDelete}, ofp.FlowGroups{})
1007 log.Debugw("rules", log.Fields{"rules": deviceRules.String()})
1008
Manikkaraj kb1a10922019-07-29 12:10:34 -04001009 if err := agent.deleteDeviceFlowsAndGroups(deviceRules, &flowMetadata); err != nil {
khenaidoo0458db62019-06-20 08:50:36 -04001010 log.Errorw("failure-updating-device-flows", log.Fields{"logicalDeviceId": agent.logicalDeviceId, "error": err})
1011 return err
1012 }
1013
khenaidoo43c82122018-11-22 18:38:28 -05001014 if err := agent.updateLogicalDeviceFlowsWithoutLock(&ofp.Flows{Items: toKeep}); err != nil {
1015 log.Errorw("Cannot-update-flows", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
khenaidoo19d7b632018-10-30 10:49:50 -04001016 return err
1017 }
1018 }
1019
1020 //TODO: send announcement on delete
1021 return nil
1022}
1023
Manikkaraj kb1a10922019-07-29 12:10:34 -04001024func (agent *LogicalDeviceAgent) addDeviceFlowsAndGroups(deviceRules *fu.DeviceRules, flowMetadata *voltha.FlowMetadata) error {
1025 log.Debugw("addDeviceFlowsAndGroups", log.Fields{"logicalDeviceID": agent.logicalDeviceId, "deviceRules": deviceRules, "flowMetadata": flowMetadata})
khenaidoo19d7b632018-10-30 10:49:50 -04001026
khenaidoo0458db62019-06-20 08:50:36 -04001027 chnlsList := make([]chan interface{}, 0)
1028 for deviceId, value := range deviceRules.GetRules() {
1029 ch := make(chan interface{})
1030 chnlsList = append(chnlsList, ch)
1031 go func(deviceId string, flows []*ofp.OfpFlowStats, groups []*ofp.OfpGroupEntry) {
Manikkaraj kb1a10922019-07-29 12:10:34 -04001032 if err := agent.deviceMgr.addFlowsAndGroups(deviceId, flows, groups, flowMetadata); err != nil {
khenaidoo0458db62019-06-20 08:50:36 -04001033 log.Errorw("flow-add-failed", log.Fields{"deviceID": deviceId, "error": err})
1034 ch <- status.Errorf(codes.Internal, "flow-add-failed: %s", deviceId)
1035 }
1036 ch <- nil
1037 }(deviceId, value.ListFlows(), value.ListGroups())
khenaidoo19d7b632018-10-30 10:49:50 -04001038 }
khenaidoo0458db62019-06-20 08:50:36 -04001039 // Wait for completion
Scott Bakerb671a862019-10-24 10:53:40 -07001040 if res := coreutils.WaitForNilOrErrorResponses(agent.defaultTimeout, chnlsList...); res != nil {
khenaidoo0458db62019-06-20 08:50:36 -04001041 return status.Errorf(codes.Aborted, "errors-%s", res)
khenaidoo19d7b632018-10-30 10:49:50 -04001042 }
khenaidoo0458db62019-06-20 08:50:36 -04001043 return nil
1044}
khenaidoo19d7b632018-10-30 10:49:50 -04001045
Manikkaraj kb1a10922019-07-29 12:10:34 -04001046func (agent *LogicalDeviceAgent) deleteDeviceFlowsAndGroups(deviceRules *fu.DeviceRules, flowMetadata *voltha.FlowMetadata) error {
khenaidoo0458db62019-06-20 08:50:36 -04001047 log.Debugw("deleteDeviceFlowsAndGroups", log.Fields{"logicalDeviceID": agent.logicalDeviceId})
1048
1049 chnlsList := make([]chan interface{}, 0)
1050 for deviceId, value := range deviceRules.GetRules() {
1051 ch := make(chan interface{})
1052 chnlsList = append(chnlsList, ch)
1053 go func(deviceId string, flows []*ofp.OfpFlowStats, groups []*ofp.OfpGroupEntry) {
Manikkaraj kb1a10922019-07-29 12:10:34 -04001054 if err := agent.deviceMgr.deleteFlowsAndGroups(deviceId, flows, groups, flowMetadata); err != nil {
khenaidoo0458db62019-06-20 08:50:36 -04001055 log.Error("flow-delete-failed", log.Fields{"deviceID": deviceId, "error": err})
1056 ch <- status.Errorf(codes.Internal, "flow-delete-failed: %s", deviceId)
1057 }
1058 ch <- nil
1059 }(deviceId, value.ListFlows(), value.ListGroups())
1060 }
1061 // Wait for completion
Scott Bakerb671a862019-10-24 10:53:40 -07001062 if res := coreutils.WaitForNilOrErrorResponses(agent.defaultTimeout, chnlsList...); res != nil {
khenaidoo0458db62019-06-20 08:50:36 -04001063 return status.Errorf(codes.Aborted, "errors-%s", res)
1064 }
1065 return nil
1066}
1067
Manikkaraj kb1a10922019-07-29 12:10:34 -04001068func (agent *LogicalDeviceAgent) updateDeviceFlowsAndGroups(deviceRules *fu.DeviceRules, flowMetadata *voltha.FlowMetadata) error {
khenaidoo0458db62019-06-20 08:50:36 -04001069 log.Debugw("updateDeviceFlowsAndGroups", log.Fields{"logicalDeviceID": agent.logicalDeviceId})
1070
1071 chnlsList := make([]chan interface{}, 0)
1072 for deviceId, value := range deviceRules.GetRules() {
1073 ch := make(chan interface{})
1074 chnlsList = append(chnlsList, ch)
1075 go func(deviceId string, flows []*ofp.OfpFlowStats, groups []*ofp.OfpGroupEntry) {
Manikkaraj kb1a10922019-07-29 12:10:34 -04001076 if err := agent.deviceMgr.updateFlowsAndGroups(deviceId, flows, groups, flowMetadata); err != nil {
khenaidoo0458db62019-06-20 08:50:36 -04001077 log.Error("flow-update-failed", log.Fields{"deviceID": deviceId, "error": err})
1078 ch <- status.Errorf(codes.Internal, "flow-update-failed: %s", deviceId)
1079 }
1080 ch <- nil
1081 }(deviceId, value.ListFlows(), value.ListGroups())
1082 }
1083 // Wait for completion
Scott Bakerb671a862019-10-24 10:53:40 -07001084 if res := coreutils.WaitForNilOrErrorResponses(agent.defaultTimeout, chnlsList...); res != nil {
khenaidoo0458db62019-06-20 08:50:36 -04001085 return status.Errorf(codes.Aborted, "errors-%s", res)
khenaidoo19d7b632018-10-30 10:49:50 -04001086 }
1087 return nil
1088}
1089
1090//flowDeleteStrict deletes a flow from the flow table of that logical device
1091func (agent *LogicalDeviceAgent) flowDeleteStrict(mod *ofp.OfpFlowMod) error {
1092 log.Debug("flowDeleteStrict")
1093 if mod == nil {
1094 return nil
1095 }
1096 agent.lockLogicalDevice.Lock()
1097 defer agent.lockLogicalDevice.Unlock()
1098
1099 var lDevice *voltha.LogicalDevice
1100 var err error
1101 if lDevice, err = agent.getLogicalDeviceWithoutLock(); err != nil {
1102 log.Errorw("no-logical-device-present", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
1103 return errors.New(fmt.Sprintf("no-logical-device-present:%s", agent.logicalDeviceId))
1104 }
Manikkaraj kb1a10922019-07-29 12:10:34 -04001105 var meters []*ofp.OfpMeterEntry
1106 var flows []*ofp.OfpFlowStats
1107 if lDevice.Meters != nil && lDevice.Meters.Items != nil {
1108 meters = lDevice.Meters.Items
1109 }
1110 if lDevice.Flows != nil && lDevice.Flows.Items != nil {
1111 flows = lDevice.Flows.Items
1112 }
1113
1114 changedFlow := false
1115 changedMeter := false
khenaidoo68c930b2019-05-13 11:46:51 -04001116 flow := fu.FlowStatsEntryFromFlowModMessage(mod)
Manikkaraj kb1a10922019-07-29 12:10:34 -04001117 flowsToDelete := make([]*ofp.OfpFlowStats, 0)
khenaidoo19d7b632018-10-30 10:49:50 -04001118 idx := fu.FindFlows(flows, flow)
1119 if idx >= 0 {
Gamze Abaka6e4ac162019-10-21 11:10:10 +00001120 changedMeter = agent.updateFlowCountOfMeterStats(mod, meters, flows[idx])
Manikkaraj kb1a10922019-07-29 12:10:34 -04001121 flowsToDelete = append(flowsToDelete, flows[idx])
khenaidoo19d7b632018-10-30 10:49:50 -04001122 flows = append(flows[:idx], flows[idx+1:]...)
Manikkaraj kb1a10922019-07-29 12:10:34 -04001123 changedFlow = true
khenaidoo19d7b632018-10-30 10:49:50 -04001124 } else {
1125 return errors.New(fmt.Sprintf("Cannot delete flow - %s", flow))
1126 }
Manikkaraj kb1a10922019-07-29 12:10:34 -04001127 if changedMeter {
1128 //Update model
1129 metersToUpdate := &ofp.Meters{}
1130 if lDevice.Meters != nil {
1131 metersToUpdate = &ofp.Meters{Items: meters}
1132 }
1133 if err := agent.updateLogicalDeviceMetersWithoutLock(metersToUpdate); err != nil {
1134 log.Errorw("db-meter-update-failed", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
1135 return err
1136 }
khenaidoo19d7b632018-10-30 10:49:50 -04001137
Manikkaraj kb1a10922019-07-29 12:10:34 -04001138 }
1139 if changedFlow {
1140 var flowMetadata voltha.FlowMetadata
1141 if err := agent.GetMeterConfig(flowsToDelete, meters, &flowMetadata); err != nil {
1142 log.Error("Meter-referred-in-flows-not-present")
1143 return err
1144 }
1145 deviceRules := agent.flowDecomposer.DecomposeRules(agent, ofp.Flows{Items: flowsToDelete}, ofp.FlowGroups{})
khenaidoo0458db62019-06-20 08:50:36 -04001146 log.Debugw("rules", log.Fields{"rules": deviceRules.String()})
1147
Manikkaraj kb1a10922019-07-29 12:10:34 -04001148 if err := agent.deleteDeviceFlowsAndGroups(deviceRules, &flowMetadata); err != nil {
khenaidoo0458db62019-06-20 08:50:36 -04001149 log.Errorw("failure-deleting-device-flows", log.Fields{"logicalDeviceId": agent.logicalDeviceId, "error": err})
1150 return err
1151 }
1152
khenaidoo43c82122018-11-22 18:38:28 -05001153 if err := agent.updateLogicalDeviceFlowsWithoutLock(&ofp.Flows{Items: flows}); err != nil {
khenaidoo0458db62019-06-20 08:50:36 -04001154 log.Errorw("Cannot-update-flows", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
khenaidoo19d7b632018-10-30 10:49:50 -04001155 return err
1156 }
1157 }
khenaidoo19d7b632018-10-30 10:49:50 -04001158 return nil
1159}
1160
1161//flowModify modifies a flow from the flow table of that logical device
1162func (agent *LogicalDeviceAgent) flowModify(mod *ofp.OfpFlowMod) error {
1163 return errors.New("flowModify not implemented")
1164}
1165
1166//flowModifyStrict deletes a flow from the flow table of that logical device
1167func (agent *LogicalDeviceAgent) flowModifyStrict(mod *ofp.OfpFlowMod) error {
1168 return errors.New("flowModifyStrict not implemented")
1169}
1170
1171func (agent *LogicalDeviceAgent) groupAdd(groupMod *ofp.OfpGroupMod) error {
1172 log.Debug("groupAdd")
1173 if groupMod == nil {
1174 return nil
1175 }
1176 agent.lockLogicalDevice.Lock()
1177 defer agent.lockLogicalDevice.Unlock()
1178
1179 var lDevice *voltha.LogicalDevice
1180 var err error
1181 if lDevice, err = agent.getLogicalDeviceWithoutLock(); err != nil {
1182 log.Errorw("no-logical-device-present", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
1183 return errors.New(fmt.Sprintf("no-logical-device-present:%s", agent.logicalDeviceId))
1184 }
1185 groups := lDevice.FlowGroups.Items
khenaidoo19d7b632018-10-30 10:49:50 -04001186 if fu.FindGroup(groups, groupMod.GroupId) == -1 {
khenaidoo68c930b2019-05-13 11:46:51 -04001187 groups = append(groups, fu.GroupEntryFromGroupMod(groupMod))
khenaidoo0458db62019-06-20 08:50:36 -04001188
1189 deviceRules := agent.flowDecomposer.DecomposeRules(agent, *lDevice.Flows, ofp.FlowGroups{Items: groups})
1190 log.Debugw("rules", log.Fields{"rules": deviceRules.String()})
Manikkaraj kb1a10922019-07-29 12:10:34 -04001191 if err := agent.addDeviceFlowsAndGroups(deviceRules, nil); err != nil {
khenaidoo0458db62019-06-20 08:50:36 -04001192 log.Errorw("failure-updating-device-flows", log.Fields{"logicalDeviceId": agent.logicalDeviceId, "error": err})
1193 return err
1194 }
1195
khenaidoo43c82122018-11-22 18:38:28 -05001196 if err := agent.updateLogicalDeviceFlowGroupsWithoutLock(&ofp.FlowGroups{Items: groups}); err != nil {
1197 log.Errorw("Cannot-update-group", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
khenaidoo19d7b632018-10-30 10:49:50 -04001198 return err
1199 }
1200 } else {
1201 return errors.New(fmt.Sprintf("Groups %d already present", groupMod.GroupId))
1202 }
khenaidoo19d7b632018-10-30 10:49:50 -04001203 return nil
1204}
1205
1206func (agent *LogicalDeviceAgent) groupDelete(groupMod *ofp.OfpGroupMod) error {
1207 log.Debug("groupDelete")
1208 if groupMod == nil {
1209 return nil
1210 }
1211 agent.lockLogicalDevice.Lock()
1212 defer agent.lockLogicalDevice.Unlock()
1213
1214 var lDevice *voltha.LogicalDevice
1215 var err error
1216 if lDevice, err = agent.getLogicalDeviceWithoutLock(); err != nil {
1217 log.Errorw("no-logical-device-present", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
1218 return errors.New(fmt.Sprintf("no-logical-device-present:%s", agent.logicalDeviceId))
1219 }
1220 groups := lDevice.FlowGroups.Items
1221 flows := lDevice.Flows.Items
1222 groupsChanged := false
1223 flowsChanged := false
1224 groupId := groupMod.GroupId
1225 if groupId == uint32(ofp.OfpGroup_OFPG_ALL) {
1226 //TODO we must delete all flows that point to this group and
1227 //signal controller as requested by flow's flag
1228 groups = []*ofp.OfpGroupEntry{}
1229 groupsChanged = true
1230 } else {
1231 if idx := fu.FindGroup(groups, groupId); idx == -1 {
1232 return nil // Valid case
1233 } else {
1234 flowsChanged, flows = fu.FlowsDeleteByGroupId(flows, groupId)
1235 groups = append(groups[:idx], groups[idx+1:]...)
1236 groupsChanged = true
1237 }
1238 }
khenaidoo0458db62019-06-20 08:50:36 -04001239 if flowsChanged || groupsChanged {
1240 deviceRules := agent.flowDecomposer.DecomposeRules(agent, ofp.Flows{Items: flows}, ofp.FlowGroups{Items: groups})
1241 log.Debugw("rules", log.Fields{"rules": deviceRules.String()})
1242
Manikkaraj kb1a10922019-07-29 12:10:34 -04001243 if err := agent.updateDeviceFlowsAndGroups(deviceRules, nil); err != nil {
khenaidoo0458db62019-06-20 08:50:36 -04001244 log.Errorw("failure-updating-device-flows-groups", log.Fields{"logicalDeviceId": agent.logicalDeviceId, "error": err})
1245 return err
1246 }
1247 }
1248
khenaidoo43c82122018-11-22 18:38:28 -05001249 if groupsChanged {
1250 if err := agent.updateLogicalDeviceFlowGroupsWithoutLock(&ofp.FlowGroups{Items: groups}); err != nil {
1251 log.Errorw("Cannot-update-group", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
khenaidoo19d7b632018-10-30 10:49:50 -04001252 return err
1253 }
1254 }
khenaidoo43c82122018-11-22 18:38:28 -05001255 if flowsChanged {
1256 if err := agent.updateLogicalDeviceFlowsWithoutLock(&ofp.Flows{Items: flows}); err != nil {
1257 log.Errorw("Cannot-update-flow", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
1258 return err
1259 }
1260 }
khenaidoo19d7b632018-10-30 10:49:50 -04001261 return nil
1262}
1263
1264func (agent *LogicalDeviceAgent) groupModify(groupMod *ofp.OfpGroupMod) error {
1265 log.Debug("groupModify")
1266 if groupMod == nil {
1267 return nil
1268 }
1269 agent.lockLogicalDevice.Lock()
1270 defer agent.lockLogicalDevice.Unlock()
1271
1272 var lDevice *voltha.LogicalDevice
1273 var err error
1274 if lDevice, err = agent.getLogicalDeviceWithoutLock(); err != nil {
1275 log.Errorw("no-logical-device-present", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
1276 return errors.New(fmt.Sprintf("no-logical-device-present:%s", agent.logicalDeviceId))
1277 }
1278 groups := lDevice.FlowGroups.Items
1279 groupsChanged := false
1280 groupId := groupMod.GroupId
1281 if idx := fu.FindGroup(groups, groupId); idx == -1 {
khenaidooca301322019-01-09 23:06:32 -05001282 return errors.New(fmt.Sprintf("group-absent:%d", groupId))
khenaidoo19d7b632018-10-30 10:49:50 -04001283 } else {
1284 //replace existing group entry with new group definition
khenaidoo68c930b2019-05-13 11:46:51 -04001285 groupEntry := fu.GroupEntryFromGroupMod(groupMod)
khenaidoo19d7b632018-10-30 10:49:50 -04001286 groups[idx] = groupEntry
1287 groupsChanged = true
1288 }
1289 if groupsChanged {
khenaidoo0458db62019-06-20 08:50:36 -04001290 deviceRules := agent.flowDecomposer.DecomposeRules(agent, ofp.Flows{Items: lDevice.Flows.Items}, ofp.FlowGroups{Items: groups})
1291 log.Debugw("rules", log.Fields{"rules": deviceRules.String()})
1292
Manikkaraj kb1a10922019-07-29 12:10:34 -04001293 if err := agent.updateDeviceFlowsAndGroups(deviceRules, nil); err != nil {
khenaidoo0458db62019-06-20 08:50:36 -04001294 log.Errorw("failure-updating-device-flows-groups", log.Fields{"logicalDeviceId": agent.logicalDeviceId, "error": err})
1295 return err
1296 }
1297
khenaidoo43c82122018-11-22 18:38:28 -05001298 //lDevice.FlowGroups.Items = groups
1299 if err := agent.updateLogicalDeviceFlowGroupsWithoutLock(&ofp.FlowGroups{Items: groups}); err != nil {
khenaidoo19d7b632018-10-30 10:49:50 -04001300 log.Errorw("Cannot-update-logical-group", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
1301 return err
1302 }
1303 }
1304 return nil
1305}
1306
1307// deleteLogicalPort removes the logical port
1308func (agent *LogicalDeviceAgent) deleteLogicalPort(lPort *voltha.LogicalPort) error {
1309 agent.lockLogicalDevice.Lock()
1310 defer agent.lockLogicalDevice.Unlock()
1311
khenaidoo92e62c52018-10-03 14:02:54 -04001312 // Get the most up to date logical device
1313 var logicaldevice *voltha.LogicalDevice
1314 if logicaldevice, _ = agent.getLogicalDeviceWithoutLock(); logicaldevice == nil {
khenaidoo19d7b632018-10-30 10:49:50 -04001315 log.Debugw("no-logical-device", log.Fields{"logicalDeviceId": agent.logicalDeviceId, "logicalPortId": lPort.Id})
khenaidoob9203542018-09-17 22:56:37 -04001316 return nil
1317 }
khenaidoo92e62c52018-10-03 14:02:54 -04001318 index := -1
1319 for i, logicalPort := range logicaldevice.Ports {
khenaidoo19d7b632018-10-30 10:49:50 -04001320 if logicalPort.Id == lPort.Id {
khenaidoo92e62c52018-10-03 14:02:54 -04001321 index = i
1322 break
1323 }
1324 }
1325 if index >= 0 {
1326 copy(logicaldevice.Ports[index:], logicaldevice.Ports[index+1:])
1327 logicaldevice.Ports[len(logicaldevice.Ports)-1] = nil
1328 logicaldevice.Ports = logicaldevice.Ports[:len(logicaldevice.Ports)-1]
1329 log.Debugw("logical-port-deleted", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
khenaidoo0a822f92019-05-08 15:15:57 -04001330 if err := agent.updateLogicalDeviceWithoutLock(logicaldevice); err != nil {
1331 log.Errorw("logical-device-update-failed", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
1332 return err
1333 }
1334 // Reset the logical device graph
khenaidoo3d3b8c22019-05-22 18:10:39 -04001335 go agent.generateDeviceGraph()
khenaidoo92e62c52018-10-03 14:02:54 -04001336 }
1337 return nil
khenaidoob9203542018-09-17 22:56:37 -04001338}
1339
khenaidoo0a822f92019-05-08 15:15:57 -04001340// deleteLogicalPorts removes the logical ports associated with that deviceId
1341func (agent *LogicalDeviceAgent) deleteLogicalPorts(deviceId string) error {
1342 agent.lockLogicalDevice.Lock()
1343 defer agent.lockLogicalDevice.Unlock()
1344
1345 // Get the most up to date logical device
1346 var logicaldevice *voltha.LogicalDevice
1347 if logicaldevice, _ = agent.getLogicalDeviceWithoutLock(); logicaldevice == nil {
1348 log.Debugw("no-logical-device", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
1349 return nil
1350 }
1351 updatedLPorts := []*voltha.LogicalPort{}
1352 for _, logicalPort := range logicaldevice.Ports {
1353 if logicalPort.DeviceId != deviceId {
1354 updatedLPorts = append(updatedLPorts, logicalPort)
1355 }
1356 }
1357 logicaldevice.Ports = updatedLPorts
1358 log.Debugw("updated-logical-ports", log.Fields{"ports": updatedLPorts})
1359 if err := agent.updateLogicalDeviceWithoutLock(logicaldevice); err != nil {
1360 log.Errorw("logical-device-update-failed", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
1361 return err
1362 }
1363 // Reset the logical device graph
khenaidoo3d3b8c22019-05-22 18:10:39 -04001364 go agent.generateDeviceGraph()
khenaidoo0a822f92019-05-08 15:15:57 -04001365
1366 return nil
1367}
1368
khenaidoo19d7b632018-10-30 10:49:50 -04001369// enableLogicalPort enables the logical port
1370func (agent *LogicalDeviceAgent) enableLogicalPort(lPort *voltha.LogicalPort) error {
1371 agent.lockLogicalDevice.Lock()
1372 defer agent.lockLogicalDevice.Unlock()
1373
1374 // Get the most up to date logical device
1375 var logicaldevice *voltha.LogicalDevice
1376 if logicaldevice, _ = agent.getLogicalDeviceWithoutLock(); logicaldevice == nil {
1377 log.Debugw("no-logical-device", log.Fields{"logicalDeviceId": agent.logicalDeviceId, "logicalPortId": lPort.Id})
1378 return nil
1379 }
1380 index := -1
1381 for i, logicalPort := range logicaldevice.Ports {
1382 if logicalPort.Id == lPort.Id {
1383 index = i
1384 break
1385 }
1386 }
1387 if index >= 0 {
1388 logicaldevice.Ports[index].OfpPort.Config = logicaldevice.Ports[index].OfpPort.Config & ^uint32(ofp.OfpPortConfig_OFPPC_PORT_DOWN)
1389 return agent.updateLogicalDeviceWithoutLock(logicaldevice)
1390 }
1391 //TODO: Trigger subsequent actions on the device
1392 return nil
1393}
1394
1395// disableLogicalPort disabled the logical port
1396func (agent *LogicalDeviceAgent) disableLogicalPort(lPort *voltha.LogicalPort) error {
1397 agent.lockLogicalDevice.Lock()
1398 defer agent.lockLogicalDevice.Unlock()
1399
1400 // Get the most up to date logical device
1401 var logicaldevice *voltha.LogicalDevice
1402 if logicaldevice, _ = agent.getLogicalDeviceWithoutLock(); logicaldevice == nil {
1403 log.Debugw("no-logical-device", log.Fields{"logicalDeviceId": agent.logicalDeviceId, "logicalPortId": lPort.Id})
1404 return nil
1405 }
1406 index := -1
1407 for i, logicalPort := range logicaldevice.Ports {
1408 if logicalPort.Id == lPort.Id {
1409 index = i
1410 break
1411 }
1412 }
1413 if index >= 0 {
1414 logicaldevice.Ports[index].OfpPort.Config = (logicaldevice.Ports[index].OfpPort.Config & ^uint32(ofp.OfpPortConfig_OFPPC_PORT_DOWN)) | uint32(ofp.OfpPortConfig_OFPPC_PORT_DOWN)
1415 return agent.updateLogicalDeviceWithoutLock(logicaldevice)
1416 }
1417 //TODO: Trigger subsequent actions on the device
1418 return nil
1419}
1420
khenaidoo89b0e942018-10-21 21:11:33 -04001421func (agent *LogicalDeviceAgent) getPreCalculatedRoute(ingress, egress uint32) []graph.RouteHop {
khenaidoo19d7b632018-10-30 10:49:50 -04001422 log.Debugw("ROUTE", log.Fields{"len": len(agent.deviceGraph.Routes)})
khenaidoo89b0e942018-10-21 21:11:33 -04001423 for routeLink, route := range agent.deviceGraph.Routes {
khenaidoo19d7b632018-10-30 10:49:50 -04001424 log.Debugw("ROUTELINKS", log.Fields{"ingress": ingress, "egress": egress, "routelink": routeLink})
khenaidoo89b0e942018-10-21 21:11:33 -04001425 if ingress == routeLink.Ingress && egress == routeLink.Egress {
1426 return route
1427 }
1428 }
1429 log.Warnw("no-route", log.Fields{"logicalDeviceId": agent.logicalDeviceId, "ingress": ingress, "egress": egress})
1430 return nil
1431}
1432
khenaidoo19d7b632018-10-30 10:49:50 -04001433func (agent *LogicalDeviceAgent) GetRoute(ingressPortNo uint32, egressPortNo uint32) []graph.RouteHop {
khenaidoo89b0e942018-10-21 21:11:33 -04001434 log.Debugw("getting-route", log.Fields{"ingress-port": ingressPortNo, "egress-port": egressPortNo})
khenaidoo89b0e942018-10-21 21:11:33 -04001435 routes := make([]graph.RouteHop, 0)
khenaidoo2c6a0992019-04-29 13:46:56 -04001436
khenaidoo19d7b632018-10-30 10:49:50 -04001437 // Note: A port value of 0 is equivalent to a nil port
1438
khenaidoo89b0e942018-10-21 21:11:33 -04001439 // Consider different possibilities
khenaidoo19d7b632018-10-30 10:49:50 -04001440 if egressPortNo != 0 && ((egressPortNo & 0x7fffffff) == uint32(ofp.OfpPortNo_OFPP_CONTROLLER)) {
khenaidoo2c6a0992019-04-29 13:46:56 -04001441 log.Debugw("controller-flow", log.Fields{"ingressPortNo": ingressPortNo, "egressPortNo": egressPortNo, "logicalPortsNo": agent.logicalPortsNo})
1442 if agent.isNNIPort(ingressPortNo) {
khenaidoo89b0e942018-10-21 21:11:33 -04001443 //This is a trap on the NNI Port
khenaidoo8f474192019-04-03 17:20:44 -04001444 if len(agent.deviceGraph.Routes) == 0 {
1445 // If there are no routes set (usually when the logical device has only NNI port(s), then just return an
Humera Kouser4ff89012019-08-25 19:01:51 -04001446 // route with same IngressHop and EgressHop
1447 hop := graph.RouteHop{DeviceID: agent.rootDeviceId, Ingress: ingressPortNo, Egress: ingressPortNo}
khenaidoo8f474192019-04-03 17:20:44 -04001448 routes = append(routes, hop)
1449 routes = append(routes, hop)
1450 return routes
1451 }
khenaidoo89b0e942018-10-21 21:11:33 -04001452 //Return a 'half' route to make the flow decomposer logic happy
1453 for routeLink, route := range agent.deviceGraph.Routes {
khenaidoo2c6a0992019-04-29 13:46:56 -04001454 if agent.isNNIPort(routeLink.Egress) {
khenaidoo89b0e942018-10-21 21:11:33 -04001455 routes = append(routes, graph.RouteHop{}) // first hop is set to empty
1456 routes = append(routes, route[1])
1457 return routes
1458 }
1459 }
khenaidoo2c6a0992019-04-29 13:46:56 -04001460 log.Warnw("no-upstream-route", log.Fields{"ingressPortNo": ingressPortNo, "egressPortNo": egressPortNo, "logicalPortsNo": agent.logicalPortsNo})
khenaidoo89b0e942018-10-21 21:11:33 -04001461 return nil
1462 }
1463 //treat it as if the output port is the first NNI of the OLT
khenaidoo2c6a0992019-04-29 13:46:56 -04001464 var err error
1465 if egressPortNo, err = agent.getFirstNNIPort(); err != nil {
1466 log.Warnw("no-nni-port", log.Fields{"error": err})
1467 return nil
1468 }
khenaidoo89b0e942018-10-21 21:11:33 -04001469 }
1470 //If ingress port is not specified (nil), it may be a wildcarded
1471 //route if egress port is OFPP_CONTROLLER or a nni logical port,
1472 //in which case we need to create a half-route where only the egress
1473 //hop is filled, the first hop is nil
khenaidoo2c6a0992019-04-29 13:46:56 -04001474 if ingressPortNo == 0 && agent.isNNIPort(egressPortNo) {
khenaidoo89b0e942018-10-21 21:11:33 -04001475 // We can use the 2nd hop of any upstream route, so just find the first upstream:
1476 for routeLink, route := range agent.deviceGraph.Routes {
khenaidoo2c6a0992019-04-29 13:46:56 -04001477 if agent.isNNIPort(routeLink.Egress) {
khenaidoo89b0e942018-10-21 21:11:33 -04001478 routes = append(routes, graph.RouteHop{}) // first hop is set to empty
1479 routes = append(routes, route[1])
1480 return routes
1481 }
1482 }
khenaidoo2c6a0992019-04-29 13:46:56 -04001483 log.Warnw("no-upstream-route", log.Fields{"ingressPortNo": ingressPortNo, "egressPortNo": egressPortNo, "logicalPortsNo": agent.logicalPortsNo})
khenaidoo89b0e942018-10-21 21:11:33 -04001484 return nil
1485 }
1486 //If egress port is not specified (nil), we can also can return a "half" route
khenaidoo19d7b632018-10-30 10:49:50 -04001487 if egressPortNo == 0 {
khenaidoo89b0e942018-10-21 21:11:33 -04001488 for routeLink, route := range agent.deviceGraph.Routes {
khenaidoo19d7b632018-10-30 10:49:50 -04001489 if routeLink.Ingress == ingressPortNo {
khenaidoo89b0e942018-10-21 21:11:33 -04001490 routes = append(routes, route[0])
1491 routes = append(routes, graph.RouteHop{})
1492 return routes
1493 }
1494 }
khenaidoo2c6a0992019-04-29 13:46:56 -04001495 log.Warnw("no-downstream-route", log.Fields{"ingressPortNo": ingressPortNo, "egressPortNo": egressPortNo, "logicalPortsNo": agent.logicalPortsNo})
khenaidoo89b0e942018-10-21 21:11:33 -04001496 return nil
1497 }
khenaidoo89b0e942018-10-21 21:11:33 -04001498 // Return the pre-calculated route
khenaidoo19d7b632018-10-30 10:49:50 -04001499 return agent.getPreCalculatedRoute(ingressPortNo, egressPortNo)
khenaidoo89b0e942018-10-21 21:11:33 -04001500}
1501
khenaidoo3d3b8c22019-05-22 18:10:39 -04001502//GetWildcardInputPorts filters out the logical port number from the set of logical ports on the device and
1503//returns their port numbers. This function is invoked only during flow decomposition where the lock on the logical
1504//device is already held. Therefore it is safe to retrieve the logical device without lock.
khenaidoo89b0e942018-10-21 21:11:33 -04001505func (agent *LogicalDeviceAgent) GetWildcardInputPorts(excludePort ...uint32) []uint32 {
1506 lPorts := make([]uint32, 0)
1507 var exclPort uint32
1508 if len(excludePort) == 1 {
1509 exclPort = excludePort[0]
1510 }
khenaidoo3d3b8c22019-05-22 18:10:39 -04001511 if lDevice, _ := agent.getLogicalDeviceWithoutLock(); lDevice != nil {
khenaidoo89b0e942018-10-21 21:11:33 -04001512 for _, port := range lDevice.Ports {
1513 if port.OfpPort.PortNo != exclPort {
1514 lPorts = append(lPorts, port.OfpPort.PortNo)
1515 }
1516 }
1517 }
1518 return lPorts
1519}
khenaidoo19d7b632018-10-30 10:49:50 -04001520
1521func (agent *LogicalDeviceAgent) GetDeviceGraph() *graph.DeviceGraph {
1522 return agent.deviceGraph
1523}
1524
khenaidoo3306c992019-05-24 16:57:35 -04001525//updateRoutes rebuilds the device graph if not done already
khenaidoo2c6a0992019-04-29 13:46:56 -04001526func (agent *LogicalDeviceAgent) updateRoutes(device *voltha.Device, port *voltha.Port) error {
1527 log.Debugf("updateRoutes", log.Fields{"logicalDeviceId": agent.logicalDeviceId, "device": device.Id, "port": port})
khenaidoo910204f2019-04-08 17:56:40 -04001528 agent.lockLogicalDevice.Lock()
1529 defer agent.lockLogicalDevice.Unlock()
khenaidoo19d7b632018-10-30 10:49:50 -04001530 if agent.deviceGraph == nil {
khenaidoo910204f2019-04-08 17:56:40 -04001531 agent.deviceGraph = graph.NewDeviceGraph(agent.logicalDeviceId, agent.deviceMgr.GetDevice)
khenaidoo2c6a0992019-04-29 13:46:56 -04001532 }
1533 // Get all the logical ports on that logical device
1534 if lDevice, err := agent.getLogicalDeviceWithoutLock(); err != nil {
manikkaraj k259a6f72019-05-06 09:55:44 -04001535 log.Errorw("unknown-logical-device", log.Fields{"error": err, "logicalDeviceId": agent.logicalDeviceId})
khenaidoo2c6a0992019-04-29 13:46:56 -04001536 return err
1537 } else {
1538 //TODO: Find a better way to refresh only missing routes
1539 agent.deviceGraph.ComputeRoutes(lDevice.Ports)
1540 }
khenaidoo2c6a0992019-04-29 13:46:56 -04001541 agent.deviceGraph.Print()
1542 return nil
khenaidoo19d7b632018-10-30 10:49:50 -04001543}
1544
khenaidoo2c6a0992019-04-29 13:46:56 -04001545//updateDeviceGraph updates the device graph if not done already and setup the default rules as well
khenaidoo910204f2019-04-08 17:56:40 -04001546func (agent *LogicalDeviceAgent) updateDeviceGraph(lp *voltha.LogicalPort) {
khenaidoo2c6a0992019-04-29 13:46:56 -04001547 log.Debugf("updateDeviceGraph", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
1548 agent.lockLogicalDevice.Lock()
1549 defer agent.lockLogicalDevice.Unlock()
khenaidoo910204f2019-04-08 17:56:40 -04001550 if agent.deviceGraph == nil {
1551 agent.deviceGraph = graph.NewDeviceGraph(agent.logicalDeviceId, agent.deviceMgr.GetDevice)
1552 }
1553 agent.deviceGraph.AddPort(lp)
khenaidoo2c6a0992019-04-29 13:46:56 -04001554 agent.deviceGraph.Print()
khenaidoo19d7b632018-10-30 10:49:50 -04001555}
khenaidoofdbad6e2018-11-06 22:26:38 -05001556
khenaidoo3d3b8c22019-05-22 18:10:39 -04001557//generateDeviceGraph regenerates the device graph
1558func (agent *LogicalDeviceAgent) generateDeviceGraph() {
khenaidoo4c9e5592019-09-09 16:20:41 -04001559 log.Debugw("generateDeviceGraph", log.Fields{"logicalDeviceId": agent.logicalDeviceId})
khenaidoo0a822f92019-05-08 15:15:57 -04001560 agent.lockLogicalDevice.Lock()
1561 defer agent.lockLogicalDevice.Unlock()
1562 // Get the latest logical device
1563 if ld, err := agent.getLogicalDeviceWithoutLock(); err != nil {
1564 log.Errorw("logical-device-not-present", log.Fields{"logicalDeviceId": agent.logicalDeviceId, "error": err})
1565 } else {
khenaidoo4c9e5592019-09-09 16:20:41 -04001566 log.Debugw("generating-graph", log.Fields{"lDeviceId": agent.logicalDeviceId, "lPorts": len(ld.Ports)})
khenaidoo3d3b8c22019-05-22 18:10:39 -04001567 if agent.deviceGraph == nil {
1568 agent.deviceGraph = graph.NewDeviceGraph(agent.logicalDeviceId, agent.deviceMgr.GetDevice)
1569 }
khenaidoo0a822f92019-05-08 15:15:57 -04001570 agent.deviceGraph.ComputeRoutes(ld.Ports)
khenaidoo3d3b8c22019-05-22 18:10:39 -04001571 agent.deviceGraph.Print()
khenaidoo0a822f92019-05-08 15:15:57 -04001572 }
1573}
1574
khenaidoofc1314d2019-03-14 09:34:21 -04001575// portAdded is a callback invoked when a port is added to the logical device.
1576// TODO: To use when POST_ADD is fixed.
1577func (agent *LogicalDeviceAgent) portAdded(args ...interface{}) interface{} {
1578 log.Debugw("portAdded-callback", log.Fields{"argsLen": len(args)})
1579
1580 var port *voltha.LogicalPort
1581
1582 // Sanity check
1583 if args[0] != nil {
1584 log.Warnw("previous-data-not-nil", log.Fields{"args0": args[0]})
1585 }
1586 var ok bool
1587 if port, ok = args[1].(*voltha.LogicalPort); !ok {
1588 log.Errorw("invalid-args", log.Fields{"args1": args[1]})
1589 return nil
1590 }
1591
1592 // Set the proxy and callback for that port
1593 agent.portProxiesLock.Lock()
Stephane Barbarie40fd3b22019-04-23 21:50:47 -04001594 agent.portProxies[port.Id] = agent.clusterDataProxy.CreateProxy(
Stephane Barbarieef6650d2019-07-18 12:15:09 -04001595 context.Background(),
khenaidoofc1314d2019-03-14 09:34:21 -04001596 fmt.Sprintf("/logical_devices/%s/ports/%s", agent.logicalDeviceId, port.Id),
1597 false)
1598 agent.portProxies[port.Id].RegisterCallback(model.POST_UPDATE, agent.portUpdated)
1599 agent.portProxiesLock.Unlock()
1600
1601 // Send the port change event to the OF controller
1602 agent.ldeviceMgr.grpcNbiHdlr.sendChangeEvent(agent.logicalDeviceId,
khenaidoo910204f2019-04-08 17:56:40 -04001603 &ofp.OfpPortStatus{Reason: ofp.OfpPortReason_OFPPR_ADD, Desc: port.OfpPort})
khenaidoofc1314d2019-03-14 09:34:21 -04001604
1605 return nil
1606}
1607
1608// portRemoved is a callback invoked when a port is removed from the logical device.
1609// TODO: To use when POST_ADD is fixed.
1610func (agent *LogicalDeviceAgent) portRemoved(args ...interface{}) interface{} {
1611 log.Debugw("portRemoved-callback", log.Fields{"argsLen": len(args)})
1612
1613 var port *voltha.LogicalPort
1614
1615 // Sanity check
1616 if args[1] != nil {
1617 log.Warnw("data-not-nil", log.Fields{"args1": args[1]})
1618 }
1619 var ok bool
1620 if port, ok = args[0].(*voltha.LogicalPort); !ok {
1621 log.Errorw("invalid-args", log.Fields{"args0": args[0]})
1622 return nil
1623 }
1624
1625 // Remove the proxy and callback for that port
1626 agent.portProxiesLock.Lock()
1627 agent.portProxies[port.Id].UnregisterCallback(model.POST_UPDATE, agent.portUpdated)
1628 delete(agent.portProxies, port.Id)
1629 agent.portProxiesLock.Unlock()
1630
1631 // Send the port change event to the OF controller
1632 agent.ldeviceMgr.grpcNbiHdlr.sendChangeEvent(agent.logicalDeviceId,
khenaidoo910204f2019-04-08 17:56:40 -04001633 &ofp.OfpPortStatus{Reason: ofp.OfpPortReason_OFPPR_DELETE, Desc: port.OfpPort})
khenaidoofc1314d2019-03-14 09:34:21 -04001634
1635 return nil
1636}
1637
1638// diff go over two lists of logical ports and return what's new, what's changed and what's removed.
khenaidoo910204f2019-04-08 17:56:40 -04001639func diff(oldList, newList []*voltha.LogicalPort) (newPorts, changedPorts, deletedPorts []*voltha.LogicalPort) {
khenaidoofc1314d2019-03-14 09:34:21 -04001640 newPorts = make([]*voltha.LogicalPort, 0)
1641 changedPorts = make([]*voltha.LogicalPort, 0)
1642 deletedPorts = make([]*voltha.LogicalPort, 0)
1643 for _, o := range oldList {
1644 found := false
khenaidoofc1314d2019-03-14 09:34:21 -04001645 for _, n := range newList {
1646 if o.Id == n.Id {
khenaidoofc1314d2019-03-14 09:34:21 -04001647 found = true
1648 break
1649 }
1650 }
1651 if !found {
1652 deletedPorts = append(deletedPorts, o)
1653 }
khenaidoofc1314d2019-03-14 09:34:21 -04001654 }
1655 for _, n := range newList {
1656 found := false
khenaidoo2bc48282019-07-16 18:13:46 -04001657 changed := false
khenaidoofc1314d2019-03-14 09:34:21 -04001658 for _, o := range oldList {
1659 if o.Id == n.Id {
khenaidoo2bc48282019-07-16 18:13:46 -04001660 changed = !reflect.DeepEqual(o, n)
khenaidoofc1314d2019-03-14 09:34:21 -04001661 found = true
1662 break
1663 }
1664 }
1665 if !found {
1666 newPorts = append(newPorts, n)
1667 }
khenaidoo2bc48282019-07-16 18:13:46 -04001668 if changed {
1669 changedPorts = append(changedPorts, n)
1670 }
khenaidoofc1314d2019-03-14 09:34:21 -04001671 }
1672 return
1673}
1674
1675// portUpdated is invoked when a port is updated on the logical device. Until
1676// the POST_ADD notification is fixed, we will use the logical device to
1677// update that data.
1678func (agent *LogicalDeviceAgent) portUpdated(args ...interface{}) interface{} {
1679 log.Debugw("portUpdated-callback", log.Fields{"argsLen": len(args)})
1680
1681 var oldLD *voltha.LogicalDevice
1682 var newlD *voltha.LogicalDevice
1683
1684 var ok bool
1685 if oldLD, ok = args[0].(*voltha.LogicalDevice); !ok {
1686 log.Errorw("invalid-args", log.Fields{"args0": args[0]})
1687 return nil
1688 }
1689 if newlD, ok = args[1].(*voltha.LogicalDevice); !ok {
1690 log.Errorw("invalid-args", log.Fields{"args1": args[1]})
1691 return nil
1692 }
1693
1694 if reflect.DeepEqual(oldLD.Ports, newlD.Ports) {
1695 log.Debug("ports-have-not-changed")
1696 return nil
1697 }
1698
1699 // Get the difference between the two list
1700 newPorts, changedPorts, deletedPorts := diff(oldLD.Ports, newlD.Ports)
1701
1702 // Send the port change events to the OF controller
khenaidoo2c6a0992019-04-29 13:46:56 -04001703 for _, newP := range newPorts {
khenaidoofc1314d2019-03-14 09:34:21 -04001704 go agent.ldeviceMgr.grpcNbiHdlr.sendChangeEvent(agent.logicalDeviceId,
khenaidoo2c6a0992019-04-29 13:46:56 -04001705 &ofp.OfpPortStatus{Reason: ofp.OfpPortReason_OFPPR_ADD, Desc: newP.OfpPort})
khenaidoofc1314d2019-03-14 09:34:21 -04001706 }
1707 for _, change := range changedPorts {
1708 go agent.ldeviceMgr.grpcNbiHdlr.sendChangeEvent(agent.logicalDeviceId,
khenaidoo910204f2019-04-08 17:56:40 -04001709 &ofp.OfpPortStatus{Reason: ofp.OfpPortReason_OFPPR_MODIFY, Desc: change.OfpPort})
khenaidoofc1314d2019-03-14 09:34:21 -04001710 }
1711 for _, del := range deletedPorts {
1712 go agent.ldeviceMgr.grpcNbiHdlr.sendChangeEvent(agent.logicalDeviceId,
khenaidoo910204f2019-04-08 17:56:40 -04001713 &ofp.OfpPortStatus{Reason: ofp.OfpPortReason_OFPPR_DELETE, Desc: del.OfpPort})
khenaidoofc1314d2019-03-14 09:34:21 -04001714 }
1715
1716 return nil
1717}
1718
khenaidoo8f474192019-04-03 17:20:44 -04001719// addNNILogicalPort adds an NNI port to the logical device. It returns a bool representing whether a port has been
1720// added and an eror in case a valid error is encountered. If the port was successfully added it will return
1721// (true, nil). If the device is not in the correct state it will return (false, nil) as this is a valid
1722// scenario. This also applies to the case where the port was already added.
khenaidoo910204f2019-04-08 17:56:40 -04001723func (agent *LogicalDeviceAgent) addNNILogicalPort(device *voltha.Device, port *voltha.Port) (bool, error) {
khenaidoo1ce37ad2019-03-24 22:07:24 -04001724 log.Debugw("addNNILogicalPort", log.Fields{"NNI": port})
khenaidoo8f474192019-04-03 17:20:44 -04001725 if device.AdminState != voltha.AdminState_ENABLED || device.OperStatus != voltha.OperStatus_ACTIVE {
1726 log.Infow("device-not-ready", log.Fields{"deviceId": device.Id, "admin": device.AdminState, "oper": device.OperStatus})
1727 return false, nil
khenaidoofc1314d2019-03-14 09:34:21 -04001728 }
khenaidoo1ce37ad2019-03-24 22:07:24 -04001729 agent.lockLogicalDevice.RLock()
1730 if agent.portExist(device, port) {
1731 log.Debugw("port-already-exist", log.Fields{"port": port})
1732 agent.lockLogicalDevice.RUnlock()
khenaidoo8f474192019-04-03 17:20:44 -04001733 return false, nil
khenaidoo1ce37ad2019-03-24 22:07:24 -04001734 }
1735 agent.lockLogicalDevice.RUnlock()
1736
khenaidoofc1314d2019-03-14 09:34:21 -04001737 var portCap *ic.PortCapability
1738 var err error
1739 // First get the port capability
1740 if portCap, err = agent.deviceMgr.getPortCapability(nil, device.Id, port.PortNo); err != nil {
1741 log.Errorw("error-retrieving-port-capabilities", log.Fields{"error": err})
khenaidoo8f474192019-04-03 17:20:44 -04001742 return false, err
khenaidoofc1314d2019-03-14 09:34:21 -04001743 }
khenaidoo1ce37ad2019-03-24 22:07:24 -04001744
1745 agent.lockLogicalDevice.Lock()
1746 defer agent.lockLogicalDevice.Unlock()
1747 // Double check again if this port has been already added since the getPortCapability could have taken a long time
1748 if agent.portExist(device, port) {
1749 log.Debugw("port-already-exist", log.Fields{"port": port})
khenaidoo8f474192019-04-03 17:20:44 -04001750 return false, nil
khenaidoo1ce37ad2019-03-24 22:07:24 -04001751 }
1752
khenaidoofc1314d2019-03-14 09:34:21 -04001753 portCap.Port.RootPort = true
1754 lp := (proto.Clone(portCap.Port)).(*voltha.LogicalPort)
1755 lp.DeviceId = device.Id
1756 lp.Id = fmt.Sprintf("nni-%d", port.PortNo)
1757 lp.OfpPort.PortNo = port.PortNo
1758 lp.OfpPort.Name = lp.Id
1759 lp.DevicePortNo = port.PortNo
1760
khenaidoofc1314d2019-03-14 09:34:21 -04001761 var ld *voltha.LogicalDevice
1762 if ld, err = agent.getLogicalDeviceWithoutLock(); err != nil {
1763 log.Errorw("error-retrieving-logical-device", log.Fields{"error": err})
khenaidoo8f474192019-04-03 17:20:44 -04001764 return false, err
khenaidoofc1314d2019-03-14 09:34:21 -04001765 }
1766 cloned := (proto.Clone(ld)).(*voltha.LogicalDevice)
1767 if cloned.Ports == nil {
1768 cloned.Ports = make([]*voltha.LogicalPort, 0)
1769 }
1770 cloned.Ports = append(cloned.Ports, lp)
1771
1772 if err = agent.updateLogicalDeviceWithoutLock(cloned); err != nil {
1773 log.Errorw("error-updating-logical-device", log.Fields{"error": err})
khenaidoo8f474192019-04-03 17:20:44 -04001774 return false, err
khenaidoofc1314d2019-03-14 09:34:21 -04001775 }
khenaidoo910204f2019-04-08 17:56:40 -04001776
1777 // Update the device graph with this new logical port
1778 clonedLP := (proto.Clone(lp)).(*voltha.LogicalPort)
1779 go agent.updateDeviceGraph(clonedLP)
1780
khenaidoo8f474192019-04-03 17:20:44 -04001781 return true, nil
khenaidoofc1314d2019-03-14 09:34:21 -04001782}
1783
khenaidoo910204f2019-04-08 17:56:40 -04001784func (agent *LogicalDeviceAgent) portExist(device *voltha.Device, port *voltha.Port) bool {
khenaidoo54544ae2019-03-18 13:22:39 -04001785 if ldevice, _ := agent.getLogicalDeviceWithoutLock(); ldevice != nil {
khenaidoofc1314d2019-03-14 09:34:21 -04001786 for _, lPort := range ldevice.Ports {
khenaidoo54544ae2019-03-18 13:22:39 -04001787 if lPort.DeviceId == device.Id && lPort.DevicePortNo == port.PortNo && lPort.Id == port.Label {
khenaidoofc1314d2019-03-14 09:34:21 -04001788 return true
1789 }
1790 }
1791 }
1792 return false
1793}
1794
khenaidoo8f474192019-04-03 17:20:44 -04001795// addUNILogicalPort adds an UNI port to the logical device. It returns a bool representing whether a port has been
1796// added and an eror in case a valid error is encountered. If the port was successfully added it will return
1797// (true, nil). If the device is not in the correct state it will return (false, nil) as this is a valid
1798// scenario. This also applies to the case where the port was already added.
khenaidoo910204f2019-04-08 17:56:40 -04001799func (agent *LogicalDeviceAgent) addUNILogicalPort(childDevice *voltha.Device, port *voltha.Port) (bool, error) {
khenaidoofc1314d2019-03-14 09:34:21 -04001800 log.Debugw("addUNILogicalPort", log.Fields{"port": port})
khenaidoo8f474192019-04-03 17:20:44 -04001801 if childDevice.AdminState != voltha.AdminState_ENABLED || childDevice.OperStatus != voltha.OperStatus_ACTIVE {
1802 log.Infow("device-not-ready", log.Fields{"deviceId": childDevice.Id, "admin": childDevice.AdminState, "oper": childDevice.OperStatus})
1803 return false, nil
khenaidoofc1314d2019-03-14 09:34:21 -04001804 }
khenaidoo1ce37ad2019-03-24 22:07:24 -04001805 agent.lockLogicalDevice.RLock()
1806 if agent.portExist(childDevice, port) {
1807 log.Debugw("port-already-exist", log.Fields{"port": port})
1808 agent.lockLogicalDevice.RUnlock()
khenaidoo8f474192019-04-03 17:20:44 -04001809 return false, nil
khenaidoo1ce37ad2019-03-24 22:07:24 -04001810 }
1811 agent.lockLogicalDevice.RUnlock()
khenaidoofc1314d2019-03-14 09:34:21 -04001812 var portCap *ic.PortCapability
1813 var err error
1814 // First get the port capability
1815 if portCap, err = agent.deviceMgr.getPortCapability(nil, childDevice.Id, port.PortNo); err != nil {
1816 log.Errorw("error-retrieving-port-capabilities", log.Fields{"error": err})
khenaidoo8f474192019-04-03 17:20:44 -04001817 return false, err
khenaidoofc1314d2019-03-14 09:34:21 -04001818 }
khenaidoo1ce37ad2019-03-24 22:07:24 -04001819 agent.lockLogicalDevice.Lock()
1820 defer agent.lockLogicalDevice.Unlock()
1821 // Double check again if this port has been already added since the getPortCapability could have taken a long time
1822 if agent.portExist(childDevice, port) {
1823 log.Debugw("port-already-exist", log.Fields{"port": port})
khenaidoo8f474192019-04-03 17:20:44 -04001824 return false, nil
khenaidoo1ce37ad2019-03-24 22:07:24 -04001825 }
khenaidoofc1314d2019-03-14 09:34:21 -04001826 // Get stored logical device
1827 if ldevice, err := agent.getLogicalDeviceWithoutLock(); err != nil {
khenaidoo8f474192019-04-03 17:20:44 -04001828 return false, status.Error(codes.NotFound, agent.logicalDeviceId)
khenaidoofc1314d2019-03-14 09:34:21 -04001829 } else {
1830 log.Debugw("adding-uni", log.Fields{"deviceId": childDevice.Id})
1831 portCap.Port.RootPort = false
Matt Jeanneret3815e322019-03-12 19:15:49 -04001832 portCap.Port.Id = port.Label
1833 portCap.Port.OfpPort.PortNo = port.PortNo
khenaidoofc1314d2019-03-14 09:34:21 -04001834 portCap.Port.DeviceId = childDevice.Id
1835 portCap.Port.DevicePortNo = port.PortNo
1836 cloned := (proto.Clone(ldevice)).(*voltha.LogicalDevice)
1837 if cloned.Ports == nil {
1838 cloned.Ports = make([]*voltha.LogicalPort, 0)
1839 }
1840 cloned.Ports = append(cloned.Ports, portCap.Port)
khenaidoo910204f2019-04-08 17:56:40 -04001841 if err := agent.updateLogicalDeviceWithoutLock(cloned); err != nil {
1842 return false, err
1843 }
khenaidoo910204f2019-04-08 17:56:40 -04001844 // Update the device graph with this new logical port
1845 clonedLP := (proto.Clone(portCap.Port)).(*voltha.LogicalPort)
1846 go agent.updateDeviceGraph(clonedLP)
1847 return true, nil
khenaidoofc1314d2019-03-14 09:34:21 -04001848 }
1849}
1850
khenaidoo43c82122018-11-22 18:38:28 -05001851func (agent *LogicalDeviceAgent) packetOut(packet *ofp.OfpPacketOut) {
khenaidoofdbad6e2018-11-06 22:26:38 -05001852 log.Debugw("packet-out", log.Fields{"packet": packet.GetInPort()})
khenaidoo68c930b2019-05-13 11:46:51 -04001853 outPort := fu.GetPacketOutPort(packet)
khenaidoofdbad6e2018-11-06 22:26:38 -05001854 //frame := packet.GetData()
1855 //TODO: Use a channel between the logical agent and the device agent
khenaidooca301322019-01-09 23:06:32 -05001856 if err := agent.deviceMgr.packetOut(agent.rootDeviceId, outPort, packet); err != nil {
khenaidoo910204f2019-04-08 17:56:40 -04001857 log.Error("packetout-failed", log.Fields{"logicalDeviceID": agent.rootDeviceId})
khenaidooca301322019-01-09 23:06:32 -05001858 }
khenaidoofdbad6e2018-11-06 22:26:38 -05001859}
1860
khenaidoo297cd252019-02-07 22:10:23 -05001861func (agent *LogicalDeviceAgent) packetIn(port uint32, transactionId string, packet []byte) {
1862 log.Debugw("packet-in", log.Fields{"port": port, "packet": packet, "transactionId": transactionId})
khenaidoo68c930b2019-05-13 11:46:51 -04001863 packetIn := fu.MkPacketIn(port, packet)
khenaidoo297cd252019-02-07 22:10:23 -05001864 agent.ldeviceMgr.grpcNbiHdlr.sendPacketIn(agent.logicalDeviceId, transactionId, packetIn)
khenaidooca301322019-01-09 23:06:32 -05001865 log.Debugw("sending-packet-in", log.Fields{"packet-in": packetIn})
khenaidoofdbad6e2018-11-06 22:26:38 -05001866}
khenaidoo2c6a0992019-04-29 13:46:56 -04001867
1868func (agent *LogicalDeviceAgent) addLogicalPortToMap(portNo uint32, nniPort bool) {
1869 agent.lockLogicalPortsNo.Lock()
1870 defer agent.lockLogicalPortsNo.Unlock()
1871 if exist := agent.logicalPortsNo[portNo]; !exist {
1872 agent.logicalPortsNo[portNo] = nniPort
1873 }
1874}
1875
khenaidoo3d3b8c22019-05-22 18:10:39 -04001876func (agent *LogicalDeviceAgent) addLogicalPortsToMap(lps []*voltha.LogicalPort) {
1877 agent.lockLogicalPortsNo.Lock()
1878 defer agent.lockLogicalPortsNo.Unlock()
1879 for _, lp := range lps {
1880 if exist := agent.logicalPortsNo[lp.DevicePortNo]; !exist {
1881 agent.logicalPortsNo[lp.DevicePortNo] = lp.RootPort
1882 }
1883 }
1884}
1885
khenaidoo2c6a0992019-04-29 13:46:56 -04001886func (agent *LogicalDeviceAgent) deleteLogicalPortFromMap(portNo uint32) {
1887 agent.lockLogicalPortsNo.Lock()
1888 defer agent.lockLogicalPortsNo.Unlock()
1889 if exist := agent.logicalPortsNo[portNo]; exist {
1890 delete(agent.logicalPortsNo, portNo)
1891 }
1892}
1893
1894func (agent *LogicalDeviceAgent) isNNIPort(portNo uint32) bool {
1895 agent.lockLogicalPortsNo.RLock()
1896 defer agent.lockLogicalPortsNo.RUnlock()
1897 if exist := agent.logicalPortsNo[portNo]; exist {
1898 return agent.logicalPortsNo[portNo]
1899 }
1900 return false
1901}
1902
1903func (agent *LogicalDeviceAgent) getFirstNNIPort() (uint32, error) {
1904 agent.lockLogicalPortsNo.RLock()
1905 defer agent.lockLogicalPortsNo.RUnlock()
1906 for portNo, nni := range agent.logicalPortsNo {
1907 if nni {
1908 return portNo, nil
1909 }
1910 }
1911 return 0, status.Error(codes.NotFound, "No NNI port found")
1912}