brooklyn.util.os.Os.java Source code

Java tutorial

Introduction

Here is the source code for brooklyn.util.os.Os.java

Source

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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 brooklyn.util.os;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import org.apache.commons.io.FileUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import brooklyn.util.exceptions.Exceptions;
import brooklyn.util.guava.Maybe;
import brooklyn.util.javalang.JavaClassNames;
import brooklyn.util.net.Urls;
import brooklyn.util.stream.Streams;
import brooklyn.util.text.Identifiers;
import brooklyn.util.text.Strings;

import com.google.common.annotations.Beta;
import com.google.common.base.Joiner;
import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
import com.google.common.base.Throwables;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import com.google.common.io.ByteStreams;
import com.google.common.io.Files;

public class Os {

    private static final Logger log = LoggerFactory.getLogger(Os.class);

    private static final int TEMP_DIR_ATTEMPTS = 1000;

    private static final char SEPARATOR_UNIX = '/';
    private static final char SEPARATOR_WIN = '\\';

    public static final String LINE_SEPARATOR = System.getProperty("line.separator");

    /** returns the best tmp dir to use; see {@link TmpDirFinder} for the logic
     * (and the explanation why this is needed!) */
    public static String tmp() {
        Maybe<String> tmp = tmpdir.get();
        if (tmp.isPresent())
            return tmp.get();

        tmpdir.useWithWarning(System.getProperty("java.io.tmpdir"));
        return tmp.get();
    }

    private static TmpDirFinder tmpdir = new TmpDirFinder();

    /** utility for finding a usable (writable) tmp dir, preferring java.io.tmpdir
     * (unless it's weird, e.g. /private/tmp/xxx or /var/tmp/... as under OS X, and /tmp is valid),
     * falling back to ~/.tmp/ (and creating that) if the others are not usable
     * <p>
     * it is weird if /tmp is not writable, but it does happen, hence this check
     * <p>
     * note you can also set java system property {@value #BROOKLYN_OS_TMPDIR_PROPERTY} 
     * to force the use of a specific tmp space */
    public static class TmpDirFinder {
        /** can be set as a jvm system property to force a particular tmp dir; directory must exist with the right permissions */
        public static String BROOKLYN_OS_TMPDIR_PROPERTY = "brooklyn.os.tmpdir";

        private String tmpdir = null;
        private boolean isFallback = false;

        public Maybe<String> get() {
            if (isFallback())
                log.debug("TmpDirFinder: using fallback tmp directory " + tmpdir,
                        new Throwable("Caller using fallback tmp dir"));
            if (isFound())
                return Maybe.of(tmpdir);
            if (find())
                return Maybe.of(tmpdir);
            return Maybe.absent(newFailure("TmpDirFinder: No valid tmp dir can be found"));
        }

        public boolean isFallback() {
            return isFallback;
        }

        public boolean useWithWarning(String dir) {
            if (tmpdir == null) {
                tmpdir = dir;
                isFallback = true;
                log.warn("Unable to find a valid tmp dir; will use " + dir
                        + " but with caution! See (debug) messages marked TmpDirFinder for more information.");
                return true;
            }
            return false;
        }

        public boolean isFound() {
            return tmpdir != null;
        }

        protected synchronized boolean find() {
            if (isFound())
                return true;

            String customtmp = System.getProperty(BROOKLYN_OS_TMPDIR_PROPERTY);
            if (customtmp != null) {
                if (checkAndSet(customtmp))
                    return true;
                log.warn("TmpDirFinder: Custom tmp directory '" + customtmp + "' in " + BROOKLYN_OS_TMPDIR_PROPERTY
                        + " is not a valid tmp dir; ignoring");
            }

            String systmp = System.getProperty("java.io.tmpdir");
            boolean systmpWeird = (systmp.contains("/var/") || systmp.startsWith("/private"));
            if (!systmpWeird)
                if (checkAndSet(systmp))
                    return true;

            if (checkAndSet(File.separator + "tmp"))
                return true;
            if (systmpWeird)
                if (checkAndSet(systmp))
                    return true;

            try {
                String hometmp = mergePaths(home(), ".tmp");
                File hometmpF = new File(hometmp);
                hometmpF.mkdirs();
                if (checkAndSet(hometmp))
                    return true;
            } catch (Exception e) {
                log.debug("TmpDirFinder: Cannot create tmp dir in user's home dir: " + e);
            }

            return false;
        }

