def create_floating_ips(cls, instance, serialized_instance):
_tasks = []
# Create non-existing 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))
shared_tenant = instance.service_project_link.service.settings.scope
if shared_tenant:
serialized_executor = core_utils.serialize_class(openstack_executors.TenantPullFloatingIPsExecutor)
serialized_tenant = core_utils.serialize_instance(shared_tenant)
_tasks.append(core_tasks.ExecutorTask().si(serialized_executor, serialized_tenant))
return _tasks
def get_delete_instance_tasks(cls, instance, serialized_instance, release_floating_ips):
_tasks = [
core_tasks.BackendMethodTask().si(
serialized_instance,
backend_method='delete_instance',
state_transition='begin_deleting',
),
core_tasks.PollBackendCheckTask().si(
serialized_instance,
backend_check_method='is_instance_deleted',
),
]
if release_floating_ips:
for index, floating_ip in enumerate(instance.floating_ips):
_tasks.append(core_tasks.BackendMethodTask().si(
core_utils.serialize_instance(floating_ip),
'delete_floating_ip',
).set(countdown=5 if not index else 0))
else:
# pull related floating IPs state after instance deletion
for index, floating_ip in enumerate(instance.floating_ips):
_tasks.append(core_tasks.BackendMethodTask().si(
core_utils.serialize_instance(floating_ip),
'pull_floating_ip_runtime_state',
).set(countdown=5 if not index else 0))
shared_tenant = instance.service_project_link.service.settings.scope
if shared_tenant:
serialized_executor = core_utils.serialize_class(openstack_executors.TenantPullFloatingIPsExecutor)
serialized_tenant = core_utils.serialize_instance(shared_tenant)
_tasks.append(core_tasks.ExecutorTask().si(serialized_executor, serialized_tenant))
return _tasks
def get_instances_cleanup_tasks(cls, serialized_tenant):
return [
core_tasks.BackendMethodTask().si(
serialized_tenant,
backend_method='delete_tenant_security_groups',
),
core_tasks.BackendMethodTask().si(
serialized_tenant,
backend_method='delete_tenant_snapshots',
),
core_tasks.PollBackendCheckTask().si(
serialized_tenant,
backend_check_method='are_all_tenant_snapshots_deleted'),
core_tasks.BackendMethodTask().si(
serialized_tenant,
backend_method='delete_tenant_instances',
),
core_tasks.PollBackendCheckTask().si(
serialized_tenant,
backend_check_method='are_all_tenant_instances_deleted'),
core_tasks.BackendMethodTask().si(
serialized_tenant,
backend_method='delete_tenant_volumes',
),
core_tasks.PollBackendCheckTask().si(
serialized_tenant,
backend_check_method='are_all_tenant_volumes_deleted'),
]
def get_task_signature(cls, instance, serialized_instance, user,
install_longhorn):
_tasks = [
core_tasks.BackendMethodTask().si(
serialized_instance,
'create_cluster',
state_transition='begin_creating')
]
_tasks += cls.create_nodes(instance.node_set.all(), user)
_tasks += [
core_tasks.PollRuntimeStateTask().si(
serialized_instance,
backend_pull_method='check_cluster_nodes',
success_state=models.Cluster.RuntimeStates.ACTIVE,
erred_state='error',
)
]
_tasks += [
core_tasks.BackendMethodTask().si(
serialized_instance,
'pull_cluster',
)
]
if install_longhorn:
# NB: countdown is needed for synchronization: wait until cluster will get ready for apps installation
_tasks += [
core_tasks.BackendMethodTask().si(
serialized_instance,
'install_longhorn_to_cluster').set(countdown=30)
]
return chain(*_tasks)
def get_task_signature(cls, instance, serialized_instance, **kwargs):
_tasks = [
core_tasks.BackendMethodTask().si(
serialized_instance,
'start_virtual_machine',
state_transition='begin_updating',
)
]
if instance.tools_installed:
_tasks.append(
core_tasks.BackendMethodTask().si(
serialized_instance, 'pull_virtual_machine',
)
)
_tasks.append(
core_tasks.PollBackendCheckTask().si(
serialized_instance, 'is_virtual_machine_tools_running'
)
)
_tasks.append(
core_tasks.BackendMethodTask().si(
serialized_instance, 'pull_virtual_machine',
)
)
return chain(_tasks)
def get_task_signature(cls, instance, serialized_instance, **kwargs):
task = core_tasks.BackendMethodTask().si(
serialized_instance, 'create_port', state_transition='begin_creating'
)
return chain(
task, core_tasks.BackendMethodTask().si(serialized_instance, 'pull_port',)
)
def get_release_floating_ips_tasks(cls, instance, release_floating_ips):
_tasks = []
if release_floating_ips:
for index, floating_ip in enumerate(instance.floating_ips):
_tasks.append(
core_tasks.BackendMethodTask()
.si(
core_utils.serialize_instance(floating_ip),
'delete_floating_ip',
)
.set(countdown=5 if not index else 0)
)
else:
# pull related floating IPs state after instance deletion
for index, floating_ip in enumerate(instance.floating_ips):
_tasks.append(
core_tasks.BackendMethodTask()
.si(
core_utils.serialize_instance(floating_ip),
'pull_floating_ip_runtime_state',
)
.set(countdown=5 if not index else 0)
)
shared_tenant = instance.service_project_link.service.settings.scope
if shared_tenant and isinstance(shared_tenant, openstack_models.Tenant):
serialized_tenant = core_utils.serialize_instance(shared_tenant)
_tasks.append(core_tasks.PollStateTask().si(serialized_tenant))
_tasks.append(
openstack_executors.TenantPullFloatingIPsExecutor.as_signature(
shared_tenant
)
)
return _tasks
def get_task_signature(cls, instance, serialized_instance, **kwargs):
flavor = kwargs.pop('flavor')
return chain(
core_tasks.BackendMethodTask().si(
serialized_instance,
backend_method='resize_instance',
state_transition='begin_updating',
flavor_id=flavor.backend_id,
),
core_tasks.PollRuntimeStateTask().si(
serialized_instance,
backend_pull_method='pull_instance_runtime_state',
success_state='VERIFY_RESIZE',
erred_state='ERRED',
),
core_tasks.BackendMethodTask().si(
serialized_instance, backend_method='confirm_instance_resize'
),
core_tasks.PollRuntimeStateTask().si(
serialized_instance,
backend_pull_method='pull_instance_runtime_state',
success_state='SHUTOFF',
erred_state='ERRED',
),
)
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_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, tenant, serialized_tenant, **kwargs):
service_settings = structure_models.ServiceSettings.objects.get(
scope=tenant)
serialized_settings = core_utils.serialize_instance(service_settings)
return chain(
core_tasks.BackendMethodTask().si(
serialized_tenant,
'pull_tenant',
state_transition='begin_updating'),
core_tasks.BackendMethodTask().si(serialized_tenant,
'pull_tenant_quotas'),
# Some resources are synchronized from openstack to openstack_tenant via handlers,
# so for pulling them needed use serialized_tenant
core_tasks.BackendMethodTask().si(serialized_tenant,
'pull_tenant_floating_ips'),
core_tasks.BackendMethodTask().si(serialized_tenant,
'pull_tenant_security_groups'),
core_tasks.IndependentBackendMethodTask().si(
serialized_tenant, 'pull_networks'),
core_tasks.IndependentBackendMethodTask().si(
serialized_settings, 'pull_images'),
core_tasks.IndependentBackendMethodTask().si(
serialized_settings, 'pull_flavors'),
core_tasks.IndependentBackendMethodTask().si(
serialized_tenant, 'pull_subnets'),
)
def get_task_signature(cls, instance, serialized_instance, **kwargs):
task = core_tasks.BackendMethodTask().si(
serialized_instance, 'create_disk', state_transition='begin_creating'
)
task = pull_datastores_for_resource(instance, task)
return chain(
task, core_tasks.BackendMethodTask().si(serialized_instance, 'pull_disk',)
)
def get_identity_cleanup_tasks(cls, serialized_tenant):
return [
core_tasks.BackendMethodTask().si(
serialized_tenant, backend_method='delete_tenant_user',
),
core_tasks.BackendMethodTask().si(
serialized_tenant, backend_method='delete_tenant',
),
]
def get_task_signature(cls, instance, serialized_instance, **kwargs):
return chain(
core_tasks.BackendMethodTask().si(
serialized_instance, 'pull_instance', state_transition='begin_updating',
),
core_tasks.BackendMethodTask().si(serialized_instance, 'pull_instance_security_groups'),
core_tasks.BackendMethodTask().si(serialized_instance, 'pull_instance_internal_ips'),
core_tasks.BackendMethodTask().si(serialized_instance, 'pull_instance_floating_ips'),
)
def get_task_signature(cls, invoice, serialized_invoice, **kwargs):
tasks = [
core_tasks.BackendMethodTask().si(serialized_invoice,
'pull_invoice'),
core_tasks.BackendMethodTask().si(serialized_invoice,
'download_invoice_pdf'),
]
return chain(*tasks)
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):
return chain(
core_tasks.BackendMethodTask().si(
serialized_instance,
'suspend_virtual_machine',
state_transition='begin_updating',
),
core_tasks.BackendMethodTask().si(
serialized_instance, 'pull_virtual_machine',
),
)
def get_task_signature(cls, instance, serialized_instance, **kwargs):
return chain(
core_tasks.BackendMethodTask().si(
serialized_instance, 'shutdown_guest', state_transition='begin_updating'
),
core_tasks.PollBackendCheckTask().si(
serialized_instance, 'is_virtual_machine_shutted_down'
),
core_tasks.BackendMethodTask().si(
serialized_instance, 'pull_virtual_machine',
),
)
def get_task_signature(cls, tenant, serialized_tenant, **kwargs):
return chain(
core_tasks.BackendMethodTask().si(
serialized_tenant,
'pull_tenant',
state_transition='begin_updating'),
core_tasks.BackendMethodTask().si(serialized_tenant,
'pull_tenant_quotas'),
core_tasks.BackendMethodTask().si(serialized_tenant,
'pull_tenant_floating_ips'),
core_tasks.BackendMethodTask().si(serialized_tenant,
'pull_tenant_security_groups'),
)
def get_task_signature(cls, instance, serialized_instance, **kwargs):
task = core_tasks.BackendMethodTask().si(
serialized_instance,
'create_virtual_machine',
state_transition='begin_creating',
)
return chain(
pull_datastores_for_resource(instance, task),
core_tasks.BackendMethodTask().si(serialized_instance, 'pull_vm_ports',),
core_tasks.BackendMethodTask().si(
serialized_instance, 'pull_virtual_machine',
),
)
def get_task_signature(cls, subnet, serialized_subnet, **kwargs):
serialized_tenant = core_utils.serialize_instance(subnet.network.tenant)
return chain(
core_tasks.BackendMethodTask().si(
serialized_subnet,
'update_subnet',
state_transition='begin_updating',
enable_default_gateway=kwargs.get('enable_default_gateway', True),
),
core_tasks.BackendMethodTask().si(
serialized_tenant, backend_method='pull_tenant_routers'
),
)
def get_task_signature(cls, tenant, serialized_tenant, **kwargs):
tasks = [
core_tasks.BackendMethodTask().si(
serialized_tenant,
'add_admin_user_to_tenant',
state_transition='begin_updating'),
core_tasks.BackendMethodTask().si(serialized_tenant,
'create_or_update_tenant_user'),
core_tasks.BackendMethodTask().si(serialized_tenant,
'pull_tenant_quotas'),
core_tasks.BackendMethodTask().si(serialized_tenant,
'pull_tenant_floating_ips'),
core_tasks.BackendMethodTask().si(serialized_tenant,
'pull_tenant_security_groups'),
core_tasks.BackendMethodTask().si(serialized_tenant,
'import_tenant_networks'),
core_tasks.BackendMethodTask().si(serialized_tenant,
'import_tenant_subnets'),
core_tasks.BackendMethodTask().si(serialized_tenant,
'detect_external_network'),
]
service_settings = structure_models.ServiceSettings.objects.get(
scope=tenant)
serialized_service_settings = core_utils.serialize_instance(
service_settings)
create_service_settings = structure_executors.ServiceSettingsCreateExecutor.get_task_signature(
service_settings, serialized_service_settings)
return chain(*tasks) | create_service_settings
def get_task_signature(cls, snapshot_restoration, serialized_snapshot_restoration, **kwargs):
serialized_volume = core_utils.serialize_instance(snapshot_restoration.volume)
_tasks = [
tasks.ThrottleProvisionTask().si(
serialized_volume, 'create_volume', state_transition='begin_creating'),
core_tasks.PollRuntimeStateTask().si(
serialized_volume, 'pull_volume_runtime_state', success_state='available', erred_state='error',
).set(countdown=30),
core_tasks.BackendMethodTask().si(serialized_volume, 'remove_bootable_flag'),
core_tasks.BackendMethodTask().si(serialized_volume, 'pull_volume'),
]
return chain(*_tasks)
def get_task_signature(cls, security_group, serialized_security_group,
**kwargs):
state_transition_task = core_tasks.StateTransitionTask().si(
serialized_security_group, state_transition='begin_deleting')
detach_task = core_tasks.BackendMethodTask().si(
serialized_security_group,
'detach_security_group_from_all_instances')
delete_task = core_tasks.BackendMethodTask().si(
serialized_security_group, 'delete_security_group')
_tasks = [state_transition_task]
if security_group.backend_id:
_tasks.append(detach_task)
_tasks.append(delete_task)
return chain(*_tasks)
def get_task_signature(cls, volume, serialized_volume, **kwargs):
return chain(
core_tasks.BackendMethodTask().si(
serialized_volume, 'retype_volume', state_transition='begin_updating'
),
core_tasks.PollRuntimeStateTask()
.si(
serialized_volume,
backend_pull_method='pull_volume_runtime_state',
success_state='available',
erred_state='error',
)
.set(countdown=10),
core_tasks.BackendMethodTask().si(serialized_volume, 'pull_volume',),
)
def pull_hosts():
pullable_hosts = Host.objects.exclude(
backend_id='') # Cannot pull hosts without backend_id
for host in pullable_hosts.filter(state=Host.States.ERRED):
serialized_host = core_utils.serialize_instance(host)
core_tasks.BackendMethodTask().apply_async(
args=(serialized_host, 'pull_host'),
link=core_tasks.RecoverTask().si(serialized_host),
link_error=core_tasks.ErrorMessageTask().s(serialized_host),
)
for host in Host.objects.filter(state=Host.States.OK):
serialized_host = core_utils.serialize_instance(host)
core_tasks.BackendMethodTask().apply_async(
args=(serialized_host, 'pull_host'),
link_error=core_tasks.ErrorStateTransitionTask().s(
serialized_host))
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 create_instance(cls, serialized_instance, flavor, ssh_key=None):
"""
It is assumed that volumes and network ports have been created beforehand.
"""
_tasks = []
kwargs = {
'backend_flavor_id': flavor.backend_id,
}
if ssh_key is not None:
kwargs['public_key'] = ssh_key.public_key
# Wait 10 seconds after volume creation due to OpenStack restrictions.
_tasks.append(
core_tasks.BackendMethodTask()
.si(serialized_instance, 'create_instance', **kwargs)
.set(countdown=10)
)
# Wait for instance creation
_tasks.append(
core_tasks.PollRuntimeStateTask().si(
serialized_instance,
backend_pull_method='pull_instance_runtime_state',
success_state=models.Instance.RuntimeStates.ACTIVE,
erred_state=models.Instance.RuntimeStates.ERROR,
)
)
return _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_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')
