blob: 336874999b126af282ba7cc730e43388b81a792b [file] [log] [blame]
khenaidoob9203542018-09-17 22:56:37 -04001/*
Joey Armstrong5f51f2e2023-01-17 17:06:26 -05002 * Copyright 2018-2023 Open Networking Foundation (ONF) and the ONF Contributors
khenaidoob9203542018-09-17 22:56:37 -04003
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"
khenaidood948f772021-08-11 17:49:24 -040021 "fmt"
David Bainbridged1afd662020-03-26 18:27:41 -070022 "sync"
23 "time"
24
khenaidood948f772021-08-11 17:49:24 -040025 "github.com/opencord/voltha-go/rw_core/config"
26 "github.com/opencord/voltha-lib-go/v7/pkg/probe"
27 "github.com/opencord/voltha-protos/v5/go/core"
28
sbarbari17d7e222019-11-05 10:02:29 -050029 "github.com/opencord/voltha-go/db/model"
Kent Hagerman2b216042020-04-03 18:28:56 -040030 "github.com/opencord/voltha-go/rw_core/core/adapter"
Kent Hagermanf5a67352020-04-30 15:15:26 -040031 "github.com/opencord/voltha-go/rw_core/core/device/event"
Kent Hagerman6031aad2020-07-29 16:36:33 -040032 "github.com/opencord/voltha-go/rw_core/core/device/state"
khenaidoo3d3b8c22019-05-22 18:10:39 -040033 "github.com/opencord/voltha-go/rw_core/utils"
khenaidood948f772021-08-11 17:49:24 -040034 "github.com/opencord/voltha-lib-go/v7/pkg/events"
35 "github.com/opencord/voltha-lib-go/v7/pkg/log"
khenaidoo9beaaf12021-10-19 17:32:01 -040036 ca "github.com/opencord/voltha-protos/v5/go/core_adapter"
khenaidood948f772021-08-11 17:49:24 -040037 ofp "github.com/opencord/voltha-protos/v5/go/openflow_13"
38 "github.com/opencord/voltha-protos/v5/go/voltha"
khenaidoob9203542018-09-17 22:56:37 -040039 "google.golang.org/grpc/codes"
40 "google.golang.org/grpc/status"
khenaidoob9203542018-09-17 22:56:37 -040041)
42
Kent Hagerman2b216042020-04-03 18:28:56 -040043// Manager represent device manager attributes
44type Manager struct {
Himani Chawlab4c25912020-11-12 17:16:38 +053045 deviceAgents sync.Map
46 rootDevices map[string]bool
47 lockRootDeviceMap sync.RWMutex
Mahir Gunyelb0343bf2021-05-11 14:14:26 -070048 *event.Agent
Kent Hagerman2b216042020-04-03 18:28:56 -040049 adapterMgr *adapter.Manager
50 logicalDeviceMgr *LogicalManager
Kent Hagerman6031aad2020-07-29 16:36:33 -040051 stateTransitions *state.TransitionMap
Mahir Gunyel03de0d32020-06-03 01:36:59 -070052 dbPath *model.Path
Kent Hagermanf5a67352020-04-30 15:15:26 -040053 dProxy *model.Proxy
npujar1d86a522019-11-14 17:11:16 +053054 coreInstanceID string
khenaidood948f772021-08-11 17:49:24 -040055 internalTimeout time.Duration
56 rpcTimeout time.Duration
Himani Chawla4b4bd252021-11-08 15:59:40 +053057 flowTimeout time.Duration
khenaidoo4c9e5592019-09-09 16:20:41 -040058 devicesLoadingLock sync.RWMutex
59 deviceLoadingInProgress map[string][]chan int
Maninder0aabf0c2021-03-17 14:55:14 +053060 config *config.RWCoreFlags
khenaidooa46458b2021-12-15 16:50:44 -050061 doneCh chan struct{}
khenaidoob9203542018-09-17 22:56:37 -040062}
63
Joey Armstrong393daca2023-07-06 08:47:54 -040064// NewManagers creates the Manager and the Logical Manager.
khenaidood948f772021-08-11 17:49:24 -040065func NewManagers(dbPath *model.Path, adapterMgr *adapter.Manager, cf *config.RWCoreFlags, coreInstanceID string, eventProxy *events.EventProxy) (*Manager, *LogicalManager) {
Kent Hagerman2b216042020-04-03 18:28:56 -040066 deviceMgr := &Manager{
Kent Hagerman2b216042020-04-03 18:28:56 -040067 rootDevices: make(map[string]bool),
Kent Hagerman2b216042020-04-03 18:28:56 -040068 coreInstanceID: coreInstanceID,
Mahir Gunyel03de0d32020-06-03 01:36:59 -070069 dbPath: dbPath,
70 dProxy: dbPath.Proxy("devices"),
Kent Hagerman2b216042020-04-03 18:28:56 -040071 adapterMgr: adapterMgr,
khenaidood948f772021-08-11 17:49:24 -040072 internalTimeout: cf.InternalTimeout,
73 rpcTimeout: cf.RPCTimeout,
Himani Chawla4b4bd252021-11-08 15:59:40 +053074 flowTimeout: cf.FlowTimeout,
Maninder0aabf0c2021-03-17 14:55:14 +053075 Agent: event.NewAgent(eventProxy, coreInstanceID, cf.VolthaStackID),
Kent Hagerman2b216042020-04-03 18:28:56 -040076 deviceLoadingInProgress: make(map[string][]chan int),
Maninder0aabf0c2021-03-17 14:55:14 +053077 config: cf,
khenaidooa46458b2021-12-15 16:50:44 -050078 doneCh: make(chan struct{}),
Kent Hagerman2b216042020-04-03 18:28:56 -040079 }
Kent Hagerman6031aad2020-07-29 16:36:33 -040080 deviceMgr.stateTransitions = state.NewTransitionMap(deviceMgr)
Kent Hagerman2f0d0552020-04-23 17:28:52 -040081
Kent Hagerman2b216042020-04-03 18:28:56 -040082 logicalDeviceMgr := &LogicalManager{
Maninder0aabf0c2021-03-17 14:55:14 +053083 Manager: event.NewManager(eventProxy, coreInstanceID, cf.VolthaStackID),
Kent Hagerman2b216042020-04-03 18:28:56 -040084 deviceMgr: deviceMgr,
Mahir Gunyel03de0d32020-06-03 01:36:59 -070085 dbPath: dbPath,
86 ldProxy: dbPath.Proxy("logical_devices"),
khenaidood948f772021-08-11 17:49:24 -040087 internalTimeout: cf.InternalTimeout,
Kent Hagerman2b216042020-04-03 18:28:56 -040088 logicalDeviceLoadingInProgress: make(map[string][]chan int),
89 }
90 deviceMgr.logicalDeviceMgr = logicalDeviceMgr
Matteo Scandolod525ae32020-04-02 17:27:29 -070091
khenaidood948f772021-08-11 17:49:24 -040092 adapterMgr.SetAdapterRestartedCallback(deviceMgr.adapterRestartedHandler)
Matteo Scandolod525ae32020-04-02 17:27:29 -070093
Kent Hagerman2b216042020-04-03 18:28:56 -040094 return deviceMgr, logicalDeviceMgr
khenaidoob9203542018-09-17 22:56:37 -040095}
96
khenaidood948f772021-08-11 17:49:24 -040097func (dMgr *Manager) Start(ctx context.Context, serviceName string) error {
khenaidoo7585a962021-06-10 16:15:38 -040098 logger.Info(ctx, "starting-device-manager")
khenaidood948f772021-08-11 17:49:24 -040099 probe.UpdateStatusFromContext(ctx, serviceName, probe.ServiceStatusPreparing)
khenaidoo7585a962021-06-10 16:15:38 -0400100
101 // Load all the devices from the dB
102 var devices []*voltha.Device
103 if err := dMgr.dProxy.List(ctx, &devices); err != nil {
104 // Any error from the dB means if we proceed we may end up with corrupted data
khenaidood948f772021-08-11 17:49:24 -0400105 logger.Errorw(ctx, "failed-to-list-devices-from-KV", log.Fields{"error": err, "service-name": serviceName})
106 return err
107 }
108
109 defer probe.UpdateStatusFromContext(ctx, serviceName, probe.ServiceStatusRunning)
110
111 if len(devices) == 0 {
112 logger.Info(ctx, "no-device-to-load")
113 return nil
khenaidoo7585a962021-06-10 16:15:38 -0400114 }
115
116 for _, device := range devices {
117 // Create an agent for each device
Himani Chawla4b4bd252021-11-08 15:59:40 +0530118 agent := newAgent(device, dMgr, dMgr.dbPath, dMgr.dProxy, dMgr.internalTimeout, dMgr.rpcTimeout, dMgr.flowTimeout)
khenaidoo7585a962021-06-10 16:15:38 -0400119 if _, err := agent.start(ctx, true, device); err != nil {
120 logger.Warnw(ctx, "failure-starting-agent", log.Fields{"device-id": device.Id})
121 } else {
122 dMgr.addDeviceAgentToMap(agent)
123 }
124 }
125
126 // TODO: Need to trigger a reconcile at this point
127
khenaidoo7585a962021-06-10 16:15:38 -0400128 logger.Info(ctx, "device-manager-started")
khenaidood948f772021-08-11 17:49:24 -0400129
130 return nil
khenaidoo7585a962021-06-10 16:15:38 -0400131}
132
khenaidooa46458b2021-12-15 16:50:44 -0500133func (dMgr *Manager) Stop(ctx context.Context, serviceName string) {
134 logger.Info(ctx, "stopping-device-manager")
135 close(dMgr.doneCh)
136 probe.UpdateStatusFromContext(ctx, serviceName, probe.ServiceStatusStopped)
137}
138
Kent Hagerman2b216042020-04-03 18:28:56 -0400139func (dMgr *Manager) addDeviceAgentToMap(agent *Agent) {
npujar1d86a522019-11-14 17:11:16 +0530140 if _, exist := dMgr.deviceAgents.Load(agent.deviceID); !exist {
141 dMgr.deviceAgents.Store(agent.deviceID, agent)
khenaidoob9203542018-09-17 22:56:37 -0400142 }
khenaidoo2c6a0992019-04-29 13:46:56 -0400143 dMgr.lockRootDeviceMap.Lock()
144 defer dMgr.lockRootDeviceMap.Unlock()
Kent Hagerman2a07b862020-06-19 15:23:07 -0400145 dMgr.rootDevices[agent.deviceID] = agent.isRootDevice
khenaidoo2c6a0992019-04-29 13:46:56 -0400146
khenaidoob9203542018-09-17 22:56:37 -0400147}
148
Kent Hagerman2b216042020-04-03 18:28:56 -0400149func (dMgr *Manager) deleteDeviceAgentFromMap(agent *Agent) {
npujar1d86a522019-11-14 17:11:16 +0530150 dMgr.deviceAgents.Delete(agent.deviceID)
khenaidoo2c6a0992019-04-29 13:46:56 -0400151 dMgr.lockRootDeviceMap.Lock()
152 defer dMgr.lockRootDeviceMap.Unlock()
npujar1d86a522019-11-14 17:11:16 +0530153 delete(dMgr.rootDevices, agent.deviceID)
khenaidoo4d4802d2018-10-04 21:59:49 -0400154}
155
khenaidoo297cd252019-02-07 22:10:23 -0500156// getDeviceAgent returns the agent managing the device. If the device is not in memory, it will loads it, if it exists
Kent Hagerman2b216042020-04-03 18:28:56 -0400157func (dMgr *Manager) getDeviceAgent(ctx context.Context, deviceID string) *Agent {
npujar1d86a522019-11-14 17:11:16 +0530158 agent, ok := dMgr.deviceAgents.Load(deviceID)
159 if ok {
Kent Hagerman2b216042020-04-03 18:28:56 -0400160 return agent.(*Agent)
khenaidoob9203542018-09-17 22:56:37 -0400161 }
khenaidoo442e7c72020-03-10 16:13:48 -0400162 // Try to load into memory - loading will also create the device agent and set the device ownership
npujar467fe752020-01-16 20:17:45 +0530163 err := dMgr.load(ctx, deviceID)
npujar1d86a522019-11-14 17:11:16 +0530164 if err == nil {
165 agent, ok = dMgr.deviceAgents.Load(deviceID)
166 if !ok {
167 return nil
168 }
Kent Hagerman2b216042020-04-03 18:28:56 -0400169 return agent.(*Agent)
npujar1d86a522019-11-14 17:11:16 +0530170 }
171 //TODO: Change the return params to return an error as well
divyadesaicb8b59d2020-08-18 09:55:47 +0000172 logger.Errorw(ctx, "loading-device-failed", log.Fields{"device-id": deviceID, "error": err})
khenaidoob9203542018-09-17 22:56:37 -0400173 return nil
174}
175
khenaidoo297cd252019-02-07 22:10:23 -0500176// listDeviceIdsFromMap returns the list of device IDs that are in memory
Kent Hagerman2b216042020-04-03 18:28:56 -0400177func (dMgr *Manager) listDeviceIdsFromMap() *voltha.IDs {
khenaidoo7ccedd52018-12-14 16:48:54 -0500178 result := &voltha.IDs{Items: make([]*voltha.ID, 0)}
Stephane Barbarieef6650d2019-07-18 12:15:09 -0400179
180 dMgr.deviceAgents.Range(func(key, value interface{}) bool {
181 result.Items = append(result.Items, &voltha.ID{Id: key.(string)})
182 return true
183 })
184
khenaidoo7ccedd52018-12-14 16:48:54 -0500185 return result
186}
187
khenaidoo6d62c002019-05-15 21:57:03 -0400188// stopManagingDevice stops the management of the device as well as any of its reference device and logical device.
189// This function is called only in the Core that does not own this device. In the Core that owns this device then a
190// deletion deletion also includes removal of any reference of this device.
Kent Hagerman2b216042020-04-03 18:28:56 -0400191func (dMgr *Manager) stopManagingDevice(ctx context.Context, id string) {
Himani Chawlab4c25912020-11-12 17:16:38 +0530192 logger.Infow(ctx, "stop-managing-device", log.Fields{"device-id": id})
khenaidoo6d62c002019-05-15 21:57:03 -0400193 if dMgr.IsDeviceInCache(id) { // Proceed only if an agent is present for this device
Kent Hagerman6031aad2020-07-29 16:36:33 -0400194 if device, err := dMgr.getDeviceReadOnly(ctx, id); err == nil && device.Root {
khenaidoo6d62c002019-05-15 21:57:03 -0400195 // stop managing the logical device
David Bainbridged1afd662020-03-26 18:27:41 -0700196 _ = dMgr.logicalDeviceMgr.stopManagingLogicalDeviceWithDeviceID(ctx, id)
khenaidoo6d62c002019-05-15 21:57:03 -0400197 }
npujar467fe752020-01-16 20:17:45 +0530198 if agent := dMgr.getDeviceAgent(ctx, id); agent != nil {
khenaidoo442e7c72020-03-10 16:13:48 -0400199 if err := agent.stop(ctx); err != nil {
Rohan Agrawal31f21802020-06-12 05:38:46 +0000200 logger.Warnw(ctx, "unable-to-stop-device-agent", log.Fields{"device-id": agent.deviceID, "error": err})
khenaidoo442e7c72020-03-10 16:13:48 -0400201 }
khenaidoo4c9e5592019-09-09 16:20:41 -0400202 dMgr.deleteDeviceAgentFromMap(agent)
khenaidoo6d62c002019-05-15 21:57:03 -0400203 }
204 }
205}
206
Kent Hagermancba2f302020-07-28 13:37:36 -0400207// getDeviceReadOnly will returns a device, either from memory or from the dB, if present
208func (dMgr *Manager) getDeviceReadOnly(ctx context.Context, id string) (*voltha.Device, error) {
Himani Chawlab4c25912020-11-12 17:16:38 +0530209 logger.Debugw(ctx, "get-device-read-only", log.Fields{"device-id": id})
npujar467fe752020-01-16 20:17:45 +0530210 if agent := dMgr.getDeviceAgent(ctx, id); agent != nil {
Kent Hagermancba2f302020-07-28 13:37:36 -0400211 return agent.getDeviceReadOnly(ctx)
khenaidoo92e62c52018-10-03 14:02:54 -0400212 }
213 return nil, status.Errorf(codes.NotFound, "%s", id)
khenaidoob9203542018-09-17 22:56:37 -0400214}
215
Kent Hagerman2a07b862020-06-19 15:23:07 -0400216func (dMgr *Manager) listDevicePorts(ctx context.Context, id string) (map[uint32]*voltha.Port, error) {
Himani Chawlab4c25912020-11-12 17:16:38 +0530217 logger.Debugw(ctx, "list-device-ports", log.Fields{"device-id": id})
Kent Hagerman2a07b862020-06-19 15:23:07 -0400218 agent := dMgr.getDeviceAgent(ctx, id)
219 if agent == nil {
220 return nil, status.Errorf(codes.NotFound, "%s", id)
221 }
222 return agent.listDevicePorts(), nil
223}
224
npujar1d86a522019-11-14 17:11:16 +0530225// IsDeviceInCache returns true if device is found in the map
Kent Hagerman2b216042020-04-03 18:28:56 -0400226func (dMgr *Manager) IsDeviceInCache(id string) bool {
Stephane Barbarieef6650d2019-07-18 12:15:09 -0400227 _, exist := dMgr.deviceAgents.Load(id)
khenaidoo297cd252019-02-07 22:10:23 -0500228 return exist
229}
230
Joey Armstrong393daca2023-07-06 08:47:54 -0400231// isParentDeviceExist checks whether device is already preprovisioned.
Kent Hagerman2b216042020-04-03 18:28:56 -0400232func (dMgr *Manager) isParentDeviceExist(ctx context.Context, newDevice *voltha.Device) (bool, error) {
Thomas Lee S51b5cb82019-10-14 14:49:34 +0530233 hostPort := newDevice.GetHostAndPort()
Kent Hagerman4f355f52020-03-30 16:01:33 -0400234 var devices []*voltha.Device
Kent Hagermanf5a67352020-04-30 15:15:26 -0400235 if err := dMgr.dProxy.List(ctx, &devices); err != nil {
Himani Chawlab4c25912020-11-12 17:16:38 +0530236 logger.Errorw(ctx, "failed-to-list-devices-from-cluster-data-proxy", log.Fields{"error": err})
Thomas Lee Se5a44012019-11-07 20:32:24 +0530237 return false, err
238 }
Kent Hagerman4f355f52020-03-30 16:01:33 -0400239 for _, device := range devices {
240 if !device.Root {
241 continue
242 }
Himani Chawla2ba1c9c2020-10-07 13:19:03 +0530243
244 if hostPort != "" && hostPort == device.GetHostAndPort() {
Kent Hagerman4f355f52020-03-30 16:01:33 -0400245 return true, nil
246 }
Himani Chawla2ba1c9c2020-10-07 13:19:03 +0530247 if newDevice.MacAddress != "" && newDevice.MacAddress == device.MacAddress {
Kent Hagerman4f355f52020-03-30 16:01:33 -0400248 return true, nil
Thomas Lee S51b5cb82019-10-14 14:49:34 +0530249 }
250 }
Thomas Lee Se5a44012019-11-07 20:32:24 +0530251 return false, nil
Thomas Lee S51b5cb82019-10-14 14:49:34 +0530252}
253
Joey Armstrong393daca2023-07-06 08:47:54 -0400254// getDeviceFromModelretrieves the device data from the model.
Kent Hagerman2b216042020-04-03 18:28:56 -0400255func (dMgr *Manager) getDeviceFromModel(ctx context.Context, deviceID string) (*voltha.Device, error) {
Kent Hagerman4f355f52020-03-30 16:01:33 -0400256 device := &voltha.Device{}
Kent Hagermanf5a67352020-04-30 15:15:26 -0400257 if have, err := dMgr.dProxy.Get(ctx, deviceID, device); err != nil {
Rohan Agrawal31f21802020-06-12 05:38:46 +0000258 logger.Errorw(ctx, "failed-to-get-device-info-from-cluster-proxy", log.Fields{"error": err})
Thomas Lee Se5a44012019-11-07 20:32:24 +0530259 return nil, err
Kent Hagerman4f355f52020-03-30 16:01:33 -0400260 } else if !have {
261 return nil, status.Error(codes.NotFound, deviceID)
Thomas Lee Se5a44012019-11-07 20:32:24 +0530262 }
Kent Hagerman4f355f52020-03-30 16:01:33 -0400263
264 return device, nil
khenaidoo6d62c002019-05-15 21:57:03 -0400265}
266
npujar1d86a522019-11-14 17:11:16 +0530267// loadDevice loads the deviceID in memory, if not present
Kent Hagerman2b216042020-04-03 18:28:56 -0400268func (dMgr *Manager) loadDevice(ctx context.Context, deviceID string) (*Agent, error) {
npujar1d86a522019-11-14 17:11:16 +0530269 if deviceID == "" {
khenaidoo297cd252019-02-07 22:10:23 -0500270 return nil, status.Error(codes.InvalidArgument, "deviceId empty")
271 }
khenaidoo4c9e5592019-09-09 16:20:41 -0400272 var err error
273 var device *voltha.Device
274 dMgr.devicesLoadingLock.Lock()
npujar1d86a522019-11-14 17:11:16 +0530275 if _, exist := dMgr.deviceLoadingInProgress[deviceID]; !exist {
276 if !dMgr.IsDeviceInCache(deviceID) {
277 dMgr.deviceLoadingInProgress[deviceID] = []chan int{make(chan int, 1)}
khenaidoo4c9e5592019-09-09 16:20:41 -0400278 dMgr.devicesLoadingLock.Unlock()
279 // Proceed with the loading only if the device exist in the Model (could have been deleted)
npujar467fe752020-01-16 20:17:45 +0530280 if device, err = dMgr.getDeviceFromModel(ctx, deviceID); err == nil {
divyadesaicb8b59d2020-08-18 09:55:47 +0000281 logger.Debugw(ctx, "loading-device", log.Fields{"device-id": deviceID})
Himani Chawla4b4bd252021-11-08 15:59:40 +0530282 agent := newAgent(device, dMgr, dMgr.dbPath, dMgr.dProxy, dMgr.internalTimeout, dMgr.rpcTimeout, dMgr.flowTimeout)
khenaidoo7585a962021-06-10 16:15:38 -0400283 if _, err = agent.start(ctx, true, device); err != nil {
Himani Chawlab4c25912020-11-12 17:16:38 +0530284 logger.Warnw(ctx, "failure-loading-device", log.Fields{"device-id": deviceID, "error": err})
khenaidoo4c9e5592019-09-09 16:20:41 -0400285 } else {
286 dMgr.addDeviceAgentToMap(agent)
287 }
288 } else {
Himani Chawlab4c25912020-11-12 17:16:38 +0530289 logger.Debugw(ctx, "device-is-not-in-model", log.Fields{"device-id": deviceID})
khenaidoo6d62c002019-05-15 21:57:03 -0400290 }
khenaidoo4c9e5592019-09-09 16:20:41 -0400291 // announce completion of task to any number of waiting channels
292 dMgr.devicesLoadingLock.Lock()
npujar1d86a522019-11-14 17:11:16 +0530293 if v, ok := dMgr.deviceLoadingInProgress[deviceID]; ok {
khenaidoo4c9e5592019-09-09 16:20:41 -0400294 for _, ch := range v {
295 close(ch)
296 }
npujar1d86a522019-11-14 17:11:16 +0530297 delete(dMgr.deviceLoadingInProgress, deviceID)
khenaidoo4c9e5592019-09-09 16:20:41 -0400298 }
299 dMgr.devicesLoadingLock.Unlock()
khenaidoo6d62c002019-05-15 21:57:03 -0400300 } else {
khenaidoo4c9e5592019-09-09 16:20:41 -0400301 dMgr.devicesLoadingLock.Unlock()
khenaidoo297cd252019-02-07 22:10:23 -0500302 }
khenaidoo4c9e5592019-09-09 16:20:41 -0400303 } else {
304 ch := make(chan int, 1)
npujar1d86a522019-11-14 17:11:16 +0530305 dMgr.deviceLoadingInProgress[deviceID] = append(dMgr.deviceLoadingInProgress[deviceID], ch)
khenaidoo4c9e5592019-09-09 16:20:41 -0400306 dMgr.devicesLoadingLock.Unlock()
307 // Wait for the channel to be closed, implying the process loading this device is done.
308 <-ch
khenaidoo297cd252019-02-07 22:10:23 -0500309 }
npujar1d86a522019-11-14 17:11:16 +0530310 if agent, ok := dMgr.deviceAgents.Load(deviceID); ok {
Kent Hagerman2b216042020-04-03 18:28:56 -0400311 return agent.(*Agent), nil
khenaidoo297cd252019-02-07 22:10:23 -0500312 }
npujar1d86a522019-11-14 17:11:16 +0530313 return nil, status.Errorf(codes.Aborted, "Error loading device %s", deviceID)
khenaidoo297cd252019-02-07 22:10:23 -0500314}
315
316// loadRootDeviceParentAndChildren loads the children and parents of a root device in memory
nikesh.krishnan1e3b98a2023-11-26 02:39:53 +0530317func (dMgr *Manager) loadRootDeviceParentAndChildren(ctx context.Context, device *voltha.Device) error {
divyadesaicb8b59d2020-08-18 09:55:47 +0000318 logger.Debugw(ctx, "loading-parent-and-children", log.Fields{"device-id": device.Id})
khenaidoo297cd252019-02-07 22:10:23 -0500319 if device.Root {
320 // Scenario A
321 if device.ParentId != "" {
Kent Hagerman2a07b862020-06-19 15:23:07 -0400322 // Load logical device if needed.
npujar467fe752020-01-16 20:17:45 +0530323 if err := dMgr.logicalDeviceMgr.load(ctx, device.ParentId); err != nil {
divyadesaicb8b59d2020-08-18 09:55:47 +0000324 logger.Warnw(ctx, "failure-loading-logical-device", log.Fields{"logical-device-id": device.ParentId})
khenaidoo297cd252019-02-07 22:10:23 -0500325 }
326 } else {
divyadesaicb8b59d2020-08-18 09:55:47 +0000327 logger.Debugw(ctx, "no-parent-to-load", log.Fields{"device-id": device.Id})
khenaidoo297cd252019-02-07 22:10:23 -0500328 }
Kent Hagerman2a07b862020-06-19 15:23:07 -0400329 // Load all child devices, if needed
nikesh.krishnan1e3b98a2023-11-26 02:39:53 +0530330 childDeviceIds := dMgr.getAllChildDeviceIds(ctx, device.Id)
Kent Hagerman2a07b862020-06-19 15:23:07 -0400331 for childDeviceID := range childDeviceIds {
332 if _, err := dMgr.loadDevice(ctx, childDeviceID); err != nil {
divyadesaicb8b59d2020-08-18 09:55:47 +0000333 logger.Warnw(ctx, "failure-loading-device", log.Fields{"device-id": childDeviceID, "error": err})
Kent Hagerman2a07b862020-06-19 15:23:07 -0400334 return err
khenaidoo297cd252019-02-07 22:10:23 -0500335 }
khenaidoo297cd252019-02-07 22:10:23 -0500336 }
Himani Chawlab4c25912020-11-12 17:16:38 +0530337 logger.Debugw(ctx, "loaded-children", log.Fields{"device-id": device.Id, "num-children": len(childDeviceIds)})
khenaidoo297cd252019-02-07 22:10:23 -0500338 }
339 return nil
340}
341
342// load loads the deviceId in memory, if not present, and also loads its accompanying parents and children. Loading
343// in memory is for improved performance. It is not imperative that a device needs to be in memory when a request
344// acting on the device is received by the core. In such a scenario, the Core will load the device in memory first
345// and the proceed with the request.
Kent Hagerman2b216042020-04-03 18:28:56 -0400346func (dMgr *Manager) load(ctx context.Context, deviceID string) error {
Rohan Agrawal31f21802020-06-12 05:38:46 +0000347 logger.Debug(ctx, "load...")
khenaidoo297cd252019-02-07 22:10:23 -0500348 // First load the device - this may fail in case the device was deleted intentionally by the other core
Kent Hagerman2b216042020-04-03 18:28:56 -0400349 var dAgent *Agent
khenaidoo297cd252019-02-07 22:10:23 -0500350 var err error
npujar467fe752020-01-16 20:17:45 +0530351 if dAgent, err = dMgr.loadDevice(ctx, deviceID); err != nil {
khenaidoo297cd252019-02-07 22:10:23 -0500352 return err
353 }
354 // Get the loaded device details
Kent Hagermancba2f302020-07-28 13:37:36 -0400355 device, err := dAgent.getDeviceReadOnly(ctx)
khenaidoo442e7c72020-03-10 16:13:48 -0400356 if err != nil {
357 return err
358 }
khenaidoo297cd252019-02-07 22:10:23 -0500359
Himani Chawla2ba1c9c2020-10-07 13:19:03 +0530360 // If the device is in Pre-provisioning or getting deleted state stop here
361 if device.AdminState == voltha.AdminState_PREPROVISIONED || dAgent.isDeletionInProgress() {
khenaidoo297cd252019-02-07 22:10:23 -0500362 return nil
363 }
364
365 // Now we face two scenarios
366 if device.Root {
Kent Hagerman2a07b862020-06-19 15:23:07 -0400367
khenaidoo297cd252019-02-07 22:10:23 -0500368 // Load all children as well as the parent of this device (logical_device)
nikesh.krishnan1e3b98a2023-11-26 02:39:53 +0530369 if err := dMgr.loadRootDeviceParentAndChildren(ctx, device); err != nil {
divyadesaicb8b59d2020-08-18 09:55:47 +0000370 logger.Warnw(ctx, "failure-loading-device-parent-and-children", log.Fields{"device-id": deviceID})
khenaidoo297cd252019-02-07 22:10:23 -0500371 return err
372 }
divyadesaicb8b59d2020-08-18 09:55:47 +0000373 logger.Debugw(ctx, "successfully-loaded-parent-and-children", log.Fields{"device-id": deviceID})
Andrey Pozolotin34dd63f2021-05-31 21:26:40 +0300374 } else if device.ParentId != "" {
khenaidoo297cd252019-02-07 22:10:23 -0500375 // Scenario B - use the parentId of that device (root device) to trigger the loading
Andrey Pozolotin34dd63f2021-05-31 21:26:40 +0300376 return dMgr.load(ctx, device.ParentId)
khenaidoo297cd252019-02-07 22:10:23 -0500377 }
Andrey Pozolotin34dd63f2021-05-31 21:26:40 +0300378
khenaidoo297cd252019-02-07 22:10:23 -0500379 return nil
380}
381
khenaidooba6b6c42019-08-02 09:11:56 -0400382// adapterRestarted is invoked whenever an adapter is restarted
Kent Hagerman2b216042020-04-03 18:28:56 -0400383func (dMgr *Manager) adapterRestarted(ctx context.Context, adapter *voltha.Adapter) error {
Himani Chawlab4c25912020-11-12 17:16:38 +0530384 logger.Debugw(ctx, "adapter-restarted", log.Fields{"adapter-id": adapter.Id, "vendor": adapter.Vendor,
Girish Gowdra11ddb232022-05-26 12:19:59 -0700385 "current-replica": adapter.CurrentReplica, "total-replicas": adapter.TotalReplicas,
386 "restarted-endpoint": adapter.Endpoint, "current-version": adapter.Version})
khenaidooba6b6c42019-08-02 09:11:56 -0400387
khenaidood948f772021-08-11 17:49:24 -0400388 numberOfDevicesToReconcile := 0
389 dMgr.deviceAgents.Range(func(key, value interface{}) bool {
390 deviceAgent, ok := value.(*Agent)
391 if ok && deviceAgent.adapterEndpoint == adapter.Endpoint {
392 // Before reconciling, abort in-process request
393 if err := deviceAgent.abortAllProcessing(utils.WithNewSpanAndRPCMetadataContext(ctx, "AbortProcessingOnRestart")); err == nil {
394 logger.Debugw(ctx, "reconciling-device",
395 log.Fields{
396 "device-id": deviceAgent.deviceID,
397 "root-device": deviceAgent.isRootDevice,
398 "restarted-endpoint": adapter.Endpoint,
399 "device-type": deviceAgent.deviceType,
400 "adapter-type": adapter.Type,
401 })
nikesh.krishnan95142d52023-02-24 15:32:11 +0530402 deviceAgent.ReconcileDevice(utils.WithNewSpanAndRPCMetadataContext(ctx, "ReconcileDevice"))
khenaidood948f772021-08-11 17:49:24 -0400403 numberOfDevicesToReconcile++
404 } else {
405 logger.Errorw(ctx, "failed-aborting-exisiting-processing", log.Fields{"error": err})
khenaidooba6b6c42019-08-02 09:11:56 -0400406 }
407 }
khenaidood948f772021-08-11 17:49:24 -0400408 return true
409 })
410 logger.Debugw(ctx, "reconciling-on-adapter-restart-initiated", log.Fields{"adapter-endpoint": adapter.Endpoint, "number-of-devices-to-reconcile": numberOfDevicesToReconcile})
khenaidooba6b6c42019-08-02 09:11:56 -0400411 return nil
412}
413
Kent Hagerman2b216042020-04-03 18:28:56 -0400414func (dMgr *Manager) UpdateDeviceUsingAdapterData(ctx context.Context, device *voltha.Device) error {
Himani Chawlab4c25912020-11-12 17:16:38 +0530415 logger.Debugw(ctx, "update-device-using-adapter-data", log.Fields{"device-id": device.Id, "device": device})
npujar467fe752020-01-16 20:17:45 +0530416 if agent := dMgr.getDeviceAgent(ctx, device.Id); agent != nil {
417 return agent.updateDeviceUsingAdapterData(ctx, device)
khenaidoob9203542018-09-17 22:56:37 -0400418 }
419 return status.Errorf(codes.NotFound, "%s", device.Id)
420}
421
khenaidoo0db4c812020-05-27 15:27:30 -0400422func (dMgr *Manager) addPeerPort(ctx context.Context, deviceID string, port *voltha.Port) error {
423 meAsPeer := &voltha.Port_PeerPort{DeviceId: deviceID, PortNo: port.PortNo}
424 for _, peerPort := range port.Peers {
425 if agent := dMgr.getDeviceAgent(ctx, peerPort.DeviceId); agent != nil {
426 if err := agent.addPeerPort(ctx, meAsPeer); err != nil {
427 return err
428 }
429 }
430 }
431 // Notify the logical device manager to setup a logical port, if needed. If the added port is an NNI or UNI
432 // then a logical port will be added to the logical device and the device route generated. If the port is a
433 // PON port then only the device graph will be generated.
Kent Hagermancba2f302020-07-28 13:37:36 -0400434 device, err := dMgr.getDeviceReadOnly(ctx, deviceID)
khenaidoo0db4c812020-05-27 15:27:30 -0400435 if err != nil {
436 return err
437 }
Kent Hagerman2a07b862020-06-19 15:23:07 -0400438 ports, err := dMgr.listDevicePorts(ctx, deviceID)
439 if err != nil {
440 return err
441 }
Himani Chawlab4c25912020-11-12 17:16:38 +0530442 subCtx := utils.WithSpanAndRPCMetadataFromContext(ctx)
443
444 if err = dMgr.logicalDeviceMgr.updateLogicalPort(subCtx, device, ports, port); err != nil {
khenaidoo0db4c812020-05-27 15:27:30 -0400445 return err
446 }
447 return nil
448}
449
Kent Hagerman2b216042020-04-03 18:28:56 -0400450func (dMgr *Manager) AddPort(ctx context.Context, deviceID string, port *voltha.Port) error {
npujar467fe752020-01-16 20:17:45 +0530451 agent := dMgr.getDeviceAgent(ctx, deviceID)
npujar1d86a522019-11-14 17:11:16 +0530452 if agent != nil {
npujar467fe752020-01-16 20:17:45 +0530453 if err := agent.addPort(ctx, port); err != nil {
khenaidoo92e62c52018-10-03 14:02:54 -0400454 return err
455 }
khenaidoo0db4c812020-05-27 15:27:30 -0400456 // Setup peer ports in its own routine
nikesh.krishnan95142d52023-02-24 15:32:11 +0530457 if err := dMgr.addPeerPort(ctx, deviceID, port); err != nil {
458 logger.Errorw(ctx, "unable-to-add-peer-port", log.Fields{"error": err, "device-id": deviceID})
459 }
khenaidoo92e62c52018-10-03 14:02:54 -0400460 return nil
khenaidoob9203542018-09-17 22:56:37 -0400461 }
npujar1d86a522019-11-14 17:11:16 +0530462 return status.Errorf(codes.NotFound, "%s", deviceID)
khenaidoob9203542018-09-17 22:56:37 -0400463}
464
Elia Battiston509fdc72022-01-04 13:28:09 +0100465func (dMgr *Manager) canAdapterRequestProceed(ctx context.Context, deviceID string) error {
466 agent := dMgr.getDeviceAgent(ctx, deviceID)
467 if agent == nil {
468 logger.Errorw(ctx, "device-nil", log.Fields{"device-id": deviceID})
469 return status.Errorf(codes.NotFound, "device-nil-for-%s", deviceID)
470 }
471 if !agent.isAdapterConnectionUp(ctx) {
472 return status.Errorf(codes.Unavailable, "adapter-connection-down-for-%s", deviceID)
473 }
474 if err := agent.canDeviceRequestProceed(ctx); err != nil {
475 return err
476 }
477 // Perform the same checks for parent device
478 if !agent.isRootDevice {
479 parentDeviceAgent := dMgr.getDeviceAgent(ctx, agent.parentID)
480 if parentDeviceAgent == nil {
481 logger.Errorw(ctx, "parent-device-adapter-nil", log.Fields{"parent-id": agent.parentID})
482 return status.Errorf(codes.NotFound, "parent-device-adapter-nil-for-%s", deviceID)
khenaidood948f772021-08-11 17:49:24 -0400483 }
Elia Battiston509fdc72022-01-04 13:28:09 +0100484 if err := parentDeviceAgent.canDeviceRequestProceed(ctx); err != nil {
khenaidood948f772021-08-11 17:49:24 -0400485 return err
486 }
487 }
Elia Battiston509fdc72022-01-04 13:28:09 +0100488
489 return nil
490}
491
492func (dMgr *Manager) canMultipleAdapterRequestProceed(ctx context.Context, deviceIDs []string) error {
493 if len(deviceIDs) == 0 {
khenaidood948f772021-08-11 17:49:24 -0400494 return status.Error(codes.Unavailable, "adapter(s)-not-ready")
495 }
Elia Battiston509fdc72022-01-04 13:28:09 +0100496
497 for _, deviceID := range deviceIDs {
498 if err := dMgr.canAdapterRequestProceed(ctx, deviceID); err != nil {
499 return err
500 }
501 }
502
khenaidood948f772021-08-11 17:49:24 -0400503 return nil
504}
505
khenaidoo9beaaf12021-10-19 17:32:01 -0400506func (dMgr *Manager) addFlowsAndGroups(ctx context.Context, deviceID string, flows []*ofp.OfpFlowStats, groups []*ofp.OfpGroupEntry, flowMetadata *ofp.FlowMetadata) error {
Himani Chawlab4c25912020-11-12 17:16:38 +0530507 logger.Debugw(ctx, "add-flows-and-groups", log.Fields{"device-id": deviceID, "groups:": groups, "flow-metadata": flowMetadata})
npujar467fe752020-01-16 20:17:45 +0530508 if agent := dMgr.getDeviceAgent(ctx, deviceID); agent != nil {
509 return agent.addFlowsAndGroups(ctx, flows, groups, flowMetadata)
khenaidoo0458db62019-06-20 08:50:36 -0400510 }
npujar1d86a522019-11-14 17:11:16 +0530511 return status.Errorf(codes.NotFound, "%s", deviceID)
khenaidoo0458db62019-06-20 08:50:36 -0400512}
513
khenaidoo787224a2020-04-16 18:08:47 -0400514// deleteParentFlows removes flows from the parent device based on specific attributes
khenaidoo9beaaf12021-10-19 17:32:01 -0400515func (dMgr *Manager) deleteParentFlows(ctx context.Context, deviceID string, uniPort uint32, metadata *ofp.FlowMetadata) error {
Himani Chawlab4c25912020-11-12 17:16:38 +0530516 logger.Debugw(ctx, "delete-parent-flows", log.Fields{"device-id": deviceID, "uni-port": uniPort, "metadata": metadata})
khenaidoo787224a2020-04-16 18:08:47 -0400517 if agent := dMgr.getDeviceAgent(ctx, deviceID); agent != nil {
Kent Hagerman2a07b862020-06-19 15:23:07 -0400518 if !agent.isRootDevice {
khenaidoo787224a2020-04-16 18:08:47 -0400519 return status.Errorf(codes.FailedPrecondition, "not-a-parent-device-%s", deviceID)
520 }
521 return agent.filterOutFlows(ctx, uniPort, metadata)
522 }
523 return status.Errorf(codes.NotFound, "%s", deviceID)
524}
525
khenaidoo9beaaf12021-10-19 17:32:01 -0400526func (dMgr *Manager) deleteFlowsAndGroups(ctx context.Context, deviceID string, flows []*ofp.OfpFlowStats, groups []*ofp.OfpGroupEntry, flowMetadata *ofp.FlowMetadata) error {
Himani Chawlab4c25912020-11-12 17:16:38 +0530527 logger.Debugw(ctx, "delete-flows-and-groups", log.Fields{"device-id": deviceID})
npujar467fe752020-01-16 20:17:45 +0530528 if agent := dMgr.getDeviceAgent(ctx, deviceID); agent != nil {
529 return agent.deleteFlowsAndGroups(ctx, flows, groups, flowMetadata)
khenaidoo0458db62019-06-20 08:50:36 -0400530 }
npujar1d86a522019-11-14 17:11:16 +0530531 return status.Errorf(codes.NotFound, "%s", deviceID)
khenaidoo0458db62019-06-20 08:50:36 -0400532}
533
khenaidoo9beaaf12021-10-19 17:32:01 -0400534func (dMgr *Manager) updateFlowsAndGroups(ctx context.Context, deviceID string, flows []*ofp.OfpFlowStats, groups []*ofp.OfpGroupEntry, flowMetadata *ofp.FlowMetadata) error {
Himani Chawlab4c25912020-11-12 17:16:38 +0530535 logger.Debugw(ctx, "update-flows-and-groups", log.Fields{"device-id": deviceID})
npujar467fe752020-01-16 20:17:45 +0530536 if agent := dMgr.getDeviceAgent(ctx, deviceID); agent != nil {
537 return agent.updateFlowsAndGroups(ctx, flows, groups, flowMetadata)
khenaidoo19d7b632018-10-30 10:49:50 -0400538 }
npujar1d86a522019-11-14 17:11:16 +0530539 return status.Errorf(codes.NotFound, "%s", deviceID)
khenaidoo19d7b632018-10-30 10:49:50 -0400540}
541
Kent Hagerman2b216042020-04-03 18:28:56 -0400542// InitPmConfigs initialize the pm configs as defined by the adapter.
543func (dMgr *Manager) InitPmConfigs(ctx context.Context, deviceID string, pmConfigs *voltha.PmConfigs) error {
khenaidoob3127472019-07-24 21:04:55 -0400544 if pmConfigs.Id == "" {
545 return status.Errorf(codes.FailedPrecondition, "invalid-device-Id")
546 }
npujar467fe752020-01-16 20:17:45 +0530547 if agent := dMgr.getDeviceAgent(ctx, deviceID); agent != nil {
548 return agent.initPmConfigs(ctx, pmConfigs)
khenaidoob9203542018-09-17 22:56:37 -0400549 }
npujar1d86a522019-11-14 17:11:16 +0530550 return status.Errorf(codes.NotFound, "%s", deviceID)
khenaidoob9203542018-09-17 22:56:37 -0400551}
552
khenaidoo9beaaf12021-10-19 17:32:01 -0400553func (dMgr *Manager) getSwitchCapability(ctx context.Context, deviceID string) (*ca.SwitchCapability, error) {
Himani Chawlab4c25912020-11-12 17:16:38 +0530554 logger.Debugw(ctx, "get-switch-capability", log.Fields{"device-id": deviceID})
npujar467fe752020-01-16 20:17:45 +0530555 if agent := dMgr.getDeviceAgent(ctx, deviceID); agent != nil {
khenaidoob9203542018-09-17 22:56:37 -0400556 return agent.getSwitchCapability(ctx)
557 }
npujar1d86a522019-11-14 17:11:16 +0530558 return nil, status.Errorf(codes.NotFound, "%s", deviceID)
khenaidoob9203542018-09-17 22:56:37 -0400559}
560
Kent Hagerman2b216042020-04-03 18:28:56 -0400561func (dMgr *Manager) UpdateDeviceStatus(ctx context.Context, deviceID string, operStatus voltha.OperStatus_Types, connStatus voltha.ConnectStatus_Types) error {
Himani Chawlab4c25912020-11-12 17:16:38 +0530562 logger.Debugw(ctx, "update-device-status", log.Fields{"device-id": deviceID, "oper-status": operStatus, "conn-status": connStatus})
npujar467fe752020-01-16 20:17:45 +0530563 if agent := dMgr.getDeviceAgent(ctx, deviceID); agent != nil {
564 return agent.updateDeviceStatus(ctx, operStatus, connStatus)
khenaidoo92e62c52018-10-03 14:02:54 -0400565 }
npujar1d86a522019-11-14 17:11:16 +0530566 return status.Errorf(codes.NotFound, "%s", deviceID)
khenaidoo92e62c52018-10-03 14:02:54 -0400567}
568
Kent Hagerman2b216042020-04-03 18:28:56 -0400569func (dMgr *Manager) UpdateChildrenStatus(ctx context.Context, deviceID string, operStatus voltha.OperStatus_Types, connStatus voltha.ConnectStatus_Types) error {
Himani Chawlab4c25912020-11-12 17:16:38 +0530570 logger.Debugw(ctx, "update-children-status", log.Fields{"parent-device-id": deviceID, "oper-status": operStatus, "conn-status": connStatus})
nikesh.krishnan1e3b98a2023-11-26 02:39:53 +0530571 for childDeviceID := range dMgr.getAllChildDeviceIds(ctx, deviceID) {
npujar467fe752020-01-16 20:17:45 +0530572 if agent := dMgr.getDeviceAgent(ctx, childDeviceID); agent != nil {
nikesh.krishnan1e3b98a2023-11-26 02:39:53 +0530573 if err := agent.updateDeviceStatus(ctx, operStatus, connStatus); err != nil {
npujar1d86a522019-11-14 17:11:16 +0530574 return status.Errorf(codes.Aborted, "childDevice:%s, error:%s", childDeviceID, err.Error())
khenaidoo4d4802d2018-10-04 21:59:49 -0400575 }
576 }
577 }
578 return nil
579}
580
Kent Hagerman2b216042020-04-03 18:28:56 -0400581func (dMgr *Manager) UpdatePortState(ctx context.Context, deviceID string, portType voltha.Port_PortType, portNo uint32, operStatus voltha.OperStatus_Types) error {
Himani Chawlab4c25912020-11-12 17:16:38 +0530582 logger.Debugw(ctx, "update-port-state", log.Fields{"device-id": deviceID, "port-type": portType, "port-no": portNo, "oper-status": operStatus})
npujar467fe752020-01-16 20:17:45 +0530583 if agent := dMgr.getDeviceAgent(ctx, deviceID); agent != nil {
584 if err := agent.updatePortState(ctx, portType, portNo, operStatus); err != nil {
Himani Chawlab4c25912020-11-12 17:16:38 +0530585 logger.Errorw(ctx, "updating-port-state-failed", log.Fields{"device-id": deviceID, "port-no": portNo, "error": err})
khenaidoo171b98e2019-10-31 11:48:15 -0400586 return err
587 }
588 // Notify the logical device manager to change the port state
Mahir Gunyel18fa0c92020-03-06 13:34:04 -0800589 // Do this for NNI and UNIs only. PON ports are not known by logical device
590 if portType == voltha.Port_ETHERNET_NNI || portType == voltha.Port_ETHERNET_UNI {
nikesh.krishnan95142d52023-02-24 15:32:11 +0530591 err := dMgr.logicalDeviceMgr.updatePortState(ctx, deviceID, portNo, operStatus)
592 if err != nil {
593 // While we want to handle (catch) and log when
594 // an update to a port was not able to be
595 // propagated to the logical port, we can report
596 // it as a warning and not an error because it
597 // doesn't stop or modify processing.
598 // TODO: VOL-2707
599 logger.Warnw(ctx, "unable-to-update-logical-port-state", log.Fields{"error": err})
600 }
Mahir Gunyel18fa0c92020-03-06 13:34:04 -0800601 }
khenaidoo442e7c72020-03-10 16:13:48 -0400602 return nil
khenaidoob9203542018-09-17 22:56:37 -0400603 }
npujar1d86a522019-11-14 17:11:16 +0530604 return status.Errorf(codes.NotFound, "%s", deviceID)
khenaidoob9203542018-09-17 22:56:37 -0400605}
606
Joey Armstrong393daca2023-07-06 08:47:54 -0400607// UpdatePortsState updates all ports on the device
Kent Hagerman2a07b862020-06-19 15:23:07 -0400608func (dMgr *Manager) UpdatePortsState(ctx context.Context, deviceID string, portTypeFilter uint32, state voltha.OperStatus_Types) error {
Himani Chawlab4c25912020-11-12 17:16:38 +0530609 logger.Debugw(ctx, "update-ports-state", log.Fields{"device-id": deviceID})
Kent Hagerman2a07b862020-06-19 15:23:07 -0400610 agent := dMgr.getDeviceAgent(ctx, deviceID)
611 if agent == nil {
612 return status.Errorf(codes.NotFound, "%s", deviceID)
khenaidoo3ab34882019-05-02 21:33:30 -0400613 }
Kent Hagerman2a07b862020-06-19 15:23:07 -0400614 if state != voltha.OperStatus_ACTIVE && state != voltha.OperStatus_UNKNOWN {
615 return status.Error(codes.Unimplemented, "state-change-not-implemented")
616 }
617 if err := agent.updatePortsOperState(ctx, portTypeFilter, state); err != nil {
Himani Chawlab4c25912020-11-12 17:16:38 +0530618 logger.Warnw(ctx, "update-ports-state-failed", log.Fields{"device-id": deviceID, "error": err})
Kent Hagerman2a07b862020-06-19 15:23:07 -0400619 return err
620 }
621 return nil
khenaidoo3ab34882019-05-02 21:33:30 -0400622}
623
Kent Hagerman2b216042020-04-03 18:28:56 -0400624func (dMgr *Manager) packetOut(ctx context.Context, deviceID string, outPort uint32, packet *ofp.OfpPacketOut) error {
Himani Chawlab4c25912020-11-12 17:16:38 +0530625 logger.Debugw(ctx, "packet-out", log.Fields{"device-id": deviceID, "out-port": outPort})
npujar467fe752020-01-16 20:17:45 +0530626 if agent := dMgr.getDeviceAgent(ctx, deviceID); agent != nil {
627 return agent.packetOut(ctx, outPort, packet)
khenaidoofdbad6e2018-11-06 22:26:38 -0500628 }
npujar1d86a522019-11-14 17:11:16 +0530629 return status.Errorf(codes.NotFound, "%s", deviceID)
khenaidoofdbad6e2018-11-06 22:26:38 -0500630}
631
npujar1d86a522019-11-14 17:11:16 +0530632// PacketIn receives packet from adapter
Kent Hagerman2b216042020-04-03 18:28:56 -0400633func (dMgr *Manager) PacketIn(ctx context.Context, deviceID string, port uint32, transactionID string, packet []byte) error {
Himani Chawlab4c25912020-11-12 17:16:38 +0530634 logger.Debugw(ctx, "packet-in", log.Fields{"device-id": deviceID, "port": port})
khenaidoofdbad6e2018-11-06 22:26:38 -0500635 // Get the logical device Id based on the deviceId
636 var device *voltha.Device
637 var err error
Kent Hagermancba2f302020-07-28 13:37:36 -0400638 if device, err = dMgr.getDeviceReadOnly(ctx, deviceID); err != nil {
divyadesaicb8b59d2020-08-18 09:55:47 +0000639 logger.Errorw(ctx, "device-not-found", log.Fields{"device-id": deviceID})
khenaidoofdbad6e2018-11-06 22:26:38 -0500640 return err
641 }
khenaidoo43c82122018-11-22 18:38:28 -0500642 if !device.Root {
divyadesaicb8b59d2020-08-18 09:55:47 +0000643 logger.Errorw(ctx, "device-not-root", log.Fields{"device-id": deviceID})
npujar1d86a522019-11-14 17:11:16 +0530644 return status.Errorf(codes.FailedPrecondition, "%s", deviceID)
khenaidoofdbad6e2018-11-06 22:26:38 -0500645 }
646
khenaidood948f772021-08-11 17:49:24 -0400647 if err := dMgr.logicalDeviceMgr.packetIn(ctx, device.ParentId, port, packet); err != nil {
khenaidoofdbad6e2018-11-06 22:26:38 -0500648 return err
649 }
650 return nil
651}
652
Kent Hagerman2b216042020-04-03 18:28:56 -0400653func (dMgr *Manager) setParentID(ctx context.Context, device *voltha.Device, parentID string) error {
Himani Chawlab4c25912020-11-12 17:16:38 +0530654 logger.Debugw(ctx, "set-parent-id", log.Fields{"device-id": device.Id, "parent-id": parentID})
npujar467fe752020-01-16 20:17:45 +0530655 if agent := dMgr.getDeviceAgent(ctx, device.Id); agent != nil {
656 return agent.setParentID(ctx, device, parentID)
khenaidooad06fd72019-10-28 12:26:05 -0400657 }
658 return status.Errorf(codes.NotFound, "%s", device.Id)
659}
660
Kent Hagerman2b216042020-04-03 18:28:56 -0400661func (dMgr *Manager) getParentDevice(ctx context.Context, childDevice *voltha.Device) *voltha.Device {
khenaidoo92e62c52018-10-03 14:02:54 -0400662 // Sanity check
663 if childDevice.Root {
664 // childDevice is the parent device
665 return childDevice
666 }
Kent Hagermancba2f302020-07-28 13:37:36 -0400667 parentDevice, _ := dMgr.getDeviceReadOnly(ctx, childDevice.ParentId)
khenaidoo92e62c52018-10-03 14:02:54 -0400668 return parentDevice
669}
670
khenaidoo4d4802d2018-10-04 21:59:49 -0400671/*
672All the functions below are callback functions where they are invoked with the latest and previous data. We can
673therefore use the data as is without trying to get the latest from the model.
674*/
675
Joey Armstrong393daca2023-07-06 08:47:54 -0400676// DisableAllChildDevices is invoked as a callback when the parent device is disabled
Kent Hagerman2b216042020-04-03 18:28:56 -0400677func (dMgr *Manager) DisableAllChildDevices(ctx context.Context, parentCurrDevice *voltha.Device) error {
Himani Chawlab4c25912020-11-12 17:16:38 +0530678 logger.Debug(ctx, "disable-all-child-devices")
nikesh.krishnan1e3b98a2023-11-26 02:39:53 +0530679 for childDeviceID := range dMgr.getAllChildDeviceIds(ctx, parentCurrDevice.Id) {
npujar467fe752020-01-16 20:17:45 +0530680 if agent := dMgr.getDeviceAgent(ctx, childDeviceID); agent != nil {
Kent Hagerman2a07b862020-06-19 15:23:07 -0400681 if err := agent.disableDevice(ctx); err != nil {
khenaidooe132f522020-03-20 15:23:15 -0400682 // Just log the error - this error happens only if the child device was already in deleted state.
divyadesaicb8b59d2020-08-18 09:55:47 +0000683 logger.Errorw(ctx, "failure-disable-device", log.Fields{"device-id": childDeviceID, "error": err.Error()})
khenaidoo92e62c52018-10-03 14:02:54 -0400684 }
685 }
686 }
687 return nil
688}
689
Joey Armstrong393daca2023-07-06 08:47:54 -0400690// getAllChildDeviceIds is a helper method to get all the child device IDs from the device passed as parameter
nikesh.krishnan1e3b98a2023-11-26 02:39:53 +0530691func (dMgr *Manager) getAllChildDeviceIds(ctx context.Context, parentDeviceID string) map[string]struct{} {
Himani Chawlab4c25912020-11-12 17:16:38 +0530692 logger.Debug(ctx, "get-all-child-device-ids")
nikesh.krishnan1e3b98a2023-11-26 02:39:53 +0530693 childDeviceIds := make(map[string]struct{})
694 dMgr.deviceAgents.Range(func(_, value interface{}) bool {
695 if value.(*Agent).device.ParentId == parentDeviceID && !value.(*Agent).device.Root {
696 childDeviceIds[value.(*Agent).device.Id] = struct{}{}
khenaidoo92e62c52018-10-03 14:02:54 -0400697 }
nikesh.krishnan1e3b98a2023-11-26 02:39:53 +0530698 return true
699 })
700 logger.Debugw(ctx, "returning-getAllChildDeviceIds.", log.Fields{"childDeviceIds": childDeviceIds})
Kent Hagerman2a07b862020-06-19 15:23:07 -0400701 return childDeviceIds
khenaidoo92e62c52018-10-03 14:02:54 -0400702}
703
Joey Armstrong393daca2023-07-06 08:47:54 -0400704// GgtAllChildDevices is a helper method to get all the child device IDs from the device passed as parameter
khenaidood948f772021-08-11 17:49:24 -0400705func (dMgr *Manager) getAllChildDevices(ctx context.Context, parentDeviceID string) (*voltha.Devices, error) {
Himani Chawlab4c25912020-11-12 17:16:38 +0530706 logger.Debugw(ctx, "get-all-child-devices", log.Fields{"parent-device-id": parentDeviceID})
nikesh.krishnan1e3b98a2023-11-26 02:39:53 +0530707 childDevices := make([]*voltha.Device, 0)
708 for deviceID := range dMgr.getAllChildDeviceIds(ctx, parentDeviceID) {
709 if d, e := dMgr.getDeviceReadOnly(ctx, deviceID); e == nil && d != nil {
710 childDevices = append(childDevices, d)
khenaidoo297cd252019-02-07 22:10:23 -0500711 }
khenaidoo297cd252019-02-07 22:10:23 -0500712 }
nikesh.krishnan1e3b98a2023-11-26 02:39:53 +0530713 return &voltha.Devices{Items: childDevices}, nil
khenaidoo297cd252019-02-07 22:10:23 -0500714}
715
Rohan Agrawal31f21802020-06-12 05:38:46 +0000716func (dMgr *Manager) NotifyInvalidTransition(ctx context.Context, device *voltha.Device) error {
Himani Chawlab4c25912020-11-12 17:16:38 +0530717 logger.Errorw(ctx, "notify-invalid-transition", log.Fields{
Kent Hagermand9cc2e92019-11-04 13:28:15 -0500718 "device": device.Id,
719 "curr-admin-state": device.AdminState,
720 "curr-oper-state": device.OperStatus,
721 "curr-conn-state": device.ConnectStatus,
Stephane Barbarieef6650d2019-07-18 12:15:09 -0400722 })
khenaidoo0a822f92019-05-08 15:15:57 -0400723 //TODO: notify over kafka?
724 return nil
725}
726
npujar1d86a522019-11-14 17:11:16 +0530727// UpdateDeviceAttribute updates value of particular device attribute
Kent Hagerman2b216042020-04-03 18:28:56 -0400728func (dMgr *Manager) UpdateDeviceAttribute(ctx context.Context, deviceID string, attribute string, value interface{}) {
npujar1d86a522019-11-14 17:11:16 +0530729 if agent, ok := dMgr.deviceAgents.Load(deviceID); ok {
Kent Hagerman2b216042020-04-03 18:28:56 -0400730 agent.(*Agent).updateDeviceAttribute(ctx, attribute, value)
khenaidoob9203542018-09-17 22:56:37 -0400731 }
732}
733
npujar1d86a522019-11-14 17:11:16 +0530734// GetParentDeviceID returns parent device id, either from memory or from the dB, if present
Kent Hagerman2b216042020-04-03 18:28:56 -0400735func (dMgr *Manager) GetParentDeviceID(ctx context.Context, deviceID string) string {
Kent Hagermancba2f302020-07-28 13:37:36 -0400736 if device, _ := dMgr.getDeviceReadOnly(ctx, deviceID); device != nil {
Himani Chawlab4c25912020-11-12 17:16:38 +0530737 logger.Infow(ctx, "get-parent-device-id", log.Fields{"device-id": device.Id, "parent-id": device.ParentId})
khenaidoo4c9e5592019-09-09 16:20:41 -0400738 return device.ParentId
khenaidoob9203542018-09-17 22:56:37 -0400739 }
khenaidoo4c9e5592019-09-09 16:20:41 -0400740 return ""
khenaidoob9203542018-09-17 22:56:37 -0400741}
serkant.uluderya334479d2019-04-10 08:26:15 -0700742
Kent Hagerman2b216042020-04-03 18:28:56 -0400743func (dMgr *Manager) UpdateDeviceReason(ctx context.Context, deviceID string, reason string) error {
Himani Chawlab4c25912020-11-12 17:16:38 +0530744 logger.Debugw(ctx, "update-device-reason", log.Fields{"device-id": deviceID, "reason": reason})
npujar467fe752020-01-16 20:17:45 +0530745 if agent := dMgr.getDeviceAgent(ctx, deviceID); agent != nil {
746 return agent.updateDeviceReason(ctx, reason)
Mahir Gunyelfdee9212019-10-16 16:52:21 -0700747 }
npujar1d86a522019-11-14 17:11:16 +0530748 return status.Errorf(codes.NotFound, "%s", deviceID)
Mahir Gunyelfdee9212019-10-16 16:52:21 -0700749}
kesavandbc2d1622020-01-21 00:42:01 -0500750
Himani Chawlab4c25912020-11-12 17:16:38 +0530751func (dMgr *Manager) SendRPCEvent(ctx context.Context, id string, rpcEvent *voltha.RPCEvent,
752 category voltha.EventCategory_Types, subCategory *voltha.EventSubCategory_Types, raisedTs int64) {
753 //TODO Instead of directly sending to the kafka bus, queue the message and send it asynchronously
Mahir Gunyelb0343bf2021-05-11 14:14:26 -0700754 dMgr.Agent.SendRPCEvent(ctx, id, rpcEvent, category, subCategory, raisedTs)
Himani Chawlab4c25912020-11-12 17:16:38 +0530755}
Manindera496f852021-02-22 09:57:56 +0530756
khenaidood948f772021-08-11 17:49:24 -0400757func (dMgr *Manager) GetTransientState(ctx context.Context, id string) (core.DeviceTransientState_Types, error) {
Manindera496f852021-02-22 09:57:56 +0530758 agent := dMgr.getDeviceAgent(ctx, id)
759 if agent == nil {
khenaidood948f772021-08-11 17:49:24 -0400760 return core.DeviceTransientState_NONE, status.Errorf(codes.NotFound, "%s", id)
Manindera496f852021-02-22 09:57:56 +0530761 }
762 return agent.getTransientState(), nil
763}
ssiddiquif076cb82021-04-23 10:47:04 +0530764
ssiddiquif076cb82021-04-23 10:47:04 +0530765func (dMgr *Manager) validateImageDownloadRequest(request *voltha.DeviceImageDownloadRequest) error {
766 if request == nil || request.Image == nil || len(request.DeviceId) == 0 {
767 return status.Errorf(codes.InvalidArgument, "invalid argument")
768 }
769
770 for _, deviceID := range request.DeviceId {
771 if deviceID == nil {
772 return status.Errorf(codes.InvalidArgument, "id is nil")
773 }
774 }
775 return nil
776}
777
778func (dMgr *Manager) validateImageRequest(request *voltha.DeviceImageRequest) error {
Elia Battiston58d1c062022-02-08 11:54:27 +0100779 if request == nil {
ssiddiquif076cb82021-04-23 10:47:04 +0530780 return status.Errorf(codes.InvalidArgument, "invalid argument")
781 }
782
783 for _, deviceID := range request.DeviceId {
784 if deviceID == nil {
785 return status.Errorf(codes.InvalidArgument, "id is nil")
786 }
787 }
788
789 return nil
790}
791
792func (dMgr *Manager) validateDeviceImageResponse(response *voltha.DeviceImageResponse) error {
793 if response == nil || len(response.GetDeviceImageStates()) == 0 || response.GetDeviceImageStates()[0] == nil {
794 return status.Errorf(codes.Internal, "invalid-response-from-adapter")
795 }
796
797 return nil
798}
799
800func (dMgr *Manager) waitForAllResponses(ctx context.Context, opName string, respCh chan []*voltha.DeviceImageState, expectedResps int) (*voltha.DeviceImageResponse, error) {
801 response := &voltha.DeviceImageResponse{}
802 respCount := 0
803 for {
804 select {
805 case resp, ok := <-respCh:
806 if !ok {
807 logger.Errorw(ctx, opName+"-failed", log.Fields{"error": "channel-closed"})
808 return response, status.Errorf(codes.Aborted, "channel-closed")
809 }
810
811 if resp != nil {
812 logger.Debugw(ctx, opName+"-result", log.Fields{"image-state": resp[0].GetImageState(), "device-id": resp[0].GetDeviceId()})
813 response.DeviceImageStates = append(response.DeviceImageStates, resp...)
814 }
815
816 respCount++
817
818 //check whether all responses received, if so, sent back the collated response
819 if respCount == expectedResps {
820 return response, nil
821 }
822 continue
823 case <-ctx.Done():
824 return nil, status.Errorf(codes.Aborted, opName+"-failed-%s", ctx.Err())
825 }
826 }
827}
Maninder0aabf0c2021-03-17 14:55:14 +0530828
829func (dMgr *Manager) ReconcilingCleanup(ctx context.Context, device *voltha.Device) error {
830 agent := dMgr.getDeviceAgent(ctx, device.Id)
831 if agent == nil {
832 logger.Errorf(ctx, "Not able to get device agent.")
833 return status.Errorf(codes.NotFound, "Not able to get device agent for device : %s", device.Id)
834 }
835 err := agent.reconcilingCleanup(ctx)
836 if err != nil {
837 logger.Errorf(ctx, err.Error())
838 return status.Errorf(codes.Internal, err.Error())
839 }
840 return nil
841}
khenaidood948f772021-08-11 17:49:24 -0400842
843func (dMgr *Manager) adapterRestartedHandler(ctx context.Context, endpoint string) error {
844 // Get the adapter corresponding to that endpoint
845 if a, _ := dMgr.adapterMgr.GetAdapterWithEndpoint(ctx, endpoint); a != nil {
Girish Gowdra11ddb232022-05-26 12:19:59 -0700846 if rollingUpdate, _ := dMgr.adapterMgr.GetRollingUpdate(ctx, endpoint); rollingUpdate {
847 dMgr.adapterMgr.RegisterOnRxStreamCloseChMap(ctx, endpoint)
848 // Blocking call. wait for the old adapters rx stream to close.
849 // That is a signal that the old adapter is completely down
850 dMgr.adapterMgr.WaitOnRxStreamCloseCh(ctx, endpoint)
851 dMgr.adapterMgr.DeleteRollingUpdate(ctx, endpoint)
852 // In case of rolling update we need to start the connection towards the new adapter instance now
853 if err := dMgr.adapterMgr.StartAdapterWithEndPoint(ctx, endpoint); err != nil {
854 return err
855 }
856 }
khenaidood948f772021-08-11 17:49:24 -0400857 return dMgr.adapterRestarted(ctx, a)
858 }
859 logger.Errorw(ctx, "restarted-adapter-not-found", log.Fields{"endpoint": endpoint})
860 return fmt.Errorf("restarted adapter at endpoint %s not found", endpoint)
861}