Java BlockReader类代码示例

import org.apache.hadoop.hdfs.BlockReader; //导入依赖的package包/类
private Callable<Void> readFromBlock(final BlockReader reader,
    final ByteBuffer buf) {
  return new Callable<Void>() {

    @Override
    public Void call() throws Exception {
      try {
        actualReadFromBlock(reader, buf);
        return null;
      } catch (IOException e) {
        LOG.info(e.getMessage());
        throw e;
      }
    }

  };
}
 

import org.apache.hadoop.hdfs.BlockReader; //导入依赖的package包/类
private BlockReader newBlockReader(final ExtendedBlock block, 
    long offsetInBlock, DatanodeInfo dnInfo) {
  if (offsetInBlock >= block.getNumBytes()) {
    return null;
  }
  try {
    InetSocketAddress dnAddr = getSocketAddress4Transfer(dnInfo);
    Token<BlockTokenIdentifier> blockToken = datanode.getBlockAccessToken(
        block, EnumSet.of(BlockTokenIdentifier.AccessMode.READ));
    /*
     * This can be further improved if the replica is local, then we can
     * read directly from DN and need to check the replica is FINALIZED
     * state, notice we should not use short-circuit local read which
     * requires config for domain-socket in UNIX or legacy config in Windows.
     *
     * TODO: add proper tracer
     */
    return RemoteBlockReader2.newBlockReader(
        "dummy", block, blockToken, offsetInBlock, 
        block.getNumBytes() - offsetInBlock, true,
        "", newConnectedPeer(block, dnAddr, blockToken, dnInfo), dnInfo,
        null, cachingStrategy, datanode.getTracer());
  } catch (IOException e) {
    return null;
  }
}
 

import org.apache.hadoop.hdfs.BlockReader; //导入依赖的package包/类
private void tryGetLocalFile() {
    if (tryGetLocalFileTimes >= TRY_GET_LOCAL_FILE_LIMIT) {
        return;
    }
    if (isSingleBlock && HDFS_READ_HACK_ENABLE) {
        try {
            InputStream is = input.getWrappedStream();
            if (is instanceof DFSInputStream) {
                BlockReader blockReader = MemoryUtil.getDFSInputStream_blockReader(is);
                if (blockReader != null && blockReader.isShortCircuit()) {
                    localFile = MemoryUtil.getBlockReaderLocal_dataIn(blockReader);
                }
            }
        } catch (Throwable e) {
            logger.debug("HDFS READ HACK failed.", e);
        }
    }
    tryGetLocalFileTimes++;
}
 

import org.apache.hadoop.hdfs.BlockReader; //导入依赖的package包/类
/**
 * Close the given BlockReader and cache its socket.
 */
private void closeBlockReader(BlockReader reader, boolean reuseConnection) 
    throws IOException {
  if (reader.hasSentStatusCode()) {
    Socket oldSock = reader.takeSocket();
    if (dfsClient.getDataTransferProtocolVersion() < 
        DataTransferProtocol.READ_REUSE_CONNECTION_VERSION ||
        !reuseConnection) {
        // close the sock for old datanode.
      if (oldSock != null) {
        IOUtils.closeSocket(oldSock);
      }
    } else {
      socketCache.put(oldSock);
    }
  }
  reader.close();
}
 

import org.apache.hadoop.hdfs.BlockReader; //导入依赖的package包/类
/**
 * try to access a block on a data node. If fails - throws exception
 * @param datanode
 * @param lblock
 * @throws IOException
 */
