Java IOUtils.deleteFilesIgnoringExceptions方法代码示例

import org.apache.lucene.util.IOUtils; //导入方法依赖的package包/类
void trimUnreferencedReaders() {
    try (ReleasableLock ignored = writeLock.acquire()) {
        if (closed.get()) {
            // we're shutdown potentially on some tragic event - don't delete anything
            return;
        }
        long minReferencedGen = outstandingViews.stream().mapToLong(View::minTranslogGeneration).min().orElse(Long.MAX_VALUE);
        minReferencedGen = Math.min(lastCommittedTranslogFileGeneration, minReferencedGen);
        final long finalMinReferencedGen = minReferencedGen;
        List<TranslogReader> unreferenced = readers.stream().filter(r -> r.getGeneration() < finalMinReferencedGen).collect(Collectors.toList());
        for (final TranslogReader unreferencedReader : unreferenced) {
            Path translogPath = unreferencedReader.path();
            logger.trace("delete translog file - not referenced and not current anymore {}", translogPath);
            IOUtils.closeWhileHandlingException(unreferencedReader);
            IOUtils.deleteFilesIgnoringExceptions(translogPath,
                    translogPath.resolveSibling(getCommitCheckpointFileName(unreferencedReader.getGeneration())));
        }
        readers.removeAll(unreferenced);
    }
}
 

import org.apache.lucene.util.IOUtils; //导入方法依赖的package包/类
/**
 * A utility for writing the {@link IndexFileNames#SEGMENTS_GEN} file to a
 * {@link Directory}.
 * 
 * <p>
 * <b>NOTE:</b> this is an internal utility which is kept public so that it's
 * accessible by code from other packages. You should avoid calling this
 * method unless you're absolutely sure what you're doing!
 * 
 * @lucene.internal
 */
public static void writeSegmentsGen(Directory dir, long generation) {
  try {
    IndexOutput genOutput = dir.createOutput(IndexFileNames.SEGMENTS_GEN, IOContext.READONCE);
    try {
      genOutput.writeInt(FORMAT_SEGMENTS_GEN_CURRENT);
      genOutput.writeLong(generation);
      genOutput.writeLong(generation);
      CodecUtil.writeFooter(genOutput);
    } finally {
      genOutput.close();
      dir.sync(Collections.singleton(IndexFileNames.SEGMENTS_GEN));
    }
  } catch (Throwable t) {
    // It's OK if we fail to write this file since it's
    // used only as one of the retry fallbacks.
    IOUtils.deleteFilesIgnoringExceptions(dir, IndexFileNames.SEGMENTS_GEN);
  }
}
 

import org.apache.lucene.util.IOUtils; //导入方法依赖的package包/类
final void rollbackCommit(Directory dir) {
  if (pendingSegnOutput != null) {
    // Suppress so we keep throwing the original exception
    // in our caller
    IOUtils.closeWhileHandlingException(pendingSegnOutput);
    pendingSegnOutput = null;

    // Must carefully compute fileName from "generation"
    // since lastGeneration isn't incremented:
    final String segmentFileName = IndexFileNames.fileNameFromGeneration(IndexFileNames.SEGMENTS,
                                                                          "",
                                                                         generation);
    // Suppress so we keep throwing the original exception
    // in our caller
    IOUtils.deleteFilesIgnoringExceptions(dir, segmentFileName);
  }
}
 

