/* This is a used by regular read() and handles ChecksumExceptions.
* name readBuffer() is chosen to imply similarity to readBuffer() in
* ChecksumFileSystem
*/
private synchronized int readBuffer(
byte buf[], int off, int len, Map<ExtendedBlock, Set<DatanodeInfo>> corruptedBlockMap)
throws IOException {
IOException ioe;
/* we retry current node only once. So this is set to true only here.
* Intention is to handle one common case of an error that is not a
* failure on datanode or client : when DataNode closes the connection
* since client is idle. If there are other cases of "non-errors" then
* then a datanode might be retried by setting this to true again.
*/
boolean retryCurrentNode = true;
while (true) {
// retry as many times as seekToNewSource allows.
try {
return blockReader.read(buf, off, len);
} catch (ChecksumException ce) {
DFSClient.LOG.warn(
"Found Checksum error for "
+ getCurrentBlock()
+ " from "
+ currentNode
+ " at "
+ ce.getPos());
ioe = ce;
retryCurrentNode = false;
// we want to remember which block replicas we have tried
addIntoCorruptedBlockMap(getCurrentBlock(), currentNode, corruptedBlockMap);
} catch (IOException e) {
if (!retryCurrentNode) {
DFSClient.LOG.warn(
"Exception while reading from "
+ getCurrentBlock()
+ " of "
+ src
+ " from "
+ currentNode,
e);
}
ioe = e;
}
boolean sourceFound = false;
if (retryCurrentNode) {
/* possibly retry the same node so that transient errors don't
* result in application level failures (e.g. Datanode could have
* closed the connection because the client is idle for too long).
*/
sourceFound = seekToBlockSource(pos);
} else {
addToDeadNodes(currentNode);
sourceFound = seekToNewSource(pos);
}
if (!sourceFound) {
throw ioe;
}
retryCurrentNode = false;
}
}
private void fetchBlockByteRange(
LocatedBlock block,
long start,
long end,
byte[] buf,
int offset,
Map<ExtendedBlock, Set<DatanodeInfo>> corruptedBlockMap)
throws IOException {
//
// Connect to best DataNode for desired Block, with potential offset
//
int refetchToken = 1; // only need to get a new access token once
while (true) {
// cached block locations may have been updated by chooseDataNode()
// or fetchBlockAt(). Always get the latest list of locations at the
// start of the loop.
block = getBlockAt(block.getStartOffset(), false);
DNAddrPair retval = chooseDataNode(block);
DatanodeInfo chosenNode = retval.info;
InetSocketAddress targetAddr = retval.addr;
BlockReader reader = null;
try {
Token<BlockTokenIdentifier> blockToken = block.getBlockToken();
int len = (int) (end - start + 1);
reader =
getBlockReader(
targetAddr,
chosenNode,
src,
block.getBlock(),
blockToken,
start,
len,
buffersize,
verifyChecksum,
dfsClient.clientName);
int nread = reader.readAll(buf, offset, len);
if (nread != len) {
throw new IOException(
"truncated return from reader.read(): " + "excpected " + len + ", got " + nread);
}
return;
} catch (ChecksumException e) {
DFSClient.LOG.warn(
"fetchBlockByteRange(). Got a checksum exception for "
+ src
+ " at "
+ block.getBlock()
+ ":"
+ e.getPos()
+ " from "
+ chosenNode);
// we want to remember what we have tried
addIntoCorruptedBlockMap(block.getBlock(), chosenNode, corruptedBlockMap);
} catch (AccessControlException ex) {
DFSClient.LOG.warn("Short circuit access failed ", ex);
dfsClient.disableShortCircuit();
continue;
} catch (IOException e) {
if (e instanceof InvalidBlockTokenException && refetchToken > 0) {
DFSClient.LOG.info(
"Will get a new access token and retry, "
+ "access token was invalid when connecting to "
+ targetAddr
+ " : "
+ e);
refetchToken--;
fetchBlockAt(block.getStartOffset());
continue;
} else {
DFSClient.LOG.warn(
"Failed to connect to "
+ targetAddr
+ " for file "
+ src
+ " for block "
+ block.getBlock()
+ ":"
+ e);
if (DFSClient.LOG.isDebugEnabled()) {
DFSClient.LOG.debug("Connection failure ", e);
}
}
} finally {
if (reader != null) {
closeBlockReader(reader);
}
}
// Put chosen node into dead list, continue
addToDeadNodes(chosenNode);
}
}