private void accessBlock(DatanodeInfo datanode, LocatedBlock lblock)
  throws IOException {
  InetSocketAddress targetAddr = null;
  Socket s = null;
  ExtendedBlock block = lblock.getBlock(); 
 
  targetAddr = NetUtils.createSocketAddr(datanode.getXferAddr());
    
  s = NetUtils.getDefaultSocketFactory(conf).createSocket();
  s.connect(targetAddr, HdfsServerConstants.READ_TIMEOUT);
  s.setSoTimeout(HdfsServerConstants.READ_TIMEOUT);

  String file = BlockReaderFactory.getFileName(targetAddr, 
      "test-blockpoolid",
      block.getBlockId());
  BlockReader blockReader =
    BlockReaderFactory.newBlockReader(new DFSClient.Conf(conf), file, block,
      lblock.getBlockToken(), 0, -1, true, "TestDataNodeVolumeFailure",
      TcpPeerServer.peerFromSocket(s), datanode, null, null, null, false);
  blockReader.close();
}
 

import org.apache.hadoop.hdfs.BlockReader; //导入依赖的package包/类
/**
 * try to access a block on a data node. If fails - throws exception
 * @param datanode
 * @param lblock
 * @throws IOException
 */
private void accessBlock(DatanodeInfo datanode, LocatedBlock lblock)
  throws IOException {
  InetSocketAddress targetAddr = null;
  Socket s = null;
  ExtendedBlock block = lblock.getBlock(); 
 
  targetAddr = NetUtils.createSocketAddr(datanode.getXferAddr());
    
  s = NetUtils.getDefaultSocketFactory(conf).createSocket();
  s.connect(targetAddr, HdfsServerConstants.READ_TIMEOUT);
  s.setSoTimeout(HdfsServerConstants.READ_TIMEOUT);

  String file = BlockReaderFactory.getFileName(targetAddr, 
      "test-blockpoolid",
      block.getBlockId());
  BlockReader blockReader =
    BlockReaderFactory.newBlockReader(new DFSClient.Conf(conf), file, block,
      lblock.getBlockToken(), 0, -1, true, "TestDataNodeVolumeFailure",
      TcpPeerServer.peerFromSocket(s), datanode, null, null, null, false,
      CachingStrategy.newDefaultStrategy());
  blockReader.close();
}
 

import org.apache.hadoop.hdfs.BlockReader; //导入依赖的package包/类
/**
 * try to access a block on a data node. If fails - throws exception
 * @param datanode
 * @param lblock
 * @throws IOException
 */
private void accessBlock(DatanodeInfo datanode, LocatedBlock lblock)
  throws IOException {
  InetSocketAddress targetAddr = null;
  Socket s = null;
  BlockReader blockReader = null; 
  Block block = lblock.getBlock(); 
 
  targetAddr = NetUtils.createSocketAddr(datanode.getName());
    
  s = new Socket();
  s.connect(targetAddr, HdfsConstants.READ_TIMEOUT);
  s.setSoTimeout(HdfsConstants.READ_TIMEOUT);

  String file = BlockReader.getFileName(targetAddr, block.getBlockId());
  blockReader = 
    BlockReader.newBlockReader(s, file, block, lblock
      .getBlockToken(), 0, -1, 4096);

  // nothing - if it fails - it will throw and exception
}
 

import org.apache.hadoop.hdfs.BlockReader; //导入依赖的package包/类
private void initChecksumAndBufferSizeIfNeeded(BlockReader blockReader) {
  if (checksum == null) {
    checksum = blockReader.getDataChecksum();
    bytesPerChecksum = checksum.getBytesPerChecksum();
    // The bufferSize is flat to divide bytesPerChecksum
    int readBufferSize = STRIPED_READ_BUFFER_SIZE;
    bufferSize = readBufferSize < bytesPerChecksum ? bytesPerChecksum :
      readBufferSize - readBufferSize % bytesPerChecksum;
  } else {
    assert blockReader.getDataChecksum().equals(checksum);
  }
}
 

import org.apache.hadoop.hdfs.BlockReader; //导入依赖的package包/类
/**
 * Read bytes from block
 */
private void actualReadFromBlock(BlockReader reader, ByteBuffer buf)
    throws IOException {
  int len = buf.remaining();
  int n = 0;
  while (n < len) {
    int nread = reader.read(buf);
    if (nread <= 0) {
      break;
    }
    n += nread;
  }
}
 

