/**
* Request space from the worker
*
* @param userId The id of the user who send the request
* @param requestBytes The requested space size, in bytes
* @return true if succeed, false otherwise
* @throws TException
*/
public boolean requestSpace(long userId, long requestBytes) throws TException {
LOG.info(
"requestSpace("
+ userId
+ ", "
+ requestBytes
+ "): Current available: "
+ mWorkerSpaceCounter.getAvailableBytes()
+ " requested: "
+ requestBytes);
if (mWorkerSpaceCounter.getCapacityBytes() < requestBytes) {
LOG.info(
"user_requestSpace(): requested memory size is larger than the total memory on"
+ " the machine.");
return false;
}
while (!mWorkerSpaceCounter.requestSpaceBytes(requestBytes)) {
if (!memoryEvictionLRU(requestBytes)) {
return false;
}
}
mUsers.addOwnBytes(userId, requestBytes);
return true;
}
/**
* Notify the worker the block is cached.
*
* <p>This call is called remotely from {@link tachyon.client.TachyonFS#cacheBlock(long)} which is
* only ever called from {@link tachyon.client.BlockOutStream#close()} (though its a public api so
* anyone could call it). There are a few interesting preconditions for this to work.
*
* <p>1) Client process writes to files locally under a tachyon defined temp directory. 2) Worker
* process is on the same node as the client 3) Client is talking to the local worker directly
*
* <p>If all conditions are true, then and only then can this method ever be called; all
* operations work on local files.
*
* @param userId The user id of the client who send the notification
* @param blockId The id of the block
* @throws FileDoesNotExistException
* @throws SuspectedFileSizeException
* @throws BlockInfoException
* @throws TException
*/
public void cacheBlock(long userId, long blockId)
throws FileDoesNotExistException, SuspectedFileSizeException, BlockInfoException, TException {
File srcFile = new File(CommonUtils.concat(getUserTempFolder(userId), blockId));
File dstFile = new File(CommonUtils.concat(mLocalDataFolder, blockId));
long fileSizeBytes = srcFile.length();
if (!srcFile.exists()) {
throw new FileDoesNotExistException("File " + srcFile + " does not exist.");
}
if (!srcFile.renameTo(dstFile)) {
throw new FileDoesNotExistException(
"Failed to rename file from " + srcFile.getPath() + " to " + dstFile.getPath());
}
addBlockId(blockId, fileSizeBytes);
mUsers.addOwnBytes(userId, -fileSizeBytes);
mMasterClient.worker_cacheBlock(
mWorkerId, mWorkerSpaceCounter.getUsedBytes(), blockId, fileSizeBytes);
LOG.info(userId + " " + dstFile);
}
/**
* Return the space which has been requested
*
* @param userId The id of the user who wants to return the space
* @param returnedBytes The returned space size, in bytes
* @throws TException
*/
public void returnSpace(long userId, long returnedBytes) throws TException {
long preAvailableBytes = mWorkerSpaceCounter.getAvailableBytes();
if (returnedBytes > mUsers.ownBytes(userId)) {
LOG.error("User " + userId + " does not own " + returnedBytes + " bytes.");
} else {
mWorkerSpaceCounter.returnUsedBytes(returnedBytes);
mUsers.addOwnBytes(userId, -returnedBytes);
}
LOG.info(
"returnSpace("
+ userId
+ ", "
+ returnedBytes
+ ") : "
+ preAvailableBytes
+ " returned: "
+ returnedBytes
+ ". New Available: "
+ mWorkerSpaceCounter.getAvailableBytes());
}
