HDFS append原理与代码分析(Hadoop 2.0)

hdfs--lease recovery和block recovery源码分析 append操作在namenode这端主要逻辑在FSNameSystem的appendFileInternal函数中处理,内部会调用 前言 在DFSClient写文件的时候,对于文件的每一个block,生成一个pipeline,然后按照这个pipeline进行数据传输,但是可能在数据传输过程中,DFSClient发生中断,例如断网等,此时该block在NameNode中处于Under... 阅读详情

在append出现之前,一个file被close之后就是immutable的了,close之前是不能被read的。而在append出现之后,一个未close的file的last block对于read来说也是visible的,那么逻辑就复杂多了。

Apache社区的jira里有对HDFS append设计的详细文档(https://issues.apache.org/jira/secure/attachment/12445209/appendDesign3.pdf)。对于概念和逻辑在那个文档里讲的更详细些,那个文档更像是类似于bible或者C++ primer,可以当字典来查。这篇文章重点解释的是append的执行流程和前后逻辑,可能更容易读懂。

1,概念block和replica

首先区分两个概念:block和replica。在NN中我们叫block,在DN中我们叫replica。

在append问世之前,replica在DN中就两种状态:temporary和finalized。Replica被创建和写入时为temporary状态,当client发送完所有的byte请求DN关闭这个replica时,转化为finalized。 DN restart会删除处于temporary状态的replica。

在append问世之后,逻辑就复杂多了,状态也多了。首先明确block和replica的状态:(如何区分block和replica:在NN中叫block,在每个DN上叫replica)

NN中的block有下面4种状态:

static public enum BlockUCState {
    COMPLETE,
    UNDER_CONSTRUCTION,
    UNDER_RECOVERY,
    COMMITTED;
  }

注意NN中的block的状态是在内存中的,不会持久化到硬盘上。当NN重启后上次未关闭文件的last block将变成under construction,其余的为Complete。

1) complete:block的length和gs不再发生变化,并且NN已经收到至少有一个DN报告有finalized状态的replica(DN上的replica状态发生变化会通过RPC blockReceivedAndDeleted向NN报告)。一个complete的block会保存finalized的replica的locations在NN的内存中。只有当文件的所有的block都是complete的,该文件才能被close。

2) under_construction: 文件被create或者append时,正在被写入的block就处于under_construction状态。该状态的length和gs都不是finalized的,但是处在该状态的block对于read来说是visible的(具体多少byte是visible的,是通过client向DN询问得知的,这个在DFSInputStream的构造函数中会发起RPC调用获得,其实是某个DN所ACK的大小,该block其他replica所received的byte都大于任何DN ACK的大小,所以这个长度在任何replica上都是能够达到的)。

3) under_recovery:如果一个file的last block处于under_construction状态的时候,client异常退出,lease超过softLimit过期,那么该block就需要走下面要说的Lease recovery和Block recovery流程释放lease关闭file。那么正在走Lease recovery和Block recovery流程的block就处于under_recovery状态。

4) committed: client端在写文件的时候,每次请求新的block(addBlock RPC请求)或者close文件时,都会顺带把previous block进行commit操作(previous block从under_construction状态转化成committed状态)。这个时候Client已经把所有的该block的byte都发送给了DN组成的pipeline,已经收到ACK请求。但是NN还没有收到任何一个DN说有finalized replica。

DN中replica有下面5种状态:

1) Finalized(类FinalizedReplica表示)

2) RBW(类ReplicaBeingWritten表示,继承自ReplicaInPipeline):刚刚被create或者append的replica,处在write的pipeline中,正在被写入。但是byte还是visible to read的。

3) RUR(类ReplicaUnderRecovery表示):Lease过期之后发生Lease和Block recovery时replica所处的状态。

4) RWR(类ReplicaWaitingToBeRecovered表示):如果一个DN挂掉并且重启之后,所有RBW的replica将会转换为RWR。RWR的replica不会出现在pipeline中,结果就是等着Lease recovery恢复。

5) Temporary(类ReplicaInPipeline表示):DN之间传输replica(例如cluster rebalance)时,正在传输的就是处在Temporary。和RBW不同的是,它对read不是visible的,DN如果重启直接删除处于Temporary状态的replica。

NN中block的blockId,numBytes和GS会持久化到硬盘,但是block状态不会持久化到磁盘;然而DN中replica的状态会持久化到磁盘。所以NN如果发生restart,那么只有最后一个block会被加载成under construction,其他的都是complete;但是DN重启会加载已经持久化到磁盘的replica的状态。

有关block和replica的状态转换过程可以参考https://issues.apache.org/jira/secure/attachment/12445209/appendDesign3.pdf的9.1和9.2,那里讲的很详细。

2,write/append代码流程

对于Append一个文件,这个文件可能处于的状态就有很多种可能了:

