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
