def version(ctx):
"""Display version of CSE plug-in."""
CLIENT_LOGGER.debug(f'Executing command: {ctx.command_path}')
ver_obj = Service.version()
ver_str = '%s, %s, version %s' % (ver_obj['product'],
ver_obj['description'],
ver_obj['version'])
stdout(ver_obj, ctx, ver_str)
CLIENT_LOGGER.debug(ver_str)
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 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_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 get_command(self, ctx, cmd_name):
"""Override this click method to customize.
:param click.core.Context ctx: Click Context
:param str cmd_name: name of the command (ex:create, delete, resize)
:return: Click command object for 'cmd_name'
:rtype: click.Core.Command
"""
try:
if not type(ctx.obj) is dict or not ctx.obj.get('client'):
client_utils.cse_restore_session(ctx)
client = ctx.obj['client']
version = client.get_api_version()
# Skipping some commands when CSE server is not running
if client_utils.is_cli_for_tkg_only() and \
cmd_name in [*UNSUPPORTED_COMMANDS_WITH_SERVER_NOT_RUNNING_BY_VERSION.get(version, []), # noqa: E501
*UNSUPPORTED_SUBCOMMANDS_WITH_SERVER_NOT_RUNNING_BY_VERSION.get(version, {}).get(self.name, [])]: # noqa: E501
return None
# Skip the command if not supported
if cmd_name in UNSUPPORTED_COMMANDS_BY_VERSION.get(version, []):
return None
# Skip the subcommand if not supported
unsupported_subcommands = UNSUPPORTED_SUBCOMMANDS_BY_VERSION.get(
version, {}).get(self.name, []) # noqa: E501
if cmd_name in unsupported_subcommands:
return None
cmd = click.Group.get_command(self, ctx, cmd_name)
unsupported_params = UNSUPPORTED_SUBCOMMAND_OPTIONS_BY_VERSION.get(
version, {}).get(self.name, {}).get(cmd_name, []) # noqa: E501
# Remove all unsupported options for this subcommand, if any
filtered_params = [
param for param in cmd.params
if param.name not in unsupported_params
] # noqa: E501
cmd.params = filtered_params
except Exception as e:
CLIENT_LOGGER.debug(f'exception while filtering {cmd_name}: {e}')
pass
return click.Group.get_command(self, ctx, cmd_name)
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 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 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 list_clusters(self, vdc=None, org=None):
filters = {
shared_constants.RequestKey.ORG_NAME: org,
shared_constants.RequestKey.OVDC_NAME: vdc
}
clusters_resp = self._native_cluster_api.list_clusters(filters=filters)
CLIENT_LOGGER.debug(clusters_resp)
clusters = []
for c in clusters_resp:
# TODO cluster api response keys need to be more well defined
cluster = {
'Name': c.get('name', 'N/A'),
'Owner': c.get('owner_name', 'N/A'),
'VDC': c.get('vdc', 'N/A'),
'Org': c.get('org_name', 'N/A'),
'K8s Runtime': c.get('k8s_type', 'N/A'),
'K8s Version': c.get('k8s_version', 'N/A'),
'Status': c.get('status', 'N/A'),
'Provider': c.get('k8s_provider', 'N/A'),
}
clusters.append(cluster)
return clusters
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 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 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 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 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 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 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 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 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 cluster_delete(ctx, cluster_name, vdc, org):
"""Delete an Ent-PKS 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')
result = cluster.delete_cluster(cluster_name, org, vdc)
# result is empty for delete cluster operation on Ent-PKS clusters.
# In that specific case, below check helps to print out a meaningful
# message to users.
if len(result) == 0:
msg = f"Delete cluster operation has been initiated on " \
f"{cluster_name}, please check the status using" \
f" 'vcd cse pks-cluster info {cluster_name}'."
click.secho(msg, fg='yellow')
CLIENT_LOGGER.debug(msg)
stdout(result, ctx)
CLIENT_LOGGER.debug(result)
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 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 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 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 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))