1) 上次关闭的时候是正常关闭,那么就是调用了DFSOutputStream.close()->FSNamesystem.completeFile()->commitOrCompleteLastBlock()并且finalizeINodeFileUnderConstruction(),那么NN中file的状态就是INode而不是INodeUnderConstruction,同时last block也一定被commit或者complete。如果是这样的文件,我们append的时候就省心了。

2) 上次关闭的时候是非正常关闭(例如client异常退出等),那么就没有调用close及一系列的后续操作。那么NN中File元数据就处于INodeUnderConstruction状态,last block也没有被commit,而且绑在这个file身上的锁(Lease)也没有被释放。

注解:HDFS中的Lease相当于写锁,HDFS只给write加锁,也就是在client发送create()或者append()请求时,NN给这个file加锁,就是lease。然后client负责定期renew lease,而在NN端Lease monitor线程检测lease是否过期。而Lease expire有两个过期时间:softLimit(60s)和hardLimit(1hour)。NN的Lease monitor只会删除超过hardLimit的Lease,而超过softLimit的Lease虽然也已经过期,但是不删除,是通过下次append或者显式调用recoverLease RPC的时候检查是否超过softLimit来处理的。

在append(或者显式调用recoverLease)的时候,上次正常关闭的file,对应的lease一定不存在了;上次未正常关闭的file,对应的lease如果超过了softLimit,那么就要进行Lease recovery操作。

未正常关闭的file,NN端Lease超过softLimit而过期,那么可能再次打开这个file的client是原来的client,也可能是新的client。这个file上次未正常关闭,last block对应的三个replica也可能处在不同的状态,需要先Block recovery多个replica的信息达成一致状态才能进行append。说白了就是在append一个file的时候,如果检查出现了lease超过softLimit过期,那么就需要先给上次异常操作擦屁股,使其达到正常close状态,这个过程就是Lease recovery和Block recovery.

先回忆下HDFS的write流程所涉及到的RPC。Client先create一个文件,然后addBlock分配块及其存放的DN,建立pipeline,然后write数据。 HDFS的append操作类似:client先向NN发送append RPC,然后是addBlock,然后建立pipeline,然后write。

Client调用DistributedFilesystem.append()接口,然后向NN发送append RPC。

Append在NN的处理逻辑会走到FSNamesystem.startFileInternal(),跟create()走到一块去了,但是在内部处理逻辑上就有分支了。

对所有的append请求都执行这句:

recoverLeaseInternal(myFile,src,holder,clientMachine,false);

recoverLeaseInternal()这个函数是用来Lease recovery的,这个函数内部逻辑只处理那些处于under construction状态的file。因为如果file已经construction完毕(处于INode状态),那么上次关闭一定是走了准确的关闭流程(上述流程1),这样的不需要Lease recovery。

3,Lease recovery:

用一句最简单的话形容Lease recovery就是:上次没有正常关闭一个write的file,没有正常释放lease,last block的多个replica可能处于不同的状态(大小和generationStamp),现在需要由NN和DN配合来完成正常关闭file的流程,Lease recovery的最终结果和上次正常关闭是一样的。

private void recoverLeaseInternal(INode fileInode,
      String src, String holder, String clientMachine,boolean force)
      throwsIOException

这个函数执行recover lease操作:首先获取对应file的INodeFileUnderConstruction(此时该file一定处于under construction状态 );然后检查该file对应的lease是否一致,是否该Lease原来的holder又继续renew lease了;然后就看如果lease超过了softLimit就调用internalReleaseLease()函数进行下一步操作。

