def delete_backup_item(request, pk):
backup_item = BackupItem.objects.get(pk=pk)
if backup_item.status == BACKUP_STATE_ERROR or \
backup_item.rbd_image is None:
backup_item.deleted = True
backup_item.change_status(BACKUP_STATE_DELETED)
backup_item.save()
return success(_("Backup item Deleted."))
if BackupItem.is_any_node_untable(backup_item.chain_id):
return fail(_("There is one task running on this chain."))
BackupItem.mark_chain_delete(backup_item)
Operation.log(backup_item, obj_name=backup_item.name, action="delete")
try:
tasks.delete_backup.delay(backup_item.id)
except Exception:
LOG.exception("Failed to delete backup item. %s", backup_item)
return error()
else:
return success(_("Deleting"))
def delete_backup_item(request, pk):
backup_item = BackupItem.objects.get(pk=pk)
if backup_item.status == BACKUP_STATE_ERROR or \
backup_item.rbd_image is None:
backup_item.deleted = True
backup_item.change_status(BACKUP_STATE_DELETED)
backup_item.save()
return success(_("Backup item Deleted."))
if BackupItem.is_any_node_untable(backup_item.chain_id):
return fail(_("There is one task running on this chain."))
BackupItem.mark_chain_delete(backup_item)
Operation.log(backup_item, obj_name=backup_item.name, action="delete")
try:
tasks.delete_backup.delay(backup_item.id)
except Exception:
LOG.exception("Failed to delete backup item. %s", backup_item)
return error()
else:
return success(_("Deleting"))
def delete_pool(request):
pool_id = request.data['pool_id']
try:
pool = BalancerPool.objects.get(
pk=pool_id,
user=request.user,
user_data_center=request.session["UDC_ID"])
except BalancerPool.DoesNotExist:
return fail(_('No balancer found.'))
if not pool.pool_uuid:
pool.deleted = True
pool.save()
return success(
_('Balancer pool %(name)s is deleted') % {'name': pool.name})
pool.status = POOL_DELETING
pool.save()
Operation.log(pool, obj_name=pool.name, action='delete')
try:
pool_delete_task.delay(pool)
except Exception:
LOG.exception("Failed to delete balancer pool[%s]", pool)
return error()
return success(_('Deleting balancer pool %(name)s') % {'name': pool.name})
def delete_pool(request):
pool_id = request.data['pool_id']
try:
pool = BalancerPool.objects.get(
pk=pool_id, user=request.user,
user_data_center=request.session["UDC_ID"])
except BalancerPool.DoesNotExist:
return fail(_('No balancer found.'))
if not pool.pool_uuid:
pool.deleted = True
pool.save()
return success(_('Balancer pool %(name)s is deleted')
% {'name': pool.name})
pool.status = POOL_DELETING
pool.save()
Operation.log(pool, obj_name=pool.name, action='delete')
try:
pool_delete_task.delay(pool)
except Exception:
LOG.exception("Failed to delete balancer pool[%s]", pool)
return error()
return success(_('Deleting balancer pool %(name)s') % {'name': pool.name})
def delete_action(volume):
if volume.instance is not None:
msg = _('Operation Failed. '
'Volume %(volume)s is attached to instance: %(instance)s') \
% {'instance': volume.instance.name, 'volume': volume.name}
return fail(msg=msg)
if BackupItem.living.filter(resource_id=volume.id,
resource_type=Volume.__name__).exists():
return fail(_("This volume has backups, please delete them first."))
if volume.volume_id:
volume.change_status(VOLUME_STATE_DELETING)
try:
volume_delete_task.delay(volume)
Operation.log(volume, obj_name=volume.name,
action="terminate", result=1)
return success(msg=_('Deleting volume'))
except Exception:
LOG.exception("Delete volume error")
volume.change_status(VOLUME_STATE_ERROR)
return error()
else:
volume.fake_delete()
return success(msg=_('Volume is deleted.'))
def volume_attach_or_detach(data, volume, action):
if 'attach' == action:
instance = Instance.objects.get(pk=data.get('instance_id'))
volume.change_status(VOLUME_STATE_ATTACHING)
Operation.log(volume, obj_name=volume.name, action="attach_volume")
try:
tasks.attach_volume_to_instance.delay(
instance=instance, volume=volume)
except Exception:
volume.change_status(VOLUME_STATE_AVAILABLE)
LOG.exception("Attach volume error")
return error()
else:
return success(msg=_('Attaching volume'),
status=status.HTTP_201_CREATED)
elif 'detach' == action:
volume.change_status(VOLUME_STATE_DETACHING)
Operation.log(volume, obj_name=volume.name, action="detach_volume")
try:
tasks.detach_volume_from_instance.delay(volume)
except Exception:
LOG.exception("Detach volume error")
volume.change_status(VOLUME_STATE_IN_USE)
return error()
else:
return success(msg=_('Detaching volume'),
status=status.HTTP_201_CREATED)
def volume_create_view(request):
try:
serializer = VolumeSerializer(data=request.data,
context={"request": request})
if not serializer.is_valid():
return fail(msg=_('Data is not valid.'),
status=status.HTTP_400_BAD_REQUEST)
volume = serializer.save()
Operation.log(volume, obj_name=volume.name, action="create", result=1)
workflow = Workflow.get_default(ResourceType.VOLUME)
if settings.SITE_CONFIG['WORKFLOW_ENABLED'] and workflow:
volume.status = VOLUME_STATE_APPLYING
volume.save()
FlowInstance.create(volume, request.user, workflow, None)
msg = _("Your application for %(size)d GB volume is successful, "
"please waiting for approval result!") \
% {'size': volume.size}
return success(msg=msg)
else:
try:
volume_create_task.delay(volume)
return success(msg=_('Creating volume'),
status=status.HTTP_201_CREATED)
except Exception as e:
LOG.exception("Failed to create volume, msg: %s", e)
volume.status = VOLUME_STATE_ERROR
volume.save()
return error()
except Exception as e:
LOG.exception("create volume error, msg:[%s]", e)
return error()
def delete_action(volume):
if volume.instance is not None:
msg = _('Operation Failed. '
'Volume %(volume)s is attached to instance:%(instance)s') \
% {'instance': volume.instance.name, 'volume': volume.name}
return fail(msg=msg)
if volume.volume_id:
volume.status = VOLUME_STATE_DELETING
volume.save()
try:
volume_delete_action_task.delay(volume)
Operation.log(volume,
obj_name=volume.name,
action="terminate",
result=1)
return success(msg=_('Deleting volume'))
except Exception as e:
LOG.exception("Delete volume error, msg:%s", e)
volume.status = VOLUME_STATE_ERROR
volume.save()
return error()
else:
volume.deleted = True
volume.save()
return success(msg=_('Volume is deleted.'))
def delete_action(volume):
if volume.instance is not None:
msg = _('Operation Failed. '
'Volume %(volume)s is attached to instance:%(instance)s') \
% {'instance': volume.instance.name, 'volume': volume.name}
return fail(msg=msg)
if volume.volume_id:
volume.status = VOLUME_STATE_DELETING
volume.save()
try:
volume_delete_action_task.delay(volume)
Operation.log(volume, obj_name=volume.name,
action="terminate", result=1)
return success(msg=_('Deleting volume'))
except Exception as e:
LOG.exception("Delete volume error, msg:%s", e)
volume.status = VOLUME_STATE_ERROR
volume.save()
return error()
else:
volume.deleted = True
volume.save()
return success(msg=_('Volume is deleted.'))
def volume_create_view(request):
try:
serializer = VolumeSerializer(data=request.data,
context={"request": request})
if not serializer.is_valid():
return fail(msg=_('Data is not valid.'),
status=status.HTTP_400_BAD_REQUEST)
volume = serializer.save()
Operation.log(volume, obj_name=volume.name, action="create", result=1)
workflow = Workflow.get_default(ResourceType.VOLUME)
if settings.SITE_CONFIG['WORKFLOW_ENABLED'] and workflow:
volume.status = VOLUME_STATE_APPLYING
volume.save()
FlowInstance.create(volume, request.user, workflow, None)
msg = _("Your application for %(size)d GB volume is successful, "
"please waiting for approval result!") \
% {'size': volume.size}
return success(msg=msg)
else:
try:
volume_create_task.delay(volume)
return success(msg=_('Creating volume'),
status=status.HTTP_201_CREATED)
except Exception as e:
LOG.exception("Failed to create volume, msg: %s", e)
volume.status = VOLUME_STATE_ERROR
volume.save()
return error()
except Exception as e:
LOG.exception("create volume error, msg:[%s]", e)
return error()
def volume_attach_or_detach(data, volume, action):
if 'attach' == action:
instance = Instance.objects.get(pk=data.get('instance_id'))
volume.change_status(VOLUME_STATE_ATTACHING)
Operation.log(volume, obj_name=volume.name, action="attach_volume")
try:
tasks.attach_volume_to_instance.delay(instance=instance,
volume=volume)
except Exception:
volume.change_status(VOLUME_STATE_AVAILABLE)
LOG.exception("Attach volume error")
return error()
else:
return success(msg=_('Attaching volume'),
status=status.HTTP_201_CREATED)
elif 'detach' == action:
volume.change_status(VOLUME_STATE_DETACHING)
Operation.log(volume, obj_name=volume.name, action="detach_volume")
try:
tasks.detach_volume_from_instance.delay(volume)
except Exception:
LOG.exception("Detach volume error")
volume.change_status(VOLUME_STATE_IN_USE)
return error()
else:
return success(msg=_('Detaching volume'),
status=status.HTTP_201_CREATED)
def delete_action(volume):
if volume.instance is not None:
msg = _('Operation Failed. '
'Volume %(volume)s is attached to instance: %(instance)s') \
% {'instance': volume.instance.name, 'volume': volume.name}
return fail(msg=msg)
if BackupItem.living.filter(resource_id=volume.id,
resource_type=Volume.__name__).exists():
return fail(_("This volume has backups, please delete them first."))
if volume.volume_id:
volume.change_status(VOLUME_STATE_DELETING)
try:
volume_delete_task.delay(volume)
Operation.log(volume,
obj_name=volume.name,
action="terminate",
result=1)
return success(msg=_('Deleting volume'))
except Exception:
LOG.exception("Delete volume error")
volume.change_status(VOLUME_STATE_ERROR)
return error()
else:
volume.fake_delete()
return success(msg=_('Volume is deleted.'))
def volume_create_view(request):
try:
os_volume_type = request.data['os_volume_type']
os_volume_type = ast.literal_eval(os_volume_type)
os_volume_type = os_volume_type['name']
LOG.info("********** os volume type is ************" +
str(os_volume_type))
request.data['os_volume_type'] = os_volume_type
LOG.info("********** os volume type is ************" +
str(os_volume_type))
serializer = VolumeSerializer(data=request.data,
context={"request": request})
if not serializer.is_valid():
#return fail(msg=_('Data is not valid.'),
return fail(msg='{}'.format(serializer.errors),
status=status.HTTP_400_BAD_REQUEST)
pay_type = request.data['pay_type']
LOG.info("********** os volume type is ************" +
str(os_volume_type))
pay_num = int(request.data['pay_num'])
volume = serializer.save()
Operation.log(volume, obj_name=volume.name, action="create", result=1)
workflow = Workflow.get_default(ResourceType.VOLUME)
if settings.SITE_CONFIG['WORKFLOW_ENABLED'] and workflow:
volume.status = VOLUME_STATE_APPLYING
volume.save()
FlowInstance.create(volume, request.data.user, workflow,
None) # TODO test this
msg = _("Your application for %(size)d GB volume is successful, "
"please waiting for approval result!") \
% {'size': volume.size}
return success(msg=msg)
else:
try:
volume_create_task.delay(volume, os_volume_type)
Order.for_volume(volume, pay_type=pay_type, pay_num=pay_num)
return success(msg=_('Creating volume'),
status=status.HTTP_201_CREATED)
except Exception as e:
LOG.exception("Failed to create volume, msg: %s", e)
volume.status = VOLUME_STATE_ERROR
volume.save()
return error()
except Exception as e:
LOG.exception("create volume error, msg:[%s]", e)
return error()
def backup_volume(request):
volume_id, name, is_full = retrieve_params(
request.data, 'volume_id', 'name', 'is_full')
udc = UserDataCenter.objects.get(pk=request.session["UDC_ID"])
is_full = True if is_full == 'true' else False
volume = Volume.objects.get(pk=volume_id)
if BackupItem.is_any_unstable(resource=volume):
return fail(_("Volume %(name)s has one backup task now.")
% {'name': volume.name})
if BackupItem.has_error_node_on_default_chain(resource=volume):
return fail(_("Volume %(name)s has one error backup node on "
"default backup chain. Please delete it first")
% {'name': volume.name})
item = BackupItem.create(volume, name, request.user, udc, is_full=is_full)
Operation.log(volume, obj_name=volume.name, action="backup")
tasks.execute_backup.delay(item.id)
return success(_("Backup is in process."))
def create_pool_vip(request):
pool_id = request.data['pool_id']
try:
pool = BalancerPool.objects.get(
pk=pool_id, user=request.user,
user_data_center=request.session["UDC_ID"])
except BalancerPool.DoesNotExist:
return fail(_("No balancer pool found!"))
serializer = BalancerVIPSerializer(data=request.data,
context={'request': request})
if not serializer.is_valid():
return fail(_('Data is not valid'))
vip = serializer.save()
Operation.log(vip, obj_name=vip.name, action='create')
pool.status = POOL_UPDATING
pool.save()
try:
pool_vip_create_task.delay(vip, pool)
except Exception:
vip.delete()
return error()
return success(_('Creating balancer vip.'))
def create_pool_member(request):
serializer = BalancerMemberSerializer(data=request.data,
context={'request': request})
if not serializer.is_valid():
return fail(_('Data is not valid.'))
pool_id = request.data['pool_id']
user = request.user
udc = UserDataCenter.objects.get(pk=request.session["UDC_ID"])
try:
pool = BalancerPool.objects.get(pk=pool_id, user=request.user)
except BalancerPool.DoesNotExist:
return fail(_('Selected balancer not found.'))
weight = int(request.data['weight'])
protocol_port = int(request.data['protocol_port'])
for instance_id in request.data.getlist('instance_ids[]'):
instance = Instance.objects.get(pk=instance_id, user=request.user)
member = BalancerMember.objects.create(
pool=pool, weight=weight, protocol_port=protocol_port,
user=user, user_data_center=udc, instance=instance
)
Operation.log(member, obj_name=instance.name, action='create')
pool_member_create_task.delay(member)
return success(_("Load balancer members are being created."))
def update_pool_monitor(request):
monitor_id = request.data['id']
try:
monitor = BalancerMonitor.objects.get(pk=monitor_id, user=request.user)
except BalancerMonitor.DoesNotExist:
return fail(_("No monitor found!"))
serializer = BalancerMonitorSerializer(data=request.data,
instance=monitor,
context={'request': request})
if not serializer.is_valid():
return fail(_("Monitor data is not valid"))
monitor.delay = int(request.data['delay'])
monitor.timeout = int(request.data['timeout'])
monitor.max_retries = int(request.data['max_retries'])
if pool_monitor_update(monitor):
monitor.save()
Operation.log(monitor, obj_name=monitor.get_type_display(),
action='update')
return success(_('Balancer monitor is updated!'))
else:
return error()
def create_pool_member(request):
serializer = BalancerMemberSerializer(data=request.data,
context={'request': request})
if not serializer.is_valid():
return fail(_('Data is not valid.'))
pool_id = request.data['pool_id']
user = request.user
udc = UserDataCenter.objects.get(pk=request.session["UDC_ID"])
try:
pool = BalancerPool.objects.get(pk=pool_id, user=request.user)
except BalancerPool.DoesNotExist:
return fail(_('Selected balancer not found.'))
weight = int(request.data['weight'])
protocol_port = int(request.data['protocol_port'])
for instance_id in request.data.getlist('instance_ids[]'):
instance = Instance.objects.get(pk=instance_id, user=request.user)
member = BalancerMember.objects.create(pool=pool,
weight=weight,
protocol_port=protocol_port,
user=user,
user_data_center=udc,
instance=instance)
Operation.log(member, obj_name=instance.name, action='create')
pool_member_create_task.delay(member)
return success(_("Load balancer members are being created."))
def instance_change_firewall_view(request):
data = request.data
try:
instance = Instance.objects.get(pk=data['instance_id'])
except Instance.DoesNotExist:
return fail(_("Instance is not found"))
try:
firewall = Firewall.objects.get(pk=data.get('firewall_id'))
except Firewall.DoesNotExist:
return fail(_("Firewall is not found"))
Operation.log(instance, obj_name=instance.name, action="change_firewall")
try:
server_update_security_groups_task.delay(instance, firewall)
except Exception:
LOG.exception("Failed to change firewall group of instance. %s",
instance)
return error()
return success(
_("Instance %(name)s's firewall is changed.") %
{'name': instance.name})
def backup_volume(request):
volume_id, name, is_full = retrieve_params(request.data, 'volume_id',
'name', 'is_full')
udc = UserDataCenter.objects.get(pk=request.session["UDC_ID"])
is_full = True if is_full == 'true' else False
volume = Volume.objects.get(pk=volume_id)
if BackupItem.is_any_unstable(resource=volume):
return fail(
_("Volume %(name)s has one backup task now.") %
{'name': volume.name})
if BackupItem.has_error_node_on_default_chain(resource=volume):
return fail(
_("Volume %(name)s has one error backup node on "
"default backup chain. Please delete it first") %
{'name': volume.name})
item = BackupItem.create(volume, name, request.user, udc, is_full=is_full)
Operation.log(volume, obj_name=volume.name, action="backup")
tasks.execute_backup.delay(item.id)
return success(_("Backup is in process."))
def update_pool_monitor(request):
monitor_id = request.data['id']
try:
monitor = BalancerMonitor.objects.get(pk=monitor_id, user=request.user)
except BalancerMonitor.DoesNotExist:
return fail(_("No monitor found!"))
serializer = BalancerMonitorSerializer(data=request.data,
instance=monitor,
context={'request': request})
if not serializer.is_valid():
return fail(_("Monitor data is not valid"))
monitor.delay = int(request.data['delay'])
monitor.timeout = int(request.data['timeout'])
monitor.max_retries = int(request.data['max_retries'])
if pool_monitor_update(monitor):
monitor.save()
Operation.log(monitor,
obj_name=monitor.get_type_display(),
action='update')
return success(_('Balancer monitor is updated!'))
else:
return error()
def create_pool_vip(request):
pool_id = request.data['pool_id']
try:
pool = BalancerPool.objects.get(
pk=pool_id,
user=request.user,
user_data_center=request.session["UDC_ID"])
except BalancerPool.DoesNotExist:
return fail(_("No balancer pool found!"))
serializer = BalancerVIPSerializer(data=request.data,
context={'request': request})
if not serializer.is_valid():
return fail(_('Data is not valid'))
vip = serializer.save()
Operation.log(vip, obj_name=vip.name, action='create')
pool.status = POOL_UPDATING
pool.save()
try:
pool_vip_create_task.delay(vip, pool)
except Exception:
vip.delete()
return error()
return success(_('Creating balancer vip.'))
def change_user_action(volume, user_id, supercode):
if validate_supercode(supercode):
volume.user = UserProxy.objects.get(pk=user_id)
volume.save()
return success(msg=_('Volume user changed'),
status=status.HTTP_201_CREATED)
else:
return fail(msg=_('Incorrect supercode'))
def attach_monitor_to_pool(pool, monitor):
Operation.log(pool, obj_name=pool.name, action='attach')
if pool_monitor_association_create(pool, monitor):
return success(_('Monitor is attached.'))
else:
return error()
def attach_monitor_to_pool(pool, monitor):
Operation.log(pool, obj_name=pool.name, action='attach')
if pool_monitor_association_create(pool, monitor):
return success(_('Monitor is attached.'))
else:
return error()
def detach_monitor_from_pool(pool, monitor):
Operation.log(pool, obj_name=pool.name, action='detach', result=1)
if pool_monitor_association_delete(pool, monitor):
return success(_('Monitor is detached'))
else:
return error()
def detach_monitor_from_pool(pool, monitor):
Operation.log(pool, obj_name=pool.name, action='detach', result=1)
if pool_monitor_association_delete(pool, monitor):
return success(_('Monitor is detached'))
else:
return error()
def create_price_rule(request):
serializer = PriceRuleSerializer(data=request.data)
if not serializer.is_valid():
return fail(_("Data is not valid."))
serializer.save()
return success(_("Price is created."))
def create_price_rule(request):
serializer = PriceRuleSerializer(data=request.data)
if not serializer.is_valid():
return fail(_("Data is not valid."))
serializer.save()
return success(_("Price is created."))
def volume_attach_or_detach(data, volume, action):
if 'attach' == action:
volume.status = VOLUME_STATE_ATTACHING
instance = Instance.objects.get(pk=data.get('instance_id'))
volume.save()
Operation.log(volume,
obj_name=volume.name,
action="attach_volume",
result=1)
try:
volume_attach_or_detach_task.delay(instance=instance,
volume=volume,
action=action)
return success(msg=_('Attaching volume'),
status=status.HTTP_201_CREATED)
except Exception as e:
volume.status = VOLUME_STATE_AVAILABLE
volume.save()
LOG.exception("Attach volume error ,msg: %s" % e)
return fail(msg=_('Attach volume error'))
elif 'detach' == action:
volume.status = VOLUME_STATE_DETACHING
instance = Instance.objects.get(pk=volume.instance.id)
volume.save()
Operation.log(volume,
obj_name=volume.name,
action="detach_volume",
result=1)
try:
volume_attach_or_detach_task.delay(instance=instance,
volume=volume,
action=action)
return success(msg=_('Detaching volume'),
status=status.HTTP_201_CREATED)
except Exception as e:
LOG.exception("Detach volume error, msg: % s", e)
volume.status = VOLUME_STATE_IN_USE
volume.save()
return
def update_price_rule(request):
pk = request.data['id']
rule = PriceRule.objects.get(pk=pk)
serializer = PriceRuleSerializer(data=request.data, instance=rule)
if not serializer.is_valid():
return fail(_("Data is not valid."))
serializer.save()
return success(_("Price is created."))
def update_price_rule(request):
pk = request.data['id']
rule = PriceRule.objects.get(pk=pk)
serializer = PriceRuleSerializer(data=request.data, instance=rule)
if not serializer.is_valid():
return fail(_("Data is not valid."))
serializer.save()
return success(_("Price is created."))
def backup_instance(request):
instance_id, name, is_full = retrieve_params(request.data, 'instance_id',
'name', 'is_full')
udc = UserDataCenter.objects.get(pk=request.session["UDC_ID"])
volume_ids = request.data.getlist('volume_ids[]')
is_full = True if is_full == 'true' else False
instance = Instance.objects.get(pk=instance_id)
volumes = Volume.objects.filter(pk__in=volume_ids)
if BackupItem.is_any_unstable(resource=instance):
return fail(
_("Instance %(name)s has one backup task now.") %
{'name': instance.name})
if BackupItem.has_error_node_on_default_chain(resource=instance):
return fail(
_("Instance %(name)s has one error backup node on "
"default backup chain. Please delete it first") %
{'name': instance.name})
for volume in volumes:
if BackupItem.is_any_unstable(resource=volume):
return fail(
_("Volume %(name)s has one backup task now.") %
{'name': volume.name})
if BackupItem.has_error_node_on_default_chain(resource=volume):
return fail(
_("Volume %(name)s has one error backup node on "
"default backup chain. Please delet it first") %
{'name': volume.name})
items = [
BackupItem.create(instance, name, request.user, udc, is_full=is_full)
]
Operation.log(instance, obj_name=instance.name, action="backup")
for volume in volumes:
items.append(
BackupItem.create(volume, name, request.user, udc,
is_full=is_full))
Operation.log(volume, obj_name=volume.name, action="backup")
for item in items:
tasks.execute_backup.delay(item.id)
return success(_("Backup is in process."))
def delete_pool_member(request):
member_id = request.data['id']
try:
member = BalancerMember.objects.get(pk=member_id)
except BalancerMember.DoesNotExist:
return success(_("Member is deleted."))
if not member.member_uuid:
member.deleted = True
member.save()
Operation.log(member, obj_name=member.instance.name, action='delete')
return success(_("Member is deleted."))
member.status = POOL_DELETING
member.save()
try:
pool_member_delete_task.delay(member)
except Exception:
member.status = POOL_ACTIVE
return error()
else:
return success(_("Deleting member"))
def pool_vip_delete_view(request):
pool_id = request.data['id']
pool = BalancerPool.objects.get(pk=pool_id, user=request.user)
vip = BalancerVIP.objects.get(pk=pool.vip.id, user=request.user,
user_data_center=request.session["UDC_ID"])
try:
pool_vip_delete_task.delay(vip, pool)
except Exception:
return error()
else:
Operation.log(vip, obj_name=vip.name, action='delete', result=1)
return success(_('Deleting balancer vip '))
def update_supercode_view(request):
if request.method == "GET":
return Response(supercode_exists())
else:
old = request.data.get("old")
new1 = request.data.get("new1")
new2 = request.data.get("new2")
if (new1 != new2):
return fail(msg=_("Inconsistent code"))
elif (not supercode_exists() or validate_supercode(old)):
update_supercode(new1)
return success(msg=_("Supercode changed"))
else:
return fail(msg=_("Incorrect supercode"))
def delete_pool_member(request):
member_id = request.data['id']
try:
member = BalancerMember.objects.get(pk=member_id)
except BalancerMember.DoesNotExist:
return success(_("Member is deleted."))
if not member.member_uuid:
member.deleted = True
member.save()
Operation.log(member, obj_name=member.instance.name, action='delete')
return success(_("Member is deleted."))
member.status = POOL_DELETING
member.save()
try:
pool_member_delete_task.delay(member)
except Exception:
member.status = POOL_ACTIVE
return error()
else:
return success(_("Deleting member"))
def pool_vip_delete_view(request):
pool_id = request.data['id']
pool = BalancerPool.objects.get(pk=pool_id, user=request.user)
vip = BalancerVIP.objects.get(pk=pool.vip.id,
user=request.user,
user_data_center=request.session["UDC_ID"])
try:
pool_vip_delete_task.delay(vip, pool)
except Exception:
return error()
else:
Operation.log(vip, obj_name=vip.name, action='delete', result=1)
return success(_('Deleting balancer vip '))
def delete_pool_monitor(request):
monitor_id = request.data['id']
monitor = BalancerMonitor.objects.get(pk=monitor_id, user=request.user)
if BalancerPoolMonitor.objects.filter(monitor=monitor).exists():
return fail(_("Monitor %(name)s is being used, can not be deleted.")
% {'name': monitor.name})
if pool_monitor_delete(monitor):
Operation.log(monitor, obj_name=monitor.get_type_display(), action='delete')
return success(_('Balancer monitor is deleted.'))
else:
return error()
def firewall_rule_delete_view(request):
data = request.data
try:
firewall_rule = FirewallRules.objects.get(pk=data.get('id'))
except FirewallRules.DoesNotExist:
return fail(_("Firewall rule not exists."))
obj_name = firewall_rule.protocol if firewall_rule.protocol else ""
Operation.log(firewall_rule, obj_name=obj_name.upper(), action="terminate")
if security_group_rule_delete_task(firewall_rule):
return success(_("Firewall Rule is deleted."))
else:
return error()
def firewall_rule_delete_view(request):
data = request.data
try:
firewall_rule = FirewallRules.objects.get(pk=data.get('id'))
except FirewallRules.DoesNotExist:
return fail(_("Firewall rule not exists."))
obj_name = firewall_rule.protocol if firewall_rule.protocol else ""
Operation.log(firewall_rule, obj_name=obj_name.upper(), action="terminate")
if security_group_rule_delete_task(firewall_rule):
return success(_("Firewall Rule is deleted."))
else:
return error()
def volume_attach_or_detach(data, volume, action):
if 'attach' == action:
volume.status = VOLUME_STATE_ATTACHING
instance = Instance.objects.get(pk=data.get('instance_id'))
volume.save()
Operation.log(volume, obj_name=volume.name,
action="attach_volume", result=1)
try:
volume_attach_or_detach_task.delay(instance=instance, volume=volume,
action=action)
return success(msg=_('Attaching volume'),
status=status.HTTP_201_CREATED)
except Exception as e:
volume.status = VOLUME_STATE_AVAILABLE
volume.save()
LOG.exception("Attach volume error ,msg: %s" % e)
return fail(msg=_('Attach volume error'))
elif 'detach' == action:
volume.status = VOLUME_STATE_DETACHING
instance = Instance.objects.get(pk=volume.instance.id)
volume.save()
Operation.log(volume, obj_name=volume.name,
action="detach_volume", result=1)
try:
volume_attach_or_detach_task.delay(instance=instance,
volume=volume, action=action)
return success(msg=_('Detaching volume'),
status=status.HTTP_201_CREATED)
except Exception as e:
LOG.exception("Detach volume error, msg: % s", e)
volume.status = VOLUME_STATE_IN_USE
volume.save()
return
def restore_backup_item(request, pk):
backup_item = BackupItem.objects.get(pk=pk)
if BackupItem.is_any_unstable(resource_id=backup_item.resource_id,
resource_type=backup_item.resource_type):
return fail(
_("Resource %(name)s has one backup task now.") %
{'name': backup_item.resource.name})
if backup_item.status == BACKUP_STATE_ERROR:
return fail(_("This backup item is available."))
if backup_item.is_instance_backup:
instance = Instance.objects.get(pk=backup_item.resource_id)
if instance.deleted:
return fail(
_("Cannot restore, because target resource has "
"already been deleted"))
if instance.is_running:
return fail(
_("Cannot restore, because target instance is running"))
else:
volume = Volume.objects.get(pk=backup_item.resource_id)
if volume.deleted:
return fail(
_("Cannot restore, because target resource has "
"already been deleted"))
if volume.instance and volume.instance.is_running:
return fail(
_("Cannot restore, because target volume is attached to"
" a running instance, stop the instance or "
"detach the volume"))
Operation.log(backup_item, obj_name=backup_item.name, action="restore")
backup_item.change_status(BACKUP_STATE_PENDING_RESTORE)
if tasks.restore_snap(backup_item.id):
return success(_("Restoring"))
else:
LOG.error("Failed to restore backup item. %s", backup_item)
return error()
def update_pool_member(request):
member_id = request.data['id']
try:
member = BalancerMember.objects.get(pk=member_id, user=request.user)
except BalancerMember.DoesNotExist:
return fail(_("Member not found."))
member.weight = int(request.data['weight'])
if pool_member_update(member):
Operation.log(member, obj_name=member.instance.name, action='update')
member.save()
return success(_("Member is updated!"))
else:
return error()
def volume_update_view(request):
try:
data = request.data
if data.get('id') is not None:
volume = Volume.objects.get(pk=data.get('id'))
Operation.log(volume, obj_name=volume.name, action="update", result=1)
volume.name = data.get('name')
volume.save()
return success(msg=_('Volume update success'),
status=status.HTTP_201_CREATED)
else:
return fail(msg=_('No volume found!'),
status=status.HTTP_404_NOT_FOUND)
except Exception as e:
LOG.exception("Failed to update volume, msg:[%s]", e)
return error()
def update_pool_member(request):
member_id = request.data['id']
try:
member = BalancerMember.objects.get(pk=member_id, user=request.user)
except BalancerMember.DoesNotExist:
return fail(_("Member not found."))
member.weight = int(request.data['weight'])
if pool_member_update(member):
Operation.log(member, obj_name=member.instance.name, action='update')
member.save()
return success(_("Member is updated!"))
else:
return error()
def create_pool_monitor(request):
serializer = BalancerMonitorSerializer(data=request.data,
context={'request': request})
if not serializer.is_valid():
return fail(_("Monitor Data is not valid"))
monitor = serializer.save()
Operation.log(monitor, obj_name=monitor.get_type_display(),
action='create')
if pool_monitor_create(monitor):
return success(_("Balancer monitor is created."))
else:
monitor.delete()
return error()
def volume_update_view(request):
try:
data = request.data
if data.get('id') is not None:
volume = Volume.objects.get(pk=data.get('id'))
Operation.log(volume, obj_name=volume.name, action="update", result=1)
volume.name = data.get('name')
volume.save()
return success(msg=_('Volume update success'),
status=status.HTTP_201_CREATED)
else:
return fail(msg=_('No volume found!'),
status=status.HTTP_404_NOT_FOUND)
except Exception as e:
LOG.exception("Failed to update volume, msg:[%s]", e)
return error()
def create_pool_monitor(request):
serializer = BalancerMonitorSerializer(data=request.data,
context={'request': request})
if not serializer.is_valid():
return fail(_("Monitor Data is not valid"))
monitor = serializer.save()
Operation.log(monitor,
obj_name=monitor.get_type_display(),
action='create')
if pool_monitor_create(monitor):
return success(_("Balancer monitor is created."))
else:
monitor.delete()
return error()
def firewall_create_view(request):
serializer = FirewallSerializer(data=request.data,
context={"request": request})
if not serializer.is_valid():
return fail(_('Data is not valid.'))
firewall = serializer.save()
Operation.log(firewall, obj_name=firewall.name, action="create")
try:
security_group_create_task.delay(firewall)
except Exception:
LOG.exception("Failed to create firewall")
firewall.delete()
return error()
return success(_('Creating firewall'))
def firewall_create_view(request):
serializer = FirewallSerializer(data=request.data,
context={"request": request})
if not serializer.is_valid():
return fail(_('Data is not valid.'))
firewall = serializer.save()
Operation.log(firewall, obj_name=firewall.name, action="create")
try:
security_group_create_task.delay(firewall)
except Exception:
LOG.exception("Failed to create firewall")
firewall.delete()
return error()
return success(_('Creating firewall'))
def backup_instance(request):
instance_id, name, is_full = retrieve_params(
request.data, 'instance_id', 'name', 'is_full')
udc = UserDataCenter.objects.get(pk=request.session["UDC_ID"])
volume_ids = request.data.getlist('volume_ids[]')
is_full = True if is_full == 'true' else False
instance = Instance.objects.get(pk=instance_id)
volumes = Volume.objects.filter(pk__in=volume_ids)
if BackupItem.is_any_unstable(resource=instance):
return fail(_("Instance %(name)s has one backup task now.")
% {'name': instance.name})
if BackupItem.has_error_node_on_default_chain(resource=instance):
return fail(_("Instance %(name)s has one error backup node on "
"default backup chain. Please delete it first")
% {'name': instance.name})
for volume in volumes:
if BackupItem.is_any_unstable(resource=volume):
return fail(_("Volume %(name)s has one backup task now.")
% {'name': volume.name})
if BackupItem.has_error_node_on_default_chain(resource=volume):
return fail(_("Volume %(name)s has one error backup node on "
"default backup chain. Please delet it first")
% {'name': volume.name})
items = [BackupItem.create(instance, name, request.user,
udc, is_full=is_full)]
Operation.log(instance, obj_name=instance.name, action="backup")
for volume in volumes:
items.append(BackupItem.create(volume, name, request.user, udc,
is_full=is_full))
Operation.log(volume, obj_name=volume.name, action="backup")
for item in items:
tasks.execute_backup.delay(item.id)
return success(_("Backup is in process."))
def create_pool(request):
serializer = BalancerPoolSerializer(data=request.data,
context={"request": request})
if not serializer.is_valid():
return fail(_('Data is not valid'))
pool = serializer.save()
Operation.log(pool, obj_name=pool.name, action='create', result=1)
try:
pool_create_task.delay(pool)
return success(_('Creating balancer pool.'))
except Exception:
LOG.exception("Failed to create balancer pool")
pool.status = POOL_ERROR
pool.save()
return error()
def delete_pool_monitor(request):
monitor_id = request.data['id']
monitor = BalancerMonitor.objects.get(pk=monitor_id, user=request.user)
if BalancerPoolMonitor.objects.filter(monitor=monitor).exists():
return fail(
_("Monitor %(name)s is being used, can not be deleted.") %
{'name': monitor.name})
if pool_monitor_delete(monitor):
Operation.log(monitor,
obj_name=monitor.get_type_display(),
action='delete')
return success(_('Balancer monitor is deleted.'))
else:
return error()
def create_pool(request):
serializer = BalancerPoolSerializer(data=request.data,
context={"request": request})
if not serializer.is_valid():
return fail(_('Data is not valid'))
pool = serializer.save()
Operation.log(pool, obj_name=pool.name, action='create', result=1)
try:
pool_create_task.delay(pool)
return success(_('Creating balancer pool.'))
except Exception:
LOG.exception("Failed to create balancer pool")
pool.status = POOL_ERROR
pool.save()
return error()
def restore_backup_item(request, pk):
backup_item = BackupItem.objects.get(pk=pk)
if BackupItem.is_any_unstable(resource_id=backup_item.resource_id,
resource_type=backup_item.resource_type):
return fail(_("Resource %(name)s has one backup task now.")
% {'name': backup_item.resource.name})
if backup_item.status == BACKUP_STATE_ERROR:
return fail(_("This backup item is available."))
if backup_item.is_instance_backup:
instance = Instance.objects.get(pk=backup_item.resource_id)
if instance.deleted:
return fail(_("Cannot restore, because target resource has "
"already been deleted"))
if instance.is_running:
return fail(_("Cannot restore, because target instance is running"))
else:
volume = Volume.objects.get(pk=backup_item.resource_id)
if volume.deleted:
return fail(_("Cannot restore, because target resource has "
"already been deleted"))
if volume.instance and volume.instance.is_running:
return fail(_("Cannot restore, because target volume is attached to"
" a running instance, stop the instance or "
"detach the volume"))
Operation.log(backup_item, obj_name=backup_item.name, action="restore")
backup_item.change_status(BACKUP_STATE_PENDING_RESTORE)
if tasks.restore_snap(backup_item.id):
return success(_("Restoring"))
else:
LOG.error("Failed to restore backup item. %s", backup_item)
return error()
def update_pool_vip(request):
vip_id = request.data['id']
try:
vip = BalancerVIP.objects.get(pk=vip_id, user=request.user)
except BalancerVIP.DoesNotExist:
return fail(_("No VIP found."))
vip.session_persistence = int(request.data['session_persistence'])
vip.name = request.data['name']
vip.description = request.data['description']
Operation.log(vip, obj_name=vip.name, action='update', result=1)
if pool_vip_update_task(vip):
vip.save()
return success(_('Vip update success'))
else:
return fail(_('Vip update fail'))
def firewall_delete_view(request):
data = request.data
firewall = Firewall.objects.get(pk=data.get('id'))
if firewall.is_default:
return fail(_("Firewall %(name)s is the default firewall, "
"cannot be deleted.") % {'name': firewall.name})
if firewall.is_in_use:
msg = _('Firewall %(name)s is being used.') % {'name': firewall.name}
return fail(msg)
Operation.log(firewall, obj_name=firewall.name, action="terminate")
if firewall.firewall_id:
try:
security_group_delete_task(firewall)
except Exception:
LOG.exception("Failed to delete firewall. %s", firewall)
return error()
firewall.deleted = True
firewall.save()
return success(_("Firewall %(name)s is deleted") % {'name': firewall.name})
def instance_change_firewall_view(request):
data = request.data
try:
instance = Instance.objects.get(pk=data['instance_id'])
except Instance.DoesNotExist:
return fail(_("Instance is not found"))
try:
firewall = Firewall.objects.get(pk=data.get('firewall_id'))
except Firewall.DoesNotExist:
return fail(_("Firewall is not found"))
Operation.log(instance, obj_name=instance.name, action="change_firewall")
try:
server_update_security_groups_task.delay(instance, firewall)
except Exception:
LOG.exception("Failed to change firewall group of instance. %s",
instance)
return error()
return success(_("Instance %(name)s's firewall is changed.")
% {'name': instance.name})
def update_pool(request):
pool_id = request.data['id']
pool = BalancerPool.objects.get(
pk=pool_id, user=request.user,
user_data_center=request.session["UDC_ID"])
serializer = BalancerPoolSerializer(data=request.data,
instance=pool,
context={"request": request})
if not serializer.is_valid():
return fail(_('Data is not valid'))
pool.status = POOL_UPDATING
pool = serializer.save()
Operation.log(pool, obj_name=pool.name, action='update')
try:
pool_update_task.delay(pool)
return success(_('Updating balancer pool.'))
except Exception:
LOG.exception("Failed to update balancer pool.")
return error()
