All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.google.common.io.MoreFiles Maven / Gradle / Ivy

There is a newer version: 3.0.0-alpha-3
Show newest version
/*
 * Copyright (C) 2013 The Guava Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.common.io;

import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.collect.Iterables.getOnlyElement;
import static java.nio.file.LinkOption.NOFOLLOW_LINKS;
import static java.util.Objects.requireNonNull;

import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import com.google.common.base.Optional;
import com.google.common.base.Predicate;
import com.google.common.collect.ImmutableList;
import com.google.common.graph.Traverser;
import com.google.j2objc.annotations.J2ObjCIncompatible;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.channels.Channels;
import java.nio.channels.SeekableByteChannel;
import java.nio.charset.Charset;
import java.nio.file.DirectoryIteratorException;
import java.nio.file.DirectoryStream;
import java.nio.file.FileAlreadyExistsException;
import java.nio.file.FileSystemException;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.NoSuchFileException;
import java.nio.file.NotDirectoryException;
import java.nio.file.OpenOption;
import java.nio.file.Path;
import java.nio.file.SecureDirectoryStream;
import java.nio.file.StandardOpenOption;
import java.nio.file.attribute.BasicFileAttributeView;
import java.nio.file.attribute.BasicFileAttributes;
import java.nio.file.attribute.FileAttribute;
import java.nio.file.attribute.FileTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.stream.Stream;
import javax.annotation.CheckForNull;

/**
 * Static utilities for use with {@link Path} instances, intended to complement {@link Files}.
 *
 * 

Many methods provided by Guava's {@code Files} class for {@link java.io.File} instances are * now available via the JDK's {@link java.nio.file.Files} class for {@code Path} - check the JDK's * class if a sibling method from {@code Files} appears to be missing from this class. * * @since 21.0 * @author Colin Decker */ @J2ktIncompatible @GwtIncompatible @J2ObjCIncompatible // java.nio.file @ElementTypesAreNonnullByDefault public final class MoreFiles { private MoreFiles() {} /** * Returns a view of the given {@code path} as a {@link ByteSource}. * *