boolean internalReleaseLease(Lease lease, String src,
      String recoveryLeaseHolder)throws AlreadyBeingCreatedException,
      IOException, UnresolvedLinkException {
    LOG.info("Recovering lease="+ lease + ", src="+ src);
    assert!isInSafeMode();
    asserthasWriteLock();
    INodeFile iFile = dir.getFileINode(src);
    if(iFile == null) {
      finalString message = "DIR* NameSystem.internalReleaseLease: "
        +"attempt to release a create lock on "
        + src +" file does not exist.";
      NameNode.stateChangeLog.warn(message);
      thrownew IOException(message);
    }
    if(!iFile.isUnderConstruction()) {
      finalString message = "DIR* NameSystem.internalReleaseLease: "
        +"attempt to release a create lock on "
        + src +" but file is already closed.";
      NameNode.stateChangeLog.warn(message);
      thrownew IOException(message);
    }
 
    INodeFileUnderConstruction pendingFile = (INodeFileUnderConstruction) iFile;
    intnrBlocks = pendingFile.numBlocks();
    BlockInfo[] blocks = pendingFile.getBlocks();
 
    intnrCompleteBlocks;
    BlockInfo curBlock =null;
    //首先检查NN保存的该file的block信息,看是否有block的状态不是complete
    for(nrCompleteBlocks =0; nrCompleteBlocks < nrBlocks; nrCompleteBlocks++) {
      curBlock = blocks[nrCompleteBlocks];
      if(!curBlock.isComplete())
        break;
      assertblockManager.checkMinReplication(curBlock) :
              "A COMPLETE block is not minimally replicated in "+ src;
    }
 
    // If there are no incomplete blocks associated with this file,
    // then reap lease immediately and close the file.
    if(nrCompleteBlocks == nrBlocks) {
      //所有block都是complete的:释放lease,file由INodeUnderConstruction变成INode,然后close file
      finalizeINodeFileUnderConstruction(src, pendingFile);
      NameNode.stateChangeLog.warn("BLOCK*"
        +" internalReleaseLease: All existing blocks are COMPLETE,"
        +" lease removed, file closed.");
      returntrue;  // closed!
    }
 
    // Only the last and the penultimate blocks may be in non COMPLETE state.
    // If the penultimate block is not COMPLETE, then it must be COMMITTED.
    // 执行到这说明有block不是complete的,所以得先修复block,再finalize & close file。
    if(nrCompleteBlocks < nrBlocks -2 ||
       nrCompleteBlocks == nrBlocks -2 &&
         curBlock !=null &&
         curBlock.getBlockUCState() != BlockUCState.COMMITTED) {
      finalString message = "DIR* NameSystem.internalReleaseLease: "
        +"attempt to release a create lock on "
        + src +" but file is already closed.";
      NameNode.stateChangeLog.warn(message);
      thrownew IOException(message);
    }
 
    // The last block is not COMPLETE, and
    // that the penultimate block if exists is either COMPLETE or COMMITTED
    finalBlockInfo lastBlock = pendingFile.getLastBlock();
    BlockUCState lastBlockState = lastBlock.getBlockUCState();
    BlockInfo penultimateBlock = pendingFile.getPenultimateBlock();
    booleanpenultimateBlockMinReplication;
    BlockUCState penultimateBlockState;
    if(penultimateBlock == null) {
      penultimateBlockState = BlockUCState.COMPLETE;
      // If penultimate block doesn't exist then its minReplication is met
      penultimateBlockMinReplication =true;
    }else {
      penultimateBlockState = BlockUCState.COMMITTED;
      penultimateBlockMinReplication =
        blockManager.checkMinReplication(penultimateBlock);
    }
    assertpenultimateBlockState == BlockUCState.COMPLETE ||
           penultimateBlockState == BlockUCState.COMMITTED :
           "Unexpected state of penultimate block in "+ src;
 
    switch(lastBlockState) {
    caseCOMPLETE:
      assertfalse : "Already checked that the last block is incomplete";
      break;
    caseCOMMITTED:
      // Close file if committed blocks are minimally replicated
      if(penultimateBlockMinReplication &&
          blockManager.checkMinReplication(lastBlock)) {
        finalizeINodeFileUnderConstruction(src, pendingFile);
        NameNode.stateChangeLog.warn("BLOCK*"
          +" internalReleaseLease: Committed blocks are minimally replicated,"
          +" lease removed, file closed.");
        returntrue;  // closed!
      }
      // Cannot close file right now, since some blocks
      // are not yet minimally replicated.
      // This may potentially cause infinite loop in lease recovery
      // if there are no valid replicas on data-nodes.
      String message ="DIR* NameSystem.internalReleaseLease: " +
          "Failed to release lease for file "+ src +
          ". Committed blocks are waiting to be minimally replicated."+
          " Try again later.";
      NameNode.stateChangeLog.warn(message);
      thrownew AlreadyBeingCreatedException(message);
    caseUNDER_CONSTRUCTION:
    caseUNDER_RECOVERY:
      finalBlockInfoUnderConstruction uc = (BlockInfoUnderConstruction)lastBlock;
      // setup the last block locations from the blockManager if not known
      if(uc.getNumExpectedLocations() == 0) {
        uc.setExpectedLocations(blockManager.getNodes(lastBlock));
      }
      // start recovery of the last block for this file
      //为这个Block生成新的GS,这个GS是在recovery过程中非常重要的变量。
      longblockRecoveryId = nextGenerationStamp();
      //重新分配lease的持有者。
      //如果是client explicit调用recoverLease RPC,那么新的lease持有者为    NAMENODE_LEASE_HOLDER,由NN作为代理持有该Lease。
      //如果是client通过调用append间接调用lease recovery,那么新的lease持有者为调用请求的client。
      lease = reassignLease(lease, src, recoveryLeaseHolder, pendingFile);
      //初始化Block recovery,首先从拥有replica的DN中选择一个primary DN作为代理发起这个过程。(具体过程在下面详细描述)
      uc.initializeBlockRecovery(blockRecoveryId);
      leaseManager.renewLease(lease);
      // Cannot close file right now, since the last block requires recovery.
      // This may potentially cause infinite loop in lease recovery
      // if there are no valid replicas on data-nodes.
      NameNode.stateChangeLog.warn(
                "DIR* NameSystem.internalReleaseLease: "+
                "File "+ src + " has not been closed."+
               " Lease recovery is in progress. "+
                "RecoveryId = "+ blockRecoveryId + " for block "+ lastBlock);
      break;
    }
    returnfalse;
  }

