AbstractFileSystemService.java

/*
 *   Copyright 2006-2018 University of Dundee. All rights reserved.
 *   Use is subject to license terms supplied in LICENSE.txt
 */

package ome.io.nio;

import java.io.File;
import java.nio.file.Paths;
import java.util.Formatter;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @author callan
 * 
 */
public class AbstractFileSystemService {

    /** The logger for this particular class */
    private static Logger log = LoggerFactory.getLogger(AbstractFileSystemService.class);

    public final static String ROOT_DEFAULT = File.separator + "OMERO"
            + File.separator;

    public final static String PIXELS_PATH = "Pixels" + File.separator;

    public final static String FILES_PATH = "Files" + File.separator;

    public final static String THUMBNAILS_PATH = "Thumbnails" + File.separator;

    private final String root;

    @Deprecated
    public AbstractFileSystemService(String path) {
        this(path, false);
        log.info("assuming read-write repository at " + path);
    }

    public AbstractFileSystemService(String path, boolean isReadOnlyRepo) {
        File rootDirectory = new File(path);
        if (!rootDirectory.isDirectory() || !rootDirectory.canRead()
                || !(isReadOnlyRepo || rootDirectory.canWrite())) {
            throw new IllegalArgumentException(
                    "Invalid directory specified for file system service."
		    + rootDirectory);
        }

        this.root = rootDirectory.getAbsolutePath();
        if (log.isDebugEnabled()) {
            log.debug("Using root path: '" + this.root + "'");
        }
    }

    /**
     * Makes sure that for a given path, its subpath exists. For example, given
     * the path "/foo/bar/foobar.txt" the method will make sure the directory
     * structure "/foo/bar" exists.
     *
     * @param path
     *            the path to check for subpath existence.
     */
    protected void createSubpath(String path) {
        File file = new File(path);
        if (!file.exists()) {
            File directory = new File(file.getParent());
            if (!directory.exists()) {
                directory.mkdirs();
            }
        }
    }

    /**
     * Returns a numbered path relative to the root of this service, but is
     * ignorant of FS and similar constructs. For example, this will return
     * "ROOT/Pixels/"
     *
     * @return the path relative to the root
     */
    public String getPixelsDirectory() {
        return Paths.get(root, PIXELS_PATH).toString();
    }

    /**
     * Returns a numbered path relative to the root of this service, but is
     * ignorant of FS and similar constructs. For example, given an id of
     * 12345 this will return "ROOT/Pixels/Dir-123/Dir-456/123456"
     *
     * @param id   the Pixels identifier
     * @return     the path relative to the root
     */
    public String getPixelsPath(Long id) {
        return getPath(PIXELS_PATH, id);
    }

    /**
     * Returns a numbered path relative to the root of this service, but is
     * ignorant of FS and similar constructs. For example, given an id of
     * 123456 this will return "ROOT/Files/Dir-123/Dir-456/123456"
     *
     * @param id   the Files identifier
     * @return     the path relative to the root
     */
    public String getFilesPath(Long id) {
        return getPath(FILES_PATH, id);
    }

    /**
     * Returns a numbered path relative to the root of this service, but is
     * ignorant of FS and similar constructs. For example, given an id of
     * 123456 this will return "ROOT/Thumbnails/Dir-123/Dir-456/123456"
     *
     * @param id     the thumbnail identifier
     * @return       the path relative to the root
     */
    public String getThumbnailPath(Long id) {
        return getPath(THUMBNAILS_PATH, id);
    }

    private String getPath(String prefix, Long id) {
        String suffix = "";
        Long remaining = id;
        Long dirno = 0L;

        if (id == null) {
            throw new NullPointerException("Expecting a not-null id.");
        }

        while (remaining > 999) {
            remaining /= 1000;

            if (remaining > 0) {
                try (final Formatter formatter = new Formatter()) {
                    dirno = remaining % 1000;
                    suffix = formatter.format("Dir-%03d", dirno).out().toString()
                            + File.separator + suffix;
                }
            }
        }
        return Paths.get(root, prefix + suffix + id).toString();
    }
}