        protected boolean checkAndSet(String candidate) {
            if (!check(candidate))
                return false;
            // seems okay
            tmpdir = candidate;
            log.debug("TmpDirFinder: Selected tmp dir '" + candidate + "' as the best tmp working space");
            return true;
        }

        protected boolean check(String candidate) {
            try {
                File f = new File(candidate);
                if (!f.exists()) {
                    log.debug("TmpDirFinder: Candidate tmp dir '" + candidate + "' does not exist");
                    return false;
                }
                if (!f.isDirectory()) {
                    log.debug("TmpDirFinder: Candidate tmp dir '" + candidate + "' is not a directory");
                    return false;
                }
                File f2 = new File(f, "brooklyn-tmp-check-" + Strings.makeRandomId(4));
                if (!f2.createNewFile()) {
                    log.debug("TmpDirFinder: Candidate tmp dir '" + candidate
                            + "' cannot have files created inside it (" + f2 + ")");
                    return false;
                }
                if (!f2.delete()) {
                    log.debug("TmpDirFinder: Candidate tmp dir '" + candidate
                            + "' cannot have files deleted inside it (" + f2 + ")");
                    return false;
                }

                return true;
            } catch (Exception e) {
                log.debug("TmpDirFinder: Candidate tmp dir '" + candidate + "' is not valid: " + e);
                return false;
            }
        }

        protected IllegalStateException newFailure(String message) {
            return new IllegalStateException(message);
        }
    }

    /** user name */
    public static String user() {
        return System.getProperty("user.name");
    }

    /** user's home directory */
    public static String home() {
        return System.getProperty("user.home");
    }

    /** merges paths using forward slash (unix way); 
     * now identical to {@link Os#mergePaths(String...)} but kept for contexts
     * where caller wants to indicate the target system should definitely be unix */
    public static String mergePathsUnix(String... items) {
        return Urls.mergePaths(items);
    }

    /** merges paths using forward slash as the "local OS file separator", because it is recognised on windows,
     * making paths more consistent and avoiding problems with backslashes being escaped */
    public static String mergePaths(String... items) {
        char separatorChar = '/';
        StringBuilder result = new StringBuilder();
        for (String item : items) {
            if (Strings.isEmpty(item))
                continue;
            if (result.length() > 0 && !isSeparator(result.codePointAt(result.length() - 1)))
                result.append(separatorChar);
            result.append(item);
        }
        return result.toString();
    }

    /** tries to delete a directory recursively;
     * use with care - see http://stackoverflow.com/questions/8320376/why-is-files-deletedirectorycontents-deprecated-in-guava.
     * <p>
     * also note this implementation refuses to delete / or ~ or anything else not passing {@link #checkSafe(File)}.
     * if you might really want to delete something like that, use {@link #deleteRecursively(File, boolean)}.
     */
    @Beta
    public static DeletionResult deleteRecursively(File dir) {
        return deleteRecursively(dir, false);
    }

    /** 
     * as {@link #deleteRecursively(File)} but includes safety checks to prevent deletion of / or ~
     * or anything else not passing {@link #checkSafe(File)}, unless the skipSafetyChecks parameter is set
     */
    @Beta
    public static DeletionResult deleteRecursively(File dir, boolean skipSafetyChecks) {
        if (dir == null)
            return new DeletionResult(null, true, null);

        try {
            if (!skipSafetyChecks)
                checkSafe(dir);

            FileUtils.deleteDirectory(dir);
            return new DeletionResult(dir, true, null);
        } catch (IllegalArgumentException e) {
            // See exception reported in https://issues.apache.org/jira/browse/BROOKLYN-72
            // If another thread is changing the contents of the directory at the same time as
            // we delete it, then can get this exception.
            return new DeletionResult(dir, false, e);
        } catch (IOException e) {
            return new DeletionResult(dir, false, e);
        }
    }