import org.apache.hadoop.hdfs.BlockReader; //导入依赖的package包/类
private void closeBlockReader(BlockReader blockReader) {
  try {
    if (blockReader != null) {
      blockReader.close();
    }
  } catch (IOException e) {
    // ignore
  }
}
 

import org.apache.hadoop.hdfs.BlockReader; //导入依赖的package包/类
protected BlockReader getBlockReader(int protocolVersion, int namespaceId,
    InetSocketAddress dnAddr, String file, long blockId,
    long generationStamp, long startOffset, long len, int bufferSize,
    boolean verifyChecksum, String clientName, long bytesToCheckReadSpeed,
    long minReadSpeedBps, boolean reuseConnection,
    FSClientReadProfilingData cliData)
    throws IOException {
  return getBlockReader(protocolVersion, namespaceId, dnAddr, file, blockId,
      generationStamp, startOffset, len, bufferSize, verifyChecksum,
      clientName, bytesToCheckReadSpeed, minReadSpeedBps, reuseConnection,
      cliData, options);
}
 

import org.apache.hadoop.hdfs.BlockReader; //导入依赖的package包/类
public static void streamBlockInAscii(InetSocketAddress addr, 
    long blockId, Token<BlockTokenIdentifier> blockToken, long genStamp,
    long blockSize, long offsetIntoBlock, long chunkSizeToView,
    JspWriter out, Configuration conf) throws IOException {
  if (chunkSizeToView == 0) return;
  Socket s = new Socket();
  s.connect(addr, HdfsConstants.READ_TIMEOUT);
  s.setSoTimeout(HdfsConstants.READ_TIMEOUT);
    
    long amtToRead = Math.min(chunkSizeToView, blockSize - offsetIntoBlock);     
    
    // Use the block name for file name. 
    String file = BlockReader.getFileName(addr, blockId);
    BlockReader blockReader = BlockReader.newBlockReader(s, file,
      new Block(blockId, 0, genStamp), blockToken,
      offsetIntoBlock, amtToRead, conf.getInt("io.file.buffer.size", 4096));
      
  byte[] buf = new byte[(int)amtToRead];
  int readOffset = 0;
  int retries = 2;
  while ( amtToRead > 0 ) {
    int numRead;
    try {
      numRead = blockReader.readAll(buf, readOffset, (int)amtToRead);
    }
    catch (IOException e) {
      retries--;
      if (retries == 0)
        throw new IOException("Could not read data from datanode");
      continue;
    }
    amtToRead -= numRead;
    readOffset += numRead;
  }
  blockReader = null;
  s.close();
  out.print(HtmlQuoting.quoteHtmlChars(new String(buf)));
}
 

import org.apache.hadoop.hdfs.BlockReader; //导入依赖的package包/类
/**
 * Test that we don't call verifiedByClient() when the client only
 * reads a partial block.
 */
@Test
public void testCompletePartialRead() throws Exception {
  // Ask for half the file
  BlockReader reader = util.getBlockReader(testBlock, 0, FILE_SIZE_K * 1024 / 2);
  DataNode dn = util.getDataNode(testBlock);
  DataBlockScanner scanner = spy(dn.blockScanner);
  dn.blockScanner = scanner;

  // And read half the file
  util.readAndCheckEOS(reader, FILE_SIZE_K * 1024 / 2, true);
  verify(scanner, never()).verifiedByClient(Mockito.isA(Block.class));
  reader.close();
}
 