4,Block recovery:

这里要用到NN和DN之间的heartbeat机制。DN每隔3s向NN发送心跳包,NN收到心跳包,除了更新该DN信息,刷新lastUpdate外,还要给DN发送一些任务:lease recovery; block replication; block invalidation; update balancer bandwith。这些功能在DatanodeManager.handleHeartbeat()这个函数中完成。

以Lease recovery为例,在每个DatanodeDescriptor中有如下数据结构存放需要recover的block:

private BlockQueue<BlockInfoUnderConstruction> recoverBlocks =
                                newBlockQueue<BlockInfoUnderConstruction>();

NN端初始化block recovery的时候选定primary DN,就会把这个Block加入primary DN对应的这个queue里面。然后在NN处理来自primary DN的heartbeat RPC请求时,检查该DN对应的这个queue里面是不是有需要recover的block,然后组成recover block命令发送给对应的DN。

这个命令发送到primary DN之后怎么处理的呢?DN有两个组件负责处理RPC请求:BPServiceActor负责处理与NN的 RPC对话;而client与DN,DN与其他DN之间的RPC对话在DataNode主线程内部处理的。

DN在BPServiceActor.run()方法内部循环执行:connectToNNAndHandshake()和offerService()向NN发送心跳,并接收来自NN的response。然后看NN发送给DN的response里面有啥内容?这里我们主要讨论Block recovery命令。DN调用DataNode.recoverBlocks(),这个函数启动一个单独的线程去做Block recovery,这个线程执行DataNode.recoverBlock()函数。

(下面这个函数只会在primary DN上执行)

private void recoverBlock(RecoveringBlock rBlock) throws IOException {
    ExtendedBlock block = rBlock.getBlock();
    String blookPoolId = block.getBlockPoolId();
    DatanodeID[] datanodeids = rBlock.getLocations();
    List<BlockRecord> syncList =new ArrayList<BlockRecord>(datanodeids.length);
    interrorCount = 0;
 
    //遍历该Block所有的replica所在的DN
    for(DatanodeID id : datanodeids) {
      try{
        BPOfferService bpos = blockPoolManager.get(blookPoolId);
        DatanodeRegistration bpReg = bpos.bpRegistration;
        InterDatanodeProtocol datanode = bpReg.equals(id)?
            this: DataNode.createInterDataNodeProtocolProxy(id, getConf(),
                dnConf.socketTimeout, dnConf.connectToDnViaHostname);
        //分别向包含replica的DN发送initReplicaRecovery RPC命令,让包含replica的每台DN都去执行自己的initReplicaRecovery过程。这就跟DN底层的数据存储相关了,所以会调用到FsDatasetImpl.initReplicaRecovery()函数。这个函数的执行过程在下面。
        ReplicaRecoveryInfo info = callInitReplicaRecovery(datanode, rBlock);
        //下面就是判断来自其他DN报告的replica信息是否有效,如果一个replica的GS比这个block的要老,那显然这个replica不是有效的。
        if(info != null &&
            info.getGenerationStamp() >= block.getGenerationStamp() &&
            info.getNumBytes() >0) {
          //把有效的replica加入待同步的数组中。同步过程就是大家来商量一个一致的对外的长度。
          syncList.add(newBlockRecord(id, datanode, info));
        }
      }catch (RecoveryInProgressException ripE) {
        //任何DN抛出RecoveryInProgressException,primary DN将中止Recovery
        InterDatanodeProtocol.LOG.warn(
            "Recovery for replica "+ block + " on data-node "+ id
            +" is already in progress. Recovery id = "
            + rBlock.getNewGenerationStamp() +" is aborted.", ripE);
        return;
      }catch (IOException e) {
        ++errorCount;
        InterDatanodeProtocol.LOG.warn(
            "Failed to obtain replica info for block (="+ block
            +") from datanode (=" + id + ")", e);
      }
    }
 
    if(errorCount == datanodeids.length) {
      //所有的DN都抛出异常,当然也得终止了。
      thrownew IOException("All datanodes failed: block="+ block
          +", datanodeids=" + Arrays.asList(datanodeids));
    }
    //商量把这些replica弄到一致的状态,长度等。
    syncBlock(rBlock, syncList);
  }

上面说到,primary DN发送initReplicaRecovery RPC命令给包含replica的其他DN,然后其他DN上就开始执行Replica Recovery并把结果作为RPC response返回给primary DN。包含replica的每台DN都会执行这个函数:

static ReplicaRecoveryInfo initReplicaRecovery(String bpid,
      ReplicaMap map, Block block, long recoveryId) throws IOException

1) 停止写:如果一个replica处于写状态(RBW),并且有对应的写线程,那么interrupted这个写线程并且等待结束。然后检查磁盘上的block文件(bytesOnDisk)和BR是否一致,检查crc文件是否有效。关闭block文件和crc文件。这样client写和block recovery就不能并发执行了。

