def protected_pubsub_fn(topic, capabilities, topic_regex=None, add_capabilities=False): """Returns dict that holds configuration for a protected-pubsub test.""" agent1, agent2, topic, msgs = build_two_agents_pubsub_agents(topic) topic_to_protect = topic_regex if topic_regex else topic topic_dict = { 'write-protect': [{ 'topic': topic_to_protect, 'capabilities': capabilities }] } topic_file = os.path.join(volttron_instance.volttron_home, 'protected_topics.json') with open(topic_file, 'w') as f: jsonapi.dump(topic_dict, f) gevent.sleep(.5) if add_capabilities: volttron_instance.add_capabilities(agent2.publickey, capabilities) gevent.sleep(.2) return { 'agent1': agent2, 'agent2': agent2, 'topic': topic, 'instance': volttron_instance, 'messages': msgs, 'capabilities': capabilities }
def update_ca_db(self, cert, ca_name, serial): """ Update the CA db with details of the file that the ca signed. :param cert: cert that was signed by ca_name :param ca_name: name of the ca that signed the cert """ db_file = self.ca_db_file(ca_name) ca_db = {} dn = "C={}/ST={}/L={}/O={}/OU={}/CN={}".format( _get_cert_attribute_value(cert, NameOID.COUNTRY_NAME), _get_cert_attribute_value(cert, NameOID.STATE_OR_PROVINCE_NAME), _get_cert_attribute_value(cert, NameOID.LOCALITY_NAME), _get_cert_attribute_value(cert, NameOID.ORGANIZATION_NAME), _get_cert_attribute_value(cert, NameOID.ORGANIZATIONAL_UNIT_NAME), _get_cert_attribute_value(cert, NameOID.COMMON_NAME)) if os.path.exists(db_file): with open(db_file, "r") as f: ca_db = jsonapi.load(f) entries = ca_db.get(dn, {}) entries['status'] = "valid" entries['expiry'] = cert.not_valid_after.strftime("%Y-%m-%d " "%H:%M:%S.%f%z") entries['serial_number'] = cert.serial_number ca_db[dn] = entries with open(db_file, 'w+') as outfile: jsonapi.dump(ca_db, outfile, indent=4) with open(self.ca_serial_file(ca_name), "w+") as f: f.write(str(serial+1)) # next available serial is current + 1
def _dump(fileobj, contents, format): if format == 'csv': csv.writer(fileobj).writerows(contents.items()) elif format == 'json': jsonapi.dump(contents, fileobj, separators=(',', ':')) elif format == 'pickle': pickle.dump(dict(contents), fileobj, 2) else: raise NotImplementedError('Unknown format: ' + repr(self.format))
def _write(self, entries, groups, roles): auth = { 'allow': [vars(x) for x in entries], 'groups': groups, 'roles': roles, 'version': self.version } with open(self.auth_file, 'w') as fp: jsonapi.dump(auth, fp, indent=2)
def get_n_volttron_instances(n, should_start=True, address_file=True): get_n_volttron_instances.count = n instances = [] vip_addresses = [] web_addresses = [] instances = [] addr_config = dict() names = [] for i in range(0, n): address = get_rand_vip() web_address = "http://{}".format(get_rand_ip_and_port()) vip_addresses.append(address) web_addresses.append(web_address) nm = 'platform{}'.format(i + 1) names.append(nm) for i in range(0, n): address = vip_addresses[i] web_address = web_addresses[i] wrapper = PlatformWrapper(messagebus='zmq', ssl_auth=False) addr_file = os.path.join(wrapper.volttron_home, 'external_address.json') if address_file: with open(addr_file, 'w') as f: jsonapi.dump(web_addresses, f) gevent.sleep(.1) wrapper.startup_platform(address, bind_web_address=web_address, setupmode=True) wrapper.skip_cleanup = True instances.append(wrapper) gevent.sleep(30) for i in range(0, n): instances[i].shutdown_platform() gevent.sleep(5) # del instances[:] for i in range(0, n): address = vip_addresses.pop(0) web_address = web_addresses.pop(0) print(address, web_address) instances[i].startup_platform(address, bind_web_address=web_address) instances[i].allow_all_connections() gevent.sleep(20) instances = instances if n > 1 else instances[0] get_n_volttron_instances.instances = instances return instances
def auth_instance(volttron_instance): with open(os.path.join(volttron_instance.volttron_home, "auth.json"), 'r') as f: auth_file = jsonapi.load(f) print(auth_file) try: yield volttron_instance finally: with with_os_environ(volttron_instance.env): with open( os.path.join(volttron_instance.volttron_home, "auth.json"), 'w') as f: jsonapi.dump(auth_file, f)
def build_n_volttron_instances(n, bad_config=False, add_my_address=True): build_n_volttron_instances.count = n instances = [] vip_addresses = [] instances = [] addr_config = dict() for i in range(0, n): address = get_rand_vip() vip_addresses.append(address) for i in range(0, n): address = vip_addresses[i] wrapper = PlatformWrapper(messagebus='zmq', ssl_auth=False) wrapper.startup_platform(address) wrapper.skip_cleanup = True instances.append(wrapper) gevent.sleep(1) for i in range(0, n): instances[i].shutdown_platform() for i in range(0, n): addr_config.clear() for j in range(0, n): if j != i or (j == i and add_my_address): name = instances[j].instance_name addr_config[name] = dict() addr_config[name]['instance-name'] = name if bad_config: addr_config[name]['vip-address123'] = vip_addresses[j] else: addr_config[name]['vip-address'] = vip_addresses[j] addr_config[name]['serverkey'] = instances[j].serverkey address_file = os.path.join(instances[i].volttron_home, 'external_platform_discovery.json') if address_file: with open(address_file, 'w') as f: jsonapi.dump(addr_config, f) gevent.sleep(1) for i in range(0, n): address = vip_addresses.pop(0) instances[i].startup_platform(address) instances[i].allow_all_connections() gevent.sleep(11) instances = instances if n > 1 else instances[0] build_n_volttron_instances.instances = instances return instances
def prep_config(volttron_home): src_driver = os.getcwd( ) + '/services/core/MasterDriverAgent/example_configurations/test_fakedriver.config' new_driver = volttron_home + '/test_fakedriver.config' shutil.copy(src_driver, new_driver) with open(new_driver, 'r+') as f: config = jsonapi.load(f) config['registry_config'] = os.getcwd( ) + '/services/core/MasterDriverAgent/example_configurations/fake.csv' f.seek(0) f.truncate() jsonapi.dump(config, f) master_config = { "agentid": "master_driver", "driver_config_list": [new_driver] } return master_config
notes.append("Min: " + str(min_value)) if max_value: notes.append("Max: " + str(max_value)) notes = ", ".join(notes) result["Notes"] = notes return result for e in elements: row = get_csv_row(e) csv_file.writerow(row) config = { "driver_config": {"url": url, "username": username, "password": password}, "driver_type": "obix", "registry_config":"config://obix.csv", "interval": 60, "timezone": "UTC" } jsonapi.dump(config, args.devicefile, indent=4)
def main(): # parse the command line arguments arg_parser = ConfigArgumentParser(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) args = arg_parser.parse_args() _log.debug("initialization") _log.debug(" - args: %r", args) # make a device object this_device = LocalDeviceObject( objectName=args.ini.objectname, objectIdentifier=int(args.ini.objectidentifier), maxApduLengthAccepted=int(args.ini.maxapdulengthaccepted), segmentationSupported=args.ini.segmentationsupported, vendorIdentifier=int(args.ini.vendoridentifier), ) # make a simple application this_application = SynchronousApplication(this_device, args.ini.address) _log.debug("starting build") result = get_iam(this_application, args.device_id, args.address) target_address = result.pduSource device_id = result.iAmDeviceIdentifier[1] _log.debug('pduSource = ' + repr(result.pduSource)) _log.debug('iAmDeviceIdentifier = ' + str(result.iAmDeviceIdentifier)) _log.debug('maxAPDULengthAccepted = ' + str(result.maxAPDULengthAccepted)) _log.debug('segmentationSupported = ' + str(result.segmentationSupported)) _log.debug('vendorID = ' + str(result.vendorID)) 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) } jsonapi.dump(config, args.driver_out_file, indent=4) try: device_name = read_prop(this_application, 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(this_application, 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(this_application, target_address, "device", device_id, "objectList", index=0) list_property = "objectList" except TypeError: object_count = read_prop(this_application, target_address, "device", device_id, "structuredObjectList", index=0) list_property = "structuredObjectList" _log.debug('objectCount = ' + str(object_count)) for object_index in range(1, object_count + 1): _log.debug('object_device_index = ' + repr(object_index)) bac_object = read_prop(this_application, target_address, "device", device_id, list_property, index=object_index) obj_type, index = bac_object try: process_object(this_application, target_address, obj_type, index, args.max_range_report, config_writer) except Exception: _log.debug("Unexpected error processing object: {} {}".format(obj_type, index)) _log.debug(traceback.format_exc())
def do_add_driver_config(self, line): """ Add/Edit the driver config <config_dir>/<driver name>.config for selected driver Example format: { "driver_config": {"name": "watts_on_1", "device_type": "watts_on", "device_address": "/dev/tty.usbserial-AL00IEEY", "port": 0, "slave_id": 2, "baudrate": 115200, "bytesize": 8, "parity": "none", "stopbits": 1, "xonxoff": 0, "addressing": "offset", "endian": "big", "write_multiple_registers": True, "register_map": "config://watts_on_map.csv"}, "driver_type": "modbus_tk", "registry_config": "config://watts_on.csv", "interval": 120, "timezone": "UTC" } If any config info does not match existed options, it'll set to its default value Option to select driver if no selected driver found Press <Enter> to exit Add a specific driver config: add_driver_config <name> <name>: name of a new driver config to add to config_dir Select name after the cmd: add_driver_config """ # Select device type device_type = dict() device_type_name = line if not device_type_name: self.get_device_type_descriptions() print('\nEnter device type name: ', end='') device_type_name = input().lower() for device in self._device_type_maps: if device.get('name', None) == device_type_name: device_type = device # If device type exist, add driver config if device_type: print("Enter driver name: ", end='') name = input().lower() config_dir = self.get_existed_directory( self._directories['config_dir'], 'config_dir') if config_dir: cont = True while cont: cont = False for f in os.listdir(config_dir): if f.endswith('.config') and f.split('.')[0] == name: self.do_driver_config(name) print( "Driver '{0}' already existed. Continue to edit the driver [y/n]: " .format(name), end='') option = input().lower() if not option or not str2bool(option): print( "Please choose a different driver name OR press <Enter> to quit: ", end='') name = input().lower() if not name: self.do_quit('') cont = True print('Enter interval (default to 60 seconds): ', end='') try: interval = int(input()) except ValueError: interval = 60 print('Enter device address: ', end='') device_address = input().lower() print('Enter port (default to 5020 - 0 for no port): ', end='') try: port = int(input()) except ValueError: port = 5020 print('Enter description: ', end='') description = input() addressing = device_type.get('addressing', 'offset') endian = device_type.get('endian', 'big') print( "Default endian for the selected device type '{0}' is '{1}'. Do you want to change it [y/n]: " .format(device_type_name, endian), end='') option = input().lower() if option and str2bool(option): print('Enter new endian. Press <Enter> if no change needed: ', end='') new_endian = input().lower() if new_endian in ('big', 'little', 'mixed'): endian = new_endian write_multiple_registers = str2bool( str(device_type.get('write_multiple_registers', 'True'))) csv_map = self.get_existed_file(self._directories['csv_dir'], device_type.get('file')) print('Enter CSV config file: ', end='') csv_config = input() csv_config = csv_config if csv_config.endswith( '.csv') else "{0}.csv".format(csv_config) csv_config = self.get_existed_file(self._directories['csv_dir'], csv_config) driver_config = { "driver_config": { "name": name, "device_type": device_type_name, "device_address": device_address, "port": port, "addressing": addressing, "endian": endian, "write_multiple_registers": write_multiple_registers, "register_map": "config://" + csv_map, "description": description }, "driver_type": "modbus_tk", "registry_config": "config://" + csv_config, "interval": interval, "timezone": "UTC" } # RTU transport if not port: print('Enter slave id (default to 1): ', end='') try: slave_id = int(input()) except ValueError: slave_id = 1 print('Enter baudrate (default to 9600): ', end='') try: baudrate = int(input()) except ValueError: baudrate = 9600 print('Enter bytesize (default to 8): ', end='') try: bytesize = int(input()) except ValueError: bytesize = 8 print('Enter bytesize (default to none): ', end='') parity = input() if parity not in ('none', 'even', 'odd', 'mark', 'space'): parity = 'none' print('Enter stopbits (default to 1): ', end='') try: stopbits = int(input()) except ValueError: stopbits = 1 print('Enter xonxoff (default to 0): ', end='') try: xonxoff = int(input()) except ValueError: xonxoff = 0 driver_config['driver_config'].update({ "slave_id": slave_id, "baudrate": baudrate, "bytesize": bytesize, "parity": parity, "stopbits": stopbits, "xonxoff": xonxoff }) with open( "{0}/{1}.config".format(self._directories['config_dir'], name), 'w') as config_file: jsonapi.dump(driver_config, config_file, indent=2) else: print("Device type '{0}' does not exist".format(device_type_name))
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) config_file_name = basename(args.registry_out_file.name) config = { "driver_config": { "device_address": str(args.address), "device_id": args.device_id }, "driver_type": "bacnet", "registry_config": "config://registry_configs/{}".format(config_file_name) } jsonapi.dump(config, args.driver_out_file, indent=4) 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()