def setUp(self): """ setup for the test """ self.agent_sessions = None # get paths from the build_vars generated by build with open('../../../.build_vars.json') as build_file: build_paths = json.load(build_file) self.context = DaosContext(build_paths['PREFIX'] + '/lib/') self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../") # generate a hostfile self.hostlist_servers = self.params.get("test_machines", '/run/hosts/') self.hostfile_servers = write_host_file.write_host_file( self.hostlist_servers, self.workdir) # fire up the DAOS servers self.server_group = self.params.get("name", '/run/server_config/', 'daos_server') self.agent_sessions = agent_utils.run_agent(self.basepath, self.hostlist_servers) server_utils.run_server(self.hostfile_servers, self.server_group, build_paths['PREFIX'] + '/../') # create a pool to test with createmode = self.params.get("mode", '/run/pool/createmode/') createuid = self.params.get("uid", '/run/pool/createuid/') creategid = self.params.get("gid", '/run/pool/creategid/') createsetid = self.params.get("setname", '/run/pool/createset/') createsize = self.params.get("size", '/run/pool/createsize/') self.pool = DaosPool(self.context) self.pool.create(createmode, createuid, creategid, createsize, createsetid) self.pool.get_uuid_str() time.sleep(2)
def setUp(self): """Set up each test case.""" super(TestWithServers, self).setUp() self.server_group = self.params.get("name", "/server_config/", "daos_server") # Determine which hosts to use as servers and optionally clients. # Support the use of a host type count to test with subsets of the # specified hosts lists test_machines = self.params.get("test_machines", "/run/hosts/*") test_servers = self.params.get("test_servers", "/run/hosts/*") test_clients = self.params.get("test_clients", "/run/hosts/*") server_count = self.params.get("server_count", "/run/hosts/*") client_count = self.params.get("client_count", "/run/hosts/*") # Supported combinations of yaml hosts arguments: # - test_machines [+ server_count] # - test_servers [+ server_count] # - test_servers [+ server_count] + test_clients [+ client_count] if test_machines: self.hostlist_servers = test_machines[:server_count] elif test_servers and test_clients: self.hostlist_servers = test_servers[:server_count] self.hostlist_clients = test_clients[:client_count] elif test_servers: self.hostlist_servers = test_servers[:server_count] self.log.info("hostlist_servers: %s", self.hostlist_servers) self.log.info("hostlist_clients: %s", self.hostlist_clients) # If a specific count is specified, verify enough servers/clients are # specified to satisy the count host_count_checks = ( ("server", server_count, len(self.hostlist_servers) if self.hostlist_servers else 0), ("client", client_count, len(self.hostlist_clients) if self.hostlist_clients else 0)) for host_type, expected_count, actual_count in host_count_checks: if expected_count: self.assertEqual( expected_count, actual_count, "Test requires {} {}; {} specified".format( expected_count, host_type, actual_count)) # Start the servers and clients # Create host files self.hostfile_servers = write_host_file.write_host_file( self.hostlist_servers, self.workdir, self.hostfile_servers_slots) if self.hostlist_clients: self.hostfile_clients = write_host_file.write_host_file( self.hostlist_clients, self.workdir, self.hostfile_clients_slots) self.agent_sessions = agent_utils.run_agent(self.basepath, self.hostlist_servers, self.hostlist_clients) if self.setup_start_servers: self.start_servers()
def setUp(self): self.agent_sessions = None self.hostlist_servers = None # get paths from the build_vars generated by build with open( os.path.join(os.path.dirname(os.path.realpath(__file__)), "../../../../.build_vars.json")) as build_file: build_paths = json.load(build_file) self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../") self.hostlist_servers = self.params.get("test_machines", '/run/hosts/') # NULL is causing connect to blow up so skip that test for now uuidlist = self.params.get("uuid", '/run/connecttests/UUID/*/') connectuuid = uuidlist[0] if connectuuid == 'NULLPTR': self.cancel("skipping null pointer test until DAOS-1781 is fixed") # launch the server self.hostfile_servers = write_host_file.write_host_file( self.hostlist_servers, self.workdir) server_group = self.params.get("name", '/server_config/', 'daos_server') self.agent_sessions = agent_utils.run_agent(self.basepath, self.hostlist_servers) server_utils.run_server(self.hostfile_servers, server_group, self.basepath)
def setUp(self): self.agent_sessions = None # get paths from the build_vars generated by build with open('../../../.build_vars.json') as build_file: build_paths = json.load(build_file) self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../") self.server_group = self.params.get("name", '/server_config/', 'daos_server') # setup the DAOS python API self.context = DaosContext(build_paths['PREFIX'] + '/lib/') self.pool = None self.d_log = DaosLog(self.context) # getting hostfile self.hostfile_servers = None self.hostlist_servers = self.params.get("test_machines", '/run/hosts/*') self.hostfile_servers = write_host_file.write_host_file( self.hostlist_servers, self.workdir) print ("Host file is: {}".format(self.hostfile_servers)) self.container = None # starting server self.agent_sessions = agent_utils.run_agent(self.basepath, self.hostlist_servers) server_utils.run_server(self.hostfile_servers, self.server_group, self.basepath)
def setUp(self): self.agent_sessions = None # get paths from the build_vars generated by build with open('../../../.build_vars.json') as build_file: build_paths = json.load(build_file) self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../") self.server_group = self.params.get("name", '/server_config/', 'daos_server') # setup the DAOS python API self.context = DaosContext(build_paths['PREFIX'] + '/lib/') self.hostlist_servers = self.params.get("test_servers", '/run/hosts/test_machines/*') self.hostfile_servers = (write_host_file.write_host_file( self.hostlist_servers, self.workdir)) print("Host file servers is: {}".format(self.hostfile_servers)) self.hostlist_clients = self.params.get("test_clients", '/run/hosts/test_machines/*') self.slots = self.params.get("slots", '/run/ior/clientslots/*') self.hostfile_clients = (write_host_file.write_host_file( self.hostlist_clients, self.workdir, self.slots)) print("Host file clients is: {}".format(self.hostfile_clients)) self.agent_sessions = agent_utils.run_agent(self.basepath, self.hostlist_servers, self.hostlist_clients) server_utils.run_server(self.hostfile_servers, self.server_group, self.basepath) if not distutils.spawn.find_executable("ior") and \ int(str(self.name).split("-")[0]) == 1: ior_utils.build_ior(self.basepath)
def setUp(self): # get paths from the build_vars generated by build with open('../../../.build_vars.json') as build_file: build_paths = json.load(build_file) self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../") self.server_group = self.params.get("name", '/server_config/', 'daos_server') # setup the DAOS python API self.context = DaosContext(build_paths['PREFIX'] + '/lib/') self.hostlist_servers = self.params.get("test_servers", '/run/hosts/*') hostfile_servers = (write_host_file.write_host_file( self.hostlist_servers, self.workdir)) print("Host file servers is: {}".format(hostfile_servers)) self.hostlist_clients = self.params.get("test_clients", '/run/hosts/*') self.slots = self.params.get("slots", '/run/ior/clientslots/*') self.hostfile_clients = (write_host_file.write_host_file( self.hostlist_clients, self.workdir, self.slots)) print("Host file clients is: {}".format(self.hostfile_clients)) self.agent_sessions = agent_utils.run_agent(self.basepath, self.hostlist_servers, self.hostlist_clients) server_utils.run_server(hostfile_servers, self.server_group, self.basepath)
def setUp(self): # get paths from the build_vars generated by build with open('../../../.build_vars.json') as build_file: build_paths = json.load(build_file) self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../") self.server_group = self.params.get("name", '/server_config/', 'daos_server') self.daosctl = self.basepath + '/install/bin/daosctl' # setup the DAOS python API self.context = DaosContext(build_paths['PREFIX'] + '/lib/') self.pool = None self.hostlist_servers = self.params.get("test_servers", '/run/hosts/test_machines/*') self.hostfile_servers = (write_host_file.write_host_file( self.hostlist_servers, self.workdir)) print("Host file servers is: {}".format(self.hostfile_servers)) self.hostlist_clients = self.params.get("test_clients", '/run/hosts/test_machines/*') self.hostfile_clients = (write_host_file.write_host_file( self.hostlist_clients, self.workdir, None)) print("Host file clientsis: {}".format(self.hostfile_clients)) # set ior_flags and object class to be used by test self.ior_flags = self.params.get("F", '/run/ior/iorflags/') self.object_class = self.params.get("o", '/run/ior/objectclass/') self.agent_sessions = agent_utils.run_agent(self.basepath, self.hostlist_servers, self.hostlist_clients) server_utils.run_server(self.hostfile_servers, self.server_group, self.basepath)
def test_destroy_connect(self): """ Test destroying a pool that has a connected client with force == false. Should fail. :avocado: tags=pool,pooldestroy,x """ host = self.hostlist_servers[0] try: # write out a hostfile_servers and start the servers with it self.hostlist_servers = self.params.get("test_machines1", '/run/hosts/') hostfile_servers = write_host_file.write_host_file( self.hostlist_servers, self.tmp) self.agent_sessions = agent_utils.run_agent( self.basepath, self.hostlist_servers) server_utils.run_server(hostfile_servers, self.server_group, self.basepath) # parameters used in pool create createmode = self.params.get("mode", '/run/poolparams/createmode/') createuid = self.params.get("uid", '/run/poolparams/createuid/') creategid = self.params.get("gid", '/run/poolparams/creategid/') createsetid = self.params.get("setname", '/run/poolparams/createset/') createsize = self.params.get("size", '/run/poolparams/createsize/') # initialize a python pool object then create the underlying # daos storage pool = DaosPool(self.context) pool.create(createmode, createuid, creategid, createsize, createsetid, None) # need a connection to create container pool.connect(1 << 1) # destroy pool with connection open pool.destroy(0) # should throw an exception and not hit this self.fail("Shouldn't hit this line.\n") except DaosApiError as excep: print("got exception which is expected so long as it is BUSY") print(excep) print(traceback.format_exc()) # pool should still be there exists = check_for_pool.check_for_pool(host, pool.get_uuid_str) if exists != 0: self.fail("Pool gone, but destroy should have failed.\n") # no matter what happens cleanup finally: if self.agent_sessions: agent_utils.stop_agent(self.agent_sessions) server_utils.stop_server(hosts=self.hostlist_servers) os.remove(hostfile_servers)
def setUp(self): super(BadExcludeTest, self).setUp() self.agent_sessions = None self.hostlist_servers = self.params.get("test_machines", '/run/hosts/') self.hostfile_servers = write_host_file.write_host_file( self.hostlist_servers, self.workdir) server_group = self.params.get("name", '/server_config/', 'daos_server') self.agent_sessions = agent_utils.run_agent(self, self.hostlist_servers) server_utils.run_server(self, self.hostfile_servers, server_group)
def test_many_servers(self): """ Test destroy on a large (relative) number of servers. :avocado: tags=pool,pooldestroy,destroybig """ try: # write out a hostfile_servers and start the servers with it self.hostlist_servers = self.params.get("test_machines6", '/run/hosts/') hostfile_servers = write_host_file.write_host_file( self.hostlist_servers, self.tmp) self.agent_sessions = agent_utils.run_agent( self.basepath, self.hostlist_servers) server_utils.run_server(hostfile_servers, self.server_group, self.basepath) # parameters used in pool create createmode = self.params.get("mode", '/run/poolparams/createmode/') createuid = self.params.get("uid", '/run/poolparams/createuid/') creategid = self.params.get("gid", '/run/poolparams/creategid/') createsetid = self.params.get("setname", '/run/poolparams/createset/') createsize = self.params.get("size", '/run/poolparams/createsize/') # initialize a python pool object then create the underlying # daos storage pool = DaosPool(self.context) pool.create(createmode, createuid, creategid, createsize, createsetid, None) time.sleep(1) # okay, get rid of it pool.destroy(1) except DaosApiError as excep: print(excep) print(traceback.format_exc()) self.fail("6 server test failed.\n") except Exception as excep: self.fail("Daos code segfaulted most likely. Error: %s" % excep) # no matter what happens cleanup finally: if self.agent_sessions: agent_utils.stop_agent(self.agent_sessions) server_utils.stop_server(hosts=self.hostlist_servers) os.remove(hostfile_servers)
def setUp(self): self.agent_sessions = None self.pool = None self.container = None self.obj = None self.ioreq = None self.hostlist = None self.hostfile = None self.no_of_dkeys = None self.no_of_akeys = None self.array_size = None self.record_length = None with open('../../.build_vars.json') as json_f: build_paths = json.load(json_f) self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../") server_group = self.params.get("name", '/server_config/', 'daos_server') self.context = DaosContext(build_paths['PREFIX'] + '/lib64/') self.d_log = DaosLog(self.context) self.hostlist = self.params.get("test_machines", '/run/hosts/*') self.hostfile = write_host_file.write_host_file( self.hostlist, self.workdir) self.no_of_dkeys = self.params.get("no_of_dkeys", '/run/dkeys/*')[0] self.no_of_akeys = self.params.get("no_of_akeys", '/run/akeys/*')[0] self.array_size = self.params.get("size", '/array_size/') self.record_length = self.params.get("length", '/run/record/*') self.agent_sessions = agent_utils.run_agent(self.basepath, self.hostlist) server_utils.run_server(self, self.hostfile, server_group) self.pool = DaosPool(self.context) self.pool.create(self.params.get("mode", '/run/pool/createmode/*'), os.geteuid(), os.getegid(), self.params.get("size", '/run/pool/createsize/*'), self.params.get("setname", '/run/pool/createset/*'), None) self.pool.connect(2) self.container = DaosContainer(self.context) self.container.create(self.pool.handle) self.container.open() self.obj = DaosObj(self.context, self.container) self.obj.create(objcls=1) self.obj.open() self.ioreq = IORequest(self.context, self.container, self.obj, objtype=4)
def setUp(self): super(PoolSvc, self).setUp() self.pool = None self.hostfile_servers = None self.hostlist_servers = self.params.get("test_machines", '/run/hosts/*') self.hostfile_servers = write_host_file.write_host_file( self.hostlist_servers, self.workdir) print("Host file is: {}".format(self.hostfile_servers)) self.agent_sessions = agent_utils.run_agent(self.basepath, self.hostlist_servers) server_utils.run_server(self.hostfile_servers, self.server_group, self.basepath)
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(Soak, self).setUp() # 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.partition_clients: 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) # include test node for log cleanup; remove from client list test_node = [socket.gethostname().split('.', 1)[0]] if test_node[0] in self.hostlist_clients: self.hostlist_clients.remove(test_node[0]) self.exclude_slurm_nodes.append(test_node[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") self.node_list = self.hostlist_clients + test_node # Start agent on test node - need daos_agent yaml file self.agent_sessions = run_agent(self, self.hostlist_servers, test_node)
def test_delete_doesnt_exist(self): """ Test destroying a pool uuid that doesn't exist. :avocado: tags=pool,pooldestroy """ self.hostlist_servers = self.params.get("test_machines1", '/run/hosts/') hostfile_servers = write_host_file.write_host_file( self.hostlist_servers, self.tmp) self.agent_sessions = agent_utils.run_agent(self.basepath, self.hostlist_servers) server_utils.run_server(hostfile_servers, self.server_group, self.basepath) setid = self.params.get("setname", '/run/setnames/validsetname/') host = self.hostlist_servers[0] try: # randomly selected uuid, that is exceptionally unlikely to exist bogus_uuid = '81ef94d7-a59d-4a5e-935b-abfbd12f2105' # TODO make these params in the yaml daosctl = self.basepath + '/install/bin/daosctl' delete_cmd = ('{0} destroy-pool -i {1} -s {2}'.format( daosctl, bogus_uuid, setid)) process.system(delete_cmd) # the above command should fail resulting in an exception so if # we get here the test has failed self.fail("Pool {0} found on host {1} when not expected.\n".format( bogus_uuid, host)) except Exception as _excep: # expecting an exception so catch and pass the test pass # no matter what happens shutdown the server finally: if self.agent_sessions: agent_utils.stop_agent(self.agent_sessions) server_utils.stop_server(hosts=self.hostlist_servers) os.remove(hostfile_servers)
def setUp(self): super(CartSelfTest, self).setUp() self.agent_sessions = None self.hostlist_servers = self.params.get("test_machines", '/run/hosts/') self.hostfile_servers = write_host_file.write_host_file( self.hostlist_servers, self.workdir) context = DaosContext(self.prefix + '/lib/') self.d_log = DaosLog(context) # self_test params self.self_test_bin = os.path.join(self.prefix, "bin/self_test") self.endpoint = self.params.get("endpoint", "/run/testparams/") self.max_rpcs = self.params.get("max_inflight_rpcs", "/run/testparams/") self.repetitions = self.params.get("repetitions", "/run/testparams/") self.message_size = (self.params.get( "size", "/run/muxtestparams/message_size/*")[0]) self.share_addr = self.params.get("val", "/run/muxtestparams/share_addr/*")[0] self.env_dict = { "CRT_PHY_ADDR_STR": "ofi+sockets", "CRT_CTX_NUM": "8", "OFI_INTERFACE": "eth0", "CRT_CTX_SHARE_ADDR": str(self.share_addr) } self.env_list = [] for key, val in self.env_dict.items(): self.env_list.append("-x") self.env_list.append("{0}={1}".format(key, val)) # daos server params self.server_group = self.params.get("name", 'server_config', 'daos_server') self.uri_file = os.path.join(self.basepath, "install", "tmp", "uri.txt") self.agent_sessions = agent_utils.run_agent(self.basepath, self.hostlist_servers) server_utils.run_server(self.hostfile_servers, self.server_group, self.basepath, uri_path=self.uri_file, env_dict=self.env_dict)
def setUp(self): super(ObjectDataValidation, self).setUp() self.agent_sessions = None self.pool = None self.container = None self.obj = None self.ioreq = None self.hostlist = None self.hostfile = None self.no_of_dkeys = None self.no_of_akeys = None self.array_size = None self.record_length = None server_group = self.params.get("name", '/server_config/', 'daos_server') self.hostlist = self.params.get("test_servers", '/run/hosts/*') self.hostfile = write_host_file.write_host_file( self.hostlist, self.workdir) self.no_of_dkeys = self.params.get("no_of_dkeys", '/run/dkeys/*')[0] self.no_of_akeys = self.params.get("no_of_akeys", '/run/akeys/*')[0] self.array_size = self.params.get("size", '/array_size/') self.record_length = self.params.get("length", '/run/record/*') self.agent_sessions = agent_utils.run_agent(self, self.hostlist) server_utils.run_server(self, self.hostfile, server_group) self.pool = DaosPool(self.context) self.pool.create(self.params.get("mode", '/run/pool/createmode/*'), os.geteuid(), os.getegid(), self.params.get("size", '/run/pool/createsize/*'), self.params.get("setname", '/run/pool/createset/*'), None) self.pool.connect(2) self.container = DaosContainer(self.context) self.container.create(self.pool.handle) self.container.open() self.obj = DaosObj(self.context, self.container) self.obj.create(objcls=1) self.obj.open() self.ioreq = IORequest(self.context, self.container, self.obj, objtype=4)
def setUp(self): self.agent_sessions = None # there is a presumption that this test lives in a specific spot # in the repo # get paths from the build_vars generated by build self.hostlist_servers = None with open('../../../.build_vars.json') as f_open: build_paths = json.load(f_open) basepath = os.path.normpath(build_paths['PREFIX'] + "/../") self.hostlist_servers = self.params.get("test_machines", '/run/hosts/') self.hostfile = write_host_file.write_host_file( self.hostlist_servers, self.workdir) server_group = self.params.get("name", '/server_config/', 'daos_server') self.agent_sessions = agent_utils.run_agent(basepath, self.hostlist_servers) server_utils.run_server(self.hostfile, server_group, basepath) self.dmg = basepath + '/install/bin/dmg'
def setUp(self): super(BadConnectTest, self).setUp() self.agent_sessions = None self.hostlist_servers = None self.hostlist_servers = self.params.get("test_servers", '/run/hosts/') # NULL is causing connect to blow up so skip that test for now uuidlist = self.params.get("uuid", '/run/connecttests/UUID/*/') connectuuid = uuidlist[0] if connectuuid == 'NULLPTR': self.cancel("skipping null pointer test until DAOS-1781 is fixed") # launch the server self.hostfile_servers = write_host_file.write_host_file( self.hostlist_servers, self.workdir) server_group = self.params.get("name", '/server_config/', 'daos_server') self.agent_sessions = agent_utils.run_agent(self, self.hostlist_servers) server_utils.run_server(self, self.hostfile_servers, server_group)
def setUp(self): # there is a presumption that this test lives in a specific # spot in the repo with open('../../../.build_vars.json') as build_file: build_paths = json.load(build_file) basepath = os.path.normpath(build_paths['PREFIX'] + "/../") self.hostlist_servers = self.params.get("test_machines", '/run/hosts/') self.hostfile_servers = write_host_file.write_host_file( self.hostlist_servers, self.workdir) server_group = self.params.get("name", '/server_config/', 'daos_server') self.agent_sessions = agent_utils.run_agent(basepath, self.hostlist_servers) server_utils.run_server(self.hostfile_servers, server_group, basepath) self.daosctl = basepath + '/install/bin/daosctl'
def setUp(self): self.agent_sessions = None # get paths from the build_vars generated by build with open(os.path.join(os.path.dirname(os.path.realpath(__file__)), "../../../../.build_vars.json")) as build_file: build_paths = json.load(build_file) self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../") self.hostlist_servers = self.params.get("test_machines", '/run/hosts/') self.hostfile_servers = write_host_file.write_host_file( self.hostlist_servers, self.workdir) server_group = self.params.get("name", '/server_config/', 'daos_server') self.agent_sessions = agent_utils.run_agent(self.basepath, self.hostlist_servers) server_utils.run_server(self.hostfile_servers, server_group, self.basepath)
def setUp(self): """ test setup """ super(MultiServerCreateDeleteTest, self).setUp() self.agent_sessions = None # there is a presumption that this test lives in a specific spot # in the repo # get paths from the build_vars generated by build self.hostlist_servers = None self.hostlist_servers = self.params.get("test_machines", '/run/hosts/') self.hostfile = write_host_file.write_host_file( self.hostlist_servers, self.workdir) server_group = self.params.get("name", '/server_config/', 'daos_server') self.agent_sessions = agent_utils.run_agent(self, self.hostlist_servers) server_utils.run_server(self, self.hostfile, server_group) self.dmg = self.basepath + '/install/bin/dmg'
def setUp(self): self.agent_sessions = None self.pool = None self.hostlist_servers = None self.hostfile_clients = None self.hostfile_servers = None self.out_queue = None self.pool_connect = True with open('../../../.build_vars.json') as json_f: build_paths = json.load(json_f) self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../") self.server_group = self.params.get("name", '/server_config/', 'daos_server') self.context = DaosContext(build_paths['PREFIX'] + '/lib/') self.d_log = DaosLog(self.context) self.hostlist_servers = self.params.get("servers", '/run/hosts/*') self.hostfile_servers = write_host_file.write_host_file( self.hostlist_servers, self.workdir) self.hostlist_clients = self.params.get("clients", '/run/hosts/*') self.hostfile_clients = write_host_file.write_host_file( self.hostlist_clients, self.workdir) self.agent_sessions = agent_utils.run_agent(self.basepath, self.hostlist_servers, self.hostlist_clients) server_utils.run_server(self.hostfile_servers, self.server_group, self.basepath) self.pool = DaosPool(self.context) self.pool.create(self.params.get("mode", '/run/pool/createmode/*'), os.geteuid(), os.getegid(), self.params.get("size", '/run/pool/createsize/*'), self.params.get("setname", '/run/pool/createset/*'), nvme_size=self.params.get("size", '/run/pool/nvmesize/*'))
def setUp(self): super(Romio, self).setUp() self.agent_sessions = None # get paths from the build_vars generated by build self.server_group = self.params.get("name", '/server_config/', 'daos_server') self.hostlist_servers = self.params.get("test_servers", '/run/hosts/') self.hostfile_servers = (write_host_file.write_host_file( self.hostlist_servers, self.workdir)) print("Host file servers is: {}".format(self.hostfile_servers)) self.hostlist_clients = self.params.get("test_clients", '/run/hosts/') self.hostfile_clients = (write_host_file.write_host_file( self.hostlist_clients, self.workdir)) print("Host file clients is: {}".format(self.hostfile_clients)) # start servers self.agent_sessions = agent_utils.run_agent(self, self.hostlist_servers, self.hostlist_clients) server_utils.run_server(self, self.hostfile_servers, self.server_group) self.mpio = None
def test_metadata_server_restart(self): """ Test ID: DAOS-1512 Test Description: This test will verify 2000 IOR small size container after server restart. Test will write IOR in 5 different threads for faster execution time. Each thread will create 400 (8bytes) containers to the same pool. Restart the servers, read IOR container file written previously and validate data integrity by using IOR option "-R -G 1". :avocado: tags=metadata,metadata_ior,nvme,small """ self.pool_connect = False files_per_thread = 400 total_ior_threads = 5 threads = [] ior_args = {} createsvc = self.params.get("svcn", '/run/pool/createsvc/') svc_list = "" for i in range(createsvc): svc_list += str(int(self.pool.svc.rl_ranks[i])) + ":" svc_list = svc_list[:-1] ior_args['client_hostfile_servers'] = self.hostfile_clients ior_args['pool_uuid'] = self.pool.get_uuid_str() ior_args['svc_list'] = svc_list ior_args['basepath'] = self.basepath ior_args['server_group'] = self.server_group ior_args['tmp_dir'] = self.workdir ior_args['iorwriteflags'] = self.params.get("F", '/run/ior/iorwriteflags/') ior_args['iorreadflags'] = self.params.get("F", '/run/ior/iorreadflags/') ior_args['iteration'] = self.params.get("iter", '/run/ior/iteration/') ior_args['stripe_size'] = self.params.get("s", '/run/ior/stripesize/*') ior_args['stripe_count'] = self.params.get("c", '/run/ior/stripecount/') ior_args['async_io'] = self.params.get("a", '/run/ior/asyncio/') ior_args['object_class'] = self.params.get("o", '/run/ior/objectclass/') ior_args['slots'] = self.params.get("slots", '/run/ior/clientslots/*') ior_args['files_per_thread'] = files_per_thread self.out_queue = Queue.Queue() #IOR write threads for i in range(total_ior_threads): threads.append( threading.Thread(target=ior_runner_thread, args=(self.out_queue, "Thread-{}".format(i), "write"), kwargs=ior_args)) if self.thread_control(threads, "write") == "FAIL": self.d_log.error(" IOR write Thread FAIL") self.fail(" IOR write Thread FAIL") #Server Restart if self.agent_sessions: agent_utils.stop_agent(self.agent_sessions, self.hostlist_clients) server_utils.stop_server(hosts=self.hostlist_servers) self.agent_sessions = agent_utils.run_agent(self.basepath, self.hostlist_clients, self.hostlist_servers) server_utils.run_server(self.hostfile_servers, self.server_group, self.basepath) #Read IOR with verification with same number of threads threads = [] for i in range(total_ior_threads): threads.append( threading.Thread(target=ior_runner_thread, args=(self.out_queue, "Thread-{}".format(i), "read"), kwargs=ior_args)) if self.thread_control(threads, "read") == "FAIL": self.d_log.error(" IOR write Thread FAIL") self.fail(" IOR read Thread FAIL")
def setUp(self): """Set up each test case.""" super(TestWithServers, self).setUp() self.server_group = self.params.get("name", "/server_config/", "daos_server") # Determine which hosts to use as servers and optionally clients. # Support the use of a host type count to test with subsets of the # specified hosts lists test_servers = self.params.get("test_servers", "/run/hosts/*") test_clients = self.params.get("test_clients", "/run/hosts/*") server_count = self.params.get("server_count", "/run/hosts/*") client_count = self.params.get("client_count", "/run/hosts/*") # If server or client host list are defined through valid slurm # partition names override any hosts specified through lists. test_servers, self.partition_servers = self.get_partition_hosts( "server_partition", test_servers) test_clients, self.partition_clients = self.get_partition_hosts( "client_partition", test_clients) # Supported combinations of yaml hosts arguments: # - test_servers [+ server_count] # - test_servers [+ server_count] + test_clients [+ client_count] if test_servers and test_clients: self.hostlist_servers = test_servers[:server_count] self.hostlist_clients = test_clients[:client_count] elif test_servers: self.hostlist_servers = test_servers[:server_count] self.log.info("hostlist_servers: %s", self.hostlist_servers) self.log.info("hostlist_clients: %s", self.hostlist_clients) # Find a configuration that meets the test requirements self.config = Configuration(self.params, self.hostlist_servers, debug=self.debug) if not self.config.set_config(self): self.cancel("Test requirements not met!") # If a specific count is specified, verify enough servers/clients are # specified to satisy the count host_count_checks = ( ("server", server_count, len(self.hostlist_servers) if self.hostlist_servers else 0), ("client", client_count, len(self.hostlist_clients) if self.hostlist_clients else 0)) for host_type, expected_count, actual_count in host_count_checks: if expected_count: self.assertEqual( expected_count, actual_count, "Test requires {} {}; {} specified".format( expected_count, host_type, actual_count)) # Create host files if self.hostlist_clients: self.hostfile_clients = write_host_file.write_host_file( self.hostlist_clients, self.workdir, self.hostfile_clients_slots) # Start the clients (agents) if self.setup_start_agents: self.agent_sessions = agent_utils.run_agent( self, self.hostlist_servers, self.hostlist_clients) # Start the servers if self.setup_start_servers: self.start_servers()
def test_container_basics(self): """ Test basic container create/destroy/open/close/query. Nothing fancy just making sure they work at a rudimentary level :avocado: tags=container,containercreate,containerdestroy,basecont """ pool = None hostlist = None try: hostlist = self.params.get("test_machines", '/run/hosts/*') hostfile = write_host_file.write_host_file(hostlist, self.workdir) self.agent_sessions = agent_utils.run_agent(self.basepath, hostlist) server_utils.run_server(hostfile, self.server_group, self.basepath) # give it time to start time.sleep(2) # parameters used in pool create createmode = self.params.get("mode", '/run/conttests/createmode/') createuid = self.params.get("uid", '/run/conttests/createuid/') creategid = self.params.get("gid", '/run/conttests/creategid/') createsetid = self.params.get("setname", '/run/conttests/createset/') createsize = self.params.get("size", '/run/conttests/createsize/') # initialize a python pool object then create the underlying # daos storage pool = DaosPool(self.context) pool.create(createmode, createuid, creategid, createsize, createsetid, None) # need a connection to create container pool.connect(1 << 1) # create a container container = DaosContainer(self.context) container.create(pool.handle) # now open it container.open() # do a query and compare the UUID returned from create with # that returned by query container.query() if container.get_uuid_str() != c_uuid_to_str( container.info.ci_uuid): self.fail("Container UUID did not match the one in info'n") container.close() # wait a few seconds and then destroy time.sleep(5) container.destroy() except DaosApiError as excep: print(excep) print(traceback.format_exc()) self.fail("Test was expected to pass but it failed.\n") except Exception as excep: self.fail("Daos code segfaulted most likely, error: %s" % excep) finally: # cleanup the pool if pool is not None: pool.disconnect() pool.destroy(1) if self.agent_sessions: agent_utils.stop_agent(self.agent_sessions) server_utils.stop_server(hosts=hostlist)
def test_destroy_async(self): """ Performn destroy asynchronously, successful and failed. :avocado: tags=pool,pooldestroy,destroyasync """ global GLOB_SIGNAL global GLOB_RC try: # write out a hostfile_servers and start the servers with it self.hostlist_servers = self.params.get("test_machines1", '/run/hosts/') hostfile_servers = write_host_file.write_host_file( self.hostlist_servers, self.tmp) self.agent_sessions = agent_utils.run_agent( self.basepath, self.hostlist_servers) server_utils.run_server(hostfile_servers, self.server_group, self.basepath) # parameters used in pool create createmode = self.params.get("mode", '/run/poolparams/createmode/') createuid = self.params.get("uid", '/run/poolparams/createuid/') creategid = self.params.get("gid", '/run/poolparams/creategid/') createsetid = self.params.get("setname", '/run/poolparams/createset/') createsize = self.params.get("size", '/run/poolparams/createsize/') # initialize a python pool object then create the underlying # daos storage pool = DaosPool(self.context) pool.create(createmode, createuid, creategid, createsize, createsetid, None) # allow the callback to tell us when its been called GLOB_SIGNAL = threading.Event() # blow it away but this time get return code via callback function pool.destroy(1, cb_func) # wait for callback GLOB_SIGNAL.wait() if GLOB_RC != 0: self.fail("RC not as expected in async test") # recreate the pool, reset the signal, shutdown the # servers so call will fail and then check rc in the callback pool.create(createmode, createuid, creategid, createsize, createsetid, None) GLOB_SIGNAL = threading.Event() GLOB_RC = -9900000 server_utils.stop_server(hosts=self.hostlist_servers) pool.destroy(1, cb_func) # wait for callback, expecting a timeout since servers are down GLOB_SIGNAL.wait() if GLOB_RC != -1011: self.fail("RC not as expected in async test") except DaosApiError as excep: print(excep) print(traceback.format_exc()) self.fail("destroy async test failed.\n") except Exception as excep: self.fail("Daos code segfaulted most likely. Error: %s" % excep) # no matter what happens cleanup finally: if self.agent_sessions: agent_utils.stop_agent(self.agent_sessions) server_utils.stop_server(hosts=self.hostlist_servers) os.remove(hostfile_servers)
def test_metadata_server_restart(self): """JIRA ID: DAOS-1512. Test Description: This test will verify 2000 IOR small size container after server restart. Test will write IOR in 5 different threads for faster execution time. Each thread will create 400 (8bytes) containers to the same pool. Restart the servers, read IOR container file written previously and validate data integrity by using IOR option "-R -G 1". Use Cases: ? :avocado: tags=metadata,metadata_ior,nvme,small """ files_per_thread = 400 total_ior_threads = 5 self.out_queue = Queue.Queue() processes = self.params.get("slots", "/run/ior/clientslots/*") list_of_uuid_lists = [[ str(uuid.uuid4()) for _ in range(files_per_thread) ] for _ in range(total_ior_threads)] # Launch threads to run IOR to write data, restart the agents and # servers, and then run IOR to read the data for operation in ("write", "read"): # Create the IOR threads threads = [] for index in range(total_ior_threads): # Define the arguments for the ior_runner_thread method ior_cmd = IorCommand() ior_cmd.get_params(self) ior_cmd.set_daos_params(self.server_group, self.pool) ior_cmd.flags.value = self.params.get( "F", "/run/ior/ior{}flags/".format(operation)) # Add a thread for these IOR arguments threads.append( threading.Thread(target=ior_runner_thread, kwargs={ "ior_cmd": ior_cmd, "uuids": list_of_uuid_lists[index], "mgr": self.orterun, "attach": self.tmp, "hostfile": self.hostfile_clients, "procs": processes, "results": self.out_queue })) self.log.info("Creatied %s thread %s with container uuids %s", operation, index, list_of_uuid_lists[index]) # Launch the IOR threads if self.thread_control(threads, operation) == "FAIL": self.d_log.error("IOR {} Thread FAIL".format(operation)) self.fail("IOR {} Thread FAIL".format(operation)) # Restart the agents and servers after the write / before the read if operation == "write": # Stop the agents and servers if self.agent_sessions: stop_agent(self.agent_sessions, self.hostlist_clients) stop_server(hosts=self.hostlist_servers) # Start the agents self.agent_sessions = run_agent(self.basepath, self.hostlist_clients, self.hostlist_servers) # Start the servers run_server(self.hostfile_servers, self.server_group, self.basepath, clean=False)
def test_rebuild_with_io(self): """ Test ID: Rebuild-003 Test Description: Trigger a rebuild while I/O is ongoing. Use Cases: -- single pool, single client performing continous read/write/verify sequence while failure/rebuild is triggered in another process :avocado: tags=pool,rebuild,rebuildwithio """ # the rebuild tests need to redo this stuff each time so not in setup # as it usually would be server_group = self.params.get("name", '/server_config/', 'daos_server') self.hostlist_servers = self.params.get("test_machines", '/run/hosts/') hostfile_servers = write_host_file.write_host_file( self.hostlist_servers, self.workdir) try: self.agent_sessions = agent_utils.run_agent(self.basepath, self.hostlist_servers) server_utils.run_server(hostfile_servers, server_group, self.basepath) # use the uid/gid of the user running the test, these should # be perfectly valid createuid = os.geteuid() creategid = os.getegid() # parameters used in pool create that are in yaml createmode = self.params.get("mode", '/run/testparams/createmode/') createsetid = self.params.get("setname", '/run/testparams/createset/') createsize = self.params.get("size", '/run/testparams/createsize/') # initialize a python pool object then create the underlying # daos storage pool = DaosPool(self.context) pool.create(createmode, createuid, creategid, createsize, createsetid, None) pool.connect(1 << 1) container = DaosContainer(self.context) container.create(pool.handle) container.open() # get pool status and make sure it all looks good before we start pool.pool_query() if pool.pool_info.pi_ndisabled != 0: self.fail("Number of disabled targets reporting incorrectly.\n") if pool.pool_info.pi_rebuild_st.rs_errno != 0: self.fail("Rebuild error but rebuild hasn't run.\n") if pool.pool_info.pi_rebuild_st.rs_done != 1: self.fail("Rebuild is running but device hasn't failed yet.\n") if pool.pool_info.pi_rebuild_st.rs_obj_nr != 0: self.fail("Rebuilt objs not zero.\n") if pool.pool_info.pi_rebuild_st.rs_rec_nr != 0: self.fail("Rebuilt recs not zero.\n") dummy_pool_version = pool.pool_info.pi_rebuild_st.rs_version # do I/O for 30 seconds dummy_bw = io_utilities.continuous_io(container, 30) # trigger the rebuild rank = self.params.get("rank", '/run/testparams/ranks/*') server = DaosServer(self.context, server_group, rank) server.kill(1) pool.exclude([rank]) # do another 30 seconds of I/O, # waiting for some improvements in server bootstrap # at which point we can move the I/O to a separate client and # really pound it with I/O dummy_bw = io_utilities.continuous_io(container, 30) # wait for the rebuild to finish while True: pool.pool_query() if pool.pool_info.pi_rebuild_st.rs_done == 1: break else: time.sleep(2) # check rebuild statistics if pool.pool_info.pi_ndisabled != 1: self.fail("Number of disabled targets reporting incorrectly: {}" .format(pool.pool_info.pi_ndisabled)) if pool.pool_info.pi_rebuild_st.rs_errno != 0: self.fail("Rebuild error reported: {}".format( pool.pool_info.pi_rebuild_st.rs_errno)) if pool.pool_info.pi_rebuild_st.rs_obj_nr <= 0: self.fail("No objects have been rebuilt.") if pool.pool_info.pi_rebuild_st.rs_rec_nr <= 0: self.fail("No records have been rebuilt.") except (ValueError, DaosApiError) as excep: print(excep) print(traceback.format_exc()) self.fail("Expecting to pass but test has failed.\n") finally: # wait for the I/O process to finish try: server_utils.stop_server(hosts=self.hostlist_servers) os.remove(hostfile_servers) # really make sure everything is gone check_for_pool.cleanup_pools(self.hostlist_servers) finally: if self.agent_sessions: agent_utils.stop_agent(self.agent_sessions) server_utils.kill_server(self.hostlist_servers)
def test_simple_delete(self): """ Test destroying a pool created on a single server, nobody is using the pool, force is not needed. :avocado: tags=pool,pooldestroy,quick """ self.hostlist_servers = self.params.get("test_machines1", '/run/hosts/') hostfile_servers = write_host_file.write_host_file( self.hostlist_servers, self.tmp) self.agent_sessions = agent_utils.run_agent(self.basepath, self.hostlist_servers) server_utils.run_server(hostfile_servers, self.server_group, self.basepath) setid = self.params.get("setname", '/run/setnames/validsetname/') try: # use the uid/gid of the user running the test, these should # be perfectly valid uid = os.geteuid() gid = os.getegid() # TODO make these params in the yaml daosctl = self.basepath + '/install/bin/daosctl' create_cmd = ('{0} create-pool -m {1} -u {2} -g {3} -s {4}'.format( daosctl, 0x731, uid, gid, setid)) uuid_str = """{0}""".format(process.system_output(create_cmd)) print("uuid is {0}\n".format(uuid_str)) host = self.hostlist_servers[0] exists = check_for_pool.check_for_pool(host, uuid_str) if exists != 0: self.fail("Pool {0} not found on host {1}.\n".format( uuid_str, host)) delete_cmd = ('{0} destroy-pool -i {1} -s {2}'.format( daosctl, uuid_str, setid)) process.system(delete_cmd) exists = check_for_pool.check_for_pool(host, uuid_str) if exists == 0: self.fail( "Pool {0} found on host {1} when not expected.\n".format( uuid_str, host)) except Exception as excep: print(excep) print(traceback.format_exc()) self.fail("Expecting to pass but test has failed.\n") # no matter what happens shutdown the server finally: try: os.remove(hostfile_servers) finally: if self.agent_sessions: agent_utils.stop_agent(self.agent_sessions) server_utils.stop_server(hosts=self.hostlist_servers)