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 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 _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