def wipeout(self, dry_run=False):
vpc_obj = self.vpc_obj(create=False, dry_run=dry_run)
if vpc_obj and not dry_run:
log.info("Wiping out VPC ID {}".format(vpc_obj.id))
self.vpc().delete_vpc(vpc_obj.id)
stanza('vpc', {})
else:
log.info("No VPC in YAML; nothing to do")
return None
def wipeout(self, dry_run=False):
vpc_obj = self.vpc_obj(create=False, dry_run=dry_run)
if vpc_obj and not dry_run:
log.info("Wiping out VPC ID {}".format(vpc_obj.id))
self.vpc().delete_vpc(vpc_obj.id)
stanza('vpc', {})
else:
log.info("No VPC in YAML; nothing to do")
return None
def walk_clusters(self, operation=None, dry_run=False):
ec2 = self._delegate["ec2"]
delegate = self._delegate["delegate"]
c_stanza = stanza("clusters")
if delegate not in c_stanza:
log.warning("Delegate {} has no instances".format(delegate))
return None
if operation == "start":
what_done = "started"
do_what = ec2.start_instances
elif operation == "stop":
what_done = "stopped"
do_what = ec2.stop_instances
elif operation == "wipeout":
what_done = "terminated"
do_what = ec2.terminate_instances
else:
assert 1 == 0
instance_id_list = []
iv_map = {} # keys are instance IDs and values are volume IDs
for role in c_stanza[delegate]:
if dry_run:
log.info("Dry run: doing nothing for role {!r}".format(role))
continue
i_id = c_stanza[delegate][role]["instance_id"]
instance_id_list.append(i_id)
if "volume_id" in c_stanza[delegate][role]:
iv_map[i_id] = {"volume_id": c_stanza[delegate][role]["volume_id"], "role": role}
if operation == "wipeout" and iv_map:
ec2.stop_instances(instance_ids=iv_map.keys())
# for i_id in iv_map.keys():
# self.instance_await_state(
# iv_map[i_id]['role'],
# i_id,
# state='stopped',
# )
log.info("Detaching {} volumes...".format(len(iv_map)))
for i_id in iv_map.keys():
v_id = iv_map[i_id]["volume_id"]
v_list = ec2.get_all_volume_status(volume_ids=[v_id])
log.debug("Volume {} status {}".format(v_id, v_list[0].__dict__))
if self.is_attached(v_id, i_id):
ec2.detach_volume(v_id, instance_id=i_id, device="/dev/sdb", force=True)
log.info("Deleting {} volumes...".format(len(iv_map)))
for i_id in iv_map.keys():
v_id = iv_map[i_id]["volume_id"]
self.wait_for_detachment(v_id, i_id)
ec2.delete_volume(v_id)
if instance_id_list:
do_what(instance_ids=instance_id_list)
if operation == "wipeout" and not dry_run:
del (c_stanza[delegate])
stanza("clusters", c_stanza)
log.info("{} instances {} for delegate {}".format(len(instance_id_list), what_done, delegate))
def wipeout(self, dry_run=False):
s_obj = self.subnet_obj(create=False, dry_run=dry_run)
if s_obj:
if not dry_run:
log.info("Wiping out Subnet ID {}".format(s_obj.id))
self.vpc().delete_subnet(s_obj.id)
s_stanza = stanza('subnets')
d = self._subnet['delegate']
del(s_stanza[d])
stanza('subnets', s_stanza)
else:
log.info("Dry run: nothing to do")
else:
log.info("No VPC in YAML: nothing to do")
return None
def wipeout(self, dry_run=False):
s_obj = self.subnet_obj(create=False, dry_run=dry_run)
if s_obj:
if not dry_run:
log.info("Wiping out Subnet ID {}".format(s_obj.id))
self.vpc().delete_subnet(s_obj.id)
s_stanza = stanza('subnets')
d = self._subnet['delegate']
del (s_stanza[d])
stanza('subnets', s_stanza)
else:
log.info("Dry run: nothing to do")
else:
log.info("No VPC in YAML: nothing to do")
return None
def import_keypair(self, dry_run):
d = self._keypair['delegate']
if dry_run:
log.info("Dry run: doing nothing")
return None
# we pitifully assume the user has already run generate-keys.sh
k_name = "{}-d{}".format(stanza('keyname'), d)
k_mat = self.get_key_material(k_name)
k_obj = self.ec2().import_key_pair(k_name, k_mat)
log.info("Keypair {} imported to AWS".format(k_name))
self._keypair['keypair_obj'] = k_obj
self._keypair['key_name'] = k_name
k_stanza = stanza('keypairs')
k_stanza[d] = {}
k_stanza[d]['keyname'] = k_name
stanza('keypairs', k_stanza)
def import_keypair(self, dry_run):
d = self._keypair['delegate']
if dry_run:
log.info("Dry run: doing nothing")
return None
# we pitifully assume the user has already run generate-keys.sh
k_name = "{}-d{}".format(stanza('keyname'), d)
k_mat = self.get_key_material(k_name)
k_obj = self.ec2().import_key_pair(k_name, k_mat)
log.info("Keypair {} imported to AWS".format(k_name))
self._keypair['keypair_obj'] = k_obj
self._keypair['key_name'] = k_name
k_stanza = stanza('keypairs')
k_stanza[d] = {}
k_stanza[d]['keyname'] = k_name
stanza('keypairs', k_stanza)
def test_stanza_assignment(self):
# existing stanza
self.reset_yaml()
orig_val = myyaml.stanza('delegates')
self.assertEqual(orig_val, 1)
new_val = 90125
myyaml.stanza('delegates', new_val)
self.assertEqual(myyaml.stanza('delegates'), new_val)
myyaml.stanza('delegates', orig_val)
self.assertEqual(myyaml.stanza('delegates'), orig_val)
# non-existing stanza
self.reset_yaml()
with self.assertRaises(AssertionError):
myyaml.stanza('prd', {})
def test_stanza_assignment(self):
# existing stanza
self.reset_yaml()
orig_val = myyaml.stanza('delegates')
self.assertEqual(orig_val, 1)
new_val = 90125
myyaml.stanza('delegates', new_val)
self.assertEqual(myyaml.stanza('delegates'), new_val)
myyaml.stanza('delegates', orig_val)
self.assertEqual(myyaml.stanza('delegates'), orig_val)
# non-existing stanza
self.reset_yaml()
with self.assertRaises(AssertionError):
myyaml.stanza('prd', {})
def region(self):
"""
gets region from yaml, default to eu-west-1
"""
if self._region['region_str']:
return self._region['region_str']
self._region['region_str'] = stanza('region')['region_str']
log.debug("Region is {}".format(self._region['region_str']))
return self._region['region_str']
def process_delegate_list(self):
max_d = stanza('delegates')
if self.args.delegate_list is None:
self.args.delegate_list = list()
if self.args.all:
self.args.delegate_list = list(range(1, max_d + 1))
if self.args.master:
self.args.delegate_list.insert(0, 0)
self.validate_delegate_list()
log.info("Delegate list is {!r}".format(self.args.delegate_list))
def process_delegate_list(self):
max_d = stanza('delegates')
if self.args.delegate_list is None:
self.args.delegate_list = []
if self.args.all:
self.args.delegate_list = range(1, max_d + 1)
if self.args.master:
self.args.delegate_list.insert(0, 0)
self.validate_delegate_list()
log.info("Delegate list is {!r}".format(self.args.delegate_list))
def availability_zone(self):
"""
gets availability_zone from yaml, default to None
"""
if self._region['az']:
return self._region['az']
self._region['az'] = stanza('region')['availability_zone']
if self._region['az']:
log.debug("Availability zone is {}"
.format(self._region['az']))
return self._region['az']
def public_ips(self):
delegate = self._delegate["delegate"]
c_stanza = stanza("clusters")
public_ips = {}
if delegate not in c_stanza:
log.info("Delegate {} not instantiated".format(delegate))
return None
d_stanza = c_stanza[delegate]
for role in d_stanza.keys():
public_ips[role] = self.fetch_public_ip(role)
return public_ips
def public_ips(self):
delegate = self._delegate['delegate']
c_stanza = stanza('clusters')
public_ips = {}
if delegate not in c_stanza:
log.info("Delegate {} not instantiated".format(delegate))
return None
d_stanza = c_stanza[delegate]
for role in d_stanza.keys():
public_ips[role] = self.fetch_public_ip(role)
return public_ips
def validate_delegate_list(self):
dl = self.args.delegate_list
if dl is None or len(dl) == 0:
return True
max_delegates = stanza('delegates')
log.debug("Maximum number of delegates is {!r}".format(max_delegates))
assert (max_delegates is not None and max_delegates > 0
and max_delegates <= 100
), "Bad delegates stanza in YAML: {!r}".format(max_delegates)
assert dl[-1] <= max_delegates, (
("Delegate list exceeds {!r} (maximum number of " +
"delegates in YAML)").format(max_delegates))
def probe(self):
delegate = self._delegate["delegate"]
c_stanza = stanza("clusters")
if delegate not in c_stanza:
log.info("Delegate {} not instantiated".format(delegate))
return None
d_stanza = c_stanza[delegate]
retval = False
for role in d_stanza.keys():
retval = True
log.info("Delegate {}, role {}, public IP {}".format(delegate, role, self.fetch_public_ip(role)))
return retval
def get_keyname_from_yaml(self):
if self._keypair['keyname']:
return self._keypair['keyname']
k_stanza = stanza('keypairs')
log.debug("Keypairs stanza is {!r}".format(k_stanza))
assert type(k_stanza) == dict
d = self._keypair['delegate']
if d in k_stanza:
if 'keyname' in k_stanza[d]:
if k_stanza[d]['keyname']:
self._keypair['keyname'] = k_stanza[d]['keyname']
return k_stanza[d]['keyname']
return None
def probe(self):
delegate = self._delegate['delegate']
c_stanza = stanza('clusters')
if delegate not in c_stanza:
log.info("Delegate {} not instantiated".format(delegate))
return None
d_stanza = c_stanza[delegate]
retval = False
for role in d_stanza.keys():
retval = True
log.info("Delegate {}, role {}, public IP {}".format(
delegate, role, self.fetch_public_ip(role)))
return retval
def get_keyname_from_yaml(self):
if self._keypair['keyname']:
return self._keypair['keyname']
k_stanza = stanza('keypairs')
log.debug("Keypairs stanza is {!r}".format(k_stanza))
assert type(k_stanza) == dict
d = self._keypair['delegate']
if d in k_stanza:
if 'keyname' in k_stanza[d]:
if k_stanza[d]['keyname']:
self._keypair['keyname'] = k_stanza[d]['keyname']
return k_stanza[d]['keyname']
return None
def validate_delegate_list(self):
dl = self.args.delegate_list
if dl is None or len(dl) == 0:
return True
max_delegates = stanza('delegates')
log.debug("Maximum number of delegates is {!r}".format(max_delegates))
assert (
max_delegates is not None and
max_delegates > 0 and
max_delegates <= 100
), "Bad delegates stanza in YAML: {!r}".format(max_delegates)
assert dl[-1] <= max_delegates, (
("Delegate list exceeds {!r} (maximum number of " +
"delegates in YAML)").format(max_delegates)
)
def roles_to_install(self):
delegate = self._delegate['delegate']
rti = []
rdd = {}
if delegate == 0:
role_def = self.assemble_role_def('master')
rdd['master'] = role_def
rti.append('master')
if delegate > 0:
cluster_def = stanza('cluster-definition')
for cluster_def_entry in cluster_def:
role = cluster_def_entry['role']
role_def = self.assemble_role_def(role)
rdd[role] = role_def
rti.append(role)
return (rti, rdd)
def roles_to_install(self):
delegate = self._delegate["delegate"]
rti = []
rdd = {}
if delegate == 0:
role_def = self.assemble_role_def("master")
rdd["master"] = role_def
rti.append("master")
if delegate > 0:
cluster_def = stanza("cluster-definition")
for cluster_def_entry in cluster_def:
role = cluster_def_entry["role"]
role_def = self.assemble_role_def(role)
rdd[role] = role_def
rti.append(role)
return (rti, rdd)
def install(self, dry_run=False):
self._delegate['roles'] = self.ready_to_install(dry_run=dry_run)
if not self._delegate['roles']:
return None
if dry_run:
log.info("Dry run: doing nothing")
delegate = self._delegate['delegate']
c_stanza = stanza('clusters')
c_stanza[delegate] = {}
stanza('clusters', c_stanza)
self.set_subnet_map_public_ip()
# instantiate node for each role
aws_objs = {}
for role in self._delegate['roles']:
c_stanza[delegate][role] = {}
stanza('clusters', c_stanza)
(i_obj, v_obj) = self.instantiate_role(role)
aws_objs[role] = {}
aws_objs[role]['instance_obj'] = i_obj
aws_objs[role]['volume_obj'] = v_obj
c_stanza[delegate][role]['instance_id'] = i_obj.id
c_stanza[delegate][role]['placement'] = i_obj.placement
if v_obj:
c_stanza[delegate][role]['volume_id'] = v_obj.id
stanza('clusters', c_stanza)
log.info("Instantiated {} node (instance ID {})".format(
role, i_obj.id))
# attach volumes
ec2 = self._delegate['ec2']
for role in self._delegate['roles']:
i_obj = aws_objs[role]['instance_obj']
v_obj = aws_objs[role]['volume_obj']
if v_obj:
c_stanza[delegate][role]['volume_id'] = v_obj.id
self.instance_await_state(role, i_obj.id, state='running')
self.volume_await_state(role, v_obj.id, state='available')
assert ec2.attach_volume(v_obj.id, i_obj.id, '/dev/sdb'), (
"Failed to attach volume to role {}, delegate {}".format(
role, delegate))
return None
def install(self, dry_run=False):
self._delegate["roles"] = self.ready_to_install(dry_run=dry_run)
if not self._delegate["roles"]:
return None
if dry_run:
log.info("Dry run: doing nothing")
delegate = self._delegate["delegate"]
c_stanza = stanza("clusters")
c_stanza[delegate] = {}
stanza("clusters", c_stanza)
self.set_subnet_map_public_ip()
# instantiate node for each role
aws_objs = {}
for role in self._delegate["roles"]:
c_stanza[delegate][role] = {}
stanza("clusters", c_stanza)
(i_obj, v_obj) = self.instantiate_role(role)
aws_objs[role] = {}
aws_objs[role]["instance_obj"] = i_obj
aws_objs[role]["volume_obj"] = v_obj
c_stanza[delegate][role]["instance_id"] = i_obj.id
c_stanza[delegate][role]["placement"] = i_obj.placement
if v_obj:
c_stanza[delegate][role]["volume_id"] = v_obj.id
stanza("clusters", c_stanza)
log.info("Instantiated {} node (instance ID {})".format(role, i_obj.id))
# attach volumes
ec2 = self._delegate["ec2"]
for role in self._delegate["roles"]:
i_obj = aws_objs[role]["instance_obj"]
v_obj = aws_objs[role]["volume_obj"]
if v_obj:
c_stanza[delegate][role]["volume_id"] = v_obj.id
self.instance_await_state(role, i_obj.id, state="running")
self.volume_await_state(role, v_obj.id, state="available")
assert ec2.attach_volume(
v_obj.id, i_obj.id, "/dev/sdb"
), "Failed to attach volume to role {}, delegate {}".format(role, delegate)
return None
def subnet_obj(self, create=False, dry_run=False):
"""
Subnet object is returned from cache if cached.
Otherwise, the method validates the subnet, creates it if
necessary, populates tree, and returns subnet object.
"""
if self._subnet['s_obj']:
return self._subnet['s_obj']
s_stanza = stanza('subnets')
log.debug("Subnet stanza {!r}".format(s_stanza))
az = self.availability_zone()
vpc = self.vpc()
vpc_obj = self.vpc_obj(create=False, quiet=True)
delegate = self._subnet['delegate']
cidr_block = '10.0.{}.0/24'.format(delegate)
if delegate not in s_stanza or s_stanza[delegate] == {}:
#
# create new subnet
if create:
s_stanza[delegate] = {}
log.debug("About to create subnet {}".format(cidr_block))
if dry_run:
log.info("Dry run: doing nothing")
s_obj = None
else:
s_obj = vpc.create_subnet(vpc_obj.id,
cidr_block,
dry_run=dry_run,
availability_zone=az)
log.info("Created subnet {} ({})".format(
s_obj.id, s_obj.cidr_block))
s_stanza[delegate]['cidr_block'] = s_obj.cidr_block
s_stanza[delegate]['id'] = s_obj.id
stanza('subnets', s_stanza)
apply_tag(s_obj, tag='Name', val=stanza('nametag'))
apply_tag(s_obj, tag='Delegate', val=delegate)
else:
log.info(
"Delegate {} subnet ID missing in yaml".format(delegate))
s_obj = None
return s_obj
#
# check id exists and cidr_block matches
s_id = s_stanza[delegate]['id']
log.debug("Getting subnet id {}".format(s_id))
s_list = vpc.get_all_subnets(subnet_ids=[s_id])
assert len(s_list) == 1, "Subnet ID {} does not exist".format(s_id)
s_obj = s_list[0]
log.info("Found subnet {} ({})".format(s_obj.id, s_obj.cidr_block))
if ('cidr_block' not in s_stanza[delegate] or
s_stanza[delegate]['cidr_block'] is None): # pragma: no cover
#
# set cidr_block
s_stanza[delegate]['cidr_block'] = s_obj.cidr_block
stanza('subnets', s_stanza)
else:
#
# validate cidr_block
assert s_stanza[delegate]['cidr_block'] == s_obj.cidr_block, ((
"Delegate {} is supposed to have subnet {}, but that "
"subnet exists with non-matching CIDR block {}").format(
delegate, s_stanza[delegate]['cidr_block'],
s_obj.cidr_block))
self._subnet['s_obj'] = s_obj
# if self.args.retag:
# apply_tag(s_obj, tag='Name', val=stanza('nametag'))
# apply_tag(s_obj, tag='Delegate', val=delegate)
return s_obj
def apply_tags(self, aws_obj, role=None):
delegate = self._delegate['delegate']
apply_tag(aws_obj, tag='Name', val=stanza('nametag'))
apply_tag(aws_obj, tag='Role', val=role)
apply_tag(aws_obj, tag='Delegate', val=delegate)
def apply_tags(self, aws_obj, role=None):
delegate = self._delegate["delegate"]
apply_tag(aws_obj, tag="Name", val=stanza("nametag"))
apply_tag(aws_obj, tag="Role", val=role)
apply_tag(aws_obj, tag="Delegate", val=delegate)
def walk_clusters(self, operation=None, dry_run=False):
ec2 = self._delegate['ec2']
delegate = self._delegate['delegate']
c_stanza = stanza('clusters')
if delegate not in c_stanza:
log.warning("Delegate {} has no instances".format(delegate))
return None
if operation == "start":
what_done = "started"
do_what = ec2.start_instances
elif operation == "stop":
what_done = "stopped"
do_what = ec2.stop_instances
elif operation == "wipeout":
what_done = "terminated"
do_what = ec2.terminate_instances
else:
assert 1 == 0
instance_id_list = []
iv_map = {} # keys are instance IDs and values are volume IDs
for role in c_stanza[delegate]:
if dry_run:
log.info("Dry run: doing nothing for role {!r}".format(role))
continue
i_id = c_stanza[delegate][role]['instance_id']
instance_id_list.append(i_id)
if 'volume_id' in c_stanza[delegate][role]:
iv_map[i_id] = {
'volume_id': c_stanza[delegate][role]['volume_id'],
'role': role
}
if operation == "wipeout" and iv_map:
ec2.stop_instances(instance_ids=iv_map.keys())
# for i_id in iv_map.keys():
# self.instance_await_state(
# iv_map[i_id]['role'],
# i_id,
# state='stopped',
# )
log.info("Detaching {} volumes...".format(len(iv_map)))
for i_id in iv_map.keys():
v_id = iv_map[i_id]['volume_id']
v_list = ec2.get_all_volume_status(volume_ids=[v_id])
log.debug("Volume {} status {}".format(v_id,
v_list[0].__dict__))
if self.is_attached(v_id, i_id):
ec2.detach_volume(v_id,
instance_id=i_id,
device='/dev/sdb',
force=True)
log.info("Deleting {} volumes...".format(len(iv_map)))
for i_id in iv_map.keys():
v_id = iv_map[i_id]['volume_id']
self.wait_for_detachment(v_id, i_id)
ec2.delete_volume(v_id)
if instance_id_list:
do_what(instance_ids=instance_id_list)
if operation == "wipeout" and not dry_run:
del (c_stanza[delegate])
stanza('clusters', c_stanza)
log.info("{} instances {} for delegate {}".format(
len(instance_id_list), what_done, delegate))
def assemble_role_def(self, role):
rd = stanza('role-definitions')
rv = copy.deepcopy(rd['defaults'])
for a in rd[role]:
rv[a] = rd[role][a]
return rv
def vpc_obj(self, create=False, dry_run=False, quiet=False):
"""
fetch VPC object, create if necessary
"""
#
# cached VPC object
if self._vpc['vpc_obj'] is not None:
return self._vpc['vpc_obj']
#
# non-cached
vpc_stanza = stanza('vpc')
vpc_conn = self.vpc()
if len(vpc_stanza) == 0: # pragma: no cover
#
# create VPC
if create:
if dry_run:
log.info("Dry run: do nothing")
vpc_obj = None
else:
log.info("VPC ID not specified in yaml: creating VPC")
vpc_obj = vpc_conn.create_vpc('10.0.0.0/16')
vpc_stanza['id'] = vpc_obj.id
vpc_stanza['cidr_block'] = vpc_obj.cidr_block
log.info("New VPC ID {} created with CIDR block {}".format(
vpc_obj.id, vpc_obj.cidr_block))
apply_tag(vpc_obj, tag='Name', val=stanza('nametag'))
self._vpc['vpc_obj'] = vpc_obj
stanza('vpc', {
'cidr_block': vpc_obj.cidr_block,
'id': vpc_obj.id
})
vpc_conn.modify_vpc_attribute(
vpc_obj.id,
enable_dns_support=True,
)
vpc_conn.modify_vpc_attribute(
vpc_obj.id,
enable_dns_hostnames=True,
)
else:
log.info("VPC ID not specified in yaml: nothing to do")
vpc_obj = None
return vpc_obj
#
# existing VPC
log.debug("VPD ID specified in yaml: fetching it")
vpc_id = vpc_stanza['id']
if not quiet:
log.info("VPC ID according to yaml is {}".format(vpc_id))
vpc_list = vpc_conn.get_all_vpcs(vpc_ids=vpc_id)
assert len(vpc_list) == 1, ("VPC ID {} does not exist".format(vpc_id))
vpc_obj = vpc_list[0]
cidr_block = vpc_obj.cidr_block
assert cidr_block == '10.0.0.0/16', ((
"VPC ID {} exists, but has wrong CIDR block {} "
"(should be 10.0.0.0/16)").format(vpc_id, cidr_block))
if not quiet:
log.info("VPC ID is {}, CIDR block is {}".format(
vpc_stanza['id'],
vpc_stanza['cidr_block'],
))
self._vpc['vpc_obj'] = vpc_obj
vpc_conn.modify_vpc_attribute(
vpc_obj.id,
enable_dns_support=True,
)
vpc_conn.modify_vpc_attribute(
vpc_obj.id,
enable_dns_hostnames=True,
)
return vpc_obj
def subnet_obj(self, create=False, dry_run=False):
"""
Subnet object is returned from cache if cached.
Otherwise, the method validates the subnet, creates it if
necessary, populates tree, and returns subnet object.
"""
if self._subnet['s_obj']:
return self._subnet['s_obj']
s_stanza = stanza('subnets')
log.debug("Subnet stanza {!r}".format(s_stanza))
az = self.availability_zone()
vpc = self.vpc()
vpc_obj = self.vpc_obj(create=False, quiet=True)
delegate = self._subnet['delegate']
cidr_block = '10.0.{}.0/24'.format(delegate)
if delegate not in s_stanza or s_stanza[delegate] == {}:
#
# create new subnet
if create:
s_stanza[delegate] = {}
log.debug("About to create subnet {}".format(cidr_block))
if dry_run:
log.info("Dry run: doing nothing")
s_obj = None
else:
s_obj = vpc.create_subnet(
vpc_obj.id,
cidr_block,
dry_run=dry_run,
availability_zone=az
)
log.info(
"Created subnet {} ({})".format(
s_obj.id,
s_obj.cidr_block
)
)
s_stanza[delegate]['cidr_block'] = s_obj.cidr_block
s_stanza[delegate]['id'] = s_obj.id
stanza('subnets', s_stanza)
apply_tag(s_obj, tag='Name', val=stanza('nametag'))
apply_tag(s_obj, tag='Delegate', val=delegate)
else:
log.info("Delegate {} subnet ID missing in yaml"
.format(delegate))
s_obj = None
return s_obj
#
# check id exists and cidr_block matches
s_id = s_stanza[delegate]['id']
log.debug("Getting subnet id {}".format(s_id))
s_list = vpc.get_all_subnets(subnet_ids=[s_id])
assert len(s_list) == 1, "Subnet ID {} does not exist".format(s_id)
s_obj = s_list[0]
log.info("Found subnet {} ({})".format(s_obj.id, s_obj.cidr_block))
if (
'cidr_block' not in s_stanza[delegate] or
s_stanza[delegate]['cidr_block'] is None
): # pragma: no cover
#
# set cidr_block
s_stanza[delegate]['cidr_block'] = s_obj.cidr_block
stanza('subnets', s_stanza)
else:
#
# validate cidr_block
assert s_stanza[delegate]['cidr_block'] == s_obj.cidr_block, (
("Delegate {} is supposed to have subnet {}, but that "
"subnet exists with non-matching CIDR block {}")
.format(
delegate,
s_stanza[delegate]['cidr_block'],
s_obj.cidr_block
))
self._subnet['s_obj'] = s_obj
# if self.args.retag:
# apply_tag(s_obj, tag='Name', val=stanza('nametag'))
# apply_tag(s_obj, tag='Delegate', val=delegate)
return s_obj
def vpc_obj(self, create=False, dry_run=False, quiet=False):
"""
fetch VPC object, create if necessary
"""
#
# cached VPC object
if self._vpc['vpc_obj'] is not None:
return self._vpc['vpc_obj']
#
# non-cached
vpc_stanza = stanza('vpc')
vpc_conn = self.vpc()
if len(vpc_stanza) == 0: # pragma: no cover
#
# create VPC
if create:
if dry_run:
log.info("Dry run: do nothing")
vpc_obj = None
else:
log.info("VPC ID not specified in yaml: creating VPC")
vpc_obj = vpc_conn.create_vpc('10.0.0.0/16')
vpc_stanza['id'] = vpc_obj.id
vpc_stanza['cidr_block'] = vpc_obj.cidr_block
log.info("New VPC ID {} created with CIDR block {}".format(
vpc_obj.id, vpc_obj.cidr_block
))
apply_tag(vpc_obj, tag='Name', val=stanza('nametag'))
self._vpc['vpc_obj'] = vpc_obj
stanza('vpc', {
'cidr_block': vpc_obj.cidr_block,
'id': vpc_obj.id
})
vpc_conn.modify_vpc_attribute(
vpc_obj.id,
enable_dns_support=True,
)
vpc_conn.modify_vpc_attribute(
vpc_obj.id,
enable_dns_hostnames=True,
)
else:
log.info("VPC ID not specified in yaml: nothing to do")
vpc_obj = None
return vpc_obj
#
# existing VPC
log.debug("VPD ID specified in yaml: fetching it")
vpc_id = vpc_stanza['id']
if not quiet:
log.info("VPC ID according to yaml is {}".format(vpc_id))
vpc_list = vpc_conn.get_all_vpcs(vpc_ids=vpc_id)
assert len(vpc_list) == 1, (
"VPC ID {} does not exist".format(vpc_id))
vpc_obj = vpc_list[0]
cidr_block = vpc_obj.cidr_block
assert cidr_block == '10.0.0.0/16', (
("VPC ID {} exists, but has wrong CIDR block {} "
"(should be 10.0.0.0/16)").format(vpc_id, cidr_block))
if not quiet:
log.info("VPC ID is {}, CIDR block is {}".format(
vpc_stanza['id'], vpc_stanza['cidr_block'],
))
self._vpc['vpc_obj'] = vpc_obj
vpc_conn.modify_vpc_attribute(
vpc_obj.id,
enable_dns_support=True,
)
vpc_conn.modify_vpc_attribute(
vpc_obj.id,
enable_dns_hostnames=True,
)
return vpc_obj
def assemble_role_def(self, role):
rd = stanza("role-definitions")
rv = copy.deepcopy(rd["defaults"])
for a in rd[role]:
rv[a] = rd[role][a]
return rv
