def get_cluster_info(self, name, headers, body):
result = {}
try:
result['body'] = []
result['status_code'] = OK
self._connect_tenant(headers)
clusters = load_from_metadata(self.client_tenant, name=name)
if len(clusters) == 0:
raise Exception('Cluster \'%s\' not found.' % name)
vapp = VApp(self.client_tenant, href=clusters[0]['vapp_href'])
vms = vapp.get_all_vms()
for vm in vms:
node_info = {
'name': vm.get('name'),
'numberOfCpus': vm.VmSpecSection.NumCpus.text,
'memoryMB':
vm.VmSpecSection.MemoryResourceMb.Configured.text,
'status': VCLOUD_STATUS_MAP.get(int(vm.get('status'))),
'ipAddress': vapp.get_primary_ip(vm.get('name'))
}
if vm.get('name').startswith(TYPE_MASTER):
node_info['node_type'] = 'master'
clusters[0].get('master_nodes').append(node_info)
elif vm.get('name').startswith(TYPE_NODE):
node_info['node_type'] = 'node'
clusters[0].get('nodes').append(node_info)
result['body'] = clusters[0]
except Exception as e:
LOGGER.error(traceback.format_exc())
result['body'] = []
result['status_code'] = INTERNAL_SERVER_ERROR
result['message'] = str(e)
return result
def get_cluster_info(self, cluster_name):
"""Get the info of the cluster.
:param cluster_name: (str): Name of the cluster
:return: (dict): Info of the cluster.
"""
self._connect_tenant()
clusters = load_from_metadata(self.tenant_client, name=cluster_name)
if len(clusters) == 0:
raise CseServerError(f"Cluster '{cluster_name}' not found.")
cluster = clusters[0]
vapp = VApp(self.tenant_client, href=clusters[0]['vapp_href'])
vms = vapp.get_all_vms()
for vm in vms:
node_info = {'name': vm.get('name'), 'ipAddress': ''}
try:
node_info['ipAddress'] = vapp.get_primary_ip(vm.get('name'))
except Exception:
LOGGER.debug(f"Unable to get ip address of node "
f"{vm.get('name')}")
if vm.get('name').startswith(TYPE_MASTER):
cluster.get('master_nodes').append(node_info)
elif vm.get('name').startswith(TYPE_NODE):
cluster.get('nodes').append(node_info)
elif vm.get('name').startswith(TYPE_NFS):
cluster.get('nfs_nodes').append(node_info)
return cluster
def get_cluster_info(self, name):
"""Get the info of the cluster.
:param cluster_name: (str): Name of the cluster
:return: (dict): Info of the cluster.
"""
result = {}
result['body'] = []
result['status_code'] = OK
self._connect_tenant()
clusters = load_from_metadata(self.tenant_client, name=name)
if len(clusters) == 0:
raise CseServerError('Cluster \'%s\' not found.' % name)
vapp = VApp(self.tenant_client, href=clusters[0]['vapp_href'])
vms = vapp.get_all_vms()
for vm in vms:
node_info = {'name': vm.get('name'), 'ipAddress': ''}
try:
node_info['ipAddress'] = vapp.get_primary_ip(vm.get('name'))
except Exception:
LOGGER.debug('cannot get ip address for node %s' %
vm.get('name'))
if vm.get('name').startswith(TYPE_MASTER):
clusters[0].get('master_nodes').append(node_info)
elif vm.get('name').startswith(TYPE_NODE):
clusters[0].get('nodes').append(node_info)
elif vm.get('name').startswith(TYPE_NFS):
clusters[0].get('nfs_nodes').append(node_info)
result['body'] = clusters[0]
return result
def get_all_host(host, org, user, password, vdc):
#Linux guest hosts
linux_os_list = ['CentOS 7 (64-bit)', 'Ubuntu Linux (64-bit)', 'CentOS 8 (64-bit)']
#Windows guest hosts
win_os_list = ['Microsoft Windows Server 2016 or later (64-bit)', 'Microsoft Windows Server 2019 (64-bit)']
#Host list of all Vapps
host_list = {}
client = Client(host,
verify_ssl_certs=True,#SSL
log_requests=False,
log_headers=False,
log_bodies=False)
client.set_highest_supported_version()
client.set_credentials(BasicLoginCredentials(user, org, password))
org_resource = client.get_org()
org = Org(client, resource=org_resource)
vdc_resource = org.get_vdc(vdc)
vdc = VDC(client, resource=vdc_resource)
vapps = vdc.list_resources()
win_list = []
linux_list = []
other_os_list = []
hostvars = {}
for vapp in vapps:
if vapp["type"] == "application/vnd.vmware.vcloud.vApp+xml":
currentHref = vdc.get_vapp_href(vapp["name"])
currentVapp = VApp(client, href=currentHref)
for vm in currentVapp.get_all_vms():
vmName = vm.get('name')
vmOs = VM(client, resource=vm)
vOs = vmOs.get_operating_system_section()
try:
vmIp = currentVapp.get_primary_ip(vmName)
except:
pass
if vmOs.is_powered_on():
if vOs.Description in win_os_list:
win_list.append(vmName)
hostvars.update({vmName:{'ansible_host':vmIp}})
elif vOs.Description in linux_os_list:
linux_list.append(vmName)
hostvars.update({vmName:{'ansible_host':vmIp}})
else:
other_os_list.append(vmName)
hostvars.update({vmName:{'ansible_host':vmIp}})
host_list.update({'windows':{'hosts':win_list}})
host_list.update({'linux':{'hosts':linux_list}})
host_list.update({'others':{'hosts':other_os_list}})
host_list.update({'_meta':{'hostvars':hostvars}})
return host_list
def get_node_info(self, cluster_name, node_name):
"""Get the info of a given node in the cluster.
:param cluster_name: (str): Name of the cluster
:param node_name: (str): Name of the node
:return: (dict): Info of the node.
"""
self._connect_tenant()
clusters = load_from_metadata(
self.tenant_client,
name=cluster_name,
org_name=self.req_spec.get(RequestKey.ORG_NAME),
vdc_name=self.req_spec.get(RequestKey.OVDC_NAME))
if len(clusters) > 1:
raise CseDuplicateClusterError(f"Multiple clusters of name"
f" '{cluster_name}' detected.")
if len(clusters) == 0:
raise ClusterNotFoundError(f"Cluster '{cluster_name}' not found.")
vapp = VApp(self.tenant_client, href=clusters[0]['vapp_href'])
vms = vapp.get_all_vms()
node_info = None
for vm in vms:
if (node_name == vm.get('name')):
node_info = {
'name': vm.get('name'),
'numberOfCpus': '',
'memoryMB': '',
'status': VCLOUD_STATUS_MAP.get(int(vm.get('status'))),
'ipAddress': ''
}
if hasattr(vm, 'VmSpecSection'):
node_info[
'numberOfCpus'] = vm.VmSpecSection.NumCpus.text
node_info[
'memoryMB'] = \
vm.VmSpecSection.MemoryResourceMb.Configured.text
try:
node_info['ipAddress'] = vapp.get_primary_ip(
vm.get('name'))
except Exception:
LOGGER.debug(f"Unable to get ip address of node "
f"{vm.get('name')}")
if vm.get('name').startswith(NodeType.MASTER):
node_info['node_type'] = 'master'
elif vm.get('name').startswith(NodeType.WORKER):
node_info['node_type'] = 'worker'
elif vm.get('name').startswith(NodeType.NFS):
node_info['node_type'] = 'nfs'
exports = self._get_nfs_exports(node_info['ipAddress'],
vapp,
vm)
node_info['exports'] = exports
if node_info is None:
raise NodeNotFoundError(f"Node '{node_name}' not found in "
f"cluster '{cluster_name}'")
return node_info
def get_node_info(self, data):
"""Get node metadata as dictionary.
Required data: cluster_name, node_name
Optional data and default values: org_name=None, ovdc_name=None
"""
required = [
RequestKey.CLUSTER_NAME,
RequestKey.NODE_NAME
]
utils.ensure_keys_in_dict(required, data, dict_name='data')
defaults = {
RequestKey.ORG_NAME: None,
RequestKey.OVDC_NAME: None
}
validated_data = {**defaults, **data}
cluster_name = validated_data[RequestKey.CLUSTER_NAME]
node_name = validated_data[RequestKey.NODE_NAME]
cluster = get_cluster(self.tenant_client, cluster_name,
org_name=validated_data[RequestKey.ORG_NAME],
ovdc_name=validated_data[RequestKey.OVDC_NAME])
vapp = VApp(self.tenant_client, href=cluster['vapp_href'])
vms = vapp.get_all_vms()
node_info = None
for vm in vms:
vm_name = vm.get('name')
if node_name != vm_name:
continue
node_info = {
'name': vm_name,
'numberOfCpus': '',
'memoryMB': '',
'status': VCLOUD_STATUS_MAP.get(int(vm.get('status'))),
'ipAddress': ''
}
if hasattr(vm, 'VmSpecSection'):
node_info['numberOfCpus'] = vm.VmSpecSection.NumCpus.text
node_info['memoryMB'] = vm.VmSpecSection.MemoryResourceMb.Configured.text # noqa: E501
try:
node_info['ipAddress'] = vapp.get_primary_ip(vm_name)
except Exception:
LOGGER.debug(f"Unable to get ip address of node {vm_name}")
if vm_name.startswith(NodeType.MASTER):
node_info['node_type'] = 'master'
elif vm_name.startswith(NodeType.WORKER):
node_info['node_type'] = 'worker'
elif vm_name.startswith(NodeType.NFS):
node_info['node_type'] = 'nfs'
node_info['exports'] = self._get_nfs_exports(node_info['ipAddress'], vapp, vm_name) # noqa: E501
if node_info is None:
raise NodeNotFoundError(f"Node '{node_name}' not found in "
f"cluster '{cluster_name}'")
return node_info
def get_node_info(self, cluster_name, node_name, headers):
"""Get the info of a given node in the cluster.
:param cluster_name: (str): Name of the cluster
:param node_name: (str): Name of the node
:param headers: (str): Request headers
:return: (dict): Info of the node.
"""
result = {}
result['body'] = []
result['status_code'] = OK
self._connect_tenant(headers)
clusters = load_from_metadata(self.client_tenant, name=cluster_name)
if len(clusters) == 0:
raise CseServerError('Cluster \'%s\' not found.' % cluster_name)
vapp = VApp(self.client_tenant, href=clusters[0]['vapp_href'])
vms = vapp.get_all_vms()
node_info = None
for vm in vms:
if (node_name == vm.get('name')):
node_info = {
'name': vm.get('name'),
'numberOfCpus': '',
'memoryMB': '',
'status': VCLOUD_STATUS_MAP.get(int(vm.get('status'))),
'ipAddress': ''
}
if hasattr(vm, 'VmSpecSection'):
node_info['numberOfCpus'] = vm.VmSpecSection.NumCpus.text
node_info[
'memoryMB'] = \
vm.VmSpecSection.MemoryResourceMb.Configured.text
try:
node_info['ipAddress'] = vapp.get_primary_ip(
vm.get('name'))
except Exception:
LOGGER.debug('cannot get ip address '
'for node %s' % vm.get('name'))
if vm.get('name').startswith(TYPE_MASTER):
node_info['node_type'] = 'master'
elif vm.get('name').startswith(TYPE_NODE):
node_info['node_type'] = 'node'
elif vm.get('name').startswith(TYPE_NFS):
node_info['node_type'] = 'nfsd'
exports = self._get_nfs_exports(node_info['ipAddress'],
vapp, vm)
node_info['exports'] = exports
if node_info is None:
raise CseServerError('Node \'%s\' not found in cluster \'%s\'' %
(node_name, cluster_name))
result['body'] = node_info
return result
def info(ctx, vapp_name, vm_name):
try:
client = ctx.obj['client']
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
vapp_resource = vdc.get_vapp(vapp_name)
vapp = VApp(client, resource=vapp_resource)
result = {}
result['primary_ip'] = vapp.get_primary_ip(vm_name)
stdout(result, ctx)
except Exception as e:
stderr(e, ctx)
def list_vms(self):
vapp_name = self.params.get('vapp_name')
vapp_resource = self.vdc.get_vapp(vapp_name)
vapp = VApp(self.client, name=vapp_name, resource=vapp_resource)
response = dict()
response['msg'] = []
for vm in vapp.get_all_vms():
vm_details = dict()
vm_details['name'] = vm.get('name')
vm_details['status'] = VM_STATUSES[vm.get('status')]
vm_details['deployed'] = vm.get('deployed') == 'true'
try:
vm_details['ip_address'] = vapp.get_primary_ip(vm.get('name'))
except:
vm_details['ip_address'] = None
response['msg'].append(vm_details)
return response
def list_vms(self):
vapp_name = self.params.get('vapp_name')
vapp_resource = self.vdc.get_vapp(vapp_name)
vapp = VApp(self.client, name=vapp_name, resource=vapp_resource)
response = dict()
response['msg'] = []
for vm in vapp.get_all_vms():
vm_details = dict()
vm_details['name'] = vm.get('name')
vm_details['status'] = VM_STATUSES[vm.get('status')]
vm_details['deployed'] = vm.get('deployed')=='true'
try:
vm_details['ip_address'] = vapp.get_primary_ip(vm.get('name'))
except:
vm_details['ip_address'] = None
response['msg'].append(vm_details)
return response
def get_cluster_info(self, data):
"""Get cluster metadata as well as node data.
Common broker function that validates data for the 'cluster info'
operation and returns cluster/node metadata as dictionary.
Required data: cluster_name
Optional data and default values: org_name=None, ovdc_name=None
"""
required = [
RequestKey.CLUSTER_NAME
]
utils.ensure_keys_in_dict(required, data, dict_name='data')
defaults = {
RequestKey.ORG_NAME: None,
RequestKey.OVDC_NAME: None
}
validated_data = {**defaults, **data}
cluster_name = validated_data[RequestKey.CLUSTER_NAME]
cluster = get_cluster(self.tenant_client, cluster_name,
org_name=validated_data[RequestKey.ORG_NAME],
ovdc_name=validated_data[RequestKey.OVDC_NAME])
cluster[K8S_PROVIDER_KEY] = K8sProvider.NATIVE
vapp = VApp(self.tenant_client, href=cluster['vapp_href'])
vms = vapp.get_all_vms()
for vm in vms:
node_info = {
'name': vm.get('name'),
'ipAddress': ''
}
try:
node_info['ipAddress'] = vapp.get_primary_ip(vm.get('name'))
except Exception:
LOGGER.debug(f"Unable to get ip address of node "
f"{vm.get('name')}")
if vm.get('name').startswith(NodeType.MASTER):
cluster.get('master_nodes').append(node_info)
elif vm.get('name').startswith(NodeType.WORKER):
cluster.get('nodes').append(node_info)
elif vm.get('name').startswith(NodeType.NFS):
cluster.get('nfs_nodes').append(node_info)
return cluster
def get_cluster_info(self, cluster_name):
"""Get the info of the cluster.
:param cluster_name: (str): Name of the cluster
:return: (dict): Info of the cluster.
"""
self._connect_tenant()
clusters = load_from_metadata(
self.tenant_client,
name=cluster_name,
org_name=self.req_spec.get(RequestKey.ORG_NAME),
vdc_name=self.req_spec.get(RequestKey.OVDC_NAME))
if len(clusters) > 1:
raise CseDuplicateClusterError(f"Multiple clusters of name"
f" '{cluster_name}' detected.")
if len(clusters) == 0:
raise ClusterNotFoundError(f"Cluster '{cluster_name}' not found.")
cluster = clusters[0]
cluster[K8S_PROVIDER_KEY] = K8sProviders.NATIVE
vapp = VApp(self.tenant_client, href=clusters[0]['vapp_href'])
vms = vapp.get_all_vms()
for vm in vms:
node_info = {
'name': vm.get('name'),
'ipAddress': ''
}
try:
node_info['ipAddress'] = vapp.get_primary_ip(
vm.get('name'))
except Exception:
LOGGER.debug(f"Unable to get ip address of node "
f"{vm.get('name')}")
if vm.get('name').startswith(NodeType.MASTER):
cluster.get('master_nodes').append(node_info)
elif vm.get('name').startswith(NodeType.WORKER):
cluster.get('nodes').append(node_info)
elif vm.get('name').startswith(NodeType.NFS):
cluster.get('nfs_nodes').append(node_info)
return cluster
def get_cluster_info(self, name, headers, body):
"""Get the info of the cluster.
:param cluster_name: (str): Name of the cluster
:param headers: (str): Request headers
:return: (dict): Info of the cluster.
"""
result = {}
try:
result['body'] = []
result['status_code'] = OK
self._connect_tenant(headers)
clusters = load_from_metadata(self.client_tenant, name=name)
if len(clusters) == 0:
raise Exception('Cluster \'%s\' not found.' % name)
vapp = VApp(self.client_tenant, href=clusters[0]['vapp_href'])
vms = vapp.get_all_vms()
for vm in vms:
node_info = {'name': vm.get('name'), 'ipAddress': ''}
try:
node_info['ipAddress'] = vapp.get_primary_ip(
vm.get('name'))
except Exception:
LOGGER.debug('cannot get ip address for node %s' %
vm.get('name'))
if vm.get('name').startswith(TYPE_MASTER):
clusters[0].get('master_nodes').append(node_info)
elif vm.get('name').startswith(TYPE_NODE):
clusters[0].get('nodes').append(node_info)
elif vm.get('name').startswith(TYPE_NFS):
clusters[0].get('nfs_nodes').append(node_info)
result['body'] = clusters[0]
except Exception as e:
LOGGER.error(traceback.format_exc())
result['body'] = []
result['status_code'] = INTERNAL_SERVER_ERROR
result['message'] = str(e)
return result
def test_0070_install_update(config, blank_cust_scripts, unregister_cse):
"""Tests installation option: '--update'.
Tests that installation:
- registers cse (when answering yes to prompt),
- creates all templates correctly,
- customizes temp vapps correctly.
command: cse install --config cse_test_config.yaml
--ssh-key ~/.ssh/id_rsa.pub --update --no-capture
required files: cse_test_config.yaml, ~/.ssh/id_rsa.pub,
ubuntu/photon init/cust scripts
expected: cse registered, ubuntu/photon ovas exist, temp vapps exist,
templates exist.
"""
env.prepare_customization_scripts()
result = env.CLI_RUNNER.invoke(cli,
['install',
'--config', env.ACTIVE_CONFIG_FILEPATH,
'--ssh-key', env.SSH_KEY_FILEPATH,
'--update',
'--no-capture'],
input='y\ny',
catch_exceptions=False)
assert result.exit_code == 0
vdc = VDC(env.CLIENT, href=env.VDC_HREF)
# check that cse was registered correctly
is_cse_registered = env.is_cse_registered()
assert is_cse_registered, \
'CSE is not registered as an extension when it should be.'
if is_cse_registered:
assert env.is_cse_registration_valid(config['amqp']['routing_key'],
config['amqp']['exchange']), \
'CSE is registered as an extension, but the extension settings ' \
'on vCD are not the same as config settings.'
# ssh into vms to check for installed software
ssh_client = paramiko.SSHClient()
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
# check that ova files and temp vapps exist
for template_config in config['broker']['templates']:
assert env.catalog_item_exists(template_config['source_ova_name']), \
'Source ova files do not exist when they should.'
temp_vapp_name = template_config['temp_vapp']
try:
vapp_resource = vdc.get_vapp(temp_vapp_name)
except EntityNotFoundException:
assert False, 'vApp does not exist when it should (--no-capture)'
vapp = VApp(env.CLIENT, resource=vapp_resource)
ip = vapp.get_primary_ip(temp_vapp_name)
try:
ssh_client.connect(ip, username='******')
# run different commands depending on OS
if 'photon' in temp_vapp_name:
script = utils.get_data_file(env.STATIC_PHOTON_CUST_SCRIPT)
pattern = r'(kubernetes\S*)'
packages = re.findall(pattern, script)
stdin, stdout, stderr = ssh_client.exec_command("rpm -qa")
installed = [line.strip('.x86_64\n') for line in stdout]
for package in packages:
assert package in installed, \
f"{package} not found in Photon VM"
elif 'ubuntu' in temp_vapp_name:
script = utils.get_data_file(env.STATIC_UBUNTU_CUST_SCRIPT)
pattern = r'((kubernetes|docker\S*|kubelet|kubeadm|kubectl)\S*=\S*)' # noqa
packages = [tup[0] for tup in re.findall(pattern, script)]
cmd = "dpkg -l | grep '^ii' | awk '{print $2\"=\"$3}'"
stdin, stdout, stderr = ssh_client.exec_command(cmd)
installed = [line.strip() for line in stdout]
for package in packages:
assert package in installed, \
f"{package} not found in Ubuntu VM"
finally:
ssh_client.close()
def test_0090_install_retain_temp_vapp(config, unregister_cse_before_test):
"""Test install.
Installation options: '--config', '--template', '--ssh-key',
'--retain-temp-vapp'.
Tests that installation:
- downloads/uploads ova file,
- creates photon temp vapp,
- creates k8s templates
- skips deleting the temp vapp
- checks that proper packages are installed in the vm in temp vApp
command: cse install --config cse_test_config.yaml --retain-temp-vapp
--ssh-key ~/.ssh/id_rsa.pub
required files: ~/.ssh/id_rsa.pub, cse_test_config.yaml
expected: cse registered, catalog exists, source ovas exist,
temp vapps exist, k8s templates exist.
"""
cmd = f"install --config {env.ACTIVE_CONFIG_FILEPATH} --ssh-key " \
f"{env.SSH_KEY_FILEPATH} --retain-temp-vapp"
result = env.CLI_RUNNER.invoke(cli, cmd.split(), catch_exceptions=False)
assert result.exit_code == 0,\
testutils.format_command_info('cse', cmd, result.exit_code,
result.output)
# check that cse was registered correctly
env.check_cse_registration(config['amqp']['routing_key'],
config['amqp']['exchange'])
vdc = VDC(env.CLIENT, href=env.VDC_HREF)
ssh_client = paramiko.SSHClient()
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
for template_config in env.TEMPLATE_DEFINITIONS:
# check that source ova file exists in catalog
assert env.catalog_item_exists(
template_config['source_ova_name']), \
'Source ova file does not existswhen it should.'
# check that k8s templates exist
catalog_item_name = get_revisioned_template_name(
template_config['name'], template_config['revision'])
assert env.catalog_item_exists(catalog_item_name), \
'k8s template does not exist when it should.'
# check that temp vapp exists
temp_vapp_name = testutils.get_temp_vapp_name(template_config['name'])
try:
vdc.reload()
vapp_resource = vdc.get_vapp(temp_vapp_name)
except EntityNotFoundException:
assert False, 'vApp does not exist when it should.'
# ssh into vms to check for installed software
vapp = VApp(env.CLIENT, resource=vapp_resource)
# The temp vapp is shutdown before the template is captured, it
# needs to be powered on before trying to ssh into it.
task = vapp.power_on()
env.CLIENT.get_task_monitor().wait_for_success(task)
# HACK! let the ssh daemon come up
time.sleep(env.WAIT_INTERVAL) # 30 seconds
ip = vapp.get_primary_ip(TEMP_VAPP_VM_NAME)
try:
ssh_client.connect(ip, username='******')
# run different commands depending on OS
if 'photon' in temp_vapp_name:
script_filepath = get_local_script_filepath(
template_config['name'], template_config['revision'],
ScriptFile.CUST)
script = read_data_file(script_filepath)
pattern = r'(kubernetes\S*)'
packages = re.findall(pattern, script)
stdin, stdout, stderr = ssh_client.exec_command("rpm -qa")
installed = [line.strip('.x86_64\n') for line in stdout]
for package in packages:
assert package in installed, \
f"{package} not found in Photon VM"
elif 'ubuntu' in temp_vapp_name:
script_filepath = get_local_script_filepath(
template_config['name'], template_config['revision'],
ScriptFile.CUST)
script = read_data_file(script_filepath)
pattern = r'((kubernetes|docker\S*|kubelet|kubeadm|kubectl)\S*=\S*)' # noqa: E501
packages = [tup[0] for tup in re.findall(pattern, script)]
cmd = "dpkg -l | awk '{print $2\"=\"$3}'"
stdin, stdout, stderr = ssh_client.exec_command(cmd)
installed = [line.strip() for line in stdout]
for package in packages:
assert package in installed, \
f"{package} not found in Ubuntu VM"
finally:
if ssh_client:
ssh_client.close()
def test_0070_install_update(self):
"""Tests installation option: '--update'.
Tests that installation configures amqp (when answering yes to prompt),
registers cse (when answering yes to prompt),
creates all templates correctly,
customizes temp vapps correctly.
command: cse install --config cse_test_config.yaml
--ssh-key ~/.ssh/id_rsa.pub --update --no-capture
required files: cse_test_config.yaml, ~/.ssh/id_rsa.pub,
ubuntu/photon init/cust scripts
expected: cse registered, amqp configured, ubuntu/photon ovas exist,
temp vapps exist, templates exist.
"""
prepare_customization_scripts()
result = self._runner.invoke(cli, [
'install', '--config', ACTIVE_CONFIG_FILEPATH, '--ssh-key',
self._ssh_key_filepath, '--update', '--no-capture'
],
input='y\ny',
catch_exceptions=False)
assert result.exit_code == 0
# reloads required due to inability to wait for catalog deletion.
# vdc can't find vapp unless we reload
self._org.reload()
self._vdc.reload()
# check that amqp was configured
assert not diff_amqp_settings(self._amqp_service, self._config['amqp'])
# check that cse was registered
try:
self._api_extension.get_extension(CSE_NAME,
namespace=CSE_NAMESPACE)
except MissingRecordException:
print('CSE is not registered as an extension when it should be.')
assert False
# ssh into vms to check for installed software
ssh_client = paramiko.SSHClient()
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
# check that ova files and temp vapps exist
for template_config in self._config['broker']['templates']:
try:
self._org.get_catalog_item(self._config['broker']['catalog'],
template_config['source_ova_name'])
except EntityNotFoundException:
print('Source ova files do not exist when they should')
assert False
temp_vapp_name = template_config['temp_vapp']
try:
vapp_resource = self._vdc.get_vapp(temp_vapp_name)
except EntityNotFoundException:
print('vApp does not exist when it should (--no-capture)')
assert False
vapp = VApp(self._client, resource=vapp_resource)
ip = vapp.get_primary_ip(temp_vapp_name)
try:
ssh_client.connect(ip, username='******')
# run different commands depending on OS
if 'photon' in temp_vapp_name:
script = get_data_file(STATIC_PHOTON_CUST_SCRIPT)
pattern = r'(kubernetes\S*)'
packages = re.findall(pattern, script)
stdin, stdout, stderr = ssh_client.exec_command("rpm -qa")
installed = [line.strip('.x86_64\n') for line in stdout]
for package in packages:
if package not in installed:
print(f"{package} not found in Photon VM")
assert False
elif 'ubuntu' in temp_vapp_name:
script = get_data_file(STATIC_UBUNTU_CUST_SCRIPT)
pattern = r'((kubernetes|docker\S*|kubelet|kubeadm|kubectl)\S*=\S*)' # noqa
packages = [tup[0] for tup in re.findall(pattern, script)]
cmd = "dpkg -l | grep '^ii' | awk '{print $2\"=\"$3}'"
stdin, stdout, stderr = ssh_client.exec_command(cmd)
installed = [line.strip() for line in stdout]
for package in packages:
if package not in installed:
print(f"{package} not found in Ubuntu VM")
assert False
finally:
ssh_client.close()