Source code for platform_driver.driver

# -*- coding: utf-8 -*- {{{
# vim: set fenc=utf-8 ft=python sw=4 ts=4 sts=4 et:
# Copyright 2020, Battelle Memorial Institute.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# See the License for the specific language governing permissions and
# limitations under the License.
# This material was prepared as an account of work sponsored by an agency of
# the United States Government. Neither the United States Government nor the
# United States Department of Energy, nor Battelle, nor any of their
# employees, nor any jurisdiction or organization that has cooperated in the
# development of these materials, makes any warranty, express or
# implied, or assumes any legal liability or responsibility for the accuracy,
# completeness, or usefulness or any information, apparatus, product,
# software, or process disclosed, or represents that its use would not infringe
# privately owned rights. Reference herein to any specific commercial product,
# process, or service by trade name, trademark, manufacturer, or otherwise
# does not necessarily constitute or imply its endorsement, recommendation, or
# favoring by the United States Government or any agency thereof, or
# Battelle Memorial Institute. The views and opinions of authors expressed
# herein do not necessarily state or reflect those of the
# United States Government or any agency thereof.
# under Contract DE-AC05-76RL01830
# }}}

from import BasicAgent, Core
from volttron.platform.agent import utils
import logging
import random
import gevent
import traceback
from volttron.platform.messaging import headers as headers_mod
from volttron.platform.messaging.topics import (DRIVER_TOPIC_BASE,

from import VIPError, Again
from .driver_locks import publish_lock
import datetime

_log = logging.getLogger(__name__)

[docs]class DriverAgent(BasicAgent): def __init__(self, parent, config, time_slot, driver_scrape_interval, device_path, group, group_offset_interval, default_publish_depth_first_all=True, default_publish_breadth_first_all=True, default_publish_depth_first=True, default_publish_breadth_first=True, **kwargs): super(DriverAgent, self).__init__(**kwargs) self.heart_beat_value = 0 self.device_name = '' #Use the parent's vip connection self.parent = parent = self.config = config self.device_path = device_path self.update_publish_types(default_publish_depth_first_all , default_publish_breadth_first_all, default_publish_depth_first, default_publish_breadth_first) try: interval = int(config.get("interval", 60)) if interval < 1.0: raise ValueError except ValueError: _log.warning("Invalid device scrape interval {}. Defaulting to 60 seconds.".format(config.get("interval"))) interval = 60 self.interval = interval self.periodic_read_event = None self.update_scrape_schedule(time_slot, driver_scrape_interval, group, group_offset_interval)
[docs] def update_publish_types(self, publish_depth_first_all, publish_breadth_first_all, publish_depth_first, publish_breadth_first): """Setup which publish types happen for a scrape. Values passed in are overridden by settings in the specific device configuration.""" self.publish_depth_first_all = bool(self.config.get("publish_depth_first_all", publish_depth_first_all)) self.publish_breadth_first_all = bool(self.config.get("publish_breadth_first_all", publish_breadth_first_all)) self.publish_depth_first = bool(self.config.get("publish_depth_first", publish_depth_first)) self.publish_breadth_first = bool(self.config.get("publish_breadth_first", publish_breadth_first))
[docs] def update_scrape_schedule(self, time_slot, driver_scrape_interval, group, group_offset_interval): self.time_slot_offset = (time_slot * driver_scrape_interval) + (group * group_offset_interval) self.time_slot = time_slot = group _log.debug("{} group: {}, time_slot: {}, offset: {}".format(self.device_path, group, time_slot, self.time_slot_offset)) if self.time_slot_offset >= self.interval: _log.warning( "Scrape offset exceeds interval. Required adjustment will cause scrapes to double up with other devices.") while self.time_slot_offset >= self.interval: self.time_slot_offset -= self.interval #check weather or not we have run our starting method. if not self.periodic_read_event: return self.periodic_read_event.cancel() next_periodic_read = self.find_starting_datetime(utils.get_aware_utc_now()) self.periodic_read_event = self.core.schedule(next_periodic_read, self.periodic_read, next_periodic_read)
[docs] def find_starting_datetime(self, now): midnight = now.replace(hour=0, minute=0, second=0, microsecond=0) seconds_from_midnight = (now - midnight).total_seconds() interval = self.interval offset = seconds_from_midnight % interval if not offset: return now previous_in_seconds = seconds_from_midnight - offset next_in_seconds = previous_in_seconds + interval from_midnight = datetime.timedelta(seconds=next_in_seconds) return midnight + from_midnight + datetime.timedelta(seconds=self.time_slot_offset)
[docs] def get_interface(self, driver_type, config_dict, config_string): """Returns an instance of the interface""" module_name = "platform_driver.interfaces." + driver_type module = __import__(module_name,globals(),locals(),[], 0) interfaces = module.interfaces sub_module = getattr(interfaces, driver_type) klass = getattr(sub_module, "Interface") interface = klass(, core=self.core, device_path=self.device_path) interface.configure(config_dict, config_string) return interface
[docs] @Core.receiver('onstart') def starting(self, sender, **kwargs): self.setup_device() # interval = self.config.get("interval", 60) # self.core.periodic(interval, self.periodic_read, wait=None) next_periodic_read = self.find_starting_datetime(utils.get_aware_utc_now()) self.periodic_read_event = self.core.schedule(next_periodic_read, self.periodic_read, next_periodic_read) self.all_path_depth, self.all_path_breadth = self.get_paths_for_point(DRIVER_TOPIC_ALL)
[docs] def setup_device(self): config = self.config driver_config = config["driver_config"] driver_type = config["driver_type"] registry_config = config.get("registry_config") self.heart_beat_point = config.get("heart_beat_point") self.interface = self.get_interface(driver_type, driver_config, registry_config) self.meta_data = {} for point in self.interface.get_register_names(): register = self.interface.get_register_by_name(point) if register.register_type == 'bit': ts_type = 'boolean' else: if register.python_type is int: ts_type = 'integer' elif register.python_type is float: ts_type = 'float' elif register.python_type is str: ts_type = 'string' self.meta_data[point] = {'units': register.get_units(), 'type': ts_type, 'tz': config.get('timezone', '')} self.base_topic = DEVICES_VALUE(campus='', building='', unit='', path=self.device_path, point=None) self.device_name = DEVICES_PATH(base='', node='', campus='', building='', unit='', path=self.device_path, point='')
# self.parent.device_startup_callback(self.device_name, self)
[docs] def periodic_read(self, now): #we not use self.core.schedule to prevent drift. next_scrape_time = now + datetime.timedelta(seconds=self.interval) # Sanity check now. # This is specifically for when this is running in a VM that gets # suspended and then resumed. # If we don't make this check a resumed VM will publish one event # per minute of # time the VM was suspended for. test_now = utils.get_aware_utc_now() if test_now - next_scrape_time > datetime.timedelta(seconds=self.interval): next_scrape_time = self.find_starting_datetime(test_now) _log.debug("{} next scrape scheduled: {}".format(self.device_path, next_scrape_time)) self.periodic_read_event = self.core.schedule(next_scrape_time, self.periodic_read, next_scrape_time) _log.debug("scraping device: " + self.device_name) self.parent.scrape_starting(self.device_name) try: results = self.interface.scrape_all() register_names = self.interface.get_register_names_view() for point in (register_names - results.keys()): depth_first_topic = self.base_topic(point=point) _log.error("Failed to scrape point: "+depth_first_topic) except (Exception, gevent.Timeout) as ex: tb = traceback.format_exc() _log.error('Failed to scrape ' + self.device_name + ':\n' + tb) return # XXX: Does a warning need to be printed? if not results: return utcnow = utils.get_aware_utc_now() utcnow_string = utils.format_timestamp(utcnow) sync_timestamp = utils.format_timestamp(now - datetime.timedelta(seconds=self.time_slot_offset)) headers = { headers_mod.DATE: utcnow_string, headers_mod.TIMESTAMP: utcnow_string, headers_mod.SYNC_TIMESTAMP: sync_timestamp } if self.publish_depth_first or self.publish_breadth_first: for point, value in results.items(): depth_first_topic, breadth_first_topic = self.get_paths_for_point(point) message = [value, self.meta_data[point]] if self.publish_depth_first: self._publish_wrapper(depth_first_topic, headers=headers, message=message) if self.publish_breadth_first: self._publish_wrapper(breadth_first_topic, headers=headers, message=message) message = [results, self.meta_data] if self.publish_depth_first_all: self._publish_wrapper(self.all_path_depth, headers=headers, message=message) if self.publish_breadth_first_all: self._publish_wrapper(self.all_path_breadth, headers=headers, message=message) self.parent.scrape_ending(self.device_name)
def _publish_wrapper(self, topic, headers, message): while True: try: with publish_lock(): _log.debug("publishing: " + topic)'pubsub', topic, headers=headers, message=message).get(timeout=10.0) _log.debug("finish publishing: " + topic) except gevent.Timeout: _log.warning("Did not receive confirmation of publish to "+topic) break except Again: _log.warning("publish delayed: " + topic + " pubsub is busy") gevent.sleep(random.random()) except VIPError as ex: _log.warning("driver failed to publish " + topic + ": " + str(ex)) break else: break
[docs] def heart_beat(self): if self.heart_beat_point is None: return self.heart_beat_value = int(not bool(self.heart_beat_value)) _log.debug("sending heartbeat: " + self.device_name + ' ' + str(self.heart_beat_value)) self.set_point(self.heart_beat_point, self.heart_beat_value)
[docs] def get_paths_for_point(self, point): depth_first = self.base_topic(point=point) parts = depth_first.split('/') breadth_first_parts = parts[1:] breadth_first_parts.reverse() breadth_first_parts = [DRIVER_TOPIC_BASE] + breadth_first_parts breadth_first = '/'.join(breadth_first_parts) return depth_first, breadth_first
[docs] def get_point(self, point_name, **kwargs): return self.interface.get_point(point_name, **kwargs)
[docs] def set_point(self, point_name, value, **kwargs): return self.interface.set_point(point_name, value, **kwargs)
[docs] def scrape_all(self): return self.interface.scrape_all()
[docs] def get_multiple_points(self, point_names, **kwargs): return self.interface.get_multiple_points(self.device_name, point_names, **kwargs)
[docs] def set_multiple_points(self, point_names_values, **kwargs): return self.interface.set_multiple_points(self.device_name, point_names_values, **kwargs)
[docs] def revert_point(self, point_name, **kwargs): self.interface.revert_point(point_name, **kwargs)
[docs] def revert_all(self, **kwargs): self.interface.revert_all(**kwargs)
[docs] def publish_cov_value(self, point_name, point_values): """ Called in the platform driver agent to publish a cov from a point :param point_name: point which sent COV notifications :param point_values: COV point values """ utcnow = utils.get_aware_utc_now() utcnow_string = utils.format_timestamp(utcnow) headers = { headers_mod.DATE: utcnow_string, headers_mod.TIMESTAMP: utcnow_string, } for point, value in point_values.items(): results = {point_name: value} meta = {point_name: self.meta_data[point_name]} all_message = [results, meta] individual_point_message = [value, self.meta_data[point_name]] depth_first_topic, breadth_first_topic = self.get_paths_for_point( point_name) if self.publish_depth_first: self._publish_wrapper(depth_first_topic, headers=headers, message=individual_point_message) # if self.publish_breadth_first: self._publish_wrapper(breadth_first_topic, headers=headers, message=individual_point_message) if self.publish_depth_first_all: self._publish_wrapper(self.all_path_depth, headers=headers, message=all_message) if self.publish_breadth_first_all: self._publish_wrapper(self.all_path_breadth, headers=headers, message=all_message)