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 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 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 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)
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
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.")