2) 如果该replica已经处于RUR状态,就是说该replica可能已经开始了recovery。那么就要检查开始的recovery和这次recovery是否是同一次。判断的标准就是那个NN发送给primary DN后扩散给每个具备replica的DN的recoveryId,也就是该block新的GS。如果这次的Id比该replica中的recoveryId要老,抛出RecoveryInProgressException异常。否则将处于RUR状态的replica的RecoveryID记为新的Id。

3) 如果没有正在运行的Recovery,那么将replica改为RUR,设置它的RecoveryId为新的Id。任何从primary DN到其他DN的交互都用这个RecoveryId标识。对于并发的blockRecovery,新的Recovery永远kill老的Recovery,两个Recovery绝不能交叉执行。

如果没有发生异常的情况下,每台DN执行上述流程后给primary DN发送response(用InitReplicaRecoveryResponseProto标识)。

Primary DN收到来自其他DN发送过来的response之后怎么处理呢,又回到了DataNode.recoverBlock()函数里。(请看上面代码里的注释)

下面看看DataNode.syncBlock()这个函数怎么把状态和大小各异的replica同步成一致状态的。

道理其实很简单,就是先找到所有replica中具有的最好的状态。什么是更好的状态呢?排名从更好到更坏依次是:Finalized, RBW, RWR, RUR, Temporary。其实也就是说明了replica的持久化程度。如果所有replica中最好的状态是Finalized,那么就以这个Finalized的为准,其他和这个replica不一致的replica都被exclude在外;如果最好的状态是RBW或者RWR,那么就选择所有replica中最短的那个作为所有replica的recovery之后的长度。

void syncBlock(RecoveringBlock rBlock,
                         List<BlockRecord> syncList)throws IOException {
    ExtendedBlock block = rBlock.getBlock();
    finalString bpid = block.getBlockPoolId();
    DatanodeProtocolClientSideTranslatorPB nn =
      getActiveNamenodeForBP(block.getBlockPoolId());
    if(nn == null) {
      thrownew IOException(
          "Unable to synchronize block "+ rBlock + ", since this DN "
          +" has not acknowledged any NN as active.");
    }
 
    longrecoveryId = rBlock.getNewGenerationStamp();
    if(LOG.isDebugEnabled()) {
      LOG.debug("block="+ block + ", (length="+ block.getNumBytes()
          +"), syncList=" + syncList);
    }
 
    // syncList.isEmpty() means that all data-nodes do not have the block
    // or their replicas have 0 length.
    // The block can be deleted.
    if(syncList.isEmpty()) {
      nn.commitBlockSynchronization(block, recoveryId,0,
          true,true, DatanodeID.EMPTY_ARRAY,null);
      return;
    }
 
    // Calculate the best available replica state.
    ReplicaState bestState = ReplicaState.RWR;
    longfinalizedLength = -1;
    for(BlockRecord r : syncList) {
      assertr.rInfo.getNumBytes() > 0: "zero length replica";
      ReplicaState rState = r.rInfo.getOriginalReplicaState();
      if(rState.getValue() < bestState.getValue())
        bestState = rState;
      if(rState == ReplicaState.FINALIZED) {
        if(finalizedLength >0 && finalizedLength != r.rInfo.getNumBytes())
          thrownew IOException("Inconsistent size of finalized replicas. "+
              "Replica "+ r.rInfo + " expected size: "+ finalizedLength);
        finalizedLength = r.rInfo.getNumBytes();
      }
    }
 
    // Calculate list of nodes that will participate in the recovery
    // and the new block size
    List<BlockRecord> participatingList =new ArrayList<BlockRecord>();
    finalExtendedBlock newBlock = newExtendedBlock(bpid, block.getBlockId(),
        -1, recoveryId);
    switch(bestState) {
    caseFINALIZED:
      assertfinalizedLength > 0: "finalizedLength is not positive";
      for(BlockRecord r : syncList) {
        ReplicaState rState = r.rInfo.getOriginalReplicaState();
        if(rState == ReplicaState.FINALIZED ||
           rState == ReplicaState.RBW &&
                      r.rInfo.getNumBytes() == finalizedLength)
          participatingList.add(r);
      }
      newBlock.setNumBytes(finalizedLength);
      break;
    caseRBW:
    caseRWR:
      longminLength = Long.MAX_VALUE;
      for(BlockRecord r : syncList) {
        ReplicaState rState = r.rInfo.getOriginalReplicaState();
        if(rState == bestState) {
          minLength = Math.min(minLength, r.rInfo.getNumBytes());
          participatingList.add(r);
        }
      }
      newBlock.setNumBytes(minLength);
      break;
    caseRUR:
    caseTEMPORARY:
      assertfalse : "bad replica state: "+ bestState;
    }
 
    List<DatanodeID> failedList =new ArrayList<DatanodeID>();
    finalList<BlockRecord> successList = newArrayList<BlockRecord>();
    for(BlockRecord r : participatingList) {
      try{
        //通过InterDatanodeProtocol RPC向其他DN发送RPC更新replica的长度和GS。这个RPC是在block recovery中专用的。各个DN分别update长度和GS,然后把replica变成Finalized。
        r.updateReplicaUnderRecovery(bpid, recoveryId, newBlock.getNumBytes());
        successList.add(r);
      }catch (IOException e) {
        InterDatanodeProtocol.LOG.warn("Failed to updateBlock (newblock="
            + newBlock +", datanode=" + r.id +")", e);
        failedList.add(r.id);
      }
    }
 
    // If any of the data-nodes failed, the recovery fails, because
    // we never know the actual state of the replica on failed data-nodes.
    // The recovery should be started over.
    if(!failedList.isEmpty()) {
      StringBuilder b =new StringBuilder();
      for(DatanodeID id : failedList) {
        b.append("\n  "+ id);
      }
      thrownew IOException("Cannot recover "+ block + ", the following "
          + failedList.size() +" data-nodes failed {" + b + "\n}");
    }
 
    // Notify the name-node about successfully recovered replicas.
    finalDatanodeID[] datanodes = newDatanodeID[successList.size()];
    finalString[] storages = newString[datanodes.length];
    for(inti = 0; i < datanodes.length; i++) {
      finalBlockRecord r = successList.get(i);
      datanodes[i] = r.id;
      storages[i] = r.storageID;
    }
    //向NN发送RPC表明block recovery顺利完成,NN完成元数据持久化工作,commitOrCompleteBlock,然后close file。
    nn.commitBlockSynchronization(block,
        newBlock.getGenerationStamp(), newBlock.getNumBytes(),true, false,
        datanodes, storages);
  }

