java类org.apache.hadoop.io.MultipleIOException的实例源码

/**
 * Close all DFSClient instances in the Cache.
 * @param onlyAutomatic only close those that are marked for automatic closing
 */
synchronized void closeAll(boolean onlyAutomatic) throws IOException {
  List<IOException> exceptions = new ArrayList<IOException>();

  ConcurrentMap<String, DFSClient> map = clientCache.asMap();

  for (Entry<String, DFSClient> item : map.entrySet()) {
    final DFSClient client = item.getValue();
    if (client != null) {
      try {
        client.close();
      } catch (IOException ioe) {
        exceptions.add(ioe);
      }
    }
  }

  if (!exceptions.isEmpty()) {
    throw MultipleIOException.createIOException(exceptions);
  }
}

/**
 * @return null if failed to report progress
 * @throws IOException
 */
@Override
public List<Path> finishWritingAndClose() throws IOException {
  boolean isSuccessful = false;
  List<Path> result = null;
  try {
    isSuccessful = finishWriting(false);
  } finally {
    result = close();
    List<IOException> thrown = closeLogWriters(null);
    if (thrown != null && !thrown.isEmpty()) {
      throw MultipleIOException.createIOException(thrown);
    }
  }
  if (isSuccessful) {
    splits = result;
  }
  return splits;
}

@Override
public List<Path> finishWritingAndClose() throws IOException {
  try {
    if (!finishWriting(false)) {
      return null;
    }
    if (hasEditsInDisablingOrDisabledTables) {
      splits = logRecoveredEditsOutputSink.finishWritingAndClose();
    } else {
      splits = new ArrayList<Path>();
    }
    // returns an empty array in order to keep interface same as old way
    return splits;
  } finally {
    List<IOException> thrown = closeRegionServerWriters();
    if (thrown != null && !thrown.isEmpty()) {
      throw MultipleIOException.createIOException(thrown);
    }
  }
}

/**
 * Just do a simple delete of the given store files
 * <p>
 * A best effort is made to delete each of the files, rather than bailing on the first failure.
 * <p>
 * This method is preferable to {@link #deleteFilesWithoutArchiving(Collection)} since it consumes
 * less resources, but is limited in terms of usefulness
 * @param compactedFiles store files to delete from the file system.
 * @throws IOException if a file cannot be deleted. All files will be attempted to deleted before
 *           throwing the exception, rather than failing at the first file.
 */
private static void deleteStoreFilesWithoutArchiving(Collection<StoreFile> compactedFiles)
    throws IOException {
  LOG.debug("Deleting store files without archiving.");
  List<IOException> errors = new ArrayList<IOException>(0);
  for (StoreFile hsf : compactedFiles) {
    try {
      hsf.deleteReader();
    } catch (IOException e) {
      LOG.error("Failed to delete store file:" + hsf.getPath());
      errors.add(e);
    }
  }
  if (errors.size() > 0) {
    throw MultipleIOException.createIOException(errors);
  }
}

/**
 * Close all DFSClient instances in the Cache.
 * @param onlyAutomatic only close those that are marked for automatic closing
 */
synchronized void closeAll(boolean onlyAutomatic) throws IOException {
  List<IOException> exceptions = new ArrayList<IOException>();

  ConcurrentMap<String, DFSClient> map = clientCache.asMap();

  for (Entry<String, DFSClient> item : map.entrySet()) {
    final DFSClient client = item.getValue();
    if (client != null) {
      try {
        client.close();
      } catch (IOException ioe) {
        exceptions.add(ioe);
      }
    }
  }

  if (!exceptions.isEmpty()) {
    throw MultipleIOException.createIOException(exceptions);
  }
}

/**
 * Close all DFSClient instances in the Cache.
 * @param onlyAutomatic only close those that are marked for automatic closing
 */
synchronized void closeAll(boolean onlyAutomatic) throws IOException {
  List<IOException> exceptions = new ArrayList<IOException>();

  ConcurrentMap<String, DFSClient> map = clientCache.asMap();

  for (Entry<String, DFSClient> item : map.entrySet()) {
    final DFSClient client = item.getValue();
    if (client != null) {
      try {
        client.close();
      } catch (IOException ioe) {
        exceptions.add(ioe);
      }
    }
  }

  if (!exceptions.isEmpty()) {
    throw MultipleIOException.createIOException(exceptions);
  }
}

