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")