Any {@linkplain OpenOption open options} provided are used when opening streams to the file * and may affect the behavior of the returned source and the streams it provides. See {@link * StandardOpenOption} for the standard options that may be provided. Providing no options is * equivalent to providing the {@link StandardOpenOption#READ READ} option. */ public static ByteSource asByteSource(Path path, OpenOption... options) { return new PathByteSource(path, options); } private static final class PathByteSource extends ByteSource { private static final LinkOption[] FOLLOW_LINKS = {}; private final Path path; private final OpenOption[] options; private final boolean followLinks; private PathByteSource(Path path, OpenOption... options) { this.path = checkNotNull(path); this.options = options.clone(); this.followLinks = followLinks(this.options); // TODO(cgdecker): validate the provided options... for example, just WRITE seems wrong } private static boolean followLinks(OpenOption[] options) { for (OpenOption option : options) { if (option == NOFOLLOW_LINKS) { return false; } } return true; } @Override public InputStream openStream() throws IOException { return Files.newInputStream(path, options); } private BasicFileAttributes readAttributes() throws IOException { return Files.readAttributes( path, BasicFileAttributes.class, followLinks ? FOLLOW_LINKS : new LinkOption[] {NOFOLLOW_LINKS}); } @Override public Optional sizeIfKnown() { BasicFileAttributes attrs; try { attrs = readAttributes(); } catch (IOException e) { // Failed to get attributes; we don't know the size. return Optional.absent(); } // Don't return a size for directories or symbolic links; their sizes are implementation // specific and they can't be read as bytes using the read methods anyway. if (attrs.isDirectory() || attrs.isSymbolicLink()) { return Optional.absent(); } return Optional.of(attrs.size()); } @Override public long size() throws IOException { BasicFileAttributes attrs = readAttributes(); // Don't return a size for directories or symbolic links; their sizes are implementation // specific and they can't be read as bytes using the read methods anyway. if (attrs.isDirectory()) { throw new IOException("can't read: is a directory"); } else if (attrs.isSymbolicLink()) { throw new IOException("can't read: is a symbolic link"); } return attrs.size(); } @Override public byte[] read() throws IOException { try (SeekableByteChannel channel = Files.newByteChannel(path, options)) { return ByteStreams.toByteArray(Channels.newInputStream(channel), channel.size()); } } @Override public CharSource asCharSource(Charset charset) { if (options.length == 0) { // If no OpenOptions were passed, delegate to Files.lines, which could have performance // advantages. (If OpenOptions were passed we can't, because Files.lines doesn't have an // overload taking OpenOptions, meaning we can't guarantee the same behavior w.r.t. things // like following/not following symlinks.) return new AsCharSource(charset) { @SuppressWarnings("FilesLinesLeak") // the user needs to close it in this case @Override public Stream lines() throws IOException { return Files.lines(path, charset); } }; } return super.asCharSource(charset); } @Override public String toString() { return "MoreFiles.asByteSource(" + path + ", " + Arrays.toString(options) + ")"; } } /** * Returns a view of the given {@code path} as a {@link ByteSink}. * *

Any {@linkplain OpenOption open options} provided are used when opening streams to the file * and may affect the behavior of the returned sink and the streams it provides. See {@link * StandardOpenOption} for the standard options that may be provided. Providing no options is * equivalent to providing the {@link StandardOpenOption#CREATE CREATE}, {@link * StandardOpenOption#TRUNCATE_EXISTING TRUNCATE_EXISTING} and {@link StandardOpenOption#WRITE * WRITE} options. */ public static ByteSink asByteSink(Path path, OpenOption... options) { return new PathByteSink(path, options); } private static final class PathByteSink extends ByteSink { private final Path path; private final OpenOption[] options; private PathByteSink(Path path, OpenOption... options) { this.path = checkNotNull(path); this.options = options.clone(); // TODO(cgdecker): validate the provided options... for example, just READ seems wrong } @Override public OutputStream openStream() throws IOException { return Files.newOutputStream(path, options); } @Override public String toString() { return "MoreFiles.asByteSink(" + path + ", " + Arrays.toString(options) + ")"; } } /** * Returns a view of the given {@code path} as a {@link CharSource} using the given {@code * charset}. * *

Any {@linkplain OpenOption open options} provided are used when opening streams to the file * and may affect the behavior of the returned source and the streams it provides. See {@link * StandardOpenOption} for the standard options that may be provided. Providing no options is * equivalent to providing the {@link StandardOpenOption#READ READ} option. */ public static CharSource asCharSource(Path path, Charset charset, OpenOption... options) { return asByteSource(path, options).asCharSource(charset); } /** * Returns a view of the given {@code path} as a {@link CharSink} using the given {@code charset}. * *

Any {@linkplain OpenOption open options} provided are used when opening streams to the file * and may affect the behavior of the returned sink and the streams it provides. See {@link * StandardOpenOption} for the standard options that may be provided. Providing no options is * equivalent to providing the {@link StandardOpenOption#CREATE CREATE}, {@link * StandardOpenOption#TRUNCATE_EXISTING TRUNCATE_EXISTING} and {@link StandardOpenOption#WRITE * WRITE} options. */ public static CharSink asCharSink(Path path, Charset charset, OpenOption... options) { return asByteSink(path, options).asCharSink(charset); } /** * Returns an immutable list of paths to the files contained in the given directory. * * @throws NoSuchFileException if the file does not exist (optional specific exception) * @throws NotDirectoryException if the file could not be opened because it is not a directory * (optional specific exception) * @throws IOException if an I/O error occurs */ public static ImmutableList listFiles(Path dir) throws IOException { try (DirectoryStream stream = Files.newDirectoryStream(dir)) { return ImmutableList.copyOf(stream); } catch (DirectoryIteratorException e) { throw e.getCause(); } } /** * Returns a {@link Traverser} instance for the file and directory tree. The returned traverser * starts from a {@link Path} and will return all files and directories it encounters. * *

The returned traverser attempts to avoid following symbolic links to directories. However, * the traverser cannot guarantee that it will not follow symbolic links to directories as it is * possible for a directory to be replaced with a symbolic link between checking if the file is a * directory and actually reading the contents of that directory. * *

If the {@link Path} passed to one of the traversal methods does not exist or is not a * directory, no exception will be thrown and the returned {@link Iterable} will contain a single * element: that path. * *

{@link DirectoryIteratorException} may be thrown when iterating {@link Iterable} instances * created by this traverser if an {@link IOException} is thrown by a call to {@link * #listFiles(Path)}. * *

Example: {@code MoreFiles.fileTraverser().depthFirstPreOrder(Paths.get("/"))} may return the * following paths: {@code ["/", "/etc", "/etc/config.txt", "/etc/fonts", "/home", "/home/alice", * ...]} * * @since 23.5 */ public static Traverser fileTraverser() { return Traverser.forTree(MoreFiles::fileTreeChildren); } private static Iterable fileTreeChildren(Path dir) { if (Files.isDirectory(dir, NOFOLLOW_LINKS)) { try { return listFiles(dir); } catch (IOException e) { // the exception thrown when iterating a DirectoryStream if an I/O exception occurs throw new DirectoryIteratorException(e); } } return ImmutableList.of(); } /** * Returns a predicate that returns the result of {@link java.nio.file.Files#isDirectory(Path, * LinkOption...)} on input paths with the given link options. */ public static Predicate isDirectory(LinkOption... options) { final LinkOption[] optionsCopy = options.clone(); return new Predicate() { @Override public boolean apply(Path input) { return Files.isDirectory(input, optionsCopy); } @Override public String toString() { return "MoreFiles.isDirectory(" + Arrays.toString(optionsCopy) + ")"; } }; } /** Returns whether or not the file with the given name in the given dir is a directory. */ private static boolean isDirectory( SecureDirectoryStream dir, Path name, LinkOption... options) throws IOException { return dir.getFileAttributeView(name, BasicFileAttributeView.class, options) .readAttributes() .isDirectory(); } /** * Returns a predicate that returns the result of {@link java.nio.file.Files#isRegularFile(Path, * LinkOption...)} on input paths with the given link options. */ public static Predicate isRegularFile(LinkOption... options) { final LinkOption[] optionsCopy = options.clone(); return new Predicate() { @Override public boolean apply(Path input) { return Files.isRegularFile(input, optionsCopy); } @Override public String toString() { return "MoreFiles.isRegularFile(" + Arrays.toString(optionsCopy) + ")"; } }; } /** * Returns true if the files located by the given paths exist, are not directories, and contain * the same bytes. * * @throws IOException if an I/O error occurs * @since 22.0 */ public static boolean equal(Path path1, Path path2) throws IOException { checkNotNull(path1); checkNotNull(path2); if (Files.isSameFile(path1, path2)) { return true; } /* * Some operating systems may return zero as the length for files denoting system-dependent * entities such as devices or pipes, in which case we must fall back on comparing the bytes * directly. */ ByteSource source1 = asByteSource(path1); ByteSource source2 = asByteSource(path2); long len1 = source1.sizeIfKnown().or(0L); long len2 = source2.sizeIfKnown().or(0L); if (len1 != 0 && len2 != 0 && len1 != len2) { return false; } return source1.contentEquals(source2); } /** * Like the unix command of the same name, creates an empty file or updates the last modified * timestamp of the existing file at the given path to the current system time. */ @SuppressWarnings("GoodTime") // reading system time without TimeSource public static void touch(Path path) throws IOException { checkNotNull(path); try { Files.setLastModifiedTime(path, FileTime.fromMillis(System.currentTimeMillis())); } catch (NoSuchFileException e) { try { Files.createFile(path); } catch (FileAlreadyExistsException ignore) { // The file didn't exist when we called setLastModifiedTime, but it did when we called // createFile, so something else created the file in between. The end result is // what we wanted: a new file that probably has its last modified time set to approximately // now. Or it could have an arbitrary last modified time set by the creator, but that's no // different than if another process set its last modified time to something else after we // created it here. } } } /** * Creates any necessary but nonexistent parent directories of the specified path. Note that if * this operation fails, it may have succeeded in creating some (but not all) of the necessary * parent directories. The parent directory is created with the given {@code attrs}. * * @throws IOException if an I/O error occurs, or if any necessary but nonexistent parent * directories of the specified file could not be created. */ public static void createParentDirectories(Path path, FileAttribute... attrs) throws IOException { // Interestingly, unlike File.getCanonicalFile(), Path/Files provides no way of getting the // canonical (absolute, normalized, symlinks resolved, etc.) form of a path to a nonexistent // file. getCanonicalFile() can at least get the canonical form of the part of the path which // actually exists and then append the normalized remainder of the path to that. Path normalizedAbsolutePath = path.toAbsolutePath().normalize(); Path parent = normalizedAbsolutePath.getParent(); if (parent == null) { // The given directory is a filesystem root. All zero of its ancestors exist. This doesn't // mean that the root itself exists -- consider x:\ on a Windows machine without such a // drive -- or even that the caller can create it, but this method makes no such guarantees // even for non-root files. return; } // Check if the parent is a directory first because createDirectories will fail if the parent // exists and is a symlink to a directory... we'd like for this to succeed in that case. // (I'm kind of surprised that createDirectories would fail in that case; doesn't seem like // what you'd want to happen.) if (!Files.isDirectory(parent)) { Files.createDirectories(parent, attrs); if (!Files.isDirectory(parent)) { throw new IOException("Unable to create parent directories of " + path); } } } /** * Returns the file extension for * the file at the given path, or the empty string if the file has no extension. The result does * not include the '{@code .}'. * *

Note: This method simply returns everything after the last '{@code .}' in the file's * name as determined by {@link Path#getFileName}. It does not account for any filesystem-specific * behavior that the {@link Path} API does not already account for. For example, on NTFS it will * report {@code "txt"} as the extension for the filename {@code "foo.exe:.txt"} even though NTFS * will drop the {@code ":.txt"} part of the name when the file is actually created on the * filesystem due to NTFS's Alternate Data Streams. */ public static String getFileExtension(Path path) { Path name = path.getFileName(); // null for empty paths and root-only paths if (name == null) { return ""; } String fileName = name.toString(); int dotIndex = fileName.lastIndexOf('.'); return dotIndex == -1 ? "" : fileName.substring(dotIndex + 1); } /** * Returns the file name without its file extension or path. This is * similar to the {@code basename} unix command. The result does not include the '{@code .}'. */ public static String getNameWithoutExtension(Path path) { Path name = path.getFileName(); // null for empty paths and root-only paths if (name == null) { return ""; } String fileName = name.toString(); int dotIndex = fileName.lastIndexOf('.'); return dotIndex == -1 ? fileName : fileName.substring(0, dotIndex); } /** * Deletes the file or directory at the given {@code path} recursively. Deletes symbolic links, * not their targets (subject to the caveat below). * *

If an I/O exception occurs attempting to read, open or delete any file under the given * directory, this method skips that file and continues. All such exceptions are collected and, * after attempting to delete all files, an {@code IOException} is thrown containing those * exceptions as {@linkplain Throwable#getSuppressed() suppressed exceptions}. * *

Warning: Security of recursive deletes

* *

On a file system that supports symbolic links and does not support {@link * SecureDirectoryStream}, it is possible for a recursive delete to delete files and directories * that are outside the directory being deleted. This can happen if, after checking that a * file is a directory (and not a symbolic link), that directory is replaced by a symbolic link to * an outside directory before the call that opens the directory to read its entries. * *

By default, this method throws {@link InsecureRecursiveDeleteException} if it can't * guarantee the security of recursive deletes. If you wish to allow the recursive deletes anyway, * pass {@link RecursiveDeleteOption#ALLOW_INSECURE} to this method to override that behavior. * * @throws NoSuchFileException if {@code path} does not exist (optional specific exception) * @throws InsecureRecursiveDeleteException if the security of recursive deletes can't be * guaranteed for the file system and {@link RecursiveDeleteOption#ALLOW_INSECURE} was not * specified * @throws IOException if {@code path} or any file in the subtree rooted at it can't be deleted * for any reason */ public static void deleteRecursively(Path path, RecursiveDeleteOption... options) throws IOException { Path parentPath = getParentPath(path); if (parentPath == null) { throw new FileSystemException(path.toString(), null, "can't delete recursively"); } Collection exceptions = null; // created lazily if needed try { boolean sdsSupported = false; try (DirectoryStream parent = Files.newDirectoryStream(parentPath)) { if (parent instanceof SecureDirectoryStream) { sdsSupported = true; exceptions = deleteRecursivelySecure( (SecureDirectoryStream) parent, /* * requireNonNull is safe because paths have file names when they have parents, * and we checked for a parent at the beginning of the method. */ requireNonNull(path.getFileName())); } } if (!sdsSupported) { checkAllowsInsecure(path, options); exceptions = deleteRecursivelyInsecure(path); } } catch (IOException e) { if (exceptions == null) { throw e; } else { exceptions.add(e); } } if (exceptions != null) { throwDeleteFailed(path, exceptions); } } /** * Deletes all files within the directory at the given {@code path} {@linkplain #deleteRecursively * recursively}. Does not delete the directory itself. Deletes symbolic links, not their targets * (subject to the caveat below). If {@code path} itself is a symbolic link to a directory, that * link is followed and the contents of the directory it targets are deleted. * *

If an I/O exception occurs attempting to read, open or delete any file under the given * directory, this method skips that file and continues. All such exceptions are collected and, * after attempting to delete all files, an {@code IOException} is thrown containing those * exceptions as {@linkplain Throwable#getSuppressed() suppressed exceptions}. * *

Warning: Security of recursive deletes

* *

On a file system that supports symbolic links and does not support {@link * SecureDirectoryStream}, it is possible for a recursive delete to delete files and directories * that are outside the directory being deleted. This can happen if, after checking that a * file is a directory (and not a symbolic link), that directory is replaced by a symbolic link to * an outside directory before the call that opens the directory to read its entries. * *

By default, this method throws {@link InsecureRecursiveDeleteException} if it can't * guarantee the security of recursive deletes. If you wish to allow the recursive deletes anyway, * pass {@link RecursiveDeleteOption#ALLOW_INSECURE} to this method to override that behavior. * * @throws NoSuchFileException if {@code path} does not exist (optional specific exception) * @throws NotDirectoryException if the file at {@code path} is not a directory (optional * specific exception) * @throws InsecureRecursiveDeleteException if the security of recursive deletes can't be * guaranteed for the file system and {@link RecursiveDeleteOption#ALLOW_INSECURE} was not * specified * @throws IOException if one or more files can't be deleted for any reason */ public static void deleteDirectoryContents(Path path, RecursiveDeleteOption... options) throws IOException { Collection exceptions = null; // created lazily if needed try (DirectoryStream stream = Files.newDirectoryStream(path)) { if (stream instanceof SecureDirectoryStream) { SecureDirectoryStream sds = (SecureDirectoryStream) stream; exceptions = deleteDirectoryContentsSecure(sds); } else { checkAllowsInsecure(path, options); exceptions = deleteDirectoryContentsInsecure(stream); } } catch (IOException e) { if (exceptions == null) { throw e; } else { exceptions.add(e); } } if (exceptions != null) { throwDeleteFailed(path, exceptions); } } /** * Secure recursive delete using {@code SecureDirectoryStream}. Returns a collection of exceptions * that occurred or null if no exceptions were thrown. */ @CheckForNull private static Collection deleteRecursivelySecure( SecureDirectoryStream dir, Path path) { Collection exceptions = null; try { if (isDirectory(dir, path, NOFOLLOW_LINKS)) { try (SecureDirectoryStream childDir = dir.newDirectoryStream(path, NOFOLLOW_LINKS)) { exceptions = deleteDirectoryContentsSecure(childDir); } // If exceptions is not null, something went wrong trying to delete the contents of the // directory, so we shouldn't try to delete the directory as it will probably fail. if (exceptions == null) { dir.deleteDirectory(path); } } else { dir.deleteFile(path); } return exceptions; } catch (IOException e) { return addException(exceptions, e); } } /** * Secure method for deleting the contents of a directory using {@code SecureDirectoryStream}. * Returns a collection of exceptions that occurred or null if no exceptions were thrown. */ @CheckForNull private static Collection deleteDirectoryContentsSecure( SecureDirectoryStream dir) { Collection exceptions = null; try { for (Path path : dir) { exceptions = concat(exceptions, deleteRecursivelySecure(dir, path.getFileName())); } return exceptions; } catch (DirectoryIteratorException e) { return addException(exceptions, e.getCause()); } } /** * Insecure recursive delete for file systems that don't support {@code SecureDirectoryStream}. * Returns a collection of exceptions that occurred or null if no exceptions were thrown. */ @CheckForNull private static Collection deleteRecursivelyInsecure(Path path) { Collection exceptions = null; try { if (Files.isDirectory(path, NOFOLLOW_LINKS)) { try (DirectoryStream stream = Files.newDirectoryStream(path)) { exceptions = deleteDirectoryContentsInsecure(stream); } } // If exceptions is not null, something went wrong trying to delete the contents of the // directory, so we shouldn't try to delete the directory as it will probably fail. if (exceptions == null) { Files.delete(path); } return exceptions; } catch (IOException e) { return addException(exceptions, e); } } /** * Simple, insecure method for deleting the contents of a directory for file systems that don't * support {@code SecureDirectoryStream}. Returns a collection of exceptions that occurred or null * if no exceptions were thrown. */ @CheckForNull private static Collection deleteDirectoryContentsInsecure( DirectoryStream dir) { Collection exceptions = null; try { for (Path entry : dir) { exceptions = concat(exceptions, deleteRecursivelyInsecure(entry)); } return exceptions; } catch (DirectoryIteratorException e) { return addException(exceptions, e.getCause()); } } /** * Returns a path to the parent directory of the given path. If the path actually has a parent * path, this is simple. Otherwise, we need to do some trickier things. Returns null if the path * is a root or is the empty path. */ @CheckForNull private static Path getParentPath(Path path) { Path parent = path.getParent(); // Paths that have a parent: if (parent != null) { // "/foo" ("/") // "foo/bar" ("foo") // "C:\foo" ("C:\") // "\foo" ("\" - current drive for process on Windows) // "C:foo" ("C:" - working dir of drive C on Windows) return parent; } // Paths that don't have a parent: if (path.getNameCount() == 0) { // "/", "C:\", "\" (no parent) // "" (undefined, though typically parent of working dir) // "C:" (parent of working dir of drive C on Windows) // // For working dir paths ("" and "C:"), return null because: // A) it's not specified that "" is the path to the working directory. // B) if we're getting this path for recursive delete, it's typically not possible to // delete the working dir with a relative path anyway, so it's ok to fail. // C) if we're getting it for opening a new SecureDirectoryStream, there's no need to get // the parent path anyway since we can safely open a DirectoryStream to the path without // worrying about a symlink. return null; } else { // "foo" (working dir) return path.getFileSystem().getPath("."); } } /** Checks that the given options allow an insecure delete, throwing an exception if not. */ private static void checkAllowsInsecure(Path path, RecursiveDeleteOption[] options) throws InsecureRecursiveDeleteException { if (!Arrays.asList(options).contains(RecursiveDeleteOption.ALLOW_INSECURE)) { throw new InsecureRecursiveDeleteException(path.toString()); } } /** * Adds the given exception to the given collection, creating the collection if it's null. Returns * the collection. */ private static Collection addException( @CheckForNull Collection exceptions, IOException e) { if (exceptions == null) { exceptions = new ArrayList<>(); // don't need Set semantics } exceptions.add(e); return exceptions; } /** * Concatenates the contents of the two given collections of exceptions. If either collection is * null, the other collection is returned. Otherwise, the elements of {@code other} are added to * {@code exceptions} and {@code exceptions} is returned. */ @CheckForNull private static Collection concat( @CheckForNull Collection exceptions, @CheckForNull Collection other) { if (exceptions == null) { return other; } else if (other != null) { exceptions.addAll(other); } return exceptions; } /** * Throws an exception indicating that one or more files couldn't be deleted when deleting {@code * path} or its contents. * *

If there is only one exception in the collection, and it is a {@link NoSuchFileException} * thrown because {@code path} itself didn't exist, then throws that exception. Otherwise, the * thrown exception contains all the exceptions in the given collection as suppressed exceptions. */ private static void throwDeleteFailed(Path path, Collection exceptions) throws FileSystemException { NoSuchFileException pathNotFound = pathNotFound(path, exceptions); if (pathNotFound != null) { throw pathNotFound; } // TODO(cgdecker): Should there be a custom exception type for this? // Also, should we try to include the Path of each file we may have failed to delete rather // than just the exceptions that occurred? FileSystemException deleteFailed = new FileSystemException( path.toString(), null, "failed to delete one or more files; see suppressed exceptions for details"); for (IOException e : exceptions) { deleteFailed.addSuppressed(e); } throw deleteFailed; } @CheckForNull private static NoSuchFileException pathNotFound(Path path, Collection exceptions) { if (exceptions.size() != 1) { return null; } IOException exception = getOnlyElement(exceptions); if (!(exception instanceof NoSuchFileException)) { return null; } NoSuchFileException noSuchFileException = (NoSuchFileException) exception; String exceptionFile = noSuchFileException.getFile(); if (exceptionFile == null) { /* * It's not clear whether this happens in practice, especially with the filesystem * implementations that are built into java.nio. */ return null; } Path parentPath = getParentPath(path); if (parentPath == null) { /* * This is probably impossible: * * - In deleteRecursively, we require the path argument to have a parent. * * - In deleteDirectoryContents, the path argument may have no parent. Fortunately, all the * *other* paths we process will be descendants of that. That leaves only the original path * argument for us to consider. And the only place we call pathNotFound is from * throwDeleteFailed, and the other place that we call throwDeleteFailed inside * deleteDirectoryContents is when an exception is thrown during the recursive steps. Any * failure during the initial lookup of the path argument itself is rethrown directly. So * any exception that we're seeing here is from a descendant, which naturally has a parent. * I think. * * Still, if this can happen somehow (a weird filesystem implementation that lets callers * change its working directly concurrently with a call to deleteDirectoryContents?), it makes * more sense for us to fall back to a generic FileSystemException (by returning null here) * than to dereference parentPath and end up producing NullPointerException. */ return null; } // requireNonNull is safe because paths have file names when they have parents. Path pathResolvedFromParent = parentPath.resolve(requireNonNull(path.getFileName())); if (exceptionFile.equals(pathResolvedFromParent.toString())) { return noSuchFileException; } return null; } }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy