def _shutdown_instance(self, instance):
ctx = context.ctx()
if instance.node_group.floating_ip_pool:
try:
networks.delete_floating_ip(instance.instance_id)
except nova_exceptions.NotFound:
LOG.warning(_LW("Attempted to delete non-existent floating IP "
"in pool {pool} from instance {instance}")
.format(pool=instance.node_group.floating_ip_pool,
instance=instance.instance_id))
try:
volumes.detach_from_instance(instance)
except Exception:
LOG.warning(_LW("Detaching volumes from instance {id} failed")
.format(id=instance.instance_id))
try:
nova.client().servers.delete(instance.instance_id)
except nova_exceptions.NotFound:
LOG.warning(_LW("Attempted to delete non-existent instance {id}")
.format(id=instance.instance_id))
conductor.instance_remove(ctx, instance)
def _detach_volume(instance, volume_id):
volume = cinder.get_volume(volume_id)
try:
LOG.debug("Detaching volume %s from instance %s" % (
volume_id, instance.instance_name))
nova.client().volumes.delete_server_volume(instance.instance_id,
volume_id)
except Exception:
LOG.exception(_LE("Can't detach volume %s"), volume.id)
detach_timeout = CONF.detach_volume_timeout
LOG.debug("Waiting %d seconds to detach %s volume" % (detach_timeout,
volume_id))
s_time = tu.utcnow()
while tu.delta_seconds(s_time, tu.utcnow()) < detach_timeout:
volume = cinder.get_volume(volume_id)
if volume.status not in ['available', 'error']:
context.sleep(2)
else:
LOG.debug("Volume %s has been detached" % volume_id)
return
else:
LOG.warn(_LW("Can't detach volume %(volume)s. "
"Current status of volume: %(status)s"),
{'volume': volume_id, 'status': volume.status})
def _shutdown_instance(self, instance):
ctx = context.ctx()
if instance.node_group.floating_ip_pool:
try:
networks.delete_floating_ip(instance.instance_id)
except nova_exceptions.NotFound:
LOG.warn(_LW("Attempted to delete non-existent floating IP in "
"pool %(pool)s from instance %(instance)s"),
{'pool': instance.node_group.floating_ip_pool,
'instance': instance.instance_id})
try:
volumes.detach_from_instance(instance)
except Exception:
LOG.warn(_LW("Detaching volumes from instance %s failed"),
instance.instance_id)
try:
nova.client().servers.delete(instance.instance_id)
except nova_exceptions.NotFound:
LOG.warn(_LW("Attempted to delete non-existent instance %s"),
instance.instance_id)
conductor.instance_remove(ctx, instance)
def _delete_auto_security_group(self, node_group):
if not node_group.auto_security_group:
return
name = node_group.security_groups[-1]
try:
nova.client().security_groups.delete(name)
except Exception:
LOG.exception("Failed to delete security group %s", name)
def _detach_volume(instance, volume_id):
volume = cinder.get_volume(volume_id)
try:
LOG.debug("Detaching volume {id} from instance".format(id=volume_id))
nova.client().volumes.delete_server_volume(instance.instance_id,
volume_id)
except Exception:
LOG.error(_LE("Can't detach volume {id}").format(id=volume.id))
detach_timeout = CONF.timeouts.detach_volume_timeout
LOG.debug("Waiting {timeout} seconds to detach {id} volume".format(
timeout=detach_timeout, id=volume_id))
_await_detach(volume_id)
def _detach_volume(instance, volume_id):
volume = cinder.get_volume(volume_id)
try:
LOG.debug("Detaching volume {id} from instance {instance}".format(
id=volume_id, instance=instance.instance_name))
nova.client().volumes.delete_server_volume(instance.instance_id,
volume_id)
except Exception:
LOG.error(_LE("Can't detach volume {id}").format(id=volume.id))
detach_timeout = CONF.timeouts.detach_volume_timeout
LOG.debug("Waiting {timeout} seconds to detach {id} volume".format(
timeout=detach_timeout, id=volume_id))
_await_detach(volume_id)
def _run_instance(self, cluster, node_group, idx, aa_group=None,
old_aa_groups=None):
"""Create instance using nova client and persist them into DB."""
ctx = context.ctx()
name = g.generate_instance_name(cluster.name, node_group.name, idx)
userdata = self._generate_user_data_script(node_group, name)
if old_aa_groups:
# aa_groups: node process -> instance ids
aa_ids = []
for node_process in node_group.node_processes:
aa_ids += old_aa_groups.get(node_process) or []
# create instances only at hosts w/ no instances
# w/ aa-enabled processes
hints = {'different_host': sorted(set(aa_ids))} if aa_ids else None
else:
hints = {'group': aa_group} if (
aa_group and self._need_aa_server_group(node_group)) else None
if CONF.use_neutron:
net_id = cluster.neutron_management_network
nics = [{"net-id": net_id, "v4-fixed-ip": ""}]
nova_instance = nova.client().servers.create(
name, node_group.get_image_id(), node_group.flavor_id,
scheduler_hints=hints, userdata=userdata,
key_name=cluster.user_keypair_id,
nics=nics, security_groups=node_group.security_groups)
else:
nova_instance = nova.client().servers.create(
name, node_group.get_image_id(), node_group.flavor_id,
scheduler_hints=hints, userdata=userdata,
key_name=cluster.user_keypair_id,
security_groups=node_group.security_groups)
instance_id = conductor.instance_add(ctx, node_group,
{"instance_id": nova_instance.id,
"instance_name": name})
if old_aa_groups:
# save instance id to aa_groups to support aa feature
for node_process in node_group.node_processes:
if node_process in cluster.anti_affinity:
aa_group_ids = old_aa_groups.get(node_process, [])
aa_group_ids.append(nova_instance.id)
old_aa_groups[node_process] = aa_group_ids
return instance_id
def _run_instance(self, cluster, node_group, idx, aa_groups):
"""Create instance using nova client and persist them into DB."""
ctx = context.ctx()
name = self._get_inst_name(cluster.name, node_group.name, idx)
userdata = self._generate_user_data_script(node_group, name)
# aa_groups: node process -> instance ids
aa_ids = []
for node_process in node_group.node_processes:
aa_ids += aa_groups.get(node_process) or []
# create instances only at hosts w/ no instances
# w/ aa-enabled processes
hints = {'different_host': list(set(aa_ids))} if aa_ids else None
if CONF.use_neutron:
net_id = cluster.neutron_management_network
nics = [{"net-id": net_id, "v4-fixed-ip": ""}]
nova_instance = nova.client().servers.create(
name,
node_group.get_image_id(),
node_group.flavor_id,
scheduler_hints=hints,
userdata=userdata,
key_name=cluster.user_keypair_id,
nics=nics)
else:
nova_instance = nova.client().servers.create(
name,
node_group.get_image_id(),
node_group.flavor_id,
scheduler_hints=hints,
userdata=userdata,
key_name=cluster.user_keypair_id)
instance_id = conductor.instance_add(ctx, node_group, {
"instance_id": nova_instance.id,
"instance_name": name
})
# save instance id to aa_groups to support aa feature
for node_process in node_group.node_processes:
if node_process in cluster.anti_affinity:
aa_group_ids = aa_groups.get(node_process, [])
aa_group_ids.append(nova_instance.id)
aa_groups[node_process] = aa_group_ids
return instance_id
def _update_limits_for_ng(limits, ng, count):
sign = lambda x: (1, -1)[x < 0]
nova = nova_client.client()
limits['instances'] += count
flavor = b.execute_with_retries(nova.flavors.get, ng.flavor_id)
limits['ram'] += flavor.ram * count
limits['cpu'] += flavor.vcpus * count
# tmckay-fp this is fine, it will be zero without it
if ng.floating_ip_pool:
limits['floatingips'] += count
if ng.volumes_per_node:
limits['volumes'] += ng.volumes_per_node * count
limits['volume_gbs'] += ng.volumes_per_node * ng.volumes_size * count
if ng.auto_security_group:
limits['security_groups'] += sign(count)
# NOTE: +3 - all traffic for private network
if CONF.use_neutron:
limits['security_group_rules'] += ((len(ng.open_ports) + 3) *
sign(count))
else:
limits['security_group_rules'] = max(
limits['security_group_rules'],
len(ng.open_ports) + 3)
if CONF.use_neutron:
limits['ports'] += count
def _create_attach_volume(ctx,
instance,
size,
volume_type,
name=None,
availability_zone=None):
if CONF.cinder.api_version == 1:
kwargs = {'size': size, 'display_name': name}
else:
kwargs = {'size': size, 'name': name}
kwargs['volume_type'] = volume_type
if availability_zone is not None:
kwargs['availability_zone'] = availability_zone
volume = cinder.client().volumes.create(**kwargs)
conductor.append_volume(ctx, instance, volume.id)
while volume.status != 'available':
volume = cinder.get_volume(volume.id)
if volume.status == 'error':
raise ex.SystemError(_("Volume %s has error status") % volume.id)
context.sleep(1)
resp = nova.client().volumes.create_server_volume(instance.instance_id,
volume.id, None)
return resp.device
def _create_auto_security_group(self, node_group):
name = g.generate_auto_security_group_name(node_group)
nova_client = nova.client()
security_group = nova_client.security_groups.create(
name, "Auto security group created by Sahara for Node Group '%s' "
"of cluster '%s'." %
(node_group.name, node_group.cluster.name))
# ssh remote needs ssh port, agents are not implemented yet
nova_client.security_group_rules.create(
security_group.id, 'tcp', SSH_PORT, SSH_PORT, "0.0.0.0/0")
# open all traffic for private networks
if CONF.use_neutron:
for cidr in neutron.get_private_network_cidrs(node_group.cluster):
for protocol in ['tcp', 'udp']:
nova_client.security_group_rules.create(
security_group.id, protocol, 1, 65535, cidr)
nova_client.security_group_rules.create(
security_group.id, 'icmp', -1, -1, cidr)
# enable ports returned by plugin
for port in node_group.open_ports:
nova_client.security_group_rules.create(
security_group.id, 'tcp', port, port, "0.0.0.0/0")
security_groups = list(node_group.security_groups or [])
security_groups.append(security_group.id)
conductor.node_group_update(context.ctx(), node_group,
{"security_groups": security_groups})
return security_groups
def test_list_registered_images(self, url_for_mock):
self.override_config('auth_uri', 'https://127.0.0.1:8080/v3/',
'keystone_authtoken')
some_images = [
FakeImage('foo', ['bar', 'baz'], 'test'),
FakeImage('baz', [], 'test'),
FakeImage('spam', [], "")]
with mock.patch('novaclient.v2.images.ImageManager.list',
return_value=some_images):
nova = nova_client.client()
images = nova.images.list_registered()
self.assertEqual(2, len(images))
images = nova.images.list_registered(name='foo')
self.assertEqual(1, len(images))
self.assertEqual('foo', images[0].name)
self.assertEqual('test', images[0].username)
images = nova.images.list_registered(name='eggs')
self.assertEqual(0, len(images))
images = nova.images.list_registered(tags=['bar'])
self.assertEqual(1, len(images))
self.assertEqual('foo', images[0].name)
images = nova.images.list_registered(tags=['bar', 'eggs'])
self.assertEqual(0, len(images))
def test_list_registered_images(self, url_for_mock):
some_images = [
FakeImage('foo', ['bar', 'baz'], 'test'),
FakeImage('baz', [], 'test'),
FakeImage('spam', [], "")
]
with mock.patch('novaclient.v1_1.images.ImageManager.list',
return_value=some_images):
nova = nova_client.client()
images = nova.images.list_registered()
self.assertEqual(2, len(images))
images = nova.images.list_registered(name='foo')
self.assertEqual(1, len(images))
self.assertEqual('foo', images[0].name)
self.assertEqual('test', images[0].username)
images = nova.images.list_registered(name='eggs')
self.assertEqual(0, len(images))
images = nova.images.list_registered(tags=['bar'])
self.assertEqual(1, len(images))
self.assertEqual('foo', images[0].name)
images = nova.images.list_registered(tags=['bar', 'eggs'])
self.assertEqual(0, len(images))
def _create_attach_volume(ctx,
instance,
size,
volume_type,
volume_local_to_instance,
name=None,
availability_zone=None):
if CONF.cinder.api_version == 1:
kwargs = {'size': size, 'display_name': name}
else:
kwargs = {'size': size, 'name': name}
kwargs['volume_type'] = volume_type
if availability_zone is not None:
kwargs['availability_zone'] = availability_zone
if volume_local_to_instance:
kwargs['scheduler_hints'] = {'local_to_instance': instance.instance_id}
volume = b.execute_with_retries(cinder.client().volumes.create, **kwargs)
conductor.append_volume(ctx, instance, volume.id)
_await_available(volume)
resp = b.execute_with_retries(nova.client().volumes.create_server_volume,
instance.instance_id, volume.id, None)
return resp.device
def check_security_groups_exist(security_groups):
security_group_list = nova.client().security_groups.list()
allowed_groups = set(reduce(
operator.add, [[sg.id, sg.name] for sg in security_group_list], []))
for sg in security_groups:
if sg not in allowed_groups:
raise ex.InvalidException(_("Security group '%s' not found") % sg)
def test_list_registered_images(self, url_for_mock):
some_images = [
FakeImage('foo', ['bar', 'baz'], 'test'),
FakeImage('baz', [], 'test'),
FakeImage('spam', [], "")]
with mock.patch('novaclient.v2.images.ImageManager.list',
return_value=some_images):
nova = nova_client.client()
images = nova.images.list_registered()
self.assertEqual(2, len(images))
images = nova.images.list_registered(name='foo')
self.assertEqual(1, len(images))
self.assertEqual('foo', images[0].name)
self.assertEqual('test', images[0].username)
images = nova.images.list_registered(name='eggs')
self.assertEqual(0, len(images))
images = nova.images.list_registered(tags=['bar'])
self.assertEqual(1, len(images))
self.assertEqual('foo', images[0].name)
images = nova.images.list_registered(tags=['bar', 'eggs'])
self.assertEqual(0, len(images))
def _create_attach_volume(ctx, instance, size, display_name=None,
volume_type=None):
volume = cinder.client().volumes.create(size=size,
display_name=display_name,
volume_type=volume_type)
conductor.append_volume(ctx, instance, volume.id)
while volume.status != 'available':
volume = cinder.get_volume(volume.id)
if volume.status == 'error':
raise ex.SystemError("Volume %s has error status" % volume.id)
context.sleep(1)
nova.client().volumes.create_server_volume(instance.instance_id,
volume.id, None)
def _create_auto_security_group(self, node_group):
name = g.generate_auto_security_group_name(node_group)
nova_client = nova.client()
security_group = nova_client.security_groups.create(
name, "Auto security group created by Sahara for Node Group '%s' "
"of cluster '%s'." % (node_group.name, node_group.cluster.name))
# ssh remote needs ssh port, agents are not implemented yet
nova_client.security_group_rules.create(security_group.id, 'tcp',
SSH_PORT, SSH_PORT,
"0.0.0.0/0")
# open all traffic for private networks
if CONF.use_neutron:
for cidr in neutron.get_private_network_cidrs(node_group.cluster):
for protocol in ['tcp', 'udp']:
nova_client.security_group_rules.create(
security_group.id, protocol, 1, 65535, cidr)
nova_client.security_group_rules.create(
security_group.id, 'icmp', -1, -1, cidr)
# enable ports returned by plugin
for port in node_group.open_ports:
nova_client.security_group_rules.create(security_group.id, 'tcp',
port, port, "0.0.0.0/0")
security_groups = list(node_group.security_groups or [])
security_groups.append(security_group.id)
conductor.node_group_update(context.ctx(), node_group,
{"security_groups": security_groups})
return security_groups
def _delete_auto_security_group(self, node_group):
if not node_group.auto_security_group:
return
if not node_group.security_groups:
# node group has no security groups
# nothing to delete
return
name = node_group.security_groups[-1]
try:
client = nova.client().security_groups
security_group = client.get(name)
if (security_group.name !=
g.generate_auto_security_group_name(node_group)):
LOG.warning(
_LW("Auto security group for node group {name} is "
"not found").format(name=node_group.name))
return
client.delete(name)
except Exception:
LOG.warning(
_LW("Failed to delete security group {name}").format(
name=name))
def test_list_registered_images(self, url_for_mock):
self.override_config('auth_uri', 'https://127.0.0.1:8080/v3/',
'keystone_authtoken')
some_images = [
FakeImage('foo', ['bar', 'baz'], 'test'),
FakeImage('baz', [], 'test'),
FakeImage('spam', [], "")
]
with mock.patch('novaclient.v2.images.ImageManager.list',
return_value=some_images):
nova = nova_client.client()
images = nova.images.list_registered()
self.assertEqual(2, len(images))
images = nova.images.list_registered(name='foo')
self.assertEqual(1, len(images))
self.assertEqual('foo', images[0].name)
self.assertEqual('test', images[0].username)
images = nova.images.list_registered(name='eggs')
self.assertEqual(0, len(images))
images = nova.images.list_registered(tags=['bar'])
self.assertEqual(1, len(images))
self.assertEqual('foo', images[0].name)
images = nova.images.list_registered(tags=['bar', 'eggs'])
self.assertEqual(0, len(images))
def _delete_aa_server_group(self, cluster):
if cluster.anti_affinity:
server_group_name = g.generate_aa_group_name(cluster.name)
client = nova.client().server_groups
server_groups = client.findall(name=server_group_name)
if len(server_groups) == 1:
client.delete(server_groups[0].id)
def check_auto_security_group(cluster_name, nodegroup):
if nodegroup.get('auto_security_group'):
name = g.generate_auto_security_group_name(
cluster_name, nodegroup['name'])
if name in [security_group.name for security_group in
nova.client().security_groups.list()]:
raise ex.NameAlreadyExistsException(
_("Security group with name '%s' already exists") % name)
def check_security_groups_exist(security_groups):
security_group_list = nova.client().security_groups.list()
allowed_groups = set(
reduce(operator.add, [[six.text_type(sg.id), sg.name]
for sg in security_group_list], []))
for sg in security_groups:
if sg not in allowed_groups:
raise ex.NotFoundException(sg, _("Security group '%s' not found"))
def _delete_aa_server_group(self, cluster):
if cluster.anti_affinity:
server_group_name = g.generate_aa_group_name(cluster.name)
client = nova.client().server_groups
server_groups = client.findall(name=server_group_name)
if len(server_groups) == 1:
client.delete(server_groups[0].id)
def _get_nova_limits():
limits = {}
nova = nova_client.client()
lim = b.execute_with_retries(nova.limits.get).to_dict()['absolute']
limits['ram'] = _sub_limit(lim['maxTotalRAMSize'], lim['totalRAMUsed'])
limits['cpu'] = _sub_limit(lim['maxTotalCores'], lim['totalCoresUsed'])
limits['instances'] = _sub_limit(lim['maxTotalInstances'],
lim['totalInstancesUsed'])
return limits
def _delete_aa_server_group(self, cluster):
if cluster.anti_affinity:
server_group_name = g.generate_aa_group_name(cluster.name)
client = nova.client().server_groups
server_groups = b.execute_with_retries(client.findall,
name=server_group_name)
if len(server_groups) == 1:
b.execute_with_retries(client.delete, server_groups[0].id)
def _get_nova_limits():
limits = {}
nova = nova_client.client()
lim = b.execute_with_retries(nova.limits.get).to_dict()['absolute']
limits['ram'] = _sub_limit(lim['maxTotalRAMSize'], lim['totalRAMUsed'])
limits['cpu'] = _sub_limit(lim['maxTotalCores'], lim['totalCoresUsed'])
limits['instances'] = _sub_limit(lim['maxTotalInstances'],
lim['totalInstancesUsed'])
return limits
def _delete_aa_server_group(self, cluster):
if cluster.anti_affinity:
server_group_name = g.generate_aa_group_name(cluster.name)
client = nova.client().server_groups
server_groups = b.execute_with_retries(client.findall,
name=server_group_name)
if len(server_groups) == 1:
b.execute_with_retries(client.delete, server_groups[0].id)
def check_security_groups_exist(security_groups):
security_group_list = nova.client().security_groups.list()
allowed_groups = set(reduce(
operator.add, [[six.text_type(sg.id), sg.name]
for sg in security_group_list], []))
for sg in security_groups:
if sg not in allowed_groups:
raise ex.NotFoundException(
sg, _("Security group '%s' not found"))
def _run_instance(self,
cluster,
node_group,
idx,
aa_group=None,
old_aa_groups=None):
"""Create instance using nova client and persist them into DB."""
ctx = context.ctx()
name = g.generate_instance_name(cluster.name, node_group.name, idx)
userdata = self._generate_user_data_script(node_group, name)
if old_aa_groups:
# aa_groups: node process -> instance ids
aa_ids = []
for node_process in node_group.node_processes:
aa_ids += old_aa_groups.get(node_process) or []
# create instances only at hosts w/ no instances
# w/ aa-enabled processes
hints = {'different_host': sorted(set(aa_ids))} if aa_ids else None
else:
hints = {
'group': aa_group
} if (aa_group
and self._need_aa_server_group(node_group)) else None
security_groups = self._map_security_groups(node_group.security_groups)
nova_kwargs = {
'scheduler_hints': hints,
'userdata': userdata,
'key_name': cluster.user_keypair_id,
'security_groups': security_groups
}
if CONF.use_neutron:
net_id = cluster.neutron_management_network
nova_kwargs['nics'] = [{"net-id": net_id, "v4-fixed-ip": ""}]
nova_instance = nova.client().servers.create(name,
node_group.get_image_id(),
node_group.flavor_id,
**nova_kwargs)
instance_id = conductor.instance_add(ctx, node_group, {
"instance_id": nova_instance.id,
"instance_name": name
})
if old_aa_groups:
# save instance id to aa_groups to support aa feature
for node_process in node_group.node_processes:
if node_process in cluster.anti_affinity:
aa_group_ids = old_aa_groups.get(node_process, [])
aa_group_ids.append(nova_instance.id)
old_aa_groups[node_process] = aa_group_ids
return instance_id
def _create_attach_volume(ctx,
instance,
size,
display_name=None,
volume_type=None):
volume = cinder.client().volumes.create(size=size,
display_name=display_name,
volume_type=volume_type)
conductor.append_volume(ctx, instance, volume.id)
while volume.status != 'available':
volume = cinder.get_volume(volume.id)
if volume.status == 'error':
raise RuntimeError("Volume %s has error status" % volume.id)
context.sleep(1)
nova.client().volumes.create_server_volume(instance.instance_id, volume.id,
None)
def check_security_groups_exist(security_groups):
security_group_list = nova.client().security_groups.list()
allowed_groups = set()
for sg in security_group_list:
allowed_groups.add(six.text_type(sg.id))
allowed_groups.add(sg.name)
for sg in security_groups:
if sg not in allowed_groups:
raise ex.NotFoundException(sg, _("Security group '%s' not found"))
def check_auto_security_group(cluster_name, nodegroup):
if nodegroup.get('auto_security_group'):
name = g.generate_auto_security_group_name(cluster_name,
nodegroup['name'])
if name in [
security_group.name
for security_group in nova.client().security_groups.list()
]:
raise ex.NameAlreadyExistsException(
_("Security group with name '%s' already exists") % name)
def check_security_groups_exist(security_groups):
security_group_list = nova.client().security_groups.list()
allowed_groups = set()
for sg in security_group_list:
allowed_groups.add(six.text_type(sg.id))
allowed_groups.add(sg.name)
for sg in security_groups:
if sg not in allowed_groups:
raise ex.NotFoundException(sg, _("Security group '%s' not found"))
def check_floatingip_pool_exists(ng_name, pool_id):
network = None
if CONF.use_neutron:
network = nova.get_network(id=pool_id)
else:
for net in nova.client().floating_ip_pools.list():
if net.name == pool_id:
network = net.name
break
if not network:
raise ex.NotFoundException(pool_id, _("Floating IP pool %s not found"))
def _create_aa_server_group(self, cluster):
server_group_name = g.generate_aa_group_name(cluster.name)
client = nova.client().server_groups
if client.findall(name=server_group_name):
raise exc.InvalidDataException(
_("Server group with name %s is already exists")
% server_group_name)
server_group = client.create(name=server_group_name,
policies=['anti-affinity'])
return server_group.id
def check_floatingip_pool_exists(ng_name, pool_id):
network = None
if CONF.use_neutron:
network = nova.get_network(id=pool_id)
else:
for net in nova.client().floating_ip_pools.list():
if net.name == pool_id:
network = net.name
break
if not network:
raise ex.NotFoundException(pool_id, _("Floating IP pool %s not found"))
def _create_aa_server_group(self, cluster):
server_group_name = g.generate_aa_group_name(cluster.name)
client = nova.client().server_groups
if client.findall(name=server_group_name):
raise exc.InvalidDataException(
_("Server group with name %s is already exists") %
server_group_name)
server_group = client.create(name=server_group_name,
policies=['anti-affinity'])
return server_group.id
def test_set_description(self, set_meta):
with mock.patch('sahara.utils.openstack.base.url_for'):
nova = nova_client.client()
nova.images.set_description('id', 'ubuntu')
self.assertEqual(
('id', {'_sahara_username': '******'}), set_meta.call_args[0])
nova.images.set_description('id', 'ubuntu', 'descr')
self.assertEqual(
('id', {'_sahara_description': 'descr',
'_sahara_username': '******'}),
set_meta.call_args[0])
def check_floatingip_pool_exists(ng_name, pool_id):
network = None
if CONF.use_neutron:
network = nova.get_network(id=pool_id)
else:
for net in nova.client().floating_ip_pools.list():
if net.name == pool_id:
network = net.name
break
if not network:
raise ex.InvalidException("Floating IP pool %s for node group "
"'%s' not found" % (pool_id, ng_name))
def check_floatingip_pool_exists(ng_name, pool_id):
network = None
if CONF.use_neutron:
network = nova.get_network(id=pool_id)
else:
for net in nova.client().floating_ip_pools.list():
if net.name == pool_id:
network = net.name
break
if not network:
raise ex.InvalidException("Floating IP pool %s for node group "
"'%s' not found" % (pool_id, ng_name))
def check_floatingip_pool_exists(ng_name, pool_id):
network = None
if CONF.use_neutron:
network = nova.get_network(id=pool_id)
else:
# tmckay-fp, whoa, this suggests that we allow floating_ip_pools with
# nova? Can that be true? Scour for this
for net in nova.client().floating_ip_pools.list():
if net.name == pool_id:
network = net.name
break
if not network:
raise ex.NotFoundException(pool_id, _("Floating IP pool %s not found"))
def check_floatingip_pool_exists(ng_name, pool_id):
network = None
if CONF.use_neutron:
network = neutron.get_network(pool_id)
else:
# tmckay-fp, whoa, this suggests that we allow floating_ip_pools with
# nova? Can that be true? Scour for this
for net in nova.client().floating_ip_pools.list():
if net.name == pool_id:
network = net.name
break
if not network:
raise ex.NotFoundException(pool_id, _("Floating IP pool %s not found"))
def check_floatingip_pool_exists(ng_name, pool_id):
network = None
if CONF.use_neutron:
network = nova.get_network(id=pool_id)
else:
for net in nova.client().floating_ip_pools.list():
if net.name == pool_id:
network = net.name
break
if not network:
raise ex.InvalidException(
_("Floating IP pool %(pool)s for node group '%(group)s' "
"not found") % {'pool': pool_id, 'group': ng_name})
def _shutdown_instance(self, instance):
ctx = context.ctx()
if instance.node_group.floating_ip_pool:
try:
networks.delete_floating_ip(instance.instance_id)
except nova_exceptions.NotFound:
LOG.warning(
_LW("Attempted to delete non-existent floating IP "
"in pool {pool} from instance").format(
pool=instance.node_group.floating_ip_pool))
try:
volumes.detach_from_instance(instance)
except Exception:
LOG.warning(_LW("Detaching volumes from instance failed"))
try:
nova.client().servers.delete(instance.instance_id)
except nova_exceptions.NotFound:
LOG.warning(_LW("Attempted to delete non-existent instance"))
conductor.instance_remove(ctx, instance)
def _find_aa_server_group(self, cluster):
server_group_name = g.generate_aa_group_name(cluster.name)
server_groups = nova.client().server_groups.findall(
name=server_group_name)
if len(server_groups) > 1:
raise exc.IncorrectStateError(
_("Several server groups with name %s found") %
server_group_name)
if len(server_groups) == 1:
return server_groups[0].id
return None
def _find_aa_server_group(self, cluster):
server_group_name = g.generate_aa_group_name(cluster.name)
server_groups = nova.client().server_groups.findall(
name=server_group_name)
if len(server_groups) > 1:
raise exc.IncorrectStateError(
_("Several server groups with name %s found")
% server_group_name)
if len(server_groups) == 1:
return server_groups[0].id
return None
def _create_attach_volume(ctx, instance, size, display_name=None):
volume = cinder.client().volumes.create(size=size,
display_name=display_name)
conductor.append_volume(ctx, instance, volume.id)
while volume.status != 'available':
volume = cinder.get_volume(volume.id)
if volume.status == 'error':
raise ex.SystemError(_("Volume %s has error status") % volume.id)
context.sleep(1)
resp = nova.client().volumes.create_server_volume(instance.instance_id,
volume.id, None)
return resp.device
def _get_nova_limits():
limits = {}
nova = nova_client.client()
lim = nova.limits.get().to_dict()['absolute']
limits['ram'] = lim['maxTotalRAMSize'] - lim['totalRAMUsed']
limits['cpu'] = lim['maxTotalCores'] - lim['totalCoresUsed']
limits['instances'] = lim['maxTotalInstances'] - lim['totalInstancesUsed']
if CONF.use_neutron:
return limits
if CONF.use_floating_ips:
limits['floatingips'] = (
lim['maxTotalFloatingIps'] - lim['totalFloatingIpsUsed'])
limits['security_groups'] = (
lim['maxSecurityGroups'] - lim['totalSecurityGroupsUsed'])
limits['security_group_rules'] = lim['maxSecurityGroupRules']
return limits
def _get_nova_limits():
limits = {}
nova = nova_client.client()
lim = nova.limits.get().to_dict()['absolute']
limits['ram'] = lim['maxTotalRAMSize'] - lim['totalRAMUsed']
limits['cpu'] = lim['maxTotalCores'] - lim['totalCoresUsed']
limits['instances'] = lim['maxTotalInstances'] - lim['totalInstancesUsed']
if CONF.use_neutron:
return limits
if CONF.use_floating_ips:
limits['floatingips'] = (lim['maxTotalFloatingIps'] -
lim['totalFloatingIpsUsed'])
limits['security_groups'] = (lim['maxSecurityGroups'] -
lim['totalSecurityGroupsUsed'])
limits['security_group_rules'] = lim['maxSecurityGroupRules']
return limits
def check_floatingip_pool_exists(ng_name, pool_id):
network = None
if CONF.use_neutron:
network = nova.get_network(id=pool_id)
else:
for net in nova.client().floating_ip_pools.list():
if net.name == pool_id:
network = net.name
break
if not network:
raise ex.InvalidException(
_("Floating IP pool %(pool)s for node group '%(group)s' "
"not found") % {
'pool': pool_id,
'group': ng_name
})
def _map_security_groups(self, security_groups):
if not security_groups:
# Nothing to do here
return None
if CONF.use_neutron:
# When using Neutron, ids work fine.
return security_groups
else:
# Nova Network requires that security groups are passed by names.
# security_groups.get method accepts both ID and names, so in case
# IDs are provided they will be converted, otherwise the names will
# just map to themselves.
names = []
for group_id_or_name in security_groups:
group = nova.client().security_groups.get(group_id_or_name)
names.append(group.name)
return names
def _shutdown_instance(self, instance):
# Heat dissociates and deletes upon deletion of resources
# See OS::Neutron::FloatingIP and OS::Neutron::FloatingIPAssociation
if instance.node_group.floating_ip_pool:
pass
try:
volumes.detach_from_instance(instance)
except Exception:
LOG.warning("Detaching volumes from instance failed")
try:
b.execute_with_retries(nova.client().servers.delete,
instance.instance_id)
except nova_exceptions.NotFound:
LOG.warning("Attempted to delete non-existent instance")
conductor.instance_remove(context.ctx(), instance)
def _map_security_groups(self, security_groups):
if not security_groups:
# Nothing to do here
return None
if CONF.use_neutron:
# When using Neutron, ids work fine.
return security_groups
else:
# Nova Network requires that security groups are passed by names.
# security_groups.get method accepts both ID and names, so in case
# IDs are provided they will be converted, otherwise the names will
# just map to themselves.
names = []
for group_id_or_name in security_groups:
group = nova.client().security_groups.get(group_id_or_name)
names.append(group.name)
return names
def _update_limits_for_ng(limits, ng, count):
sign = lambda x: (1, -1)[x < 0]
nova = nova_client.client()
limits['instances'] += count
flavor = b.execute_with_retries(nova.flavors.get, ng.flavor_id)
limits['ram'] += flavor.ram * count
limits['cpu'] += flavor.vcpus * count
# tmckay-fp this is fine, it will be zero without it
if ng.floating_ip_pool:
limits['floatingips'] += count
if ng.volumes_per_node:
limits['volumes'] += ng.volumes_per_node * count
limits['volume_gbs'] += ng.volumes_per_node * ng.volumes_size * count
if ng.auto_security_group:
limits['security_groups'] += sign(count)
# NOTE: +3 - all traffic for private network
limits['security_group_rules'] += (
(len(ng.open_ports) + 3) * sign(count))
limits['ports'] += count
def _get_nova_limits():
limits = {}
nova = nova_client.client()
lim = b.execute_with_retries(nova.limits.get).to_dict()['absolute']
limits['ram'] = _sub_limit(lim['maxTotalRAMSize'], lim['totalRAMUsed'])
limits['cpu'] = _sub_limit(lim['maxTotalCores'], lim['totalCoresUsed'])
limits['instances'] = _sub_limit(lim['maxTotalInstances'],
lim['totalInstancesUsed'])
if CONF.use_neutron:
return limits
# tmckay-fp here we would just get the limits all the time
limits['floatingips'] = _sub_limit(lim['maxTotalFloatingIps'],
lim['totalFloatingIpsUsed'])
limits['security_groups'] = _sub_limit(lim['maxSecurityGroups'],
lim['totalSecurityGroupsUsed'])
limits['security_group_rules'] = _sub_limit(lim['maxSecurityGroupRules'],
0)
return limits
def _delete_aa_server_groups(self, cluster):
if cluster.anti_affinity:
for i in range(1, cluster.anti_affinity_ratio):
server_group_name = g.generate_aa_group_name(cluster.name, i)
client = nova.client().server_groups
server_groups = b.execute_with_retries(client.findall,
name=server_group_name)
if len(server_groups) == 1:
b.execute_with_retries(client.delete, server_groups[0].id)
'''In case the server group is created
using mitaka or older version'''
old_server_group_name = server_group_name.rsplit('-', 1)[0]
server_groups_old = b.execute_with_retries(
client.findall, name=old_server_group_name)
if len(server_groups_old) == 1:
b.execute_with_retries(client.delete,
server_groups_old[0].id)
def _shutdown_instance(self, instance):
if instance.node_group.floating_ip_pool:
try:
b.execute_with_retries(networks.delete_floating_ip,
instance.instance_id)
except nova_exceptions.NotFound:
LOG.warning(_LW("Attempted to delete non-existent floating IP "
"in pool {pool} from instance")
.format(pool=instance.node_group.floating_ip_pool))
try:
volumes.detach_from_instance(instance)
except Exception:
LOG.warning(_LW("Detaching volumes from instance failed"))
try:
b.execute_with_retries(nova.client().servers.delete,
instance.instance_id)
except nova_exceptions.NotFound:
LOG.warning(_LW("Attempted to delete non-existent instance"))
conductor.instance_remove(context.ctx(), instance)
def _create_attach_volume(ctx, instance, size, volume_type,
volume_local_to_instance, name=None,
availability_zone=None):
if CONF.cinder.api_version == 1:
kwargs = {'size': size, 'display_name': name}
else:
kwargs = {'size': size, 'name': name}
kwargs['volume_type'] = volume_type
if availability_zone is not None:
kwargs['availability_zone'] = availability_zone
if volume_local_to_instance:
kwargs['scheduler_hints'] = {'local_to_instance': instance.instance_id}
volume = b.execute_with_retries(cinder.client().volumes.create, **kwargs)
conductor.append_volume(ctx, instance, volume.id)
_await_available(volume)
resp = b.execute_with_retries(nova.client().volumes.create_server_volume,
instance.instance_id, volume.id, None)
return resp.device
