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 = self.params.get("test_machines", '/run/hosts/')
self.hostfile = write_host_file.write_host_file(self.hostlist,
self.workdir)
# fire up the DAOS servers
self.server_group = self.params.get("name", '/run/server_config/',
'daos_server')
self.agent_sessions = AgentUtils.run_agent(self.basepath, self.hostlist)
server_utils.run_server(self.hostfile, 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):
# 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):
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
self.hostlist = 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 = 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 = write_host_file.write_host_file(self.hostlist,
self.workdir)
server_group = self.params.get("name", '/server_config/',
'daos_server')
self.agent_sessions = AgentUtils.run_agent(self.basepath, self.hostlist)
server_utils.run_server(self.hostfile, server_group, self.basepath)
def setUp(self):
self.agent_sessions = None
self.hostlist = None
self.pool = 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.hostlist = self.params.get("test_machines", '/run/hosts/*')
self.hostfile = write_host_file.write_host_file(self.hostlist,
self.workdir)
print("Host file is: {}".format(self.hostfile))
self.agent_sessions = AgentUtils.run_agent(self.basepath, self.hostlist)
server_utils.run_server(self.hostfile, self.server_group, self.basepath)
time.sleep(10)
def setUp(self):
self.agent_sessions = None
# get paths from the build_vars generated by build
self.hostlist = None
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')
# parameters used in pool create
self.createmode = self.params.get("mode",
'/run/createtests/createmode/')
self.createuid = os.geteuid()
self.creategid = os.getegid()
self.createsetid = self.params.get("setname",
'/run/createtests/createset/')
self.createsize = self.params.get("size",
'/run/createtests/createsize/')
# setup the DAOS python API
self.context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.pool = None
self.container = None
# hostlist and logging
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.agent_sessions = AgentUtils.run_agent(self.basepath, self.hostlist)
server_utils.run_server(self.hostfile, 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'] + "/../")
print("<<{}>>".format(self.basepath))
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.num_procs = self.params.get("np", '/run/ior/client_processes/*')
self.hostfile_clients = (
write_host_file.write_host_file(self.hostlist_clients, self.workdir,
None))
print("Host file clients is: {}".format(self.hostfile_clients))
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/')
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 = AgentUtils.run_agent(self.basepath,
self.hostlist_servers,
self.hostlist_clients)
server_utils.run_server(self.hostfile_servers, self.server_group,
self.basepath)
self.mpio = None
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):
# 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 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):
self.agent_sessions = None
self.hostlist = None
self.subtest_name = self.params.get("test_name",
'/run/daos_tests/Tests/*')
self.subtest_name = self.subtest_name.replace(" ", "_")
# get paths from the build_vars generated by build
with open('../../../.build_vars.json') as build_vars:
build_paths = json.load(build_vars)
self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
self.server_group = self.params.get("name", '/server_config/',
'daos_server')
self.daos_test = self.basepath + '/install/bin/daos_test'
self.orterun = self.basepath + '/install/bin/orterun'
self.hostlist = self.params.get("test_machines", '/run/hosts/*')
self.hostfile = write_host_file.write_host_file(self.hostlist,
self.workdir)
logfile_env = os.environ['D_LOG_FILE']
self.log_dir, self.server_log = os.path.split(logfile_env)
self.client_log = os.path.join(self.log_dir,
self.subtest_name + "_" + CLIENT_LOG)
#To generate the seperate client log file
self.orterun_env = '-x D_LOG_FILE={}'.format(self.client_log)
self.agent_sessions = AgentUtils.run_agent(self.basepath, self.hostlist)
server_utils.run_server(self.hostfile, self.server_group, self.basepath)
def setUp(self):
self.agent_sessions = None
with open('../../../.build_vars.json') as json_f:
build_paths = json.load(json_f)
basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
server_group = self.params.get("name",
'/server_config/',
'daos_server')
self.context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.container = None
self.hostlist = self.params.get("test_machines", '/run/hosts/*')
self.hostfile = write_host_file.write_host_file(self.hostlist,
self.workdir)
self.agent_sessions = AgentUtils.run_agent(basepath, self.hostlist)
server_utils.run_server(self.hostfile, server_group, 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/*'),
None)
self.pool.connect(1 << 1)
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 = self.params.get("test_machines1", '/run/hosts/')
hostfile = write_host_file.write_host_file(self.hostlist, self.tmp)
self.agent_sessions = AgentUtils.run_agent(self.basepath, self.hostlist)
server_utils.run_server(hostfile, 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[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)
finally:
if self.agent_sessions:
AgentUtils.stop_agent(self.hostlist, self.agent_sessions)
server_utils.stop_server(hosts=self.hostlist)
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):
# initialising variables
self.basepath = None
self.server_group = None
self.context = None
self.pool = None
self.mpio = None
self.agent_sessions = None
self.hostlist_servers = None
self.hostfile_servers = None
self.hostlist_clients = None
self.hostfile_clients = None
self.createsvc = None
# get paths from the build_vars generated by build
with open('../../../.build_vars.json') as var_file:
build_paths = json.load(var_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/')
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, None)
print("Host file clients is: {}".format(self.hostfile_clients))
self.agent_sessions = AgentUtils.run_agent(self.basepath,
self.hostlist_servers,
self.hostlist_clients)
# start servers
server_utils.run_server(self.hostfile_servers, self.server_group,
self.basepath)
try:
# parameters used in pool create
createmode = self.params.get("mode", '/run/pool/createmode/*/')
createuid = os.geteuid()
creategid = os.getegid()
createsetid = self.params.get("setname", '/run/pool/createset/')
createsize = self.params.get("size", '/run/pool/createsize/')
self.createsvc = self.params.get("svcn", '/run/pool/createsvc/')
# initialize a python pool object then create the underlying
# daos storage
self.pool = DaosPool(self.context)
self.pool.create(createmode, createuid, creategid, createsize,
createsetid, None, None, self.createsvc)
except (DaosApiError) as excep:
self.fail("<Test Failed at pool create> \n{1}".format(excep))
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))
# Create host files
self.hostfile_servers = write_host_file.write_host_file(
self.hostlist_servers, self.workdir)
if self.hostlist_clients:
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)
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[0]
try:
# write out a hostfile and start the servers with it
self.hostlist = self.params.get("test_machines1", '/run/hosts/')
hostfile = write_host_file.write_host_file(self.hostlist, self.tmp)
self.agent_sessions = AgentUtils.run_agent(self.basepath,
self.hostlist)
server_utils.run_server(hostfile, 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:
AgentUtils.stop_agent(self.hostlist, self.agent_sessions)
server_utils.stop_server(hosts=self.hostlist)
os.remove(hostfile)
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)
basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
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 = 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 = AgentUtils.run_agent(basepath, self.hostlist)
server_utils.run_server(self.hostfile, server_group, 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/*'),
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
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):
self.agent_sessions = None
try:
# 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 = self.params.get("test_machines", '/run/hosts/*')
self.hostfile = write_host_file.write_host_file(self.hostlist,
self.workdir)
self.agent_sessions = AgentUtils.run_agent(self.basepath,
self.hostlist)
server_utils.run_server(self.hostfile, self.server_group,
self.basepath)
# parameters used in pool create
createmode = self.params.get("mode", '/run/pool/createmode/')
createsetid = self.params.get("setname", '/run/pool/createset/')
createsize = self.params.get("size", '/run/pool/createsize/')
createuid = os.geteuid()
creategid = os.getegid()
# initialize a python pool object then create the underlying
# daos storage
self.pool = DaosPool(self.context)
self.pool.create(createmode, createuid, creategid,
createsize, createsetid, None)
self.pool.connect(1 << 1)
# create a container
self.container = DaosContainer(self.context)
self.container.create(self.pool.handle)
# now open it
self.container.open()
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
self.fail("Test failed during setup.\n")
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):
super(TestWithServers, self).setUp()
self.server_group = self.params.get("server_group", '/server/',
'daos_server')
self.hostlist_servers = self.params.get("test_machines", '/run/hosts/*')
self.hostfile_servers = write_host_file.write_host_file(
self.hostlist_servers,
self.workdir)
self.agent_sessions = AgentUtils.run_agent(self.basepath,
self.hostlist_servers)
server_utils.run_server(self.hostfile_servers, self.server_group,
self.basepath)
def test_many_servers(self):
"""
Test destroy on a large (relative) number of servers.
:avocado: tags=pool,pooldestroy,destroybig
"""
try:
# write out a hostfile and start the servers with it
self.hostlist = self.params.get("test_machines6", '/run/hosts/')
hostfile = write_host_file.write_host_file(self.hostlist, self.tmp)
self.agent_sessions = AgentUtils.run_agent(self.basepath,
self.hostlist)
server_utils.run_server(hostfile, 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:
AgentUtils.stop_agent(self.hostlist, self.agent_sessions)
server_utils.stop_server(hosts=self.hostlist)
os.remove(hostfile)
def setUp(self):
# get paths from the build_vars generated by build
with open('../../../.build_vars.json') as finput:
build_paths = json.load(finput)
basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
server_group = self.params.get("name", '/server_config/',
'daos_server')
# setup the DAOS python API
self.context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.d_log = DaosLog(self.context)
self.hostlist = self.params.get("test_machines", '/run/hosts/*')
hostfile = write_host_file.write_host_file(self.hostlist, self.workdir)
server_utils.run_server(hostfile, server_group, basepath)
# Set up the pool and container.
try:
# parameters used in pool create
createmode = self.params.get("mode", '/run/pool/createmode/')
createsetid = self.params.get("setname", '/run/pool/createset/')
createsize = self.params.get("size", '/run/pool/createsize/*')
createuid = os.geteuid()
creategid = os.getegid()
# initialize a pool object then create the underlying
# daos storage
self.pool = DaosPool(self.context)
self.pool.create(createmode, createuid, creategid, createsize,
createsetid, None)
# need a connection to create container
self.pool.connect(1 << 1)
# create a container
self.container = DaosContainer(self.context)
self.container.create(self.pool.handle)
# now open it
self.container.open()
except DaosApiError as error:
print(error)
print(traceback.format_exc())
self.fail("Test failed before snapshot taken")
def setUp(self):
# get paths from the build_vars generated by build
with open('../../../.build_vars.json') as finput:
build_paths = json.load(finput)
basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
server_group = self.params.get("name", '/server_config/',
'daos_server')
# setup the DAOS python API
self.context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.d_log = DaosLog(self.context)
self.hostlist = self.params.get("test_machines", '/run/hosts/*')
hostfile = write_host_file.write_host_file(self.hostlist, self.workdir)
server_utils.run_server(hostfile, server_group, basepath)
# Set up the pool and container.
try:
# parameters used in pool create
createmode = self.params.get("mode", '/run/pool/createmode/')
createsetid = self.params.get("setname", '/run/pool/createset/')
createsize = self.params.get("size", '/run/pool/createsize/*')
createuid = os.geteuid()
creategid = os.getegid()
# initialize a pool object then create the underlying
# daos storage
self.pool = DaosPool(self.context)
self.pool.create(createmode, createuid, creategid,
createsize, createsetid, None)
# need a connection to create container
self.pool.connect(1 << 1)
# create a container
self.container = DaosContainer(self.context)
self.container.create(self.pool.handle)
# now open it
self.container.open()
except DaosApiError as error:
print(error)
print(traceback.format_exc())
self.fail("Test failed before snapshot taken")
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.hostlist = self.params.get("test_machines", '/run/hosts/')
self.hostfile = write_host_file.write_host_file(self.hostlist,
self.workdir)
server_group = self.params.get("name", '/server_config/',
'daos_server')
self.agent_sessions = AgentUtils.run_agent(self.basepath, self.hostlist)
server_utils.run_server(self.hostfile, server_group, self.basepath)
def start_servers(self, server_groups=None):
"""Start the servers and clients.
Args:
server_groups (dict, optional): [description]. Defaults to None.
"""
if isinstance(server_groups, dict):
# Optionally start servers on a different subset of hosts with a
# different server group
for group, hosts in server_groups.items():
self.log.info("Starting servers: group=%s, hosts=%s", group,
hosts)
hostfile = write_host_file.write_host_file(hosts, self.workdir)
server_utils.run_server(hostfile, group, self.basepath)
else:
server_utils.run_server(self.hostfile_servers, self.server_group,
self.basepath)
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):
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 = None
with open('../../../.build_vars.json') as f_open:
build_paths = json.load(f_open)
basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
self.hostlist = self.params.get("test_machines", '/run/hosts/')
self.hostfile = write_host_file.write_host_file(self.hostlist,
self.workdir)
server_group = self.params.get("name", '/server_config/',
'daos_server')
self.agent_sessions = AgentUtils.run_agent(basepath, self.hostlist)
server_utils.run_server(self.hostfile, server_group, basepath)
self.dmg = basepath + '/install/bin/dmg'
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):
""" 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 = self.params.get("test_machines", '/run/hosts/')
self.hostfile = write_host_file.write_host_file(self.hostlist,
self.workdir)
# fire up the DAOS servers
self.server_group = self.params.get("name", '/run/server_config/',
'daos_server')
self.agent_sessions = AgentUtils.run_agent(self.basepath, self.hostlist)
server_utils.run_server(self.hostfile, 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)
uuid = self.pool.get_uuid_str()
time.sleep(2)
# stuff some bogus data into the pool
how_many_bytes = long(self.params.get("datasize",
'/run/testparams/datatowrite/'))
exepath = os.path.join(build_paths['PREFIX'],
"/../src/tests/ftest/util/write_some_data.py")
cmd = "export DAOS_POOL={0}; export DAOS_SVCL=1; mpirun"\
" --np 1 --host {1} {2} {3} testfile".format(
uuid, self.hostlist[0], exepath, how_many_bytes)
subprocess.call(cmd, shell=True)
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 = self.params.get("test_machines", '/run/hosts/')
self.hostfile = write_host_file.write_host_file(self.hostlist,
self.workdir)
server_group = self.params.get("name", '/server_config/',
'daos_server')
self.agent_sessions = AgentUtils.run_agent(basepath, self.hostlist)
server_utils.run_server(self.hostfile, server_group, basepath)
self.daosctl = basepath + '/install/bin/daosctl'
def setUp(self):
self.agent_sessions = None
self.pool = None
self.hostlist = None
with open('../../../.build_vars.json') as filep:
build_paths = json.load(filep)
basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
self.context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.hostlist = self.params.get("test_machines", '/run/hosts/')
self.hostfile = write_host_file.write_host_file(self.hostlist,
self.workdir)
server_group = self.params.get("name", '/server_config/',
'daos_server')
self.agent_sessions = AgentUtils.run_agent(basepath, self.hostlist)
server_utils.run_server(self.hostfile, server_group, basepath)
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 test_delete_doesnt_exist(self):
"""
Test destroying a pool uuid that doesn't exist.
:avocado: tags=pool,pooldestroy
"""
self.hostlist = self.params.get("test_machines1", '/run/hosts/')
hostfile = write_host_file.write_host_file(self.hostlist, self.tmp)
self.agent_sessions = AgentUtils.run_agent(self.basepath, self.hostlist)
server_utils.run_server(hostfile, self.server_group, self.basepath)
setid = self.params.get("setname",
'/run/setnames/validsetname/')
host = self.hostlist[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:
AgentUtils.stop_agent(self.hostlist, self.agent_sessions)
server_utils.stop_server(hosts=self.hostlist)
os.remove(hostfile)
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):
# intermediate results are stored in this global
# start off with it empty
self.soak_results = {}
self.partition = None
# initialize anything we rely on existing
self.pool = None
self.hostlist_servers = None
# get paths from the build_vars generated by build
with open('../../../.build_vars.json') as thefile:
build_paths = json.load(thefile)
self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
# workdir was not successful, not sure why right now
self.tmpdir = self.basepath + "/install/tmp"
try:
os.makedirs(self.tmpdir)
except:
pass
# setup the DAOS python API
self.context = DaosContext(build_paths['PREFIX'] + '/lib/')
# start the servers
self.hostlist_servers = self.params.get("daos_servers",
'/run/hosts/test_machines/*')
filename = write_host_file.write_host_file(self.hostlist_servers,
self.workdir)
self.server_group = self.params.get("name", '/server_config/',
'daos_server')
print("Servers {} group {} basepath {}".format(self.hostlist_servers,
self.server_group,
self.basepath))
server_utils.run_server(filename, self.server_group, self.basepath)
# setup the storage
self.create_pool()
def setUp(self):
# intermediate results are stored in this global
# start off with it empty
self.soak_results = {}
self.partition = None
# initialize anything we rely on existing
self.pool = None
self.hostlist_servers = None
# get paths from the build_vars generated by build
with open('../../../.build_vars.json') as thefile:
build_paths = json.load(thefile)
self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
# workdir was not successful, not sure why right now
self.tmpdir = self.basepath + "/install/tmp"
try:
os.makedirs(self.tmpdir)
except:
pass
# setup the DAOS python API
self.context = DaosContext(build_paths['PREFIX'] + '/lib/')
# start the servers
self.hostlist_servers = self.params.get("daos_servers",
'/run/hosts/test_machines/*')
filename = write_host_file.write_host_file(self.hostlist_servers,
self.workdir)
self.server_group = self.params.get("name", '/server_config/',
'daos_server')
print("Servers {} group {} basepath {}".format(self.hostlist_servers,
self.server_group,
self.basepath))
server_utils.run_server(filename, self.server_group, self.basepath)
# setup the storage
self.create_pool()
def setUp(self):
self.pool = None
self.hostlist = None
self.hostfile_clients = None
self.hostfile = None
self.out_queue = None
self.pool_connect = False
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 = self.params.get("servers", '/run/hosts/*')
self.hostfile = write_host_file.write_host_file(self.hostlist,
self.workdir)
#Start Server
server_utils.run_server(self.hostfile, self.server_group, self.basepath)
def setUp(self):
# these are first since they are referenced in teardown
self.pool = None
self.hostlist = None
self.hostlist = self.params.get("test_servers", '/run/hosts/')
# 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.server_group = self.params.get("name", '/server_config/',
'daos_server')
# setup the DAOS python API
self.context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.hostfile = write_host_file.write_host_file(self.hostlist,
self.workdir)
self.agent_sessions = AgentUtils.run_agent(self.basepath, self.hostlist)
server_utils.run_server(self.hostfile, self.server_group, self.basepath)
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.server_group = self.params.get("name", '/server_config/',
'daos_default_oops')
self.context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.cont = None
self.cont2 = None
self.pool = DaosPool(self.context)
self.d_log = DaosLog(self.context)
self.hostlist = self.params.get("test_machines1", '/hosts/')
self.hostfile = write_host_file.write_host_file(self.hostlist,
self.workdir)
self.agent_sessions = AgentUtils.run_agent(self.basepath, self.hostlist)
server_utils.run_server(self.hostfile, 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')
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("clients",
'/run/hosts/test_machines/test_clients/*'))
self.hostfile_clients = (
write_host_file.write_host_file(self.hostlist_clients,
self.workdir))
print("Host file clientsis: {}".format(self.hostfile_clients))
self.agent_sessions = AgentUtils.run_agent(self.basepath,
self.hostlist_servers,
self.hostlist_clients)
server_utils.run_server(self.hostfile_servers, self.server_group,
self.basepath)
if int(str(self.name).split("-")[0]) == 1:
ior_utils.build_ior(self.basepath)
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):
try:
self.pool = None
self.hostlist = None
with open('../../../.build_vars.json') as build_file:
build_paths = json.load(build_file)
basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
server_group = self.params.get("name",
'/server_config/',
'daos_server')
context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.hostlist = self.params.get("test_machines", '/run/hosts/*')
self.hostfile = write_host_file.write_host_file(self.hostlist,
self.workdir)
server_utils.run_server(self.hostfile, server_group, basepath)
createmode = self.params.get("mode",
'/run/attrtests/createmode/')
createuid = os.geteuid()
creategid = os.getgid()
createsetid = self.params.get("setname",
'/run/attrtests/createset/')
createsize = self.params.get("size",
'/run/attrtests/createsize/')
self.pool = DaosPool(context)
self.pool.create(createmode, createuid, creategid, createsize,
createsetid)
self.pool.connect(1 << 1)
self.large_data_set = {}
except DaosApiError as excep:
print("In the setup exception handler\n")
print(excep)
print(traceback.format_exc())
def setUp(self):
try:
self.pool = None
self.hostlist = None
with open('../../../.build_vars.json') as build_file:
build_paths = json.load(build_file)
basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
server_group = self.params.get("name",
'/server_config/',
'daos_server')
context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.hostlist = self.params.get("test_machines", '/run/hosts/*')
self.hostfile = write_host_file.write_host_file(self.hostlist,
self.workdir)
server_utils.run_server(self.hostfile, server_group, basepath)
createmode = self.params.get("mode",
'/run/attrtests/createmode/')
createuid = os.geteuid()
creategid = os.getgid()
createsetid = self.params.get("setname",
'/run/attrtests/createset/')
createsize = self.params.get("size",
'/run/attrtests/createsize/')
self.pool = DaosPool(context)
self.pool.create(createmode, createuid, creategid, createsize,
createsetid)
self.pool.connect(1 << 1)
self.large_data_set = {}
except DaosApiError as excep:
print("In the setup exception handler\n")
print(excep)
print(traceback.format_exc())
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 setUp(self):
self.agent_sessions = None
self.pool = None
self.hostlist = None
self.hostfile_clients = None
self.hostfile = 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 = self.params.get("servers", '/run/hosts/*')
self.hostfile = write_host_file.write_host_file(self.hostlist,
self.workdir)
self.hostlist_clients = self.params.get("clients", '/run/hosts/*')
self.hostfile_clients = (
write_host_file.write_host_file(hostlist_clients, self.workdir))
self.agent_sessions = AgentUtils.run_agent(self.basepath, self.hostlist,
self.hostlist_clients)
server_utils.run_server(self.hostfile, 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):
self.agent_sessions = None
self.hostlist = None
# get paths from the build_vars generated by build
with open('../../../.build_vars.json') as file_ds:
self.build_paths = json.load(file_ds)
# setup the DAOS python API
self.context = DaosContext(self.build_paths['PREFIX'] + '/lib/')
self.createuid = os.geteuid()
self.creategid = os.getegid()
# parameters used in pool create that are in yaml
self.createmode = self.params.get("mode", '/run/testparams/createmode/')
self.createsetid = self.params.get("setname",
'/run/testparams/createset/')
self.createsize = self.params.get("size",
'/run/testparams/createsize/')
# how many objects and records are we creating
self.objcount = self.params.get("objcount",
'/run/testparams/numobjects/*')
self.reccount = self.params.get("reccount",
'/run/testparams/numrecords/*')
if self.objcount == 0:
self.reccount = 0
# which rank to write to and kill
self.rank = self.params.get("rank", '/run/testparams/ranks/*')
# how much data to write with each key
self.size = self.params.get("size", '/run/testparams/datasize/*')
#Start the server
self.server_group = self.params.get("name", '/server_config/',
'daos_server')
basepath = os.path.normpath(self.build_paths['PREFIX'] + "/../")
self.hostlist = self.params.get("test_machines", '/run/hosts/')
hostfile = write_host_file.write_host_file(self.hostlist, self.workdir)
self.agent_sessions = AgentUtils.run_agent(basepath, self.hostlist)
server_utils.run_server(hostfile, self.server_group, basepath)
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 = AgentUtils.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:
AgentUtils.stop_agent(hostlist, self.agent_sessions)
server_utils.stop_server(hosts=hostlist)
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_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)
