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 test_global_handle(self):
"""
Test ID: DAO
Test Description: Use a pool handle in another process.
:avocado: tags=pool,poolhandle,vm,small,regression
"""
try:
# 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)
# create a container just to make sure handle is good
container = DaosContainer(self.context)
container.create(pool.handle)
# create a global handle
iov_len, buf_len, buf = pool.local2global()
# this should work in the future but need on-line server addition
#arg_list = (buf_len, iov_len, buf, pool.get_uuid_str(), 0)
#p = Process(target=check_handle, args=arg_list)
#p.start()
#p.join()
# for now verifying global handle in the same process which is not
# the intended use case
check_handle(buf_len, iov_len, buf, pool.get_uuid_str(), 0)
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
self.fail("Expecting to pass but test has failed.\n")
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)
class Soak(Test):
"""
Test class Description: DAOS Soak test cases
"""
def job_done(self, args):
"""
This is a callback function called when a job is done
handle --which job, i.e. the job ID
state --string indicating job completion status
"""
self.soak_results[args["handle"]] = args["state"]
def create_pool(self):
"""
Creates a pool that the various tests use for storage.
"""
createmode = self.params.get("mode", '/run/pool1/createmode/*/')
createuid = os.geteuid()
creategid = os.getegid()
createsetid = self.params.get("setname", '/run/pool1/createset/')
createsize = self.params.get("size", '/run/pool1/createsize/')
self.createsvc = self.params.get("svcn", '/run/pool1/createsvc/')
self.pool = DaosPool(self.context)
self.pool.create(createmode, createuid, creategid, createsize,
createsetid, None, None, self.createsvc)
def build_ior_script(self, job):
"""
Builds an IOR command string which is then added to slurm script
job --which job to read in the yaml file
"""
# for the moment build IOR
#IorUtils.build_ior(self.basepath)
# read job info
job_params = "/run/" + job + "/"
job_name = self.params.get("name", job_params)
job_nodes = self.params.get("nodes", job_params)
job_processes = self.params.get("process_per_node", job_params)
job_spec = self.params.get("jobspec", job_params)
# read ior cmd info
spec = "/run/" + job_spec + "/"
iteration = self.params.get("iter", spec + 'iteration/')
ior_flags = self.params.get("F", spec + 'iorflags/')
transfer_size = self.params.get("t", spec + 'transfersize/')
record_size = self.params.get("r", spec + 'recordsize/*')
stripe_size = self.params.get("s", spec + 'stripesize/*')
stripe_count = self.params.get("c", spec + 'stripecount/')
async_io = self.params.get("a", spec + 'asyncio/')
object_class = self.params.get("o", spec + 'objectclass/')
self.partition = self.params.get("partition",
'/run/hosts/test_machines/')
pool_uuid = self.pool.get_uuid_str()
tmplist = []
svc_list = ""
for i in range(self.createsvc):
tmplist.append(int(self.pool.svc.rl_ranks[i]))
svc_list += str(tmplist[i]) + ":"
svc_list = svc_list[:-1]
block_size = '1536m'
if stripe_size == '8m':
transfer_size = stripe_size
hostfile = os.path.join(self.tmpdir, "ior_hosts_" + job_name)
cmd = ior_utils.get_ior_cmd(ior_flags, iteration, block_size,
transfer_size, pool_uuid, svc_list,
record_size, stripe_size, stripe_count,
async_io, object_class, self.basepath,
hostfile, job_processes)
output = os.path.join(self.tmpdir, job_name + "_results.out")
script = slurm_utils.write_slurm_script(self.tmpdir, job_name, output,
int(job_nodes), [cmd])
return script
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 tearDown(self):
server_utils.stop_server(hosts=self.hostlist_servers)
def test_soak_1(self):
"""
Test ID: DAOS-2192
Test Description: This test runs 2 DAOS API IOR jobs.
:avocado: tags=soak1
"""
try:
# turn job parameters into slurm script
script1 = self.build_ior_script('job1')
# queue it up to run and register a callback to retrieve results
job_id1 = slurm_utils.run_slurm_script(script1)
slurm_utils.register_for_job_results(job_id1, self, maxwait=3600)
# queue up a second job
script2 = self.build_ior_script('job2')
job_id2 = slurm_utils.run_slurm_script(script2)
slurm_utils.register_for_job_results(job_id2, self, maxwait=3600)
# wait for all the jobs to finish
while len(self.soak_results) < 2:
time.sleep(10)
for job, result in self.soak_results.iteritems():
if result != "COMPLETED":
self.fail(
"Soak job: {} didn't complete as expected: {}".format(
job, result))
except (DaosApiError, ior_utils.IorFailed) as error:
self.fail("<Soak Test 1 Failed>\n {}".format(error))
finally:
try:
os.remove(script1)
except StandardError:
pass
try:
os.remove(script2)
except StandardError:
pass
def test_soak_2(self):
"""
Test ID: DAOS-2192
Test Description: This test verifies that a dmg script can be submitted.
:avocado: tags=soak2
"""
script = None
try:
dmgcmds = dmg_utils.get_dmg_script("dmg1", self.params,
self.basepath)
s2_job1_name = self.params.get("name", '/run/job3/')
s2_job1_nodes = self.params.get("nodes", '/run/job3/')
output = os.path.join(self.tmpdir, s2_job1_name + "_results.out")
script = slurm_utils.write_slurm_script(self.tmpdir, s2_job1_name,
output, s2_job1_nodes,
dmgcmds)
job_id = slurm_utils.run_slurm_script(script)
slurm_utils.register_for_job_results(job_id, self, maxwait=3600)
# wait for all the jobs to finish
while len(self.soak_results) < 1:
time.sleep(10)
for job, result in self.soak_results.iteritems():
if result != "COMPLETED":
self.fail(
"Soak job: {} didn't complete as expected: {}".format(
job, result))
except (DaosApiError, ior_utils.IorFailed) as error:
self.fail("Soak Test 2 Failed/n {}".format(error))
finally:
try:
os.remove(script)
finally:
pass
def test_soak_3(self):
"""
Test ID: DAOS-2192
Test Description: this time try a dmg command combined with IOR run
Use Cases:
:avocado: tags=soak3
"""
script1 = None
script2 = None
try:
# retrieve IOR job parameters
script1 = self.build_ior_script('job1')
job_id1 = slurm_utils.run_slurm_script(script1)
slurm_utils.register_for_job_results(job_id1, self, maxwait=3600)
# now do the dmg job
dmgcmds = dmg_utils.get_dmg_script("dmg1", self.params,
self.basepath)
s3_job2_name = self.params.get("name", '/run/job3/')
s3_job2_nodes = self.params.get("nodes", '/run/job3/')
output = os.path.join(self.tmpdir, s3_job2_name + "_results.out")
script2 = slurm_utils.write_slurm_script(self.tmpdir, s3_job2_name,
output, s3_job2_nodes,
dmgcmds)
job_id2 = slurm_utils.run_slurm_script(script2)
slurm_utils.register_for_job_results(job_id2, self, maxwait=3600)
# wait for all the jobs to finish
while len(self.soak_results) < 2:
time.sleep(10)
for job, result in self.soak_results.iteritems():
if result != "COMPLETED":
self.fail(
"Soak job: {} didn't complete as expected: {}".format(
job, result))
except (DaosApiError, ior_utils.IorFailed) as error:
self.fail("Soak Test 3 Failed\n {}".format(error))
finally:
try:
os.remove(script1)
except StandardError:
pass
try:
os.remove(script2)
except StandardError:
pass
def test_container_create(self):
"""
Test ID: DAOS-689
Test Description: valid and invalid container creation and close.
:avocado: tags=regression,cont,contcreate
"""
pool = None
contuuid = None
expected_results = []
try:
# initialize a python pool object then create the underlying
# daos storage
createmode = self.params.get("mode", '/run/poolparams/')
createuid = os.geteuid()
creategid = os.getegid()
createsetid = self.params.get("setname", '/run/poolparams/')
createsize = self.params.get("size", '/run/poolparams/')
# setup the pool
pool = DaosPool(self.context)
pool.create(createmode, createuid, creategid,
createsize, createsetid)
pool.connect(1 << 1)
# maybe use the good handle, maybe not
handleparam = self.params.get("handle", '/run/poolhandle/*')
if handleparam == 'VALID':
poh = pool.handle
else:
poh = handleparam
expected_results.append('FAIL')
# maybe use a good UUID, maybe not
uuidparam = self.params.get("uuid", "/uuids/*")
expected_results.append(uuidparam[1])
if uuidparam[0] == 'NULLPTR':
self.cancel("skipping this test until DAOS-2043 is fixed")
contuuid = 'NULLPTR'
else:
contuuid = uuid.UUID(uuidparam[0])
should_fail = False
for result in expected_results:
if result == 'FAIL':
should_fail = True
break
self.container = DaosContainer(self.context)
self.container.create(poh, contuuid)
# check UUID is the specified one
if (uuidparam[0]).upper() != self.container.get_uuid_str().upper():
print("uuidparam[0] is {}, uuid_str is {}".format(
uuidparam[0], self.container.get_uuid_str()))
self.fail("Container UUID differs from specified at create\n")
if should_fail:
self.fail("Test was expected to fail but it passed.\n")
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
if not should_fail:
self.fail("Test was expected to pass but it failed.\n")
finally:
if pool is not None:
pool.disconnect()
pool.destroy(1)
class MultipleClients(Test):
"""
Test class Description: Runs IOR with multiple clients.
"""
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 tearDown(self):
try:
if self.hostfile_clients is not None:
os.remove(self.hostfile_clients)
if self.hostfile_servers is not None:
os.remove(self.hostfile_servers)
if self.pool is not None and self.pool.attached:
self.pool.destroy(1)
finally:
if self.agent_sessions:
AgentUtils.stop_agent(self.hostlist_clients,
self.agent_sessions)
server_utils.stop_server(hosts=self.hostlist_servers)
def test_multipleclients(self):
"""
Test ID: DAOS-1263
Test Description: Test IOR with 16 and 32 clients config.
Use Cases: Different combinations of 16/32 Clients, 8b/1k/4k
record size, 1m/8m stripesize and 16 async io.
:avocado: tags=ior,twoservers,multipleclients
"""
# 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/')
createsvc = self.params.get("svcn", '/run/pool/createsvc/')
iteration = self.params.get("iter", '/run/ior/iteration/')
slots = self.params.get("slots", '/run/ior/clientslots/*')
ior_flags = self.params.get("F", '/run/ior/iorflags/')
transfer_size = self.params.get("t", '/run/ior/transfersize/')
record_size = self.params.get("r", '/run/ior/recordsize/*')
stripe_size = self.params.get("s", '/run/ior/stripesize/*')
stripe_count = self.params.get("c", '/run/ior/stripecount/')
async_io = self.params.get("a", '/run/ior/asyncio/')
object_class = self.params.get("o", '/run/ior/objectclass/')
try:
# 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, createsvc)
with open(self.hostfile_clients) as client_file:
new_text = client_file.read().replace('slots=1',
'slots={0}').format(slots)
with open(self.hostfile_clients, "w") as client_file:
client_file.write(new_text)
pool_uuid = self.pool.get_uuid_str()
tmp_rank_list = []
svc_list = ""
for i in range(createsvc):
tmp_rank_list.append(int(self.pool.svc.rl_ranks[i]))
svc_list += str(tmp_rank_list[i]) + ":"
svc_list = svc_list[:-1]
if slots == 8:
block_size = '3g'
elif slots == 16:
block_size = '1536m'
if stripe_size == '8m':
transfer_size = stripe_size
ior_utils.run_ior(self.hostfile_clients, ior_flags, iteration,
block_size, transfer_size, pool_uuid, svc_list,
record_size, stripe_size, stripe_count, async_io,
object_class, self.basepath, slots)
except (DaosApiError, ior_utils.IorFailed) as excep:
self.fail("<MultipleClients Test run Failed>\n {}".format(excep))
class IorSingleServer(Test):
"""
Tests IOR with Single Server config.
"""
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("clients",
'/run/hosts/test_machines/diff_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 tearDown(self):
try:
if self.hostfile_clients is not None:
os.remove(self.hostfile_clients)
if self.hostfile_servers is not None:
os.remove(self.hostfile_servers)
if self.pool is not None and self.pool.attached:
self.pool.destroy(1)
finally:
if self.agent_sessions:
AgentUtils.stop_agent(self.hostlist_clients,
self.agent_sessions)
server_utils.stop_server(hosts=self.hostlist_servers)
def test_singleserver(self):
"""
Test IOR with Single Server config.
:avocado: tags=ior,singleserver
"""
# parameters used in pool create
createmode = self.params.get("mode", '/run/createtests/createmode/*/')
createuid = os.geteuid()
creategid = os.getegid()
createsetid = self.params.get("setname", '/run/createtests/createset/')
createsize = self.params.get("size", '/run/createtests/createsize/')
createsvc = self.params.get("svcn", '/run/createtests/createsvc/')
iteration = self.params.get("iter", '/run/ior/iteration/')
ior_flags = self.params.get("F", '/run/ior/iorflags/')
transfer_size = self.params.get("t", '/run/ior/transfersize/')
record_size = self.params.get("r", '/run/ior/recordsize/')
segment_count = self.params.get("s", '/run/ior/segmentcount/')
stripe_count = self.params.get("c", '/run/ior/stripecount/')
async_io = self.params.get("a", '/run/ior/asyncio/')
object_class = self.params.get("o", '/run/ior/objectclass/')
try:
# 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, createsvc)
pool_uuid = self.pool.get_uuid_str()
print ("pool_uuid: {}".format(pool_uuid))
tmp_rank_list = []
svc_list = ""
for i in range(createsvc):
tmp_rank_list.append(int(self.pool.svc.rl_ranks[i]))
svc_list += str(tmp_rank_list[i]) + ":"
svc_list = svc_list[:-1]
if len(self.hostlist_clients) == 1:
block_size = '12g'
elif len(self.hostlist_clients) == 2:
block_size = '6g'
elif len(self.hostlist_clients) == 4:
block_size = '3g'
ior_utils.run_ior(self.hostfile_clients, ior_flags, iteration,
block_size, transfer_size, pool_uuid, svc_list,
record_size, segment_count, stripe_count,
async_io, object_class, self.basepath)
except (DaosApiError, ior_utils.IorFailed) as excep:
self.fail("<Single Server Test FAILED>\n {}".format(excep))
class PoolAttributeTest(Test):
"""
Test class Description: Tests DAOS pool attribute get/set/list.
"""
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 tearDown(self):
try:
if self.pool is not None:
self.pool.disconnect()
self.pool.destroy(1)
finally:
server_utils.stop_server(hosts=self.hostlist)
def create_data_set(self):
"""
To create the large attribute dictionary
"""
allchar = string.ascii_letters + string.digits
for i in range(1024):
self.large_data_set[str(i)] = (
"".join(random.choice(allchar)
for x in range(random.randint(1, 100))))
def test_pool_attributes(self):
"""
Test ID: DAOS-1359
Test description: Test basic pool attribute tests (sync).
:avocado: tags=regression,pool,pool_attr,attribute,sync_poolattribute
"""
expected_for_param = []
name = self.params.get("name", '/run/attrtests/name_handles/*/')
expected_for_param.append(name[1])
value = self.params.get("value", '/run/attrtests/value_handles/*/')
if value[0] is None:
self.cancel("skipping these tests until DAOS-2170 is fixed")
expected_for_param.append(value[1])
attr_dict = {name[0]:value[0]}
if name[0] is not None:
if "largenumberofattr" in name[0]:
self.create_data_set()
attr_dict = self.large_data_set
expected_result = 'PASS'
for result in expected_for_param:
if result == 'FAIL':
expected_result = 'FAIL'
break
try:
self.pool.set_attr(data=attr_dict)
size, buf = self.pool.list_attr()
verify_list_attr(attr_dict, size.value, buf)
if name[0] is not None:
# Request something that doesn't exist
if "Negative" in name[0]:
name[0] = "rubbish"
# large attr test messes with the dictionary so skip
# the get test
if "largenumberofattr" not in name[0]:
results = {}
results = self.pool.get_attr([name[0]])
verify_get_attr(attr_dict, results)
if expected_result in ['FAIL']:
self.fail("Test was expected to fail but it passed.\n")
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
if expected_result == 'PASS':
self.fail("Test was expected to pass but it failed.\n")
def test_pool_attribute_asyn(self):
"""
Test ID: DAOS-1359
Test description: Test basic pool attribute tests (async).
:avocado: tags=regression,pool,pool_attr,attribute,async_poolattribute
"""
global GLOB_SIGNAL
global GLOB_RC
expected_for_param = []
name = self.params.get("name", '/run/attrtests/name_handles/*/')
# workaround until async functions are fixed
if name[0] is not None and "Negative" in name[0]:
pass
else:
expected_for_param.append(name[1])
value = self.params.get("value", '/run/attrtests/value_handles/*/')
if value[0] is None:
self.cancel("skipping this test until DAOS-2170 is fixed")
expected_for_param.append(value[1])
attr_dict = {name[0]:value[0]}
if name[0] is not None:
if "largenumberofattr" in name[0]:
self.create_data_set()
attr_dict = self.large_data_set
expected_result = 'PASS'
for result in expected_for_param:
if result == 'FAIL':
expected_result = 'FAIL'
break
try:
GLOB_SIGNAL = threading.Event()
self.pool.set_attr(attr_dict, None, cb_func)
GLOB_SIGNAL.wait()
if expected_result == 'PASS' and GLOB_RC != 0:
self.fail("RC not as expected after set_attr {0}"
.format(GLOB_RC))
if expected_result == 'FAIL' and GLOB_RC == 0:
self.fail("RC not as expected after set_attr {0}"
.format(GLOB_RC))
except DaosApiError as excep:
print (excep)
print (traceback.format_exc())
if expected_result == 'PASS':
self.fail("Test was expected to pass but it failed.\n")
class ContainerAsync(Test):
"""
Tests DAOS pool connect permissions (non existing pool handle, bad uuid)
and close.
"""
def __init__(self, *args, **kwargs):
super(ContainerAsync, self).__init__(*args, **kwargs)
self.container1 = None
self.container2 = None
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 tearDown(self):
try:
if self.pool is not None and self.pool.attached:
self.pool.destroy(1)
finally:
if self.agent_sessions:
AgentUtils.stop_agent(self.hostlist, self.agent_sessions)
time.sleep(5)
server_utils.stop_server(hosts=self.hostlist)
def test_createasync(self):
"""
Test container create for asynchronous mode.
:avocado: tags=container,containerasync,createasync
"""
global GLOB_SIGNAL
global GLOB_RC
# parameters used in pool create
createmode = self.params.get("mode", '/run/createtests/createmode/*/')
createsetid = self.params.get("setname", '/run/createtests/createset/')
createsize = self.params.get("size", '/run/createtests/createsize/')
createuid = os.geteuid()
creategid = os.getegid()
try:
# 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)
poh = self.pool.handle
self.pool.connect(1 << 1)
# Container initialization and creation
self.container1 = DaosContainer(self.context)
self.container2 = DaosContainer(self.context)
GLOB_SIGNAL = threading.Event()
self.container1.create(poh, None, cb_func)
GLOB_SIGNAL.wait()
if GLOB_RC != 0:
self.fail("RC not as expected in async test")
print("RC after successful container create: ", GLOB_RC)
# Try to recreate container after destroying pool,
# this should fail. Checking rc after failure.
self.pool.destroy(1)
GLOB_SIGNAL = threading.Event()
GLOB_RC = -9900000
self.container2.create(poh, None, cb_func)
GLOB_SIGNAL.wait()
if GLOB_RC == 0:
self.fail("RC not as expected in async test")
print("RC after unsuccessful container create: ", GLOB_RC)
# cleanup the pool and container
self.pool = None
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
def test_destroyasync(self):
"""
Test container destroy for asynchronous mode.
:avocado: tags=container,containerasync,contdestroyasync
"""
global GLOB_SIGNAL
global GLOB_RC
# parameters used in pool create
createmode = self.params.get("mode", '/run/createtests/createmode/*/')
createsetid = self.params.get("setname", '/run/createtests/createset/')
createsize = self.params.get("size", '/run/createtests/createsize/')
createuid = os.geteuid()
creategid = os.getegid()
try:
# 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)
poh = self.pool.handle
self.pool.connect(1 << 1)
# Container initialization and creation
self.container1 = DaosContainer(self.context)
self.container2 = DaosContainer(self.context)
self.container1.create(poh)
GLOB_SIGNAL = threading.Event()
self.container1.destroy(1, poh, None, cb_func)
GLOB_SIGNAL.wait()
if GLOB_RC != 0:
self.fail("RC not as expected in async test")
print("RC after successful container create: ", GLOB_RC)
# Try to destroy container again, this should fail, as non-existent.
# Checking rc after failure.
GLOB_SIGNAL = threading.Event()
GLOB_RC = -9900000
self.container2.destroy(1, poh, None, cb_func)
GLOB_SIGNAL.wait()
if GLOB_RC != -1003:
self.fail("RC not as expected in async test")
print("RC after container destroy failed:", GLOB_RC)
# cleanup the pool and container
self.pool.disconnect()
self.pool.destroy(1)
self.pool = None
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
def test_openasync(self):
"""
Test container open for asynchronous mode.
:avocado: tags=container,containerasync,openasync
"""
global GLOB_SIGNAL
global GLOB_RC
# parameters used in pool create
createmode = self.params.get("mode", '/run/createtests/createmode/*/')
createsetid = self.params.get("setname", '/run/createtests/createset/')
createsize = self.params.get("size", '/run/createtests/createsize/')
createuid = os.geteuid()
creategid = os.getegid()
try:
# 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)
poh = self.pool.handle
self.pool.connect(1 << 1)
# Container initialization and creation
self.container1 = DaosContainer(self.context)
self.container2 = DaosContainer(self.context)
self.container1.create(poh)
str_cuuid = self.container1.get_uuid_str()
cuuid = uuid.UUID(str_cuuid)
GLOB_SIGNAL = threading.Event()
self.container1.open(poh, cuuid, 2, cb_func)
GLOB_SIGNAL.wait()
if GLOB_RC != 0:
self.fail("RC not as expected in async test")
print("RC after successful container create: ", GLOB_RC)
# Try to open container2, this should fail, as non-existent.
# Checking rc after failure.
GLOB_SIGNAL = threading.Event()
GLOB_RC = -9900000
self.container2.open(None, None, None, cb_func)
GLOB_SIGNAL.wait()
if GLOB_RC == 0:
self.fail("RC not as expected in async test")
print("RC after container destroy failed:", GLOB_RC)
# cleanup the pool and container
self.container1.close()
self.container1.destroy()
self.pool.disconnect()
self.pool.destroy(1)
self.pool = None
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
def test_closeasync(self):
"""
Test container close for asynchronous mode.
:avocado: tags=container,containerasync,closeasync
"""
global GLOB_SIGNAL
global GLOB_RC
# parameters used in pool create
createmode = self.params.get("mode", '/run/createtests/createmode/*/')
createsetid = self.params.get("setname", '/run/createtests/createset/')
createsize = self.params.get("size", '/run/createtests/createsize/')
createuid = os.geteuid()
creategid = os.getegid()
try:
# 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)
poh = self.pool.handle
self.pool.connect(1 << 1)
# Container initialization and creation
self.container1 = DaosContainer(self.context)
self.container2 = DaosContainer(self.context)
self.container1.create(poh)
str_cuuid = self.container1.get_uuid_str()
cuuid = uuid.UUID(str_cuuid)
self.container1.open(poh, cuuid, 2)
GLOB_SIGNAL = threading.Event()
self.container1.close(cb_func=cb_func)
GLOB_SIGNAL.wait()
if GLOB_RC != 0:
self.fail("RC not as expected in async test: "
"{0}".format(GLOB_RC))
print("RC after successful container create: ", GLOB_RC)
# Try to open container2, this should fail, as non-existent.
# Checking rc after failure.
GLOB_SIGNAL = threading.Event()
GLOB_RC = -9900000
self.container2.close(cb_func=cb_func)
GLOB_SIGNAL.wait()
if GLOB_RC == 0:
self.fail("RC not as expected in async test: "
"{0}".format(GLOB_RC))
print("RC after container destroy failed:", GLOB_RC)
# cleanup the pool and container
self.container1.destroy()
self.pool.disconnect()
self.pool.destroy(1)
self.pool = None
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
def test_queryasync(self):
"""
Test container query for asynchronous mode.
:avocado: tags=container,containerasync,queryasync
"""
global GLOB_SIGNAL
global GLOB_RC
# parameters used in pool create
createmode = self.params.get("mode", '/run/createtests/createmode/*/')
createsetid = self.params.get("setname", '/run/createtests/createset/')
createsize = self.params.get("size", '/run/createtests/createsize/')
createuid = os.geteuid()
creategid = os.getegid()
try:
# 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)
poh = self.pool.handle
self.pool.connect(1 << 1)
# Container initialization and creation
self.container1 = DaosContainer(self.context)
self.container2 = DaosContainer(self.context)
self.container1.create(poh)
dummy_str_cuuid = self.container1.get_uuid_str()
# Open container
self.container1.open(poh, None, 2, None)
GLOB_SIGNAL = threading.Event()
self.container1.query(cb_func=cb_func)
GLOB_SIGNAL.wait()
if GLOB_RC != 0:
self.fail("RC not as expected in async test: "
"{0}".format(GLOB_RC))
print("RC after successful container create: ", GLOB_RC)
# Close opened container
self.container1.close()
# Try to open container2, this should fail, as non-existent.
# Checking rc after failure.
GLOB_SIGNAL = threading.Event()
GLOB_RC = -9900000
self.container2.query(cb_func=cb_func)
GLOB_SIGNAL.wait()
if GLOB_RC == 0:
self.fail("RC not as expected in async test: "
"{0}".format(GLOB_RC))
print("RC after container destroy failed:", GLOB_RC)
# cleanup the pool and container
self.container1.destroy()
self.pool.disconnect()
self.pool.destroy(1)
self.pool = None
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
class InfoTests(Test):
"""
Tests DAOS pool query.
"""
def setUp(self):
# 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 f:
build_paths = json.load(f)
self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
self.tmp = build_paths['PREFIX'] + '/tmp'
self.server_group = self.params.get("server_group", '/server/',
'daos_server')
context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.pool = DaosPool(context)
self.d_log = DaosLog(context)
self.hostlist = self.params.get("test_machines1", '/run/hosts/')
self.hostfile = WriteHostFile.WriteHostFile(self.hostlist, self.tmp)
ServerUtils.runServer(self.hostfile, self.server_group, self.basepath)
def tearDown(self):
# shut 'er down
try:
if self.pool:
self.pool.destroy(1)
os.remove(self.hostfile)
finally:
ServerUtils.stopServer(hosts=self.hostlist)
def test_simple_query(self):
"""
Test querying a pool created on a single server.
:avocado: tags=pool,poolquery,infotest
"""
# create pool
mode = self.params.get("mode", '/run/testparams/modes/*', 0731)
if mode == 73:
self.cancel('Cancel the mode test 73 because of DAOS-1877')
uid = os.geteuid()
gid = os.getegid()
size = self.params.get("size", '/run/testparams/sizes/*', 0)
group = self.server_group
self.pool.create(mode, uid, gid, size, group, None)
# connect to the pool
flags = self.params.get("perms", '/run/testparams/connectperms/*', '')
connect_flags = 1 << flags
self.pool.connect(connect_flags)
# query the pool
pool_info = self.pool.pool_query()
# check uuid
uuid_str = c_uuid_to_str(pool_info.pi_uuid)
if uuid_str != self.pool.get_uuid_str():
self.d_log.error("UUID str does not match expected string")
self.fail("UUID str does not match expected string")
'''
# validate size of pool is what we expect
This check is currently disabled, as space is not implemented in
DAOS C API yet.
if size != pool_info.pi_space:
self.d_log.error("expected size {0} did not match actual size {1}"
.format(size, pool_info.pi_space))
self.fail("expected size {0} did not match actual size {1}"
.format(size, pool_info.pi_space))
'''
# number of targets
if pool_info.pi_ntargets != len(self.hostlist):
self.d_log.error("found number of targets in pool did not match "
"expected number, 1. num targets: {0}".format(
pool_info.pi_ntargets))
self.fail("found number of targets in pool did not match "
"expected number, 1. num targets: {0}".format(
pool_info.pi_ntargets))
# number of disabled targets
if pool_info.pi_ndisabled > 0:
self.d_log.error("found disabled targets, none expected to be")
self.fail("found disabled targets, none expected to be disabled")
# mode
if pool_info.pi_mode != mode:
self.d_log.error(
"found different mode than expected. expected {0}, "
"found {1}.".format(mode, pool_info.pi_mode))
self.fail("found different mode than expected. expected {0}, "
"found {1}.".format(mode, pool_info.pi_mode))
# uid
if pool_info.pi_uid != uid:
self.d_log.error(
"found actual pool uid {0} does not match expected "
"uid {1}".format(pool_info.pi_uid, uid))
self.fail("found actual pool uid {0} does not match expected uid "
"{1}".format(pool_info.pi_uid, uid))
# gid
if pool_info.pi_gid != gid:
self.d_log.error(
"found actual pool gid {0} does not match expected "
"gid {1}".format(pool_info.pi_gid, gid))
self.fail("found actual pool gid {0} does not match expected gid "
"{1}".format(pool_info.pi_gid, gid))
class EightServers(Test):
"""
Test class Description: Runs IOR with 8 servers.
"""
def __init__(self, *args, **kwargs):
super(EightServers, self).__init__(*args, **kwargs)
self.basepath = None
self.server_group = None
self.context = None
self.pool = None
self.num_procs = None
self.hostlist_servers = None
self.hostfile_servers = None
self.hostlist_clients = None
self.hostfile_clients = None
self.mpio = None
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 tearDown(self):
try:
if self.pool is not None and self.pool.attached:
self.pool.destroy(1)
finally:
server_utils.stop_server(hosts=self.hostlist_servers)
def executable(self, iorflags=None):
"""
Executable function to run ior for ssf and fpp
"""
# 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/')
createscm_size = self.params.get("scm_size", '/run/pool/createsize/')
createnvme_size = self.params.get("nvme_size", '/run/pool/createsize/')
createsvc = self.params.get("svcn", '/run/pool/createsvc/')
iteration = self.params.get("iter", '/run/ior/iteration/')
block_size = self.params.get("b", '/run/ior/transfersize_blocksize/*/')
transfer_size = self.params.get("t",
'/run/ior/transfersize_blocksize/*/')
try:
# initialize MpioUtils
self.mpio = MpioUtils()
if self.mpio.mpich_installed(self.hostlist_clients) is False:
self.fail("Exiting Test: Mpich not installed")
#print self.mpio.mpichinstall
# initialize a python pool object then create the underlying
# daos storage
self.pool = DaosPool(self.context)
self.pool.create(createmode, createuid, creategid, createscm_size,
createsetid, None, None, createsvc,
createnvme_size)
pool_uuid = self.pool.get_uuid_str()
svc_list = ""
for i in range(createsvc):
svc_list += str(int(self.pool.svc.rl_ranks[i])) + ":"
svc_list = svc_list[:-1]
print("svc_list: {}".format(svc_list))
ior_utils.run_ior_mpiio(self.basepath, self.mpio.mpichinstall,
pool_uuid, svc_list, self.num_procs,
self.hostfile_clients, iorflags, iteration,
transfer_size, block_size, True)
except (DaosApiError, MpioFailed) as excep:
print(excep)
def test_ssf(self):
"""
Test ID: DAOS-2121
Test Description: Run IOR with 1,64 and 128 clients config in ssf mode.
Use Cases: Different combinations of 1/64/128 Clients,
1K/4K/32K/128K/512K/1M transfersize and block size of 32M
for 1K transfer size and 128M for rest.
:avocado: tags=ior,mpiio,eightservers,ior_ssf
"""
ior_flags = self.params.get("F", '/run/ior/iorflags/ssf/')
self.executable(ior_flags)
def test_fpp(self):
"""
Test ID: DAOS-2121
Test Description: Run IOR with 1,64 and 128 clients config in fpp mode.
Use Cases: Different combinations of 1/64/128 Clients,
1K/4K/32K/128K/512K/1M transfersize and block size of 32M
for 1K transfer size and 128M for rest.
:avocado: tags=ior,mpiio,eightservers,ior_fpp
"""
ior_flags = self.params.get("F", '/run/ior/iorflags/fpp/')
self.executable(ior_flags)
def test_query(self):
"""
Pass bad parameters to pool query
:avocado: tags=pool,poolquery,badparam,badconnect
"""
# parameters used in pool create/connect
connectmode = self.params.get("mode", '/run/querytests/connectmode/')
createmode = self.params.get("mode", '/run/querytests/createmode/')
createuid = self.params.get("uid", '/run/querytests/createuid/')
creategid = self.params.get("gid", '/run/querytests/creategid/')
createsetid = self.params.get("setname", '/run/querytests/createset/')
createsize = self.params.get("size", '/run/querytests/createsize/')
# Accumulate a list of pass/fail indicators representing what is
# expected for each parameter then "and" them to determine the
# expected result of the test
expected_for_param = []
handlelist = self.params.get("handle", '/run/querytests/handles/*/')
handle = handlelist[0]
expected_for_param.append(handlelist[1])
infolist = self.params.get("info", '/run/querytests/infoptr/*/')
infoptr = infolist[0]
expected_for_param.append(infolist[1])
# if any parameter is FAIL then the test should FAIL, in this test
# virtually everyone should FAIL since we are testing bad parameters
expected_result = 'PASS'
for result in expected_for_param:
if result == 'FAIL':
expected_result = 'FAIL'
break
try:
# setup the DAOS python API
with open('../../../.build_vars.json') as f:
data = json.load(f)
CONTEXT = DaosContext(data['PREFIX'] + '/lib/')
# initialize a python pool object then create the underlying
# daos storage
POOL = DaosPool(CONTEXT)
POOL.create(createmode, createuid, creategid,
createsize, createsetid, None)
POOL.connect(connectmode)
# trash the pool handle value
if not handle == 'VALID':
POOL.handle = handle
if infoptr == 'NULL':
info = POOL.pool_query(InfoPtr=None)
else:
info = POOL.pool_query()
if expected_result in ['FAIL']:
self.fail("Test was expected to fail but it passed.\n")
except ValueError as e:
print e
print traceback.format_exc()
if expected_result in ['PASS']:
self.fail("Test was expected to pass but it failed.\n")
class ContainerAttributeTest(TestWithServers):
"""
Tests DAOS container attribute get/set/list.
:avocado: recursive
"""
def setUp(self):
super(ContainerAttributeTest, self).setUp()
self.large_data_set = {}
self.pool = DaosPool(self.context)
self.pool.create(
self.params.get("mode", '/run/attrtests/createmode/*'),
os.geteuid(),
os.getegid(),
self.params.get("size", '/run/attrtests/createsize/*'),
self.params.get("setname", '/run/attrtests/createset/*'),
None)
self.pool.connect(1 << 1)
poh = self.pool.handle
self.container = DaosContainer(self.context)
self.container.create(poh)
self.container.open()
def create_data_set(self):
"""
To create the large attribute dictionary
"""
allchar = string.ascii_letters + string.digits
for i in range(1024):
self.large_data_set[str(i)] = (
"".join(random.choice(allchar)
for x in range(random.randint(1, 100))))
def test_container_large_attributes(self):
"""
Test ID: DAOS-1359
Test description: Test large randomly created container attribute.
:avocado: tags=container,container_attr,attribute,large_conattribute
"""
self.create_data_set()
attr_dict = self.large_data_set
try:
self.container.set_attr(data=attr_dict)
size, buf = self.container.list_attr()
verify_list_attr(attr_dict, size, buf)
results = {}
results = self.container.get_attr(attr_dict.keys())
verify_get_attr(attr_dict, results)
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
self.fail("Test was expected to pass but it failed.\n")
def test_container_attribute(self):
"""
Test basic container attribute tests.
:avocado: tags=all,tiny,full_regression,container,sync_conattribute
"""
expected_for_param = []
name = self.params.get("name", '/run/attrtests/name_handles/*/')
expected_for_param.append(name[1])
value = self.params.get("value", '/run/attrtests/value_handles/*/')
expected_for_param.append(value[1])
attr_dict = {name[0]: value[0]}
expected_result = 'PASS'
for result in expected_for_param:
if result == 'FAIL':
expected_result = 'FAIL'
break
try:
self.container.set_attr(data=attr_dict)
size, buf = self.container.list_attr()
verify_list_attr(attr_dict, size, buf)
# Request something that doesn't exist
if name[0] is not None and "Negative" in name[0]:
name[0] = "rubbish"
results = {}
results = self.container.get_attr([name[0]])
verify_get_attr(attr_dict, results)
if expected_result in ['FAIL']:
self.fail("Test was expected to fail but it passed.\n")
except (DaosApiError, DaosTestError) as excep:
print(excep)
print(traceback.format_exc())
if expected_result == 'PASS':
self.fail("Test was expected to pass but it failed.\n")
def test_container_attribute_asyn(self):
"""
Test basic container attribute tests.
:avocado: tags=all,small,full_regression,container,async_conattribute
"""
global GLOB_SIGNAL
global GLOB_RC
expected_for_param = []
name = self.params.get("name", '/run/attrtests/name_handles/*/')
expected_for_param.append(name[1])
value = self.params.get("value", '/run/attrtests/value_handles/*/')
expected_for_param.append(value[1])
attr_dict = {name[0]: value[0]}
expected_result = 'PASS'
for result in expected_for_param:
if result == 'FAIL':
expected_result = 'FAIL'
break
try:
GLOB_SIGNAL = threading.Event()
self.container.set_attr(data=attr_dict, cb_func=cb_func)
GLOB_SIGNAL.wait()
if GLOB_RC != 0 and expected_result in ['PASS']:
self.fail("RC not as expected after set_attr First {0}"
.format(GLOB_RC))
GLOB_SIGNAL = threading.Event()
size, buf = self.container.list_attr(cb_func=cb_func)
GLOB_SIGNAL.wait()
if GLOB_RC != 0 and expected_result in ['PASS']:
self.fail("RC not as expected after list_attr First {0}"
.format(GLOB_RC))
if expected_result in ['PASS']:
verify_list_attr(attr_dict, size, buf, mode="async")
# Request something that doesn't exist
if name[0] is not None and "Negative" in name[0]:
name[0] = "rubbish"
GLOB_SIGNAL = threading.Event()
self.container.get_attr([name[0]], cb_func=cb_func)
GLOB_SIGNAL.wait()
if GLOB_RC != 0 and expected_result in ['PASS']:
self.fail("RC not as expected after get_attr {0}"
.format(GLOB_RC))
# not verifying the get_attr since its not available asynchronously
if value[0] is not None:
if GLOB_RC == 0 and expected_result in ['FAIL']:
self.fail("Test was expected to fail but it passed.\n")
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
if expected_result == 'PASS':
self.fail("Test was expected to pass but it failed.\n")
class PoolSvc(TestWithServers):
"""
Tests svc argument while pool create.
:avocado: recursive
"""
def test_poolsvc(self):
"""
Test svc arg during pool create.
:avocado: tags=all,pool,pr,medium,svc
"""
# parameters used in pool create
createmode = self.params.get("mode", '/run/createtests/createmode/*/')
createuid = os.geteuid()
creategid = os.getegid()
createsetid = self.params.get("setname", '/run/createtests/createset/')
createsize = self.params.get("size", '/run/createtests/createsize/')
createsvc = self.params.get("svc", '/run/createtests/createsvc/*/')
expected_result = createsvc[1]
try:
# 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, createsvc[0])
self.pool.connect(1 << 1)
# checking returned rank list for server more than 1
iterator = 0
while (int(self.pool.svc.rl_ranks[iterator]) > 0
and int(self.pool.svc.rl_ranks[iterator]) <= createsvc[0]
and int(self.pool.svc.rl_ranks[iterator]) != 999999):
iterator += 1
if iterator != createsvc[0]:
self.fail("Length of Returned Rank list is not equal to "
"the number of Pool Service members.\n")
rank_list = []
for iterator in range(createsvc[0]):
rank_list.append(int(self.pool.svc.rl_ranks[iterator]))
if len(rank_list) != len(set(rank_list)):
self.fail("Duplicate values in returned rank list")
self.pool.pool_query()
leader = self.pool.pool_info.pi_leader
if createsvc[0] == 3:
# kill pool leader and exclude it
self.pool.pool_svc_stop()
self.pool.exclude([leader])
# perform pool disconnect, try connect again and disconnect
self.pool.disconnect()
self.pool.connect(1 << 1)
self.pool.disconnect()
# kill another server which is not a leader and exclude it
server = DaosServer(self.context, self.server_group, 3)
server.kill(1)
self.pool.exclude([3])
# perform pool connect
self.pool.connect(1 << 1)
if expected_result in ['FAIL']:
self.fail("Test was expected to fail but it passed.\n")
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
if expected_result == 'PASS':
self.fail("Test was expected to pass but it failed.\n")
def test_multipool_rebuild(self):
"""
Test ID: Rebuild-002
Test Description: Expand on the basic test by rebuilding 2
pools at once.
Use Cases:
-- multipool rebuild, single client, various object and record counds
:avocado: tags=pool,rebuild,rebuildmulti
"""
try:
# initialize python pool object then create the underlying
# daos storage, the way the code is now the pools should be
# on the same storage and have the same service leader
pool1 = DaosPool(self.context)
pool2 = DaosPool(self.context)
pool1.create(self.createmode, self.createuid, self.creategid,
self.createsize, self.createsetid)
pool2.create(self.createmode, self.createuid, self.creategid,
self.createsize, self.createsetid)
# want an open connection during rebuild
pool1.connect(1 << 1)
pool2.connect(1 << 1)
# create containers
container1 = DaosContainer(self.context)
container1.create(pool1.handle)
container2 = DaosContainer(self.context)
container2.create(pool2.handle)
# now open them
container1.open()
container2.open()
# Putting the same data in both pools, at least for now to simplify
# checking its correct
saved_data = []
for _objc in range(self.objcount):
obj = None
for _recc in range(self.reccount):
# make some stuff up and write
dkey = (
''.join(random.choice(string.ascii_uppercase +
string.digits) for _ in range(5)))
akey = (
''.join(random.choice(string.ascii_uppercase +
string.digits) for _ in range(5)))
data = (
''.join(random.choice(string.ascii_uppercase +
string.digits) for _ in
range(self.size)))
# Used DAOS_OC_R1S_SPEC_RANK
# 1 replica with specified rank
obj, txn = container1.write_an_obj(data, len(data), dkey,
akey, obj, self.rank,
obj_cls=15)
obj, txn = container2.write_an_obj(data, len(data), dkey,
akey, obj, self.rank,
obj_cls=15)
saved_data.append((obj, dkey, akey, data, txn))
# read the data back and make sure its correct containers
data2 = container1.read_an_obj(self.size, dkey, akey, obj,
txn)
if data != data2.value:
self.fail("Wrote data P1, read it back, didn't match\n")
data2 = container2.read_an_obj(self.size, dkey, akey, obj,
txn)
if data != data2.value:
self.fail("Wrote data P2, read it back, didn't match\n")
# kill a server
server = DaosServer(self.context, self.server_group, self.rank)
server.kill(1)
# temporarily, the exclude of a failed target must be done
# manually
pool1.exclude([self.rank])
pool2.exclude([self.rank])
# check that rebuild finishes, no errors, progress data as
# know it to be. Check pool 1 first then we'll check 2 below.
while True:
pool1.pool_query()
if pool1.pool_info.pi_rebuild_st.rs_done == 1:
break
else:
time.sleep(2)
# check there are no errors and other data matches what we
# apriori know to be true,
if pool1.pool_info.pi_ndisabled != 1:
self.fail("P1 number disabled targets reporting incorrectly: {}"
.format(pool1.pool_info.pi_ndisabled))
if pool1.pool_info.pi_rebuild_st.rs_errno != 0:
self.fail("P1 rebuild error reported: {}"
.format(pool1.pool_info.pi_rebuild_st.rs_errno))
if pool1.pool_info.pi_rebuild_st.rs_obj_nr != self.objcount:
self.fail("P1 rebuilt objs not as expected: {0} {1}"
.format(pool1.pool_info.pi_rebuild_st.rs_obj_nr,
self.objcount))
if (pool1.pool_info.pi_rebuild_st.rs_rec_nr !=
(self.reccount*self.objcount)):
self.fail("P1 rebuilt recs not as expected: {0} {1}"
.format(pool1.pool_info.pi_rebuild_st.rs_rec_nr,
self.reccount*self.objcount))
# now that the rebuild finished verify the records are correct
for tup in saved_data:
data2 = container1.read_an_obj(len(tup[3]), tup[1], tup[2],
tup[0], tup[4])
if tup[3] != data2.value:
self.fail("after rebuild data didn't check out")
# now check the other pool
while True:
pool2.pool_query()
if pool2.pool_info.pi_rebuild_st.rs_done == 1:
break
else:
time.sleep(2)
# check there are no errors and other data matches what we
# apriori know to be true
if pool2.pool_info.pi_ndisabled != 1:
self.fail("Number disabled targets reporting incorrectly: {}"
.format(pool2.pool_info.pi_ndisabled))
if pool2.pool_info.pi_rebuild_st.rs_errno != 0:
self.fail("Rebuild error reported: {}"
.format(pool2.pool_info.pi_rebuild_st.rs_errno))
if pool2.pool_info.pi_rebuild_st.rs_obj_nr != self.objcount:
self.fail("Rebuilt objs not as expected: {0} {1}"
.format(pool2.pool_info.pi_rebuild_st.rs_obj_nr,
self.objcount))
if (pool2.pool_info.pi_rebuild_st.rs_rec_nr !=
(self.reccount*self.objcount)):
self.fail("Rebuilt recs not as expected: {0} {1}".
format(pool2.pool_info.pi_rebuild_st.rs_rec_nr,
(self.reccount*self.objcount)))
# now that the rebuild finished verify the records are correct
for tup in saved_data:
data2 = container2.read_an_obj(len(tup[3]), tup[1], tup[2],
tup[0], tup[4])
if tup[3] != data2.value:
self.fail("after rebuild data didn't check out")
except DaosApiError as excp:
print (excp)
print (traceback.format_exc())
self.fail("Expecting to pass but test has failed.\n")
def test_connect(self):
"""
Pass bad parameters to pool connect
:avocado: tags=pool,poolconnect,badparam,badconnect
"""
# parameters used in pool create
createmode = self.params.get("mode", '/run/connecttests/createmode/')
createuid = self.params.get("uid", '/run/connecttests/uids/createuid/')
creategid = self.params.get("gid", '/run/connecttests/gids/creategid/')
createsetid = self.params.get("setname",
'/run/connecttests/setnames/createset/')
createsize = self.params.get("size",
'/run/connecttests/psize/createsize/')
# Accumulate a list of pass/fail indicators representing what is
# expected for each parameter then "and" them to determine the
# expected result of the test
expected_for_param = []
modelist = self.params.get("mode", '/run/connecttests/connectmode/*/')
connectmode = modelist[0]
expected_for_param.append(modelist[1])
svclist = self.params.get("ranklist", '/run/connecttests/svrlist/*/')
svc = svclist[0]
expected_for_param.append(svclist[1])
setlist = self.params.get("setname",
'/run/connecttests/connectsetnames/*/')
connectset = setlist[0]
expected_for_param.append(setlist[1])
uuidlist = self.params.get("uuid", '/run/connecttests/UUID/*/')
connectuuid = uuidlist[0]
expected_for_param.append(uuidlist[1])
# if any parameter is FAIL then the test should FAIL, in this test
# virtually everyone should FAIL since we are testing bad parameters
expected_result = 'PASS'
for result in expected_for_param:
if result == 'FAIL':
expected_result = 'FAIL'
break
puuid = (ctypes.c_ubyte * 16)()
psvc = RankList()
pgroup = ctypes.create_string_buffer(0)
pool = None
try:
# setup the DAOS python API
with open('../../../.build_vars.json') as build_file:
data = json.load(build_file)
context = DaosContext(data['PREFIX'] + '/lib/')
# initialize a python pool object then create the underlying
# daos storage
pool = DaosPool(context)
pool.create(createmode, createuid, creategid,
createsize, createsetid, None)
# save this uuid since we might trash it as part of the test
ctypes.memmove(puuid, pool.uuid, 16)
# trash the the pool service rank list
psvc.rl_ranks = pool.svc.rl_ranks
psvc.rl_nr = pool.svc.rl_nr
if not svc == 'VALID':
rl_ranks = ctypes.POINTER(ctypes.c_uint)()
pool.svc = RankList(rl_ranks, 1)
# trash the pool group value
pgroup = pool.group
if connectset == 'NULLPTR':
pool.group = None
# trash the UUID value in various ways
if connectuuid == 'NULLPTR':
pool.uuid = None
if connectuuid == 'JUNK':
pool.uuid[4] = 244
pool.connect(connectmode)
if expected_result in ['FAIL']:
self.fail("Test was expected to fail but it passed.\n")
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
if expected_result in ['PASS']:
self.fail("Test was expected to pass but it failed.\n")
# cleanup the pool
finally:
if pool is not None and pool.attached == 1:
# restore values in case we trashed them during test
pool.svc.rl_ranks = psvc.rl_ranks
pool.svc.rl_nr = psvc.rl_nr
pool.group = pgroup
ctypes.memmove(pool.uuid, puuid, 16)
print("pool uuid after restore {}".format(
pool.get_uuid_str()))
pool.destroy(1)
class DeleteContainerTest(Test):
"""
Tests DAOS container delete and close.
"""
def setUp(self):
# get paths from the build_vars generated by build
self.hostlist = None
with open('../../../.build_vars.json') as f:
build_paths = json.load(f)
self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
self.server_group = self.params.get("server_group", '/server/',
'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 = WriteHostFile.WriteHostFile(self.hostlist,
self.workdir)
ServerUtils.runServer(self.hostfile, self.server_group, self.basepath)
def tearDown(self):
ServerUtils.stopServer(hosts=self.hostlist)
def test_container_delete(self):
"""
Test basic container delete
:avocado: tags=regression,cont,vm,contdelete
"""
expected_for_param = []
uuidlist = self.params.get("uuid",
'/run/createtests/ContainerUUIDS/*/')
contUUID = uuidlist[0]
expected_for_param.append(uuidlist[1])
pohlist = self.params.get("poh", '/run/createtests/PoolHandles/*/')
poh = pohlist[0]
expected_for_param.append(pohlist[1])
openlist = self.params.get("opened",
"/run/createtests/ConnectionOpened/*/")
opened = openlist[0]
expected_for_param.append(openlist[1])
forcelist = self.params.get("force",
"/run/createtests/ForceDestroy/*/")
force = forcelist[0]
expected_for_param.append(forcelist[1])
if force >= 1:
self.cancel("Force >= 1 blocked by issue described in "
"https://jira.hpdd.intel.com/browse/DAOS-689")
if force == 0:
self.cancel("Force = 0 blocked by "
"https://jira.hpdd.intel.com/browse/DAOS-1935")
expected_result = 'PASS'
for result in expected_for_param:
if result == 'FAIL':
expected_result = 'FAIL'
break
try:
# initialize a python pool object then create the underlying
# daos storage
self.pool = DaosPool(self.context)
self.pool.create(self.createmode, self.createuid, self.creategid,
self.createsize, self.createsetid, None)
# need a connection to create container
self.pool.connect(1 << 1)
self.container = DaosContainer(self.context)
# create should always work (testing destroy)
if not contUUID == 'INVALID':
contUUID = uuid.UUID(uuidlist[0])
self.container.create(self.pool.handle, contUUID)
else:
self.container.create(self.pool.handle)
# Opens the container if required
if opened:
self.container.open(self.pool.handle)
# wait a few seconds and then attempts to destroy container
time.sleep(5)
if poh == 'VALID':
poh = self.pool.handle
# if container is INVALID, overwrite with non existing UUID
if contUUID == 'INVALID':
contUUID = uuid.uuid4()
self.container.destroy(force=force, poh=poh, con_uuid=contUUID)
self.container = None
if expected_result in ['FAIL']:
self.fail("Test was expected to fail but it passed.\n")
except DaosApiError as e:
self.d_log.error(e)
self.d_log.error(traceback.format_exc())
if expected_result == 'PASS':
self.fail("Test was expected to pass but it failed.\n")
finally:
# clean up the pool
if self.pool is not None:
self.pool.destroy(1)
self.pool = None
class RebuildNoCap(Test):
"""
Test Class Description:
This class contains tests for pool rebuild.
:avocado: tags=pool,rebuild,nocap
"""
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 tearDown(self):
""" cleanup after the test """
try:
os.remove(self.hostfile)
if self.pool:
self.pool.destroy(1)
finally:
if self.agent_sessions:
AgentUtils.stop_agent(self.hostlist, self.agent_sessions)
server_utils.stop_server(hosts=self.hostlist)
def test_rebuild_no_capacity(self):
"""
:avocado: tags=pool,rebuild,nocap
"""
try:
print("\nsetup complete, starting test\n")
# create a server object that references on of our pool target hosts
# and then kill it
svr_to_kill = int(self.params.get("rank_to_kill",
'/run/testparams/ranks/'))
d_server = DaosServer(self.context, bytes(self.server_group),
svr_to_kill)
time.sleep(1)
d_server.kill(1)
# exclude the target from the dead server
self.pool.exclude([svr_to_kill])
# exclude should trigger rebuild, check
self.pool.connect(1 << 1)
status = self.pool.pool_query()
if not status.pi_ntargets == len(self.hostlist):
self.fail("target count wrong.\n")
if not status.pi_ndisabled == 1:
self.fail("disabled target count wrong.\n")
# the pool should be too full to start a rebuild so
# expecting an error
# not sure yet specifically what error
if status.pi_rebuild_st.rs_errno == 0:
self.fail("expecting rebuild to fail but it didn't.\n")
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
self.fail("Expecting to pass but test has failed.\n")
class SegCount(Test):
"""
Test class Description: Runs IOR with different segment counts.
"""
def __init__(self, *args, **kwargs):
super(SegCount, self).__init__(*args, **kwargs)
self.basepath = None
self.Context = None
self.pool = None
self.slots = None
self.hostlist_servers = None
self.hostfile_clients = None
def setUp(self):
# get paths from the build_vars generated by build
with open('../../../.build_vars.json') as f:
build_paths = json.load(f)
self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
self.server_group = self.params.get("server_group", '/server/', '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 = WriteHostFile.WriteHostFile(self.hostlist_servers, self.workdir)
print("Host file servers is: {}".format(hostfile_servers))
hostlist_clients = self.params.get("test_clients", '/run/hosts/*')
self.slots = self.params.get("slots", '/run/ior/clientslots/*')
self.hostfile_clients = WriteHostFile.WriteHostFile(hostlist_clients, self.workdir, self.slots)
print("Host file clients is: {}".format(self.hostfile_clients))
ServerUtils.runServer(hostfile_servers, self.server_group, self.basepath)
if int(str(self.name).split("-")[0]) == 1:
IorUtils.build_ior(self.basepath)
def tearDown(self):
try:
if self.pool is not None and self.pool.attached:
self.pool.destroy(1)
finally:
ServerUtils.stopServer(hosts=self.hostlist_servers)
def test_segcount(self):
"""
Test ID: DAOS-1782
Test Description: Run IOR with 32,64 and 128 clients with different
segment counts.
Use Cases: Different combinations of 32/64/128 Clients, 8b/1k/4k
record size, 1k/4k/1m/8m transfersize and stripesize
and 16 async io.
:avocado: tags=ior,eightservers,ior_segcount,performance
"""
# 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/')
createsvc = self.params.get("svcn", '/run/pool/createsvc/')
iteration = self.params.get("iter", '/run/ior/iteration/')
block_size = self.params.get("b", '/run/ior/blocksize_transfersize_stripesize/*/')
ior_flags = self.params.get("F", '/run/ior/iorflags/')
transfer_size = self.params.get("t", '/run/ior/blocksize_transfersize_stripesize/*/')
record_size = self.params.get("r", '/run/ior/recordsize/*')
stripe_size = self.params.get("s", '/run/ior/blocksize_transfersize_stripesize/*/')
stripe_count = self.params.get("c", '/run/ior/stripecount/')
async_io = self.params.get("a", '/run/ior/asyncio/')
object_class = self.params.get("o", '/run/ior/objectclass/*/')
if (block_size == '4k' and self.slots == 16):
segment_count = 491500
elif (block_size == '4k' and self.slots == 32):
segment_count = 245750
elif (block_size == '4k' and self.slots == 64):
segment_count = 122875
elif (block_size == '1m' and self.slots == 16):
segment_count = 1920
elif (block_size == '1m' and self.slots == 32):
segment_count = 960
elif (block_size == '1m' and self.slots == 64):
segment_count = 480
elif (block_size == '4m' and self.slots == 16):
segment_count = 480
elif (block_size == '4m' and self.slots == 32):
segment_count = 240
elif (block_size == '4m' and self.slots == 64):
segment_count = 120
try:
# 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, createsvc)
pool_uuid = self.pool.get_uuid_str()
svc_list = ""
for i in range(createsvc):
svc_list += str(int(self.pool.svc.rl_ranks[i])) + ":"
svc_list = svc_list[:-1]
IorUtils.run_ior(self.hostfile_clients, ior_flags, iteration, block_size, transfer_size,
pool_uuid, svc_list, record_size, stripe_size, stripe_count,
async_io, object_class, self.basepath, self.slots, segment_count)
except (IorUtils.IorFailed, DaosApiError) as e:
self.fail("<SegCount Test FAILED>.{}".format(e))
class PoolSvc(Test):
"""
Tests svc argument while pool create.
"""
def setUp(self):
# get paths from the build_vars generated by build
with open('../../../.build_vars.json') as f:
build_paths = json.load(f)
self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
self.tmp = build_paths['PREFIX'] + '/tmp'
self.server_group = self.params.get("server_group", '/server/',
'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.hostfile = None
hostlist = self.params.get("test_machines", '/run/hosts/*')
self.hostfile = WriteHostFile.WriteHostFile(hostlist, self.tmp)
print("Host file is: {}".format(self.hostfile))
ServerUtils.runServer(self.hostfile, self.server_group, self.basepath)
time.sleep(5)
def tearDown(self):
if self.hostfile is not None:
os.remove(self.hostfile)
if self.POOL is not None and self.POOL.attached:
self.POOL.destroy(1)
ServerUtils.stopServer()
def test_poolsvc(self):
"""
Test svc arg during pool create.
:avocado: tags=pool,svc
"""
# parameters used in pool create
createmode = self.params.get("mode", '/run/createtests/createmode/*/')
createuid = os.geteuid()
creategid = os.getegid()
createsetid = self.params.get("setname", '/run/createtests/createset/')
createsize = self.params.get("size", '/run/createtests/createsize/')
createsvc = self.params.get("svc", '/run/createtests/createsvc/*/')
expected_result = createsvc[1]
try:
# 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, createsvc[0])
self.POOL.connect(1 << 1)
if (createsvc[0] == 3):
self.POOL.disconnect()
cmd = ('{0} kill-leader --uuid={1}'.format(
self.daosctl, self.POOL.get_uuid_str()))
process.system(cmd)
time.sleep(5)
self.POOL.connect(1 << 1)
self.POOL.disconnect()
server = DaosServer(self.Context, self.server_group, 1)
server.kill(1)
time.sleep(5)
self.POOL.connect(1 << 1)
if expected_result in ['FAIL']:
self.fail("Test was expected to fail but it passed.\n")
# cleanup the pool
self.POOL.disconnect()
self.POOL.destroy(1)
self.POOL = None
except ValueError as e:
print e
print traceback.format_exc()
if expected_result == 'PASS':
self.fail("Test was expected to pass but it failed.\n")
class PunchTest(TestWithServers):
"""
Simple test to verify the 3 different punch calls.
:avocado: recursive
"""
def setUp(self):
try:
super(PunchTest, self).setUp()
# 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 excpn:
print(excpn)
print(traceback.format_exc())
self.fail("Test failed during setup.\n")
def test_dkey_punch(self):
"""
The most basic test of the dkey punch function.
:avocado: tags=all,object,pr,small,dkeypunch
"""
try:
# create an object and write some data into it
thedata = "a string that I want to stuff into an object"
dkey = "this is the dkey"
akey = "this is the akey"
obj, txn = self.container.write_an_obj(thedata, len(thedata)+1,
dkey, akey, obj_cls=1)
# read the data back and make sure its correct
thedata2 = self.container.read_an_obj(len(thedata)+1, dkey, akey,
obj, txn)
if thedata != thedata2.value:
print("data I wrote:" + thedata)
print("data I read back" + thedata2.value)
self.fail("Wrote data, read it back, didn't match\n")
# now punch this data, should fail, can't punch committed data
obj.punch_dkeys(txn, [dkey])
# expecting punch of commit data above to fail
self.fail("Punch should have failed but it didn't.\n")
# expecting an exception so do nothing
except DaosApiError as dummy_e:
pass
try:
# now punch this data
obj.punch_dkeys(0, [dkey])
# this one should work so error if exception occurs
except DaosApiError as dummy_e:
self.fail("Punch should have worked.\n")
# there are a bunch of other cases to test here,
# --test punching the same updating and punching the same data in
# the same tx, should fail
# --test non updated data in an open tx, should work
def test_akey_punch(self):
"""
The most basic test of the akey punch function.
:avocado: tags=all,object,pr,small,akeypunch
"""
try:
# create an object and write some data into it
dkey = "this is the dkey"
data1 = [("this is akey 1", "this is data value 1"),
("this is akey 2", "this is data value 2"),
("this is akey 3", "this is data value 3")]
obj, txn = self.container.write_multi_akeys(dkey, data1, obj_cls=1)
# read back the 1st epoch's data and check 1 value just to make sure
# everything is on the up and up
readbuf = [(data1[0][0], len(data1[0][1]) + 1),
(data1[1][0], len(data1[1][1]) + 1),
(data1[2][0], len(data1[2][1]) + 1)]
retrieved_data = self.container.read_multi_akeys(dkey, readbuf, obj,
txn)
if retrieved_data[data1[1][0]] != data1[1][1]:
print("middle akey: {}".format(retrieved_data[data1[1][0]]))
self.fail("data retrieval failure")
# now punch one akey from this data
obj.punch_akeys(txn, dkey, [data1[1][0]])
# expecting punch of commit data above to fail
self.fail("Punch should have failed but it didn't.\n")
# expecting an exception so do nothing
except DaosApiError as excep:
print(excep)
try:
# now punch the object without a tx
obj.punch_akeys(0, dkey, [data1[1][0]])
# expecting it to work this time so error
except DaosApiError as excep:
self.fail("Punch should have worked: {}\n".format(excep))
def test_obj_punch(self):
"""
The most basic test of the object punch function. Really similar
to above except the whole object is deleted.
:avocado: tags=all,object,pr,small,objpunch
"""
try:
# create an object and write some data into it
thedata = "a string that I want to stuff into an object"
dkey = "this is the dkey"
akey = "this is the akey"
obj, txn = self.container.write_an_obj(thedata, len(thedata)+1,
dkey, akey, obj_cls=1)
# read the data back and make sure its correct
thedata2 = self.container.read_an_obj(len(thedata)+1, dkey, akey,
obj, txn)
if thedata != thedata2.value:
print("data I wrote:" + thedata)
print("data I read back" + thedata2.value)
self.fail("Wrote data, read it back, didn't match\n")
# now punch the object, commited so not expecting it to work
obj.punch(txn)
# expecting punch of commit data above to fail
self.fail("Punch should have failed but it didn't.\n")
# expecting an exception so do nothing
except DaosApiError as excep:
print(excep)
try:
obj.punch(0)
# expecting it to work without a tx
except DaosApiError as excep:
print(excep)
self.fail("Punch should have worked.\n")
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 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)
# 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)
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:
AgentUtils.stop_agent(self.hostlist, self.agent_sessions)
server_utils.stop_server(hosts=self.hostlist)
os.remove(hostfile)
class DeleteContainerTest(Test):
"""
Tests DAOS container delete
and close.
"""
def setUp(self):
# get paths from the build_vars generated by build
with open('../../../.build_vars.json') as f:
build_paths = json.load(f)
self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
self.tmp = build_paths['PREFIX'] + '/tmp'
self.server_group = self.params.get("server_group", '/server/',
'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
self.hostfile = None
self.hostlist = self.params.get("test_machines", '/run/hosts/*')
self.hostfile = WriteHostFile.WriteHostFile(self.hostlist, self.tmp)
ServerUtils.runServer(self.hostfile, self.server_group, self.basepath)
def tearDown(self):
try:
if self.hostfile is not None:
os.remove(self.hostfile)
finally:
ServerUtils.stopServer(hosts=self.hostlist)
def test_container_delete(self):
"""
Test basic container delete
:avocado: tags=regression,cont,vm
"""
expected_for_param = []
uuidlist = self.params.get("uuid",
'/run/createtests/ContainerUUIDS/*/')
contUUID = uuidlist[0]
expected_for_param.append(uuidlist[1])
pohlist = self.params.get("poh", '/run/createtests/PoolHandles/*/')
poh = pohlist[0]
expected_for_param.append(pohlist[1])
openlist = self.params.get("opened",
"/run/createtests/ConnectionOpened/*/")
opened = openlist[0]
expected_for_param.append(openlist[1])
forcelist = self.params.get("force",
"/run/createtests/ForceDestroy/*/")
force = forcelist[0]
expected_for_param.append(forcelist[1])
expected_result = 'PASS'
for result in expected_for_param:
if result == 'FAIL':
expected_result = 'FAIL'
break
# special expected result for a specific case:
# valid pool handle + valid container UUID, container opened, force destroy > 0
if opened and force > 0 and not contUUID == 'INVALID' and poh == 'VALID':
expected_result = 'PASS'
try:
# initialize a python pool object then create the underlying
# daos storage
self.POOL = DaosPool(self.Context)
self.POOL.create(self.createmode, self.createuid, self.creategid,
self.createsize, self.createsetid, None)
# need a connection to create container
self.POOL.connect(1 << 1)
self.CONTAINER = DaosContainer(self.Context)
# create should always work (testing destroy)
if not contUUID == 'INVALID':
contUUID = uuid.UUID(uuidlist[0])
self.CONTAINER.create(self.POOL.handle, contUUID)
else:
self.CONTAINER.create(self.POOL.handle)
# Opens the container if required
if opened:
self.CONTAINER.open(self.POOL.handle)
# wait a few seconds and then attempds to destroy container
time.sleep(5)
if poh == 'VALID':
poh = self.POOL.handle
# if container is INVALID, overwrite with non existing UUID
if contUUID == 'INVALID':
contUUID = uuid.uuid4()
self.CONTAINER.destroy(force, poh, contUUID)
self.CONTAINER = None
# cleanup the pool
#self.POOL.disconnect()
self.POOL.destroy(1)
self.POOL = None
if expected_result in ['FAIL']:
self.fail("Test was expected to fail but it passed.\n")
except DaosApiError as e:
print(e)
print(traceback.format_exc())
if expected_result == 'PASS':
self.fail("Test was expected to pass but it failed.\n")
class CreateManyDkeys(Test):
"""
Test Class Description:
Tests that create large numbers of keys in objects/containers and then
destroy the containers and verify the space has been reclaimed.
"""
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 tearDown(self):
try:
if self.hostfile is not None:
os.remove(self.hostfile)
if self.pool:
self.pool.destroy(1)
finally:
if self.agent_sessions:
AgentUtils.stop_agent(self.hostlist, self.agent_sessions)
server_utils.stop_server(hosts=self.hostlist)
def write_a_bunch_of_values(self, how_many):
"""
Write data to an object, each with a dkey and akey. The how_many
parameter determines how many key:value pairs are written.
"""
self.container = DaosContainer(self.context)
self.container.create(self.pool.handle)
self.container.open()
ioreq = IORequest(self.context, self.container, None)
epoch = self.container.get_new_epoch()
c_epoch = ctypes.c_uint64(epoch)
print("Started Writing the Dataset-----------\n")
inc = 50000
last_key = inc
for key in range(how_many):
c_dkey = ctypes.create_string_buffer("dkey {0}".format(key))
c_akey = ctypes.create_string_buffer("akey {0}".format(key))
c_value = ctypes.create_string_buffer(
"some data that gets stored with the key {0}".format(key))
c_size = ctypes.c_size_t(ctypes.sizeof(c_value))
ioreq.single_insert(c_dkey,
c_akey,
c_value,
c_size,
c_epoch)
if key > last_key:
print("written: {}".format(key))
sys.stdout.flush()
last_key = key + inc
self.container.commit_epoch(c_epoch)
print("Started Verification of the Dataset-----------\n")
last_key = inc
for key in range(how_many):
c_dkey = ctypes.create_string_buffer("dkey {0}".format(key))
c_akey = ctypes.create_string_buffer("akey {0}".format(key))
the_data = "some data that gets stored with the key {0}".format(key)
val = ioreq.single_fetch(c_dkey,
c_akey,
len(the_data)+1,
c_epoch)
if the_data != (repr(val.value)[1:-1]):
self.fail("ERROR: Data mismatch for dkey = {0}, akey={1}, "
"Expected Value={2} and Received Value={3}\n"
.format("dkey {0}".format(key),
"akey {0}".format(key),
the_data,
repr(val.value)[1:-1]))
if key > last_key:
print("veried: {}".format(key))
sys.stdout.flush()
last_key = key + inc
print("starting destroy")
self.container.close()
self.container.destroy()
print("destroy complete")
@avocado.fail_on(DaosApiError)
@avocado.skip("Skipping until DAOS-1721 is fixed.")
def test_many_dkeys(self):
"""
Test ID: DAOS-1701
Test Description: Test many of dkeys in same object.
Use Cases: 1. large key counts
2. space reclaimation after destroy
:avocado: tags=object,vm,many_dkeys
"""
no_of_dkeys = self.params.get("number_of_dkeys", '/run/dkeys/')
# write a lot of individual data items, verify them, then destroy
self.write_a_bunch_of_values(no_of_dkeys)
# do it again, which should verify the first container
# was truely destroyed because a second round won't fit otherwise
self.write_a_bunch_of_values(no_of_dkeys)
class ContainerAttributeTest(Test):
"""
Tests DAOS container attribute get/set/list.
"""
def setUp(self):
with open('../../../.build_vars.json') as f:
build_paths = json.load(f)
basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
tmp = build_paths['PREFIX'] + '/tmp'
server_group = self.params.get("server_group", '/server/',
'daos_server')
self.Context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.hostlist = self.params.get("test_machines", '/run/hosts/*')
self.hostfile = WriteHostFile.WriteHostFile(self.hostlist, tmp)
ServerUtils.runServer(self.hostfile, server_group, basepath)
self.POOL = DaosPool(self.Context)
self.POOL.create(
self.params.get("mode", '/run/attrtests/createmode/*'),
os.geteuid(), os.getegid(),
self.params.get("size", '/run/attrtests/createsize/*'),
self.params.get("setname", '/run/attrtests/createset/*'), None)
self.POOL.connect(1 << 1)
poh = self.POOL.handle
self.CONTAINER = DaosContainer(self.Context)
self.CONTAINER.create(poh)
self.CONTAINER.open()
self.large_data_set = {}
def tearDown(self):
if self.hostfile is not None:
os.remove(self.hostfile)
self.CONTAINER.close()
ServerUtils.stopServer()
def create_data_set(self):
"""
To create the large attribute dictionary
"""
allchar = string.ascii_letters + string.digits
for i in range(1024):
self.large_data_set[str(i)] = "".join(
random.choice(allchar) for x in range(random.randint(1, 100)))
def test_container_attribute(self):
"""
Test basic container attribute tests.
:avocado: tags=container,container_attr,attribute,sync_conattribute
"""
expected_for_param = []
name = self.params.get("name", '/run/attrtests/name_handles/*/')
expected_for_param.append(name[1])
value = self.params.get("value", '/run/attrtests/value_handles/*/')
expected_for_param.append(value[1])
attr_dict = dict(zip(name, value))
if name[0] is not None:
if "largenumberofattr" in name[0]:
self.create_data_set()
attr_dict = self.large_data_set
if 'PASS' in attr_dict:
del attr_dict['PASS']
if 'FAIL' in attr_dict:
del attr_dict['FAIL']
expected_result = 'PASS'
for result in expected_for_param:
if result == 'FAIL':
expected_result = 'FAIL'
break
try:
print("===== Set Attr")
self.CONTAINER.set_attr(data=attr_dict)
size, buf = self.CONTAINER.list_attr()
verify_list_attr(attr_dict, size, buf)
##This is for requesting the name which is not exist.
if "Negative" in name[0]:
attr_dict["Wrong_Value"] = attr_dict.pop(name[0])
val = self.CONTAINER.get_attr(data=attr_dict)
verify_get_attr(attr_dict, val)
if expected_result in ['FAIL']:
self.fail("Test was expected to fail but it passed.\n")
except Exception as e:
print(e)
print(traceback.format_exc())
if expected_result == 'PASS':
self.fail("Test was expected to pass but it failed.\n")
def test_container_attribute_asyn(self):
"""
Test basic container attribute tests.
:avocado: tags=container,container_attr,attribute,async_conattribute
"""
global GLOB_SIGNAL
global GLOB_RC
expected_for_param = []
name = self.params.get("name", '/run/attrtests/name_handles/*/')
expected_for_param.append(name[1])
value = self.params.get("value", '/run/attrtests/value_handles/*/')
expected_for_param.append(value[1])
attr_dict = dict(zip(name, value))
if name[0] is not None:
if "largenumberofattr" in name[0]:
self.create_data_set()
attr_dict = self.large_data_set
if 'PASS' in attr_dict:
del attr_dict['PASS']
if 'FAIL' in attr_dict:
del attr_dict['FAIL']
expected_result = 'PASS'
for result in expected_for_param:
if result == 'FAIL':
expected_result = 'FAIL'
break
try:
print("===== Set Attr")
GLOB_SIGNAL = threading.Event()
self.CONTAINER.set_attr(data=attr_dict, cb_func=cb_func)
GLOB_SIGNAL.wait()
if GLOB_RC != 0:
self.fail("RC not as expected after set_attr First {0}".format(
GLOB_RC))
GLOB_SIGNAL = threading.Event()
size, buf = self.CONTAINER.list_attr(cb_func=cb_func)
GLOB_SIGNAL.wait()
if GLOB_RC != 0:
self.fail(
"RC not as expected after list_attr First {0}".format(
GLOB_RC))
verify_list_attr(attr_dict, size, buf, mode="async")
#This is for requesting the name which is not exist.
if "Negative" in name[0]:
attr_dict["Wrong_Value"] = attr_dict.pop(name[0])
GLOB_SIGNAL = threading.Event()
val = self.CONTAINER.get_attr(data=attr_dict, cb_func=cb_func)
GLOB_SIGNAL.wait()
if GLOB_RC != 0:
self.fail(
"RC not as expected after get_attr {0}".format(GLOB_RC))
verify_get_attr(attr_dict, val)
if expected_result in ['FAIL']:
self.fail("Test was expected to fail but it passed.\n")
except Exception as e:
print(e)
print(traceback.format_exc())
if expected_result == 'PASS':
self.fail("Test was expected to pass but it failed.\n")
def test_exclude(self):
"""
Pass bad parameters to pool connect
:avocado: tags=pool,poolexclude,badparam,badexclude
"""
# 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()
# Accumulate a list of pass/fail indicators representing what is
# expected for each parameter then "and" them to determine the
# expected result of the test
expected_for_param = []
tgtlist = self.params.get("ranklist", '/run/testparams/tgtlist/*/')
targets = []
if tgtlist[0] == "NULLPTR":
targets = None
self.cancel("skipping null pointer test until DAOS-1929 is fixed")
else:
targets.append(tgtlist[0])
expected_for_param.append(tgtlist[1])
svclist = self.params.get("ranklist", '/run/testparams/svrlist/*/')
svc = svclist[0]
expected_for_param.append(svclist[1])
setlist = self.params.get("setname",
'/run/testparams/connectsetnames/*/')
connectset = setlist[0]
expected_for_param.append(setlist[1])
uuidlist = self.params.get("uuid", '/run/testparams/UUID/*/')
excludeuuid = uuidlist[0]
expected_for_param.append(uuidlist[1])
# if any parameter is FAIL then the test should FAIL, in this test
# virtually everyone should FAIL since we are testing bad parameters
expected_result = 'PASS'
for result in expected_for_param:
if result == 'FAIL':
expected_result = 'FAIL'
break
saved_svc = None
saved_grp = None
saved_uuid = None
pool = None
try:
# setup the DAOS python API
with open('../../../.build_vars.json') as build_file:
data = json.load(build_file)
context = DaosContext(data['PREFIX'] + '/lib/')
# initialize a python pool object then create the underlying
# daos storage
pool = DaosPool(context)
pool.create(createmode, createuid, creategid,
createsize, createsetid, None)
# trash the the pool service rank list
if not svc == 'VALID':
self.cancel("skipping this test until DAOS-1931 is fixed")
saved_svc = RankList(pool.svc.rl_ranks, pool.svc.rl_nr)
pool.svc = None
# trash the pool group value
if connectset == 'NULLPTR':
saved_grp = pool.group
pool.group = None
# trash the UUID value in various ways
if excludeuuid == 'NULLPTR':
self.cancel("skipping this test until DAOS-1932 is fixed")
ctypes.memmove(saved_uuid, pool.uuid, 16)
pool.uuid = 0
if excludeuuid == 'CRAP':
self.cancel("skipping this test until DAOS-1932 is fixed")
ctypes.memmove(saved_uuid, pool.uuid, 16)
pool.uuid[4] = 244
pool.exclude(targets)
if expected_result in ['FAIL']:
self.fail("Test was expected to fail but it passed.\n")
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
if expected_result in ['PASS']:
self.fail("Test was expected to pass but it failed.\n")
finally:
if pool is not None:
if saved_svc is not None:
pool.svc = saved_svc
if saved_grp is not None:
pool.group = saved_grp
if saved_uuid is not None:
ctypes.memmove(pool.uuid, saved_uuid, 16)
pool.destroy(1)
class PoolAttributeTest(TestWithServers):
"""
Test class Description: Tests DAOS pool attribute get/set/list.
:avocado: recursive
"""
def setUp(self):
super(PoolAttributeTest, self).setUp()
self.large_data_set = {}
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/')
try:
self.pool = DaosPool(self.context)
self.pool.create(createmode, createuid, creategid, createsize,
createsetid)
self.pool.connect(1 << 1)
except DaosApiError as excep:
print("In the setup exception handler\n")
print(excep)
print(traceback.format_exc())
def create_data_set(self):
"""
To create the large attribute dictionary
"""
allchar = string.ascii_letters + string.digits
for i in range(1024):
self.large_data_set[str(i)] = (
"".join(random.choice(allchar)
for x in range(random.randint(1, 100))))
def test_pool_large_attributes(self):
"""
Test ID: DAOS-1359
Test description: Test large randomly created pool attribute.
:avocado: tags=regression,pool,pool_attr,attribute,large_poolattribute
"""
self.create_data_set()
attr_dict = self.large_data_set
try:
self.pool.set_attr(data=attr_dict)
size, buf = self.pool.list_attr()
verify_list_attr(attr_dict, size.value, buf)
results = {}
results = self.pool.get_attr(attr_dict.keys())
verify_get_attr(attr_dict, results)
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
self.fail("Test was expected to pass but it failed.\n")
def test_pool_attributes(self):
"""
Test ID: DAOS-1359
Test description: Test basic pool attribute tests (sync).
:avocado: tags=all,pool,pr,tiny,sync_poolattribute
"""
expected_for_param = []
name = self.params.get("name", '/run/attrtests/name_handles/*/')
expected_for_param.append(name[1])
value = self.params.get("value", '/run/attrtests/value_handles/*/')
expected_for_param.append(value[1])
expected_result = 'PASS'
for result in expected_for_param:
if result == 'FAIL':
expected_result = 'FAIL'
break
attr_dict = {name[0]: value[0]}
try:
self.pool.set_attr(data=attr_dict)
size, buf = self.pool.list_attr()
verify_list_attr(attr_dict, size.value, buf)
if name[0] is not None:
# Request something that doesn't exist
if "Negative" in name[0]:
name[0] = "rubbish"
results = {}
results = self.pool.get_attr([name[0]])
verify_get_attr(attr_dict, results)
if expected_result in ['FAIL']:
self.fail("Test was expected to fail but it passed.\n")
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
if expected_result == 'PASS':
self.fail("Test was expected to pass but it failed.\n")
def test_pool_attribute_asyn(self):
"""
Test ID: DAOS-1359
Test description: Test basic pool attribute tests (async).
:avocado: tags=all,pool,full_regression,tiny,async_poolattribute
"""
global GLOB_SIGNAL
global GLOB_RC
expected_for_param = []
name = self.params.get("name", '/run/attrtests/name_handles/*/')
# workaround until async functions are fixed
if name[0] is not None and "Negative" in name[0]:
pass
else:
expected_for_param.append(name[1])
value = self.params.get("value", '/run/attrtests/value_handles/*/')
expected_for_param.append(value[1])
expected_result = 'PASS'
for result in expected_for_param:
if result == 'FAIL':
expected_result = 'FAIL'
break
attr_dict = {name[0]: value[0]}
try:
GLOB_SIGNAL = threading.Event()
self.pool.set_attr(attr_dict, None, cb_func)
GLOB_SIGNAL.wait()
if expected_result == 'PASS' and GLOB_RC != 0:
self.fail("RC not as expected after set_attr {0}"
.format(GLOB_RC))
if expected_result == 'FAIL' and GLOB_RC == 0:
self.fail("RC not as expected after set_attr {0}"
.format(GLOB_RC))
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
if expected_result == 'PASS':
self.fail("Test was expected to pass but it failed.\n")
def test_create(self):
"""
Pass bad parameters to pool create.
:avocado: tags=pool,poolcreate,badparam,badcreate
"""
# Accumulate a list of pass/fail indicators representing what is
# expected for each parameter then "and" them to determine the
# expected result of the test
pool = None
expected_for_param = []
modelist = self.params.get("mode", '/run/createtests/modes/*')
mode = modelist[0]
expected_for_param.append(modelist[1])
uidlist = self.params.get("uid", '/run/createtests/uids/*')
uid = uidlist[0]
expected_for_param.append(uidlist[1])
gidlist = self.params.get("gid", '/run/createtests/gids/*')
gid = gidlist[0]
expected_for_param.append(gidlist[1])
setidlist = self.params.get("setname", '/run/createtests/setnames/*')
if setidlist[0] == 'NULLPTR':
group = None
self.cancel("skipping this test until DAOS-1991 is fixed")
else:
group = setidlist[0]
expected_for_param.append(setidlist[1])
targetlist = self.params.get("rankptr", '/run/createtests/target/*')
if targetlist[0] == 'NULL':
targetptr = None
else:
targetptr = [0]
expected_for_param.append(targetlist[1])
# not ready for this yet
#devicelist = self.params.get("devptr", '/run/createtests/device/*')
#if devicelist[0] == 'NULL':
# devptr = None
#else:
# devptr = devicelist[0]
#expected_for_param.append(devicelist[1])
sizelist = self.params.get("size", '/run/createtests/psize/*')
size = sizelist[0]
expected_for_param.append(sizelist[1])
# parameter not presently supported
#svclist = self.params.get("rankptr", '/run/createtests/svc/*')
#if svclist[0] == 'NULL':
# svc = None
#else:
# svc = None
#expected_for_param.append(devicelist[1])
# if any parameter is FAIL then the test should FAIL, in this test
# virtually everyone should FAIL since we are testing bad parameters
expected_result = 'PASS'
for result in expected_for_param:
if result == 'FAIL':
expected_result = 'FAIL'
break
try:
# setup the DAOS python API
with open('../../../.build_vars.json') as build_file:
data = json.load(build_file)
context = DaosContext(data['PREFIX'] + '/lib/')
# initialize a python pool object then create the underlying
# daos storage
pool = DaosPool(context)
pool.create(mode, uid, gid, size, group, targetptr)
if expected_result in ['FAIL']:
self.fail("Test was expected to fail but it passed.\n")
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
if expected_result == 'PASS':
self.fail("Test was expected to pass but it failed.\n")
finally:
if pool is not None and pool.attached:
pool.destroy(1)
def test_tx_basics(self):
"""
Perform I/O to an object in a container in 2 different transactions,
verifying basic I/O and transactions in particular.
NOTE: this was an epoch test and all I did was get it working with tx
Not a good test at this point, need to redesign when tx is fully
working.
:avocado: tags=all,container,tx,small,smoke,pr,basictx
"""
pool = None
try:
# parameters used in pool create
createmode = self.params.get("mode", '/run/poolparams/createmode/')
createuid = os.geteuid()
creategid = os.getegid()
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)
# 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")
# create an object and write some data into it
thedata = "a string that I want to stuff into an object"
thedatasize = 45
dkey = "this is the dkey"
akey = "this is the akey"
oid, txn = container.write_an_obj(thedata, thedatasize,
dkey, akey, None, None, 2)
# read the data back and make sure its correct
thedata2 = container.read_an_obj(thedatasize, dkey, akey,
oid, txn)
if thedata != thedata2.value:
print("thedata>" + thedata)
print("thedata2>" + thedata2.value)
self.fail("Write data 1, read it back, didn't match\n")
# repeat above, but know that the write_an_obj call is advancing
# the epoch so the original copy remains and the new copy is in
# a new epoch.
thedata3 = "a different string"
thedatasize2 = 19
# note using the same keys so writing to the same spot
dkey = "this is the dkey"
akey = "this is the akey"
oid, tx2 = container.write_an_obj(thedata3, thedatasize2,
dkey, akey, oid, None, 2)
# read the data back and make sure its correct
thedata4 = container.read_an_obj(thedatasize2, dkey, akey,
oid, tx2)
if thedata3 != thedata4.value:
self.fail("Write data 2, read it back, didn't match\n")
# transactions generally don't work this way but need to explore
# an alternative to below code once model is complete, maybe
# read from a snapshot or read from TX_NONE etc.
# the original data should still be there too
#thedata5 = container.read_an_obj(thedatasize, dkey, akey,
# oid, transaction)
#if thedata != thedata5.value:
# self.fail("Write data 3, read it back, didn't match\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")
finally:
# cleanup the pool
if pool is not None:
pool.disconnect()
pool.destroy(1)
class NvmeIo(avocado.Test):
"""
Test Class Description:
Test the general Metadata operations and boundary conditions.
"""
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 tearDown(self):
try:
if self.pool_connect:
self.pool.disconnect()
self.pool.destroy(1)
finally:
server_utils.stop_server(hosts=self.hostlist)
def verify_pool_size(self, original_pool_info, ior_args):
"""
Function is to validate the pool size
original_pool_info: Pool info prior to IOR
ior_args: IOR args to calculate the file size
"""
#Get the current pool size for comparison
current_pool_info = self.pool.pool_query()
#if Transfer size is < 4K, Pool size will verified against NVMe, else
#it will be checked against SCM
if ior_args['stripe_size'] >= 4096:
print("Size is > 4K,Size verification will be done with NVMe size")
storage_index = 1
else:
print("Size is < 4K,Size verification will be done with SCM size")
storage_index = 0
free_pool_size = (
original_pool_info.pi_space.ps_space.s_free[storage_index]
- current_pool_info.pi_space.ps_space.s_free[storage_index])
obj_multiplier = 1
replica_number = re.findall(r'\d+', "ior_args['object_class']")
if replica_number:
obj_multiplier = int(replica_number[0])
expected_pool_size = (ior_args['slots'] * ior_args['block_size'] *
obj_multiplier)
if free_pool_size < expected_pool_size:
raise DaosTestError(
'Pool Free Size did not match Actual = {} Expected = {}'
.format(free_pool_size, expected_pool_size))
@avocado.fail_on(DaosApiError)
def test_nvme_io(self):
"""
Test ID: DAOS-2082
Test Description: Test will run IOR with standard and non standard
sizes.IOR will be run for all Object type supported. Purpose is to
verify pool size (SCM and NVMe) for IOR file.
This test is running multiple IOR on same server start instance.
:avocado: tags=nvme,nvme_io,large
"""
ior_args = {}
hostlist_clients = self.params.get("clients", '/run/hosts/*')
tests = self.params.get("ior_sequence", '/run/ior/*')
object_type = self.params.get("object_type", '/run/ior/*')
#Loop for every IOR object type
for obj_type in object_type:
for ior_param in tests:
self.hostfile_clients = write_host_file.write_host_file(
hostlist_clients,
self.workdir,
ior_param[4])
#There is an issue with NVMe if Transfer size>64M, Skipped this
#sizes for now
if ior_param[2] > 67108864:
print ("Xfersize > 64M getting failed, DAOS-1264")
continue
self.pool = DaosPool(self.context)
self.pool.create(self.params.get("mode",
'/run/pool/createmode/*'),
os.geteuid(),
os.getegid(),
ior_param[0],
self.params.get("setname",
'/run/pool/createset/*'),
nvme_size=ior_param[1])
self.pool.connect(1 << 1)
self.pool_connect = True
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'] = 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['iorflags'] = self.params.get("iorflags",
'/run/ior/*')
ior_args['iteration'] = self.params.get("iteration",
'/run/ior/*')
ior_args['stripe_size'] = ior_param[2]
ior_args['block_size'] = ior_param[3]
ior_args['stripe_count'] = self.params.get("stripecount",
'/run/ior/*')
ior_args['async_io'] = self.params.get("asyncio",
'/run/ior/*')
ior_args['object_class'] = obj_type
ior_args['slots'] = ior_param[4]
#IOR is going to use the same --daos.stripeSize,
#--daos.recordSize and Transfer size.
try:
size_before_ior = self.pool.pool_query()
ior_utils.run_ior(ior_args['client_hostfile'],
ior_args['iorflags'],
ior_args['iteration'],
ior_args['block_size'],
ior_args['stripe_size'],
ior_args['pool_uuid'],
ior_args['svc_list'],
ior_args['stripe_size'],
ior_args['stripe_size'],
ior_args['stripe_count'],
ior_args['async_io'],
ior_args['object_class'],
ior_args['basepath'],
ior_args['slots'],
filename=str(uuid.uuid4()),
display_output=True)
self.verify_pool_size(size_before_ior, ior_args)
except ior_utils.IorFailed as exe:
print (exe)
print (traceback.format_exc())
self.fail()
try:
if self.pool_connect:
self.pool.disconnect()
self.pool_connect = False
if self.pool:
self.pool.destroy(1)
except DaosApiError as exe:
print (exe)
self.fail("Failed to Destroy/Disconnect the Pool")
class RebuildNoCap(Test):
"""
Test Class Description:
This class contains tests for pool rebuild.
:avocado: tags=pool,rebuild,nocap
"""
build_paths = []
server_group = ""
CONTEXT = None
POOL = None
hostfile = ""
def setUp(self):
""" setup for the test """
# get paths from the build_vars generated by build
with open('../../../.build_vars.json') as f:
build_paths = json.load(f)
self.CONTEXT = DaosContext(build_paths['PREFIX'] + '/lib/')
# generate a hostfile
self.host_list = self.params.get("test_machines",'/run/hosts/')
tmp = build_paths['PREFIX'] + '/tmp'
self.hostfile = WriteHostFile.WriteHostFile(self.host_list, tmp)
# fire up the DAOS servers
self.server_group = self.params.get("server_group",'/run/server/',
'daos_server')
ServerUtils.runServer(self.hostfile, self.server_group,
build_paths['PREFIX'] + '/../')
time.sleep(3)
# 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 = build_paths['PREFIX'] +\
"/../src/tests/ftest/util/WriteSomeData.py"
cmd = "export DAOS_POOL={0}; export DAOS_SVCL=1; mpirun"\
" --np 1 --host {1} {2} {3} testfile".format(
uuid, self.host_list[0], exepath, how_many_bytes)
subprocess.call(cmd, shell=True)
def tearDown(self):
""" cleanup after the test """
os.remove(self.hostfile)
self.POOL.destroy(1)
ServerUtils.stopServer()
def test_rebuild_no_capacity(self):
"""
:avocado: tags=pool,rebuild,nocap
"""
try:
print "\nsetup complete, starting test\n"
# create a server object that references on of our pool target hosts
# and then kill it
svr_to_kill = int(self.params.get("rank_to_kill",
'/run/testparams/ranks/'))
sh = DaosServer(self.CONTEXT, bytes(self.server_group), svr_to_kill)
time.sleep(1)
sh.kill(1)
# exclude the target from the dead server
self.POOL.exclude([svr_to_kill])
# exclude should trigger rebuild, check
self.POOL.connect(1 << 1)
status = self.POOL.pool_query()
if not status.pi_ntargets == len(self.host_list):
self.fail("target count wrong.\n")
if not status.pi_ndisabled == 1:
self.fail("disabled target count wrong.\n")
# the pool should be too full to start a rebuild so
# expecting an error
# not sure yet specifically what error
if status.pi_rebuild_st[2] == 0:
self.fail("expecting rebuild to fail but it didn't.\n")
except ValueError as e:
print(e)
print(traceback.format_exc())
self.fail("Expecting to pass but test has failed.\n")
def test_simple_rebuild(self):
"""
Test ID: Rebuild-001
Test Description: The most basic rebuild test.
Use Cases:
-- single pool rebuild, single client, various reord/object
counts
:avocado: tags=pool,rebuild,rebuildsimple
"""
try:
# initialize a python pool object then create the underlying
# daos storage
pool = DaosPool(self.context)
pool.create(self.createmode, self.createuid, self.creategid,
self.createsize, self.createsetid)
# want an open connection during rebuild
pool.connect(1 << 1)
# get pool status we want to test later
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")
# create a container
container = DaosContainer(self.context)
container.create(pool.handle)
# now open it
container.open()
saved_data = []
for _objc in range(self.objcount):
obj = None
for _recc in range(self.reccount):
# make some stuff up and write
dkey = (
''.join(random.choice(string.ascii_uppercase +
string.digits) for _ in range(5)))
akey = (
''.join(random.choice(string.ascii_uppercase +
string.digits) for _ in range(5)))
data = (''.join(random.choice(string.ascii_uppercase +
string.digits)
for _ in range(self.size)))
obj, txn = container.write_an_obj(data, len(data), dkey,
akey, obj, self.rank,
obj_cls=16)
saved_data.append((obj, dkey, akey, data, txn))
# read the data back and make sure its correct
data2 = container.read_an_obj(self.size, dkey, akey, obj,
txn)
if data != data2.value:
self.fail("Write data 1, read it back, didn't match\n")
# kill a server that has
server = DaosServer(self.context, self.server_group, self.rank)
server.kill(1)
# temporarily, the exclude of a failed target must be done manually
pool.exclude([self.rank])
while True:
# get the pool/rebuild status again
pool.pool_query()
if pool.pool_info.pi_rebuild_st.rs_done == 1:
break
else:
time.sleep(2)
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 != self.objcount:
self.fail("Rebuilt objs not as expected: {0} {1}"
.format(pool.pool_info.pi_rebuild_st.rs_obj_nr,
self.objcount))
if (pool.pool_info.pi_rebuild_st.rs_rec_nr !=
(self.reccount*self.objcount)):
self.fail("Rebuilt recs not as expected: {0} {1}"
.format(pool.pool_info.pi_rebuild_st.rs_rec_nr,
self.reccount*self.objcount))
# now that the rebuild finished verify the records are correct
for tup in saved_data:
data2 = container.read_an_obj(len(tup[3]), tup[1], tup[2],
tup[0], tup[4])
if tup[3] != data2.value:
self.fail("after rebuild data didn't check out")
except DaosApiError as excp:
print (excp)
print (traceback.format_exc())
self.fail("Expecting to pass but test has failed.\n")
def test_evict(self):
"""
Pass bad parameters to the pool evict clients call.
:avocado: tags=pool,poolevict,badparam,badevict
"""
# parameters used in pool create
createmode = self.params.get("mode",'/run/evicttests/createmode/')
createuid = self.params.get("uid",'/run/evicttests/createuid/')
creategid = self.params.get("gid",'/run/evicttests/creategid/')
createsetid = self.params.get("setname",'/run/evicttests/createset/')
createsize = self.params.get("size",'/run/evicttests/createsize/')
# Accumulate a list of pass/fail indicators representing what is
# expected for each parameter then "and" them to determine the
# expected result of the test
expected_for_param = []
svclist = self.params.get("ranklist",'/run/evicttests/svrlist/*/')
svc = svclist[0]
expected_for_param.append(svclist[1])
setlist = self.params.get("setname",
'/run/evicttests/connectsetnames/*/')
evictset = setlist[0]
expected_for_param.append(setlist[1])
uuidlist = self.params.get("uuid",'/run/evicttests/UUID/*/')
excludeuuid = uuidlist[0]
expected_for_param.append(uuidlist[1])
# if any parameter is FAIL then the test should FAIL, in this test
# virtually everyone should FAIL since we are testing bad parameters
expected_result = 'PASS'
for result in expected_for_param:
if result == 'FAIL':
expected_result = 'FAIL'
break
try:
# setup the DAOS python API
with open('../../../.build_vars.json') as f:
data = json.load(f)
CONTEXT = DaosContext(data['PREFIX'] + '/lib/')
# initialize a python pool object then create the underlying
# daos storage
POOL = DaosPool(CONTEXT)
POOL.create(createmode, createuid, creategid,
createsize, createsetid, None)
# trash the the pool service rank list
if not svc == 'VALID':
rl_ranks = ctypes.POINTER(ctypes.c_uint)()
POOL.svc = RankList(rl_ranks, 1);
# trash the pool group value
if evictset == None:
POOL.group = None
# trash the UUID value in various ways
if excludeuuid == None:
POOL.uuid = None
if excludeuuid == 'JUNK':
POOL.uuid[4] = 244
POOL.evict()
if expected_result in ['FAIL']:
self.fail("Test was expected to fail but it passed.\n")
except ValueError as e:
print e
print traceback.format_exc()
if expected_result in ['PASS']:
self.fail("Test was expected to pass but it failed.\n")
except Exception as e:
self.fail("Daos code segfaulted most likely %s" % e)
class ContainerAttributeTest(Test):
"""
Tests DAOS container attribute get/set/list.
"""
def setUp(self):
self.agent_sessions = None
self.pool = None
self.container = None
self.hostlist = None
self.large_data_set = {}
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')
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(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/attrtests/createmode/*'),
os.geteuid(),
os.getegid(),
self.params.get("size", '/run/attrtests/createsize/*'),
self.params.get("setname",
'/run/attrtests/createset/*'),
None)
self.pool.connect(1 << 1)
poh = self.pool.handle
self.container = DaosContainer(self.context)
self.container.create(poh)
self.container.open()
def tearDown(self):
try:
if self.container:
self.container.close()
finally:
if self.agent_sessions:
AgentUtils.stop_agent(self.hostlist, self.agent_sessions)
server_utils.stop_server(hosts=self.hostlist)
def create_data_set(self):
"""
To create the large attribute dictionary
"""
allchar = string.ascii_letters + string.digits
for i in range(1024):
self.large_data_set[str(i)] = (
"".join(random.choice(allchar)
for x in range(random.randint(1, 100))))
def test_container_attribute(self):
"""
Test basic container attribute tests.
:avocado: tags=container,container_attr,attribute,sync_conattribute
"""
expected_for_param = []
name = self.params.get("name", '/run/attrtests/name_handles/*/')
expected_for_param.append(name[1])
value = self.params.get("value", '/run/attrtests/value_handles/*/')
expected_for_param.append(value[1])
attr_dict = {name[0]:value[0]}
if name[0] is not None:
if "largenumberofattr" in name[0]:
self.create_data_set()
attr_dict = self.large_data_set
attr_dict[name[0]] = value[0]
expected_result = 'PASS'
for result in expected_for_param:
if result == 'FAIL':
expected_result = 'FAIL'
break
try:
self.container.set_attr(data=attr_dict)
size, buf = self.container.list_attr()
verify_list_attr(attr_dict, size, buf)
# Request something that doesn't exist
if name[0] is not None and "Negative" in name[0]:
name[0] = "rubbish"
results = {}
results = self.container.get_attr([name[0]])
# for this test the dictionary has been altered, need to just
# set it to what we are expecting to get back
if name[0] is not None:
if "largenumberofattr" in name[0]:
attr_dict.clear()
attr_dict[name[0]] = value[0]
verify_get_attr(attr_dict, results)
if expected_result in ['FAIL']:
self.fail("Test was expected to fail but it passed.\n")
except (DaosApiError, DaosTestError) as excep:
print(excep)
print(traceback.format_exc())
if expected_result == 'PASS':
self.fail("Test was expected to pass but it failed.\n")
def test_container_attribute_asyn(self):
"""
Test basic container attribute tests.
:avocado: tags=container,container_attr,attribute,async_conattribute
"""
global GLOB_SIGNAL
global GLOB_RC
expected_for_param = []
name = self.params.get("name", '/run/attrtests/name_handles/*/')
expected_for_param.append(name[1])
value = self.params.get("value", '/run/attrtests/value_handles/*/')
expected_for_param.append(value[1])
attr_dict = {name[0]:value[0]}
if name[0] is not None:
if "largenumberofattr" in name[0]:
self.create_data_set()
attr_dict = self.large_data_set
attr_dict[name[0]] = value[0]
expected_result = 'PASS'
for result in expected_for_param:
if result == 'FAIL':
expected_result = 'FAIL'
break
try:
GLOB_SIGNAL = threading.Event()
self.container.set_attr(data=attr_dict, cb_func=cb_func)
GLOB_SIGNAL.wait()
if GLOB_RC != 0 and expected_result in ['PASS']:
self.fail("RC not as expected after set_attr First {0}"
.format(GLOB_RC))
GLOB_SIGNAL = threading.Event()
size, buf = self.container.list_attr(cb_func=cb_func)
GLOB_SIGNAL.wait()
if GLOB_RC != 0 and expected_result in ['PASS']:
self.fail("RC not as expected after list_attr First {0}"
.format(GLOB_RC))
if expected_result in ['PASS']:
verify_list_attr(attr_dict, size, buf, mode="async")
# Request something that doesn't exist
if name[0] is not None and "Negative" in name[0]:
name[0] = "rubbish"
GLOB_SIGNAL = threading.Event()
self.container.get_attr([name[0]], cb_func=cb_func)
GLOB_SIGNAL.wait()
if GLOB_RC != 0 and expected_result in ['PASS']:
self.fail("RC not as expected after get_attr {0}"
.format(GLOB_RC))
# not verifying the get_attr since its not available asynchronously
if value[0] != None:
if GLOB_RC == 0 and expected_result in ['FAIL']:
self.fail("Test was expected to fail but it passed.\n")
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
if expected_result == 'PASS':
self.fail("Test was expected to pass but it failed.\n")
class Permission(Test):
"""
Tests DAOS pool permissions while connect, whether
modifying file with specific permissions work as expected.
:avocado: tags=pool,permission
"""
def setUp(self):
# get paths from the build_vars generated by build
with open('../../../.build_vars.json') as f:
build_paths = json.load(f)
self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
self.tmp = build_paths['PREFIX'] + '/tmp'
self.server_group = self.params.get("server_group", '/server/',
'daos_server')
# setup the DAOS python API
self.Context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.POOL = None
# getting hostfile
hostfile = None
hostlist = self.params.get("test_machines", '/run/hosts/*')
hostfile = WriteHostFile.WriteHostFile(hostlist, self.tmp)
print("Host file is: {}".format(hostfile))
# starting server
ServerUtils.runServer(hostfile, self.server_group, self.basepath)
# give it time to start
time.sleep(2)
def tearDown(self):
if self.POOL is not None and self.POOL.attached:
self.POOL.destroy(1)
# stop servers
ServerUtils.stopServer()
def test_connectpermission(self):
"""
Test pool connections with specific permissions.
:avocado: tags=pool,permission,connectpermission
"""
# parameters used in pool create
createmode = self.params.get("mode", '/run/createtests/createmode/*/')
createuid = self.params.get("uid", '/run/createtests/createuid/')
creategid = self.params.get("gid", '/run/createtests/creategid/')
createsetid = self.params.get("setname", '/run/createtests/createset/')
createsize = self.params.get("size", '/run/createtests/createsize/')
# parameters used for pool connect
permissions = self.params.get("perm", '/run/createtests/permissions/*')
if (createmode in [73, 511] and permissions == 0):
expected_result = 'PASS'
elif (createmode in [146, 511] and permissions == 1):
expected_result = 'PASS'
elif (createmode in [292, 511] and permissions == 2):
expected_result = 'PASS'
else:
expected_result = 'FAIL'
try:
# initialize a python pool object then create the underlying
# daos storage
self.POOL = DaosPool(self.Context)
print("Pool initialisation successful")
self.POOL.create(createmode, createuid, creategid, createsize,
createsetid, None)
print("Pool Creation successful")
self.POOL.connect(1 << permissions)
print("Pool Connect successful")
if expected_result in ['FAIL']:
self.fail("Test was expected to fail but it passed.\n")
except ValueError as e:
print(e)
print(traceback.format_exc())
if expected_result == 'PASS':
self.fail("Test was expected to pass but it failed.\n")
finally:
if hostfile is not None:
os.remove(hostfile)
# cleanup the pool
self.POOL.disconnect()
self.POOL.destroy(1)
self.POOL = None
def test_filemodification(self):
"""
Test whether file modification happens as expected under different
permission levels.
:avocado: tags=pool,permission,filemodification
"""
# parameters used in pool create
createmode = self.params.get("mode", '/run/createtests/createmode/*/')
createuid = self.params.get("uid", '/run/createtests/createuid/')
creategid = self.params.get("gid", '/run/createtests/creategid/')
createsetid = self.params.get("setname", '/run/createtests/createset/')
createsize = self.params.get("size", '/run/createtests/createsize/')
if createmode == 73:
permissions = 0
expected_result = 'FAIL'
elif createmode in [146, 511]:
permissions = 1
expected_result = 'PASS'
elif createmode == 292:
permissions = 2
expected_result = 'PASS'
try:
# initialize a python pool object then create the underlying
# daos storage
self.POOL = DaosPool(self.Context)
print("Pool initialisation successful")
self.POOL.create(createmode, createuid, creategid, createsize,
createsetid, None)
print("Pool Creation successful")
self.POOL.connect(1 << permissions)
print("Pool Connect successful")
self.CONTAINER = DaosContainer(self.Context)
print("Contianer initialisation successful")
self.CONTAINER.create(self.POOL.handle)
print("Container create successful")
# now open it
self.CONTAINER.open()
print("Container open successful")
thedata = "a string that I want to stuff into an object"
size = 45
dkey = "this is the dkey"
akey = "this is the akey"
self.CONTAINER.write_an_obj(thedata, size, dkey, akey)
print("Container write successful")
if expected_result in ['FAIL']:
self.fail("Test was expected to fail but it passed.\n")
except ValueError as e:
print(e)
print(traceback.format_exc())
if expected_result == 'PASS':
self.fail("Test was expected to pass but it failed.\n")
finally:
if hostfile is not None:
os.remove(hostfile)
# cleanup the container and pool
self.CONTAINER.close()
self.CONTAINER.destroy()
self.POOL.disconnect()
self.POOL.destroy(1)
self.POOL = None
class EightServers(Test):
"""
Test class Description: Runs IOR with 8 servers.
"""
def __init__(self, *args, **kwargs):
super(EightServers, self).__init__(*args, **kwargs)
self.basepath = None
self.server_group = None
self.context = None
self.pool = None
self.num_procs = None
self.hostlist_servers = None
self.hostfile_servers = None
self.hostlist_clients = None
self.hostfile_clients = None
self.mpio = None
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 tearDown(self):
try:
if self.pool is not None and self.pool.attached:
self.pool.destroy(1)
finally:
server_utils.stop_server(hosts=self.hostlist_servers)
def executable(self, iorflags=None):
"""
Executable function to run ior for ssf and fpp
"""
# 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/')
createscm_size = self.params.get("scm_size", '/run/pool/createsize/')
createnvme_size = self.params.get("nvme_size", '/run/pool/createsize/')
createsvc = self.params.get("svcn", '/run/pool/createsvc/')
iteration = self.params.get("iter", '/run/ior/iteration/')
block_size = self.params.get("b", '/run/ior/transfersize_blocksize/*/')
transfer_size = self.params.get("t",
'/run/ior/transfersize_blocksize/*/')
try:
# initialize MpioUtils
self.mpio = MpioUtils()
if self.mpio.mpich_installed(self.hostlist_clients) is False:
self.fail("Exiting Test: Mpich not installed")
#print self.mpio.mpichinstall
# initialize a python pool object then create the underlying
# daos storage
self.pool = DaosPool(self.context)
self.pool.create(createmode, createuid, creategid,
createscm_size, createsetid, None, None, createsvc,
createnvme_size)
pool_uuid = self.pool.get_uuid_str()
svc_list = ""
for i in range(createsvc):
svc_list += str(int(self.pool.svc.rl_ranks[i])) + ":"
svc_list = svc_list[:-1]
print ("svc_list: {}".format(svc_list))
ior_utils.run_ior_mpiio(self.basepath, self.mpio.mpichinstall,
pool_uuid, svc_list, self.num_procs,
self.hostfile_clients, iorflags, iteration,
transfer_size, block_size, True)
except (DaosApiError, MpioFailed) as excep:
print(excep)
def test_ssf(self):
"""
Test ID: DAOS-2121
Test Description: Run IOR with 1,64 and 128 clients config in ssf mode.
Use Cases: Different combinations of 1/64/128 Clients,
1K/4K/32K/128K/512K/1M transfersize and block size of 32M
for 1K transfer size and 128M for rest.
:avocado: tags=ior,mpiio,eightservers,ior_ssf
"""
ior_flags = self.params.get("F", '/run/ior/iorflags/ssf/')
self.executable(ior_flags)
def test_fpp(self):
"""
Test ID: DAOS-2121
Test Description: Run IOR with 1,64 and 128 clients config in fpp mode.
Use Cases: Different combinations of 1/64/128 Clients,
1K/4K/32K/128K/512K/1M transfersize and block size of 32M
for 1K transfer size and 128M for rest.
:avocado: tags=ior,mpiio,eightservers,ior_fpp
"""
ior_flags = self.params.get("F", '/run/ior/iorflags/fpp/')
self.executable(ior_flags)
def test_create(self):
"""
Pass bad parameters to pool create.
:avocado: tags=pool,poolcreate,badparam,badcreate
"""
# Accumulate a list of pass/fail indicators representing what is
# expected for each parameter then "and" them to determine the
# expected result of the test
expected_for_param = []
modelist = self.params.get("mode", '/run/createtests/modes/*')
mode = modelist[0]
expected_for_param.append(modelist[1])
uidlist = self.params.get("uid", '/run/createtests/uids/*')
uid = uidlist[0]
expected_for_param.append(uidlist[1])
gidlist = self.params.get("gid", '/run/createtests/gids/*')
gid = gidlist[0]
expected_for_param.append(gidlist[1])
setidlist = self.params.get("setname", '/run/createtests/setnames/*')
if setidlist[0] == 'NULL':
group = None
else:
group = setidlist[0]
expected_for_param.append(setidlist[1])
targetlist = self.params.get("rankptr", '/run/createtests/target/*')
if targetlist[0] == 'NULL':
targetptr = None
else:
targetptr = [0]
expected_for_param.append(targetlist[1])
# not ready for this yet
#devicelist = self.params.get("devptr", '/run/createtests/device/*')
#if devicelist[0] == 'NULL':
# devptr = None
#else:
# devptr = devicelist[0]
#expected_for_param.append(devicelist[1])
sizelist = self.params.get("size", '/run/createtests/psize/*')
size = sizelist[0]
expected_for_param.append(sizelist[1])
# parameter not presently supported
#svclist = self.params.get("rankptr", '/run/createtests/svc/*')
#if svclist[0] == 'NULL':
# svc = None
#else:
# svc = None
#expected_for_param.append(devicelist[1])
# if any parameter is FAIL then the test should FAIL, in this test
# virtually everyone should FAIL since we are testing bad parameters
expected_result = 'PASS'
for result in expected_for_param:
if result == 'FAIL':
expected_result = 'FAIL'
break
try:
# setup the DAOS python API
with open('../../../.build_vars.json') as f:
data = json.load(f)
CONTEXT = DaosContext(data['PREFIX'] + '/lib/')
# initialize a python pool object then create the underlying
# daos storage
POOL = DaosPool(CONTEXT)
POOL.create(mode, uid, gid, size, group, targetptr)
if expected_result in ['FAIL']:
self.fail("Test was expected to fail but it passed.\n")
except DaosApiError as e:
print(e)
print(traceback.format_exc())
if expected_result == 'PASS':
self.fail("Test was expected to pass but it failed.\n")
finally:
if POOL is not None and POOL.attached:
POOL.destroy(1)
class OpenContainerTest(Test):
"""
Tests DAOS container bad create (non existing pool handle, bad uuid)
and close.
:avocado: tags=container,containeropen
"""
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.pool1 = None
self.pool2 = None
self.container1 = None
self.container2 = None
self.hostfile = None
self.hostlist = self.params.get("test_machines", '/run/hosts/*')
self.hostfile = write_host_file.write_host_file(self.hostlist,
self.workdir)
# common parameters used in pool create
self.createmode = self.params.get("mode",
'/run/createtests/createmode/')
self.createsetid = self.params.get("setname",
'/run/createtests/createset/')
self.createsize = self.params.get("size",
'/run/createtests/createsize/')
# pool 1 UID GID
self.createuid1 = self.params.get("uid", '/run/createtests/createuid1/')
self.creategid1 = self.params.get("gid", '/run/createtests/creategid1/')
# pool 2 UID GID
self.createuid2 = self.params.get("uid", '/run/createtests/createuid2/')
self.creategid2 = self.params.get("gid", '/run/createtests/creategid2/')
self.agent_sessions = AgentUtils.run_agent(self.basepath, self.hostlist)
server_utils.run_server(self.hostfile, self.server_group, self.basepath)
def tearDown(self):
try:
if self.container1 is not None:
self.container1.destroy()
if self.container2 is not None:
self.container2.destroy()
if self.pool1 is not None and self.pool1.attached:
self.pool1.destroy(1)
if self.pool2 is not None and self.pool2.attached:
self.pool2.destroy(1)
finally:
if self.agent_sessions:
AgentUtils.stop_agent(self.hostlist, self.agent_sessions)
server_utils.stop_server(hosts=self.hostlist)
def test_container_open(self):
"""
Test basic container bad create.
:avocado: tags=container,containeropen
"""
container_uuid = None
expected_for_param = []
uuidlist = self.params.get("uuid", '/run/createtests/uuids/*/')
container_uuid = uuidlist[0]
expected_for_param.append(uuidlist[1])
pohlist = self.params.get("poh", '/run/createtests/handles/*/')
poh = pohlist[0]
expected_for_param.append(pohlist[1])
expected_result = 'PASS'
for result in expected_for_param:
if result == 'FAIL':
expected_result = 'FAIL'
break
try:
# create two pools and try to create containers in these pools
self.pool1 = DaosPool(self.context)
self.pool1.create(self.createmode, self.createuid1, self.creategid1,
self.createsize, self.createsetid, None)
self.pool2 = DaosPool(self.context)
self.pool2.create(self.createmode, self.createuid2, self.creategid2,
self.createsize, None, None)
# Connect to the pools
self.pool1.connect(1 << 1)
self.pool2.connect(1 << 1)
# defines pool handle for container open
if pohlist[0] == 'pool1':
poh = self.pool1.handle
else:
poh = self.pool2.handle
# Create a container in pool1
self.container1 = DaosContainer(self.context)
self.container1.create(self.pool1.handle)
# defines test UUID for container open
if uuidlist[0] == 'pool1':
struuid = self.container1.get_uuid_str()
container_uuid = uuid.UUID(struuid)
else:
if uuidlist[0] == 'MFUUID':
container_uuid = "misformed-uuid-0000"
else:
container_uuid = uuid.uuid4() # random uuid
# tries to open the container1
# open should be ok only if poh = pool1.handle &&
# containerUUID = container1.uuid
self.container1.open(poh, container_uuid)
# wait a few seconds and then destroy containers
time.sleep(5)
self.container1.close()
self.container1.destroy()
self.container1 = None
# cleanup the pools
self.pool1.disconnect()
self.pool1.destroy(1)
self.pool1 = None
self.pool2.disconnect()
self.pool2.destroy(1)
self.pool2 = None
if expected_result in ['FAIL']:
self.fail("Test was expected to fail but it passed.\n")
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
if expected_result == 'PASS':
self.fail("Test was expected to pass but it failed.\n")
finally:
if self.hostfile is not None:
os.remove(self.hostfile)
def test_null_values(self):
"""
Test ID: DAOS-1376
Test Description: Pass a dkey and an akey that is null.
:avocado: tags=object,objupdate,objupdatenull,regression,vm,small
"""
try:
# parameters used in pool create
createmode = self.params.get("mode", '/run/conttests/createmode/')
createsetid = self.params.get("setname",
'/run/conttests/createset/')
createsize = self.params.get("size", '/run/conttests/createsize/')
createuid = os.geteuid()
creategid = os.getegid()
# initialize a python pool object then create the underlying
# daos storage
pool = DaosPool(self.Context)
pool.create(createmode, createuid, creategid, createsize,
createsetid, None)
self.pl.info("Pool %s created.", pool.get_uuid_str())
# need a connection to create container
pool.connect(1 << 1)
# create a container
container = DaosContainer(self.Context)
container.create(pool.handle)
self.pl.info("Container %s created.", container.get_uuid_str())
# now open it
container.open()
# data used in the test
thedata = "a string that I want to stuff into an object"
thedatasize = len(thedata) + 1
except ValueError as e:
print e
print traceback.format_exc()
self.fail("Test failed during setup .\n")
try:
# try using a null dkey
dkey = None
akey = "this is the akey"
obj, epoch = container.write_an_obj(thedata, thedatasize, dkey,
akey)
container.close()
container.destroy()
pool.disconnect()
pool.destroy(1)
self.pl.error("Didn't get expected return code.")
self.fail("Test was expected to return a -1003 but it has not.\n")
except ValueError as e:
if not '-1003' in str(e):
container.close()
container.destroy()
pool.disconnect()
pool.destroy(1)
self.pl.error("Didn't get expected return code.")
print e
print traceback.format_exc()
self.fail("Test was expected to get -1003 but it has not.\n")
try:
# try using a null akey/io descriptor
dkey = "this is the dkey"
akey = None
obj, epoch = container.write_an_obj(thedata, thedatasize, dkey,
akey)
self.fail("Test was expected to return a -1003 but it has not.\n")
except ValueError as e:
if not '-1003' in str(e):
self.pl.error("Didn't get expected return code.")
print e
print traceback.format_exc()
self.fail("Test was expected to get -1003 but it has not.\n")
try:
# lastly try passing no data
thedata = None
thedatasize = 0
dkey = "this is the dkey"
akey = "this is the akey"
obj, epoch = container.write_an_obj(thedata, thedatasize, dkey,
akey)
self.pl.info("Update with no data worked")
except ValueError as e:
container.close()
container.destroy()
pool.disconnect()
pool.destroy(1)
print e
print traceback.format_exc()
self.pl.error("Update with no data failed")
self.fail("Update with no data failed.\n")
container.close()
container.destroy()
pool.disconnect()
pool.destroy(1)
self.pl.info("Test Complete")
class DeleteContainerTest(Test):
"""
Tests DAOS container delete and close.
"""
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 tearDown(self):
if self.agent_sessions:
AgentUtils.stop_agent(self.hostlist, self.agent_sessions)
server_utils.stop_server(hosts=self.hostlist)
def test_container_delete(self):
"""
Test basic container delete
:avocado: tags=regression,cont,vm,contdelete
"""
expected_for_param = []
uuidlist = self.params.get("uuid",
'/run/createtests/ContainerUUIDS/*/')
cont_uuid = uuidlist[0]
expected_for_param.append(uuidlist[1])
pohlist = self.params.get("poh", '/run/createtests/PoolHandles/*/')
poh = pohlist[0]
expected_for_param.append(pohlist[1])
openlist = self.params.get("opened",
"/run/createtests/ConnectionOpened/*/")
opened = openlist[0]
expected_for_param.append(openlist[1])
forcelist = self.params.get("force", "/run/createtests/ForceDestroy/*/")
force = forcelist[0]
expected_for_param.append(forcelist[1])
if force >= 1:
self.cancel("Force >= 1 blocked by issue described in "
"https://jira.hpdd.intel.com/browse/DAOS-689")
if force == 0:
self.cancel("Force = 0 blocked by "
"https://jira.hpdd.intel.com/browse/DAOS-1935")
expected_result = 'PASS'
for result in expected_for_param:
if result == 'FAIL':
expected_result = 'FAIL'
break
try:
# initialize a python pool object then create the underlying
# daos storage
self.pool = DaosPool(self.context)
self.pool.create(self.createmode, self.createuid, self.creategid,
self.createsize, self.createsetid, None)
# need a connection to create container
self.pool.connect(1 << 1)
self.container = DaosContainer(self.context)
# create should always work (testing destroy)
if not cont_uuid == 'INVALID':
cont_uuid = uuid.UUID(uuidlist[0])
self.container.create(self.pool.handle, cont_uuid)
else:
self.container.create(self.pool.handle)
# Opens the container if required
if opened:
self.container.open(self.pool.handle)
# wait a few seconds and then attempts to destroy container
time.sleep(5)
if poh == 'VALID':
poh = self.pool.handle
# if container is INVALID, overwrite with non existing UUID
if cont_uuid == 'INVALID':
cont_uuid = uuid.uuid4()
self.container.destroy(force=force, poh=poh, con_uuid=cont_uuid)
self.container = None
if expected_result in ['FAIL']:
self.fail("Test was expected to fail but it passed.\n")
except DaosApiError as excep:
self.d_log.error(excep)
self.d_log.error(traceback.format_exc())
if expected_result == 'PASS':
self.fail("Test was expected to pass but it failed.\n")
finally:
# clean up the pool
if self.pool is not None:
self.pool.destroy(1)
self.pool = None
def test_bad_handle(self):
"""
Test ID: DAOS-1376
Test Description: Pass a bogus object handle, should return bad handle.
:avocado: tags=object,objupdate,objbadhand,regression,vm,small
"""
try:
# parameters used in pool create
createmode = self.params.get("mode", '/run/conttests/createmode/')
createsetid = self.params.get("setname",
'/run/conttests/createset/')
createsize = self.params.get("size", '/run/conttests/createsize/')
createuid = os.geteuid()
creategid = os.getegid()
# initialize a python pool object then create the underlying
# daos storage
pool = DaosPool(self.Context)
pool.create(createmode, createuid, creategid, createsize,
createsetid, None)
self.pl.info("Pool %s created.", pool.get_uuid_str())
# need a connection to create container
pool.connect(1 << 1)
# create a container
container = DaosContainer(self.Context)
container.create(pool.handle)
self.pl.info("Container %s created.", container.get_uuid_str())
# now open it
container.open()
# create an object and write some data into it
thedata = "a string that I want to stuff into an object"
thedatasize = len(thedata) + 1
dkey = "this is the dkey"
akey = "this is the akey"
obj, epoch = container.write_an_obj(thedata, thedatasize, dkey,
akey)
saved_oh = obj.oh
obj.oh = 99999
obj, epoch = container.write_an_obj(thedata, thedatasize, dkey,
akey, obj)
container.oh = saved_oh
container.close()
container.destroy()
pool.disconnect()
pool.destroy(1)
self.fail("Test was expected to return a -1002 but it has not.\n")
except ValueError as e:
container.oh = saved_oh
container.close()
container.destroy()
pool.disconnect()
pool.destroy(1)
self.pl.info("Test Complete")
if not '-1002' in str(e):
print e
print traceback.format_exc()
self.fail("Test was expected to get -1002 but it has not.\n")
def test_destroy_recreate(self):
"""
Test destroy and recreate one right after the other multiple times
Should fail.
:avocado: tags=pool,pooldestroy,destroyredo
"""
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)
# blow it away immediately
pool.destroy(1)
# now recreate
pool.create(createmode, createuid, creategid,
createsize, createsetid, None)
# blow it away immediately
pool.destroy(1)
# now recreate
pool.create(createmode, createuid, creategid,
createsize, createsetid, None)
# blow it away immediately
pool.destroy(1)
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
self.fail("create/destroy/create/destroy 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 test_exclude(self):
"""
Pass bad parameters to pool connect
:avocado: tags=pool,poolexclude,badparam,badexclude
"""
# 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()
# Accumulate a list of pass/fail indicators representing what is
# expected for each parameter then "and" them to determine the
# expected result of the test
expected_for_param = []
tgtlist = self.params.get("ranklist", '/run/testparams/tgtlist/*/')
targets = []
if tgtlist[0] == "NULLPTR":
targets = None
self.cancel("skipping null pointer test until DAOS-1929 is fixed")
else:
targets.append(tgtlist[0])
expected_for_param.append(tgtlist[1])
svclist = self.params.get("ranklist", '/run/testparams/svrlist/*/')
svc = svclist[0]
expected_for_param.append(svclist[1])
setlist = self.params.get("setname",
'/run/testparams/connectsetnames/*/')
connectset = setlist[0]
expected_for_param.append(setlist[1])
uuidlist = self.params.get("uuid", '/run/testparams/UUID/*/')
excludeuuid = uuidlist[0]
expected_for_param.append(uuidlist[1])
# if any parameter is FAIL then the test should FAIL, in this test
# virtually everyone should FAIL since we are testing bad parameters
expected_result = 'PASS'
for result in expected_for_param:
if result == 'FAIL':
expected_result = 'FAIL'
break
saved_svc = None
saved_grp = None
saved_uuid = None
pool = None
try:
# setup the DAOS python API
with open('../../../.build_vars.json') as f:
data = json.load(f)
context = DaosContext(data['PREFIX'] + '/lib/')
# initialize a python pool object then create the underlying
# daos storage
pool = DaosPool(context)
pool.create(createmode, createuid, creategid, createsize,
createsetid, None)
# trash the the pool service rank list
if not svc == 'VALID':
self.cancel("skipping this test until DAOS-1931 is fixed")
saved_svc = RankList(pool.svc.rl_ranks, pool.svc.rl_nr)
pool.svc = None
# trash the pool group value
if connectset == 'NULLPTR':
saved_grp = pool.group
pool.group = None
# trash the UUID value in various ways
if excludeuuid == 'NULLPTR':
self.cancel("skipping this test until DAOS-1932 is fixed")
ctypes.memmove(saved_uuid, pool.uuid, 16)
pool.uuid = 0
if excludeuuid == 'CRAP':
self.cancel("skipping this test until DAOS-1932 is fixed")
ctypes.memmove(saved_uuid, pool.uuid, 16)
pool.uuid[4] = 244
pool.exclude(targets)
if expected_result in ['FAIL']:
self.fail("Test was expected to fail but it passed.\n")
except DaosApiError as e:
print(e)
print(traceback.format_exc())
if expected_result in ['PASS']:
self.fail("Test was expected to pass but it failed.\n")
finally:
if pool is not None:
if saved_svc is not None:
pool.svc = saved_svc
if saved_grp is not None:
pool.group = saved_grp
if saved_uuid is not None:
ctypes.memmove(pool.uuid, saved_uuid, 16)
pool.destroy(1)
def test_destroy_withdata(self):
"""
Test destroy and recreate one right after the other multiple times
Should fail.
:avocado: tags=pool,pooldestroy,destroydata
"""
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)
# create a container
container = DaosContainer(self.context)
container.create(pool.handle)
pool.disconnect()
daosctl = self.basepath + '/install/bin/daosctl'
write_cmd = ('{0} write-pattern -i {1} -l 0 -c {2} -p sequential'.
format(daosctl, c_uuid_to_str(pool.uuid),
c_uuid_to_str(container.uuid)))
process.system_output(write_cmd)
# blow it away
pool.destroy(1)
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
self.fail("create/destroy/create/destroy 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)
class OpenClose(Test):
"""
Tests DAOS container open/close function with handle parameter.
"""
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 f:
build_paths = json.load(f)
self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
self.server_group = self.params.get("server_group", '/server/',
'daos_server')
# setup the DAOS python API
self.Context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.hostfile = WriteHostFile.WriteHostFile(self.hostlist,
self.workdir)
ServerUtils.runServer(self.hostfile, self.server_group, self.basepath)
def tearDown(self):
try:
if self.pool is not None and self.pool.attached:
self.pool.destroy(1)
finally:
try:
ServerUtils.stopServer(hosts=self.hostlist)
except ServerFailed as e:
pass
def test_closehandle(self):
"""
Test container close function with container handle paramter.
:avocado: tags=container,openclose,closehandle
"""
saved_coh = None
# 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/')
coh_params = self.params.get("coh",
'/run/container/container_handle/*/')
expected_result = coh_params[1]
try:
# 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)
poh = self.pool.handle
self.pool.connect(1 << 1)
# Container initialization and creation
self.Container1 = DaosContainer(self.Context)
self.Container1.create(poh)
str_cuuid = self.Container1.get_uuid_str()
cuuid = uuid.UUID(str_cuuid)
self.Container1.open(poh, cuuid, 2, None)
# Defining 'good' and 'bad' container handles
saved_coh = self.Container1.coh
if coh_params[0] == 'GOOD':
coh = self.Container1.coh
else:
# create a second container, open to get a handle
# then close & destroy so handle is invalid
self.Container2 = DaosContainer(self.Context)
self.Container2.create(poh)
self.Container2.open(poh, cuuid, 2, None)
coh = self.Container2.coh
self.Container2.close()
self.Container2.destroy()
# close container with either good or bad handle
self.Container1.close(coh)
if expected_result in ['FAIL']:
self.fail("Test was expected to fail but it passed.\n")
except DaosApiError as e:
if expected_result == 'PASS':
print(e)
print(traceback.format_exc())
self.fail("Test was expected to pass but it failed.\n")
# close above failed so close for real with the right coh
if saved_coh is not None:
self.Container1.close(saved_coh)
finally:
self.Container1.destroy(1)
self.pool.disconnect()
self.pool.destroy(1)
self.pool = None
class ObjectMetadata(avocado.Test):
"""
Test Class Description:
Test the general Metadata operations and boundary conditions.
"""
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 tearDown(self):
try:
if self.pool_connect:
self.pool.disconnect()
if self.pool:
self.pool.destroy(1)
finally:
if self.agent_sessions:
AgentUtils.stop_agent(self.hostlist_clients,
self.agent_sessions)
server_utils.stop_server(hosts=self.hostlist)
@avocado.skip("Skipping until DAOS-1936/DAOS-1946 is fixed.")
def test_metadata_fillup(self):
"""
Test ID: DAOS-1512
Test Description: Test to verify no IO happens after metadata is full.
:avocado: tags=metadata,metadata_fill,nvme,small
"""
self.pool.connect(2)
container = DaosContainer(self.context)
self.d_log.debug("Fillup Metadata....")
for _cont in range(NO_OF_MAX_CONTAINER):
container.create(self.pool.handle)
self.d_log.debug("Metadata Overload...")
#This should fail with no Metadata space Error.
try:
for _cont in range(250):
container.create(self.pool.handle)
except DaosApiError as exe:
print (exe, traceback.format_exc())
return
self.fail("Test was expected to fail but it passed.\n")
@avocado.skip("Skipping until DAOS-1965 is fixed.")
@avocado.fail_on(DaosApiError)
def test_metadata_addremove(self):
"""
Test ID: DAOS-1512
Test Description: Verify metadata release the space
after container delete.
:avocado: tags=metadata,metadata_free_space,nvme,small
"""
self.pool.connect(2)
for k in range(10):
container_array = []
self.d_log.debug("Container Create Iteration {}".format(k))
for cont in range(NO_OF_MAX_CONTAINER):
container = DaosContainer(self.context)
container.create(self.pool.handle)
container_array.append(container)
self.d_log.debug("Container Remove Iteration {} ".format(k))
for cont in container_array:
cont.destroy()
def thread_control(self, threads, operation):
"""
Start threads and wait till all threads execution is finished.
It check queue for "FAIL" message and fail the avocado test.
"""
self.d_log.debug("IOR {0} Threads Started -----".format(operation))
for thrd in threads:
thrd.start()
for thrd in threads:
thrd.join()
while not self.out_queue.empty():
if self.out_queue.get() == "FAIL":
return "FAIL"
self.d_log.debug("IOR {0} Threads Finished -----".format(operation))
return "PASS"
@avocado.fail_on(DaosApiError)
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'] = 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:
AgentUtils.stop_agent(self.hostlist_clients, self.agent_sessions)
server_utils.stop_server(hosts=self.hostlist)
self.agent_sessions = AgentUtils.run_agent(self.basepath,
self.hostlist_clients,
self.hostlist)
server_utils.run_server(self.hostfile, 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")
class ObjFetchBadParam(Test):
"""
Test Class Description:
Pass an assortment of bad parameters to the daos_obj_fetch function.
"""
def setUp(self):
self.pl = logging.getLogger("progress")
# get paths from the build_vars generated by build
with open('../../../.build_vars.json') as f:
build_paths = json.load(f)
self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
self.tmp = build_paths['PREFIX'] + '/tmp'
self.server_group = self.params.get("server_group", '/server/',
'daos_server')
# setup the DAOS python API
self.Context = DaosContext(build_paths['PREFIX'] + '/lib/')
hostlist = self.params.get("test_machines", '/run/hosts/*')
self.hostfile = WriteHostFile.WriteHostFile(hostlist, self.tmp)
ServerUtils.runServer(self.hostfile, self.server_group, self.basepath)
time.sleep(5)
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 python 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()
# create an object and write some data into it
thedata = "a string that I want to stuff into an object"
self.datasize = len(thedata) + 1
self.dkey = "this is the dkey"
self.akey = "this is the akey"
self.obj, self.epoch = self.container.write_an_obj(
thedata, self.datasize, self.dkey, self.akey)
thedata2 = self.container.read_an_obj(self.datasize, self.dkey,
self.akey, self.obj,
self.epoch)
if thedata not in thedata2.value:
print(thedata)
print(thedata2.value)
self.fail("Error reading back data, test failed during"\
" the initial setup.\n")
except ValueError as e:
print(e)
print traceback.format_exc()
self.fail("Test failed during the initial setup.\n")
def tearDown(self):
self.container.close()
self.container.destroy()
self.pool.disconnect()
self.pool.destroy(1)
ServerUtils.stopServer()
if self.hostfile is not None:
os.remove(self.hostfile)
def test_bad_handle(self):
"""
Test ID: DAOS-1377
Test Description: Pass a bogus object handle, should return bad handle.
:avocado: tags=object,objfetch,objfetchbadhand,regression,vm,small
"""
try:
# trash the handle and read again
saved_oh = self.obj.oh
self.obj.oh = 99999
# expecting this to fail with -1002
thedata2 = self.container.read_an_obj(self.datasize, self.dkey,
self.akey, self.obj,
self.epoch)
self.container.oh = saved_oh
self.fail("Test was expected to return a -1002 but it has not.\n")
except ValueError as e:
self.container.oh = saved_oh
if not '-1002' in str(e):
print(e)
print(traceback.format_exc())
self.fail("Test was expected to get -1002 but it has not.\n")
def test_null_ptrs(self):
"""
Test ID: DAOS-1377
Test Description: Pass null pointers for various fetch parameters.
:avocado: tags=object,objfetch,objfetchnull,regression,vm,small
"""
try:
# now try it with a bad dkey, expecting this to fail with -1003
thedata2 = self.container.read_an_obj(self.datasize, None,
self.akey, self.obj,
self.epoch)
self.container.close()
self.container.destroy()
self.pool.disconnect()
self.pool.destroy(1)
self.fail("Test was expected to return a -1003 but it has not.\n")
except ValueError as e:
if not '-1003' in str(e):
print(e)
print(traceback.format_exc())
self.fail("Test was expected to get -1003 but it has not.\n")
try:
# now try it with a null sgl, expecting this to fail with -1003
test_hints = ['sglnull']
thedata2 = self.container.read_an_obj(self.datasize, self.dkey,
self.akey, self.obj,
self.epoch, test_hints)
# behavior not as expect so commented out for now
# when DAOS-1448 is complete, uncomment and retest
#self.fail("Test was expected to return a -1003 but it has not.\n")
except ValueError as e:
if not '-1003' in str(e):
print(e)
print(traceback.format_exc())
self.fail("Test was expected to get -1003 but it has not.\n")
try:
# when DAOS-1449 is complete, uncomment and retest
# now try it with a null iod, expecting this to fail with -1003
#test_hints = ['iodnull']
#thedata2 = self.container.read_an_obj(self.datasize, dkey, akey,
# self.obj, self.epoch, test_hints)
pass
#self.fail("Test was expected to return a -1003 but it has not.\n")
except ValueError as e:
if not '-1003' in str(e):
print(e)
print(traceback.format_exc())
self.fail("Test was expected to get -1003 but it has not.\n")
class FullPoolContainerCreate(Test):
"""
Class for test to create a container in a pool with no remaining free space.
"""
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 tearDown(self):
# shut 'er down
"""
wrap pool destroy in a try; in case pool create didn't succeed, we
still need the server to be shut down in any case
"""
try:
self.pool.destroy(1)
finally:
if self.agent_sessions:
AgentUtils.stop_agent(self.hostlist, self.agent_sessions)
server_utils.stop_server(hosts=self.hostlist)
def test_no_space_cont_create(self):
"""
:avocado: tags=pool,cont,fullpoolcontcreate,small,vm
"""
# full storage rc
err = "-1007"
# probably should be -1007, revisit later
err2 = "-1009"
# create pool
mode = self.params.get("mode", '/conttests/createmode/')
self.d_log.debug("mode is {0}".format(mode))
uid = os.geteuid()
gid = os.getegid()
# 16 mb pool, minimum size currently possible
size = 16777216
self.d_log.debug("creating pool")
self.pool.create(mode, uid, gid, size, self.server_group, None)
self.d_log.debug("created pool")
# connect to the pool
self.d_log.debug("connecting to pool")
self.pool.connect(1 << 1)
self.d_log.debug("connected to pool")
# query the pool
self.d_log.debug("querying pool info")
dummy_pool_info = self.pool.pool_query()
self.d_log.debug("queried pool info")
# create a container
try:
self.d_log.debug("creating container")
self.cont = DaosContainer(self.context)
self.cont.create(self.pool.handle)
self.d_log.debug("created container")
except DaosApiError as excep:
self.d_log.error("caught exception creating container: "
"{0}".format(excep))
self.fail("caught exception creating container: {0}".format(excep))
self.d_log.debug("opening container")
self.cont.open()
self.d_log.debug("opened container")
# generate random dkey, akey each time
# write 1mb until no space, then 1kb, etc. to fill pool quickly
for obj_sz in [1048576, 1024, 1]:
write_count = 0
while True:
self.d_log.debug("writing obj {0}, sz {1} to "
"container".format(write_count, obj_sz))
my_str = "a" * obj_sz
my_str_sz = obj_sz
dkey = (
''.join(random.choice(string.lowercase) for i in range(5)))
akey = (
''.join(random.choice(string.lowercase) for i in range(5)))
try:
dummy_oid, dummy_tx = self.cont.write_an_obj(my_str,
my_str_sz,
dkey, akey,
obj_cls=1)
self.d_log.debug("wrote obj {0}, sz {1}".format(write_count,
obj_sz))
write_count += 1
except DaosApiError as excep:
if not (err in repr(excep) or err2 in repr(excep)):
self.d_log.error("caught exception while writing "
"object: {0}".format(repr(excep)))
self.fail("caught exception while writing object: {0}"
.format(repr(excep)))
else:
self.d_log.debug("pool is too full for {0} byte "
"objects".format(obj_sz))
break
self.d_log.debug("closing container")
self.cont.close()
self.d_log.debug("closed container")
# create a 2nd container now that pool is full
try:
self.d_log.debug("creating 2nd container")
self.cont2 = DaosContainer(self.context)
self.cont2.create(self.pool.handle)
self.d_log.debug("created 2nd container")
self.d_log.debug("opening container 2")
self.cont2.open()
self.d_log.debug("opened container 2")
self.d_log.debug("writing one more object, write expected to fail")
self.cont2.write_an_obj(my_str, my_str_sz, dkey, akey, obj_cls=1)
self.d_log.debug("wrote one more object--this should never print")
except DaosApiError as excep:
if not (err in repr(excep) or err2 in repr(excep)):
self.d_log.error("caught unexpected exception while "
"writing object: {0}".format(repr(excep)))
self.fail("caught unexpected exception while writing "
"object: {0}".format(repr(excep)))
else:
self.d_log.debug("correctly caught -1007 while attempting "
"to write object in full pool")
def test_evict(self):
"""
Test ID: DAOS-427
Test Description: Pass bad parameters to the pool evict clients call.
:avocado: tags=all,pool,full_regression,tiny,badevict
"""
# parameters used in pool create
createmode = self.params.get("mode", '/run/evicttests/createmode/')
createsetid = self.params.get("setname", '/run/evicttests/createset/')
createsize = self.params.get("size", '/run/evicttests/createsize/')
createuid = os.geteuid()
creategid = os.getegid()
# Accumulate a list of pass/fail indicators representing what is
# expected for each parameter then "and" them to determine the
# expected result of the test
expected_for_param = []
svclist = self.params.get("ranklist", '/run/evicttests/svrlist/*/')
svc = svclist[0]
expected_for_param.append(svclist[1])
setlist = self.params.get("setname",
'/run/evicttests/connectsetnames/*/')
evictset = setlist[0]
expected_for_param.append(setlist[1])
uuidlist = self.params.get("uuid", '/run/evicttests/UUID/*/')
excludeuuid = uuidlist[0]
expected_for_param.append(uuidlist[1])
# if any parameter is FAIL then the test should FAIL, in this test
# virtually everyone should FAIL since we are testing bad parameters
expected_result = 'PASS'
for result in expected_for_param:
if result == 'FAIL':
expected_result = 'FAIL'
break
saveduuid = None
savedgroup = None
savedsvc = None
pool = None
try:
# setup the DAOS python API
with open('../../../.build_vars.json') as build_file:
data = json.load(build_file)
context = DaosContext(data['PREFIX'] + '/lib/')
# initialize a python pool object then create the underlying
# daos storage
pool = DaosPool(context)
pool.create(createmode, createuid, creategid, createsize,
createsetid, None)
# trash the the pool service rank list
if not svc == 'VALID':
savedsvc = pool.svc
rl_ranks = ctypes.POINTER(ctypes.c_uint)()
pool.svc = RankList(rl_ranks, 1)
# trash the pool group value
if evictset is None:
savedgroup = pool.group
pool.group = None
# trash the UUID value in various ways
if excludeuuid is None:
saveduuid = (ctypes.c_ubyte * 16)(0)
for item in range(0, len(saveduuid)):
saveduuid[item] = pool.uuid[item]
pool.uuid[0:] = [0 for item in range(0, len(pool.uuid))]
if excludeuuid == 'JUNK':
saveduuid = (ctypes.c_ubyte * 16)(0)
for item in range(0, len(saveduuid)):
saveduuid[item] = pool.uuid[item]
pool.uuid[4] = 244
pool.evict()
if expected_result in ['FAIL']:
self.fail("Test was expected to fail but it passed.\n")
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
if expected_result in ['PASS']:
self.fail("Test was expected to pass but it failed.\n")
finally:
if pool is not None:
# if the test trashed some pool parameter, put it back the
# way it was
if savedgroup is not None:
pool.group = savedgroup
if saveduuid is not None:
for item in range(0, len(saveduuid)):
pool.uuid[item] = saveduuid[item]
if savedsvc is not None:
pool.svc = savedsvc
pool.destroy(1)
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')
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)
try:
self.agent_sessions = AgentUtils.run_agent(basepath, self.hostlist)
server_utils.run_server(hostfile, server_group, 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)
os.remove(hostfile)
# really make sure everything is gone
check_for_pool.cleanup_pools(self.hostlist)
finally:
if self.agent_sessions:
AgentUtils.stop_agent(self.hostlist, self.agent_sessions)
server_utils.kill_server(self.hostlist)
class LlnlMpi4pyHdf5(TestWithServers):
"""
Runs LLNL, MPI4PY and HDF5 test suites.
:avocado: recursive
"""
def setUp(self):
super(LlnlMpi4pyHdf5, self).setUp()
# initialising variables
self.mpio = None
self.hostfile_clients = None
# setting client variables
self.hostfile_clients = write_host_file.write_host_file(
self.hostlist_clients, self.workdir, None)
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 run_test(self, test_repo, test_name):
"""
Executable function to be used by test functions below
test_repo --location of test repository
test_name --name of the test to be run
"""
# initialize MpioUtils
self.mpio = MpioUtils()
if not self.mpio.mpich_installed(self.hostlist_clients):
self.fail("Exiting Test: Mpich not installed")
try:
# initialise test specific variables
client_processes = self.params.get("np", '/run/client_processes/')
# obtaining pool uuid and svc list
pool_uuid = self.pool.get_uuid_str()
svc_list = ""
for i in range(self.createsvc):
svc_list += str(int(self.pool.svc.rl_ranks[i])) + ":"
svc_list = svc_list[:-1]
# running tests
self.mpio.run_llnl_mpi4py_hdf5(self.basepath,
self.hostfile_clients, pool_uuid,
test_repo, test_name,
client_processes)
# Parsing output to look for failures
# stderr directed to stdout
stdout = self.logdir + "/stdout"
searchfile = open(stdout, "r")
error_message = [
"non-zero exit code", "MPI_Abort", "MPI_ABORT", "ERROR"
]
for line in searchfile:
# pylint: disable=C0200
for i in range(len(error_message)):
if error_message[i] in line:
self.fail("Test Failed with error_message: {}".format(
error_message[i]))
except (MpioFailed, DaosApiError) as excep:
self.fail("<{0} Test Failed> \n{1}".format(test_name, excep))
def test_llnl(self):
"""
Jira ID: DAOS-2231
Test Description: Run LLNL test suite.
Testing various I/O functions provided in llnl test suite
such as:-
test_collective, test_datareps, test_errhandlers,
test_filecontrol, test_localpointer, test_manycomms,
test_manyopens, test_openclose, test_openmodes,
test_nb_collective, test_nb_localpointer, test_nb_rdwr,
test_nb_readwrite, test_rdwr, test_readwrite
:avocado: tags=mpio,llnlmpi4pyhdf5,llnl
"""
test_repo = self.params.get("llnl", '/run/test_repo/')
self.run_test(test_repo, "llnl")
def test_mpi4py(self):
"""
Jira ID: DAOS-2231
Test Description: Run mpi4py io test provided in mpi4py package
Testing various I/O functions provided in mpi4py test suite
such as:-
testReadWriteAt, testIReadIWriteAt, testReadWrite
testIReadIWrite, testReadWriteAtAll, testIReadIWriteAtAll
testReadWriteAtAllBeginEnd, testReadWriteAll
testIReadIWriteAll, testReadWriteAllBeginEnd
:avocado: tags=mpio,llnlmpi4pyhdf5,mpi4py
"""
test_repo = self.params.get("mpi4py", '/run/test_repo/')
self.run_test(test_repo, "mpi4py")
def test_hdf5(self):
"""
Jira ID: DAOS-2252
Test Description: Run HDF5 testphdf5 and t_shapesame provided in
HDF5 package. Testing various I/O functions provided in HDF5 test
suite such as:-
test_fapl_mpio_dup, test_split_comm_access, test_page_buffer_access,
test_file_properties, dataset_writeInd, dataset_readInd,
dataset_writeAll, dataset_readAll, extend_writeInd, extend_readInd,
extend_writeAll, extend_readAll,extend_writeInd2,none_selection_chunk,
zero_dim_dset, multiple_dset_write, multiple_group_write,
multiple_group_read, compact_dataset, collective_group_write,
independent_group_read, big_dataset, coll_chunk1, coll_chunk2,
coll_chunk3, coll_chunk4, coll_chunk5, coll_chunk6, coll_chunk7,
coll_chunk8, coll_chunk9, coll_chunk10, coll_irregular_cont_write,
coll_irregular_cont_read, coll_irregular_simple_chunk_write,
coll_irregular_simple_chunk_read , coll_irregular_complex_chunk_write,
coll_irregular_complex_chunk_read , null_dataset , io_mode_confusion,
rr_obj_hdr_flush_confusion, chunk_align_bug_1,lower_dim_size_comp_test,
link_chunk_collective_io_test, actual_io_mode_tests,
no_collective_cause_tests, test_plist_ed, file_image_daisy_chain_test,
test_dense_attr, test_partial_no_selection_coll_md_read
:avocado: tags=mpio,llnlmpi4pyhdf5,hdf5
"""
test_repo = self.params.get("hdf5", '/run/test_repo/')
self.run_test(test_repo, "hdf5")
class OpenClose(Test):
"""
Tests DAOS container open/close function with handle parameter.
"""
def __init__(self, *args, **kwargs):
super(OpenClose, self).__init__(*args, **kwargs)
self.container1 = None
self.container2 = None
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 tearDown(self):
try:
if self.pool is not None and self.pool.attached:
self.pool.destroy(1)
finally:
try:
if self.agent_sessions:
AgentUtils.stop_agent(self.hostlist, self.agent_sessions)
server_utils.stop_server(hosts=self.hostlist)
except server_utils.ServerFailed:
pass
def test_closehandle(self):
"""
Test container close function with container handle paramter.
:avocado: tags=container,openclose,closehandle
"""
saved_coh = None
# 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/')
coh_params = self.params.get("coh",
'/run/container/container_handle/*/')
expected_result = coh_params[1]
try:
# 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)
poh = self.pool.handle
self.pool.connect(1 << 1)
# Container initialization and creation
self.container1 = DaosContainer(self.context)
self.container1.create(poh)
str_cuuid = self.container1.get_uuid_str()
cuuid = uuid.UUID(str_cuuid)
self.container1.open(poh, cuuid, 2, None)
# Defining 'good' and 'bad' container handles
saved_coh = self.container1.coh
if coh_params[0] == 'GOOD':
coh = self.container1.coh
else:
# create a second container, open to get a handle
# then close & destroy so handle is invalid
self.container2 = DaosContainer(self.context)
self.container2.create(poh)
self.container2.open(poh, cuuid, 2, None)
coh = self.container2.coh
self.container2.close()
self.container2.destroy()
# close container with either good or bad handle
self.container1.close(coh)
if expected_result in ['FAIL']:
self.fail("Test was expected to fail but it passed.\n")
except DaosApiError as excep:
if expected_result == 'PASS':
print(excep)
print(traceback.format_exc())
self.fail("Test was expected to pass but it failed.\n")
# close above failed so close for real with the right coh
if saved_coh is not None:
self.container1.close(saved_coh)
finally:
self.container1.destroy(1)
self.pool.disconnect()
self.pool.destroy(1)
self.pool = None
class EightServers(Test):
"""
Test class Description: Runs IOR with 8 servers.
"""
def __init__(self, *args, **kwargs):
super(EightServers, self).__init__(*args, **kwargs)
self.basepath = None
self.server_group = None
self.Context = None
self.pool = None
self.slots = None
self.hostlist_servers = None
self.hostfile_servers = None
hostlist_clients = None
self.hostfile_clients = None
def setUp(self):
# get paths from the build_vars generated by build
with open('../../../.build_vars.json') as f:
build_paths = json.load(f)
self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
self.server_group = self.params.get("server_group", '/server/', '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 = WriteHostFile.WriteHostFile(self.hostlist_servers, self.workdir)
print("Host file servers is: {}".format(self.hostfile_servers))
hostlist_clients = self.params.get("test_clients", '/run/hosts/test_machines/*')
self.slots = self.params.get("slots", '/run/ior/clientslots/*')
self.hostfile_clients = WriteHostFile.WriteHostFile(hostlist_clients, self.workdir, self.slots)
print("Host file clients is: {}".format(self.hostfile_clients))
ServerUtils.runServer(self.hostfile_servers, self.server_group, self.basepath)
if int(str(self.name).split("-")[0]) == 1:
IorUtils.build_ior(self.basepath)
def tearDown(self):
try:
if self.pool is not None and self.pool.attached:
self.pool.destroy(1)
finally:
ServerUtils.stopServer(hosts=self.hostlist_servers)
def executable(self, iorflags=None):
"""
Executable function to run ior for sequential and random order
"""
# 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/')
createsvc = self.params.get("svcn", '/run/pool/createsvc/')
iteration = self.params.get("iter", '/run/ior/iteration/')
block_size = self.params.get("blocksize", '/run/ior/clientslots/*')
transfer_size = self.params.get("t", '/run/ior/transfersize_stripesize/*/')
record_size = self.params.get("r", '/run/ior/recordsize/*')
stripe_size = self.params.get("s", '/run/ior/transfersize_stripesize/*/')
stripe_count = self.params.get("c", '/run/ior/stripecount/')
async_io = self.params.get("a", '/run/ior/asyncio/')
object_class = self.params.get("o", '/run/ior/objectclass/*/')
expected_result = 'PASS'
if (record_size == '4k' and transfer_size == '1k'):
expected_result = 'FAIL'
try:
# 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, createsvc)
pool_uuid = self.pool.get_uuid_str()
svc_list = ""
for i in range(createsvc):
svc_list += str(int(self.pool.svc.rl_ranks[i])) + ":"
svc_list = svc_list[:-1]
print ("svc_list: {}".format(svc_list))
IorUtils.run_ior(self.hostfile_clients, iorflags, iteration, block_size, transfer_size,
pool_uuid, svc_list, record_size, stripe_size, stripe_count,
async_io, object_class, self.basepath, self.slots)
if expected_result == 'FAIL':
self.fail("Test was expected to fail but it passed.\n")
except (DaosApiError, IorUtils.IorFailed) as e:
print(e)
if expected_result != 'FAIL':
self.fail("Test was expected to pass but it failed.\n")
def test_sequential(self):
"""
Test ID: DAOS-1264
Test Description: Run IOR with 32,64 and 128 clients config sequentially.
Use Cases: Different combinations of 32/64/128 Clients, 8b/1k/4k
record size, 1k/4k/1m/8m transfersize and stripesize
and 16 async io.
:avocado: tags=ior,eightservers,ior_sequential
"""
ior_flags = self.params.get("F", '/run/ior/iorflags/sequential/')
self.executable(ior_flags)
def test_random(self):
"""
Test ID: DAOS-1264
Test Description: Run IOR with 32,64 and 128 clients config in random order.
Use Cases: Different combinations of 32/64/128 Clients, 8b/1k/4k
record size, 1k/4k/1m/8m transfersize and stripesize
and 16 async io.
:avocado: tags=ior,eightservers,ior_random
"""
ior_flags = self.params.get("F", '/run/ior/iorflags/random/')
self.executable(ior_flags)
def test_array_obj(self):
"""
Test ID: DAOS-961
Test Description: Writes an array to an object and then reads it
back and verifies it.
:avocado: tags=object,arrayobj,regression,vm,small
"""
try:
# parameters used in pool create
createmode = self.params.get("mode", '/run/pool_params/createmode/')
createsetid = self.params.get("setname",
'/run/pool_params/createset/')
createsize = self.params.get("size", '/run/pool_params/createsize/')
createuid = os.geteuid()
creategid = os.getegid()
# initialize a python pool object then create the underlying
# daos storage
pool = DaosPool(self.context)
pool.create(createmode, createuid, creategid,
createsize, createsetid, None)
self.plog.info("Pool %s created.", pool.get_uuid_str())
# need a connection to create container
pool.connect(1 << 1)
# create a container
container = DaosContainer(self.context)
container.create(pool.handle)
self.plog.info("Container %s created.", container.get_uuid_str())
# 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")
# create an object and write some data into it
thedata = []
thedata.append("data string one")
thedata.append("data string two")
thedata.append("data string tre")
dkey = "this is the dkey"
akey = "this is the akey"
self.plog.info("writing array to dkey >%s< akey >%s<.", dkey, akey)
oid, epoch = container.write_an_array_value(thedata, dkey, akey,
obj_cls=3)
# read the data back and make sure its correct
length = len(thedata[0])
thedata2 = container.read_an_array(len(thedata), length+1,
dkey, akey, oid, epoch)
if thedata[0][0:length-1] != thedata2[0][0:length-1]:
self.plog.error("Data mismatch")
self.plog.error("Wrote: >%s<", thedata[0])
self.plog.error("Read: >%s<", thedata2[0])
self.fail("Write data, read it back, didn't match\n")
if thedata[2][0:length-1] != thedata2[2][0:length-1]:
self.plog.error("Data mismatch")
self.plog.error("Wrote: >%s<", thedata[2])
self.plog.error("Read: >%s<", thedata2[2])
self.fail("Write data, read it back, didn't match\n")
container.close()
# wait a few seconds and then destroy
time.sleep(5)
container.destroy()
# cleanup the pool
pool.disconnect()
pool.destroy(1)
self.plog.info("Test Complete")
except DaosApiError as excep:
self.plog.error("Test Failed, exception was thrown.")
print(excep)
print(traceback.format_exc())
self.fail("Test was expected to pass but it failed.\n")
def test_destroy_recreate(self):
"""
Test destroy and recreate one right after the other multiple times
Should fail.
:avocado: tags=pool,pooldestroy,destroyredo
"""
try:
# write out a hostfile and start the servers with it
self.hostlist = self.params.get("test_machines1", '/run/hosts/')
hostfile = WriteHostFile.WriteHostFile(self.hostlist, self.tmp)
ServerUtils.runServer(hostfile, self.server_group, self.basepath)
# give it time to reach steady state
time.sleep(1)
# 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)
# blow it away immediately
POOL.destroy(1)
# now recreate
POOL.create(createmode, createuid, creategid,
createsize, createsetid, None)
# blow it away immediately
POOL.destroy(1)
# now recreate
POOL.create(createmode, createuid, creategid,
createsize, createsetid, None)
# blow it away immediately
POOL.destroy(1)
except DaosApiError as e:
print (e)
print (traceback.format_exc())
self.fail("create/destroy/create/destroy test failed.\n")
except Exception as e:
self.fail("Daos code segfaulted most likely. Error: %s" % e)
# no matter what happens cleanup
finally:
ServerUtils.stopServer(hosts=self.hostlist)
os.remove(hostfile)
def test_evict(self):
"""
Test ID: DAOS-427
Test Description: Pass bad parameters to the pool evict clients call.
:avocado: tags=pool,poolevict,badparam,badevict
"""
# parameters used in pool create
createmode = self.params.get("mode", '/run/evicttests/createmode/')
createsetid = self.params.get("setname", '/run/evicttests/createset/')
createsize = self.params.get("size", '/run/evicttests/createsize/')
createuid = os.geteuid()
creategid = os.getegid()
# Accumulate a list of pass/fail indicators representing what is
# expected for each parameter then "and" them to determine the
# expected result of the test
expected_for_param = []
svclist = self.params.get("ranklist", '/run/evicttests/svrlist/*/')
svc = svclist[0]
expected_for_param.append(svclist[1])
setlist = self.params.get("setname",
'/run/evicttests/connectsetnames/*/')
evictset = setlist[0]
expected_for_param.append(setlist[1])
uuidlist = self.params.get("uuid", '/run/evicttests/UUID/*/')
excludeuuid = uuidlist[0]
expected_for_param.append(uuidlist[1])
# if any parameter is FAIL then the test should FAIL, in this test
# virtually everyone should FAIL since we are testing bad parameters
expected_result = 'PASS'
for result in expected_for_param:
if result == 'FAIL':
expected_result = 'FAIL'
break
saveduuid = None
savedgroup = None
savedsvc = None
pool = None
try:
# setup the DAOS python API
with open('../../../.build_vars.json') as build_file:
data = json.load(build_file)
context = DaosContext(data['PREFIX'] + '/lib/')
# initialize a python pool object then create the underlying
# daos storage
pool = DaosPool(context)
pool.create(createmode, createuid, creategid,
createsize, createsetid, None)
# trash the the pool service rank list
if not svc == 'VALID':
savedsvc = pool.svc
rl_ranks = ctypes.POINTER(ctypes.c_uint)()
pool.svc = RankList(rl_ranks, 1)
# trash the pool group value
if evictset is None:
savedgroup = pool.group
pool.group = None
# trash the UUID value in various ways
if excludeuuid is None:
saveduuid = (ctypes.c_ubyte * 16)(0)
for i in range(0, len(saveduuid)):
saveduuid[i] = pool.uuid[i]
pool.uuid[0:] = [0 for i in range(0, len(pool.uuid))]
if excludeuuid == 'JUNK':
saveduuid = (ctypes.c_ubyte * 16)(0)
for i in range(0, len(saveduuid)):
saveduuid[i] = pool.uuid[i]
pool.uuid[4] = 244
pool.evict()
if expected_result in ['FAIL']:
self.fail("Test was expected to fail but it passed.\n")
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
if expected_result in ['PASS']:
self.fail("Test was expected to pass but it failed.\n")
finally:
if pool is not None:
# if the test trashed some pool parameter, put it back the
# way it was
if savedgroup is not None:
pool.group = savedgroup
if saveduuid is not None:
for i in range(0, len(saveduuid)):
pool.uuid[i] = saveduuid[i]
if savedsvc is not None:
pool.svc = savedsvc
pool.destroy(1)
def test_destroy_withdata(self):
"""
Test destroy and recreate one right after the other multiple times
Should fail.
:avocado: tags=pool,pooldestroy,destroydata
"""
try:
# write out a hostfile and start the servers with it
self.hostlist = self.params.get("test_machines1", '/run/hosts/')
hostfile = WriteHostFile.WriteHostFile(self.hostlist, self.tmp)
ServerUtils.runServer(hostfile, self.server_group, self.basepath)
# give it time to reach steady state
time.sleep(1)
# 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)
# create a container
CONTAINER = DaosContainer(self.Context)
CONTAINER.create(POOL.handle)
POOL.disconnect()
daosctl = self.basepath + '/install/bin/daosctl'
write_cmd = ('{0} write-pattern -i {1} -l 0 -c {2} -p sequential'.
format(daosctl, c_uuid_to_str(POOL.uuid),
c_uuid_to_str(CONTAINER.uuid)))
process.system_output(write_cmd)
# blow it away
POOL.destroy(1)
except DaosApiError as e:
print (e)
print (traceback.format_exc())
self.fail("create/destroy/create/destroy test failed.\n")
except Exception as e:
self.fail("Daos code segfaulted most likely. Error: %s" % e)
# no matter what happens cleanup
finally:
ServerUtils.stopServer(hosts=self.hostlist)
os.remove(hostfile)
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)
class FullPoolContainerCreate(Test):
"""
Class for test to create a container in a pool with no remaining free space.
"""
def setUp(self):
# 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 f:
build_paths = json.load(f)
self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
self.tmp = build_paths['PREFIX'] + '/tmp'
self.server_group = self.params.get("server_group", '/server/',
'daos_default_oops')
self.context = DaosContext(build_paths['PREFIX'] + '/lib/')
print("initialized!!!\n")
self.pool = DaosPool(self.context)
self.hostlist = self.params.get("test_machines1", '/hosts/')
self.hostfile = WriteHostFile.WriteHostFile(self.hostlist, self.tmp)
ServerUtils.runServer(self.hostfile, self.server_group, self.basepath)
time.sleep(5)
def tearDown(self):
# shut 'er down
ServerUtils.stopServer()
if self.hostfile is not None:
os.remove(self.hostfile)
def test_no_space_cont_create(self):
"""
:avocado: tags=pool,container,fullpoolcontcreate,small,vm
"""
setid = self.params.get("setname",
'/run/testparams/setnames/validsetname/')
# create pool
mode = self.params.get("mode", '/conttests/createmode/')
print("mode is {0}".format(mode))
uid = os.geteuid()
gid = os.getegid()
# 16 mb pool, minimum size currently possible
size = 16777216
print("creating pool")
self.pool.create(mode, uid, gid, size, self.server_group, None)
print("created pool")
# connect to the pool
print("connecting to pool")
self.pool.connect(1 << 1)
print("connected to pool")
# query the pool
print("querying pool info")
pool_info = self.pool.pool_query()
print("queried pool info")
# create a container
try:
print("creating container")
self.cont = DaosContainer(self.context)
self.cont.create(self.pool.handle)
print("created container")
except ValueError as e:
self.fail("caught exception creating container: {0}".format(e))
print("opening container")
self.cont.open()
print("opened container")
# generate random dkey, akey each time
# write 1mb until no space, then 1kb, etc. to fill pool quickly
for x in [1048576, 1024, 1]:
write_count = 0
while(True):
print("writing obj {0}, sz {1} to container".format(write_count, x))
my_str = "a" * x
my_str_sz = x
dkey = ''.join(random.choice(string.lowercase) for i in range(5))
akey = ''.join(random.choice(string.lowercase) for i in range(5))
try:
oid, epoch = self.cont.write_an_obj(my_str, my_str_sz, dkey, akey)
print("wrote obj {0}, sz {1}".format(write_count, x))
write_count += 1
except ValueError as e:
if "RC: -1007" not in repr(e):
self.fail("caught exception while writing object: {0}"
.format(repr(e)))
else:
print("pool is too full for {0} byte objects".format(x))
break
print("closing container")
self.cont.close()
print("closed container")
# create a 2nd container now that pool is full
try:
print("creating 2nd container")
self.cont2 = DaosContainer(self.context)
self.cont2.create(self.pool.handle)
print("created 2nd container")
print("writing one more object, write expected to fail")
self.cont2.write_an_obj(my_str, my_str_sz, dkey, akey)
print("wrote one more object--this should never print")
except ValueError as e:
if "RC: -1007" not in repr(e):
self.fail("caught unexpected exception while writing "
"object: {0}".format(repr(e)))
else:
print("correctly caught -1007 while attempting "
"to write object in full pool")
