def call_node_method(self, nodes, method_name, *args, **kwargs):
"""
Run a particular method command across a set of nodes
nodes is a list of nodes to to run the command against.
if nodes is None then we run on all nodes.
"""
if self.need_to_refresh_cluster():
self._refresh_cluster()
if nodes == 'all':
use_nodes = self.nodes.values()
elif isinstance(nodes, list):
use_nodes = []
for node in nodes:
try:
node_list = self.get_node(node)
if isinstance(node_list, list):
use_nodes.extend(self.get_node(node))
else:
use_nodes.append(self.get_node(node))
except Exception: # Ignore ambiguous and key errors
continue
else:
raise TypeError("nodes should be 'all' or list found %s" %
type(nodes))
if len(use_nodes) == 0:
raise IOError('Unable to find any Aerospike nodes')
return dict(
util.concurrent_map(
lambda node: (node.key, getattr(node, method_name)
(*args, **kwargs)), use_nodes))
def _crawl(self):
"""
Find all the nodes in the cluster and add them to self.nodes.
"""
nodes_to_add = self.find_new_nodes()
if not nodes_to_add or len(nodes_to_add) == 0:
return
try:
all_services = set()
visited = set()
unvisited = set(nodes_to_add)
while unvisited - visited:
l_unvisited = list(unvisited)
nodes = util.concurrent_map(self._register_node, l_unvisited)
live_nodes = [
node for node in nodes
if (node is not None and node.alive and node not in visited
)
]
visited |= unvisited
unvisited.clear()
if not self.only_connect_seed:
services_list = util.concurrent_map(
self._get_services, live_nodes)
for node, services in zip(live_nodes, services_list):
if isinstance(services, Exception):
continue
all_services.update(set(services))
all_services.add((node.ip, node.port, node.tls_name))
unvisited = all_services - visited
self._refresh_node_liveliness()
except Exception:
pass
finally:
self.clear_node_list()
def test_concurrent_map(self):
value = range(10)
expected = map(lambda v: v*v, value)
result = util.concurrent_map(lambda v: v*v, value)
self.assertEqual(result, expected)
def test_concurrent_map(self):
value = range(10)
expected = map(lambda v: v * v, value)
result = util.concurrent_map(lambda v: v * v, value)
self.assertEqual(result, expected,
"concurrent_map did not return the expected result")