synchronized FSVolume getNextVolume(long blockSize) throws IOException {
int startVolume = curVolume;
while (true) {
FSVolume volume = volumes[curVolume];
curVolume = (curVolume + 1) % volumes.length;
if (volume.getAvailable() > blockSize) {
return volume;
}
if (curVolume == startVolume) {
throw new DiskOutOfSpaceException("Insufficient space for an additional block");
}
}
}
/** {@inheritDoc} */
public void validateBlockMetadata(Block b) throws IOException {
DatanodeBlockInfo info = volumeMap.get(b);
if (info == null) {
throw new IOException("Block " + b + " does not exist in volumeMap.");
}
FSVolume v = info.getVolume();
File tmp = v.getTmpFile(b);
File f = getFile(b);
if (f == null) {
f = tmp;
}
if (f == null) {
throw new IOException("Block " + b + " does not exist on disk.");
}
if (!f.exists()) {
throw new IOException("Block " + b + " block file " + f + " does not exist on disk.");
}
if (b.getNumBytes() != f.length()) {
throw new IOException(
"Block "
+ b
+ " length is "
+ b.getNumBytes()
+ " does not match block file length "
+ f.length());
}
File meta = getMetaFile(f, b);
if (meta == null) {
throw new IOException("Block " + b + " metafile does not exist.");
}
if (!meta.exists()) {
throw new IOException("Block " + b + " metafile " + meta + " does not exist on disk.");
}
if (meta.length() == 0) {
throw new IOException("Block " + b + " metafile " + meta + " is empty.");
}
long stamp = parseGenerationStamp(f, meta);
if (stamp != b.getGenerationStamp()) {
throw new IOException(
"Block "
+ b
+ " genstamp is "
+ b.getGenerationStamp()
+ " does not match meta file stamp "
+ stamp);
}
}
synchronized File createTmpFile(FSVolume vol, Block blk) throws IOException {
if (vol == null) {
vol = volumeMap.get(blk).getVolume();
if (vol == null) {
throw new IOException("Could not find volume for block " + blk);
}
}
return vol.createTmpFile(blk);
}
/** Complete the block write! */
public synchronized void finalizeBlock(Block b) throws IOException {
ActiveFile activeFile = ongoingCreates.get(b);
if (activeFile == null) {
throw new IOException("Block " + b + " is already finalized.");
}
File f = activeFile.file;
if (f == null || !f.exists()) {
throw new IOException("No temporary file " + f + " for block " + b);
}
FSVolume v = volumeMap.get(b).getVolume();
if (v == null) {
throw new IOException("No volume for temporary file " + f + " for block " + b);
}
File dest = null;
dest = v.addBlock(b, f);
volumeMap.put(b, new DatanodeBlockInfo(v, dest));
ongoingCreates.remove(b);
}
/** Returns handles to the block file and its metadata file */
public synchronized BlockInputStreams getTmpInputStreams(Block b, long blkOffset, long ckoff)
throws IOException {
DatanodeBlockInfo info = volumeMap.get(b);
if (info == null) {
throw new IOException("Block " + b + " does not exist in volumeMap.");
}
FSVolume v = info.getVolume();
File blockFile = v.getTmpFile(b);
RandomAccessFile blockInFile = new RandomAccessFile(blockFile, "r");
if (blkOffset > 0) {
blockInFile.seek(blkOffset);
}
File metaFile = getMetaFile(blockFile, b);
RandomAccessFile metaInFile = new RandomAccessFile(metaFile, "r");
if (ckoff > 0) {
metaInFile.seek(ckoff);
}
return new BlockInputStreams(
new FileInputStream(blockInFile.getFD()), new FileInputStream(metaInFile.getFD()));
}
/** Sets the offset in the block to which the the next write will write data to. */
public void setChannelPosition(Block b, BlockWriteStreams streams, long dataOffset, long ckOffset)
throws IOException {
long size = 0;
synchronized (this) {
FSVolume vol = volumeMap.get(b).getVolume();
size = vol.getTmpFile(b).length();
}
if (size < dataOffset) {
String msg =
"Trying to change block file offset of block "
+ b
+ " to "
+ dataOffset
+ " but actual size of file is "
+ size;
throw new IOException(msg);
}
FileOutputStream file = (FileOutputStream) streams.dataOut;
file.getChannel().position(dataOffset);
file = (FileOutputStream) streams.checksumOut;
file.getChannel().position(ckOffset);
}
/**
* We're informed that a block is no longer valid. We could lazily garbage-collect the block, but
* why bother? just get rid of it.
*/
public void invalidate(Block invalidBlks[]) throws IOException {
boolean error = false;
for (int i = 0; i < invalidBlks.length; i++) {
File f = null;
FSVolume v;
synchronized (this) {
f = getFile(invalidBlks[i]);
DatanodeBlockInfo dinfo = volumeMap.get(invalidBlks[i]);
if (dinfo == null) {
DataNode.LOG.warn(
"Unexpected error trying to delete block "
+ invalidBlks[i]
+ ". BlockInfo not found in volumeMap.");
error = true;
continue;
}
v = dinfo.getVolume();
if (f == null) {
DataNode.LOG.warn(
"Unexpected error trying to delete block "
+ invalidBlks[i]
+ ". Block not found in blockMap."
+ ((v == null) ? " " : " Block found in volumeMap."));
error = true;
continue;
}
if (v == null) {
DataNode.LOG.warn(
"Unexpected error trying to delete block "
+ invalidBlks[i]
+ ". No volume for this block."
+ " Block found in blockMap. "
+ f
+ ".");
error = true;
continue;
}
File parent = f.getParentFile();
if (parent == null) {
DataNode.LOG.warn(
"Unexpected error trying to delete block "
+ invalidBlks[i]
+ ". Parent not found for file "
+ f
+ ".");
error = true;
continue;
}
v.clearPath(parent);
volumeMap.remove(invalidBlks[i]);
}
File metaFile = getMetaFile(f, invalidBlks[i]);
long blockSize = f.length() + metaFile.length();
if (!f.delete() || (!metaFile.delete() && metaFile.exists())) {
DataNode.LOG.warn(
"Unexpected error trying to delete block " + invalidBlks[i] + " at file " + f);
error = true;
continue;
}
v.decDfsUsed(blockSize);
DataNode.LOG.info("Deleting block " + invalidBlks[i] + " file " + f);
if (f.exists()) {
//
// This is a temporary check especially for hadoop-1220.
// This will go away in the future.
//
DataNode.LOG.info("File " + f + " was deleted but still exists!");
}
}
if (error) {
throw new IOException("Error in deleting blocks.");
}
}