def upload_template(hostname, username, password, provider, url, name,
provider_data, stream, upload_folder):
try:
kwargs = {}
if name is None:
name = cfme_data['basic_info']['appliance_template']
logger.info("OPENSHIFT:%r Start uploading Template: %r", provider,
name)
if not check_kwargs(**kwargs):
return False
if name not in list_templates(hostname, username, password,
upload_folder):
with SSHClient(hostname=hostname,
username=username,
password=password) as ssh:
dest_dir = os.path.join(upload_folder, name)
result = ssh.run_command('mkdir {dir}'.format(dir=dest_dir))
if result.failed:
logger.exception("OPENSHIFT: cant create folder %r",
str(result))
raise
download_cmd = (
'wget -q --no-parent --no-directories --reject "index.html*" '
'--directory-prefix={dir} -r {url}')
result = ssh.run_command(
download_cmd.format(dir=dest_dir, url=url))
if result.failed:
logger.exception("OPENSHIFT: cannot upload template %r",
str(result))
raise
if not provider_data:
logger.info("OPENSHIFT:%r Adding template %r to trackerbot",
provider, name)
trackerbot.trackerbot_add_provider_template(
stream, provider, name)
else:
logger.info("OPENSHIFT:%r template %r already exists", provider,
name)
except Exception:
logger.exception('OPENSHIFT:%r Exception during upload_template',
provider)
return False
finally:
logger.info("OPENSHIFT:%r End uploading Template: %r", 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(hostname, username, password, provider, url, name, provider_data,
stream, upload_folder, oc_username, oc_password):
try:
kwargs = {}
if name is None:
name = cfme_data['basic_info']['appliance_template']
logger.info("OPENSHIFT:%r Start uploading Template: %r", provider, name)
if not check_kwargs(**kwargs):
return False
logger.info("checking whether this template is already present in provider env")
if name not in list_templates(hostname, username, password, upload_folder):
with SSHClient(hostname=hostname, username=username, password=password) as ssh:
# creating folder to store template files
dest_dir = os.path.join(upload_folder, name)
logger.info("creating folder for templates: {f}".format(f=dest_dir))
result = ssh.run_command('mkdir {dir}'.format(dir=dest_dir))
if result.failed:
err_text = "OPENSHIFT: cant create folder {}".format(str(result))
logger.exception(err_text)
raise RuntimeError(err_text)
download_cmd = ('wget -q --no-parent --no-directories --reject "index.html*" '
'--directory-prefix={dir} -r {url}')
logger.info("downloading templates to destination dir {f}".format(f=dest_dir))
result = ssh.run_command(download_cmd.format(dir=dest_dir, url=url))
if result.failed:
err_text = "OPENSHIFT: cannot download template {}".format(str(result))
logger.exception(err_text)
raise RuntimeError(err_text)
# updating image streams in openshift
logger.info("logging in to openshift")
login_cmd = 'oc login --username={u} --password={p}'
result = ssh.run_command(login_cmd.format(u=oc_username, p=oc_password))
if result.failed:
err_text = "OPENSHIFT: couldn't login to openshift {}".format(str(result))
logger.exception(err_text)
raise RuntimeError(err_text)
logger.info("looking for templates in destination dir {f}".format(f=dest_dir))
get_urls_cmd = 'find {d} -type f -name "cfme-openshift-*" -exec tail -1 {{}} \;'
result = ssh.run_command(get_urls_cmd.format(d=dest_dir))
if result.failed:
err_text = "OPENSHIFT: couldn't get img stream urls {}".format(str(result))
logger.exception(err_text)
raise RuntimeError(err_text)
tags = {}
for img_url in str(result).split():
update_img_cmd = 'docker pull {url}'
logger.info("updating image stream to tag {t}".format(t=img_url))
result = ssh.run_command(update_img_cmd.format(url=img_url))
# url ex:
# brew-pulp-docker01.web.prod.ext.phx2.redhat.com:8888/cloudforms46/cfme-openshift-httpd:2.4.6-14
tag_name, tag_value = img_url.split('/')[-1].split(':')
tag_url = img_url.rpartition(':')[-1]
tags[tag_name] = {'tag': tag_value, 'url': tag_url}
if result.failed:
err_text = ("OPENSHIFT: couldn't update image stream using url "
"{}, {}".format(img_url, str(result)))
logger.exception(err_text)
raise RuntimeError(err_text)
logger.info('updating templates before upload to openshift')
# updating main template file, adding essential patches
main_template_file = 'cfme-template.yaml'
main_template = os.path.join(dest_dir, main_template_file)
default_template_name = 'cloudforms'
new_template_name = name
logger.info('removing old templates from ocp if those exist')
for template in (default_template_name, new_template_name):
if ssh.run_command('oc get template {t} '
'--namespace=openshift'.format(t=template)).success:
ssh.run_command('oc delete template {t} '
'--namespace=openshift'.format(t=template))
logger.info('changing template name to unique one')
change_name_cmd = """python -c 'import yaml
data = yaml.safe_load(open("{file}"))
data["metadata"]["name"] = "{new_name}"
yaml.safe_dump(data, stream=open("{file}", "w"))'""".format(new_name=new_template_name,
file=main_template)
# our templates always have the same name but we have to keep many templates
# of the same stream. So we have to change template name before upload to ocp
# in addition, openshift doesn't provide any convenient way to change template name
logger.info(change_name_cmd)
result = ssh.run_command(change_name_cmd)
if result.failed:
err_text = "OPENSHIFT: couldn't change default template name"
logger.exception(err_text)
raise RuntimeError(err_text)
logger.info("uploading main template to ocp")
result = ssh.run_command('oc create -f {t} '
'--namespace=openshift'.format(t=main_template))
if result.failed:
err_text = "OPENSHIFT: couldn't upload template to openshift"
logger.exception(err_text)
raise RuntimeError(err_text)
if not provider_data:
logger.info("OPENSHIFT:%r Adding template %r to trackerbot", provider, name)
trackerbot.trackerbot_add_provider_template(stream=stream,
provider=provider,
template_name=name,
custom_data={'TAGS': tags})
logger.info("upload has been finished successfully")
else:
logger.info("OPENSHIFT:%r template %r already exists", provider, name)
except Exception:
logger.exception('OPENSHIFT:%r Exception during upload_template', provider)
return False
finally:
logger.info("OPENSHIFT:%r End uploading Template: %r", provider, name)
def track_template(self, **kwargs):
trackerbot.trackerbot_add_provider_template(self.stream,
self.provider_key,
self.template_name,
**kwargs)
return True
def upload_template(client, hostname, username, password, provider, url, name,
provider_data, stream, results):
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):
results[provider] = False
return
if name in client.list_template():
logger.info("VSPHERE:%r template %r already exists", provider,
name)
else:
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)
results[provider] = False
return
if kwargs.get('disk'):
if not add_disk(client, name, provider):
logger.error(
'"VSPHERE:%r FAILED adding disk to VM, exiting',
provider)
results[provider] = False
return
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)
results[provider] = False
return
if not provider_data:
logger.info("VSPHERE:%r Adding template %r to trackerbot",
provider, name)
trackerbot.trackerbot_add_provider_template(
stream, 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)
# If we get here without hitting an exception, we passed...
results[provider] = True
except Exception:
logger.exception('VSPHERE:%r Exception during upload_template',
provider)
results[provider] = False
return
finally:
logger.info("VSPHERE:%r End uploading Template: %r", provider, name)
def upload_template(hostname, username, password, provider, url, name,
provider_data, stream, upload_folder, oc_username,
oc_password):
try:
kwargs = {}
if name is None:
name = cfme_data['basic_info']['appliance_template']
logger.info("OPENSHIFT:%r Start uploading Template: %r", provider,
name)
if not check_kwargs(**kwargs):
return False
logger.info(
"checking whether this template is already present in provider env"
)
if name not in list_templates(hostname, username, password,
upload_folder):
with SSHClient(hostname=hostname,
username=username,
password=password) as ssh:
dest_dir = os.path.join(upload_folder, name)
logger.info(
"creating folder for templates: {f}".format(f=dest_dir))
result = ssh.run_command('mkdir {dir}'.format(dir=dest_dir))
if result.failed:
logger.exception("OPENSHIFT: cant create folder %r",
str(result))
raise
download_cmd = (
'wget -q --no-parent --no-directories --reject "index.html*" '
'--directory-prefix={dir} -r {url}')
logger.info(
"downloading templates to destination dir {f}".format(
f=dest_dir))
result = ssh.run_command(
download_cmd.format(dir=dest_dir, url=url))
if result.failed:
logger.exception("OPENSHIFT: cannot upload template %r",
str(result))
raise
# updating image streams in openshift
login_cmd = 'oc login --username={u} --password={p}'
result = ssh.run_command(
login_cmd.format(u=oc_username, p=oc_password))
if result.failed:
logger.exception(
"OPENSHIFT: couldn't login to openshift %r",
str(result))
raise
logger.info(
"looking for templates in destination dir {f}".format(
f=dest_dir))
get_urls_cmd = 'find {d} -type f -name "cfme-openshift-*" -exec tail -1 {{}} \;'
result = ssh.run_command(get_urls_cmd.format(d=dest_dir))
if result.failed:
logger.exception(
"OPENSHIFT: couldn't get img stream urls %r",
str(result))
raise
for img_url in str(result).split():
update_img_cmd = 'docker pull {url}'
logger.info(
"updating image stream to tag {t}".format(t=img_url))
result = ssh.run_command(
update_img_cmd.format(url=img_url))
if result.failed:
logger.exception(
"OPENSHIFT: couldn't update image stream using url %r,"
"%r", img_url, str(result))
raise
if not provider_data:
logger.info("OPENSHIFT:%r Adding template %r to trackerbot",
provider, name)
trackerbot.trackerbot_add_provider_template(
stream, provider, name)
else:
logger.info("OPENSHIFT:%r template %r already exists", provider,
name)
except Exception:
logger.exception('OPENSHIFT:%r Exception during upload_template',
provider)
return False
finally:
logger.info("OPENSHIFT:%r End uploading Template: %r", provider, name)
def upload_template(hostname, username, password, provider, url, name, provider_data,
stream, upload_folder, oc_username, oc_password):
try:
kwargs = {}
if name is None:
name = cfme_data['basic_info']['appliance_template']
logger.info("OPENSHIFT:%r Start uploading Template: %r", provider, name)
if not check_kwargs(**kwargs):
return False
logger.info("checking whether this template is already present in provider env")
if name not in list_templates(hostname, username, password, upload_folder):
with SSHClient(hostname=hostname, username=username, password=password) as ssh:
dest_dir = os.path.join(upload_folder, name)
logger.info("creating folder for templates: {f}".format(f=dest_dir))
result = ssh.run_command('mkdir {dir}'.format(dir=dest_dir))
if result.failed:
logger.exception("OPENSHIFT: cant create folder %r", str(result))
raise
download_cmd = ('wget -q --no-parent --no-directories --reject "index.html*" '
'--directory-prefix={dir} -r {url}')
logger.info("downloading templates to destination dir {f}".format(f=dest_dir))
result = ssh.run_command(download_cmd.format(dir=dest_dir, url=url))
if result.failed:
logger.exception("OPENSHIFT: cannot upload template %r", str(result))
raise
# updating image streams in openshift
login_cmd = 'oc login --username={u} --password={p}'
result = ssh.run_command(login_cmd.format(u=oc_username, p=oc_password))
if result.failed:
logger.exception("OPENSHIFT: couldn't login to openshift %r", str(result))
raise
logger.info("looking for templates in destination dir {f}".format(f=dest_dir))
get_urls_cmd = 'find {d} -type f -name "cfme-openshift-*" -exec tail -1 {{}} \;'
result = ssh.run_command(get_urls_cmd.format(d=dest_dir))
if result.failed:
logger.exception("OPENSHIFT: couldn't get img stream urls %r", str(result))
raise
for img_url in str(result).split():
update_img_cmd = 'docker pull {url}'
logger.info("updating image stream to tag {t}".format(t=img_url))
result = ssh.run_command(update_img_cmd.format(url=img_url))
if result.failed:
logger.exception("OPENSHIFT: couldn't update image stream using url %r,"
"%r", img_url, str(result))
raise
if not provider_data:
logger.info("OPENSHIFT:%r Adding template %r to trackerbot", provider, name)
trackerbot.trackerbot_add_provider_template(stream, provider, name)
else:
logger.info("OPENSHIFT:%r template %r already exists", provider, name)
except Exception:
logger.exception('OPENSHIFT:%r Exception during upload_template', provider)
return False
finally:
logger.info("OPENSHIFT:%r End uploading Template: %r", provider, name)
def upload_template(client, hostname, username, password,
provider, url, name, provider_data, stream,
results):
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):
results[provider] = False
return
if name in client.list_template():
logger.info("VSPHERE:%r template %r already exists", provider, name)
else:
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)
results[provider] = False
return
if kwargs.get('disk'):
if not add_disk(client, name, provider):
logger.error('"VSPHERE:%r FAILED adding disk to VM, exiting', provider)
results[provider] = False
return
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)
results[provider] = False
return
if not provider_data:
logger.info("VSPHERE:%r Adding template %r to trackerbot", provider, name)
trackerbot.trackerbot_add_provider_template(stream, 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)
# If we get here without hitting an exception, we passed...
results[provider] = True
except Exception:
logger.exception('VSPHERE:%r Exception during upload_template', provider)
results[provider] = False
return
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, glance):
try:
logger.info("RHEVM:%r Template %r upload started", 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
qcowname = get_qcow_name(image_url)
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']
kwargs = update_params_api(api, **kwargs)
check_kwargs(**kwargs)
if api.templates.get(template_name) is not None:
logger.info("RHEVM:%r Found finished template with name %r.", provider, template_name)
logger.info("RHEVM:%r The script will now end.", provider)
return True
logger.info("RHEVM:%r Downloading .qcow2 file...", provider)
download_qcow(kwargs.get('image_url'))
try:
logger.info("RHEVM:%r Uploading template to Glance", provider)
glance_args = {'image': qcowname, 'image_name_in_glance': template_name,
'provider': glance, 'disk_format': 'qcow2'}
getattr(__import__('image_upload_glance'), "run")(**glance_args)
logger.info("RHEVM:%r Adding Glance", provider)
add_glance(api, provider, glance)
logger.info("RHEVM:%r Importing new template to data domain", provider)
import_template_from_glance(api, kwargs.get('sdomain'), kwargs.get('cluster'),
temp_template_name, glance, provider, template_name)
logger.info("RHEVM:%r Making a temporary VM from new template", provider)
make_vm_from_template(api, stream, cfme_data, kwargs.get('cluster'), temp_template_name,
temp_vm_name, provider, mgmt_network=kwargs.get('mgmt_network'))
logger.info("RHEVM:%r Adding disk to created VM", 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)
logger.info("RHEVM:%r Templatizing VM", provider)
templatize_vm(api, template_name, kwargs.get('cluster'), temp_vm_name, provider)
if not provider_data:
logger.info("RHEVM:%r Add template %r to trackerbot", provider, template_name)
trackerbot.trackerbot_add_provider_template(stream, provider, template_name)
finally:
cleanup(api, qcowname, provider, temp_template_name, temp_vm_name)
api.disconnect()
logger.info("RHEVM:%r Template %r upload Ended", provider, template_name)
if provider_data and api.templates.get(template_name):
logger.info("RHEVM:%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)
logger.info("RHEVM:%r Template %r upload Ended", provider, template_name)
except Exception:
logger.exception("RHEVM:%r Template %r upload exception", provider, template_name)
return False
def upload_template(rhevip, sshname, sshpass, username, password,
provider, image_url, template_name, provider_data, stream):
try:
logger.info("RHEVM:%r Template %r upload started", provider, template_name)
if provider_data:
kwargs = make_kwargs_rhevm(provider_data, provider)
providers = provider_data['management_systems']
mgmt = get_mgmt(kwargs.get('provider'), providers=providers)
else:
kwargs = make_kwargs_rhevm(cfme_data, provider)
mgmt = get_mgmt(kwargs.get('provider'))
kwargs['image_url'] = image_url
kwargs['template_name'] = template_name
ovaname = get_ova_name(image_url)
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(mgmt, kwargs.get('edomain'))
kwargs = update_params_api(mgmt, **kwargs)
check_kwargs(**kwargs)
if mgmt.does_template_exist(template_name):
logger.info("RHEVM:%r Found finished template with name %r.", provider, template_name)
logger.info("RHEVM:%r The script will now end.", provider)
return True
logger.info("RHEVM:%r Downloading .ova file...", provider)
with make_ssh_client(rhevip, sshname, sshpass) as ssh_client:
download_ova(ssh_client, kwargs.get('image_url'))
try:
logger.info("RHEVM:%r Templatizing .ova file", provider)
template_from_ova(mgmt, username, password, rhevip, kwargs.get('edomain'),
ovaname, ssh_client, temp_template_name, provider)
logger.info("RHEVM:%r Importing new template to data domain", provider)
import_template(mgmt, cfme_data, kwargs.get('edomain'), kwargs.get('sdomain'),
kwargs.get('cluster'), temp_template_name, provider)
logger.info("RHEVM:%r Making a temporary VM from new template", provider)
make_vm_from_template(mgmt, stream, cfme_data,
kwargs.get('cluster'),
temp_template_name, temp_vm_name, provider,
mgmt_network=kwargs.get('mgmt_network'))
logger.info("RHEVM:%r Adding disk to created VM", provider)
add_disk_to_vm(mgmt, kwargs.get('sdomain'), kwargs.get('disk_size'),
kwargs.get('disk_format'), kwargs.get('disk_interface'),
temp_vm_name, provider)
logger.info("RHEVM:%r Templatizing VM", provider)
templatize_vm(mgmt, template_name, kwargs.get('cluster'), temp_vm_name, provider)
if not provider_data:
logger.info("RHEVM:%r Add template %r to trackerbot", provider, template_name)
trackerbot.trackerbot_add_provider_template(stream, provider, template_name)
finally:
cleanup(mgmt, kwargs.get('edomain'), ssh_client, ovaname, provider,
temp_template_name, temp_vm_name)
change_edomain_state(mgmt, 'maintenance', kwargs.get('edomain'), provider)
cleanup_empty_dir_on_edomain(path, edomain_ip,
sshname, sshpass, rhevip, provider)
change_edomain_state(mgmt, 'active', kwargs.get('edomain'), provider)
mgmt.disconnect()
logger.info("RHEVM:%r Template %r upload Ended", provider, template_name)
if provider_data and mgmt.does_template_exist(template_name):
logger.info("RHEVM:%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)
logger.info("RHEVM:%r Template %r upload Ended", provider, template_name)
except Exception:
logger.exception("RHEVM:%r Template %r upload exception", provider, template_name)
return False
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
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:%s Make Template out of the VHD %s", 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:%s Template Library: %s", 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:%s Uploading VHD image to Library VHD folder.",
provider)
upload_vhd(client, url, library, new_vhd_name)
if kwargs.get('template'):
logger.info("SCVMM:%s Make Template out of the VHD %s",
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:%s template %s uploaded success", provider,
new_template_name)
logger.info("SCVMM:%s Add template %s to trackerbot", provider,
new_template_name)
trackerbot.trackerbot_add_provider_template(
kwargs.get('stream'), provider,
kwargs.get('template_name'))
except Exception:
logger.exception(
"SCVMM:%s Exception verifying the template %s", provider,
new_template_name)
else:
logger.info(
"SCVMM: A Template with that name already exists in the SCVMMLibrary"
)
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
def track_template(self, *args, **kwargs):
trackerbot.trackerbot_add_provider_template(*args, **kwargs)
return True
def track_template(self, *args, **kwargs):
trackerbot.trackerbot_add_provider_template(*args, **kwargs)
return True
def upload_template(hostname, username, password, provider, url, name, provider_data,
stream, upload_folder, oc_username, oc_password):
try:
kwargs = {}
if name is None:
name = cfme_data['basic_info']['appliance_template']
logger.info("OPENSHIFT:%r Start uploading Template: %r", provider, name)
if not check_kwargs(**kwargs):
return False
logger.info("checking whether this template is already present in provider env")
if name not in list_templates(hostname, username, password, upload_folder):
with SSHClient(hostname=hostname, username=username, password=password) as ssh:
# creating folder to store template files
dest_dir = os.path.join(upload_folder, name)
logger.info("creating folder for templates: {f}".format(f=dest_dir))
result = ssh.run_command('mkdir {dir}'.format(dir=dest_dir))
if result.failed:
err_text = "OPENSHIFT: cant create folder {}".format(str(result))
logger.exception(err_text)
raise RuntimeError(err_text)
download_cmd = ('wget -q --no-parent --no-directories --reject "index.html*" '
'--directory-prefix={dir} -r {url}')
logger.info("downloading templates to destination dir {f}".format(f=dest_dir))
result = ssh.run_command(download_cmd.format(dir=dest_dir, url=url))
if result.failed:
err_text = "OPENSHIFT: cannot download template {}".format(str(result))
logger.exception(err_text)
raise RuntimeError(err_text)
# updating image streams in openshift
logger.info("logging in to openshift")
login_cmd = 'oc login --username={u} --password={p}'
result = ssh.run_command(login_cmd.format(u=oc_username, p=oc_password))
if result.failed:
err_text = "OPENSHIFT: couldn't login to openshift {}".format(str(result))
logger.exception(err_text)
raise RuntimeError(err_text)
logger.info("looking for templates in destination dir {f}".format(f=dest_dir))
get_urls_cmd = 'find {d} -type f -name "cfme-openshift-*" -exec tail -1 {{}} \;'
result = ssh.run_command(get_urls_cmd.format(d=dest_dir))
if result.failed:
err_text = "OPENSHIFT: couldn't get img stream urls {}".format(str(result))
logger.exception(err_text)
raise RuntimeError(err_text)
tags = {}
for img_url in str(result).split():
update_img_cmd = 'docker pull {url}'
logger.info("updating image stream to tag {t}".format(t=img_url))
result = ssh.run_command(update_img_cmd.format(url=img_url))
# url ex:
# brew-pulp-docker01.web.prod.ext.phx2.redhat.com:8888/cloudforms46/cfme-openshift-httpd:2.4.6-14
tag_name, tag_value = img_url.split('/')[-1].split(':')
tag_url = img_url.rpartition(':')[-1]
tags[tag_name] = {'tag': tag_value, 'url': tag_url}
if result.failed:
err_text = ("OPENSHIFT: couldn't update image stream using url "
"{}, {}".format(img_url, str(result)))
logger.exception(err_text)
raise RuntimeError(err_text)
logger.info('updating templates before upload to openshift')
# updating main template file, adding essential patches
main_template_file = 'cfme-template.yaml'
main_template = os.path.join(dest_dir, main_template_file)
default_template_name = 'cloudforms'
new_template_name = name
logger.info('removing old templates from ocp if those exist')
for template in (default_template_name, new_template_name):
if ssh.run_command('oc get template {t} '
'--namespace=openshift'.format(t=template)).success:
ssh.run_command('oc delete template {t} '
'--namespace=openshift'.format(t=template))
logger.info('changing template name to unique one')
change_name_cmd = """python -c 'import yaml
data = yaml.safe_load(open("{file}"))
data["metadata"]["name"] = "{new_name}"
yaml.safe_dump(data, stream=open("{file}", "w"))'""".format(new_name=new_template_name,
file=main_template)
# our templates always have the same name but we have to keep many templates
# of the same stream. So we have to change template name before upload to ocp
# in addition, openshift doesn't provide any convenient way to change template name
logger.info(change_name_cmd)
result = ssh.run_command(change_name_cmd)
if result.failed:
err_text = "OPENSHIFT: couldn't change default template name"
logger.exception(err_text)
raise RuntimeError(err_text)
logger.info("uploading main template to ocp")
result = ssh.run_command('oc create -f {t} '
'--namespace=openshift'.format(t=main_template))
if result.failed:
err_text = "OPENSHIFT: couldn't upload template to openshift"
logger.exception(err_text)
raise RuntimeError(err_text)
if not provider_data:
logger.info("OPENSHIFT:%r Adding template %r to trackerbot", provider, name)
trackerbot.trackerbot_add_provider_template(stream=stream,
provider=provider,
template_name=name,
custom_data={'TAGS': tags})
logger.info("upload has been finished successfully")
else:
logger.info("OPENSHIFT:%r template %r already exists", provider, name)
except Exception:
logger.exception('OPENSHIFT:%r Exception during upload_template', provider)
return False
finally:
logger.info("OPENSHIFT:%r End uploading Template: %r", provider, name)
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 list_provider_keys("ec2")
if ('disabled' not in mgmt_sys[prov_key]['tags'] and
not mgmt_sys[prov_key].get('template_upload', {}).get('block_upload', False))
]
if valid_providers:
logger.info("Uploading to following enabled ec2 providers/regions: %r", valid_providers)
else:
logger.info('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:
logger.info('ERROR: Already multiple images with name "%r"', ami_name)
return
if ami_id:
# TODO roll this into a flag that copies it to regions without it
logger.info('EC2 %r: AMI already exists with name "%r"', 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:
logger.info('DONE: No templates to upload, all regions have the ami: "%r"', ami_name)
return
# download image
logger.info("INFO: Starting image download %r ...", kwargs.get('image_url'))
file_name, file_path = download_image_file(image_url)
logger.info("INFO: Image downloaded %r ...", 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')
logger.info('EC2:%r:%r Starting S3 upload of %r', 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
logger.info("EC2:%r:%r Adding template %r to trackerbot for stream %r",
prov_key, region, ami_name, stream)
trackerbot.trackerbot_add_provider_template(stream, prov_key, ami_name)
logger.info('EC2:%r:%r Template %r creation complete', prov_key, region, ami_name)
def run(**kwargs):
for provider in list_provider_keys("scvmm"):
# skip provider if block_upload is set
if (cfme_data[provider].get('template_upload') and
cfme_data[provider]['template_upload'].get('block_upload')):
logger.info('Skipping upload on {} due to block_upload'.format(provider))
continue
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:%s Make Template out of the VHD %s", 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:%s Template Library: %s", 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:%s Uploading VHD image to Library VHD folder.", provider)
upload_vhd(client, url, library, new_vhd_name)
if kwargs.get('template'):
logger.info("SCVMM:%s Make Template out of the VHD %s", 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:%s template %s uploaded success", provider, new_template_name)
logger.info("SCVMM:%s Add template %s to trackerbot", provider, new_template_name)
trackerbot.trackerbot_add_provider_template(kwargs.get('stream'),
provider,
kwargs.get('template_name'))
except Exception:
logger.exception("SCVMM:%s Exception verifying the template %s",
provider, new_template_name)
else:
logger.info("SCVMM: A Template with that name already exists in the SCVMMLibrary")
def track_template(self):
trackerbot.trackerbot_add_provider_template(self.stream, self.provider,
self.template_name)
return True
def track_template(self, **kwargs):
trackerbot.trackerbot_add_provider_template(self.stream,
self.provider_key,
self.template_name,
**kwargs)
return True
def upload_template(rhevip, sshname, sshpass, username, password, provider,
image_url, template_name, provider_data, stream, glance):
try:
logger.info("RHEVM:%r Template %r upload started", 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
qcowname = get_qcow_name(image_url)
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']
kwargs = update_params_api(api, **kwargs)
check_kwargs(**kwargs)
if api.templates.get(template_name) is not None:
logger.info("RHEVM:%r Found finished template with name %r.",
provider, template_name)
logger.info("RHEVM:%r The script will now end.", provider)
return True
logger.info("RHEVM:%r Downloading .qcow2 file...", provider)
download_qcow(kwargs.get('image_url'))
try:
logger.info("RHEVM:%r Uploading template to Glance", provider)
glance_args = {
'image': qcowname,
'image_name_in_glance': template_name,
'provider': glance,
'disk_format': 'qcow2'
}
getattr(__import__('image_upload_glance'), "run")(**glance_args)
logger.info("RHEVM:%r Adding Glance", provider)
add_glance(api, provider, glance)
logger.info("RHEVM:%r Importing new template to data domain",
provider)
import_template_from_glance(api, kwargs.get('sdomain'),
kwargs.get('cluster'),
temp_template_name, glance, provider,
template_name)
logger.info("RHEVM:%r Making a temporary VM from new template",
provider)
make_vm_from_template(api,
stream,
cfme_data,
kwargs.get('cluster'),
temp_template_name,
temp_vm_name,
provider,
mgmt_network=kwargs.get('mgmt_network'))
logger.info("RHEVM:%r Adding disk to created VM", 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)
logger.info("RHEVM:%r Templatizing VM", provider)
templatize_vm(api, template_name, kwargs.get('cluster'),
temp_vm_name, provider)
if not provider_data:
logger.info("RHEVM:%r Add template %r to trackerbot", provider,
template_name)
trackerbot.trackerbot_add_provider_template(
stream, provider, template_name)
finally:
cleanup(api, qcowname, provider, temp_template_name, temp_vm_name)
api.disconnect()
logger.info("RHEVM:%r Template %r upload Ended", provider,
template_name)
if provider_data and api.templates.get(template_name):
logger.info("RHEVM:%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)
logger.info("RHEVM:%r Template %r upload Ended", provider,
template_name)
except Exception:
logger.exception("RHEVM:%r Template %r upload exception", provider,
template_name)
return False
def create_template(provider, **kwargs):
mgmt_sys = cfme_data['management_systems'][provider]
host_fqdn = mgmt_sys['hostname_fqdn']
creds = credentials[mgmt_sys['credentials']]
kwargs = make_kwargs_scvmm(
cfme_data, provider, kwargs.get('image_url'), kwargs.get('template_name'))
check_kwargs(**kwargs)
# 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 = '{}\\{}'.format(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:%s Make Template out of the VHD %s", 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'))
db_disk = kwargs.get('db_disk', mgmt_sys['template_upload'].get('db_disk'))
logger.info("SCVMM:%s Template Library: %s", provider, library)
# The VHD name changed, match the template_name.
new_vhd_name = '{}.vhd'.format(new_template_name)
network = mgmt_sys['template_upload'].get('network')
os_type = mgmt_sys['template_upload'].get('os_type')
cores = mgmt_sys['template_upload'].get('cores')
ram = mgmt_sys['template_upload'].get('ram')
# Uses PowerShell Get-SCVMTemplate to return a list of templates and aborts if exists.
if client.does_template_exist(new_template_name):
logger.info("SCVMM: A Template with that name already exists in the SCVMMLibrary")
else:
if kwargs.get('upload'):
logger.info("SCVMM:%s Uploading VHD image to Library VHD folder.", provider)
upload_vhd(client, url, library, new_vhd_name)
if kwargs.get('template'):
logger.info("SCVMM:%s Make Template out of the VHD %s", provider, new_template_name)
make_template(
client,
host_fqdn,
new_template_name,
library,
network,
os_type,
username_scvmm,
cores,
ram,
db_disk,
)
wait_for(lambda: client.does_template_exist(new_template_name), delay=5, num_sec=600)
# end else
template_name = kwargs.get('template_name')
if template_name:
logger.info("SCVMM:%s Add template %s to trackerbot", provider, template_name)
trackerbot.trackerbot_add_provider_template(kwargs.get('stream'), provider, template_name)
def upload_template(rhevip, sshname, sshpass, username, password, provider,
image_url, template_name, provider_data, stream):
try:
logger.info("RHEVM:%r Template %r upload started", provider,
template_name)
if provider_data:
kwargs = make_kwargs_rhevm(provider_data, provider)
providers = provider_data['management_systems']
mgmt = get_mgmt(kwargs.get('provider'), providers=providers)
else:
kwargs = make_kwargs_rhevm(cfme_data, provider)
mgmt = get_mgmt(kwargs.get('provider'))
kwargs['image_url'] = image_url
kwargs['template_name'] = template_name
ovaname = get_ova_name(image_url)
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(mgmt, kwargs.get('edomain'))
kwargs = update_params_api(mgmt, **kwargs)
check_kwargs(**kwargs)
if mgmt.does_template_exist(template_name):
logger.info("RHEVM:%r Found finished template with name %r.",
provider, template_name)
logger.info("RHEVM:%r The script will now end.", provider)
return True
logger.info("RHEVM:%r Downloading .ova file...", provider)
with make_ssh_client(rhevip, sshname, sshpass) as ssh_client:
download_ova(ssh_client, kwargs.get('image_url'))
try:
logger.info("RHEVM:%r Templatizing .ova file", provider)
template_from_ova(mgmt, username, password, rhevip,
kwargs.get('edomain'), ovaname, ssh_client,
temp_template_name, provider)
logger.info("RHEVM:%r Importing new template to data domain",
provider)
import_template(mgmt, cfme_data, kwargs.get('edomain'),
kwargs.get('sdomain'), kwargs.get('cluster'),
temp_template_name, provider)
logger.info("RHEVM:%r Making a temporary VM from new template",
provider)
make_vm_from_template(mgmt,
stream,
cfme_data,
kwargs.get('cluster'),
temp_template_name,
temp_vm_name,
provider,
mgmt_network=kwargs.get('mgmt_network'))
logger.info("RHEVM:%r Adding disk to created VM", provider)
add_disk_to_vm(mgmt, kwargs.get('sdomain'),
kwargs.get('disk_size'),
kwargs.get('disk_format'),
kwargs.get('disk_interface'), temp_vm_name,
provider)
logger.info("RHEVM:%r Templatizing VM", provider)
templatize_vm(mgmt, template_name, kwargs.get('cluster'),
temp_vm_name, provider)
if not provider_data:
logger.info("RHEVM:%r Add template %r to trackerbot",
provider, template_name)
trackerbot.trackerbot_add_provider_template(
stream, provider, template_name)
finally:
cleanup(mgmt, kwargs.get('edomain'), ssh_client, ovaname,
provider, temp_template_name, temp_vm_name)
change_edomain_state(mgmt, 'maintenance',
kwargs.get('edomain'), provider)
cleanup_empty_dir_on_edomain(path, edomain_ip, sshname,
sshpass, rhevip, provider)
change_edomain_state(mgmt, 'active', kwargs.get('edomain'),
provider)
mgmt.disconnect()
logger.info("RHEVM:%r Template %r upload Ended", provider,
template_name)
if provider_data and mgmt.does_template_exist(template_name):
logger.info("RHEVM:%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)
logger.info("RHEVM:%r Template %r upload Ended", provider,
template_name)
except Exception:
logger.exception("RHEVM:%r Template %r upload exception", provider,
template_name)
return False
def track_template(self):
trackerbot.trackerbot_add_provider_template(self.stream, self.provider, self.template_name)
return True
