def read(client, context, name):
#logging.basicConfig(level=logging.DEBUG)
logging.debug("__INIT__read[catalog]__ %s", name)
logging.debug("catalog_name %s", name)
try:
logged_in_org = client.get_org()
org = Org(client, resource=logged_in_org)
result = pyvcloudprovider_pb2.ReadCatalogResult()
result.present = False
try:
catalog = org.get_catalog(name)
logging.info(vars(catalog))
logging.info("\n==desc=[%s]", catalog.Description)
result.name = str(catalog.get("name"))
result.description = str(catalog.Description)
result.shared = catalog.IsPublished
result.present = True
except Exception as e:
logging.warning(
"__ERROR__ while reading catalog[{0}]. __ERROR_MESSAGE__[{1}]".
format(name, str(e)))
return result
except Exception as e:
logging.error(
"__ERROR__ while reading catalog[{0}]. __ERROR_MESSAGE__[{1}]".
format(name, str(e)))
raise
def read(client, name):
#logging.basicConfig(level=logging.DEBUG)
logging.debug("===__INIT__===catalog_is_present %s", name)
try:
logged_in_org = client.get_org()
org = Org(client, resource=logged_in_org)
result = pyvcloudprovider_pb2.ReadCatalogResult()
result.present = False
try:
catalog = org.get_catalog(name)
logging.info(vars(catalog))
logging.info("\n==desc=[%s]", catalog.Description)
#for i in inspect.getmembers(catalog):
# print(i)
#ogging.info(description)
result.description = str(catalog.Description)
result.present = True
except Exception as e:
print(e)
logging.warn(e)
logging.info("catalog is not present")
return result
except Exception as e:
logging.warn("===__ERROR__=== ....__catalog_is_present ERROR occured",
e)
raise
def info(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:
catalog = org.get_catalog(catalog_name)
result = to_dict(catalog)
# We don't have a way to know in advance if a user has access to a
# catalog's ACL or not. So we try to retrieve it always. If the
# call fails due to permission issues, we silently eat the
# exception and exclude ACL settings from the output of the current
# command. Users who have access to ACL of the catalog will remain
# unaffected. Also any other errors/exceptions will bubble up as
# usual.
try:
access_control_settings = access_settings_to_dict(
org.get_catalog_access_settings(catalog_name))
result.update(access_control_settings)
except AccessForbiddenException as e:
pass
else:
catalog_item = org.get_catalog_item(catalog_name, item_name)
result = to_dict(catalog_item)
vapp = VApp(client, href=catalog_item.Entity.get('href'))
vapp.reload()
template = vapp_to_dict(vapp.resource)
for k, v in template.items():
result['template-%s' % k] = v
stdout(result, ctx)
except Exception as e:
stderr(e, ctx)
def info(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:
catalog = org.get_catalog(catalog_name)
result = to_dict(catalog)
# We don't have a way to know in advance if a user has access to a
# catalog's ACL or not. So we try to retrieve it always. If the
# call fails due to permission issues, we silently eat the
# exception and exclude ACL settings from the output of the current
# command. Users who have access to ACL of the catalog will remain
# unaffected. Also any other errors/exceptions will bubble up as
# usual.
try:
access_control_settings = access_settings_to_dict(
org.get_catalog_access_settings(catalog_name))
result.update(access_control_settings)
except AccessForbiddenException as e:
pass
else:
catalog_item = org.get_catalog_item(catalog_name, item_name)
result = to_dict(catalog_item)
vapp = VApp(client, href=catalog_item.Entity.get('href'))
vapp.reload()
template = vapp_to_dict(vapp.resource)
for k, v in template.items():
result['template-%s' % k] = v
stdout(result, ctx)
except Exception as e:
stderr(e, ctx)
def capture(ctx, name, catalog, template, customizable, description):
try:
restore_session(ctx, vdc_required=True)
client = ctx.obj['client']
in_use_org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, in_use_org_href)
catalog_resource = org.get_catalog(catalog)
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
vapp_resource = vdc.get_vapp(name)
overwrite = False
if template is None:
template = vapp_resource.get('name')
else:
overwrite = True
task = org.capture_vapp(
catalog_resource,
vapp_href=vapp_resource.get('href'),
catalog_item_name=template,
description=description,
customize_on_instantiate=customizable == 'customizable',
overwrite=overwrite)
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
def capture_vapp(client, context, capture_info):
logging.debug("__INIT__capture_vapp [%s]", capture_info)
vapp_name = capture_info.vapp_name
vdc_name = capture_info.vdc_name
catalog_name = capture_info.catalog_name
item_name = capture_info.item_name
desc = capture_info.description
customize_on_instantiate = capture_info.customize_on_instantiate
result = catalog_item_pb2.CaptureVAppResult()
try:
logged_in_org = client.get_org()
org = Org(client, resource=logged_in_org)
v = org.get_vdc(vdc_name)
if v is None:
raise errors.VDCNotFoundError(vappInfo.vdc)
vdc = VDC(client, href=v.get('href'))
vapp = vdc.get_vapp(vapp_name)
logging.info(vapp.get('href'))
catalog = org.get_catalog(catalog_name)
org.capture_vapp(catalog_resource=catalog,
vapp_href=vapp.get('href'),
catalog_item_name=item_name,
description=desc,
customize_on_instantiate=customize_on_instantiate)
result.captured = True
logging.debug("__DONE__capture_vapp [%s] , [%s] , [%s] ", vapp_name,
vdc_name, catalog_name)
return result
except Exception as e:
error_message = 'ERROR.. capture vapp failed {0} {1} {2}'.format(
vapp_name, vdc_name, catalog_name)
logging.warn(error_message, e)
context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
context.set_details(error_message)
def read(client, context, name):
#logging.basicConfig(level=logging.DEBUG)
logging.debug("__INIT__read[catalog]__ %s", name)
logging.debug("catalog_name %s", name)
try:
logged_in_org = client.get_org()
org = Org(client, resource=logged_in_org)
result = pyvcloudprovider_pb2.ReadCatalogResult()
result.present = False
try:
catalog = org.get_catalog(name)
logging.info(vars(catalog))
logging.info("\n==desc=[%s]", catalog.Description)
result.name = str(catalog.get("name"))
result.description = str(catalog.Description)
result.shared = catalog.IsPublished
result.present = True
except Exception as e:
logging.warning(
"__ERROR__ while reading catalog[{0}]. __ERROR_MESSAGE__[{1}]".
format(name, str(e)))
return result
except Exception as e:
logging.error(
"__ERROR__ while reading catalog[{0}]. __ERROR_MESSAGE__[{1}]".
format(name, str(e)))
raise
def capture(ctx, name, catalog, template, customizable, description):
try:
restore_session(ctx, vdc_required=True)
client = ctx.obj['client']
in_use_org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, in_use_org_href)
catalog_resource = org.get_catalog(catalog)
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
vapp_resource = vdc.get_vapp(name)
overwrite = False
if template is None:
template = vapp_resource.get('name')
else:
overwrite = True
task = org.capture_vapp(
catalog_resource,
vapp_href=vapp_resource.get('href'),
catalog_item_name=template,
description=description,
customize_on_instantiate=customizable == 'customizable',
overwrite=overwrite)
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
def test_05_catalog_control_access_retrieval(self):
org_in_use = self.client.get_org_by_name(
self.config['vcd']['org_in_use'])
org = Org(self.client, resource=org_in_use)
catalog = org.get_catalog(self.config['vcd']['catalog'])
assert self.config['vcd']['catalog'] == catalog.get('name')
control_access = org.get_catalog_access_settings(catalog.get('name'))
assert len(control_access.AccessSettings.AccessSetting) == 3
def test_catalog_control_access_retrieval(self):
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
catalog = org.get_catalog(self.config['vcd']['catalog'])
assert self.config['vcd']['catalog'] == catalog.get('name')
control_access = org.get_catalog_access_control_settings(
catalog.get('name'))
assert control_access is not None
def test_05_catalog_control_access_retrieval(self):
org_in_use = self.client.get_org_by_name(
self.config['vcd']['org_in_use'])
org = Org(self.client, resource=org_in_use)
catalog = org.get_catalog(self.config['vcd']['catalog'])
assert self.config['vcd']['catalog'] == catalog.get('name')
control_access = org.get_catalog_access_settings(catalog.get('name'))
assert len(control_access.AccessSettings.AccessSetting) == 3
def validate_broker_config_content(config, client, template='*'):
from container_service_extension.config import bool_to_msg
logged_in_org = client.get_org()
org = Org(client, resource=logged_in_org)
org.get_catalog(config['broker']['catalog'])
click.echo('Find catalog \'%s\': %s' %
(config['broker']['catalog'], bool_to_msg(True)))
default_template_found = False
for t in config['broker']['templates']:
if template == '*' or template == t['name']:
click.secho('Validating template: %s' % t['name'])
if config['broker']['default_template'] == t['name']:
default_template_found = True
click.secho(' Is default template: %s' % True)
else:
click.secho(' Is default template: %s' % False)
org.get_catalog_item(config['broker']['catalog'],
t['catalog_item'])
click.echo('Find template \'%s\', \'%s\': %s' %
(config['broker']['catalog'], t['catalog_item'],
bool_to_msg(True)))
assert default_template_found
def capture_vapp(client):
logging.info('ok')
logged_in_org = client.get_org()
org = Org(client, resource=logged_in_org)
v = org.get_vdc('OVD2')
if v is None:
raise errors.VDCNotFoundError(vappInfo.vdc)
vdc = VDC(client, href=v.get('href'))
vapp = vdc.get_vapp('vappacc8')
logging.info(vapp.get('href'))
catalog = org.get_catalog('c1')
org.capture_vapp(catalog_resource=catalog,
vapp_href=vapp.get('href'),
catalog_item_name='captured',
description='captured',
customize_on_instantiate=False)
def capture_vapp(client):
logging.info('ok')
logged_in_org = client.get_org()
org = Org(client, resource=logged_in_org)
v = org.get_vdc('OVD2')
if v is None:
raise errors.VDCNotFoundError(vappInfo.vdc)
vdc = VDC(client, href=v.get('href'))
vapp = vdc.get_vapp('vappacc8')
logging.info(vapp.get('href'))
catalog = org.get_catalog('c1')
org.capture_vapp(
catalog_resource=catalog,
vapp_href=vapp.get('href'),
catalog_item_name='captured',
description='captured',
customize_on_instantiate=False)
def isPresent(client, name):
logging.basicConfig(level=logging.DEBUG)
logging.debug("=== isPresent called === \n")
try:
logged_in_org = client.get_org()
org = Org(client, resource=logged_in_org)
result = pyvcloudprovider_pb2.IsPresentCatalogResult()
result.present = False
try:
catalog = org.get_catalog(name)
result.present = True
except Exception as e:
logging.info("catalog is not present")
return result
except Exception as e:
logging.warn("=====>>>>>>> error occured", e)
def capture(ctx, name, catalog, template, customizable):
try:
client = ctx.obj['client']
in_use_org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, in_use_org_href)
catalog_resource = org.get_catalog(catalog)
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
vapp_resource = vdc.get_vapp(name)
if template is None:
template = vapp_resource.get('name')
task = org.capture_vapp(
catalog_resource,
vapp_href=vapp_resource.get('href'),
catalog_item_name=template,
description='',
customize_on_instantiate=customizable == 'customizable')
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
def info(ctx, catalog_name, item_name):
try:
client = ctx.obj['client']
org_name = ctx.obj['profiles'].get('org')
in_use_org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, in_use_org_href, org_name == 'System')
if item_name is None:
catalog = org.get_catalog(catalog_name)
result = to_dict(catalog)
else:
catalog_item = org.get_catalog_item(catalog_name, item_name)
result = to_dict(catalog_item)
vapp = VApp(client, href=catalog_item.Entity.get('href'))
vapp.reload()
template = vapp_to_dict(vapp.resource)
for k, v in template.items():
result['template-%s' % k] = v
stdout(result, ctx)
except Exception as e:
stderr(e, ctx)
def info(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:
catalog = org.get_catalog(catalog_name)
result = to_dict(catalog)
access_control_settings = access_settings_to_dict(
org.get_catalog_access_settings(catalog_name))
result.update(access_control_settings)
else:
catalog_item = org.get_catalog_item(catalog_name, item_name)
result = to_dict(catalog_item)
vapp = VApp(client, href=catalog_item.Entity.get('href'))
vapp.reload()
template = vapp_to_dict(vapp.resource)
for k, v in template.items():
result['template-%s' % k] = v
stdout(result, ctx)
except Exception as e:
stderr(e, ctx)
def capture_vapp(client, context, capture_info):
logging.debug("__INIT__capture_vapp [%s]", capture_info)
vapp_name = capture_info.vapp_name
vdc_name = capture_info.vdc_name
catalog_name = capture_info.catalog_name
item_name = capture_info.item_name
desc = capture_info.description
customize_on_instantiate = capture_info.customize_on_instantiate
result = catalog_item_pb2.CaptureVAppResult()
try:
logged_in_org = client.get_org()
org = Org(client, resource=logged_in_org)
v = org.get_vdc(vdc_name)
if v is None:
raise errors.VDCNotFoundError(vappInfo.vdc)
vdc = VDC(client, href=v.get('href'))
vapp = vdc.get_vapp(vapp_name)
logging.info(vapp.get('href'))
catalog = org.get_catalog(catalog_name)
org.capture_vapp(
catalog_resource=catalog,
vapp_href=vapp.get('href'),
catalog_item_name=item_name,
description=desc,
customize_on_instantiate=customize_on_instantiate)
result.captured = True
logging.debug("__DONE__capture_vapp [%s] , [%s] , [%s] ", vapp_name,
vdc_name, catalog_name)
return result
except Exception as e:
error_message = 'ERROR.. capture vapp failed {0} {1} {2}'.format(
vapp_name, vdc_name, catalog_name)
logging.warn(error_message, e)
context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
context.set_details(error_message)
_fill_in_netpool_default(client, vdc_kwargs)
# Now create the VDC.
admin_vdc_resource = org.create_org_vdc(**vdc_kwargs)
# The 'admin_vdc_resource' is not a task but an AdminVdc entity. Tasks
# are two levels down.
handle_task(client, admin_vdc_resource.Tasks.Task[0])
org.reload()
vdc_resource = org.get_vdc(cfg.vdc['vdc_name'])
vdc = VDC(client, resource=vdc_resource)
print("VDC now exists: {0}".format(vdc.name))
# Ensure the catalog exists. For now we don't do anything special with
# permissions. As with VDC's we reload the org if we create a catalog
# so that it's visible in future calls.
try:
catalog_resource = org.get_catalog(cfg.catalog['name'])
print("Catalog already exists: {0}".format(cfg.catalog['name']))
except Exception as e:
print("Catalog does not exist, creating: {0}".format(cfg.catalog['name']))
catalog_kwargs = cfg.catalog
catalog_resource = org.create_catalog(**catalog_kwargs)
org.reload()
print("Catalog now exists: {0}".format(catalog_resource.get('name')))
# Check for catalog_items containing OVF templates in the catalog and
# upload them if they are missing.
for catalog_item in cfg.catalog_items:
try:
catalog_item_resource = org.get_catalog_item(
catalog_item['catalog_name'], catalog_item['item_name'])
print("Catalog item exists: {0}".format(catalog_item['item_name']))
def test_catalog_exists(self):
logged_in_org = self.client.get_org()
org = Org(self.client, org_resource=logged_in_org)
catalog = org.get_catalog(self.config['vcd']['catalog'])
assert self.config['vcd']['catalog'] == catalog.get('name')
def test_01_catalog_exists(self):
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
catalog = org.get_catalog(self.config['vcd']['catalog'])
assert self.config['vcd']['catalog'] == catalog.get('name')
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 Catalog(VcdAnsibleModule):
def __init__(self, **kwargs):
super(Catalog, 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.create()
if state == "absent":
return self.delete()
if state == "update":
return self.update()
def manage_operations(self):
operation = self.params.get('operation')
if operation == "shared":
return self.shared()
if operation == "read":
return self.read()
if operation == "list_items":
return self.list_items()
def create(self):
catalog_name = self.params.get('catalog_name')
description = self.params.get('description')
response = dict()
response['changed'] = False
try:
self.org.get_catalog(name=catalog_name)
except EntityNotFoundException:
self.org.create_catalog(name=catalog_name, description=description)
response['msg'] = 'Catalog {} has been created.'.format(
catalog_name)
response['changed'] = True
else:
response['warnings'] = 'Catalog {} is already present.'.format(
catalog_name)
return response
def delete(self):
catalog_name = self.params.get('catalog_name')
response = dict()
response['changed'] = False
try:
self.org.get_catalog(name=catalog_name)
except EntityNotFoundException:
response['warnings'] = 'Catalog {} is not present.'.format(
catalog_name)
else:
self.org.delete_catalog(catalog_name)
response['msg'] = 'Catalog {} has been deleted.'.format(
catalog_name)
response['changed'] = True
return response
def update(self):
catalog_name = self.params.get('catalog_name')
new_catalog_name = self.params.get('new_catalog_name')
description = self.params.get('description')
response = dict()
response['changed'] = False
if not new_catalog_name:
new_catalog_name = catalog_name
self.org.update_catalog(old_catalog_name=catalog_name,
new_catalog_name=new_catalog_name,
description=description)
response['msg'] = 'Catalog {} has been updated.'.format(catalog_name)
response['changed'] = True
return response
def shared(self):
catalog_name = self.params.get('catalog_name')
shared = self.params.get('shared')
response = dict()
response['changed'] = False
self.org.share_catalog(name=catalog_name, share=shared)
response[
'msg'] = 'Catalog {} shared state has been updated to [shared={}].'.format(
catalog_name, shared)
response['changed'] = True
return response
def read(self):
catalog_name = self.params.get('catalog_name')
response = dict()
result = dict()
response['changed'] = False
catalog = self.org.get_catalog(catalog_name)
result['name'] = str(catalog.get("name"))
result['description'] = str(catalog.Description)
result['shared'] = str(catalog.IsPublished)
response['msg'] = result
response['changed'] = False
return response
def list_items(self):
catalog_name = self.params.get('catalog_name')
response = dict()
response['changed'] = False
catalog_items = self.org.list_catalog_items(catalog_name)
response['msg'] = [
catalog_item['name'] for catalog_item in catalog_items
]
response['changed'] = False
return response
def install_cse(ctx, config_file_name, template_name, no_capture, update,
amqp_install, ext_install):
check_config(config_file_name)
click.secho('Installing CSE on 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-install.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)))
click.secho('Installing \'%s\' service broker' % config['broker']['type'])
if config['broker']['type'] == 'default':
orgs = client.get_org_list()
org_href = None
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)))
try:
catalog = org.get_catalog(config['broker']['catalog'])
except Exception:
click.secho('Creating catalog %s ' % config['broker']['catalog'],
nl=False,
fg='green')
catalog = org.create_catalog(config['broker']['catalog'],
'CSE catalog')
org.share_catalog(config['broker']['catalog'])
click.secho('done', fg='blue')
catalog = org.get_catalog(config['broker']['catalog'])
click.echo(
'Find catalog \'%s\': %s' %
(config['broker']['catalog'], bool_to_msg(catalog is not None)))
for template in config['broker']['templates']:
if template_name == '*' or template['name'] == template_name:
click.secho('Processing template: %s' % template['name'])
k8s_template = None
try:
k8s_template = org.get_catalog_item(
config['broker']['catalog'], template['catalog_item'])
click.echo(
'Find template \'%s\', \'%s\': %s' %
(config['broker']['catalog'], template['catalog_item'],
bool_to_msg(k8s_template is not None)))
except Exception:
pass
try:
if k8s_template is None or update:
if update:
click.secho('Updating template')
else:
click.secho('Creating template')
create_template(ctx, config, client, org, vdc_resource,
catalog, no_capture, template)
k8s_template = org.get_catalog_item(
config['broker']['catalog'],
template['catalog_item'])
if update:
click.echo('Updated template \'%s\', \'%s\': %s' %
(config['broker']['catalog'],
template['catalog_item'],
bool_to_msg(k8s_template is not None)))
else:
click.echo('Find template \'%s\', \'%s\': %s' %
(config['broker']['catalog'],
template['catalog_item'],
bool_to_msg(k8s_template is not None)))
except Exception:
LOGGER.error(traceback.format_exc())
click.echo('Can\'t create or update template \'%s\' '
'\'%s\': %s' %
(template['name'], config['broker']['catalog'],
template['catalog_item']))
configure_amqp_settings(ctx, client, config, amqp_install)
register_extension(ctx, client, config, ext_install)
click.secho('Start CSE with: \'cse run %s\'' % config_file_name)
#except Exception:
# print("Catalogs fetch error")
# List catalog items (Templates).
#try:
# catalog_items = org.list_catalog_items(cfg.catalog['name'])
# print("Catalog items: {0}".format(catalog_items))
#except Exception:
# print("Catalog items fetch error")
# exit(0)
# Ensure the catalog (vApp template) and catalog item (VM template) exists
for vm_cfg in cfg.vapp['vms']:
try:
catalog = org.get_catalog(vm_cfg['catalog'])
print(" Catalog '{0}' ... OK".format(vm_cfg['catalog']))
except Exception:
print(" Catalog '{0}' ... KO. Exiting.".format(vm_cfg['catalog']))
exit(0)
try:
catalog_item = org.get_catalog_item(vm_cfg['catalog'],
vm_cfg['catalog_item'])
print(" Catalog item '{0} / {1}' ... OK".format(
vm_cfg['catalog'], vm_cfg['catalog_item']))
except Exception:
print(" Catalog item '{0} / {1}' ... KO. Exiting.".format(
vm_cfg['catalog'], vm_cfg['catalog_item']))
exit(0)
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 Catalog(VcdAnsibleModule):
def __init__(self, **kwargs):
super(Catalog, 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.create()
if state == "absent":
return self.delete()
if state == "update":
return self.update()
def manage_operations(self):
operation = self.params.get('operation')
if operation == "shared":
return self.shared()
if operation == "read":
return self.read()
if operation == "list_items":
return self.list_items()
def create(self):
catalog_name = self.params.get('catalog_name')
description = self.params.get('description')
response = dict()
response['changed'] = False
try:
self.org.get_catalog(name=catalog_name)
except EntityNotFoundException:
self.org.create_catalog(name=catalog_name, description=description)
response['msg'] = 'Catalog {} has been created.'.format(catalog_name)
response['changed'] = True
else:
response['warnings'] = 'Catalog {} is already present.'.format(catalog_name)
return response
def delete(self):
catalog_name = self.params.get('catalog_name')
response = dict()
response['changed'] = False
try:
self.org.get_catalog(name=catalog_name)
except EntityNotFoundException:
response['warnings'] = 'Catalog {} is not present.'.format(catalog_name)
else:
self.org.delete_catalog(catalog_name)
response['msg'] = 'Catalog {} has been deleted.'.format(catalog_name)
response['changed'] = True
return response
def update(self):
catalog_name = self.params.get('catalog_name')
new_catalog_name = self.params.get('new_catalog_name')
description = self.params.get('description')
response = dict()
response['changed'] = False
if not new_catalog_name:
new_catalog_name = catalog_name
self.org.update_catalog(old_catalog_name=catalog_name,
new_catalog_name=new_catalog_name,
description=description)
response['msg'] = 'Catalog {} has been updated.'.format(catalog_name)
response['changed'] = True
return response
def shared(self):
catalog_name = self.params.get('catalog_name')
shared = self.params.get('shared')
response = dict()
response['changed'] = False
self.org.share_catalog(name=catalog_name, share=shared)
response['msg'] = 'Catalog {} shared state has been updated to [shared={}].'.format(catalog_name, shared)
response['changed'] = True
return response
def read(self):
catalog_name = self.params.get('catalog_name')
response = dict()
result = dict()
response['changed'] = False
catalog = self.org.get_catalog(catalog_name)
result['name'] = str(catalog.get("name"))
result['description'] = str(catalog.Description)
result['shared'] = str(catalog.IsPublished)
response['msg'] = result
response['changed'] = False
return response
def list_items(self):
catalog_name = self.params.get('catalog_name')
response = dict()
response['changed'] = False
catalog_items = self.org.list_catalog_items(catalog_name)
response['msg'] = [catalog_item['name'] for catalog_item in catalog_items]
response['changed'] = False
return response
