지침:
1. Hadoop 버전: 3.1.3
2. 읽기 도구: IDEA 2023.1.2
3. 소스 코드 획득: /dist/hadoop/core/hadoop-3.1.3 색인(apache.org)
4. 프로젝트 가져오기: 다운로드 소스 코드 그런 다음 압축된 패키지를 가져오고 현재 디렉터리에서 PowerShell을 열고 명령을 사용하여 압축을 푼 다음 IDEA를 사용하여 폴더를 엽니다. Maven 또는 Gradle Warehouse를 구성할 때 주의하세요. 그렇지 않으면 jar 패키지 가져오기가 느려집니다. 5. 참고 강좌: www.bilibili.com /video/BV1Qp…hadoop-3.1.3-src.tar.gztar -zxvfhadoop-3.1.3-src
HDFS 업로드
간단한 업로드 코드:
public void test() throws IOException {
FSDataOutputStream fos = fs.create(new Path("/input"));
fos.write("hello world".getBytes());
}보시다시피 하나를 먼저 생성
FSDataOutputStream하고 여기에 데이터를 쓰는 과정을 거쳐 생성 생성 과정 과 소스 코드를 읽고 분석하는 쓰기 업로드 과정으로 나누어집니다.
create생성 프로세스
1. 클라이언트가 NN에 생성 요청을 보냅니다.
먼저 create메소드를 입력하고 FileSystem.java로 이동하십시오.
생성 메소드를 찾고 정적 메소드를 찾을 때까지 계속 입력하십시오 create.
그러면 정적 메서드 호출로 돌아가 보겠습니다.
ctrl+alt+B는 이 정적 메서드의 구현 클래스를 찾습니다.
입장 DistributedFileSystem:
계속 아래를 내려다보세요:
doCall메소드에서 출력 스트림 객체가 생성되는 것을 볼 수 있습니다 .
계속해서 create메소드를 입력하고 DFSClient.java로 이동합니다.
newStreamForCreate방법을 찾으려면 아래쪽으로 계속 검색하세요 .
newStreamForCreate메소드를 입력 하고 DFSOutputStream.java로 이동하세요.
여기서 클라이언트는 RPC 통신을 통해 처리하기 위해 생성 요청을 NN으로 보냅니다.
스레드 시작
2.NN은 클라이언트의 생성 요청을 처리합니다.
newStreamForCreate메소드에 create 메소드를 입력하고 ClientProtocol.java로 이동하십시오.
구현 클래스를 찾으십시오.
다음과 같이 NameNodeRpcServer를 입력합니다 create.
@Override // ClientProtocol
public HdfsFileStatus create(String src, FsPermission masked,
String clientName, EnumSetWritable<CreateFlag> flag,
boolean createParent, short replication, long blockSize,
CryptoProtocolVersion[] supportedVersions, String ecPolicyName)
throws IOException {
checkNNStartup(); //检查NN是否启动
String clientMachine = getClientMachine();
if (stateChangeLog.isDebugEnabled()) {
stateChangeLog.debug("*DIR* NameNode.create: file "
+src+" for "+clientName+" at "+clientMachine);
}
if (!checkPathLength(src)) { //检查路径长度
throw new IOException("create: Pathname too long. Limit "
+ MAX_PATH_LENGTH + " characters, " + MAX_PATH_DEPTH + " levels.");
}
namesystem.checkOperation(OperationCategory.WRITE);
CacheEntryWithPayload cacheEntry = RetryCache.waitForCompletion(retryCache, null);
if (cacheEntry != null && cacheEntry.isSuccess()) { //缓存相关检查
return (HdfsFileStatus) cacheEntry.getPayload();
}
HdfsFileStatus status = null;
try {
PermissionStatus perm = new PermissionStatus(getRemoteUser()
.getShortUserName(), null, masked);
//开启文件（重要）
status = namesystem.startFile(src, perm, clientName, clientMachine,
flag.get(), createParent, replication, blockSize, supportedVersions,
ecPolicyName, cacheEntry != null);
} finally {
RetryCache.setState(cacheEntry, status != null, status);
}
metrics.incrFilesCreated();
metrics.incrCreateFileOps();
return status;
}startFile다음으로 메소드를 입력 하고 FSNamesystem.java로 이동합니다.
입력 startFileInt:
src(파일 경로)를 INodesInPath로 캡슐화합니다.
INodesInPath 클래스 설명: 지정된 경로에서 확인된 INodes 정보를 포함합니다.
먼저 INodes 클래스의 개념을 명확히 해야 합니다.
INodes는 추상 클래스이며 공식적인 설명은 다음과 같습니다.
간단히 말해서 기본 INode 클래스는 파일 및 디렉토리 inode에 대한 공통 필드를 포함하는 파일/블록 계층 구조의 메모리 내 표현입니다.
INodes는 파일과 디렉터리에 공통적인 일부 속성을 저장하는 최하위 클래스인 반면, INodesInPath 클래스는 지정된 경로에서 구문 분석된 Inode 정보를 저장하는 것을 볼 수 있습니다.
다음 위치 startFile:
입력하다startFile
- 먼저 파일 경로가 존재하는지 확인하십시오.
입력 getLastINode:
입력 getINode:
i=-1일 때,return inodes[inodes.length-1];
즉, 마지막 위치의 inode를 얻어오면, 해당 파일 경로가 이미 존재한다는 의미이다.
다음으로 덮어쓰기가 허용되는지 여부를 결정합니다.
덮어쓰기가 허용되지 않는 경우 파일 경로가 이미 존재하므로 파일을 반복 업로드할 수 없음을 알리는 예외가 발생합니다.
- 그런 다음 상위 디렉터리가 존재하는지 확인합니다.
상위 디렉터리가 존재하는 경우 해당 디렉터리에 파일 메타데이터 정보를 추가합니다( addFile메서드).
참가 addFile방법:
입력 addINode:
Inode의 디렉토리 트리에 데이터를 기록하면 이제 파일 디렉토리가 생성됩니다.
3.DataStreamer 시작 프로세스
NN 처리가 완료된 후 다시 클라이언트로 돌아가 해당 스레드를 시작합니다.
DFSOutputStream.java를 열고 newStreamForCreate메서드를 찾습니다. NN이 생성 요청을 완료한 후 출력 스트림을 생성합니다.
대상 DFSOutputStream:
청크 크기 계산 (디렉터리 => 파일 => 블록(128M) => 패킷(64K) => 청크(청크 512byte + 청크합 4byte))
newStreamForCreate메소드 로 돌아가서 입력하세요.out.start()
계속해서 입력하세요:
계속해서 입력하세요 DataStreamer:
입력 Daemon:
보시다시피 out.start 메소드는 스레드를 시작하므로 DataStreamer로 돌아가서 run 메소드를 검색하십시오.
dataQueue에 데이터가 없으면 코드가 차단됩니다.
dataQueue가 비어 있지 않으면 거기에서 패킷을 가져옵니다.
업로드 프로세스 작성
1. DataStreamer의 대기열에 데이터 쓰기
DataStreamer는 생성 단계에서 시작되고 데이터는 쓰기 단계에서 기록됩니다.
쓰기 메소드를 입력하고 FilterOutputStream.java로 이동하십시오.
추상 메소드에 도달할 때까지 계속 진행하세요 write.
구현 클래스를 찾으려면 Ctrl+Alt+B를 사용하세요.
FSOutputSummer.java를 입력하고 쓰기 메소드를 찾으십시오.
flushBuffer이름에서 알 수 있듯이 진입 방법은 버퍼를 플러시하는 것입니다.
참가 writeChecksumChunks방법:
입력 writeChunk방법(데이터 대기열에 청크 쓰기):
추상 메소드이므로 구현 클래스를 찾으십시오.
writeChunkDFSOutputStream.java를 입력하면 다음과 같이 메소드의 특정 구현 논리를 볼 수 있습니다 .
@Override
protected synchronized void writeChunk(byte[] b, int offset, int len,
byte[] checksum, int ckoff, int cklen) throws IOException {
writeChunkPrepare(len, ckoff, cklen);
currentPacket.writeChecksum(checksum, ckoff, cklen); //往packet里面写chunk的校验和 4byte
currentPacket.writeData(b, offset, len); // 往packet里面写一个chunk 512byte
// 记录写入packet中的chunk个数，累计到127个chuck，这个packet就满了
currentPacket.incNumChunks();
getStreamer().incBytesCurBlock(len);
//如果packet已经满了，则将其放入队列等待传输
if (currentPacket.getNumChunks() == currentPacket.getMaxChunks() ||
getStreamer().getBytesCurBlock() == blockSize) {
enqueueCurrentPacketFull();
}
}참가 enqueueCurrentPacketFull방법:
참가 enqueueCurrentPacket방법:
참가 waitAndQueuePacket방법:
void waitAndQueuePacket(DFSPacket packet) throws IOException {
synchronized (dataQueue) {
try {
// 如果队列满了，则等待
boolean firstWait = true;
try {
while (!streamerClosed && dataQueue.size() + ackQueue.size() >
dfsClient.getConf().getWriteMaxPackets()) {
if (firstWait) {
Span span = Tracer.getCurrentSpan();
if (span != null) {
span.addTimelineAnnotation("dataQueue.wait");
}
firstWait = false;
}
try {
dataQueue.wait(); //等待队列有充足的空间
} catch (InterruptedException e) {
// If we get interrupted while waiting to queue data, we still need to get rid
// of the current packet. This is because we have an invariant that if
// currentPacket gets full, it will get queued before the next writeChunk.
//
// Rather than wait around for space in the queue, we should instead try to
// return to the caller as soon as possible, even though we slightly overrun
// the MAX_PACKETS length.
Thread.currentThread().interrupt();
break;
}
}
} finally {
Span span = Tracer.getCurrentSpan();
if ((span != null) && (!firstWait)) {
span.addTimelineAnnotation("end.wait");
}
}
checkClosed();
//如果队列没满，则向队列中添加数据
queuePacket(packet);
} catch (ClosedChannelException ignored) {
}
}
}queuePacket메소드(큐에 데이터를 추가하는 논리)를 입력 하고 DataStreamer.java로 이동합니다.
2. 파이프라인 구축
2.1 랙 인식(블록의 저장 위치 결정)
Ctrl + n 전역 검색 DataStreamer, 검색 run방법:
@Override
public void run() {
long lastPacket = Time.monotonicNow();
TraceScope scope = null;
while (!streamerClosed && dfsClient.clientRunning) {
// if the Responder encountered an error, shutdown Responder
if (errorState.hasError()) {
closeResponder();
}
DFSPacket one;
try {
// process datanode IO errors if any
boolean doSleep = processDatanodeOrExternalError();
final int halfSocketTimeout = dfsClient.getConf().getSocketTimeout()/2;
//步骤一：等待要发送的packet到来
synchronized (dataQueue) {
// wait for a packet to be sent.
long now = Time.monotonicNow();
while ((!shouldStop() && dataQueue.size() == 0 &&
(stage != BlockConstructionStage.DATA_STREAMING ||
now - lastPacket < halfSocketTimeout)) || doSleep) {
long timeout = halfSocketTimeout - (now-lastPacket);
timeout = timeout <= 0 ? 1000 : timeout;
timeout = (stage == BlockConstructionStage.DATA_STREAMING)?
timeout : 1000;
try {
//如果dataQueue中没有数据，代码会阻塞在这里
dataQueue.wait(timeout);
} catch (InterruptedException e) {
LOG.warn("Caught exception", e);
}
doSleep = false;
now = Time.monotonicNow();
}
if (shouldStop()) {
continue;
}
// 获取要发送的数据包
if (dataQueue.isEmpty()) {
one = createHeartbeatPacket();
}
else {
try {
backOffIfNecessary();
} catch (InterruptedException e) {
LOG.warn("Caught exception", e);
}
//如果数据队列不为空，则从其中取出packet
one = dataQueue.getFirst();
SpanId[] parents = one.getTraceParents();
if (parents.length > 0) {
scope = dfsClient.getTracer().
newScope("dataStreamer", parents[0]);
scope.getSpan().setParents(parents);
}
}
}
//步骤二：从NN获取新的block
if (LOG.isDebugEnabled()) {
LOG.debug("stage=" + stage + ", " + this);
}
if (stage == BlockConstructionStage.PIPELINE_SETUP_CREATE) {
LOG.debug("Allocating new block: {}", this);
//向NN申请block并建立数据管道（Pipeline）
setPipeline(nextBlockOutputStream());
//启动ResponseProcessor用来监听packet发送是否成功
initDataStreaming();
} else if (stage == BlockConstructionStage.PIPELINE_SETUP_APPEND) {
LOG.debug("Append to block {}", block);
setupPipelineForAppendOrRecovery();
if (streamerClosed) {
continue;
}
initDataStreaming();
}
long lastByteOffsetInBlock = one.getLastByteOffsetBlock();
if (lastByteOffsetInBlock > stat.getBlockSize()) {
throw new IOException("BlockSize " + stat.getBlockSize() +
" < lastByteOffsetInBlock, " + this + ", " + one);
}
if (one.isLastPacketInBlock()) {
// wait for all data packets have been successfully acked
synchronized (dataQueue) {
while (!shouldStop() && ackQueue.size() != 0) {
try {
// wait for acks to arrive from datanodes
dataQueue.wait(1000);
} catch (InterruptedException e) {
LOG.warn("Caught exception", e);
}
}
}
if (shouldStop()) {
continue;
}
stage = BlockConstructionStage.PIPELINE_CLOSE;
}
// 步骤三：发送packet
SpanId spanId = SpanId.INVALID;
synchronized (dataQueue) {
// move packet from dataQueue to ackQueue
if (!one.isHeartbeatPacket()) {
if (scope != null) {
spanId = scope.getSpanId();
scope.detach();
one.setTraceScope(scope);
}
scope = null;
dataQueue.removeFirst(); //从dataQueue 把要发送的这个packet 移除出去
ackQueue.addLast(one); //ackQueue 里面添加这个packet
packetSendTime.put(one.getSeqno(), Time.monotonicNow());
dataQueue.notifyAll();
}
}
LOG.debug("{} sending {}", this, one);
// 步骤四：向DN中写数据
try (TraceScope ignored = dfsClient.getTracer().
newScope("DataStreamer#writeTo", spanId)) {
one.writeTo(blockStream); //写出数据
blockStream.flush();
} catch (IOException e) {
// HDFS-3398 treat primary DN is down since client is unable to
// write to primary DN. If a failed or restarting node has already
// been recorded by the responder, the following call will have no
// effect. Pipeline recovery can handle only one node error at a
// time. If the primary node fails again during the recovery, it
// will be taken out then.
errorState.markFirstNodeIfNotMarked();
throw e;
}
lastPacket = Time.monotonicNow();
// update bytesSent
long tmpBytesSent = one.getLastByteOffsetBlock();
if (bytesSent < tmpBytesSent) {
bytesSent = tmpBytesSent;
}
if (shouldStop()) {
continue;
}
// Is this block full?
if (one.isLastPacketInBlock()) {
// wait for the close packet has been acked
synchronized (dataQueue) {
while (!shouldStop() && ackQueue.size() != 0) {
dataQueue.wait(1000);// wait for acks to arrive from datanodes
}
}
if (shouldStop()) {
continue;
}
endBlock();
}
if (progress != null) { progress.progress(); }
// This is used by unit test to trigger race conditions.
if (artificialSlowdown != 0 && dfsClient.clientRunning) {
Thread.sleep(artificialSlowdown);
}
} catch (Throwable e) {
// Log warning if there was a real error.
if (!errorState.isRestartingNode()) {
// Since their messages are descriptive enough, do not always
// log a verbose stack-trace WARN for quota exceptions.
if (e instanceof QuotaExceededException) {
LOG.debug("DataStreamer Quota Exception", e);
} else {
LOG.warn("DataStreamer Exception", e);
}
}
lastException.set(e);
assert !(e instanceof NullPointerException);
errorState.setInternalError();
if (!errorState.isNodeMarked()) {
// Not a datanode issue
streamerClosed = true;
}
} finally {
if (scope != null) {
scope.close();
scope = null;
}
}
}
closeInternal();
}Enter nextBlockOutputStream(68행):
입력 locateFollowingBlock:
입력 addBlock:
addBlockClientProtocol 클래스에 들어가서 들어갑니다.
따라서 이 방식은 NN의 클라이언트 에이전트를 통해 구현된 것으로 판단할 수 있다.
구현 클래스를 찾으십시오.
NameNodeRpcServer를 입력하고 addBlock을 찾습니다.
입력 getAdditionalBlock:
블록의 저장 위치를 선택합니다.
입력 chooseTargetForNewBlock:
입력 chooseTarget4NewBlock:
입력 chooseTarget:
계속해서 입력하세요 chooseTarget:
추상 클래스임을 알 수 있으므로 해당 구현 클래스를 찾으세요.
BlockPlacementPolicyDefault.java를 입력합니다.
입력 chooseTarget:
입력 chooseTarget:
chooseTargetInOrder랙 인식 논리를 입력합니다 .
protected Node chooseTargetInOrder(int numOfReplicas,
Node writer,
final Set<Node> excludedNodes,
final long blocksize,
final int maxNodesPerRack,
final List<DatanodeStorageInfo> results,
final boolean avoidStaleNodes,
final boolean newBlock,
EnumMap<StorageType, Integer> storageTypes)
throws NotEnoughReplicasException {
final int numOfResults = results.size();
if (numOfResults == 0) {
//第一个block存储在当前节点
DatanodeStorageInfo storageInfo = chooseLocalStorage(writer,
excludedNodes, blocksize, maxNodesPerRack, results, avoidStaleNodes,
storageTypes, true);
writer = (storageInfo != null) ? storageInfo.getDatanodeDescriptor()
: null;
if (--numOfReplicas == 0) {
return writer;
}
}
final DatanodeDescriptor dn0 = results.get(0).getDatanodeDescriptor();
if (numOfResults <= 1) {
//第二个block存储在另外一个机架
chooseRemoteRack(1, dn0, excludedNodes, blocksize, maxNodesPerRack,
results, avoidStaleNodes, storageTypes);
if (--numOfReplicas == 0) {
return writer;
}
}
if (numOfResults <= 2) {
final DatanodeDescriptor dn1 = results.get(1).getDatanodeDescriptor();
if (clusterMap.isOnSameRack(dn0, dn1)) {
//如果第一个和第二个在同一个机架，那么第三个放在其他机架
chooseRemoteRack(1, dn0, excludedNodes, blocksize, maxNodesPerRack,
results, avoidStaleNodes, storageTypes);
} else if (newBlock){
//如果是新块，和第二个块存储在同一个机架
chooseLocalRack(dn1, excludedNodes, blocksize, maxNodesPerRack,
results, avoidStaleNodes, storageTypes);
} else {
//如果不是新块，放在当前机架
chooseLocalRack(writer, excludedNodes, blocksize, maxNodesPerRack,
results, avoidStaleNodes, storageTypes);
}
if (--numOfReplicas == 0) {
return writer;
}
}
chooseRandom(numOfReplicas, NodeBase.ROOT, excludedNodes, blocksize,
maxNodesPerRack, results, avoidStaleNodes, storageTypes);
return writer;
}2.2 소켓 전송
다음으로 돌아가기 nextBlockOutputStream:
입력 createBlockOutputStream:
설명에서 볼 수 있듯이 이 방법의 주요 기능은 파이프라인의 첫 번째 DN과 연결을 설정하는 것입니다.
boolean createBlockOutputStream(DatanodeInfo[] nodes,
StorageType[] nodeStorageTypes, String[] nodeStorageIDs,
long newGS, boolean recoveryFlag) {
if (nodes.length == 0) {
LOG.info("nodes are empty for write pipeline of " + block);
return false;
}
String firstBadLink = "";
boolean checkRestart = false;
if (LOG.isDebugEnabled()) {
LOG.debug("pipeline = " + Arrays.toString(nodes) + ", " + this);
}
// persist blocks on namenode on next flush
persistBlocks.set(true);
int refetchEncryptionKey = 1;
while (true) {
boolean result = false;
DataOutputStream out = null;
try {
assert null == s : "Previous socket unclosed";
assert null == blockReplyStream : "Previous blockReplyStream unclosed";
//和DN创建socket连接
s = createSocketForPipeline(nodes[0], nodes.length, dfsClient);
long writeTimeout = dfsClient.getDatanodeWriteTimeout(nodes.length);
long readTimeout = dfsClient.getDatanodeReadTimeout(nodes.length);
//输出流，用于写数据到DN
OutputStream unbufOut = NetUtils.getOutputStream(s, writeTimeout);
//输入流，用于读取写数据到DN的结果
InputStream unbufIn = NetUtils.getInputStream(s, readTimeout);
IOStreamPair saslStreams = dfsClient.saslClient.socketSend(s,
unbufOut, unbufIn, dfsClient, accessToken, nodes[0]);
unbufOut = saslStreams.out;
unbufIn = saslStreams.in;
out = new DataOutputStream(new BufferedOutputStream(unbufOut,
DFSUtilClient.getSmallBufferSize(dfsClient.getConfiguration())));
blockReplyStream = new DataInputStream(unbufIn);
//
// Xmit header info to datanode
//
BlockConstructionStage bcs = recoveryFlag ?
stage.getRecoveryStage() : stage;
// We cannot change the block length in 'block' as it counts the number
// of bytes ack'ed.
ExtendedBlock blockCopy = block.getCurrentBlock();
blockCopy.setNumBytes(stat.getBlockSize());
boolean[] targetPinnings = getPinnings(nodes);
// 发送数据
new Sender(out).writeBlock(blockCopy, nodeStorageTypes[0], accessToken,
dfsClient.clientName, nodes, nodeStorageTypes, null, bcs,
nodes.length, block.getNumBytes(), bytesSent, newGS,
checksum4WriteBlock, cachingStrategy.get(), isLazyPersistFile,
(targetPinnings != null && targetPinnings[0]), targetPinnings,
nodeStorageIDs[0], nodeStorageIDs);
// receive ack for connect
BlockOpResponseProto resp = BlockOpResponseProto.parseFrom(
PBHelperClient.vintPrefixed(blockReplyStream));
Status pipelineStatus = resp.getStatus();
firstBadLink = resp.getFirstBadLink();
// Got an restart OOB ack.
// If a node is already restarting, this status is not likely from
// the same node. If it is from a different node, it is not
// from the local datanode. Thus it is safe to treat this as a
// regular node error.
if (PipelineAck.isRestartOOBStatus(pipelineStatus) &&
!errorState.isRestartingNode()) {
checkRestart = true;
throw new IOException("A datanode is restarting.");
}
String logInfo = "ack with firstBadLink as " + firstBadLink;
DataTransferProtoUtil.checkBlockOpStatus(resp, logInfo);
assert null == blockStream : "Previous blockStream unclosed";
blockStream = out;
result = true; // success
errorState.resetInternalError();
lastException.clear();
// remove all restarting nodes from failed nodes list
failed.removeAll(restartingNodes);
restartingNodes.clear();
} catch (IOException ie) {
if (!errorState.isRestartingNode()) {
LOG.info("Exception in createBlockOutputStream " + this, ie);
}
if (ie instanceof InvalidEncryptionKeyException &&
refetchEncryptionKey > 0) {
LOG.info("Will fetch a new encryption key and retry, "
+ "encryption key was invalid when connecting to "
+ nodes[0] + " : " + ie);
// The encryption key used is invalid.
refetchEncryptionKey--;
dfsClient.clearDataEncryptionKey();
// Don't close the socket/exclude this node just yet. Try again with
// a new encryption key.
continue;
}
// find the datanode that matches
if (firstBadLink.length() != 0) {
for (int i = 0; i < nodes.length; i++) {
// NB: Unconditionally using the xfer addr w/o hostname
if (firstBadLink.equals(nodes[i].getXferAddr())) {
errorState.setBadNodeIndex(i);
break;
}
}
} else {
assert !checkRestart;
errorState.setBadNodeIndex(0);
}
final int i = errorState.getBadNodeIndex();
// Check whether there is a restart worth waiting for.
if (checkRestart) {
errorState.initRestartingNode(i,
"Datanode " + i + " is restarting: " + nodes[i],
shouldWaitForRestart(i));
}
errorState.setInternalError();
lastException.set(ie);
result = false; // error
} finally {
if (!result) {
IOUtils.closeSocket(s);
s = null;
IOUtils.closeStream(out);
IOUtils.closeStream(blockReplyStream);
blockReplyStream = null;
}
}
return result;
}
}입력 writeBlock:
보내기 입력:
데이터를 깜박임 으로써 flush;
2.3.소켓 수신
데이터 수신은 DN의 작업이므로 DataXceiverServer.java를 입력하고 run메소드를 찾으십시오.
소켓 요청을 수신합니다.
클라이언트가 블록을 보낼 때마다 DataXceiver블록 처리를 시작합니다.
DataXceiver실행 메소드를 입력 하고 찾으십시오.
데이터를 읽는 작업 유형입니다.
작업 유형에 따라 데이터를 처리합니다.
입력 processOp:
다양한 작업 유형을 볼 수 있습니다.
입력 opWriteBlock(데이터 쓰기):
Ctrl +alt +b writeBlock의 구현 클래스를 찾고 DataXceiver.java를 입력합니다.
BlockReceiver를 생성합니다.
다운스트림 소켓으로 데이터 보내기
다음을 입력하세요 getBlockReceiver:
입력 BlockReceiver:
파이프라인을 생성합니다.
입력 createRbw:
FsDatasetImpl.java를 입력합니다.
입력 createRbw:
createRbwFile파일을 생성 하여
3. 클라이언트는 DN으로부터 응답을 받습니다.
DataStreamer.java로 돌아가서 다음을 실행하도록 탐색합니다.
initDataStreaming패킷이 성공적으로 전송되었는지 모니터링하는 메서드를 통해 ResponseProcessor를 시작합니다.
ResponseProcessor를 생성하고 스레드를 시작합니다.
실행을 입력 ResponseProcessor하고 찾습니다.
@Override
public void run() {
setName("ResponseProcessor for block " + block);
PipelineAck ack = new PipelineAck();
TraceScope scope = null;
while (!responderClosed && dfsClient.clientRunning && !isLastPacketInBlock) {
// 处理来自DN的应答
try {
// 从管道中读取一个ack
ack.readFields(blockReplyStream);
if (ack.getSeqno() != DFSPacket.HEART_BEAT_SEQNO) {
Long begin = packetSendTime.get(ack.getSeqno());
if (begin != null) {
long duration = Time.monotonicNow() - begin;
if (duration > dfsclientSlowLogThresholdMs) {
LOG.info("Slow ReadProcessor read fields for block " + block
+ " took " + duration + "ms (threshold="
+ dfsclientSlowLogThresholdMs + "ms); ack: " + ack
+ ", targets: " + Arrays.asList(targets));
}
}
}
if (LOG.isDebugEnabled()) {
LOG.debug("DFSClient {}", ack);
}
long seqno = ack.getSeqno();
// processes response status from datanodes.
ArrayList<DatanodeInfo> congestedNodesFromAck = new ArrayList<>();
for (int i = ack.getNumOfReplies()-1; i >=0 && dfsClient.clientRunning; i--) {
final Status reply = PipelineAck.getStatusFromHeader(ack
.getHeaderFlag(i));
if (PipelineAck.getECNFromHeader(ack.getHeaderFlag(i)) ==
PipelineAck.ECN.CONGESTED) {
congestedNodesFromAck.add(targets[i]);
}
// Restart will not be treated differently unless it is
// the local node or the only one in the pipeline.
if (PipelineAck.isRestartOOBStatus(reply)) {
final String message = "Datanode " + i + " is restarting: "
+ targets[i];
errorState.initRestartingNode(i, message,
shouldWaitForRestart(i));
throw new IOException(message);
}
// node error
if (reply != SUCCESS) {
errorState.setBadNodeIndex(i); // mark bad datanode
throw new IOException("Bad response " + reply +
" for " + block + " from datanode " + targets[i]);
}
}
if (!congestedNodesFromAck.isEmpty()) {
synchronized (congestedNodes) {
congestedNodes.clear();
congestedNodes.addAll(congestedNodesFromAck);
}
} else {
synchronized (congestedNodes) {
congestedNodes.clear();
lastCongestionBackoffTime = 0;
}
}
assert seqno != PipelineAck.UNKOWN_SEQNO :
"Ack for unknown seqno should be a failed ack: " + ack;
if (seqno == DFSPacket.HEART_BEAT_SEQNO) { // a heartbeat ack
continue;
}
// 标志成功传输的ack
DFSPacket one;
synchronized (dataQueue) {
one = ackQueue.getFirst();
}
if (one.getSeqno() != seqno) {
throw new IOException("ResponseProcessor: Expecting seqno " +
" for block " + block +
one.getSeqno() + " but received " + seqno);
}
isLastPacketInBlock = one.isLastPacketInBlock();
// Fail the packet write for testing in order to force a
// pipeline recovery.
if (DFSClientFaultInjector.get().failPacket() &&
isLastPacketInBlock) {
failPacket = true;
throw new IOException(
"Failing the last packet for testing.");
}
// update bytesAcked
block.setNumBytes(one.getLastByteOffsetBlock());
synchronized (dataQueue) {
scope = one.getTraceScope();
if (scope != null) {
scope.reattach();
one.setTraceScope(null);
}
lastAckedSeqno = seqno;
pipelineRecoveryCount = 0;
ackQueue.removeFirst(); //从ack队列中移除
packetSendTime.remove(seqno);
dataQueue.notifyAll(); //通知dataQueue应答处理完毕
one.releaseBuffer(byteArrayManager);
}
} catch (Exception e) {
if (!responderClosed) {
lastException.set(e);
errorState.setInternalError();
errorState.markFirstNodeIfNotMarked();
synchronized (dataQueue) {
dataQueue.notifyAll();
}
if (!errorState.isRestartingNode()) {
LOG.warn("Exception for " + block, e);
}
responderClosed = true;
}
} finally {
if (scope != null) {
scope.close();
}
scope = null;
}
}
}이 시점에서 클라이언트가 DN으로부터 응답을 성공적으로 수신하면 업로드 프로세스가 완료됩니다.