def setUp(self):
# get paths from the build_vars generated by build
with open('../../../.build_vars.json') as f:
build_paths = json.load(f)
self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
self.server_group = self.params.get("server_group", '/server/',
'daos_server')
# setup the DAOS python API
self.Context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.hostlist_servers = self.params.get("test_servers", '/run/hosts/')
self.hostfile_servers = WriteHostFile.WriteHostFile(
self.hostlist_servers, self.workdir)
print("Host file servers is: {}".format(self.hostfile_servers))
self.hostlist_clients = self.params.get("test_clients", '/run/hosts/')
self.hostfile_clients = WriteHostFile.WriteHostFile(
self.hostlist_clients, self.workdir)
print("Host file clients is: {}".format(self.hostfile_clients))
# start servers
ServerUtils.runServer(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 build_file:
build_paths = json.load(build_file)
self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
self.server_group = self.params.get("name", '/server_config/',
'daos_server')
# setup the DAOS python API
self.context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.hostlist_servers = self.params.get("test_servers", '/run/hosts/*')
hostfile_servers = (write_host_file.write_host_file(
self.hostlist_servers, self.workdir))
print("Host file servers is: {}".format(hostfile_servers))
self.hostlist_clients = self.params.get("test_clients", '/run/hosts/*')
self.slots = self.params.get("slots", '/run/ior/clientslots/*')
self.hostfile_clients = (write_host_file.write_host_file(
self.hostlist_clients, self.workdir, self.slots))
print("Host file clients is: {}".format(self.hostfile_clients))
self.agent_sessions = agent_utils.run_agent(self.basepath,
self.hostlist_servers,
self.hostlist_clients)
server_utils.run_server(hostfile_servers, self.server_group,
self.basepath)
def setUp(self):
# get paths from the build_vars generated by build
with open('../../../.build_vars.json') as f:
build_paths = json.load(f)
self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
self.server_group = self.params.get("server_group", '/server/',
'daos_server')
# setup the DAOS python API
self.Context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.hostlist_servers = self.params.get("test_servers",
'/run/hosts/test_machines/*')
self.hostfile_servers = WriteHostFile.WriteHostFile(
self.hostlist_servers, self.workdir)
print("Host file servers is: {}".format(self.hostfile_servers))
hostlist_clients = self.params.get("test_clients",
'/run/hosts/test_machines/*')
self.slots = self.params.get("slots", '/run/ior/clientslots/*')
self.hostfile_clients = WriteHostFile.WriteHostFile(
hostlist_clients, self.workdir, self.slots)
print("Host file clients is: {}".format(self.hostfile_clients))
ServerUtils.runServer(self.hostfile_servers, self.server_group,
self.basepath)
if not distutils.spawn.find_executable("ior") and \
int(str(self.name).split("-")[0]) == 1:
IorUtils.build_ior(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')
self.daosctl = self.basepath + '/install/bin/daosctl'
# setup the DAOS python API
self.Context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.POOL = None
self.hostlist_servers = self.params.get("test_servers",
'/run/hosts/test_machines/*')
self.hostfile_servers = WriteHostFile.WriteHostFile(
self.hostlist_servers, self.workdir)
print("Host file servers is: {}".format(self.hostfile_servers))
self.hostlist_clients = self.params.get(
"clients", '/run/hosts/test_machines/diff_clients/*')
self.hostfile_clients = WriteHostFile.WriteHostFile(
self.hostlist_clients, self.workdir)
print("Host file clientsis: {}".format(self.hostfile_clients))
ServerUtils.runServer(self.hostfile_servers, self.server_group,
self.basepath)
if int(str(self.name).split("-")[0]) == 1:
IorUtils.build_ior(self.basepath)
def check_handle(buf_len, iov_len, buf, uuidstr, rank):
"""
This gets run in a child process and verifyes the global
handle can be turned into a local handle in another process.
"""
try:
# get paths from the build_vars generated by build
with open('../../../.build_vars.json') as build_file:
build_paths = json.load(build_file)
# setup the DAOS python API in this process
context = DaosContext(build_paths['PREFIX'] + '/lib/')
pool = DaosPool(context)
pool.set_uuid_str(uuidstr)
pool.set_svc(rank)
pool.group = "daos_server"
# note that the handle is stored inside the pool as well
dummy_local_handle = pool.global2local(context, iov_len, buf_len, buf)
# perform some operations that will use the new handle
pool.pool_query()
container = DaosContainer(context)
container.create(pool.handle)
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
raise
return
def setUp(self):
# get paths from the build_vars generated by build
with open('../../../.build_vars.json') as f:
self.build_paths = json.load(f)
# setup the DAOS python API
self.Context = DaosContext(self.build_paths['PREFIX'] + '/lib/')
def setUp(self):
self.agent_sessions = None
# get paths from the build_vars generated by build
with open('../../../.build_vars.json') as build_file:
build_paths = json.load(build_file)
self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
self.server_group = self.params.get("name", '/server_config/',
'daos_server')
# setup the DAOS python API
self.context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.hostlist_servers = self.params.get("test_servers",
'/run/hosts/test_machines/*')
self.hostfile_servers = (write_host_file.write_host_file(
self.hostlist_servers, self.workdir))
print("Host file servers is: {}".format(self.hostfile_servers))
self.hostlist_clients = self.params.get("test_clients",
'/run/hosts/test_machines/*')
self.slots = self.params.get("slots", '/run/ior/clientslots/*')
self.hostfile_clients = (write_host_file.write_host_file(
self.hostlist_clients, self.workdir, self.slots))
print("Host file clients is: {}".format(self.hostfile_clients))
self.agent_sessions = agent_utils.run_agent(self.basepath,
self.hostlist_servers,
self.hostlist_clients)
server_utils.run_server(self.hostfile_servers, self.server_group,
self.basepath)
if not distutils.spawn.find_executable("ior") and \
int(str(self.name).split("-")[0]) == 1:
ior_utils.build_ior(self.basepath)
def setUp(self):
"""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('../../../.build_vars.json') as f:
build_paths = json.load(f)
self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
self.tmp = build_paths['PREFIX'] + '/tmp'
self.server_group = self.params.get("server_group", '/server/',
'daos_server')
# parameters used in pool create
self.createmode = self.params.get("mode",
'/run/createtests/createmode/')
self.createuid = os.geteuid()
self.creategid = os.getegid()
self.createsetid = self.params.get("setname",
'/run/createtests/createset/')
self.createsize = self.params.get("size",
'/run/createtests/createsize/')
# setup the DAOS python API
self.Context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.POOL = None
self.CONTAINER = None
self.hostfile = None
hostlist = self.params.get("test_machines", '/run/hosts/*')
self.hostfile = WriteHostFile.WriteHostFile(hostlist, self.tmp)
ServerUtils.runServer(self.hostfile, self.server_group, self.basepath)
def setUp(self):
""" setup for the test """
self.agent_sessions = None
# get paths from the build_vars generated by build
with open('../../../.build_vars.json') as build_file:
build_paths = json.load(build_file)
self.context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
# generate a hostfile
self.hostlist_servers = self.params.get("test_machines", '/run/hosts/')
self.hostfile_servers = write_host_file.write_host_file(
self.hostlist_servers, self.workdir)
# fire up the DAOS servers
self.server_group = self.params.get("name", '/run/server_config/',
'daos_server')
self.agent_sessions = agent_utils.run_agent(self.basepath,
self.hostlist_servers)
server_utils.run_server(self.hostfile_servers, self.server_group,
build_paths['PREFIX'] + '/../')
# create a pool to test with
createmode = self.params.get("mode", '/run/pool/createmode/')
createuid = self.params.get("uid", '/run/pool/createuid/')
creategid = self.params.get("gid", '/run/pool/creategid/')
createsetid = self.params.get("setname", '/run/pool/createset/')
createsize = self.params.get("size", '/run/pool/createsize/')
self.pool = DaosPool(self.context)
self.pool.create(createmode, createuid, creategid, createsize,
createsetid)
self.pool.get_uuid_str()
time.sleep(2)
def setUp(self):
with open('../../../.build_vars.json') as json_f:
build_paths = json.load(json_f)
basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
tmp = build_paths['PREFIX'] + '/tmp'
server_group = self.params.get("server_group", '/server/',
'daos_server')
self.context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.hostlist = self.params.get("test_machines", '/run/hosts/*')
self.hostfile = WriteHostFile.WriteHostFile(self.hostlist, tmp)
ServerUtils.runServer(self.hostfile, server_group, basepath)
self.pool = DaosPool(self.context)
self.pool.create(self.params.get("mode", '/run/pool/createmode/*'),
os.geteuid(), os.getegid(),
self.params.get("size", '/run/pool/createsize/*'),
self.params.get("setname", '/run/pool/createset/*'),
None)
self.pool.connect(1 << 1)
poh = self.pool.handle
self.container = DaosContainer(self.context)
self.container.create(poh)
self.container.open()
def setUp(self):
# get paths from the build_vars generated by build
with open('../../../.build_vars.json') as build_file:
build_paths = json.load(build_file)
self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
self.server_group = self.params.get("name", '/server_config/',
'daos_server')
self.daosctl = self.basepath + '/install/bin/daosctl'
# setup the DAOS python API
self.context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.pool = None
self.hostlist_servers = self.params.get("test_servers",
'/run/hosts/test_machines/*')
self.hostfile_servers = (write_host_file.write_host_file(
self.hostlist_servers, self.workdir))
print("Host file servers is: {}".format(self.hostfile_servers))
self.hostlist_clients = self.params.get("test_clients",
'/run/hosts/test_machines/*')
self.hostfile_clients = (write_host_file.write_host_file(
self.hostlist_clients, self.workdir, None))
print("Host file clientsis: {}".format(self.hostfile_clients))
# set ior_flags and object class to be used by test
self.ior_flags = self.params.get("F", '/run/ior/iorflags/')
self.object_class = self.params.get("o", '/run/ior/objectclass/')
self.agent_sessions = agent_utils.run_agent(self.basepath,
self.hostlist_servers,
self.hostlist_clients)
server_utils.run_server(self.hostfile_servers, self.server_group,
self.basepath)
def setUp(self):
self.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):
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):
""" setup for the test """
# get paths from the build_vars generated by build
with open('../../../.build_vars.json') as f:
build_paths = json.load(f)
self.CONTEXT = DaosContext(build_paths['PREFIX'] + '/lib/')
# generate a hostfile
self.hostlist = self.params.get("test_machines",'/run/hosts/')
tmp = build_paths['PREFIX'] + '/tmp'
self.hostfile = WriteHostFile.WriteHostFile(self.hostlist, tmp)
# fire up the DAOS servers
self.server_group = self.params.get("server_group",'/run/server/',
'daos_server')
ServerUtils.runServer(self.hostfile, self.server_group,
build_paths['PREFIX'] + '/../')
time.sleep(3)
# create a pool to test with
createmode = self.params.get("mode",'/run/pool/createmode/')
createuid = self.params.get("uid",'/run/pool/createuid/')
creategid = self.params.get("gid",'/run/pool/creategid/')
createsetid = self.params.get("setname",'/run/pool/createset/')
createsize = self.params.get("size",'/run/pool/createsize/')
self.POOL = DaosPool(self.CONTEXT)
self.POOL.create(createmode, createuid, creategid, createsize,
createsetid)
uuid = self.POOL.get_uuid_str()
time.sleep(2)
def setUp(self):
# initialising variables
self.basepath = None
self.server_group = None
self.context = None
self.pool = None
self.mpio = None
self.agent_sessions = None
self.hostlist_servers = None
self.hostfile_servers = None
self.hostlist_clients = None
self.hostfile_clients = None
self.createsvc = None
# get paths from the build_vars generated by build
with open('../../../.build_vars.json') as var_file:
build_paths = json.load(var_file)
self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
self.server_group = self.params.get("name", '/server_config/',
'daos_server')
# setup the DAOS python API
self.context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.hostlist_servers = self.params.get("test_servers", '/run/hosts/')
self.hostfile_servers = write_host_file.write_host_file(
self.hostlist_servers, self.workdir)
print("Host file servers is: {}".format(self.hostfile_servers))
self.hostlist_clients = self.params.get("test_clients", '/run/hosts/')
self.hostfile_clients = write_host_file.write_host_file(
self.hostlist_clients, self.workdir, None)
print("Host file clients is: {}".format(self.hostfile_clients))
self.agent_sessions = AgentUtils.run_agent(self.basepath,
self.hostlist_servers,
self.hostlist_clients)
# start servers
server_utils.run_server(self.hostfile_servers, self.server_group,
self.basepath)
try:
# parameters used in pool create
createmode = self.params.get("mode", '/run/pool/createmode/*/')
createuid = os.geteuid()
creategid = os.getegid()
createsetid = self.params.get("setname", '/run/pool/createset/')
createsize = self.params.get("size", '/run/pool/createsize/')
self.createsvc = self.params.get("svcn", '/run/pool/createsvc/')
# initialize a python pool object then create the underlying
# daos storage
self.pool = DaosPool(self.context)
self.pool.create(createmode, createuid, creategid, createsize,
createsetid, None, None, self.createsvc)
except (DaosApiError) as excep:
self.fail("<Test Failed at pool create> \n{1}".format(excep))
def check_handle(pool_glob_handle, uuidstr, cont_glob_handle, rank):
"""
This gets run in a child process and verifyes the global
handles can be turned into local handles in another process.
"""
try:
# get paths from the build_vars generated by build
with open('../../../.build_vars.json') as build_file:
build_paths = json.load(build_file)
# setup the DAOS python API in this process
context = DaosContext(build_paths['PREFIX'] + '/lib/')
# setup the pool and connect using global handle
pool = DaosPool(context)
pool.uuid = uuidstr
pool.set_svc(rank)
pool.group = "daos_server"
buf = ctypes.cast(pool_glob_handle.iov_buf,
ctypes.POINTER(ctypes.c_byte *
pool_glob_handle.iov_buf_len))
buf2 = bytearray()
buf2.extend(buf.contents)
pool_handle = pool.global2local(context,
pool_glob_handle.iov_len,
pool_glob_handle.iov_buf_len,
buf2)
# perform an operation that will use the new handle, if it
# doesn't throw an exception, then all is well.
pool.pool_query()
# setup the container and then connect using the global handle
container = DaosContainer(context)
container.poh = pool_handle
buf = ctypes.cast(cont_glob_handle.iov_buf,
ctypes.POINTER(ctypes.c_byte *
cont_glob_handle.iov_buf_len))
buf2 = bytearray()
buf2.extend(buf.contents)
dummy_cont_handle = container.global2local(context,
cont_glob_handle.iov_len,
cont_glob_handle.iov_buf_len,
buf2)
# just try one thing to make sure handle is good
container.query()
except DaosApiError as excep:
print(excep)
print(traceback.format_exc())
raise
return
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/')
def setUp(self):
# there is a presumption that this test lives in a specific
# spot in the repo
with open('../../../.build_vars.json') as f:
build_paths = json.load(f)
self.basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
self.tmp = build_paths['PREFIX'] + '/tmp'
self.server_group = self.params.get("server_group", '/server/',
'daos_server')
# setup the DAOS python API
self.Context = DaosContext(build_paths['PREFIX'] + '/lib/')
def setUp(self):
try:
# get paths from the build_vars generated by build
with open('../../../.build_vars.json') as f:
build_paths = json.load(f)
self.basepath = os.path.normpath(build_paths['PREFIX'] +
"/../")
self.tmp = build_paths['PREFIX'] + '/tmp'
self.server_group = self.params.get("server_group", '/server/',
'daos_server')
# setup the DAOS python API
self.Context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.hostlist = self.params.get("test_machines",
'/run/hosts/*')
self.hostfile = WriteHostFile.WriteHostFile(
self.hostlist, self.tmp)
ServerUtils.runServer(self.hostfile, self.server_group,
self.basepath)
# parameters used in pool create
createmode = self.params.get("mode", '/run/pool/createmode/')
createsetid = self.params.get("setname",
'/run/pool/createset/')
createsize = self.params.get("size", '/run/pool/createsize/')
createuid = os.geteuid()
creategid = os.getegid()
# initialize a python pool object then create the underlying
# daos storage
self.pool = DaosPool(self.Context)
self.pool.create(createmode, createuid, creategid, createsize,
createsetid, None)
self.pool.connect(1 << 1)
# create a container
self.container = DaosContainer(self.Context)
self.container.create(self.pool.handle)
# now open it
self.container.open()
except DaosApiError as e:
print(e)
print(traceback.format_exc())
self.fail("Test failed during setup.\n")
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('../../../.build_vars.json') as finput:
build_paths = json.load(finput)
basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
server_group = self.params.get("name", '/server_config/',
'daos_server')
# setup the DAOS python API
self.context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.d_log = DaosLog(self.context)
self.hostlist = self.params.get("test_machines", '/run/hosts/*')
hostfile = write_host_file.write_host_file(self.hostlist, self.workdir)
server_utils.run_server(hostfile, server_group, basepath)
# Set up the pool and container.
try:
# parameters used in pool create
createmode = self.params.get("mode", '/run/pool/createmode/')
createsetid = self.params.get("setname", '/run/pool/createset/')
createsize = self.params.get("size", '/run/pool/createsize/*')
createuid = os.geteuid()
creategid = os.getegid()
# initialize a pool object then create the underlying
# daos storage
self.pool = DaosPool(self.context)
self.pool.create(createmode, createuid, creategid, createsize,
createsetid, None)
# need a connection to create container
self.pool.connect(1 << 1)
# create a container
self.container = DaosContainer(self.context)
self.container.create(self.pool.handle)
# now open it
self.container.open()
except DaosApiError as error:
print(error)
print(traceback.format_exc())
self.fail("Test failed before snapshot taken")
def setUp(self):
# get paths from the build_vars generated by build
with open(
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):
# 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):
self.pool = None
self.hostlist = None
with open('../../../.build_vars.json') as filep:
build_paths = json.load(filep)
basepath = os.path.normpath(build_paths['PREFIX'] + "/../")
self.context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.hostlist = self.params.get("test_machines", '/run/hosts/')
hostfile = WriteHostFile.WriteHostFile(self.hostlist, self.workdir)
server_group = self.params.get("server_group", '/server/',
'daos_server')
ServerUtils.runServer(self.hostfile, server_group, basepath)
def setUp(self):
self.hostlist = None
# 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/')
# setup the DAOS python API
self.context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.hostlist = self.params.get("test_machines",'/run/hosts/*')
hostfile = WriteHostFile.WriteHostFile(self.hostlist, self.workdir)
ServerUtils.runServer(hostfile, self.server_group, self.basepath)
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/')
print("initialized!!!\n")
self.pool = DaosPool(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 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):
# get paths from the build_vars generated by build
with open('../../../.build_vars.json') as f:
self.build_paths = json.load(f)
# setup the DAOS python API
self.Context = DaosContext(self.build_paths['PREFIX'] + '/lib/')
server_group = self.params.get("server_group", '/server/',
'daos_server')
basepath = os.path.normpath(self.build_paths['PREFIX'] + "/../")
tmp = self.build_paths['PREFIX'] + '/tmp'
self.hostlist = self.params.get("test_machines", '/run/hosts/')
self.hostfile = WriteHostFile.WriteHostFile(self.hostlist, tmp)
ServerUtils.runServer(self.hostfile, server_group, 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.tmp = build_paths['PREFIX'] + '/tmp'
self.server_group = self.params.get("server_group",'/server/','daos_server')
# setup the DAOS python API
self.Context = DaosContext(build_paths['PREFIX'] + '/lib/')
self.POOL = None
hostlist = self.params.get("test_machines",'/run/hosts/*')
self.hostfile = WriteHostFile.WriteHostFile(hostlist, self.tmp)
print("Host file is: {}".format(self.hostfile))
ServerUtils.runServer(self.hostfile, self.server_group, self.basepath)
time.sleep(10)
