HBase源码分析之HRegion上compact流程分析(三)

柏辰爸爸 2016-03-04

hbase 源码 request file

        在《HBase源码分析之HRegion上compact流程分析(二)》一文中,我们没有讲解真正执行合并的CompactionContext的compact()方法。现在我们来分析下它的具体实现。

        首先,CompactionContext表示合并的上下文信息,它只是一个抽象类,其compact()并没有实现,代码如下:

/**
   * Runs the compaction based on current selection. select/forceSelect must have been called.
   * @return The new file paths resulting from compaction.
   */
  public abstract List<Path> compact() throws IOException;
        那么,我们来找下它的实现类。它一共有两种实现类:DefaultCompactionContext和StripeCompaction,今天我们以DefaultCompactionContext为例来讲解。

        首先看下DefaultCompactionContext中compact()方法的实现:

    @Override
    public List<Path> compact() throws IOException {
      return compactor.compact(request);
    }
        这个compactor可以根据参数hbase.hstore.defaultengine.compactor.class配置,但是默认实现为DefaultCompactor。那么,接下来,我们看下它的实现:

  /**
   * Do a minor/major compaction on an explicit set of storefiles from a Store.
   * 在一个Store中明确的storefiles集合中执行一个minor或者major合并
   */
  public List<Path> compact(final CompactionRequest request) throws IOException {
    
	  // 从请求中获取文件详情fd,fd是FileDetails类型
	  FileDetails fd = getFileDetails(request.getFiles(), request.isAllFiles());
    
	  // 构造合并过程追踪器CompactionProgress
	  this.progress = new CompactionProgress(fd.maxKeyCount);

    // Find the smallest read point across all the Scanners.
	  // 找到scanners中的最小的可读点,实际上就是找到最小能够读取数据的点
    long smallestReadPoint = getSmallestReadPoint();

    List<StoreFileScanner> scanners;
    Collection<StoreFile> readersToClose;
    
    // 根据参数hbase.regionserver.compaction.private.readers确定是否使用私有readers
    if (this.conf.getBoolean("hbase.regionserver.compaction.private.readers", false)) {
      
      // clone all StoreFiles, so we'll do the compaction on a independent copy of StoreFiles,
      // HFileFiles, and their readers
      // 克隆所有的StoreFiles,以便我们将在StoreFiles、HFileFiles以及它们的readers等一个独立的副本上执行合并
      
      
      // 根据请求中待合并文件的数目创建一个StoreFile列表:readersToClose
      readersToClose = new ArrayList<StoreFile>(request.getFiles().size());
      
      // 将待合并文件复制一份加入readersToClose列表
      for (StoreFile f : request.getFiles()) {
        readersToClose.add(new StoreFile(f));
      }
      
      // 根据readersToClose列表,即待合并文件的副本创建文件浏览器FileScanners
      scanners = createFileScanners(readersToClose, smallestReadPoint);
    } else {
      // 创建空的列表readersToClose
      readersToClose = Collections.emptyList();
      
      // 根据实际请求中的待合并文件列表创建文件浏览器FileScanners
      scanners = createFileScanners(request.getFiles(), smallestReadPoint);
    }

    StoreFile.Writer writer = null;
    List<Path> newFiles = new ArrayList<Path>();
    boolean cleanSeqId = false;
    IOException e = null;
    try {
      InternalScanner scanner = null;
      try {
        /* Include deletes, unless we are doing a compaction of all files */
        
    	// 确定scan类型scanType:
    	// 如果compact请求是MAJOR或ALL_FILES合并,则scanType为COMPACT_DROP_DELETES;
    	// 如果compact请求是MINOR合并,则scanType为COMPACT_RETAIN_DELETES。
    	ScanType scanType =
            request.isAllFiles() ? ScanType.COMPACT_DROP_DELETES : ScanType.COMPACT_RETAIN_DELETES;
        
    	// 如果有协处理器,调用协处理器的preCreateCoprocScanner()方法
    	scanner = preCreateCoprocScanner(request, scanType, fd.earliestPutTs, scanners);
        if (scanner == null) {
          // 如果协处理器中未创建scanner,调用createScanner()方法创建一个
          scanner = createScanner(store, scanners, scanType, smallestReadPoint, fd.earliestPutTs);
        }
        
        // 如果有协处理器,调用协处理器的preCompact()方法
        scanner = postCreateCoprocScanner(request, scanType, scanner);
        if (scanner == null) {
          // NULL scanner returned from coprocessor hooks means skip normal processing.
          return newFiles;
        }
        // Create the writer even if no kv(Empty store file is also ok),
        // because we need record the max seq id for the store file, see HBASE-6059
        
        // 确定最小读取点smallestReadPoint
        if(fd.minSeqIdToKeep > 0) {
          smallestReadPoint = Math.min(fd.minSeqIdToKeep, smallestReadPoint);
          cleanSeqId = true;
        }

        // When all MVCC readpoints are 0, don't write them.
        // See HBASE-8166, HBASE-12600, and HBASE-13389.
        // 调用HStore的createWriterInTmp()方法,获取writer
        writer = store.createWriterInTmp(fd.maxKeyCount, this.compactionCompression, true,
          fd.maxMVCCReadpoint > 0, fd.maxTagsLength > 0);
        
        // 调用performCompaction()方法,执行合并
        boolean finished = performCompaction(scanner, writer, smallestReadPoint, cleanSeqId);
        
        // 如果没有完成合并
        if (!finished) {
          // 关闭writer
          writer.close();
          
          // 删除writer中的临时文件
          store.getFileSystem().delete(writer.getPath(), false);
          writer = null;
          
          // 抛出异常
          throw new InterruptedIOException( "Aborting compaction of store " + store +
              " in region " + store.getRegionInfo().getRegionNameAsString() +
              " because it was interrupted.");
         }
       } finally {
    	   
    	 // 关闭scanner
         if (scanner != null) {
           scanner.close();
         }
      }
    } catch (IOException ioe) {
      e = ioe;
      // Throw the exception
      throw ioe;
    }
    finally {
      try {
        if (writer != null) {
          if (e != null) {
        	// 无异常的话,关闭writer
            writer.close();
          } else {
        	  
        	// 存在异常的话,写入元数据,关闭writer,并将写入地址加入newFiles
            writer.appendMetadata(fd.maxSeqId, request.isAllFiles());
            writer.close();
            newFiles.add(writer.getPath());
          }
        }
      } finally {
    	  
    	// 依次关闭readersToClose中StoreFile的Reader
        for (StoreFile f : readersToClose) {
          try {
            f.closeReader(true);
          } catch (IOException ioe) {
            LOG.warn("Exception closing " + f, ioe);
          }
        }
      }
    }
    
    // 返回newFiles
    return newFiles;
  }
        总结下DefaultCompactor的compact()方法的处理流程,大体有如下几点:

        1、通过父类Compactor的getFileDetails()方法从请求中获取文件详情fd,fd是FileDetails类型,这个FileDetails类型的文件详情中主要包含如下信息:

              (1)合并之后总的keyvalue数目:maxKeyCount;

              (2)如果是major合并,最早的Put时间戳earliestPutTs;

              (3)合并时文件中最大的序列号maxSeqId;

              (4)相关文件中最新的MemStore数据读取点maxMVCCReadpoint;

              (5)最大的tag长度maxTagsLength;

              (6)在major合并期间需要保持的最小序列号minSeqIdToKeep。

        2、构造合并过程追踪器CompactionProgress,用于追踪合并过程;

        3、通过父类Compactor的getSmallestReadPoint()方法找到所有scanners中的最小的可读点,实际上就是找到最小能够读取数据的点smallestReadPoint;

        4、根据参数hbase.regionserver.compaction.private.readers确定是否使用私有readers,默认为false不使用:

              4.1、如果需要使用,即参数配置为true的话,克隆所有的StoreFiles,以便我们将在StoreFiles、HFileFiles以及它们的readers等一个独立的副本上执行合并;

                       4.1.1、根据请求中待合并文件的数目创建一个StoreFile列表:readersToClose;

                       4.1.2、将请求中待合并文件逐一复制加入readersToClose列表;

                       4.1.3、根据readersToClose列表,即待合并文件的副本创建文件浏览器FileScanners;

              4.2、如果不需要使用,即参数配置为false的话,使用请求中实际发送的文件列表;

                       4.2.1、创建空的列表readersToClose;

                       4.2.2、根据实际请求中的待合并文件列表创建文件浏览器FileScanners;

         5、根据compact请求类型确定scan类型scanType:

               如果compact请求是MAJOR或ALL_FILES合并,则scanType为COMPACT_DROP_DELETES;

               如果compact请求是MINOR合并,则scanType为COMPACT_RETAIN_DELETES。

         6、如果有协处理器,调用协处理器的preCreateCoprocScanner()方法,获得scanner,如果协处理器中未创建scanner,调用createScanner()方法创建一个;

         7、如果有协处理器,调用协处理器的preCompact()方法;

         8、根据之前获取的smallestReadPoint和文件详情fd中的minSeqIdToKeep确定最小读取点smallestReadPoint,并置状态位cleanSeqId;

         9、调用HStore的createWriterInTmp()方法,获取writer;

        10、调用父类Compactor的performCompaction()方法,利用scanner、writer、smallestReadPoint、cleanSeqId执行合并:

                实际上就是利用scanner读取旧文件数据,利用writer写入新文件数据。

        11、如果没有完成合并:关闭writer、删除writer中的临时文件并抛出异常;

        12、关闭scanner;

        13、无异常的话,关闭writer;存在异常的话,写入元数据,关闭writer,并将写入地址加入newFiles;

        14、依次关闭readersToClose中StoreFile的Reader;

        15、返回newFiles。

        大体流程就是如此。针对其中的某些细节,我们逐一进行分析。

        首先说下这个文件详情FileDetails,它是通过getFileDetails()方法获取的。文件详情FileDetails类定义如下:

  /** The sole reason this class exists is that java has no ref/out/pointer parameters. */
  protected static class FileDetails {
    /** Maximum key count after compaction (for blooms) */
	// 合并之后总的keyvalue数目
    public long maxKeyCount = 0;
    /** Earliest put timestamp if major compaction */
    // 如果是major合并,最早的Put时间戳earliestPutTs
    public long earliestPutTs = HConstants.LATEST_TIMESTAMP;
    /** The last key in the files we're compacting. */
    // 合并时文件中最大的序列号
    public long maxSeqId = 0;
    /** Latest memstore read point found in any of the involved files */
    // 相关文件中最新的MemStore数据读取点maxMVCCReadpoint
    public long maxMVCCReadpoint = 0;
    /** Max tags length**/
    // 最大的tag长度maxTagsLength
    public int maxTagsLength = 0;
    /** Min SeqId to keep during a major compaction **/
    // 在major合并期间需要保持的最小序列号minSeqIdToKeep
    public long minSeqIdToKeep = 0;
  }

        而它的获取方法如下:

