blob: 913f9e46842de29127e13033cc91b16c49e3d582 [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
khenaidoob9203542018-09-17 22:56:37 -040017package core
18
19import (
20 "context"
Matteo Scandolo360605d2019-11-05 18:29:17 -080021 "encoding/hex"
khenaidoo3ab34882019-05-02 21:33:30 -040022 "fmt"
Chaitrashree G Sa773e992019-09-09 21:04:15 -040023 "reflect"
24 "sync"
25 "time"
26
khenaidoob9203542018-09-17 22:56:37 -040027 "github.com/gogo/protobuf/proto"
sbarbari17d7e222019-11-05 10:02:29 -050028 "github.com/opencord/voltha-go/db/model"
Scott Bakerb671a862019-10-24 10:53:40 -070029 coreutils "github.com/opencord/voltha-go/rw_core/utils"
serkant.uluderya2ae470f2020-01-21 11:13:09 -080030 fu "github.com/opencord/voltha-lib-go/v3/pkg/flows"
31 "github.com/opencord/voltha-lib-go/v3/pkg/log"
32 ic "github.com/opencord/voltha-protos/v3/go/inter_container"
33 ofp "github.com/opencord/voltha-protos/v3/go/openflow_13"
34 "github.com/opencord/voltha-protos/v3/go/voltha"
khenaidoob9203542018-09-17 22:56:37 -040035 "google.golang.org/grpc/codes"
36 "google.golang.org/grpc/status"
khenaidoob9203542018-09-17 22:56:37 -040037)
38
npujar1d86a522019-11-14 17:11:16 +053039// DeviceAgent represents device agent attributes
khenaidoob9203542018-09-17 22:56:37 -040040type DeviceAgent struct {
npujar1d86a522019-11-14 17:11:16 +053041 deviceID string
42 parentID string
khenaidoo43c82122018-11-22 18:38:28 -050043 deviceType string
khenaidoo2c6a0992019-04-29 13:46:56 -040044 isRootdevice bool
khenaidoo9a468962018-09-19 15:33:13 -040045 adapterProxy *AdapterProxy
serkant.uluderya334479d2019-04-10 08:26:15 -070046 adapterMgr *AdapterManager
khenaidoo9a468962018-09-19 15:33:13 -040047 deviceMgr *DeviceManager
48 clusterDataProxy *model.Proxy
khenaidoo92e62c52018-10-03 14:02:54 -040049 deviceProxy *model.Proxy
khenaidoo9a468962018-09-19 15:33:13 -040050 exitChannel chan int
khenaidoo92e62c52018-10-03 14:02:54 -040051 lockDevice sync.RWMutex
khenaidoo6e55d9e2019-12-12 18:26:26 -050052 device *voltha.Device
khenaidoo2c6a0992019-04-29 13:46:56 -040053 defaultTimeout int64
khenaidoob9203542018-09-17 22:56:37 -040054}
55
Scott Baker80678602019-11-14 16:57:36 -080056//newDeviceAgent creates a new device agent. The device will be initialized when start() is called.
khenaidoo2c6a0992019-04-29 13:46:56 -040057func newDeviceAgent(ap *AdapterProxy, device *voltha.Device, deviceMgr *DeviceManager, cdProxy *model.Proxy, timeout int64) *DeviceAgent {
khenaidoob9203542018-09-17 22:56:37 -040058 var agent DeviceAgent
khenaidoob9203542018-09-17 22:56:37 -040059 agent.adapterProxy = ap
Scott Baker80678602019-11-14 16:57:36 -080060 if device.Id == "" {
npujar1d86a522019-11-14 17:11:16 +053061 agent.deviceID = CreateDeviceID()
Scott Baker80678602019-11-14 16:57:36 -080062 } else {
npujar1d86a522019-11-14 17:11:16 +053063 agent.deviceID = device.Id
Stephane Barbarie1ab43272018-12-08 21:42:13 -050064 }
Scott Baker80678602019-11-14 16:57:36 -080065
khenaidoo2c6a0992019-04-29 13:46:56 -040066 agent.isRootdevice = device.Root
npujar1d86a522019-11-14 17:11:16 +053067 agent.parentID = device.ParentId
Scott Baker80678602019-11-14 16:57:36 -080068 agent.deviceType = device.Type
khenaidoob9203542018-09-17 22:56:37 -040069 agent.deviceMgr = deviceMgr
khenaidoo21d51152019-02-01 13:48:37 -050070 agent.adapterMgr = deviceMgr.adapterMgr
khenaidoob9203542018-09-17 22:56:37 -040071 agent.exitChannel = make(chan int, 1)
khenaidoo9a468962018-09-19 15:33:13 -040072 agent.clusterDataProxy = cdProxy
khenaidoo92e62c52018-10-03 14:02:54 -040073 agent.lockDevice = sync.RWMutex{}
khenaidoo2c6a0992019-04-29 13:46:56 -040074 agent.defaultTimeout = timeout
khenaidoo6e55d9e2019-12-12 18:26:26 -050075 agent.device = proto.Clone(device).(*voltha.Device)
khenaidoob9203542018-09-17 22:56:37 -040076 return &agent
77}
78
Scott Baker80678602019-11-14 16:57:36 -080079// start()
80// save the device to the data model and registers for callbacks on that device if deviceToCreate!=nil. Otherwise,
npujar1d86a522019-11-14 17:11:16 +053081// it will load the data from the dB and setup the necessary callbacks and proxies. Returns the device that
Scott Baker80678602019-11-14 16:57:36 -080082// was started.
83func (agent *DeviceAgent) start(ctx context.Context, deviceToCreate *voltha.Device) (*voltha.Device, error) {
84 var device *voltha.Device
85
khenaidoo92e62c52018-10-03 14:02:54 -040086 agent.lockDevice.Lock()
87 defer agent.lockDevice.Unlock()
npujar1d86a522019-11-14 17:11:16 +053088 log.Debugw("starting-device-agent", log.Fields{"deviceId": agent.deviceID})
Scott Baker80678602019-11-14 16:57:36 -080089 if deviceToCreate == nil {
90 // Load the existing device
Thomas Lee Se5a44012019-11-07 20:32:24 +053091 loadedDevice, err := agent.clusterDataProxy.Get(ctx, "/devices/"+agent.deviceID, 1, true, "")
92 if err != nil {
93 log.Errorw("failed-to-get-from-cluster-data-proxy", log.Fields{"error": err})
94 return nil, err
95 }
96 if loadedDevice != nil {
Scott Baker80678602019-11-14 16:57:36 -080097 var ok bool
98 if device, ok = loadedDevice.(*voltha.Device); ok {
99 agent.deviceType = device.Adapter
khenaidoo6e55d9e2019-12-12 18:26:26 -0500100 agent.device = proto.Clone(device).(*voltha.Device)
Scott Baker80678602019-11-14 16:57:36 -0800101 } else {
npujar1d86a522019-11-14 17:11:16 +0530102 log.Errorw("failed-to-convert-device", log.Fields{"deviceId": agent.deviceID})
103 return nil, status.Errorf(codes.NotFound, "device-%s", agent.deviceID)
khenaidoo297cd252019-02-07 22:10:23 -0500104 }
105 } else {
npujar1d86a522019-11-14 17:11:16 +0530106 log.Errorw("failed-to-load-device", log.Fields{"deviceId": agent.deviceID})
107 return nil, status.Errorf(codes.NotFound, "device-%s", agent.deviceID)
khenaidoo297cd252019-02-07 22:10:23 -0500108 }
npujar1d86a522019-11-14 17:11:16 +0530109 log.Debugw("device-loaded-from-dB", log.Fields{"deviceId": agent.deviceID})
khenaidoo297cd252019-02-07 22:10:23 -0500110 } else {
Scott Baker80678602019-11-14 16:57:36 -0800111 // Create a new device
112 // Assumption is that AdminState, FlowGroups, and Flows are unitialized since this
113 // is a new device, so populate them here before passing the device to clusterDataProxy.AddWithId.
114 // agent.deviceId will also have been set during newDeviceAgent().
115 device = (proto.Clone(deviceToCreate)).(*voltha.Device)
npujar1d86a522019-11-14 17:11:16 +0530116 device.Id = agent.deviceID
Scott Baker80678602019-11-14 16:57:36 -0800117 device.AdminState = voltha.AdminState_PREPROVISIONED
118 device.FlowGroups = &ofp.FlowGroups{Items: nil}
119 device.Flows = &ofp.Flows{Items: nil}
120 if !deviceToCreate.GetRoot() && deviceToCreate.ProxyAddress != nil {
121 // Set the default vlan ID to the one specified by the parent adapter. It can be
122 // overwritten by the child adapter during a device update request
123 device.Vlan = deviceToCreate.ProxyAddress.ChannelId
124 }
125
khenaidoo297cd252019-02-07 22:10:23 -0500126 // Add the initial device to the local model
Thomas Lee Se5a44012019-11-07 20:32:24 +0530127 added, err := agent.clusterDataProxy.AddWithID(ctx, "/devices", agent.deviceID, device, "")
128 if err != nil {
129 log.Errorw("failed-to-save-devices-to-cluster-proxy", log.Fields{"error": err})
130 return nil, err
131 }
132 if added == nil {
npujar1d86a522019-11-14 17:11:16 +0530133 log.Errorw("failed-to-add-device", log.Fields{"deviceId": agent.deviceID})
134 return nil, status.Errorf(codes.Aborted, "failed-adding-device-%s", agent.deviceID)
khenaidoo297cd252019-02-07 22:10:23 -0500135 }
khenaidoo6e55d9e2019-12-12 18:26:26 -0500136 agent.device = proto.Clone(device).(*voltha.Device)
khenaidoob9203542018-09-17 22:56:37 -0400137 }
Thomas Lee Se5a44012019-11-07 20:32:24 +0530138 var err error
139 if agent.deviceProxy, err = agent.clusterDataProxy.CreateProxy(ctx, "/devices/"+agent.deviceID, false); err != nil {
140 log.Errorw("failed-to-add-devices-to-cluster-proxy", log.Fields{"error": err})
141 return nil, err
142 }
npujar9a30c702019-11-14 17:06:39 +0530143 agent.deviceProxy.RegisterCallback(model.PostUpdate, agent.processUpdate)
khenaidoo19d7b632018-10-30 10:49:50 -0400144
npujar1d86a522019-11-14 17:11:16 +0530145 log.Debugw("device-agent-started", log.Fields{"deviceId": agent.deviceID})
Scott Baker80678602019-11-14 16:57:36 -0800146 return device, nil
khenaidoob9203542018-09-17 22:56:37 -0400147}
148
khenaidoo4d4802d2018-10-04 21:59:49 -0400149// stop stops the device agent. Not much to do for now
150func (agent *DeviceAgent) stop(ctx context.Context) {
khenaidoo92e62c52018-10-03 14:02:54 -0400151 agent.lockDevice.Lock()
152 defer agent.lockDevice.Unlock()
khenaidoo49085352020-01-13 19:15:43 -0500153
154 log.Debugw("stopping-device-agent", log.Fields{"deviceId": agent.deviceID, "parentId": agent.parentID})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500155
156 // First unregister any callbacks
npujar9a30c702019-11-14 17:06:39 +0530157 agent.deviceProxy.UnregisterCallback(model.PostUpdate, agent.processUpdate)
khenaidoo6e55d9e2019-12-12 18:26:26 -0500158
khenaidoo0a822f92019-05-08 15:15:57 -0400159 // Remove the device from the KV store
Thomas Lee Se5a44012019-11-07 20:32:24 +0530160 removed, err := agent.clusterDataProxy.Remove(ctx, "/devices/"+agent.deviceID, "")
161 if err != nil {
162 log.Errorw("Failed-to-remove-device-from-cluster-data-proxy", log.Fields{"error": err})
163 return
164 }
165 if removed == nil {
npujar1d86a522019-11-14 17:11:16 +0530166 log.Debugw("device-already-removed", log.Fields{"id": agent.deviceID})
khenaidoo0a822f92019-05-08 15:15:57 -0400167 }
khenaidoob9203542018-09-17 22:56:37 -0400168 agent.exitChannel <- 1
khenaidoo49085352020-01-13 19:15:43 -0500169 log.Debugw("device-agent-stopped", log.Fields{"deviceId": agent.deviceID, "parentId": agent.parentID})
khenaidoob9203542018-09-17 22:56:37 -0400170}
171
Scott Baker80678602019-11-14 16:57:36 -0800172// Load the most recent state from the KVStore for the device.
npujar467fe752020-01-16 20:17:45 +0530173func (agent *DeviceAgent) reconcileWithKVStore(ctx context.Context) {
Scott Baker80678602019-11-14 16:57:36 -0800174 agent.lockDevice.Lock()
175 defer agent.lockDevice.Unlock()
176 log.Debug("reconciling-device-agent-devicetype")
177 // TODO: context timeout
npujar467fe752020-01-16 20:17:45 +0530178 device, err := agent.clusterDataProxy.Get(ctx, "/devices/"+agent.deviceID, 1, true, "")
Thomas Lee Se5a44012019-11-07 20:32:24 +0530179 if err != nil {
180 log.Errorw("Failed to get device info from cluster data proxy", log.Fields{"error": err})
181 return
182 }
183 if device != nil {
Scott Baker80678602019-11-14 16:57:36 -0800184 if d, ok := device.(*voltha.Device); ok {
185 agent.deviceType = d.Adapter
khenaidoo6e55d9e2019-12-12 18:26:26 -0500186 agent.device = proto.Clone(d).(*voltha.Device)
npujar1d86a522019-11-14 17:11:16 +0530187 log.Debugw("reconciled-device-agent-devicetype", log.Fields{"Id": agent.deviceID, "type": agent.deviceType})
Scott Baker80678602019-11-14 16:57:36 -0800188 }
189 }
190}
191
khenaidoo6e55d9e2019-12-12 18:26:26 -0500192// getDevice returns the device data from cache
193func (agent *DeviceAgent) getDevice() *voltha.Device {
khenaidoo1ce37ad2019-03-24 22:07:24 -0400194 agent.lockDevice.RLock()
195 defer agent.lockDevice.RUnlock()
khenaidoo6e55d9e2019-12-12 18:26:26 -0500196 return proto.Clone(agent.device).(*voltha.Device)
khenaidoo92e62c52018-10-03 14:02:54 -0400197}
198
khenaidoo4d4802d2018-10-04 21:59:49 -0400199// getDeviceWithoutLock is a helper function to be used ONLY by any device agent function AFTER it has acquired the device lock.
khenaidoo6e55d9e2019-12-12 18:26:26 -0500200func (agent *DeviceAgent) getDeviceWithoutLock() *voltha.Device {
201 return proto.Clone(agent.device).(*voltha.Device)
khenaidoo92e62c52018-10-03 14:02:54 -0400202}
203
khenaidoo3ab34882019-05-02 21:33:30 -0400204// enableDevice activates a preprovisioned or a disable device
khenaidoob9203542018-09-17 22:56:37 -0400205func (agent *DeviceAgent) enableDevice(ctx context.Context) error {
khenaidoo92e62c52018-10-03 14:02:54 -0400206 agent.lockDevice.Lock()
207 defer agent.lockDevice.Unlock()
npujar1d86a522019-11-14 17:11:16 +0530208 log.Debugw("enableDevice", log.Fields{"id": agent.deviceID})
khenaidoo21d51152019-02-01 13:48:37 -0500209
khenaidoo6e55d9e2019-12-12 18:26:26 -0500210 cloned := agent.getDeviceWithoutLock()
211
npujar1d86a522019-11-14 17:11:16 +0530212 // First figure out which adapter will handle this device type. We do it at this stage as allow devices to be
213 // pre-provisionned with the required adapter not registered. At this stage, since we need to communicate
214 // with the adapter then we need to know the adapter that will handle this request
khenaidoo6e55d9e2019-12-12 18:26:26 -0500215 adapterName, err := agent.adapterMgr.getAdapterName(cloned.Type)
npujar1d86a522019-11-14 17:11:16 +0530216 if err != nil {
khenaidoo6e55d9e2019-12-12 18:26:26 -0500217 log.Warnw("no-adapter-registered-for-device-type", log.Fields{"deviceType": cloned.Type, "deviceAdapter": cloned.Adapter})
npujar1d86a522019-11-14 17:11:16 +0530218 return err
219 }
khenaidoo6e55d9e2019-12-12 18:26:26 -0500220 cloned.Adapter = adapterName
npujar1d86a522019-11-14 17:11:16 +0530221
khenaidoo6e55d9e2019-12-12 18:26:26 -0500222 if cloned.AdminState == voltha.AdminState_ENABLED {
npujar1d86a522019-11-14 17:11:16 +0530223 log.Debugw("device-already-enabled", log.Fields{"id": agent.deviceID})
224 return nil
225 }
226
khenaidoo6e55d9e2019-12-12 18:26:26 -0500227 if cloned.AdminState == voltha.AdminState_DELETED {
npujar1d86a522019-11-14 17:11:16 +0530228 // This is a temporary state when a device is deleted before it gets removed from the model.
khenaidoo6e55d9e2019-12-12 18:26:26 -0500229 err = status.Error(codes.FailedPrecondition, fmt.Sprintf("cannot-enable-a-deleted-device: %s ", cloned.Id))
230 log.Warnw("invalid-state", log.Fields{"id": agent.deviceID, "state": cloned.AdminState, "error": err})
npujar1d86a522019-11-14 17:11:16 +0530231 return err
232 }
233
khenaidoo6e55d9e2019-12-12 18:26:26 -0500234 previousAdminState := cloned.AdminState
npujar1d86a522019-11-14 17:11:16 +0530235
236 // Update the Admin State and set the operational state to activating before sending the request to the
237 // Adapters
npujar1d86a522019-11-14 17:11:16 +0530238 cloned.AdminState = voltha.AdminState_ENABLED
239 cloned.OperStatus = voltha.OperStatus_ACTIVATING
240
npujar467fe752020-01-16 20:17:45 +0530241 if err := agent.updateDeviceInStoreWithoutLock(ctx, cloned, false, ""); err != nil {
npujar1d86a522019-11-14 17:11:16 +0530242 return err
243 }
244
245 // Adopt the device if it was in preprovision state. In all other cases, try to reenable it.
khenaidoo6e55d9e2019-12-12 18:26:26 -0500246 device := proto.Clone(cloned).(*voltha.Device)
npujar1d86a522019-11-14 17:11:16 +0530247 if previousAdminState == voltha.AdminState_PREPROVISIONED {
248 if err := agent.adapterProxy.AdoptDevice(ctx, device); err != nil {
249 log.Debugw("adoptDevice-error", log.Fields{"id": agent.deviceID, "error": err})
250 return err
251 }
khenaidoob9203542018-09-17 22:56:37 -0400252 } else {
npujar1d86a522019-11-14 17:11:16 +0530253 if err := agent.adapterProxy.ReEnableDevice(ctx, device); err != nil {
254 log.Debugw("renableDevice-error", log.Fields{"id": agent.deviceID, "error": err})
khenaidoo21d51152019-02-01 13:48:37 -0500255 return err
khenaidoob9203542018-09-17 22:56:37 -0400256 }
257 }
258 return nil
259}
260
npujar467fe752020-01-16 20:17:45 +0530261func (agent *DeviceAgent) sendBulkFlowsToAdapters(ctx context.Context, device *voltha.Device, flows *voltha.Flows, groups *voltha.FlowGroups, flowMetadata *voltha.FlowMetadata, response coreutils.Response) {
262 if err := agent.adapterProxy.UpdateFlowsBulk(ctx, device, flows, groups, flowMetadata); err != nil {
npujar1d86a522019-11-14 17:11:16 +0530263 log.Debugw("update-flow-bulk-error", log.Fields{"id": agent.deviceID, "error": err})
Kent Hagerman8da2f1e2019-11-25 17:28:09 -0500264 response.Error(err)
khenaidoo2c6a0992019-04-29 13:46:56 -0400265 }
Kent Hagerman8da2f1e2019-11-25 17:28:09 -0500266 response.Done()
khenaidoo2c6a0992019-04-29 13:46:56 -0400267}
268
npujar467fe752020-01-16 20:17:45 +0530269func (agent *DeviceAgent) sendIncrementalFlowsToAdapters(ctx context.Context, device *voltha.Device, flows *ofp.FlowChanges, groups *ofp.FlowGroupChanges, flowMetadata *voltha.FlowMetadata, response coreutils.Response) {
270 if err := agent.adapterProxy.UpdateFlowsIncremental(ctx, device, flows, groups, flowMetadata); err != nil {
npujar1d86a522019-11-14 17:11:16 +0530271 log.Debugw("update-flow-incremental-error", log.Fields{"id": agent.deviceID, "error": err})
Kent Hagerman8da2f1e2019-11-25 17:28:09 -0500272 response.Error(err)
khenaidoo2c6a0992019-04-29 13:46:56 -0400273 }
Kent Hagerman8da2f1e2019-11-25 17:28:09 -0500274 response.Done()
khenaidoo2c6a0992019-04-29 13:46:56 -0400275}
276
khenaidoob2121e52019-12-16 17:17:22 -0500277//deleteFlowWithoutPreservingOrder removes a flow specified by index from the flows slice. This function will
278//panic if the index is out of range.
279func deleteFlowWithoutPreservingOrder(flows []*ofp.OfpFlowStats, index int) []*ofp.OfpFlowStats {
280 flows[index] = flows[len(flows)-1]
281 flows[len(flows)-1] = nil
282 return flows[:len(flows)-1]
283}
284
285//deleteGroupWithoutPreservingOrder removes a group specified by index from the groups slice. This function will
286//panic if the index is out of range.
287func deleteGroupWithoutPreservingOrder(groups []*ofp.OfpGroupEntry, index int) []*ofp.OfpGroupEntry {
288 groups[index] = groups[len(groups)-1]
289 groups[len(groups)-1] = nil
290 return groups[:len(groups)-1]
291}
292
293func flowsToUpdateToDelete(newFlows, existingFlows []*ofp.OfpFlowStats) (updatedNewFlows, flowsToDelete, updatedAllFlows []*ofp.OfpFlowStats) {
294 // Process flows
295 for _, flow := range existingFlows {
296 if idx := fu.FindFlows(newFlows, flow); idx == -1 {
297 updatedAllFlows = append(updatedAllFlows, flow)
298 } else {
299 // We have a matching flow (i.e. the following field matches: "TableId", "Priority", "Flags", "Cookie",
300 // "Match". If this is an exact match (i.e. all other fields matches as well) then this flow will be
301 // ignored. Otherwise, the previous flow will be deleted and the new one added
302 if proto.Equal(newFlows[idx], flow) {
303 // Flow already exist, remove it from the new flows but keep it in the updated flows slice
304 newFlows = deleteFlowWithoutPreservingOrder(newFlows, idx)
305 updatedAllFlows = append(updatedAllFlows, flow)
306 } else {
307 // Minor change to flow, delete old and add new one
308 flowsToDelete = append(flowsToDelete, flow)
309 }
310 }
311 }
312 updatedAllFlows = append(updatedAllFlows, newFlows...)
313 return newFlows, flowsToDelete, updatedAllFlows
314}
315
316func groupsToUpdateToDelete(newGroups, existingGroups []*ofp.OfpGroupEntry) (updatedNewGroups, groupsToDelete, updatedAllGroups []*ofp.OfpGroupEntry) {
317 for _, group := range existingGroups {
318 if idx := fu.FindGroup(newGroups, group.Desc.GroupId); idx == -1 { // does not exist now
319 updatedAllGroups = append(updatedAllGroups, group)
320 } else {
321 // Follow same logic as flows
322 if proto.Equal(newGroups[idx], group) {
323 // Group already exist, remove it from the new groups
324 newGroups = deleteGroupWithoutPreservingOrder(newGroups, idx)
325 updatedAllGroups = append(updatedAllGroups, group)
326 } else {
327 // Minor change to group, delete old and add new one
328 groupsToDelete = append(groupsToDelete, group)
329 }
330 }
331 }
332 updatedAllGroups = append(updatedAllGroups, newGroups...)
333 return newGroups, groupsToDelete, updatedAllGroups
334}
335
npujar467fe752020-01-16 20:17:45 +0530336func (agent *DeviceAgent) addFlowsAndGroupsToAdapter(ctx context.Context, newFlows []*ofp.OfpFlowStats, newGroups []*ofp.OfpGroupEntry, flowMetadata *voltha.FlowMetadata) (coreutils.Response, error) {
npujar1d86a522019-11-14 17:11:16 +0530337 log.Debugw("addFlowsAndGroups", log.Fields{"deviceId": agent.deviceID, "flows": newFlows, "groups": newGroups, "flowMetadata": flowMetadata})
khenaidoo0458db62019-06-20 08:50:36 -0400338
khenaidoo2c6a0992019-04-29 13:46:56 -0400339 if (len(newFlows) | len(newGroups)) == 0 {
npujar1d86a522019-11-14 17:11:16 +0530340 log.Debugw("nothing-to-update", log.Fields{"deviceId": agent.deviceID, "flows": newFlows, "groups": newGroups})
A R Karthick5c28f552019-12-11 22:47:44 -0800341 return coreutils.DoneResponse(), nil
khenaidoo2c6a0992019-04-29 13:46:56 -0400342 }
343
khenaidoo19d7b632018-10-30 10:49:50 -0400344 agent.lockDevice.Lock()
345 defer agent.lockDevice.Unlock()
khenaidoo2c6a0992019-04-29 13:46:56 -0400346
khenaidoo6e55d9e2019-12-12 18:26:26 -0500347 device := agent.getDeviceWithoutLock()
khenaidoo0458db62019-06-20 08:50:36 -0400348 existingFlows := proto.Clone(device.Flows).(*voltha.Flows)
349 existingGroups := proto.Clone(device.FlowGroups).(*ofp.FlowGroups)
350
khenaidoo0458db62019-06-20 08:50:36 -0400351 // Process flows
khenaidoob2121e52019-12-16 17:17:22 -0500352 newFlows, flowsToDelete, updatedAllFlows := flowsToUpdateToDelete(newFlows, existingFlows.Items)
khenaidoo0458db62019-06-20 08:50:36 -0400353
354 // Process groups
khenaidoob2121e52019-12-16 17:17:22 -0500355 newGroups, groupsToDelete, updatedAllGroups := groupsToUpdateToDelete(newGroups, existingGroups.Items)
khenaidoo0458db62019-06-20 08:50:36 -0400356
357 // Sanity check
khenaidoob2121e52019-12-16 17:17:22 -0500358 if (len(updatedAllFlows) | len(flowsToDelete) | len(updatedAllGroups) | len(groupsToDelete)) == 0 {
npujar1d86a522019-11-14 17:11:16 +0530359 log.Debugw("nothing-to-update", log.Fields{"deviceId": agent.deviceID, "flows": newFlows, "groups": newGroups})
A R Karthick5c28f552019-12-11 22:47:44 -0800360 return coreutils.DoneResponse(), nil
khenaidoo0458db62019-06-20 08:50:36 -0400361 }
362
363 // Send update to adapters
364 // Create two channels to receive responses from the dB and from the adapters.
365 // Do not close these channels as this function may exit on timeout before the dB or adapters get a chance
366 // to send their responses. These channels will be garbage collected once all the responses are
367 // received
Kent Hagerman8da2f1e2019-11-25 17:28:09 -0500368 response := coreutils.NewResponse()
khenaidoo0458db62019-06-20 08:50:36 -0400369 dType := agent.adapterMgr.getDeviceType(device.Type)
khenaidooe7be1332020-01-24 18:58:33 -0500370 if dType == nil {
371 log.Errorw("non-existent device type", log.Fields{"deviceType": device.Type})
372 return coreutils.DoneResponse(), status.Errorf(codes.FailedPrecondition, "non-existent device type %s", device.Type)
373 }
khenaidoo0458db62019-06-20 08:50:36 -0400374 if !dType.AcceptsAddRemoveFlowUpdates {
375
khenaidoob2121e52019-12-16 17:17:22 -0500376 if len(updatedAllGroups) != 0 && reflect.DeepEqual(existingGroups.Items, updatedAllGroups) && len(updatedAllFlows) != 0 && reflect.DeepEqual(existingFlows.Items, updatedAllFlows) {
npujar1d86a522019-11-14 17:11:16 +0530377 log.Debugw("nothing-to-update", log.Fields{"deviceId": agent.deviceID, "flows": newFlows, "groups": newGroups})
A R Karthick5c28f552019-12-11 22:47:44 -0800378 return coreutils.DoneResponse(), nil
khenaidoo0458db62019-06-20 08:50:36 -0400379 }
npujar467fe752020-01-16 20:17:45 +0530380 go agent.sendBulkFlowsToAdapters(ctx, device, &voltha.Flows{Items: updatedAllFlows}, &voltha.FlowGroups{Items: updatedAllGroups}, flowMetadata, response)
khenaidoo0458db62019-06-20 08:50:36 -0400381
382 } else {
383 flowChanges := &ofp.FlowChanges{
Matt Jeanneret518b5a42019-10-29 10:30:46 -0400384 ToAdd: &voltha.Flows{Items: newFlows},
khenaidoo0458db62019-06-20 08:50:36 -0400385 ToRemove: &voltha.Flows{Items: flowsToDelete},
386 }
387 groupChanges := &ofp.FlowGroupChanges{
Matt Jeanneret518b5a42019-10-29 10:30:46 -0400388 ToAdd: &voltha.FlowGroups{Items: newGroups},
389 ToRemove: &voltha.FlowGroups{Items: groupsToDelete},
khenaidoo0458db62019-06-20 08:50:36 -0400390 ToUpdate: &voltha.FlowGroups{Items: []*ofp.OfpGroupEntry{}},
391 }
npujar467fe752020-01-16 20:17:45 +0530392 go agent.sendIncrementalFlowsToAdapters(ctx, device, flowChanges, groupChanges, flowMetadata, response)
khenaidoo0458db62019-06-20 08:50:36 -0400393 }
394
395 // store the changed data
khenaidoob2121e52019-12-16 17:17:22 -0500396 device.Flows = &voltha.Flows{Items: updatedAllFlows}
397 device.FlowGroups = &voltha.FlowGroups{Items: updatedAllGroups}
npujar467fe752020-01-16 20:17:45 +0530398 if err := agent.updateDeviceWithoutLock(ctx, device); err != nil {
A R Karthick5c28f552019-12-11 22:47:44 -0800399 return coreutils.DoneResponse(), status.Errorf(codes.Internal, "failure-updating-%s", agent.deviceID)
Kent Hagerman3c513972019-11-25 13:49:41 -0500400 }
khenaidoo0458db62019-06-20 08:50:36 -0400401
A R Karthick5c28f552019-12-11 22:47:44 -0800402 return response, nil
403}
404
405//addFlowsAndGroups adds the "newFlows" and "newGroups" from the existing flows/groups and sends the update to the
406//adapters
npujar467fe752020-01-16 20:17:45 +0530407func (agent *DeviceAgent) addFlowsAndGroups(ctx context.Context, newFlows []*ofp.OfpFlowStats, newGroups []*ofp.OfpGroupEntry, flowMetadata *voltha.FlowMetadata) error {
408 response, err := agent.addFlowsAndGroupsToAdapter(ctx, newFlows, newGroups, flowMetadata)
A R Karthick5c28f552019-12-11 22:47:44 -0800409 if err != nil {
410 return err
411 }
Kent Hagerman8da2f1e2019-11-25 17:28:09 -0500412 if res := coreutils.WaitForNilOrErrorResponses(agent.defaultTimeout, response); res != nil {
Manikkaraj kb1a10922019-07-29 12:10:34 -0400413 log.Debugw("Failed to get response from adapter[or] DB", log.Fields{"result": res})
khenaidoo0458db62019-06-20 08:50:36 -0400414 return status.Errorf(codes.Aborted, "errors-%s", res)
415 }
khenaidoo0458db62019-06-20 08:50:36 -0400416 return nil
417}
418
npujar467fe752020-01-16 20:17:45 +0530419func (agent *DeviceAgent) deleteFlowsAndGroupsFromAdapter(ctx context.Context, flowsToDel []*ofp.OfpFlowStats, groupsToDel []*ofp.OfpGroupEntry, flowMetadata *voltha.FlowMetadata) (coreutils.Response, error) {
npujar1d86a522019-11-14 17:11:16 +0530420 log.Debugw("deleteFlowsAndGroups", log.Fields{"deviceId": agent.deviceID, "flows": flowsToDel, "groups": groupsToDel})
khenaidoo0458db62019-06-20 08:50:36 -0400421
422 if (len(flowsToDel) | len(groupsToDel)) == 0 {
npujar1d86a522019-11-14 17:11:16 +0530423 log.Debugw("nothing-to-update", log.Fields{"deviceId": agent.deviceID, "flows": flowsToDel, "groups": groupsToDel})
A R Karthick5c28f552019-12-11 22:47:44 -0800424 return coreutils.DoneResponse(), nil
khenaidoo0458db62019-06-20 08:50:36 -0400425 }
426
427 agent.lockDevice.Lock()
428 defer agent.lockDevice.Unlock()
429
khenaidoo6e55d9e2019-12-12 18:26:26 -0500430 device := agent.getDeviceWithoutLock()
khenaidoo0458db62019-06-20 08:50:36 -0400431
432 existingFlows := proto.Clone(device.Flows).(*voltha.Flows)
433 existingGroups := proto.Clone(device.FlowGroups).(*ofp.FlowGroups)
434
435 var flowsToKeep []*ofp.OfpFlowStats
436 var groupsToKeep []*ofp.OfpGroupEntry
437
438 // Process flows
439 for _, flow := range existingFlows.Items {
440 if idx := fu.FindFlows(flowsToDel, flow); idx == -1 {
441 flowsToKeep = append(flowsToKeep, flow)
442 }
443 }
444
445 // Process groups
446 for _, group := range existingGroups.Items {
447 if fu.FindGroup(groupsToDel, group.Desc.GroupId) == -1 { // does not exist now
448 groupsToKeep = append(groupsToKeep, group)
449 }
450 }
451
452 log.Debugw("deleteFlowsAndGroups",
453 log.Fields{
npujar1d86a522019-11-14 17:11:16 +0530454 "deviceId": agent.deviceID,
khenaidoo0458db62019-06-20 08:50:36 -0400455 "flowsToDel": len(flowsToDel),
456 "flowsToKeep": len(flowsToKeep),
457 "groupsToDel": len(groupsToDel),
458 "groupsToKeep": len(groupsToKeep),
459 })
460
461 // Sanity check
462 if (len(flowsToKeep) | len(flowsToDel) | len(groupsToKeep) | len(groupsToDel)) == 0 {
npujar1d86a522019-11-14 17:11:16 +0530463 log.Debugw("nothing-to-update", log.Fields{"deviceId": agent.deviceID, "flowsToDel": flowsToDel, "groupsToDel": groupsToDel})
A R Karthick5c28f552019-12-11 22:47:44 -0800464 return coreutils.DoneResponse(), nil
khenaidoo0458db62019-06-20 08:50:36 -0400465 }
466
467 // Send update to adapters
Kent Hagerman8da2f1e2019-11-25 17:28:09 -0500468 response := coreutils.NewResponse()
khenaidoo0458db62019-06-20 08:50:36 -0400469 dType := agent.adapterMgr.getDeviceType(device.Type)
khenaidooe7be1332020-01-24 18:58:33 -0500470 if dType == nil {
471 log.Errorw("non-existent device type", log.Fields{"deviceType": device.Type})
472 return coreutils.DoneResponse(), status.Errorf(codes.FailedPrecondition, "non-existent device type %s", device.Type)
473 }
khenaidoo0458db62019-06-20 08:50:36 -0400474 if !dType.AcceptsAddRemoveFlowUpdates {
475 if len(groupsToKeep) != 0 && reflect.DeepEqual(existingGroups.Items, groupsToKeep) && len(flowsToKeep) != 0 && reflect.DeepEqual(existingFlows.Items, flowsToKeep) {
npujar1d86a522019-11-14 17:11:16 +0530476 log.Debugw("nothing-to-update", log.Fields{"deviceId": agent.deviceID, "flowsToDel": flowsToDel, "groupsToDel": groupsToDel})
A R Karthick5c28f552019-12-11 22:47:44 -0800477 return coreutils.DoneResponse(), nil
khenaidoo0458db62019-06-20 08:50:36 -0400478 }
npujar467fe752020-01-16 20:17:45 +0530479 go agent.sendBulkFlowsToAdapters(ctx, device, &voltha.Flows{Items: flowsToKeep}, &voltha.FlowGroups{Items: groupsToKeep}, flowMetadata, response)
khenaidoo0458db62019-06-20 08:50:36 -0400480 } else {
481 flowChanges := &ofp.FlowChanges{
482 ToAdd: &voltha.Flows{Items: []*ofp.OfpFlowStats{}},
483 ToRemove: &voltha.Flows{Items: flowsToDel},
484 }
485 groupChanges := &ofp.FlowGroupChanges{
486 ToAdd: &voltha.FlowGroups{Items: []*ofp.OfpGroupEntry{}},
487 ToRemove: &voltha.FlowGroups{Items: groupsToDel},
488 ToUpdate: &voltha.FlowGroups{Items: []*ofp.OfpGroupEntry{}},
489 }
npujar467fe752020-01-16 20:17:45 +0530490 go agent.sendIncrementalFlowsToAdapters(ctx, device, flowChanges, groupChanges, flowMetadata, response)
khenaidoo0458db62019-06-20 08:50:36 -0400491 }
492
493 // store the changed data
494 device.Flows = &voltha.Flows{Items: flowsToKeep}
495 device.FlowGroups = &voltha.FlowGroups{Items: groupsToKeep}
npujar467fe752020-01-16 20:17:45 +0530496 if err := agent.updateDeviceWithoutLock(ctx, device); err != nil {
A R Karthick5c28f552019-12-11 22:47:44 -0800497 return coreutils.DoneResponse(), status.Errorf(codes.Internal, "failure-updating-%s", agent.deviceID)
Kent Hagerman3c513972019-11-25 13:49:41 -0500498 }
khenaidoo0458db62019-06-20 08:50:36 -0400499
A R Karthick5c28f552019-12-11 22:47:44 -0800500 return response, nil
501
502}
503
504//deleteFlowsAndGroups removes the "flowsToDel" and "groupsToDel" from the existing flows/groups and sends the update to the
505//adapters
npujar467fe752020-01-16 20:17:45 +0530506func (agent *DeviceAgent) deleteFlowsAndGroups(ctx context.Context, flowsToDel []*ofp.OfpFlowStats, groupsToDel []*ofp.OfpGroupEntry, flowMetadata *voltha.FlowMetadata) error {
507 response, err := agent.deleteFlowsAndGroupsFromAdapter(ctx, flowsToDel, groupsToDel, flowMetadata)
A R Karthick5c28f552019-12-11 22:47:44 -0800508 if err != nil {
509 return err
510 }
Kent Hagerman8da2f1e2019-11-25 17:28:09 -0500511 if res := coreutils.WaitForNilOrErrorResponses(agent.defaultTimeout, response); res != nil {
khenaidoo0458db62019-06-20 08:50:36 -0400512 return status.Errorf(codes.Aborted, "errors-%s", res)
513 }
514 return nil
khenaidoo0458db62019-06-20 08:50:36 -0400515}
516
npujar467fe752020-01-16 20:17:45 +0530517func (agent *DeviceAgent) updateFlowsAndGroupsToAdapter(ctx context.Context, updatedFlows []*ofp.OfpFlowStats, updatedGroups []*ofp.OfpGroupEntry, flowMetadata *voltha.FlowMetadata) (coreutils.Response, error) {
npujar1d86a522019-11-14 17:11:16 +0530518 log.Debugw("updateFlowsAndGroups", log.Fields{"deviceId": agent.deviceID, "flows": updatedFlows, "groups": updatedGroups})
khenaidoo0458db62019-06-20 08:50:36 -0400519
520 if (len(updatedFlows) | len(updatedGroups)) == 0 {
npujar1d86a522019-11-14 17:11:16 +0530521 log.Debugw("nothing-to-update", log.Fields{"deviceId": agent.deviceID, "flows": updatedFlows, "groups": updatedGroups})
A R Karthick5c28f552019-12-11 22:47:44 -0800522 return coreutils.DoneResponse(), nil
khenaidoo0458db62019-06-20 08:50:36 -0400523 }
524
525 agent.lockDevice.Lock()
526 defer agent.lockDevice.Unlock()
khenaidoo6e55d9e2019-12-12 18:26:26 -0500527
528 device := agent.getDeviceWithoutLock()
529
khenaidoo0458db62019-06-20 08:50:36 -0400530 existingFlows := proto.Clone(device.Flows).(*voltha.Flows)
531 existingGroups := proto.Clone(device.FlowGroups).(*ofp.FlowGroups)
532
533 if len(updatedGroups) != 0 && reflect.DeepEqual(existingGroups.Items, updatedGroups) && len(updatedFlows) != 0 && reflect.DeepEqual(existingFlows.Items, updatedFlows) {
npujar1d86a522019-11-14 17:11:16 +0530534 log.Debugw("nothing-to-update", log.Fields{"deviceId": agent.deviceID, "flows": updatedFlows, "groups": updatedGroups})
A R Karthick5c28f552019-12-11 22:47:44 -0800535 return coreutils.DoneResponse(), nil
khenaidoo0458db62019-06-20 08:50:36 -0400536 }
537
538 log.Debugw("updating-flows-and-groups",
539 log.Fields{
npujar1d86a522019-11-14 17:11:16 +0530540 "deviceId": agent.deviceID,
khenaidoo0458db62019-06-20 08:50:36 -0400541 "updatedFlows": updatedFlows,
542 "updatedGroups": updatedGroups,
543 })
544
Kent Hagerman8da2f1e2019-11-25 17:28:09 -0500545 response := coreutils.NewResponse()
khenaidoo0458db62019-06-20 08:50:36 -0400546 dType := agent.adapterMgr.getDeviceType(device.Type)
khenaidooe7be1332020-01-24 18:58:33 -0500547 if dType == nil {
548 log.Errorw("non-existent device type", log.Fields{"deviceType": device.Type})
549 return coreutils.DoneResponse(), status.Errorf(codes.FailedPrecondition, "non-existent device type %s", device.Type)
550 }
khenaidoo0458db62019-06-20 08:50:36 -0400551
552 // Process bulk flow update differently than incremental update
553 if !dType.AcceptsAddRemoveFlowUpdates {
npujar467fe752020-01-16 20:17:45 +0530554 go agent.sendBulkFlowsToAdapters(ctx, device, &voltha.Flows{Items: updatedFlows}, &voltha.FlowGroups{Items: updatedGroups}, nil, response)
khenaidoo0458db62019-06-20 08:50:36 -0400555 } else {
556 var flowsToAdd []*ofp.OfpFlowStats
khenaidoo2c6a0992019-04-29 13:46:56 -0400557 var flowsToDelete []*ofp.OfpFlowStats
khenaidoo0458db62019-06-20 08:50:36 -0400558 var groupsToAdd []*ofp.OfpGroupEntry
khenaidoo2c6a0992019-04-29 13:46:56 -0400559 var groupsToDelete []*ofp.OfpGroupEntry
khenaidoo2c6a0992019-04-29 13:46:56 -0400560
561 // Process flows
khenaidoo0458db62019-06-20 08:50:36 -0400562 for _, flow := range updatedFlows {
563 if idx := fu.FindFlows(existingFlows.Items, flow); idx == -1 {
564 flowsToAdd = append(flowsToAdd, flow)
565 }
khenaidoo2c6a0992019-04-29 13:46:56 -0400566 }
khenaidoo2c6a0992019-04-29 13:46:56 -0400567 for _, flow := range existingFlows.Items {
khenaidoo0458db62019-06-20 08:50:36 -0400568 if idx := fu.FindFlows(updatedFlows, flow); idx != -1 {
khenaidoo2c6a0992019-04-29 13:46:56 -0400569 flowsToDelete = append(flowsToDelete, flow)
570 }
571 }
572
573 // Process groups
khenaidoo0458db62019-06-20 08:50:36 -0400574 for _, g := range updatedGroups {
575 if fu.FindGroup(existingGroups.Items, g.Desc.GroupId) == -1 { // does not exist now
576 groupsToAdd = append(groupsToAdd, g)
577 }
khenaidoo2c6a0992019-04-29 13:46:56 -0400578 }
khenaidoo2c6a0992019-04-29 13:46:56 -0400579 for _, group := range existingGroups.Items {
khenaidoo0458db62019-06-20 08:50:36 -0400580 if fu.FindGroup(updatedGroups, group.Desc.GroupId) != -1 { // does not exist now
khenaidoo2c6a0992019-04-29 13:46:56 -0400581 groupsToDelete = append(groupsToDelete, group)
582 }
583 }
584
khenaidoo0458db62019-06-20 08:50:36 -0400585 log.Debugw("updating-flows-and-groups",
586 log.Fields{
npujar1d86a522019-11-14 17:11:16 +0530587 "deviceId": agent.deviceID,
khenaidoo0458db62019-06-20 08:50:36 -0400588 "flowsToAdd": flowsToAdd,
589 "flowsToDelete": flowsToDelete,
590 "groupsToAdd": groupsToAdd,
591 "groupsToDelete": groupsToDelete,
592 })
593
khenaidoo2c6a0992019-04-29 13:46:56 -0400594 // Sanity check
khenaidoo0458db62019-06-20 08:50:36 -0400595 if (len(flowsToAdd) | len(flowsToDelete) | len(groupsToAdd) | len(groupsToDelete) | len(updatedGroups)) == 0 {
npujar1d86a522019-11-14 17:11:16 +0530596 log.Debugw("nothing-to-update", log.Fields{"deviceId": agent.deviceID, "flows": updatedFlows, "groups": updatedGroups})
A R Karthick5c28f552019-12-11 22:47:44 -0800597 return coreutils.DoneResponse(), nil
khenaidoo2c6a0992019-04-29 13:46:56 -0400598 }
599
khenaidoo0458db62019-06-20 08:50:36 -0400600 flowChanges := &ofp.FlowChanges{
601 ToAdd: &voltha.Flows{Items: flowsToAdd},
602 ToRemove: &voltha.Flows{Items: flowsToDelete},
khenaidoo19d7b632018-10-30 10:49:50 -0400603 }
khenaidoo0458db62019-06-20 08:50:36 -0400604 groupChanges := &ofp.FlowGroupChanges{
605 ToAdd: &voltha.FlowGroups{Items: groupsToAdd},
606 ToRemove: &voltha.FlowGroups{Items: groupsToDelete},
607 ToUpdate: &voltha.FlowGroups{Items: updatedGroups},
608 }
npujar467fe752020-01-16 20:17:45 +0530609 go agent.sendIncrementalFlowsToAdapters(ctx, device, flowChanges, groupChanges, flowMetadata, response)
khenaidoo19d7b632018-10-30 10:49:50 -0400610 }
khenaidoo0458db62019-06-20 08:50:36 -0400611
612 // store the updated data
613 device.Flows = &voltha.Flows{Items: updatedFlows}
614 device.FlowGroups = &voltha.FlowGroups{Items: updatedGroups}
npujar467fe752020-01-16 20:17:45 +0530615 if err := agent.updateDeviceWithoutLock(ctx, device); err != nil {
A R Karthick5c28f552019-12-11 22:47:44 -0800616 return coreutils.DoneResponse(), status.Errorf(codes.Internal, "failure-updating-%s", agent.deviceID)
Kent Hagerman3c513972019-11-25 13:49:41 -0500617 }
khenaidoo0458db62019-06-20 08:50:36 -0400618
A R Karthick5c28f552019-12-11 22:47:44 -0800619 return response, nil
620}
621
622//updateFlowsAndGroups replaces the existing flows and groups with "updatedFlows" and "updatedGroups" respectively. It
623//also sends the updates to the adapters
npujar467fe752020-01-16 20:17:45 +0530624func (agent *DeviceAgent) updateFlowsAndGroups(ctx context.Context, updatedFlows []*ofp.OfpFlowStats, updatedGroups []*ofp.OfpGroupEntry, flowMetadata *voltha.FlowMetadata) error {
625 response, err := agent.updateFlowsAndGroupsToAdapter(ctx, updatedFlows, updatedGroups, flowMetadata)
A R Karthick5c28f552019-12-11 22:47:44 -0800626 if err != nil {
627 return err
628 }
Kent Hagerman8da2f1e2019-11-25 17:28:09 -0500629 if res := coreutils.WaitForNilOrErrorResponses(agent.defaultTimeout, response); res != nil {
khenaidoo0458db62019-06-20 08:50:36 -0400630 return status.Errorf(codes.Aborted, "errors-%s", res)
631 }
632 return nil
khenaidoo19d7b632018-10-30 10:49:50 -0400633}
634
khenaidoo4d4802d2018-10-04 21:59:49 -0400635//disableDevice disable a device
khenaidoo92e62c52018-10-03 14:02:54 -0400636func (agent *DeviceAgent) disableDevice(ctx context.Context) error {
khenaidoo59ef7be2019-06-21 12:40:28 -0400637 agent.lockDevice.Lock()
638 defer agent.lockDevice.Unlock()
npujar1d86a522019-11-14 17:11:16 +0530639 log.Debugw("disableDevice", log.Fields{"id": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500640
641 cloned := agent.getDeviceWithoutLock()
642
643 if cloned.AdminState == voltha.AdminState_DISABLED {
npujar1d86a522019-11-14 17:11:16 +0530644 log.Debugw("device-already-disabled", log.Fields{"id": agent.deviceID})
645 return nil
646 }
khenaidoo6e55d9e2019-12-12 18:26:26 -0500647 if cloned.AdminState == voltha.AdminState_PREPROVISIONED ||
648 cloned.AdminState == voltha.AdminState_DELETED {
npujar1d86a522019-11-14 17:11:16 +0530649 log.Debugw("device-not-enabled", log.Fields{"id": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500650 return status.Errorf(codes.FailedPrecondition, "deviceId:%s, invalid-admin-state:%s", agent.deviceID, cloned.AdminState)
npujar1d86a522019-11-14 17:11:16 +0530651 }
khenaidoo4554f7c2019-05-29 22:13:15 -0400652
npujar1d86a522019-11-14 17:11:16 +0530653 // Update the Admin State and operational state before sending the request out
npujar1d86a522019-11-14 17:11:16 +0530654 cloned.AdminState = voltha.AdminState_DISABLED
655 cloned.OperStatus = voltha.OperStatus_UNKNOWN
npujar467fe752020-01-16 20:17:45 +0530656 if err := agent.updateDeviceInStoreWithoutLock(ctx, cloned, false, ""); err != nil {
npujar1d86a522019-11-14 17:11:16 +0530657 return err
658 }
khenaidoo6e55d9e2019-12-12 18:26:26 -0500659 if err := agent.adapterProxy.DisableDevice(ctx, proto.Clone(cloned).(*voltha.Device)); err != nil {
npujar1d86a522019-11-14 17:11:16 +0530660 log.Debugw("disableDevice-error", log.Fields{"id": agent.deviceID, "error": err})
661 return err
khenaidoo0a822f92019-05-08 15:15:57 -0400662 }
663 return nil
664}
665
npujar467fe752020-01-16 20:17:45 +0530666func (agent *DeviceAgent) updateAdminState(ctx context.Context, adminState voltha.AdminState_Types) error {
khenaidoo0a822f92019-05-08 15:15:57 -0400667 agent.lockDevice.Lock()
668 defer agent.lockDevice.Unlock()
npujar1d86a522019-11-14 17:11:16 +0530669 log.Debugw("updateAdminState", log.Fields{"id": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500670
671 cloned := agent.getDeviceWithoutLock()
672
673 if cloned.AdminState == adminState {
npujar1d86a522019-11-14 17:11:16 +0530674 log.Debugw("no-change-needed", log.Fields{"id": agent.deviceID, "state": adminState})
675 return nil
676 }
677 // Received an Ack (no error found above). Now update the device in the model to the expected state
npujar1d86a522019-11-14 17:11:16 +0530678 cloned.AdminState = adminState
npujar467fe752020-01-16 20:17:45 +0530679 if err := agent.updateDeviceInStoreWithoutLock(ctx, cloned, false, ""); err != nil {
npujar1d86a522019-11-14 17:11:16 +0530680 return err
khenaidoo92e62c52018-10-03 14:02:54 -0400681 }
682 return nil
683}
684
khenaidoo4d4802d2018-10-04 21:59:49 -0400685func (agent *DeviceAgent) rebootDevice(ctx context.Context) error {
686 agent.lockDevice.Lock()
687 defer agent.lockDevice.Unlock()
npujar1d86a522019-11-14 17:11:16 +0530688 log.Debugw("rebootDevice", log.Fields{"id": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500689
690 device := agent.getDeviceWithoutLock()
npujar1d86a522019-11-14 17:11:16 +0530691 if err := agent.adapterProxy.RebootDevice(ctx, device); err != nil {
692 log.Debugw("rebootDevice-error", log.Fields{"id": agent.deviceID, "error": err})
693 return err
khenaidoo4d4802d2018-10-04 21:59:49 -0400694 }
695 return nil
696}
697
698func (agent *DeviceAgent) deleteDevice(ctx context.Context) error {
699 agent.lockDevice.Lock()
khenaidoo0a822f92019-05-08 15:15:57 -0400700 defer agent.lockDevice.Unlock()
npujar1d86a522019-11-14 17:11:16 +0530701 log.Debugw("deleteDevice", log.Fields{"id": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500702
703 cloned := agent.getDeviceWithoutLock()
704 if cloned.AdminState == voltha.AdminState_DELETED {
npujar1d86a522019-11-14 17:11:16 +0530705 log.Debugw("device-already-in-deleted-state", log.Fields{"id": agent.deviceID})
706 return nil
707 }
khenaidoo6e55d9e2019-12-12 18:26:26 -0500708 if (cloned.AdminState != voltha.AdminState_DISABLED) &&
709 (cloned.AdminState != voltha.AdminState_PREPROVISIONED) {
npujar1d86a522019-11-14 17:11:16 +0530710 log.Debugw("device-not-disabled", log.Fields{"id": agent.deviceID})
711 //TODO: Needs customized error message
712 return status.Errorf(codes.FailedPrecondition, "deviceId:%s, expected-admin-state:%s", agent.deviceID, voltha.AdminState_DISABLED)
713 }
khenaidoo6e55d9e2019-12-12 18:26:26 -0500714 if cloned.AdminState != voltha.AdminState_PREPROVISIONED {
npujar1d86a522019-11-14 17:11:16 +0530715 // Send the request to an Adapter only if the device is not in poreporovision state and wait for a response
khenaidoo6e55d9e2019-12-12 18:26:26 -0500716 if err := agent.adapterProxy.DeleteDevice(ctx, cloned); err != nil {
npujar1d86a522019-11-14 17:11:16 +0530717 log.Debugw("deleteDevice-error", log.Fields{"id": agent.deviceID, "error": err})
Mahir Gunyelb5851672019-07-24 10:46:26 +0300718 return err
khenaidoo4d4802d2018-10-04 21:59:49 -0400719 }
npujar1d86a522019-11-14 17:11:16 +0530720 }
721 // Set the state to deleted after we receive an Ack - this will trigger some background process to clean up
722 // the device as well as its association with the logical device
npujar1d86a522019-11-14 17:11:16 +0530723 cloned.AdminState = voltha.AdminState_DELETED
npujar467fe752020-01-16 20:17:45 +0530724 if err := agent.updateDeviceInStoreWithoutLock(ctx, cloned, false, ""); err != nil {
npujar1d86a522019-11-14 17:11:16 +0530725 return err
726 }
727 // If this is a child device then remove the associated peer ports on the parent device
khenaidoo6e55d9e2019-12-12 18:26:26 -0500728 if !cloned.Root {
npujar1d86a522019-11-14 17:11:16 +0530729 go func() {
npujar467fe752020-01-16 20:17:45 +0530730 // since the caller does not wait for this for complete, use background context
731 err := agent.deviceMgr.deletePeerPorts(context.Background(), cloned.ParentId, cloned.Id)
npujar1d86a522019-11-14 17:11:16 +0530732 if err != nil {
733 log.Errorw("unable-to-delete-peer-ports", log.Fields{"error": err})
734 }
735 }()
khenaidoo4d4802d2018-10-04 21:59:49 -0400736 }
737 return nil
738}
739
npujar467fe752020-01-16 20:17:45 +0530740func (agent *DeviceAgent) setParentID(ctx context.Context, device *voltha.Device, parentID string) error {
khenaidooad06fd72019-10-28 12:26:05 -0400741 agent.lockDevice.Lock()
742 defer agent.lockDevice.Unlock()
npujar1d86a522019-11-14 17:11:16 +0530743 log.Debugw("setParentId", log.Fields{"deviceId": device.Id, "parentId": parentID})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500744
745 cloned := agent.getDeviceWithoutLock()
npujar1d86a522019-11-14 17:11:16 +0530746 cloned.ParentId = parentID
747 // Store the device
npujar467fe752020-01-16 20:17:45 +0530748 if err := agent.updateDeviceInStoreWithoutLock(ctx, cloned, false, ""); err != nil {
npujar1d86a522019-11-14 17:11:16 +0530749 return err
750 }
751 return nil
khenaidooad06fd72019-10-28 12:26:05 -0400752}
753
khenaidoob3127472019-07-24 21:04:55 -0400754func (agent *DeviceAgent) updatePmConfigs(ctx context.Context, pmConfigs *voltha.PmConfigs) error {
755 agent.lockDevice.Lock()
756 defer agent.lockDevice.Unlock()
757 log.Debugw("updatePmConfigs", log.Fields{"id": pmConfigs.Id})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500758
759 cloned := agent.getDeviceWithoutLock()
npujar1d86a522019-11-14 17:11:16 +0530760 cloned.PmConfigs = proto.Clone(pmConfigs).(*voltha.PmConfigs)
761 // Store the device
npujar467fe752020-01-16 20:17:45 +0530762 if err := agent.updateDeviceInStoreWithoutLock(ctx, cloned, false, ""); err != nil {
npujar1d86a522019-11-14 17:11:16 +0530763 return err
764 }
765 // Send the request to the adapter
766 if err := agent.adapterProxy.UpdatePmConfigs(ctx, cloned, pmConfigs); err != nil {
767 log.Errorw("update-pm-configs-error", log.Fields{"id": agent.deviceID, "error": err})
768 return err
769 }
770 return nil
khenaidoob3127472019-07-24 21:04:55 -0400771}
772
npujar467fe752020-01-16 20:17:45 +0530773func (agent *DeviceAgent) initPmConfigs(ctx context.Context, pmConfigs *voltha.PmConfigs) error {
khenaidoob3127472019-07-24 21:04:55 -0400774 agent.lockDevice.Lock()
775 defer agent.lockDevice.Unlock()
776 log.Debugw("initPmConfigs", log.Fields{"id": pmConfigs.Id})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500777
778 cloned := agent.getDeviceWithoutLock()
npujar1d86a522019-11-14 17:11:16 +0530779 cloned.PmConfigs = proto.Clone(pmConfigs).(*voltha.PmConfigs)
780 // Store the device
npujar467fe752020-01-16 20:17:45 +0530781 updateCtx := context.WithValue(ctx, model.RequestTimestamp, time.Now().UnixNano())
Thomas Lee Se5a44012019-11-07 20:32:24 +0530782 afterUpdate, err := agent.clusterDataProxy.Update(updateCtx, "/devices/"+agent.deviceID, cloned, false, "")
783 if err != nil {
784 return status.Errorf(codes.Internal, "%s", agent.deviceID)
785 }
npujar1d86a522019-11-14 17:11:16 +0530786 if afterUpdate == nil {
787 return status.Errorf(codes.Internal, "%s", agent.deviceID)
788 }
789 return nil
khenaidoob3127472019-07-24 21:04:55 -0400790}
791
792func (agent *DeviceAgent) listPmConfigs(ctx context.Context) (*voltha.PmConfigs, error) {
793 agent.lockDevice.RLock()
794 defer agent.lockDevice.RUnlock()
npujar1d86a522019-11-14 17:11:16 +0530795 log.Debugw("listPmConfigs", log.Fields{"id": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500796
797 return agent.getDeviceWithoutLock().PmConfigs, nil
khenaidoob3127472019-07-24 21:04:55 -0400798}
799
khenaidoof5a5bfa2019-01-23 22:20:29 -0500800func (agent *DeviceAgent) downloadImage(ctx context.Context, img *voltha.ImageDownload) (*voltha.OperationResp, error) {
801 agent.lockDevice.Lock()
802 defer agent.lockDevice.Unlock()
npujar1d86a522019-11-14 17:11:16 +0530803 log.Debugw("downloadImage", log.Fields{"id": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500804
805 device := agent.getDeviceWithoutLock()
806
npujar1d86a522019-11-14 17:11:16 +0530807 if device.AdminState != voltha.AdminState_ENABLED {
808 log.Debugw("device-not-enabled", log.Fields{"id": agent.deviceID})
809 return nil, status.Errorf(codes.FailedPrecondition, "deviceId:%s, expected-admin-state:%s", agent.deviceID, voltha.AdminState_ENABLED)
810 }
811 // Save the image
812 clonedImg := proto.Clone(img).(*voltha.ImageDownload)
813 clonedImg.DownloadState = voltha.ImageDownload_DOWNLOAD_REQUESTED
814 cloned := proto.Clone(device).(*voltha.Device)
815 if cloned.ImageDownloads == nil {
816 cloned.ImageDownloads = []*voltha.ImageDownload{clonedImg}
khenaidoof5a5bfa2019-01-23 22:20:29 -0500817 } else {
818 if device.AdminState != voltha.AdminState_ENABLED {
npujar1d86a522019-11-14 17:11:16 +0530819 log.Debugw("device-not-enabled", log.Fields{"id": agent.deviceID})
820 return nil, status.Errorf(codes.FailedPrecondition, "deviceId:%s, expected-admin-state:%s", agent.deviceID, voltha.AdminState_ENABLED)
khenaidoof5a5bfa2019-01-23 22:20:29 -0500821 }
822 // Save the image
823 clonedImg := proto.Clone(img).(*voltha.ImageDownload)
Stephane Barbariedf5479f2019-01-29 22:13:00 -0500824 clonedImg.DownloadState = voltha.ImageDownload_DOWNLOAD_REQUESTED
khenaidoof5a5bfa2019-01-23 22:20:29 -0500825 cloned := proto.Clone(device).(*voltha.Device)
826 if cloned.ImageDownloads == nil {
827 cloned.ImageDownloads = []*voltha.ImageDownload{clonedImg}
828 } else {
829 cloned.ImageDownloads = append(cloned.ImageDownloads, clonedImg)
830 }
831 cloned.AdminState = voltha.AdminState_DOWNLOADING_IMAGE
npujar467fe752020-01-16 20:17:45 +0530832 if err := agent.updateDeviceInStoreWithoutLock(ctx, cloned, false, ""); err != nil {
Mahir Gunyelb5851672019-07-24 10:46:26 +0300833 return nil, err
khenaidoof5a5bfa2019-01-23 22:20:29 -0500834 }
835 // Send the request to the adapter
836 if err := agent.adapterProxy.DownloadImage(ctx, cloned, clonedImg); err != nil {
npujar1d86a522019-11-14 17:11:16 +0530837 log.Debugw("downloadImage-error", log.Fields{"id": agent.deviceID, "error": err, "image": img.Name})
khenaidoof5a5bfa2019-01-23 22:20:29 -0500838 return nil, err
839 }
840 }
841 return &voltha.OperationResp{Code: voltha.OperationResp_OPERATION_SUCCESS}, nil
842}
843
844// isImageRegistered is a helper method to figure out if an image is already registered
845func isImageRegistered(img *voltha.ImageDownload, device *voltha.Device) bool {
846 for _, image := range device.ImageDownloads {
847 if image.Id == img.Id && image.Name == img.Name {
848 return true
849 }
850 }
851 return false
852}
853
854func (agent *DeviceAgent) cancelImageDownload(ctx context.Context, img *voltha.ImageDownload) (*voltha.OperationResp, error) {
855 agent.lockDevice.Lock()
856 defer agent.lockDevice.Unlock()
npujar1d86a522019-11-14 17:11:16 +0530857 log.Debugw("cancelImageDownload", log.Fields{"id": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500858
859 device := agent.getDeviceWithoutLock()
860
npujar1d86a522019-11-14 17:11:16 +0530861 // Verify whether the Image is in the list of image being downloaded
862 if !isImageRegistered(img, device) {
863 return nil, status.Errorf(codes.FailedPrecondition, "deviceId:%s, image-not-registered:%s", agent.deviceID, img.Name)
864 }
khenaidoof5a5bfa2019-01-23 22:20:29 -0500865
npujar1d86a522019-11-14 17:11:16 +0530866 // Update image download state
867 cloned := proto.Clone(device).(*voltha.Device)
868 for _, image := range cloned.ImageDownloads {
869 if image.Id == img.Id && image.Name == img.Name {
870 image.DownloadState = voltha.ImageDownload_DOWNLOAD_CANCELLED
khenaidoof5a5bfa2019-01-23 22:20:29 -0500871 }
npujar1d86a522019-11-14 17:11:16 +0530872 }
khenaidoof5a5bfa2019-01-23 22:20:29 -0500873
npujar1d86a522019-11-14 17:11:16 +0530874 if device.AdminState == voltha.AdminState_DOWNLOADING_IMAGE {
875 // Set the device to Enabled
876 cloned.AdminState = voltha.AdminState_ENABLED
npujar467fe752020-01-16 20:17:45 +0530877 if err := agent.updateDeviceInStoreWithoutLock(ctx, cloned, false, ""); err != nil {
npujar1d86a522019-11-14 17:11:16 +0530878 return nil, err
879 }
880 // Send the request to the adapter
881 if err := agent.adapterProxy.CancelImageDownload(ctx, device, img); err != nil {
882 log.Debugw("cancelImageDownload-error", log.Fields{"id": agent.deviceID, "error": err, "image": img.Name})
883 return nil, err
khenaidoof5a5bfa2019-01-23 22:20:29 -0500884 }
885 }
886 return &voltha.OperationResp{Code: voltha.OperationResp_OPERATION_SUCCESS}, nil
serkant.uluderya334479d2019-04-10 08:26:15 -0700887}
khenaidoof5a5bfa2019-01-23 22:20:29 -0500888
889func (agent *DeviceAgent) activateImage(ctx context.Context, img *voltha.ImageDownload) (*voltha.OperationResp, error) {
890 agent.lockDevice.Lock()
891 defer agent.lockDevice.Unlock()
npujar1d86a522019-11-14 17:11:16 +0530892 log.Debugw("activateImage", log.Fields{"id": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500893 cloned := agent.getDeviceWithoutLock()
894
npujar1d86a522019-11-14 17:11:16 +0530895 // Verify whether the Image is in the list of image being downloaded
khenaidoo6e55d9e2019-12-12 18:26:26 -0500896 if !isImageRegistered(img, cloned) {
npujar1d86a522019-11-14 17:11:16 +0530897 return nil, status.Errorf(codes.FailedPrecondition, "deviceId:%s, image-not-registered:%s", agent.deviceID, img.Name)
898 }
899
khenaidoo6e55d9e2019-12-12 18:26:26 -0500900 if cloned.AdminState == voltha.AdminState_DOWNLOADING_IMAGE {
npujar1d86a522019-11-14 17:11:16 +0530901 return nil, status.Errorf(codes.FailedPrecondition, "deviceId:%s, device-in-downloading-state:%s", agent.deviceID, img.Name)
902 }
903 // Update image download state
npujar1d86a522019-11-14 17:11:16 +0530904 for _, image := range cloned.ImageDownloads {
905 if image.Id == img.Id && image.Name == img.Name {
906 image.ImageState = voltha.ImageDownload_IMAGE_ACTIVATING
907 }
908 }
909 // Set the device to downloading_image
910 cloned.AdminState = voltha.AdminState_DOWNLOADING_IMAGE
npujar467fe752020-01-16 20:17:45 +0530911 if err := agent.updateDeviceInStoreWithoutLock(ctx, cloned, false, ""); err != nil {
npujar1d86a522019-11-14 17:11:16 +0530912 return nil, err
913 }
914
khenaidoo6e55d9e2019-12-12 18:26:26 -0500915 if err := agent.adapterProxy.ActivateImageUpdate(ctx, proto.Clone(cloned).(*voltha.Device), img); err != nil {
npujar1d86a522019-11-14 17:11:16 +0530916 log.Debugw("activateImage-error", log.Fields{"id": agent.deviceID, "error": err, "image": img.Name})
917 return nil, err
918 }
919 // The status of the AdminState will be changed following the update_download_status response from the adapter
920 // The image name will also be removed from the device list
serkant.uluderya334479d2019-04-10 08:26:15 -0700921 return &voltha.OperationResp{Code: voltha.OperationResp_OPERATION_SUCCESS}, nil
922}
khenaidoof5a5bfa2019-01-23 22:20:29 -0500923
924func (agent *DeviceAgent) revertImage(ctx context.Context, img *voltha.ImageDownload) (*voltha.OperationResp, error) {
925 agent.lockDevice.Lock()
926 defer agent.lockDevice.Unlock()
npujar1d86a522019-11-14 17:11:16 +0530927 log.Debugw("revertImage", log.Fields{"id": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500928
929 cloned := agent.getDeviceWithoutLock()
930
npujar1d86a522019-11-14 17:11:16 +0530931 // Verify whether the Image is in the list of image being downloaded
khenaidoo6e55d9e2019-12-12 18:26:26 -0500932 if !isImageRegistered(img, cloned) {
npujar1d86a522019-11-14 17:11:16 +0530933 return nil, status.Errorf(codes.FailedPrecondition, "deviceId:%s, image-not-registered:%s", agent.deviceID, img.Name)
934 }
khenaidoof5a5bfa2019-01-23 22:20:29 -0500935
khenaidoo6e55d9e2019-12-12 18:26:26 -0500936 if cloned.AdminState != voltha.AdminState_ENABLED {
npujar1d86a522019-11-14 17:11:16 +0530937 return nil, status.Errorf(codes.FailedPrecondition, "deviceId:%s, device-not-enabled-state:%s", agent.deviceID, img.Name)
938 }
939 // Update image download state
npujar1d86a522019-11-14 17:11:16 +0530940 for _, image := range cloned.ImageDownloads {
941 if image.Id == img.Id && image.Name == img.Name {
942 image.ImageState = voltha.ImageDownload_IMAGE_REVERTING
khenaidoof5a5bfa2019-01-23 22:20:29 -0500943 }
npujar1d86a522019-11-14 17:11:16 +0530944 }
Mahir Gunyelb5851672019-07-24 10:46:26 +0300945
npujar467fe752020-01-16 20:17:45 +0530946 if err := agent.updateDeviceInStoreWithoutLock(ctx, cloned, false, ""); err != nil {
npujar1d86a522019-11-14 17:11:16 +0530947 return nil, err
948 }
khenaidoof5a5bfa2019-01-23 22:20:29 -0500949
khenaidoo6e55d9e2019-12-12 18:26:26 -0500950 if err := agent.adapterProxy.RevertImageUpdate(ctx, proto.Clone(cloned).(*voltha.Device), img); err != nil {
npujar1d86a522019-11-14 17:11:16 +0530951 log.Debugw("revertImage-error", log.Fields{"id": agent.deviceID, "error": err, "image": img.Name})
952 return nil, err
khenaidoof5a5bfa2019-01-23 22:20:29 -0500953 }
954 return &voltha.OperationResp{Code: voltha.OperationResp_OPERATION_SUCCESS}, nil
serkant.uluderya334479d2019-04-10 08:26:15 -0700955}
khenaidoof5a5bfa2019-01-23 22:20:29 -0500956
957func (agent *DeviceAgent) getImageDownloadStatus(ctx context.Context, img *voltha.ImageDownload) (*voltha.ImageDownload, error) {
958 agent.lockDevice.Lock()
959 defer agent.lockDevice.Unlock()
npujar1d86a522019-11-14 17:11:16 +0530960 log.Debugw("getImageDownloadStatus", log.Fields{"id": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500961
962 cloned := agent.getDeviceWithoutLock()
963 resp, err := agent.adapterProxy.GetImageDownloadStatus(ctx, cloned, img)
npujar1d86a522019-11-14 17:11:16 +0530964 if err != nil {
965 log.Debugw("getImageDownloadStatus-error", log.Fields{"id": agent.deviceID, "error": err, "image": img.Name})
966 return nil, err
967 }
968 return resp, nil
khenaidoof5a5bfa2019-01-23 22:20:29 -0500969}
970
npujar467fe752020-01-16 20:17:45 +0530971func (agent *DeviceAgent) updateImageDownload(ctx context.Context, img *voltha.ImageDownload) error {
khenaidoof5a5bfa2019-01-23 22:20:29 -0500972 agent.lockDevice.Lock()
973 defer agent.lockDevice.Unlock()
npujar1d86a522019-11-14 17:11:16 +0530974 log.Debugw("updateImageDownload", log.Fields{"id": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500975
976 cloned := agent.getDeviceWithoutLock()
977
npujar1d86a522019-11-14 17:11:16 +0530978 // Update the image as well as remove it if the download was cancelled
npujar1d86a522019-11-14 17:11:16 +0530979 clonedImages := make([]*voltha.ImageDownload, len(cloned.ImageDownloads))
980 for _, image := range cloned.ImageDownloads {
981 if image.Id == img.Id && image.Name == img.Name {
982 if image.DownloadState != voltha.ImageDownload_DOWNLOAD_CANCELLED {
983 clonedImages = append(clonedImages, img)
khenaidoof5a5bfa2019-01-23 22:20:29 -0500984 }
985 }
npujar1d86a522019-11-14 17:11:16 +0530986 }
987 cloned.ImageDownloads = clonedImages
988 // Set the Admin state to enabled if required
989 if (img.DownloadState != voltha.ImageDownload_DOWNLOAD_REQUESTED &&
990 img.DownloadState != voltha.ImageDownload_DOWNLOAD_STARTED) ||
991 (img.ImageState != voltha.ImageDownload_IMAGE_ACTIVATING) {
992 cloned.AdminState = voltha.AdminState_ENABLED
993 }
khenaidoof5a5bfa2019-01-23 22:20:29 -0500994
npujar467fe752020-01-16 20:17:45 +0530995 if err := agent.updateDeviceInStoreWithoutLock(ctx, cloned, false, ""); err != nil {
npujar1d86a522019-11-14 17:11:16 +0530996 return err
khenaidoof5a5bfa2019-01-23 22:20:29 -0500997 }
998 return nil
999}
1000
1001func (agent *DeviceAgent) getImageDownload(ctx context.Context, img *voltha.ImageDownload) (*voltha.ImageDownload, error) {
khenaidoo1ce37ad2019-03-24 22:07:24 -04001002 agent.lockDevice.RLock()
1003 defer agent.lockDevice.RUnlock()
npujar1d86a522019-11-14 17:11:16 +05301004 log.Debugw("getImageDownload", log.Fields{"id": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -05001005
1006 cloned := agent.getDeviceWithoutLock()
1007 for _, image := range cloned.ImageDownloads {
npujar1d86a522019-11-14 17:11:16 +05301008 if image.Id == img.Id && image.Name == img.Name {
1009 return image, nil
1010 }
1011 }
1012 return nil, status.Errorf(codes.NotFound, "image-not-found:%s", img.Name)
khenaidoof5a5bfa2019-01-23 22:20:29 -05001013}
1014
npujar1d86a522019-11-14 17:11:16 +05301015func (agent *DeviceAgent) listImageDownloads(ctx context.Context, deviceID string) (*voltha.ImageDownloads, error) {
khenaidoo1ce37ad2019-03-24 22:07:24 -04001016 agent.lockDevice.RLock()
1017 defer agent.lockDevice.RUnlock()
npujar1d86a522019-11-14 17:11:16 +05301018 log.Debugw("listImageDownloads", log.Fields{"id": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -05001019
1020 return &voltha.ImageDownloads{Items: agent.getDeviceWithoutLock().ImageDownloads}, nil
khenaidoof5a5bfa2019-01-23 22:20:29 -05001021}
1022
khenaidoo4d4802d2018-10-04 21:59:49 -04001023// getPorts retrieves the ports information of the device based on the port type.
khenaidoo92e62c52018-10-03 14:02:54 -04001024func (agent *DeviceAgent) getPorts(ctx context.Context, portType voltha.Port_PortType) *voltha.Ports {
npujar1d86a522019-11-14 17:11:16 +05301025 log.Debugw("getPorts", log.Fields{"id": agent.deviceID, "portType": portType})
khenaidoob9203542018-09-17 22:56:37 -04001026 ports := &voltha.Ports{}
npujar467fe752020-01-16 20:17:45 +05301027 if device, _ := agent.deviceMgr.GetDevice(ctx, agent.deviceID); device != nil {
khenaidoob9203542018-09-17 22:56:37 -04001028 for _, port := range device.Ports {
khenaidoo92e62c52018-10-03 14:02:54 -04001029 if port.Type == portType {
khenaidoob9203542018-09-17 22:56:37 -04001030 ports.Items = append(ports.Items, port)
1031 }
1032 }
1033 }
1034 return ports
1035}
1036
khenaidoo4d4802d2018-10-04 21:59:49 -04001037// getSwitchCapability is a helper method that a logical device agent uses to retrieve the switch capability of a
1038// parent device
khenaidoo79232702018-12-04 11:00:41 -05001039func (agent *DeviceAgent) getSwitchCapability(ctx context.Context) (*ic.SwitchCapability, error) {
npujar1d86a522019-11-14 17:11:16 +05301040 log.Debugw("getSwitchCapability", log.Fields{"deviceId": agent.deviceID})
npujar467fe752020-01-16 20:17:45 +05301041 device, err := agent.deviceMgr.GetDevice(ctx, agent.deviceID)
npujar1d86a522019-11-14 17:11:16 +05301042 if device == nil {
khenaidoob9203542018-09-17 22:56:37 -04001043 return nil, err
khenaidoob9203542018-09-17 22:56:37 -04001044 }
npujar1d86a522019-11-14 17:11:16 +05301045 var switchCap *ic.SwitchCapability
1046 if switchCap, err = agent.adapterProxy.GetOfpDeviceInfo(ctx, device); err != nil {
1047 log.Debugw("getSwitchCapability-error", log.Fields{"id": device.Id, "error": err})
1048 return nil, err
1049 }
1050 return switchCap, nil
khenaidoob9203542018-09-17 22:56:37 -04001051}
1052
khenaidoo4d4802d2018-10-04 21:59:49 -04001053// getPortCapability is a helper method that a logical device agent uses to retrieve the port capability of a
1054// device
khenaidoo79232702018-12-04 11:00:41 -05001055func (agent *DeviceAgent) getPortCapability(ctx context.Context, portNo uint32) (*ic.PortCapability, error) {
npujar1d86a522019-11-14 17:11:16 +05301056 log.Debugw("getPortCapability", log.Fields{"deviceId": agent.deviceID})
npujar467fe752020-01-16 20:17:45 +05301057 device, err := agent.deviceMgr.GetDevice(ctx, agent.deviceID)
npujar1d86a522019-11-14 17:11:16 +05301058 if device == nil {
khenaidoob9203542018-09-17 22:56:37 -04001059 return nil, err
khenaidoob9203542018-09-17 22:56:37 -04001060 }
npujar1d86a522019-11-14 17:11:16 +05301061 var portCap *ic.PortCapability
1062 if portCap, err = agent.adapterProxy.GetOfpPortInfo(ctx, device, portNo); err != nil {
1063 log.Debugw("getPortCapability-error", log.Fields{"id": device.Id, "error": err})
1064 return nil, err
1065 }
1066 return portCap, nil
khenaidoob9203542018-09-17 22:56:37 -04001067}
1068
npujar467fe752020-01-16 20:17:45 +05301069func (agent *DeviceAgent) packetOut(ctx context.Context, outPort uint32, packet *ofp.OfpPacketOut) error {
Scott Baker80678602019-11-14 16:57:36 -08001070 // If deviceType=="" then we must have taken ownership of this device.
1071 // Fixes VOL-2226 where a core would take ownership and have stale data
1072 if agent.deviceType == "" {
npujar467fe752020-01-16 20:17:45 +05301073 agent.reconcileWithKVStore(ctx)
Scott Baker80678602019-11-14 16:57:36 -08001074 }
khenaidoofdbad6e2018-11-06 22:26:38 -05001075 // Send packet to adapter
npujar467fe752020-01-16 20:17:45 +05301076 if err := agent.adapterProxy.packetOut(ctx, agent.deviceType, agent.deviceID, outPort, packet); err != nil {
Matteo Scandolo360605d2019-11-05 18:29:17 -08001077 log.Debugw("packet-out-error", log.Fields{
npujar1d86a522019-11-14 17:11:16 +05301078 "id": agent.deviceID,
Matteo Scandolo360605d2019-11-05 18:29:17 -08001079 "error": err,
1080 "packet": hex.EncodeToString(packet.Data),
1081 })
khenaidoofdbad6e2018-11-06 22:26:38 -05001082 return err
1083 }
1084 return nil
1085}
1086
khenaidoo4d4802d2018-10-04 21:59:49 -04001087// processUpdate is a callback invoked whenever there is a change on the device manages by this device agent
npujar467fe752020-01-16 20:17:45 +05301088func (agent *DeviceAgent) processUpdate(ctx context.Context, args ...interface{}) interface{} {
khenaidoo43c82122018-11-22 18:38:28 -05001089 //// Run this callback in its own go routine
1090 go func(args ...interface{}) interface{} {
1091 var previous *voltha.Device
1092 var current *voltha.Device
1093 var ok bool
1094 if len(args) == 2 {
1095 if previous, ok = args[0].(*voltha.Device); !ok {
1096 log.Errorw("invalid-callback-type", log.Fields{"data": args[0]})
1097 return nil
1098 }
1099 if current, ok = args[1].(*voltha.Device); !ok {
1100 log.Errorw("invalid-callback-type", log.Fields{"data": args[1]})
1101 return nil
1102 }
1103 } else {
1104 log.Errorw("too-many-args-in-callback", log.Fields{"len": len(args)})
1105 return nil
1106 }
npujar467fe752020-01-16 20:17:45 +05301107 // Perform the state transition in it's own go routine (since the caller doesn't wait for this, use a background context)
1108 if err := agent.deviceMgr.processTransition(context.Background(), previous, current); err != nil {
khenaidoof5a5bfa2019-01-23 22:20:29 -05001109 log.Errorw("failed-process-transition", log.Fields{"deviceId": previous.Id,
1110 "previousAdminState": previous.AdminState, "currentAdminState": current.AdminState})
1111 }
khenaidoo43c82122018-11-22 18:38:28 -05001112 return nil
1113 }(args...)
1114
khenaidoo92e62c52018-10-03 14:02:54 -04001115 return nil
1116}
1117
Mahir Gunyel8e2707d2019-07-25 00:36:21 -07001118// updatePartialDeviceData updates a subset of a device that an Adapter can update.
1119// TODO: May need a specific proto to handle only a subset of a device that can be changed by an adapter
1120func (agent *DeviceAgent) mergeDeviceInfoFromAdapter(device *voltha.Device) (*voltha.Device, error) {
khenaidoo6e55d9e2019-12-12 18:26:26 -05001121 cloned := agent.getDeviceWithoutLock()
Mahir Gunyel8e2707d2019-07-25 00:36:21 -07001122 cloned.Root = device.Root
1123 cloned.Vendor = device.Vendor
1124 cloned.Model = device.Model
1125 cloned.SerialNumber = device.SerialNumber
1126 cloned.MacAddress = device.MacAddress
1127 cloned.Vlan = device.Vlan
1128 cloned.Reason = device.Reason
1129 return cloned, nil
1130}
npujar467fe752020-01-16 20:17:45 +05301131func (agent *DeviceAgent) updateDeviceUsingAdapterData(ctx context.Context, device *voltha.Device) error {
khenaidoo92e62c52018-10-03 14:02:54 -04001132 agent.lockDevice.Lock()
khenaidoo43c82122018-11-22 18:38:28 -05001133 defer agent.lockDevice.Unlock()
Mahir Gunyel8e2707d2019-07-25 00:36:21 -07001134 log.Debugw("updateDeviceUsingAdapterData", log.Fields{"deviceId": device.Id})
npujar1d86a522019-11-14 17:11:16 +05301135 updatedDevice, err := agent.mergeDeviceInfoFromAdapter(device)
1136 if err != nil {
Mahir Gunyel8e2707d2019-07-25 00:36:21 -07001137 log.Errorw("failed to update device ", log.Fields{"deviceId": device.Id})
1138 return status.Errorf(codes.Internal, "%s", err.Error())
Mahir Gunyel8e2707d2019-07-25 00:36:21 -07001139 }
npujar1d86a522019-11-14 17:11:16 +05301140 cloned := proto.Clone(updatedDevice).(*voltha.Device)
npujar467fe752020-01-16 20:17:45 +05301141 return agent.updateDeviceInStoreWithoutLock(ctx, cloned, false, "")
khenaidoo43c82122018-11-22 18:38:28 -05001142}
1143
npujar467fe752020-01-16 20:17:45 +05301144func (agent *DeviceAgent) updateDeviceWithoutLock(ctx context.Context, device *voltha.Device) error {
khenaidoo43c82122018-11-22 18:38:28 -05001145 log.Debugw("updateDevice", log.Fields{"deviceId": device.Id})
1146 cloned := proto.Clone(device).(*voltha.Device)
npujar467fe752020-01-16 20:17:45 +05301147 return agent.updateDeviceInStoreWithoutLock(ctx, cloned, false, "")
khenaidoob9203542018-09-17 22:56:37 -04001148}
1149
npujar467fe752020-01-16 20:17:45 +05301150func (agent *DeviceAgent) updateDeviceStatus(ctx context.Context, operStatus voltha.OperStatus_Types, connStatus voltha.ConnectStatus_Types) error {
khenaidoo92e62c52018-10-03 14:02:54 -04001151 agent.lockDevice.Lock()
khenaidoo0a822f92019-05-08 15:15:57 -04001152 defer agent.lockDevice.Unlock()
khenaidoo6e55d9e2019-12-12 18:26:26 -05001153
1154 cloned := agent.getDeviceWithoutLock()
1155
npujar1d86a522019-11-14 17:11:16 +05301156 // Ensure the enums passed in are valid - they will be invalid if they are not set when this function is invoked
serkant.uluderya2ae470f2020-01-21 11:13:09 -08001157 if s, ok := voltha.ConnectStatus_Types_value[connStatus.String()]; ok {
npujar1d86a522019-11-14 17:11:16 +05301158 log.Debugw("updateDeviceStatus-conn", log.Fields{"ok": ok, "val": s})
1159 cloned.ConnectStatus = connStatus
1160 }
serkant.uluderya2ae470f2020-01-21 11:13:09 -08001161 if s, ok := voltha.OperStatus_Types_value[operStatus.String()]; ok {
npujar1d86a522019-11-14 17:11:16 +05301162 log.Debugw("updateDeviceStatus-oper", log.Fields{"ok": ok, "val": s})
1163 cloned.OperStatus = operStatus
1164 }
1165 log.Debugw("updateDeviceStatus", log.Fields{"deviceId": cloned.Id, "operStatus": cloned.OperStatus, "connectStatus": cloned.ConnectStatus})
1166 // Store the device
npujar467fe752020-01-16 20:17:45 +05301167 return agent.updateDeviceInStoreWithoutLock(ctx, cloned, false, "")
khenaidoo92e62c52018-10-03 14:02:54 -04001168}
1169
npujar467fe752020-01-16 20:17:45 +05301170func (agent *DeviceAgent) enablePorts(ctx context.Context) error {
khenaidoo3ab34882019-05-02 21:33:30 -04001171 agent.lockDevice.Lock()
1172 defer agent.lockDevice.Unlock()
khenaidoo6e55d9e2019-12-12 18:26:26 -05001173
1174 cloned := agent.getDeviceWithoutLock()
1175
npujar1d86a522019-11-14 17:11:16 +05301176 for _, port := range cloned.Ports {
1177 port.AdminState = voltha.AdminState_ENABLED
1178 port.OperStatus = voltha.OperStatus_ACTIVE
1179 }
1180 // Store the device
npujar467fe752020-01-16 20:17:45 +05301181 return agent.updateDeviceInStoreWithoutLock(ctx, cloned, false, "")
khenaidoo3ab34882019-05-02 21:33:30 -04001182}
1183
npujar467fe752020-01-16 20:17:45 +05301184func (agent *DeviceAgent) disablePorts(ctx context.Context) error {
npujar1d86a522019-11-14 17:11:16 +05301185 log.Debugw("disablePorts", log.Fields{"deviceid": agent.deviceID})
khenaidoo3ab34882019-05-02 21:33:30 -04001186 agent.lockDevice.Lock()
1187 defer agent.lockDevice.Unlock()
khenaidoo6e55d9e2019-12-12 18:26:26 -05001188 cloned := agent.getDeviceWithoutLock()
npujar1d86a522019-11-14 17:11:16 +05301189 for _, port := range cloned.Ports {
1190 port.AdminState = voltha.AdminState_DISABLED
1191 port.OperStatus = voltha.OperStatus_UNKNOWN
1192 }
1193 // Store the device
npujar467fe752020-01-16 20:17:45 +05301194 return agent.updateDeviceInStoreWithoutLock(ctx, cloned, false, "")
khenaidoo3ab34882019-05-02 21:33:30 -04001195}
1196
npujar467fe752020-01-16 20:17:45 +05301197func (agent *DeviceAgent) updatePortState(ctx context.Context, portType voltha.Port_PortType, portNo uint32, operStatus voltha.OperStatus_Types) error {
khenaidoo92e62c52018-10-03 14:02:54 -04001198 agent.lockDevice.Lock()
khenaidoo59ef7be2019-06-21 12:40:28 -04001199 defer agent.lockDevice.Unlock()
khenaidoo92e62c52018-10-03 14:02:54 -04001200 // Work only on latest data
1201 // TODO: Get list of ports from device directly instead of the entire device
khenaidoo6e55d9e2019-12-12 18:26:26 -05001202 cloned := agent.getDeviceWithoutLock()
1203
npujar1d86a522019-11-14 17:11:16 +05301204 // Ensure the enums passed in are valid - they will be invalid if they are not set when this function is invoked
1205 if _, ok := voltha.Port_PortType_value[portType.String()]; !ok {
1206 return status.Errorf(codes.InvalidArgument, "%s", portType)
1207 }
1208 for _, port := range cloned.Ports {
1209 if port.Type == portType && port.PortNo == portNo {
1210 port.OperStatus = operStatus
1211 // Set the admin status to ENABLED if the operational status is ACTIVE
1212 // TODO: Set by northbound system?
1213 if operStatus == voltha.OperStatus_ACTIVE {
1214 port.AdminState = voltha.AdminState_ENABLED
1215 }
1216 break
1217 }
1218 }
1219 log.Debugw("portStatusUpdate", log.Fields{"deviceId": cloned.Id})
1220 // Store the device
npujar467fe752020-01-16 20:17:45 +05301221 return agent.updateDeviceInStoreWithoutLock(ctx, cloned, false, "")
khenaidoob9203542018-09-17 22:56:37 -04001222}
1223
npujar467fe752020-01-16 20:17:45 +05301224func (agent *DeviceAgent) deleteAllPorts(ctx context.Context) error {
npujar1d86a522019-11-14 17:11:16 +05301225 log.Debugw("deleteAllPorts", log.Fields{"deviceId": agent.deviceID})
khenaidoo0a822f92019-05-08 15:15:57 -04001226 agent.lockDevice.Lock()
1227 defer agent.lockDevice.Unlock()
khenaidoo6e55d9e2019-12-12 18:26:26 -05001228
1229 cloned := agent.getDeviceWithoutLock()
1230
1231 if cloned.AdminState != voltha.AdminState_DISABLED && cloned.AdminState != voltha.AdminState_DELETED {
1232 err := status.Error(codes.FailedPrecondition, fmt.Sprintf("invalid-state-%v", cloned.AdminState))
1233 log.Warnw("invalid-state-removing-ports", log.Fields{"state": cloned.AdminState, "error": err})
npujar1d86a522019-11-14 17:11:16 +05301234 return err
1235 }
khenaidoo6e55d9e2019-12-12 18:26:26 -05001236 if len(cloned.Ports) == 0 {
npujar1d86a522019-11-14 17:11:16 +05301237 log.Debugw("no-ports-present", log.Fields{"deviceId": agent.deviceID})
1238 return nil
1239 }
khenaidoo6e55d9e2019-12-12 18:26:26 -05001240
npujar1d86a522019-11-14 17:11:16 +05301241 cloned.Ports = []*voltha.Port{}
1242 log.Debugw("portStatusUpdate", log.Fields{"deviceId": cloned.Id})
1243 // Store the device
npujar467fe752020-01-16 20:17:45 +05301244 return agent.updateDeviceInStoreWithoutLock(ctx, cloned, false, "")
khenaidoo0a822f92019-05-08 15:15:57 -04001245}
1246
npujar467fe752020-01-16 20:17:45 +05301247func (agent *DeviceAgent) addPort(ctx context.Context, port *voltha.Port) error {
khenaidoo92e62c52018-10-03 14:02:54 -04001248 agent.lockDevice.Lock()
1249 defer agent.lockDevice.Unlock()
npujar1d86a522019-11-14 17:11:16 +05301250 log.Debugw("addPort", log.Fields{"deviceId": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -05001251
1252 cloned := agent.getDeviceWithoutLock()
npujar1d86a522019-11-14 17:11:16 +05301253 if cloned.Ports == nil {
1254 // First port
1255 log.Debugw("addPort-first-port-to-add", log.Fields{"deviceId": agent.deviceID})
1256 cloned.Ports = make([]*voltha.Port, 0)
khenaidoob9203542018-09-17 22:56:37 -04001257 } else {
npujar1d86a522019-11-14 17:11:16 +05301258 for _, p := range cloned.Ports {
1259 if p.Type == port.Type && p.PortNo == port.PortNo {
1260 log.Debugw("port already exists", log.Fields{"port": *port})
1261 return nil
manikkaraj k259a6f72019-05-06 09:55:44 -04001262 }
khenaidoob9203542018-09-17 22:56:37 -04001263 }
khenaidoo92e62c52018-10-03 14:02:54 -04001264 }
npujar1d86a522019-11-14 17:11:16 +05301265 cp := proto.Clone(port).(*voltha.Port)
1266 // Set the admin state of the port to ENABLE if the operational state is ACTIVE
1267 // TODO: Set by northbound system?
1268 if cp.OperStatus == voltha.OperStatus_ACTIVE {
1269 cp.AdminState = voltha.AdminState_ENABLED
1270 }
1271 cloned.Ports = append(cloned.Ports, cp)
1272 // Store the device
npujar467fe752020-01-16 20:17:45 +05301273 return agent.updateDeviceInStoreWithoutLock(ctx, cloned, false, "")
khenaidoo92e62c52018-10-03 14:02:54 -04001274}
1275
npujar467fe752020-01-16 20:17:45 +05301276func (agent *DeviceAgent) addPeerPort(ctx context.Context, port *voltha.Port_PeerPort) error {
khenaidoo92e62c52018-10-03 14:02:54 -04001277 agent.lockDevice.Lock()
1278 defer agent.lockDevice.Unlock()
1279 log.Debug("addPeerPort")
khenaidoo6e55d9e2019-12-12 18:26:26 -05001280
1281 cloned := agent.getDeviceWithoutLock()
1282
npujar1d86a522019-11-14 17:11:16 +05301283 // Get the peer port on the device based on the port no
1284 for _, peerPort := range cloned.Ports {
1285 if peerPort.PortNo == port.PortNo { // found port
1286 cp := proto.Clone(port).(*voltha.Port_PeerPort)
1287 peerPort.Peers = append(peerPort.Peers, cp)
1288 log.Debugw("found-peer", log.Fields{"portNo": port.PortNo, "deviceId": agent.deviceID})
1289 break
1290 }
1291 }
1292 // Store the device
npujar467fe752020-01-16 20:17:45 +05301293 return agent.updateDeviceInStoreWithoutLock(ctx, cloned, false, "")
khenaidoob9203542018-09-17 22:56:37 -04001294}
1295
npujar467fe752020-01-16 20:17:45 +05301296func (agent *DeviceAgent) deletePeerPorts(ctx context.Context, deviceID string) error {
khenaidoo0a822f92019-05-08 15:15:57 -04001297 agent.lockDevice.Lock()
1298 defer agent.lockDevice.Unlock()
1299 log.Debug("deletePeerPorts")
khenaidoo6e55d9e2019-12-12 18:26:26 -05001300
1301 cloned := agent.getDeviceWithoutLock()
1302
npujar1d86a522019-11-14 17:11:16 +05301303 var updatedPeers []*voltha.Port_PeerPort
1304 for _, port := range cloned.Ports {
1305 updatedPeers = make([]*voltha.Port_PeerPort, 0)
1306 for _, peerPort := range port.Peers {
1307 if peerPort.DeviceId != deviceID {
1308 updatedPeers = append(updatedPeers, peerPort)
1309 }
1310 }
1311 port.Peers = updatedPeers
1312 }
1313
1314 // Store the device with updated peer ports
npujar467fe752020-01-16 20:17:45 +05301315 return agent.updateDeviceInStoreWithoutLock(ctx, cloned, false, "")
khenaidoo0a822f92019-05-08 15:15:57 -04001316}
1317
khenaidoob9203542018-09-17 22:56:37 -04001318// TODO: A generic device update by attribute
npujar467fe752020-01-16 20:17:45 +05301319func (agent *DeviceAgent) updateDeviceAttribute(ctx context.Context, name string, value interface{}) {
khenaidoo92e62c52018-10-03 14:02:54 -04001320 agent.lockDevice.Lock()
1321 defer agent.lockDevice.Unlock()
khenaidoob9203542018-09-17 22:56:37 -04001322 if value == nil {
1323 return
1324 }
khenaidoo6e55d9e2019-12-12 18:26:26 -05001325
1326 cloned := agent.getDeviceWithoutLock()
khenaidoob9203542018-09-17 22:56:37 -04001327 updated := false
khenaidoo6e55d9e2019-12-12 18:26:26 -05001328 s := reflect.ValueOf(cloned).Elem()
khenaidoob9203542018-09-17 22:56:37 -04001329 if s.Kind() == reflect.Struct {
1330 // exported field
1331 f := s.FieldByName(name)
1332 if f.IsValid() && f.CanSet() {
1333 switch f.Kind() {
1334 case reflect.String:
1335 f.SetString(value.(string))
1336 updated = true
1337 case reflect.Uint32:
1338 f.SetUint(uint64(value.(uint32)))
1339 updated = true
1340 case reflect.Bool:
1341 f.SetBool(value.(bool))
1342 updated = true
1343 }
1344 }
1345 }
khenaidoo6e55d9e2019-12-12 18:26:26 -05001346 log.Debugw("update-field-status", log.Fields{"deviceId": cloned.Id, "name": name, "updated": updated})
khenaidoob9203542018-09-17 22:56:37 -04001347 // Save the data
khenaidoo6e55d9e2019-12-12 18:26:26 -05001348
npujar467fe752020-01-16 20:17:45 +05301349 if err := agent.updateDeviceInStoreWithoutLock(ctx, cloned, false, ""); err != nil {
khenaidoob9203542018-09-17 22:56:37 -04001350 log.Warnw("attribute-update-failed", log.Fields{"attribute": name, "value": value})
1351 }
khenaidoob9203542018-09-17 22:56:37 -04001352}
serkant.uluderya334479d2019-04-10 08:26:15 -07001353
1354func (agent *DeviceAgent) simulateAlarm(ctx context.Context, simulatereq *voltha.SimulateAlarmRequest) error {
1355 agent.lockDevice.Lock()
1356 defer agent.lockDevice.Unlock()
npujar1d86a522019-11-14 17:11:16 +05301357 log.Debugw("simulateAlarm", log.Fields{"id": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -05001358
1359 cloned := agent.getDeviceWithoutLock()
1360
npujar1d86a522019-11-14 17:11:16 +05301361 // First send the request to an Adapter and wait for a response
khenaidoo6e55d9e2019-12-12 18:26:26 -05001362 if err := agent.adapterProxy.SimulateAlarm(ctx, cloned, simulatereq); err != nil {
npujar1d86a522019-11-14 17:11:16 +05301363 log.Debugw("simulateAlarm-error", log.Fields{"id": agent.deviceID, "error": err})
1364 return err
serkant.uluderya334479d2019-04-10 08:26:15 -07001365 }
1366 return nil
1367}
Mahir Gunyelb5851672019-07-24 10:46:26 +03001368
1369//This is an update operation to model without Lock.This function must never be invoked by another function unless the latter holds a lock on the device.
1370// It is an internal helper function.
npujar467fe752020-01-16 20:17:45 +05301371func (agent *DeviceAgent) updateDeviceInStoreWithoutLock(ctx context.Context, device *voltha.Device, strict bool, txid string) error {
1372 updateCtx := context.WithValue(ctx, model.RequestTimestamp, time.Now().UnixNano())
Thomas Lee Se5a44012019-11-07 20:32:24 +05301373 afterUpdate, err := agent.clusterDataProxy.Update(updateCtx, "/devices/"+agent.deviceID, device, strict, txid)
1374 if err != nil {
1375 return status.Errorf(codes.Internal, "failed-update-device:%s", agent.deviceID)
1376 }
1377 if afterUpdate == nil {
npujar1d86a522019-11-14 17:11:16 +05301378 return status.Errorf(codes.Internal, "failed-update-device:%s", agent.deviceID)
Mahir Gunyelb5851672019-07-24 10:46:26 +03001379 }
npujar1d86a522019-11-14 17:11:16 +05301380 log.Debugw("updated-device-in-store", log.Fields{"deviceId: ": agent.deviceID})
Mahir Gunyelb5851672019-07-24 10:46:26 +03001381
khenaidoo6e55d9e2019-12-12 18:26:26 -05001382 agent.device = proto.Clone(device).(*voltha.Device)
1383
Mahir Gunyelb5851672019-07-24 10:46:26 +03001384 return nil
1385}
Mahir Gunyelfdee9212019-10-16 16:52:21 -07001386
npujar467fe752020-01-16 20:17:45 +05301387func (agent *DeviceAgent) updateDeviceReason(ctx context.Context, reason string) error {
Mahir Gunyelfdee9212019-10-16 16:52:21 -07001388 agent.lockDevice.Lock()
1389 defer agent.lockDevice.Unlock()
khenaidoo6e55d9e2019-12-12 18:26:26 -05001390
1391 cloned := agent.getDeviceWithoutLock()
npujar1d86a522019-11-14 17:11:16 +05301392 cloned.Reason = reason
1393 log.Debugw("updateDeviceReason", log.Fields{"deviceId": cloned.Id, "reason": cloned.Reason})
1394 // Store the device
npujar467fe752020-01-16 20:17:45 +05301395 return agent.updateDeviceInStoreWithoutLock(ctx, cloned, false, "")
Mahir Gunyelfdee9212019-10-16 16:52:21 -07001396}