import org.apache.lucene.util.IOUtils; //导入方法依赖的package包/类
/** try to install our custom rule profile into sandbox_init() to block execution */
private static void macImpl(Path tmpFile) throws IOException {
    // first be defensive: we can give nice errors this way, at the very least.
    boolean supported = Constants.MAC_OS_X;
    if (supported == false) {
        throw new IllegalStateException("bug: should not be trying to initialize seatbelt for an unsupported OS");
    }

    // we couldn't link methods, could be some really ancient OS X (< Leopard) or some bug
    if (libc_mac == null) {
        throw new UnsupportedOperationException("seatbelt unavailable: could not link methods. requires Leopard or above.");
    }

    // write rules to a temporary file, which will be passed to sandbox_init()
    Path rules = Files.createTempFile(tmpFile, "es", "sb");
    Files.write(rules, Collections.singleton(SANDBOX_RULES));

    boolean success = false;
    try {
        PointerByReference errorRef = new PointerByReference();
        int ret = libc_mac.sandbox_init(rules.toAbsolutePath().toString(), SANDBOX_NAMED, errorRef);
        // if sandbox_init() fails, add the message from the OS (e.g. syntax error) and free the buffer
        if (ret != 0) {
            Pointer errorBuf = errorRef.getValue();
            RuntimeException e = new UnsupportedOperationException("sandbox_init(): " + errorBuf.getString(0));
            libc_mac.sandbox_free_error(errorBuf);
            throw e;
        }
        logger.debug("OS X seatbelt initialization successful");
        success = true;
    } finally {
        if (success) {
            Files.delete(rules);
        } else {
            IOUtils.deleteFilesIgnoringExceptions(rules);
        }
    }
}
 

import org.apache.lucene.util.IOUtils; //导入方法依赖的package包/类
public void testDeleteSnapshotWithMissingIndexAndShardMetadata() throws Exception {
    Client client = client();

    Path repo = randomRepoPath();
    logger.info("-->  creating repository at {}", repo.toAbsolutePath());
    assertAcked(client.admin().cluster().preparePutRepository("test-repo")
            .setType("fs").setSettings(Settings.builder()
                    .put("location", repo)
                    .put("compress", false)
                    .put("chunk_size", randomIntBetween(100, 1000), ByteSizeUnit.BYTES)));

    createIndex("test-idx-1", "test-idx-2");
    logger.info("--> indexing some data");
    indexRandom(true,
            client().prepareIndex("test-idx-1", "doc").setSource("foo", "bar"),
            client().prepareIndex("test-idx-2", "doc").setSource("foo", "bar"));

    logger.info("--> creating snapshot");
    CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap-1").setWaitForCompletion(true).setIndices("test-idx-*").get();
    assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), greaterThan(0));
    assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));

    logger.info("--> delete index metadata and shard metadata");
    Path indices = repo.resolve("indices");
    Path testIndex1 = indices.resolve("test-idx-1");
    Path testIndex2 = indices.resolve("test-idx-2");
    Path testIndex2Shard0 = testIndex2.resolve("0");
    IOUtils.deleteFilesIgnoringExceptions(testIndex1.resolve("snapshot-test-snap-1"));
    IOUtils.deleteFilesIgnoringExceptions(testIndex2Shard0.resolve("snapshot-test-snap-1"));

    logger.info("--> delete snapshot");
    client.admin().cluster().prepareDeleteSnapshot("test-repo", "test-snap-1").get();

    logger.info("--> make sure snapshot doesn't exist");
    assertThrows(client.admin().cluster().prepareGetSnapshots("test-repo").addSnapshots("test-snap-1"), SnapshotMissingException.class);
}
 

import org.apache.lucene.util.IOUtils; //导入方法依赖的package包/类
/** Save a single segment's info. */
@Override
public void write(Directory dir, SegmentInfo si, FieldInfos fis, IOContext ioContext) throws IOException {
  final String fileName = IndexFileNames.segmentFileName(si.name, "", Lucene40SegmentInfoFormat.SI_EXTENSION);
  si.addFile(fileName);

  final IndexOutput output = dir.createOutput(fileName, ioContext);

  boolean success = false;
  try {
    CodecUtil.writeHeader(output, Lucene40SegmentInfoFormat.CODEC_NAME, Lucene40SegmentInfoFormat.VERSION_CURRENT);
    // Write the Lucene version that created this segment, since 3.1
    output.writeString(si.getVersion().toString());
    output.writeInt(si.getDocCount());

    output.writeByte((byte) (si.getUseCompoundFile() ? SegmentInfo.YES : SegmentInfo.NO));
    output.writeStringStringMap(si.getDiagnostics());
    output.writeStringStringMap(Collections.<String,String>emptyMap());
    output.writeStringSet(si.files());

    success = true;
  } finally {
    if (!success) {
      IOUtils.closeWhileHandlingException(output);
      // TODO: why must we do this? do we not get tracking dir wrapper?
      IOUtils.deleteFilesIgnoringExceptions(si.dir, fileName);
    } else {
      output.close();
    }
  }
}
 

