Java IOUtils类代码示例

import org.apache.lucene.util.IOUtils; //导入依赖的package包/类
private FileChannel openReader(long generationId) throws IOException {
    ensureOpen();
    if (readChannels.containsKey(generationId)) {
        return readChannels.get(generationId);
    }
    try {
        Path translogFilePath = this.translogPath.resolve(getFileNameFromId(tmpTranslogGeneration.get()));
        if (!Files.exists(translogFilePath)) {
            return null;
        }
        // maybe a lot of readers try to open reader and put it to readChannel cache, because read lock is shared
        FileChannel readChannel = FileChannel.open(translogFilePath, StandardOpenOption.READ);
        FileChannel originReadChannel = readChannels.putIfAbsent(generationId, readChannel);
        if (originReadChannel != null) {
            IOUtils.close(readChannel);
            return originReadChannel;
        } else {
            return readChannel;
        }
    } catch (Throwable e) {
        throw e;
    }
}
 

import org.apache.lucene.util.IOUtils; //导入依赖的package包/类
/**
 * Tries to lock all local shards for the given index. If any of the shard locks can't be acquired
 * an {@link LockObtainFailedException} is thrown and all previously acquired locks are released.
 *
 * @param index the index to lock shards for
 * @param lockTimeoutMS how long to wait for acquiring the indices shard locks
 * @return the {@link ShardLock} instances for this index.
 * @throws IOException if an IOException occurs.
 */
public List<ShardLock> lockAllForIndex(Index index, Settings settings, long lockTimeoutMS) throws IOException {
    final Integer numShards = settings.getAsInt(IndexMetaData.SETTING_NUMBER_OF_SHARDS, null);
    if (numShards == null || numShards <= 0) {
        throw new IllegalArgumentException("settings must contain a non-null > 0 number of shards");
    }
    logger.trace("locking all shards for index {} - [{}]", index, numShards);
    List<ShardLock> allLocks = new ArrayList<>(numShards);
    boolean success = false;
    long startTimeNS = System.nanoTime();
    try {
        for (int i = 0; i < numShards; i++) {
            long timeoutLeftMS = Math.max(0, lockTimeoutMS - TimeValue.nsecToMSec((System.nanoTime() - startTimeNS)));
            allLocks.add(shardLock(new ShardId(index, i), timeoutLeftMS));
        }
        success = true;
    } finally {
        if (success == false) {
            logger.trace("unable to lock all shards for index {}", index);
            IOUtils.closeWhileHandlingException(allLocks);
        }
    }
    return allLocks;
}
 

import org.apache.lucene.util.IOUtils; //导入依赖的package包/类
/** called from DirectoryReader.open(...) methods */
static DirectoryReader open(final Directory directory, final IndexCommit commit,
                        final int termInfosIndexDivisor) throws IOException {
  return (DirectoryReader) new SegmentInfos.FindSegmentsFile(directory) {
    @Override
    protected Object doBody(String segmentFileName) throws IOException {
      SegmentInfos sis = new SegmentInfos();
      sis.read(directory, segmentFileName);
      final SegmentReader[] readers = new SegmentReader[sis.size()];
      for (int i = sis.size()-1; i >= 0; i--) {
        boolean success = false;
        try {
          readers[i] = new SegmentReader(sis.info(i), termInfosIndexDivisor, IOContext.READ);
          success = true;
        } finally {
          if (!success) {
            IOUtils.closeWhileHandlingException(readers);
          }
        }
      }
      return new StandardDirectoryReader(directory, readers, null, sis, termInfosIndexDivisor, false);
    }
  }.run(commit);
}
 

import org.apache.lucene.util.IOUtils; //导入依赖的package包/类
public void loopRead(Executor executor) {
    executor.execute(new AbstractRunnable() {
        @Override
        public void onFailure(Exception e) {
            if (isOpen.get()) {
                try {
                    onException(MockChannel.this, e);
                } catch (Exception ex) {
                    logger.warn("failed on handling exception", ex);
                    IOUtils.closeWhileHandlingException(MockChannel.this); // pure paranoia
                }
            }
        }

        @Override
        protected void doRun() throws Exception {
            StreamInput input = new InputStreamStreamInput(new BufferedInputStream(activeChannel.getInputStream()));
            // There is a (slim) chance that we get interrupted right after a loop iteration, so check explicitly
            while (isOpen.get() && !Thread.currentThread().isInterrupted()) {
                cancellableThreads.executeIO(() -> readMessage(MockChannel.this, input));
            }
        }
    });
}
 

import org.apache.lucene.util.IOUtils; //导入依赖的package包/类
/**
 * @param type the ec2 hostname type to discover.
 * @return the appropriate host resolved from ec2 meta-data, or null if it cannot be obtained.
 * @see CustomNameResolver#resolveIfPossible(String)
 */
