def test_real(self):
options = [{'availability_zone': {u'name': u'ap-southeast-2a', u'zone_state': u'available',
u'region_name': u'ap-southeast-2'}, 'name': u'ap-southeast-2',
'region_name': u'ap-southeast-2'}]
enumerable = [
{'country': 'Australia',
'availability_zone': {'name': 'ap-southeast-2a', 'zone_state': 'available',
'region_name': 'ap-southeast-2'},
'driver': 'EC2NodeDriver', 'id': '0', 'name': 'ap-southeast-2a'}, {'country': 'Australia',
'availability_zone': {
'name': 'ap-southeast-2b',
'zone_state': 'available',
'region_name': 'ap-southeast-2'},
'driver': 'EC2NodeDriver',
'id': '1',
'name': 'ap-southeast-2b'},
{'country': 'Australia', 'availability_zone': {'name': 'ap-southeast-2c', 'zone_state': 'available',
'region_name': 'ap-southeast-2'},
'driver': 'EC2NodeDriver', 'id': '2', 'name': 'ap-southeast-2c'}]
self.assertDictEqual(enumerable[0]['availability_zone'], options[0]['availability_zone'])
intersect = tuple(lists_of_dicts_intersection_on(('availability_zone',), enumerable, options))
self.assertGreater(len(intersect), 0, 'intersect is empty')
it_consumes(self.assertEqual(obj['availability_zone'], options[idx]['availability_zone'])
for idx, obj in enumerate(intersect))
def pp_lines(log, result, key, op=None, op_args=None):
it_consumes(
list(
map(
lambda l: log.info("{host} - {l}".format(
host=result._host.name, l=l)),
result._result[key] if op is None else getattr(
result._result[key], op)(
*(iter(()) if op_args is None else op_args)),
)))
def test_simple(self):
l0 = [{'foo': 5, 'bar': 'foobar', 'can': 5}]
l1 = [{'foo': 5, 'bar': 'foobar', 'can': 6}]
r0 = tuple(lists_of_dicts_intersection_on(('foo', 'bar'), l0, l1))
self.assertGreater(len(r0), 0, 'r0 is empty')
it_consumes(all((self.assertEqual(obj['foo'], l1[idx]['foo']),
self.assertEqual(obj['bar'], l1[idx]['bar'])))
for idx, obj in enumerate(r0))
r1 = tuple(lists_of_dicts_intersection_on(('foo', 'can'), l0, l1))
self.assertEqual(len(r1), 0, 'r1 is not empty')
def test_complex(self):
l0 = [{'foo': 5e5, 'can': u'haz', 'bar': [{'alpha': 'a'}]}]
l1 = [{'foo': 5e5, 'can': u'haz', 'bar': [{'alpha': 'b'}]}]
l2 = [{'foo': 5e6, 'can': u'haz', 'bar': [{'alpha': 'b'}]}]
r0 = tuple(lists_of_dicts_intersection_on(('foo', 'bar'), l0, l1))
self.assertEqual(len(r0), 0, 'r0 is not empty')
r1 = tuple(lists_of_dicts_intersection_on(('foo', 'can'), l0, l1))
self.assertGreater(len(r1), 0, 'r1 is empty')
it_consumes(all((self.assertEqual(obj['foo'], l1[idx]['foo']),
self.assertEqual(obj['can'], l1[idx]['can'])))
for idx, obj in enumerate(r1))
r2 = tuple(lists_of_dicts_intersection_on(('can', 'bar'), l1, l2))
self.assertGreater(len(r2), 0, 'r2 is empty')
it_consumes(all((self.assertEqual(obj['can'], l2[idx]['can']),
self.assertEqual(obj['bar'], l2[idx]['bar'])))
for idx, obj in enumerate(r2))
r3 = next(lists_of_dicts_intersection_on_any((('foo', 'bar'), ('foo', 'can')), l0, l1))
self.assertIsNotNone(r3, 'r3 is None')
it_consumes(all((self.assertEqual(obj['foo'], l1[idx]['foo']),
self.assertEqual(obj['can'], l1[idx]['can'])))
for idx, obj in enumerate([r3]))
def destroy(config_filename, restrict_provider_to=None):
with open(config_filename, 'rt') as f:
config_contents = f.read()
config_dict = loads(replace_variables(config_contents))
del config_contents
providers = tuple(obj for obj in config_dict['provider']['options']
if obj['provider']['name'] in restrict_provider_to
or obj['provider']['name'] == restrict_provider_to) if restrict_provider_to \
else tuple(obj for obj in config_dict['provider']['options'])
client = (lambda etcd_server_location: Client(
protocol=etcd_server_location.scheme,
host=etcd_server_location.hostname,
port=etcd_server_location.port
))(urlparse(config_dict['etcd_server']))
provider2conf_and_driver = dict(
imap(lambda provider_dict: (provider_dict['provider']['name'],
namedtuple('_', 'conf driver_cls')(
provider_dict,
(lambda provider_cls: provider_cls(
region=provider_dict['provider']['region'],
**provider_dict['auth']
))(get_driver(
getattr(Provider, provider_dict['provider']['name'])
if hasattr(Provider, provider_dict['provider']['name'])
else itemgetter(1)(next(ifilter(
lambda (prov_name, value): value == provider_dict['provider'][
'name'].lower(),
imap(lambda prov_name: (prov_name, getattr(Provider, prov_name)),
dir(Provider))
)))
)))), providers)
)
# Map nodes to their provider, including ones outside etcd
provider2nodes = {
provider: tuple(
namedtuple('_', 'uuid node')(node.uuid, node) for node in
driver.driver_cls.list_nodes(*((driver.conf['create_with']['ex_cloud_service_name'],)
if driver.conf['provider']['name'] == 'AZURE'
else tuple()
))
if driver.driver_cls.NODE_STATE_MAP and node.state in (
driver.driver_cls.NODE_STATE_MAP.get(
'running',
next((node.state for k, v in driver.driver_cls.NODE_STATE_MAP.iteritems()
if 'running' in v), None)
),
driver.driver_cls.NODE_STATE_MAP.get('active')
) or not driver.driver_cls.NODE_STATE_MAP and node.state in ('running',)
)
for provider, driver in provider2conf_and_driver.iteritems()}
uuid2key = {loads(client.get(key).value)['uuid']: key
for key in flatten(etcd_ls(client))
if (lambda v: isinstance(v, basestring) and v.startswith('{'))(client.get(key).value)}
# TODO: Only call `client.get` once per `key` ^
# Filter to just ones inside etcd; then deprovision and delete from etcd
logger.info('Dropped: {}'.format(
{
provider: tuple(imap(lambda n: rm_prov_etcd(client, n.node), nodes))
for provider, nodes in provider2nodes.iteritems()
for node in nodes
if node.uuid in uuid2key
}
))
# Delete all empty etcd directories.
for i in xrange(20): # TODO: walk the tree rather than hackily rerun
it_consumes(
logger.info('rmdir {directory}'.format(directory=directory, res=client.delete(directory, dir=True)))
for directory in flatten(etcd_empty_dirs(client))
)
return client