import org.apache.lucene.util.IOUtils; //导入方法依赖的package包/类
public void abort() {
  try {
    close();
  } catch (Throwable ignored) {}
  IOUtils.deleteFilesIgnoringExceptions(directory,
      IndexFileNames.segmentFileName(segment, "", FIELDS_EXTENSION),
      IndexFileNames.segmentFileName(segment, "", FIELDS_INDEX_EXTENSION));
}
 

import org.apache.lucene.util.IOUtils; //导入方法依赖的package包/类
@Override
public void abort() {
  try {
    close();
  } catch (Throwable ignored) {}
  IOUtils.deleteFilesIgnoringExceptions(directory, IndexFileNames.segmentFileName(segment, "", Lucene40TermVectorsReader.VECTORS_INDEX_EXTENSION),
      IndexFileNames.segmentFileName(segment, "", Lucene40TermVectorsReader.VECTORS_DOCUMENTS_EXTENSION),
      IndexFileNames.segmentFileName(segment, "", Lucene40TermVectorsReader.VECTORS_FIELDS_EXTENSION));
}
 

import org.apache.lucene.util.IOUtils; //导入方法依赖的package包/类
/** Save a single segment's info. */
@Override
public void write(Directory dir, SegmentInfo si, FieldInfos fis, IOContext ioContext) throws IOException {
  final String fileName = IndexFileNames.segmentFileName(si.name, "", Lucene46SegmentInfoFormat.SI_EXTENSION);
  si.addFile(fileName);

  final IndexOutput output = dir.createOutput(fileName, ioContext);

  boolean success = false;
  try {
    CodecUtil.writeHeader(output, Lucene46SegmentInfoFormat.CODEC_NAME, Lucene46SegmentInfoFormat.VERSION_CURRENT);
    Version version = si.getVersion();
    if (version.major < 3 || version.major > 4) {
      throw new IllegalArgumentException("invalid major version: should be 3 or 4 but got: " + version.major + " segment=" + si);
    }
    // Write the Lucene version that created this segment, since 3.1
    output.writeString(version.toString());
    output.writeInt(si.getDocCount());

    output.writeByte((byte) (si.getUseCompoundFile() ? SegmentInfo.YES : SegmentInfo.NO));
    output.writeStringStringMap(si.getDiagnostics());
    output.writeStringSet(si.files());
    CodecUtil.writeFooter(output);
    success = true;
  } finally {
    if (!success) {
      IOUtils.closeWhileHandlingException(output);
      // TODO: are we doing this outside of the tracking wrapper? why must SIWriter cleanup like this?
      IOUtils.deleteFilesIgnoringExceptions(si.dir, fileName);
    } else {
      output.close();
    }
  }
}
 

import org.apache.lucene.util.IOUtils; //导入方法依赖的package包/类
@Override
public void abort() {
  IOUtils.closeWhileHandlingException(this);
  IOUtils.deleteFilesIgnoringExceptions(directory,
      IndexFileNames.segmentFileName(segment, segmentSuffix, VECTORS_EXTENSION),
      IndexFileNames.segmentFileName(segment, segmentSuffix, VECTORS_INDEX_EXTENSION));
}
 

import org.apache.lucene.util.IOUtils; //导入方法依赖的package包/类
@Override
public void abort() {
  IOUtils.closeWhileHandlingException(this);
  IOUtils.deleteFilesIgnoringExceptions(directory,
      IndexFileNames.segmentFileName(segment, segmentSuffix, FIELDS_EXTENSION),
      IndexFileNames.segmentFileName(segment, segmentSuffix, FIELDS_INDEX_EXTENSION));
}
 

