flume spoolDirectorySource中的 File has been modified since being read与File has changed size since being read错误

 　　以下内容都为自己浅显的理解，用作备忘的流水账，所以写的比较混乱。如理解有错误，请帮忙指正

　　FLUME-NG中没有之前的对文件的实时流SOURCE，只提供了spoolDir的source，这个source的功能监控指定文件夹，放入文件夹内的文件不能再做任何修改（包括修改时间和文件大小），这2个错误正是对应这2个

在代码中体现为

org.apache.flume.client.avro.ReliableSpoolingFileEventReader.retireCurrentFile()方法内

File fileToRoll = new File(currentFile.get().getFile().getAbsolutePath());
 
 currentFile.get().getDeserializer().close();
 
 // Verify that spooling assumptions hold
 if (fileToRoll.lastModified() != currentFile.get().getLastModified()) {
   String message = "File has been modified since being read: " + fileToRoll +"\n"
           + "fileToRoll.lastModified() : " + fileToRoll.lastModified() +
           "currentFile.get().getLastModified() : " + currentFile.get().getLastModified();
   throw new IllegalStateException(message);
 }
 if (fileToRoll.length() != currentFile.get().getLength()) {
   String message = "File has changed size since  being read: " + fileToRoll +"\n"
           + "fileToRoll.length() : " + fileToRoll.length() +
           "currentFile.get().getLength() : " + currentFile.get().getLength();
   throw new IllegalStateException(message);
 }

 

 但是问题是我们确实没有对文件做出过任何修改啊，会什么还是会报这个错误。查看了代码后，发现他的这个线程频率为500ms,当我们拷贝一个大些的文件的时候，500ms还没有拷贝完成，所以就会出现这样的错误。当然flume被设计成500MS，是因为默认大家都是传很小的文件，每几分钟或者每几秒就做写一个日志文件，就不会存在这样的问题。

org.apache.flume.source.SpoolDirectorySource

//这个检验的太快，当文件比较大的时候，需要拷贝的时间比较超过500毫秒，就会报文件更改或者文件大小的变化,改为5000
private static final int POLL_DELAY_MS = 15000;

 

    默认为500MS,我给改成15000ms。

 

    那么问题既然出来了，我想就把这个值调大点吧，调成15秒总行了吧。但是经过测试后发现，还是不可以。

    那这又是为什么呢？原因很简单，即使我们把这个值调成1万秒，当一个大点的文件正好在第9999秒的时候往里面拷贝了，一秒后线程启动了发现一个新文件并记下了这时候的这个文件的修改时间与大小，但是因为文件并没有拷贝完成，所以这2个值都是错误。当刚才的那部分读完后，程序中检查文件的修改时间与大小看看是否被改变，刚才那段时间文件又被copy了一些进来，此时就会报上面的错误了。

    知道了根本的原因，就像从根本上解决这个问题，最好的方式就是我们等文件完全拷贝完成，我们再开始读这个文件。那找到代码中获取要读文件的这部分

/**
 * Find and open the oldest file in the chosen directory. If two or more
 * files are equally old, the file name with lower lexicographical value is
 * returned. If the directory is empty, this will return an absent option.
 */
private Optional<FileInfo> getNextFile() {
  /* Filter to exclude finished or hidden files */
  FileFilter filter = new FileFilter() {
    public boolean accept(File candidate) {
      String fileName = candidate.getName();
      if ((candidate.isDirectory()) ||
          (fileName.endsWith(completedSuffix)) ||
          (fileName.startsWith(".")) ||
          ignorePattern.matcher(fileName).matches()) {
        return false;
      }
      return true;
    }
  };
  List<File> candidateFiles = Arrays.asList(spoolDirectory.listFiles(filter)); //获取spoolDirectory下满足条件的文件
  if (candidateFiles.isEmpty()) {
    return Optional.absent();
  } else {
    Collections.sort(candidateFiles, new Comparator<File>() { //按最后修改时间排序文件
      public int compare(File a, File b) {
        int timeComparison = new Long(a.lastModified()).compareTo(
            new Long(b.lastModified()));
        if (timeComparison != 0) {
          return timeComparison;
        }
        else {
          return a.getName().compareTo(b.getName());
        }
      }
    });
    File nextFile = candidateFiles.get(0); //因为每次获取到的文件处理完都会被标记为已完成，所以直接取拍完序的第一个
    //修复传输大文件报错文件被修改的BUG
    this.checkFileCpIsOver(nextFile);//此处被阻塞，直到文件拷贝文件或者超过20秒
 
    try {
      // roll the meta file, if needed
      String nextPath = nextFile.getPath();
      PositionTracker tracker =
          DurablePositionTracker.getInstance(metaFile, nextPath);
      if (!tracker.getTarget().equals(nextPath)) {
        tracker.close();
        deleteMetaFile();
        tracker = DurablePositionTracker.getInstance(metaFile, nextPath);
      }
 
      // sanity check
      Preconditions.checkState(tracker.getTarget().equals(nextPath),
          "Tracker target %s does not equal expected filename %s",
          tracker.getTarget(), nextPath);
 
      ResettableInputStream in =
          new ResettableFileInputStream(nextFile, tracker,
              ResettableFileInputStream.DEFAULT_BUF_SIZE, inputCharset,
              decodeErrorPolicy);
      EventDeserializer deserializer = EventDeserializerFactory.getInstance
          (deserializerType, deserializerContext, in);
 
      return Optional.of(new FileInfo(nextFile, deserializer));
    } catch (FileNotFoundException e) {
      // File could have been deleted in the interim
      logger.warn("Could not find file: " + nextFile, e);
      return Optional.absent();
    } catch (IOException e) {
      logger.error("Exception opening file: " + nextFile, e);
      return Optional.absent();
    }
  }
}

 

在方法的第36行是获取准备要读的文件的部分，之前就是直接拿到文件不会检查文件是否拷贝完成，第38行为自己添加的方法

方法如下：

 

/**
 *
 * @Title: checkFileCpIsOver
 * @Description: TODO(用来检查文件拷贝是否完成)
 * @param @param currentFile    设定文件
 * @return void    返回类型
 * @throws
 */
private void checkFileCpIsOver(File file) {
    long modified = file.lastModified();//目前文件的修改时间
    long length = file.length();//目前文件的大小
    try {
      Thread.sleep(1000);//等待1秒钟
    } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    File currentFile = new File(file.getAbsolutePath());
    int count = 0;//记录循环次数，超过20次，也就是10秒后抛出异常
    while(currentFile.lastModified() != modified || currentFile.length() != length) {
        if(count > 20) {
            String message = "File Copy time too long. please check copy whether exception!" + "\n"
                      + "File at :" + file.getAbsolutePath() + "\n"
                      + "File current length is：" + currentFile.lastModified();
            new IllegalStateException(message);
        }
        count++;
        modified = currentFile.lastModified();
        length = currentFile.length();
        try {
          Thread.sleep(500);//等待500毫秒
        } catch (InterruptedException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
        }
        currentFile = new File(file.getAbsolutePath());
         
         
    }
    //一直到文件传输完成就可以退出
}

 

修复完成，将修改涉及到的部分重新打包，替换线上JAR包，再次验证。