def run(ctx, config, skip_check):
"""Run CSE service."""
try:
check_python_version(ConsoleMessagePrinter())
except Exception as err:
click.secho(str(err), fg='red')
sys.exit(1)
try:
service = Service(config, should_check_config=not skip_check)
service.run(msg_update_callback=ConsoleMessagePrinter())
except (NotAcceptableException, VcdException, ValueError, KeyError,
TypeError) as err:
click.secho(str(err), fg='red')
except AmqpConnectionError as err:
click.secho(str(err), fg='red')
click.secho("check config file amqp section.", fg='red')
except requests.exceptions.ConnectionError as err:
click.secho(f"Cannot connect to {err.request.url}.", fg='red')
except vim.fault.InvalidLogin:
click.secho("vCenter login failed (check config file vCenter "
"username/password).", fg='red')
except Exception as err:
click.secho(str(err), fg='red')
click.secho("CSE Server failure. Please check the logs.", fg='red')
def install(ctx, config, skip_template_creation, force_update,
retain_temp_vapp, ssh_key_file):
"""Install CSE on vCloud Director."""
try:
check_python_version(ConsoleMessagePrinter())
except Exception as err:
click.secho(str(err), fg='red')
sys.exit(1)
if retain_temp_vapp and not ssh_key_file:
click.echo('Must provide ssh-key file (using --ssh-key OR -k) if '
'--no-capture is True, or else temporary vm will '
'be inaccessible')
return
ssh_key = None
if ssh_key_file is not None:
ssh_key = ssh_key_file.read()
try:
install_cse(ctx, config_file_name=config,
skip_template_creation=skip_template_creation,
force_update=force_update, ssh_key=ssh_key,
retain_temp_vapp=retain_temp_vapp,
msg_update_callback=ConsoleMessagePrinter())
except (EntityNotFoundException, NotAcceptableException, VcdException,
ValueError, KeyError, TypeError) as err:
click.secho(str(err), fg='red')
except AmqpConnectionError as err:
click.secho(str(err), fg='red')
click.secho("check config file amqp section.", fg='red')
except requests.exceptions.ConnectionError as err:
click.secho(f"Cannot connect to {err.request.url}.", fg='red')
except vim.fault.InvalidLogin:
click.secho("vCenter login failed (check config file vCenter "
"username/password).", fg='red')
def check(ctx, config, check_install):
"""Validate CSE config file."""
try:
check_python_version(ConsoleMessagePrinter())
except Exception as err:
click.secho(str(err), fg='red')
sys.exit(1)
config_dict = None
try:
config_dict = get_validated_config(
config, msg_update_callback=ConsoleMessagePrinter())
except (NotAcceptableException, VcdException, ValueError,
KeyError, TypeError) as err:
click.secho(str(err), fg='red')
except AmqpConnectionError as err:
click.secho(str(err), fg='red')
click.secho("check config file amqp section.", fg='red')
except requests.exceptions.ConnectionError as err:
click.secho(f"Cannot connect to {err.request.url}.", fg='red')
except vim.fault.InvalidLogin:
click.secho("vCenter login failed (check config file vCenter "
"username/password).", fg='red')
if check_install and config_dict:
try:
check_cse_installation(
config_dict, msg_update_callback=ConsoleMessagePrinter())
except Exception as err:
click.secho(f"Error : {err}")
click.secho("CSE installation is invalid", fg='red')
def install(ctx, config, template, update, no_capture, ssh_key_file):
"""Install CSE on vCloud Director."""
try:
check_python_version()
except Exception as err:
click.secho(str(err), fg='red')
sys.exit(0)
if no_capture and ssh_key_file is None:
click.echo('Must provide ssh-key file (using --ssh-key OR -k) if '
'--no-capture is True, or else temporary vm will '
'be inaccessible')
return
ssh_key = None
if ssh_key_file is not None:
ssh_key = ssh_key_file.read()
try:
install_cse(ctx, config_file_name=config, template_name=template,
update=update, no_capture=no_capture, ssh_key=ssh_key)
except (EntityNotFoundException, NotAcceptableException, VcdException,
ValueError, KeyError, TypeError) as err:
click.secho(str(err), fg='red')
except AmqpConnectionError as err:
click.secho(str(err), fg='red')
click.secho("check config file amqp section.", fg='red')
except requests.exceptions.ConnectionError:
click.secho("Cannot connect to vCD host (check config file vCD host).",
fg='red')
except vim.fault.InvalidLogin:
click.secho("vCenter login failed (check config file vCenter "
"username/password).", fg='red')
def check(ctx, config, check_install, template):
"""Validate CSE config file."""
try:
check_python_version()
except Exception as err:
click.secho(str(err), fg='red')
sys.exit(0)
config_dict = None
try:
config_dict = get_validated_config(config)
except (NotAcceptableException, VcdException, ValueError,
KeyError, TypeError) as err:
click.secho(str(err), fg='red')
except AmqpConnectionError as err:
click.secho(str(err), fg='red')
click.secho("check config file amqp section.", fg='red')
except requests.exceptions.ConnectionError:
click.secho("Cannot connect to vCD host (check config file vCD host).",
fg='red')
except vim.fault.InvalidLogin:
click.secho("vCenter login failed (check config file vCenter "
"username/password).", fg='red')
if not check_install or config_dict is None:
return
try:
check_cse_installation(config_dict, check_template=template)
except EntityNotFoundException:
click.secho("CSE installation is invalid", fg='red')
def sample(ctx, output, pks_config):
"""Display sample CSE config file contents."""
try:
check_python_version()
except Exception as err:
click.secho(str(err), fg='red')
sys.exit(1)
click.secho(
generate_sample_config(output=output, generate_pks_config=pks_config))
def install(ctx, config, pks_config, skip_config_decryption,
skip_template_creation, force_update, retain_temp_vapp,
ssh_key_file):
"""Install CSE on vCloud Director."""
if skip_config_decryption:
password = None
else:
password = os.getenv('CSE_CONFIG_PASSWORD') or prompt_text(
PASSWORD_FOR_CONFIG_DECRYPTION_MSG, color='green', hide_input=True)
try:
check_python_version(ConsoleMessagePrinter())
except Exception as err:
click.secho(str(err), fg='red')
sys.exit(1)
if retain_temp_vapp and not ssh_key_file:
click.echo('Must provide ssh-key file (using --ssh-key OR -k) if '
'--retain-temp-vapp is provided, or else temporary vm will '
'be inaccessible')
sys.exit(1)
ssh_key = None
if ssh_key_file is not None:
ssh_key = ssh_key_file.read()
try:
install_cse(config_file_name=config,
pks_config_file_name=pks_config,
skip_template_creation=skip_template_creation,
force_update=force_update,
ssh_key=ssh_key,
retain_temp_vapp=retain_temp_vapp,
skip_config_decryption=skip_config_decryption,
decryption_password=password,
msg_update_callback=ConsoleMessagePrinter())
except (EntityNotFoundException, NotAcceptableException, VcdException,
ValueError, KeyError, TypeError) as err:
click.secho(str(err), fg='red')
except AmqpConnectionError as err:
click.secho(str(err), fg='red')
click.secho("check config file amqp section.", fg='red')
except requests.exceptions.ConnectionError as err:
click.secho(f"Cannot connect to {err.request.url}.", fg='red')
except vim.fault.InvalidLogin:
click.secho(
"vCenter login failed (check config file vCenter "
"username/password).",
fg='red')
except cryptography.fernet.InvalidToken:
click.secho(CONFIG_DECRYPTION_ERROR_MSG, fg='red')
def encrypt(ctx, input_file, password, output_file):
"""Encrypt CSE config file."""
password = os.getenv('CSE_CONFIG_PASSWORD') or prompt_text(
PASSWORD_FOR_CONFIG_ENCRYPTION_MSG, hide_input=True, color='green')
try:
check_python_version(ConsoleMessagePrinter())
encrypt_file(input_file, password, output_file)
except cryptography.fernet.InvalidToken:
click.secho("Encryption failed: invalid password", fg='red')
sys.exit(1)
except Exception as err:
click.secho(str(err), fg='red')
sys.exit(1)
click.secho("\nEncryption is successfully completed", fg='green')
def check(ctx, config, pks_config, skip_config_decryption, check_install):
"""Validate CSE config file."""
if skip_config_decryption:
password = None
else:
password = os.getenv('CSE_CONFIG_PASSWORD') or prompt_text(
PASSWORD_FOR_CONFIG_DECRYPTION_MSG, color='green', hide_input=True)
try:
check_python_version(ConsoleMessagePrinter())
except Exception as err:
click.secho(str(err), fg='red')
sys.exit(1)
config_dict = None
try:
config_dict = get_validated_config(
config,
pks_config_file_name=pks_config,
skip_config_decryption=skip_config_decryption,
decryption_password=password,
msg_update_callback=ConsoleMessagePrinter())
except (NotAcceptableException, VcdException, ValueError, KeyError,
TypeError) as err:
click.secho(str(err), fg='red')
except AmqpConnectionError as err:
click.secho(str(err), fg='red')
click.secho("check config file amqp section.", fg='red')
except requests.exceptions.ConnectionError as err:
click.secho(f"Cannot connect to {err.request.url}.", fg='red')
except cryptography.fernet.InvalidToken:
click.secho(CONFIG_DECRYPTION_ERROR_MSG, fg='red')
except vim.fault.InvalidLogin:
click.secho(
"vCenter login failed (check config file vCenter "
"username/password).",
fg='red')
if check_install and config_dict:
try:
check_cse_installation(config_dict,
msg_update_callback=ConsoleMessagePrinter())
except Exception as err:
click.secho(f"Error : {err}")
click.secho("CSE installation is invalid", fg='red')
def run(ctx, config, pks_config, skip_check, skip_config_decryption):
"""Run CSE service."""
if skip_config_decryption:
password = None
else:
password = os.getenv('CSE_CONFIG_PASSWORD') or prompt_text(
PASSWORD_FOR_CONFIG_DECRYPTION_MSG, color='green', hide_input=True)
try:
check_python_version(ConsoleMessagePrinter())
except Exception as err:
click.secho(str(err), fg='red')
sys.exit(1)
try:
service = Service(config,
pks_config_file=pks_config,
should_check_config=not skip_check,
skip_config_decryption=skip_config_decryption,
decryption_password=password)
service.run(msg_update_callback=ConsoleMessagePrinter())
except (NotAcceptableException, VcdException, ValueError, KeyError,
TypeError) as err:
click.secho(str(err), fg='red')
except AmqpConnectionError as err:
click.secho(str(err), fg='red')
click.secho("check config file amqp section.", fg='red')
except requests.exceptions.ConnectionError as err:
click.secho(f"Cannot connect to {err.request.url}.", fg='red')
except vim.fault.InvalidLogin:
click.secho(
"vCenter login failed (check config file vCenter "
"username/password).",
fg='red')
except cryptography.fernet.InvalidToken:
click.secho(CONFIG_DECRYPTION_ERROR_MSG, fg='red')
except Exception as err:
click.secho(str(err), fg='red')
click.secho("CSE Server failure. Please check the logs.", fg='red')
def list_template(ctx, config_file_name, skip_config_decryption,
display_option):
"""List CSE k8s templates."""
if skip_config_decryption:
password = None
else:
password = os.getenv('CSE_CONFIG_PASSWORD') or prompt_text(
PASSWORD_FOR_CONFIG_DECRYPTION_MSG, color='green', hide_input=True)
try:
console_message_printer = ConsoleMessagePrinter()
try:
check_python_version()
except Exception as err:
click.secho(str(err), fg='red')
sys.exit(1)
# We don't want to validate config file, because server startup or
# installation is not being perfomred. If values in config file are
# missing or bad, appropriate exception will be raised while accessing
# or using them.
if skip_config_decryption:
with open(config_file_name) as config_file:
config_dict = yaml.safe_load(config_file) or {}
else:
console_message_printer.info(f"Decrypting '{config_file_name}'")
config_dict = yaml.safe_load(
get_decrypted_file_contents(config_file_name, password)) or {}
local_templates = []
if display_option in (DISPLAY_ALL, DISPLAY_DIFF, DISPLAY_LOCAL):
client = None
try:
# To suppress the warning message that pyvcloud prints if
# ssl_cert verification is skipped.
if not config_dict['vcd']['verify']:
requests.packages.urllib3.disable_warnings()
client = Client(config_dict['vcd']['host'],
api_version=config_dict['vcd']['api_version'],
verify_ssl_certs=config_dict['vcd']['verify'])
credentials = BasicLoginCredentials(
config_dict['vcd']['username'], SYSTEM_ORG_NAME,
config_dict['vcd']['password'])
client.set_credentials(credentials)
org_name = config_dict['broker']['org']
catalog_name = config_dict['broker']['catalog']
local_template_definitions = \
get_all_k8s_local_template_definition(
client=client,
catalog_name=catalog_name,
org_name=org_name)
default_template_name = \
config_dict['broker']['default_template_name']
default_template_revision = \
str(config_dict['broker']['default_template_revision'])
for definition in local_template_definitions:
template = {}
template['name'] = definition[LocalTemplateKey.NAME]
template['revision'] = \
definition[LocalTemplateKey.REVISION]
template['compute_policy'] = \
definition[LocalTemplateKey.COMPUTE_POLICY]
template['local'] = True
template['remote'] = False
if str(definition[LocalTemplateKey.REVISION]
) == default_template_revision and definition[
LocalTemplateKey.
NAME] == default_template_name: # noqa: E501
template['default'] = True
else:
template['default'] = False
template['deprecated'] = \
str_to_bool(definition[LocalTemplateKey.DEPRECATED])
template['cpu'] = definition[LocalTemplateKey.CPU]
template['memory'] = definition[LocalTemplateKey.MEMORY]
template['description'] = \
definition[LocalTemplateKey.DESCRIPTION]
local_templates.append(template)
finally:
if client:
client.logout()
remote_templates = []
if display_option in (DISPLAY_ALL, DISPLAY_DIFF, DISPLAY_REMOTE):
rtm = RemoteTemplateManager(
remote_template_cookbook_url=config_dict['broker']
['remote_template_cookbook_url'], # noqa: E501
msg_update_callback=ConsoleMessagePrinter())
remote_template_cookbook = rtm.get_remote_template_cookbook()
remote_template_definitions = remote_template_cookbook['templates']
for definition in remote_template_definitions:
template = {}
template['name'] = definition[RemoteTemplateKey.NAME]
template['revision'] = definition[RemoteTemplateKey.REVISION]
template['compute_policy'] = \
definition[RemoteTemplateKey.COMPUTE_POLICY]
template['local'] = False
template['remote'] = True
template['default'] = False
template['deprecated'] = \
str_to_bool(definition[RemoteTemplateKey.DEPRECATED])
template['cpu'] = definition[RemoteTemplateKey.CPU]
template['memory'] = definition[RemoteTemplateKey.MEMORY]
template['description'] = \
definition[RemoteTemplateKey.DESCRIPTION]
remote_templates.append(template)
result = []
if display_option is DISPLAY_ALL:
result = remote_templates
# If local copy of template exists, update the remote definition
# with relevant values, else add the local definition to the result
# list.
for local_template in local_templates:
found = False
for remote_template in remote_templates:
if str(local_template[LocalTemplateKey.REVISION]) == str(
remote_template[RemoteTemplateKey.REVISION]
) and local_template[
LocalTemplateKey.NAME] == remote_template[
RemoteTemplateKey.NAME]: # noqa: E501
remote_template['compute_policy'] = \
local_template['compute_policy']
remote_template['local'] = local_template['local']
remote_template['default'] = local_template['default']
found = True
break
if not found:
result.append(local_template)
elif display_option in DISPLAY_DIFF:
for remote_template in remote_templates:
found = False
for local_template in local_templates:
if str(local_template[LocalTemplateKey.REVISION]) == str(
remote_template[RemoteTemplateKey.REVISION]
) and local_template[
LocalTemplateKey.NAME] == remote_template[
RemoteTemplateKey.NAME]: # noqa: E501
found = True
break
if not found:
result.append(remote_template)
elif display_option in DISPLAY_LOCAL:
result = local_templates
elif display_option in DISPLAY_REMOTE:
result = remote_templates
stdout(result, ctx, sort_headers=False)
except cryptography.fernet.InvalidToken:
click.secho(CONFIG_DECRYPTION_ERROR_MSG, fg='red')
except Exception as err:
click.secho(str(err), fg='red')
def convert_cluster(ctx, config_file_name, skip_config_decryption,
cluster_name, admin_password, org_name, vdc_name,
skip_wait_for_gc):
if skip_config_decryption:
decryption_password = None
else:
decryption_password = os.getenv('CSE_CONFIG_PASSWORD') or prompt_text(
PASSWORD_FOR_CONFIG_DECRYPTION_MSG, color='green', hide_input=True)
try:
check_python_version()
except Exception as err:
click.secho(str(err), fg='red')
sys.exit(1)
client = None
try:
console_message_printer = ConsoleMessagePrinter()
config = get_validated_config(
config_file_name,
skip_config_decryption=skip_config_decryption,
decryption_password=decryption_password,
msg_update_callback=console_message_printer)
log_filename = None
log_wire = str_to_bool(config['service'].get('log_wire'))
if log_wire:
log_filename = 'cluster_convert_wire.log'
client = Client(config['vcd']['host'],
api_version=config['vcd']['api_version'],
verify_ssl_certs=config['vcd']['verify'],
log_file=log_filename,
log_requests=log_wire,
log_headers=log_wire,
log_bodies=log_wire)
credentials = BasicLoginCredentials(config['vcd']['username'],
SYSTEM_ORG_NAME,
config['vcd']['password'])
client.set_credentials(credentials)
msg = f"Connected to vCD as system administrator: " \
f"{config['vcd']['host']}:{config['vcd']['port']}"
console_message_printer.general(msg)
cluster_records = get_all_clusters(client=client,
cluster_name=cluster_name,
org_name=org_name,
ovdc_name=vdc_name)
if len(cluster_records) == 0:
console_message_printer.info(f"No clusters were found.")
return
vms = []
for cluster in cluster_records:
console_message_printer.info(
f"Processing cluster '{cluster['name']}'.")
vapp_href = cluster['vapp_href']
vapp = VApp(client, href=vapp_href)
# this step removes the old 'cse.template' metadata and adds
# cse.template.name and cse.template.revision metadata
# using hard-coded values taken from github history
console_message_printer.info("Processing metadata of cluster.")
metadata_dict = metadata_to_dict(vapp.get_metadata())
old_template_name = metadata_dict.get(
ClusterMetadataKey.BACKWARD_COMPATIBILE_TEMPLATE_NAME
) # noqa: E501
new_template_name = None
cse_version = metadata_dict.get(ClusterMetadataKey.CSE_VERSION)
if old_template_name:
console_message_printer.info(
"Determining k8s version on cluster.")
if 'photon' in old_template_name:
new_template_name = 'photon-v2'
if cse_version in ('1.0.0'):
new_template_name += '_k8s-1.8_weave-2.0.5'
elif cse_version in ('1.1.0', '1.2.0', '1.2.1', '1.2.2',
'1.2.3', '1.2.4'): # noqa: E501
new_template_name += '_k8s-1.9_weave-2.3.0'
elif cse_version in (
'1.2.5',
'1.2.6',
'1.2.7',
): # noqa: E501
new_template_name += '_k8s-1.10_weave-2.3.0'
elif cse_version in ('2.0.0'):
new_template_name += '_k8s-1.12_weave-2.3.0'
elif 'ubuntu' in old_template_name:
new_template_name = 'ubuntu-16.04'
if cse_version in ('1.0.0'):
new_template_name += '_k8s-1.9_weave-2.1.3'
elif cse_version in ('1.1.0', '1.2.0', '1.2.1', '1.2.2',
'1.2.3', '1.2.4', '1.2.5', '1.2.6',
'1.2.7'): # noqa: E501
new_template_name += '_k8s-1.10_weave-2.3.0'
elif cse_version in ('2.0.0'):
new_template_name += '_k8s-1.13_weave-2.3.0'
if new_template_name:
console_message_printer.info("Updating metadata of cluster.")
task = vapp.remove_metadata(
ClusterMetadataKey.BACKWARD_COMPATIBILE_TEMPLATE_NAME
) # noqa: E501
client.get_task_monitor().wait_for_success(task)
new_metadata_to_add = {
ClusterMetadataKey.TEMPLATE_NAME: new_template_name,
ClusterMetadataKey.TEMPLATE_REVISION: 0
}
task = vapp.set_multiple_metadata(new_metadata_to_add)
client.get_task_monitor().wait_for_success(task)
# this step uses hard-coded data from the newly updated
# cse.template.name and cse.template.revision metadata fields as
# well as github history to add [cse.os, cse.docker.version,
# cse.kubernetes, cse.kubernetes.version, cse.cni, cse.cni.version]
# to the clusters
vapp.reload()
metadata_dict = metadata_to_dict(vapp.get_metadata())
template_name = metadata_dict.get(ClusterMetadataKey.TEMPLATE_NAME)
template_revision = str(
metadata_dict.get(ClusterMetadataKey.TEMPLATE_REVISION,
'0')) # noqa: E501
if template_name:
k8s_version, docker_version = get_k8s_and_docker_versions(
template_name,
template_revision=template_revision,
cse_version=cse_version) # noqa: E501
tokens = template_name.split('_')
new_metadata = {
ClusterMetadataKey.OS: tokens[0],
ClusterMetadataKey.DOCKER_VERSION: docker_version,
ClusterMetadataKey.KUBERNETES: 'upstream',
ClusterMetadataKey.KUBERNETES_VERSION: k8s_version,
ClusterMetadataKey.CNI: tokens[2].split('-')[0],
ClusterMetadataKey.CNI_VERSION: tokens[2].split('-')[1],
}
task = vapp.set_multiple_metadata(new_metadata)
client.get_task_monitor().wait_for_success(task)
console_message_printer.general(
"Finished processing metadata of cluster.")
reset_admin_pw = False
vm_resources = vapp.get_all_vms()
for vm_resource in vm_resources:
try:
vapp.get_admin_password(vm_resource.get('name'))
except EntityNotFoundException:
reset_admin_pw = True
break
if reset_admin_pw:
try:
console_message_printer.info(
f"Undeploying the vApp '{cluster['name']}'")
task = vapp.undeploy()
client.get_task_monitor().wait_for_success(task)
console_message_printer.general(
"Successfully undeployed the vApp.")
except Exception as err:
console_message_printer.error(str(err))
for vm_resource in vm_resources:
console_message_printer.info(
f"Processing vm '{vm_resource.get('name')}'.")
vm = VM(client, href=vm_resource.get('href'))
vms.append(vm)
console_message_printer.info("Updating vm admin password")
task = vm.update_guest_customization_section(
enabled=True,
admin_password_enabled=True,
admin_password_auto=not admin_password,
admin_password=admin_password,
)
client.get_task_monitor().wait_for_success(task)
console_message_printer.general("Successfully updated vm")
console_message_printer.info("Deploying vm.")
task = vm.power_on_and_force_recustomization()
client.get_task_monitor().wait_for_success(task)
console_message_printer.general("Successfully deployed vm")
console_message_printer.info("Deploying cluster")
task = vapp.deploy(power_on=True)
client.get_task_monitor().wait_for_success(task)
console_message_printer.general(
"Successfully deployed cluster") # noqa: E501
console_message_printer.general(
f"Successfully processed cluster '{cluster['name']}'")
if skip_wait_for_gc:
return
while True:
to_remove = []
for vm in vms:
status = vm.get_guest_customization_status()
if status != 'GC_PENDING':
to_remove.append(vm)
for vm in to_remove:
vms.remove(vm)
console_message_printer.info(
f"Waiting on guest customization to finish on {len(vms)} vms.")
if not len(vms) == 0:
time.sleep(5)
else:
break
except cryptography.fernet.InvalidToken:
click.secho(CONFIG_DECRYPTION_ERROR_MSG, fg='red')
except Exception as err:
click.secho(str(err), fg='red')
finally:
if client:
client.logout()
def convert_cluster(ctx, config_file_name, cluster_name, password, org_name,
vdc_name, skip_wait_for_gc):
try:
check_python_version()
except Exception as err:
click.secho(str(err), fg='red')
sys.exit(1)
client = None
try:
console_message_printer = ConsoleMessagePrinter()
config = get_validated_config(
config_file_name, msg_update_callback=console_message_printer)
log_filename = None
log_wire = str_to_bool(config['service'].get('log_wire'))
if log_wire:
log_filename = 'cluster_convert_wire.log'
client = Client(config['vcd']['host'],
api_version=config['vcd']['api_version'],
verify_ssl_certs=config['vcd']['verify'],
log_file=log_filename,
log_requests=log_wire,
log_headers=log_wire,
log_bodies=log_wire)
credentials = BasicLoginCredentials(config['vcd']['username'],
SYSTEM_ORG_NAME,
config['vcd']['password'])
client.set_credentials(credentials)
msg = f"Connected to vCD as system administrator: " \
f"{config['vcd']['host']}:{config['vcd']['port']}"
console_message_printer.general(msg)
cluster_records = get_all_clusters(client=client,
cluster_name=cluster_name,
org_name=org_name,
ovdc_name=vdc_name)
if len(cluster_records) == 0:
console_message_printer.info(f"No clusters were found.")
return
vms = []
for cluster in cluster_records:
console_message_printer.info(
f"Processing cluster '{cluster['name']}'.")
vapp_href = cluster['vapp_href']
vapp = VApp(client, href=vapp_href)
console_message_printer.info("Processing metadata of cluster.")
metadata = metadata_to_dict(vapp.get_metadata())
old_template_name = None
new_template_name = None
if ClusterMetadataKey.BACKWARD_COMPATIBILE_TEMPLATE_NAME in metadata: # noqa: E501
old_template_name = metadata.pop(ClusterMetadataKey.BACKWARD_COMPATIBILE_TEMPLATE_NAME) # noqa: E501
version = metadata.get(ClusterMetadataKey.CSE_VERSION)
if old_template_name:
console_message_printer.info(
"Determining k8s version on cluster.")
if 'photon' in old_template_name:
new_template_name = 'photon-v2'
if '1.0.0' in version:
new_template_name += '_k8s-1.8_weave-2.0.5'
elif any(ver in version for ver in ('1.1.0', '1.2.0', '1.2.1', '1.2.2', '1.2.3', '1.2.4',)): # noqa: E501
new_template_name += '_k8s-1.9_weave-2.3.0'
elif any(ver in version for ver in ('1.2.5', '1.2.6', '1.2.7',)): # noqa: E501
new_template_name += '_k8s-1.10_weave-2.3.0'
elif '2.0.0' in version:
new_template_name += '_k8s-1.12_weave-2.3.0'
elif 'ubuntu' in old_template_name:
new_template_name = 'ubuntu-16.04'
if '1.0.0' in version:
new_template_name += '_k8s-1.9_weave-2.1.3'
elif any(ver in version for ver in ('1.1.0', '1.2.0', '1.2.1', '1.2.2', '1.2.3', '1.2.4', '1.2.5', '1.2.6', '1.2.7')): # noqa: E501
new_template_name += '_k8s-1.10_weave-2.3.0'
elif '2.0.0' in version:
new_template_name += '_k8s-1.13_weave-2.3.0'
if new_template_name:
console_message_printer.info("Updating metadata of cluster.")
task = vapp.remove_metadata(ClusterMetadataKey.BACKWARD_COMPATIBILE_TEMPLATE_NAME) # noqa: E501
client.get_task_monitor().wait_for_success(task)
new_metadata_to_add = {
ClusterMetadataKey.TEMPLATE_NAME: new_template_name,
ClusterMetadataKey.TEMPLATE_REVISION: 0
}
task = vapp.set_multiple_metadata(new_metadata_to_add)
client.get_task_monitor().wait_for_success(task)
console_message_printer.general(
"Finished processing metadata of cluster.")
try:
console_message_printer.info(
f"Undeploying the vApp '{cluster['name']}'")
task = vapp.undeploy()
client.get_task_monitor().wait_for_success(task)
console_message_printer.general(
"Successfully undeployed the vApp.")
except Exception as err:
console_message_printer.error(str(err))
vm_resources = vapp.get_all_vms()
for vm_resource in vm_resources:
console_message_printer.info(
f"Processing vm '{vm_resource.get('name')}'.")
vm = VM(client, href=vm_resource.get('href'))
vms.append(vm)
console_message_printer.info("Updating vm admin password.")
task = vm.update_guest_customization_section(
enabled=True,
admin_password_enabled=True,
admin_password_auto=not password,
admin_password=password,
)
client.get_task_monitor().wait_for_success(task)
console_message_printer.general("Successfully updated vm .")
console_message_printer.info("Deploying vm.")
task = vm.power_on_and_force_recustomization()
client.get_task_monitor().wait_for_success(task)
console_message_printer.general("Successfully deployed vm.")
console_message_printer.info("Deploying cluster")
task = vapp.deploy(power_on=True)
client.get_task_monitor().wait_for_success(task)
console_message_printer.general("Successfully deployed cluster.")
console_message_printer.general(
f"Successfully processed cluster '{cluster['name']}'.")
if skip_wait_for_gc:
return
while True:
for vm in vms:
status = vm.get_guest_customization_status()
if status != 'GC_PENDING':
vms.remove(vm)
console_message_printer.info(
f"Waiting on guest customization to finish on {len(vms)} vms.")
if not len(vms) == 0:
time.sleep(5)
else:
break
except Exception as err:
click.secho(str(err), fg='red')
finally:
if client:
client.logout()