执行完Lease recovery和Block recovery之后,一个unclose的file被close掉了,这个文件恢复成正常close的状态了。那么这个时候执行append操作就和一个正常close的file没有区别了。然后就是通过addBlock获取replica所在DN,建立pipeline,向DN write数据,这个过程可以参考上一篇博客(HDFS write流程与代码分析)。

从这个流程中再一次深刻体会到一个系统级软件,60%以上的代码是在解决异常情况。一个unclose给我们后续的处理带来这么大的代码量。。。

参考文献:

https://issues.apache.org/jira/secure/attachment/12445209/appendDesign3.pdf

http://blog.youkuaiyun.com/chenpingbupt/article/details/7972589

Hadoop-1.0.0 HDFS append操作深入分析 社区版Hadoop 1.0.0中对HDFS append操作进行了重新设计和实现,解决了之前append操作实现的很多缺陷。下图是对HDFS append操作详细的一般分析,该操作涉及到client,namenode和datanode的很多交付,可见其复杂性。 从Client角度来看,append一个文件首先需要调用DistributedFileSystem的append 阅读详情

相关推荐

Hadoop IO底层原理与HDFS写入故障排查指南

Hadoop IO是HDFS文件系统中输入输出行为的核心机制,涉及序列化、压缩编码、块对齐与校验写入等协同流程。其原理根植于客户端API、RPC协议栈与DataNode落盘三层穿透路径,技术价值在于保障大规模数据写入的可靠性与效率。典型应用场景包括伪分布式环境搭建、MapReduce任务调优及HDFS数据损坏诊断。实践中常见问题如'Filesystem closed'异常、Gzip压缩失效、MAP卡死等,本质源于对FSDataOutputStream生命周期、CompressionCodec加载时机及dfs

weixin_29054399的博客 65

关于 HDFS Append

作者:用户1984346023(1) 背景早期的HDFS版本不支持HDFS append功能. 当一个文件被关闭时, 这个文件就不能再被修改了. 如果要修改的话, 就只能重读此文件并将数据写入一个新的文件. 虽然这种方式很简单, 但和map/reduce的需求却是非常match的. map/reduce jobs会向HDFS写入多个结果文件, 这种方式比修改已经存在的输入文件...

weixin_34183910的博客 722

Claude Code VSCode集成开发指南:AI编程助手完整配置

Claude Code与Visual Studio Code的深度集成为开发者提供了强大的AI编程支持。本文详细介绍Claude Code VSCode扩展的安装配置、功能特性和实际应用方法。通过完整的配置流程和代码示例,帮助开发者充分利用Claude AI的智能编程能力。文章涵盖从环境搭建到高级功能应用的完整指南,包括代码自动补全、智能重构、实时代码分析等核心功能的使用技巧,以及与现有开发工作流的整合方案。

2501_93058131的博客 5991

HDFS append操作

