def get_task_signature(cls, backup, serialized_backup, **kwargs):
serialized_snapshots = [
core_utils.serialize_instance(snapshot)
for snapshot in backup.snapshots.all()
]
_tasks = [
core_tasks.StateTransitionTask().si(
serialized_backup, state_transition='begin_creating'
)
]
for serialized_snapshot in serialized_snapshots:
_tasks.append(
tasks.ThrottleProvisionTask().si(
serialized_snapshot,
'create_snapshot',
force=True,
state_transition='begin_creating',
)
)
_tasks.append(
core_tasks.PollRuntimeStateTask().si(
serialized_snapshot,
backend_pull_method='pull_snapshot_runtime_state',
success_state='available',
erred_state='error',
)
)
_tasks.append(
core_tasks.StateTransitionTask().si(
serialized_snapshot, state_transition='set_ok'
)
)
return chain(*_tasks)
def get_task_signature(cls, service_settings, serialized_service_settings,
**kwargs):
user = models.User.objects.get(settings=service_settings,
alias=service_settings.username)
user.password = kwargs.pop('password')
user.schedule_updating()
user.save()
serialized_user = utils.serialize_instance(user)
_tasks = [
tasks.StateTransitionTask().si(serialized_service_settings,
state_transition='begin_updating'),
tasks.BackendMethodTask().si(serialized_user,
'update_user',
state_transition='begin_updating'),
UpdateSettingsCredentials().si(serialized_service_settings,
serialized_user),
tasks.StateTransitionTask().si(serialized_user,
state_transition='set_ok'),
]
if user.phone:
message = 'Zabbix "%s" password: %s' % (user.settings.name,
user.password)
_tasks.append(SMSTask().si(serialized_service_settings, message,
user.phone))
return chain(*_tasks)
def get_success_signature(cls, instance, serialized_instance, **kwargs):
serialized_volume = core_utils.serialize_instance(
instance.volume_set.first())
return chain(
core_tasks.StateTransitionTask().si(serialized_volume,
state_transition='set_ok'),
core_tasks.StateTransitionTask().si(serialized_instance,
state_transition='set_ok'))
def _get_state_change_task(cls, instance, serialized_instance):
if instance.state == GoogleCalendar.States.CREATION_SCHEDULED:
return core_tasks.StateTransitionTask().si(
serialized_instance, state_transition='begin_creating'
)
else:
return core_tasks.StateTransitionTask().si(
serialized_instance, state_transition='begin_updating'
)
def get_success_signature(cls, tenant, serialized_tenant, **kwargs):
service_settings = structure_models.ServiceSettings.objects.get(
scope=tenant)
serialized_service_settings = core_utils.serialize_instance(
service_settings)
tasks = [
core_tasks.StateTransitionTask().si(serialized_tenant,
state_transition='set_ok'),
core_tasks.StateTransitionTask().si(serialized_service_settings,
state_transition='set_ok')
]
return chain(*tasks)
def get_success_signature(cls, package, serialized_package, **kwargs):
""" Get Celery signature of task that should be applied on successful execution. """
service_settings = package.service_settings
serialized_service_settings = core_utils.serialize_instance(
service_settings)
return core_tasks.StateTransitionTask().si(serialized_service_settings,
state_transition='set_ok')
def get_task_signature(cls, instance, serialized_instance, **kwargs):
_tasks = [
core_tasks.StateTransitionTask().si(
serialized_instance, state_transition='begin_updating')
]
# Create non-exist floating IPs
for floating_ip in instance.floating_ips.filter(backend_id=''):
serialized_floating_ip = core_utils.serialize_instance(floating_ip)
_tasks.append(core_tasks.BackendMethodTask().si(
serialized_floating_ip, 'create_floating_ip'))
# Push instance floating IPs
_tasks.append(core_tasks.BackendMethodTask().si(
serialized_instance, 'push_instance_floating_ips'))
# Wait for operation completion
for index, floating_ip in enumerate(instance.floating_ips):
_tasks.append(core_tasks.PollRuntimeStateTask().si(
core_utils.serialize_instance(floating_ip),
backend_pull_method='pull_floating_ip_runtime_state',
success_state='ACTIVE',
erred_state='ERRED',
).set(countdown=5 if not index else 0))
# Pull floating IPs again to update state of disconnected IPs
_tasks.append(core_tasks.IndependentBackendMethodTask().si(
serialized_instance, 'pull_floating_ips'))
return chain(*_tasks)
def get_task_signature(cls,
instance,
serialized_instance,
force=False,
**kwargs):
delete_volumes = kwargs.pop('delete_volumes', True)
release_floating_ips = kwargs.pop('release_floating_ips', True)
delete_instance = cls.get_delete_instance_tasks(
instance, serialized_instance, release_floating_ips)
# Case 1. Instance does not exist at backend
if not instance.backend_id:
return core_tasks.StateTransitionTask().si(
serialized_instance, state_transition='begin_deleting')
# Case 2. Instance exists at backend.
# Data volumes are deleted by OpenStack because delete_on_termination=True
elif delete_volumes:
return chain(delete_instance)
# Case 3. Instance exists at backend.
# Data volumes are detached and not deleted.
else:
detach_volumes = cls.get_detach_data_volumes_tasks(
instance, serialized_instance)
return chain(detach_volumes + delete_instance)
def create_volumes(cls, serialized_volumes):
"""
Create all instance volumes and wait for them to provision.
"""
_tasks = []
# Create volumes
for serialized_volume in serialized_volumes:
_tasks.append(tasks.ThrottleProvisionTask().si(
serialized_volume, 'create_volume', state_transition='begin_creating'))
for index, serialized_volume in enumerate(serialized_volumes):
# Wait for volume creation
_tasks.append(core_tasks.PollRuntimeStateTask().si(
serialized_volume,
backend_pull_method='pull_volume_runtime_state',
success_state='available',
erred_state='error',
).set(countdown=30 if index == 0 else 0))
# Pull volume to sure that it is bootable
_tasks.append(core_tasks.BackendMethodTask().si(serialized_volume, 'pull_volume'))
# Mark volume as OK
_tasks.append(core_tasks.StateTransitionTask().si(serialized_volume, state_transition='set_ok'))
return _tasks
def get_task_signature(cls, backup, serialized_backup, force=False, **kwargs):
serialized_snapshots = [
core_utils.serialize_instance(snapshot)
for snapshot in backup.snapshots.all()
]
_tasks = [
core_tasks.StateTransitionTask().si(
serialized_backup, state_transition='begin_deleting'
)
]
for serialized_snapshot in serialized_snapshots:
_tasks.append(
core_tasks.BackendMethodTask().si(
serialized_snapshot,
'delete_snapshot',
state_transition='begin_deleting',
)
)
for serialized_snapshot in serialized_snapshots:
_tasks.append(
core_tasks.PollBackendCheckTask().si(
serialized_snapshot, 'is_snapshot_deleted'
)
)
_tasks.append(core_tasks.DeletionTask().si(serialized_snapshot))
return chain(*_tasks)
def get_failure_signature(
cls, snapshot_restoration, serialized_snapshot_restoration, **kwargs
):
serialized_volume = core_utils.serialize_instance(snapshot_restoration.volume)
return core_tasks.StateTransitionTask().si(
serialized_volume, state_transition='set_erred'
)
def get_delete_incomplete_instance_tasks(cls, instance, serialized_instance):
_tasks = []
_tasks.append(core_tasks.StateTransitionTask().si(
serialized_instance,
state_transition='begin_deleting'
))
_tasks.append(core_tasks.BackendMethodTask().si(
serialized_instance,
backend_method='delete_instance_internal_ips',
))
for volume in instance.volumes.all():
if volume.backend_id:
serialized_volume = core_utils.serialize_instance(volume)
_tasks.append(core_tasks.BackendMethodTask().si(
serialized_volume,
'delete_volume',
state_transition='begin_deleting'
))
_tasks.append(core_tasks.PollBackendCheckTask().si(
serialized_volume,
'is_volume_deleted'
))
return _tasks
def get_task_signature(cls, instance, serialized_instance, **kwargs):
updated_fields = kwargs['updated_fields']
if 'name' in updated_fields:
return core_tasks.BackendMethodTask().si(
serialized_instance, 'update_instance', state_transition='begin_updating')
else:
return core_tasks.StateTransitionTask().si(serialized_instance, state_transition='begin_updating')
def get_task_signature(cls, snapshot, serialized_snapshot, **kwargs):
updated_fields = kwargs['updated_fields']
# TODO: call separate task on metadata update
if 'name' in updated_fields or 'description' in updated_fields:
return core_tasks.BackendMethodTask().si(
serialized_snapshot, 'update_snapshot', state_transition='begin_updating')
else:
return core_tasks.StateTransitionTask().si(serialized_snapshot, state_transition='begin_updating')
def get_task_signature(cls, network, serialized_network, **kwargs):
if network.backend_id:
return core_tasks.BackendMethodTask().si(
serialized_network,
'delete_network',
state_transition='begin_deleting')
else:
return core_tasks.StateTransitionTask().si(
serialized_network, state_transition='begin_deleting')
def get_task_signature(cls, instance, serialized_instance, **kwargs):
if instance.backend_id:
return core_tasks.BackendMethodTask().si(
serialized_instance,
'delete_cluster',
state_transition='begin_deleting')
else:
return core_tasks.StateTransitionTask().si(
serialized_instance, state_transition='begin_deleting')
def get_task_signature(cls, snapshot, serialized_snapshot, **kwargs):
if snapshot.backend_id:
return chain(
core_tasks.BackendMethodTask().si(
serialized_snapshot, 'delete_snapshot', state_transition='begin_deleting'),
core_tasks.PollBackendCheckTask().si(serialized_snapshot, 'is_snapshot_deleted'),
)
else:
return core_tasks.StateTransitionTask().si(serialized_snapshot, state_transition='begin_deleting')
def get_task_signature(cls, volume, serialized_volume, **kwargs):
if volume.backend_id:
return chain(
core_tasks.BackendMethodTask().si(
serialized_volume, 'delete_volume', state_transition='begin_deleting'),
core_tasks.PollBackendCheckTask().si(serialized_volume, 'is_volume_deleted'),
)
else:
return core_tasks.StateTransitionTask().si(serialized_volume, state_transition='begin_deleting')
def get_task_signature(cls, subnet, serialized_subnet, **kwargs):
if subnet.backend_id:
return core_tasks.BackendMethodTask().si(
serialized_subnet,
'delete_subnet',
state_transition='begin_deleting')
else:
return core_tasks.StateTransitionTask().si(
serialized_subnet, state_transition='begin_deleting')
def get_task_signature(cls, instance, serialized_instance, **kwargs):
if instance.backend_id and {'name'} & set(kwargs['updated_fields']):
return core_tasks.BackendMethodTask().si(
serialized_instance,
'update_cluster',
state_transition='begin_updating')
else:
return core_tasks.StateTransitionTask().si(
serialized_instance, state_transition='begin_updating')
def get_task_signature(cls, instance, serialized_instance, **kwargs):
if instance.backend_id:
return chain(
core_tasks.BackendMethodTask().si(
serialized_instance, backend_method='destroy_vm', state_transition='begin_deleting'),
core_tasks.PollBackendCheckTask().si(serialized_instance, 'is_vm_deleted'),
)
else:
return core_tasks.StateTransitionTask().si(serialized_instance, state_transition='begin_deleting')
def get_task_signature(cls, comment, serialized_comment, **kwargs):
if comment.backend_id:
return tasks.BackendMethodTask().si(
serialized_comment,
'delete_comment',
state_transition='begin_deleting')
else:
return tasks.StateTransitionTask().si(
serialized_comment, state_transition='begin_deleting')
def get_task_signature(cls, issue, serialized_issue, **kwargs):
if issue.backend_id:
return tasks.BackendMethodTask().si(
serialized_issue,
'delete_issue',
state_transition='begin_deleting')
else:
return tasks.StateTransitionTask().si(
serialized_issue, state_transition='begin_deleting')
def get_task_signature(cls, instance, serialized_instance, **kwargs):
if instance.backend_id:
task = core_tasks.BackendMethodTask().si(
serialized_instance, 'delete_disk', state_transition='begin_deleting'
)
return pull_datastores_for_resource(instance, task)
else:
return core_tasks.StateTransitionTask().si(
serialized_instance, state_transition='begin_deleting'
)
def get_task_signature(cls, instance, serialized_instance, **kwargs):
if instance.backend_id:
return core_tasks.BackendMethodTask().si(
serialized_instance,
backend_method='delete_pgsql_database',
state_transition='begin_deleting',
)
else:
return core_tasks.StateTransitionTask().si(
serialized_instance, state_transition='begin_deleting')
def get_task_signature(cls, project, serialized_project, **kwargs):
return chain(
tasks.StateTransitionTask().si(serialized_project,
state_transition='begin_updating'),
tasks.PollRuntimeStateTask().si(
serialized_project,
backend_pull_method='import_project_batch',
success_state='success',
erred_state='error',
))
def get_task_signature(cls, tenant, serialized_tenant, **kwargs):
updated_fields = kwargs['updated_fields']
if 'name' in updated_fields or 'description' in updated_fields:
return core_tasks.BackendMethodTask().si(
serialized_tenant,
'update_tenant',
state_transition='begin_updating')
else:
return core_tasks.StateTransitionTask().si(
serialized_tenant, state_transition='begin_updating')
def get_task_signature(cls, security_group, serialized_security_group,
**kwargs):
if security_group.backend_id:
return core_tasks.BackendMethodTask().si(
serialized_security_group,
'delete_security_group',
state_transition='begin_deleting')
else:
return core_tasks.StateTransitionTask().si(
serialized_security_group, state_transition='begin_deleting')
def get_task_signature(cls, volume, serialized_volume, **kwargs):
if volume.instance is None:
return chain(
core_tasks.BackendMethodTask().si(
serialized_volume,
backend_method='extend_volume',
state_transition='begin_updating',
),
core_tasks.PollRuntimeStateTask().si(
serialized_volume,
backend_pull_method='pull_volume_runtime_state',
success_state='available',
erred_state='error'
)
)
return chain(
core_tasks.StateTransitionTask().si(
core_utils.serialize_instance(volume.instance),
state_transition='begin_updating'
),
core_tasks.BackendMethodTask().si(
serialized_volume,
backend_method='detach_volume',
state_transition='begin_updating'
),
core_tasks.PollRuntimeStateTask().si(
serialized_volume,
backend_pull_method='pull_volume_runtime_state',
success_state='available',
erred_state='error'
),
core_tasks.BackendMethodTask().si(
serialized_volume,
backend_method='extend_volume',
),
core_tasks.PollRuntimeStateTask().si(
serialized_volume,
backend_pull_method='pull_volume_runtime_state',
success_state='available',
erred_state='error'
),
core_tasks.BackendMethodTask().si(
serialized_volume,
instance_uuid=volume.instance.uuid.hex,
device=volume.device,
backend_method='attach_volume',
),
core_tasks.PollRuntimeStateTask().si(
serialized_volume,
backend_pull_method='pull_volume_runtime_state',
success_state='in-use',
erred_state='error'
),
)
def get_task_signature(cls, instance, serialized_instance, **kwargs):
serialized_resource_group = core_utils.serialize_instance(
instance.resource_group)
return chain(
core_tasks.StateTransitionTask().si(
serialized_instance, state_transition='begin_creating'),
core_tasks.BackendMethodTask().si(
serialized_resource_group,
backend_method='create_resource_group',
state_transition='begin_creating',
),
core_tasks.StateTransitionTask().si(
serialized_resource_group,
state_transition='set_ok',
),
core_tasks.BackendMethodTask().si(
serialized_instance,
backend_method='create_pgsql_server',
),
)
