def prepare_alba_backend(name=None): """ Create an ALBA backend and claim disks :param name: Name for the backend :return: None """ # @TODO: Fix this, because backend_type should not be configurable if you always create an ALBA backend # @TODO 2: Get rid of these asserts, any test (or testsuite) should verify the required params first before starting execution autotest_config = General.get_config() if name is None: name = autotest_config.get('backend', 'name') nr_of_disks_to_claim = autotest_config.getint('backend', 'nr_of_disks_to_claim') type_of_disks_to_claim = autotest_config.get('backend', 'type_of_disks_to_claim') assert name,\ "Please fill out a valid backend name in autotest.cfg file" storage_routers = GeneralStorageRouter.get_storage_routers() for sr in storage_routers: if GeneralStorageRouter.has_roles(storagerouter=sr, roles='DB') is False: GeneralDisk.add_db_role(sr) if GeneralStorageRouter.has_roles(storagerouter=sr, roles=['SCRUB', 'WRITE']) is False: GeneralDisk.add_write_scrub_roles(sr) backend = GeneralBackend.get_by_name(name) if not backend: alba_backend = GeneralAlba.add_alba_backend(name) else: alba_backend = backend.alba_backend GeneralAlba.claim_asds(alba_backend, nr_of_disks_to_claim, type_of_disks_to_claim) if GeneralAlba.has_preset(alba_backend=alba_backend, preset_name=GeneralAlba.ONE_DISK_PRESET) is False: GeneralAlba.add_preset(alba_backend=alba_backend, name=GeneralAlba.ONE_DISK_PRESET, policies=[[1, 1, 1, 2]])
def add_vpool(vpool_parameters=None, storagerouters=None): """ Create a vPool based on the kwargs provided or default parameters found in the autotest.cfg :param vpool_parameters: Parameters to be used for vPool creation :type vpool_parameters: dict :param storagerouters: Guids of the Storage Routers on which to create and extend this vPool :type storagerouters: list :return: Created or extended vPool :rtype: VPool """ if storagerouters is None: storagerouters = list(GeneralStorageRouter.get_storage_routers()) if vpool_parameters is None: vpool_parameters = {} if not isinstance(storagerouters, list) or len(storagerouters) == 0: raise ValueError("Storage Routers should be a list and contain at least 1 element to add a vPool on") vpool_name = None storagerouter_param_map = dict( (sr, GeneralVPool.get_add_vpool_params(storagerouter=sr, **vpool_parameters)) for sr in storagerouters ) for index, sr in enumerate(storagerouters): vpool_name = storagerouter_param_map[sr]["vpool_name"] if GeneralStorageRouter.has_roles(storagerouter=sr, roles="DB") is False and sr.node_type == "MASTER": GeneralDisk.add_db_role(sr) if GeneralStorageRouter.has_roles(storagerouter=sr, roles=["SCRUB", "WRITE"]) is False: GeneralDisk.add_write_scrub_roles(sr) print storagerouter_param_map[sr] task_result = GeneralVPool.api.execute_post_action( component="storagerouters", guid=sr.guid, action="add_vpool", data={"call_parameters": storagerouter_param_map[sr]}, wait=True, timeout=GeneralVPool.TIMEOUT_ADD_VPOOL, ) if task_result[0] is not True: raise RuntimeError( "vPool was not {0} successfully: {1}".format("extended" if index > 0 else "created", task_result[1]) ) vpool = GeneralVPool.get_vpool_by_name(vpool_name) if vpool is None: raise RuntimeError("vPool with name {0} could not be found in model".format(vpool_name)) return vpool, storagerouter_param_map
def setup(): """ Setup for Backend package, will be executed when any test in this package is being executed Make necessary changes before being able to run the tests :return: None """ autotest_config = General.get_config() backend_name = autotest_config.get('backend', 'name') assert backend_name, "Please fill out a valid backend name in autotest.cfg file" my_sr = GeneralStorageRouter.get_local_storagerouter() if GeneralStorageRouter.has_roles(storagerouter=my_sr, roles='DB') is False: GeneralDisk.add_db_role(my_sr)
def setup(): """ Setup for Backend package, will be executed when any test in this package is being executed Make necessary changes before being able to run the tests :return: None """ General.validate_required_config_settings(settings={'backend': ['name']}) my_sr = GeneralStorageRouter.get_local_storagerouter() if GeneralStorageRouter.has_roles(storagerouter=my_sr, roles='DB') is False: GeneralDisk.add_db_role(my_sr) alba_backend_name = General.get_config().get('backend', 'name') alba_backend = GeneralAlba.get_by_name(alba_backend_name) if alba_backend is None: GeneralAlba.add_alba_backend(alba_backend_name)
def validate_alba_backend_sanity_without_claimed_disks(alba_backend): """ Validate whether the ALBA backend is configured correctly :param alba_backend: ALBA backend :return: None """ # Attribute validation assert alba_backend.available is True,\ 'ALBA backend {0} is not available'.format(alba_backend.backend.name) assert len(alba_backend.presets) >= 1,\ 'No preset found for ALBA backend {0}'.format(alba_backend.backend.name) assert len([default for default in alba_backend.presets if default['is_default'] is True]) == 1,\ 'Could not find default preset for backend {0}'.format(alba_backend.backend.name) assert alba_backend.backend.backend_type.code == 'alba',\ 'Backend type for ALBA backend is {0}'.format(alba_backend.backend.backend_type.code) assert alba_backend.backend.status == 'RUNNING',\ 'Status for ALBA backend is {0}'.format(alba_backend.backend.status) # Validate ABM and NSM services storagerouters = GeneralStorageRouter.get_storage_routers() storagerouters_with_db_role = [sr for sr in storagerouters if GeneralStorageRouter.has_roles(storagerouter=sr, roles='DB') is True and sr.node_type == 'MASTER'] assert len(alba_backend.abm_services) == len(storagerouters_with_db_role),\ 'Not enough ABM services found' assert len(alba_backend.nsm_services) == len(storagerouters_with_db_role),\ 'Not enough NSM services found' # Validate ALBA backend configuration structure alba_backend_key = '/ovs/alba/backends' assert Configuration.dir_exists(key=alba_backend_key) is True,\ 'Configuration does not contain key {0}'.format(alba_backend_key) actual_config_keys = [key for key in Configuration.list(alba_backend_key)] expected_config_keys = ['global_gui_error_interval', alba_backend.guid, 'default_nsm_hosts'] optional_config_keys = ['verification_factor'] expected_keys_amount = 0 for optional_key in optional_config_keys: if optional_key in actual_config_keys: expected_keys_amount += 1 for expected_key in expected_config_keys: if not re.match(Toolbox.regex_guid, expected_key): expected_keys_amount += 1 assert expected_key in actual_config_keys,\ 'Key {0} was not found in tree {1}'.format(expected_key, alba_backend_key) for actual_key in list(actual_config_keys): if re.match(Toolbox.regex_guid, actual_key): actual_config_keys.remove(actual_key) # Remove all alba backend keys assert len(actual_config_keys) == expected_keys_amount,\ 'Another key was added to the {0} tree'.format(alba_backend_key) this_alba_backend_key = '{0}/{1}'.format(alba_backend_key, alba_backend.guid) actual_keys = [key for key in Configuration.list(this_alba_backend_key)] expected_keys = ['maintenance'] assert actual_keys == expected_keys,\ 'Actual keys: {0} - Expected keys: {1}'.format(actual_keys, expected_keys) maintenance_key = '{0}/maintenance'.format(this_alba_backend_key) actual_keys = [key for key in Configuration.list(maintenance_key)] expected_keys = ['nr_of_agents', 'config'] assert set(actual_keys) == set(expected_keys),\ 'Actual keys: {0} - Expected keys: {1}'.format(actual_keys, expected_keys) # @TODO: Add validation for config values # Validate ASD node configuration structure alba_nodes = GeneralAlba.get_alba_nodes() assert len(alba_nodes) > 0,\ 'Could not find any ALBA nodes in the model' alba_node_key = '/ovs/alba/asdnodes' actual_keys = [key for key in Configuration.list(alba_node_key)] assert len(alba_nodes) == len(actual_keys),\ 'Amount of ALBA nodes in model: {0} >< amount of ALBA nodes in configuration: {1}.'.format(len(alba_nodes), len(actual_keys)) for alba_node in alba_nodes: assert alba_node.node_id in actual_keys,\ 'ALBA node with ID {0} not present in configuration'.format(alba_node.node_id) actual_asdnode_keys = [key for key in Configuration.list('{0}/{1}'.format(alba_node_key, alba_node.node_id))] expected_asdnode_keys = ['config', 'services'] assert actual_asdnode_keys == expected_asdnode_keys,\ 'Actual keys: {0} - Expected keys: {1}'.format(actual_asdnode_keys, expected_asdnode_keys) actual_config_keys = [key for key in Configuration.list('{0}/{1}/config'.format(alba_node_key, alba_node.node_id))] expected_config_keys = ['main', 'network'] assert set(actual_config_keys) == set(expected_config_keys),\ 'Actual keys: {0} - Expected keys: {1}'.format(actual_config_keys, expected_config_keys) # @TODO: Add validation for main and network values # Validate Arakoon configuration structure arakoon_abm_key = '/ovs/arakoon/{0}/config'.format(alba_backend.abm_services[0].service.name).replace('arakoon-', '') arakoon_nsm_key = '/ovs/arakoon/{0}/config'.format(alba_backend.nsm_services[0].service.name).replace('arakoon-', '') assert Configuration.exists(key=arakoon_abm_key, raw=True) is True,\ 'Configuration key {0} does not exist'.format(arakoon_abm_key) assert Configuration.exists(key=arakoon_nsm_key, raw=True) is True,\ 'Configuration key {0} does not exist'.format(arakoon_nsm_key) # @TODO: Add validation for config values # Validate maintenance agents actual_amount_agents = len([service for node_services in [alba_node.client.list_maintenance_services() for alba_node in alba_nodes] for service in node_services]) expected_amount_agents = 1 assert actual_amount_agents == expected_amount_agents,\ 'Amount of maintenance agents is incorrect. Found {0} - Expected {1}'.format(actual_amount_agents, expected_amount_agents) # Validate arakoon services machine_ids = [sr.machine_id for sr in storagerouters_with_db_role] abm_service_name = alba_backend.abm_services[0].service.name nsm_service_name = alba_backend.nsm_services[0].service.name for storagerouter in storagerouters_with_db_role: root_client = SSHClient(endpoint=storagerouter, username='******') for service_name in [abm_service_name, nsm_service_name]: assert GeneralService.has_service(name=service_name, client=root_client) is True,\ 'Service {0} not deployed on Storage Router {1}'.format(service_name, storagerouter.name) exitcode, output = GeneralService.get_service_status(name=service_name, client=root_client) assert exitcode is True,\ 'Service {0} not running on Storage Router {1} - {2}'.format(service_name, storagerouter.name, output) out, err, _ = General.execute_command('arakoon --who-master -config {0}'.format(Configuration.get_configuration_path('/ovs/arakoon/{0}/config'.format(abm_service_name.replace('arakoon-', ''))))) assert out.strip() in machine_ids,\ 'Arakoon master is {0}, but should be 1 of "{1}"'.format(out.strip(), ', '.join(machine_ids))