def cluster_config(ctx, cluster_name, vdc, org):
"""Display Ent-PKS cluster configuration.
To write to a file: `vcd cse pks-cluster config mycluster > ~/.kube/my_config` # noqa: E501
"""
CLIENT_LOGGER.debug(f'Executing command: {ctx.command_path}')
try:
restore_session(ctx)
client = ctx.obj['client']
cluster = PksCluster(client)
if not client.is_sysadmin() and org is None:
org = ctx.obj['profiles'].get('org_in_use')
cluster_config = cluster.get_cluster_config(
cluster_name, vdc=vdc,
org=org).get(RESPONSE_MESSAGE_KEY) # noqa: E501
# Config information with linux new-line should be converted to
# carriage-return to output in windows console.
if os.name == 'nt':
cluster_config = str.replace(cluster_config, '\n', '\r\n')
click.secho(cluster_config)
CLIENT_LOGGER.debug(cluster_config)
except Exception as e:
stderr(e, ctx)
CLIENT_LOGGER.error(str(e))
def list_clusters(ctx, vdc, org_name):
"""Display clusters in vCD that are visible to the logged in user."""
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.get_clusters(vdc=vdc, org=org_name)
clusters = []
for c in result:
# TODO cluster api response keys need to be more well defined
cluster = {
'Name': c.get('name') or 'N/A',
'VDC': c.get('vdc') or 'N/A',
'Org': c.get('org_name') or 'N/A',
'K8s Runtime': c.get('k8s_type') or 'N/A',
'K8s Version': c.get('k8s_version') or 'N/A',
'Status': c.get('status') or 'N/A',
'Provider': c.get('k8s_provider') or 'N/A',
}
clusters.append(cluster)
stdout(clusters, ctx, show_id=True, sort_headers=False)
CLIENT_LOGGER.debug(result)
except Exception as e:
stderr(e, ctx)
CLIENT_LOGGER.error(str(e))
def cluster_create(ctx, cluster_name, vdc, node_count, org_name):
"""Create an Ent-PKS Kubernetes cluster (max name length is 25 characters).""" # noqa: E501
CLIENT_LOGGER.debug(f'Executing command: {ctx.command_path}')
try:
client_utils.cse_restore_session(ctx)
if vdc is None:
vdc = ctx.obj['profiles'].get('vdc_in_use')
if not vdc:
raise Exception("Virtual datacenter context is not set. "
"Use either command 'vcd vdc use' or option "
"'--vdc' to set the vdc context.")
if org_name is None:
org_name = ctx.obj['profiles'].get('org_in_use')
client = ctx.obj['client']
cluster = PksCluster(client)
result = cluster.create_cluster(
vdc,
cluster_name,
node_count=node_count,
org=org_name)
stdout(result, ctx)
CLIENT_LOGGER.debug(result)
except Exception as e:
stderr(e, ctx)
CLIENT_LOGGER.error(str(e))
def ovdc_enable(ctx, ovdc_name, pks_plan,
pks_cluster_domain, org_name):
"""Set Kubernetes provider to be Ent-PKS for an org VDC."""
CLIENT_LOGGER.debug(f'Executing command: {ctx.command_path}')
try:
client_utils.cse_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=True,
ovdc_name=ovdc_name,
org_name=org_name,
k8s_provider=K8sProvider.PKS,
pks_plan=pks_plan,
pks_cluster_domain=pks_cluster_domain)
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_upgrade_plan(ctx, cluster_name, vdc, org_name):
"""Display templates that the specified cluster can upgrade to."""
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')
templates = cluster.get_upgrade_plan(cluster_name, vdc=vdc,
org=org_name)
result = []
for template in templates:
result.append({
'Template Name': template[LocalTemplateKey.NAME],
'Template Revision': template[LocalTemplateKey.REVISION],
'Kubernetes': template[LocalTemplateKey.KUBERNETES_VERSION],
'Docker-CE': template[LocalTemplateKey.DOCKER_VERSION],
'CNI': f"{template[LocalTemplateKey.CNI]} {template[LocalTemplateKey.CNI_VERSION]}" # noqa: E501
})
if not templates:
result = f"No valid upgrade targets for cluster '{cluster_name}'"
stdout(result, ctx, sort_headers=False)
CLIENT_LOGGER.debug(result)
except Exception as e:
stderr(e, ctx)
CLIENT_LOGGER.error(str(e))
def apply(ctx, cluster_config_file_path):
CLIENT_LOGGER.debug(f'Executing command: {ctx.command_path}')
try:
restore_session(ctx)
client = ctx.obj['client']
cluster = Cluster(client)
cluster.apply(cluster_config_file_path)
except Exception as e:
stderr(e, ctx)
CLIENT_LOGGER.error(str(e))
def cluster_create(ctx, name, vdc, node_count, cpu, memory, network_name,
storage_profile, ssh_key_file, template_name,
template_revision, enable_nfs, disable_rollback, org_name):
"""Create a Kubernetes cluster (max name length is 25 characters)."""
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 flags --template-name(-t) and "
"--template-revision (-r) must be specified.")
restore_session(ctx)
if vdc is None:
vdc = ctx.obj['profiles'].get('vdc_in_use')
if not vdc:
raise Exception("Virtual datacenter context is not set. "
"Use either command 'vcd vdc use' or option "
"'--vdc' to set the vdc context.")
if org_name is None:
org_name = ctx.obj['profiles'].get('org_in_use')
ssh_key = None
if ssh_key_file is not None:
ssh_key = ssh_key_file.read()
client = ctx.obj['client']
cluster = Cluster(client)
result = cluster.create_cluster(
vdc,
network_name,
name,
node_count=node_count,
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,
org=org_name)
stdout(result, ctx)
CLIENT_LOGGER.debug(result)
except CseResponseError as e:
minor_error_code_to_error_message = {
MinorErrorCode.REQUEST_KEY_NETWORK_NAME_MISSING: 'Missing option "-n" / "--network".', # noqa: E501
MinorErrorCode.REQUEST_KEY_NETWORK_NAME_INVALID: 'Invalid or missing value for option "-n" / "--network".' # noqa: E501
}
e.error_message = \
minor_error_code_to_error_message.get(
e.minor_error_code, e.error_message)
stderr(e, ctx)
CLIENT_LOGGER.error(str(e))
except Exception as e:
stderr(e, ctx)
CLIENT_LOGGER.error(str(e))
def list_templates(ctx):
"""Display templates that can be used by native Kubernetes provider."""
CLIENT_LOGGER.debug(f'Executing command: {ctx.command_path}')
try:
restore_session(ctx)
client = ctx.obj['client']
cluster = Cluster(client)
result = cluster.get_templates()
stdout(result, ctx, sort_headers=False)
CLIENT_LOGGER.debug(result)
except Exception as e:
stderr(e, ctx)
CLIENT_LOGGER.error(str(e))
def list_ovdcs(ctx, list_pks_plans):
"""Display org VDCs in vCD that are visible to the logged in user."""
CLIENT_LOGGER.debug(f'Executing command: {ctx.command_path}')
try:
restore_session(ctx)
client = ctx.obj['client']
ovdc = Ovdc(client)
result = ovdc.list_ovdc_for_k8s(list_pks_plans=list_pks_plans)
stdout(result, ctx, sort_headers=False)
CLIENT_LOGGER.debug(result)
except Exception as e:
stderr(e, ctx)
CLIENT_LOGGER.error(str(e))
def disable_service(ctx):
"""Disable CSE server."""
CLIENT_LOGGER.debug(f'Executing command: {ctx.command_path}')
try:
restore_session(ctx)
client = ctx.obj['client']
system = System(client)
result = system.update_service_status(action=ServerAction.DISABLE)
stdout(result, ctx)
CLIENT_LOGGER.debug(result)
except Exception as e:
stderr(e, ctx)
CLIENT_LOGGER.error(str(e))
def system_info(ctx):
"""Display CSE server info."""
CLIENT_LOGGER.debug(f'Executing command: {ctx.command_path}')
try:
restore_session(ctx)
client = ctx.obj['client']
system = System(client)
result = system.get_info()
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, template_name,
template_revision, cpu, memory, ssh_key_file):
"""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).
"""
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 not client.is_sysadmin() and org_name is None:
org_name = ctx.obj['profiles'].get('org_in_use')
ssh_key = None
if ssh_key_file:
ssh_key = ssh_key_file.read()
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,
template_name=template_name,
template_revision=template_revision,
cpu=cpu,
memory=memory,
ssh_key=ssh_key)
stdout(result, ctx)
CLIENT_LOGGER.debug(result)
except CseResponseError as e:
minor_error_code_to_error_message = {
MinorErrorCode.REQUEST_KEY_NETWORK_NAME_MISSING: 'Missing option "-n" / "--network".', # noqa: E501
MinorErrorCode.REQUEST_KEY_NETWORK_NAME_INVALID: 'Invalid or missing value for option "-n" / "--network".' # noqa: E501
}
e.error_message = \
minor_error_code_to_error_message.get(
e.minor_error_code, e.error_message)
stderr(e, ctx)
CLIENT_LOGGER.error(str(e))
except Exception as e:
stderr(e, ctx)
CLIENT_LOGGER.error(str(e))
def compute_policy_list(ctx, org_name, ovdc_name):
CLIENT_LOGGER.debug(f'Executing command: {ctx.command_path}')
try:
restore_session(ctx)
client = ctx.obj['client']
if not client.is_sysadmin():
raise Exception("Insufficient permission to perform operation.")
ovdc = Ovdc(client)
result = ovdc.list_ovdc_compute_policies(ovdc_name, org_name)
stdout(result, ctx)
CLIENT_LOGGER.debug(result)
except Exception as e:
stderr(e, ctx)
CLIENT_LOGGER.error(str(e))
def list_clusters(ctx, vdc, org_name):
"""Display clusters in Ent-PKS that are visible to the logged in user."""
CLIENT_LOGGER.debug(f'Executing command: {ctx.command_path}')
try:
client_utils.cse_restore_session(ctx)
client = ctx.obj['client']
cluster = PksCluster(client)
if not client.is_sysadmin() and org_name is None:
org_name = ctx.obj['profiles'].get('org_in_use')
result = cluster.get_clusters(vdc=vdc, org=org_name)
stdout(result, ctx, show_id=True, sort_headers=False)
CLIENT_LOGGER.debug(result)
except Exception as e:
stderr(e, ctx)
CLIENT_LOGGER.error(str(e))
def cluster_info(ctx, cluster_name, org, vdc):
"""Display info about an Ent-PKS K8 cluster."""
CLIENT_LOGGER.debug(f'Executing command: {ctx.command_path}')
try:
client_utils.cse_restore_session(ctx)
client = ctx.obj['client']
cluster = PksCluster(client)
if not client.is_sysadmin() and org is None:
org = ctx.obj['profiles'].get('org_in_use')
cluster_info = cluster.get_cluster_info(cluster_name, org=org, vdc=vdc)
stdout(cluster_info, ctx, show_id=True)
CLIENT_LOGGER.debug(cluster_info)
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."""
CLIENT_LOGGER.debug(f'Executing command: {ctx.command_path}')
try:
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))
def node_info(ctx, cluster_name, node_name, org_name, vdc):
"""Display info about a node in a native Kubernetes provider cluster."""
CLIENT_LOGGER.debug(f'Executing command: {ctx.command_path}')
try:
restore_session(ctx)
client = ctx.obj['client']
cluster = Cluster(client)
if org_name is None and not client.is_sysadmin():
org_name = ctx.obj['profiles'].get('org_in_use')
node_info = cluster.get_node_info(cluster_name, node_name,
org_name, vdc)
stdout(node_info, ctx, show_id=True)
CLIENT_LOGGER.debug(node_info)
except Exception as e:
stderr(e, ctx)
CLIENT_LOGGER.error(str(e))
def list_nodes(ctx, name, org, vdc):
"""Display nodes of a cluster that uses native Kubernetes provider."""
CLIENT_LOGGER.debug(f'Executing command: {ctx.command_path}')
try:
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)
cluster_info = cluster.get_cluster_info(name, org=org, vdc=vdc)
if cluster_info.get(K8S_PROVIDER_KEY) != K8sProvider.NATIVE:
raise Exception("'node list' operation is not supported by non "
"native clusters.")
all_nodes = cluster_info['master_nodes'] + cluster_info['nodes']
stdout(all_nodes, ctx, show_id=True)
CLIENT_LOGGER.debug(all_nodes)
except Exception as e:
stderr(e, ctx)
CLIENT_LOGGER.error(str(e))
def ovdc_info(ctx, ovdc_name, org_name):
"""Display information about Kubernetes provider 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.info_ovdc_for_k8s(ovdc_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 compute_policy_remove(ctx, org_name, ovdc_name, compute_policy_name,
remove_compute_policy_from_vms):
CLIENT_LOGGER.debug(f'Executing command: {ctx.command_path}')
try:
restore_session(ctx)
client = ctx.obj['client']
if not client.is_sysadmin():
raise Exception("Insufficient permission to perform operation.")
ovdc = Ovdc(client)
result = ovdc.update_ovdc_compute_policies(ovdc_name,
org_name,
compute_policy_name,
ComputePolicyAction.REMOVE,
remove_compute_policy_from_vms) # noqa: E501
stdout(result, ctx)
CLIENT_LOGGER.debug(result)
except Exception as e:
stderr(e, ctx)
CLIENT_LOGGER.error(str(e))
def cluster_config(ctx, name, vdc, org):
"""Display cluster configuration.
To write to a file: `vcd cse cluster config mycluster > ~/.kube/my_config`
"""
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')
cluster_config = cluster.get_cluster_config(name, vdc=vdc, org=org).get(RESPONSE_MESSAGE_KEY) # noqa: E501
if os.name == 'nt':
cluster_config = str.replace(cluster_config, '\n', '\r\n')
click.secho(cluster_config)
CLIENT_LOGGER.debug(cluster_config)
except Exception as e:
stderr(e, ctx)
CLIENT_LOGGER.error(str(e))
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_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 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_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 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))