HDFS append操作 本篇背景是需要向HDFS写入文件,但写入文件数据是按照小时为单位生成的,那么我们需要将 每小时产出数据,聚类到一个文件,这时就需要用到HDFS append操作 代码 public void append(String body, String fileName, String filePath) { FSDataOutputStream out = null; Path f = new Path(filePath); try {

weixin_43946605的博客 1469

eLabRadio软件无线电虚实结合仿真开发平台简介

在使用仿真平台时,不要关闭设备或断开设备与PC机之间的网络连接,否则,仿真平台将无法正常工作。注:采用eNodeX设备认证方式,当出现“设备不存在”的报错时,请检查计算机IP是否和硬件设备IP处于同一网段,或者是否是先连接好网线,再开启硬件设备的。①此登录方式下,需要先建立软件与硬件的通信:在登录窗口点击【网络配置】,参照下图输入设备IP,服务器地址无需设置,设置完成后点击确认,此时登录界面无需设置账号密码;,拷贝到电脑上,使用管理员权限运行setup.exe,下一步直到安装完成,桌面会生成快捷方式。

weixin_55349105的博客 6320

C#怼倍福TwinCAT3:ADS协议封装实战(附完整读写源码+避坑清单)

变量名大小写敏感:PLC里定义的是GVL.bStart,你写GVL.BStart绝对读不到;数组访问格式:PLC数组是,C#里读单个元素要写,读整个数组不用写索引;句柄要释放:用创建的句柄,一定要用using包起来,否则会占着资源;PLC必须运行:哪怕变量定义对了,PLC没Run(只是Login)也读不到数据;路由配置:如果上位机和PLC不在一个网段,要在TwinCAT3里添加路由(Router→Edit Routes)。倍福ADS通信其实不难,核心就是“配置对+变量名写对+数据类型匹配”。

这里只有干货:从 Modbus 通信到 MES 对接,从 YOLO 训练到工控机部署,带你搞定工业软件开发全流程。 952

hadoop运行时lease recovery is in progress解决办法

借鉴于https://blog.csdn.net/xutao_ccu/article/details/84729640 今天做厦门大学大数据系统的课的实验2时,出现了如题错误。按照链接的办法成功解决了。 出现问题的原因是:集群节点少于3个在运行时就会抛异常; 解决办法就是加入conf.set(“dfs.client.block.write.replace-datanode-on-failure....

Moreinterest的博客 1997

FPGA学习笔记(一)入门背景、软件及时钟约束的概念及程序下载与固化

使用正点原子的PFPGA开拓者V2学习,通过b站上正点原子的手把手教你学FPGA-基于开拓者V2学习。

贾saisai的博客 3281

hadoop hdfs追加写

public class PutMerge { /** * @param args *            void * @throws IOException */ public static void main(String[] args) throws IOException { // TODO Auto-generated method stub    Confi

chuanzhongdu1的专栏 2365

QT实现警报应用程序

QT实现警报应用程序

希望我的博客,能帮上你解决学习中工作中所遇到的问题 2044

Android 10.0 任务栏音乐播放器后台播放杀进程功能实现

在10.0的系统rom定制化开发过程中,在某些情况下在安装第三方播放器以后,播放音乐的时候,在最近任务栏recents列表中,点击全部清除,发现音乐播放器还在播放音乐,导致出现bug,完整的 解决方法,肯定是需要点击全部清除以后,音乐播放器也被杀掉进程,接下来看下这个问题怎么解决

安卓兼职framework和app工程师的博客 657

HDFS只支持文件append操作, 而依赖HDFS的HBase如何完成数据的增删改查

转:http://www.th7.cn/db/nosql/201510/135382.shtml 1. HDFS的文件append功能 早期版本的HDFS不支持任何的文件更新操作,一旦一个文件创建、写完数据、并关闭之后,这个文件就再也不能被改变了。为什么这么设计?是为了与MapReduce完美配合,MapReduce的工作模式是接受一系列输入文件,经过map和reduce处理,...

dfug3303的博客 129

RK3568移植AP6256

本文主要是记录RK3568移植正基的AP6256的WIFIBT模块,感兴趣的朋友可以一起学习!!!提示:以下是本篇文章正文内容,下面案例可供参考。

qq_24093081的博客 3718

Hadoop学习笔记之HDFS

Hadoop简介 优点 1、高可靠性:可以将数据分发到多个副本上进行存储,并且在副本损坏的时候,及时将副本的数据同步到新的副本中 2、高扩展性:横向扩展,数以千计的节点 3、高效性:基于MapReduce,可以进行并行处理数据,最后再合并计算结果 4、高容错性:能够自动将失败的任务进行重新分配 组成 1.0 MR + HDFS +Common(辅助工具) 2.0 MR + HDFS + YARN + Common(辅助工具) 区别 1.0时,计算的资源分配也是由MR来进行调度的,2.0之后,增加了YARN,

notCodeTester的博客 230

【网络安全】SSRF漏洞讲解

SSRF漏洞讲解一、初识SSRF漏洞1.定义2.产生原理3.会导致的危害4.常见产生SSRF的地方5.常见缺失函数二、SSRF漏洞利用1.函数(1) file_get_contents(2)fsockopen()(3) curl_exec()2.协议(1)file协议(2)http协议(3)dict协议(4)gopher协议三、绕过1.绕过方式(1)检查IP是否为内网IP(2)Host获取与DNS绕过(3)通过各种协议(4)利用URL解析器滥用问题四、修复修复方案五、小结 一、初识SSRF漏洞 1.定义

你在看屏幕的同时,屏幕也在注视着你 3182

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

五、Sqoop 增量导入:精通 Append 与 Lastmodified 模式

在实际业务场景中,数据是不断变化的,怎么用 Sqoop 实现“只拉新增或变化部分”而不是每次全量导入?这一篇就详细讲清楚 Sqoop 增量导入的两种模式(append 和 lastmodified),重点解释 lastmodified 模式下 merge-key 怎么用,配套实战例子和常见坑,讲完你就能搞明白增量同步该怎么配置了。

专注于 Agent 工程、AI 产品、Harness Engineering、LLM 算法等方向,OpenMathModel、Nivik 等开源项目作者 7万+

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

Hadoop-HDFS详解(学习笔记)

Hadoop-HDFS详解 1. 简介 基于流资料模式存取和处理超大档案的需求而开发。采用Master/Slave结构模型,一个HDFS丛集是由一个NameNode和许多个DataNode组成 主要特征: 处理超大档案:目前已经可以到PB级别 流式存取资料:一个资料集一旦由资料来源产生,就会被复制分发到不同的储存节点中,然后回应各种各样的资料分析工作请求1 执行于廉价商用机器丛集上:廉价性也会...

weixin_40511114的博客 481

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

Apache Pulsar HDFS2 Sink Connector 完全指南:从 Pulsar Topic 落盘 HDFS 的配置、部署与源码剖析

HDFS2 sink connector 是 Apache Pulsar 内置的 IO 连接器之一,负责将 Pulsar topic 中的消息持续拉取并写入 Hadoop HDFS 2.x 文件系统,是流式数据入湖、离线数仓对接等场景的常用落盘通道。本文以 [site2/docs/io-hdfs2-sink.md](https://link.gitcode.com/i/f11712db8b63d1

gitblog_01190的博客 527

Hadoop的hdfs-site.xml配置描述

hdfs-site.xml的配置项      name  value Description  dfs.default.chunk.view.size 32768 namenode的http访问页面中针对每个文件的内容显示大小,通常无需设置。 dfs.datanode.du.reserved 1073741824 每块磁盘所保留

nengyu的专栏 1468

Hadoop配置项整理(hdfs-site.xml)

续上篇整理一下hdfs相关的配置项      name  value Description  dfs.default.chunk.view.size 32768 ...

weixin_33713350的博客 1532

hdfs上的append测试

  hbase在写入数据之前会先写hlog,hlog目前是sequencefile格式,采用append的方式往里追加数据。之前团队的同学测试关闭hlog会一定程序上提升写hbase的稳定性。而在我之前的想象中,hlog的写入速度应该是稳定的。于是写了个append程序专门测试hdfs的append性能。   代码如下: [code="java"]  FSDataOutputStream ...

蓝色时分 409

hdfs-site.xml 配置参数详情

name value Description dfs.default.chunk.view.size 32768 NameNode 的http访问页面中针对每个文件的内容显示大小,通常无需设置。 dfs.DataNode .du.reserved ...

哈 1880

Hadoop配置项(hdfs-site.xml)

name  value Description  dfs.default.chunk.view.size 32768 namenode的http访问页面中针对每个文件的内容显示大小,通常无需设置。 dfs.datanode.du.reserved 1073741824 每块磁盘所保留的空间大小,需要设置一些,主要是给非hdfs文件使用,默认是不保留,0字节

u014078192的专栏 1902

hadoop

最后的地址:/usr/local/hadoop/tmp/dfs/data/current/BP-1572212494-172.18.0.2-1774500901217(自己的块id名字)/current/finalized/subdir0/subdir0。cd /usr/local/hadoop/tmp/dfs/data/current/BP-1572212494-172.18.0.2-1774500901217(自己的块id名字)/current/finalized/subdir0/subdir0。

wsyczhhh的博客 527

Sqoop数据迁移:MySQL到HDFS的核心原理与实战优化

数据迁移是大数据处理中的基础环节,Sqoop作为Hadoop生态系统的关键工具,专为关系型数据库与HDFS之间的高效数据传输设计。其核心原理基于MapReduce并行计算框架,通过Connector插件支持多种数据库类型,自动处理数据类型映射与分片策略。在数据仓库构建场景中,Sqoop的增量导入(append/lastmodified模式)和条件过滤功能大幅提升ETL效率。结合MySQL等OLTP系统,工程师可通过调整并行度(num-mappers)、启用压缩传输(SnappyCodec)等优化手段实现TB

weixin_30843605的博客 385
上一篇: Shmget: Invalid argument. Why i get this error?
下一篇: linux下fork和pthread混用的问题
迷途小码
博客等级 码龄19年 71粉丝 95原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值