/**
   * Extracts some details about the files to compact that are commonly needed by compactors.
   * 提取文件合并的一些细节
   * @param filesToCompact Files.
   * @param allFiles Whether all files are included for compaction
   * @return The result.
   */
  protected FileDetails getFileDetails(
      Collection<StoreFile> filesToCompact, boolean allFiles) throws IOException {
    
	// 构造一个FileDetails实例fd
	FileDetails fd = new FileDetails();
	
	// 计算保持MVCC的最新HFile时间戳:当前时间-24小时 * keepSeqIdPeriod
	// keepSeqIdPeriod为一个参数,即被指定的在major合并期间MVCC值可以保持多少天
    long oldestHFileTimeStampToKeepMVCC = System.currentTimeMillis() - 
      (1000L * 60 * 60 * 24 * this.keepSeqIdPeriod);  

    // 遍历需要合并的文件
    for (StoreFile file : filesToCompact) {
    	
      // 如果allFiles为true,即所有文件都需要检测,且文件的修改时间小于上述保持MVCC的最新HFile时间戳
      if(allFiles && (file.getModificationTimeStamp() < oldestHFileTimeStampToKeepMVCC)) {
        // when isAllFiles is true, all files are compacted so we can calculate the smallest 
        // MVCC value to keep
        
    	// 如果文件细节中需要保持的最小序列号小于文件MemStore的时间戳
        if(fd.minSeqIdToKeep < file.getMaxMemstoreTS()) {
          // 将文件MemStore的时间戳赋值给fd的需要保持的最小序列号minSeqIdToKeep
          fd.minSeqIdToKeep = file.getMaxMemstoreTS();
        }
      }
      
      // 获取文件的最大序列号ID
      long seqNum = file.getMaxSequenceId();
      
      // 赋值给文件细节fd中的maxSeqId,记录待合并文件的最大序列号ID
      fd.maxSeqId = Math.max(fd.maxSeqId, seqNum);
      
      // 获取Reader
      StoreFile.Reader r = file.getReader();
      if (r == null) {
        LOG.warn("Null reader for " + file.getPath());
        continue;
      }
      // NOTE: use getEntries when compacting instead of getFilterEntries, otherwise under-sized
      // blooms can cause progress to be miscalculated or if the user switches bloom
      // type (e.g. from ROW to ROWCOL)
      
      // 获取文件中的keyvalue数量,实际上就是列的数量,
      // HBase底层对每个列都是按照keyvalue格式存储的,key包含rowkey+column family+quality+tm等,value即列值
      long keyCount = r.getEntries();
      
      // 累加keyvalue数目maxKeyCount
      fd.maxKeyCount += keyCount;
      
      // calculate the latest MVCC readpoint in any of the involved store files
      // 计算所有相关存储文件的最新mvcc读取点maxMVCCReadpoint
      
      // 先加载文件信息fileInfo
      Map<byte[], byte[]> fileInfo = r.loadFileInfo();
      
      byte tmp[] = null;
      // Get and set the real MVCCReadpoint for bulk loaded files, which is the
      // SeqId number.
      
      // 如果是Bulk导入的,maxMVCCReadpoint为fd的maxMVCCReadpoint和文件SequenceID中较大者
      if (r.isBulkLoaded()) {
        fd.maxMVCCReadpoint = Math.max(fd.maxMVCCReadpoint, r.getSequenceID());
      }
      else {
    	// 否则,读取文件信息中最大的memstore时间戳MAX_MEMSTORE_TS_KEY
        tmp = fileInfo.get(HFileWriterV2.MAX_MEMSTORE_TS_KEY);
        if (tmp != null) {
          // maxMVCCReadpoint就是fd的maxMVCCReadpoint和文件信息中最大的memstore时间戳MAX_MEMSTORE_TS_KEY中较大者
          fd.maxMVCCReadpoint = Math.max(fd.maxMVCCReadpoint, Bytes.toLong(tmp));
        }
      }
      
      // 更新最大标签长度maxTagsLength
      tmp = fileInfo.get(FileInfo.MAX_TAGS_LEN);
      if (tmp != null) {
        fd.maxTagsLength = Math.max(fd.maxTagsLength, Bytes.toInt(tmp));
      }
      // If required, calculate the earliest put timestamp of all involved storefiles.
      // This is used to remove family delete marker during compaction.
      long earliestPutTs = 0;
      
      // 获取最早的Put时间戳earliestPutTs
      if (allFiles) {
        tmp = fileInfo.get(StoreFile.EARLIEST_PUT_TS);
        if (tmp == null) {
          // There's a file with no information, must be an old one
          // assume we have very old puts
          fd.earliestPutTs = earliestPutTs = HConstants.OLDEST_TIMESTAMP;
        } else {
          earliestPutTs = Bytes.toLong(tmp);
          fd.earliestPutTs = Math.min(fd.earliestPutTs, earliestPutTs);
        }
      }
      if (LOG.isDebugEnabled()) {
        LOG.debug("Compacting " + file +
          ", keycount=" + keyCount +
          ", bloomtype=" + r.getBloomFilterType().toString() +
          ", size=" + StringUtils.humanReadableInt(r.length()) +
          ", encoding=" + r.getHFileReader().getDataBlockEncoding() +
          ", seqNum=" + seqNum +
          (allFiles ? ", earliestPutTs=" + earliestPutTs: ""));
      }
    }
    
    // 返回合并细节fd
    return fd;
  }
        接下来再看下找到scanners中的最小的可读点,实际上就是找到最小能够读取数据的点,它是通过父类Compactor的getSmallestReadPoint()方法实现的,代码如下:

