Package com.atlassian.bamboo.utils.files

Class MoreFiles

  • public final class MoreFiles
extends Object
    Took from Bitbucket DC. Since 9.4.0

    • Constructor Detail

      • MoreFiles

        public MoreFiles()

    • Method Detail

      • resolve

        @NotNull
public static @NotNull Path resolve​(@NotNull
                                    @NotNull Path path,
                                    @NotNull
                                    @NotNull String first,
                                    @NotNull
                                    @NotNull String... more)
        Simplifies resolving several subpaths in a single call.
        Parameters:
        path - the base path, from which subpaths should be resolved
        first - the first subpath, used to enforce that at least a single subpath is provided
        more - zero or more additional subpaths
        Returns:
        the resolved path

      • mkdir

        @NotNull
public static @NotNull Path mkdir​(@NotNull
                                  @NotNull Path parent,
                                  @NotNull
                                  @NotNull String child)
        Creates the specified child directory beneath the parent, if it does not already exist. If the path does exist, it is validated that it is a directory and not a file.
        Parameters:
        parent - the base path for creating the new directory
        child - the path beneath the parent for the new directory
        Returns:
        the created directory
        Throws:
        IllegalArgumentException - if the child path is blank or empty
        IllegalStateException - if the child path already exists and is not a directory, or if the directory cannot be created
        NullPointerException - if the provided parent or child is null

      • mkdir

        @NotNull
public static @NotNull Path mkdir​(@NotNull
                                  @NotNull Path directory)
        Creates the specified directory, if it does not already exist. If the path does exist, it is validated that it is a directory and not a file.
        Parameters:
        directory - the directory to create
        Returns:
        the created directory
        Throws:
        IllegalStateException - if the directory path already exists and is not a directory, or if the directory cannot be created
        NullPointerException - if the provided directory is null

      • isWithin

        public static boolean isWithin​(@NotNull
                               @NotNull Path path,
                               @NotNull
                               @NotNull Path expectedParent)
                        throws IOException
        Returns true if the specified path is contained within the expectedParent. This should be used to ensure paths created with user-entered data don't "escape" the specified parent, to prevent path traversal attacks.
        Parameters:
        path - the path to validate
        expectedParent - the required parent directory
        Returns:
        true if path is contained within expectedParent; otherwise, false
        Throws:
        IllegalArgumentException - if expectedParent does not exist or is not a directory
        IOException - if the real path for either of the provided paths cannot be resolved

      • cleanDirectory

        public static void cleanDirectory​(@NotNull
                                  @NotNull Path directory)
                           throws IOException
        Deletes any files or subdirectories in the specified directory and leaves the directory empty.
        Parameters:
        directory - the directory to clean
        Throws:
        IOException - if the path does not denote a directory, or the directory's contents could not be deleted

      • deleteRecursively

        public static void deleteRecursively​(@NotNull
                                     @NotNull Path path)
                              throws IOException
        Recursively deletes the specified path.

        If the specified Path denotes a directory, the directory's contents are recursively deleted, depth-first, to empty the directory so it can be deleted. If any files or subdirectories can't be deleted, an exception will be thrown. Note that some files and subdirectories may have been deleted prior to the exception being thrown. Additionally, if the directory contains any symbolic links the links themselves are deleted, not their targets.

        If the specified Path denotes a symbolic link, the symbolic link itself is deleted, rather than the target of the link. If the path is a symbolic link to a directory, that directory's contents are not removed.

        If the specified Path denotes a file, it is deleted.

        If the specified path does not exist, nothing happens and no exception is thrown.

        Parameters:
        path - the path to delete, which may be a file or a directory
        Throws:
        IOException - if the specified path cannot be deleted

      • size

        public static long size​(@NotNull
                        @NotNull Path path)
        Gets the size of the specified Path.

        Like File.length(), if the path does not exist or its attributes cannot be read, 0L is returned rather than throwing an exception. Use Files.size(java.nio.file.Path) directly if an exception is desired.

        Parameters:
        path - the path to retrieve the size of
        Returns:
        the file's size, or 0L if the size could not be determined

      • deleteOnExit

        public static void deleteOnExit​(@NotNull
                                @NotNull Path path)
        Registers the provided path to be deleted when the JVM exits.

        Delete-on-exit is performed on a best-effort basis, and should not be relied upon as the primary solution for deleting files. Additionally, it only works for files and empty directories.

        Parameters:
        path - the path to register for deletion when the JVM exits
        See Also:
        File.deleteOnExit()

      • touch

        public static void touch​(@NotNull
                         @NotNull Path path)
                  throws IOException
        Creates the specified path, if it doesn't exist, or sets its last modified time if it does.
        Parameters:
        path - the path to create or set a last modification time for
        Throws:
        IOException - if a nonexistent file cannot be created, or if the last modification time cannot be set for an existing file