def testLayoutReturnFsid(t, env):
"""
Return all of a filesystem's layouts
FLAGS: pnfs
DEPEND: GETLAYOUT1
CODE: LAYOUTRET2
"""
sess = env.c1.new_pnfs_client_session(env.testname(t))
blocksize = get_blocksize(sess, use_obj(env.opts.path))
# Create the file
res = create_file(sess, env.testname(t))
check(res)
# Get layout
fh = res.resarray[-1].object
open_stateid = res.resarray[-2].stateid
ops = [op.putfh(fh),
op.layoutget(False, LAYOUT4_BLOCK_VOLUME, LAYOUTIOMODE4_READ,
0, 0xffffffffffffffff, 4*blocksize, open_stateid, 0xffff)]
res = sess.compound(ops)
check(res)
# Return layout
ops = use_obj(env.opts.path) + \
[op.layoutreturn(False, LAYOUT4_BLOCK_VOLUME, LAYOUTIOMODE4_ANY,
layoutreturn4(LAYOUTRETURN4_FSID))]
res = sess.compound(ops)
check(res)
def testGetDevList(t, env):
"""Check devlist
FLAGS: pnfs
CODE: GETDLIST1
"""
# Make sure E_ID returns MDS capabilities
c1 = env.c1.new_client(env.testname(t), flags=EXCHGID4_FLAG_USE_PNFS_MDS)
if not c1.flags & EXCHGID4_FLAG_USE_PNFS_MDS:
fail("Server did not set EXCHGID4_FLAG_USE_PNFS_MDS")
sess = c1.create_session()
# Test that fs handles block layouts
ops = use_obj(env.opts.path) + [op.getattr(1<<FATTR4_FS_LAYOUT_TYPE)]
res = sess.compound(ops)
check(res)
if FATTR4_FS_LAYOUT_TYPE not in res.resarray[-1].obj_attributes:
fail("fs_layout_type not available")
for lo_type in res.resarray[-1].obj_attributes[FATTR4_FS_LAYOUT_TYPE]:
# Send GETDEVICELIST
ops = use_obj(env.opts.path) + [op.getdevicelist(lo_type, 0xffffffff, 0, "")]
res = sess.compound(ops)
check(res)
# STUB - check block stuff
dev_list = res.resarray[-1].gdlr_deviceid_list
print dev_list
def testGetDevInfo(t, env):
"""Check devlist
FLAGS: pnfs
DEPEND: GETDLIST1
CODE: GETDINFO1
"""
sess = env.c1.new_pnfs_client_session(env.testname(t))
# Test that fs handles block layouts
ops = use_obj(env.opts.path) + [op.getattr(1<<FATTR4_FS_LAYOUT_TYPES)]
res = sess.compound(ops)
check(res)
if FATTR4_FS_LAYOUT_TYPES not in res.resarray[-1].obj_attributes:
fail("fs_layout_type not available")
for lo_type in res.resarray[-1].obj_attributes[FATTR4_FS_LAYOUT_TYPES]:
# Send GETDEVICELIST
lo_type = LAYOUT4_BLOCK_VOLUME
ops = use_obj(env.opts.path) + [op.getdevicelist(lo_type, 0xffffffff, 0, "")]
res = sess.compound(ops)
check(res)
dev_list = res.resarray[-1].gdlr_deviceid_list
p = BlockUnpacker("")
for dev_id in dev_list:
ops = use_obj(env.opts.path) + [op.getdeviceinfo(dev_id, lo_type, 0xffffffff, 0)]
res = sess.compound(ops)
check(res)
if lo_type==LAYOUT4_BLOCK_VOLUME:
p.reset(res.resarray[-1].da_addr_body)
decode = p.unpack_pnfs_block_deviceaddr4()
p.done()
print decode
def testGetDevInfo(t, env):
"""Check devlist
FLAGS: pnfs
DEPEND: GETDLIST1
CODE: GETDINFO1
"""
# Make sure E_ID returns MDS capabilities
c1 = env.c1.new_client(env.testname(t), flags=EXCHGID4_FLAG_USE_PNFS_MDS)
if not c1.flags & EXCHGID4_FLAG_USE_PNFS_MDS:
fail("Server did not set EXCHGID4_FLAG_USE_PNFS_MDS")
sess = c1.create_session()
# Test that fs handles block layouts
ops = use_obj(env.opts.path) + [op.getattr(1<<FATTR4_FS_LAYOUT_TYPE)]
res = sess.compound(ops)
check(res)
if FATTR4_FS_LAYOUT_TYPE not in res.resarray[-1].obj_attributes:
fail("fs_layout_type not available")
for lo_type in res.resarray[-1].obj_attributes[FATTR4_FS_LAYOUT_TYPE]:
# Send GETDEVICELIST
lo_type = LAYOUT4_BLOCK_VOLUME
ops = use_obj(env.opts.path) + [op.getdevicelist(lo_type, 0xffffffff, 0, "")]
res = sess.compound(ops)
check(res)
dev_list = res.resarray[-1].gdlr_deviceid_list
p = BlockUnpacker("")
for dev_id in dev_list:
ops = use_obj(env.opts.path) + [op.getdeviceinfo(dev_id, lo_type, 0xffffffff, 0)]
res = sess.compound(ops)
check(res)
if lo_type==LAYOUT4_BLOCK_VOLUME:
p.reset(res.resarray[-1].da_addr_body)
decode = p.unpack_pnfs_block_deviceaddr4()
p.done()
print decode
def testGetDevList(t, env):
"""Check devlist
FLAGS: getdevicelist all
CODE: GETDLIST1
"""
# Make sure E_ID returns MDS capabilities
c1 = env.c1.new_client(env.testname(t), flags=EXCHGID4_FLAG_USE_PNFS_MDS)
if not c1.flags & EXCHGID4_FLAG_USE_PNFS_MDS:
fail("Server did not set EXCHGID4_FLAG_USE_PNFS_MDS")
sess = c1.create_session()
# Test that fs handles block layouts
ops = use_obj(env.opts.path) + [op.getattr(1 << FATTR4_FS_LAYOUT_TYPE)]
res = sess.compound(ops)
check(res)
if FATTR4_FS_LAYOUT_TYPE not in res.resarray[-1].obj_attributes:
fail("fs_layout_type not available")
for lo_type in res.resarray[-1].obj_attributes[FATTR4_FS_LAYOUT_TYPE]:
# Send GETDEVICELIST
ops = use_obj(
env.opts.path) + [op.getdevicelist(lo_type, 0xffffffff, 0, "")]
res = sess.compound(ops)
check(res)
# STUB - check block stuff
dev_list = res.resarray[-1].gdlr_deviceid_list
print dev_list
def testGetDevInfo(t, env):
"""Check devlist
FLAGS: pnfs
DEPEND: GETDLIST1
CODE: GETDINFO1
"""
# Make sure E_ID returns MDS capabilities
c1 = env.c1.new_client(env.testname(t), flags=EXCHGID4_FLAG_USE_PNFS_MDS)
if not c1.flags & EXCHGID4_FLAG_USE_PNFS_MDS:
fail("Server did not set EXCHGID4_FLAG_USE_PNFS_MDS")
sess = c1.create_session()
# Test that fs handles block layouts
ops = use_obj(env.opts.path) + [op.getattr(1<<FATTR4_FS_LAYOUT_TYPES)]
res = sess.compound(ops)
check(res)
if FATTR4_FS_LAYOUT_TYPES not in res.resarray[-1].obj_attributes:
fail("fs_layout_type not available")
for lo_type in res.resarray[-1].obj_attributes[FATTR4_FS_LAYOUT_TYPES]:
# Send GETDEVICELIST
lo_type = LAYOUT4_BLOCK_VOLUME
ops = use_obj(env.opts.path) + [op.getdevicelist(lo_type, 0xffffffff, 0, "")]
res = sess.compound(ops)
check(res)
dev_list = res.resarray[-1].gdlr_deviceid_list
p = BlockUnpacker("")
for dev_id in dev_list:
ops = use_obj(env.opts.path) + [op.getdeviceinfo(dev_id, lo_type, 0xffffffff, 0)]
res = sess.compound(ops)
check(res)
if lo_type==LAYOUT4_BLOCK_VOLUME:
p.reset(res.resarray[-1].da_addr_body)
decode = p.unpack_pnfs_block_deviceaddr4()
p.done()
print decode
def _try_mand(t, env, path):
c1 = env.c1.new_client(env.testname(t))
sess1 = c1.create_session()
mand_bits = [attr.bitnum for attr in env.attr_info if attr.mandatory and attr.name != "rdattr_error"]
dict = do_getattrdict(sess1, path, mand_bits)
ops = use_obj(path) + [op.verify(dict)] + use_obj(path)
res = sess1.compound(ops)
check(res, msg="Verifying mandatory attributes against getattr")
def _try_mand(t, env, path):
c1 = env.c1.new_client(env.testname(t))
sess1 = c1.create_session()
mand_bits = [
attr.bitnum for attr in env.attr_info
if attr.mandatory and attr.name != 'rdattr_error'
]
dict = do_getattrdict(sess1, path, mand_bits)
ops = use_obj(path) + [op.verify(dict)] + use_obj(path)
res = sess1.compound(ops)
check(res, msg="Verifying mandatory attributes against getattr")
def testLayoutReturnFsid(t, env):
"""
Return all of a filesystem's layouts
FLAGS: pnfs
DEPEND: GETLAYOUT1
CODE: LAYOUTRET2
"""
# Make sure E_ID returns MDS capabilities
c1 = env.c1.new_client(env.testname(t), flags=EXCHGID4_FLAG_USE_PNFS_MDS)
if not c1.flags & EXCHGID4_FLAG_USE_PNFS_MDS:
fail("Server can not be used as pnfs metadata server")
sess = c1.create_session()
print sess.c.homedir
# Create the file
res = create_file(sess, env.testname(t))
check(res)
# Get layout
fh = res.resarray[-1].object
open_stateid = res.resarray[-2].stateid
ops = [op.putfh(fh),
op.layoutget(False, LAYOUT4_BLOCK_VOLUME, LAYOUTIOMODE4_READ,
0, 0xffffffffffffffff, 0, open_stateid, 0xffff)]
res = sess.compound(ops)
check(res)
# Return layout
ops = use_obj(env.opts.path) + \
[op.layoutreturn(False, LAYOUT4_BLOCK_VOLUME, LAYOUTIOMODE4_ANY,
layoutreturn4(LAYOUTRETURN4_FSID))]
res = sess.compound(ops)
check(res)
def testEMCGetLayout(t, env):
"""Verify layout handling
Debugging test that looks for pre-existing file (server2fs1/dump.eth)
so we don't have to worry about creating a file.
FLAGS:
CODE: GETLAYOUT100
"""
sess = env.c1.new_pnfs_client_session(env.testname(t))
blocksize = get_blocksize(sess, use_obj(env.opts.path))
# Create the file
file = ["server2fs1", "dump.eth"]
res = open_file(sess, env.testname(t), file)
check(res)
# Get layout
fh = res.resarray[-1].object
stateid = res.resarray[-2].stateid
stateid.seqid = 0
ops = [op.putfh(fh),
op.layoutget(False, LAYOUT4_BLOCK_VOLUME, LAYOUTIOMODE4_READ,
0, 0xffffffffffffffff, 4*blocksize, stateid, 0xffff)]
res = sess.compound(ops)
check(res)
# Parse opaque
for layout in res.resarray[-1].logr_layout:
if layout.loc_type == LAYOUT4_BLOCK_VOLUME:
p = BlockUnpacker(layout.loc_body)
opaque = p.unpack_pnfs_block_layout4()
p.done()
print opaque
def testGetLayout(t, env):
"""Verify layout handling
FLAGS: pnfs
CODE: GETLAYOUT1
"""
sess = env.c1.new_pnfs_client_session(env.testname(t))
blocksize = get_blocksize(sess, use_obj(env.opts.path))
# Create the file
res = create_file(sess, env.testname(t))
check(res)
# Get layout
fh = res.resarray[-1].object
open_stateid = res.resarray[-2].stateid
ops = [op.putfh(fh),
op.layoutget(False, LAYOUT4_BLOCK_VOLUME, LAYOUTIOMODE4_READ,
0, 0xffffffffffffffff, 4*blocksize, open_stateid, 0xffff)]
res = sess.compound(ops)
check(res)
# Parse opaque
for layout in res.resarray[-1].logr_layout:
if layout.loc_type == LAYOUT4_BLOCK_VOLUME:
p = BlockUnpacker(layout.loc_body)
opaque = p.unpack_pnfs_block_layout4()
p.done()
print opaque
def testSupported2(t, env):
"""GETFH after do a SECINFO_NO_NAME or SECINFO
result in a NOFILEHANDLE error, See rfc 5661 section 2.6.3.1.1.8
FLAGS: all
CODE: SEC2
"""
name = env.testname(t)
sess = env.c1.new_client_session(env.testname(t))
# Create a tmpfile for testing
owner = "owner_%s" % name
path = sess.c.homedir + [name]
res = create_file(sess, owner, path, access=OPEN4_SHARE_ACCESS_WRITE)
check(res)
fh = res.resarray[-1].object
stateid = res.resarray[-2].stateid
# Get the filehandle of the tmpfile's parent dir
res = sess.compound(use_obj(sess.c.homedir) + [op.getfh()])
check(res)
fh_p = res.resarray[-1].object
# GETFH after do a SECINFO should get error NFS4ERR_NOFILEHANDLE
res = sess.compound([op.putfh(fh_p), op.secinfo(name), op.getfh()])
check(res, NFS4ERR_NOFILEHANDLE)
# Cleanup
res = sess.compound([op.putfh(fh), op.close(0, stateid)])
check(res)
def testSupported(t, env):
"""Do a simple SECINFO
FLAGS: all
CODE: SEC1
"""
name = env.testname(t)
sess = env.c1.new_client_session(env.testname(t))
# Create a tmpfile for testing
owner = "owner_%s" % name
path = sess.c.homedir + [name]
res = create_file(sess, owner, path, access=OPEN4_SHARE_ACCESS_WRITE)
check(res)
fh = res.resarray[-1].object
stateid = res.resarray[-2].stateid
# Get the filehandle of the tmpfile's parent dir
res = sess.compound(use_obj(sess.c.homedir) + [op.getfh()])
check(res)
fh_p = res.resarray[-1].object
# Just do a simple SECINFO
res = sess.compound([op.putfh(fh_p), op.secinfo(name)])
check(res)
# Cleanup
res = sess.compound([op.putfh(fh), op.close(0, stateid)])
check(res)
def testSupported2(t, env):
"""GETFH after do a SECINFO_NO_NAME or SECINFO
result in a NOFILEHANDLE error, See rfc 5661 section 2.6.3.1.1.8
FLAGS: all
CODE: SEC2
"""
name = env.testname(t)
c = env.c1.new_client(env.testname(t))
sess = c.create_session()
# Create a tmpfile for testing
owner = "owner_%s" % name
path = sess.c.homedir + [name]
res = create_file(sess, owner, path, access=OPEN4_SHARE_ACCESS_WRITE)
check(res)
# Get the filehandle of the tmpfile's parent dir
res = sess.compound(use_obj(sess.c.homedir) + [op.getfh()])
check(res)
fh = res.resarray[-1].object
# GETFH after do a SECINFO should get error NFS4ERR_NOFILEHANDLE
res = sess.compound([op.putfh(fh), op.secinfo(name), op.getfh()])
check(res, NFS4ERR_NOFILEHANDLE)
def testSupported(t, env):
"""Do a simple SECINFO
FLAGS: all
CODE: SEC1
"""
name = env.testname(t)
sess = env.c1.new_client_session(env.testname(t))
# Create a tmpfile for testing
owner = "owner_%s" % name
path = sess.c.homedir + [name]
res = create_file(sess, owner, path, access=OPEN4_SHARE_ACCESS_WRITE)
check(res)
fh = res.resarray[-1].object
stateid = res.resarray[-2].stateid
# Get the filehandle of the tmpfile's parent dir
res = sess.compound(use_obj(sess.c.homedir) + [op.getfh()])
check(res)
fh_p = res.resarray[-1].object
# Just do a simple SECINFO
res = sess.compound([op.putfh(fh_p), op.secinfo(name)])
check(res)
# Cleanup
res = sess.compound([op.putfh(fh), op.close(0, stateid)])
check(res)
def testLayoutReturnFsid(t, env):
"""
Return all of a filesystem's layouts
FLAGS: layoutreturn all
DEPEND: GETLAYOUT1
CODE: LAYOUTRET2
"""
# Make sure E_ID returns MDS capabilities
c1 = env.c1.new_client(env.testname(t), flags=EXCHGID4_FLAG_USE_PNFS_MDS)
if not c1.flags & EXCHGID4_FLAG_USE_PNFS_MDS:
fail("Server can not be used as pnfs metadata server")
sess = c1.create_session()
print sess.c.homedir
# Create the file
res = create_file(sess, env.testname(t))
check(res)
# Get layout
fh = res.resarray[-1].object
open_stateid = res.resarray[-2].stateid
ops = [
op.putfh(fh),
op.layoutget(False, LAYOUT4_BLOCK_VOLUME, LAYOUTIOMODE4_READ, 0,
0xffffffffffffffff, 0, open_stateid, 0xffff)
]
res = sess.compound(ops)
check(res)
# Return layout
ops = use_obj(env.opts.path) + \
[op.layoutreturn(False, LAYOUT4_BLOCK_VOLUME, LAYOUTIOMODE4_ANY,
layoutreturn4(LAYOUTRETURN4_FSID))]
res = sess.compound(ops)
check(res)
def testLink(t, env):
"""LOOKUPP with non-dir (cfh)
FLAGS: lookupp symlink all
CODE: LKPP1a
"""
c1 = env.c1.new_client(env.testname(t))
sess1 = c1.create_session()
ops = use_obj(env.opts.uselink) + [op.lookupp()]
res = sess1.compound(ops)
check(res, NFS4ERR_SYMLINK, "LOOKUPP with non-dir <cfh>")
def testSock(t, env):
"""LOOKUPP with non-dir (cfh)
FLAGS: lookupp socket all
CODE: LKPP1s
"""
c1 = env.c1.new_client(env.testname(t))
sess1 = c1.create_session()
ops = use_obj(env.opts.usesocket) + [op.lookupp()]
res = sess1.compound(ops)
check(res, NFS4ERR_NOTDIR, "LOOKUPP with non-dir <cfh>")
def testSock(t, env):
"""LOOKUPP with non-dir (cfh)
FLAGS: lookupp socket all
CODE: LKPP1s
"""
c1 = env.c1.new_client(env.testname(t))
sess1 = c1.create_session()
ops = use_obj(env.opts.usesocket) + [op.lookupp()]
res = sess1.compound(ops)
check(res, NFS4ERR_NOTDIR, "LOOKUPP with non-dir <cfh>")
def testLink(t, env):
"""LOOKUPP with non-dir (cfh)
FLAGS: lookupp symlink all
CODE: LKPP1a
"""
c1 = env.c1.new_client(env.testname(t))
sess1 = c1.create_session()
ops = use_obj(env.opts.uselink) + [op.lookupp()]
res = sess1.compound(ops)
check(res, NFS4ERR_SYMLINK, "LOOKUPP with non-dir <cfh>")
def _try_put(t, sess, path):
# Get fh via LOOKUP
res = sess.compound(use_obj(path) + [op.getfh()])
check(res)
oldfh = res.resarray[-1].object
# Now try PUTFH and GETFH, see if it agrees
res = sess.compound([op.putfh(oldfh), op.getfh()])
check(res)
newfh = res.resarray[-1].object
if oldfh != newfh:
t.fail("GETFH did not return input of PUTFH for /%s" % '/'.join(path))
def _try_put(t, sess, path):
# Get fh via LOOKUP
res = sess.compound(use_obj(path) + [op.getfh()])
check(res)
oldfh = res.resarray[-1].object
# Now try PUTFH and GETFH, see if it agrees
res = sess.compound([op.putfh(oldfh), op.getfh()])
check(res)
newfh = res.resarray[-1].object
if oldfh != newfh:
t.fail("GETFH did not return input of PUTFH for /%s" % '/'.join(path))
def testGetDevList(t, env):
"""Check devlist
FLAGS: pnfs
CODE: GETDLIST1
"""
sess = env.c1.new_pnfs_client_session(env.testname(t))
# Test that fs handles block layouts
ops = use_obj(env.opts.path) + [op.getattr(1<<FATTR4_FS_LAYOUT_TYPES)]
res = sess.compound(ops)
check(res)
if FATTR4_FS_LAYOUT_TYPES not in res.resarray[-1].obj_attributes:
fail("fs_layout_type not available")
for lo_type in res.resarray[-1].obj_attributes[FATTR4_FS_LAYOUT_TYPES]:
# Send GETDEVICELIST
ops = use_obj(env.opts.path) + [op.getdevicelist(lo_type, 0xffffffff, 0, "")]
res = sess.compound(ops)
check(res)
# STUB - check block stuff
dev_list = res.resarray[-1].gdlr_deviceid_list
print dev_list
def testLayoutCommit(t, env):
"""
Do some commits
FLAGS: pnfs
CODE: LAYOUTCOMMIT1
"""
sess = env.c1.new_pnfs_client_session(env.testname(t))
blocksize = get_blocksize(sess, use_obj(env.opts.path))
# Create the file
res = create_file(sess, env.testname(t))
check(res)
# Get layout
fh = res.resarray[-1].object
open_stateid = res.resarray[-2].stateid
ops = [op.putfh(fh),
op.layoutget(False, LAYOUT4_BLOCK_VOLUME, LAYOUTIOMODE4_RW,
0, 4*blocksize, 4*blocksize, open_stateid, 0xffff)]
res = sess.compound(ops)
check(res)
layout_stateid = res.resarray[-1].logr_stateid
# Parse opaque
for layout in res.resarray[-1].logr_layout:
if layout.loc_type != LAYOUT4_BLOCK_VOLUME:
fail("Did not get Block layout")
p = BlockUnpacker(layout.loc_body)
opaque = p.unpack_pnfs_block_layout4()
p.done()
print opaque
final_extent = opaque.blo_extents[-1]
print final_extent
if final_extent.bex_state != PNFS_BLOCK_INVALID_DATA:
fail("Expected INVALID_DATA in extent")
# LAYOUTCOMMIT
final_extent.bex_state = PNFS_BLOCK_READWRITE_DATA
p = BlockPacker()
p.pack_pnfs_block_layoutupdate4(pnfs_block_layoutupdate4([final_extent]))
notime = newtime4(False)
ops = [op.putfh(fh),
op.layoutcommit(final_extent.bex_file_offset,
final_extent.bex_length,
False, layout_stateid,
newoffset4(True, 4 * blocksize - 1),
notime,
layoutupdate4(LAYOUT4_BLOCK_VOLUME, p.get_buffer()))]
res = sess.compound(ops)
check(res)
print res
def testEMCGetLayout(t, env):
"""Verify layout handling
Debugging test that looks for pre-existing file (server2fs1/dump.eth)
so we don't have to worry about creating a file.
FLAGS:
CODE: GETLAYOUT100
"""
# Make sure E_ID returns MDS capabilities
c1 = env.c1.new_client(env.testname(t), flags=EXCHGID4_FLAG_USE_PNFS_MDS)
if not c1.flags & EXCHGID4_FLAG_USE_PNFS_MDS:
fail("Server can not be used as pnfs metadata server")
sess = c1.create_session()
# Test that fs handles block layouts
ops = use_obj(env.opts.path) + [op.getattr(1 << FATTR4_FS_LAYOUT_TYPE)]
res = sess.compound(ops)
check(res)
if FATTR4_FS_LAYOUT_TYPE not in res.resarray[-1].obj_attributes:
fail("fs_layout_type not available")
if LAYOUT4_BLOCK_VOLUME not in res.resarray[-1].obj_attributes[
FATTR4_FS_LAYOUT_TYPE]:
fail("layout_type does not contain BLOCK")
# Create the file
file = ["server2fs1", "dump.eth"]
res = open_file(sess, env.testname(t), file)
check(res)
# Get layout
fh = res.resarray[-1].object
stateid = res.resarray[-2].stateid
stateid.seqid = 0
ops = [
op.putfh(fh),
op.layoutget(False, LAYOUT4_BLOCK_VOLUME, LAYOUTIOMODE4_READ, 0,
0xffffffffffffffff, 0, stateid, 0xffff)
]
res = sess.compound(ops)
check(res)
# Parse opaque
for layout in res.resarray[-1].logr_layout:
if layout.loc_type == LAYOUT4_BLOCK_VOLUME:
p = BlockUnpacker(layout.loc_body)
opaque = p.unpack_pnfs_block_layout4()
p.done()
print opaque
def testEMCGetLayout(t, env):
"""Verify layout handling
Debugging test that looks for pre-existing file (server2fs1/dump.eth)
so we don't have to worry about creating a file.
FLAGS:
CODE: GETLAYOUT100
"""
# Make sure E_ID returns MDS capabilities
c1 = env.c1.new_client(env.testname(t), flags=EXCHGID4_FLAG_USE_PNFS_MDS)
if not c1.flags & EXCHGID4_FLAG_USE_PNFS_MDS:
fail("Server can not be used as pnfs metadata server")
sess = c1.create_session()
# Test that fs handles block layouts
ops = use_obj(env.opts.path) + [op.getattr(1<<FATTR4_FS_LAYOUT_TYPE)]
res = sess.compound(ops)
check(res)
if FATTR4_FS_LAYOUT_TYPE not in res.resarray[-1].obj_attributes:
fail("fs_layout_type not available")
if LAYOUT4_BLOCK_VOLUME not in res.resarray[-1].obj_attributes[FATTR4_FS_LAYOUT_TYPE]:
fail("layout_type does not contain BLOCK")
# Create the file
file = ["server2fs1", "dump.eth"]
res = open_file(sess, env.testname(t), file)
check(res)
# Get layout
fh = res.resarray[-1].object
stateid = res.resarray[-2].stateid
stateid.seqid = 0
ops = [op.putfh(fh),
op.layoutget(False, LAYOUT4_BLOCK_VOLUME, LAYOUTIOMODE4_READ,
0, 0xffffffffffffffff, 0, stateid, 0xffff)]
res = sess.compound(ops)
check(res)
# Parse opaque
for layout in res.resarray[-1].logr_layout:
if layout.loc_type == LAYOUT4_BLOCK_VOLUME:
p = BlockUnpacker(layout.loc_body)
opaque = p.unpack_pnfs_block_layout4()
p.done()
print opaque
def testLayoutCommit(t, env):
"""
Do some commits
FLAGS: layoutcommit all
CODE: LAYOUTCOMMIT1
"""
# Make sure E_ID returns MDS capabilities
c1 = env.c1.new_client(env.testname(t), flags=EXCHGID4_FLAG_USE_PNFS_MDS)
if not c1.flags & EXCHGID4_FLAG_USE_PNFS_MDS:
fail("Server can not be used as pnfs metadata server")
sess = c1.create_session()
# Test that fs handles block layouts
ops = use_obj(env.opts.path) + [
op.getattr(1 << FATTR4_FS_LAYOUT_TYPE | 1 << FATTR4_LAYOUT_BLKSIZE)
]
res = sess.compound(ops)
check(res)
attrdict = res.resarray[-1].obj_attributes
if FATTR4_FS_LAYOUT_TYPE not in attrdict:
fail("fs_layout_type not available")
if LAYOUT4_BLOCK_VOLUME not in attrdict[FATTR4_FS_LAYOUT_TYPE]:
fail("layout_type does not contain BLOCK")
blocksize = attrdict[FATTR4_LAYOUT_BLKSIZE]
# Create the file
res = create_file(sess, env.testname(t))
check(res)
# Get layout
fh = res.resarray[-1].object
open_stateid = res.resarray[-2].stateid
ops = [
op.putfh(fh),
op.layoutget(False, LAYOUT4_BLOCK_VOLUME, LAYOUTIOMODE4_RW, 0,
4 * blocksize, 4 * blocksize, open_stateid, 0xffff)
]
res = sess.compound(ops)
check(res)
layout_stateid = res.resarray[-1].logr_stateid
# Parse opaque
for layout in res.resarray[-1].logr_layout:
if layout.loc_type != LAYOUT4_BLOCK_VOLUME:
fail("Did not get Block layout")
p = BlockUnpacker(layout.loc_body)
opaque = p.unpack_pnfs_block_layout4()
p.done()
print opaque
final_extent = opaque.blo_extents[-1]
print final_extent
if final_extent.bex_state != PNFS_BLOCK_INVALID_DATA:
fail("Expected INVALID_DATA in extent")
# LAYOUTCOMMIT
final_extent.bex_state = PNFS_BLOCK_READWRITE_DATA
p = BlockPacker()
p.pack_pnfs_block_layoutupdate4(pnfs_block_layoutupdate4([final_extent]))
notime = newtime4(False)
ops = [
op.putfh(fh),
op.layoutcommit(final_extent.bex_file_offset, final_extent.bex_length,
False, layout_stateid,
newoffset4(True, 4 * blocksize - 1), notime,
layoutupdate4(LAYOUT4_BLOCK_VOLUME, p.get_buffer()))
]
res = sess.compound(ops)
check(res)
print res
def testLayoutCommit(t, env):
"""
Do some commits
FLAGS: pnfs
CODE: LAYOUTCOMMIT1
"""
# Make sure E_ID returns MDS capabilities
c1 = env.c1.new_client(env.testname(t), flags=EXCHGID4_FLAG_USE_PNFS_MDS)
if not c1.flags & EXCHGID4_FLAG_USE_PNFS_MDS:
fail("Server can not be used as pnfs metadata server")
sess = c1.create_session()
# Test that fs handles block layouts
ops = use_obj(env.opts.path) + [op.getattr(1<<FATTR4_FS_LAYOUT_TYPE |
1<<FATTR4_LAYOUT_BLKSIZE)]
res = sess.compound(ops)
check(res)
attrdict = res.resarray[-1].obj_attributes
if FATTR4_FS_LAYOUT_TYPE not in attrdict:
fail("fs_layout_type not available")
if LAYOUT4_BLOCK_VOLUME not in attrdict[FATTR4_FS_LAYOUT_TYPE]:
fail("layout_type does not contain BLOCK")
blocksize = attrdict[FATTR4_LAYOUT_BLKSIZE]
# Create the file
res = create_file(sess, env.testname(t))
check(res)
# Get layout
fh = res.resarray[-1].object
open_stateid = res.resarray[-2].stateid
ops = [op.putfh(fh),
op.layoutget(False, LAYOUT4_BLOCK_VOLUME, LAYOUTIOMODE4_RW,
0, 4*blocksize, 4*blocksize, open_stateid, 0xffff)]
res = sess.compound(ops)
check(res)
layout_stateid = res.resarray[-1].logr_stateid
# Parse opaque
for layout in res.resarray[-1].logr_layout:
if layout.loc_type != LAYOUT4_BLOCK_VOLUME:
fail("Did not get Block layout")
p = BlockUnpacker(layout.loc_body)
opaque = p.unpack_pnfs_block_layout4()
p.done()
print opaque
final_extent = opaque.blo_extents[-1]
print final_extent
if final_extent.bex_state != PNFS_BLOCK_INVALID_DATA:
fail("Expected INVALID_DATA in extent")
# LAYOUTCOMMIT
final_extent.bex_state = PNFS_BLOCK_READWRITE_DATA
p = BlockPacker()
p.pack_pnfs_block_layoutupdate4(pnfs_block_layoutupdate4([final_extent]))
notime = newtime4(False)
ops = [op.putfh(fh),
op.layoutcommit(final_extent.bex_file_offset,
final_extent.bex_length,
False, layout_stateid,
newoffset4(True, 4 * blocksize - 1),
notime,
layoutupdate4(LAYOUT4_BLOCK_VOLUME, p.get_buffer()))]
res = sess.compound(ops)
check(res)
print res
