def setUp(self):
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("server_group", '/server/',
'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 = WriteHostFile.WriteHostFile(self.hostlist,
self.workdir)
hostlist_clients = self.params.get("clients", '/run/hosts/*')
self.hostfile_clients = WriteHostFile.WriteHostFile(
hostlist_clients, self.workdir)
ServerUtils.runServer(self.hostfile, self.server_group, self.basepath)
self.pool = DaosPool(self.context)
self.pool.create(self.params.get("mode", '/run/pool/createmode/*'),
os.geteuid(),
os.getegid(),
self.params.get("size", '/run/pool/createsize/*'),
self.params.get("setname", '/run/pool/createset/*'),
nvme_size=self.params.get("size",
'/run/pool/nvmesize/*'))
def setUp(self):
# 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 setUp(self):
self.agent_sessions = None
# get paths from the build_vars generated by build
with open('../../../.build_vars.json') as build_file:
build_paths = json.load(build_file)
self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
self.server_group = self.params.get("name",
'/server_config/',
'daos_server')
# setup the DAOS python API
self.context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.pool = None
self.d_log = DaosLog(self.context)
# getting hostfile
self.hostfile_servers = None
self.hostlist_servers = self.params.get("test_machines", '/run/hosts/*')
self.hostfile_servers = write_host_file.write_host_file(
self.hostlist_servers, self.workdir)
print ("Host file is: {}".format(self.hostfile_servers))
self.container = None
# starting server
self.agent_sessions = agent_utils.run_agent(self.basepath,
self.hostlist_servers)
server_utils.run_server(self.hostfile_servers, self.server_group,
self.basepath)
def setUp(self):
self.agent_sessions = None
self.pool = None
self.container = None
self.obj = None
self.ioreq = None
self.hostlist = None
self.hostfile = None
self.no_of_dkeys = None
self.no_of_akeys = None
self.array_size = None
self.record_length = None
with open('../../../.build_vars.json') as json_f:
build_paths = json.load(json_f)
basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
server_group = self.params.get("name", '/server_config/',
'daos_server')
self.context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.d_log = DaosLog(self.context)
self.hostlist = self.params.get("test_machines", '/run/hosts/*')
self.hostfile = write_host_file.write_host_file(
self.hostlist, self.workdir)
self.no_of_dkeys = self.params.get("no_of_dkeys", '/run/dkeys/*')[0]
self.no_of_akeys = self.params.get("no_of_akeys", '/run/akeys/*')[0]
self.array_size = self.params.get("size", '/array_size/')
self.record_length = self.params.get("length", '/run/record/*')
self.agent_sessions = agent_utils.run_agent(basepath, self.hostlist)
server_utils.run_server(self.hostfile, server_group, basepath)
self.pool = DaosPool(self.context)
self.pool.create(self.params.get("mode", '/run/pool/createmode/*'),
os.geteuid(), os.getegid(),
self.params.get("size", '/run/pool/createsize/*'),
self.params.get("setname", '/run/pool/createset/*'),
None)
self.pool.connect(2)
self.container = DaosContainer(self.context)
self.container.create(self.pool.handle)
self.container.open()
self.obj = DaosObj(self.context, self.container)
self.obj.create(objcls=1)
self.obj.open()
self.ioreq = IORequest(self.context,
self.container,
self.obj,
objtype=4)
def setUp(self):
# 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'] + "/../")
tmp = build_paths['PREFIX'] + '/tmp'
self.hostlist = self.params.get("test_machines", '/run/hosts/')
self.hostfile = WriteHostFile.WriteHostFile(self.hostlist, tmp)
context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.d_log = DaosLog(context)
# self_test params
self.self_test_bin = os.path.join(build_paths["CART_PREFIX"],
"bin/self_test")
self.orterun = os.path.join(build_paths["OMPI_PREFIX"], "bin/orterun")
self.endpoint = self.params.get("endpoint", "/run/testparams/")
self.max_rpcs = self.params.get("max_inflight_rpcs",
"/run/testparams/")
self.repetitions = self.params.get("repetitions", "/run/testparams/")
self.message_size = self.params.get(
"size", "/run/muxtestparams/message_size/*")[0]
self.share_addr = self.params.get("val",
"/run/muxtestparams/share_addr/*")[0]
self.env_dict = {
"CRT_PHY_ADDR_STR": "ofi+sockets",
"CRT_CTX_NUM": "8",
"OFI_INTERFACE": "eth0",
"CRT_CTX_SHARE_ADDR": str(self.share_addr)
}
self.env_list = []
for k, v in self.env_dict.items():
self.env_list.append("-x")
self.env_list.append("{0}={1}".format(k, v))
# daos server params
self.server_group = self.params.get("server", 'server_group',
'daos_server')
self.uri_file = os.path.join(self.basepath, "install", "tmp",
"uri.txt")
ServerUtils.runServer(self.hostfile,
self.server_group,
self.basepath,
uri_path=self.uri_file,
env_dict=self.env_dict)
def setUp(self):
self.agent_sessions = None
# get paths from the build_vars generated by build
self.hostlist = None
with open('../../../.build_vars.json') as build_file:
build_paths = json.load(build_file)
self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
self.server_group = self.params.get("name", '/server_config/',
'daos_server')
# parameters used in pool create
self.createmode = self.params.get("mode",
'/run/createtests/createmode/')
self.createuid = os.geteuid()
self.creategid = os.getegid()
self.createsetid = self.params.get("setname",
'/run/createtests/createset/')
self.createsize = self.params.get("size",
'/run/createtests/createsize/')
# setup the DAOS python API
self.context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.pool = None
self.container = None
# hostlist and logging
self.d_log = DaosLog(self.context)
self.hostlist = self.params.get("test_machines", '/run/hosts/*')
self.hostfile = write_host_file.write_host_file(self.hostlist,
self.workdir)
self.agent_sessions = AgentUtils.run_agent(self.basepath, self.hostlist)
server_utils.run_server(self.hostfile, self.server_group, self.basepath)
def setUp(self):
"""Set up run before each test."""
super(TestWithoutServers, self).setUp()
# get paths from the build_vars generated by build
with open('../../../.build_vars.json') as build_vars:
build_paths = json.load(build_vars)
self.basepath = os.path.normpath(
os.path.join(build_paths['PREFIX'], '..') + os.path.sep)
self.prefix = build_paths['PREFIX']
self.ompi_prefix = build_paths["OMPI_PREFIX"]
self.tmp = os.path.join(self.prefix, 'tmp')
self.daos_test = os.path.join(self.basepath, 'install', 'bin',
'daos_test')
self.orterun = os.path.join(self.ompi_prefix, "bin", "orterun")
self.daosctl = os.path.join(self.basepath, 'install', 'bin', 'daosctl')
# setup fault injection, this MUST be before API setup
fault_list = self.params.get("fault_list", '/run/faults/*/')
if fault_list:
# not using workdir because the huge path was messing up
# orterun or something, could re-evaluate this later
tmp = os.path.join(self.basepath, 'install', 'tmp')
self.fault_file = fault_config_utils.write_fault_file(
tmp, fault_list, None)
os.environ["D_FI_CONFIG"] = self.fault_file
self.context = DaosContext(self.prefix + '/lib/')
self.d_log = DaosLog(self.context)
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.server_group = self.params.get("server_group", '/server/',
'daos_default_oops')
self.context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.pool = DaosPool(self.context)
self.d_log = DaosLog(self.context)
self.hostlist = self.params.get("test_machines1", '/hosts/')
self.hostfile = WriteHostFile.WriteHostFile(self.hostlist, self.workdir)
ServerUtils.runServer(self.hostfile, self.server_group, self.basepath)
def setUp(self):
super(CartSelfTest, self).setUp()
self.agent_sessions = None
self.hostlist_servers = self.params.get("test_machines", '/run/hosts/')
self.hostfile_servers = write_host_file.write_host_file(
self.hostlist_servers, self.workdir)
context = DaosContext(self.prefix + '/lib/')
self.d_log = DaosLog(context)
# self_test params
self.self_test_bin = os.path.join(self.prefix, "bin/self_test")
self.endpoint = self.params.get("endpoint", "/run/testparams/")
self.max_rpcs = self.params.get("max_inflight_rpcs",
"/run/testparams/")
self.repetitions = self.params.get("repetitions", "/run/testparams/")
self.message_size = (self.params.get(
"size", "/run/muxtestparams/message_size/*")[0])
self.share_addr = self.params.get("val",
"/run/muxtestparams/share_addr/*")[0]
self.env_dict = {
"CRT_PHY_ADDR_STR": "ofi+sockets",
"CRT_CTX_NUM": "8",
"OFI_INTERFACE": "eth0",
"CRT_CTX_SHARE_ADDR": str(self.share_addr)
}
self.env_list = []
for key, val in self.env_dict.items():
self.env_list.append("-x")
self.env_list.append("{0}={1}".format(key, val))
# daos server params
self.server_group = self.params.get("name", 'server_config',
'daos_server')
self.uri_file = os.path.join(self.basepath, "install", "tmp",
"uri.txt")
self.agent_sessions = agent_utils.run_agent(self.basepath,
self.hostlist_servers)
server_utils.run_server(self.hostfile_servers,
self.server_group,
self.basepath,
uri_path=self.uri_file,
env_dict=self.env_dict)
def setUp(self):
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_server')
context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.pool = DaosPool(context)
self.d_log = DaosLog(context)
self.hostlist_servers = self.params.get("test_machines1",
'/run/hosts/')
self.hostfile_servers = write_host_file.write_host_file(
self.hostlist_servers, self.workdir)
self.agent_sessions = agent_utils.run_agent(self.basepath,
self.hostlist_servers)
server_utils.run_server(self.hostfile_servers, self.server_group,
self.basepath)
def setUp(self):
# 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.pool = None
self.d_log = DaosLog(self.Context)
# getting hostfile
self.hostfile = None
self.hostlist = self.params.get("test_machines", '/run/hosts/*')
self.hostfile = WriteHostFile.WriteHostFile(self.hostlist,
self.workdir)
print("Host file is: {}".format(self.hostfile))
# starting server
ServerUtils.runServer(self.hostfile, self.server_group, self.basepath)
def setUp(self):
self.agent_sessions = None
self.pool = None
self.container = None
self.obj = None
self.ioreq = None
self.hostlist = None
self.hostfile = None
self.no_of_dkeys = None
self.no_of_akeys = None
self.array_size = None
self.record_length = None
with open('../../../.build_vars.json') as json_f:
build_paths = json.load(json_f)
basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
server_group = self.params.get("name",
'/server_config/',
'daos_server')
self.context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.d_log = DaosLog(self.context)
self.hostlist = self.params.get("test_machines", '/run/hosts/*')
self.hostfile = write_host_file.write_host_file(self.hostlist,
self.workdir)
self.no_of_dkeys = self.params.get("no_of_dkeys", '/run/dkeys/*')[0]
self.no_of_akeys = self.params.get("no_of_akeys", '/run/akeys/*')[0]
self.array_size = self.params.get("size", '/array_size/')
self.record_length = self.params.get("length", '/run/record/*')
self.agent_sessions = AgentUtils.run_agent(basepath, self.hostlist)
server_utils.run_server(self.hostfile, server_group, basepath)
self.pool = DaosPool(self.context)
self.pool.create(self.params.get("mode", '/run/pool/createmode/*'),
os.geteuid(),
os.getegid(),
self.params.get("size", '/run/pool/createsize/*'),
self.params.get("setname", '/run/pool/createset/*'),
None)
self.pool.connect(2)
self.container = DaosContainer(self.context)
self.container.create(self.pool.handle)
self.container.open()
self.obj = DaosObj(self.context, self.container)
self.obj.create(objcls=1)
self.obj.open()
self.ioreq = IORequest(self.context,
self.container,
self.obj, objtype=4)
def setUp(self):
# get paths from the build_vars generated by build
with open('../../../.build_vars.json') as finput:
build_paths = json.load(finput)
basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
server_group = self.params.get("name", '/server_config/',
'daos_server')
# setup the DAOS python API
self.context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.d_log = DaosLog(self.context)
self.hostlist = self.params.get("test_machines", '/run/hosts/*')
hostfile = write_host_file.write_host_file(self.hostlist, self.workdir)
server_utils.run_server(hostfile, server_group, basepath)
# Set up the pool and container.
try:
# parameters used in pool create
createmode = self.params.get("mode", '/run/pool/createmode/')
createsetid = self.params.get("setname", '/run/pool/createset/')
createsize = self.params.get("size", '/run/pool/createsize/*')
createuid = os.geteuid()
creategid = os.getegid()
# initialize a pool object then create the underlying
# daos storage
self.pool = DaosPool(self.context)
self.pool.create(createmode, createuid, creategid, createsize,
createsetid, None)
# need a connection to create container
self.pool.connect(1 << 1)
# create a container
self.container = DaosContainer(self.context)
self.container.create(self.pool.handle)
# now open it
self.container.open()
except DaosApiError as error:
print(error)
print(traceback.format_exc())
self.fail("Test failed before snapshot taken")
def setUp(self):
self.pool = None
self.hostlist = None
self.hostfile_clients = None
self.hostfile = None
self.out_queue = None
self.pool_connect = False
with open('../../../.build_vars.json') as json_f:
build_paths = json.load(json_f)
self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
self.server_group = self.params.get("name", '/server_config/',
'daos_server')
self.context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.d_log = DaosLog(self.context)
self.hostlist = self.params.get("servers", '/run/hosts/*')
self.hostfile = write_host_file.write_host_file(self.hostlist,
self.workdir)
#Start Server
server_utils.run_server(self.hostfile, self.server_group, self.basepath)
def setUp(self):
self.agent_sessions = None
# get paths from the build_vars generated by build
with open(os.path.join(os.path.dirname(os.path.realpath(__file__)),
"../../../../.build_vars.json")) as build_file:
build_paths = json.load(build_file)
self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
self.server_group = self.params.get("name", '/server_config/',
'daos_default_oops')
self.context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.cont = None
self.cont2 = None
self.pool = DaosPool(self.context)
self.d_log = DaosLog(self.context)
self.hostlist = self.params.get("test_machines1", '/hosts/')
self.hostfile = write_host_file.write_host_file(self.hostlist,
self.workdir)
self.agent_sessions = AgentUtils.run_agent(self.basepath, self.hostlist)
server_utils.run_server(self.hostfile, self.server_group, self.basepath)
def setUp(self):
self.agent_sessions = None
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/*'))
class ObjectMetadata(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 = 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("server_group", '/server/',
'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 = WriteHostFile.WriteHostFile(self.hostlist,
self.workdir)
hostlist_clients = self.params.get("clients", '/run/hosts/*')
self.hostfile_clients = WriteHostFile.WriteHostFile(
hostlist_clients, self.workdir)
ServerUtils.runServer(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:
ServerUtils.stopServer(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() is "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
ServerUtils.stopServer(hosts=self.hostlist)
ServerUtils.runServer(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 CartSelfTest(TestWithoutServers):
"""
Runs a few variations of CaRT self-test to ensure network is in a
stable state prior to testing.
:avocado: recursive
"""
def __init__(self, *args, **kwargs):
super(CartSelfTest, self).__init__(*args, **kwargs)
self.self_test_bin = None
self.endpoint = None
self.max_rpcs = None
self.repetitions = None
self.message_size = None
self.share_addr = None
self.env_dict = None
self.env_list = None
# start servers, establish file locations, etc.
def setUp(self):
super(CartSelfTest, self).setUp()
self.agent_sessions = None
self.hostlist_servers = self.params.get("test_machines", '/run/hosts/')
self.hostfile_servers = write_host_file.write_host_file(
self.hostlist_servers, self.workdir)
context = DaosContext(self.prefix + '/lib/')
self.d_log = DaosLog(context)
# self_test params
self.self_test_bin = os.path.join(self.prefix, "bin/self_test")
self.endpoint = self.params.get("endpoint", "/run/testparams/")
self.max_rpcs = self.params.get("max_inflight_rpcs",
"/run/testparams/")
self.repetitions = self.params.get("repetitions", "/run/testparams/")
self.message_size = (self.params.get(
"size", "/run/muxtestparams/message_size/*")[0])
self.share_addr = self.params.get("val",
"/run/muxtestparams/share_addr/*")[0]
self.env_dict = {
"CRT_PHY_ADDR_STR": "ofi+sockets",
"CRT_CTX_NUM": "8",
"OFI_INTERFACE": "eth0",
"CRT_CTX_SHARE_ADDR": str(self.share_addr)
}
self.env_list = []
for key, val in self.env_dict.items():
self.env_list.append("-x")
self.env_list.append("{0}={1}".format(key, val))
# daos server params
self.server_group = self.params.get("name", 'server_config',
'daos_server')
self.uri_file = os.path.join(self.basepath, "install", "tmp",
"uri.txt")
self.agent_sessions = agent_utils.run_agent(self.basepath,
self.hostlist_servers)
server_utils.run_server(self.hostfile_servers,
self.server_group,
self.basepath,
uri_path=self.uri_file,
env_dict=self.env_dict)
def tearDown(self):
try:
os.remove(self.hostfile_servers)
os.remove(self.uri_file)
finally:
if self.agent_sessions:
agent_utils.stop_agent(self.agent_sessions)
server_utils.stop_server(hosts=self.hostlist_servers)
super(CartSelfTest, self).tearDown()
def test_self_test(self):
"""
Run a few CaRT self-test scenarios
:avocado: tags=all,smoke,pr,unittest,tiny,cartselftest
"""
base_cmd = [
self.orterun, "-np", "1", "-ompi-server",
"file:{0}".format(self.uri_file)
]
selftest = [
self.self_test_bin, "--group-name",
"{0}".format(self.server_group), "--endpoint",
"{0}".format(self.endpoint), "--message-sizes",
"{0}".format(self.message_size), "--max-inflight-rpcs",
"{0}".format(self.max_rpcs), "--repetitions",
"{0}".format(self.repetitions)
]
cmd = base_cmd + self.env_list + selftest
cmd_log_str = ""
for elem in cmd:
cmd_log_str += elem + " "
try:
self.d_log.info("Running cmd {0}".format(cmd_log_str))
subprocess.check_output(cmd, stderr=subprocess.STDOUT)
except subprocess.CalledProcessError as exc:
self.d_log.error("CaRT self_test returned non-zero. "
"rc {0}:".format(exc.returncode))
for line in exc.output.split('\n'):
self.d_log.error("{0}".format(line))
self.fail("CaRT self_test returned non-zero")
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 ObjOpenBadParam(Test):
"""
Test Class Description:
Pass an assortment of bad parameters to the daos_obj_open function.
"""
def __init__(self, *args, **kwargs):
"""
Initialize values for variables that are used in tearDown() such that
if setUp() fails for any reason, tearDown() will avoid throwing
an AttributeError exception.
"""
super(ObjOpenBadParam, self).__init__(*args, **kwargs)
self.container = None
self.pool = None
def setUp(self):
self.agent_sessions = None
self.hostlist = None
# get paths from the build_vars generated by build
with open('../../../.build_vars.json') as 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.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)
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,
obj_cls=1)
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)
err_str = "Error reading back data, test failed during the " \
"initial setup."
self.d_log.error(err_str)
self.fail(err_str)
# setup leaves object in open state, so closing to start clean
self.obj.close()
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
self.fail("Test failed during the initial setup.")
def tearDown(self):
try:
self.container.close()
self.container.destroy()
self.pool.disconnect()
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_bad_obj_handle(self):
"""
Test ID: DAOS-1320
Test Description: Attempt to open a garbage object handle.
:avocado: tags=object,objopen,objopenbadhand,regression,vm,small
"""
saved_handle = self.obj.obj_handle
self.obj.obj_handle = 8675309
try:
dummy_obj = self.obj.open()
except DaosApiError as excep:
if '-1002' not in str(excep):
self.d_log.error("test expected a -1002 but did not get it")
self.d_log.error(traceback.format_exc())
self.fail("test expected a -1002 but did not get it")
finally:
self.obj.obj_handle = saved_handle
def test_invalid_container_handle(self):
"""
Test ID: DAOS-1320
Test Description: Attempt to open an object with a garbage container
handle.
:avocado: tags=object,objopen,objopenbadconthand,regression,vm,small
"""
saved_coh = self.container.coh
self.container.coh = 8675309
try:
dummy_obj = self.obj.open()
except DaosApiError as excep:
if '-1002' not in str(excep):
self.d_log.error("test expected a -1002 but did not get it")
self.d_log.error(traceback.format_exc())
self.fail("test expected a -1002 but did not get it")
finally:
self.container.coh = saved_coh
def test_closed_container_handle(self):
"""
Test ID: DAOS-1320
Test Description: Attempt to open an object in a container with
a closed handle.
:avocado: tags=object,objopen,objopenclosedcont,regression,vm,small
"""
self.container.close()
try:
dummy_obj = self.obj.open()
except DaosApiError as excep:
if '-1002' not in str(excep):
self.d_log.error("test expected a -1002 but did not get it")
self.d_log.error(traceback.format_exc())
self.fail("test expected a -1002 but did not get it")
finally:
self.container.open()
def test_pool_handle_as_obj_handle(self):
"""
Test ID: DAOS-1320
Test Description: Adding this test by request, this test attempts
to open an object that's had its handle set to
be the same as a valid pool handle.
:avocado: tags=object,objopen,objopenpoolhandle,regression,vm,small
"""
saved_oh = self.obj.obj_handle
self.obj.obj_handle = self.pool.handle
try:
dummy_obj = self.obj.open()
except DaosApiError as excep:
if '-1002' not in str(excep):
self.d_log.error("test expected a -1002 but did not get it")
self.d_log.error(traceback.format_exc())
self.fail("test expected a -1002 but did not get it")
finally:
self.obj.obj_handle = saved_oh
def test_null_ranklist(self):
"""
Test ID: DAOS-1320
Test Description: Attempt to open an object in a container with
an empty ranklist.
:avocado: tags=object,objopen,objopennullrl,regression,vm,small
"""
# null rl
saved_rl = self.obj.tgt_rank_list
self.obj.tgt_rank_list = None
try:
dummy_obj = self.obj.open()
except DaosApiError as excep:
if '-1003' not in str(excep):
self.d_log.error("test expected a -1003 but did not get it")
self.d_log.error(traceback.format_exc())
self.fail("test expected a -1003 but did not get it")
finally:
self.obj.tgt_rank_list = saved_rl
def test_null_oid(self):
"""
Test ID: DAOS-1320
Test Description: Attempt to open an object in a container with
null object id.
:avocado: tags=object,objopen,objopennulloid,regression,vm,small
"""
# null oid
saved_oid = self.obj.c_oid
self.obj.c_oid = DaosObjId(0, 0)
try:
dummy_obj = self.obj.open()
except DaosApiError as excep:
if '-1003' not in str(excep):
self.d_log.error("Test expected a -1003 but did not get it")
self.d_log.error(traceback.format_exc())
self.fail("test expected a -1003 but did not get it")
finally:
self.obj.c_oid = saved_oid
def test_null_tgts(self):
"""
Test ID: DAOS-1320
Test Description: Attempt to open an object in a container with
null tgt.
:avocado: tags=object,objopen,objopennulltgts,regression,vm,small
"""
# null tgts
saved_ctgts = self.obj.c_tgts
self.obj.c_tgts = 0
try:
dummy_obj = self.obj.open()
except DaosApiError as excep:
if '-1003' not in str(excep):
self.d_log.error("Test expected a -1003 but did not get it")
self.d_log.error(traceback.format_exc())
self.fail("test expected a -1003 but did not get it")
finally:
self.obj.c_tgts = saved_ctgts
def test_null_attrs(self):
"""
Test ID: DAOS-1320
Test Description: Attempt to open an object in a container with
null object attributes.
:avocado: tags=object,objopen,objopennullattr,regression,vm,small
"""
# null attr
saved_attr = self.obj.attr
self.obj.attr = 0
try:
dummy_obj = self.obj.open()
except DaosApiError as excep:
if '-1003' not in str(excep):
self.d_log.error("test expected a -1003 but did not get it")
self.d_log.error(traceback.format_exc())
self.fail("test expected a -1003 but did not get it")
finally:
self.obj.attr = saved_attr
def setUp(self):
self.agent_sessions = None
self.hostlist = None
# get paths from the build_vars generated by build
with open('../../../.build_vars.json') as 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.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)
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,
obj_cls=1)
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)
err_str = "Error reading back data, test failed during the " \
"initial setup."
self.d_log.error(err_str)
self.fail(err_str)
# setup leaves object in open state, so closing to start clean
self.obj.close()
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
self.fail("Test failed during the initial setup.")
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.pool = None
self.container = None
self.obj = None
self.ioreq = None
self.hostlist = None
self.hostfile = None
self.no_of_dkeys = None
self.no_of_akeys = None
self.array_size = None
self.record_length = None
with open('../../../.build_vars.json') as json_f:
build_paths = json.load(json_f)
basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
server_group = self.params.get("server_group", '/server/',
'daos_server')
self.context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.d_log = DaosLog(self.context)
self.hostlist = self.params.get("test_machines", '/run/hosts/*')
self.hostfile = WriteHostFile.WriteHostFile(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/*')
ServerUtils.runServer(self.hostfile, server_group, basepath)
self.pool = DaosPool(self.context)
self.pool.create(self.params.get("mode", '/run/pool/createmode/*'),
os.geteuid(), os.getegid(),
self.params.get("size", '/run/pool/createsize/*'),
self.params.get("setname", '/run/pool/createset/*'),
None)
self.pool.connect(2)
self.container = DaosContainer(self.context)
self.container.create(self.pool.handle)
self.container.open()
self.obj = DaosObj(self.context, self.container)
self.obj.create(objcls=1)
self.obj.open()
self.ioreq = IORequest(self.context,
self.container,
self.obj,
objtype=4)
def tearDown(self):
try:
if self.container:
self.container.close()
self.container.destroy()
if self.pool:
self.pool.disconnect()
self.pool.destroy(1)
finally:
ServerUtils.stopServer(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_single_object_validation(self):
"""
Test ID: DAOS-707
Test Description: Write Avocado Test to verify single data after pool/container
disconnect/reconnect.
:avocado: tags=single_object,data_verification,medium,vm
"""
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)
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=array_object,data_verification,array,medium,vm
"""
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
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)
basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
server_group = self.params.get("name",
'/server_config/',
'daos_server')
self.context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.d_log = DaosLog(self.context)
self.hostlist = self.params.get("test_machines", '/run/hosts/*')
self.hostfile = write_host_file.write_host_file(self.hostlist,
self.workdir)
self.no_of_dkeys = self.params.get("no_of_dkeys", '/run/dkeys/*')[0]
self.no_of_akeys = self.params.get("no_of_akeys", '/run/akeys/*')[0]
self.array_size = self.params.get("size", '/array_size/')
self.record_length = self.params.get("length", '/run/record/*')
self.agent_sessions = AgentUtils.run_agent(basepath, self.hostlist)
server_utils.run_server(self.hostfile, server_group, basepath)
self.pool = DaosPool(self.context)
self.pool.create(self.params.get("mode", '/run/pool/createmode/*'),
os.geteuid(),
os.getegid(),
self.params.get("size", '/run/pool/createsize/*'),
self.params.get("setname", '/run/pool/createset/*'),
None)
self.pool.connect(2)
self.container = DaosContainer(self.context)
self.container.create(self.pool.handle)
self.container.open()
self.obj = DaosObj(self.context, self.container)
self.obj.create(objcls=1)
self.obj.open()
self.ioreq = IORequest(self.context,
self.container,
self.obj, objtype=4)
def 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:
AgentUtils.stop_agent(self.hostlist, 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_single_object_validation(self):
"""
Test ID: DAOS-707
Test Description: Write Avocado Test to verify single data after
pool/container disconnect/reconnect.
:avocado: tags=single_object,data_verification,medium,vm
"""
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)
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=array_object,data_verification,array,medium,vm
"""
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
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.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
self.d_log = DaosLog(self.Context)
# getting hostfile
self.hostfile = None
self.hostlist = self.params.get("test_machines", '/run/hosts/*')
self.hostfile = WriteHostFile.WriteHostFile(self.hostlist,
self.workdir)
print("Host file is: {}".format(self.hostfile))
# starting server
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:
# stop servers
ServerUtils.stopServer(hosts=self.hostlist)
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 = os.geteuid()
creategid = os.getegid()
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 == 73):
expected_result = 'FAIL'
if (createmode == 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)
self.d_log.debug("Pool initialisation successful")
self.pool.create(createmode, createuid, creategid, createsize,
createsetid, None)
self.d_log.debug("Pool Creation successful")
self.pool.connect(1 << permissions)
self.d_log.debug("Pool Connect successful")
if expected_result in ['FAIL']:
self.fail("Test was expected to fail but it passed.\n")
except DaosApiError as e:
print(e)
if expected_result == 'PASS':
self.fail("Test was expected to pass but it failed.\n")
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:
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)
self.d_log.debug("Pool initialisation successful")
self.pool.create(createmode, createuid, creategid, createsize,
createsetid, None)
self.d_log.debug("Pool Creation successful")
self.pool.connect(1 << permissions)
self.d_log.debug("Pool Connect successful")
self.container = DaosContainer(self.Context)
self.d_log.debug("Contianer initialisation successful")
self.container.create(self.pool.handle)
self.d_log.debug("Container create successful")
# now open it
self.container.open()
self.d_log.debug("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)
self.d_log.debug("Container write successful")
if expected_result in ['FAIL']:
self.fail("Test was expected to fail but it passed.\n")
except DaosApiError as e:
print(e)
if expected_result == 'PASS':
self.fail("Test was expected to pass but it failed.\n")
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.server_group = self.params.get("server_group", '/server/',
'daos_default_oops')
self.context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.pool = DaosPool(self.context)
self.d_log = DaosLog(self.context)
self.hostlist = self.params.get("test_machines1", '/hosts/')
self.hostfile = WriteHostFile.WriteHostFile(self.hostlist, self.workdir)
ServerUtils.runServer(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:
ServerUtils.stopServer(hosts=self.hostlist)
def test_no_space_cont_create(self):
"""
:avocado: tags=pool,cont,fullpoolcontcreate,small,vm
"""
setid = self.params.get("setname",
'/run/testparams/setnames/validsetname/')
# 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")
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 e:
self.d_log.error("caught exception creating container: "
"{0}".format(e))
self.fail("caught exception creating container: {0}".format(e))
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 x in [1048576, 1024, 1]:
write_count = 0
while(True):
self.d_log.debug("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, 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,
x))
write_count += 1
except DaosApiError as e:
if not (err in repr(e) or err2 in repr(e)):
self.d_log.error("caught exception while writing "
"object: {0}".format(repr(e)))
self.fail("caught exception while writing object: {0}"
.format(repr(e)))
else:
self.d_log.debug("pool is too full for {0} byte "
"objects".format(x))
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 e:
if not (err in repr(e) or err2 in repr(e)):
self.d_log.error("caught unexpected exception while "
"writing object: {0}".format(repr(e)))
self.fail("caught unexpected exception while writing "
"object: {0}".format(repr(e)))
else:
self.d_log.debug("correctly caught -1007 while attempting "
"to write object in full pool")
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")
class ObjOpenBadParam(Test):
"""
Test Class Description:
Pass an assortment of bad parameters to the daos_obj_open function.
"""
def __init__(self, *args, **kwargs):
"""
Initialize values for variables that are used in tearDown() such that
if setUp() fails for any reason, tearDown() will avoid throwing
an AttributeError exception.
"""
super(ObjOpenBadParam, self).__init__(*args, **kwargs)
self.container = None
self.pool = 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.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)
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,
obj_cls=1)
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)
err_str = "Error reading back data, test failed during the " \
"initial setup."
self.d_log.error(err_str)
self.fail(err_str)
# setup leaves object in open state, so closing to start clean
self.obj.close()
except DaosApiError as e:
print(e)
print(traceback.format_exc())
self.fail("Test failed during the initial setup.")
def tearDown(self):
try:
self.container.close()
self.container.destroy()
self.pool.disconnect()
self.pool.destroy(1)
finally:
ServerUtils.stopServer()
ServerUtils.killServer(self.hostlist)
def test_bad_obj_handle(self):
"""
Test ID: DAOS-1320
Test Description: Attempt to open a garbage object handle.
:avocado: tags=object,objopen,objopenbadhand,regression,vm,small
"""
saved_handle = self.obj.oh
self.obj.oh = 8675309
try:
dummy_obj = self.obj.open()
except DaosApiError as excep:
if not "-1002" in str(excep):
self.d_log.error("test expected a -1002 but did not get it")
self.d_log.error(traceback.format_exc())
self.fail("test expected a -1002 but did not get it")
finally:
self.obj.oh = saved_handle
def test_invalid_container_handle(self):
"""
Test ID: DAOS-1320
Test Description: Attempt to open an object with a garbage container
handle.
:avocado: tags=object,objopen,objopenbadconthand,regression,vm,small
"""
saved_coh = self.container.coh
self.container.coh = 8675309
try:
dummy_obj = self.obj.open()
except DaosApiError as excep:
if not "-1002" in str(excep):
self.d_log.error("test expected a -1002 but did not get it")
self.d_log.error(traceback.format_exc())
self.fail("test expected a -1002 but did not get it")
finally:
self.container.coh = saved_coh
def test_closed_container_handle(self):
"""
Test ID: DAOS-1320
Test Description: Attempt to open an object in a container with
a closed handle.
:avocado: tags=object,objopen,objopenclosedcont,regression,vm,small
"""
self.container.close()
try:
dummy_obj = self.obj.open()
except DaosApiError as excep:
if not "-1002" in str(excep):
self.d_log.error("test expected a -1002 but did not get it")
self.d_log.error(traceback.format_exc())
self.fail("test expected a -1002 but did not get it")
finally:
self.container.open()
def test_pool_handle_as_obj_handle(self):
"""
Test ID: DAOS-1320
Test Description: Adding this test by request, this test attempts
to open an object that's had its handle set to
be the same as a valid pool handle.
:avocado: tags=object,objopen,objopenpoolhandle,regression,vm,small
"""
saved_oh = self.obj.oh
self.obj.oh = self.pool.handle
try:
dummy_obj = self.obj.open()
except DaosApiError as excep:
if not "-1002" in str(excep):
self.d_log.error("test expected a -1002 but did not get it")
self.d_log.error(traceback.format_exc())
self.fail("test expected a -1002 but did not get it")
finally:
self.obj.oh = saved_oh
def test_null_ranklist(self):
"""
Test ID: DAOS-1320
Test Description: Attempt to open an object in a container with
an empty ranklist.
:avocado: tags=object,objopen,objopennullrl,regression,vm,small
"""
# null rl
saved_rl = self.obj.tgt_rank_list
self.obj.tgt_rank_list = None
try:
dummy_obj = self.obj.open()
except DaosApiError as excep:
if not "-1003" in str(excep):
self.d_log.error("test expected a -1003 but did not get it")
self.d_log.error(traceback.format_exc())
self.fail("test expected a -1003 but did not get it")
finally:
self.obj.tgt_rank_list = saved_rl
def test_null_oid(self):
"""
Test ID: DAOS-1320
Test Description: Attempt to open an object in a container with
null object id.
:avocado: tags=object,objopen,objopennulloid,regression,vm,small
"""
# null oid
saved_oid = self.obj.c_oid
self.obj.c_oid = DaosObjId(0, 0)
try:
dummy_obj = self.obj.open()
except DaosApiError as excep:
if not "-1003" in str(excep):
self.d_log.error("Test expected a -1003 but did not get it")
self.d_log.error(traceback.format_exc())
self.fail("test expected a -1003 but did not get it")
finally:
self.obj.c_oid = saved_oid
def test_null_tgts(self):
"""
Test ID: DAOS-1320
Test Description: Attempt to open an object in a container with
null tgt.
:avocado: tags=object,objopen,objopennulltgts,regression,vm,small
"""
# null tgts
saved_ctgts = self.obj.c_tgts
self.obj.c_tgts = 0
try:
dummy_obj = self.obj.open()
except DaosApiError as excep:
if not "-1003" in str(excep):
self.d_log.error("Test expected a -1003 but did not get it")
self.d_log.error(traceback.format_exc())
self.fail("test expected a -1003 but did not get it")
finally:
self.obj.c_tgts = saved_ctgts
def test_null_attrs(self):
"""
Test ID: DAOS-1320
Test Description: Attempt to open an object in a container with
null object attributes.
:avocado: tags=object,objopen,objopennullattr,regression,vm,small
"""
# null attr
saved_attr = self.obj.attr
self.obj.attr = 0
try:
dummy_obj = self.obj.open()
except DaosApiError as excep:
if not "-1003" in str(excep):
self.d_log.error("test expected a -1003 but did not get it")
self.d_log.error(traceback.format_exc())
self.fail("test expected a -1003 but did not get it")
finally:
self.obj.attr = saved_attr
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)
basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
server_group = self.params.get("name", '/server_config/',
'daos_server')
self.context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.d_log = DaosLog(self.context)
self.hostlist = self.params.get("test_machines", '/run/hosts/*')
self.hostfile = write_host_file.write_host_file(
self.hostlist, self.workdir)
self.no_of_dkeys = self.params.get("no_of_dkeys", '/run/dkeys/*')[0]
self.no_of_akeys = self.params.get("no_of_akeys", '/run/akeys/*')[0]
self.array_size = self.params.get("size", '/array_size/')
self.record_length = self.params.get("length", '/run/record/*')
self.agent_sessions = agent_utils.run_agent(basepath, self.hostlist)
server_utils.run_server(self.hostfile, server_group, basepath)
self.pool = DaosPool(self.context)
self.pool.create(self.params.get("mode", '/run/pool/createmode/*'),
os.geteuid(), os.getegid(),
self.params.get("size", '/run/pool/createsize/*'),
self.params.get("setname", '/run/pool/createset/*'),
None)
self.pool.connect(2)
self.container = DaosContainer(self.context)
self.container.create(self.pool.handle)
self.container.open()
self.obj = DaosObj(self.context, self.container)
self.obj.create(objcls=1)
self.obj.open()
self.ioreq = IORequest(self.context,
self.container,
self.obj,
objtype=4)
def 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 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.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)
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,
obj_cls=1)
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)
err_str = "Error reading back data, test failed during the " \
"initial setup."
self.d_log.error(err_str)
self.fail(err_str)
# setup leaves object in open state, so closing to start clean
self.obj.close()
except DaosApiError as e:
print(e)
print(traceback.format_exc())
self.fail("Test failed during the initial setup.")
class CartSelfTest(Test):
"""
Runs a few variations of CaRT self-test to ensure network is in a
stable state prior to testing.
"""
# start servers, establish file locations, etc.
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'] + "/../")
tmp = build_paths['PREFIX'] + '/tmp'
self.hostlist = self.params.get("test_machines", '/run/hosts/')
self.hostfile = WriteHostFile.WriteHostFile(self.hostlist, tmp)
context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.d_log = DaosLog(context)
# self_test params
self.self_test_bin = os.path.join(build_paths["CART_PREFIX"],
"bin/self_test")
self.orterun = os.path.join(build_paths["OMPI_PREFIX"], "bin/orterun")
self.endpoint = self.params.get("endpoint", "/run/testparams/")
self.max_rpcs = self.params.get("max_inflight_rpcs",
"/run/testparams/")
self.repetitions = self.params.get("repetitions", "/run/testparams/")
self.message_size = self.params.get(
"size", "/run/muxtestparams/message_size/*")[0]
self.share_addr = self.params.get("val",
"/run/muxtestparams/share_addr/*")[0]
self.env_dict = {
"CRT_PHY_ADDR_STR": "ofi+sockets",
"CRT_CTX_NUM": "8",
"OFI_INTERFACE": "eth0",
"CRT_CTX_SHARE_ADDR": str(self.share_addr)
}
self.env_list = []
for k, v in self.env_dict.items():
self.env_list.append("-x")
self.env_list.append("{0}={1}".format(k, v))
# daos server params
self.server_group = self.params.get("server", 'server_group',
'daos_server')
self.uri_file = os.path.join(self.basepath, "install", "tmp",
"uri.txt")
ServerUtils.runServer(self.hostfile,
self.server_group,
self.basepath,
uri_path=self.uri_file,
env_dict=self.env_dict)
def tearDown(self):
try:
os.remove(self.hostfile)
os.remove(self.uri_file)
finally:
ServerUtils.stopServer(hosts=self.hostlist)
def test_self_test(self):
"""
Run a few CaRT self-test scenarios
:avocado: tags=network,small,quick,cartselftest
"""
base_cmd = [
self.orterun, "-np", "1", "-ompi-server",
"file:{0}".format(self.uri_file)
]
selftest = [
self.self_test_bin, "--group-name",
"{0}".format(self.server_group), "--endpoint",
"{0}".format(self.endpoint), "--message-sizes",
"{0}".format(self.message_size), "--max-inflight-rpcs",
"{0}".format(self.max_rpcs), "--repetitions",
"{0}".format(self.repetitions)
]
cmd = base_cmd + self.env_list + selftest
cmd_log_str = ""
for x in cmd:
cmd_log_str += x + " "
try:
self.d_log.info("Running cmd {0}".format(cmd_log_str))
subprocess.check_output(cmd, stderr=subprocess.STDOUT)
except subprocess.CalledProcessError as exc:
self.d_log.error("CaRT self_test returned non-zero. "
"rc {0}:".format(exc.returncode))
for line in exc.output.split('\n'):
self.d_log.error("{0}".format(line))
self.fail("CaRT self_test returned non-zero")
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
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 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