    /** fails if the dir is not "safe" for deletion, currently length <= 2 or the home directory */
    protected static void checkSafe(File dir) throws IOException {
        String dp = dir.getAbsolutePath();
        dp = Strings.removeFromEnd(dp, "/");
        if (dp.length() <= 2)
            throw new IOException("Refusing instruction to delete " + dir + ": name too short");

        if (Os.home().equals(dp))
            throw new IOException("Refusing instruction to delete " + dir + ": it's the home directory");
    }

    /**
     * @see {@link #deleteRecursively(File)}
     */
    @Beta
    public static DeletionResult deleteRecursively(String dir) {
        if (dir == null)
            return new DeletionResult(null, true, null);
        return deleteRecursively(new File(dir));
    }

    public static class DeletionResult {
        private final File file;
        private final boolean successful;
        private final Throwable throwable;

        public DeletionResult(File file, boolean successful, Throwable throwable) {
            this.file = file;
            this.successful = successful;
            this.throwable = throwable;
        }

        public boolean wasSuccessful() {
            return successful;
        }

        public DeletionResult throwIfFailed() {
            if (!successful)
                throw Exceptions.propagate(
                        new IOException("Unable to delete '" + file + "': delete returned false", throwable));
            return this;
        }

        public File getFile() {
            return file;
        }

        public Throwable getThrowable() {
            return throwable;
        }

        public <T> T asNullIgnoringError() {
            return null;
        }

        public <T> T asNullOrThrowing() {
            throwIfFailed();
            return null;
        }
    }

    private static class FileDeletionHook {
        public FileDeletionHook(File f, boolean recursively) {
            this.path = f;
            this.recursively = recursively;
        }

        final File path;
        final boolean recursively;

        public void run() throws IOException {
            if (path.exists()) {
                if (recursively && path.isDirectory()) {
                    Os.deleteRecursively(path);
                } else {
                    path.delete();
                }
            }
        }
    }

    private static final Map<String, FileDeletionHook> deletions = new LinkedHashMap<String, Os.FileDeletionHook>();

    private static void addShutdownFileDeletionHook(String path, FileDeletionHook hook) {
        synchronized (deletions) {
            if (deletions.isEmpty()) {
                Runtime.getRuntime().addShutdownHook(new Thread() {
                    @Override
                    public void run() {
                        synchronized (deletions) {
                            List<String> pathsToDelete = new ArrayList<String>(deletions.keySet());
                            Collections.sort(pathsToDelete, Strings.lengthComparator().reverse());
                            for (String path : pathsToDelete) {
                                try {
                                    deletions.remove(path).run();
                                } catch (Exception e) {
                                    log.warn("Unable to delete '" + path + "' on shutdown: " + e);
                                }
                            }
                        }
                    }
                });
            }
            FileDeletionHook oldHook = deletions.put(path, hook);
            if (oldHook != null && oldHook.recursively)
                // prefer any hook which is recursive
                deletions.put(path, oldHook);
        }
    }

    /** deletes the given file or empty directory on exit
     * <p>
     * similar to {@link File#deleteOnExit()} except it is smart about trying to delete longer filenames first
     * (and the shutdown hook order does not use proprietary java hooks)
     * <p>
     * note this does not delete non-empty directories; see {@link #deleteOnExitRecursively(File)} for that */
    public static void deleteOnExit(File directoryToDeleteIfEmptyOrFile) {
        addShutdownFileDeletionHook(directoryToDeleteIfEmptyOrFile.getAbsolutePath(),
                new FileDeletionHook(directoryToDeleteIfEmptyOrFile, false));
    }

    /** deletes the given file or directory and, in the case of directories, any contents;
     * similar to apache commons FileUtils.cleanDirectoryOnExit but corrects a bug in that implementation
     * which causes it to fail if content is added to that directory after the hook is registered */
    public static void deleteOnExitRecursively(File directoryToCleanOrFile) {
        addShutdownFileDeletionHook(directoryToCleanOrFile.getAbsolutePath(),
                new FileDeletionHook(directoryToCleanOrFile, true));
    }