@SuppressForbidden(reason = "We call getInputStream in doPrivileged and provide SocketPermission")
public InetAddress[] resolve(Ec2HostnameType type) throws IOException {
    InputStream in = null;
    String metadataUrl = AwsEc2ServiceImpl.EC2_METADATA_URL + type.ec2Name;
    try {
        URL url = new URL(metadataUrl);
        logger.debug("obtaining ec2 hostname from ec2 meta-data url {}", url);
        URLConnection urlConnection = SocketAccess.doPrivilegedIOException(url::openConnection);
        urlConnection.setConnectTimeout(2000);
        in = SocketAccess.doPrivilegedIOException(urlConnection::getInputStream);
        BufferedReader urlReader = new BufferedReader(new InputStreamReader(in, StandardCharsets.UTF_8));

        String metadataResult = urlReader.readLine();
        if (metadataResult == null || metadataResult.length() == 0) {
            throw new IOException("no gce metadata returned from [" + url + "] for [" + type.configName + "]");
        }
        // only one address: because we explicitly ask for only one via the Ec2HostnameType
        return new InetAddress[] { InetAddress.getByName(metadataResult) };
    } catch (IOException e) {
        throw new IOException("IOException caught when fetching InetAddress from [" + metadataUrl + "]", e);
    } finally {
        IOUtils.closeWhileHandlingException(in);
    }
}
 

import org.apache.lucene.util.IOUtils; //导入依赖的package包/类
private TestCluster buildAndPutCluster(Scope currentClusterScope, long seed) throws Exception {
    final Class<?> clazz = this.getClass();
    TestCluster testCluster = clusters.remove(clazz); // remove this cluster first
    clearClusters(); // all leftovers are gone by now... this is really just a double safety if we miss something somewhere
    switch (currentClusterScope) {
        case SUITE:
            if (testCluster == null) { // only build if it's not there yet
                testCluster = buildWithPrivateContext(currentClusterScope, seed);
            }
            break;
        case TEST:
            // close the previous one and create a new one
            IOUtils.closeWhileHandlingException(testCluster);
            testCluster = buildTestCluster(currentClusterScope, seed);
            break;
    }
    clusters.put(clazz, testCluster);
    return testCluster;
}
 

import org.apache.lucene.util.IOUtils; //导入依赖的package包/类
/**
 * Copies the file <i>src</i> to {@link Directory} <i>to</i> under the new
 * file name <i>dest</i>.
 * <p>
 * If you want to copy the entire source directory to the destination one, you
 * can do so like this:
 * 
 * <pre class="prettyprint">
 * Directory to; // the directory to copy to
 * for (String file : dir.listAll()) {
 *   dir.copy(to, file, newFile, IOContext.DEFAULT); // newFile can be either file, or a new name
 * }
 * </pre>
 * <p>
 * <b>NOTE:</b> this method does not check whether <i>dest</i> exist and will
 * overwrite it if it does.
 */
public void copy(Directory to, String src, String dest, IOContext context) throws IOException {
  IndexOutput os = null;
  IndexInput is = null;
  boolean success = false;
  try {
    os = to.createOutput(dest, context);
    is = openInput(src, context);
    os.copyBytes(is, is.length());
    success = true;
  } finally {
    if (success) {
      IOUtils.close(os, is);
    } else {
      IOUtils.closeWhileHandlingException(os, is);
      try {
        to.deleteFile(dest);
      } catch (Throwable t) {
      }
    }
  }
}
 

import org.apache.lucene.util.IOUtils; //导入依赖的package包/类
private void notifyCoreClosedListeners(Throwable th) {
  synchronized(coreClosedListeners) {
    for (CoreClosedListener listener : coreClosedListeners) {
      // SegmentReader uses our instance as its
      // coreCacheKey:
      try {
        listener.onClose(this);
      } catch (Throwable t) {
        if (th == null) {
          th = t;
        } else {
          th.addSuppressed(t);
        }
      }
    }
    IOUtils.reThrowUnchecked(th);
  }
}
 

import org.apache.lucene.util.IOUtils; //导入依赖的package包/类
/**
 * Tries to lock all local shards for the given index. If any of the shard locks can't be acquired
 * a {@link ShardLockObtainFailedException} is thrown and all previously acquired locks are released.
 *
 * @param index the index to lock shards for
 * @param lockTimeoutMS how long to wait for acquiring the indices shard locks
 * @return the {@link ShardLock} instances for this index.
 * @throws IOException if an IOException occurs.
 */
