def terminate_resource(serialized_resource, serialized_user):
resource = core_utils.deserialize_instance(serialized_resource)
user = core_utils.deserialize_instance(serialized_user)
view = views.ResourceViewSet.as_view({'post': 'terminate'})
response = create_request(view, user, {}, uuid=resource.uuid.hex)
if response.status_code != status.HTTP_200_OK:
raise exceptions.ResourceTerminateException(response.rendered_content)
def process_role_revoked(serialized_profile, serialized_structure):
profile = core_utils.deserialize_instance(serialized_profile)
structure = core_utils.deserialize_instance(serialized_structure)
allocations = get_structure_allocations(structure)
for allocation in allocations:
allocation.get_backend().delete_user(allocation, profile.username)
def update_remote_project_permissions(serialized_project,
serialized_user,
role,
grant=True,
expiration_time=None):
project = deserialize_instance(serialized_project)
user = deserialize_instance(serialized_user)
new_expiration_time = (dateparse.parse_datetime(expiration_time)
if expiration_time else expiration_time)
sync_project_permission(grant, project, role, user, new_expiration_time)
def update_remote_customer_permissions(serialized_customer,
serialized_user,
role,
grant=True,
expiration_time=None):
customer = deserialize_instance(serialized_customer)
user = deserialize_instance(serialized_user)
new_expiration_time = (dateparse.parse_datetime(expiration_time)
if expiration_time else expiration_time)
for project in customer.projects.all():
sync_project_permission(grant, project, role, user,
new_expiration_time)
def update_referrable(serialized_referrable):
referrable = core_utils.deserialize_instance(serialized_referrable)
try:
logger.debug('Updating referrals of a Referrable %s.' % referrable)
get_datacite_info_helper(referrable)
except Exception as e:
logger.critical(e)
def link_doi_with_collection(serialized_instance):
instance = core_utils.deserialize_instance(serialized_instance)
try:
backend.DataciteBackend().link_doi_with_collection(instance)
except exceptions.DataciteException as e:
logger.critical(e)
def submit_job(serialized_job):
job = deserialize_instance(serialized_job)
try:
oauth_token = OAuthToken.objects.get(provider='keycloak', user=job.user)
except OAuthToken.DoesNotExist:
logger.debug('OAuth token for user %s is not found', job.user)
job.state = Job.States.ERRED
job.error_message = 'OAuth token is not found'
job.save()
return
token = oauth_token.access_token
if not token:
logger.debug('Access token for user %s is not found', job.user)
job.state = Job.States.ERRED
job.error_message = 'Access token is not found'
job.save()
return
api_url = job.service_settings.options.get('firecrest_api_url')
if not api_url:
logger.debug(
'Service settings %s does not have Firecrest API URL', job.service_settings
)
job.state = Job.States.ERRED
job.error_message = 'Service does not have Firecrest API URL'
job.save()
return
try:
utils.submit_job(api_url, token, job)
except FirecrestException as e:
job.state = Job.States.ERRED
job.error_message = str(e)
job.save()
def send_change_email_notification(request_serialized):
request = core_utils.deserialize_instance(request_serialized)
link = core_utils.format_homeport_link('user_email_change/{code}/',
code=request.uuid.hex)
context = {'request': request, 'link': link}
core_utils.broadcast_mail('structure', 'change_email_request', context,
[request.email])
def create_report(serialized_report):
report = deserialize_instance(serialized_report)
today = datetime.datetime.today()
timestamp = today.strftime('%Y%m%dT%H%M%S')
archive_filename = 'waldur-logs-%s-%s.tar.gz' % (timestamp,
report.uuid.hex)
try:
cf = create_report_archive(
settings.WALDUR_CORE['LOGGING_REPORT_DIRECTORY'],
settings.WALDUR_CORE['LOGGING_REPORT_INTERVAL'],
)
except (tarfile.TarError, OSError, ValueError) as e:
report.state = Report.States.ERRED
error_message = 'Error message: %s. Traceback: %s' % (
str(e),
traceback.format_exc(),
)
report.error_message = error_message
report.save()
else:
report.file.save(archive_filename, cf)
report.file_size = cf.size
report.state = Report.States.DONE
report.save()
def execute(self, tenant, serialized_new_template, serialized_old_package,
serialized_service_settings, *args, **kwargs):
new_template = core_utils.deserialize_instance(serialized_new_template)
old_package = core_utils.deserialize_instance(serialized_old_package)
service_settings = core_utils.deserialize_instance(serialized_service_settings)
with transaction.atomic():
serializers._set_tenant_quotas(tenant, new_template)
serializers._set_related_service_settings_quotas(tenant, new_template)
serializers._set_tenant_extra_configuration(tenant, new_template)
old_package.delete()
models.OpenStackPackage.objects.create(
template=new_template,
service_settings=service_settings,
tenant=tenant
)
def send_change_email_notification(request_serialized):
request = core_utils.deserialize_instance(request_serialized)
link = settings.WALDUR_CORE['EMAIL_CHANGE_URL'].format(
code=request.uuid.hex)
context = {'request': request, 'link': link}
core_utils.broadcast_mail('structure', 'change_email_request', context,
[request.email])
def send_issue_updated_notification(serialized_issue, changed):
issue = core_utils.deserialize_instance(serialized_issue)
_send_issue_notification(
issue=issue,
template='issue_updated',
extra_context={'changed': changed},
)
def execute(self, droplet, serialized_size, *args, **kwargs):
size = utils.deserialize_instance(serialized_size)
logger.info('Successfully resized droplet %s', droplet.uuid.hex)
log.event_logger.droplet_resize.info(
'Droplet {droplet_name} has been resized.',
event_type='droplet_resize_succeeded',
event_context={'droplet': droplet, 'size': size},
)
def send_comment_added_notification(serialized_comment):
comment = core_utils.deserialize_instance(serialized_comment)
_send_issue_notification(
issue=comment.issue,
template='comment_added',
extra_context={'comment': comment},
)
def run(self, serialized_instance):
instance = core_utils.deserialize_instance(serialized_instance)
try:
self.pull(instance)
except ServiceBackendError as e:
self.on_pull_fail(instance, e)
else:
self.on_pull_success(instance)
def run(self, serialized_executor, serialized_model, serialized_project,
*args, **kwargs):
executor = core_utils.deserialize_class(serialized_executor)
model_cls = core_utils.deserialize_class(serialized_model)
project = core_utils.deserialize_instance(serialized_project)
for resource in model_cls.objects.filter(project=project):
executor.execute(resource, async=False, force=True, **kwargs)
def send_comment_updated_notification(serialized_comment, old_description):
comment = core_utils.deserialize_instance(serialized_comment)
_send_issue_notification(
issue=comment.issue,
template='comment_updated',
extra_context={'comment': comment, 'old_description': old_description,},
)
def detect_vm_coordinates(serialized_virtual_machine):
try:
vm = utils.deserialize_instance(serialized_virtual_machine)
except exceptions.ObjectDoesNotExist:
logger.warning('Missing virtual machine %s.',
serialized_virtual_machine)
return
geo_ip_utils.detect_coordinates(vm)
def create_confirmation_comment(serialized_issue):
issue = core_utils.deserialize_instance(serialized_issue)
try:
backend.get_active_backend().create_confirmation_comment(issue)
except Exception as e:
issue.error_message = str(e)
issue.save(update_fields=['error_message'])
else:
issue.error_message = ''
issue.save(update_fields=['error_message'])
def run(self, action_id, serialized_droplet):
droplet = utils.deserialize_instance(serialized_droplet)
backend = droplet.get_backend()
action = backend.manager.get_action(action_id)
if action.status == 'completed':
backend_droplet = backend.get_droplet(droplet.backend_id)
droplet.ip_address = backend_droplet.ip_address
droplet.save(update_fields=['ip_address'])
return True
else:
self.retry()
def send_expert_comment_added_notification(serialized_comment):
# Send Expert notifications
comment = core_utils.deserialize_instance(serialized_comment)
expert_request = comment.issue.expertrequest_set.first()
expert_contract = getattr(expert_request, 'contract', None)
if expert_contract:
experts = expert_contract.team.get_users(structure_models.ProjectRole.ADMINISTRATOR)
if comment.author.user not in experts:
for expert in experts:
_send_issue_notification(comment.issue, 'comment_added', receiver=expert)
def execute(self, tenant, event, new_package, old_package, service_settings, *args, **kwargs):
service_settings = core_utils.deserialize_instance(service_settings)
event_type = 'openstack_package_change_succeeded' if event == 'succeeded' else 'openstack_package_change_failed'
event_logger.openstack_package.info(
'Tenant package changing has %s. '
'Old value: %s, new value: {package_template_name}' % (event, old_package),
event_type=event_type,
event_context={
'tenant': tenant,
'package_template_name': new_package,
'service_settings': service_settings,
})
def _get_issue_details(self, validated_data):
issue_details = super(OfferingCreateSerializer,
self)._get_issue_details(validated_data)
order_item_serialized = self.context['request'].data.get('order_item')
if order_item_serialized:
order_item = core_utils.deserialize_instance(order_item_serialized)
issue_details['resource_object_id'] = order_item.id
issue_details[
'resource_content_type'] = ContentType.objects.get_for_model(
order_item)
return issue_details
def create_doi(serialized_instance):
instance = core_utils.deserialize_instance(serialized_instance)
if instance.datacite_doi:
logger.warning(
'Registration of %s has been skipped because datacite_doi field is not empty.'
% instance)
return
try:
backend.DataciteBackend().create_doi(instance)
except exceptions.DataciteException as e:
logger.critical(e)
def send_issue_feedback_notification(serialized_issue):
issue = core_utils.deserialize_instance(serialized_issue)
signer = signing.TimestampSigner()
token = signer.sign(issue.uuid.hex)
extra_context = {
'feedback_link':
get_feedback_link(token),
'feedback_links': [{
'label': value,
'link': get_feedback_link(token, key),
} for (key, value) in models.Feedback.Evaluation.CHOICES],
}
_send_issue_feedback(
issue=issue,
template='issue_feedback',
extra_context=extra_context,
)
def run(self, serialized_instance, *args, **kwargs):
""" Deserialize input data and start backend operation execution """
try:
instance = utils.deserialize_instance(serialized_instance)
except ObjectDoesNotExist:
raise ObjectDoesNotExist(
'Cannot restore instance from serialized object %s. Probably it was deleted.'
% serialized_instance)
self.args = args
self.kwargs = kwargs
self.pre_execute(instance)
result = self.execute(instance, *self.args, **self.kwargs)
self.post_execute(instance)
if result and isinstance(result, django_models.Model):
result = utils.serialize_instance(result)
return result
def detect_vm_coordinates(serialized_virtual_machine):
try:
vm = core_utils.deserialize_instance(serialized_virtual_machine)
except exceptions.ObjectDoesNotExist:
logger.warning('Missing virtual machine %s.', serialized_virtual_machine)
return
try:
coordinates = vm.detect_coordinates()
except utils.GeoIpException as e:
logger.warning('Unable to detect coordinates for virtual machines %s: %s.', serialized_virtual_machine, e)
return
if coordinates:
vm.latitude = coordinates.latitude
vm.longitude = coordinates.longitude
vm.save(update_fields=['latitude', 'longitude'])
def send_issue_feedback_notification(serialized_issue):
issue = core_utils.deserialize_instance(serialized_issue)
signer = signing.TimestampSigner()
token = signer.sign(issue.uuid.hex)
extra_context = {
'feedback_links': [{
'label':
value,
'link':
settings.ISSUE_FEEDBACK_LINK_TEMPLATE.format(token=token,
evaluation=key),
} for (key, value) in models.Feedback.Evaluation.CHOICES],
}
_send_issue_feedback(
issue=issue,
template='issue_feedback',
extra_context=extra_context,
)
def create_invoice_pdf(serialized_invoice):
invoice = core_utils.deserialize_instance(serialized_invoice)
utils.create_invoice_pdf(invoice)
def process_order(serialized_order, serialized_user):
order = core_utils.deserialize_instance(serialized_order)
user = core_utils.deserialize_instance(serialized_user)
for item in order.items.all():
process_order_item(item, user)
