blob: 360d83b61ba970f0c2252a175fc0977e3b9f3490 [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 */
npujar1d86a522019-11-14 17:11:16 +053016
Kent Hagerman2b216042020-04-03 18:28:56 -040017package device
khenaidoob9203542018-09-17 22:56:37 -040018
19import (
20 "context"
21 "errors"
Kent Hagerman45a13e42020-04-13 12:23:50 -040022 "io"
Kent Hagermanfa9d6d42020-05-25 11:49:40 -040023 "strconv"
David Bainbridged1afd662020-03-26 18:27:41 -070024 "strings"
25 "sync"
26 "time"
27
Kent Hagerman433a31a2020-05-20 19:04:48 -040028 "github.com/golang/protobuf/ptypes/empty"
sbarbari17d7e222019-11-05 10:02:29 -050029 "github.com/opencord/voltha-go/db/model"
Kent Hagerman433a31a2020-05-20 19:04:48 -040030 "github.com/opencord/voltha-go/rw_core/core/device/event"
31 "github.com/opencord/voltha-go/rw_core/utils"
Maninderdfadc982020-10-28 14:04:33 +053032 "github.com/opencord/voltha-lib-go/v4/pkg/kafka"
33 "github.com/opencord/voltha-lib-go/v4/pkg/log"
34 "github.com/opencord/voltha-protos/v4/go/openflow_13"
35 "github.com/opencord/voltha-protos/v4/go/voltha"
khenaidoob9203542018-09-17 22:56:37 -040036 "google.golang.org/grpc/codes"
37 "google.golang.org/grpc/status"
khenaidoob9203542018-09-17 22:56:37 -040038)
39
Kent Hagerman2b216042020-04-03 18:28:56 -040040// LogicalManager represent logical device manager attributes
41type LogicalManager struct {
Kent Hagerman45a13e42020-04-13 12:23:50 -040042 *event.Manager
khenaidoo4c9e5592019-09-09 16:20:41 -040043 logicalDeviceAgents sync.Map
Kent Hagerman2b216042020-04-03 18:28:56 -040044 deviceMgr *Manager
npujar467fe752020-01-16 20:17:45 +053045 kafkaICProxy kafka.InterContainerProxy
Mahir Gunyel03de0d32020-06-03 01:36:59 -070046 dbPath *model.Path
Kent Hagermanf5a67352020-04-30 15:15:26 -040047 ldProxy *model.Proxy
khenaidoo442e7c72020-03-10 16:13:48 -040048 defaultTimeout time.Duration
khenaidoo4c9e5592019-09-09 16:20:41 -040049 logicalDevicesLoadingLock sync.RWMutex
50 logicalDeviceLoadingInProgress map[string][]chan int
khenaidoob9203542018-09-17 22:56:37 -040051}
52
Kent Hagerman2b216042020-04-03 18:28:56 -040053func (ldMgr *LogicalManager) addLogicalDeviceAgentToMap(agent *LogicalAgent) {
npujar1d86a522019-11-14 17:11:16 +053054 if _, exist := ldMgr.logicalDeviceAgents.Load(agent.logicalDeviceID); !exist {
55 ldMgr.logicalDeviceAgents.Store(agent.logicalDeviceID, agent)
khenaidoob9203542018-09-17 22:56:37 -040056 }
57}
58
khenaidoo8c3303d2019-02-13 14:59:39 -050059// getLogicalDeviceAgent returns the logical device agent. If the device is not in memory then the device will
60// be loaded from dB and a logical device agent created to managed it.
Kent Hagerman2b216042020-04-03 18:28:56 -040061func (ldMgr *LogicalManager) getLogicalDeviceAgent(ctx context.Context, logicalDeviceID string) *LogicalAgent {
Rohan Agrawal31f21802020-06-12 05:38:46 +000062 logger.Debugw(ctx, "get-logical-device-agent", log.Fields{"logical-device-id": logicalDeviceID})
npujar1d86a522019-11-14 17:11:16 +053063 agent, ok := ldMgr.logicalDeviceAgents.Load(logicalDeviceID)
64 if ok {
Kent Hagerman2b216042020-04-03 18:28:56 -040065 lda := agent.(*LogicalAgent)
khenaidoo93d5a3d2020-01-15 12:37:05 -050066 if lda.logicalDevice == nil {
67 // This can happen when an agent for the logical device has been created but the logical device
68 // itself is not ready for action as it is waiting for switch and port capabilities from the
69 // relevant adapter. In such a case prevent any request aimed at that logical device.
Himani Chawlab4c25912020-11-12 17:16:38 +053070 logger.Debugf(ctx, "logical-device-%s-is-not-ready-to-serve-requests", logicalDeviceID)
khenaidoo93d5a3d2020-01-15 12:37:05 -050071 return nil
72 }
73 return lda
npujar1d86a522019-11-14 17:11:16 +053074 }
75 // Try to load into memory - loading will also create the logical device agent
npujar467fe752020-01-16 20:17:45 +053076 if err := ldMgr.load(ctx, logicalDeviceID); err == nil {
npujar1d86a522019-11-14 17:11:16 +053077 if agent, ok = ldMgr.logicalDeviceAgents.Load(logicalDeviceID); ok {
Kent Hagerman2b216042020-04-03 18:28:56 -040078 return agent.(*LogicalAgent)
khenaidoo8c3303d2019-02-13 14:59:39 -050079 }
khenaidoob9203542018-09-17 22:56:37 -040080 }
81 return nil
82}
83
Kent Hagerman2b216042020-04-03 18:28:56 -040084func (ldMgr *LogicalManager) deleteLogicalDeviceAgent(logicalDeviceID string) {
npujar1d86a522019-11-14 17:11:16 +053085 ldMgr.logicalDeviceAgents.Delete(logicalDeviceID)
khenaidoo92e62c52018-10-03 14:02:54 -040086}
87
khenaidoo8c3303d2019-02-13 14:59:39 -050088// GetLogicalDevice provides a cloned most up to date logical device. If device is not in memory
89// it will be fetched from the dB
Kent Hagerman45a13e42020-04-13 12:23:50 -040090func (ldMgr *LogicalManager) GetLogicalDevice(ctx context.Context, id *voltha.ID) (*voltha.LogicalDevice, error) {
Himani Chawlab4c25912020-11-12 17:16:38 +053091 ctx = utils.WithRPCMetadataContext(ctx, "GetLogicalDevice")
92 logger.Debugw(ctx, "get-logical-device", log.Fields{"logical-device-id": id})
Kent Hagerman45a13e42020-04-13 12:23:50 -040093 if agent := ldMgr.getLogicalDeviceAgent(ctx, id.Id); agent != nil {
Kent Hagermancba2f302020-07-28 13:37:36 -040094 return agent.GetLogicalDeviceReadOnly(ctx)
khenaidoob9203542018-09-17 22:56:37 -040095 }
96 return nil, status.Errorf(codes.NotFound, "%s", id)
97}
98
Kent Hagerman2b216042020-04-03 18:28:56 -040099//ListLogicalDevices returns the list of all logical devices
Kent Hagerman45a13e42020-04-13 12:23:50 -0400100func (ldMgr *LogicalManager) ListLogicalDevices(ctx context.Context, _ *empty.Empty) (*voltha.LogicalDevices, error) {
Himani Chawlab4c25912020-11-12 17:16:38 +0530101 ctx = utils.WithRPCMetadataContext(ctx, "ListLogicalDevices")
102 logger.Debug(ctx, "list-all-logical-devices")
Kent Hagerman4f355f52020-03-30 16:01:33 -0400103
104 var logicalDevices []*voltha.LogicalDevice
Esin Karamana4e4e002021-03-02 10:42:16 +0000105 ldMgr.logicalDeviceAgents.Range(func(key, value interface{}) bool {
106 if ld, err := value.(*LogicalAgent).GetLogicalDeviceReadOnly(ctx); err == nil {
107 logicalDevices = append(logicalDevices, ld)
108 } else {
109 logger.Errorw(ctx, "unable-to-get-logical-device", log.Fields{"err": err})
110 }
111 return true
112 })
Kent Hagerman4f355f52020-03-30 16:01:33 -0400113 return &voltha.LogicalDevices{Items: logicalDevices}, nil
khenaidoob9203542018-09-17 22:56:37 -0400114}
115
Kent Hagerman2b216042020-04-03 18:28:56 -0400116func (ldMgr *LogicalManager) createLogicalDevice(ctx context.Context, device *voltha.Device) (*string, error) {
divyadesaicb8b59d2020-08-18 09:55:47 +0000117 logger.Debugw(ctx, "creating-logical-device", log.Fields{"device-id": device.Id})
khenaidoob9203542018-09-17 22:56:37 -0400118 // Sanity check
119 if !device.Root {
khenaidoo2c6a0992019-04-29 13:46:56 -0400120 return nil, errors.New("device-not-root")
khenaidoob9203542018-09-17 22:56:37 -0400121 }
122
123 // Create a logical device agent - the logical device Id is based on the mac address of the device
124 // For now use the serial number - it may contain any combination of alphabetic characters and numbers,
125 // with length varying from eight characters to a maximum of 14 characters. Mac Address is part of oneof
126 // in the Device model. May need to be moved out.
Kent Hagerman2b216042020-04-03 18:28:56 -0400127 id := utils.CreateLogicalDeviceID()
David Bainbridged1afd662020-03-26 18:27:41 -0700128 sn := strings.Replace(device.MacAddress, ":", "", -1)
khenaidoo92e62c52018-10-03 14:02:54 -0400129 if id == "" {
divyadesaicb8b59d2020-08-18 09:55:47 +0000130 logger.Errorw(ctx, "mac-address-not-set", log.Fields{"device-id": device.Id, "serial-number": sn})
khenaidoo92e62c52018-10-03 14:02:54 -0400131 return nil, errors.New("mac-address-not-set")
132 }
David Bainbridged1afd662020-03-26 18:27:41 -0700133
divyadesaicb8b59d2020-08-18 09:55:47 +0000134 logger.Debugw(ctx, "logical-device-id", log.Fields{"logical-device-id": id})
khenaidoob9203542018-09-17 22:56:37 -0400135
Rohan Agrawal31f21802020-06-12 05:38:46 +0000136 agent := newLogicalAgent(ctx, id, sn, device.Id, ldMgr, ldMgr.deviceMgr, ldMgr.dbPath, ldMgr.ldProxy, ldMgr.defaultTimeout)
khenaidoob9203542018-09-17 22:56:37 -0400137 ldMgr.addLogicalDeviceAgentToMap(agent)
khenaidooad06fd72019-10-28 12:26:05 -0400138
139 // Update the root device with the logical device Id reference
npujar467fe752020-01-16 20:17:45 +0530140 if err := ldMgr.deviceMgr.setParentID(ctx, device, id); err != nil {
divyadesaicb8b59d2020-08-18 09:55:47 +0000141 logger.Errorw(ctx, "failed-setting-parent-id", log.Fields{"logical-device-id": id, "device-id": device.Id})
khenaidooad06fd72019-10-28 12:26:05 -0400142 return nil, err
143 }
144
npujar1d86a522019-11-14 17:11:16 +0530145 go func() {
Kent Hagermanf5a67352020-04-30 15:15:26 -0400146 //TODO: either wait for the agent to be started before returning, or
147 // implement locks in the agent to ensure request are not processed before start() is complete
Himani Chawlab4c25912020-11-12 17:16:38 +0530148 ldCtx := utils.WithSpanAndRPCMetadataFromContext(ctx)
149 err := agent.start(ldCtx, false)
npujar1d86a522019-11-14 17:11:16 +0530150 if err != nil {
Rohan Agrawal31f21802020-06-12 05:38:46 +0000151 logger.Errorw(ctx, "unable-to-create-the-logical-device", log.Fields{"error": err})
khenaidoo442e7c72020-03-10 16:13:48 -0400152 ldMgr.deleteLogicalDeviceAgent(id)
npujar1d86a522019-11-14 17:11:16 +0530153 }
154 }()
khenaidoob9203542018-09-17 22:56:37 -0400155
Rohan Agrawal31f21802020-06-12 05:38:46 +0000156 logger.Debug(ctx, "creating-logical-device-ends")
khenaidoob9203542018-09-17 22:56:37 -0400157 return &id, nil
158}
159
khenaidoo6d62c002019-05-15 21:57:03 -0400160// stopManagingLogicalDeviceWithDeviceId stops the management of the logical device. This implies removal of any
161// reference of this logical device in cache. The device Id is passed as param because the logical device may already
162// have been removed from the model. This function returns the logical device Id if found
Kent Hagerman2b216042020-04-03 18:28:56 -0400163func (ldMgr *LogicalManager) stopManagingLogicalDeviceWithDeviceID(ctx context.Context, id string) string {
divyadesaicb8b59d2020-08-18 09:55:47 +0000164 logger.Infow(ctx, "stop-managing-logical-device", log.Fields{"device-id": id})
khenaidoo6d62c002019-05-15 21:57:03 -0400165 // Go over the list of logical device agents to find the one which has rootDeviceId as id
npujar1d86a522019-11-14 17:11:16 +0530166 var ldID = ""
Stephane Barbarieef6650d2019-07-18 12:15:09 -0400167 ldMgr.logicalDeviceAgents.Range(func(key, value interface{}) bool {
Kent Hagerman2b216042020-04-03 18:28:56 -0400168 ldAgent := value.(*LogicalAgent)
npujar1d86a522019-11-14 17:11:16 +0530169 if ldAgent.rootDeviceID == id {
divyadesaicb8b59d2020-08-18 09:55:47 +0000170 logger.Infow(ctx, "stopping-logical-device-agent", log.Fields{"logical-device-id": key})
npujar467fe752020-01-16 20:17:45 +0530171 if err := ldAgent.stop(ctx); err != nil {
Rohan Agrawal31f21802020-06-12 05:38:46 +0000172 logger.Errorw(ctx, "failed-to-stop-LDAgent", log.Fields{"error": err})
Thomas Lee Se5a44012019-11-07 20:32:24 +0530173 return false
174 }
npujar1d86a522019-11-14 17:11:16 +0530175 ldID = key.(string)
176 ldMgr.logicalDeviceAgents.Delete(ldID)
khenaidoo6d62c002019-05-15 21:57:03 -0400177 }
Stephane Barbarieef6650d2019-07-18 12:15:09 -0400178 return true
179 })
npujar1d86a522019-11-14 17:11:16 +0530180 return ldID
khenaidoo6d62c002019-05-15 21:57:03 -0400181}
182
183//getLogicalDeviceFromModel retrieves the logical device data from the model.
Kent Hagerman2b216042020-04-03 18:28:56 -0400184func (ldMgr *LogicalManager) getLogicalDeviceFromModel(ctx context.Context, lDeviceID string) (*voltha.LogicalDevice, error) {
Kent Hagerman4f355f52020-03-30 16:01:33 -0400185 logicalDevice := &voltha.LogicalDevice{}
Kent Hagermanf5a67352020-04-30 15:15:26 -0400186 if have, err := ldMgr.ldProxy.Get(ctx, lDeviceID, logicalDevice); err != nil {
Rohan Agrawal31f21802020-06-12 05:38:46 +0000187 logger.Errorw(ctx, "failed-to-get-logical-devices-from-cluster-proxy", log.Fields{"error": err})
Thomas Lee Se5a44012019-11-07 20:32:24 +0530188 return nil, err
Kent Hagerman4f355f52020-03-30 16:01:33 -0400189 } else if !have {
190 return nil, status.Error(codes.NotFound, lDeviceID)
Thomas Lee Se5a44012019-11-07 20:32:24 +0530191 }
Kent Hagerman4f355f52020-03-30 16:01:33 -0400192
193 return logicalDevice, nil
khenaidoo6d62c002019-05-15 21:57:03 -0400194}
195
khenaidoo297cd252019-02-07 22:10:23 -0500196// load loads a logical device manager in memory
Kent Hagerman2b216042020-04-03 18:28:56 -0400197func (ldMgr *LogicalManager) load(ctx context.Context, lDeviceID string) error {
npujar1d86a522019-11-14 17:11:16 +0530198 if lDeviceID == "" {
khenaidoo4c9e5592019-09-09 16:20:41 -0400199 return nil
khenaidoo297cd252019-02-07 22:10:23 -0500200 }
khenaidoo4c9e5592019-09-09 16:20:41 -0400201 // Add a lock to prevent two concurrent calls from loading the same device twice
202 ldMgr.logicalDevicesLoadingLock.Lock()
npujar1d86a522019-11-14 17:11:16 +0530203 if _, exist := ldMgr.logicalDeviceLoadingInProgress[lDeviceID]; !exist {
204 if ldAgent, _ := ldMgr.logicalDeviceAgents.Load(lDeviceID); ldAgent == nil {
205 ldMgr.logicalDeviceLoadingInProgress[lDeviceID] = []chan int{make(chan int, 1)}
khenaidoo4c9e5592019-09-09 16:20:41 -0400206 ldMgr.logicalDevicesLoadingLock.Unlock()
npujar467fe752020-01-16 20:17:45 +0530207 if _, err := ldMgr.getLogicalDeviceFromModel(ctx, lDeviceID); err == nil {
Rohan Agrawal31f21802020-06-12 05:38:46 +0000208 logger.Debugw(ctx, "loading-logical-device", log.Fields{"lDeviceId": lDeviceID})
209 agent := newLogicalAgent(ctx, lDeviceID, "", "", ldMgr, ldMgr.deviceMgr, ldMgr.dbPath, ldMgr.ldProxy, ldMgr.defaultTimeout)
npujar467fe752020-01-16 20:17:45 +0530210 if err := agent.start(ctx, true); err != nil {
khenaidoo442e7c72020-03-10 16:13:48 -0400211 return err
khenaidoo4c9e5592019-09-09 16:20:41 -0400212 }
khenaidoo442e7c72020-03-10 16:13:48 -0400213 ldMgr.logicalDeviceAgents.Store(agent.logicalDeviceID, agent)
khenaidoo4c9e5592019-09-09 16:20:41 -0400214 } else {
Himani Chawlab4c25912020-11-12 17:16:38 +0530215 logger.Debugw(ctx, "logical-device-not-in-model", log.Fields{"logical-device-id": lDeviceID})
khenaidoo4c9e5592019-09-09 16:20:41 -0400216 }
217 // announce completion of task to any number of waiting channels
218 ldMgr.logicalDevicesLoadingLock.Lock()
npujar1d86a522019-11-14 17:11:16 +0530219 if v, ok := ldMgr.logicalDeviceLoadingInProgress[lDeviceID]; ok {
khenaidoo4c9e5592019-09-09 16:20:41 -0400220 for _, ch := range v {
221 close(ch)
222 }
npujar1d86a522019-11-14 17:11:16 +0530223 delete(ldMgr.logicalDeviceLoadingInProgress, lDeviceID)
khenaidoo4c9e5592019-09-09 16:20:41 -0400224 }
225 ldMgr.logicalDevicesLoadingLock.Unlock()
226 } else {
227 ldMgr.logicalDevicesLoadingLock.Unlock()
228 }
229 } else {
230 ch := make(chan int, 1)
npujar1d86a522019-11-14 17:11:16 +0530231 ldMgr.logicalDeviceLoadingInProgress[lDeviceID] = append(ldMgr.logicalDeviceLoadingInProgress[lDeviceID], ch)
khenaidoo4c9e5592019-09-09 16:20:41 -0400232 ldMgr.logicalDevicesLoadingLock.Unlock()
233 // Wait for the channel to be closed, implying the process loading this device is done.
234 <-ch
235 }
npujar1d86a522019-11-14 17:11:16 +0530236 if _, exist := ldMgr.logicalDeviceAgents.Load(lDeviceID); exist {
khenaidoo4c9e5592019-09-09 16:20:41 -0400237 return nil
238 }
npujar1d86a522019-11-14 17:11:16 +0530239 return status.Errorf(codes.Aborted, "Error loading logical device %s", lDeviceID)
khenaidoo297cd252019-02-07 22:10:23 -0500240}
241
Kent Hagerman2b216042020-04-03 18:28:56 -0400242func (ldMgr *LogicalManager) deleteLogicalDevice(ctx context.Context, device *voltha.Device) error {
divyadesaicb8b59d2020-08-18 09:55:47 +0000243 logger.Debugw(ctx, "deleting-logical-device", log.Fields{"device-id": device.Id})
khenaidoo92e62c52018-10-03 14:02:54 -0400244 // Sanity check
245 if !device.Root {
khenaidoo2c6a0992019-04-29 13:46:56 -0400246 return errors.New("device-not-root")
khenaidoo92e62c52018-10-03 14:02:54 -0400247 }
npujar1d86a522019-11-14 17:11:16 +0530248 logDeviceID := device.ParentId
npujar467fe752020-01-16 20:17:45 +0530249 if agent := ldMgr.getLogicalDeviceAgent(ctx, logDeviceID); agent != nil {
khenaidoo92e62c52018-10-03 14:02:54 -0400250 // Stop the logical device agent
Thomas Lee Se5a44012019-11-07 20:32:24 +0530251 if err := agent.stop(ctx); err != nil {
Rohan Agrawal31f21802020-06-12 05:38:46 +0000252 logger.Errorw(ctx, "failed-to-stop-agent", log.Fields{"error": err})
Thomas Lee Se5a44012019-11-07 20:32:24 +0530253 return err
254 }
khenaidoo92e62c52018-10-03 14:02:54 -0400255 //Remove the logical device agent from the Map
npujar1d86a522019-11-14 17:11:16 +0530256 ldMgr.deleteLogicalDeviceAgent(logDeviceID)
khenaidoo92e62c52018-10-03 14:02:54 -0400257 }
258
Rohan Agrawal31f21802020-06-12 05:38:46 +0000259 logger.Debug(ctx, "deleting-logical-device-ends")
khenaidoo92e62c52018-10-03 14:02:54 -0400260 return nil
261}
262
Kent Hagerman2b216042020-04-03 18:28:56 -0400263func (ldMgr *LogicalManager) getLogicalDeviceID(ctx context.Context, device *voltha.Device) (*string, error) {
khenaidoo92e62c52018-10-03 14:02:54 -0400264 // Device can either be a parent or a child device
265 if device.Root {
266 // Parent device. The ID of a parent device is the logical device ID
267 return &device.ParentId, nil
268 }
269 // Device is child device
270 // retrieve parent device using child device ID
Kent Hagermanfa9d6d42020-05-25 11:49:40 -0400271 // TODO: return (string, have) instead of *string
272 // also: If not root device, just return device.parentID instead of loading the parent device.
npujar467fe752020-01-16 20:17:45 +0530273 if parentDevice := ldMgr.deviceMgr.getParentDevice(ctx, device); parentDevice != nil {
khenaidoo92e62c52018-10-03 14:02:54 -0400274 return &parentDevice.ParentId, nil
275 }
276 return nil, status.Errorf(codes.NotFound, "%s", device.Id)
277}
278
Kent Hagerman2b216042020-04-03 18:28:56 -0400279func (ldMgr *LogicalManager) getLogicalDeviceIDFromDeviceID(ctx context.Context, deviceID string) (*string, error) {
khenaidoo3ab34882019-05-02 21:33:30 -0400280 // Get the device
281 var device *voltha.Device
282 var err error
Kent Hagermancba2f302020-07-28 13:37:36 -0400283 if device, err = ldMgr.deviceMgr.getDeviceReadOnly(ctx, deviceID); err != nil {
khenaidoo3ab34882019-05-02 21:33:30 -0400284 return nil, err
285 }
npujar467fe752020-01-16 20:17:45 +0530286 return ldMgr.getLogicalDeviceID(ctx, device)
khenaidoo3ab34882019-05-02 21:33:30 -0400287}
288
npujar1d86a522019-11-14 17:11:16 +0530289// ListLogicalDeviceFlows returns the flows of logical device
Kent Hagerman45a13e42020-04-13 12:23:50 -0400290func (ldMgr *LogicalManager) ListLogicalDeviceFlows(ctx context.Context, id *voltha.ID) (*openflow_13.Flows, error) {
Himani Chawlab4c25912020-11-12 17:16:38 +0530291 ctx = utils.WithRPCMetadataContext(ctx, "ListLogicalDeviceFlows")
292 logger.Debugw(ctx, "list-logical-device-flows", log.Fields{"logical-device-id": id.Id})
Kent Hagerman433a31a2020-05-20 19:04:48 -0400293 agent := ldMgr.getLogicalDeviceAgent(ctx, id.Id)
294 if agent == nil {
295 return nil, status.Errorf(codes.NotFound, "%s", id.Id)
khenaidoodd237172019-05-27 16:37:17 -0400296 }
Kent Hagerman433a31a2020-05-20 19:04:48 -0400297
298 flows := agent.listLogicalDeviceFlows()
299 ctr, ret := 0, make([]*openflow_13.OfpFlowStats, len(flows))
300 for _, flow := range flows {
301 ret[ctr] = flow
302 ctr++
303 }
304 return &openflow_13.Flows{Items: ret}, nil
khenaidoodd237172019-05-27 16:37:17 -0400305}
306
npujar1d86a522019-11-14 17:11:16 +0530307// ListLogicalDeviceFlowGroups returns logical device flow groups
Kent Hagerman45a13e42020-04-13 12:23:50 -0400308func (ldMgr *LogicalManager) ListLogicalDeviceFlowGroups(ctx context.Context, id *voltha.ID) (*openflow_13.FlowGroups, error) {
Himani Chawlab4c25912020-11-12 17:16:38 +0530309 ctx = utils.WithRPCMetadataContext(ctx, "ListLogicalDeviceFlowGroups")
310 logger.Debugw(ctx, "list-logical-device-flow-groups", log.Fields{"logical-device-id": id.Id})
Kent Hagerman433a31a2020-05-20 19:04:48 -0400311 agent := ldMgr.getLogicalDeviceAgent(ctx, id.Id)
312 if agent == nil {
313 return nil, status.Errorf(codes.NotFound, "%s", id.Id)
khenaidoodd237172019-05-27 16:37:17 -0400314 }
Kent Hagerman433a31a2020-05-20 19:04:48 -0400315
316 groups := agent.listLogicalDeviceGroups()
317 ctr, ret := 0, make([]*openflow_13.OfpGroupEntry, len(groups))
318 for _, group := range groups {
319 ret[ctr] = group
320 ctr++
321 }
322 return &openflow_13.FlowGroups{Items: ret}, nil
khenaidoodd237172019-05-27 16:37:17 -0400323}
324
npujar1d86a522019-11-14 17:11:16 +0530325// ListLogicalDevicePorts returns logical device ports
Kent Hagerman45a13e42020-04-13 12:23:50 -0400326func (ldMgr *LogicalManager) ListLogicalDevicePorts(ctx context.Context, id *voltha.ID) (*voltha.LogicalPorts, error) {
Himani Chawlab4c25912020-11-12 17:16:38 +0530327 ctx = utils.WithRPCMetadataContext(ctx, "ListLogicalDevicePorts")
328 logger.Debugw(ctx, "list-logical-device-ports", log.Fields{"logical-device-id": id.Id})
Kent Hagermanfa9d6d42020-05-25 11:49:40 -0400329 agent := ldMgr.getLogicalDeviceAgent(ctx, id.Id)
330 if agent == nil {
331 return nil, status.Errorf(codes.NotFound, "%s", id.Id)
khenaidoo19d7b632018-10-30 10:49:50 -0400332 }
Kent Hagermanfa9d6d42020-05-25 11:49:40 -0400333
Rohan Agrawal31f21802020-06-12 05:38:46 +0000334 ports := agent.listLogicalDevicePorts(ctx)
Kent Hagermanfa9d6d42020-05-25 11:49:40 -0400335 ctr, ret := 0, make([]*voltha.LogicalPort, len(ports))
336 for _, port := range ports {
337 ret[ctr] = port
338 ctr++
339 }
340 return &voltha.LogicalPorts{Items: ret}, nil
khenaidoo19d7b632018-10-30 10:49:50 -0400341}
342
Kent Hagerman45a13e42020-04-13 12:23:50 -0400343// GetLogicalDevicePort returns logical device port details
344func (ldMgr *LogicalManager) GetLogicalDevicePort(ctx context.Context, lPortID *voltha.LogicalPortId) (*voltha.LogicalPort, error) {
Himani Chawlab4c25912020-11-12 17:16:38 +0530345 ctx = utils.WithRPCMetadataContext(ctx, "GetLogicalDevicePort")
Kent Hagermanfa9d6d42020-05-25 11:49:40 -0400346 // Get the logical device where this port is attached
347 agent := ldMgr.getLogicalDeviceAgent(ctx, lPortID.Id)
348 if agent == nil {
349 return nil, status.Errorf(codes.NotFound, "%s", lPortID.Id)
khenaidoo19d7b632018-10-30 10:49:50 -0400350 }
Kent Hagermanfa9d6d42020-05-25 11:49:40 -0400351
Rohan Agrawal31f21802020-06-12 05:38:46 +0000352 for _, port := range agent.listLogicalDevicePorts(ctx) {
npujar1d86a522019-11-14 17:11:16 +0530353 if port.Id == lPortID.PortId {
khenaidoo19d7b632018-10-30 10:49:50 -0400354 return port, nil
355 }
356 }
npujar1d86a522019-11-14 17:11:16 +0530357 return nil, status.Errorf(codes.NotFound, "%s-%s", lPortID.Id, lPortID.PortId)
khenaidoo19d7b632018-10-30 10:49:50 -0400358}
359
khenaidoo2c6a0992019-04-29 13:46:56 -0400360// updateLogicalPort sets up a logical port on the logical device based on the device port
361// information, if needed
Kent Hagerman2a07b862020-06-19 15:23:07 -0400362func (ldMgr *LogicalManager) updateLogicalPort(ctx context.Context, device *voltha.Device, devicePorts map[uint32]*voltha.Port, port *voltha.Port) error {
npujar467fe752020-01-16 20:17:45 +0530363 ldID, err := ldMgr.getLogicalDeviceID(ctx, device)
npujar1d86a522019-11-14 17:11:16 +0530364 if err != nil || *ldID == "" {
khenaidoo2c6a0992019-04-29 13:46:56 -0400365 // This is not an error as the logical device may not have been created at this time. In such a case,
366 // the ports will be created when the logical device is ready.
367 return nil
khenaidoo2c6a0992019-04-29 13:46:56 -0400368 }
npujar467fe752020-01-16 20:17:45 +0530369 if agent := ldMgr.getLogicalDeviceAgent(ctx, *ldID); agent != nil {
Kent Hagerman2a07b862020-06-19 15:23:07 -0400370 if err := agent.updateLogicalPort(ctx, device, devicePorts, port); err != nil {
npujar1d86a522019-11-14 17:11:16 +0530371 return err
khenaidoofc1314d2019-03-14 09:34:21 -0400372 }
373 }
374 return nil
375}
376
khenaidoo0a822f92019-05-08 15:15:57 -0400377// deleteLogicalPort removes the logical port associated with a child device
Kent Hagerman2b216042020-04-03 18:28:56 -0400378func (ldMgr *LogicalManager) deleteLogicalPorts(ctx context.Context, deviceID string) error {
Rohan Agrawal31f21802020-06-12 05:38:46 +0000379 logger.Debugw(ctx, "deleting-logical-ports", log.Fields{"device-id": deviceID})
khenaidoo0a822f92019-05-08 15:15:57 -0400380 // Get logical port
npujar467fe752020-01-16 20:17:45 +0530381 ldID, err := ldMgr.getLogicalDeviceIDFromDeviceID(ctx, deviceID)
npujar1d86a522019-11-14 17:11:16 +0530382 if err != nil {
khenaidoo0a822f92019-05-08 15:15:57 -0400383 return err
npujar1d86a522019-11-14 17:11:16 +0530384 }
npujar467fe752020-01-16 20:17:45 +0530385 if agent := ldMgr.getLogicalDeviceAgent(ctx, *ldID); agent != nil {
386 if err = agent.deleteLogicalPorts(ctx, deviceID); err != nil {
Rohan Agrawal31f21802020-06-12 05:38:46 +0000387 logger.Warnw(ctx, "delete-logical-ports-failed", log.Fields{"logical-device-id": *ldID})
npujar1d86a522019-11-14 17:11:16 +0530388 return err
khenaidoo0a822f92019-05-08 15:15:57 -0400389 }
390 }
Rohan Agrawal31f21802020-06-12 05:38:46 +0000391 logger.Debug(ctx, "deleting-logical-ports-ends")
khenaidoo0a822f92019-05-08 15:15:57 -0400392 return nil
393}
394
Kent Hagerman2a07b862020-06-19 15:23:07 -0400395func (ldMgr *LogicalManager) setupUNILogicalPorts(ctx context.Context, childDevice *voltha.Device, childDevicePorts map[uint32]*voltha.Port) error {
Himani Chawlab4c25912020-11-12 17:16:38 +0530396 logger.Debugw(ctx, "setup-uni-logical-ports", log.Fields{"child-device-id": childDevice.Id, "parent-device-id": childDevice.ParentId, "current-data": childDevice})
khenaidoob9203542018-09-17 22:56:37 -0400397 // Sanity check
398 if childDevice.Root {
399 return errors.New("Device-root")
400 }
401
402 // Get the logical device id parent device
npujar1d86a522019-11-14 17:11:16 +0530403 parentID := childDevice.ParentId
npujar467fe752020-01-16 20:17:45 +0530404 logDeviceID := ldMgr.deviceMgr.GetParentDeviceID(ctx, parentID)
khenaidoob9203542018-09-17 22:56:37 -0400405
Himani Chawlab4c25912020-11-12 17:16:38 +0530406 logger.Debugw(ctx, "setup-uni-logical-ports", log.Fields{"logical-device-id": logDeviceID, "parentId": parentID})
khenaidoob9203542018-09-17 22:56:37 -0400407
npujar1d86a522019-11-14 17:11:16 +0530408 if parentID == "" || logDeviceID == "" {
khenaidoo2c6a0992019-04-29 13:46:56 -0400409 return errors.New("device-in-invalid-state")
khenaidoo5e677ae2019-02-28 17:26:29 -0500410 }
411
npujar467fe752020-01-16 20:17:45 +0530412 if agent := ldMgr.getLogicalDeviceAgent(ctx, logDeviceID); agent != nil {
Kent Hagerman2a07b862020-06-19 15:23:07 -0400413 if err := agent.setupUNILogicalPorts(ctx, childDevice, childDevicePorts); err != nil {
khenaidoobcf205b2019-01-25 22:21:14 -0500414 return err
415 }
khenaidoob9203542018-09-17 22:56:37 -0400416 }
khenaidoo21d51152019-02-01 13:48:37 -0500417 return nil
khenaidoob9203542018-09-17 22:56:37 -0400418}
khenaidoo19d7b632018-10-30 10:49:50 -0400419
Kent Hagerman2b216042020-04-03 18:28:56 -0400420func (ldMgr *LogicalManager) deleteAllLogicalPorts(ctx context.Context, device *voltha.Device) error {
Himani Chawlab4c25912020-11-12 17:16:38 +0530421 logger.Debugw(ctx, "delete-all-logical-ports", log.Fields{"device-id": device.Id})
khenaidoo0a822f92019-05-08 15:15:57 -0400422
npujar1d86a522019-11-14 17:11:16 +0530423 var ldID *string
khenaidoo0a822f92019-05-08 15:15:57 -0400424 var err error
425 //Get the logical device Id for this device
npujar467fe752020-01-16 20:17:45 +0530426 if ldID, err = ldMgr.getLogicalDeviceID(ctx, device); err != nil {
divyadesaicb8b59d2020-08-18 09:55:47 +0000427 logger.Warnw(ctx, "no-logical-device-found", log.Fields{"device-id": device.Id, "error": err})
khenaidoo0a822f92019-05-08 15:15:57 -0400428 return err
429 }
npujar467fe752020-01-16 20:17:45 +0530430 if agent := ldMgr.getLogicalDeviceAgent(ctx, *ldID); agent != nil {
Girish Gowdra408cd962020-03-11 14:31:31 -0700431 if err := agent.deleteAllLogicalPorts(ctx); err != nil {
khenaidoo0a822f92019-05-08 15:15:57 -0400432 return err
433 }
434 }
435 return nil
436}
Hardik Windlassc704def2020-02-26 18:23:19 +0000437
Kent Hagerman2b216042020-04-03 18:28:56 -0400438func (ldMgr *LogicalManager) updatePortState(ctx context.Context, deviceID string, portNo uint32, state voltha.OperStatus_Types) error {
Himani Chawlab4c25912020-11-12 17:16:38 +0530439 logger.Debugw(ctx, "update-Port-state", log.Fields{"device-id": deviceID, "state": state, "port-no": portNo})
khenaidoo171b98e2019-10-31 11:48:15 -0400440
npujar1d86a522019-11-14 17:11:16 +0530441 var ldID *string
khenaidoo171b98e2019-10-31 11:48:15 -0400442 var err error
443 //Get the logical device Id for this device
npujar467fe752020-01-16 20:17:45 +0530444 if ldID, err = ldMgr.getLogicalDeviceIDFromDeviceID(ctx, deviceID); err != nil {
divyadesaicb8b59d2020-08-18 09:55:47 +0000445 logger.Warnw(ctx, "no-logical-device-found", log.Fields{"device-id": deviceID, "error": err})
khenaidoo171b98e2019-10-31 11:48:15 -0400446 return err
447 }
npujar467fe752020-01-16 20:17:45 +0530448 if agent := ldMgr.getLogicalDeviceAgent(ctx, *ldID); agent != nil {
Kent Hagermanfa9d6d42020-05-25 11:49:40 -0400449 if err := agent.updatePortState(ctx, portNo, state); err != nil {
khenaidoo171b98e2019-10-31 11:48:15 -0400450 return err
451 }
452 }
453 return nil
454}
khenaidoo0a822f92019-05-08 15:15:57 -0400455
Kent Hagerman45a13e42020-04-13 12:23:50 -0400456// UpdateLogicalDeviceFlowTable updates logical device flow table
457func (ldMgr *LogicalManager) UpdateLogicalDeviceFlowTable(ctx context.Context, flow *openflow_13.FlowTableUpdate) (*empty.Empty, error) {
Himani Chawlab4c25912020-11-12 17:16:38 +0530458 ctx = utils.WithRPCMetadataContext(ctx, "UpdateLogicalDeviceFlowTable")
459 logger.Debugw(ctx, "update-logical-device-flow-table", log.Fields{"logical-device-id": flow.Id})
Kent Hagerman45a13e42020-04-13 12:23:50 -0400460 agent := ldMgr.getLogicalDeviceAgent(ctx, flow.Id)
461 if agent == nil {
462 return nil, status.Errorf(codes.NotFound, "%s", flow.Id)
khenaidoo19d7b632018-10-30 10:49:50 -0400463 }
Maninderf421da62020-12-04 11:44:58 +0530464 return &empty.Empty{}, agent.updateFlowTable(ctx, flow)
khenaidoo19d7b632018-10-30 10:49:50 -0400465}
466
Kent Hagerman45a13e42020-04-13 12:23:50 -0400467// UpdateLogicalDeviceMeterTable - This function sends meter mod request to logical device manager and waits for response
468func (ldMgr *LogicalManager) UpdateLogicalDeviceMeterTable(ctx context.Context, meter *openflow_13.MeterModUpdate) (*empty.Empty, error) {
Himani Chawlab4c25912020-11-12 17:16:38 +0530469 ctx = utils.WithRPCMetadataContext(ctx, "UpdateLogicalDeviceMeterTable")
470 logger.Debugw(ctx, "update-logical-device-meter-table", log.Fields{"logical-device-id": meter.Id})
Kent Hagerman45a13e42020-04-13 12:23:50 -0400471 agent := ldMgr.getLogicalDeviceAgent(ctx, meter.Id)
472 if agent == nil {
473 return nil, status.Errorf(codes.NotFound, "%s", meter.Id)
Manikkaraj kb1a10922019-07-29 12:10:34 -0400474 }
Kent Hagerman45a13e42020-04-13 12:23:50 -0400475 return &empty.Empty{}, agent.updateMeterTable(ctx, meter.MeterMod)
Manikkaraj kb1a10922019-07-29 12:10:34 -0400476}
477
npujar1d86a522019-11-14 17:11:16 +0530478// ListLogicalDeviceMeters returns logical device meters
Kent Hagerman45a13e42020-04-13 12:23:50 -0400479func (ldMgr *LogicalManager) ListLogicalDeviceMeters(ctx context.Context, id *voltha.ID) (*openflow_13.Meters, error) {
Himani Chawlab4c25912020-11-12 17:16:38 +0530480 ctx = utils.WithRPCMetadataContext(ctx, "ListLogicalDeviceMeters")
481 logger.Debugw(ctx, "list-logical-device-meters", log.Fields{"logical-device-id": id.Id})
Kent Hagerman45a13e42020-04-13 12:23:50 -0400482 agent := ldMgr.getLogicalDeviceAgent(ctx, id.Id)
483 if agent == nil {
484 return nil, status.Errorf(codes.NotFound, "%s", id.Id)
Manikkaraj kb1a10922019-07-29 12:10:34 -0400485 }
Kent Hagerman433a31a2020-05-20 19:04:48 -0400486 meters := agent.listLogicalDeviceMeters()
487 ctr, ret := 0, make([]*openflow_13.OfpMeterEntry, len(meters))
488 for _, meter := range meters {
489 ret[ctr] = meter
490 ctr++
491 }
492 return &openflow_13.Meters{Items: ret}, nil
khenaidoo19d7b632018-10-30 10:49:50 -0400493}
494
Kent Hagerman45a13e42020-04-13 12:23:50 -0400495// UpdateLogicalDeviceFlowGroupTable updates logical device flow group table
496func (ldMgr *LogicalManager) UpdateLogicalDeviceFlowGroupTable(ctx context.Context, flow *openflow_13.FlowGroupTableUpdate) (*empty.Empty, error) {
Himani Chawlab4c25912020-11-12 17:16:38 +0530497 ctx = utils.WithRPCMetadataContext(ctx, "UpdateLogicalDeviceFlowGroupTable")
498 logger.Debugw(ctx, "update-group-table", log.Fields{"logical-device-id": flow.Id})
Kent Hagerman45a13e42020-04-13 12:23:50 -0400499 agent := ldMgr.getLogicalDeviceAgent(ctx, flow.Id)
500 if agent == nil {
501 return nil, status.Errorf(codes.NotFound, "%s", flow.Id)
khenaidoo19d7b632018-10-30 10:49:50 -0400502 }
Kent Hagerman45a13e42020-04-13 12:23:50 -0400503 return &empty.Empty{}, agent.updateGroupTable(ctx, flow.GroupMod)
khenaidoo19d7b632018-10-30 10:49:50 -0400504}
505
Kent Hagerman45a13e42020-04-13 12:23:50 -0400506// EnableLogicalDevicePort enables logical device port
507func (ldMgr *LogicalManager) EnableLogicalDevicePort(ctx context.Context, id *voltha.LogicalPortId) (*empty.Empty, error) {
Himani Chawlab4c25912020-11-12 17:16:38 +0530508 ctx = utils.WithRPCMetadataContext(ctx, "EnableLogicalDevicePort")
509 logger.Debugw(ctx, "enable-logical-device-port", log.Fields{"logical-device-id": id})
Kent Hagerman45a13e42020-04-13 12:23:50 -0400510 agent := ldMgr.getLogicalDeviceAgent(ctx, id.Id)
511 if agent == nil {
512 return nil, status.Errorf(codes.NotFound, "%s", id.Id)
khenaidoo19d7b632018-10-30 10:49:50 -0400513 }
Kent Hagermanfa9d6d42020-05-25 11:49:40 -0400514 portNo, err := strconv.ParseUint(id.PortId, 10, 32)
515 if err != nil {
516 return nil, status.Errorf(codes.InvalidArgument, "failed to parse %s as a number", id.PortId)
517 }
518 return &empty.Empty{}, agent.enableLogicalPort(ctx, uint32(portNo))
Kent Hagerman45a13e42020-04-13 12:23:50 -0400519}
520
521// DisableLogicalDevicePort disables logical device port
522func (ldMgr *LogicalManager) DisableLogicalDevicePort(ctx context.Context, id *voltha.LogicalPortId) (*empty.Empty, error) {
Himani Chawlab4c25912020-11-12 17:16:38 +0530523 ctx = utils.WithRPCMetadataContext(ctx, "DisableLogicalDevicePort")
524 logger.Debugw(ctx, "disable-logical-device-port", log.Fields{"logical-device-id": id})
Kent Hagerman45a13e42020-04-13 12:23:50 -0400525 agent := ldMgr.getLogicalDeviceAgent(ctx, id.Id)
526 if agent == nil {
527 return nil, status.Errorf(codes.NotFound, "%s", id.Id)
528 }
Kent Hagermanfa9d6d42020-05-25 11:49:40 -0400529 portNo, err := strconv.ParseUint(id.PortId, 10, 32)
530 if err != nil {
531 return nil, status.Errorf(codes.InvalidArgument, "failed to parse %s as a number", id.PortId)
532 }
533 return &empty.Empty{}, agent.disableLogicalPort(ctx, uint32(portNo))
khenaidoo19d7b632018-10-30 10:49:50 -0400534}
khenaidoofdbad6e2018-11-06 22:26:38 -0500535
Kent Hagerman2b216042020-04-03 18:28:56 -0400536func (ldMgr *LogicalManager) packetIn(ctx context.Context, logicalDeviceID string, port uint32, transactionID string, packet []byte) error {
Himani Chawlab4c25912020-11-12 17:16:38 +0530537 logger.Debugw(ctx, "packet-in", log.Fields{"logical-device-id": logicalDeviceID, "port": port})
npujar467fe752020-01-16 20:17:45 +0530538 if agent := ldMgr.getLogicalDeviceAgent(ctx, logicalDeviceID); agent != nil {
Rohan Agrawal31f21802020-06-12 05:38:46 +0000539 agent.packetIn(ctx, port, transactionID, packet)
khenaidoofdbad6e2018-11-06 22:26:38 -0500540 } else {
divyadesaicb8b59d2020-08-18 09:55:47 +0000541 logger.Error(ctx, "logical-device-not-exist", log.Fields{"logical-device-id": logicalDeviceID})
khenaidoofdbad6e2018-11-06 22:26:38 -0500542 }
543 return nil
544}
Kent Hagerman2b216042020-04-03 18:28:56 -0400545
Kent Hagerman45a13e42020-04-13 12:23:50 -0400546// StreamPacketsOut sends packets to adapter
547func (ldMgr *LogicalManager) StreamPacketsOut(packets voltha.VolthaService_StreamPacketsOutServer) error {
Rohan Agrawal31f21802020-06-12 05:38:46 +0000548 ctx := context.Background()
Himani Chawlab4c25912020-11-12 17:16:38 +0530549 logger.Debugw(ctx, "stream-packets-out-request", log.Fields{"packets": packets})
550
Kent Hagerman45a13e42020-04-13 12:23:50 -0400551loop:
552 for {
553 select {
554 case <-packets.Context().Done():
Himani Chawlab4c25912020-11-12 17:16:38 +0530555 logger.Infow(ctx, "stream-packets-out-context-done", log.Fields{"packets": packets, "error": packets.Context().Err()})
Kent Hagerman45a13e42020-04-13 12:23:50 -0400556 break loop
557 default:
558 }
559
560 packet, err := packets.Recv()
561
Himani Chawlab4c25912020-11-12 17:16:38 +0530562 pktCtx := utils.WithRPCMetadataContext(packets.Context(), "StreamPacketsOut")
563
Kent Hagerman45a13e42020-04-13 12:23:50 -0400564 if err == io.EOF {
Himani Chawlab4c25912020-11-12 17:16:38 +0530565 logger.Debugw(ctx, "received-eof", log.Fields{"packets": packets})
Kent Hagerman45a13e42020-04-13 12:23:50 -0400566 break loop
567 }
Kent Hagerman45a13e42020-04-13 12:23:50 -0400568 if err != nil {
Himani Chawlab4c25912020-11-12 17:16:38 +0530569 logger.Errorw(ctx, "failed-to-receive-packet-out", log.Fields{"error": err})
Andrea Campanellaff2d73a2021-03-04 14:47:17 +0100570 // we do not have the resource Id here due to error in the packet, setting to empty
Himani Chawla606a4f02021-03-23 19:45:58 +0530571 ldMgr.SendRPCEvent(pktCtx, "", err.Error(), nil,
572 "RPC_ERROR_RAISE_EVENT", voltha.EventCategory_COMMUNICATION, nil, time.Now().Unix())
Kent Hagerman45a13e42020-04-13 12:23:50 -0400573 continue
574 }
575
Himani Chawlab4c25912020-11-12 17:16:38 +0530576 if agent := ldMgr.getLogicalDeviceAgent(pktCtx, packet.Id); agent != nil {
577 agent.packetOut(pktCtx, packet.PacketOut)
Kent Hagerman45a13e42020-04-13 12:23:50 -0400578 } else {
Himani Chawlab4c25912020-11-12 17:16:38 +0530579 logger.Errorf(ctx, "no-logical-device-agent-present", log.Fields{"logical-device-id": packet.Id})
Kent Hagerman45a13e42020-04-13 12:23:50 -0400580 }
Kent Hagerman2b216042020-04-03 18:28:56 -0400581 }
Kent Hagerman45a13e42020-04-13 12:23:50 -0400582
Himani Chawlab4c25912020-11-12 17:16:38 +0530583 logger.Debugw(ctx, "stream-packets-out-request-done", log.Fields{"packets": packets})
Kent Hagerman45a13e42020-04-13 12:23:50 -0400584 return nil
Kent Hagerman2b216042020-04-03 18:28:56 -0400585}
Himani Chawlab4c25912020-11-12 17:16:38 +0530586
587func (ldMgr *LogicalManager) SendRPCEvent(ctx context.Context, resourceID, desc string, context map[string]string,
588 id string, category voltha.EventCategory_Types, subCategory *voltha.EventSubCategory_Types, raisedTs int64) {
Mahir Gunyelb0343bf2021-05-11 14:14:26 -0700589 ldMgr.Manager.Agent.GetAndSendRPCEvent(ctx, resourceID, desc, context, id,
Himani Chawlab4c25912020-11-12 17:16:38 +0530590 category, subCategory, raisedTs)
591}