protected long getSmallestReadPoint() {
	// 获取的是HStore中的SmallestReadPoint
    return store.getSmallestReadPoint();
  }
        可以看出,父类的该方法实际上还是通过HStore中的getSmallestReadPoint()方法实现的,如下:

@Override
  public long getSmallestReadPoint() {
	// 获取的是Region中的SmallestReadPoint,因为HBase是行级事务,SmallestReadPoint应该也是行级的
    return this.region.getSmallestReadPoint();
  }
        而HStore实际上最终获取的是Region中的SmallestReadPoint,这也从侧面反映了那个我们熟知的问题:因为HBase是行级事务,SmallestReadPoint应该也是行级的。而具体的SmallestReadPoint该如何获取,我们在以后的多版本控制协议MVCC中再细讲。

        接下来,我们再看下如何创建文件浏览器FileScanners,它是通过父类Compactor的createFileScanners()方法来构造的,代码如下:

  /**
   * Creates file scanners for compaction.
   * @param filesToCompact Files.
   * @return Scanners.
   */
  protected List<StoreFileScanner> createFileScanners(
      final Collection<StoreFile> filesToCompact, long smallestReadPoint) throws IOException {
    return StoreFileScanner.getScannersForStoreFiles(filesToCompact, false, false, true,
      smallestReadPoint);
  }
        它是一个专门为合并创建scanner的方法,这个scanner区别于客户端的scanner,我们继续看StoreFileScanner的getScannersForStoreFiles()方法,如下:

