def list_dhcp_pool(ctx, gateway_name):
try:
gateway_resource = get_gateway(ctx, gateway_name)
result = gateway_resource.list_dhcp_pools()
stdout(result, ctx)
except Exception as e:
stderr(e, ctx)
def enable_activation_status(ctx, gateway_name, enabled):
try:
gateway_resource = get_gateway(ctx, gateway_name)
gateway_resource.enable_activation_status_ipsec_vpn(enabled)
stdout('IPsec VPN activation status changed.', ctx)
except Exception as e:
stderr(e, ctx)
def info_dhcp_pool(ctx, gateway_name, pool_id):
try:
resource = get_dhcp_pool(ctx, gateway_name, pool_id)
result = resource.get_pool_info()
stdout(result, ctx)
except Exception as e:
stderr(e, ctx)
def list_disks(ctx):
try:
restore_session(ctx, vdc_required=True)
client = ctx.obj['client']
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
disks = vdc.get_disks()
result = []
for disk in disks:
attached_vms = ''
if hasattr(disk, 'attached_vms') and \
hasattr(disk.attached_vms, 'VmReference'):
attached_vms = disk.attached_vms.VmReference.get('name')
result.append({
'name':
disk.get('name'),
'id':
extract_id(disk.get('id')),
'owner':
disk.Owner.User.get('name'),
'size':
humanfriendly.format_size(int(disk.get('size'))),
'size_bytes':
disk.get('size'),
'status':
VCLOUD_STATUS_MAP.get(int(disk.get('status'))),
'vms_attached':
attached_vms
})
stdout(result, ctx, show_id=True)
except Exception as e:
stderr(e, ctx)
def list_service_certificate(ctx, gateway_name):
try:
gateway_resource = get_gateway(ctx, gateway_name)
result = gateway_resource.list_service_certificates()
stdout(result, ctx)
except Exception as e:
stderr(e, ctx)
def create_isolated_network(ctx, name, gateway_ip, netmask, description,
primary_dns_ip, secondary_dns_ip, dns_suffix,
ip_range_start, ip_range_end, is_dhcp_enabled,
default_lease_time, max_lease_time,
dhcp_ip_range_start, dhcp_ip_range_end, is_shared):
try:
restore_session(ctx, vdc_required=True)
client = ctx.obj['client']
in_use_vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=in_use_vdc_href)
prefix_len = netmask_to_cidr_prefix_len(gateway_ip, netmask)
network_cidr = gateway_ip + '/' + str(prefix_len)
result = vdc.create_isolated_vdc_network(
network_name=name,
network_cidr=network_cidr,
description=description,
primary_dns_ip=primary_dns_ip,
secondary_dns_ip=secondary_dns_ip,
dns_suffix=dns_suffix,
ip_range_start=ip_range_start,
ip_range_end=ip_range_end,
is_dhcp_enabled=is_dhcp_enabled,
default_lease_time=default_lease_time,
max_lease_time=max_lease_time,
dhcp_ip_range_start=dhcp_ip_range_start,
dhcp_ip_range_end=dhcp_ip_range_end,
is_shared=is_shared)
stdout(result.Tasks.Task[0], ctx)
except Exception as e:
stderr(e, ctx)
def use(ctx, name):
try:
restore_session(ctx)
client = ctx.obj['client']
in_use_org_name = ctx.obj['profiles'].get('org_in_use')
orgs = client.get_org_list()
for org_resource in orgs:
if org_resource.get('name').lower() == in_use_org_name.lower():
for link in get_links(org_resource,
media_type=EntityType.VDC.value):
if link.name == name:
vdc_in_use = name
vapp_in_use = ''
vapp_href = ''
client.get_resource(link.href)
ctx.obj['profiles'].set('vdc_in_use', vdc_in_use)
ctx.obj['profiles'].set('vdc_href', str(link.href))
ctx.obj['profiles'].set('vapp_in_use', vapp_in_use)
ctx.obj['profiles'].set('vapp_href', vapp_href)
message = 'now using org: \'%s\', vdc: \'%s\', vApp:' \
' \'%s\'.' % (in_use_org_name, vdc_in_use,
vapp_in_use)
stdout({
'org': in_use_org_name,
'vdc': vdc_in_use,
'vapp': vapp_in_use
}, ctx, message)
return
raise Exception('Org \'%s\' not found' % in_use_org_name)
except Exception as e:
stderr(e, ctx)
def create(ctx, name, pvdc_name, network_pool_name, allocation_model, sp_name,
sp_limit, description, cpu_allocated, cpu_limit):
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)
storage_profiles = [{
'name': sp_name,
'enabled': True,
'units': 'MB',
'limit': sp_limit,
'default': True
}]
vdc_resource = org.create_org_vdc(
name,
pvdc_name,
network_pool_name=network_pool_name,
description=description,
allocation_model=allocation_model,
cpu_allocated=cpu_allocated,
cpu_limit=cpu_limit,
storage_profiles=storage_profiles,
uses_fast_provisioning=True,
is_thin_provision=True)
stdout(vdc_resource.Tasks.Task[0], 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 create(ctx, name, description, catalog, template, network, memory, cpu,
disk_size, ip_allocation_mode, vm_name, hostname, storage_profile,
accept_all_eulas):
try:
restore_session(ctx, vdc_required=True)
client = ctx.obj['client']
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
if catalog is None and template is None:
vapp_resource = vdc.create_vapp(
name,
description=description,
network=network,
accept_all_eulas=accept_all_eulas)
else:
vapp_resource = vdc.instantiate_vapp(
name,
catalog,
template,
description=description,
network=network,
memory=memory,
cpu=cpu,
disk_size=disk_size,
deploy=True,
power_on=True,
accept_all_eulas=accept_all_eulas,
cust_script=None,
ip_allocation_mode=ip_allocation_mode,
vm_name=vm_name,
hostname=hostname,
storage_profile=storage_profile)
stdout(vapp_resource.Tasks.Task[0], ctx)
except Exception as e:
stderr(e, ctx)
def delete_firewall_rule_service(ctx, name, id, protocol):
try:
firewall_rule_resource = get_firewall_rule(ctx, name, id)
firewall_rule_resource.delete_firewall_rule_service(protocol)
stdout('Firewall rule\'s service deleted successfully', ctx)
except Exception as e:
stderr(e, ctx)
def delete_service_certificate(ctx, gateway_name, id):
try:
certificate_obj = get_service_certificate(ctx, gateway_name, id)
certificate_obj.delete_certificate()
stdout('Service certificate deleted successfully.', ctx)
except Exception as e:
stderr(e, ctx)
def create(ctx, user_name, password, role_name, full_name, description, email,
telephone, im, enabled, alert_enabled, alert_email,
alert_email_prefix, external, default_cached, group_role,
stored_vm_quota, deployed_vm_quota):
try:
if len(password) < 6:
raise Exception('Password must be at least 6 characters long.')
restore_session(ctx)
client = ctx.obj['client']
in_use_org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, in_use_org_href)
role = org.get_role_record(role_name)
role_href = role.get('href')
result = org.create_user(
user_name=user_name,
password=password,
role_href=role_href,
full_name=full_name,
description=description,
email=email,
telephone=telephone,
im=im,
alert_email=alert_email,
alert_email_prefix=alert_email_prefix,
stored_vm_quota=stored_vm_quota,
deployed_vm_quota=deployed_vm_quota,
is_group_role=group_role,
is_default_cached=default_cached,
is_external=external,
is_alert_enabled=alert_enabled,
is_enabled=enabled)
stdout('User \'%s\' is successfully created.' % result.get('name'),
ctx)
except Exception as e:
stderr(e, ctx)
def info_logging_settings(ctx, gateway_name):
try:
gateway_resource = get_gateway(ctx, gateway_name)
result = gateway_resource.info_logging_settings_ipsec_vpn()
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 info(ctx, gateway_name, rule_id):
try:
resource = get_nat_rule(ctx, gateway_name, rule_id)
result = resource.get_nat_rule_info()
stdout(result, ctx)
except Exception as e:
stderr(e, ctx)
def reorder_nat_rule(ctx, gateway_name, rule_id, index):
try:
gateway_resource = get_gateway(ctx, gateway_name)
gateway_resource.reorder_nat_rule(rule_id, position=index)
stdout('NAT rule reordered successfully.', ctx)
except Exception as e:
stderr(e, ctx)
def list_catalogs_or_items(ctx, catalog_name):
try:
restore_session(ctx)
client = ctx.obj['client']
if catalog_name is None:
in_use_org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, in_use_org_href)
result = org.list_catalogs()
else:
result = []
if is_sysadmin(ctx):
resource_type = ResourceType.ADMIN_CATALOG_ITEM.value
else:
resource_type = ResourceType.CATALOG_ITEM.value
q = client.get_typed_query(
resource_type,
query_result_format=QueryResultFormat.ID_RECORDS,
equality_filter=('catalogName', catalog_name))
records = list(q.execute())
if len(records) == 0:
result = 'not found'
else:
for r in records:
result.append(to_dict(r, resource_type=resource_type))
stdout(result, ctx)
except Exception as e:
stderr(e, ctx)
def list_firewall_rule_service(ctx, name, id):
try:
firewall_rule_resource = get_firewall_rule(ctx, name, id)
result = firewall_rule_resource.list_firewall_rule_service()
stdout(result, ctx)
except Exception as e:
stderr(e, ctx)
def list(ctx, gateway_name):
try:
gateway_resource = get_gateway(ctx, gateway_name)
nat_list = gateway_resource.list_nat_rules()
stdout(nat_list, ctx)
except Exception as e:
stderr(e, ctx)
def info_activation_status(ctx, gateway_name):
try:
gateway_resource = get_gateway(ctx, gateway_name)
result = gateway_resource.info_activation_status_ipsec_vpn()
stdout(result, ctx)
except Exception as e:
stderr(e, ctx)
def info_ipsec_vpn(ctx, gateway_name, id):
try:
ipsec_vpn_obj = get_ipsec_vpn(ctx, gateway_name, id)
result = ipsec_vpn_obj.get_vpn_site_info()
stdout(result, ctx)
except Exception as e:
stderr(e, ctx)
def set_log_level(ctx, gateway_name, log_level):
try:
gateway_resource = get_gateway(ctx, gateway_name)
gateway_resource.set_log_level_ipsec_vpn(log_level)
stdout('IPsec VPN log level changed.', ctx)
except Exception as e:
stderr(e, ctx)
def delete_dhcp_pool(ctx, gateway_name, pool_id):
try:
resource = get_dhcp_pool(ctx, gateway_name, pool_id)
resource.delete_pool()
stdout('DHCP Pool deleted successfully.', ctx)
except Exception as e:
stderr(e, ctx)
def list_ipsec_vpn(ctx, gateway_name):
try:
gateway_resource = get_gateway(ctx, gateway_name)
result = gateway_resource.list_ipsec_vpn()
stdout(result, ctx)
except Exception as e:
stderr(e, ctx)
def enable_logging(ctx, gateway_name, enabled):
try:
gateway_resource = get_gateway(ctx, gateway_name)
gateway_resource.enable_logging_ipsec_vpn(enabled)
stdout('IPsec VPN logging enable status changed.', ctx)
except Exception as e:
stderr(e, ctx)
def change_shared_key(ctx, gateway_name, new_shared_key):
try:
gateway_resource = get_gateway(ctx, gateway_name)
gateway_resource.change_shared_key_ipsec_vpn(new_shared_key)
stdout('IPsec VPN shared key changed.', ctx)
except Exception as e:
stderr(e, ctx)
def delete(ctx, gateway_name, rule_id):
try:
resource = get_nat_rule(ctx, gateway_name, rule_id)
resource.delete_nat_rule()
stdout('Nat Rule deleted successfully.', ctx)
except Exception as e:
stderr(e, ctx)
def delete_ipsec_vpn(ctx, gateway_name, id):
try:
ipsec_vpn_obj = get_ipsec_vpn(ctx, gateway_name, id)
ipsec_vpn_obj.delete_ipsec_vpn()
stdout('IPsec VPN deleted successfully.', ctx)
except Exception as e:
stderr(e, ctx)
def use(ctx, name):
try:
restore_session(ctx)
client = ctx.obj['client']
org_resource = client.get_org_by_name(name)
in_use_vdc = ''
vdc_href = ''
in_use_vapp = ''
vapp_href = ''
for link in get_links(org_resource, media_type=EntityType.VDC.value):
in_use_vdc = link.name
vdc_href = link.href
break
ctx.obj['profiles'].set('org_in_use', str(name))
ctx.obj['profiles'].set('org_href', str(org_resource.get('href')))
ctx.obj['profiles'].set('vdc_in_use', str(in_use_vdc))
ctx.obj['profiles'].set('vdc_href', str(vdc_href))
ctx.obj['profiles'].set('vapp_in_use', str(in_use_vapp))
ctx.obj['profiles'].set('vapp_href', vapp_href)
message = 'now using org: \'%s\', vdc: \'%s\', vApp: \'%s\'.' \
% (name, in_use_vdc, in_use_vapp)
stdout({
'org': name,
'vdc': in_use_vdc,
'vapp': in_use_vapp
}, ctx, message)
except Exception as e:
stderr(e, ctx)
def use(ctx, name):
try:
restore_session(ctx)
client = ctx.obj['client']
in_use_org_name = ctx.obj['profiles'].get('org_in_use')
orgs = client.get_org_list()
for org_resource in orgs:
if org_resource.get('name').lower() == in_use_org_name.lower():
if client.get_api_version() < ApiVersion.VERSION_33.value:
links = get_links(org_resource,
media_type=EntityType.VDC.value)
else:
links = client.get_resource_link_from_query_object(
org_resource,
media_type=EntityType.RECORDS.value,
type='vdc')
for link in links:
if link.name == name:
vdc_in_use = name
vapp_in_use = ''
vapp_href = ''
client.get_resource(link.href)
ctx.obj['profiles'].set('vdc_in_use', vdc_in_use)
ctx.obj['profiles'].set('vdc_href', str(link.href))
ctx.obj['profiles'].set('vapp_in_use', vapp_in_use)
ctx.obj['profiles'].set('vapp_href', vapp_href)
message = 'now using org: \'%s\', vdc: \'%s\', vApp:' \
' \'%s\'.' % (in_use_org_name, vdc_in_use,
vapp_in_use)
stdout(
{
'org': in_use_org_name,
'vdc': vdc_in_use,
'vapp': vapp_in_use
}, ctx, message)
return
raise Exception('Org Vdc \'%s\' not found in org \'%s\'' %
(name, in_use_org_name))
except Exception as e:
stderr(e, ctx)
def update(ctx, vapp_name, vm_name, cpu, cores, memory):
try:
restore_session(ctx, vdc_required=True)
vm = _get_vm(ctx, vapp_name, vm_name)
if cpu is not None:
task_cpu_update = vm.modify_cpu(cpu, cores)
stdout("Updating cpu (and core(s) if specified) for the VM")
stdout(task_cpu_update, ctx)
if memory is not None:
task_memory_update = vm.modify_memory(memory)
stdout("Updating memory for the VM")
stdout(task_memory_update, ctx)
except Exception as e:
stderr(e, ctx)
def list_templates(ctx, is_tkgm):
"""Display templates that can be used to deploy native/TKG clusters."""
CLIENT_LOGGER.debug(f'Executing command: {ctx.command_path}')
try:
client_utils.cse_restore_session(ctx)
client = ctx.obj['client']
template = Template(client)
result = template.get_templates(is_tkgm)
CLIENT_LOGGER.debug(result)
value_field_to_display_field = {
'name': 'Name',
'revision': 'Revision',
'catalog': 'Catalog',
'catalog_item': 'Catalog Item',
'description': 'Description'
}
filtered_result = client_utils.filter_columns(
result, value_field_to_display_field) # noqa: E501
stdout(filtered_result, ctx, sort_headers=False)
except Exception as e:
stderr(e, ctx)
CLIENT_LOGGER.error(str(e), exc_info=True)
def list_metadata(ctx, name):
try:
vdc = _get_vdc_ref(ctx)
client = ctx.obj['client']
routed_network = vdc.get_routed_orgvdc_network(name)
vdcNetwork = VdcNetwork(client, resource=routed_network)
metadata = vdcNetwork.get_all_metadata()
result = []
for metadata_entry in metadata.MetadataEntry:
visibility = MetadataVisibility.READ_WRITE.value
if hasattr(metadata_entry, 'Domain'):
visibility = metadata_entry.Domain.get('visibility')
type = metadata_entry.TypedValue.get('{' + NSMAP['xsi'] + '}type')
result.append({
'Name': metadata_entry.Key,
'Value': metadata_entry.TypedValue.Value,
'Type': type,
'User access': visibility
})
stdout(result, ctx)
except Exception as e:
stderr(e, ctx)
def download(ctx, catalog_name, item_name, file_name, progress, overwrite):
try:
restore_session(ctx)
save_as_name = item_name
if file_name is not None:
save_as_name = file_name
if not overwrite and os.path.isfile(save_as_name):
raise Exception('File exists.')
client = ctx.obj['client']
in_use_org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, in_use_org_href)
cb = download_callback if progress else None
bytes_written = org.download_catalog_item(
catalog_name,
item_name,
save_as_name,
callback=cb,
task_callback=task_callback)
result = {'file': save_as_name, 'size': bytes_written}
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 cluster_info(ctx, name, org, vdc, k8_runtime=None, cluster_id=None):
"""Display info about a Kubernetes cluster.
\b
Example
vcd cse cluster info mycluster
Display detailed information about cluster 'mycluster'.
'--vdc' option can be used for faster command execution.
\b
vcd cse cluster info --id urn:vcloud:entity:cse:nativeCluster:1.0.0:0632c7c7-a613-427c-b4fc-9f1247da5561
Display cluster information about cluster with
ID 'urn:vcloud:entity:cse:nativeCluster:1.0.0:0632c7c7-a613-427c-b4fc-9f1247da5561'
(--id option is supported only for api version >= 35)
""" # noqa: E501
CLIENT_LOGGER.debug(f'Executing command: {ctx.command_path}')
try:
if not (cluster_id or name):
# --id is not required when working with api version 33 and 34
raise Exception("Please specify cluster name (or) cluster Id. "
"Note that '--id' flag is applicable for API versions >= 35 only.") # noqa: E501
client_utils.cse_restore_session(ctx)
if client_utils.is_cli_for_tkg_s_only():
if k8_runtime in shared_constants.CSE_SERVER_RUNTIMES:
# Cannot run the command as cse cli is enabled only for native
raise CseServerNotRunningError()
k8_runtime = shared_constants.ClusterEntityKind.TKG_S.value
client = ctx.obj['client']
cluster = Cluster(client, k8_runtime=k8_runtime)
# Users should be explicit in their intent about the org on which the
# command needs to be executed.
if not client.is_sysadmin() and org is None:
org = ctx.obj['profiles'].get('org_in_use')
result = cluster.get_cluster_info(name, cluster_id=cluster_id,
org=org, vdc=vdc)
stdout(result, ctx)
CLIENT_LOGGER.debug(result)
except Exception as e:
stderr(e, ctx)
CLIENT_LOGGER.error(str(e), exc_info=True)
def create(ctx, catalog, template, name, network, memory, cpu,
ip_allocation_mode, identical):
try:
cust_script = None
client = ctx.obj['client']
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
vapp_resource = vdc.instantiate_vapp(
name,
catalog,
template,
network=network,
memory=memory,
cpu=cpu,
deploy=True,
power_on=True,
cust_script=cust_script,
ip_allocation_mode=ip_allocation_mode,
identical=identical)
stdout(vapp_resource.Tasks.Task[0], ctx)
except Exception as e:
stderr(e, ctx)
def ovdc_disable(ctx, ovdc_name, org_name):
"""Disable Kubernetes cluster deployment for an org VDC."""
CLIENT_LOGGER.debug(f'Executing command: {ctx.command_path}')
try:
restore_session(ctx)
client = ctx.obj['client']
if client.is_sysadmin():
ovdc = Ovdc(client)
if org_name is None:
org_name = ctx.obj['profiles'].get('org_in_use')
result = ovdc.update_ovdc_for_k8s(enable=False,
ovdc_name=ovdc_name,
org_name=org_name)
stdout(result, ctx)
CLIENT_LOGGER.debug(result)
else:
msg = "Insufficient permission to perform operation."
stderr(msg, ctx)
CLIENT_LOGGER.error(msg)
except Exception as e:
stderr(e, ctx)
CLIENT_LOGGER.error(str(e))
def cluster_delete(ctx, name, vdc, org):
"""Delete a Kubernetes cluster."""
CLIENT_LOGGER.debug(f'Executing command: {ctx.command_path}')
try:
restore_session(ctx)
client = ctx.obj['client']
cluster = Cluster(client)
if not client.is_sysadmin() and org is None:
org = ctx.obj['profiles'].get('org_in_use')
result = cluster.delete_cluster(name, org, vdc)
# result is empty for delete cluster operation on PKS-managed clusters.
# In that specific case, below check helps to print out a meaningful
# message to users.
if len(result) == 0:
click.secho(f"Delete cluster operation has been initiated on "
f"{name}, please check the status using"
f" 'vcd cse cluster info {name}'.", fg='yellow')
stdout(result, ctx)
CLIENT_LOGGER.debug(result)
except Exception as e:
stderr(e, ctx)
CLIENT_LOGGER.error(str(e))
def cluster_resize(ctx, cluster_name, node_count, network_name, org_name,
vdc_name, disable_rollback):
"""Resize the cluster to contain the specified number of worker nodes.
Clusters that use native Kubernetes provider can not be sized down
(use 'vcd cse node delete' command to do so).
"""
try:
restore_session(ctx)
client = ctx.obj['client']
if not client.is_sysadmin() and org_name is None:
org_name = ctx.obj['profiles'].get('org_in_use')
cluster = Cluster(client)
result = cluster.resize_cluster(network_name,
cluster_name,
node_count=node_count,
org=org_name,
vdc=vdc_name,
rollback=not disable_rollback)
stdout(result, ctx)
except Exception as e:
stderr(e, ctx)
def convert_to_advanced_gateway(ctx, name):
"""Convert to advanced gateway.
\b
Note
System Administrators and Organization Administrator can
convert legacy gateway to advanced.
\b
Examples
vcd gateway convert-to-advanced <gateway-name>
Convert gateway to advanced by providing gateway name
"""
try:
restore_session(ctx, vdc_required=True)
client = ctx.obj['client']
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
gateway = vdc.get_gateway(name)
gateway_resource = Gateway(client, href=gateway.get('href'))
task = gateway_resource.convert_to_advanced()
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
def cluster_upgrade(ctx, cluster_name, template_name, template_revision,
vdc, org_name):
"""Upgrade cluster software to specified template's software versions.
Affected software: Docker-CE, Kubernetes, CNI
"""
CLIENT_LOGGER.debug(f'Executing command: {ctx.command_path}')
try:
restore_session(ctx)
client = ctx.obj['client']
cluster = Cluster(client)
if not client.is_sysadmin() and org_name is None:
org_name = ctx.obj['profiles'].get('org_in_use')
result = cluster.upgrade_cluster(cluster_name, template_name,
template_revision, ovdc_name=vdc,
org_name=org_name)
stdout(result, ctx)
CLIENT_LOGGER.debug(result)
except Exception as e:
stderr(e, ctx)
CLIENT_LOGGER.error(str(e))
def delete_nodes(ctx, cluster_name, node_names, org, vdc):
"""Delete node(s) in a cluster that uses native Kubernetes provider.
\b
Example
vcd cse node delete mycluster node-xxxx --yes
Delete node 'node-xxxx' in cluster 'mycluster' without prompting.
"""
CLIENT_LOGGER.debug(f'Executing command: {ctx.command_path}')
try:
client_utils.cse_restore_session(ctx)
client = ctx.obj['client']
if not client.is_sysadmin() and org is None:
org = ctx.obj['profiles'].get('org_in_use')
cluster = Cluster(client)
result = cluster.delete_nodes(cluster_name, list(node_names), org=org,
vdc=vdc)
stdout(result, ctx)
CLIENT_LOGGER.debug(result)
except Exception as e:
stderr(e, ctx)
CLIENT_LOGGER.error(str(e), exc_info=True)
def remove(ctx, catalog_name, access_list, all):
try:
client = ctx.obj['client']
in_use_org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, in_use_org_href)
if all:
click.confirm(
'Do you want to remove all access settings from the catalog '
'\'%s\'' % catalog_name,
abort=True)
updated_acl = org.remove_catalog_access_settings(
catalog_name=catalog_name,
access_settings_list=acl_str_to_list_of_dict(access_list),
remove_all=all)
stdout(
access_settings_to_list(
updated_acl, ctx.obj['profiles'].get('org_in_use')),
ctx,
sort_headers=False)
except Exception as e:
stderr(e, ctx)
def info(ctx, name):
try:
restore_session(ctx)
client = ctx.obj['client']
in_use_org_name = ctx.obj['profiles'].get('org_in_use')
in_use_vdc = ctx.obj['profiles'].get('vdc_in_use')
org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, href=org_href)
vdc_resource = org.get_vdc(name)
vdc = VDC(client, resource=vdc_resource)
access_settings = None
try:
access_settings = vdc.get_access_settings()
except OperationNotSupportedException:
pass
result = vdc_to_dict(vdc_resource,
access_settings_to_dict(access_settings))
result['in_use'] = in_use_vdc == name
result['org'] = in_use_org_name
stdout(result, ctx)
except Exception as e:
stderr(e, ctx)
def cluster_resize(ctx, cluster_name, node_count, org_name, vdc_name):
"""Resize the Ent-PKS to contain the specified number of worker nodes.
Clusters that use native Kubernetes provider can not be sized down
(use 'vcd cse node delete' command to do so).
"""
CLIENT_LOGGER.debug(f'Executing command: {ctx.command_path}')
try:
restore_session(ctx)
client = ctx.obj['client']
if not client.is_sysadmin() and org_name is None:
org_name = ctx.obj['profiles'].get('org_in_use')
cluster = PksCluster(client)
result = cluster.resize_cluster(cluster_name,
node_count=node_count,
org=org_name,
vdc=vdc_name)
stdout(result, ctx)
CLIENT_LOGGER.debug(result)
except Exception as e:
stderr(e, ctx)
CLIENT_LOGGER.error(str(e))
def remove(ctx, vdc_name, access_list, all):
try:
restore_session(ctx)
client = ctx.obj['client']
in_use_org_href = ctx.obj['profiles'].get('org_href')
if all:
click.confirm(
'Do you want to remove all access settings from the vdc '
'\'%s\'' % vdc_name,
abort=True)
org = Org(client, in_use_org_href)
vdc_resource = org.get_vdc(vdc_name)
vdc = VDC(client, resource=vdc_resource)
vdc.remove_access_settings(
access_settings_list=acl_str_to_list_of_dict(access_list),
remove_all=all)
stdout('Access settings removed from vdc \'%s\'.' % vdc_name, ctx)
except Exception as e:
stderr(e, ctx)
def upload(ctx, catalog_name, file_name, item_name, progress):
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)
cb = upload_callback if progress else None
filename, file_extension = os.path.splitext(file_name)
if file_extension == '.ova':
bytes_written = org.upload_ovf(catalog_name,
file_name,
item_name,
callback=cb)
else:
bytes_written = org.upload_media(catalog_name,
file_name,
item_name,
callback=cb)
result = {'file': file_name, 'size': bytes_written}
stdout(result, ctx)
except Exception as e:
stderr(e, ctx)
def add_firewall_rule(ctx, vapp_name, network_name, firewall_rule_name,
is_enable, policy, protocols, source_port_range,
source_ip, destination_port_range, destination_ip,
is_logging):
try:
protocol_list = ['Any']
if protocols is not None:
protocol_list = protocols.split(',')
vapp_firewall = get_vapp_network_firewall(ctx, vapp_name, network_name)
result = vapp_firewall.add_firewall_rule(
name=firewall_rule_name,
is_enabled=is_enable,
policy=policy,
protocols=protocol_list,
source_port_range=source_port_range,
source_ip=source_ip,
destination_port_range=destination_port_range,
destination_ip=destination_ip,
enable_logging=is_logging)
stdout(result, ctx)
except Exception as e:
stderr(e, ctx)
def attach(ctx, vc_name, vc_host, vc_user, vc_pwd, vc_root_folder,
nsx_server_name, nsx_host, nsx_user, nsx_pwd, enable):
try:
restore_session(ctx)
client = ctx.obj['client']
platform = Platform(client)
result = platform.attach_vcenter(vc_server_name=vc_name,
vc_server_host=vc_host,
vc_admin_user=vc_user,
vc_admin_pwd=vc_pwd,
vc_root_folder=vc_root_folder,
nsx_server_name=nsx_server_name,
nsx_host=nsx_host,
nsx_admin_user=nsx_user,
nsx_admin_pwd=nsx_pwd,
is_enabled=enable)
vc = result.find('vmext:VimServer', NSMAP)
Tasks = vc.find('vcloud:Tasks', NSMAP)
stdout(Tasks.Task[0], ctx)
stdout('VirtualCenter server attached successfully.', ctx)
except Exception as e:
stderr(e, ctx)
def create_dnat_rule(ctx, gateway_name, action, type, original_address,
translated_address, enabled, logging_enabled,
description, vnic, protocol, original_Port,
translated_Port):
try:
gateway_resource = get_gateway(ctx, gateway_name)
gateway_resource.add_nat_rule(
action=action,
original_address=original_address,
translated_address=translated_address,
description=description,
type=type,
logging_enabled=logging_enabled,
enabled=enabled,
vnic=vnic,
protocol=protocol,
original_port=original_Port,
translated_port=translated_Port)
stdout('DNAT rule created successfully.', ctx)
except Exception as e:
stderr(e, ctx)
def create_node(ctx, cluster_name, node_count, org, vdc, cpu, memory,
network_name, storage_profile, ssh_key_file, template_name,
template_revision, enable_nfs, disable_rollback):
"""Add node(s) to a cluster that uses native Kubernetes provider."""
CLIENT_LOGGER.debug(f'Executing command: {ctx.command_path}')
try:
if (template_name and not template_revision) or \
(not template_name and template_revision):
raise Exception("Both --template-name (-t) and "
"--template-revision (-r) must be specified.")
restore_session(ctx)
client = ctx.obj['client']
if org is None and not client.is_sysadmin():
org = ctx.obj['profiles'].get('org_in_use')
cluster = Cluster(client)
ssh_key = None
if ssh_key_file is not None:
ssh_key = ssh_key_file.read()
result = cluster.add_node(
network_name,
cluster_name,
node_count=node_count,
org=org,
vdc=vdc,
cpu=cpu,
memory=memory,
storage_profile=storage_profile,
ssh_key=ssh_key,
template_name=template_name,
template_revision=template_revision,
enable_nfs=enable_nfs,
rollback=not disable_rollback)
stdout(result, ctx)
CLIENT_LOGGER.debug(result)
except Exception as e:
stderr(e, ctx)
CLIENT_LOGGER.error(str(e))
def deploy(ctx, name, vm_names, power_on, force_customization):
try:
client = ctx.obj['client']
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
vapp_resource = vdc.get_vapp(name)
vapp = VApp(client, resource=vapp_resource)
if power_on is not None:
power_on = False
if force_customization is not None:
force_customization = True
if len(vm_names) == 0:
task = vapp.deploy(power_on=power_on)
stdout(task, ctx)
else:
for vm_name in vm_names:
vm = VM(client, href=vapp.get_vm(vm_name).get('href'))
vm.reload()
task = vm.deploy(power_on=power_on,
force_customization=force_customization)
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
def print_paginated_result(generator, should_print_all=False, logger=NULL_LOGGER): # noqa: E501
"""Print results by prompting the user for more results.
:param Generator[(List[dict], int), None, None] generator: generator which
yields a list of results and a boolean indicating if more results
are present.
:param bool should_print_all: print all the results without prompting the
user.
:param logger logger: logger to log the results or exceptions.
"""
try:
headers_printed = False
for result, has_more_results in generator:
stdout(result, sort_headers=False,
show_headers=not headers_printed)
headers_printed = True
logger.debug(result)
if not has_more_results or \
not (should_print_all or click.confirm("Do you want more results?")): # noqa: E501
break
except Exception as e:
logger.error(f"Error while iterating over the paginated response: {e}")
raise
def use(ctx, name):
try:
client = ctx.obj['client']
in_use_org_name = ctx.obj['profiles'].get('org_in_use')
orgs = client.get_org_list()
for org in [o for o in orgs.Org if hasattr(orgs, 'Org')]:
if org.get('name') == in_use_org_name:
resource = client.get_resource(org.get('href'))
for v in get_links(resource, media_type=EntityType.VDC.value):
if v.name == name:
client.get_resource(v.href)
ctx.obj['profiles'].set('vdc_in_use', str(name))
ctx.obj['profiles'].set('vdc_href', str(v.href))
message = 'now using org: \'%s\', vdc: \'%s\'.' % \
(in_use_org_name, name)
stdout({
'org': in_use_org_name,
'vdc': vdc
}, ctx, message)
return
raise Exception('not found')
except Exception as e:
stderr(e, ctx)
def info(ctx, name):
try:
client = ctx.obj['client']
in_use_org_name = ctx.obj['profiles'].get('org_in_use')
in_use_vdc = ctx.obj['profiles'].get('vdc_in_use')
orgs = client.get_org_list()
result = {}
vdc_resource = None
for org in [o for o in orgs.Org if hasattr(orgs, 'Org')]:
if org.get('name') == in_use_org_name:
resource = client.get_resource(org.get('href'))
for v in get_links(resource, media_type=EntityType.VDC.value):
if v.name == name:
vdc_resource = client.get_resource(v.href)
result = vdc_to_dict(vdc_resource)
result['in_use'] = in_use_vdc == name
result['org'] = in_use_org_name
break
if vdc_resource is None:
raise Exception('not found')
stdout(result, ctx)
except Exception as e:
stderr(e, ctx)
def create(ctx, name, node_count, cpu, memory, network_name, storage_profile,
ssh_key_file, template, enable_nfs):
"""Create a Kubernetes cluster."""
try:
restore_session(ctx, vdc_required=True)
client = ctx.obj['client']
cluster = Cluster(client)
ssh_key = None
if ssh_key_file is not None:
ssh_key = ssh_key_file.read()
result = cluster.create_cluster(ctx.obj['profiles'].get('vdc_in_use'),
network_name,
name,
node_count=node_count,
cpu=cpu,
memory=memory,
storage_profile=storage_profile,
ssh_key=ssh_key,
template=template,
enable_nfs=enable_nfs)
stdout(result, ctx)
except Exception as e:
stderr(e, ctx)
def create_node(ctx, name, node_count, cpu, memory, network_name,
storage_profile, ssh_key_file, template, node_type):
"""Add a node to a Kubernetes cluster."""
try:
restore_session(ctx)
client = ctx.obj['client']
cluster = Cluster(client)
ssh_key = None
if ssh_key_file is not None:
ssh_key = ssh_key_file.read()
result = cluster.add_node(ctx.obj['profiles'].get('vdc_in_use'),
network_name,
name,
node_count=node_count,
cpu=cpu,
memory=memory,
storage_profile=storage_profile,
ssh_key=ssh_key,
template=template,
node_type=node_type)
stdout(result, ctx)
except Exception as e:
stderr(e, ctx)
def add_vm(ctx, name, source_vapp, source_vm, catalog, target_vm, hostname,
network, ip_allocation_mode, storage_profile, password_auto,
accept_all_eulas):
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)
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
source_vapp_resource = None
if catalog is None:
source_vapp_resource = vdc.get_vapp(source_vapp)
else:
catalog_item = org.get_catalog_item(catalog, source_vapp)
source_vapp_resource = client.get_resource(
catalog_item.Entity.get('href'))
assert source_vapp_resource is not None
vapp_resource = vdc.get_vapp(name)
vapp = VApp(client, resource=vapp_resource)
spec = {'source_vm_name': source_vm, 'vapp': source_vapp_resource}
if target_vm is not None:
spec['target_vm_name'] = target_vm
if hostname is not None:
spec['hostname'] = hostname
if network is not None:
spec['network'] = network
spec['ip_allocation_mode'] = ip_allocation_mode
if storage_profile is not None:
spec['storage_profile'] = vdc.get_storage_profile(storage_profile)
if password_auto is not None:
spec['password_auto'] = password_auto
task = vapp.add_vms([spec], all_eulas_accepted=accept_all_eulas)
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