import org.apache.lucene.util.IOUtils; //导入方法依赖的package包/类
synchronized private void persist() throws IOException {
  String fileName = SNAPSHOTS_PREFIX + nextWriteGen;
  IndexOutput out = dir.createOutput(fileName, IOContext.DEFAULT);
  boolean success = false;
  try {
    CodecUtil.writeHeader(out, CODEC_NAME, VERSION_CURRENT);   
    out.writeVInt(refCounts.size());
    for(Entry<Long,Integer> ent : refCounts.entrySet()) {
      out.writeVLong(ent.getKey());
      out.writeVInt(ent.getValue());
    }
    success = true;
  } finally {
    if (!success) {
      IOUtils.closeWhileHandlingException(out);
      IOUtils.deleteFilesIgnoringExceptions(dir, fileName);
    } else {
      IOUtils.close(out);
    }
  }

  dir.sync(Collections.singletonList(fileName));
  
  if (nextWriteGen > 0) {
    String lastSaveFile = SNAPSHOTS_PREFIX + (nextWriteGen-1);
    // exception OK: likely it didn't exist
    IOUtils.deleteFilesIgnoringExceptions(dir, lastSaveFile);
  }

  nextWriteGen++;
}
 

import org.apache.lucene.util.IOUtils; //导入方法依赖的package包/类
/**
 * Copy the contents of the file with specified extension into the provided
 * output stream.
 */
private final long copyFileEntry(IndexOutput dataOut, FileEntry fileEntry)
    throws IOException {
  final IndexInput is = fileEntry.dir.openInput(fileEntry.file, IOContext.READONCE);
  boolean success = false;
  try {
    final long startPtr = dataOut.getFilePointer();
    final long length = fileEntry.length;
    dataOut.copyBytes(is, length);
    // Verify that the output length diff is equal to original file
    long endPtr = dataOut.getFilePointer();
    long diff = endPtr - startPtr;
    if (diff != length)
      throw new IOException("Difference in the output file offsets " + diff
          + " does not match the original file length " + length);
    fileEntry.offset = startPtr;
    success = true;
    return length;
  } finally {
    if (success) {
      IOUtils.close(is);
      // copy successful - delete file
      // if we can't we rely on IFD to pick up and retry
      IOUtils.deleteFilesIgnoringExceptions(fileEntry.dir, fileEntry.file);
    } else {
      IOUtils.closeWhileHandlingException(is);
    }
  }
}
 

import org.apache.lucene.util.IOUtils; //导入方法依赖的package包/类
/**
 * Download the given checksum URL to the destination and check the checksum
 * @param checksumURL URL for the checksum file
 * @param originalFile original file to calculate checksum of
 * @param checksumFile destination to download the checksum file to
 * @param hashFunc class used to calculate the checksum of the file
 * @return true if the checksum was validated, false if it did not exist
 * @throws Exception if the checksum failed to match
 */
public boolean downloadAndVerifyChecksum(URL checksumURL, Path originalFile, Path checksumFile,
                                         @Nullable DownloadProgress progress,
                                         TimeValue timeout, Checksummer hashFunc) throws Exception {
    try {
        if (download(checksumURL, checksumFile, progress, timeout)) {
            byte[] fileBytes = Files.readAllBytes(originalFile);
            List<String> checksumLines = Files.readAllLines(checksumFile, StandardCharsets.UTF_8);
            if (checksumLines.size() != 1) {
                throw new ElasticsearchCorruptionException("invalid format for checksum file (" +
                        hashFunc.name() + "), expected 1 line, got: " + checksumLines.size());
            }
            String checksumHex = checksumLines.get(0);
            String fileHex = hashFunc.checksum(fileBytes);
            if (fileHex.equals(checksumHex) == false) {
                throw new ElasticsearchCorruptionException("incorrect hash (" + hashFunc.name() +
                        "), file hash: [" + fileHex + "], expected: [" + checksumHex + "]");
            }
            return true;
        }
    } catch (FileNotFoundException | NoSuchFileException e) {
        // checksum file doesn't exist
        return false;
    } finally {
        IOUtils.deleteFilesIgnoringExceptions(checksumFile);
    }
    return false;
}
 

import org.apache.lucene.util.IOUtils; //导入方法依赖的package包/类
/**
 * Closes streams, interrupts the download, may delete the
 * output file.
 */
void closeStreams() throws IOException {
    interrupt();
    if (success) {
        IOUtils.close(is, os);
    } else {
        IOUtils.closeWhileHandlingException(is, os);
        if (dest != null && Files.exists(dest)) {
            IOUtils.deleteFilesIgnoringExceptions(dest);
        }
    }
}