/**
   * Return an array of scanners corresponding to the given set of store files,
   * And set the ScanQueryMatcher for each store file scanner for further
   * optimization
   */
  public static List<StoreFileScanner> getScannersForStoreFiles(
      Collection<StoreFile> files, boolean cacheBlocks, boolean usePread,
      boolean isCompaction, ScanQueryMatcher matcher, long readPt) throws IOException {
    List<StoreFileScanner> scanners = new ArrayList<StoreFileScanner>(
        files.size());
    
    // 遍历StoreFile文件files
    for (StoreFile file : files) {
      // 获取每个文件的Reader
      StoreFile.Reader r = file.createReader();
      
      // 根据Reader获取StoreFileScanner类型的scanner,这个scanner专门用于读取StoreFile
      StoreFileScanner scanner = r.getStoreFileScanner(cacheBlocks, usePread,
          isCompaction, readPt);
      scanner.setScanQueryMatcher(matcher);
      
      // 加入scanner列表scanners
      scanners.add(scanner);
    }
    
    // 返回scanner列表
    return scanners;
  }
        很简单,不再赘述,读者可以自己阅读源码。

        继续,我们再看下如果获取一个内部InternalScanner类型的scanner,它是通过createScanner()来获取的,代码如下:

  /**
   * 创建一个scanner
   * 
   * @param store store
   * @param scanners Store file scanners.
   * @param scanType Scan type.
   * @param smallestReadPoint Smallest MVCC read point.
   * @param earliestPutTs Earliest put across all files.
   * @return A compaction scanner.
   */
  protected InternalScanner createScanner(Store store, List<StoreFileScanner> scanners,
      ScanType scanType, long smallestReadPoint, long earliestPutTs) throws IOException {
    
	// 构造一个Scan实例scan
	Scan scan = new Scan();
	
    // 设置最大版本号,即列簇被设置的最大版本号(是不是从这里就能看出,compact时会做数据清理工作呢,O(∩_∩)O)
	scan.setMaxVersions(store.getFamily().getMaxVersions());
    
	// 返回一个StoreScanner实例
    return new StoreScanner(store, store.getScanInfo(), scan, scanners,
        scanType, smallestReadPoint, earliestPutTs);
  }
        这里的scanner,实际上是StoreScanner类型的实例,它是针对Store的内部Scanner,而且,这里有一个重点,创建scan时会设置最大版本号,即列簇被设置的最大版本号,那么我们是不是从这里就能看出,compact时会做数据清理工作呢,答案当然是肯定的。所以HBase在数据修改时,并不是简单的删除,而是增加一个版本,而过期数据则会在compact过程中,通过scanner设置最大版本号的方式来过滤掉,这种处理方式是很高效的,它体现了HBase低延迟的特点。

        有了读数据的scanner,我们接着来看下写数据的writer。毕竟数据得有读有写,才能将旧文件合并成新文件,而writer是通过HStore的createWriterInTmp()方法来创建的,如下:

