def cinder_api(self):
assert self.api_session is not None, 'Unable to use cinder_api without a Keystoneauth session'
params = {'api_session': self.api_session}
try:
if self.volume_backup.region:
params['region_name'] = self.volume_backup.region.id
else:
backup_related_volume = self.volume_backup.volume
if backup_related_volume:
params['region_name'] = backup_related_volume.region
return cinder_client(**params)
except VolumeModel.DoesNotExist:
return cinder_client(**params)
def cinder_admin_api(self):
"""
:rtype: cinderclient.v3.client.Client
"""
assert self.admin_session is not None, 'Unable to use admin_api without a Keystoneauth session'
return cinder_client(api_session=self.admin_session)
def create(self,
name,
size,
region_name,
type=None,
source_type=None,
source_id=None):
"""
:type region_name: str or unicode
:param size: Size of volume in GB
:param name: Name of the volume
:param type: Type of volume
:param source_type: the source type to create volume from
:param source_id: the source id/uuid (volume or image / snapshot)
:rtype: :class:`cinderclient.v2.volumes.Volume`
"""
extra_params = {}
if source_type and source_id:
if source_type == 'image':
extra_params['imageRef'] = source_id
elif source_type == 'volume':
extra_params['source_volid'] = source_id
if type:
extra_params['volume_type'] = type
cc = cinder_client(api_session=self.api_session,
region_name=region_name)
return cc.volumes.create(size=size, name=name, **extra_params)
def get_volume_from_api(self, volume_id, region, api_session=None):
api_session = api_session or self.api_session
cc = cinder_client(api_session=api_session, region_name=region)
try:
volume = cc.volumes.get(volume_id)
except cinderclient.exceptions.NotFound:
LOG.debug('Unable to get volume missing in OpenStack: {}'.format(
volume_id))
return None
return volume
def wait_for_volume_status(self, volume_id, project_id, project_domain_id,
region_name, status):
if volume_id:
os_api = OSApi(project=project_id, domain=project_domain_id)
cc = cinder_client(api_session=os_api.get_session(),
region_name=region_name)
volume = cc.volumes.get(volume_id)
if volume.status != status:
self.retry(countdown=5)
else:
return volume_id
return None
def create(self, volume_id, name, force=False, description=None, region_name=None, metadata=None):
if not region_name:
volume = VolumeModel.objects.filter(id=volume_id).first()
if not volume:
raise APIBadRequest(_('Volume to create snapshot for does not exist.'))
region_name = volume.region
cc = cinder_client(api_session=self.api_session, region_name=region_name)
return cc.volume_snapshots.create(
volume_id=volume_id,
force=force,
name=name,
description=description,
metadata=metadata,
)
def create(self,
volume_id,
region_id,
container=None,
name=None,
description=None,
incremental=False,
force=False):
cc = cinder_client(api_session=self.api_session, region_name=region_id)
return cc.backups.create(
volume_id=volume_id,
container=container,
name=name,
description=description,
incremental=incremental,
force=force,
)
def sync_volume_extra_details(self, volume_id, region_name):
del self # unused
os_api = OSAdminApi()
cc = cinder_client(api_session=os_api.get_session(),
region_name=region_name)
try:
volume_from_os = cc.volumes.get(volume_id)
except cinder_exceptions.NotFound:
pass
else:
db_volume = Volume.objects.filter(id=volume_id).first()
if db_volume and volume_from_os:
if volume_from_os.bootable == 'true':
db_volume.bootable = True
if volume_from_os.bootable == 'false':
db_volume.bootable = False
db_volume.save()
def get_qos_spec_from_api(self, payload, region, api_session=None):
name = payload.get('name', None)
id = payload.get('id', None)
if not name and not id:
LOG.warning('Unable to get QoS spec without a name or id')
return None
api_session = api_session or self.api_session
cc = cinder_client(api_session=api_session, region_name=region)
try:
# name is unique in openstack
if name:
qos_spec = cc.qos_specs.find(name=name)
else:
qos_spec = cc.qos_specs.get(id)
except cinderclient.exceptions.NotFound:
LOG.debug('Unable to get QoS spec missing in OpenStack: {}'.format(
name or id))
return None
return qos_spec
def sync_cinder(region_id=None):
assert region_id is not None, 'Unable to sync cinder objects without a region'
cc = cinder_client(api_session=get_keystone_admin().session, region_name=region_id)
try:
volume_types = cc.volume_types.list()
except EndpointNotFound as e:
LOG.error(str(e))
return
sync_volume_types(volume_types=volume_types, region=region_id)
for volume_type in volume_types:
sync_volume_type_extra_specs(volume_type=volume_type)
if not volume_type.is_public:
volume_type_to_projects = cc.volume_type_access.list(volume_type=volume_type.id)
sync_volume_type_to_projects(volume_type_to_projects=volume_type_to_projects)
qos_specs = cc.qos_specs.list()
sync_qos_specs(qos_specs=qos_specs)
sync_volumes(cc, region_id)
sync_volume_backups(cinder=cc, region_id=region_id)
sync_volume_snapshots(cinder=cc, region_id=region_id)
def delete_openstack_volume(self,
volume_id,
region,
project_id,
user_id: Optional[int] = None):
del self # unused
project = Project.with_admin_session(project_id, cache=AUTH_CACHE)
cc = cinder_client(api_session=project.api_session, region_name=region)
try:
db_volume = OpenstackVolume.objects.filter(id=volume_id).first()
user = AppUser.objects.filter(id=user_id).first()
cc.volumes.delete(volume=volume_id)
if user and db_volume:
if user.is_staff:
staff_signals.staff_delete_volume.send(
sender=__name__,
user=user,
user_id=user.id,
volume_name=db_volume.name,
volume_id=db_volume.id,
username=user.username,
)
else:
user_signals.user_delete_volume.send(
sender=__name__,
user=user,
user_id=user.id,
volume_name=db_volume.name,
volume_id=db_volume.id,
username=user.username,
)
except cinder_exceptions.NotFound:
OpenstackVolume.objects.filter(id=volume_id).delete()
def cinder_api(self):
assert self.api_session is not None, 'Unable to use cinder_api without a Keystoneauth session'
return cinder_client(api_session=self.api_session,
region_name=self.volume.region)
