// Tests that caching a block successfully persists the block if the block exists
@Test
public void cacheBlockTest() throws Exception {
mFileSystem.createFile(new AlluxioURI("/testFile"));
URIStatus file = mFileSystem.getStatus(new AlluxioURI("/testFile"));
final int blockSize = (int) WORKER_CAPACITY_BYTES / 10;
// Construct the block ids for the file.
final long blockId0 = BlockId.createBlockId(BlockId.getContainerId(file.getFileId()), 0);
final long blockId1 = BlockId.createBlockId(BlockId.getContainerId(file.getFileId()), 1);
String filename =
mBlockWorkerServiceHandler.requestBlockLocation(SESSION_ID, blockId0, blockSize);
createBlockFile(filename, blockSize);
mBlockWorkerServiceHandler.cacheBlock(SESSION_ID, blockId0);
// The master should be immediately updated with the persisted block
Assert.assertEquals(blockSize, mBlockMasterClient.getUsedBytes());
// Attempting to cache a non existent block should throw an exception
Exception exception = null;
try {
mBlockWorkerServiceHandler.cacheBlock(SESSION_ID, blockId1);
} catch (TException e) {
exception = e;
}
Assert.assertNotNull(exception);
}
// Tests that space will be allocated when possible
@Test
public void requestSpaceTest() throws Exception {
final long blockId1 = 12345L;
final long blockId2 = 12346L;
final int chunkSize = (int) WORKER_CAPACITY_BYTES / 10;
mBlockWorkerServiceHandler.requestBlockLocation(SESSION_ID, blockId1, chunkSize);
boolean result = mBlockWorkerServiceHandler.requestSpace(SESSION_ID, blockId1, chunkSize);
// Initial request and first additional request should succeed
Assert.assertTrue(result);
result = mBlockWorkerServiceHandler.requestSpace(SESSION_ID, blockId1, WORKER_CAPACITY_BYTES);
// Impossible request should fail
Assert.assertFalse(result);
// Request for space on a nonexistent block should fail
Assert.assertFalse(mBlockWorkerServiceHandler.requestSpace(SESSION_ID, blockId2, chunkSize));
// Request for impossible initial space should fail
Exception exception = null;
try {
mBlockWorkerServiceHandler.requestBlockLocation(
SESSION_ID, blockId2, WORKER_CAPACITY_BYTES + 1);
} catch (AlluxioTException e) {
exception = e;
}
Assert.assertNotNull(exception);
}
// Tests that lock block returns the correct path
@Test
public void lockBlockTest() throws Exception {
final int blockSize = (int) WORKER_CAPACITY_BYTES / 2;
CreateFileOptions options =
CreateFileOptions.defaults()
.setBlockSizeBytes(blockSize)
.setWriteType(WriteType.MUST_CACHE);
FileOutStream out = mFileSystem.createFile(new AlluxioURI("/testFile"), options);
URIStatus file = mFileSystem.getStatus(new AlluxioURI("/testFile"));
final long blockId = BlockId.createBlockId(BlockId.getContainerId(file.getFileId()), 0);
out.write(BufferUtils.getIncreasingByteArray(blockSize));
out.close();
String localPath = mBlockWorkerServiceHandler.lockBlock(blockId, SESSION_ID).getBlockPath();
// The local path should exist
Assert.assertNotNull(localPath);
UnderFileSystem ufs = UnderFileSystem.get(localPath, mMasterConfiguration);
byte[] data = new byte[blockSize];
int bytesRead = ufs.open(localPath).read(data);
// The data in the local file should equal the data we wrote earlier
Assert.assertEquals(blockSize, bytesRead);
Assert.assertTrue(BufferUtils.equalIncreasingByteArray(bytesRead, data));
mBlockWorkerServiceHandler.unlockBlock(blockId, SESSION_ID);
}
// Tests that cancelling a block will remove the temporary file
@Test
public void cancelBlockTest() throws Exception {
mFileSystem.createFile(new AlluxioURI("/testFile"));
URIStatus file = mFileSystem.getStatus(new AlluxioURI("/testFile"));
final int blockSize = (int) WORKER_CAPACITY_BYTES / 2;
final long blockId = BlockId.createBlockId(BlockId.getContainerId(file.getFileId()), 0);
String filename =
mBlockWorkerServiceHandler.requestBlockLocation(SESSION_ID, blockId, blockSize);
createBlockFile(filename, blockSize);
mBlockWorkerServiceHandler.cancelBlock(SESSION_ID, blockId);
// The block should not exist after being cancelled
Assert.assertFalse(new File(filename).exists());
// The master should not have recorded any used space after the block is cancelled
waitForHeartbeat();
Assert.assertEquals(0, mBlockMasterClient.getUsedBytes());
}
// Tests that multiple users cannot request a combined space greater than worker space
@Test
public void totalOverCapacityRequestSpaceTest() throws Exception {
final int chunkSize = (int) WORKER_CAPACITY_BYTES / 2;
final long userId1 = SESSION_ID;
final long userId2 = SESSION_ID + 1;
final long blockId1 = 12345L;
final long blockId2 = 23456L;
String filePath1 =
mBlockWorkerServiceHandler.requestBlockLocation(userId1, blockId1, chunkSize);
String filePath2 =
mBlockWorkerServiceHandler.requestBlockLocation(userId2, blockId2, chunkSize);
// Initial requests should succeed
Assert.assertTrue(filePath1 != null);
Assert.assertTrue(filePath2 != null);
// Additional requests for space should fail
Assert.assertFalse(mBlockWorkerServiceHandler.requestSpace(userId1, blockId1, chunkSize));
Assert.assertFalse(mBlockWorkerServiceHandler.requestSpace(userId2, blockId2, chunkSize));
}
// Tests that lock block returns error on failure
@Test
public void lockBlockFailureTest() throws Exception {
mFileSystem.createFile(new AlluxioURI("/testFile"));
URIStatus file = mFileSystem.getStatus(new AlluxioURI("/testFile"));
final long blockId = BlockId.createBlockId(BlockId.getContainerId(file.getFileId()), 0);
Exception exception = null;
try {
mBlockWorkerServiceHandler.lockBlock(blockId, SESSION_ID);
} catch (AlluxioTException e) {
exception = e;
}
// A file does not exist exception should have been thrown
Assert.assertNotNull(exception);
}