def setUp(self): """Define test setup to be done.""" self.log.info("<<setUp Started>> at %s", time.ctime()) super(SoakTestBase, self).setUp() self.username = getuser() # Initialize loop param for all tests self.loop = 1 self.exclude_slurm_nodes = [] # Setup logging directories for soak logfiles # self.output dir is an avocado directory .../data/ self.log_dir = get_log_file("soak") self.outputsoakdir = self.outputdir + "/soak" # Fail if slurm partition daos_client is not defined if not self.client_partition: raise SoakTestError( "<<FAILED: Partition is not correctly setup for daos " "slurm partition>>") # Check if the server nodes are in the client list; # this will happen when only one partition is specified for host_server in self.hostlist_servers: if host_server in self.hostlist_clients: self.hostlist_clients.remove(host_server) self.exclude_slurm_nodes.append(host_server) # Include test node for log cleanup; remove from client list local_host_list = include_local_host(None) self.exclude_slurm_nodes.extend(local_host_list) if local_host_list[0] in self.hostlist_clients: self.hostlist_clients.remove((local_host_list[0])) self.log.info("<<Updated hostlist_clients %s >>", self.hostlist_clients) if not self.hostlist_clients: self.fail("There are no nodes that are client only;" "check if the partition also contains server nodes")
def setUp(self): """Define test setup to be done.""" self.log.info("<<setUp Started>> at %s", time.ctime()) super().setUp() # Log the version of rpms being used for this test cmd = "sudo dnf list daos-client" try: _ = run_command(cmd, timeout=30) except DaosTestError as error: self.log.info("No daos rpm package info available %s", error) self.username = getuser() # Initialize loop param for all tests self.loop = 1 self.exclude_slurm_nodes = [] # Setup logging directories for soak logfiles # self.output dir is an avocado directory .../data/ self.log_dir = get_log_file("soak") self.outputsoakdir = self.outputdir + "/soak" # Create the remote log directories on all client nodes self.test_log_dir = self.log_dir + "/pass" + str(self.loop) self.local_pass_dir = self.outputsoakdir + "/pass" + str(self.loop) self.sharedlog_dir = self.tmp + "/soak" self.sharedsoakdir = self.sharedlog_dir + "/pass" + str(self.loop) # Initialize dmg cmd self.dmg_command = self.get_dmg_command() # Fail if slurm partition is not defined # NOTE: Slurm reservation and partition are created before soak runs. # CI uses partition=daos_client and no reservation. # A21 uses partition=normal/default and reservation=daos-test. # Partition and reservation names are updated in the yaml file. # It is assumed that if there is no reservation (CI only), then all # the nodes in the partition will be used for soak. if not self.client_partition: raise SoakTestError( "<<FAILED: Partition is not correctly setup for daos " "slurm partition>>") self.srun_params = {"partition": self.client_partition} if self.client_reservation: self.srun_params["reservation"] = self.client_reservation # Check if the server nodes are in the client list; # this will happen when only one partition is specified for host_server in self.hostlist_servers: if host_server in self.hostlist_clients: self.hostlist_clients.remove(host_server) self.exclude_slurm_nodes.append(host_server) # Include test node for log cleanup; remove from client list local_host_list = include_local_host(None) self.exclude_slurm_nodes.extend(local_host_list) if local_host_list[0] in self.hostlist_clients: self.hostlist_clients.remove((local_host_list[0])) if not self.hostlist_clients: self.fail( "There are no valid nodes in this partition to run " "soak. Check partition {} for valid nodes".format( self.client_partition))
def test_daos_agent_config_basic(self): """ JIRA ID: DAOS-1508 Test Description: Test daos_agent start/stops properly. on the system. :avocado: tags=all,daily_regression :avocado: tags=small,agent_start,basic :avocado: tags=control,daos_agent_config_test :avocado: tags=test_daos_agent_config_basic """ # Setup the agents self.add_agent_manager() self.configure_manager("agent", self.agent_managers[-1], include_local_host(self.hostlist_clients), self.hostfile_clients_slots) # Get the input to verify c_val = self.params.get("config_val", "/run/agent_config_val/*/") # Identify the attribute and modify its value to test value self.assertTrue( self.agent_managers[-1].set_config_value(c_val[0], c_val[1]), "Error setting the '{}' config file parameter to '{}'".format( c_val[0], c_val[1])) # Setup the access points with the server hosts self.log.info("Starting agent with %s = %s, expecting it to %s", c_val[0], c_val[1], c_val[2]) try: self.agent_managers[-1].start() exception = None except CommandFailure as err: exception = err # Verify if c_val[2] == "FAIL" and exception is None: self.log.error("Agent was expected to fail") self.fail( "Starting agent completed successfully when it was expected to " "fail with {} = {}".format(c_val[0], c_val[1])) elif c_val[2] == "PASS" and exception is not None: self.log.error("Agent was expected to start") self.fail("Starting agent failed when it was expected to complete " "successfully with {} = {}: {}".format( c_val[0], c_val[1], exception)) self.log.info("Test passed - starting the agent with %s = %s %sed", c_val[0], c_val[1], c_val[2].lower())
def setUp(self): """Set up before each test.""" self.subtest_name = self.get_test_param("test_name") self.subtest_name = self.subtest_name.replace(" ", "_") # obtain separate logs self.update_log_file_names(self.subtest_name) super(DaosCoreBase, self).setUp() # if no client specified update self.hostlist_clients to local host # and create a new self.hostfile_clients. if self.hostlist_clients is None: self.hostlist_clients = include_local_host(self.hostlist_clients) self.hostfile_clients = write_host_file.write_host_file( self.hostlist_clients, self.workdir, None)
def setUp(self): """Define test setup to be done.""" self.log.info("<<setUp Started>> at %s", time.ctime()) # Start the daos_agents in the job scripts self.setup_start_servers = True self.setup_start_agents = False super(SoakTestBase, self).setUp() self.username = getuser() # Initialize loop param for all tests self.loop = 1 self.exclude_slurm_nodes = [] # Setup logging directories for soak logfiles # self.output dir is an avocado directory .../data/ self.log_dir = self.params.get("logdir", "/run/*") self.outputsoakdir = self.outputdir + "/soak" # Create the remote log directories on all client nodes self.test_log_dir = self.log_dir + "/pass" + str(self.loop) self.local_pass_dir = self.outputsoakdir + "/pass" + str(self.loop) # Fail if slurm partition daos_client is not defined if not self.client_partition: raise SoakTestError( "<<FAILED: Partition is not correctly setup for daos " "slurm partition>>") # Check if the server nodes are in the client list; # this will happen when only one partition is specified for host_server in self.hostlist_servers: if host_server in self.hostlist_clients: self.hostlist_clients.remove(host_server) self.exclude_slurm_nodes.append(host_server) self.log.info("<<Updated hostlist_clients %s >>", self.hostlist_clients) if not self.hostlist_clients: self.fail("There are no nodes that are client only;" "check if the partition also contains server nodes") # Include test node for log cleanup; remove from client list local_host_list = include_local_host(None) self.exclude_slurm_nodes.extend(local_host_list) # Start an agent on the test control host to enable API calls for # reserved pool and containers. The test control host should be the # last host in the hostlist_clients list. agent_groups = {self.server_group: local_host_list} self.start_agents(agent_groups)
def start_agents(self, agent_groups=None, servers=None): """Start the daos_agent processes. Args: agent_groups (dict, optional): dictionary of lists of hosts on which to start the daos agent using a unique server group name key. Defaults to None which will use the server group name from the test's yaml file to start the daos agents on all client hosts specified in the test's yaml file. servers (list): list of hosts running the daos servers to be used to define the access points in the agent yaml config file Raises: avocado.core.exceptions.TestFail: if there is an error starting the agents """ if agent_groups is None: # Include running the daos_agent on the test control host for API # calls and calling the daos command from this host. agent_groups = { self.server_group: include_local_host(self.hostlist_clients)} self.log.debug("--- STARTING AGENT GROUPS: %s ---", agent_groups) if isinstance(agent_groups, dict): for group, hosts in agent_groups.items(): transport = DaosAgentTransportCredentials(self.workdir) # Use the unique agent group name to create a unique yaml file config_file = self.get_config_file(group, "agent") # Setup the access points with the server hosts common_cfg = CommonConfig(group, transport) self.add_agent_manager(config_file, common_cfg) self.configure_manager( "agent", self.agent_managers[-1], hosts, self.hostfile_clients_slots, servers) self.start_agent_managers()
def pool_acl_verification(self, current_user_acl, read, write, secondary_grp_test=False): """Verify the daos pool security with an acl file. Steps: (1)Setup dmg tool for creating a pool (2)Generate acl file with permissions (3)Create a pool with acl (4)Verify the pool create status (5)Get the pool's acl list (6)Verify pool's ace entry update and delete (7)Verify pool read operation (8)Verify pool write operation (9)Cleanup user and destroy pool Args: current_user_acl (str): acl with read write access credential. read (str): expecting read permission. write (str): expecting write permission. Return: None: pass to continue; fail to report the testlog and stop. """ # (1)Create dmg command scm_size = self.params.get("scm_size", "/run/pool_acl/*") get_acl_file = self.params.get("acl_file", "/run/pool_acl/*", "acl_test.txt") acl_file = os.path.join(self.tmp, get_acl_file) num_user = self.params.get("num_user", "/run/pool_acl/*") num_group = self.params.get("num_group", "/run/pool_acl/*") self.hostlist_clients = agu.include_local_host(self.hostlist_clients) # (2)Generate acl file with permissions self.log.info(" (1)Generate acl file with user/group permissions") permission_list = self.create_pool_acl(num_user, num_group, current_user_acl, acl_file) # (3)Create a pool with acl self.dmg.exit_status_exception = False data = self.dmg.pool_create(scm_size, acl_file=acl_file) self.dmg.exit_status_exception = True self.log.info(" (2)dmg= %s", self.dmg) self.log.info(" (3)Create a pool with acl") # (4)Verify the pool create status self.log.info(" (4)dmg.run() result=\n%s", self.dmg.result) if "ERR" in self.dmg.result.stderr: self.fail("##(4)Unable to parse pool uuid and svc.") # (5)Get the pool's acl list # dmg pool get-acl --pool <UUID> self.log.info(" (5)Get a pool's acl list by: " "dmg pool get-acl --pool --hostlist") pool_acl_list = self.get_pool_acl_list(data["uuid"]) self.log.info(" pool original permission_list: %s", permission_list) self.log.info(" pool get_acl permission_list: %s", pool_acl_list) # (6)Verify pool acl ace update and delete self.log.info(" (6)Verify update and delete of pool's acl entry.") tmp_ace = "daos_ci_test_new" new_entries = [ secTestBase.acl_entry("user", tmp_ace, "", PERMISSIONS), secTestBase.acl_entry("group", tmp_ace, "", PERMISSIONS) ] acl_principals = [ secTestBase.acl_principal("user", tmp_ace), secTestBase.acl_principal("group", tmp_ace) ] for new_entry in new_entries: self.update_pool_acl_entry(data["uuid"], "update", new_entry) for principal in acl_principals: self.update_pool_acl_entry(data["uuid"], "delete", principal) # (7)Verify pool read operation # daos pool query --pool <uuid> self.log.info(" (7)Verify pool read by: daos pool query --pool") self.verify_pool_readwrite(data["svc"], data["uuid"], "read", expect=read) # (8)Verify pool write operation # daos container create --pool <uuid> self.log.info( " (8)Verify pool write by: daos container create --pool") self.verify_pool_readwrite(data["svc"], data["uuid"], "write", expect=write) if secondary_grp_test: self.log.info(" (8-0)Verifying verify_pool_acl_prim_sec_groups") self.verify_pool_acl_prim_sec_groups(pool_acl_list, acl_file, data["uuid"], data["svc"]) # (9)Cleanup user and destroy pool self.log.info(" (9)Cleanup users and groups") self.cleanup_user_group(num_user, num_group)
def setUp(self): """Define test setup to be done.""" self.log.info("<<setUp Started>> at %s", time.ctime()) super(SoakTestBase, self).setUp() self.username = getuser() # Initialize loop param for all tests self.loop = 1 self.exclude_slurm_nodes = [] # Setup logging directories for soak logfiles # self.output dir is an avocado directory .../data/ self.log_dir = get_log_file("soak") self.outputsoakdir = self.outputdir + "/soak" # Create the remote log directories on all client nodes self.test_log_dir = self.log_dir + "/pass" + str(self.loop) self.local_pass_dir = self.outputsoakdir + "/pass" + str(self.loop) self.sharedlog_dir = self.tmp + "/soak" self.sharedsoakdir = self.sharedlog_dir + "/pass" + str(self.loop) # Fail if slurm partition is not defined if not self.client_partition: raise SoakTestError( "<<FAILED: Partition is not correctly setup for daos " "slurm partition>>") # Check if the server nodes are in the client list; # this will happen when only one partition is specified for host_server in self.hostlist_servers: if host_server in self.hostlist_clients: self.hostlist_clients.remove(host_server) self.exclude_slurm_nodes.append(host_server) # Include test node for log cleanup; remove from client list local_host_list = include_local_host(None) self.exclude_slurm_nodes.extend(local_host_list) if local_host_list[0] in self.hostlist_clients: self.hostlist_clients.remove((local_host_list[0])) # Check if requested reservation is allowed in partition # NOTE: Slurm reservation and partition are created before soak runs. # CI uses partition=daos_client and no reservation. # A21 uses partition=normal/default and reservation=daos-test. # Partition and reservation names are updated in the yaml file. # It is assumed that if there is no reservation (CI only), then all # the nodes in the partition will be used for soak. self.srun_params = {"partition": self.client_partition} slurm_reservation = self.params.get( "reservation", "/run/srun_params/*") if slurm_reservation is not None: # verify that the reservation is valid reserved_nodes = slurm_utils.get_reserved_nodes( slurm_reservation, self.client_partition) if not reserved_nodes: # client nodes are invalid for requested reservation self.hostlist_clients = [] raise SoakTestError( "<<FAILED: Reservation {} is invalid " "in partition {}>>".format( slurm_reservation, self.client_partition)) # update srun params self.srun_params["reservation"] = slurm_reservation self.log.info( "<<Updated hostlist_clients %s >>", self.hostlist_clients) if not self.hostlist_clients: self.fail( "There are no valid nodes in this partition to run " "soak. Check partition {} for valid nodes".format( self.client_partition))
def setUp(self): """Setup Test Case""" super().setUp() # using localhost as client if client list is empty if self.hostlist_clients is None: self.hostlist_clients = agu.include_local_host(None)