    /** causes empty directories from subsubdir up to and including dir to be deleted on exit;
     * useful e.g. if we create  /tmp/brooklyn-test/foo/test1/  and someone else might create
     * /tmp/brooklyn-test/foo/test2/   and we'd like the last tear-down to result in /tmp/brooklyn-test  being deleted!
     * <p> 
     * returns number of directories queued for deletion so caller can check for errors if desired;
     * if dir is not an ancestor of subsubdir this logs a warning but does not throw  */
    public static int deleteOnExitEmptyParentsUpTo(File subsubDirOrFile, File dir) {
        if (subsubDirOrFile == null || dir == null)
            return 0;

        List<File> dirsToDelete = new ArrayList<File>();
        File d = subsubDirOrFile;
        do {
            dirsToDelete.add(d);
            if (d.equals(dir))
                break;
            d = d.getParentFile();
        } while (d != null);

        if (d == null) {
            log.warn("File " + subsubDirOrFile + " has no ancestor " + dir
                    + ": will not attempt to clean up with ancestors on exit");
            // dir is not an ancestor if subsubdir
            return 0;
        }

        for (File f : dirsToDelete)
            deleteOnExit(f);

        return dirsToDelete.size();
    }

    /** like {@link #deleteOnExitRecursively(File)} followed by {@link #deleteOnExitEmptyParentsUpTo(File, File)} */
    public static void deleteOnExitRecursivelyAndEmptyParentsUpTo(File directoryToCleanOrFile,
            File highestAncestorToDelete) {
        deleteOnExitRecursively(directoryToCleanOrFile);
        deleteOnExitEmptyParentsUpTo(directoryToCleanOrFile, highestAncestorToDelete);
    }

    /** as {@link File#mkdirs()} but throwing on failure and returning the directory made for fluent convenience */
    public static File mkdirs(File dir) {
        dir.mkdirs();
        if (dir.isDirectory()) {
            return dir;
        }
        throw Exceptions.propagate(
                new IOException("Failed to create directory " + dir + (dir.isFile() ? "(is file)" : "")));
    }

    /** writes given contents to a temporary file which will be deleted on exit */
    public static File writeToTempFile(InputStream is, String prefix, String suffix) {
        return writeToTempFile(is, new File(Os.tmp()), prefix, suffix);
    }

    /** writes given contents to a temporary file which will be deleted on exit, located under the given directory */
    public static File writeToTempFile(InputStream is, File tempDir, String prefix, String suffix) {
        Preconditions.checkNotNull(is, "Input stream required to create temp file for %s*%s", prefix, suffix);
        mkdirs(tempDir);
        File tempFile = newTempFile(prefix, suffix);
        OutputStream out = null;
        try {
            out = new FileOutputStream(tempFile);
            ByteStreams.copy(is, out);
        } catch (IOException e) {
            throw Throwables.propagate(e);
        } finally {
            Streams.closeQuietly(is);
            Streams.closeQuietly(out);
        }
        return tempFile;
    }

    public static File writePropertiesToTempFile(Properties props, String prefix, String suffix) {
        return writePropertiesToTempFile(props, new File(Os.tmp()), prefix, suffix);
    }

    public static File writePropertiesToTempFile(Properties props, File tempDir, String prefix, String suffix) {
        Preconditions.checkNotNull(props, "Properties required to create temp file for %s*%s", prefix, suffix);
        File tempFile;
        try {
            tempFile = File.createTempFile(prefix, suffix, tempDir);
        } catch (IOException e) {
            throw Throwables.propagate(e);
        }
        tempFile.deleteOnExit();

        OutputStream out = null;
        try {
            out = new FileOutputStream(tempFile);
            props.store(out, "Auto-generated by Brooklyn");
        } catch (IOException e) {
            throw Throwables.propagate(e);
        } finally {
            Streams.closeQuietly(out);
        }
        return tempFile;
    }

    /**
     * Tidy up a file path.
     * <p>
     * Removes duplicate or trailing path separators (Unix style forward
     * slashes only), replaces initial {@literal ~} with the
     * value of {@link #home()} and folds out use of {@literal ..} and
     * {@literal .} path segments.
     *
     * @see com.google.common.io.Files#simplifyPath(String)
     */
    public static String tidyPath(String path) {
        Preconditions.checkNotNull(path, "path");
        Iterable<String> segments = Splitter.on("/").split(Files.simplifyPath(path));
        if (Iterables.get(segments, 0).equals("~")) { // Always at least one segment after simplifyPath
            segments = Iterables.concat(ImmutableSet.of(Os.home()), Iterables.skip(segments, 1));
        }
        String result = Joiner.on("/").join(segments);
        if (log.isTraceEnabled() && !result.equals(path))
            log.trace("Quietly changing '{}' to '{}'", path, result);
        return result;
    }

