def _do_hire_next_broker(self, prev_result, index, hiring_positions,
skip_brokers):
if index >= len(hiring_positions):
if _Debug:
lg.args(_DebugLevel,
index=index,
hiring_positions=hiring_positions,
skip_brokers=skip_brokers,
prev_result=prev_result,
connecting_brokers=self.connecting_brokers)
return
broker_pos = hiring_positions[index]
if _Debug:
lg.args(_DebugLevel,
broker_pos=broker_pos,
index=index,
hiring_positions=hiring_positions,
skip_brokers=skip_brokers,
prev_result=prev_result,
connecting_brokers=self.connecting_brokers)
if prev_result and id_url.is_not_in(
prev_result, skip_brokers, as_field=False, as_bin=True):
skip_brokers.append(prev_result)
d = self._do_lookup_one_broker(broker_pos, skip_brokers)
d.addCallback(self._do_hire_next_broker, index + 1, hiring_positions,
skip_brokers)
if _Debug:
d.addErrback(lg.errback,
debug=_Debug,
debug_level=_DebugLevel,
method='group_member._do_hire_next_broker')
d.addErrback(self._do_hire_next_broker, index + 1, hiring_positions,
skip_brokers)
def unregister_share(A):
"""
"""
global _ActiveShares
global _ActiveSharesByIDURL
_ActiveShares.pop(A.key_id, None)
if id_url.is_not_in(A.customer_idurl, _ActiveSharesByIDURL):
lg.warn('given customer idurl not found in active shares list')
else:
_ActiveSharesByIDURL[A.customer_idurl] = []
def isSomeCandidatesListed(self, *args, **kwargs):
"""
Condition method.
"""
global _SuppliersToHire
available = []
for idurl in _SuppliersToHire:
if id_url.is_not_in(idurl, contactsdb.suppliers(), as_field=False):
available.append(idurl)
return len(available) > 0
def register_share(A):
"""
"""
global _ActiveShares
global _ActiveSharesByIDURL
if A.key_id in _ActiveShares:
raise Exception('share already exist')
if id_url.is_not_in(A.customer_idurl, _ActiveSharesByIDURL):
_ActiveSharesByIDURL[A.customer_idurl] = []
_ActiveSharesByIDURL[A.customer_idurl].append(A)
_ActiveShares[A.key_id] = A
def doPopCandidate(self, *args, **kwargs):
"""
Action method.
"""
global _SuppliersToHire
for idurl in _SuppliersToHire:
if id_url.is_not_in(idurl, contactsdb.suppliers(), as_field=False):
self.target_idurl = id_url.field(idurl)
_SuppliersToHire.remove(idurl)
break
lg.info('populate supplier %r from "hire" list, %d more in the list' %
(self.target_idurl, len(_SuppliersToHire)))
def register_group_member(A):
"""
"""
global _ActiveGroupMembers
global _ActiveGroupMembersByIDURL
if _Debug:
lg.args(_DebugLevel, instance=repr(A))
if A.group_key_id in _ActiveGroupMembers:
raise Exception('group_member already exist')
_ActiveGroupMembers[A.group_key_id] = A
if id_url.is_not_in(A.group_creator_idurl, _ActiveGroupMembersByIDURL):
_ActiveGroupMembersByIDURL[A.group_creator_idurl] = []
_ActiveGroupMembersByIDURL[A.group_creator_idurl].append(A)
def _do_collect_results(all_results):
if _Debug:
lg.args(_DebugLevel, all_results=len(all_results))
final_result = []
all_brokers = []
for one_success, one_result in all_results:
if one_success and one_result['broker_idurl']:
if id_url.is_not_in(one_result['broker_idurl'],
all_brokers,
as_field=False):
all_brokers.append(one_result['broker_idurl'])
final_result.append(one_result)
result.callback(final_result)
return None
def doRemoveSuppliers(self, *args, **kwargs):
"""
Action method.
"""
current_suppliers = contactsdb.suppliers()
desired_suppliers = settings.getSuppliersNumberDesired()
if len(current_suppliers) < desired_suppliers:
lg.warn('must have more suppliers %d<%d' %
(len(current_suppliers), desired_suppliers))
removed_suppliers = []
for supplier_idurl in self.dismiss_list:
if id_url.is_not_in(supplier_idurl,
current_suppliers,
as_field=False):
lg.warn('%s not a supplier' % supplier_idurl)
continue
pos = current_suppliers.index(id_url.field(supplier_idurl))
current_suppliers[pos] = ''
removed_suppliers.append((
pos,
supplier_idurl,
))
misc.writeSupplierData(
supplier_idurl,
'disconnected',
time.strftime('%d-%m-%Y %H:%M:%S'),
my_id.getLocalID(),
)
current_suppliers = current_suppliers[:desired_suppliers]
contactsdb.update_suppliers(current_suppliers)
contactsdb.save_suppliers()
from main import control
control.on_suppliers_changed(current_suppliers)
for position, supplier_idurl in removed_suppliers:
events.send(
'supplier-modified',
dict(
new_idurl=None,
old_idurl=supplier_idurl,
position=position,
))
lg.info(
'removed some suppliers : %d desired_suppliers=%d current_suppliers=%d'
% (len(self.dismiss_list), desired_suppliers,
len(contactsdb.suppliers())))
if _Debug:
lg.out(_DebugLevel,
' my current suppliers: %r' % contactsdb.suppliers())
def unregister_group_member(A):
"""
"""
global _ActiveGroupMembers
global _ActiveGroupMembersByIDURL
if _Debug:
lg.args(_DebugLevel, instance=repr(A))
if id_url.is_not_in(A.group_creator_idurl, _ActiveGroupMembersByIDURL):
lg.warn(
'for given customer idurl %r did not found active group members list'
% A.group_creator_idurl)
else:
if A in _ActiveGroupMembersByIDURL[A.group_creator_idurl]:
_ActiveGroupMembersByIDURL[A.group_creator_idurl].remove(A)
else:
lg.warn('group_member() instance not found for customer %r' %
A.group_creator_idurl)
_ActiveGroupMembers.pop(A.group_key_id, None)
def test_in_dict(self):
self._cache_identity('alice')
self._cache_identity('bob')
self._cache_identity('carl')
d = {}
d[id_url.field(alice_text)] = 'alice'
d[id_url.field(bob)] = 'bob'
self.assertIn(id_url.field(alice_text), d)
self.assertNotIn(id_url.field(carl), d)
self.assertTrue(id_url.is_in(alice_text, d))
self.assertTrue(id_url.is_not_in(carl, d))
d2 = {
id_url.field(bob): 'bob',
'some_key': 'some_value',
}
self.assertIn('some_key', d2)
keys = list(d2.keys())
with self.assertRaises(TypeError):
(keys[0] != keys[1])
def verify_broker(self, broker_idurl, position, known_brokers, known_streams):
if not self.InSync or self.state != 'CONNECTED':
lg.warn('not able to verify another broker because %r is not in sync' % self)
return None
if self.cooperated_brokers:
if id_url.is_not_in(broker_idurl, self.cooperated_brokers.values()):
return 'unknown broker'
if position not in self.cooperated_brokers.keys():
return 'unknown position'
if not id_url.is_the_same(self.cooperated_brokers[position], broker_idurl):
return 'position mismatch'
if len(self.cooperated_brokers) != len(known_brokers):
return 'brokers count mismatch'
for i, b_idurl in self.cooperated_brokers.items():
if not id_url.is_the_same(known_brokers[i], b_idurl):
return 'broker mismatch'
if self.known_streams and known_streams:
for my_queue_alias, my_archive_folder_path in self.known_streams.items():
for other_queue_alias, other_archive_folder_path in self.known_streams.items():
# TODO: verify streams
pass
return None
def doHireNewBroker(self, event, *args, **kwargs):
"""
Action method.
"""
known_brokers = {}
known_brokers.update(self.cooperated_brokers or {})
known_brokers[self.desired_position] = self.my_broker_idurl
target_pos = self.desired_position - 1
exclude_brokers = list(
id_url.to_bin_list(filter(None, self.dht_brokers.values())))
exclude_brokers.extend(
list(
id_url.to_bin_list(
filter(None, self.requestor_known_brokers.values()))))
preferred_brokers = []
preferred_brokers_raw = config.conf().getData(
'services/message-broker/preferred-brokers').strip()
if preferred_brokers_raw:
preferred_brokers_list = re.split('\n|,|;| ',
preferred_brokers_raw)
preferred_brokers.extend(preferred_brokers_list)
preferred_brokers = id_url.to_bin_list(preferred_brokers)
if preferred_brokers:
preferred_brokers = [
x for x in preferred_brokers if x not in exclude_brokers
]
if _Debug:
lg.args(_DebugLevel,
e=event,
my=self.my_position,
desired=self.desired_position,
target=target_pos,
exclude=exclude_brokers,
preferred=preferred_brokers)
if preferred_brokers:
preferred_broker_idurl = id_url.field(preferred_brokers[0])
if preferred_broker_idurl and id_url.is_not_in(
preferred_broker_idurl, exclude_brokers, as_field=False):
result = p2p_service_seeker.connect_known_node(
remote_idurl=preferred_broker_idurl,
service_name='service_message_broker',
service_params=lambda idurl: self
._do_prepare_service_request_params(
idurl, target_pos, known_brokers, event),
request_service_timeout=self.broker_negotiate_ack_timeout *
(target_pos + 1),
exclude_nodes=list(exclude_brokers),
force_handshake=True,
attempts=1,
)
result.addCallback(self._on_new_broker_hired, target_pos,
self.my_position, self.desired_position)
if _Debug:
result.addErrback(
lg.errback,
debug=_Debug,
debug_level=_DebugLevel,
method='broker_negotiator.doHirePrevBroker')
result.addErrback(self._on_new_broker_lookup_failed,
target_pos)
return
result = p2p_service_seeker.connect_random_node(
lookup_method=lookup.random_message_broker,
service_name='service_message_broker',
service_params=lambda
idurl: self._do_prepare_service_request_params(
idurl, target_pos, known_brokers, event),
request_service_timeout=self.broker_negotiate_ack_timeout *
(target_pos + 1),
exclude_nodes=list(exclude_brokers),
attempts=1,
force_handshake=True,
)
result.addCallback(self._on_new_broker_hired, target_pos,
self.my_position, self.desired_position)
if _Debug:
result.addErrback(lg.errback,
debug=_Debug,
debug_level=_DebugLevel,
method='broker_negotiator.doHirePrevBroker')
result.addErrback(self._on_new_broker_lookup_failed, target_pos)