/*
   * @param maxKeyCount
   * @param compression Compression algorithm to use
   * @param isCompaction whether we are creating a new file in a compaction
   * @param includesMVCCReadPoint - whether to include MVCC or not
   * @param includesTag - includesTag or not
   * @return Writer for a new StoreFile in the tmp dir.
   */
  @Override
  public StoreFile.Writer createWriterInTmp(long maxKeyCount, Compression.Algorithm compression,
      boolean isCompaction, boolean includeMVCCReadpoint, boolean includesTag)
  throws IOException {
    final CacheConfig writerCacheConf;
    
    // 是否为合并
    if (isCompaction) {// 如果是合并,不在writerCacheConf上缓存数据
      // Don't cache data on write on compactions.
      writerCacheConf = new CacheConfig(cacheConf);
      writerCacheConf.setCacheDataOnWrite(false);
    } else {
      writerCacheConf = cacheConf;
    }
    
    InetSocketAddress[] favoredNodes = null;
    
    // 获取有利节点
    if (region.getRegionServerServices() != null) {
      favoredNodes = region.getRegionServerServices().getFavoredNodesForRegion(
          region.getRegionInfo().getEncodedName());
    }
    
    // 创建HFile上下文HFileContext
    HFileContext hFileContext = createFileContext(compression, includeMVCCReadpoint, includesTag,
      cryptoContext);
    
    // 创建StoreFile的StoreFile,需要使用上述信息,比如文件系统、文件路径、合并器、最大keyvalue数目、有利节点等
    StoreFile.Writer w = new StoreFile.WriterBuilder(conf, writerCacheConf,
        this.getFileSystem())// 文件系统
            .withFilePath(fs.createTempName())// 文件路径
            .withComparator(comparator)// 合并器
            .withBloomType(family.getBloomFilterType())
            .withMaxKeyCount(maxKeyCount)// 最大keyvalue数目
            .withFavoredNodes(favoredNodes)// 有利节点
            .withFileContext(hFileContext)// HFile上下文信息
            .build();
    return w;
  }
        这个writer本质上是StoreFile的Writer,它是针对存储文件的写入者,其中包含很多关键信息,比如文件系统、文件路径、合并器、最大keyvalue数目、有利节点、HFile上下文信息等。

        有了scanner,可以读数据了,又有了writer,也可以写数据了,那么我们就可以开始合并了:由旧文件读取数据,往新文件写入数据。我们看下Compactor的performCompaction()方法,代码如下:

  /**
   * Performs the compaction.
   * 执行合并
   * 
   * @param scanner Where to read from.
   * @param writer Where to write to.
   * @param smallestReadPoint Smallest read point.
   * @param cleanSeqId When true, remove seqId(used to be mvcc) value which is <= smallestReadPoint
   * @return Whether compaction ended; false if it was interrupted for some reason.
   */
  protected boolean performCompaction(InternalScanner scanner,
      CellSink writer, long smallestReadPoint, boolean cleanSeqId) throws IOException {
    
	// 已写字节数
	long bytesWritten = 0;
	
	// 处于写过程的字节数
    long bytesWrittenProgress = 0;
    // Since scanner.next() can return 'false' but still be delivering data,
    // we have to use a do/while loop.
    
    // Cell列表
    List<Cell> cells = new ArrayList<Cell>();
    
    // 周期性检测的阈值:合并已被处理的数据量大小,取参数hbase.hstore.close.check.interval,默认为10M
    long closeCheckInterval = HStore.getCloseCheckInterval();
    
    long lastMillis = 0;
    if (LOG.isDebugEnabled()) {
      lastMillis = EnvironmentEdgeManager.currentTime();
    }
    long now = 0;
    
    // 进入一个do...while循环,一直循环的条件是hasMore为true,即scanner中还有数据
    boolean hasMore;
    do {
      // scanner中是否还存在数据,取出到cells中
      hasMore = scanner.next(cells, compactionKVMax);
      if (LOG.isDebugEnabled()) {
        now = EnvironmentEdgeManager.currentTime();
      }
      // output to writer:
      // 遍历cells,写入writer
      for (Cell c : cells) {
        if (cleanSeqId && c.getSequenceId() <= smallestReadPoint) {
          CellUtil.setSequenceId(c, 0);
        }
        
        // 写入writer
        writer.append(c);
        // keyvalue大小
        int len = KeyValueUtil.length(c);
        
        // 计数器累加:kv累计数目和累计大小
        ++progress.currentCompactedKVs;
        progress.totalCompactedSize += len;
        
        if (LOG.isDebugEnabled()) {
          bytesWrittenProgress += len;
        }
        
        // check periodically to see if a system stop is requested
        // 周期性检测是否一个系统停止被请求
        if (closeCheckInterval > 0) {
        	
          // 累加已写字节数bytesWritten
          bytesWritten += len;
          
          // 如果已写字节数bytesWritten大于closeCheckInterval
          if (bytesWritten > closeCheckInterval) {
            
        	// 重置已写字节数bytesWritten  
        	bytesWritten = 0;
        	
        	// 判断HStore是否可写,不可写的话,说明一个system stop请求已发起,则通过progress取消合并
            if (!store.areWritesEnabled()) {
              progress.cancel();
              return false;
            }
          }
        }
      }
      // Log the progress of long running compactions every minute if
      // logging at DEBUG level
      if (LOG.isDebugEnabled()) {
        if ((now - lastMillis) >= 60 * 1000) {
          LOG.debug("Compaction progress: " + progress + String.format(", rate=%.2f kB/sec",
            (bytesWrittenProgress / 1024.0) / ((now - lastMillis) / 1000.0)));
          lastMillis = now;
          bytesWrittenProgress = 0;
        }
      }
      
      // 情况cell列表
      cells.clear();
    } while (hasMore);
    
    // 合并过程progress标记已完成
    progress.complete();
    return true;
  }
        这个合并执行的过程还是比较简单的,它通过一个do...while循环,不断的从scanner中读取数据,放入cell列表,然后遍历cells,将Cell依次写入writer,并累加kv数目和大小,直到scanner中数据被处理完。如此,旧文件数据不断的被读取出来,然后将其不断的写入新文件,最好通过合并过程progress标记合并已完成。大致就是这个流程。

        这里有个需要特别说明的地方,在数据合并过程中,还需要周期性的检测是否有外部发起系统关系的请求,如果是的话,则需要取消合并。这个周期性不是针对时间的,而是针对一个已合并数据量的阈值closeCheckInterval,这个closeCheckInterval取自参数hbase.hstore.close.check.interval,默认为10M。在合并过程中,被合并数据大小bytesWritten不断的被累加,直到超过阈值closeCheckInterval,清空,并且根据HStore的可写状态来判断是否有外部发起系统停止的请求,如果有的话,通过progress取消合并,否则继续进入下一个累加至阈值再进行判断的周期。

        接下来,根据上述合并的结果finished,来判断后续处理步骤:如果没有完成合并:关闭writer、删除writer中的临时文件并抛出异常。

        最好,如果存在异常e,写入元数据,关闭writer,并将写入地址加入newFiles;如果不存在异常e,则关闭writer,返回合并后的文件列表newFiles。不管结果如何,最终依次关闭readersToClose中StoreFile的Reader。

        至此,整个HRegion中精确到HStore上的compact流程就分析完毕了。限于篇幅的原因,可能部分细节简单掠过或者没有提及,留待以后再慢慢分析吧!






        







登录 后评论
下一篇
云栖号
8465人浏览
2020-03-04
相关推荐
深入HBase架构解析(二)
2050人浏览
2016-05-17 17:26:11
hbase的Region分裂代码分析
730人浏览
2014-12-28 20:25:48
深入 HBase 架构解析(2)
771人浏览
2015-10-06 16:38:13
HBase MetaStore和Compaction剖析
1059人浏览
2018-02-10 17:21:00
HBase系统架构
7643人浏览
2018-07-11 09:29:28
Hbase原理解析
500人浏览
2017-09-21 21:23:00
0
0
0
783