/**
 * Simple delete of regular files from the {@link FileSystem}.
 * <p>
 * This method is a more generic implementation that the other deleteXXX methods in this class,
 * allowing more code reuse at the cost of a couple more, short-lived objects (which should have
 * minimum impact on the jvm).
 * @param fs {@link FileSystem} where the files live
 * @param files {@link Collection} of files to be deleted
 * @throws IOException if a file cannot be deleted. All files will be attempted to deleted before
 *           throwing the exception, rather than failing at the first file.
 */
private static void deleteFilesWithoutArchiving(Collection<File> files) throws IOException {
  List<IOException> errors = new ArrayList<IOException>(0);
  for (File file : files) {
    try {
      LOG.debug("Deleting region file:" + file);
      file.delete();
    } catch (IOException e) {
      LOG.error("Failed to delete file:" + file);
      errors.add(e);
    }
  }
  if (errors.size() > 0) {
    throw MultipleIOException.createIOException(errors);
  }
}

/**
 * Just do a simple delete of the given store files
 * <p>
 * A best effort is made to delete each of the files, rather than bailing on the first failure.
 * <p>
 * This method is preferable to {@link #deleteFilesWithoutArchiving(Collection)} since it consumes
 * less resources, but is limited in terms of usefulness
 * @param compactedFiles store files to delete from the file system.
 * @throws IOException if a file cannot be deleted. All files will be attempted to deleted before
 *           throwing the exception, rather than failing at the first file.
 */
private static void deleteStoreFilesWithoutArchiving(Collection<StoreFile> compactedFiles)
    throws IOException {
  LOG.debug("Deleting store files without archiving.");
  List<IOException> errors = new ArrayList<IOException>(0);
  for (StoreFile hsf : compactedFiles) {
    try {
      hsf.deleteReader();
    } catch (IOException e) {
      LOG.error("Failed to delete store file:" + hsf.getPath());
      errors.add(e);
    }
  }
  if (errors.size() > 0) {
    throw MultipleIOException.createIOException(errors);
  }
}

/**
 * Close all DFSClient instances in the Cache.
 * @param onlyAutomatic only close those that are marked for automatic closing
 */
synchronized void closeAll(boolean onlyAutomatic) throws IOException {
  List<IOException> exceptions = new ArrayList<IOException>();

  ConcurrentMap<String, DFSClient> map = clientCache.asMap();

  for (Entry<String, DFSClient> item : map.entrySet()) {
    final DFSClient client = item.getValue();
    if (client != null) {
      try {
        client.close();
      } catch (IOException ioe) {
        exceptions.add(ioe);
      }
    }
  }

  if (!exceptions.isEmpty()) {
    throw MultipleIOException.createIOException(exceptions);
  }
}

/**
 * @return null if failed to report progress
 * @throws IOException
 */
@Override
List<Path> finishWritingAndClose() throws IOException {
  boolean isSuccessful = false;
  List<Path> result = null;
  try {
    isSuccessful = finishWriting();
  } finally {
    result = close();
    List<IOException> thrown = closeLogWriters(null);
    if (thrown != null && !thrown.isEmpty()) {
      throw MultipleIOException.createIOException(thrown);
    }
  }
  if (isSuccessful) {
    splits = result;
  }
  return splits;
}

@Override
List<Path> finishWritingAndClose() throws IOException {
  try {
    if (!finishWriting()) {
      return null;
    }
    if (hasEditsInDisablingOrDisabledTables) {
      splits = logRecoveredEditsOutputSink.finishWritingAndClose();
    } else {
      splits = new ArrayList<Path>();
    }
    // returns an empty array in order to keep interface same as old way
    return splits;
  } finally {
    List<IOException> thrown = closeRegionServerWriters();
    if (thrown != null && !thrown.isEmpty()) {
      throw MultipleIOException.createIOException(thrown);
    }
  }
}

/**
 * Just do a simple delete of the given store files
 * <p>
 * A best effort is made to delete each of the files, rather than bailing on the first failure.
 * <p>
 * This method is preferable to {@link #deleteFilesWithoutArchiving(Collection)} since it consumes
 * less resources, but is limited in terms of usefulness
 * @param compactedFiles store files to delete from the file system.
 * @throws IOException if a file cannot be deleted. All files will be attempted to deleted before
 *           throwing the exception, rather than failing at the first file.
 */
private static void deleteStoreFilesWithoutArchiving(Collection<StoreFile> compactedFiles)
    throws IOException {
  LOG.debug("Deleting store files without archiving.");
  List<IOException> errors = new ArrayList<IOException>(0);
  for (StoreFile hsf : compactedFiles) {
    try {
      hsf.deleteReader();
    } catch (IOException e) {
      LOG.error("Failed to delete store file:" + hsf.getPath());
      errors.add(e);
    }
  }
  if (errors.size() > 0) {
    throw MultipleIOException.createIOException(errors);
  }
}

