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 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 doStartListening(self, *args, **kwargs):
"""
Action method.
"""
try:
_, info = args[0]
self.router_proto_host = (info.proto, info.host)
except:
try:
s = config.conf().getString('services/proxy-transport/current-router').strip()
_, router_proto, router_host = s.split(' ')
self.router_proto_host = (router_proto, strng.to_bin(router_host), )
except:
lg.exc()
self.router_identity = identitycache.FromCache(self.router_idurl)
config.conf().setString('services/proxy-transport/current-router', '%s %s %s' % (
strng.to_text(self.router_idurl),
strng.to_text(self.router_proto_host[0]),
strng.to_text(self.router_proto_host[1]),
))
current_identity = my_id.getLocalIdentity().serialize()
previous_identity = ReadMyOriginalIdentitySource()
if previous_identity:
lg.warn('my original identity is not empty, SKIP overwriting')
lg.out(2, '\nPREVIOUS ORIGINAL IDENTITY:\n%s\n' % current_identity)
else:
WriteMyOriginalIdentitySource(current_identity)
lg.warn('current identity was stored as my-original-identity')
self.request_service_packet_id = []
callback.insert_inbox_callback(0, self._on_inbox_packet_received)
if contact_status.isKnown(self.router_idurl):
contact_status.A(self.router_idurl).addStateChangedCallback(
self._on_router_contact_status_connected, newstate='CONNECTED')
contact_status.A(self.router_idurl).addStateChangedCallback(
self._on_router_contact_status_offline, newstate='OFFLINE')
active_router_sessions = gateway.find_active_session(info.proto, info.host)
if active_router_sessions:
self.router_connection_info = {
'id': active_router_sessions[0].id,
'index': active_router_sessions[0].index,
'proto': info.proto,
'host': info.host,
'idurl': self.router_idurl,
'global_id': global_id.UrlToGlobalID(self.router_idurl),
}
active_router_session_machine = automat.objects().get(self.router_connection_info['index'], None)
if active_router_session_machine:
active_router_session_machine.addStateChangedCallback(
self._on_router_session_disconnected, oldstate='CONNECTED')
lg.info('connected to proxy router and set active session: %s' % self.router_connection_info)
else:
lg.err('not found proxy router session state machine: %s' % self.router_connection_info['index'])
else:
lg.err('active connection with proxy router at %s:%s was not found' % (info.proto, info.host, ))
if _Debug:
lg.out(2, 'proxy_receiver.doStartListening !!!!!!! router: %s at %s://%s' % (
self.router_idurl, self.router_proto_host[0], self.router_proto_host[1]))
def _do_process_request(self, *args, **kwargs):
global _MaxRoutesNumber
json_payload, request, info = args[0]
user_id = request.CreatorID
#--- commands.RequestService()
if request.Command == commands.RequestService():
if len(self.routes) >= _MaxRoutesNumber:
if _Debug:
lg.out(
_DebugLevel,
'proxy_server.doProcessRequest RequestService rejected: too many routes'
)
lg.out(_DebugLevel, ' %r' % self.routes)
p2p_service.SendAck(request, 'rejected', wide=True)
else:
try:
# idsrc = strng.to_bin(json_payload['identity'])
idsrc = json_payload['identity']
cached_id = identity.identity(xmlsrc=idsrc)
except:
lg.out(_DebugLevel, 'payload: [%s]' % request.Payload)
lg.exc()
return
if not cached_id.Valid():
lg.warn('incoming identity is not valid')
return
if not cached_id.isCorrect():
lg.warn('incoming identity is not correct')
return
if user_id != cached_id.getIDURL():
lg.warn(
'incoming identity is not belong to request packet creator'
)
return
if contactsdb.is_supplier(user_id):
if _Debug:
lg.out(
_DebugLevel,
'proxy_server.doProcessRequest RequestService rejected: this user is my supplier'
)
p2p_service.SendAck(request, 'rejected', wide=True)
return
oldnew = ''
if user_id not in list(self.routes.keys()):
# accept new route
oldnew = 'NEW'
self.routes[user_id] = {}
else:
# accept existing routed user
oldnew = 'OLD'
if not self._is_my_contacts_present_in_identity(cached_id):
if _Debug:
lg.out(_DebugLevel,
' DO OVERRIDE identity for %s' % user_id)
identitycache.OverrideIdentity(user_id,
cached_id.serialize())
else:
if _Debug:
lg.out(
_DebugLevel,
' SKIP OVERRIDE identity for %s' % user_id)
self.routes[user_id]['time'] = time.time()
self.routes[user_id]['identity'] = cached_id.serialize(
as_text=True)
self.routes[user_id]['publickey'] = strng.to_text(
cached_id.publickey)
self.routes[user_id][
'contacts'] = cached_id.getContactsAsTuples(as_text=True)
self.routes[user_id]['address'] = []
self._write_route(user_id)
active_user_sessions = gateway.find_active_session(
info.proto, info.host)
if active_user_sessions:
user_connection_info = {
'id': active_user_sessions[0].id,
'index': active_user_sessions[0].index,
'proto': info.proto,
'host': info.host,
'idurl': user_id,
}
active_user_session_machine = automat.objects().get(
user_connection_info['index'], None)
if active_user_session_machine:
active_user_session_machine.addStateChangedCallback(
lambda o, n, e, a: self.
_on_user_session_disconnected(user_id, o, n, e, a),
oldstate='CONNECTED',
)
if _Debug:
lg.out(
_DebugLevel,
'proxy_server.doProcessRequest connected %s routed user, set active session: %s'
% (oldnew.capitalize(), user_connection_info))
else:
lg.err('not found session state machine: %s' %
user_connection_info['index'])
else:
if _Debug:
lg.out(
_DebugLevel,
'proxy_server.doProcessRequest active connection with user %s at %s:%s not yet exist'
% (
user_id,
info.proto,
info.host,
))
lg.out(
_DebugLevel, ' current active sessions: %d' %
len(gateway.list_active_sessions(info.proto)))
self.acks.append(
p2p_service.SendAck(request, 'accepted', wide=True))
if _Debug:
lg.out(
_DebugLevel,
'proxy_server.doProcessRequest !!!!!!! ACCEPTED %s ROUTE for %s contacts=%s'
% (
oldnew.capitalize(),
user_id,
self.routes[user_id]['contacts'],
))
#--- commands.CancelService()
elif request.Command == commands.CancelService():
if user_id in self.routes:
# cancel existing route
self._remove_route(user_id)
self.routes.pop(user_id)
identitycache.StopOverridingIdentity(user_id)
p2p_service.SendAck(request, 'accepted', wide=True)
if _Debug:
lg.out(
_DebugLevel,
'proxy_server.doProcessRequest !!!!!!! CANCELLED ROUTE for %s'
% user_id)
else:
p2p_service.SendAck(request, 'rejected', wide=True)
if _Debug:
lg.out(
_DebugLevel,
'proxy_server.doProcessRequest CancelService rejected : %s is not found in routes'
% user_id)
lg.out(_DebugLevel, ' %r' % self.routes)
else:
p2p_service.SendFail(request, 'rejected', wide=True)
