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 perform_create(self, serializer: StaffVolumeCreateSerializer):
if not validate_cloud_objects_limit():
raise APIBadRequest(
_('Licence cloud objects limit reached. Please check your license.'
))
os_api = OSApi.from_project_id(
project_id=serializer.validated_data['project'].project_id)
volume_source = serializer.validated_data.pop('source', {})
source_type = volume_source.get('source_type')
source = volume_source.get('source')
source_id = source.pk if source else None
try:
os_api.volumes.create(
name=serializer.validated_data['name'],
size=serializer.validated_data['size'],
region_name=serializer.validated_data['region'],
type=serializer.validated_data.get('type', None),
source_type=source_type,
source_id=source_id)
except EndpointNotFound as e:
LOG.error(e)
raise APIBadRequest(
detail=_('Cinder endpoint not found for region {}').format(
serializer.validated_data['region'], ))
except Unauthorized as e:
LOG.error(e)
raise OpenstackAuthError(_('Operation not allowed'))
except Exception as e:
LOG.error(e)
handle(self.request, message=e)
def create_instance_task(self,
volume_id,
project_id,
project_domain_id,
region_name,
name,
image,
flavor,
nics,
block_device_mapping_v2,
block_device_mapping,
user_data=None,
user_id=None,
admin_pass=None,
key_name=None,
key_content=None):
os_api = OSApi(project=project_id, domain=project_domain_id)
boot_device = None
if block_device_mapping_v2:
for block_device in block_device_mapping_v2:
if block_device.get('boot_index') == '0':
boot_device = block_device
if boot_device and volume_id: # NOTE(tomo): Boot from volume with a volume type specified
boot_device['source_type'] = 'volume'
boot_device['uuid'] = volume_id
try:
server = os_api.instances.create(
name=name,
image=image,
flavor=flavor,
admin_pass=admin_pass,
nics=nics,
region_name=region_name,
key_name=key_name,
key_content=key_content,
user_data=user_data,
block_device_mapping=block_device_mapping,
block_device_mapping_v2=block_device_mapping_v2)
except Exception as e:
openstack_error.send(
sender='create_instance_task',
event_type='fleio_instance_create',
payload=dict(exception=str(e)),
region=region_name,
)
raise e
if user_id:
user = AppUser.objects.filter(id=user_id).first()
if user:
instance_create.send(sender=__name__,
user=user,
username=user.username,
instance_id=server.id,
request=None)
activity_helper.add_current_activity_params(object_id=server.id)
return server.id
def create_instance_volume(project_id, project_domain_id, region_name,
source_type, source_id, volume_size, volume_type):
os_api = OSApi(project=project_id, domain=project_domain_id)
new_volume = os_api.volumes.create(name=None,
size=volume_size,
region_name=region_name,
type=volume_type,
source_type=source_type,
source_id=source_id)
return new_volume.id
def auto_create_network(self, request):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
project_id = serializer.validated_data['project'].project_id
os_api = OSApi.from_project_id(project_id=project_id)
net_id = None
try:
net_id = os_api.networks.auto_create_network(
project_id=project_id,
region=serializer.validated_data['region'])
except Exception as e:
LOG.error(e)
handle(self.request, message=_('Unable to auto create network'))
return Response({'id': net_id})
def perform_create(self, serializer: StaffVolumeBackupCreateSerializer):
if not validate_cloud_objects_limit():
raise APIBadRequest(
_('Licence cloud objects limit reached. Please check your license.'
))
volume_id = serializer.validated_data.get('volume_id')
volume = Volume.objects.filter(id=volume_id).first()
if volume:
if serializer.validated_data.pop('for_client'):
try:
volume_related_project = volume.project
except Project.DoesNotExist:
raise APIBadRequest(
_('Cannot create volume backup for client because related volume has not '
'client project associated'))
else:
project_id_used = volume_related_project.project_id
os_api = OSApi.from_project_id(
project_id=volume_related_project.project_id)
else:
project_id_used = plugin_settings.USER_PROJECT_ID
os_api = OSAdminApi()
if serializer.validated_data.get('incremental') is True:
if not has_full_backup_for_incremental_backup(
project_id=project_id_used, related_volume=volume):
# for incremental backups check if a full backup related to the volume exists in the same project
# - openstack doesn't validate this at specific project level
raise APIBadRequest(detail=_(
'Cannot create incremental backup without having a full backup first '
'in your os project'))
try:
volume_backup = os_api.volume_backups.create(
region_id=volume.region,
**serializer.validated_data,
)
activity_helper.add_current_activity_params(
object_id=volume_backup.id)
except Exception as e:
LOG.error(e)
handle(self.request,
message=_('Unable to create volume backup'))
return Response(
{'detail': _('Volume backup creation in progress')})
else:
raise APIBadRequest(
_('Cannot create volume backup as related volume does not exist'
))
def perform_create(self, serializer: StaffVolumeSnapshotCreateSerializer):
if not validate_cloud_objects_limit():
raise APIBadRequest(
_('Licence cloud objects limit reached. Please check your license.'
))
volume_id = serializer.validated_data.get('volume_id')
for_client = serializer.validated_data.pop('for_client', False)
volume = Volume.objects.filter(id=volume_id).first()
if volume:
try:
if for_client:
if not volume.project:
raise APIBadRequest(
_('Cannot create snapshot for client as volume does not have a related '
'project in the database.'))
if volume.project.project_id == plugin_settings.user_project_id:
raise APIBadRequest(
_('The volume is in the admin project. No client found.'
))
os_api = OSApi.from_project_id(
project_id=volume.project.project_id)
else:
os_api = OSAdminApi()
volume_snapshot = os_api.volume_snapshots.create(
region_name=volume.region,
**serializer.validated_data,
)
activity_helper.add_current_activity_params(
object_id=volume_snapshot.id)
except Exception as e:
handle(self.request, message=str(e))
return Response(
{'detail': _('Volume snapshot creation in progress')})
else:
raise APIBadRequest(
_('Cannot create volume snapshot as related volume does not exist'
))
def perform_create(self, serializer: VolumeSnapshotCreateSerializer):
if not validate_cloud_objects_limit():
raise APIBadRequest(
_('Licence cloud objects limit reached. Please check your license.'
))
volume_id = serializer.validated_data.get('volume_id')
volume = Volume.objects.filter(id=volume_id).first()
if volume:
os_api = OSApi.from_request(request=self.request)
try:
volume_snapshot = os_api.volume_snapshots.create(
region_name=volume.region,
**serializer.validated_data,
)
activity_helper.add_current_activity_params(
object_id=volume_snapshot.id)
except Exception as e:
handle(self.request, message=str(e))
return Response(
{'detail': _('Volume snapshot creation in progress')})
else:
raise APIBadRequest(
_('Cannot create volume snapshot as related volume does not exist'
))
def get_os_api(self, request):
project_id = self.get_project_id(request=request)
project = Project.objects.filter(project_id=project_id).first()
return OSApi(project=project_id, domain=project.project_domain_id)
def get_os_api(self):
return OSApi.with_admin()
def create(self, service: Service) -> bool:
LOG.debug('Openstack module create called for service {0}:{1}'.format(
service.id, service))
client = service.client
try:
# if service was terminated and an openstack project remained in the db to keep revenue data,
# completely remove it
if service.openstack_project:
service.openstack_project.delete()
except Exception as e:
del e # unused
project_context = {'client': client}
# TODO: maybe this should be moved to OpenstackProject
try:
project_name = Template(
plugin_settings.default_project_name).render(
Context(project_context))
except Exception as e:
LOG.exception(e)
project_name = '{} - {}'.format(client.name, client.id)
project_description = 'Fleio created for {}'.format(client.name)
try:
admin_api = IdentityAdminApi()
except ConfigException:
LOG.error(
'Cannot perform action because openstack settings are missing/incorrect'
)
return False
project = admin_api.create_project(project_name,
plugin_settings.PROJECT_DOMAIN_ID,
project_description)
admin_api.grant_user_role(project.id, plugin_settings.USERNAME,
plugin_settings.DEFAULT_ROLE)
try:
with transaction.atomic():
Project.objects.create(service=service, project_id=project.id)
except IntegrityError:
# project may be created by updated, fetch and update
db_project = Project.objects.get(project_id=project.id)
db_project.service = service
db_project.save(update_fields=['service'])
product_settings = OpenstackProductSettings.objects.filter(
product=service.product).first()
if product_settings:
if product_settings.run_get_me_a_network_on_auto_setup:
# run get me a network for each defined region
os_api = OSApi.from_project_id(project_id=project.id,
auth_cache=None)
if product_settings.network_auto_allocated_topology_regions:
for region in product_settings.network_auto_allocated_topology_regions.all(
):
try:
os_api.networks.auto_create_network(
project_id=project.id,
region=region.id,
)
except neutron_exceptions.NeutronException as e:
LOG.error(
'Could not auto allocate network topology in region {}: {}'
.format(region.id, str(e)))
ServiceHelper.init_service_dynamic_usage(service)
return True
def os_api(self):
return OSApi.from_request(request=self.request)
def get_openstack_volume_snapshot(self, volume_snapshot=None):
volume_snapshot = volume_snapshot or self.get_object()
os_api = OSApi.from_request(request=self.request)
return os_api.volume_snapshots.get(volume_snapshot=volume_snapshot)