/**
 * Just do a simple delete of the given store files
 * <p>
 * A best effort is made to delete each of the files, rather than bailing on the first failure.
 * <p>
 * This method is preferable to {@link #deleteFilesWithoutArchiving(Collection)} since it consumes
 * less resources, but is limited in terms of usefulness
 * @param compactedFiles store files to delete from the file system.
 * @throws IOException if a file cannot be deleted. All files will be attempted to deleted before
 *           throwing the exception, rather than failing at the first file.
 */
private static void deleteStoreFilesWithoutArchiving(Collection<StoreFile> compactedFiles)
    throws IOException {
  LOG.debug("Deleting store files without archiving.");
  List<IOException> errors = new ArrayList<IOException>(0);
  for (StoreFile hsf : compactedFiles) {
    try {
      hsf.deleteReader();
    } catch (IOException e) {
      LOG.error("Failed to delete store file:" + hsf.getPath());
      errors.add(e);
    }
  }
  if (errors.size() > 0) {
    throw MultipleIOException.createIOException(errors);
  }
}

/**
 * @return null if failed to report progress
 * @throws IOException
 */
@Override
List<Path> finishWritingAndClose() throws IOException {
  boolean isSuccessful = false;
  List<Path> result = null;
  try {
    isSuccessful = finishWriting();
  } finally {
    result = close();
    List<IOException> thrown = closeLogWriters(null);
    if (thrown != null && !thrown.isEmpty()) {
      throw MultipleIOException.createIOException(thrown);
    }
  }
  if (isSuccessful) {
    splits = result;
  }
  return splits;
}

@Override
List<Path> finishWritingAndClose() throws IOException {
  try {
    if (!finishWriting()) {
      return null;
    }
    if (hasEditsInDisablingOrDisabledTables) {
      splits = logRecoveredEditsOutputSink.finishWritingAndClose();
    } else {
      splits = new ArrayList<Path>();
    }
    // returns an empty array in order to keep interface same as old way
    return splits;
  } finally {
    List<IOException> thrown = closeRegionServerWriters();
    if (thrown != null && !thrown.isEmpty()) {
      throw MultipleIOException.createIOException(thrown);
    }
  }
}

/**
 * Close all DFSClient instances in the Cache.
 *
 * @param onlyAutomatic
 *     only close those that are marked for automatic closing
 */
synchronized void closeAll(boolean onlyAutomatic) throws IOException {
  List<IOException> exceptions = new ArrayList<IOException>();

  ConcurrentMap<String, DFSClient> map = clientCache.asMap();

  for (Entry<String, DFSClient> item : map.entrySet()) {
    final DFSClient client = item.getValue();
    if (client != null) {
      try {
        client.close();
      } catch (IOException ioe) {
        exceptions.add(ioe);
      }
    }
  }

  if (!exceptions.isEmpty()) {
    throw MultipleIOException.createIOException(exceptions);
  }
}

/**
 * Simple delete of regular files from the {@link FileSystem}.
 * <p>
 * This method is a more generic implementation that the other deleteXXX
 * methods in this class, allowing more code reuse at the cost of a couple
 * more, short-lived objects (which should have minimum impact on the jvm).
 * @param fs {@link FileSystem} where the files live
 * @param files {@link Collection} of files to be deleted
 * @throws IOException if a file cannot be deleted. All files will be
 *           attempted to deleted before throwing the exception, rather than
 *           failing at the first file.
 */
private static void deleteFilesWithoutArchiving(Collection<File> files) throws IOException {
  List<IOException> errors = new ArrayList<IOException>(0);
  for (File file : files) {
    try {
      LOG.debug("Deleting region file:" + file);
      file.delete();
    } catch (IOException e) {
      LOG.error("Failed to delete file:" + file);
      errors.add(e);
    }
  }
  if (errors.size() > 0) {
    throw MultipleIOException.createIOException(errors);
  }
}

/**
 * Just do a simple delete of the given store files
 * <p>
 * A best effort is made to delete each of the files, rather than bailing on the first failure.
 * <p>
 * This method is preferable to {@link #deleteFilesWithoutArchiving(Collection)} since it consumes
 * less resources, but is limited in terms of usefulness
 * @param compactedFiles store files to delete from the file system.
 * @throws IOException if a file cannot be deleted. All files will be attempted to deleted before
 *           throwing the exception, rather than failing at the first file.
 */
