Actuator and driver agent fixes

services/core/ActuatorAgent/actuator/agent.py

@@ -1382,11 +1382,8 @@ def _request_new_schedule(self, sender, task_id, priority, requests, publish_res
                                             'data': {'agentID': sender,
                                                      'taskID': task_id}})
 
-        # If we are successful we do something else with the real result data
-        data = result.data if not result.success else {}
-
         results = {'result': success,
-                   'data': data,
+                   'data': result.data,
                    'info': result.info_string}
 
         if publish_result:

services/core/ActuatorAgent/actuator/scheduler.py

@@ -21,14 +21,14 @@
 #
 # ===----------------------------------------------------------------------===
 # }}}
-
-
 import bisect
 import logging
-from pickle import dumps, loads
+
+from base64 import b64encode
 from collections import defaultdict, namedtuple
 from copy import deepcopy
 from datetime import timedelta
+from pickle import dumps, loads
 
 from volttron.platform.agent import utils
 
@@ -340,7 +340,7 @@ def save_state(self, now):
 
         try:
             self._cleanup(now)
-            self.save_state_callback(dumps(self.tasks))
+            self.save_state_callback(b64encode(dumps(self.tasks)).decode("utf-8"))
         except Exception:
             _log.error('Failed to save scheduler state!')
 
@@ -411,7 +411,10 @@ def request_slots(self, agent_id, id_, requests, priority, now=None):
 
         self.save_state(now)
 
-        return RequestResult(True, preempted_tasks, '')
+        if preempted_tasks:
+            return RequestResult(True, list(preempted_tasks), 'TASK_WERE_PREEMPTED')
+        else:
+            return RequestResult(True, {}, '')
 
     def cancel_task(self, agent_id, task_id, now):
         if task_id not in self.tasks:

services/core/PlatformDriverAgent/platform_driver/agent.py

@@ -487,7 +487,10 @@ def heart_beat(self):
         """
         _log.debug("sending heartbeat")
         for device in self.instances.values():
-            device.heart_beat()
+            try:
+                device.heart_beat()
+            except (Exception, gevent.Timeout) as e:
+                _log.warning(f'Failed to set heart_beat point on device: {device.device_name} -- {e}.')
 
     @RPC.export
     def revert_point(self, path, point_name, **kwargs):

services/core/PlatformDriverAgent/platform_driver/interfaces/bacnet.py

@@ -22,7 +22,7 @@
 # ===----------------------------------------------------------------------===
 # }}}
 
-
+import gevent
 import logging
 from datetime import datetime, timedelta
 
@@ -97,10 +97,10 @@ def ping_target(self):
             self.vip.rpc.call(self.proxy_address, 'ping_device', self.target_address, self.device_id).get(timeout=self.timeout)
             pinged = True
         except errors.Unreachable:
-            _log.warning("Unable to reach BACnet proxy.")
-
-        except errors.VIPError:
-            _log.warning("Error trying to ping device.")
+            _log.warning(f"Unable to reach BACnet proxy at: {self.proxy_address}.")
+        except (Exception, gevent.Timeout) as e:
+            _log.warning(f"Error trying to ping device with device_id '{self.device_id}' at {self.target_address}"
+                         f"through proxy {self.proxy_address}: {e}")
 
         self.scheduled_ping = None