def _on_inbox_packet_received(self, newpacket, info, status, error_message):
from logs import lg
from contacts import contactsdb
from userid import my_id
from userid import global_id
from storage import backup_control
from p2p import commands
from p2p import p2p_service
if newpacket.Command == commands.Files():
list_files_global_id = global_id.ParseGlobalID(newpacket.PacketID)
if not list_files_global_id['idurl']:
lg.warn('invalid PacketID: %s' % newpacket.PacketID)
return False
if list_files_global_id['idurl'] != my_id.getLocalIDURL():
# lg.warn('skip %s which is from another customer' % newpacket)
return False
if not contactsdb.is_supplier(newpacket.OwnerID):
lg.warn('%s came, but %s is not my supplier' % (newpacket, newpacket.OwnerID, ))
# skip Files() if this is not my supplier
return False
lg.out(self.debug_level, "service_backups._on_inbox_packet_received: %r for us from %s at %s" % (
newpacket, newpacket.CreatorID, info))
if backup_control.IncomingSupplierListFiles(newpacket, list_files_global_id):
# send ack packet back
p2p_service.SendAck(newpacket)
else:
p2p_service.SendFail(newpacket)
return True
return False
def _on_my_dht_relations_discovered(self, discovered_suppliers_list):
from p2p import p2p_service
from contacts import contactsdb
from logs import lg
suppliers_to_be_dismissed = set()
# clean up old suppliers
for idurl in discovered_suppliers_list:
if not idurl:
continue
if not contactsdb.is_supplier(idurl):
lg.warn('dht relation with %s is not valid anymore' % idurl)
suppliers_to_be_dismissed.add(idurl)
for idurl in suppliers_to_be_dismissed:
p2p_service.SendCancelService(
remote_idurl=idurl,
service_name='service_supplier',
)
p2p_service.SendCancelService(
remote_idurl=idurl,
service_name='service_supplier_relations',
)
if suppliers_to_be_dismissed:
lg.info(
'found %d suppliers to be cleaned and sent CancelService() packets'
% len(suppliers_to_be_dismissed))
def on_files_received(newpacket, info):
list_files_global_id = global_id.ParseGlobalID(newpacket.PacketID)
if not list_files_global_id['idurl']:
lg.warn('invalid PacketID: %s' % newpacket.PacketID)
return False
if list_files_global_id['idurl'] != my_id.getLocalID():
# ignore Files() if this is another customer
if _Debug:
lg.dbg(
_DebugLevel,
'ignore incoming %r which is owned by another customer' %
newpacket)
return False
if not contactsdb.is_supplier(newpacket.OwnerID):
# ignore Files() if this is not my supplier
if _Debug:
lg.dbg(
_DebugLevel,
'incoming %r received, but %r is not my supplier' % (
newpacket,
newpacket.OwnerID,
))
return False
if _Debug:
lg.args(
_DebugLevel,
"service_backups._on_inbox_packet_received: %r for us from %s at %s"
% (newpacket, newpacket.CreatorID, info))
if IncomingSupplierListFiles(newpacket, list_files_global_id):
p2p_service.SendAck(newpacket)
else:
p2p_service.SendFail(newpacket)
return True
def _on_my_dht_relations_discovered(self, dht_result):
from p2p import p2p_service
from contacts import contactsdb
from logs import lg
if not (dht_result and isinstance(dht_result, dict) and len(dht_result.get('suppliers', [])) > 0):
lg.warn('no dht records found for my customer family')
return
suppliers_to_be_dismissed = set()
# clean up old suppliers
for idurl in dht_result['suppliers']:
if not idurl:
continue
if not contactsdb.is_supplier(idurl):
lg.warn('dht relation with %s is not valid anymore' % idurl)
suppliers_to_be_dismissed.add(idurl)
for supplier_idurl in suppliers_to_be_dismissed:
p2p_service.SendCancelService(
remote_idurl=supplier_idurl,
service_name='service_supplier',
)
# p2p_service.SendCancelService(
# remote_idurl=idurl,
# service_name='service_p2p_notifications',
# )
if suppliers_to_be_dismissed:
lg.info('found %d suppliers to be cleaned and sent CancelService() packets' % len(suppliers_to_be_dismissed))
def _supplier_connector_state(self, supplier_idurl, newstate):
if supplier_idurl != self.target_idurl:
return
if newstate is 'CONNECTED':
if not contactsdb.is_supplier(self.target_idurl):
self.automat('supplier-connected', self.target_idurl)
elif newstate in ['DISCONNECTED', 'NO_SERVICE', ]:
self.automat('supplier-not-connected')
def _supplier_connector_state(self, supplier_idurl, newstate):
if supplier_idurl != self.target_idurl:
return
if newstate is 'CONNECTED':
if not contactsdb.is_supplier(self.target_idurl):
self.automat('supplier-connected', self.target_idurl)
elif newstate in ['DISCONNECTED', 'NO_SERVICE', ]:
self.automat('supplier-not-connected')
def _on_my_dht_relations_discovered(self, dht_result):
from p2p import p2p_service
from contacts import contactsdb
from userid import my_id
from userid import id_url
from crypt import my_keys
from logs import lg
if not (dht_result and isinstance(dht_result, dict)
and len(dht_result.get('suppliers', [])) > 0):
lg.warn('no dht records found for my customer family')
return
if id_url.is_some_empty(contactsdb.suppliers()):
lg.warn(
'some of my suppliers are not hired yet, skip doing any changes'
)
return
suppliers_to_be_dismissed = set()
dht_suppliers = id_url.to_bin_list(dht_result['suppliers'])
# clean up old suppliers
for idurl in dht_suppliers:
if not idurl:
continue
if not contactsdb.is_supplier(idurl):
lg.warn('dht relation with %r is not valid anymore' % idurl)
suppliers_to_be_dismissed.add(idurl)
for supplier_idurl in suppliers_to_be_dismissed:
service_info = {}
my_customer_key_id = my_id.getGlobalID(key_alias='customer')
if my_keys.is_key_registered(my_customer_key_id):
service_info['customer_public_key'] = my_keys.get_key_info(
key_id=my_customer_key_id,
include_private=False,
include_signature=False,
generate_signature=False,
)
p2p_service.SendCancelService(
remote_idurl=supplier_idurl,
service_name='service_supplier',
json_payload=service_info,
)
if suppliers_to_be_dismissed:
lg.info(
'found %d suppliers to be cleaned and sent CancelService() packets'
% len(suppliers_to_be_dismissed))
def _on_inbox_packet_received(self, newpacket, info, status,
error_message):
from logs import lg
from main import settings
from contacts import contactsdb
from userid import my_id
from userid import global_id
from storage import backup_control
from p2p import commands
if newpacket.Command == commands.Data():
if newpacket.OwnerID != my_id.getLocalID():
# only catch data belongs to me
return False
lg.out(
self.debug_level,
"service_backups._on_inbox_packet_received: %r for us from %s"
% (
newpacket,
newpacket.RemoteID,
))
if newpacket.PacketID == global_id.MakeGlobalID(
idurl=my_id.getLocalID(),
path=settings.BackupIndexFileName(),
):
# TODO: move to service_backup_db
backup_control.IncomingSupplierBackupIndex(newpacket)
return True
if newpacket.Command == commands.Files():
if not newpacket.PacketID.startswith(my_id.getGlobalID() + ':'):
# skip Files() which are from another customer
return False
if not contactsdb.is_supplier(newpacket.OwnerID):
# skip Files() if this is not my supplier
return False
lg.out(
self.debug_level,
"service_backups._on_inbox_packet_received: %r for us from %s"
% (
newpacket,
newpacket.RemoteID,
))
return backup_control.IncomingSupplierListFiles(newpacket)
return False
def _supplier_connector_state(self, supplier_idurl, newstate, **kwargs):
if id_url.field(supplier_idurl) != self.target_idurl:
return
if newstate in [
'DISCONNECTED',
'NO_SERVICE',
]:
self.automat('supplier-not-connected')
return
if newstate != 'CONNECTED':
return
if contactsdb.is_supplier(self.target_idurl):
return
family_position = kwargs.get('family_position', None)
ecc_map = kwargs.get('ecc_map')
self.automat('supplier-connected',
self.target_idurl,
family_position=family_position,
ecc_map=ecc_map,
family_snapshot=self.family_snapshot)
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)