private static void deleteStoreFilesWithoutArchiving(Collection<StoreFile> compactedFiles)
    throws IOException {
  LOG.debug("Deleting store files without archiving.");
  List<IOException> errors = new ArrayList<IOException>(0);
  for (StoreFile hsf : compactedFiles) {
    try {
      hsf.deleteReader();
    } catch (IOException e) {
      LOG.error("Failed to delete store file:" + hsf.getPath());
      errors.add(e);
    }
  }
  if (errors.size() > 0) {
    throw MultipleIOException.createIOException(errors);
  }
}

/**
 * @return null if failed to report progress
 * @throws IOException
 */
@Override
public List<Path> finishWritingAndClose() throws IOException {
  boolean isSuccessful = false;
  List<Path> result = null;
  try {
    isSuccessful = finishWriting(false);
  } finally {
    result = close();
    List<IOException> thrown = closeLogWriters(null);
    if (CollectionUtils.isNotEmpty(thrown)) {
      throw MultipleIOException.createIOException(thrown);
    }
  }
  if (isSuccessful) {
    splits = result;
  }
  return splits;
}

private Path writeThenClose(RegionEntryBuffer buffer) throws IOException {
  WriterAndPath wap = appendBuffer(buffer, false);
  if(wap != null) {
    String encodedRegionName = Bytes.toString(buffer.encodedRegionName);
    Long value = regionRecoverStatMap.putIfAbsent(encodedRegionName, wap.editsWritten);
    if (value != null) {
      Long newValue = regionRecoverStatMap.get(encodedRegionName) + wap.editsWritten;
      regionRecoverStatMap.put(encodedRegionName, newValue);
    }
  }

  Path dst = null;
  List<IOException> thrown = new ArrayList<>();
  if(wap != null){
    dst = closeWriter(Bytes.toString(buffer.encodedRegionName), wap, thrown);
  }
  if (!thrown.isEmpty()) {
    throw MultipleIOException.createIOException(thrown);
  }
  return dst;
}

/**
 * Just do a simple delete of the given store files
 * <p>
 * A best effort is made to delete each of the files, rather than bailing on the first failure.
 * <p>
 * @param compactedFiles store files to delete from the file system.
 * @throws IOException if a file cannot be deleted. All files will be attempted to deleted before
 *           throwing the exception, rather than failing at the first file.
 */
private static void deleteStoreFilesWithoutArchiving(Collection<HStoreFile> compactedFiles)
    throws IOException {
  LOG.debug("Deleting store files without archiving.");
  List<IOException> errors = new ArrayList<>(0);
  for (HStoreFile hsf : compactedFiles) {
    try {
      hsf.deleteStoreFile();
    } catch (IOException e) {
      LOG.error("Failed to delete store file:" + hsf.getPath());
      errors.add(e);
    }
  }
  if (errors.size() > 0) {
    throw MultipleIOException.createIOException(errors);
  }
}

/**
 * Just do a simple delete of the given store files
 * <p>
 * A best effort is made to delete each of the files, rather than bailing on the first failure.
 * <p>
 * This method is preferable to {@link #deleteFilesWithoutArchiving(Collection)} since it consumes
 * less resources, but is limited in terms of usefulness
 * @param compactedFiles store files to delete from the file system.
 * @throws IOException if a file cannot be deleted. All files will be attempted to deleted before
 *           throwing the exception, rather than failing at the first file.
 */
private static void deleteStoreFilesWithoutArchiving(Collection<StoreFile> compactedFiles)
    throws IOException {
  LOG.debug("Deleting store files without archiving.");
  List<IOException> errors = new ArrayList<IOException>(0);
  for (StoreFile hsf : compactedFiles) {
    try {
      hsf.deleteReader();
    } catch (IOException e) {
      LOG.error("Failed to delete store file:" + hsf.getPath());
      errors.add(e);
    }
  }
  if (errors.size() > 0) {
    throw MultipleIOException.createIOException(errors);
  }
}

/**
 * @return null if failed to report progress
 * @throws IOException
 */
@Override
List<Path> finishWritingAndClose() throws IOException {
  boolean isSuccessful = false;
  List<Path> result = null;
  try {
    isSuccessful = finishWriting();
  } finally {
    result = close();
    List<IOException> thrown = closeLogWriters(null);
    if (thrown != null && !thrown.isEmpty()) {
      throw MultipleIOException.createIOException(thrown);
    }
  }
  if (isSuccessful) {
    splits = result;
  }
  return splits;
}

