def _append_allow_curve_key(self, publickey): entry = AuthEntry(credentials=publickey) authfile = AuthFile(self.volttron_home + "/auth.json") try: authfile.add(entry) except AuthFileEntryAlreadyExists: pass
def _allow(self, environ, start_response, data=None): _log.info('Allowing new vc instance to connect to server.') jsondata = jsonapi.loads(data) json_validate_request(jsondata) assert jsondata.get('method') == 'allowvc' assert jsondata.get('params') params = jsondata.get('params') if isinstance(params, list): vcpublickey = params[0] else: vcpublickey = params.get('vcpublickey') assert vcpublickey assert len(vcpublickey) == 43 authfile = AuthFile() authentry = AuthEntry(credentials=vcpublickey) try: authfile.add(authentry) except AuthFileEntryAlreadyExists: pass start_response('200 OK', [('Content-Type', 'application/json')]) return jsonapi.dumps(json_result(jsondata['id'], "Added"))
def build_connection(self, peer=None, address=None, identity=None, publickey=None, secretkey=None, serverkey=None, capabilities=[], **kwargs): self.logit('Building connection to {}'.format(peer)) self.allow_all_connections() if address is None: self.logit( 'Default address was None so setting to current instances') address = self.vip_address serverkey = self.serverkey if serverkey is None: self.logit("serverkey wasn't set but the address was.") raise Exception("Invalid state.") if publickey is None or secretkey is None: self.logit('generating new public secret key pair') keyfile = tempfile.mktemp(".keys", "agent", self.volttron_home) keys = KeyStore(keyfile) keys.generate() publickey = keys.public secretkey = keys.secret entry = AuthEntry(capabilities=capabilities, comments="Added by test", credentials=keys.public) file = AuthFile(self.volttron_home + "/auth.json") file.add(entry) conn = Connection(address=address, peer=peer, publickey=publickey, secretkey=secretkey, serverkey=serverkey, volttron_home=self.volttron_home) return conn
def forwarder(request, volttron_instances): #print "Fixture forwarder" global volttron_instance1, volttron_instance2 global forwarder_uuid, forwarder_config # 1. Update destination address in forwarder configuration if volttron_instance1.encrypt: tf = tempfile.NamedTemporaryFile() ks = KeyStore(tf.name) # generate public private key pair for instance1 ks.generate() # add public key of instance1 to instance2 auth file authfile = AuthFile(volttron_instance2.volttron_home + "/auth.json") entry = AuthEntry(credentials=ks.public) authfile.add(entry) # setup destination address to include keys forwarder_config["destination-vip"] =\ "{}?serverkey={}&publickey={}&secretkey={}".format( volttron_instance2.vip_address, volttron_instance2.serverkey, ks.public, ks.secret) else: forwarder_config["destination-vip"] = volttron_instance2.vip_address # 1: Install historian agent # Install and start sqlhistorian agent in instance2 forwarder_uuid = volttron_instance1.install_agent( agent_dir="services/core/ForwardHistorian", config_file=forwarder_config, start=True) print("forwarder agent id: ", forwarder_uuid)
def forwarder(request, volttron_instances): #print "Fixture forwarder" global volttron_instance1, volttron_instance2 global forwarder_uuid, forwarder_config # 1. Update destination address in forwarder configuration if volttron_instance1.encrypt: tf = tempfile.NamedTemporaryFile() ks = KeyStore(tf.name) # generate public private key pair for instance1 ks.generate() # add public key of instance1 to instance2 auth file authfile = AuthFile(volttron_instance2.volttron_home + "/auth.json") entry = AuthEntry(credentials=ks.public()) authfile.add(entry) # setup destination address to include keys forwarder_config["destination-vip"] =\ "{}?serverkey={}&publickey={}&secretkey={}".format( volttron_instance2.vip_address, volttron_instance2.serverkey, ks.public(), ks.secret()) else: forwarder_config["destination-vip"] = volttron_instance2.vip_address # 1: Install historian agent # Install and start sqlhistorian agent in instance2 forwarder_uuid = volttron_instance1.install_agent( agent_dir="services/core/ForwardHistorian", config_file=forwarder_config, start=True) print("forwarder agent id: ", forwarder_uuid)
def allow_all_connections(self): """ Add a /.*/ entry to the auth.json file. """ entry = AuthEntry(credentials="/.*/") authfile = AuthFile(self.volttron_home + "/auth.json") try: authfile.add(entry) except AuthFileEntryAlreadyExists: pass
def manage(self, address, vcserverkey=None, vcpublickey=None): """ Allows the `VolttronCentralPlatform` to be managed. From the web perspective this should be after the user has specified that a user has blessed an agent to be able to be managed. When the user enters a discovery address in `VolttronCentral` it is implied that the user wants to manage a platform. :returns publickey of the `VolttronCentralPlatform` """ _log.info('Manage request from address: {} serverkey: {}'.format( address, vcserverkey)) self._was_unmanaged = False parsed = urlparse.urlparse(address) same_address = False if parsed.scheme == 'ipc': if self._volttron_central_ipc_address == address: same_address = True self._volttron_central_ipc_address = address elif parsed.scheme == 'tcp': _log.debug('Found tcp scheme adding AuthEntry') if self._volttron_central_tcp_address == address: same_address = True self._volttron_central_tcp_address = address self._volttron_central_serverkey = vcserverkey # Add the vcpublickey to the auth file. entry = AuthEntry( credentials=vcpublickey, capabilities=['manager']) # , address=parsedaddress.hostname) authfile = AuthFile() authfile.add(entry) else: raise AttributeError('Invalid scheme in address') if self._vc_connection() is not None: self._is_registered = True self._is_registering = False _log.debug("Returning publickey from manage function.") return self.core.publickey raise NotManagedError( "Could not connect to specified volttron central")
def _enable_setup_mode(self, session_user, params): id = params.pop('message_id') if 'admin' not in session_user['groups']: _log.debug('Returning json_error enable_setup_mode') return jsonrpc.json_error( id, UNAUTHORIZED, "Admin access is required to enable setup mode") auth_file = AuthFile() entries = auth_file.find_by_credentials(".*") if len(entries) > 0: return "SUCCESS" entry = AuthEntry(credentials="/.*/", comments="Un-Authenticated connections allowed here", user_id="unknown") auth_file.add(entry) return "SUCCESS"
def manage(self, address, vcserverkey, vcpublickey): """ Allows the `VolttronCentralPlatform` to be managed. From the web perspective this should be after the user has specified that a user has blessed an agent to be able to be managed. When the user enters a discovery address in `VolttronCentral` it is implied that the user wants to manage a platform. :returns publickey of the `VolttronCentralPlatform` """ _log.info('Manage request from address: {} serverkey: {}'.format( address, vcserverkey)) if self._managed: raise AlreadyManagedError() parsedaddress = urlparse.urlparse(address) if 'ipc://' == address[:6].lower(): self._agent_connected_to_vc = self else: # Attempt to connect to the passed address and serverkey. self._agent_connected_to_vc = build_agent( address=address, serverkey=vcserverkey, publickey=self.core.publickey, secretkey=self.core.secretkey) version, peer, identity = self._agent_connected_to_vc.vip.hello().get( timeout=30) if not self == self._agent_connected_to_vc: # Add the vcpublickey to the auth file. entry = AuthEntry( credentials="CURVE:{}".format(vcpublickey), capabilities=['manager']) # , address=parsedaddress.hostname) authfile = AuthFile() authfile.add(entry) self._managed = True self.core.spawn_later(2, self._publish_agent_list_to_vc) self.core.spawn_later(2, self._publish_stats) return self.core.publickey
def test_forwarding(volttron_instance1_encrypt, volttron_instance2_encrypt): global FORWARDER_CONFIG tf = tempfile.NamedTemporaryFile() tf2 = tempfile.NamedTemporaryFile() tf3 = tempfile.NamedTemporaryFile() ks = KeyStore(tf.name) ks.generate() ks2 = KeyStore(tf2.name) ks2.generate() ks3 = KeyStore(tf2.name) ks3.generate() wrap1 = volttron_instance1_encrypt wrap2 = volttron_instance2_encrypt authfile1 = AuthFile(wrap1.volttron_home+"/auth.json") entry1 = AuthEntry( credentials="CURVE:{}".format(ks3.public()) ) authfile1.add(entry1) authfile = AuthFile(wrap2.volttron_home+"/auth.json") entry = AuthEntry( credentials="CURVE:{}".format(ks.public())) authfile.add(entry) entry = AuthEntry( credentials="CURVE:{}".format(ks2.public())) authfile.add(entry) forward_to_vip = "{}?serverkey={}&publickey={}&secretkey={}".format( wrap2.vip_address, wrap2.publickey, ks.public(), ks.secret() ) FORWARDER_CONFIG["destination-vip"] = forward_to_vip forwarder_config = FORWARDER_CONFIG print("THE CONFIG = {}".format(forwarder_config)) wrap1.install_agent( agent_dir="services/core/ForwardHistorian", config_file=forwarder_config ) connect_to_wrap2 = "{}?serverkey={}&publickey={}&secretkey={}".format( wrap2.vip_address, wrap2.publickey, ks2.public(), ks2.secret() ) connect_to_wrap1 = "{}?serverkey={}&publickey={}&secretkey={}".format( wrap1.vip_address, wrap1.publickey, ks3.public(), ks3.secret() ) agent_connected1 = wrap1.build_agent(address=connect_to_wrap1) agent_connected2 = wrap2.build_agent(address=connect_to_wrap2) message = '' agent_connected2.vip.pubsub.subscribe('pubsub', '', callback=onmessage) gevent.sleep(0.2) do_publish(agent1=agent_connected1) gevent.sleep(1) assert allforwardedmessage
def test_forwarding(volttron_instance1_encrypt, volttron_instance2_encrypt): global FORWARDER_CONFIG tf = tempfile.NamedTemporaryFile() tf2 = tempfile.NamedTemporaryFile() tf3 = tempfile.NamedTemporaryFile() ks = KeyStore(tf.name) ks.generate() ks2 = KeyStore(tf2.name) ks2.generate() ks3 = KeyStore(tf2.name) ks3.generate() wrap1 = volttron_instance1_encrypt wrap2 = volttron_instance2_encrypt authfile1 = AuthFile(wrap1.volttron_home + "/auth.json") entry1 = AuthEntry(credentials="CURVE:{}".format(ks3.public())) authfile1.add(entry1) authfile = AuthFile(wrap2.volttron_home + "/auth.json") entry = AuthEntry(credentials="CURVE:{}".format(ks.public())) authfile.add(entry) entry = AuthEntry(credentials="CURVE:{}".format(ks2.public())) authfile.add(entry) forward_to_vip = "{}?serverkey={}&publickey={}&secretkey={}".format( wrap2.vip_address, wrap2.publickey, ks.public(), ks.secret()) FORWARDER_CONFIG["destination-vip"] = forward_to_vip forwarder_config = FORWARDER_CONFIG print("THE CONFIG = {}".format(forwarder_config)) wrap1.install_agent(agent_dir="services/core/ForwardHistorian", config_file=forwarder_config) connect_to_wrap2 = "{}?serverkey={}&publickey={}&secretkey={}".format( wrap2.vip_address, wrap2.publickey, ks2.public(), ks2.secret()) connect_to_wrap1 = "{}?serverkey={}&publickey={}&secretkey={}".format( wrap1.vip_address, wrap1.publickey, ks3.public(), ks3.secret()) agent_connected1 = wrap1.build_agent(address=connect_to_wrap1) agent_connected2 = wrap2.build_agent(address=connect_to_wrap2) message = '' agent_connected2.vip.pubsub.subscribe('pubsub', '', callback=onmessage) gevent.sleep(0.2) do_publish(agent1=agent_connected1) gevent.sleep(1) assert allforwardedmessage
def _periodic_attempt_registration(self): _log.debug("periodic attempt to register.") if self._scheduled_connection_event is not None: # This won't hurt anything if we are canceling ourselves. self._scheduled_connection_event.cancel() if not self.enable_registration: _log.debug('Registration of vcp is not enabled.') next_update_time = self._next_update_time() self._scheduled_connection_event = self.core.schedule( next_update_time, self._periodic_attempt_registration) return try: vc = self.get_vc_connection() if vc is None: _log.debug("vc not connected") return local_address = self.current_config.get( 'local_external_addresses')[0] if not vc.call("is_registered", address=local_address): _log.debug("platform agent is not registered.") self.registration_state = RegistrationStates.NotRegistered if self.registration_state == RegistrationStates.NotRegistered: vc_agent_publickey = vc.call("get_publickey") _log.debug( 'vc agent publickey is {}'.format(vc_agent_publickey)) assert vc_agent_publickey and len(vc_agent_publickey) == 43 authfile = AuthFile() # find_by_credentials returns a list. entries = authfile.find_by_credentials(vc_agent_publickey) if entries is not None and len(entries) > 0: entry = entries[0] if "manage" not in entry.capabilities: _log.debug("Updating vc capability.") entry.add_capabilities("manager") authfile.add(entry, overwrite=True) else: _log.debug('Adding vc publickey to auth') entry = AuthEntry(credentials=vc_agent_publickey, capabilities=['manager'], comments="Added by VCP", user_id="vc") authfile = AuthFile() authfile.add(entry) local_address = self.current_config.get( 'local_external_addresses')[0] local_name = self.current_config.get('local_instance_name', local_address) local_serverkey = self.current_config.get('local_serverkey') vc_address = self.current_config.get( 'volttron_central_address') _log.debug("Registering with vc from vcp.") _log.debug("Instance is named: {}".format(local_name)) _log.debug("Local Address is: {}".format(local_address)) _log.debug("VC Address is: {}".format(vc_address)) vc.call('register_instance', address=local_address, display_name=local_name, vcpserverkey=local_serverkey, vcpagentkey=self.core.publickey) else: _log.debug("Current platform registration state: {}".format( self.registration_state)) except Unreachable as e: _log.error("Couldn't connect to volttron.central. {}".format( self.current_config.get('volttron_central_address'))) except ValueError as e: _log.error(e.message) except Exception as e: _log.error("Error: {}".format(e.args)) except gevent.Timeout as e: _log.error("timout occured connecting to remote platform.") finally: _log.debug('Scheduling next periodic call') next_update_time = self._next_update_time() self._scheduled_connection_event = self.core.schedule( next_update_time, self._periodic_attempt_registration)
def add_to_auth(volttron_home, publickey, capabilities=None): authfile = AuthFile(os.path.join(volttron_home, 'auth.json')) entry = AuthEntry( credentials=publickey, mechanism="CURVE", capabilities=capabilities ) authfile.add(entry, overwrite=True)
VIRGINIA TECH – ADVANCED RESEARCH INSTITUTE under Contract DE-EE0006352 #__author__ = "BEMOSS Team" #__credits__ = "" #__version__ = "2.0" #__maintainer__ = "BEMOSS Team" #__email__ = "*****@*****.**" #__website__ = "www.bemoss.org" #__created__ = "2014-09-12 12:04:50" #__lastUpdated__ = "2016-03-14 11:23:33" ''' import os path = os.environ.get('VOLTTRON_HOME') from volttron.platform.auth import AuthEntry, AuthFile if __name__ == "__main__": print "Adding new Auth entry" auth_file = AuthFile(path + '/auth.json') entry = AuthEntry(credentials='NULL', comments='second', user_id="BEMOSSAGENT", capabilities=["BEMOSS_BASIC_AGENT"]) auth_file.add(entry) print "NEW AUTH IS ADDED BY BEMOSS" # p = Popen([ "volttron-ctl auth-update 0 ;"], stdin=PIPE, shell=True) # p.communicate("\n".join(["", "BEMOSSAGENT", "", "", "", "", "", "", "", "", ""])) # print "finished adding userid"
def _register_instance(self, discovery_address, display_name=None, provisional=False): """ Register an instance with VOLTTRON Central based on jsonrpc. NOTE: This method is meant to be called from the jsonrpc method. The registration of the instance will fail in the following cases: - no discoverable instance at the passed uri - no platform.agent installed at the discoverable instance - is a different volttron central managing the discoverable instance. If the display name is not set then the display name becomes the same as the discovery_address. This will be used in the volttron central ui. :param discovery_address: A ip:port for an instance of volttron discovery. :param display_name: :return: dictionary: The dictionary will hold either an error object or a result object. """ _log.info('Attempting to register name: {} with address: {}'.format( display_name, discovery_address)) try: discovery_response = DiscoveryInfo.request_discovery_info( discovery_address) except DiscoveryError as e: return {'error': {'code': DISCOVERY_ERROR, 'message': e.message}} pa_instance_serverkey = discovery_response.serverkey pa_vip_address = discovery_response.vip_address assert pa_instance_serverkey _log.debug('connecting to pa_instance') try: connected_to_pa = ConnectedPlatform( address=pa_vip_address, serverkey=pa_instance_serverkey, secretkey=self.core.secretkey, publickey=self.core.publickey) connected_to_pa.connect() if not connected_to_pa.is_connected(): return { 'error': { 'code': UNABLE_TO_REGISTER_INSTANCE, 'message': 'Could not connect to {}'.format(pa_vip_address) } } except gevent.Timeout: return { 'error': { 'code': UNABLE_TO_REGISTER_INSTANCE, 'message': 'Could not connect to {}'.format(pa_vip_address) } } except Exception as ex: return { 'error': { 'code': UNHANDLED_EXCEPTION, 'message': ex.message } } _log.debug('Connected to address') peers = connected_to_pa.agent.vip.peerlist().get(timeout=30) if VOLTTRON_CENTRAL_PLATFORM not in peers: connected_to_pa.core.stop() return { 'error': { 'code': UNABLE_TO_REGISTER_INSTANCE, 'message': '{} not present.'.format(VOLTTRON_CENTRAL_PLATFORM) } } # The call to manage should return a public key for that agent result = connected_to_pa.agent.vip.rpc.call( VOLTTRON_CENTRAL_PLATFORM, 'manage', self._web_info.vip_address, self._web_info.serverkey, self.core.publickey).get(timeout=30) # Magic number 43 is the length of a encoded public key. if len(result) != 43: return { 'error': { 'code': UNABLE_TO_REGISTER_INSTANCE, 'message': 'Invalid publickey returned from {}'.format( VOLTTRON_CENTRAL_PLATFORM) } } # Add the pa's public key so it can connect back to us. auth_file = AuthFile() auth_entry = AuthEntry(credentials="CURVE:{}".format(result), capabilities=['managing']) auth_file.add(auth_entry) # TODO: figure out if we are local or not entry = PlatformRegistry.build_entry(pa_vip_address, pa_instance_serverkey, discovery_address, display_name, False) self._registry.register(entry) self._pa_agents[entry.platform_uuid] = connected_to_pa _log.debug("Adding {}".format(entry.platform_uuid)) instance_name = display_name if display_name else discovery_address context = 'Registered instance {}'.format(instance_name) connected_to_pa.agent.vip.rpc.call( VOLTTRON_CENTRAL_PLATFORM, 'reconfigure', platform_uuid=entry.platform_uuid).get(timeout=30) return {'status': 'SUCCESS', 'context': context}
def _append_allow_curve_key(self, publickey): entry = AuthEntry(credentials="CURVE:{}".format(publickey)) authfile = AuthFile(self.volttron_home+"/auth.json") authfile.add(entry)
def _vc_connection(self): """ Attempt to connect to volttron central management console. The attempts will be done in the following order. 1. if peer is vc register with it. 2. volttron-central-tcp and serverkey 2. volttron-central-http (looks up tcp and serverkey) 3. volttron-central-ipc :param sender: :param kwargs: :return: """ assert self._agent_started, "cannot be called before onstart signal" if self._volttron_central_connection: # if connected return the connection. if self._volttron_central_connection.is_connected(5): _log.debug('Returning connection') return self._volttron_central_connection _log.debug("Resetting connection as the peer wasn't responding.") # reset the connection so we can try it again below. self._volttron_central_connection.kill() self._volttron_central_connection = None # First check to see if there is a peer with a volttron.central # identity, if there is use it as the manager of the platform. peers = self.vip.peerlist().get(timeout=5) if VOLTTRON_CENTRAL in peers: _log.debug('VC is a local peer.') self._volttron_central_connection = Connection( self.core.address, VOLTTRON_CENTRAL) if self._volttron_central_connection.is_connected() and \ self._volttron_central_connection.is_peer_connected(): _log.debug("Connection has been established to local peer.") return self._volttron_central_connection # If we have an http address for volttron central, but haven't # looked up the address yet, then look up and set the address from # volttron central discovery. if self._volttron_central_http_address is not None and \ self._volttron_central_tcp_address is None and \ self._volttron_central_serverkey is None: _log.debug('Using discovery to lookup tcp connection') response = requests.get("{}/discovery/".format( self._volttron_central_http_address)) if response.ok: jsonresp = response.json() entry = AuthEntry(credentials="/.*/", capabilities=['manager'] #, #address=jsonresp['vip-address'] ) authfile = AuthFile(get_home() + "/auth.json") authfile.add(entry) self._volttron_central_tcp_address = jsonresp['vip-address'] self._volttron_central_serverkey = jsonresp['serverkey'] # First see if we are able to connect via tcp with the serverkey. if self._volttron_central_tcp_address is not None and \ self._volttron_central_serverkey is not None: _log.debug('Connecting to volttron central using tcp.') vc_conn = Connection(address=self._volttron_central_tcp_address, peer=VOLTTRON_CENTRAL, serverkey=self._volttron_central_serverkey, publickey=self.core.publickey, secretkey=self.core.secretkey) if not vc_conn.is_connected(5): raise ValueError("Unable to connect to remote platform") if not vc_conn.is_peer_connected(5): raise ValueError( "Peer: {} unavailable on remote platform.".format( VOLTTRON_CENTRAL)) #TODO Only add a single time for this address. if self._volttron_central_publickey: # Add the vcpublickey to the auth file. entry = AuthEntry(credentials=self._volttron_central_publickey, capabilities=['manager']) authfile = AuthFile() authfile.add(entry) self._volttron_central_connection = vc_conn return self._volttron_central_connection # Next see if we have a valid ipc address (Not Local though) if self._volttron_central_ipc_address is not None: self._volttron_central_connection = Connection( address=self._volttron_central_ipc_address, peer=VOLTTRON_CENTRAL) return self._volttron_central_connection
def _register_instance(self, discovery_address, display_name=None, provisional=False): """ Register an instance with VOLTTRON Central based on jsonrpc. NOTE: This method is meant to be called from the jsonrpc method. The registration of the instance will fail in the following cases: - no discoverable instance at the passed uri - no platform.agent installed at the discoverable instance - is a different volttron central managing the discoverable instance. If the display name is not set then the display name becomes the same as the discovery_address. This will be used in the volttron central ui. :param discovery_address: A ip:port for an instance of volttron discovery. :param display_name: :return: dictionary: The dictionary will hold either an error object or a result object. """ _log.info( 'Attempting to register name: {} with address: {}'.format( display_name, discovery_address)) try: discovery_response = DiscoveryInfo.request_discovery_info( discovery_address) except DiscoveryError as e: return { 'error': { 'code': DISCOVERY_ERROR, 'message': e.message }} pa_instance_serverkey = discovery_response.serverkey pa_vip_address = discovery_response.vip_address assert pa_instance_serverkey _log.debug('connecting to pa_instance') try: connected_to_pa = ConnectedPlatform( address=pa_vip_address, serverkey=pa_instance_serverkey, secretkey=self.core.secretkey, publickey=self.core.publickey ) connected_to_pa.connect() if not connected_to_pa.is_connected(): return { 'error': { 'code': UNABLE_TO_REGISTER_INSTANCE, 'message': 'Could not connect to {}' .format(pa_vip_address) }} except gevent.Timeout: return { 'error': { 'code': UNABLE_TO_REGISTER_INSTANCE, 'message': 'Could not connect to {}' .format(pa_vip_address) }} except Exception as ex: return {'error': {'code': UNHANDLED_EXCEPTION, 'message': ex.message }} _log.debug('Connected to address') peers = connected_to_pa.agent.vip.peerlist().get(timeout=30) if VOLTTRON_CENTRAL_PLATFORM not in peers: connected_to_pa.core.stop() return {'error': {'code': UNABLE_TO_REGISTER_INSTANCE, 'message': '{} not present.'.format( VOLTTRON_CENTRAL_PLATFORM) }} # The call to manage should return a public key for that agent result = connected_to_pa.agent.vip.rpc.call( VOLTTRON_CENTRAL_PLATFORM, 'manage', self._web_info.vip_address, self._web_info.serverkey, self.core.publickey).get(timeout=30) # Magic number 43 is the length of a encoded public key. if len(result) != 43: return {'error': {'code': UNABLE_TO_REGISTER_INSTANCE, 'message': 'Invalid publickey returned from {}' .format(VOLTTRON_CENTRAL_PLATFORM) }} # Add the pa's public key so it can connect back to us. auth_file = AuthFile() auth_entry = AuthEntry(credentials="CURVE:{}".format(result), capabilities=['managing'] ) auth_file.add(auth_entry) # TODO: figure out if we are local or not entry = PlatformRegistry.build_entry( pa_vip_address, pa_instance_serverkey, discovery_address, display_name, False) self._registry.register(entry) self._pa_agents[entry.platform_uuid] = connected_to_pa _log.debug("Adding {}".format(entry.platform_uuid)) instance_name = display_name if display_name else discovery_address context = 'Registered instance {}'.format(instance_name) connected_to_pa.agent.vip.rpc.call( VOLTTRON_CENTRAL_PLATFORM, 'reconfigure', platform_uuid=entry.platform_uuid).get(timeout=30) return {'status': 'SUCCESS', 'context': context}
def allow_all_connections(self): """ Add a CURVE:.* entry to the auth.json file. """ entry = AuthEntry(credentials="/CURVE:.*/") authfile = AuthFile(self.volttron_home+"/auth.json") authfile.add(entry)
def allow_all_connections(self): """ Add a CURVE:.* entry to the auth.json file. """ entry = AuthEntry(credentials="/CURVE:.*/") authfile = AuthFile(self.volttron_home + "/auth.json") authfile.add(entry)
def _append_allow_curve_key(self, publickey): entry = AuthEntry(credentials="CURVE:{}".format(publickey)) authfile = AuthFile(self.volttron_home + "/auth.json") authfile.add(entry)
def add_to_auth(volttron_home, publickey, capabilities=None): authfile = AuthFile(os.path.join(volttron_home, 'auth.json')) entry = AuthEntry(credentials=publickey, mechanism="CURVE", capabilities=capabilities) authfile.add(entry, overwrite=True)
def add_to_auth(volttron_home, publickey, capabilities=None): authfile = AuthFile(os.path.join(volttron_home, 'auth.json')) entry = AuthEntry( credentials="CURVE:{}".format(publickey), capabilities=capabilities ) authfile.add(entry)