import org.apache.hadoop.hdfs.BlockReader; //导入依赖的package包/类
private static void tryRead(final Configuration conf, LocatedBlock lblock,
    boolean shouldSucceed) {
  InetSocketAddress targetAddr = null;
  IOException ioe = null;
  BlockReader blockReader = null;
  ExtendedBlock block = lblock.getBlock();
  try {
    DatanodeInfo[] nodes = lblock.getLocations();
    targetAddr = NetUtils.createSocketAddr(nodes[0].getXferAddr());

    blockReader = new BlockReaderFactory(new DFSClient.Conf(conf)).
        setFileName(BlockReaderFactory.getFileName(targetAddr, 
                      "test-blockpoolid", block.getBlockId())).
        setBlock(block).
        setBlockToken(lblock.getBlockToken()).
        setInetSocketAddress(targetAddr).
        setStartOffset(0).
        setLength(-1).
        setVerifyChecksum(true).
        setClientName("TestBlockTokenWithDFS").
        setDatanodeInfo(nodes[0]).
        setCachingStrategy(CachingStrategy.newDefaultStrategy()).
        setClientCacheContext(ClientContext.getFromConf(conf)).
        setConfiguration(conf).
        setRemotePeerFactory(new RemotePeerFactory() {
          @Override
          public Peer newConnectedPeer(InetSocketAddress addr,
              Token<BlockTokenIdentifier> blockToken, DatanodeID datanodeId)
              throws IOException {
            Peer peer = null;
            Socket sock = NetUtils.getDefaultSocketFactory(conf).createSocket();
            try {
              sock.connect(addr, HdfsServerConstants.READ_TIMEOUT);
              sock.setSoTimeout(HdfsServerConstants.READ_TIMEOUT);
              peer = TcpPeerServer.peerFromSocket(sock);
            } finally {
              if (peer == null) {
                IOUtils.closeSocket(sock);
              }
            }
            return peer;
          }
        }).
        build();
  } catch (IOException ex) {
    ioe = ex;
  } finally {
    if (blockReader != null) {
      try {
        blockReader.close();
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
    }
  }
  if (shouldSucceed) {
    Assert.assertNotNull("OP_READ_BLOCK: access token is invalid, "
          + "when it is expected to be valid", blockReader);
  } else {
    Assert.assertNotNull("OP_READ_BLOCK: access token is valid, "
        + "when it is expected to be invalid", ioe);
    Assert.assertTrue(
        "OP_READ_BLOCK failed due to reasons other than access token: ",
        ioe instanceof InvalidBlockTokenException);
  }
}
 

import org.apache.hadoop.hdfs.BlockReader; //导入依赖的package包/类
/**
 * try to access a block on a data node. If fails - throws exception
 * @param datanode
 * @param lblock
 * @throws IOException
 */
private void accessBlock(DatanodeInfo datanode, LocatedBlock lblock)
  throws IOException {
  InetSocketAddress targetAddr = null;
  ExtendedBlock block = lblock.getBlock(); 
 
  targetAddr = NetUtils.createSocketAddr(datanode.getXferAddr());

  BlockReader blockReader = new BlockReaderFactory(new DFSClient.Conf(conf)).
    setInetSocketAddress(targetAddr).
    setBlock(block).
    setFileName(BlockReaderFactory.getFileName(targetAddr,
                  "test-blockpoolid", block.getBlockId())).
    setBlockToken(lblock.getBlockToken()).
    setStartOffset(0).
    setLength(-1).
    setVerifyChecksum(true).
    setClientName("TestDataNodeVolumeFailure").
    setDatanodeInfo(datanode).
    setCachingStrategy(CachingStrategy.newDefaultStrategy()).
    setClientCacheContext(ClientContext.getFromConf(conf)).
    setConfiguration(conf).
    setRemotePeerFactory(new RemotePeerFactory() {
      @Override
      public Peer newConnectedPeer(InetSocketAddress addr,
          Token<BlockTokenIdentifier> blockToken, DatanodeID datanodeId)
          throws IOException {
        Peer peer = null;
        Socket sock = NetUtils.getDefaultSocketFactory(conf).createSocket();
        try {
          sock.connect(addr, HdfsServerConstants.READ_TIMEOUT);
          sock.setSoTimeout(HdfsServerConstants.READ_TIMEOUT);
          peer = TcpPeerServer.peerFromSocket(sock);
        } finally {
          if (peer == null) {
            IOUtils.closeSocket(sock);
          }
        }
        return peer;
      }
    }).
    build();
  blockReader.close();
}