def doStopListening(self, *args, **kwargs): """ Action method. """ if _Debug: lg.args(_DebugLevel, router_idurl=self.router_idurl) if online_status.isKnown(self.router_idurl): online_status.remove_online_status_listener_callback( idurl=self.router_idurl, callback_method=self._on_router_contact_status_connected, ) online_status.remove_online_status_listener_callback( idurl=self.router_idurl, callback_method=self._on_router_contact_status_offline, ) active_router_session_machine_index = None if self.router_connection_info: active_router_session_machine = None active_router_session_machine_index = self.router_connection_info.get('index', None) if active_router_session_machine_index is not None: active_router_session_machine = automat.by_index(active_router_session_machine_index) if not active_router_session_machine: active_router_sessions = gateway.find_active_session( proto=self.router_connection_info.get('proto'), host=self.router_connection_info.get('host'), ) if not active_router_sessions: active_router_sessions = gateway.find_active_session( proto=self.router_connection_info.get('proto'), idurl=id_url.to_bin(self.router_idurl), ) if active_router_sessions: active_router_session_machine = automat.by_index(active_router_sessions[0].index) if active_router_session_machine is not None: active_router_session_machine.removeStateChangedCallback(self._on_router_session_disconnected) lg.info('removed callback from router active session: %r' % active_router_session_machine) else: lg.err('did not found active router session state machine with index %s' % active_router_session_machine_index) WriteMyOriginalIdentitySource('') config.conf().setString('services/proxy-transport/current-router', '') callback.remove_inbox_callback(self._on_inbox_packet_received) self.router_identity = None self.router_idurl = None self.router_id = '' self.router_proto_host = None self.request_service_packet_id = [] self.router_connection_info = None my_id.rebuildLocalIdentity()
def doDestroyMe(self, *args, **kwargs): """ Action method. """ global _Shutdowner del _Shutdowner _Shutdowner = None self.destroy() if _Debug: lg.out( _DebugLevel, 'shutdowner.doDestroyMe %d machines left in memory:\n %s' % (len(automat.objects()), '\n '.join([ '%d: %r' % (k, automat.by_index(k)) for k in automat.objects().keys() ]))) if self.enableMemoryProfile: try: from guppy import hpy # @UnresolvedImport hp = hpy() hp.setrelheap() if _Debug: lg.out(_DebugLevel, 'hp.heap():\n' + str(hp.heap())) lg.out(_DebugLevel, 'hp.heap().byrcs:\n' + str(hp.heap().byrcs)) lg.out(_DebugLevel, 'hp.heap().byvia:\n' + str(hp.heap().byvia)) except: if _Debug: lg.out(_DebugLevel, "guppy package is not installed")
def find_active_shares(customer_idurl): """ """ global _ActiveSharesByIDURL result = [] for automat_index in _ActiveSharesByIDURL.values(): A = automat.by_index(automat_index) if not A: continue if A.customer_idurl == customer_idurl: result.append(A) return result
def find_active_message_producers(group_creator_idurl): """ """ global _ActiveMessageProducersByIDURL result = [] for automat_index in _ActiveMessageProducersByIDURL.values(): A = automat.by_index(automat_index) if not A: continue if A.group_creator_idurl == group_creator_idurl: result.append(A) return result
def _on_request_service_ack(self, response, info): self.router_connection_info = None if response.PacketID not in self.request_service_packet_id: lg.warn('wrong PacketID in response: %s, but outgoing was : %s' % ( response.PacketID, str(self.request_service_packet_id))) self.automat('service-refused', (response, info)) return if response.PacketID in self.request_service_packet_id: self.request_service_packet_id.remove(response.PacketID) else: lg.warn('%s was not found in pending requests: %s' % (response.PacketID, self.request_service_packet_id)) if _Debug: lg.out(_DebugLevel, 'proxy_receiver._on_request_service_ack : %s' % str(response.Payload)) if self.router_idurl != response.CreatorID: lg.err('received unexpected response from another node: %r ~ %r' % (self.router_idurl, response.CreatorID, )) self.automat('service-refused', (response, info)) return service_ack_info = strng.to_text(response.Payload) if service_ack_info.startswith('rejected'): self.automat('service-refused', (response, info)) return active_router_sessions = gateway.find_active_session(info.proto, host=info.host) if not active_router_sessions: active_router_sessions = gateway.find_active_session(info.proto, idurl=id_url.to_bin(response.CreatorID)) if not active_router_sessions: lg.err('active connection with proxy router at %s:%s was not found' % (info.proto, info.host, )) if _Debug: lg.args(_DebugLevel, router_idurl=self.router_idurl, ack_packet=info, active_sessions=gateway.list_active_sessions(info.proto)) self.automat('service-refused', (response, info)) return self.router_connection_info = { 'id': active_router_sessions[0].id, 'index': active_router_sessions[0].index, 'repr': repr(active_router_sessions[0]), 'proto': info.proto, 'host': info.host, 'idurl': self.router_idurl, 'global_id': global_id.UrlToGlobalID(self.router_idurl), } active_router_session_machine = automat.by_index(self.router_connection_info['index']) if active_router_session_machine is None: lg.err('did not found proxy router session state machine instance: %s' % self.router_connection_info) self.router_connection_info = None if _Debug: lg.args(_DebugLevel, automats=automat.objects()) self.automat('service-refused', (response, info)) return lg.info('found active session for proxy router: %s' % active_router_session_machine) self.automat('service-accepted', (response, info, active_router_session_machine))
def do_p2p_connector_test(result_defer): if _Debug: lg.dbg(_DebugLevel, 'checking p2p_connector') try: p2p_connector_lookup = automat.find('p2p_connector') if not p2p_connector_lookup: lg.warn('disconnected, reason is "p2p_connector_not_found"') result_defer.callback( dict( error='disconnected', reason='p2p_connector_not_found', )) return None p2p_connector_machine = automat.by_index(p2p_connector_lookup[0]) if not p2p_connector_machine: lg.warn('disconnected, reason is "p2p_connector_not_exist"') result_defer.callback( dict( error='disconnected', reason='p2p_connector_not_exist', )) return None if p2p_connector_machine.state in [ 'DISCONNECTED', ]: lg.warn( 'disconnected, reason is "p2p_connector_disconnected", sending "check-synchronize" event to p2p_connector()' ) p2p_connector_machine.automat('check-synchronize') result_defer.callback( dict( error='disconnected', reason='p2p_connector_disconnected', )) return None do_service_proxy_transport_test(result_defer) except: lg.exc() result_defer.callback( dict( error='disconnected', reason='p2p_connector_error', )) return None
def connected(wait_timeout=5): ret = Deferred() if driver.is_enabled('service_proxy_transport'): p2p_connector_lookup = automat.find('p2p_connector') if p2p_connector_lookup: p2p_connector_machine = automat.by_index(p2p_connector_lookup[0]) if p2p_connector_machine and p2p_connector_machine.state == 'CONNECTED': proxy_receiver_lookup = automat.find('proxy_receiver') if proxy_receiver_lookup: proxy_receiver_machine = automat.by_index( proxy_receiver_lookup[0]) if proxy_receiver_machine and proxy_receiver_machine.state == 'LISTEN': # service_proxy_transport() is enabled, proxy_receiver() is listening: all good wait_timeout_defer = Deferred() wait_timeout_defer.addBoth(lambda _: ret.callback({ 'service_network': 'started', 'service_gateway': 'started', 'service_p2p_hookups': 'started', 'service_proxy_transport': 'started', 'proxy_receiver_state': proxy_receiver_machine.state, })) if not wait_timeout: wait_timeout = 0.01 wait_timeout_defer.addTimeout(wait_timeout, clock=reactor) return ret else: d = driver.is_healthy('service_proxy_transport') d.addCallback(on_service_proxy_transport_check_healthy, wait_timeout=wait_timeout) d.addErrback(lg.errback, debug=_Debug, debug_level=_DebugLevel, method='network_service.connected', ignore=True) lg.warn( 'disconnected, reason is proxy_receiver() not started yet' ) ret.callback( dict( error='disconnected', reason='proxy_receiver_not_started', )) return ret if not my_id.isLocalIdentityReady(): lg.warn('local identity is not valid or not exist') ret.callback( dict( error='local identity is not valid or not exist', reason='identity_not_exist', )) return ret if not driver.is_enabled('service_network'): lg.warn('service_network() is disabled') ret.callback( dict( error='service_network() is disabled', reason='service_network_disabled', )) return ret if not driver.is_enabled('service_gateway'): lg.warn('service_gateway() is disabled') ret.callback( dict( error='service_gateway() is disabled', reason='service_gateway_disabled', )) return ret if not driver.is_enabled('service_p2p_hookups'): lg.warn('service_p2p_hookups() is disabled') ret.callback( dict( error='service_p2p_hookups() is disabled', reason='service_p2p_hookups_disabled', )) return ret do_service_test('service_network', ret, wait_timeout) return ret
def do_service_proxy_transport_test(result_defer): if _Debug: lg.dbg(_DebugLevel, 'checking proxy_transport') if not driver.is_enabled('service_proxy_transport'): result_defer.callback({ 'service_network': 'started', 'service_gateway': 'started', 'service_p2p_hookups': 'started', 'service_proxy_transport': 'disabled', }) return None try: proxy_receiver_lookup = automat.find('proxy_receiver') if not proxy_receiver_lookup: lg.warn('disconnected, reason is "proxy_receiver_not_found"') result_defer.callback( dict( error='disconnected', reason='proxy_receiver_not_found', )) return None proxy_receiver_machine = automat.by_index(proxy_receiver_lookup[0]) if not proxy_receiver_machine: lg.warn('disconnected, reason is "proxy_receiver_not_exist"') result_defer.callback( dict( error='disconnected', reason='proxy_receiver_not_exist', )) return None if proxy_receiver_machine.state != 'LISTEN': lg.warn( 'disconnected, reason is "proxy_receiver_disconnected", sending "start" event to proxy_receiver()' ) proxy_receiver_machine.automat('start') result_defer.callback( dict( error='disconnected', reason='proxy_receiver_disconnected', )) return None result_defer.callback({ 'service_network': 'started', 'service_gateway': 'started', 'service_p2p_hookups': 'started', 'service_proxy_transport': 'started', 'proxy_receiver_state': proxy_receiver_machine.state, }) except: lg.exc() result_defer.callback( dict( error='disconnected', reason='proxy_receiver_error', )) return None