Java MultipleIOException.createIOException方法代码示例

import org.apache.hadoop.io.MultipleIOException; //导入方法依赖的package包/类
/**
 * 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);
  }
}
 

import org.apache.hadoop.io.MultipleIOException; //导入方法依赖的package包/类
/**
 * @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;
}
 

import org.apache.hadoop.io.MultipleIOException; //导入方法依赖的package包/类
/**
 * 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);
  }
}
 

import org.apache.hadoop.io.MultipleIOException; //导入方法依赖的package包/类
/**
 * 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);
  }
}
 

import org.apache.hadoop.io.MultipleIOException; //导入方法依赖的package包/类
/**
 * @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;
}
 

import org.apache.hadoop.io.MultipleIOException; //导入方法依赖的package包/类
/**
 * 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);
  }
}
 

import org.apache.hadoop.io.MultipleIOException; //导入方法依赖的package包/类
/**
 * 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);
  }
}
 

import org.apache.hadoop.io.MultipleIOException; //导入方法依赖的package包/类
/**
 * @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;
}
 

import org.apache.hadoop.io.MultipleIOException; //导入方法依赖的package包/类
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;
}
 

import org.apache.hadoop.io.MultipleIOException; //导入方法依赖的package包/类
/**
 * 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);
  }
}
 

import org.apache.hadoop.io.MultipleIOException; //导入方法依赖的package包/类
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);
  }
}
 

import org.apache.hadoop.io.MultipleIOException; //导入方法依赖的package包/类
/**
 * Close all FileSystem 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>();

  // Make a copy of the keys in the map since we'll be modifying
  // the map while iterating over it, which isn't safe.
  List<Key> keys = new ArrayList<Key>();
  keys.addAll(map.keySet());

  for (Key key : keys) {
    final FileSystem fs = map.get(key);

    if (onlyAutomatic && !toAutoClose.contains(key)) {
      continue;
    }

    //remove from cache
    map.remove(key);
    toAutoClose.remove(key);

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

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

import org.apache.hadoop.io.MultipleIOException; //导入方法依赖的package包/类
/**
 * Close all FileSystem 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>();

  // Make a copy of the keys in the map since we'll be modifying
  // the map while iterating over it, which isn't safe.
  List<Key> keys = new ArrayList<Key>();
  keys.addAll(map.keySet());

  for (Key key : keys) {
    final FileSystem fs = map.get(key);

    if (onlyAutomatic && !toAutoClose.contains(key)) {
      continue;
    }

    //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);
  }
}
 

import org.apache.hadoop.io.MultipleIOException; //导入方法依赖的package包/类
private void addVolumeAndBlockPool(Collection<StorageLocation> dataLocations,
    Storage.StorageDirectory sd, final Collection<String> bpids)
    throws IOException {
  final File dir = sd.getCurrentDir();
  final StorageType storageType =
      getStorageTypeFromLocations(dataLocations, sd.getRoot());

  final FsVolumeImpl fsVolume = new FsVolumeImpl(
      this, sd.getStorageUuid(), dir, this.conf, storageType);
  final ReplicaMap tempVolumeMap = new ReplicaMap(fsVolume);

  List<IOException> exceptions = Lists.newArrayList();
  for (final String bpid : bpids) {
    try {
      fsVolume.addBlockPool(bpid, this.conf);
      fsVolume.getVolumeMap(bpid, tempVolumeMap, ramDiskReplicaTracker);
    } catch (IOException e) {
      LOG.warn("Caught exception when adding " + fsVolume +
          ". Will throw later.", e);
      exceptions.add(e);
    }
  }
  if (!exceptions.isEmpty()) {
    // The states of FsDatasteImpl are not modified, thus no need to rolled back.
    throw MultipleIOException.createIOException(exceptions);
  }

  volumeMap.addAll(tempVolumeMap);
  storageMap.put(sd.getStorageUuid(),
      new DatanodeStorage(sd.getStorageUuid(),
          DatanodeStorage.State.NORMAL,
          storageType));
  asyncDiskService.addVolume(sd.getCurrentDir());
  volumes.addVolume(fsVolume);

  LOG.info("Added volume - " + dir + ", StorageType: " + storageType);
}
 

import org.apache.hadoop.io.MultipleIOException; //导入方法依赖的package包/类
/**
 * Populate hbi's from regionInfos loaded from file system. 
 */
private void loadTableInfo() throws IOException {
  List<IOException> ioes = new ArrayList<IOException>();
  // generate region split structure
  for (HbckInfo hbi : regionInfo.values()) {
    // only load entries that haven't been loaded yet.
    if (hbi.metaEntry == null) {
      try {
        loadMetaEntry(hbi);
      } catch (IOException ioe) {
        String msg = "Unable to load region info for table " + hbi.hdfsTableName
          + "!  It may be an invalid format or version file.  You may want to "
          + "remove " + hbi.foundRegionDir.getPath()
          + " region from hdfs and retry.";
        errors.report(msg);
        LOG.error(msg, ioe);
        ioes.add(new RegionInfoLoadException(msg, ioe));
        continue;
      }
    }

    // get table name from hdfs, populate various HBaseFsck tables.
    String tableName = hbi.hdfsTableName;
    TInfo modTInfo = tablesInfo.get(tableName);
    if (modTInfo == null) {
      modTInfo = new TInfo(tableName);
    }
    modTInfo.addRegionInfo(hbi);
    tablesInfo.put(tableName, modTInfo);
  }

  if (ioes.size() != 0) {
    throw MultipleIOException.createIOException(ioes);
  }
}