def upload_template(rhosip, sshname, sshpass, username, password, auth_url, provider, image_url,
template_name, provider_data, stream):
try:
print("RHOS:{} Starting template {} upload...".format(provider, template_name))
if provider_data:
kwargs = make_kwargs_rhos(provider_data, provider)
else:
kwargs = make_kwargs_rhos(cfme_data, provider)
ssh_client = make_ssh_client(rhosip, sshname, sshpass)
kwargs['image_url'] = image_url
if template_name is None:
template_name = cfme_data['basic_info']['appliance_template']
export = make_export(username, password, kwargs.get('tenant_id'), auth_url)
if not check_image_exists(template_name, export, ssh_client):
output = upload_qc2_file(ssh_client, kwargs.get('image_url'), template_name, export,
provider)
if not output:
print("RHOS:{} Error occurred in upload_qc2_file".format(provider, template_name))
else:
image_id = get_image_id(output)
wait_for(check_image_status, [image_id, export, ssh_client],
fail_condition=False, delay=5, num_sec=300)
print("RHOS:{} Successfully uploaded the template.".format(provider))
if not provider_data:
print("RHOS:{} Adding template {} to trackerbot...".format(provider,
template_name))
trackerbot.trackerbot_add_provider_template(stream, provider, template_name)
else:
print("RHOS:{} Found image with name {}. Exiting...".format(provider, template_name))
if provider_data and check_image_exists(template_name, export, ssh_client):
print("RHOS:{} Deploying Template {}....".format(provider, template_name))
vm_name = 'test_{}_{}'.format(template_name, fauxfactory.gen_alphanumeric(8))
deploy_args = {'provider': provider, 'vm_name': vm_name,
'template': template_name, 'deploy': True}
getattr(__import__('clone_template'), "main")(**deploy_args)
ssh_client.close()
except Exception as e:
print(e)
print("RHOS:{} Error occurred in upload_qc2_file".format(provider, template_name))
return False
finally:
print("RHOS:{} End template {} upload...".format(provider, template_name))
def upload_template(rhevip, sshname, sshpass, username, password,
provider, image_url, template_name, provider_data, stream):
try:
print("RHEVM:{} Template {} upload started".format(provider, template_name))
if provider_data:
kwargs = make_kwargs_rhevm(provider_data, provider)
providers = provider_data['management_systems']
api = get_mgmt(kwargs.get('provider'), providers=providers).api
else:
kwargs = make_kwargs_rhevm(cfme_data, provider)
api = get_mgmt(kwargs.get('provider')).api
kwargs['image_url'] = image_url
kwargs['template_name'] = template_name
ovaname = get_ova_name(image_url)
ssh_client = make_ssh_client(rhevip, sshname, sshpass)
temp_template_name = ('auto-tmp-{}-'.format(
fauxfactory.gen_alphanumeric(8))) + template_name
temp_vm_name = ('auto-vm-{}-'.format(
fauxfactory.gen_alphanumeric(8))) + template_name
if template_name is None:
template_name = cfme_data['basic_info']['appliance_template']
path, edomain_ip = get_edomain_path(api, kwargs.get('edomain'))
kwargs = update_params_api(api, **kwargs)
check_kwargs(**kwargs)
if api.templates.get(template_name) is not None:
print("RHEVM:{} Found finished template with name {}.".format(provider, template_name))
print("RHEVM:{} The script will now end.".format(provider))
ssh_client.close()
else:
print("RHEVM:{} Downloading .ova file...".format(provider))
download_ova(ssh_client, kwargs.get('image_url'))
try:
print("RHEVM:{} Templatizing .ova file...".format(provider))
template_from_ova(api, username, password, rhevip, kwargs.get('edomain'),
ovaname, ssh_client, temp_template_name, provider)
print("RHEVM:{} Importing new template to data domain...".format(provider))
import_template(api, kwargs.get('edomain'), kwargs.get('sdomain'),
kwargs.get('cluster'), temp_template_name, provider)
print("RHEVM:{} Making a temporary VM from new template...".format(provider))
make_vm_from_template(api, kwargs.get('cluster'), temp_template_name, temp_vm_name,
provider, mgmt_network=kwargs.get('mgmt_network', None))
print("RHEVM:{} Adding disk to created VM...".format(provider))
add_disk_to_vm(api, kwargs.get('sdomain'), kwargs.get('disk_size'),
kwargs.get('disk_format'), kwargs.get('disk_interface'),
temp_vm_name, provider)
print("RHEVM:{} Templatizing VM...".format(provider))
templatize_vm(api, template_name, kwargs.get('cluster'), temp_vm_name, provider)
if not provider_data:
print("RHEVM:{} Adding template {} to trackerbot..".format(
provider, template_name))
trackerbot.trackerbot_add_provider_template(stream, provider, template_name)
finally:
cleanup(api, kwargs.get('edomain'), ssh_client, ovaname, provider,
temp_template_name, temp_vm_name)
change_edomain_state(api, 'maintenance', kwargs.get('edomain'), provider)
cleanup_empty_dir_on_edomain(path, edomain_ip,
sshname, sshpass, rhevip, provider)
change_edomain_state(api, 'active', kwargs.get('edomain'), provider)
ssh_client.close()
api.disconnect()
print("RHEVM:{} Template {} upload Ended".format(provider, template_name))
if provider_data and api.templates.get(template_name):
print("RHEVM:{} Deploying Template {}....".format(provider, template_name))
vm_name = 'test_{}_{}'.format(template_name, fauxfactory.gen_alphanumeric(8))
deploy_args = {'provider': provider, 'vm_name': vm_name,
'template': template_name, 'deploy': True}
getattr(__import__('clone_template'), "main")(**deploy_args)
print("RHEVM:{} Template {} upload Ended".format(provider, template_name))
except Exception as e:
print(e)
return False
def upload_template(rhosip, sshname, sshpass, username, password, auth_url,
provider, image_url, template_name, provider_data, stream):
try:
print("RHOS:{} Starting template {} upload...".format(
provider, template_name))
if provider_data:
kwargs = make_kwargs_rhos(provider_data, provider)
else:
kwargs = make_kwargs_rhos(cfme_data, provider)
ssh_client = make_ssh_client(rhosip, sshname, sshpass)
kwargs['image_url'] = image_url
if template_name is None:
template_name = cfme_data['basic_info']['appliance_template']
export = make_export(username, password, kwargs.get('tenant_id'),
auth_url)
if not check_image_exists(template_name, export, ssh_client):
output = upload_qc2_file(ssh_client, kwargs.get('image_url'),
template_name, export, provider)
if not output:
print("RHOS:{} Error occurred in upload_qc2_file".format(
provider, template_name))
else:
image_id = get_image_id(output)
wait_for(check_image_status, [image_id, export, ssh_client],
fail_condition=False,
delay=5,
num_sec=300)
print("RHOS:{} Successfully uploaded the template.".format(
provider))
if not provider_data:
print("RHOS:{} Adding template {} to trackerbot...".format(
provider, template_name))
trackerbot.trackerbot_add_provider_template(
stream, provider, template_name)
else:
print("RHOS:{} Found image with name {}. Exiting...".format(
provider, template_name))
if provider_data and check_image_exists(template_name, export,
ssh_client):
print("RHOS:{} Deploying Template {}....".format(
provider, template_name))
vm_name = 'test_{}_{}'.format(template_name,
fauxfactory.gen_alphanumeric(8))
deploy_args = {
'provider': provider,
'vm_name': vm_name,
'template': template_name,
'deploy': True
}
getattr(__import__('clone_template'), "main")(**deploy_args)
ssh_client.close()
except Exception as e:
print(e)
print("RHOS:{} Error occurred in upload_qc2_file".format(
provider, template_name))
return False
finally:
print("RHOS:{} End template {} upload...".format(
provider, template_name))
def upload_template(provider,
template_name,
stream,
file_name,
file_path,
ssh_client,
bucket_name=None):
bucket = bucket_name or cfme_data['template_upload']['template_upload_gce']['bucket_name']
try:
# IMAGE CHECK
log_detail('Checking if template {} present...'.format(template_name), provider)
result = ssh_client.run_command('gcloud compute images list {}'.format(template_name))
if 'Listed 0 items' not in result.output:
log_detail('Image {} already present in GCE, stopping upload'.format(template_name),
provider)
return True
log_detail('Image {} NOT present, continuing upload'.format(template_name), provider)
# MAKE BUCKET
log_detail('Creating bucket {}...'.format(bucket))
# gsutil has RC 1 and a API 409 in stdout if bucket exists
result = ssh_client.run_command('gsutil mb gs://{}'.format(bucket))
assert result or 'already exists' in result
# BUCKET CHECK
log_detail('Checking if file on bucket already...')
result = ssh_client.run_command('gsutil ls gs://{}'.format(join(bucket, file_name)))
if result.failed:
# FILE UPLOAD
log_detail('Uploading to bucket...')
result = ssh_client.run_command('gsutil cp {} gs://{}'
.format(join(file_path, file_name),
bucket))
assert result.success
log_detail('File uploading done ...')
else:
log_detail('File already on bucket...')
# IMAGE CREATION
log_detail('Creating template {}...'.format(template_name), provider)
template_name = check_template_name(template_name)
result = ssh_client.run_command('gcloud compute images create {} --source-uri gs://{}'
.format(template_name,
join(bucket, file_name)))
assert result.success
log_detail('Successfully added template {} from bucket {}'.format(template_name, bucket),
provider)
log_detail('Adding template {} to trackerbot for stream {}'
.format(template_name, stream), provider)
trackerbot.trackerbot_add_provider_template(stream, provider, template_name)
# DELETE FILE FROM BUCKET
log_detail('Cleaning up, removing {} from bucket {}...'.format(file_name, bucket), provider)
result = ssh_client.run_command('gsutil rm gs://{}'.format(join(bucket, file_name)))
assert result.success
except Exception as e:
print(e)
# exception often empty, try to include last ssh command output
log_detail('Error occurred in upload_template: \n {}'.format(result.output), provider)
return False
finally:
log_detail('End template {} upload...'.format(template_name), provider)
return True
def upload_template(client, hostname, username, password,
provider, url, name, provider_data, stream):
try:
if provider_data:
kwargs = make_kwargs_vsphere(provider_data, provider)
else:
kwargs = make_kwargs_vsphere(cfme_data, provider)
kwargs['ovf_tool_username'] = credentials['host_default']['username']
kwargs['ovf_tool_password'] = credentials['host_default']['password']
if name is None:
name = cfme_data['basic_info']['appliance_template']
print("VSPHERE:{} Start uploading Template: {}".format(provider, name))
if not check_kwargs(**kwargs):
return False
if not check_template_exists(client, name, provider):
if kwargs.get('upload'):
# Wrapper for ovftool - sometimes it just won't work
ova_ret, ova_out = (1, 'no output yet')
for i in range(0, NUM_OF_TRIES_OVFTOOL):
print("VSPHERE:{} Trying ovftool {}...".format(provider, i))
ova_ret, ova_out = upload_ova(hostname,
username,
password,
name,
kwargs.get('datastore'),
kwargs.get('cluster'),
kwargs.get('datacenter'),
url,
provider,
kwargs.get('proxy'),
kwargs.get('ovf_tool_client'),
kwargs['ovf_tool_username'],
kwargs['ovf_tool_password'])
if ova_ret is 0:
break
if ova_ret is -1:
print("VSPHERE:{} Ovftool failed to upload file.".format(provider))
print(ova_out)
return
if kwargs.get('disk'):
add_disk(client, name, provider)
if kwargs.get('template'):
try:
client.mark_as_template(vm_name=name)
print(" VSPHERE:{} Successfully templatized machine".format(provider))
except Exception:
print(" VSPHERE:{} Failed to templatize machine".format(provider))
sys.exit(127)
if not provider_data:
print("RHEVM:{} Adding template {} to trackerbot...".format(provider, name))
trackerbot.trackerbot_add_provider_template(stream, provider, name)
if provider_data and check_template_exists(client, name, provider):
print("VSPHERE:{} Deploying {}....".format(provider, name))
vm_name = 'test_{}_{}'.format(name, fauxfactory.gen_alphanumeric(8))
deploy_args = {'provider': provider, 'vm_name': vm_name,
'template': name, 'deploy': True}
getattr(__import__('clone_template'), "main")(**deploy_args)
except Exception as e:
print(e)
return False
finally:
print("VSPHERE:{} End uploading Template: {}".format(provider, name))
def upload_template(provider,
template_name,
stream,
file_name,
file_path,
ssh_client,
bucket_name=None):
bucket = bucket_name or cfme_data['template_upload'][
'template_upload_gce']['bucket_name']
try:
# IMAGE CHECK
log_detail('Checking if template {} present...'.format(template_name),
provider)
result = ssh_client.run_command(
'gcloud compute images list {}'.format(template_name))
if 'Listed 0 items' not in result.output:
log_detail(
'Image {} already present in GCE, stopping upload'.format(
template_name), provider)
return True
log_detail(
'Image {} NOT present, continuing upload'.format(template_name),
provider)
# MAKE BUCKET
log_detail('Creating bucket {}...'.format(bucket))
# gsutil has RC 1 and a API 409 in stdout if bucket exists
result = ssh_client.run_command('gsutil mb gs://{}'.format(bucket))
assert result or 'already exists' in result
# BUCKET CHECK
log_detail('Checking if file on bucket already...')
result = ssh_client.run_command('gsutil ls gs://{}'.format(
join(bucket, file_name)))
if result.failed:
# FILE UPLOAD
log_detail('Uploading to bucket...')
result = ssh_client.run_command('gsutil cp {} gs://{}'.format(
join(file_path, file_name), bucket))
assert result.success
log_detail('File uploading done ...')
else:
log_detail('File already on bucket...')
# IMAGE CREATION
log_detail('Creating template {}...'.format(template_name), provider)
template_name = check_template_name(template_name)
result = ssh_client.run_command(
'gcloud compute images create {} --source-uri gs://{}'.format(
template_name, join(bucket, file_name)))
assert result.success
log_detail(
'Successfully added template {} from bucket {}'.format(
template_name, bucket), provider)
log_detail(
'Adding template {} to trackerbot for stream {}'.format(
template_name, stream), provider)
trackerbot.trackerbot_add_provider_template(stream, provider,
template_name)
# DELETE FILE FROM BUCKET
log_detail(
'Cleaning up, removing {} from bucket {}...'.format(
file_name, bucket), provider)
result = ssh_client.run_command('gsutil rm gs://{}'.format(
join(bucket, file_name)))
assert result.success
except Exception as e:
print(e)
# exception often empty, try to include last ssh command output
log_detail(
'Error occurred in upload_template: \n {}'.format(result.output),
provider)
return False
finally:
log_detail('End template {} upload...'.format(template_name), provider)
return True
def run(**kwargs):
for provider in list_provider_keys("scvmm"):
kwargs = make_kwargs_scvmm(cfme_data, provider,
kwargs.get('image_url'), kwargs.get('template_name'))
check_kwargs(**kwargs)
mgmt_sys = cfme_data['management_systems'][provider]
host_fqdn = mgmt_sys['hostname_fqdn']
creds = credentials[mgmt_sys['credentials']]
# For powershell to work, we need to extract the User Name from the Domain
user = creds['username'].split('\\')
if len(user) == 2:
username_powershell = user[1]
else:
username_powershell = user[0]
username_scvmm = creds['domain'] + "\\" + creds['username']
scvmm_args = {
"hostname": mgmt_sys['ipaddress'],
"username": username_powershell,
"password": creds['password'],
"domain": creds['domain'],
"provisioning": mgmt_sys['provisioning']
}
client = SCVMMSystem(**scvmm_args)
url = kwargs.get('image_url')
# Template name equals either user input of we extract the name from the url
new_template_name = kwargs.get('template_name')
if new_template_name is None:
new_template_name = os.path.basename(url)[:-4]
logger.info("SCVMM:{} Make Template out of the VHD {}", provider, new_template_name)
# use_library is either user input or we use the cfme_data value
library = kwargs.get('library', mgmt_sys['template_upload'].get('vhds', None))
logger.info("SCVMM:{} Template Library: {}", provider, library)
# The VHD name changed, match the template_name.
new_vhd_name = new_template_name + '.vhd'
network = mgmt_sys['template_upload'].get('network', None)
os_type = mgmt_sys['template_upload'].get('os_type', None)
cores = mgmt_sys['template_upload'].get('cores', None)
ram = mgmt_sys['template_upload'].get('ram', None)
# Uses PowerShell Get-SCVMTemplate to return a list of templates and aborts if exists.
if not client.does_template_exist(new_template_name):
if kwargs.get('upload'):
logger.info("SCVMM:{} Uploading VHD image to Library VHD folder.", provider)
upload_vhd(client, url, library, new_vhd_name)
if kwargs.get('template'):
logger.info("SCVMM:{} Make Template out of the VHD {}", provider, new_template_name)
make_template(
client,
host_fqdn,
new_template_name,
library,
network,
os_type,
username_scvmm,
cores,
ram
)
try:
wait_for(lambda: client.does_template_exist(new_template_name),
fail_condition=False, delay=5)
logger.info("SCVMM:{} template {} uploaded success", provider, new_template_name)
logger.info("SCVMM:{} Add template {} to trackerbot", provider, new_template_name)
trackerbot.trackerbot_add_provider_template(kwargs.get('stream'),
provider,
kwargs.get('template_name'))
except Exception:
logger.exception("SCVMM:{} Exception verifying the template {}",
provider, new_template_name)
else:
logger.info("SCVMM: A Template with that name already exists in the SCVMMLibrary")
def upload_template(client, hostname, username, password, provider, url, name,
provider_data, stream):
try:
if provider_data:
kwargs = make_kwargs_vsphere(provider_data, provider)
else:
kwargs = make_kwargs_vsphere(cfme_data, provider)
kwargs['ovf_tool_username'] = credentials['host_default']['username']
kwargs['ovf_tool_password'] = credentials['host_default']['password']
if name is None:
name = cfme_data['basic_info']['appliance_template']
logger.info("VSPHERE:%r Start uploading Template: %r", provider, name)
if not check_kwargs(**kwargs):
return False
if name in client.list_template():
if kwargs.get('upload'):
# Wrapper for ovftool - sometimes it just won't work
for i in range(0, NUM_OF_TRIES_OVFTOOL):
logger.info("VSPHERE:%r ovftool try #%r", provider, i)
upload_result = upload_ova(hostname, username, password,
name, kwargs.get('datastore'),
kwargs.get('cluster'),
kwargs.get('datacenter'), url,
provider, kwargs.get('proxy'),
kwargs.get('ovf_tool_client'),
kwargs['ovf_tool_username'],
kwargs['ovf_tool_password'])
if upload_result:
break
else:
logger.error(
"VSPHERE:%r Ovftool failed upload after multiple tries",
provider)
return
if kwargs.get('disk'):
if not add_disk(client, name, provider):
logger.error(
'"VSPHERE:%r FAILED adding disk to VM, exiting',
provider)
return False
if kwargs.get('template'):
try:
client.mark_as_template(vm_name=name)
logger.info("VSPHERE:%r Successfully templatized machine",
provider)
except Exception:
logger.exception("VSPHERE:%r FAILED to templatize machine",
provider)
return False
if not provider_data:
logger.info("VSPHERE:%r Adding template %r to trackerbot",
provider, name)
trackerbot.trackerbot_add_provider_template(
stream, provider, name)
else:
logger.info("VSPHERE:%r template %r already exists", provider,
name)
if provider_data and name in client.list_template():
logger.info(
"VSPHERE:%r Template and provider_data exist, Deploy %r",
provider, name)
vm_name = 'test_{}_{}'.format(name,
fauxfactory.gen_alphanumeric(8))
deploy_args = {
'provider': provider,
'vm_name': vm_name,
'template': name,
'deploy': True
}
getattr(__import__('clone_template'), "main")(**deploy_args)
except Exception:
logger.exception('VSPHERE:%r Exception during upload_template',
provider)
return False
finally:
logger.info("VSPHERE:%r End uploading Template: %r", provider, name)
def upload_template(rhevip, sshname, sshpass, username, password,
provider, image_url, template_name, provider_data, stream):
try:
print("RHEVM:{} Template {} upload started".format(provider, template_name))
if provider_data:
kwargs = make_kwargs_rhevm(provider_data, provider)
providers = provider_data['management_systems']
api = get_mgmt(kwargs.get('provider'), providers=providers).api
else:
kwargs = make_kwargs_rhevm(cfme_data, provider)
api = get_mgmt(kwargs.get('provider')).api
kwargs['image_url'] = image_url
kwargs['template_name'] = template_name
ovaname = get_ova_name(image_url)
ssh_client = make_ssh_client(rhevip, sshname, sshpass)
temp_template_name = ('auto-tmp-{}-'.format(
fauxfactory.gen_alphanumeric(8))) + template_name
temp_vm_name = ('auto-vm-{}-'.format(
fauxfactory.gen_alphanumeric(8))) + template_name
if template_name is None:
template_name = cfme_data['basic_info']['appliance_template']
path, edomain_ip = get_edomain_path(api, kwargs.get('edomain'))
kwargs = update_params_api(api, **kwargs)
check_kwargs(**kwargs)
if api.templates.get(template_name) is not None:
print("RHEVM:{} Found finished template with name {}.".format(provider, template_name))
print("RHEVM:{} The script will now end.".format(provider))
ssh_client.close()
else:
print("RHEVM:{} Downloading .ova file...".format(provider))
download_ova(ssh_client, kwargs.get('image_url'))
try:
print("RHEVM:{} Templatizing .ova file...".format(provider))
template_from_ova(api, username, password, rhevip, kwargs.get('edomain'),
ovaname, ssh_client, temp_template_name, provider)
print("RHEVM:{} Importing new template to data domain...".format(provider))
import_template(api, kwargs.get('edomain'), kwargs.get('sdomain'),
kwargs.get('cluster'), temp_template_name, provider)
print("RHEVM:{} Making a temporary VM from new template...".format(provider))
make_vm_from_template(api, kwargs.get('cluster'), temp_template_name, temp_vm_name,
provider, mgmt_network=kwargs.get('mgmt_network'))
print("RHEVM:{} Adding disk to created VM...".format(provider))
add_disk_to_vm(api, kwargs.get('sdomain'), kwargs.get('disk_size'),
kwargs.get('disk_format'), kwargs.get('disk_interface'),
temp_vm_name, provider)
print("RHEVM:{} Templatizing VM...".format(provider))
templatize_vm(api, template_name, kwargs.get('cluster'), temp_vm_name, provider)
if not provider_data:
print("RHEVM:{} Adding template {} to trackerbot..".format(
provider, template_name))
trackerbot.trackerbot_add_provider_template(stream, provider, template_name)
finally:
cleanup(api, kwargs.get('edomain'), ssh_client, ovaname, provider,
temp_template_name, temp_vm_name)
change_edomain_state(api, 'maintenance', kwargs.get('edomain'), provider)
cleanup_empty_dir_on_edomain(path, edomain_ip,
sshname, sshpass, rhevip, provider)
change_edomain_state(api, 'active', kwargs.get('edomain'), provider)
ssh_client.close()
api.disconnect()
print("RHEVM:{} Template {} upload Ended".format(provider, template_name))
if provider_data and api.templates.get(template_name):
print("RHEVM:{} Deploying Template {}....".format(provider, template_name))
vm_name = 'test_{}_{}'.format(template_name, fauxfactory.gen_alphanumeric(8))
deploy_args = {'provider': provider, 'vm_name': vm_name,
'template': template_name, 'deploy': True}
getattr(__import__('clone_template'), "main")(**deploy_args)
print("RHEVM:{} Template {} upload Ended".format(provider, template_name))
except Exception as e:
print("RHEVM:{} Template {} upload exception: {}".format(provider, template_name, e))
return False
def run(template_name, image_url, stream, **kwargs):
"""
Download file from image_url, upload it to an S3 bucket and import into ec2
Should handle all ec2 regions and minimize uploading by copying images
:param template_name: string name of the template
:param image_url: string url to download template image
:param stream: string stream name
:param kwargs: other kwargs
:return: none
"""
mgmt_sys = cfme_data['management_systems']
ami_name = template_name
prov_to_upload = []
valid_providers = [
prov_key for prov_key in mgmt_sys
if (mgmt_sys[prov_key]['type'] == 'ec2') and (
'disabled' not in mgmt_sys[prov_key]['tags'])
]
if valid_providers:
print(
"Uploading to following enabled ec2 providers/regions: {}".format(
valid_providers))
else:
print('ERROR: No providers found with ec2 type and no disabled tag')
return
# Look for template name on all ec2 regions, in case we can just copy it
# Also ec2 lets you upload duplicate names, so we'll skip upload if its already there
for prov_key in valid_providers:
ec2 = get_mgmt(provider_key=prov_key)
try:
ami_id = check_for_ami(ec2, ami_name)
except MultipleImagesError:
print('ERROR: Already multiple images with name "{}"'.format(
ami_name))
return
if ami_id:
# TODO roll this into a flag that copies it to regions without it
print('EC2 {}: AMI already exists with name "{}"'.format(
prov_key, ami_name))
continue
else:
# Need to upload on this region
prov_to_upload.append(prov_key)
# See if we actually need to upload
if not prov_to_upload:
print('DONE: No templates to upload, all regions have the ami: "{}"'.
format(ami_name))
return
# download image
print("INFO: Starting image download {} ...".format(
kwargs.get('image_url')))
file_name, file_path = download_image_file(image_url)
print("INFO: Image downloaded {} ...".format(file_path))
# TODO: thread + copy within amazon for when we have multiple regions enabled
# create ami's in the regions
for prov_key in prov_to_upload:
region = mgmt_sys[prov_key].get('region', prov_key)
bucket_name = mgmt_sys[prov_key].get('upload_bucket_name',
'cfme-template-upload')
print('EC2:{}:{} Starting S3 upload of {}'.format(
prov_key, region, file_path))
ec2 = get_mgmt(provider_key=prov_key)
upload_to_s3(ec2=ec2,
bucket_name=bucket_name,
ami_name=ami_name,
file_path=file_path)
create_image(ec2=ec2, ami_name=ami_name, bucket_name=bucket_name)
cleanup_s3(ec2=ec2, bucket_name=bucket_name, ami_name=ami_name)
# Track it
print("EC2:{}:{} Adding template {} to trackerbot for stream ".format(
prov_key, region, ami_name, stream))
trackerbot.trackerbot_add_provider_template(stream, prov_key, ami_name)
print('EC2:{}:{} Template {} creation complete'.format(
prov_key, region, ami_name))
def run(**kwargs):
for provider in list_providers("scvmm"):
kwargs = make_kwargs_scvmm(cfme_data, provider,
kwargs.get('image_url'), kwargs.get('template_name'))
check_kwargs(**kwargs)
mgmt_sys = cfme_data['management_systems'][provider]
host_fqdn = mgmt_sys['hostname_fqdn']
creds = credentials[mgmt_sys['credentials']]
# For powershell to work, we need to extract the User Name from the Domain
user = creds['username'].split('\\')
if len(user) == 2:
username_powershell = user[1]
else:
username_powershell = user[0]
username_scvmm = creds['domain'] + "\\" + creds['username']
scvmm_args = {
"hostname": mgmt_sys['ipaddress'],
"username": username_powershell,
"password": creds['password'],
"domain": creds['domain'],
}
client = SCVMMSystem(**scvmm_args)
url = kwargs.get('image_url', None)
# Template name equals either user input of we extract the name from the url
new_template_name = kwargs.get('template_name', None)
if new_template_name is None:
new_template_name = os.path.basename(url)[:-4]
print("SCVMM:{} started template {} upload".format(provider, new_template_name))
print("SCVMM:{} Make Template out of the VHD {}".format(provider, new_template_name))
# use_library is either user input or we use the cfme_data value
use_library = kwargs.get('library', None)
if use_library is None:
use_library = mgmt_sys['template_upload'].get('library', None) + "\\VHDS\\"
print("SCVMM:{} Template Library: {}".format(provider, use_library))
# The VHD name changed, match the template_name.
new_vhd_name = new_template_name + '.vhd'
use_network = mgmt_sys['template_upload'].get('network', None)
use_os_type = mgmt_sys['template_upload'].get('os_type', None)
cores = mgmt_sys['template_upload'].get('cores', None)
ram = mgmt_sys['template_upload'].get('ram', None)
# Uses PowerShell Get-SCVMTemplate to return a list of templates and aborts if exists.
if not check_template_exists(client, new_template_name):
if kwargs.get('upload'):
upload_vhd(client, url, use_library, new_vhd_name)
if kwargs.get('template'):
print("SCVMM:{} Make Template out of the VHD {}".format(
provider, new_template_name))
make_template(
client,
host_fqdn,
new_template_name,
use_library,
use_network,
use_os_type,
username_scvmm,
cores,
ram
)
try:
wait_for(check_template_exists,
[client, new_template_name], fail_condition=False, delay=5)
print("SCVMM:{} template {} uploaded successfully".format(
provider, new_template_name))
print("SCVMM:{} Adding template {} to trackerbot".format(
provider, new_template_name))
trackerbot.trackerbot_add_provider_template(kwargs.get('stream'),
provider, kwargs.get('template_name'))
except Exception as e:
print(e)
print("SCVMM:{} Exception occured while verifying the template {} upload".format(
provider, new_template_name))
else:
print("SCVMM: A Template with that name already exists in the SCVMMLibrary")
def upload_template(client, hostname, username, password, provider, url, name,
provider_data, stream):
try:
if provider_data:
kwargs = make_kwargs_vsphere(provider_data, provider)
else:
kwargs = make_kwargs_vsphere(cfme_data, provider)
kwargs['ovf_tool_username'] = credentials['host_default']['username']
kwargs['ovf_tool_password'] = credentials['host_default']['password']
if name is None:
name = cfme_data['basic_info']['appliance_template']
print("VSPHERE:{} Start uploading Template: {}".format(provider, name))
if not check_kwargs(**kwargs):
return False
if not check_template_exists(client, name, provider):
if kwargs.get('upload'):
# Wrapper for ovftool - sometimes it just won't work
ova_ret, ova_out = (1, 'no output yet')
for i in range(0, NUM_OF_TRIES_OVFTOOL):
print("VSPHERE:{} Trying ovftool {}...".format(
provider, i))
ova_ret, ova_out = upload_ova(
hostname, username, password, name,
kwargs.get('datastore'), kwargs.get('cluster'),
kwargs.get('datacenter'), url, provider,
kwargs.get('proxy'), kwargs.get('ovf_tool_client'),
kwargs['ovf_tool_username'],
kwargs['ovf_tool_password'])
if ova_ret is 0:
break
if ova_ret is -1:
print("VSPHERE:{} Ovftool failed to upload file.".format(
provider))
print(ova_out)
return
if kwargs.get('disk'):
add_disk(client, name, provider)
if kwargs.get('template'):
# make_template(client, name, hostname, username, password)
make_template(client, name, provider)
if not provider_data:
print("RHEVM:{} Adding template {} to trackerbot...".format(
provider, name))
trackerbot.trackerbot_add_provider_template(
stream, provider, name)
if provider_data and check_template_exists(client, name, provider):
print("VSPHERE:{} Deploying {}....".format(provider, name))
vm_name = 'test_{}_{}'.format(name,
fauxfactory.gen_alphanumeric(8))
deploy_args = {
'provider': provider,
'vm_name': vm_name,
'template': name,
'deploy': True
}
getattr(__import__('clone_template'), "main")(**deploy_args)
client.api.logout()
except Exception as e:
print(e)
return False
finally:
print("VSPHERE:{} End uploading Template: {}".format(provider, name))
def upload_template(rhosip, sshname, sshpass, username, password, auth_url,
provider, image_url, template_name, provider_data, stream):
try:
logger.info("RHOS:%r Starting template %r upload", provider,
template_name)
if provider_data:
kwargs = make_kwargs_rhos(provider_data, provider)
else:
kwargs = make_kwargs_rhos(cfme_data, provider)
kwargs['image_url'] = image_url
if template_name is None:
template_name = cfme_data['basic_info']['appliance_template']
export = make_export(username, password, kwargs.get('tenant_id'),
auth_url)
with make_ssh_client(rhosip, sshname, sshpass) as ssh_client:
if not check_image_exists(template_name, export, ssh_client):
output = upload_qc2_file(ssh_client, kwargs.get('image_url'),
template_name, export, provider)
if not output:
logger.error("RHOS:%r upload_qc2_file returned None: %r",
provider, template_name)
else:
image_id = get_image_id(output)
wait_for(check_image_status,
[image_id, export, ssh_client],
fail_condition=False,
delay=5,
num_sec=300)
logger.info("RHOS:%r Successfully uploaded the template.",
provider)
if not provider_data:
logger.info("RHOS:%r Adding template %r to trackerbot",
provider, template_name)
trackerbot.trackerbot_add_provider_template(
stream, provider, template_name)
else:
logger.info("RHOS:%r Found image with name %r. Exiting",
provider, template_name)
if provider_data and check_image_exists(template_name, export,
ssh_client):
logger.info("RHOS:%r Deploying Template %r....", provider,
template_name)
vm_name = 'test_{}_{}'.format(template_name,
fauxfactory.gen_alphanumeric(8))
deploy_args = {
'provider': provider,
'vm_name': vm_name,
'template': template_name,
'deploy': True
}
getattr(__import__('clone_template'), "main")(**deploy_args)
except Exception:
logger.exception("RHOS:%r Exception while uploading template",
provider)
return False
finally:
logger.info("RHOS:%r End template %r upload", provider, template_name)
def upload_template(provider,
template_name,
stream,
file_name,
file_path,
ssh_client,
bucket_name=None):
bucket = bucket_name or cfme_data['template_upload']['template_upload_gce']['bucket_name']
try:
# IMAGE CHECK
logger.info('GCE: %r: Checking if template %r present', provider, template_name)
result = ssh_client.run_command('gcloud compute images list {}'.format(template_name))
if 'Listed 0 items' not in result.output:
logger.info('GCE: %r: Image %r already present in GCE, stopping upload',
provider, template_name)
return True
logger.info('GCE: %r: Image %r NOT present, continuing upload', provider, template_name)
# MAKE BUCKET
logger.info('GCE: %r: Creating bucket %r...', provider, bucket)
# gsutil has RC 1 and a API 409 in stdout if bucket exists
result = ssh_client.run_command('gsutil mb gs://{}'.format(bucket))
assert result or 'already exists' in result
# BUCKET CHECK
logger.info('GCE: %r: Checking if file on bucket already', provider)
result = ssh_client.run_command('gsutil ls gs://{}'.format(join(bucket, file_name)))
if result.failed:
# FILE UPLOAD
logger.info('GCE: %r: Uploading to bucket...')
result = ssh_client.run_command('gsutil cp {} gs://{}'
.format(join(file_path, file_name),
bucket))
assert result.success
logger.info('GCE: %r: File uploading done ...')
else:
logger.info('GCE: %r: File already on bucket...')
# IMAGE CREATION
logger.info('GCE: %r: Creating template %r', provider, template_name)
template_name = check_template_name(template_name)
result = ssh_client.run_command('gcloud compute images create {} --source-uri gs://{}'
.format(template_name,
join(bucket, file_name)))
assert result.success
logger.info('GCE: %r: Successfully added template %r from bucket %r',
provider, template_name, bucket)
logger.info('GCE: %r: Adding template %r to trackerbot for stream %r',
provider, template_name, stream)
trackerbot.trackerbot_add_provider_template(stream, provider, template_name)
# DELETE FILE FROM BUCKET
logger.info('GCE: %r: Cleaning up, removing %r from bucket %r',
provider, file_name, bucket)
result = ssh_client.run_command('gsutil rm gs://{}'.format(join(bucket, file_name)))
assert result.success
except Exception:
# Exception often empty, include last code's stdout
logger.exception('GCE: %r: Exception occurred in upload_template, last ssh stdout: \n %r',
provider, str(result))
return False
finally:
logger.info('GCE: %r: End template %r upload...', provider, template_name)
return True
