def enable_image_validation(machine_request, init_task, final_task, original_status="", error_handler_task=None):
if not error_handler_task:
error_handler_task = machine_request_error.s(machine_request.id)
# Task 3 = Validate the new image by launching an instance
admin_ident = machine_request.new_admin_identity()
admin_driver = get_admin_driver(machine_request.new_machine_provider)
if 'validating' == original_status:
image_id = machine_request.new_machine.identifier
celery_logger.info("Start with validating:%s" % image_id)
# If validating, seed the image_id and start here..
validate_task = validate_new_image.s(image_id, machine_request.id)
init_task = validate_task
else:
validate_task = validate_new_image.s(machine_request.id)
init_task.link(validate_task)
#Validate task returns an instance_id
# Task 4 = Wait for new instance to be 'active'
wait_for_task = wait_for_instance.s(
# NOTE: 1st arg, instance_id, passed from last task.
admin_driver.__class__,
admin_driver.provider,
admin_driver.identity,
"active",
test_tmp_status=True,
return_id=True)
validate_task.link(wait_for_task)
validate_task.link_error(error_handler_task)
# Task 5 = Terminate the new instance on completion
destroy_task = destroy_instance.s(
admin_ident.created_by, admin_ident.uuid)
wait_for_task.link(destroy_task)
wait_for_task.link_error(error_handler_task)
destroy_task.link_error(error_handler_task)
destroy_task.link(final_task)
return init_task
def enable_image_validation(machine_request, init_task, final_task, original_status="", error_handler_task=None):
if not error_handler_task:
error_handler_task = machine_request_error.s(machine_request.id)
# Task 3 = Validate the new image by launching an instance
admin_ident = machine_request.new_admin_identity()
admin_driver = get_admin_driver(machine_request.new_machine_provider)
if 'validating' in original_status:
image_id = machine_request.new_machine.identifier
celery_logger.info("Start with validating:%s" % image_id)
# If validating, seed the image_id and start here..
validate_task = validate_new_image.s(image_id, machine_request.id)
init_task = validate_task
else:
validate_task = validate_new_image.s(machine_request.id)
init_task.link(validate_task)
#Validate task returns an instance_id
# Task 4 = Wait for new instance to be 'active'
wait_for_task = wait_for_instance.s(
# NOTE: 1st arg, instance_id, passed from last task.
admin_driver.__class__,
admin_driver.provider,
admin_driver.identity,
"active",
test_tmp_status=True,
return_id=True)
validate_task.link(wait_for_task)
validate_task.link_error(error_handler_task)
# Task 5 = Terminate the new instance on completion
destroy_task = destroy_instance.s(
admin_ident.created_by, admin_ident.uuid)
wait_for_task.link(destroy_task)
wait_for_task.link_error(error_handler_task)
destroy_task.link_error(error_handler_task)
destroy_task.link(final_task)
return init_task
def start_machine_imaging(machine_request, delay=False):
"""
Builds up a machine imaging task using core.models.machine_request
delay - If true, wait until task is completed before returning
"""
new_status, _ = StatusType.objects.get_or_create(name="started")
machine_request.status = new_status
machine_request.save()
original_status = machine_request.old_status
last_run_error, original_status = _recover_from_error(original_status)
if last_run_error:
machine_request.old_status = original_status
machine_request.save()
instance_id = machine_request.instance.provider_alias
(orig_managerCls, orig_creds, dest_managerCls,
dest_creds) = machine_request.prepare_manager()
imaging_args = machine_request.get_imaging_args()
admin_driver = get_admin_driver(machine_request.new_machine_provider)
admin_ident = machine_request.new_admin_identity()
imaging_error_task = machine_request_error.s(machine_request.id)
# Task 2 = Imaging w/ Chromogenic
imaging_task = _get_imaging_task(orig_managerCls, orig_creds,
dest_managerCls, dest_creds, imaging_args)
imaging_task.link_error(imaging_error_task)
# Assume we are starting from the beginning.
init_task = imaging_task
# Task 2 = Process the machine request
if 'processing' in original_status:
# If processing, start here..
image_id = original_status.replace("processing - ", "")
logger.info("Start with processing:%s" % image_id)
process_task = process_request.s(image_id, machine_request.id)
init_task = process_task
else:
# Link from imaging to process..
process_task = process_request.s(machine_request.id)
imaging_task.link(process_task)
process_task.link_error(imaging_error_task)
# Task 3 = Validate the new image by launching an instance
if 'validating' in original_status:
image_id = machine_request.new_machine.identifier
celery_logger.info("Start with validating:%s" % image_id)
# If validating, seed the image_id and start here..
validate_task = validate_new_image.s(image_id, machine_request.id)
init_task = validate_task
else:
validate_task = validate_new_image.s(machine_request.id)
process_task.link(validate_task)
# Task 4 = Wait for new instance to be 'active'
wait_for_task = wait_for_instance.s(
# NOTE: 1st arg, instance_id, passed from last task.
admin_driver.__class__,
admin_driver.provider,
admin_driver.identity,
"active",
return_id=True)
validate_task.link(wait_for_task)
validate_task.link_error(imaging_error_task)
# Task 5 = Terminate the new instance on completion
destroy_task = destroy_instance.s(admin_ident.created_by, admin_ident.uuid)
wait_for_task.link(destroy_task)
wait_for_task.link_error(imaging_error_task)
# Task 6 - Finally, email the user that their image is ready!
# NOTE: si == Ignore the result of the last task.
email_task = imaging_complete.si(machine_request.id)
destroy_task.link_error(imaging_error_task)
destroy_task.link(email_task)
email_task.link_error(imaging_error_task)
# Set status to imaging ONLY if our initial task is the imaging task.
if init_task == imaging_task:
machine_request.old_status = 'imaging'
machine_request.save()
# Start the task.
async = init_task.apply_async()
if delay:
async .get()
return async
def start_machine_imaging(machine_request, delay=False):
"""
Builds up a machine imaging task using core.models.machine_request
delay - If true, wait until task is completed before returning
"""
new_status, _ = StatusType.objects.get_or_create(name="started")
machine_request.status = new_status
machine_request.save()
original_status = machine_request.old_status
last_run_error, original_status = _recover_from_error(original_status)
if last_run_error:
machine_request.old_status = original_status
machine_request.save()
instance_id = machine_request.instance.provider_alias
(orig_managerCls, orig_creds,
dest_managerCls, dest_creds) = machine_request.prepare_manager()
imaging_args = machine_request.get_imaging_args()
admin_driver = get_admin_driver(machine_request.new_machine_provider)
admin_ident = machine_request.new_admin_identity()
imaging_error_task = machine_request_error.s(machine_request.id)
# Task 2 = Imaging w/ Chromogenic
imaging_task = _get_imaging_task(orig_managerCls, orig_creds,
dest_managerCls, dest_creds,
imaging_args)
imaging_task.link_error(imaging_error_task)
# Assume we are starting from the beginning.
init_task = imaging_task
# Task 2 = Process the machine request
if 'processing' in original_status:
# If processing, start here..
image_id = original_status.replace("processing - ", "")
logger.info("Start with processing:%s" % image_id)
process_task = process_request.s(image_id, machine_request.id)
init_task = process_task
else:
# Link from imaging to process..
process_task = process_request.s(machine_request.id)
imaging_task.link(process_task)
process_task.link_error(imaging_error_task)
# Task 3 = Validate the new image by launching an instance
if 'validating' in original_status:
image_id = machine_request.new_machine.identifier
celery_logger.info("Start with validating:%s" % image_id)
# If validating, seed the image_id and start here..
validate_task = validate_new_image.s(image_id, machine_request.id)
init_task = validate_task
else:
validate_task = validate_new_image.s(machine_request.id)
process_task.link(validate_task)
# Task 4 = Wait for new instance to be 'active'
wait_for_task = wait_for_instance.s(
# NOTE: 1st arg, instance_id, passed from last task.
admin_driver.__class__,
admin_driver.provider,
admin_driver.identity,
"active",
return_id=True)
validate_task.link(wait_for_task)
validate_task.link_error(imaging_error_task)
# Task 5 = Terminate the new instance on completion
destroy_task = destroy_instance.s(
admin_ident.uuid)
wait_for_task.link(destroy_task)
wait_for_task.link_error(imaging_error_task)
# Task 6 - Finally, email the user that their image is ready!
# NOTE: si == Ignore the result of the last task.
email_task = imaging_complete.si(machine_request.id)
destroy_task.link_error(imaging_error_task)
destroy_task.link(email_task)
email_task.link_error(imaging_error_task)
# Set status to imaging ONLY if our initial task is the imaging task.
if init_task == imaging_task:
machine_request.old_status = 'imaging'
machine_request.save()
# Start the task.
async = init_task.apply_async()
if delay:
async.get()
return async
def start_machine_imaging(machine_request, delay=False):
"""
Builds up a machine imaging task using core.models.machine_request
delay - If true, wait until task is completed before returning
"""
machine_request.status = "imaging"
machine_request.save()
instance_id = machine_request.instance.provider_alias
(orig_managerCls, orig_creds, dest_managerCls, dest_creds) = machine_request.prepare_manager()
imaging_args = machine_request.get_imaging_args()
admin_driver = machine_request.new_admin_driver()
admin_ident = machine_request.new_admin_identity()
imaging_error_task = machine_request_error.s(machine_request.id)
init_task = None
if dest_managerCls and dest_creds != orig_creds:
# Task 1 = Migrate Task
migrate_task = migrate_instance_task.si(
orig_managerCls, orig_creds, dest_managerCls, dest_creds, **imaging_args
)
if not init_task:
init_task = migrate_task
else:
init_task.link(migrate_task)
else:
# Task 1 = Imaging Task
image_task = machine_imaging_task.si(orig_managerCls, orig_creds, imaging_args)
if not init_task:
init_task = image_task
else:
init_task.link(image_task)
# Task 2 = Process the machine request
# (Save tags, name, description, metadata, etc.)
process_task = process_request.s(machine_request.id)
process_task.link_error(imaging_error_task)
if dest_managerCls and dest_creds != orig_creds:
migrate_task.link(process_task)
migrate_task.link_error(imaging_error_task)
else:
image_task.link(process_task)
image_task.link_error(imaging_error_task)
# Task 3 = Validate the new image by launching an instance
validate_task = validate_new_image.s(machine_request.id)
process_task.link(validate_task)
# Task 4 = Wait for new instance to be 'active'
wait_for_task = wait_for.s(
admin_driver.__class__, admin_driver.provider, admin_driver.identity, "active", return_id=True
)
validate_task.link(wait_for_task)
validate_task.link_error(imaging_error_task)
# Task 5 = Terminate the new instance on completion
destroy_task = destroy_instance.s(admin_ident.id)
wait_for_task.link(destroy_task)
wait_for_task.link_error(imaging_error_task)
# Task 6 - Finally, email the user that their image is ready!
email_task = imaging_complete.s(machine_request.id)
destroy_task.link_error(imaging_error_task)
destroy_task.link(email_task)
# Start the task.
async = init_task.apply_async()
if delay:
async.get()
return async
def start_machine_imaging(machine_request, delay=False):
"""
Builds up a machine imaging task using core.models.machine_request
delay - If true, wait until task is completed before returning
"""
machine_request.status = 'imaging'
machine_request.save()
instance_id = machine_request.instance.provider_alias
(orig_managerCls, orig_creds, dest_managerCls,
dest_creds) = machine_request.prepare_manager()
imaging_args = machine_request.get_imaging_args()
admin_driver = machine_request.new_admin_driver()
admin_ident = machine_request.new_admin_identity()
imaging_error_task = machine_request_error.s(machine_request.id)
init_task = None
if dest_managerCls and dest_creds != orig_creds:
#Task 1 = Migrate Task
migrate_task = migrate_instance_task.si(orig_managerCls, orig_creds,
dest_managerCls, dest_creds,
**imaging_args)
if not init_task:
init_task = migrate_task
else:
init_task.link(migrate_task)
else:
#Task 1 = Imaging Task
image_task = machine_imaging_task.si(orig_managerCls, orig_creds,
imaging_args)
if not init_task:
init_task = image_task
else:
init_task.link(image_task)
#Task 2 = Process the machine request
# (Save tags, name, description, metadata, etc.)
process_task = process_request.s(machine_request.id)
process_task.link_error(imaging_error_task)
if dest_managerCls and dest_creds != orig_creds:
migrate_task.link(process_task)
migrate_task.link_error(imaging_error_task)
else:
image_task.link(process_task)
image_task.link_error(imaging_error_task)
#Task 3 = Validate the new image by launching an instance
validate_task = validate_new_image.s(machine_request.id)
process_task.link(validate_task)
#Task 4 = Wait for new instance to be 'active'
wait_for_task = wait_for.s(admin_driver.__class__,
admin_driver.provider,
admin_driver.identity,
"active",
return_id=True)
validate_task.link(wait_for_task)
validate_task.link_error(imaging_error_task)
#Task 5 = Terminate the new instance on completion
destroy_task = destroy_instance.s(admin_ident.id)
wait_for_task.link(destroy_task)
wait_for_task.link_error(imaging_error_task)
#Task 6 - Finally, email the user that their image is ready!
email_task = imaging_complete.s(machine_request.id)
destroy_task.link_error(imaging_error_task)
destroy_task.link(email_task)
# Start the task.
async = init_task.apply_async()
if delay:
async .get()
return async