@Override
List<Path> finishWritingAndClose() throws IOException {
  try {
    if (!finishWriting()) {
      return null;
    }
    if (hasEditsInDisablingOrDisabledTables) {
      splits = logRecoveredEditsOutputSink.finishWritingAndClose();
    } else {
      splits = new ArrayList<Path>();
    }
    // returns an empty array in order to keep interface same as old way
    return splits;
  } finally {
    List<IOException> thrown = closeRegionServerWriters();
    if (thrown != null && !thrown.isEmpty()) {
      throw MultipleIOException.createIOException(thrown);
    }
  }
}

/**
 * Just do a simple delete of the given store files
 * <p>
 * A best effort is made to delete each of the files, rather than bailing on the first failure.
 * <p>
 * This method is preferable to {@link #deleteFilesWithoutArchiving(Collection)} since it consumes
 * less resources, but is limited in terms of usefulness
 * @param compactedFiles store files to delete from the file system.
 * @throws IOException if a file cannot be deleted. All files will be attempted to deleted before
 *           throwing the exception, rather than failing at the first file.
 */
private static void deleteStoreFilesWithoutArchiving(Collection<StoreFile> compactedFiles)
    throws IOException {
  LOG.debug("Deleting store files without archiving.");
  List<IOException> errors = new ArrayList<IOException>(0);
  for (StoreFile hsf : compactedFiles) {
    try {
      hsf.deleteReader();
    } catch (IOException e) {
      LOG.error("Failed to delete store file:" + hsf.getPath());
      errors.add(e);
    }
  }
  if (errors.size() > 0) {
    throw MultipleIOException.createIOException(errors);
  }
}

/**
 * @return null if failed to report progress
 * @throws IOException
 */
@Override
List<Path> finishWritingAndClose() throws IOException {
  boolean isSuccessful = false;
  List<Path> result = null;
  try {
    isSuccessful = finishWriting();
  } finally {
    result = close();
    List<IOException> thrown = closeLogWriters(null);
    if (thrown != null && !thrown.isEmpty()) {
      throw MultipleIOException.createIOException(thrown);
    }
  }
  if (isSuccessful) {
    splits = result;
  }
  return splits;
}

@Override
List<Path> finishWritingAndClose() throws IOException {
  try {
    if (!finishWriting()) {
      return null;
    }
    if (hasEditsInDisablingOrDisabledTables) {
      splits = logRecoveredEditsOutputSink.finishWritingAndClose();
    } else {
      splits = new ArrayList<Path>();
    }
    // returns an empty array in order to keep interface same as old way
    return splits;
  } finally {
    List<IOException> thrown = closeRegionServerWriters();
    if (thrown != null && !thrown.isEmpty()) {
      throw MultipleIOException.createIOException(thrown);
    }
  }
}

synchronized void closeAll() throws IOException {
  List<IOException> exceptions = new ArrayList<IOException>();
  for(; !map.isEmpty(); ) {
    Map.Entry<Key, FileSystem> e = map.entrySet().iterator().next();
    final Key key = e.getKey();
    final FileSystem fs = e.getValue();

    //remove from cache
    remove(key, fs);

    if (fs != null) {
      try {
        fs.close();
      }
      catch(IOException ioe) {
        exceptions.add(ioe);
      }
    }
  }

  if (!exceptions.isEmpty()) {
    throw MultipleIOException.createIOException(exceptions);
  }
}

/**
 * Close all DFSClient instances in the Cache.
 * @param onlyAutomatic only close those that are marked for automatic closing
 */
synchronized void closeAll(boolean onlyAutomatic) throws IOException {
  List<IOException> exceptions = new ArrayList<IOException>();

  ConcurrentMap<String, DFSClient> map = clientCache.asMap();

  for (Entry<String, DFSClient> item : map.entrySet()) {
    final DFSClient client = item.getValue();
    if (client != null) {
      try {
        client.close();
      } catch (IOException ioe) {
        exceptions.add(ioe);
      }
    }
  }

  if (!exceptions.isEmpty()) {
    throw MultipleIOException.createIOException(exceptions);
  }
}

synchronized void closeAll() throws IOException {
  List<IOException> exceptions = new ArrayList<IOException>();
  for(; !map.isEmpty(); ) {
    Map.Entry<Key, FileSystem> e = map.entrySet().iterator().next();
    final Key key = e.getKey();
    final FileSystem fs = e.getValue();

    //remove from cache
    remove(key, fs);

    if (fs != null) {
      try {
        fs.close();
      }
      catch(IOException ioe) {
        exceptions.add(ioe);
      }
    }
  }

  if (!exceptions.isEmpty()) {
    throw MultipleIOException.createIOException(exceptions);
  }
}