@Test
public void testGetXattrSize() throws Exception {
VOLUME_NAME = "testGetXattrSize";
String fileName = "testfile";
client.createVolume(mrcAddress, auth, userCredentials, VOLUME_NAME);
Volume volume = client.openVolume(VOLUME_NAME, null, options);
FileHandle fh =
volume.openFile(
userCredentials,
fileName,
SYSTEM_V_FCNTL.SYSTEM_V_FCNTL_H_O_CREAT.getNumber()
| SYSTEM_V_FCNTL.SYSTEM_V_FCNTL_H_O_RDWR.getNumber()
| SYSTEM_V_FCNTL.SYSTEM_V_FCNTL_H_O_SYNC.getNumber(),
0777);
fh.close();
int size = volume.getXAttrSize(userCredentials, fileName, "xtreemfs.set_repl_update_policy");
assertEquals(0, size);
size = volume.getXAttrSize(userCredentials, fileName, "xtreemfs.owner");
assertEquals(userCredentials.getUsername().length(), size);
size = volume.getXAttrSize(userCredentials, fileName, "doesnt-exist");
assertEquals(-1, size);
volume.setXAttr(userCredentials, fileName, "foo", "bar", XATTR_FLAGS.XATTR_FLAGS_CREATE);
size = volume.getXAttrSize(userCredentials, fileName, "foo");
assertEquals(3, size);
size = volume.getXAttrSize(userCredentials, fileName, "doesnt-exist-in-cache");
assertEquals(-1, size);
}
@Test
public void testRenameFile() throws Exception {
VOLUME_NAME = "testRenameFile";
String fileName = "testfile";
String renamedFileName = "renamed";
client.createVolume(mrcAddress, auth, userCredentials, VOLUME_NAME);
Volume volume = client.openVolume(VOLUME_NAME, null, options);
FileHandle fh =
volume.openFile(
userCredentials,
fileName,
SYSTEM_V_FCNTL.SYSTEM_V_FCNTL_H_O_CREAT.getNumber()
| SYSTEM_V_FCNTL.SYSTEM_V_FCNTL_H_O_RDWR.getNumber(),
0777);
fh.close();
// nothing should happen
volume.rename(userCredentials, fileName, fileName);
DirectoryEntries dir = volume.readDir(userCredentials, "/", 0, 100, true);
assertEquals(fileName, dir.getEntries(2).getName());
assertEquals(3, dir.getEntriesCount());
volume.rename(userCredentials, fileName, renamedFileName);
dir = volume.readDir(userCredentials, "/", 0, 100, true);
assertEquals(renamedFileName, dir.getEntries(2).getName());
assertEquals(3, dir.getEntriesCount());
}
@Test
public void testVolumeQuota() throws Exception {
final String VOLUME_NAME = "testVolumeQuota";
client.createVolume(
mrcAddress,
auth,
userCredentials,
VOLUME_NAME,
0,
userCredentials.getUsername(),
userCredentials.getGroups(0),
AccessControlPolicyType.ACCESS_CONTROL_POLICY_NULL,
StripingPolicyType.STRIPING_POLICY_RAID0,
defaultStripingPolicy.getStripeSize(),
defaultStripingPolicy.getWidth(),
new ArrayList<KeyValuePair>());
Volume volume = client.openVolume(VOLUME_NAME, null, options);
volume.setXAttr(userCredentials, "/", "xtreemfs.quota", "8", XATTR_FLAGS.XATTR_FLAGS_CREATE);
assertEquals("8", volume.getXAttr(userCredentials, "/", "xtreemfs.quota"));
int flags =
SYSTEM_V_FCNTL.SYSTEM_V_FCNTL_H_O_CREAT.getNumber()
| SYSTEM_V_FCNTL.SYSTEM_V_FCNTL_H_O_RDWR.getNumber();
byte[] content = "foo foo foo".getBytes(); // 11 bytes will exceed quota
FileHandle file = volume.openFile(userCredentials, "/test1.txt", flags, 0777);
boolean osdWriteException = false;
try {
file.write(userCredentials, content, content.length, 0);
} catch (Exception ex) {
osdWriteException = true;
}
if (!osdWriteException) {
fail("OSD performed write operation although it exceeds the quota.");
}
content = "foo bar ".getBytes(); // 8 bytes to fit quota perfectly
file.write(userCredentials, content, content.length, 0);
file.close();
try {
file = volume.openFile(userCredentials, "/test2.txt", flags, 0777);
assertTrue(false);
} catch (PosixErrorException exc) {
// check if right exception was thrown
if (!exc.getMessage().contains("POSIX_ERROR_ENOSPC")) {
assertTrue(false);
}
}
}
@Test
public void testTruncate() throws Exception {
VOLUME_NAME = "testTruncate";
String fileName = "testfile";
String emptyFileName = "emptyFileName";
client.createVolume(mrcAddress, auth, userCredentials, VOLUME_NAME);
Volume volume = client.openVolume(VOLUME_NAME, null, options);
FileHandle fileHandle =
volume.openFile(
userCredentials,
fileName,
SYSTEM_V_FCNTL.SYSTEM_V_FCNTL_H_O_CREAT.getNumber()
| SYSTEM_V_FCNTL.SYSTEM_V_FCNTL_H_O_RDWR.getNumber(),
0777);
String data = "1234567890";
fileHandle.write(userCredentials, data.getBytes(), data.length(), 0);
fileHandle.flush();
assertEquals(data.length(), volume.getAttr(userCredentials, fileName).getSize());
volume.truncate(userCredentials, fileName, 5);
assertEquals(5, volume.getAttr(userCredentials, fileName).getSize());
fileHandle.close();
fileHandle =
volume.openFile(
userCredentials,
emptyFileName,
SYSTEM_V_FCNTL.SYSTEM_V_FCNTL_H_O_CREAT.getNumber()
| SYSTEM_V_FCNTL.SYSTEM_V_FCNTL_H_O_RDWR.getNumber(),
0777);
assertEquals(0, fileHandle.getAttr(userCredentials).getSize());
volume.truncate(userCredentials, emptyFileName, 1000);
assertEquals(1000, fileHandle.getAttr(userCredentials).getSize());
fileHandle.close();
}
@Test
public void testAccessSuccess() throws Exception {
VOLUME_NAME = "testAccessSuccess";
String fileName = "testfile";
client.createVolume(mrcAddress, auth, userCredentials, VOLUME_NAME);
Volume volume = client.openVolume(VOLUME_NAME, null, options);
FileHandle fh =
volume.openFile(
userCredentials,
fileName,
SYSTEM_V_FCNTL.SYSTEM_V_FCNTL_H_O_CREAT.getNumber()
| SYSTEM_V_FCNTL.SYSTEM_V_FCNTL_H_O_RDWR.getNumber(),
0753);
fh.close();
volume.access(userCredentials, fileName, 0753);
}
@Test
public void testReadLinkWithLink() throws Exception {
VOLUME_NAME = "testReadLinkWithLink";
String fileName = "testfile";
String linkName = "linkToFile";
client.createVolume(mrcAddress, auth, userCredentials, VOLUME_NAME);
Volume volume = client.openVolume(VOLUME_NAME, null, options);
FileHandle fh =
volume.openFile(
userCredentials,
fileName,
SYSTEM_V_FCNTL.SYSTEM_V_FCNTL_H_O_CREAT.getNumber()
| SYSTEM_V_FCNTL.SYSTEM_V_FCNTL_H_O_RDWR.getNumber(),
0777);
fh.close();
volume.symlink(userCredentials, fileName, linkName);
assertEquals(fileName, volume.readLink(userCredentials, linkName));
}
/**
* @param args args[0] = URL to existing volume e.g., pbrpcs://localhost/regular
* @return
* @throws Exception
*/
public static void main(String[] args) {
if (args.length < 1) {
System.out.println("usage: <URL to existing volume e.g., pbrpcs://localhost/regular>");
return;
}
Client client = null;
FileHandle fileHandle = null;
try {
// Parse command line parameter.
int lastSlashIndex = args[0].lastIndexOf('/');
final ONCRPCServiceURL url =
new ONCRPCServiceURL(
args[0].substring(0, lastSlashIndex),
Schemes.SCHEME_PBRPC,
PORTS.DIR_PBRPC_PORT_DEFAULT.getNumber());
final String volumeName = args[0].substring(lastSlashIndex + 1);
// Init libxtreemfs
final Options options = new Options();
final UserCredentials userCredentials =
UserCredentials.newBuilder()
.setUsername(System.getProperty("user.name"))
.addGroups("root")
.build();
final SSLOptions sslOptions =
url.getProtocol().equals(Schemes.SCHEME_PBRPC)
? null
: new SSLOptions(
new FileInputStream(CERT_DIR + "Client.p12"),
"passphrase",
SSLOptions.PKCS12_CONTAINER,
new FileInputStream(CERT_DIR + "trusted.jks"),
"passphrase",
SSLOptions.JKS_CONTAINER,
false,
false,
null);
// Alternatively, specify own certificate files for debugging:
// final SSLOptions sslOptions = new SSLOptions(
// new FileInputStream(
// "/home/mberlin/ZIB/XtreemFS/tasks archive/2013-08-05 Debug SSL
// issues/xtfsclient/config/xtfs-vm-certs/TestUser01.p12"),
// "test123",
// SSLOptions.PKCS12_CONTAINER,
// new FileInputStream(
// "/home/mberlin/ZIB/XtreemFS/tasks archive/2013-08-05 Debug SSL
// issues/xtfsclient/config/xtfs-vm-certs/trusted.jks"),
// "J9AUcbrdVkFg75kcqumz", SSLOptions.JKS_CONTAINER, false, false, null);
Logging.start(Logging.LEVEL_WARN);
client =
ClientFactory.createClient(
url.getHost() + ":" + url.getPort(), userCredentials, sslOptions, options);
client.start();
Volume volume = client.openVolume(volumeName, sslOptions, options);
// Open a file.
fileHandle =
volume.openFile(
userCredentials,
"/example_libxtreemfs_test_"
+ String.format("%03d", (int) (Math.random() * 1000))
+ ".bin",
SYSTEM_V_FCNTL.SYSTEM_V_FCNTL_H_O_CREAT.getNumber()
| SYSTEM_V_FCNTL.SYSTEM_V_FCNTL_H_O_EXCL.getNumber()
| SYSTEM_V_FCNTL.SYSTEM_V_FCNTL_H_O_RDWR.getNumber(),
0644);
// Init chunk to be written.
byte[] data = new byte[1 << 17]; // 128 kB chunk.
Arrays.fill(data, (byte) 0xAB);
// Write 1 MB to file.
for (int offset = 0; offset < (1 << 20); offset += data.length) {
fileHandle.write(userCredentials, data, data.length, offset);
}
// Read 1 MB from file.
byte[] readData = new byte[data.length];
for (int offset = 0; offset < (1 << 20); offset += data.length) {
int readCount = fileHandle.read(userCredentials, readData, data.length, offset);
if (readCount != data.length) {
throw new IOException(
"Read less data than expected: " + readCount + " bytes instead of: " + data.length);
}
if (!Arrays.equals(readData, data)) {
throw new IOException("Read data differs from written chunk at offset: " + offset);
}
}
} catch (Exception e) {
System.err.println(
"An error occurred: " + e.getMessage() + "\n Full Stacktrace:\n" + e.getStackTrace());
return;
} finally {
if (fileHandle != null) {
try {
fileHandle.close();
} catch (IOException e) {
System.err.println(
"Failed to close() the file: "
+ e.getMessage()
+ "\n Full Stacktrace:\n"
+ e.getStackTrace());
return;
}
}
if (client != null) {
client.shutdown();
}
System.out.println("If no errors are shown, the example was successfully executed.");
}
return;
}
