def __init__(self, agentid, lock, dev, msgque, raw_queue, message_bus): Process.__init__(self) self.lock = lock self.msgque = msgque self.raw_queue = raw_queue ident = 'Agent' + str(agentid) self.agent = Agent(address=get_address(), identity=ident, message_bus=message_bus) event = gevent.event.Event() self.agent._agentid = 'Agent' + str(agentid) self.task = gevent.spawn(self.agent.core.run, event) event.wait(timeout=2) self.agent.vip.pubsub.subscribe('pubsub', 'devices', self.on_message) _log.debug("Process id: {}".format(os.getpid())) eprint("eprint - Process id: {}".format(os.getpid())) self.count = 0 self.publishes = 0 self.data_list = [[], [], [], [], []] self.delta_list = [] self.msg = [] self.devices = dev self.max_publishes = 5*dev self.utcnow_string = ''
def __init__(self, owner, address=None, identity=None, context=None, publickey=None, secretkey=None, serverkey=None, volttron_home=os.path.abspath(platform.get_home()), agent_uuid=None, reconnect_interval=None, version='0.1', instance_name=None, messagebus=None): self.volttron_home = volttron_home # These signals need to exist before calling super().__init__() self.onviperror = Signal() self.onsockevent = Signal() self.onconnected = Signal() self.ondisconnected = Signal() self.configuration = Signal() super(Core, self).__init__(owner) self.address = address if address is not None else get_address() self.identity = str(identity) if identity is not None else str(uuid.uuid4()) self.agent_uuid = agent_uuid self.publickey = publickey self.secretkey = secretkey self.serverkey = serverkey self.reconnect_interval = reconnect_interval self._reconnect_attempt = 0 self.instance_name = instance_name self.messagebus = messagebus self.subsystems = {'error': self.handle_error} self.__connected = False self._version = version self.socket = None self.connection = None _log.debug('address: %s', address) _log.debug('identity: %s', self.identity) _log.debug('agent_uuid: %s', agent_uuid) _log.debug('serverkey: %s', serverkey)
def build_agent(address=get_address(), identity=None, publickey=ks.public, secretkey=ks.secret, timeout=10, serverkey=None, agent_class=Agent, **kwargs): """ Builds a dynamic agent connected to the specifiedd address. All key parameters should have been encoded with :py:meth:`volttron.platform.vip.socket.encode_key` :param str address: VIP address to connect to :param str identity: Agent's identity :param str publickey: Agent's Base64-encoded CURVE public key :param str secretkey: Agent's Base64-encoded CURVE secret key :param str serverkey: Server's Base64-encoded CURVE public key :param class agent_class: Class to use for creating the instance :param int timeout: Seconds to wait for agent to start :param kwargs: Any Agent specific parameters :return: an agent based upon agent_class that has been started :rtype: agent_class """ agent = agent_class(address=address, identity=identity, publickey=publickey, secretkey=secretkey, serverkey=serverkey, **kwargs) event = gevent.event.Event() gevent.spawn(agent.core.run, event) with gevent.Timeout(timeout): event.wait() return agent
def __init__(self, owner, address=None, identity=None, context=None, publickey=None, secretkey=None, serverkey=None, volttron_home=os.path.abspath(platform.get_home()), agent_uuid=None, reconnect_interval=None, version='0.1'): self.volttron_home = volttron_home # These signals need to exist before calling super().__init__() self.onviperror = Signal() self.onsockevent = Signal() self.onconnected = Signal() self.ondisconnected = Signal() self.configuration = Signal() super(Core, self).__init__(owner) self.context = context or zmq.Context.instance() self.address = address if address is not None else get_address() self.identity = str(identity) if identity is not None else str(uuid.uuid4()) self.agent_uuid = agent_uuid self.publickey = publickey self.secretkey = secretkey self.serverkey = serverkey self.reconnect_interval = reconnect_interval self._reconnect_attempt = 0 self._set_keys() _log.debug('address: %s', address) _log.debug('identity: %s', identity) _log.debug('agent_uuid: %s', agent_uuid) _log.debug('serverkey: %s', serverkey) self.socket = None self.subsystems = {'error': self.handle_error} self.__connected = False self._version = version
def get_configs(config_id, output_directory): keystore = KeyStore() agent = Agent(address=get_address(), publickey=keystore.public, secretkey=keystore.secret, enable_store=False) event = gevent.event.Event() gevent.spawn(agent.core.run, event) event.wait() config_list = agent.vip.rpc.call(CONFIGURATION_STORE, 'manage_list_configs', config_id).get(timeout=10) if not config_list: print "Config store", config_id, "does not exist." return ensure_dir(output_directory) os.chdir(output_directory) for config in config_list: print "Retrieving configuration", config raw_config = agent.vip.rpc.call(CONFIGURATION_STORE, 'manage_get', config_id, config, raw=True).get(timeout=10) ensure_dir(os.path.dirname(config)) with open(config, "w") as f: f.write(raw_config)
def build_agent(address=None, identity=None, publickey=None, secretkey=None, timeout=10, serverkey=None, agent_class=Agent, volttron_central_address=None, volttron_central_instance_name=None, **kwargs) -> Agent: """ Builds a dynamic agent connected to the specifiedd address. All key parameters should have been encoded with :py:meth:`volttron.platform.vip.socket.encode_key` :param str address: VIP address to connect to :param str identity: Agent's identity :param str publickey: Agent's Base64-encoded CURVE public key :param str secretkey: Agent's Base64-encoded CURVE secret key :param str serverkey: Server's Base64-encoded CURVE public key :param class agent_class: Class to use for creating the instance :param int timeout: Seconds to wait for agent to start :param kwargs: Any Agent specific parameters :return: an agent based upon agent_class that has been started :rtype: agent_class """ address = address if address is not None else get_address() # This is a fix allows the connect to message bus to be different than # the one that is currently running. if publickey is None or secretkey is None: publickey, secretkey = get_server_keys() try: message_bus = kwargs.pop('message_bus') except KeyError: message_bus = os.environ.get('MESSAGEBUS', 'zmq') try: enable_store = kwargs.pop('enable_store') except KeyError: enable_store = False agent = agent_class( address=address, identity=identity, publickey=publickey, secretkey=secretkey, serverkey=serverkey, volttron_central_address=volttron_central_address, volttron_central_instance_name=volttron_central_instance_name, message_bus=message_bus, enable_store=enable_store, **kwargs) event = gevent.event.Event() gevent.spawn(agent.core.run, event) with gevent.Timeout(timeout): event.wait() return agent
def main(): # parse the command line arguments arg_parser = argparse.ArgumentParser(description=__doc__) arg_parser.add_argument( "--address", help="Target only device(s) at <address> for request") arg_parser.add_argument( "--range", type=int, nargs=2, metavar=('LOW', 'HIGH'), help="Lower and upper limit on device ID in results") arg_parser.add_argument( "--timeout", type=int, metavar=('SECONDS'), help="Time, in seconds, to wait for responses. Default: %(default)s", default=5) arg_parser.add_argument("--proxy-id", help="VIP IDENTITY of the BACnet proxy agent.", default="platform.bacnet_proxy") args = arg_parser.parse_args() _log.debug("initialization") _log.debug(" - args: %r", args) keystore = KeyStore() agent = BACnetInteraction(args.proxy_id, address=get_address(), volttron_home=get_home(), publickey=keystore.public, secretkey=keystore.secret, enable_store=False) event = gevent.event.Event() gevent.spawn(agent.core.run, event) event.wait() kwargs = {'address': args.address} if args.range is not None: kwargs['low_device_id'] = int(args.range[0]) kwargs['high_device_id'] = int(args.range[1]) try: agent.send_iam(**kwargs) except errors.Unreachable: _log.error( "There is no BACnet proxy Agent running on the platform with the VIP IDENTITY {}" .format(args.proxy_id)) else: gevent.sleep(args.timeout)
def __init__(self): self.address = get_address() self.peer = 'messagedebugger' self._server = Agent(identity='message.viewer', address=self.address, publickey=KeyStore().public, secretkey=KeyStore().secret, serverkey=KnownHostsStore().serverkey(self.address), enable_store=False, enable_channel=True) self._greenlet = None
def build_connection(identity, peer='', address=get_address(), publickey=ks.public, secretkey=ks.secret, **kwargs): cn = Connection(address=address, identity=identity, peer=peer, publickey=publickey, secretkey=secretkey, **kwargs) return cn
def get_keys(): """Gets keys from keystore and known-hosts store :returns: Keys for connecting to the platform :rtype: dict """ hosts = KnownHostsStore() serverkey = hosts.serverkey(get_address()) key_store = KeyStore() publickey = key_store.public secretkey = key_store.secret return {'publickey': publickey, 'secretkey': secretkey, 'serverkey': serverkey}
def vip_main(agent_class, identity=None, version='0.1', **kwargs): """Default main entry point implementation for VIP agents.""" try: # If stdout is a pipe, re-open it line buffered if isapipe(sys.stdout): # Hold a reference to the previous file object so it doesn't # get garbage collected and close the underlying descriptor. stdout = sys.stdout sys.stdout = os.fdopen(stdout.fileno(), 'w', 1) # Quiet printing of KeyboardInterrupt by greenlets Hub = gevent.hub.Hub Hub.NOT_ERROR = Hub.NOT_ERROR + (KeyboardInterrupt, ) config = os.environ.get('AGENT_CONFIG') identity = os.environ.get('AGENT_VIP_IDENTITY', identity) message_bus = os.environ.get('MESSAGEBUS', 'zmq') if identity is not None: if not is_valid_identity(identity): _log.warning('Deprecation warining') _log.warning( 'All characters in {identity} are not in the valid set.'. format(idenity=identity)) address = get_address() agent_uuid = os.environ.get('AGENT_UUID') volttron_home = get_home() from volttron.platform.certs import Certs certs = Certs() agent = agent_class(config_path=config, identity=identity, address=address, agent_uuid=agent_uuid, volttron_home=volttron_home, version=version, message_bus=message_bus, **kwargs) try: run = agent.run except AttributeError: run = agent.core.run task = gevent.spawn(run) try: task.join() finally: task.kill() except KeyboardInterrupt: pass
def install_configs(input_directory, keep=False): os.chdir(input_directory) keystore = KeyStore() agent = Agent(address=get_address(), identity="master_driver_update_agent", publickey=keystore.public, secretkey=keystore.secret, enable_store=False) event = gevent.event.Event() gevent.spawn(agent.core.run, event) event.wait() if not keep: print "Deleting old Master Driver store" agent.vip.rpc.call('config.store', 'manage_delete_store', 'platform.driver').get(timeout=10) with open("config") as f: print "Storing main configuration" agent.vip.rpc.call('config.store', 'manage_store', 'platform.driver', 'config', f.read(), config_type="json").get(timeout=10) for name in glob.iglob("registry_configs/*"): with open(name) as f: print "Storing configuration:", name agent.vip.rpc.call('config.store', 'manage_store', 'platform.driver', name, f.read(), config_type="csv").get(timeout=10) for dir_path, _, files in os.walk("devices"): for file_name in files: name = os.path.join(dir_path, file_name) with open(name) as f: print "Storing configuration:", name agent.vip.rpc.call('config.store', 'manage_store', 'platform.driver', name, f.read(), config_type="json").get(timeout=10)
def install_configs(input_directory, keep=False): os.chdir(input_directory) keystore = KeyStore() agent = Agent(address=get_address(), identity="master_driver_update_agent", publickey=keystore.public, secretkey=keystore.secret, enable_store=False) event = gevent.event.Event() gevent.spawn(agent.core.run, event) event.wait() if not keep: print("Deleting old Master Driver store") agent.vip.rpc.call(CONFIGURATION_STORE, 'manage_delete_store', PLATFORM_DRIVER).get(timeout=10) with open("config") as f: print("Storing main configuration") agent.vip.rpc.call(CONFIGURATION_STORE, 'manage_store', PLATFORM_DRIVER, 'config', f.read(), config_type="json").get(timeout=10) for name in glob.iglob("registry_configs/*"): with open(name) as f: print("Storing configuration:", name) agent.vip.rpc.call(CONFIGURATION_STORE, 'manage_store', PLATFORM_DRIVER, name, f.read(), config_type="csv").get(timeout=10) for dir_path, _, files in os.walk("devices"): for file_name in files: name = os.path.join(dir_path, file_name) with open(name) as f: print("Storing configuration:", name) agent.vip.rpc.call(CONFIGURATION_STORE, 'manage_store', PLATFORM_DRIVER, name, f.read(), config_type="json").get(timeout=10)
def main(): # parse the command line arguments arg_parser = argparse.ArgumentParser(description=__doc__) arg_parser.add_argument("--address", help="Target only device(s) at <address> for request") arg_parser.add_argument("--range", type=int, nargs=2, metavar=('LOW', 'HIGH'), help="Lower and upper limit on device ID in results") arg_parser.add_argument("--timeout", type=int, metavar=('SECONDS'), help="Time, in seconds, to wait for responses. Default: %(default)s", default=5) arg_parser.add_argument("--proxy-id", help="VIP IDENTITY of the BACnet proxy agent.", default="platform.bacnet_proxy") args = arg_parser.parse_args() _log.debug("initialization") _log.debug(" - args: %r", args) keystore = KeyStore() agent = BACnetInteraction(args.proxy_id, address=get_address(), volttron_home=get_home(), publickey=keystore.public, secretkey=keystore.secret, enable_store=False) event = gevent.event.Event() gevent.spawn(agent.core.run, event) event.wait() kwargs = {'address': args.address} if args.range is not None: kwargs['low_device_id'] = int(args.range[0]) kwargs['high_device_id'] = int(args.range[1]) try: agent.send_iam(**kwargs) except errors.Unreachable: _log.error("There is no BACnet proxy Agent running on the platform with the VIP IDENTITY {}".format(args.proxy_id)) else: gevent.sleep(args.timeout)
def build_connection(identity, peer='', address=None, publickey=None, secretkey=None, message_bus=None, **kwargs): address = address if address is not None else get_address() if publickey is None or secretkey is None: publickey, secretkey = get_server_keys(publickey, secretkey) cn = Connection(address=address, identity=identity, peer=peer, publickey=publickey, secretkey=secretkey, message_bus=message_bus, **kwargs) return cn
def vip_main(agent_class, identity=None, version='0.1', **kwargs): """Default main entry point implementation for VIP agents.""" try: # If stdout is a pipe, re-open it line buffered if isapipe(sys.stdout): # Hold a reference to the previous file object so it doesn't # get garbage collected and close the underlying descriptor. stdout = sys.stdout sys.stdout = os.fdopen(stdout.fileno(), 'w', 1) # Quiet printing of KeyboardInterrupt by greenlets Hub = gevent.hub.Hub Hub.NOT_ERROR = Hub.NOT_ERROR + (KeyboardInterrupt,) config = os.environ.get('AGENT_CONFIG') identity = os.environ.get('AGENT_VIP_IDENTITY', identity) if identity is not None: if not is_valid_identity(identity): _log.warn('Deprecation warining') _log.warn( 'All characters in {identity} are not in the valid set.' .format(idenity=identity)) address = get_address() agent_uuid = os.environ.get('AGENT_UUID') volttron_home = get_home() agent = agent_class(config_path=config, identity=identity, address=address, agent_uuid=agent_uuid, volttron_home=volttron_home, version=version, **kwargs) try: run = agent.run except AttributeError: run = agent.core.run task = gevent.spawn(run) try: task.join() finally: task.kill() except KeyboardInterrupt: pass
def vip_main(agent_class, identity=None, **kwargs): """Default main entry point implementation for VIP agents.""" try: # If stdout is a pipe, re-open it line buffered if isapipe(sys.stdout): # Hold a reference to the previous file object so it doesn't # get garbage collected and close the underlying descriptor. stdout = sys.stdout sys.stdout = os.fdopen(stdout.fileno(), 'w', 1) # Quiet printing of KeyboardInterrupt by greenlets Hub = gevent.hub.Hub Hub.NOT_ERROR = Hub.NOT_ERROR + (KeyboardInterrupt, ) config = os.environ.get('AGENT_CONFIG') identity = os.environ.get('AGENT_VIP_IDENTITY', identity) address = get_address() agent_uuid = os.environ.get('AGENT_UUID') volttron_home = get_home() agent = agent_class(config_path=config, identity=identity, address=address, agent_uuid=agent_uuid, volttron_home=volttron_home, **kwargs) try: run = agent.run except AttributeError: run = agent.core.run task = gevent.spawn(run) try: task.join() finally: task.kill() except KeyboardInterrupt: pass
def main(): global agent # parse the command line arguments arg_parser = argparse.ArgumentParser(description=__doc__) arg_parser.add_argument("device_id", type=int, help="Device ID of the target device" ) arg_parser.add_argument("--address", help="Address of target device, may be needed to help route initial request to device." ) arg_parser.add_argument("--registry-out-file", type=argparse.FileType('wb'), help="Output registry to CSV file", default=sys.stdout ) arg_parser.add_argument("--driver-out-file", type=argparse.FileType('wb'), help="Output driver configuration to JSON file.", default=sys.stdout) arg_parser.add_argument("--max-range-report", nargs='?', type=float, help='Affects how very large numbers are reported in the "Unit Details" column of the output. ' 'Does not affect driver behavior.', default=1.0e+20 ) arg_parser.add_argument("--proxy-id", help="VIP IDENTITY of the BACnet proxy agent.", default="platform.bacnet_proxy") args = arg_parser.parse_args() _log.debug("initialization") _log.debug(" - args: %r", args) key_store = KeyStore() agent = BACnetInteraction(args.proxy_id, address=get_address(), volttron_home=get_home(), publickey=key_store.public, secretkey=key_store.secret, enable_store=False) event = gevent.event.Event() gevent.spawn(agent.core.run, event) event.wait() async_result = AsyncResult() try: agent.get_iam(args.device_id, async_result.set, args.address) except errors.Unreachable: _log.error("There is no BACnet proxy Agent running on the platform with the VIP IDENTITY {}".format(args.proxy_id)) sys.exit(1) try: results = async_result.get(timeout=5.0) except gevent.Timeout: _log.error("No response from device id {}".format(args.device_id)) sys.exit(1) target_address = results["address"] device_id = results["device_id"] config_file_name = basename(args.registry_out_file.name) config = { "driver_config": {"device_address": str(target_address), "device_id": device_id}, "driver_type": "bacnet", "registry_config": "config://registry_configs/{}".format(config_file_name) } json.dump(config, args.driver_out_file, indent=4) _log.debug('pduSource = ' + target_address) _log.debug('iAmDeviceIdentifier = ' + str(device_id)) _log.debug('maxAPDULengthAccepted = ' + str(results["max_apdu_length"])) _log.debug('segmentationSupported = ' + results["segmentation_supported"]) _log.debug('vendorID = ' + str(results["vendor_id"])) try: device_name = read_prop(target_address, "device", device_id, "objectName") _log.debug('device_name = ' + str(device_name)) except TypeError: _log.debug('device missing objectName') try: device_description = read_prop(target_address, "device", device_id, "description") _log.debug('description = ' + str(device_description)) except TypeError: _log.debug('device missing description') config_writer = DictWriter(args.registry_out_file, ('Reference Point Name', 'Volttron Point Name', 'Units', 'Unit Details', 'BACnet Object Type', 'Property', 'Writable', 'Index', 'Write Priority', 'Notes')) config_writer.writeheader() try: object_count = read_prop(target_address, "device", device_id, "objectList", index=0) list_property = "objectList" except TypeError: object_count = read_prop(target_address, "device", device_id, "structuredObjectList", index=0) list_property = "structuredObjectList" _log.debug('object_count = ' + str(object_count)) for object_index in xrange(1,object_count+1): _log.debug('object_device_index = ' + repr(object_index)) bac_object = read_prop(target_address, "device", device_id, list_property, index=object_index) obj_type, index = bac_object process_object(target_address, obj_type, index, args.max_range_report, config_writer)
import os import sys import gevent from volttron.platform import get_address from volttron.platform.agent.known_identities import VOLTTRON_CENTRAL_PLATFORM from volttron.platform.keystore import KeyStore from volttron.platform.messaging import topics from volttron.platform.vip.agent import Agent keystore = KeyStore() agent = Agent(address=get_address(), identity="blahagent", publickey=keystore.public(), secretkey=keystore.secret(), enable_store=False) event = gevent.event.Event() config_store_task = gevent.spawn(agent.core.run, event) event.wait() del event if VOLTTRON_CENTRAL_PLATFORM not in agent.vip.peerlist().get(): agent.core.stop() print('no vcp availablel') sys.exit() def receive_platform_data(peer, sender, bus, topic, headers, message): #assert 'message' in kwargs
def main(): global agent global config_writer # parse the command line arguments arg_parser = argparse.ArgumentParser(description=__doc__) arg_parser.add_argument("device_id", type=int, help="Device ID of the target device" ) arg_parser.add_argument("--address", help="Address of target device, may be needed to help route initial request to device." ) arg_parser.add_argument("--registry-out-file", type=argparse.FileType('wb'), help="Output registry to CSV file", default=sys.stdout ) arg_parser.add_argument("--driver-out-file", type=argparse.FileType('wb'), help="Output driver configuration to JSON file.", default=sys.stdout) arg_parser.add_argument("--max-range-report", nargs='?', type=float, help='Affects how very large numbers are reported in the "Unit Details" column of the output. ' 'Does not affect driver behavior.', default=1.0e+20 ) arg_parser.add_argument("--proxy-id", help="VIP IDENTITY of the BACnet proxy agent.", default="platform.bacnet_proxy") args = arg_parser.parse_args() _log.debug("initialization") _log.debug(" - args: %r", args) key_store = KeyStore() config_writer = DictWriter(args.registry_out_file, ('Reference Point Name', 'Volttron Point Name', 'Units', 'Unit Details', 'BACnet Object Type', 'Property', 'Writable', 'Index', 'Write Priority', 'Notes')) config_writer.writeheader() agent = build_agent(address=get_address(), volttron_home=get_home(), publickey=key_store.public, secretkey=key_store.secret, enable_store=False) bn = BACnetReader(agent.vip, args.proxy_id, bacnet_response) async_result = AsyncResult() try: bn.get_iam(args.device_id, async_result.set, args.address) except errors.Unreachable: msg = "No BACnet proxy Agent running on the platform with the " \ "VIP IDENTITY {}".format(args.proxy_id) sys.exit(1) try: results = async_result.get(timeout=5.0) except gevent.Timeout: _log.error("No response from device id {}".format(args.device_id)) sys.exit(1) if args.address and args.address != results["address"]: msg = "Inconsistent results from passed address " \ "({}) and device address ({}) using results.".format( args.address, results["address"]) _log.warning(msg) args.address = results["address"] elif results["address"]: args.address = results["address"] bn.read_device_properties(target_address=args.address, device_id=args.device_id) agent.core.stop()
def main(): global agent global config_writer # parse the command line arguments arg_parser = argparse.ArgumentParser(description=__doc__) arg_parser.add_argument("device_id", type=int, help="Device ID of the target device") arg_parser.add_argument( "--address", help= "Address of target device, may be needed to help route initial request to device." ) arg_parser.add_argument("--registry-out-file", type=argparse.FileType('w'), help="Output registry to CSV file", default=sys.stdout) arg_parser.add_argument("--driver-out-file", type=argparse.FileType('w'), help="Output driver configuration to JSON file.", default=sys.stdout) arg_parser.add_argument( "--max-range-report", nargs='?', type=float, help= 'Affects how very large numbers are reported in the "Unit Details" column of the ' 'output. Does not affect driver behavior.', default=1.0e+20) arg_parser.add_argument("--proxy-id", help="VIP IDENTITY of the BACnet proxy agent.", default="platform.bacnet_proxy") args = arg_parser.parse_args() _log.debug("initialization") _log.debug(" - args: %r", args) key_store = KeyStore() config_writer = DictWriter( args.registry_out_file, ('Reference Point Name', 'Volttron Point Name', 'Units', 'Unit Details', 'BACnet Object Type', 'Property', 'Writable', 'Index', 'Write Priority', 'Notes')) config_writer.writeheader() agent = build_agent(address=get_address(), volttron_home=get_home(), publickey=key_store.public, secretkey=key_store.secret, enable_store=False) bn = BACnetReader(agent.vip, args.proxy_id, bacnet_response) async_result = AsyncResult() try: bn.get_iam(args.device_id, async_result.set, args.address) except errors.Unreachable as ure: _log.error(ure) _log.error( "No BACnet proxy Agent running on the platform with the VIP IDENTITY {}" .format(args.proxy_id)) sys.exit(1) try: results = async_result.get(timeout=5.0) except gevent.Timeout: _log.error("No response from device id {}".format(args.device_id)) sys.exit(1) if args.address and args.address != results["address"]: msg = "Inconsistent results from passed address ({}) and device address ({}) using results.".format( args.address, results["address"]) _log.warning(msg) args.address = results["address"] elif results["address"]: args.address = results["address"] bn.read_device_properties(target_address=args.address, device_id=args.device_id) agent.core.stop()
keys = output_dict.keys() for k in range(keylen): if k < keylen - 1: keyline += "%s," % keys[k] valueline += "%s," % output_dict[keys[k]] else: keyline += "%s" % keys[k] valueline += "%s" % output_dict[keys[k]] sys.stdout.write("%s\n%s\n" % (keyline, valueline)) if __name__ == '__main__': parser = argparse.ArgumentParser(version=__version__) parser.add_argument("-a", "--vip-address", default=get_address(), help="vip-address to connect to.") parser.add_argument("-vh", "--volttron-home", default=get_home(), help="local volttron-home for the instance.") parser.add_argument("-vr", "--volttron-root", default=get_volttron_root(), help="location of the volttron root on the filesystem.") parser.add_argument("-s", "--agent-source", required=True, help="source directory of the agent which is to be installed.") parser.add_argument("-i", "--vip-identity", default=None, help="identity of the agent to be installed (unique per instance)") parser.add_argument("-c", "--config", default=None, type=file, help="agent configuration file that will be packaged with the agent.") parser.add_argument("-wh", "--wheelhouse", default=None, help="location of agents after they have been built") parser.add_argument("-t", "--tag", default=None, help="a tag is a means of identifying an agent.")
def main(): # parse the command line arguments arg_parser = argparse.ArgumentParser(description=__doc__) arg_parser.add_argument("--address", help="Target only device(s) at <address> for request") arg_parser.add_argument("--range", type=int, nargs=2, metavar=('LOW', 'HIGH'), help="Lower and upper limit on device ID in results") arg_parser.add_argument("--timeout", type=int, metavar=('SECONDS'), help="Time, in seconds, to wait for responses. Default: %(default)s", default=5) arg_parser.add_argument("--proxy-id", help="VIP IDENTITY of the BACnet proxy agent.", default="platform.bacnet_proxy") arg_parser.add_argument("--csv-out", dest="csv_out", help="Write results to the CSV file specified.") arg_parser.add_argument("--debug", action="store_true", help="Set the logger in debug mode") args = arg_parser.parse_args() core_logger = logging.getLogger("volttron.platform.vip.agent.core") core_logger.setLevel(logging.WARN) _log.setLevel(logging.WARN) if args.debug: _log.setLevel(logging.DEBUG) core_logger.setLevel(logging.DEBUG) _log.debug("initialization") _log.debug(" - args: %r", args) csv_writer = None if args.csv_out is not None: f = open(args.csv_out, "wb") field_names = ["address", "device_id", "max_apdu_length", "segmentation_supported", "vendor_id"] csv_writer = csv.DictWriter(f, field_names) csv_writer.writeheader() keystore = KeyStore() agent = BACnetInteraction(args.proxy_id, csv_writer=csv_writer, address=get_address(), volttron_home=get_home(), publickey=keystore.public, secretkey=keystore.secret, enable_store=False) event = gevent.event.Event() gevent.spawn(agent.core.run, event) event.wait() kwargs = {'address': args.address} if args.range is not None: kwargs['low_device_id'] = int(args.range[0]) kwargs['high_device_id'] = int(args.range[1]) try: agent.send_iam(**kwargs) except errors.Unreachable: _log.error("There is no BACnet proxy Agent running on the platform with the VIP IDENTITY {}".format(args.proxy_id)) else: gevent.sleep(args.timeout)
def main(): global agent # parse the command line arguments arg_parser = argparse.ArgumentParser(description=__doc__) arg_parser.add_argument("device_id", type=int, help="Device ID of the target device") arg_parser.add_argument( "--address", help= "Address of target device, may be needed to help route initial request to device." ) arg_parser.add_argument("--registry-out-file", type=argparse.FileType('wb'), help="Output registry to CSV file", default=sys.stdout) arg_parser.add_argument("--driver-out-file", type=argparse.FileType('wb'), help="Output driver configuration to JSON file.", default=sys.stdout) arg_parser.add_argument( "--max-range-report", nargs='?', type=float, help= 'Affects how very large numbers are reported in the "Unit Details" column of the output. ' 'Does not affect driver behavior.', default=1.0e+20) arg_parser.add_argument("--proxy-id", help="VIP IDENTITY of the BACnet proxy agent.", default="platform.bacnet_proxy") args = arg_parser.parse_args() _log.debug("initialization") _log.debug(" - args: %r", args) key_store = KeyStore() agent = BACnetInteraction(args.proxy_id, address=get_address(), volttron_home=get_home(), publickey=key_store.public, secretkey=key_store.secret, enable_store=False) event = gevent.event.Event() gevent.spawn(agent.core.run, event) event.wait() async_result = AsyncResult() try: agent.get_iam(args.device_id, async_result.set, args.address) except errors.Unreachable: _log.error( "There is no BACnet proxy Agent running on the platform with the VIP IDENTITY {}" .format(args.proxy_id)) sys.exit(1) try: results = async_result.get(timeout=5.0) except gevent.Timeout: _log.error("No response from device id {}".format(args.device_id)) sys.exit(1) target_address = results["address"] device_id = results["device_id"] config_file_name = basename(args.registry_out_file.name) config = { "driver_config": { "device_address": str(target_address), "device_id": device_id }, "driver_type": "bacnet", "registry_config": "config://registry_configs/{}".format(config_file_name) } json.dump(config, args.driver_out_file, indent=4) _log.debug('pduSource = ' + target_address) _log.debug('iAmDeviceIdentifier = ' + str(device_id)) _log.debug('maxAPDULengthAccepted = ' + str(results["max_apdu_length"])) _log.debug('segmentationSupported = ' + results["segmentation_supported"]) _log.debug('vendorID = ' + str(results["vendor_id"])) try: device_name = read_prop(target_address, "device", device_id, "objectName") _log.debug('device_name = ' + str(device_name)) except TypeError: _log.debug('device missing objectName') try: device_description = read_prop(target_address, "device", device_id, "description") _log.debug('description = ' + str(device_description)) except TypeError: _log.debug('device missing description') config_writer = DictWriter( args.registry_out_file, ('Reference Point Name', 'Volttron Point Name', 'Units', 'Unit Details', 'BACnet Object Type', 'Property', 'Writable', 'Index', 'Write Priority', 'Notes')) config_writer.writeheader() try: object_count = read_prop(target_address, "device", device_id, "objectList", index=0) list_property = "objectList" except TypeError: object_count = read_prop(target_address, "device", device_id, "structuredObjectList", index=0) list_property = "structuredObjectList" _log.debug('object_count = ' + str(object_count)) for object_index in xrange(1, object_count + 1): _log.debug('object_device_index = ' + repr(object_index)) bac_object = read_prop(target_address, "device", device_id, list_property, index=object_index) obj_type, index = bac_object process_object(target_address, obj_type, index, args.max_range_report, config_writer)
def main(): # parse the command line arguments arg_parser = argparse.ArgumentParser(description=__doc__) arg_parser.add_argument( "--address", help="Target only device(s) at <address> for request") arg_parser.add_argument( "--range", type=int, nargs=2, metavar=('LOW', 'HIGH'), help="Lower and upper limit on device ID in results") arg_parser.add_argument( "--timeout", type=int, metavar=('SECONDS'), help="Time, in seconds, to wait for responses. Default: %(default)s", default=5) arg_parser.add_argument("--proxy-id", help="VIP IDENTITY of the BACnet proxy agent.", default="platform.bacnet_proxy") arg_parser.add_argument("--csv-out", dest="csv_out", help="Write results to the CSV file specified.") arg_parser.add_argument("--debug", action="store_true", help="Set the logger in debug mode") args = arg_parser.parse_args() core_logger = logging.getLogger("volttron.platform.vip.agent.core") core_logger.setLevel(logging.WARN) _log.setLevel(logging.WARN) if args.debug: _log.setLevel(logging.DEBUG) core_logger.setLevel(logging.DEBUG) _log.debug("initialization") _log.debug(" - args: %r", args) csv_writer = None if args.csv_out is not None: f = open(args.csv_out, "wb") field_names = [ "address", "device_id", "max_apdu_length", "segmentation_supported", "vendor_id" ] csv_writer = csv.DictWriter(f, field_names) csv_writer.writeheader() keystore = KeyStore() agent = BACnetInteraction(args.proxy_id, csv_writer=csv_writer, address=get_address(), volttron_home=get_home(), publickey=keystore.public, secretkey=keystore.secret, enable_store=False) event = gevent.event.Event() gevent.spawn(agent.core.run, event) event.wait() kwargs = {'address': args.address} if args.range is not None: kwargs['low_device_id'] = int(args.range[0]) kwargs['high_device_id'] = int(args.range[1]) try: agent.send_iam(**kwargs) except errors.Unreachable: _log.error( "There is no BACnet proxy Agent running on the platform with the VIP IDENTITY {}" .format(args.proxy_id)) else: gevent.sleep(args.timeout)
if k < keylen - 1: keyline += "%s," % keys[k] valueline += "%s," % output_dict[keys[k]] else: keyline += "%s" % keys[k] valueline += "%s" % output_dict[keys[k]] sys.stdout.write("%s\n%s\n" % (keyline, valueline)) if __name__ == '__main__': parser = argparse.ArgumentParser(version=__version__) parser.add_argument("-a", "--vip-address", default=get_address(), help="vip-address to connect to.") parser.add_argument("-vh", "--volttron-home", default=get_home(), help="local volttron-home for the instance.") parser.add_argument( "-vr", "--volttron-root", default=get_volttron_root(), help="location of the volttron root on the filesystem.") parser.add_argument( "-s", "--agent-source", required=True, help="source directory of the agent which is to be installed.")