def delete_catalog_item(item_name):
org = Org(CLIENT, href=ORG_HREF)
try:
org.delete_catalog_item(CATALOG_NAME, item_name)
utils.wait_for_catalog_item_to_resolve(CLIENT, CATALOG_NAME, item_name,
org=org)
org.reload()
except EntityNotFoundException:
pass
def delete_catalog_item(item_name, logger=NULL_LOGGER):
logger.debug(f"Deleting catalog item: {item_name}")
org = Org(CLIENT, href=ORG_HREF)
try:
org.delete_catalog_item(CATALOG_NAME, item_name)
pyvcloud_utils.wait_for_catalog_item_to_resolve(CLIENT,
CATALOG_NAME,
item_name,
org=org)
org.reload()
logger.debug(f"Successfully deleted the catalog item: {item_name}")
except EntityNotFoundException as e:
logger.warning(f"Failed to delete catalog item {item_name}: {e}")
def delete_catalog_or_item(ctx, catalog_name, item_name):
try:
client = ctx.obj['client']
in_use_org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, in_use_org_href)
if item_name is None:
org.delete_catalog(catalog_name)
stdout('Catalog deleted.', ctx)
else:
org.delete_catalog_item(catalog_name, item_name)
stdout('Item deleted.', ctx)
except Exception as e:
stderr(e, ctx)
def delete_catalog_or_item(ctx, catalog_name, item_name):
try:
restore_session(ctx)
client = ctx.obj['client']
in_use_org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, in_use_org_href)
if item_name is None:
org.delete_catalog(catalog_name)
stdout('Catalog deleted.', ctx)
else:
org.delete_catalog_item(catalog_name, item_name)
stdout('Item deleted.', ctx)
except Exception as e:
stderr(e, ctx)
def delete(client, catalog_name, item_name):
logging.debug("===== delete ova to %s catalog called === \n",
catalog_name)
result = catalog_item_pb2.DeleteCatalogItemResult()
result.deleted = False
try:
logged_in_org = client.get_org()
org = Org(client, resource=logged_in_org)
org.delete_catalog_item(name=catalog_name, item_name=item_name)
result.deleted = True
return result
except Exception as e:
logging.warn("error occured", e)
return result
def delete(client, catalog_name, item_name):
logging.debug("===== delete ova to %s catalog called === \n",
catalog_name)
result = catalog_item_pb2.DeleteCatalogItemResult()
result.deleted = False
try:
logged_in_org = client.get_org()
org = Org(client, resource=logged_in_org)
org.delete_catalog_item(name=catalog_name, item_name=item_name)
result.deleted = True
return result
except Exception as e:
logging.warn("error occured", e)
return result
def uninstall_cse(ctx, config_file_name, template_name):
click.secho('Uninstalling CSE from vCD from file: %s, template: %s' %
(config_file_name, template_name))
config = get_config(config_file_name)
client = Client(
config['vcd']['host'],
api_version=config['vcd']['api_version'],
verify_ssl_certs=config['vcd']['verify'],
log_file='cse.log',
log_headers=True,
log_bodies=True)
client.set_credentials(
BasicLoginCredentials(config['vcd']['username'], 'System',
config['vcd']['password']))
click.echo('Connected to vCloud Director as system '
'administrator (%s:%s): %s' % (config['vcd']['host'],
config['vcd']['port'],
bool_to_msg(True)))
ctx.obj = {}
ctx.obj['client'] = client
if config['broker']['type'] == 'default':
ctx.obj = {}
ctx.obj['client'] = client
orgs = client.get_org_list()
for org in [o for o in orgs.Org if hasattr(orgs, 'Org')]:
if org.get('name') == config['broker']['org']:
org_href = org.get('href')
org = Org(client, href=org_href)
click.echo('Find org \'%s\': %s' % (org.get_name(), bool_to_msg(True)))
vdc_resource = org.get_vdc(config['broker']['vdc'])
click.echo('Find vdc \'%s\': %s' % (vdc_resource.get('name'),
bool_to_msg(True)))
vdc = VDC(client, resource=vdc_resource)
assert vdc
for template in config['broker']['templates']:
if template_name == '*' or template['name'] == template_name:
click.secho('Deleting template: %s (%s:%s)' %
(template['name'], config['broker']['catalog'],
template['catalog_item']))
org.delete_catalog_item(config['broker']['catalog'],
template['catalog_item'])
class CatalogItem(VcdAnsibleModule):
def __init__(self, **kwargs):
super(CatalogItem, self).__init__(**kwargs)
logged_in_org = self.client.get_org()
self.org = Org(self.client, resource=logged_in_org)
def manage_states(self):
state = self.params.get('state')
if state == "present":
return self.upload()
if state == "absent":
return self.delete()
def manage_operations(self):
operation = self.params.get('operation')
if operation == "capturevapp":
return self.capture_vapp()
if operation == "list_vms":
return self.list_vms()
def is_present(self):
params = self.params
catalog_name = params.get('catalog_name')
item_name = params.get('item_name')
try:
self.org.get_catalog_item(catalog_name, item_name)
except EntityNotFoundException:
return False
return True
def upload(self):
params = self.params
catalog_name = params.get('catalog_name')
item_name = params.get('item_name')
file_name = params.get('file_name')
chunk_size = params.get('chunk_size')
response = dict()
response['changed'] = False
item_details = {
"catalog_name": catalog_name,
"item_name": item_name,
"file_name": file_name,
"chunk_size": chunk_size
}
if self.is_present():
response['warnings'] = "Catalog Item {} is already present.".format(item_name)
return response
if file_name.endswith(".ova") or file_name.endswith(".ovf"):
self.org.upload_ovf(**item_details)
self.ova_check_resolved()
if not file_name.endswith(".ova"):
self.org.upload_media(**item_details)
response['msg'] = "Catalog item {} is uploaded.".format(item_name)
response['changed'] = True
return response
def delete(self):
params = self.params
catalog_name = params.get('catalog_name')
item_name = params.get('item_name')
response = dict()
response['changed'] = False
if not self.is_present():
response['warnings'] = "Catalog Item {} is not present.".format(item_name)
return response
self.org.delete_catalog_item(name=catalog_name, item_name=item_name)
response['msg'] = "Catalog Item {} has been deleted.".format(item_name)
response['changed'] = True
return response
def capture_vapp(self):
params = self.params
vapp_name = params.get('vapp_name')
vdc_name = params.get('vdc_name')
catalog_name = params.get('catalog_name')
item_name = params.get('item_name')
desc = params.get('description')
customize_on_instantiate = params.get('customize_on_instantiate')
overwrite = params.get('overwrite')
client = self.client
response = dict()
response['changed'] = False
v = self.org.get_vdc(vdc_name)
vdc = VDC(client, href=v.get('href'))
vapp = vdc.get_vapp(vapp_name)
catalog = self.org.get_catalog(catalog_name)
self.org.capture_vapp(
catalog_resource=catalog,
vapp_href=vapp.get('href'),
catalog_item_name=item_name,
description=desc,
customize_on_instantiate=customize_on_instantiate,
overwrite=overwrite)
self.ova_check_resolved()
response['msg'] = "Catalog Item {} has been captured".format(item_name)
response['changed'] = True
return response
def ova_check_resolved(self):
params = self.params
catalog_name = params.get('catalog_name')
item_name = params.get('item_name')
response = False
source_ova_item = self.org.get_catalog_item(catalog_name, item_name)
self.check_resolved(source_ova_item, catalog_name, item_name)
response = True
return response
def check_resolved(self, source_ova_item, catalog_name, item_name):
client = self.client
item_id = source_ova_item.get('id')
while True:
q = client.get_typed_query(
'catalogItem',
query_result_format=QueryResultFormat.ID_RECORDS,
qfilter='id==%s' % item_id
)
records = list(q.execute())
if records[0].get('status') == 'RESOLVED':
break
else:
time.sleep(5)
# TODO might have to check when status goes to other state than resolved
def list_vms(self):
params = self.params
catalog_name = params.get('catalog_name')
item_name = params.get('item_name')
response = dict()
result = list()
response['changed'] = False
catalog_item = self.org.get_catalog_item(catalog_name, item_name)
vapp_template_resource = self.client.get_resource(
catalog_item.Entity.get('href'))
vapp_template = VApp(self.client, name=item_name, resource=vapp_template_resource)
for vm in vapp_template.get_all_vms():
result.append(vm.get('name'))
response['msg'] = result
response['changed'] = False
return response
class CatalogItem(VcdAnsibleModule):
def __init__(self, **kwargs):
super(CatalogItem, self).__init__(**kwargs)
logged_in_org = self.client.get_org()
self.org = Org(self.client, resource=logged_in_org)
def manage_states(self):
state = self.params.get('state')
if state == "present":
return self.upload()
if state == "absent":
return self.delete()
def manage_operations(self):
operation = self.params.get('operation')
if operation == "capturevapp":
return self.capture_vapp()
if operation == "list_vms":
return self.list_vms()
def is_present(self):
params = self.params
catalog_name = params.get('catalog_name')
item_name = params.get('item_name')
try:
self.org.get_catalog_item(catalog_name, item_name)
except EntityNotFoundException:
return False
return True
def upload(self):
params = self.params
catalog_name = params.get('catalog_name')
item_name = params.get('item_name')
file_name = params.get('file_name')
chunk_size = params.get('chunk_size')
response = dict()
response['changed'] = False
item_details = {
"catalog_name": catalog_name,
"item_name": item_name,
"file_name": file_name,
"chunk_size": chunk_size
}
if self.is_present():
response['warnings'] = "Catalog Item {} is already present.".format(item_name)
return response
if file_name.endswith(".ova") or file_name.endswith(".ovf"):
self.org.upload_ovf(**item_details)
self.ova_check_resolved()
if not file_name.endswith(".ova"):
self.org.upload_media(**item_details)
response['msg'] = "Catalog item {} is uploaded.".format(item_name)
response['changed'] = True
return response
def delete(self):
params = self.params
catalog_name = params.get('catalog_name')
item_name = params.get('item_name')
response = dict()
response['changed'] = False
if not self.is_present():
response['warnings'] = "Catalog Item {} is not present.".format(item_name)
return response
self.org.delete_catalog_item(name=catalog_name, item_name=item_name)
response['msg'] = "Catalog Item {} has been deleted.".format(item_name)
response['changed'] = True
return response
def capture_vapp(self):
params = self.params
vapp_name = params.get('vapp_name')
vdc_name = params.get('vdc_name')
catalog_name = params.get('catalog_name')
item_name = params.get('item_name')
desc = params.get('description')
customize_on_instantiate = params.get('customize_on_instantiate')
overwrite = params.get('overwrite')
client = self.client
response = dict()
response['changed'] = False
v = self.org.get_vdc(vdc_name)
vdc = VDC(client, href=v.get('href'))
vapp = vdc.get_vapp(vapp_name)
catalog = self.org.get_catalog(catalog_name)
self.org.capture_vapp(
catalog_resource=catalog,
vapp_href=vapp.get('href'),
catalog_item_name=item_name,
description=desc,
customize_on_instantiate=customize_on_instantiate,
overwrite=overwrite)
self.ova_check_resolved()
response['msg'] = "Catalog Item {} has been captured".format(item_name)
response['changed'] = True
return response
def ova_check_resolved(self):
params = self.params
catalog_name = params.get('catalog_name')
item_name = params.get('item_name')
response = False
source_ova_item = self.org.get_catalog_item(catalog_name, item_name)
self.check_resolved(source_ova_item, catalog_name, item_name)
response = True
return response
def check_resolved(self, source_ova_item, catalog_name, item_name):
client = self.client
item_id = source_ova_item.get('id')
while True:
q = client.get_typed_query(
'catalogItem',
query_result_format=QueryResultFormat.ID_RECORDS,
qfilter='id==%s' % item_id
)
records = list(q.execute())
if records[0].get('status') == 'RESOLVED':
break
else:
time.sleep(5)
# TODO might have to check when status goes to other state than resolved
def list_vms(self):
params = self.params
catalog_name = params.get('catalog_name')
item_name = params.get('item_name')
response = dict()
result = list()
response['changed'] = False
catalog_item = self.org.get_catalog_item(catalog_name, item_name)
vapp_template_resource = self.client.get_resource(
catalog_item.Entity.get('href'))
vapp_template = VApp(self.client, name=item_name, resource=vapp_template_resource)
for vm in vapp_template.get_all_vms():
result.append(vm.get('name'))
response['msg'] = result
response['changed'] = False
return response
class OVFUploader(object):
""" Class to convert input image into OVF format """
def __init__(self,
ovf_file,
vcd_url=None,
username=None,
password=None,
orgname=None):
self.ovf_file = os.path.abspath(ovf_file)
self.vcd_url = vcd_url
self.username = username
self.password = password
self.orgname = orgname
try:
client = Client(self.vcd_url,
verify_ssl_certs=False,
api_version=ApiVersion.VERSION_32.value,
log_requests=True,
log_headers=True,
log_bodies=True,
log_file=LOG_FILE)
# sclient.set_highest_supported_version()
client.set_credentials(
BasicLoginCredentials(self.username, self.orgname,
self.password))
logger.info("Logged into {} using version {}".format(
self.vcd_url, client.get_api_version()))
self.client = client
self.org = Org(self.client, resource=self.client.get_org())
except Exception as exp:
problem = Exception(
"Failed to connect to vCD at {}, org {}, username {}:\n{}".
format(self.vcd_url, self.orgname, self.username, exp))
logger.error(problem)
raise problem
try:
# Retrieve the VM name from the OVF. We will use this as both the image and catalog name
OVF_tree = etree.parse(self.ovf_file)
root = OVF_tree.getroot()
nsmap = {k: v for k, v in root.nsmap.items() if k}
nsmap["xmlns"] = "http://schemas.dmtf.org/ovf/envelope/1"
virtuasystem = root.find('xmlns:VirtualSystem', nsmap)
name_tag = virtuasystem.find('xmlns:Name', nsmap)
self.image_name = name_tag.text
info_tag = virtuasystem.find('xmlns:Info', nsmap)
self.image_description = info_tag.text
references = root.find('xmlns:References', nsmap)
file = references.find('xmlns:File', nsmap)
self.vmdk_file = "{}/{}".format(
os.path.dirname(self.ovf_file),
file.attrib['{http://schemas.dmtf.org/ovf/envelope/1}href'])
logger.info("Loaded VM {}: {}".format(self.image_name,
self.image_description))
except Exception as exp:
problem = Exception(
"Failed to fetch VirtualSystem Name element from OVF {}:\n{}".
format(self.ovf_file, exp))
logger.error(problem)
raise problem
def make_catalog(self):
self.catalog_id = None
try:
for catalog in self.org.list_catalogs():
if catalog['name'] == self.image_name:
self.catalog_id = catalog['id']
if self.catalog_id is None:
logger.info("Creating a new catalog entry {} in vCD".format(
self.image_name))
result = self.org.create_catalog(self.image_name,
self.image_description)
if result is None:
raise Exception("Failed to create new catalog entry")
self.catalog_id = result.attrib['id'].split(':')[-1]
self.org.reload()
logger.debug("Using catalog {}, id {}".format(
self.image_name, self.catalog_id))
except Exception as exp:
problem = Exception("Failed to fetch catalog for {}:\n{} ".format(
self.image_name, exp))
logger.error(problem)
raise problem
def upload_ovf(self):
ova_tarfilename, _ = os.path.splitext(self.ovf_file)
ova_tarfilename += '.ova'
try:
# Check if the content already exists:
resource_type = ResourceType.CATALOG_ITEM.value
q = self.client.get_typed_query(
resource_type,
query_result_format=QueryResultFormat.ID_RECORDS,
equality_filter=('catalogName', self.image_name))
for item in list(q.execute()):
if item.get('name') == self.image_name:
logger.info("Removing old version from catalog")
try:
self.org.delete_catalog_item(self.image_name,
self.image_name)
except InternalServerException as exp:
problem = Exception(
"Cannot delete vAppTemplate {}. Please check in vCD if "
"the content is still being imported into the catalog"
.format(self.image_name))
raise problem
# Create a single OVA bundle
ova = tarfile.open(name=ova_tarfilename, mode='w')
ova.add(self.ovf_file, arcname=os.path.basename(self.ovf_file))
ova.add(self.vmdk_file, arcname=os.path.basename(self.vmdk_file))
ova.close()
logger.info("Uploading content to vCD")
self.org.upload_ovf(self.image_name,
ova_tarfilename,
item_name=self.image_name,
description=self.image_description,
callback=report_progress)
except Exception as exp:
problem = Exception("Failed to upload OVF {}:\n{} ".format(
self.ovf_file, exp))
logger.error(problem)
raise problem
finally:
if os.path.exists(ova_tarfilename):
os.remove(ova_tarfilename)
def wait_for_task_completion(self):
logger.info("Importing content to vCD")
try:
query = self.client.get_typed_query(
query_type_name=ResourceType.TASK.value,
qfilter='ownerName==' + self.username +
';(status==queued,status==preRunning,status==running)',
query_result_format=QueryResultFormat.REFERENCES)
upload_task = None
tasks = list(query.execute())
for task in tasks:
if task.get('name') == 'VDC_UPLOAD_OVF_CONTENTS':
upload_task = self.client.get_resource(task.get('href'))
break
bad_statuses = [
TaskStatus.ABORTED, TaskStatus.CANCELED, TaskStatus.ERROR
]
except Exception as exp:
problem = Exception("Failed to import OVF {}:\n{} ".format(
self.ovf_file, exp))
logger.error(problem)
raise problem
while (True):
task_status = upload_task.get('status').lower()
if (hasattr(upload_task, 'Progress')):
print("{}% complete \r".format(upload_task.Progress), end='')
for status in bad_statuses:
if task_status == status.value.lower():
problem = Exception(
"vCD failed to import OVF {}:\n{}: {} ".format(
self.ovf_file, task_status,
upload_task.Error.get('Message')))
logger.error(problem)
raise problem
if task_status == str(TaskStatus.SUCCESS.value).lower():
break
time.sleep(2)
upload_task = self.client.get_resource(upload_task.get('href'))
logger.info("OVF upload and import complete, content is ready to use")
