class ObjectDataValidation(avocado.Test):
"""
Test Class Description:
Tests that create Different length records,
Disconnect the pool/container and reconnect,
validate the data after reconnect.
"""
# pylint: disable=too-many-instance-attributes
def setUp(self):
self.agent_sessions = None
self.pool = None
self.container = None
self.obj = None
self.ioreq = None
self.hostlist = None
self.hostfile = None
self.no_of_dkeys = None
self.no_of_akeys = None
self.array_size = None
self.record_length = None
with open('../../.build_vars.json') as json_f:
build_paths = json.load(json_f)
self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
server_group = self.params.get("name", '/server_config/',
'daos_server')
self.context = DaosContext(build_paths['PREFIX'] + '/lib64/')
self.d_log = DaosLog(self.context)
self.hostlist = self.params.get("test_machines", '/run/hosts/*')
self.hostfile = write_host_file.write_host_file(
self.hostlist, self.workdir)
self.no_of_dkeys = self.params.get("no_of_dkeys", '/run/dkeys/*')[0]
self.no_of_akeys = self.params.get("no_of_akeys", '/run/akeys/*')[0]
self.array_size = self.params.get("size", '/array_size/')
self.record_length = self.params.get("length", '/run/record/*')
self.agent_sessions = agent_utils.run_agent(self.basepath,
self.hostlist)
server_utils.run_server(self, self.hostfile, server_group)
self.pool = DaosPool(self.context)
self.pool.create(self.params.get("mode", '/run/pool/createmode/*'),
os.geteuid(), os.getegid(),
self.params.get("size", '/run/pool/createsize/*'),
self.params.get("setname", '/run/pool/createset/*'),
None)
self.pool.connect(2)
self.container = DaosContainer(self.context)
self.container.create(self.pool.handle)
self.container.open()
self.obj = DaosObj(self.context, self.container)
self.obj.create(objcls=1)
self.obj.open()
self.ioreq = IORequest(self.context,
self.container,
self.obj,
objtype=4)
def tearDown(self):
try:
if self.container:
self.container.close()
self.container.destroy()
if self.pool:
self.pool.disconnect()
self.pool.destroy(1)
finally:
if self.agent_sessions:
agent_utils.stop_agent(self.agent_sessions)
server_utils.stop_server(hosts=self.hostlist)
def reconnect(self):
'''
Function to reconnect the pool/container and reopen the Object
for read verification.
'''
#Close the Obj/Container, Disconnect the Pool.
self.obj.close()
self.container.close()
self.pool.disconnect()
time.sleep(5)
#Connect Pool, Open Container and Object
self.pool.connect(2)
self.container.open()
self.obj.open()
self.ioreq = IORequest(self.context,
self.container,
self.obj,
objtype=4)
@avocado.fail_on(DaosApiError)
def test_invalid_tx_commit_close(self):
"""
Test ID:
(1)DAOS-1346: Verify commit tx bad parameter behavior.
(2)DAOS-1343: Verify tx_close bad parameter behavior.
(3)DAOS-1342: Verify tx_close through daos_api.
(4)DAOS-1338: Add and verify tx_abort through daos_api.
(5)DAOS-1339: Verify tx_abort bad parameter behavior.
Test Description:
Write Avocado Test to verify commit tx and close tx
bad parameter behavior.
:avocado: tags=all,object,full_regression,small,invalid_tx
"""
self.d_log.info("==Writing the Single Dataset for negative test...")
record_index = 0
expected_error = "RC: -1002"
dkey = 0
akey = 0
indata = ("{0}".format(str(akey)[0]) *
self.record_length[record_index])
c_dkey = ctypes.create_string_buffer("dkey {0}".format(dkey))
c_akey = ctypes.create_string_buffer("akey {0}".format(akey))
c_value = ctypes.create_string_buffer(indata)
c_size = ctypes.c_size_t(ctypes.sizeof(c_value))
try:
new_transaction = self.container.get_new_tx()
except DaosApiError as excep:
#initial container get_new_tx failed, skip rest of the test
self.fail("##container get_new_tx failed: {}".format(excep))
invalid_transaction = new_transaction + random.randint(1000, 383838)
self.log.info("==new_transaction= %s", new_transaction)
self.log.info("==invalid_transaction= %s", invalid_transaction)
self.ioreq.single_insert(c_dkey, c_akey, c_value, c_size,
new_transaction)
try:
self.container.commit_tx(invalid_transaction)
self.fail("##(1.1)Container.commit_tx passing with invalid handle")
except DaosApiError as excep:
self.log.info(str(excep))
self.log.info(
"==(1)Expecting failure: invalid Container.commit_tx.")
if expected_error not in str(excep):
self.fail(
"##(1.2)Expecting error RC: -1002, but got {}.".format(
str(excep)))
try:
self.container.close_tx(invalid_transaction)
self.fail("##(2.1)Container.close_tx passing with invalid handle")
except DaosApiError as excep:
self.log.info(str(excep))
self.log.info(
"==(2)Expecting failure: invalid Container.commit_tx.")
if expected_error not in str(excep):
self.fail(
"##(2.2)Expecting error RC: -1002, but got {}.".format(
str(excep)))
try:
self.container.close_tx(new_transaction)
self.log.info("==(3)container.close_tx test passed.")
except DaosApiError as excep:
self.log.info(str(excep))
self.fail("##(3)Failed on close_tx.")
try:
self.container.abort_tx(invalid_transaction)
self.fail("##(4.1)Container.abort_tx passing with invalid handle")
except DaosApiError as excep:
self.log.info(str(excep))
self.log.info(
"==(4)Expecting failure: invalid Container.abort_tx.")
if expected_error not in str(excep):
self.fail(
"##(4.2)Expecting error RC: -1002, but got {}.".format(
str(excep)))
#Try to abort the transaction which already closed.
try:
self.container.abort_tx(new_transaction)
self.fail("##(5.1)Container.abort_tx passing with a closed handle")
except DaosApiError as excep:
self.log.info(str(excep))
self.log.info(
"==(5)Expecting failure: Container.abort_tx closed handle.")
if expected_error not in str(excep):
self.fail(
"##(5.2)Expecting error RC: -1002, but got {}.".format(
str(excep)))
#open another transaction for abort test
try:
new_transaction2 = self.container.get_new_tx()
except DaosApiError as excep:
self.fail("##(6.1)container get_new_tx failed: {}".format(excep))
self.log.info("==new_transaction2= %s", new_transaction2)
self.ioreq.single_insert(c_dkey, c_akey, c_value, c_size,
new_transaction2)
try:
self.container.abort_tx(new_transaction2)
self.log.info("==(6)container.abort_tx test passed.")
except DaosApiError as excep:
self.log.info(str(excep))
self.fail("##(6.2)Failed on abort_tx.")
@avocado.fail_on(DaosApiError)
@skipForTicket("DAOS-3208")
def test_single_object_validation(self):
"""
Test ID: DAOS-707
Test Description: Write Avocado Test to verify single data after
pool/container disconnect/reconnect.
:avocado: tags=all,object,full_regression,small,single_object
"""
self.d_log.info("Writing the Single Dataset")
record_index = 0
transaction = []
for dkey in range(self.no_of_dkeys):
for akey in range(self.no_of_akeys):
indata = ("{0}".format(str(akey)[0]) *
self.record_length[record_index])
c_dkey = ctypes.create_string_buffer("dkey {0}".format(dkey))
c_akey = ctypes.create_string_buffer("akey {0}".format(akey))
c_value = ctypes.create_string_buffer(indata)
c_size = ctypes.c_size_t(ctypes.sizeof(c_value))
new_transaction = self.container.get_new_tx()
self.ioreq.single_insert(c_dkey, c_akey, c_value, c_size,
new_transaction)
self.container.commit_tx(new_transaction)
transaction.append(new_transaction)
record_index = record_index + 1
if record_index == len(self.record_length):
record_index = 0
self.reconnect()
self.d_log.info("Single Dataset Verification -- Started")
record_index = 0
transaction_index = 0
for dkey in range(self.no_of_dkeys):
for akey in range(self.no_of_akeys):
indata = ("{0}".format(str(akey)[0]) *
self.record_length[record_index])
c_dkey = ctypes.create_string_buffer("dkey {0}".format(dkey))
c_akey = ctypes.create_string_buffer("akey {0}".format(akey))
val = self.ioreq.single_fetch(c_dkey, c_akey, len(indata) + 1)
if indata != (repr(val.value)[1:-1]):
self.d_log.error("ERROR:Data mismatch for "
"dkey = {0}, "
"akey = {1}".format(
"dkey {0}".format(dkey),
"akey {0}".format(akey)))
self.fail(
"ERROR: Data mismatch for dkey = {0}, akey={1}".format(
"dkey {0}".format(dkey), "akey {0}".format(akey)))
transaction_index = transaction_index + 1
record_index = record_index + 1
if record_index == len(self.record_length):
record_index = 0
@avocado.fail_on(DaosApiError)
@skipForTicket("DAOS-3208")
def test_array_object_validation(self):
"""
Test ID: DAOS-707
Test Description: Write Avocado Test to verify Array data after
pool/container disconnect/reconnect.
:avocado: tags=all,object,full_regression,small,array_object
"""
self.d_log.info("Writing the Array Dataset")
record_index = 0
transaction = []
for dkey in range(self.no_of_dkeys):
for akey in range(self.no_of_akeys):
c_values = []
value = ("{0}".format(str(akey)[0]) *
self.record_length[record_index])
for item in range(self.array_size):
c_values.append(
(ctypes.create_string_buffer(value), len(value) + 1))
c_dkey = ctypes.create_string_buffer("dkey {0}".format(dkey))
c_akey = ctypes.create_string_buffer("akey {0}".format(akey))
new_transaction = self.container.get_new_tx()
self.ioreq.insert_array(c_dkey, c_akey, c_values,
new_transaction)
self.container.commit_tx(new_transaction)
transaction.append(new_transaction)
record_index = record_index + 1
if record_index == len(self.record_length):
record_index = 0
self.reconnect()
self.d_log.info("Array Dataset Verification -- Started")
record_index = 0
transaction_index = 0
for dkey in range(self.no_of_dkeys):
for akey in range(self.no_of_akeys):
indata = []
value = ("{0}".format(str(akey)[0]) *
self.record_length[record_index])
for item in range(self.array_size):
indata.append(value)
c_dkey = ctypes.create_string_buffer("dkey {0}".format(dkey))
c_akey = ctypes.create_string_buffer("akey {0}".format(akey))
c_rec_count = ctypes.c_uint(len(indata))
c_rec_size = ctypes.c_size_t(len(indata[0]) + 1)
outdata = self.ioreq.fetch_array(c_dkey, c_akey, c_rec_count,
c_rec_size)
for item in enumerate(indata):
if indata[item[0]] != outdata[item[0]][:-1]:
self.d_log.error("ERROR:Data mismatch for "
"dkey = {0}, "
"akey = {1}".format(
"dkey {0}".format(dkey),
"akey {0}".format(akey)))
self.fail(
"ERROR:Data mismatch for dkey = {0}, akey={1}".
format("dkey {0}".format(dkey),
"akey {0}".format(akey)))
transaction_index = transaction_index + 1
record_index = record_index + 1
if record_index == len(self.record_length):
record_index = 0
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=all,smoke,pr,object,tiny,basicobject
"""
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_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:
# initialize a python pool object then create the underlying
# daos storage
pool = DaosPool(self.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
savedgroup = pool.group
if evictset is None:
pool.group = None
else:
pool.set_group(evictset)
# 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))]
elif 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:
self.log.error(str(excep))
self.log.error(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
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(0)
def test_bad_handle(self):
"""
Test ID: DAOS-1376
Test Description: Pass a bogus object handle, should return bad handle.
:avocado: tags=all,object,full_regression,small,objbadhand
"""
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.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()
# 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, dummy_tx = container.write_an_obj(thedata, thedatasize, dkey,
akey, None, None, 2)
saved_oh = obj.obj_handle
obj.obj_handle = 99999
obj, dummy_tx = container.write_an_obj(thedata, thedatasize, dkey,
akey, obj, None, 2)
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 DaosApiError as excep:
container.oh = saved_oh
container.close()
container.destroy()
pool.disconnect()
pool.destroy(1)
self.plog.info("Test Complete")
if '-1002' not in str(excep):
print(excep)
print(traceback.format_exc())
self.fail("Test was expected to get -1002 but it has not.\n")
def test_connect(self):
"""
Pass bad parameters to pool connect
:avocado: tags=all,pool,full_regression,tiny,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:
# initialize a python pool object then create the underlying
# daos storage
pool = DaosPool(self.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.disconnect()
pool.destroy(1)
class ContainerAsync(TestWithServers):
"""
Tests DAOS pool connect permissions (non existing pool handle, bad uuid)
and close.
:avocado: recursive
"""
def __init__(self, *args, **kwargs):
super(ContainerAsync, self).__init__(*args, **kwargs)
self.container1 = None
self.container2 = None
self.pool = None
def test_createasync(self):
"""
Test container create for asynchronous mode.
:avocado: tags=all,small,full_regression,container,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.disconnect()
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=all,small,full_regression,container,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)
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
def test_openasync(self):
"""
Test container open for asynchronous mode.
:avocado: tags=all,small,full_regression,container,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 container
self.container1.close()
self.container1.destroy()
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
def test_closeasync(self):
"""
Test container close for asynchronous mode.
:avocado: tags=all,small,full_regression,container,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 container
self.container1.destroy()
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
def test_queryasync(self):
"""
Test container query for asynchronous mode.
:avocado: tags=all,small,full_regression,container,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 container
self.container1.destroy()
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
def test_null_values(self):
"""
Test ID: DAOS-1376
Test Description: Pass a dkey and an akey that is null.
:avocado: tags=all,object,full_regression,small,objupdatenull
"""
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.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()
# data used in the test
thedata = "a string that I want to stuff into an object"
thedatasize = len(thedata) + 1
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
self.fail("Test failed during setup .\n")
try:
# try using a null dkey
dkey = None
akey = "this is the akey"
container.write_an_obj(thedata, thedatasize, dkey, akey, None,
None, 2)
container.close()
container.destroy()
pool.disconnect()
pool.destroy(1)
self.plog.error("Didn't get expected return code.")
self.fail("Test was expected to return a -1003 but it has not.\n")
except DaosApiError as excep:
if '-1003' not in str(excep):
container.close()
container.destroy()
pool.disconnect()
pool.destroy(1)
self.plog.error("Didn't get expected return code.")
print(excep)
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
container.write_an_obj(thedata, thedatasize, dkey, akey, None,
None, 2)
self.fail("Test was expected to return a -1003 but it has not.\n")
except DaosApiError as excep:
if '-1003' not in str(excep):
self.plog.error("Didn't get expected return code.")
print(excep)
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"
container.write_an_obj(thedata, thedatasize, dkey, akey, None,
None, 2)
self.plog.info("Update with no data worked")
except DaosApiError as excep:
container.close()
container.destroy()
pool.disconnect()
pool.destroy(1)
print(excep)
print(traceback.format_exc())
self.plog.error("Update with no data failed")
self.fail("Update with no data failed.\n")
container.close()
container.destroy()
pool.disconnect()
pool.destroy(1)
self.plog.info("Test Complete")
def test_create(self):
"""Test ID: DAOS-???.
Test Description:
Pass bad parameters to pool create.
:avocado: tags=all,pool,full_regression,tiny,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]
if uid == 'VALID':
uid = os.geteuid()
expected_for_param.append(uidlist[1])
gidlist = self.params.get("gid", '/run/createtests/gids/*')
gid = gidlist[0]
if gid == 'VALID':
gid = os.getegid()
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:
# initialize a python pool object then create the underlying
# daos storage
pool = DaosPool(self.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:
self.log.error(str(excep))
self.log.error(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 NvmeIo(IorTestBase):
"""Test class for NVMe with IO tests.
Test Class Description:
Test the general Metadata operations and boundary conditions.
:avocado: recursive
"""
@avocado.fail_on(DaosApiError)
def test_nvme_io(self):
"""Jira 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.
Use Cases:
Running multiple IOR on same server start instance.
:avocado: tags=all,daosio,full_regression,hw,nvme_io
"""
# Pool params
pool_mode = self.params.get("mode", '/run/pool/createmode/*')
pool_uid = os.geteuid()
pool_gid = os.getegid()
pool_group = self.params.get("setname", '/run/pool/createset/*')
pool_svcn = self.params.get("svcn", '/run/pool/createsvc/')
# Test params
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:
# There is an issue with NVMe if Transfer size>64M,
# Skipped this sizes for now
if ior_param[2] > 67108864:
self.log.warning("Xfersize > 64M fails - DAOS-1264")
continue
# Create and connect to a pool
self.pool = DaosPool(self.context)
self.pool.create(pool_mode,
pool_uid,
pool_gid,
ior_param[0],
pool_group,
svcn=pool_svcn,
nvme_size=ior_param[1])
self.pool.connect(1 << 1)
# Get the current pool sizes
size_before_ior = self.pool.pool_query()
# Run ior with the parameters specified for this pass
self.ior_cmd.transfer_size.update(ior_param[2])
self.ior_cmd.block_size.update(ior_param[3])
self.ior_cmd.daos_oclass.update(obj_type)
self.ior_cmd.set_daos_params(self.server_group, self.pool)
self.run_ior(self.get_job_manager_command(), ior_param[4])
# Verify IOR consumed the expected amount ofrom the pool
self.verify_pool_size(size_before_ior, ior_param[4])
try:
if self.pool:
self.pool.disconnect()
self.pool.destroy(1)
except DaosApiError as error:
self.log.error("Pool disconnect/destroy error: %s",
str(error))
self.fail("Failed to Destroy/Disconnect the Pool")
def test_exclude(self):
"""
Pass bad parameters to pool connect
:avocado: tags=all,pool,full_regression,tiny,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:
# initialize a python pool object then create the underlying
# daos storage
pool = DaosPool(self.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 DeleteContainerTest(TestWithServers):
"""
Tests DAOS container delete and close.
:avocado: recursive
"""
def setUp(self):
super(DeleteContainerTest, self).setUp()
# 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/')
def test_container_delete(self):
"""
Test basic container delete
:avocado: tags=all,container,tiny,smoke,pr,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
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.
:avocado: recursive
"""
def setUp(self):
super(CreateManyDkeys, self).setUp()
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.pool:
self.pool.disconnect()
self.pool.destroy(1)
finally:
super(CreateManyDkeys, self).tearDown()
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_tx()
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_tx(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)
@skipForTicket("DAOS-1721")
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=all,full,small,object,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)
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 ObjFetchBadParam(TestWithServers):
"""
Test Class Description:
Pass an assortment of bad parameters to the daos_obj_fetch function.
:avocado: recursive
"""
def setUp(self):
super(ObjFetchBadParam, self).setUp()
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, None, None, 2)
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 DaosApiError as excep:
print(excep)
print(traceback.format_exc())
self.fail("Test failed during the initial setup.\n")
def test_bad_handle(self):
"""
Test ID: DAOS-1377
Test Description: Pass a bogus object handle, should return bad handle.
:avocado: tags=all,object,full_regression,small,objbadhandle
"""
try:
# trash the handle and read again
saved_oh = self.obj.obj_handle
self.obj.obj_handle = 99999
# expecting this to fail with -1002
dummy_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 DaosApiError as excep:
self.container.oh = saved_oh
if '-1002' not in str(excep):
print(excep)
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=all,object,full_regression,small,objfetchnull
"""
try:
# now try it with a bad dkey, expecting this to fail with -1003
dummy_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 DaosApiError as excep:
if '-1003' not in str(excep):
print(excep)
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 (iod_size is not set)
# expecting this to fail with -2013
test_hints = ['sglnull']
dummy_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 -2013 but it has not.\n")
except DaosApiError as excep:
if '-2013' not in str(excep):
print(excep)
print(traceback.format_exc())
self.fail("Test was expected to get -2013 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 DaosApiError as excep:
if '-1003' not in str(excep):
print(excep)
print(traceback.format_exc())
self.fail("Test was expected to get -1003 but it has not.\n")