def contacts_remote():
"""
Return ID's list of all known peers.
"""
allcontactslist = id_url.to_bin_list(contacts_full())
if my_id.getLocalID().to_bin() in allcontactslist:
allcontactslist.remove(my_id.getLocalID().to_bin())
return id_url.fields_list(allcontactslist)
def contacts_remote(include_all=False, include_enabled=True):
"""
Return ID's list of all known peers.
"""
allcontactslist = id_url.to_bin_list(contacts(include_all=include_all, include_enabled=include_enabled))
if my_id.getLocalID().to_bin() in allcontactslist:
allcontactslist.remove(my_id.getLocalID().to_bin())
return id_url.fields_list(allcontactslist)
def _do_verify(dht_value, customer_idurl_bin):
if customer_idurl_bin in rotated_idurls:
rotated_idurls.remove(customer_idurl_bin)
ret = {
'suppliers': [],
'ecc_map': None,
'customer_idurl': customer_idurl,
'revision': 0,
'publisher_idurl': None,
'timestamp': None,
}
if not dht_value or not isinstance(dht_value, dict):
if not rotated_idurls:
result.callback(ret)
return ret
another_customer_idurl_bin = rotated_idurls.pop(0)
lg.warn(
'found another rotated idurl %r and re-try reading customer suppliers'
% another_customer_idurl_bin)
d = dht_records.get_suppliers(another_customer_idurl_bin,
return_details=True,
use_cache=False)
d.addCallback(_do_verify, another_customer_idurl_bin)
d.addErrback(_on_error)
return ret
try:
_ecc_map = strng.to_text(dht_value['ecc_map'])
if as_fields:
_customer_idurl = id_url.field(dht_value['customer_idurl'])
_publisher_idurl = id_url.field(
dht_value.get('publisher_idurl'))
_suppliers_list = id_url.fields_list(dht_value['suppliers'])
else:
_customer_idurl = id_url.to_bin(dht_value['customer_idurl'])
_publisher_idurl = id_url.to_bin(
dht_value.get('publisher_idurl'))
_suppliers_list = id_url.to_bin_list(dht_value['suppliers'])
_revision = int(dht_value.get('revision'))
_timestamp = int(dht_value.get('timestamp'))
except:
lg.exc()
result.callback(ret)
return ret
ret.update({
'suppliers': _suppliers_list,
'ecc_map': _ecc_map,
'customer_idurl': _customer_idurl,
'revision': _revision,
'publisher_idurl': _publisher_idurl,
'timestamp': _timestamp,
})
return _do_identity_cache(ret)
def set_suppliers(idlist, customer_idurl=None):
"""
Set suppliers ID's list.
"""
global _SuppliersList
if not customer_idurl:
customer_idurl = my_id.getLocalID()
customer_idurl = id_url.field(customer_idurl)
if customer_idurl not in _SuppliersList:
_SuppliersList[customer_idurl] = []
lg.info('created new suppliers list in memory for customer %r' % customer_idurl)
_SuppliersList[customer_idurl] = id_url.fields_list(idlist)
if _Debug:
lg.args(_DebugLevel, suppliers=_SuppliersList[customer_idurl], customer_idurl=customer_idurl)
def test_dict_of_lists(self):
self._cache_identity('alice')
self._cache_identity('bob')
self._cache_identity('carl')
self._cache_identity('frank')
d = {}
d[id_url.field(alice_text)] = []
d[id_url.field(bob)] = []
d[id_url.field(alice_text)].append(id_url.field(carl))
d[id_url.field(alice_text)].append(id_url.field(frank_1))
d[id_url.field(bob)].append(id_url.field(''))
d[id_url.field(bob)].append(id_url.field(frank_2))
d[id_url.field(bob)].append(id_url.field(None))
d[id_url.field(bob)].append(id_url.field(b''))
self.assertIn(id_url.field(frank_1), d[id_url.field(alice_text)])
self.assertIn(id_url.field(frank_1), d[id_url.field(bob)])
self.assertFalse(id_url.is_some_empty(d[id_url.field(alice_text)]))
self.assertTrue(id_url.is_some_empty(d[id_url.field(bob)]))
self.assertEqual(len(id_url.fields_list(d[id_url.field(bob)])), 4)
def _do_verify(dht_value):
ret = {
'suppliers': [],
'ecc_map': None,
'customer_idurl': customer_idurl,
'revision': 0,
'publisher_idurl': None,
'timestamp': None,
}
if not dht_value or not isinstance(dht_value, dict):
result.callback(ret)
return ret
try:
_ecc_map = strng.to_text(dht_value['ecc_map'])
if as_fields:
_customer_idurl = id_url.field(dht_value['customer_idurl'])
_publisher_idurl = id_url.field(
dht_value.get('publisher_idurl'))
_suppliers_list = id_url.fields_list(dht_value['suppliers'])
else:
_customer_idurl = id_url.to_bin(dht_value['customer_idurl'])
_publisher_idurl = id_url.to_bin(
dht_value.get('publisher_idurl'))
_suppliers_list = id_url.to_bin_list(dht_value['suppliers'])
_revision = int(dht_value.get('revision'))
_timestamp = int(dht_value.get('timestamp'))
except:
lg.exc()
result.callback(ret)
return ret
ret.update({
'suppliers': _suppliers_list,
'ecc_map': _ecc_map,
'customer_idurl': _customer_idurl,
'revision': _revision,
'publisher_idurl': _publisher_idurl,
'timestamp': _timestamp,
})
return _do_identity_cache(ret)
def write_customer_suppliers(
customer_idurl,
suppliers_list,
ecc_map=None,
revision=None,
publisher_idurl=None,
):
customer_idurl = id_url.field(customer_idurl)
publisher_idurl = id_url.field(publisher_idurl)
if customer_idurl == my_id.getIDURL():
lg.warn(
'skip writing my own suppliers list which suppose to be written to DHT'
)
else:
contactsdb.set_suppliers(suppliers_list, customer_idurl=customer_idurl)
contactsdb.save_suppliers(customer_idurl=customer_idurl)
return dht_records.set_suppliers(
customer_idurl=customer_idurl,
suppliers_list=id_url.fields_list(suppliers_list),
ecc_map=ecc_map,
revision=revision,
publisher_idurl=publisher_idurl,
)
def set_customers(idlist):
"""
Set customers list.
"""
global _CustomersList
_CustomersList = id_url.fields_list(idlist)
def test_in_list(self):
self._cache_identity('alice')
self._cache_identity('bob')
self._cache_identity('carl')
l = [
id_url.field(alice_text),
id_url.field(bob),
id_url.field(frank_1),
id_url.field(frank_2),
]
with self.assertRaises(KeyError):
(id_url.field(carl) not in l)
self.assertTrue(id_url.field(alice_text) in l)
with self.assertRaises(KeyError):
(id_url.field(b'http://fake.com/frank.xml') not in l)
with self.assertRaises(KeyError):
(id_url.field(ethan_not_exist) not in l)
self.assertTrue(id_url.field(bob) in l)
with self.assertRaises(KeyError):
(id_url.field(frank_1) in l)
with self.assertRaises(KeyError):
(id_url.field(frank_2) in l)
self.assertTrue(len(l), 4)
with self.assertRaises(KeyError):
(l[0] != l[3])
with self.assertRaises(KeyError):
(l[2] == l[3])
self._cache_identity('frank')
self.assertTrue(l[2] == l[3])
self.assertTrue(l[0] != l[3])
self.assertIn(id_url.field(frank_1), l)
self.assertFalse(id_url.is_some_empty(l))
self.assertEqual(l.count(None), 0)
self.assertEqual(id_url.empty_count(l), 0)
l += [
id_url.field(b''),
] * 3
self.assertEqual(l.count(None), 3)
self.assertEqual(l.count(b''), 3)
self.assertEqual(l.count(''), 3)
self.assertEqual(l.count(id_url.field(None)), 3)
self.assertEqual(l.count(id_url.field(b'')), 3)
self.assertEqual(l.count(id_url.field('')), 3)
self.assertEqual(id_url.fields_list([
b'',
]), [
b'',
])
self.assertEqual(id_url.fields_list([
b'',
]), [
None,
])
self.assertEqual(id_url.fields_list([
id_url.field(''),
]), [
None,
])
self.assertEqual(id_url.fields_list([
None,
]), [
id_url.field(''),
])
self.assertNotEqual(id_url.fields_list([None, None]), [
id_url.field(''),
])
self.assertEqual(len(id_url.fields_list([
None,
])), 1)
def _on_incoming_contacts_packet(self, newpacket, info):
from twisted.internet import reactor # @UnresolvedImport
from logs import lg
from lib import serialization
from lib import strng
from supplier import family_member
from userid import my_id
from userid import id_url
try:
json_payload = serialization.BytesToDict(newpacket.Payload,
keys_to_text=True)
contacts_type = strng.to_text(json_payload['type'])
contacts_space = strng.to_text(json_payload['space'])
except:
lg.exc()
return False
if contacts_space != 'family_member':
return False
if contacts_type == 'suppliers_list':
try:
customer_idurl = id_url.field(json_payload['customer_idurl'])
ecc_map = strng.to_text(json_payload['customer_ecc_map'])
suppliers_list = id_url.fields_list(
json_payload['suppliers_list'])
transaction_revision = json_payload.get('transaction_revision')
except:
lg.exc()
return False
if customer_idurl.to_bin() == my_id.getLocalID().to_bin():
lg.warn('received contacts for my own customer family')
return False
if not id_url.is_cached(customer_idurl):
lg.warn('received contacts from unknown user: %r' %
customer_idurl)
return False
fm = family_member.by_customer_idurl(customer_idurl)
if not fm:
lg.warn(
'family_member() instance not found for incoming %s from %s for customer %r'
% (
newpacket,
info,
customer_idurl,
))
return False
reactor.callLater(0, fm.automat, 'contacts-received', { # @UndefinedVariable
'type': contacts_type,
'packet': newpacket,
'customer_idurl': customer_idurl,
'customer_ecc_map': ecc_map,
'suppliers_list': suppliers_list,
'transaction_revision': transaction_revision,
})
return True
elif contacts_type == 'supplier_position':
try:
customer_idurl = id_url.field(json_payload['customer_idurl'])
ecc_map = strng.to_text(json_payload['customer_ecc_map'])
supplier_idurl = id_url.field(json_payload['supplier_idurl'])
supplier_position = json_payload['supplier_position']
family_snapshot = id_url.to_bin_list(
json_payload.get('family_snapshot'))
except:
lg.exc()
return False
if customer_idurl.to_bin() == my_id.getLocalID().to_bin():
lg.warn('received contacts for my own customer family')
return False
fm = family_member.by_customer_idurl(customer_idurl)
if not fm:
lg.warn(
'family_member() instance not found for incoming %s from %s for customer %r'
% (
newpacket,
info,
customer_idurl,
))
return False
reactor.callLater(0, fm.automat, 'contacts-received', { # @UndefinedVariable
'type': contacts_type,
'packet': newpacket,
'customer_idurl': customer_idurl,
'customer_ecc_map': ecc_map,
'supplier_idurl': supplier_idurl,
'supplier_position': supplier_position,
'family_snapshot': family_snapshot,
})
return True
return False
def contacts_remote(include_all=False, include_enabled=True):
"""
Return ID's list of all known peers.
"""
l = id_url.to_bin_list(contacts(include_all=include_all, include_enabled=include_enabled))
return [i for i in id_url.fields_list(l) if not id_url.is_the_same(i, my_id.getIDURL())]
