blob: 8cbc63a3e8cfc88e0c0cbbd22c8fb343efc2171a [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"
Scott Baker807addd2019-10-24 15:16:21 -070030 fu "github.com/opencord/voltha-lib-go/v2/pkg/flows"
31 "github.com/opencord/voltha-lib-go/v2/pkg/log"
Scott Baker555307d2019-11-04 08:58:01 -080032 ic "github.com/opencord/voltha-protos/v2/go/inter_container"
33 ofp "github.com/opencord/voltha-protos/v2/go/openflow_13"
34 "github.com/opencord/voltha-protos/v2/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 }
khenaidoo43c82122018-11-22 18:38:28 -0500143 agent.deviceProxy.RegisterCallback(model.POST_UPDATE, 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()
khenaidoob9203542018-09-17 22:56:37 -0400153 log.Debug("stopping-device-agent")
khenaidoo6e55d9e2019-12-12 18:26:26 -0500154
155 // First unregister any callbacks
156 agent.deviceProxy.UnregisterCallback(model.POST_UPDATE, agent.processUpdate)
157
khenaidoo0a822f92019-05-08 15:15:57 -0400158 // Remove the device from the KV store
Thomas Lee Se5a44012019-11-07 20:32:24 +0530159 removed, err := agent.clusterDataProxy.Remove(ctx, "/devices/"+agent.deviceID, "")
160 if err != nil {
161 log.Errorw("Failed-to-remove-device-from-cluster-data-proxy", log.Fields{"error": err})
162 return
163 }
164 if removed == nil {
npujar1d86a522019-11-14 17:11:16 +0530165 log.Debugw("device-already-removed", log.Fields{"id": agent.deviceID})
khenaidoo0a822f92019-05-08 15:15:57 -0400166 }
khenaidoob9203542018-09-17 22:56:37 -0400167 agent.exitChannel <- 1
168 log.Debug("device-agent-stopped")
khenaidoo0a822f92019-05-08 15:15:57 -0400169
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.
173func (agent *DeviceAgent) reconcileWithKVStore() {
174 agent.lockDevice.Lock()
175 defer agent.lockDevice.Unlock()
176 log.Debug("reconciling-device-agent-devicetype")
177 // TODO: context timeout
Thomas Lee Se5a44012019-11-07 20:32:24 +0530178 device, err := agent.clusterDataProxy.Get(context.Background(), "/devices/"+agent.deviceID, 1, true, "")
179 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
241 if err := agent.updateDeviceInStoreWithoutLock(cloned, false, ""); err != nil {
242 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
Kent Hagerman8da2f1e2019-11-25 17:28:09 -0500261func (agent *DeviceAgent) sendBulkFlowsToAdapters(device *voltha.Device, flows *voltha.Flows, groups *voltha.FlowGroups, flowMetadata *voltha.FlowMetadata, response coreutils.Response) {
Manikkaraj kb1a10922019-07-29 12:10:34 -0400262 if err := agent.adapterProxy.UpdateFlowsBulk(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
Kent Hagerman8da2f1e2019-11-25 17:28:09 -0500269func (agent *DeviceAgent) sendIncrementalFlowsToAdapters(device *voltha.Device, flows *ofp.FlowChanges, groups *ofp.FlowGroupChanges, flowMetadata *voltha.FlowMetadata, response coreutils.Response) {
Manikkaraj kb1a10922019-07-29 12:10:34 -0400270 if err := agent.adapterProxy.UpdateFlowsIncremental(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
A R Karthick5c28f552019-12-11 22:47:44 -0800336func (agent *DeviceAgent) addFlowsAndGroupsToAdapter(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)
370 if !dType.AcceptsAddRemoveFlowUpdates {
371
khenaidoob2121e52019-12-16 17:17:22 -0500372 if len(updatedAllGroups) != 0 && reflect.DeepEqual(existingGroups.Items, updatedAllGroups) && len(updatedAllFlows) != 0 && reflect.DeepEqual(existingFlows.Items, updatedAllFlows) {
npujar1d86a522019-11-14 17:11:16 +0530373 log.Debugw("nothing-to-update", log.Fields{"deviceId": agent.deviceID, "flows": newFlows, "groups": newGroups})
A R Karthick5c28f552019-12-11 22:47:44 -0800374 return coreutils.DoneResponse(), nil
khenaidoo0458db62019-06-20 08:50:36 -0400375 }
khenaidoob2121e52019-12-16 17:17:22 -0500376 go agent.sendBulkFlowsToAdapters(device, &voltha.Flows{Items: updatedAllFlows}, &voltha.FlowGroups{Items: updatedAllGroups}, flowMetadata, response)
khenaidoo0458db62019-06-20 08:50:36 -0400377
378 } else {
379 flowChanges := &ofp.FlowChanges{
Matt Jeanneret518b5a42019-10-29 10:30:46 -0400380 ToAdd: &voltha.Flows{Items: newFlows},
khenaidoo0458db62019-06-20 08:50:36 -0400381 ToRemove: &voltha.Flows{Items: flowsToDelete},
382 }
383 groupChanges := &ofp.FlowGroupChanges{
Matt Jeanneret518b5a42019-10-29 10:30:46 -0400384 ToAdd: &voltha.FlowGroups{Items: newGroups},
385 ToRemove: &voltha.FlowGroups{Items: groupsToDelete},
khenaidoo0458db62019-06-20 08:50:36 -0400386 ToUpdate: &voltha.FlowGroups{Items: []*ofp.OfpGroupEntry{}},
387 }
Kent Hagerman8da2f1e2019-11-25 17:28:09 -0500388 go agent.sendIncrementalFlowsToAdapters(device, flowChanges, groupChanges, flowMetadata, response)
khenaidoo0458db62019-06-20 08:50:36 -0400389 }
390
391 // store the changed data
khenaidoob2121e52019-12-16 17:17:22 -0500392 device.Flows = &voltha.Flows{Items: updatedAllFlows}
393 device.FlowGroups = &voltha.FlowGroups{Items: updatedAllGroups}
Kent Hagerman3c513972019-11-25 13:49:41 -0500394 if err := agent.updateDeviceWithoutLock(device); err != nil {
A R Karthick5c28f552019-12-11 22:47:44 -0800395 return coreutils.DoneResponse(), status.Errorf(codes.Internal, "failure-updating-%s", agent.deviceID)
Kent Hagerman3c513972019-11-25 13:49:41 -0500396 }
khenaidoo0458db62019-06-20 08:50:36 -0400397
A R Karthick5c28f552019-12-11 22:47:44 -0800398 return response, nil
399}
400
401//addFlowsAndGroups adds the "newFlows" and "newGroups" from the existing flows/groups and sends the update to the
402//adapters
403func (agent *DeviceAgent) addFlowsAndGroups(newFlows []*ofp.OfpFlowStats, newGroups []*ofp.OfpGroupEntry, flowMetadata *voltha.FlowMetadata) error {
404 response, err := agent.addFlowsAndGroupsToAdapter(newFlows, newGroups, flowMetadata)
405 if err != nil {
406 return err
407 }
Kent Hagerman8da2f1e2019-11-25 17:28:09 -0500408 if res := coreutils.WaitForNilOrErrorResponses(agent.defaultTimeout, response); res != nil {
Manikkaraj kb1a10922019-07-29 12:10:34 -0400409 log.Debugw("Failed to get response from adapter[or] DB", log.Fields{"result": res})
khenaidoo0458db62019-06-20 08:50:36 -0400410 return status.Errorf(codes.Aborted, "errors-%s", res)
411 }
khenaidoo0458db62019-06-20 08:50:36 -0400412 return nil
413}
414
A R Karthick5c28f552019-12-11 22:47:44 -0800415func (agent *DeviceAgent) deleteFlowsAndGroupsFromAdapter(flowsToDel []*ofp.OfpFlowStats, groupsToDel []*ofp.OfpGroupEntry, flowMetadata *voltha.FlowMetadata) (coreutils.Response, error) {
npujar1d86a522019-11-14 17:11:16 +0530416 log.Debugw("deleteFlowsAndGroups", log.Fields{"deviceId": agent.deviceID, "flows": flowsToDel, "groups": groupsToDel})
khenaidoo0458db62019-06-20 08:50:36 -0400417
418 if (len(flowsToDel) | len(groupsToDel)) == 0 {
npujar1d86a522019-11-14 17:11:16 +0530419 log.Debugw("nothing-to-update", log.Fields{"deviceId": agent.deviceID, "flows": flowsToDel, "groups": groupsToDel})
A R Karthick5c28f552019-12-11 22:47:44 -0800420 return coreutils.DoneResponse(), nil
khenaidoo0458db62019-06-20 08:50:36 -0400421 }
422
423 agent.lockDevice.Lock()
424 defer agent.lockDevice.Unlock()
425
khenaidoo6e55d9e2019-12-12 18:26:26 -0500426 device := agent.getDeviceWithoutLock()
khenaidoo0458db62019-06-20 08:50:36 -0400427
428 existingFlows := proto.Clone(device.Flows).(*voltha.Flows)
429 existingGroups := proto.Clone(device.FlowGroups).(*ofp.FlowGroups)
430
431 var flowsToKeep []*ofp.OfpFlowStats
432 var groupsToKeep []*ofp.OfpGroupEntry
433
434 // Process flows
435 for _, flow := range existingFlows.Items {
436 if idx := fu.FindFlows(flowsToDel, flow); idx == -1 {
437 flowsToKeep = append(flowsToKeep, flow)
438 }
439 }
440
441 // Process groups
442 for _, group := range existingGroups.Items {
443 if fu.FindGroup(groupsToDel, group.Desc.GroupId) == -1 { // does not exist now
444 groupsToKeep = append(groupsToKeep, group)
445 }
446 }
447
448 log.Debugw("deleteFlowsAndGroups",
449 log.Fields{
npujar1d86a522019-11-14 17:11:16 +0530450 "deviceId": agent.deviceID,
khenaidoo0458db62019-06-20 08:50:36 -0400451 "flowsToDel": len(flowsToDel),
452 "flowsToKeep": len(flowsToKeep),
453 "groupsToDel": len(groupsToDel),
454 "groupsToKeep": len(groupsToKeep),
455 })
456
457 // Sanity check
458 if (len(flowsToKeep) | len(flowsToDel) | len(groupsToKeep) | len(groupsToDel)) == 0 {
npujar1d86a522019-11-14 17:11:16 +0530459 log.Debugw("nothing-to-update", log.Fields{"deviceId": agent.deviceID, "flowsToDel": flowsToDel, "groupsToDel": groupsToDel})
A R Karthick5c28f552019-12-11 22:47:44 -0800460 return coreutils.DoneResponse(), nil
khenaidoo0458db62019-06-20 08:50:36 -0400461 }
462
463 // Send update to adapters
Kent Hagerman8da2f1e2019-11-25 17:28:09 -0500464 response := coreutils.NewResponse()
khenaidoo0458db62019-06-20 08:50:36 -0400465 dType := agent.adapterMgr.getDeviceType(device.Type)
466 if !dType.AcceptsAddRemoveFlowUpdates {
467 if len(groupsToKeep) != 0 && reflect.DeepEqual(existingGroups.Items, groupsToKeep) && len(flowsToKeep) != 0 && reflect.DeepEqual(existingFlows.Items, flowsToKeep) {
npujar1d86a522019-11-14 17:11:16 +0530468 log.Debugw("nothing-to-update", log.Fields{"deviceId": agent.deviceID, "flowsToDel": flowsToDel, "groupsToDel": groupsToDel})
A R Karthick5c28f552019-12-11 22:47:44 -0800469 return coreutils.DoneResponse(), nil
khenaidoo0458db62019-06-20 08:50:36 -0400470 }
Kent Hagerman8da2f1e2019-11-25 17:28:09 -0500471 go agent.sendBulkFlowsToAdapters(device, &voltha.Flows{Items: flowsToKeep}, &voltha.FlowGroups{Items: groupsToKeep}, flowMetadata, response)
khenaidoo0458db62019-06-20 08:50:36 -0400472 } else {
473 flowChanges := &ofp.FlowChanges{
474 ToAdd: &voltha.Flows{Items: []*ofp.OfpFlowStats{}},
475 ToRemove: &voltha.Flows{Items: flowsToDel},
476 }
477 groupChanges := &ofp.FlowGroupChanges{
478 ToAdd: &voltha.FlowGroups{Items: []*ofp.OfpGroupEntry{}},
479 ToRemove: &voltha.FlowGroups{Items: groupsToDel},
480 ToUpdate: &voltha.FlowGroups{Items: []*ofp.OfpGroupEntry{}},
481 }
Kent Hagerman8da2f1e2019-11-25 17:28:09 -0500482 go agent.sendIncrementalFlowsToAdapters(device, flowChanges, groupChanges, flowMetadata, response)
khenaidoo0458db62019-06-20 08:50:36 -0400483 }
484
485 // store the changed data
486 device.Flows = &voltha.Flows{Items: flowsToKeep}
487 device.FlowGroups = &voltha.FlowGroups{Items: groupsToKeep}
Kent Hagerman3c513972019-11-25 13:49:41 -0500488 if err := agent.updateDeviceWithoutLock(device); err != nil {
A R Karthick5c28f552019-12-11 22:47:44 -0800489 return coreutils.DoneResponse(), status.Errorf(codes.Internal, "failure-updating-%s", agent.deviceID)
Kent Hagerman3c513972019-11-25 13:49:41 -0500490 }
khenaidoo0458db62019-06-20 08:50:36 -0400491
A R Karthick5c28f552019-12-11 22:47:44 -0800492 return response, nil
493
494}
495
496//deleteFlowsAndGroups removes the "flowsToDel" and "groupsToDel" from the existing flows/groups and sends the update to the
497//adapters
498func (agent *DeviceAgent) deleteFlowsAndGroups(flowsToDel []*ofp.OfpFlowStats, groupsToDel []*ofp.OfpGroupEntry, flowMetadata *voltha.FlowMetadata) error {
499 response, err := agent.deleteFlowsAndGroupsFromAdapter(flowsToDel, groupsToDel, flowMetadata)
500 if err != nil {
501 return err
502 }
Kent Hagerman8da2f1e2019-11-25 17:28:09 -0500503 if res := coreutils.WaitForNilOrErrorResponses(agent.defaultTimeout, response); res != nil {
khenaidoo0458db62019-06-20 08:50:36 -0400504 return status.Errorf(codes.Aborted, "errors-%s", res)
505 }
506 return nil
khenaidoo0458db62019-06-20 08:50:36 -0400507}
508
A R Karthick5c28f552019-12-11 22:47:44 -0800509func (agent *DeviceAgent) updateFlowsAndGroupsToAdapter(updatedFlows []*ofp.OfpFlowStats, updatedGroups []*ofp.OfpGroupEntry, flowMetadata *voltha.FlowMetadata) (coreutils.Response, error) {
npujar1d86a522019-11-14 17:11:16 +0530510 log.Debugw("updateFlowsAndGroups", log.Fields{"deviceId": agent.deviceID, "flows": updatedFlows, "groups": updatedGroups})
khenaidoo0458db62019-06-20 08:50:36 -0400511
512 if (len(updatedFlows) | len(updatedGroups)) == 0 {
npujar1d86a522019-11-14 17:11:16 +0530513 log.Debugw("nothing-to-update", log.Fields{"deviceId": agent.deviceID, "flows": updatedFlows, "groups": updatedGroups})
A R Karthick5c28f552019-12-11 22:47:44 -0800514 return coreutils.DoneResponse(), nil
khenaidoo0458db62019-06-20 08:50:36 -0400515 }
516
517 agent.lockDevice.Lock()
518 defer agent.lockDevice.Unlock()
khenaidoo6e55d9e2019-12-12 18:26:26 -0500519
520 device := agent.getDeviceWithoutLock()
521
khenaidoo0458db62019-06-20 08:50:36 -0400522 existingFlows := proto.Clone(device.Flows).(*voltha.Flows)
523 existingGroups := proto.Clone(device.FlowGroups).(*ofp.FlowGroups)
524
525 if len(updatedGroups) != 0 && reflect.DeepEqual(existingGroups.Items, updatedGroups) && len(updatedFlows) != 0 && reflect.DeepEqual(existingFlows.Items, updatedFlows) {
npujar1d86a522019-11-14 17:11:16 +0530526 log.Debugw("nothing-to-update", log.Fields{"deviceId": agent.deviceID, "flows": updatedFlows, "groups": updatedGroups})
A R Karthick5c28f552019-12-11 22:47:44 -0800527 return coreutils.DoneResponse(), nil
khenaidoo0458db62019-06-20 08:50:36 -0400528 }
529
530 log.Debugw("updating-flows-and-groups",
531 log.Fields{
npujar1d86a522019-11-14 17:11:16 +0530532 "deviceId": agent.deviceID,
khenaidoo0458db62019-06-20 08:50:36 -0400533 "updatedFlows": updatedFlows,
534 "updatedGroups": updatedGroups,
535 })
536
Kent Hagerman8da2f1e2019-11-25 17:28:09 -0500537 response := coreutils.NewResponse()
khenaidoo0458db62019-06-20 08:50:36 -0400538 dType := agent.adapterMgr.getDeviceType(device.Type)
539
540 // Process bulk flow update differently than incremental update
541 if !dType.AcceptsAddRemoveFlowUpdates {
Kent Hagerman8da2f1e2019-11-25 17:28:09 -0500542 go agent.sendBulkFlowsToAdapters(device, &voltha.Flows{Items: updatedFlows}, &voltha.FlowGroups{Items: updatedGroups}, nil, response)
khenaidoo0458db62019-06-20 08:50:36 -0400543 } else {
544 var flowsToAdd []*ofp.OfpFlowStats
khenaidoo2c6a0992019-04-29 13:46:56 -0400545 var flowsToDelete []*ofp.OfpFlowStats
khenaidoo0458db62019-06-20 08:50:36 -0400546 var groupsToAdd []*ofp.OfpGroupEntry
khenaidoo2c6a0992019-04-29 13:46:56 -0400547 var groupsToDelete []*ofp.OfpGroupEntry
khenaidoo2c6a0992019-04-29 13:46:56 -0400548
549 // Process flows
khenaidoo0458db62019-06-20 08:50:36 -0400550 for _, flow := range updatedFlows {
551 if idx := fu.FindFlows(existingFlows.Items, flow); idx == -1 {
552 flowsToAdd = append(flowsToAdd, flow)
553 }
khenaidoo2c6a0992019-04-29 13:46:56 -0400554 }
khenaidoo2c6a0992019-04-29 13:46:56 -0400555 for _, flow := range existingFlows.Items {
khenaidoo0458db62019-06-20 08:50:36 -0400556 if idx := fu.FindFlows(updatedFlows, flow); idx != -1 {
khenaidoo2c6a0992019-04-29 13:46:56 -0400557 flowsToDelete = append(flowsToDelete, flow)
558 }
559 }
560
561 // Process groups
khenaidoo0458db62019-06-20 08:50:36 -0400562 for _, g := range updatedGroups {
563 if fu.FindGroup(existingGroups.Items, g.Desc.GroupId) == -1 { // does not exist now
564 groupsToAdd = append(groupsToAdd, g)
565 }
khenaidoo2c6a0992019-04-29 13:46:56 -0400566 }
khenaidoo2c6a0992019-04-29 13:46:56 -0400567 for _, group := range existingGroups.Items {
khenaidoo0458db62019-06-20 08:50:36 -0400568 if fu.FindGroup(updatedGroups, group.Desc.GroupId) != -1 { // does not exist now
khenaidoo2c6a0992019-04-29 13:46:56 -0400569 groupsToDelete = append(groupsToDelete, group)
570 }
571 }
572
khenaidoo0458db62019-06-20 08:50:36 -0400573 log.Debugw("updating-flows-and-groups",
574 log.Fields{
npujar1d86a522019-11-14 17:11:16 +0530575 "deviceId": agent.deviceID,
khenaidoo0458db62019-06-20 08:50:36 -0400576 "flowsToAdd": flowsToAdd,
577 "flowsToDelete": flowsToDelete,
578 "groupsToAdd": groupsToAdd,
579 "groupsToDelete": groupsToDelete,
580 })
581
khenaidoo2c6a0992019-04-29 13:46:56 -0400582 // Sanity check
khenaidoo0458db62019-06-20 08:50:36 -0400583 if (len(flowsToAdd) | len(flowsToDelete) | len(groupsToAdd) | len(groupsToDelete) | len(updatedGroups)) == 0 {
npujar1d86a522019-11-14 17:11:16 +0530584 log.Debugw("nothing-to-update", log.Fields{"deviceId": agent.deviceID, "flows": updatedFlows, "groups": updatedGroups})
A R Karthick5c28f552019-12-11 22:47:44 -0800585 return coreutils.DoneResponse(), nil
khenaidoo2c6a0992019-04-29 13:46:56 -0400586 }
587
khenaidoo0458db62019-06-20 08:50:36 -0400588 flowChanges := &ofp.FlowChanges{
589 ToAdd: &voltha.Flows{Items: flowsToAdd},
590 ToRemove: &voltha.Flows{Items: flowsToDelete},
khenaidoo19d7b632018-10-30 10:49:50 -0400591 }
khenaidoo0458db62019-06-20 08:50:36 -0400592 groupChanges := &ofp.FlowGroupChanges{
593 ToAdd: &voltha.FlowGroups{Items: groupsToAdd},
594 ToRemove: &voltha.FlowGroups{Items: groupsToDelete},
595 ToUpdate: &voltha.FlowGroups{Items: updatedGroups},
596 }
Kent Hagerman8da2f1e2019-11-25 17:28:09 -0500597 go agent.sendIncrementalFlowsToAdapters(device, flowChanges, groupChanges, flowMetadata, response)
khenaidoo19d7b632018-10-30 10:49:50 -0400598 }
khenaidoo0458db62019-06-20 08:50:36 -0400599
600 // store the updated data
601 device.Flows = &voltha.Flows{Items: updatedFlows}
602 device.FlowGroups = &voltha.FlowGroups{Items: updatedGroups}
Kent Hagerman3c513972019-11-25 13:49:41 -0500603 if err := agent.updateDeviceWithoutLock(device); err != nil {
A R Karthick5c28f552019-12-11 22:47:44 -0800604 return coreutils.DoneResponse(), status.Errorf(codes.Internal, "failure-updating-%s", agent.deviceID)
Kent Hagerman3c513972019-11-25 13:49:41 -0500605 }
khenaidoo0458db62019-06-20 08:50:36 -0400606
A R Karthick5c28f552019-12-11 22:47:44 -0800607 return response, nil
608}
609
610//updateFlowsAndGroups replaces the existing flows and groups with "updatedFlows" and "updatedGroups" respectively. It
611//also sends the updates to the adapters
612func (agent *DeviceAgent) updateFlowsAndGroups(updatedFlows []*ofp.OfpFlowStats, updatedGroups []*ofp.OfpGroupEntry, flowMetadata *voltha.FlowMetadata) error {
613 response, err := agent.updateFlowsAndGroupsToAdapter(updatedFlows, updatedGroups, flowMetadata)
614 if err != nil {
615 return err
616 }
Kent Hagerman8da2f1e2019-11-25 17:28:09 -0500617 if res := coreutils.WaitForNilOrErrorResponses(agent.defaultTimeout, response); res != nil {
khenaidoo0458db62019-06-20 08:50:36 -0400618 return status.Errorf(codes.Aborted, "errors-%s", res)
619 }
620 return nil
khenaidoo19d7b632018-10-30 10:49:50 -0400621}
622
khenaidoo4d4802d2018-10-04 21:59:49 -0400623//disableDevice disable a device
khenaidoo92e62c52018-10-03 14:02:54 -0400624func (agent *DeviceAgent) disableDevice(ctx context.Context) error {
khenaidoo59ef7be2019-06-21 12:40:28 -0400625 agent.lockDevice.Lock()
626 defer agent.lockDevice.Unlock()
npujar1d86a522019-11-14 17:11:16 +0530627 log.Debugw("disableDevice", log.Fields{"id": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500628
629 cloned := agent.getDeviceWithoutLock()
630
631 if cloned.AdminState == voltha.AdminState_DISABLED {
npujar1d86a522019-11-14 17:11:16 +0530632 log.Debugw("device-already-disabled", log.Fields{"id": agent.deviceID})
633 return nil
634 }
khenaidoo6e55d9e2019-12-12 18:26:26 -0500635 if cloned.AdminState == voltha.AdminState_PREPROVISIONED ||
636 cloned.AdminState == voltha.AdminState_DELETED {
npujar1d86a522019-11-14 17:11:16 +0530637 log.Debugw("device-not-enabled", log.Fields{"id": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500638 return status.Errorf(codes.FailedPrecondition, "deviceId:%s, invalid-admin-state:%s", agent.deviceID, cloned.AdminState)
npujar1d86a522019-11-14 17:11:16 +0530639 }
khenaidoo4554f7c2019-05-29 22:13:15 -0400640
npujar1d86a522019-11-14 17:11:16 +0530641 // Update the Admin State and operational state before sending the request out
npujar1d86a522019-11-14 17:11:16 +0530642 cloned.AdminState = voltha.AdminState_DISABLED
643 cloned.OperStatus = voltha.OperStatus_UNKNOWN
644 if err := agent.updateDeviceInStoreWithoutLock(cloned, false, ""); err != nil {
645 return err
646 }
khenaidoo6e55d9e2019-12-12 18:26:26 -0500647 if err := agent.adapterProxy.DisableDevice(ctx, proto.Clone(cloned).(*voltha.Device)); err != nil {
npujar1d86a522019-11-14 17:11:16 +0530648 log.Debugw("disableDevice-error", log.Fields{"id": agent.deviceID, "error": err})
649 return err
khenaidoo0a822f92019-05-08 15:15:57 -0400650 }
651 return nil
652}
653
654func (agent *DeviceAgent) updateAdminState(adminState voltha.AdminState_AdminState) error {
655 agent.lockDevice.Lock()
656 defer agent.lockDevice.Unlock()
npujar1d86a522019-11-14 17:11:16 +0530657 log.Debugw("updateAdminState", log.Fields{"id": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500658
659 cloned := agent.getDeviceWithoutLock()
660
661 if cloned.AdminState == adminState {
npujar1d86a522019-11-14 17:11:16 +0530662 log.Debugw("no-change-needed", log.Fields{"id": agent.deviceID, "state": adminState})
663 return nil
664 }
665 // Received an Ack (no error found above). Now update the device in the model to the expected state
npujar1d86a522019-11-14 17:11:16 +0530666 cloned.AdminState = adminState
667 if err := agent.updateDeviceInStoreWithoutLock(cloned, false, ""); err != nil {
668 return err
khenaidoo92e62c52018-10-03 14:02:54 -0400669 }
670 return nil
671}
672
khenaidoo4d4802d2018-10-04 21:59:49 -0400673func (agent *DeviceAgent) rebootDevice(ctx context.Context) error {
674 agent.lockDevice.Lock()
675 defer agent.lockDevice.Unlock()
npujar1d86a522019-11-14 17:11:16 +0530676 log.Debugw("rebootDevice", log.Fields{"id": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500677
678 device := agent.getDeviceWithoutLock()
npujar1d86a522019-11-14 17:11:16 +0530679 if err := agent.adapterProxy.RebootDevice(ctx, device); err != nil {
680 log.Debugw("rebootDevice-error", log.Fields{"id": agent.deviceID, "error": err})
681 return err
khenaidoo4d4802d2018-10-04 21:59:49 -0400682 }
683 return nil
684}
685
686func (agent *DeviceAgent) deleteDevice(ctx context.Context) error {
687 agent.lockDevice.Lock()
khenaidoo0a822f92019-05-08 15:15:57 -0400688 defer agent.lockDevice.Unlock()
npujar1d86a522019-11-14 17:11:16 +0530689 log.Debugw("deleteDevice", log.Fields{"id": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500690
691 cloned := agent.getDeviceWithoutLock()
692 if cloned.AdminState == voltha.AdminState_DELETED {
npujar1d86a522019-11-14 17:11:16 +0530693 log.Debugw("device-already-in-deleted-state", log.Fields{"id": agent.deviceID})
694 return nil
695 }
khenaidoo6e55d9e2019-12-12 18:26:26 -0500696 if (cloned.AdminState != voltha.AdminState_DISABLED) &&
697 (cloned.AdminState != voltha.AdminState_PREPROVISIONED) {
npujar1d86a522019-11-14 17:11:16 +0530698 log.Debugw("device-not-disabled", log.Fields{"id": agent.deviceID})
699 //TODO: Needs customized error message
700 return status.Errorf(codes.FailedPrecondition, "deviceId:%s, expected-admin-state:%s", agent.deviceID, voltha.AdminState_DISABLED)
701 }
khenaidoo6e55d9e2019-12-12 18:26:26 -0500702 if cloned.AdminState != voltha.AdminState_PREPROVISIONED {
npujar1d86a522019-11-14 17:11:16 +0530703 // 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 -0500704 if err := agent.adapterProxy.DeleteDevice(ctx, cloned); err != nil {
npujar1d86a522019-11-14 17:11:16 +0530705 log.Debugw("deleteDevice-error", log.Fields{"id": agent.deviceID, "error": err})
Mahir Gunyelb5851672019-07-24 10:46:26 +0300706 return err
khenaidoo4d4802d2018-10-04 21:59:49 -0400707 }
npujar1d86a522019-11-14 17:11:16 +0530708 }
709 // Set the state to deleted after we receive an Ack - this will trigger some background process to clean up
710 // the device as well as its association with the logical device
npujar1d86a522019-11-14 17:11:16 +0530711 cloned.AdminState = voltha.AdminState_DELETED
712 if err := agent.updateDeviceInStoreWithoutLock(cloned, false, ""); err != nil {
713 return err
714 }
715 // If this is a child device then remove the associated peer ports on the parent device
khenaidoo6e55d9e2019-12-12 18:26:26 -0500716 if !cloned.Root {
npujar1d86a522019-11-14 17:11:16 +0530717 go func() {
khenaidoo6e55d9e2019-12-12 18:26:26 -0500718 err := agent.deviceMgr.deletePeerPorts(cloned.ParentId, cloned.Id)
npujar1d86a522019-11-14 17:11:16 +0530719 if err != nil {
720 log.Errorw("unable-to-delete-peer-ports", log.Fields{"error": err})
721 }
722 }()
khenaidoo4d4802d2018-10-04 21:59:49 -0400723 }
724 return nil
725}
726
npujar1d86a522019-11-14 17:11:16 +0530727func (agent *DeviceAgent) setParentID(device *voltha.Device, parentID string) error {
khenaidooad06fd72019-10-28 12:26:05 -0400728 agent.lockDevice.Lock()
729 defer agent.lockDevice.Unlock()
npujar1d86a522019-11-14 17:11:16 +0530730 log.Debugw("setParentId", log.Fields{"deviceId": device.Id, "parentId": parentID})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500731
732 cloned := agent.getDeviceWithoutLock()
npujar1d86a522019-11-14 17:11:16 +0530733 cloned.ParentId = parentID
734 // Store the device
735 if err := agent.updateDeviceInStoreWithoutLock(cloned, false, ""); err != nil {
736 return err
737 }
738 return nil
khenaidooad06fd72019-10-28 12:26:05 -0400739}
740
khenaidoob3127472019-07-24 21:04:55 -0400741func (agent *DeviceAgent) updatePmConfigs(ctx context.Context, pmConfigs *voltha.PmConfigs) error {
742 agent.lockDevice.Lock()
743 defer agent.lockDevice.Unlock()
744 log.Debugw("updatePmConfigs", log.Fields{"id": pmConfigs.Id})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500745
746 cloned := agent.getDeviceWithoutLock()
npujar1d86a522019-11-14 17:11:16 +0530747 cloned.PmConfigs = proto.Clone(pmConfigs).(*voltha.PmConfigs)
748 // Store the device
749 if err := agent.updateDeviceInStoreWithoutLock(cloned, false, ""); err != nil {
750 return err
751 }
752 // Send the request to the adapter
753 if err := agent.adapterProxy.UpdatePmConfigs(ctx, cloned, pmConfigs); err != nil {
754 log.Errorw("update-pm-configs-error", log.Fields{"id": agent.deviceID, "error": err})
755 return err
756 }
757 return nil
khenaidoob3127472019-07-24 21:04:55 -0400758}
759
760func (agent *DeviceAgent) initPmConfigs(pmConfigs *voltha.PmConfigs) error {
761 agent.lockDevice.Lock()
762 defer agent.lockDevice.Unlock()
763 log.Debugw("initPmConfigs", log.Fields{"id": pmConfigs.Id})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500764
765 cloned := agent.getDeviceWithoutLock()
npujar1d86a522019-11-14 17:11:16 +0530766 cloned.PmConfigs = proto.Clone(pmConfigs).(*voltha.PmConfigs)
767 // Store the device
768 updateCtx := context.WithValue(context.Background(), model.RequestTimestamp, time.Now().UnixNano())
Thomas Lee Se5a44012019-11-07 20:32:24 +0530769 afterUpdate, err := agent.clusterDataProxy.Update(updateCtx, "/devices/"+agent.deviceID, cloned, false, "")
770 if err != nil {
771 return status.Errorf(codes.Internal, "%s", agent.deviceID)
772 }
npujar1d86a522019-11-14 17:11:16 +0530773 if afterUpdate == nil {
774 return status.Errorf(codes.Internal, "%s", agent.deviceID)
775 }
776 return nil
khenaidoob3127472019-07-24 21:04:55 -0400777}
778
779func (agent *DeviceAgent) listPmConfigs(ctx context.Context) (*voltha.PmConfigs, error) {
780 agent.lockDevice.RLock()
781 defer agent.lockDevice.RUnlock()
npujar1d86a522019-11-14 17:11:16 +0530782 log.Debugw("listPmConfigs", log.Fields{"id": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500783
784 return agent.getDeviceWithoutLock().PmConfigs, nil
khenaidoob3127472019-07-24 21:04:55 -0400785}
786
khenaidoof5a5bfa2019-01-23 22:20:29 -0500787func (agent *DeviceAgent) downloadImage(ctx context.Context, img *voltha.ImageDownload) (*voltha.OperationResp, error) {
788 agent.lockDevice.Lock()
789 defer agent.lockDevice.Unlock()
npujar1d86a522019-11-14 17:11:16 +0530790 log.Debugw("downloadImage", log.Fields{"id": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500791
792 device := agent.getDeviceWithoutLock()
793
npujar1d86a522019-11-14 17:11:16 +0530794 if device.AdminState != voltha.AdminState_ENABLED {
795 log.Debugw("device-not-enabled", log.Fields{"id": agent.deviceID})
796 return nil, status.Errorf(codes.FailedPrecondition, "deviceId:%s, expected-admin-state:%s", agent.deviceID, voltha.AdminState_ENABLED)
797 }
798 // Save the image
799 clonedImg := proto.Clone(img).(*voltha.ImageDownload)
800 clonedImg.DownloadState = voltha.ImageDownload_DOWNLOAD_REQUESTED
801 cloned := proto.Clone(device).(*voltha.Device)
802 if cloned.ImageDownloads == nil {
803 cloned.ImageDownloads = []*voltha.ImageDownload{clonedImg}
khenaidoof5a5bfa2019-01-23 22:20:29 -0500804 } else {
805 if device.AdminState != voltha.AdminState_ENABLED {
npujar1d86a522019-11-14 17:11:16 +0530806 log.Debugw("device-not-enabled", log.Fields{"id": agent.deviceID})
807 return nil, status.Errorf(codes.FailedPrecondition, "deviceId:%s, expected-admin-state:%s", agent.deviceID, voltha.AdminState_ENABLED)
khenaidoof5a5bfa2019-01-23 22:20:29 -0500808 }
809 // Save the image
810 clonedImg := proto.Clone(img).(*voltha.ImageDownload)
Stephane Barbariedf5479f2019-01-29 22:13:00 -0500811 clonedImg.DownloadState = voltha.ImageDownload_DOWNLOAD_REQUESTED
khenaidoof5a5bfa2019-01-23 22:20:29 -0500812 cloned := proto.Clone(device).(*voltha.Device)
813 if cloned.ImageDownloads == nil {
814 cloned.ImageDownloads = []*voltha.ImageDownload{clonedImg}
815 } else {
816 cloned.ImageDownloads = append(cloned.ImageDownloads, clonedImg)
817 }
818 cloned.AdminState = voltha.AdminState_DOWNLOADING_IMAGE
Mahir Gunyelb5851672019-07-24 10:46:26 +0300819 if err := agent.updateDeviceInStoreWithoutLock(cloned, false, ""); err != nil {
820 return nil, err
khenaidoof5a5bfa2019-01-23 22:20:29 -0500821 }
822 // Send the request to the adapter
823 if err := agent.adapterProxy.DownloadImage(ctx, cloned, clonedImg); err != nil {
npujar1d86a522019-11-14 17:11:16 +0530824 log.Debugw("downloadImage-error", log.Fields{"id": agent.deviceID, "error": err, "image": img.Name})
khenaidoof5a5bfa2019-01-23 22:20:29 -0500825 return nil, err
826 }
827 }
828 return &voltha.OperationResp{Code: voltha.OperationResp_OPERATION_SUCCESS}, nil
829}
830
831// isImageRegistered is a helper method to figure out if an image is already registered
832func isImageRegistered(img *voltha.ImageDownload, device *voltha.Device) bool {
833 for _, image := range device.ImageDownloads {
834 if image.Id == img.Id && image.Name == img.Name {
835 return true
836 }
837 }
838 return false
839}
840
841func (agent *DeviceAgent) cancelImageDownload(ctx context.Context, img *voltha.ImageDownload) (*voltha.OperationResp, error) {
842 agent.lockDevice.Lock()
843 defer agent.lockDevice.Unlock()
npujar1d86a522019-11-14 17:11:16 +0530844 log.Debugw("cancelImageDownload", log.Fields{"id": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500845
846 device := agent.getDeviceWithoutLock()
847
npujar1d86a522019-11-14 17:11:16 +0530848 // Verify whether the Image is in the list of image being downloaded
849 if !isImageRegistered(img, device) {
850 return nil, status.Errorf(codes.FailedPrecondition, "deviceId:%s, image-not-registered:%s", agent.deviceID, img.Name)
851 }
khenaidoof5a5bfa2019-01-23 22:20:29 -0500852
npujar1d86a522019-11-14 17:11:16 +0530853 // Update image download state
854 cloned := proto.Clone(device).(*voltha.Device)
855 for _, image := range cloned.ImageDownloads {
856 if image.Id == img.Id && image.Name == img.Name {
857 image.DownloadState = voltha.ImageDownload_DOWNLOAD_CANCELLED
khenaidoof5a5bfa2019-01-23 22:20:29 -0500858 }
npujar1d86a522019-11-14 17:11:16 +0530859 }
khenaidoof5a5bfa2019-01-23 22:20:29 -0500860
npujar1d86a522019-11-14 17:11:16 +0530861 if device.AdminState == voltha.AdminState_DOWNLOADING_IMAGE {
862 // Set the device to Enabled
863 cloned.AdminState = voltha.AdminState_ENABLED
864 if err := agent.updateDeviceInStoreWithoutLock(cloned, false, ""); err != nil {
865 return nil, err
866 }
867 // Send the request to the adapter
868 if err := agent.adapterProxy.CancelImageDownload(ctx, device, img); err != nil {
869 log.Debugw("cancelImageDownload-error", log.Fields{"id": agent.deviceID, "error": err, "image": img.Name})
870 return nil, err
khenaidoof5a5bfa2019-01-23 22:20:29 -0500871 }
872 }
873 return &voltha.OperationResp{Code: voltha.OperationResp_OPERATION_SUCCESS}, nil
serkant.uluderya334479d2019-04-10 08:26:15 -0700874}
khenaidoof5a5bfa2019-01-23 22:20:29 -0500875
876func (agent *DeviceAgent) activateImage(ctx context.Context, img *voltha.ImageDownload) (*voltha.OperationResp, error) {
877 agent.lockDevice.Lock()
878 defer agent.lockDevice.Unlock()
npujar1d86a522019-11-14 17:11:16 +0530879 log.Debugw("activateImage", log.Fields{"id": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500880 cloned := agent.getDeviceWithoutLock()
881
npujar1d86a522019-11-14 17:11:16 +0530882 // Verify whether the Image is in the list of image being downloaded
khenaidoo6e55d9e2019-12-12 18:26:26 -0500883 if !isImageRegistered(img, cloned) {
npujar1d86a522019-11-14 17:11:16 +0530884 return nil, status.Errorf(codes.FailedPrecondition, "deviceId:%s, image-not-registered:%s", agent.deviceID, img.Name)
885 }
886
khenaidoo6e55d9e2019-12-12 18:26:26 -0500887 if cloned.AdminState == voltha.AdminState_DOWNLOADING_IMAGE {
npujar1d86a522019-11-14 17:11:16 +0530888 return nil, status.Errorf(codes.FailedPrecondition, "deviceId:%s, device-in-downloading-state:%s", agent.deviceID, img.Name)
889 }
890 // Update image download state
npujar1d86a522019-11-14 17:11:16 +0530891 for _, image := range cloned.ImageDownloads {
892 if image.Id == img.Id && image.Name == img.Name {
893 image.ImageState = voltha.ImageDownload_IMAGE_ACTIVATING
894 }
895 }
896 // Set the device to downloading_image
897 cloned.AdminState = voltha.AdminState_DOWNLOADING_IMAGE
898 if err := agent.updateDeviceInStoreWithoutLock(cloned, false, ""); err != nil {
899 return nil, err
900 }
901
khenaidoo6e55d9e2019-12-12 18:26:26 -0500902 if err := agent.adapterProxy.ActivateImageUpdate(ctx, proto.Clone(cloned).(*voltha.Device), img); err != nil {
npujar1d86a522019-11-14 17:11:16 +0530903 log.Debugw("activateImage-error", log.Fields{"id": agent.deviceID, "error": err, "image": img.Name})
904 return nil, err
905 }
906 // The status of the AdminState will be changed following the update_download_status response from the adapter
907 // The image name will also be removed from the device list
serkant.uluderya334479d2019-04-10 08:26:15 -0700908 return &voltha.OperationResp{Code: voltha.OperationResp_OPERATION_SUCCESS}, nil
909}
khenaidoof5a5bfa2019-01-23 22:20:29 -0500910
911func (agent *DeviceAgent) revertImage(ctx context.Context, img *voltha.ImageDownload) (*voltha.OperationResp, error) {
912 agent.lockDevice.Lock()
913 defer agent.lockDevice.Unlock()
npujar1d86a522019-11-14 17:11:16 +0530914 log.Debugw("revertImage", log.Fields{"id": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500915
916 cloned := agent.getDeviceWithoutLock()
917
npujar1d86a522019-11-14 17:11:16 +0530918 // Verify whether the Image is in the list of image being downloaded
khenaidoo6e55d9e2019-12-12 18:26:26 -0500919 if !isImageRegistered(img, cloned) {
npujar1d86a522019-11-14 17:11:16 +0530920 return nil, status.Errorf(codes.FailedPrecondition, "deviceId:%s, image-not-registered:%s", agent.deviceID, img.Name)
921 }
khenaidoof5a5bfa2019-01-23 22:20:29 -0500922
khenaidoo6e55d9e2019-12-12 18:26:26 -0500923 if cloned.AdminState != voltha.AdminState_ENABLED {
npujar1d86a522019-11-14 17:11:16 +0530924 return nil, status.Errorf(codes.FailedPrecondition, "deviceId:%s, device-not-enabled-state:%s", agent.deviceID, img.Name)
925 }
926 // Update image download state
npujar1d86a522019-11-14 17:11:16 +0530927 for _, image := range cloned.ImageDownloads {
928 if image.Id == img.Id && image.Name == img.Name {
929 image.ImageState = voltha.ImageDownload_IMAGE_REVERTING
khenaidoof5a5bfa2019-01-23 22:20:29 -0500930 }
npujar1d86a522019-11-14 17:11:16 +0530931 }
Mahir Gunyelb5851672019-07-24 10:46:26 +0300932
npujar1d86a522019-11-14 17:11:16 +0530933 if err := agent.updateDeviceInStoreWithoutLock(cloned, false, ""); err != nil {
934 return nil, err
935 }
khenaidoof5a5bfa2019-01-23 22:20:29 -0500936
khenaidoo6e55d9e2019-12-12 18:26:26 -0500937 if err := agent.adapterProxy.RevertImageUpdate(ctx, proto.Clone(cloned).(*voltha.Device), img); err != nil {
npujar1d86a522019-11-14 17:11:16 +0530938 log.Debugw("revertImage-error", log.Fields{"id": agent.deviceID, "error": err, "image": img.Name})
939 return nil, err
khenaidoof5a5bfa2019-01-23 22:20:29 -0500940 }
941 return &voltha.OperationResp{Code: voltha.OperationResp_OPERATION_SUCCESS}, nil
serkant.uluderya334479d2019-04-10 08:26:15 -0700942}
khenaidoof5a5bfa2019-01-23 22:20:29 -0500943
944func (agent *DeviceAgent) getImageDownloadStatus(ctx context.Context, img *voltha.ImageDownload) (*voltha.ImageDownload, error) {
945 agent.lockDevice.Lock()
946 defer agent.lockDevice.Unlock()
npujar1d86a522019-11-14 17:11:16 +0530947 log.Debugw("getImageDownloadStatus", log.Fields{"id": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500948
949 cloned := agent.getDeviceWithoutLock()
950 resp, err := agent.adapterProxy.GetImageDownloadStatus(ctx, cloned, img)
npujar1d86a522019-11-14 17:11:16 +0530951 if err != nil {
952 log.Debugw("getImageDownloadStatus-error", log.Fields{"id": agent.deviceID, "error": err, "image": img.Name})
953 return nil, err
954 }
955 return resp, nil
khenaidoof5a5bfa2019-01-23 22:20:29 -0500956}
957
serkant.uluderya334479d2019-04-10 08:26:15 -0700958func (agent *DeviceAgent) updateImageDownload(img *voltha.ImageDownload) error {
khenaidoof5a5bfa2019-01-23 22:20:29 -0500959 agent.lockDevice.Lock()
960 defer agent.lockDevice.Unlock()
npujar1d86a522019-11-14 17:11:16 +0530961 log.Debugw("updateImageDownload", log.Fields{"id": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500962
963 cloned := agent.getDeviceWithoutLock()
964
npujar1d86a522019-11-14 17:11:16 +0530965 // Update the image as well as remove it if the download was cancelled
npujar1d86a522019-11-14 17:11:16 +0530966 clonedImages := make([]*voltha.ImageDownload, len(cloned.ImageDownloads))
967 for _, image := range cloned.ImageDownloads {
968 if image.Id == img.Id && image.Name == img.Name {
969 if image.DownloadState != voltha.ImageDownload_DOWNLOAD_CANCELLED {
970 clonedImages = append(clonedImages, img)
khenaidoof5a5bfa2019-01-23 22:20:29 -0500971 }
972 }
npujar1d86a522019-11-14 17:11:16 +0530973 }
974 cloned.ImageDownloads = clonedImages
975 // Set the Admin state to enabled if required
976 if (img.DownloadState != voltha.ImageDownload_DOWNLOAD_REQUESTED &&
977 img.DownloadState != voltha.ImageDownload_DOWNLOAD_STARTED) ||
978 (img.ImageState != voltha.ImageDownload_IMAGE_ACTIVATING) {
979 cloned.AdminState = voltha.AdminState_ENABLED
980 }
khenaidoof5a5bfa2019-01-23 22:20:29 -0500981
npujar1d86a522019-11-14 17:11:16 +0530982 if err := agent.updateDeviceInStoreWithoutLock(cloned, false, ""); err != nil {
983 return err
khenaidoof5a5bfa2019-01-23 22:20:29 -0500984 }
985 return nil
986}
987
988func (agent *DeviceAgent) getImageDownload(ctx context.Context, img *voltha.ImageDownload) (*voltha.ImageDownload, error) {
khenaidoo1ce37ad2019-03-24 22:07:24 -0400989 agent.lockDevice.RLock()
990 defer agent.lockDevice.RUnlock()
npujar1d86a522019-11-14 17:11:16 +0530991 log.Debugw("getImageDownload", log.Fields{"id": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -0500992
993 cloned := agent.getDeviceWithoutLock()
994 for _, image := range cloned.ImageDownloads {
npujar1d86a522019-11-14 17:11:16 +0530995 if image.Id == img.Id && image.Name == img.Name {
996 return image, nil
997 }
998 }
999 return nil, status.Errorf(codes.NotFound, "image-not-found:%s", img.Name)
khenaidoof5a5bfa2019-01-23 22:20:29 -05001000}
1001
npujar1d86a522019-11-14 17:11:16 +05301002func (agent *DeviceAgent) listImageDownloads(ctx context.Context, deviceID string) (*voltha.ImageDownloads, error) {
khenaidoo1ce37ad2019-03-24 22:07:24 -04001003 agent.lockDevice.RLock()
1004 defer agent.lockDevice.RUnlock()
npujar1d86a522019-11-14 17:11:16 +05301005 log.Debugw("listImageDownloads", log.Fields{"id": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -05001006
1007 return &voltha.ImageDownloads{Items: agent.getDeviceWithoutLock().ImageDownloads}, nil
khenaidoof5a5bfa2019-01-23 22:20:29 -05001008}
1009
khenaidoo4d4802d2018-10-04 21:59:49 -04001010// getPorts retrieves the ports information of the device based on the port type.
khenaidoo92e62c52018-10-03 14:02:54 -04001011func (agent *DeviceAgent) getPorts(ctx context.Context, portType voltha.Port_PortType) *voltha.Ports {
npujar1d86a522019-11-14 17:11:16 +05301012 log.Debugw("getPorts", log.Fields{"id": agent.deviceID, "portType": portType})
khenaidoob9203542018-09-17 22:56:37 -04001013 ports := &voltha.Ports{}
npujar1d86a522019-11-14 17:11:16 +05301014 if device, _ := agent.deviceMgr.GetDevice(agent.deviceID); device != nil {
khenaidoob9203542018-09-17 22:56:37 -04001015 for _, port := range device.Ports {
khenaidoo92e62c52018-10-03 14:02:54 -04001016 if port.Type == portType {
khenaidoob9203542018-09-17 22:56:37 -04001017 ports.Items = append(ports.Items, port)
1018 }
1019 }
1020 }
1021 return ports
1022}
1023
khenaidoo4d4802d2018-10-04 21:59:49 -04001024// getSwitchCapability is a helper method that a logical device agent uses to retrieve the switch capability of a
1025// parent device
khenaidoo79232702018-12-04 11:00:41 -05001026func (agent *DeviceAgent) getSwitchCapability(ctx context.Context) (*ic.SwitchCapability, error) {
npujar1d86a522019-11-14 17:11:16 +05301027 log.Debugw("getSwitchCapability", log.Fields{"deviceId": agent.deviceID})
1028 device, err := agent.deviceMgr.GetDevice(agent.deviceID)
1029 if device == nil {
khenaidoob9203542018-09-17 22:56:37 -04001030 return nil, err
khenaidoob9203542018-09-17 22:56:37 -04001031 }
npujar1d86a522019-11-14 17:11:16 +05301032 var switchCap *ic.SwitchCapability
1033 if switchCap, err = agent.adapterProxy.GetOfpDeviceInfo(ctx, device); err != nil {
1034 log.Debugw("getSwitchCapability-error", log.Fields{"id": device.Id, "error": err})
1035 return nil, err
1036 }
1037 return switchCap, nil
khenaidoob9203542018-09-17 22:56:37 -04001038}
1039
khenaidoo4d4802d2018-10-04 21:59:49 -04001040// getPortCapability is a helper method that a logical device agent uses to retrieve the port capability of a
1041// device
khenaidoo79232702018-12-04 11:00:41 -05001042func (agent *DeviceAgent) getPortCapability(ctx context.Context, portNo uint32) (*ic.PortCapability, error) {
npujar1d86a522019-11-14 17:11:16 +05301043 log.Debugw("getPortCapability", log.Fields{"deviceId": agent.deviceID})
1044 device, err := agent.deviceMgr.GetDevice(agent.deviceID)
1045 if device == nil {
khenaidoob9203542018-09-17 22:56:37 -04001046 return nil, err
khenaidoob9203542018-09-17 22:56:37 -04001047 }
npujar1d86a522019-11-14 17:11:16 +05301048 var portCap *ic.PortCapability
1049 if portCap, err = agent.adapterProxy.GetOfpPortInfo(ctx, device, portNo); err != nil {
1050 log.Debugw("getPortCapability-error", log.Fields{"id": device.Id, "error": err})
1051 return nil, err
1052 }
1053 return portCap, nil
khenaidoob9203542018-09-17 22:56:37 -04001054}
1055
khenaidoofdbad6e2018-11-06 22:26:38 -05001056func (agent *DeviceAgent) packetOut(outPort uint32, packet *ofp.OfpPacketOut) error {
Scott Baker80678602019-11-14 16:57:36 -08001057 // If deviceType=="" then we must have taken ownership of this device.
1058 // Fixes VOL-2226 where a core would take ownership and have stale data
1059 if agent.deviceType == "" {
1060 agent.reconcileWithKVStore()
1061 }
khenaidoofdbad6e2018-11-06 22:26:38 -05001062 // Send packet to adapter
npujar1d86a522019-11-14 17:11:16 +05301063 if err := agent.adapterProxy.packetOut(agent.deviceType, agent.deviceID, outPort, packet); err != nil {
Matteo Scandolo360605d2019-11-05 18:29:17 -08001064 log.Debugw("packet-out-error", log.Fields{
npujar1d86a522019-11-14 17:11:16 +05301065 "id": agent.deviceID,
Matteo Scandolo360605d2019-11-05 18:29:17 -08001066 "error": err,
1067 "packet": hex.EncodeToString(packet.Data),
1068 })
khenaidoofdbad6e2018-11-06 22:26:38 -05001069 return err
1070 }
1071 return nil
1072}
1073
khenaidoo4d4802d2018-10-04 21:59:49 -04001074// processUpdate is a callback invoked whenever there is a change on the device manages by this device agent
khenaidoo92e62c52018-10-03 14:02:54 -04001075func (agent *DeviceAgent) processUpdate(args ...interface{}) interface{} {
khenaidoo43c82122018-11-22 18:38:28 -05001076 //// Run this callback in its own go routine
1077 go func(args ...interface{}) interface{} {
1078 var previous *voltha.Device
1079 var current *voltha.Device
1080 var ok bool
1081 if len(args) == 2 {
1082 if previous, ok = args[0].(*voltha.Device); !ok {
1083 log.Errorw("invalid-callback-type", log.Fields{"data": args[0]})
1084 return nil
1085 }
1086 if current, ok = args[1].(*voltha.Device); !ok {
1087 log.Errorw("invalid-callback-type", log.Fields{"data": args[1]})
1088 return nil
1089 }
1090 } else {
1091 log.Errorw("too-many-args-in-callback", log.Fields{"len": len(args)})
1092 return nil
1093 }
1094 // Perform the state transition in it's own go routine
khenaidoof5a5bfa2019-01-23 22:20:29 -05001095 if err := agent.deviceMgr.processTransition(previous, current); err != nil {
1096 log.Errorw("failed-process-transition", log.Fields{"deviceId": previous.Id,
1097 "previousAdminState": previous.AdminState, "currentAdminState": current.AdminState})
1098 }
khenaidoo43c82122018-11-22 18:38:28 -05001099 return nil
1100 }(args...)
1101
khenaidoo92e62c52018-10-03 14:02:54 -04001102 return nil
1103}
1104
Mahir Gunyel8e2707d2019-07-25 00:36:21 -07001105// updatePartialDeviceData updates a subset of a device that an Adapter can update.
1106// TODO: May need a specific proto to handle only a subset of a device that can be changed by an adapter
1107func (agent *DeviceAgent) mergeDeviceInfoFromAdapter(device *voltha.Device) (*voltha.Device, error) {
khenaidoo6e55d9e2019-12-12 18:26:26 -05001108 cloned := agent.getDeviceWithoutLock()
Mahir Gunyel8e2707d2019-07-25 00:36:21 -07001109 cloned.Root = device.Root
1110 cloned.Vendor = device.Vendor
1111 cloned.Model = device.Model
1112 cloned.SerialNumber = device.SerialNumber
1113 cloned.MacAddress = device.MacAddress
1114 cloned.Vlan = device.Vlan
1115 cloned.Reason = device.Reason
1116 return cloned, nil
1117}
1118func (agent *DeviceAgent) updateDeviceUsingAdapterData(device *voltha.Device) error {
khenaidoo92e62c52018-10-03 14:02:54 -04001119 agent.lockDevice.Lock()
khenaidoo43c82122018-11-22 18:38:28 -05001120 defer agent.lockDevice.Unlock()
Mahir Gunyel8e2707d2019-07-25 00:36:21 -07001121 log.Debugw("updateDeviceUsingAdapterData", log.Fields{"deviceId": device.Id})
npujar1d86a522019-11-14 17:11:16 +05301122 updatedDevice, err := agent.mergeDeviceInfoFromAdapter(device)
1123 if err != nil {
Mahir Gunyel8e2707d2019-07-25 00:36:21 -07001124 log.Errorw("failed to update device ", log.Fields{"deviceId": device.Id})
1125 return status.Errorf(codes.Internal, "%s", err.Error())
Mahir Gunyel8e2707d2019-07-25 00:36:21 -07001126 }
npujar1d86a522019-11-14 17:11:16 +05301127 cloned := proto.Clone(updatedDevice).(*voltha.Device)
1128 return agent.updateDeviceInStoreWithoutLock(cloned, false, "")
khenaidoo43c82122018-11-22 18:38:28 -05001129}
1130
1131func (agent *DeviceAgent) updateDeviceWithoutLock(device *voltha.Device) error {
1132 log.Debugw("updateDevice", log.Fields{"deviceId": device.Id})
1133 cloned := proto.Clone(device).(*voltha.Device)
Mahir Gunyelb5851672019-07-24 10:46:26 +03001134 return agent.updateDeviceInStoreWithoutLock(cloned, false, "")
khenaidoob9203542018-09-17 22:56:37 -04001135}
1136
khenaidoo92e62c52018-10-03 14:02:54 -04001137func (agent *DeviceAgent) updateDeviceStatus(operStatus voltha.OperStatus_OperStatus, connStatus voltha.ConnectStatus_ConnectStatus) error {
1138 agent.lockDevice.Lock()
khenaidoo0a822f92019-05-08 15:15:57 -04001139 defer agent.lockDevice.Unlock()
khenaidoo6e55d9e2019-12-12 18:26:26 -05001140
1141 cloned := agent.getDeviceWithoutLock()
1142
npujar1d86a522019-11-14 17:11:16 +05301143 // Ensure the enums passed in are valid - they will be invalid if they are not set when this function is invoked
1144 if s, ok := voltha.ConnectStatus_ConnectStatus_value[connStatus.String()]; ok {
1145 log.Debugw("updateDeviceStatus-conn", log.Fields{"ok": ok, "val": s})
1146 cloned.ConnectStatus = connStatus
1147 }
1148 if s, ok := voltha.OperStatus_OperStatus_value[operStatus.String()]; ok {
1149 log.Debugw("updateDeviceStatus-oper", log.Fields{"ok": ok, "val": s})
1150 cloned.OperStatus = operStatus
1151 }
1152 log.Debugw("updateDeviceStatus", log.Fields{"deviceId": cloned.Id, "operStatus": cloned.OperStatus, "connectStatus": cloned.ConnectStatus})
1153 // Store the device
1154 return agent.updateDeviceInStoreWithoutLock(cloned, false, "")
khenaidoo92e62c52018-10-03 14:02:54 -04001155}
1156
khenaidoo3ab34882019-05-02 21:33:30 -04001157func (agent *DeviceAgent) enablePorts() error {
1158 agent.lockDevice.Lock()
1159 defer agent.lockDevice.Unlock()
khenaidoo6e55d9e2019-12-12 18:26:26 -05001160
1161 cloned := agent.getDeviceWithoutLock()
1162
npujar1d86a522019-11-14 17:11:16 +05301163 for _, port := range cloned.Ports {
1164 port.AdminState = voltha.AdminState_ENABLED
1165 port.OperStatus = voltha.OperStatus_ACTIVE
1166 }
1167 // Store the device
1168 return agent.updateDeviceInStoreWithoutLock(cloned, false, "")
khenaidoo3ab34882019-05-02 21:33:30 -04001169}
1170
1171func (agent *DeviceAgent) disablePorts() error {
npujar1d86a522019-11-14 17:11:16 +05301172 log.Debugw("disablePorts", log.Fields{"deviceid": agent.deviceID})
khenaidoo3ab34882019-05-02 21:33:30 -04001173 agent.lockDevice.Lock()
1174 defer agent.lockDevice.Unlock()
khenaidoo6e55d9e2019-12-12 18:26:26 -05001175 cloned := agent.getDeviceWithoutLock()
npujar1d86a522019-11-14 17:11:16 +05301176 for _, port := range cloned.Ports {
1177 port.AdminState = voltha.AdminState_DISABLED
1178 port.OperStatus = voltha.OperStatus_UNKNOWN
1179 }
1180 // Store the device
1181 return agent.updateDeviceInStoreWithoutLock(cloned, false, "")
khenaidoo3ab34882019-05-02 21:33:30 -04001182}
1183
khenaidoo92e62c52018-10-03 14:02:54 -04001184func (agent *DeviceAgent) updatePortState(portType voltha.Port_PortType, portNo uint32, operStatus voltha.OperStatus_OperStatus) error {
1185 agent.lockDevice.Lock()
khenaidoo59ef7be2019-06-21 12:40:28 -04001186 defer agent.lockDevice.Unlock()
khenaidoo92e62c52018-10-03 14:02:54 -04001187 // Work only on latest data
1188 // TODO: Get list of ports from device directly instead of the entire device
khenaidoo6e55d9e2019-12-12 18:26:26 -05001189 cloned := agent.getDeviceWithoutLock()
1190
npujar1d86a522019-11-14 17:11:16 +05301191 // Ensure the enums passed in are valid - they will be invalid if they are not set when this function is invoked
1192 if _, ok := voltha.Port_PortType_value[portType.String()]; !ok {
1193 return status.Errorf(codes.InvalidArgument, "%s", portType)
1194 }
1195 for _, port := range cloned.Ports {
1196 if port.Type == portType && port.PortNo == portNo {
1197 port.OperStatus = operStatus
1198 // Set the admin status to ENABLED if the operational status is ACTIVE
1199 // TODO: Set by northbound system?
1200 if operStatus == voltha.OperStatus_ACTIVE {
1201 port.AdminState = voltha.AdminState_ENABLED
1202 }
1203 break
1204 }
1205 }
1206 log.Debugw("portStatusUpdate", log.Fields{"deviceId": cloned.Id})
1207 // Store the device
1208 return agent.updateDeviceInStoreWithoutLock(cloned, false, "")
khenaidoob9203542018-09-17 22:56:37 -04001209}
1210
khenaidoo0a822f92019-05-08 15:15:57 -04001211func (agent *DeviceAgent) deleteAllPorts() error {
npujar1d86a522019-11-14 17:11:16 +05301212 log.Debugw("deleteAllPorts", log.Fields{"deviceId": agent.deviceID})
khenaidoo0a822f92019-05-08 15:15:57 -04001213 agent.lockDevice.Lock()
1214 defer agent.lockDevice.Unlock()
khenaidoo6e55d9e2019-12-12 18:26:26 -05001215
1216 cloned := agent.getDeviceWithoutLock()
1217
1218 if cloned.AdminState != voltha.AdminState_DISABLED && cloned.AdminState != voltha.AdminState_DELETED {
1219 err := status.Error(codes.FailedPrecondition, fmt.Sprintf("invalid-state-%v", cloned.AdminState))
1220 log.Warnw("invalid-state-removing-ports", log.Fields{"state": cloned.AdminState, "error": err})
npujar1d86a522019-11-14 17:11:16 +05301221 return err
1222 }
khenaidoo6e55d9e2019-12-12 18:26:26 -05001223 if len(cloned.Ports) == 0 {
npujar1d86a522019-11-14 17:11:16 +05301224 log.Debugw("no-ports-present", log.Fields{"deviceId": agent.deviceID})
1225 return nil
1226 }
khenaidoo6e55d9e2019-12-12 18:26:26 -05001227
npujar1d86a522019-11-14 17:11:16 +05301228 cloned.Ports = []*voltha.Port{}
1229 log.Debugw("portStatusUpdate", log.Fields{"deviceId": cloned.Id})
1230 // Store the device
1231 return agent.updateDeviceInStoreWithoutLock(cloned, false, "")
khenaidoo0a822f92019-05-08 15:15:57 -04001232}
1233
khenaidoob9203542018-09-17 22:56:37 -04001234func (agent *DeviceAgent) addPort(port *voltha.Port) error {
khenaidoo92e62c52018-10-03 14:02:54 -04001235 agent.lockDevice.Lock()
1236 defer agent.lockDevice.Unlock()
npujar1d86a522019-11-14 17:11:16 +05301237 log.Debugw("addPort", log.Fields{"deviceId": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -05001238
1239 cloned := agent.getDeviceWithoutLock()
npujar1d86a522019-11-14 17:11:16 +05301240 if cloned.Ports == nil {
1241 // First port
1242 log.Debugw("addPort-first-port-to-add", log.Fields{"deviceId": agent.deviceID})
1243 cloned.Ports = make([]*voltha.Port, 0)
khenaidoob9203542018-09-17 22:56:37 -04001244 } else {
npujar1d86a522019-11-14 17:11:16 +05301245 for _, p := range cloned.Ports {
1246 if p.Type == port.Type && p.PortNo == port.PortNo {
1247 log.Debugw("port already exists", log.Fields{"port": *port})
1248 return nil
manikkaraj k259a6f72019-05-06 09:55:44 -04001249 }
khenaidoob9203542018-09-17 22:56:37 -04001250 }
khenaidoo92e62c52018-10-03 14:02:54 -04001251 }
npujar1d86a522019-11-14 17:11:16 +05301252 cp := proto.Clone(port).(*voltha.Port)
1253 // Set the admin state of the port to ENABLE if the operational state is ACTIVE
1254 // TODO: Set by northbound system?
1255 if cp.OperStatus == voltha.OperStatus_ACTIVE {
1256 cp.AdminState = voltha.AdminState_ENABLED
1257 }
1258 cloned.Ports = append(cloned.Ports, cp)
1259 // Store the device
1260 return agent.updateDeviceInStoreWithoutLock(cloned, false, "")
khenaidoo92e62c52018-10-03 14:02:54 -04001261}
1262
1263func (agent *DeviceAgent) addPeerPort(port *voltha.Port_PeerPort) error {
1264 agent.lockDevice.Lock()
1265 defer agent.lockDevice.Unlock()
1266 log.Debug("addPeerPort")
khenaidoo6e55d9e2019-12-12 18:26:26 -05001267
1268 cloned := agent.getDeviceWithoutLock()
1269
npujar1d86a522019-11-14 17:11:16 +05301270 // Get the peer port on the device based on the port no
1271 for _, peerPort := range cloned.Ports {
1272 if peerPort.PortNo == port.PortNo { // found port
1273 cp := proto.Clone(port).(*voltha.Port_PeerPort)
1274 peerPort.Peers = append(peerPort.Peers, cp)
1275 log.Debugw("found-peer", log.Fields{"portNo": port.PortNo, "deviceId": agent.deviceID})
1276 break
1277 }
1278 }
1279 // Store the device
1280 return agent.updateDeviceInStoreWithoutLock(cloned, false, "")
khenaidoob9203542018-09-17 22:56:37 -04001281}
1282
npujar1d86a522019-11-14 17:11:16 +05301283func (agent *DeviceAgent) deletePeerPorts(deviceID string) error {
khenaidoo0a822f92019-05-08 15:15:57 -04001284 agent.lockDevice.Lock()
1285 defer agent.lockDevice.Unlock()
1286 log.Debug("deletePeerPorts")
khenaidoo6e55d9e2019-12-12 18:26:26 -05001287
1288 cloned := agent.getDeviceWithoutLock()
1289
npujar1d86a522019-11-14 17:11:16 +05301290 var updatedPeers []*voltha.Port_PeerPort
1291 for _, port := range cloned.Ports {
1292 updatedPeers = make([]*voltha.Port_PeerPort, 0)
1293 for _, peerPort := range port.Peers {
1294 if peerPort.DeviceId != deviceID {
1295 updatedPeers = append(updatedPeers, peerPort)
1296 }
1297 }
1298 port.Peers = updatedPeers
1299 }
1300
1301 // Store the device with updated peer ports
1302 return agent.updateDeviceInStoreWithoutLock(cloned, false, "")
khenaidoo0a822f92019-05-08 15:15:57 -04001303}
1304
khenaidoob9203542018-09-17 22:56:37 -04001305// TODO: A generic device update by attribute
1306func (agent *DeviceAgent) updateDeviceAttribute(name string, value interface{}) {
khenaidoo92e62c52018-10-03 14:02:54 -04001307 agent.lockDevice.Lock()
1308 defer agent.lockDevice.Unlock()
khenaidoob9203542018-09-17 22:56:37 -04001309 if value == nil {
1310 return
1311 }
khenaidoo6e55d9e2019-12-12 18:26:26 -05001312
1313 cloned := agent.getDeviceWithoutLock()
khenaidoob9203542018-09-17 22:56:37 -04001314 updated := false
khenaidoo6e55d9e2019-12-12 18:26:26 -05001315 s := reflect.ValueOf(cloned).Elem()
khenaidoob9203542018-09-17 22:56:37 -04001316 if s.Kind() == reflect.Struct {
1317 // exported field
1318 f := s.FieldByName(name)
1319 if f.IsValid() && f.CanSet() {
1320 switch f.Kind() {
1321 case reflect.String:
1322 f.SetString(value.(string))
1323 updated = true
1324 case reflect.Uint32:
1325 f.SetUint(uint64(value.(uint32)))
1326 updated = true
1327 case reflect.Bool:
1328 f.SetBool(value.(bool))
1329 updated = true
1330 }
1331 }
1332 }
khenaidoo6e55d9e2019-12-12 18:26:26 -05001333 log.Debugw("update-field-status", log.Fields{"deviceId": cloned.Id, "name": name, "updated": updated})
khenaidoob9203542018-09-17 22:56:37 -04001334 // Save the data
khenaidoo6e55d9e2019-12-12 18:26:26 -05001335
1336 if err := agent.updateDeviceInStoreWithoutLock(cloned, false, ""); err != nil {
khenaidoob9203542018-09-17 22:56:37 -04001337 log.Warnw("attribute-update-failed", log.Fields{"attribute": name, "value": value})
1338 }
khenaidoob9203542018-09-17 22:56:37 -04001339}
serkant.uluderya334479d2019-04-10 08:26:15 -07001340
1341func (agent *DeviceAgent) simulateAlarm(ctx context.Context, simulatereq *voltha.SimulateAlarmRequest) error {
1342 agent.lockDevice.Lock()
1343 defer agent.lockDevice.Unlock()
npujar1d86a522019-11-14 17:11:16 +05301344 log.Debugw("simulateAlarm", log.Fields{"id": agent.deviceID})
khenaidoo6e55d9e2019-12-12 18:26:26 -05001345
1346 cloned := agent.getDeviceWithoutLock()
1347
npujar1d86a522019-11-14 17:11:16 +05301348 // First send the request to an Adapter and wait for a response
khenaidoo6e55d9e2019-12-12 18:26:26 -05001349 if err := agent.adapterProxy.SimulateAlarm(ctx, cloned, simulatereq); err != nil {
npujar1d86a522019-11-14 17:11:16 +05301350 log.Debugw("simulateAlarm-error", log.Fields{"id": agent.deviceID, "error": err})
1351 return err
serkant.uluderya334479d2019-04-10 08:26:15 -07001352 }
1353 return nil
1354}
Mahir Gunyelb5851672019-07-24 10:46:26 +03001355
1356//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.
1357// It is an internal helper function.
1358func (agent *DeviceAgent) updateDeviceInStoreWithoutLock(device *voltha.Device, strict bool, txid string) error {
1359 updateCtx := context.WithValue(context.Background(), model.RequestTimestamp, time.Now().UnixNano())
Thomas Lee Se5a44012019-11-07 20:32:24 +05301360 afterUpdate, err := agent.clusterDataProxy.Update(updateCtx, "/devices/"+agent.deviceID, device, strict, txid)
1361 if err != nil {
1362 return status.Errorf(codes.Internal, "failed-update-device:%s", agent.deviceID)
1363 }
1364 if afterUpdate == nil {
npujar1d86a522019-11-14 17:11:16 +05301365 return status.Errorf(codes.Internal, "failed-update-device:%s", agent.deviceID)
Mahir Gunyelb5851672019-07-24 10:46:26 +03001366 }
npujar1d86a522019-11-14 17:11:16 +05301367 log.Debugw("updated-device-in-store", log.Fields{"deviceId: ": agent.deviceID})
Mahir Gunyelb5851672019-07-24 10:46:26 +03001368
khenaidoo6e55d9e2019-12-12 18:26:26 -05001369 agent.device = proto.Clone(device).(*voltha.Device)
1370
Mahir Gunyelb5851672019-07-24 10:46:26 +03001371 return nil
1372}
Mahir Gunyelfdee9212019-10-16 16:52:21 -07001373
1374func (agent *DeviceAgent) updateDeviceReason(reason string) error {
1375 agent.lockDevice.Lock()
1376 defer agent.lockDevice.Unlock()
khenaidoo6e55d9e2019-12-12 18:26:26 -05001377
1378 cloned := agent.getDeviceWithoutLock()
npujar1d86a522019-11-14 17:11:16 +05301379 cloned.Reason = reason
1380 log.Debugw("updateDeviceReason", log.Fields{"deviceId": cloned.Id, "reason": cloned.Reason})
1381 // Store the device
1382 return agent.updateDeviceInStoreWithoutLock(cloned, false, "")
Mahir Gunyelfdee9212019-10-16 16:52:21 -07001383}