def _on_my_list_files_refreshed(self, evt):
from access import shared_access_coordinator
from customer import supplier_connector
from p2p import p2p_service
from p2p import commands
for key_id in shared_access_coordinator.list_active_shares():
cur_share = shared_access_coordinator.get_active_share(key_id)
if not cur_share:
continue
if cur_share.state != 'CONNECTED':
continue
for supplier_idurl in cur_share.known_suppliers_list:
sc = supplier_connector.by_idurl(
supplier_idurl,
customer_idurl=cur_share.customer_idurl,
)
if sc is not None and sc.state == 'CONNECTED':
p2p_service.SendListFiles(
target_supplier=supplier_idurl,
customer_idurl=cur_share.customer_idurl,
key_id=cur_share.key_id,
callbacks={
commands.Files():
lambda r, i: self._on_list_files_response(
r, i, cur_share.customer_idurl, supplier_idurl,
cur_share.key_id),
commands.Fail():
lambda r, i: self._on_list_files_failed(
r, i, cur_share.customer_idurl, supplier_idurl,
cur_share.key_id),
})
def _do_request_list_files(self, suppliers_list):
backup_matrix.add_list_files_query_callback(
customer_idurl=self.queue_owner_idurl,
query_path=self.queue_alias,
callback_method=self._on_list_files_response,
)
self.correctable_errors = eccmap.GetCorrectableErrors(
len(suppliers_list))
for supplier_pos, supplier_idurl in enumerate(suppliers_list):
if not supplier_idurl:
self.requested_list_files[supplier_pos] = False
continue
outpacket = p2p_service.SendListFiles(
target_supplier=supplier_idurl,
key_id=self.group_key_id,
query_items=[
self.queue_alias,
],
timeout=30,
callbacks={
commands.Fail():
lambda resp, info: self._on_list_files_failed(supplier_pos
),
None:
lambda pkt_out: self._on_list_files_failed(supplier_pos),
},
)
self.requested_list_files[
supplier_pos] = None if outpacket else False
if _Debug:
lg.args(_DebugLevel, requested=self.requested_list_files)
self.request_list_files_timer = reactor.callLater(
30, self._on_request_list_files_timeout) # @UndefinedVariable
def _do_request(self, x=None):
from raid import eccmap
self.received_lf_counter = 0
self.requested_lf_packet_ids.clear()
known_suppliers = contactsdb.suppliers(customer_idurl=self.target_customer_idurl)
try:
self.critical_suppliers_number = eccmap.GetCorrectableErrors(len(known_suppliers))
except:
lg.warn('number of known suppliers for customer %r is not standard' % self.target_customer_idurl)
self.critical_suppliers_number = int(float(len(known_suppliers)) * 0.75)
for idurl in known_suppliers:
if idurl:
if online_status.isOnline(idurl):
if _Debug:
lg.out(_DebugLevel, 'list_files_orator._do_request ListFiles() from my supplier %s' % idurl)
outpacket = p2p_service.SendListFiles(
target_supplier=idurl,
customer_idurl=self.target_customer_idurl,
timeout=30,
)
if outpacket:
self.requested_lf_packet_ids.add(outpacket.PacketID)
else:
lg.err('failed sending ListFiles() to %r' % idurl)
else:
lg.warn('skip sending ListFiles() because %s is not online' % idurl)
def doRequestSupplierFiles(self, *args, **kwargs):
"""
Action method.
"""
p2p_service.SendListFiles(
target_supplier=args[0],
customer_idurl=self.customer_idurl,
key_id=self.key_id,
)
def _on_key_transfer_success(self, customer_idurl, supplier_idurl, key_id):
from logs import lg
from p2p import p2p_service
lg.info('public key %r shared to supplier %r of customer %r, now will send ListFiles()' % (key_id, supplier_idurl, customer_idurl))
p2p_service.SendListFiles(
target_supplier=supplier_idurl,
customer_idurl=customer_idurl,
key_id=key_id,
)
def _on_key_transfer_success(self, customer_idurl, supplier_idurl, key_id):
if _Debug:
lg.out(
_DebugLevel,
'shared_access_coordinator._on_key_transfer_success public key %r shared to supplier %r of customer %r, now will send ListFiles() again'
% (key_id, supplier_idurl, customer_idurl))
p2p_service.SendListFiles(
target_supplier=supplier_idurl,
customer_idurl=customer_idurl,
key_id=key_id,
)
def doRequestRemoteFiles(self, arg):
global _RequestedListFilesCounter
global _RequestedListFilesPacketIDs
_RequestedListFilesCounter = 0
_RequestedListFilesPacketIDs.clear()
for idurl in contactsdb.suppliers():
if idurl:
if contact_status.isOnline(idurl):
p2p_service.SendListFiles(target_supplier=idurl)
_RequestedListFilesPacketIDs.add(idurl)
else:
lg.out(
6,
'list_files_orator.doRequestRemoteFiles SKIP %s is not online'
% idurl)
def doRequestFilesOneSupplier(self, *args, **kwargs):
"""
Action method.
"""
supplier_idurl = args[0]
if _Debug:
lg.out(
_DebugLevel,
'list_files_orator.doRequestFilesOneSupplier from %s' %
supplier_idurl)
outpacket = p2p_service.SendListFiles(target_supplier=supplier_idurl, )
if outpacket:
_RequestedListFilesPacketIDs.add(outpacket.PacketID)
else:
lg.err('failed sending ListFiles() to %r' % supplier_idurl)
def _on_key_transfer_success(self, customer_idurl, supplier_idurl, key_id):
from logs import lg
from p2p import commands
from p2p import p2p_service
lg.info('public key %r shared to supplier %r of customer %r, now will send ListFiles()' % (key_id, supplier_idurl, customer_idurl))
p2p_service.SendListFiles(
target_supplier=supplier_idurl,
customer_idurl=customer_idurl,
key_id=key_id,
timeout=30,
callbacks={
commands.Files(): lambda r, i: self._on_list_files_response(r, i, customer_idurl, supplier_idurl, key_id),
commands.Fail(): lambda r, i: self._on_list_files_failed(r, i, customer_idurl, supplier_idurl, key_id),
}
)
def doRequestSupplierFiles(self, *args, **kwargs):
"""
Action method.
"""
supplier_idurl = args[0]
p2p_service.SendListFiles(
target_supplier=supplier_idurl,
customer_idurl=self.customer_idurl,
key_id=self.key_id,
callbacks={
commands.Files():
lambda r, i: self._on_list_files_response(
r, i, self.customer_idurl, supplier_idurl, self.key_id),
commands.Fail():
lambda r, i: self._on_list_files_failed(
r, i, self.customer_idurl, supplier_idurl, self.key_id),
})
def doRequestSupplierFiles(self, *args, **kwargs):
"""
Action method.
"""
supplier_idurl = args[0]
pkt_out = p2p_service.SendListFiles(
target_supplier=supplier_idurl,
customer_idurl=self.customer_idurl,
key_id=self.key_id,
callbacks={
commands.Files():
lambda r, i: self._on_list_files_response(
r, i, self.customer_idurl, supplier_idurl, self.key_id),
commands.Fail():
lambda r, i: self._on_list_files_failed(
r, i, self.customer_idurl, supplier_idurl, self.key_id),
},
timeout=20,
)
self.outgoing_list_files_packets_ids.append(pkt_out.PacketID)
def _do_request(self, x=None):
global _ReceivedListFilesCounter
global _RequestedListFilesPacketIDs
_ReceivedListFilesCounter = 0
_RequestedListFilesPacketIDs.clear()
for idurl in contactsdb.suppliers():
if idurl:
if online_status.isOnline(idurl):
if _Debug:
lg.out(
_DebugLevel,
'list_files_orator._do_request ListFiles() from my supplier %s'
% idurl)
outpacket = p2p_service.SendListFiles(
target_supplier=idurl, )
if outpacket:
_RequestedListFilesPacketIDs.add(outpacket.PacketID)
else:
lg.err('failed sending ListFiles() to %r' % idurl)
else:
lg.warn(
'skip sending ListFiles() because %s is not online' %
idurl)
def _do_request_supplier_list_files(self, supplier_idurl, customer_idurl,
key_id):
pkt_out = p2p_service.SendListFiles(
target_supplier=supplier_idurl,
customer_idurl=customer_idurl,
key_id=key_id,
callbacks={
commands.Files():
lambda r, i: self._on_list_files_response(
r, i, customer_idurl, supplier_idurl, key_id),
commands.Fail():
lambda r, i: self._on_list_files_failed(
r, i, customer_idurl, supplier_idurl, key_id),
},
timeout=20,
)
self.outgoing_list_files_packets_ids.append(pkt_out.PacketID)
if _Debug:
lg.args(
_DebugLevel,
supplier=supplier_idurl,
pid=pkt_out.PacketID,
outgoing=len(self.outgoing_list_files_packets_ids),
)
def doRequestSupplierFiles(self, arg):
"""
Action method.
"""
p2p_service.SendListFiles(arg, customer_idurl=self.customer_idurl)
