org.jboss.shrinkwrap.impl.nio.file.ShrinkWrapFileSystem Maven / Gradle / Ivy

Go to download
/*
 * JBoss, Home of Professional Open Source
 * Copyright 2012, Red Hat Middleware LLC, and individual contributors
 * by the @authors tag. See the copyright.txt in the distribution for a
 * full listing of individual contributors.
 *
 * 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 org.jboss.shrinkwrap.impl.nio.file;

import java.io.IOException;
import java.nio.file.ClosedFileSystemException;
import java.nio.file.FileStore;
import java.nio.file.FileSystem;
import java.nio.file.Path;
import java.nio.file.PathMatcher;
import java.nio.file.WatchService;
import java.nio.file.attribute.BasicFileAttributeView;
import java.nio.file.attribute.UserPrincipalLookupService;
import java.nio.file.spi.FileSystemProvider;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.jboss.shrinkwrap.api.Archive;
import org.jboss.shrinkwrap.api.ArchivePath;
import org.jboss.shrinkwrap.api.ArchivePaths;

/**
 * ShrinkWrap implementation adapting a {@link Archive} to a {@link FileSystem}; Thread-safe, though access to the
 * underlying {@link Archive} is *not*.
 *
 * @author Andrew Lee Rubinger
 */
public class ShrinkWrapFileSystem extends FileSystem {

    /**
     * Contracted name of the {@link BasicFileAttributeView}
     */
    static final String FILE_ATTR_VIEW_BASIC = "basic";

    /**
     * Provider which created this {@link ShrinkWrapFileSystem}
     */
    private final ShrinkWrapFileSystemProvider provider;

    /**
     * Underlying {@link Archive}
     */
    private final Archive archive;

    private final List fileStores;

    /**
     * Whether or not this FS is open; volatile as we don't need compound operations and thus don't need full sync
     */
    private volatile boolean open;

    public ShrinkWrapFileSystem(final ShrinkWrapFileSystemProvider provider, final Archive archive) {
        this.provider = provider;
        this.archive = archive;
        this.open = true;
        // Each ShrinkWrapFileSystem has one file store
        final FileStore store = new ShrinkWrapFileStore(this.archive);
        final List stores = new ArrayList<>(1);
        stores.add(store);
        this.fileStores = Collections.unmodifiableList(stores);
    }

    /**
     * {@inheritDoc}
     *
     * @see java.nio.file.FileSystem#provider()
     */
    @Override
    public FileSystemProvider provider() {
        return provider;
    }

    /**
     * {@inheritDoc}
     *
     * @see java.nio.file.FileSystem#close()
     */
    @Override
    public void close() throws IOException {
        this.open = false;
    }

    /**
     * {@inheritDoc}
     *
     * @see java.nio.file.FileSystem#isOpen()
     */
    @Override
    public boolean isOpen() {
        return this.open;
    }

    /**
     * {@inheritDoc}
     *
     * @see java.nio.file.FileSystem#isReadOnly()
     */
    @Override
    public boolean isReadOnly() {
        return false;
    }

    /**
     * {@inheritDoc}
     *
     * @see java.nio.file.FileSystem#getSeparator()
     */
    @Override
    public String getSeparator() {
        return ArchivePath.SEPARATOR_STRING;
    }

    /**
     * {@inheritDoc}
     *
     * @see java.nio.file.FileSystem#getRootDirectories()
     */
    @Override
    public Iterable getRootDirectories() {

        this.checkClosed();

        // Each ShrinkWrapFileSystem has one root directory
        final Path path = new ShrinkWrapPath(ArchivePaths.root(), this);
        final List paths = new ArrayList<>(1);
        paths.add(path);
        return Collections.unmodifiableList(paths);
    }

    /**
     * {@inheritDoc}
     *
     * @see java.nio.file.FileSystem#getFileStores()
     */
    @Override
    public Iterable getFileStores() {

        this.checkClosed();

        return this.fileStores;
    }

    /**
     * {@inheritDoc}
     *
     * @see java.nio.file.FileSystem#supportedFileAttributeViews()
     */
    @Override
    public Set supportedFileAttributeViews() {

        this.checkClosed();

        final Set names = new HashSet<>(1);
        // Required by spec
        names.add(FILE_ATTR_VIEW_BASIC);
        return Collections.unmodifiableSet(names);
    }

    /**
     * {@inheritDoc}
     *
     * @see java.nio.file.FileSystem#getPath(java.lang.String, java.lang.String[])
     */
    @Override
    public Path getPath(final String first, final String... more) {

        this.checkClosed();

        if (first == null) {
            throw new IllegalArgumentException("At least one path component must be specified");
        }

        final String merged = this.merge(first, more);
        final Path path = new ShrinkWrapPath(merged, this);

        return path;
    }

    /**
     * Merges the path context with a varargs String sub-contexts, returning the result
     *
     * @param first
     * @param more
     * @return
     */
    private String merge(final String first, final String[] more) {
        assert first != null : "first must be specified";
        assert more != null : "more must be specified";

        final StringBuilder merged = new StringBuilder();
        merged.append(first);
        for (int i = 0; i < more.length; i++) {
            merged.append(ArchivePath.SEPARATOR);
            merged.append(more[i]);
        }
        return merged.toString();

    }

    /*
     * (non-Javadoc)
     *
     * @see java.nio.file.FileSystem#getPathMatcher(java.lang.String)
     */
    @Override
    public PathMatcher getPathMatcher(final String syntaxAndPattern) {

        this.checkClosed();

        // TODO Is there some matcher we can reuse?
        throw new UnsupportedOperationException("ShrinkWrap archives do not support Path Matcher operations");
    }

    /**
     * {@inheritDoc}
     *
     * @see java.nio.file.FileSystem#getUserPrincipalLookupService()
     */
    @Override
    public UserPrincipalLookupService getUserPrincipalLookupService() {
        throw new UnsupportedOperationException("ShrinkWrap archives do not support file ownership.");
    }

    /**
     * {@inheritDoc}
     *
     * @see java.nio.file.FileSystem#newWatchService()
     */
    @Override
    public WatchService newWatchService() throws IOException {
        throw new UnsupportedOperationException("ShrinkWrap archives do not support a "
            + WatchService.class.getSimpleName() + ".");
    }

    /**
     * {@inheritDoc}
     *
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        return this.getClass().getSimpleName() + " with mounted archive: " + archive.toString();
    }

    /**
     * Checks if the {@link ShrinkWrapFileSystem} is closed, and throws a {@link ClosedFileSystemException} if so
     *
     * @throws ClosedFileSystemException
     */
    private void checkClosed() throws ClosedFileSystemException {
        // Check closed?
        if (!this.isOpen()) {
            throw new ClosedFileSystemException();
        }
    }

    /**
     * Obtains the underlying archive
     */
    Archive getArchive() {
        return this.archive;
    }

}