|
/*
* Copyright (c) 2017, 2020, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package jdk.test.lib.util;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.UncheckedIOException;
import java.lang.ProcessBuilder.Redirect;
import java.lang.management.ManagementFactory;
import java.nio.file.DirectoryNotEmptyException;
import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.NoSuchFileException;
import java.nio.file.Path;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.attribute.BasicFileAttributes;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;
import jdk.test.lib.Platform;
import com.sun.management.UnixOperatingSystemMXBean;
/**
* Common library for various test file utility functions.
*/
public final class FileUtils {
private static final boolean IS_WINDOWS = Platform.isWindows();
private static final int RETRY_DELETE_MILLIS = IS_WINDOWS ? 500 : 0;
private static final int MAX_RETRY_DELETE_TIMES = IS_WINDOWS ? 15 : 0;
private static volatile boolean nativeLibLoaded;
/**
* Deletes a file, retrying if necessary.
*
* @param path the file to delete
*
* @throws NoSuchFileException
* if the file does not exist (optional specific exception)
* @throws DirectoryNotEmptyException
* if the file is a directory and could not otherwise be deleted
* because the directory is not empty (optional specific exception)
* @throws IOException
* if an I/O error occurs
*/
public static void deleteFileWithRetry(Path path) throws IOException {
try {
deleteFileWithRetry0(path);
} catch (InterruptedException x) {
throw new IOException("Interrupted while deleting.", x);
}
}
/**
* Deletes a file, retrying if necessary.
* No exception thrown if file doesn't exist.
*
* @param path the file to delete
*
* @throws NoSuchFileException
* if the file does not exist (optional specific exception)
* @throws DirectoryNotEmptyException
* if the file is a directory and could not otherwise be deleted
* because the directory is not empty (optional specific exception)
* @throws IOException
* if an I/O error occurs
*/
public static void deleteFileIfExistsWithRetry(Path path) throws IOException {
try {
if (!Files.notExists(path)) {
deleteFileWithRetry0(path);
}
} catch (InterruptedException x) {
throw new IOException("Interrupted while deleting.", x);
}
}
private static void deleteFileWithRetry0(Path path)
throws IOException, InterruptedException {
int times = 0;
IOException ioe = null;
while (true) {
try {
Files.delete(path);
// Checks for absence of the file. Semantics of Files.exists() is not the same.
while (!Files.notExists(path)) {
times++;
if (times > MAX_RETRY_DELETE_TIMES) {
throw new IOException("File still exists after " + times + " waits.");
}
Thread.sleep(RETRY_DELETE_MILLIS);
}
break;
} catch (NoSuchFileException | DirectoryNotEmptyException x) {
throw x;
} catch (IOException x) {
// Backoff/retry in case another process is accessing the file
times++;
if (ioe == null) {
ioe = x;
} else {
ioe.addSuppressed(x);
}
if (times > MAX_RETRY_DELETE_TIMES) {
throw ioe;
}
Thread.sleep(RETRY_DELETE_MILLIS);
}
}
}
/**
* Deletes a directory and its subdirectories, retrying if necessary.
*
* @param dir the directory to delete
*
* @throws IOException
* If an I/O error occurs. Any such exceptions are caught
* internally. If only one is caught, then it is re-thrown.
* If more than one exception is caught, then the second and
* following exceptions are added as suppressed exceptions of the
* first one caught, which is then re-thrown.
*/
public static void deleteFileTreeWithRetry(Path dir) throws IOException {
IOException ioe = null;
final List<IOException> excs = deleteFileTreeUnchecked(dir);
if (!excs.isEmpty()) {
ioe = excs.remove(0);
for (IOException x : excs) {
ioe.addSuppressed(x);
}
}
if (ioe != null) {
throw ioe;
}
}
public static List<IOException> deleteFileTreeUnchecked(Path dir) {
final List<IOException> excs = new ArrayList<>();
try {
java.nio.file.Files.walkFileTree(dir, new SimpleFileVisitor<>() {
@Override
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
try {
deleteFileWithRetry0(file);
} catch (IOException x) {
excs.add(x);
} catch (InterruptedException x) {
excs.add(new IOException("Interrupted while deleting.", x));
return FileVisitResult.TERMINATE;
}
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult postVisitDirectory(Path dir, IOException exc) {
try {
deleteFileWithRetry0(dir);
} catch (IOException x) {
excs.add(x);
} catch (InterruptedException x) {
excs.add(new IOException("Interrupted while deleting.", x));
return FileVisitResult.TERMINATE;
}
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult visitFileFailed(Path file, IOException exc) {
excs.add(exc);
return FileVisitResult.CONTINUE;
}
});
} catch (IOException x) {
excs.add(x);
}
return excs;
}
/**
* Checks whether all file systems are accessible. This is performed
* by checking free disk space on all mounted file systems via a
* separate, spawned process. File systems are considered to be
* accessible if this process completes successfully before a given
* fixed duration has elapsed.
*
* @implNote On Unix this executes the {@code df} command in a separate
* process and on Windows always returns {@code true}.
*/
public static boolean areFileSystemsAccessible() throws IOException {
boolean areFileSystemsAccessible = true;
if (!IS_WINDOWS) {
// try to check whether 'df' hangs
System.out.println("\n--- df output ---");
System.out.flush();
Process proc = new ProcessBuilder("df").inheritIO().start();
try {
proc.waitFor(90, TimeUnit.SECONDS);
} catch (InterruptedException ignored) {
}
try {
int exitValue = proc.exitValue();
if (exitValue != 0) {
System.err.printf("df process exited with %d != 0%n",
exitValue);
areFileSystemsAccessible = false;
}
} catch (IllegalThreadStateException ignored) {
System.err.println("df command apparently hung");
areFileSystemsAccessible = false;
}
}
return areFileSystemsAccessible;
}
/**
* Checks whether all file systems are accessible and there are no
* duplicate mount points. This is performed by checking free disk
* space on all mounted file systems via a separate, spawned process.
* File systems are considered to be accessible if this process completes
* successfully before a given fixed duration has elapsed.
*
* @implNote On Unix this executes the {@code df} command in a separate
* process and on Windows always returns {@code true}.
*
* @return whether file systems appear to be accessible and duplicate-free
*/
public static boolean areMountPointsAccessibleAndUnique() {
if (IS_WINDOWS) return true;
final AtomicBoolean areMountPointsOK = new AtomicBoolean(true);
Thread thr = new Thread(() -> {
try {
Process proc = new ProcessBuilder("df").start();
BufferedReader reader = new BufferedReader
(new InputStreamReader(proc.getInputStream()));
// Skip the first line as it is the "df" output header.
if (reader.readLine() != null ) {
Set mountPoints = new HashSet();
String mountPoint = null;
while ((mountPoint = reader.readLine()) != null) {
if (!mountPoints.add(mountPoint)) {
System.err.printf
("Config error: duplicate mount point %s%n",
mountPoint);
areMountPointsOK.set(false);
break;
}
}
}
try {
proc.waitFor(90, TimeUnit.SECONDS);
} catch (InterruptedException ignored) {
}
try {
int exitValue = proc.exitValue();
if (exitValue != 0) {
System.err.printf("df process exited with %d != 0%n",
exitValue);
areMountPointsOK.set(false);
}
} catch (IllegalThreadStateException ignored) {
System.err.println("df command apparently hung");
areMountPointsOK.set(false);
}
} catch (IOException ioe) {
throw new RuntimeException(ioe);
};
});
final AtomicReference throwableReference =
new AtomicReference<Throwable>();
thr.setUncaughtExceptionHandler(
new Thread.UncaughtExceptionHandler() {
public void uncaughtException(Thread t, Throwable e) {
throwableReference.set(e);
}
});
thr.start();
try {
thr.join(120*1000L);
} catch (InterruptedException ie) {
throw new RuntimeException(ie);
}
Throwable uncaughtException = (Throwable)throwableReference.get();
if (uncaughtException != null) {
throw new RuntimeException(uncaughtException);
}
if (thr.isAlive()) {
throw new RuntimeException("df thread did not join in time");
}
return areMountPointsOK.get();
}
/**
* List the open file descriptors (if supported by the 'lsof' command).
* @param ps a printStream to send the output to
* @throws UncheckedIOException if an error occurs
*/
public static void listFileDescriptors(PrintStream ps) {
Optional<String[]> lsof = Arrays.stream(lsCommands)
.filter(args -> Files.isExecutable(Path.of(args[0])))
.findFirst();
lsof.ifPresent(args -> {
try {
ps.printf("Open File Descriptors:%n");
long pid = ProcessHandle.current().pid();
ProcessBuilder pb = new ProcessBuilder(args[0], args[1], Integer.toString((int) pid));
pb.redirectErrorStream(true); // combine stderr and stdout
pb.redirectOutput(Redirect.PIPE);
Process p = pb.start();
Instant start = Instant.now();
p.getInputStream().transferTo(ps);
try {
int timeout = 10;
if (!p.waitFor(timeout, TimeUnit.SECONDS)) {
System.out.printf("waitFor timed out: %d%n", timeout);
}
} catch (InterruptedException ie) {
throw new IOException("interrupted", ie);
}
ps.println();
} catch (IOException ioe) {
throw new UncheckedIOException("error listing file descriptors", ioe);
}
});
}
// Return the current process handle count
public static long getProcessHandleCount() {
if (IS_WINDOWS) {
if (!nativeLibLoaded) {
System.loadLibrary("FileUtils");
nativeLibLoaded = true;
}
return getWinProcessHandleCount();
} else {
return ((UnixOperatingSystemMXBean)ManagementFactory.getOperatingSystemMXBean()).getOpenFileDescriptorCount();
}
}
/**
* Patches a part of a file.
*
* @param path the file
* @param fromLine the first line to patch. This is the number you see in an editor, 1-based, inclusive.
* @param toLine the last line to patch. This is the number you see in an editor, inclusive.
* Set {@code toLine} to {@code fromLine - 1} if you only want to insert lines.
* @param from lines to remove, used to ensure the correct lines are removed. Can be multiple lines or empty.
* It's compared to existing lines with all lines trimmed and no new lines at both ends. Ignored if null.
* @param to the newly added lines, can be multiple lines or empty. New line at end is optional. Cannot be null.
* @throws IOException if there's an I/O error or {@code from} does not match the existing lines
* @throws IndexOutOfBoundsException if {@code fromLine} or {@code toLine} is invalid
*/
public static void patch(Path path, int fromLine, int toLine, String from, String to) throws IOException {
var lines = Files.readAllLines(path);
// The next line does a from/to as well
var subList = lines.subList(fromLine - 1, toLine);
if (from != null) {
// Each line is trimmed so caller needs not care about indentation.
// Caller also needs not care about new lines on both ends.
// New lines inside are preserved.
String actuallyRemoved = subList.stream()
.map(String::trim)
.collect(Collectors.joining("\n")).trim();
String wantToRemove = from.lines()
.map(String::trim)
.collect(Collectors.joining("\n")).trim();
if (!actuallyRemoved.equals(wantToRemove)) {
throw new IOException("Removed not the same: ["
+ String.join("\\n", subList) + "] and ["
+ from.replaceAll("\\n", "\\\\n") + "]");
}
}
subList.clear();
lines.addAll(fromLine - 1, to.lines().toList());
Files.write(path, lines);
}
private static native long getWinProcessHandleCount();
// Possible command locations and arguments
static String[][] lsCommands = new String[][] {
{"/usr/bin/lsof", "-p"},
{"/usr/sbin/lsof", "-p"},
{"/bin/lsof", "-p"},
{"/sbin/lsof", "-p"},
{"/usr/local/bin/lsof", "-p"},
};
}
¤ Dauer der Verarbeitung: 0.7 Sekunden
(vorverarbeitet)
¤
|
Haftungshinweis
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung ist noch experimentell.
|
