def test_get_minion_node_ips(self):
"""
Exercises the config_utils.get_master_node_ips() function
"""
boot_conf_file = pkg_resources.resource_filename(
'tests.deployment.boot.conf', 'boot.yaml')
boot_conf = file_utils.read_yaml(boot_conf_file)
hb_conf_file = pkg_resources.resource_filename(
'tests.deployment.kubernetes.conf', 'k8s.yaml')
hb_conf = file_utils.read_yaml(hb_conf_file)
minion_ips = config_utils.get_minion_node_ips(boot_conf, hb_conf)
self.assertEqual(1, len(minion_ips))
self.assertTrue('10.0.0.12' in minion_ips)
def test_deploy(self, apply_pb):
self.assertIsNotNone(apply_pb)
boot_conf_filename = pkg_resources.resource_filename(
'tests.deployment.boot.conf', 'boot.yaml')
boot_conf = file_utils.read_yaml(boot_conf_filename)
adrenaline_conf_file = pkg_resources.resource_filename(
'tests.deployment.kubernetes.conf', 'k8s.yaml')
hb_conf = file_utils.read_yaml(adrenaline_conf_file)
k8s_conf = config_utils.k8s_conf_dict(boot_conf, hb_conf)
user = hb_conf['node_info']['user']
deployer.deploy(k8s_conf, user)
def __init__(self,
method_name='runTest',
os_creds=None,
ext_net_name=None,
flavor_metadata=None,
image_metadata=None,
log_level=logging.DEBUG):
"""
Super for test classes requiring a connection to OpenStack
:param method_name: default 'runTest'
:param os_creds: the OSCreds object, when null it searches for the file
in the package snaps.openstack.tests.conf.os_env.yaml
:param ext_net_name: the name of the external network that is used for
creating routers for floating IPs
:param flavor_metadata: dict() to be sent directly into the Nova client
generally used for page sizes
:param image_metadata: ability to override images being used in the
tests (see examples/image-metadata)
:param log_level: the logging level of your test run (default DEBUG)
"""
super(OSComponentTestCase, self).__init__(method_name)
logging.basicConfig(level=log_level)
self.ext_net_name = None
self.flavor_metadata = None
if os_creds:
self.os_creds = os_creds
else:
if file_utils.file_exists(dev_os_env_file):
self.os_creds = openstack_tests.get_credentials(
dev_os_env_file=dev_os_env_file)
test_conf = file_utils.read_yaml(dev_os_env_file)
self.ext_net_name = test_conf.get('ext_net')
os_env_dict = file_utils.read_yaml(dev_os_env_file)
flavor_metadata = os_env_dict.get('flavor_metadata')
if flavor_metadata:
self.flavor_metadata = {'metadata': flavor_metadata}
else:
raise Exception('Unable to obtain OSCreds')
self.os_session = keystone_utils.keystone_session(self.os_creds)
self.image_metadata = image_metadata
if not self.ext_net_name:
self.ext_net_name = ext_net_name
if not self.flavor_metadata:
self.flavor_metadata = flavor_metadata
def test_convert_and_save_conf(self):
"""
Exercises the config_utils.persist_config_to_file() function
"""
boot_conf_file = pkg_resources.resource_filename(
'tests.deployment.boot.conf', 'boot.yaml')
boot_conf = file_utils.read_yaml(boot_conf_file)
conf_file_path = "/tmp/boot-conf-{}.yaml".format(uuid.uuid4())
self.conf_file = config_utils.persist_config_to_file(
boot_conf, conf_file_path)
self.assertIsNotNone(self.conf_file)
self.assertTrue(os.path.exists(self.conf_file.name))
conf_check = file_utils.read_yaml(self.conf_file.name)
self.assertEqual(boot_conf, conf_check)
def test_deploy(self, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12,
m13, m14, m15, m16, m17, m18):
boot_conf_filename = pkg_resources.resource_filename(
'tests.deployment.boot.conf', 'boot.yaml')
with open(boot_conf_filename, 'r') as boot_conf_file:
boot_conf_file.close()
k8s_conf_file = pkg_resources.resource_filename(
'tests.deployment.kubernetes.conf', 'k8s.yaml')
k8s_conf = file_utils.read_yaml(k8s_conf_file)
user = k8s_conf['node_info']['user']
boot_timeout = k8s_conf['build_info']['reboot_timeout']
boot_conf = file_utils.read_yaml(boot_conf_filename)
deployer.deploy(boot_conf, user, None, boot_timeout)
def test_get_first_master_node_ip(self):
"""
Exercises the config_utils.get_first_master_ip() function
"""
boot_conf_file = pkg_resources.resource_filename(
'tests.deployment.boot.conf', 'boot.yaml')
boot_conf = file_utils.read_yaml(boot_conf_file)
self.assertIsNotNone(boot_conf)
hb_conf_file = pkg_resources.resource_filename(
'tests.deployment.kubernetes.conf', 'k8s.yaml')
hb_conf = file_utils.read_yaml(hb_conf_file)
self.assertIsNotNone(hb_conf)
ip = config_utils.get_node_ip(boot_conf,
hb_conf['docker']['repo_host'])
self.assertIsNotNone(ip)
self.assertEqual('10.0.0.11', ip)
def test_get_node_password(self):
"""
Exercises the config_utils.get_node_pass() function
"""
boot_conf_file = pkg_resources.resource_filename(
'tests.deployment.boot.conf', 'boot.yaml')
boot_conf = file_utils.read_yaml(boot_conf_file)
self.assertIsNotNone(boot_conf)
password = config_utils.get_node_pass(boot_conf)
self.assertEqual('Pa$$w0rd', password)
def test_get_node_user(self):
"""
Exercises the config_utils.get_node_user() function
"""
boot_conf_file = pkg_resources.resource_filename(
'tests.deployment.boot.conf', 'boot.yaml')
boot_conf = file_utils.read_yaml(boot_conf_file)
self.assertIsNotNone(boot_conf)
user = config_utils.get_node_user(boot_conf)
self.assertEqual('foo_user', user)
def __generate_confs(boot_tmplt_file, hb_conf_file, env_file):
"""
Returns a tuple 3 respectively: boot_conf, hb_conf, k8s_conf
:param boot_tmplt_file: the path to the snaps-boot template config file
:param hb_conf_file: the path to the adrenaline configuration
:param env_file: the Jinga2 environment file to apply against the
boot_tmplt_filename and k8s_tmplt_filename
:return: tuple3 dictionaries
"""
logger.info('Adrenaline setting up boot and k8s config')
if env_file:
env = Environment(loader=FileSystemLoader(
searchpath=os.path.dirname(hb_conf_file)))
hb_tmplt = env.get_template(os.path.basename(hb_conf_file))
env_dict = file_utils.read_yaml(env_file)
hb_output = hb_tmplt.render(**env_dict)
hb_conf = yaml.safe_load(hb_output)
else:
hb_conf = file_utils.read_yaml(hb_conf_file)
if env_file:
# Apply env_file/substitution file to template
env = Environment(loader=FileSystemLoader(
searchpath=os.path.dirname(boot_tmplt_file)))
boot_tmplt = env.get_template(os.path.basename(boot_tmplt_file))
env_dict = file_utils.read_yaml(env_file)
boot_output = boot_tmplt.render(**env_dict)
boot_conf = yaml.safe_load(boot_output)
else:
with open(boot_tmplt_file, 'r') as boot_conf_file:
boot_conf_file.close()
boot_conf = file_utils.read_yaml(boot_tmplt_file)
# Setup k8s config
k8s_conf = config_utils.k8s_conf_dict(boot_conf, hb_conf)
logger.info('k8s_conf -\n%s', k8s_conf)
validation_utils.validate_deployment_file(k8s_conf)
return boot_conf, hb_conf, k8s_conf
def test_get_k8s_version(self):
"""
Exercises the config_utils.get_k8s_version() function
"""
boot_conf_file = pkg_resources.resource_filename(
'tests.deployment.boot.conf', 'boot.yaml')
boot_conf = file_utils.read_yaml(boot_conf_file)
hb_conf_file = pkg_resources.resource_filename(
'tests.deployment.kubernetes.conf', 'k8s.yaml')
hb_conf = file_utils.read_yaml(hb_conf_file)
k8s_conf = config_utils.k8s_conf_dict(boot_conf, hb_conf)
version_long = config_utils.get_k8s_version(k8s_conf)
self.assertEqual('1.21.1', version_long)
version_short = config_utils.get_k8s_version(k8s_conf,
maj_min_only=True)
self.assertEqual('1.21', version_short)
k8s_conf['kubernetes']['version'] = '6'
with self.assertRaises(Exception):
config_utils.get_k8s_version(k8s_conf)
def test_get_node_ips(self):
"""
Exercises the config_utils.get_node_ips_from_config() function
"""
boot_conf_file = pkg_resources.resource_filename(
'tests.deployment.boot.conf', 'boot.yaml')
boot_conf = file_utils.read_yaml(boot_conf_file)
self.assertIsNotNone(boot_conf)
ips = config_utils.get_node_ips_from_config(boot_conf)
self.assertTrue('10.0.0.11' in ips)
self.assertTrue('10.0.0.12' in ips)
self.assertFalse('10.0.0.10' in ips)
self.assertFalse('10.0.0.13' in ips)
def main(arguments):
"""
Will need to set environment variable ANSIBLE_HOST_KEY_CHECKING=False or
Create a file located in /etc/ansible/ansible/cfg or ~/.ansible.cfg
containing the following content:
[defaults]
host_key_checking = False
CWD must be this directory where this script is located.
:return: To the OS
"""
log_level = logging.INFO
if arguments.log_level != 'INFO':
log_level = logging.DEBUG
logging.basicConfig(level=log_level)
logger.info('Starting to Deploy')
# Apply env_file/substitution file to template
env = Environment(loader=FileSystemLoader(
searchpath=os.path.dirname(arguments.tmplt_file)))
template = env.get_template(os.path.basename(arguments.tmplt_file))
env_dict = dict()
if arguments.env_file:
env_dict = file_utils.read_yaml(arguments.env_file)
output = template.render(**env_dict)
config = yaml.load(output)
if config:
clean = arguments.clean is not ARG_NOT_SET
clean_image = arguments.clean_image is not ARG_NOT_SET
deploy = arguments.deploy is not ARG_NOT_SET
launch_utils.launch_config(config, arguments.tmplt_file, deploy, clean,
clean_image)
else:
logger.error('Unable to read configuration file - ' +
arguments.tmplt_file)
exit(1)
exit(0)
def test_get_k8s_conf_dict(self):
"""
Exercises the config_utils.k8s_conf_dict() function
"""
boot_conf_file = pkg_resources.resource_filename(
'tests.deployment.boot.conf', 'boot.yaml')
boot_conf = file_utils.read_yaml(boot_conf_file)
hb_conf_file = pkg_resources.resource_filename(
'tests.deployment.kubernetes.conf', 'k8s.yaml')
hb_conf = file_utils.read_yaml(hb_conf_file)
k8s_conf = config_utils.k8s_conf_dict(boot_conf, hb_conf)
kube_dict = k8s_conf['kubernetes']
self.assertIsNotNone(kube_dict.get('api_host'))
self.assertEquals('foo.com:5555', kube_dict['api_host'])
validation_utils.validate_deployment_file(k8s_conf)
self.assertIsNotNone(kube_dict)
self.assertEquals('v{}'.format(consts.DFLT_K8S_VERSION),
kube_dict['version'])
self.assertEquals(consts.DFLT_KUBESPRAY_URL,
kube_dict['kubespray_url'])
self.assertEquals(consts.DFLT_KUBESPRAY_BRANCH,
kube_dict['kubespray_branch'])
self.assertIsNotNone(kube_dict['Docker_Repo'])
docker_repo = kube_dict['Docker_Repo']
self.assertEqual('10.0.0.11', docker_repo['ip'])
self.assertEqual('password', docker_repo['password'])
self.assertEqual(4000, docker_repo['port'])
self.assertEqual('root', docker_repo['user'])
self.assertIsNotNone(kube_dict['Networks'])
networks = kube_dict['Networks']
default_net = networks[0]['Default_Network']
self.assertEqual('true', default_net['isMaster'])
self.assertEqual('default-network', default_net['network_name'])
self.assertEqual('contiv', default_net['networking_plugin'])
self.assertEqual('10.251.0.0/16', default_net['pod_subnet'])
self.assertEqual('10.241.0.0/16', default_net['service_subnet'])
multis_nets = networks[1]['Multus_network']
self.assertIsNotNone(multis_nets)
self.assertEqual(2, len(multis_nets))
self.assertTrue('CNI' in multis_nets[0])
self.assertTrue('CNI_Configuration' in multis_nets[1])
cnis = multis_nets[0]['CNI']
self.assertEqual(4, len(cnis))
self.assertTrue('macvlan' in cnis)
self.assertTrue('weave' in cnis)
self.assertTrue('flannel' in cnis)
self.assertTrue('dhcp' in cnis)
cni_conf = multis_nets[1]['CNI_Configuration']
self.assertEqual(3, len(cni_conf))
self.assertIsNotNone(kube_dict['Persistent_Volumes'])
persist_vols = kube_dict['Persistent_Volumes']
self.assertEqual(2, len(persist_vols))
self.assertFalse('Ceph_Volume' in persist_vols)
self.assertTrue('Host_Volume' in persist_vols)
host_vols = persist_vols['Host_Volume']
self.assertEqual(2, len(host_vols))
self.assertTrue('claim_parameters' in host_vols[0])
claim_params1 = host_vols[0]['claim_parameters']
self.assertEqual(2, len(claim_params1))
self.assertTrue('Claim_name' in claim_params1)
self.assertEqual('claim5', claim_params1['Claim_name'])
self.assertTrue('storage' in claim_params1)
self.assertEqual('4Gi', claim_params1['storage'])
claim_params2 = host_vols[1]['claim_parameters']
self.assertEqual(2, len(claim_params2))
self.assertTrue('Claim_name' in claim_params2)
self.assertEqual('claim6', claim_params2['Claim_name'])
self.assertTrue('storage' in claim_params2)
self.assertEqual('5Gi', claim_params2['storage'])
self.assertIsNotNone(kube_dict['Project_name'])
self.assertEqual('bar', kube_dict['Project_name'])
self.assertIsNotNone(kube_dict['basic_authentication'])
basic_auth = kube_dict['basic_authentication']
self.assertEqual(1, len(basic_auth))
self.assertTrue('user' in basic_auth[0])
basic_auth_user = basic_auth[0]['user']
self.assertTrue('user_id' in basic_auth_user)
self.assertEqual('admin', basic_auth_user['user_id'])
self.assertTrue('user_name' in basic_auth_user)
self.assertEqual('admin', basic_auth_user['user_name'])
self.assertTrue('user_password' in basic_auth_user)
self.assertEqual('admin', basic_auth_user['user_password'])
self.assertIsNotNone(kube_dict['enable_metrics_server'])
self.assertTrue(kube_dict['enable_metrics_server'])
self.assertIsNotNone(kube_dict['node_configuration'])
node_configs = kube_dict['node_configuration']
self.assertEqual(2, len(node_configs))
self.assertTrue('host' in node_configs[0])
node_config1 = node_configs[0]['host']
self.assertEqual(8, len(node_config1))
self.assertTrue('hostname' in node_config1)
self.assertEqual('master1', node_config1['hostname'])
self.assertTrue('ip' in node_config1)
self.assertEqual('10.0.0.11', node_config1['ip'])
self.assertTrue('label_key' in node_config1)
self.assertEqual('zone', node_config1['label_key'])
self.assertTrue('label_value' in node_config1)
self.assertEqual('master1', node_config1['label_value'])
self.assertTrue('node_type' in node_config1)
self.assertEqual('master', node_config1['node_type'])
self.assertTrue('password' in node_config1)
self.assertEqual('Pa$$w0rd', node_config1['password'])
self.assertTrue('registry_port' in node_config1)
self.assertEqual(2376, node_config1['registry_port'])
self.assertTrue('user' in node_config1)
self.assertEqual('root', node_config1['user'])
self.assertTrue('host' in node_configs[1])
node_config2 = node_configs[1]['host']
self.assertEqual(8, len(node_config2))
self.assertTrue('hostname' in node_config2)
self.assertEqual('minion1', node_config2['hostname'])
self.assertTrue('ip' in node_config2)
self.assertEqual('10.0.0.12', node_config2['ip'])
self.assertTrue('label_key' in node_config2)
self.assertEqual('zone', node_config2['label_key'])
self.assertTrue('label_value' in node_config2)
self.assertEqual('minion1', node_config2['label_value'])
self.assertTrue('node_type' in node_config2)
self.assertEqual('minion', node_config2['node_type'])
self.assertTrue('password' in node_config2)
self.assertEqual('Pa$$w0rd', node_config2['password'])
self.assertTrue('registry_port' in node_config2)
self.assertEqual(4386, node_config2['registry_port'])
self.assertTrue('user' in node_config2)
self.assertEqual('root', node_config2['user'])
self.assertIsNotNone(kube_dict['proxies'])
proxies = kube_dict['proxies']
self.assertTrue('ftp_proxy' in proxies)
self.assertEqual('', proxies['ftp_proxy'])
self.assertTrue('http_proxy' in proxies)
self.assertEqual('', proxies['http_proxy'])
self.assertTrue('https_proxy' in proxies)
self.assertEqual('', proxies['https_proxy'])
self.assertTrue('no_proxy' in proxies)
self.assertEqual('127.0.0.1,localhost,', proxies['no_proxy'])
def main(arguments):
"""
Begins running unit tests.
argv[1] if used must be the source filename else os_env.yaml will be
leveraged instead
argv[2] if used must be the proxy server <host>:<port>
"""
logger.info('Starting test suite')
log_level = LOG_LEVELS.get(arguments.log_level, logging.DEBUG)
flavor_metadata = None
if arguments.flavor_metadata:
flavor_metadata = {
'metadata': {
'hw:mem_page_size': arguments.flavor_metadata
}
}
image_metadata = None
if arguments.image_metadata_file:
image_metadata = file_utils.read_yaml(arguments.image_metadata_file)
concurrent_suite = None
sequential_suite = None
if arguments.env and arguments.ext_net:
unit = arguments.include_unit != ARG_NOT_SET
connection = arguments.include_connection != ARG_NOT_SET
api = arguments.include_api != ARG_NOT_SET
integration = arguments.include_integration != ARG_NOT_SET
ci = arguments.continuous_integration != ARG_NOT_SET
staging = arguments.include_staging != ARG_NOT_SET
if (not unit and not connection and not api and not integration
and not staging and not ci):
unit = True
connection = True
api = True
integration = True
concurrent_suite = __create_concurrent_test_suite(
arguments.env, arguments.ext_net, arguments.proxy,
arguments.ssh_proxy_cmd, unit, connection, api, integration,
staging, flavor_metadata, image_metadata,
arguments.floating_ips != ARG_NOT_SET, ci, log_level)
if (arguments.include_integration != ARG_NOT_SET
and arguments.floating_ips != ARG_NOT_SET):
sequential_suite = __create_sequential_test_suite(
arguments.env, arguments.ext_net, arguments.proxy,
arguments.ssh_proxy_cmd, integration, flavor_metadata,
image_metadata, arguments.floating_ips != ARG_NOT_SET,
log_level)
else:
logger.error('Environment file or external network not defined')
exit(1)
i = 0
while i < int(arguments.num_runs):
i += 1
if concurrent_suite:
logger.info('Running Concurrent Tests')
concurrent_runner = unittest.TextTestRunner(verbosity=2)
concurrent_suite = ConcurrentTestSuite(
concurrent_suite, fork_for_tests(int(arguments.threads)))
concurrent_results = concurrent_runner.run(concurrent_suite)
__output_results(concurrent_results)
if ((concurrent_results.errors
and len(concurrent_results.errors) > 0)
or (concurrent_results.failures
and len(concurrent_results.failures) > 0)):
logger.error('See above for test failures')
exit(1)
else:
logger.info(
'Concurrent tests completed successfully in run #%s', i)
if sequential_suite:
logger.info('Running Sequential Tests')
sequential_runner = unittest.TextTestRunner(verbosity=2)
sequential_results = sequential_runner.run(sequential_suite)
__output_results(sequential_results)
if ((sequential_results.errors
and len(sequential_results.errors) > 0)
or (sequential_results.failures
and len(sequential_results.failures) > 0)):
logger.error('See above for test failures')
exit(1)
else:
logger.info(
'Sequential tests completed successfully in run #%s', i)
logger.info('Successful completion of %s test runs', i)
exit(0)
def get_credentials(os_env_file=None,
proxy_settings_str=None,
ssh_proxy_cmd=None,
dev_os_env_file=None,
overrides=None):
"""
Returns the OpenStack credentials object. It first attempts to retrieve
them from a standard OpenStack source file. If that file is None, it will
attempt to retrieve them with a YAML file.
:param os_env_file: the OpenStack source file
:param proxy_settings_str: proxy settings string <host>:<port> (optional)
:param ssh_proxy_cmd: the SSH proxy command for your environment (optional)
:param dev_os_env_file: the YAML file to retrieve both the OS credentials
and proxy settings
:param overrides: dict() containing values to override the credentials
found and passed in.
:return: the SNAPS credentials object
"""
if os_env_file:
logger.debug('Reading RC file - ' + os_env_file)
config = file_utils.read_os_env_file(os_env_file)
proj_name = config.get('OS_PROJECT_NAME')
if not proj_name:
proj_name = config.get('OS_TENANT_NAME')
proxy_settings = None
if proxy_settings_str:
tokens = re.split(':', proxy_settings_str)
proxy_settings = ProxySettings(host=tokens[0],
port=tokens[1],
ssh_proxy_cmd=ssh_proxy_cmd)
https_cacert = None
if config.get('OS_CACERT'):
https_cacert = config.get('OS_CACERT')
elif config.get('OS_INSECURE'):
https_cacert = False
interface = 'public'
if config.get('OS_INTERFACE'):
interface = config.get('OS_INTERFACE')
creds_dict = {
'username': config['OS_USERNAME'],
'password': config['OS_PASSWORD'],
'auth_url': config['OS_AUTH_URL'],
'project_name': proj_name,
'identity_api_version': config.get('OS_IDENTITY_API_VERSION'),
'image_api_version': config.get('OS_IMAGE_API_VERSION'),
'network_api_version': config.get('OS_NETWORK_API_VERSION'),
'compute_api_version': config.get('OS_COMPUTE_API_VERSION'),
'heat_api_version': config.get('OS_HEAT_API_VERSION'),
'user_domain_id': config.get('OS_USER_DOMAIN_ID'),
'user_domain_name': config.get('OS_USER_DOMAIN_NAME'),
'project_domain_id': config.get('OS_PROJECT_DOMAIN_ID'),
'project_domain_name': config.get('OS_PROJECT_DOMAIN_NAME'),
'volume_api_version': config.get('OS_VOLUME_API_VERSION'),
'interface': interface,
'proxy_settings': proxy_settings,
'cacert': https_cacert,
'region_name': config.get('OS_REGION_NAME')
}
else:
logger.info('Reading development os_env file - ' + dev_os_env_file)
config = file_utils.read_yaml(dev_os_env_file)
proxy_settings = None
proxy_str = config.get('http_proxy')
if proxy_str:
tokens = re.split(':', proxy_str)
proxy_settings = ProxySettings(
host=tokens[0],
port=tokens[1],
ssh_proxy_cmd=config.get('ssh_proxy_cmd'))
creds_dict = {
'username': config['username'],
'password': config['password'],
'auth_url': config['os_auth_url'],
'project_name': config['project_name'],
'identity_api_version': config.get('identity_api_version'),
'image_api_version': config.get('image_api_version'),
'network_api_version': config.get('network_api_version'),
'compute_api_version': config.get('compute_api_version'),
'heat_api_version': config.get('heat_api_version'),
'user_domain_id': config.get('user_domain_id'),
'user_domain_name': config.get('user_domain_name'),
'project_domain_id': config.get('project_domain_id'),
'project_domain_name': config.get('project_domain_name'),
'volume_api_version': config.get('volume_api_version'),
'interface': config.get('interface'),
'proxy_settings': proxy_settings,
'cacert': config.get('cacert'),
'region_name': config.get('region_name')
}
if overrides and isinstance(overrides, dict):
creds_dict.update(overrides)
for key, value in creds_dict.items():
if value is not None and isinstance(value, str):
creds_dict[key] = value.replace('"', '').replace('\'', '')
os_creds = OSCreds(**creds_dict)
logger.info('OS Credentials = %s', os_creds.__str__)
return os_creds