    /**
     * Checks whether a file system path is absolute in a platform neutral way.
     * <p>
     * As a consequence of the platform neutrality some edge cases are
     * not handled correctly:
     * <ul>
     *  <li>On Windows relative paths starting with slash (either forward or backward) or ~ are treated as absolute.
     *  <li>On UNIX relative paths starting with X:/ are treated as absolute.
     * </ul>
     *
     * @param path A string representing a file system path.
     * @return whether the path is absolute under the above constraints.
     */
    public static boolean isAbsolutish(String path) {
        return path.codePointAt(0) == SEPARATOR_UNIX || path.equals("~") || path.startsWith("~" + SEPARATOR_UNIX)
                || path.length() >= 3 && path.codePointAt(1) == ':' && isSeparator(path.codePointAt(2));
    }

    /** @deprecated since 0.7.0, use {@link #isAbsolutish(String)} */
    @Deprecated
    public static boolean isAbsolute(String path) {
        return isAbsolutish(path);
    }

    private static boolean isSeparator(int sep) {
        return sep == SEPARATOR_UNIX || sep == SEPARATOR_WIN;
    }

    public static String fromHome(String path) {
        return new File(Os.home(), path).getAbsolutePath();
    }

    public static String nativePath(String path) {
        return new File(path).getPath();
    }

    public static boolean isMicrosoftWindows() {
        String os = System.getProperty("os.name").toLowerCase();
        //see org.apache.commons.lang.SystemUtils.IS_WINDOWS
        return os.startsWith("windows");
    }

    /** creates a private temp file which will be deleted on exit;
     * either prefix or ext may be null; 
     * if ext is non-empty and not > 4 chars and not starting with a ., then a dot will be inserted */
    public static File newTempFile(String prefix, String ext) {
        String sanitizedPrefix = (prefix != null ? prefix + "-" : "");
        String sanitizedExt = (ext != null ? ext.startsWith(".") || ext.length() > 4 ? ext : "." + ext : "");
        try {
            File tempFile = File.createTempFile(sanitizedPrefix, sanitizedExt, new File(tmp()));
            tempFile.deleteOnExit();
            return tempFile;
        } catch (IOException e) {
            throw Exceptions.propagate(e);
        }
    }

    /** as {@link #newTempFile(String, String)} using the class as the basis for a prefix */
    public static File newTempFile(Class<?> clazz, String ext) {
        return newTempFile(JavaClassNames.cleanSimpleClassName(clazz), ext);
    }

    /** creates a temp dir which will be deleted on exit */
    public static File newTempDir(String prefix) {
        String sanitizedPrefix = (prefix == null ? "" : prefix + "-");
        String tmpParent = tmp();

        //With lots of stale temp dirs it is possible to have 
        //name collisions so we need to retry until a unique 
        //name is found
        for (int i = 0; i < TEMP_DIR_ATTEMPTS; i++) {
            String baseName = sanitizedPrefix + Identifiers.makeRandomId(4);
            File tempDir = new File(tmpParent, baseName);
            if (!tempDir.exists()) {
                if (tempDir.mkdir()) {
                    Os.deleteOnExitRecursively(tempDir);
                    return tempDir;
                } else {
                    log.warn("Attempt to create temp dir failed " + tempDir
                            + ". Either an IO error (disk full, no rights) or someone else created the folder after the !exists() check.");
                }
            } else {
                log.debug("Attempt to create temp dir failed, already exists " + tempDir
                        + ". With ID of length 4 it is not unusual (15% chance) to have duplicate names at the 2000 samples mark.");
            }
        }
        throw new IllegalStateException("cannot create temporary folders in parent " + tmpParent + " after "
                + TEMP_DIR_ATTEMPTS + " attempts.");
    }

    /** as {@link #newTempDir(String)}, using the class as the basis for a prefix */
    public static File newTempDir(Class<?> clazz) {
        return newTempDir(JavaClassNames.cleanSimpleClassName(clazz));
    }

}