def update_config_file_from_file(self, dst_hosts, test_dir, generated_yaml):
"""Update config file and object.
Create and place the new config file in /etc/daos/daos_server.yml
Then update SCM-related data in engine_params so that those disks will
be wiped.
Args:
dst_hosts (list): Destination server hostnames to place the new config file.
test_dir (str): Directory where the server config data from
generated_yaml will be written.
generated_yaml (YAMLObject): New server config data.
"""
# Create a temporary file in test_dir and write the generated config.
temp_file_path = os.path.join(test_dir, "temp_server.yml")
try:
with open(temp_file_path, 'w') as write_file:
yaml.dump(generated_yaml, write_file, default_flow_style=False)
except Exception as error:
raise CommandFailure(
"Error writing the yaml file! {}: {}".format(temp_file_path, error)) from error
# Copy the config from temp dir to /etc/daos of the server node.
default_server_config = get_default_config_file("server")
try:
distribute_files(
dst_hosts, temp_file_path, default_server_config, verbose=False, sudo=True)
except DaosTestError as error:
raise CommandFailure(
"ERROR: Copying yaml configuration file to {}: "
"{}".format(dst_hosts, error)) from error
# Before restarting daos_server, we need to clear SCM. Unmount the mount
# point, wipefs the disks, etc. This clearing step is built into the
# server start steps. It'll look at the engine_params of the
# server_manager and clear the SCM set there, so we need to overwrite it
# before starting to the values from the generated config.
self.log.info("Resetting engine_params")
self.manager.job.yaml.engine_params = []
engines = generated_yaml["engines"]
for i, engine in enumerate(engines):
self.log.info("engine %d", i)
for storage_tier in engine["storage"]:
if storage_tier["class"] != "dcpm":
continue
self.log.info("scm_mount = %s", storage_tier["scm_mount"])
self.log.info("class = %s", storage_tier["class"])
self.log.info("scm_list = %s", storage_tier["scm_list"])
per_engine_yaml_parameters = DaosServerYamlParameters.PerEngineYamlParameters(i)
per_engine_yaml_parameters.scm_mount.update(storage_tier["scm_mount"])
per_engine_yaml_parameters.scm_class.update(storage_tier["class"])
per_engine_yaml_parameters.scm_size.update(None)
per_engine_yaml_parameters.scm_list.update(storage_tier["scm_list"])
per_engine_yaml_parameters.reset_yaml_data_updated()
self.manager.job.yaml.engine_params.append(
per_engine_yaml_parameters)
def test_destroy_wrong_group(self):
"""Test destroying a pool with wrong server group.
Test Steps:
Two servers run with different group names, daos_server_a and
daos_server_b. A pool is created on daos_server_a. Try destroying this
pool specifying daos_server_b.
We create a third dmg config file and specify the wrong server name in
the name field and the right hostlist as below.
daos_control_a.yml
hostlist:
- wolf-a
name: daos_server_a
daos_control_b.yml
hostlist:
- wolf-b
name: daos_server_b
daos_control_c.yml
hostlist:
- wolf-a
name: daos_server_b
We'll use daos_control_c.yml during dmg pool destroy and verify that it
fails. It should show something like:
"request system does not match running system (daos_server_b !=
daos_server_a)"
:avocado: tags=all,full_regression
:avocado: tags=vm
:avocado: tags=pool,pool_destroy
:avocado: tags=pool_destroy_wrong_group
"""
server_group_a = self.server_group + "_a"
server_group_b = self.server_group + "_b"
# Prepare and configure dmg config files for a and b.
dmg_config_file_a = get_default_config_file(name="control_a")
dmg_config_temp_a = self.get_config_file(name=server_group_a,
command="dmg",
path=self.test_dir)
dmg_config_file_b = get_default_config_file(name="control_b")
dmg_config_temp_b = self.get_config_file(name=server_group_b,
command="dmg",
path=self.test_dir)
# Prepare server group info with corresponding dmg config file.
group_info_a = self.get_group_info(hosts=[self.hostlist_servers[0]],
dmg_config_file=dmg_config_file_a,
dmg_config_temp=dmg_config_temp_a)
group_info_b = self.get_group_info(hosts=[self.hostlist_servers[1]],
dmg_config_file=dmg_config_file_b,
dmg_config_temp=dmg_config_temp_b)
# Put everything into a dictionary and start server a and b.
server_groups_a_b = {
server_group_a: group_info_a,
server_group_b: group_info_b
}
self.start_servers(server_groups=server_groups_a_b)
self.add_pool(connect=False)
# Get dmg_c instance that uses daos_control_c.yml. Server group is b.
cert_dir = os.path.join(os.sep, "etc", "daos", "certs")
dmg_config_file_c = get_default_config_file(name="control_c")
dmg_config_temp_c = self.get_config_file(name=server_group_b,
command="dmg",
path=self.test_dir)
dmg_c = get_dmg_command(group=server_group_b,
cert_dir=cert_dir,
bin_dir=self.bin,
config_file=dmg_config_file_c,
config_temp=dmg_config_temp_c)
# Update the third server manager's hostlist from "localhost" to
# daos_server_a's hostname.
dmg_c.hostlist = self.hostlist_servers[:1]
# Try destroying the pool in server a with dmg_c. Should fail because
# of the group name mismatch.
case_c = "Pool is in a, hostlist is a, and name is b."
self.validate_pool_destroy(hosts=[self.hostlist_servers[0]],
case=case_c,
exception_expected=True,
new_dmg=dmg_c)
# Try destroying the pool in server a with the dmg that uses
# daos_control_b.yml. Should fail because the pool doesn't exist in b.
case_b = "Pool is in a, hostlist is b, and name is b."
self.validate_pool_destroy(hosts=[self.hostlist_servers[0]],
case=case_b,
exception_expected=True,
new_dmg=self.server_managers[1].dmg)
# Try destroying the pool in server a with the dmg that uses
# daos_control_a.yml. Should pass.
case_a = "Pool is in a, hostlist is a, and name is a."
self.validate_pool_destroy(hosts=[self.hostlist_servers[0]],
case=case_a,
exception_expected=False,
new_dmg=self.server_managers[0].dmg)
def test_destroy_invalid_group(self):
"""Test destroying a pool with invalid server group.
Test Steps:
Run a server with group name "daos_server_a" and create a pool on it.
Try destroying this pool specifying daos_server_i. "i" for invalid.
We create a second dmg config file and specify the invalid server name
in the name field and the right hostlist as below.
daos_control_a.yml
hostlist:
- wolf-a
name: daos_server_a
daos_control_i.yml
hostlist:
- wolf-a
name: daos_server_i
We'll use daos_control_i.yml during dmg pool destroy and verify that it
fails. It should show something like:
"request system does not match running system (daos_server_i !=
daos_server_a)"
:avocado: tags=all,full_regression
:avocado: tags=pool,destroy,destroy_invalid_group
"""
server_group_a = self.server_group + "_a"
server_group_i = self.server_group + "_i"
# Prepare and configure dmg config files for a.
dmg_config_file_a = get_default_config_file(name="control_a")
dmg_config_temp_a = self.get_config_file(name=server_group_a,
command="dmg",
path=self.test_dir)
# Prepare server group info with corresponding dmg config file.
group_info_a = self.get_group_info(hosts=[self.hostlist_servers[0]],
dmg_config_file=dmg_config_file_a,
dmg_config_temp=dmg_config_temp_a)
# Put everything into a dictionary and start server a.
server_groups_a = {
server_group_a: group_info_a,
}
self.start_servers(server_groups=server_groups_a)
self.add_pool(connect=False)
# Get dmg_i instance that uses daos_control_i.yml. Server group is i.
cert_dir = os.path.join(os.sep, "etc", "daos", "certs")
dmg_config_file_i = get_default_config_file(name="control_i")
dmg_config_temp_i = self.get_config_file(name=server_group_i,
command="dmg",
path=self.test_dir)
dmg_i = get_dmg_command(group=server_group_i,
cert_dir=cert_dir,
bin_dir=self.bin,
config_file=dmg_config_file_i,
config_temp=dmg_config_temp_i)
# Update the second server manager's hostlist from "localhost" to
# daos_server_a's hostname.
dmg_i.hostlist = self.hostlist_servers[0]
# Try destroying the pool in server a with dmg_i. Should fail because
# of the group name mismatch.
case_i = "Pool is in a, hostlist is a, and name is i."
self.validate_pool_destroy(hosts=[self.hostlist_servers[0]],
case=case_i,
exception_expected=True,
new_dmg=dmg_i)
# Try destroying the pool in server a with the dmg that uses
# daos_control_a.yml. Should pass.
case_a = "Pool is in a, hostlist is a, and name is a."
self.validate_pool_destroy(hosts=[self.hostlist_servers[0]],
case=case_a,
exception_expected=False,
new_dmg=self.server_managers[0].dmg)