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