public List<ShardLock> lockAllForIndex(Index index, IndexSettings settings, long lockTimeoutMS)
        throws IOException, ShardLockObtainFailedException {
    final int numShards = settings.getNumberOfShards();
    if (numShards <= 0) {
        throw new IllegalArgumentException("settings must contain a non-null > 0 number of shards");
    }
    logger.trace("locking all shards for index {} - [{}]", index, numShards);
    List<ShardLock> allLocks = new ArrayList<>(numShards);
    boolean success = false;
    long startTimeNS = System.nanoTime();
    try {
        for (int i = 0; i < numShards; i++) {
            long timeoutLeftMS = Math.max(0, lockTimeoutMS - TimeValue.nsecToMSec((System.nanoTime() - startTimeNS)));
            allLocks.add(shardLock(new ShardId(index, i), timeoutLeftMS));
        }
        success = true;
    } finally {
        if (success == false) {
            logger.trace("unable to lock all shards for index {}", index);
            IOUtils.closeWhileHandlingException(allLocks);
        }
    }
    return allLocks;
}
 

import org.apache.lucene.util.IOUtils; //导入依赖的package包/类
public void close(String reason, boolean flushEngine) throws IOException {
    synchronized (mutex) {
        try {
            changeState(IndexShardState.CLOSED, reason);
        } finally {
            final Engine engine = this.currentEngineReference.getAndSet(null);
            try {
                if (engine != null && flushEngine) {
                    engine.flushAndClose();
                }
            } finally {
                // playing safe here and close the engine even if the above succeeds - close can be called multiple times
                // Also closing refreshListeners to prevent us from accumulating any more listeners
                IOUtils.close(engine, refreshListeners);
                indexShardOperationsLock.close();
            }
        }
    }
}
 

import org.apache.lucene.util.IOUtils; //导入依赖的package包/类
@Override
public void close() throws IOException {
  // TODO: add a finish() at least to PushBase? DV too...?
  boolean success = false;
  try {
    if (docOut != null) {
      CodecUtil.writeFooter(docOut);
    }
    if (posOut != null) {
      CodecUtil.writeFooter(posOut);
    }
    if (payOut != null) {
      CodecUtil.writeFooter(payOut);
    }
    success = true;
  } finally {
    if (success) {
      IOUtils.close(docOut, posOut, payOut);
    } else {
      IOUtils.closeWhileHandlingException(docOut, posOut, payOut);
    }
    docOut = posOut = payOut = null;
  }
}
 

import org.apache.lucene.util.IOUtils; //导入依赖的package包/类
public Location writeToLocal(BytesReference data) throws IOException {
    final long position;
    final long generation;
    try (ReleasableLock lock = writeLock.acquire()) {
        ensureOpen();
        if (writtenOffset > TRANSLOG_ROLLING_SIZE_BYTES) {
            IOUtils.close(writeChannel);
            tmpTranslogGeneration.incrementAndGet();
            writeChannel = FileChannel.open(this.translogPath.resolve(getFileNameFromId(tmpTranslogGeneration.get())), StandardOpenOption.CREATE_NEW, StandardOpenOption.WRITE);
            writtenOffset = 0;
        }
        generation = tmpTranslogGeneration.get();
        position = writtenOffset;
        try {
            data.writeTo(writeChannel);
        } catch (Throwable e) {
            throw e;
        }
        writtenOffset = writtenOffset + data.length();
    }
    return new Translog.Location(generation, position, data.length());
}
 

import org.apache.lucene.util.IOUtils; //导入依赖的package包/类
@Override
public void commit() throws IOException {
    ImmutableTranslogReader toClose = null;
    try (ReleasableLock lock = writeLock.acquire()) {
        ensureOpen();
        if (currentCommittingTranslog == null) {
            prepareCommit();
        }
        lastCommittedTranslogFileGeneration = current.getGeneration(); // this is important - otherwise old files will not be cleaned up
        if (recoveredTranslogs.isEmpty() == false) {
            IOUtils.close(recoveredTranslogs);
            recoveredTranslogs.clear();
        }
        toClose = this.currentCommittingTranslog;
        this.currentCommittingTranslog = null;
    } finally {
        IOUtils.close(toClose);
    }
}
 

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包/类
/**
 * Moves the index folder found in <code>source</code> to <code>target</code>
 */
void upgrade(final Index index, final Path source, final Path target) throws IOException {
    boolean success = false;
    try {
        Files.move(source, target, StandardCopyOption.ATOMIC_MOVE);
        success = true;
    } catch (NoSuchFileException | FileNotFoundException exception) {
        // thrown when the source is non-existent because the folder was renamed
        // by another node (shared FS) after we checked if the target exists
        logger.error((Supplier<?>) () -> new ParameterizedMessage("multiple nodes trying to upgrade [{}] in parallel, retry " +
            "upgrading with single node", target), exception);
        throw exception;
    } finally {
        if (success) {
            logger.info("{} moved from [{}] to [{}]", index, source, target);
            logger.trace("{} syncing directory [{}]", index, target);
            IOUtils.fsync(target, true);
        }
    }
}