com.palantir.giraffe.file.base.CachingBaseFileSystemProvider Maven / Gradle / Ivy
/**
* Copyright 2015 Palantir Technologies, Inc.
*
* 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.palantir.giraffe.file.base;
import java.io.IOException;
import java.net.URI;
import java.nio.file.FileSystem;
import java.nio.file.FileSystemAlreadyExistsException;
import java.nio.file.FileSystemNotFoundException;
import java.util.Map;
import java.util.concurrent.ExecutionException;
/**
* A {@link BaseFileSystemProvider} that caches created file systems, allowing
* at most one open file system for a given URI at a time. A new file system can
* be created for a given URI after the previous one is closed.
*
* @author bkeyes
*
* @param the type of path used by the provider's file systems
*/
public abstract class CachingBaseFileSystemProvider
> extends
BaseFileSystemProvider
{
private final SystemCache> cache = new SystemCache<>();
protected CachingBaseFileSystemProvider(Class pathClass) {
super(pathClass);
}
@Override
public final FileSystem newFileSystem(final URI uri, final Map env)
throws IOException {
Object key = uriToCacheKey(checkUri(uri));
BaseFileSystem fs = cache.init(key, new SystemCache.Factory>() {
@Override
public BaseFileSystem newSystem() throws IOException {
return openFileSystem(uri, env);
}
});
if (fs != null) {
return fs;
} else {
throw new FileSystemAlreadyExistsException();
}
}
/**
* Creates a new, open file system. The file system returned by this method
* is cached until it is closed.
*
* @param uri a valid file system URI
* @param env a possible empty map of provider specific properties
*
* @return a new file system
*
* @throws IllegalArgumentException if {@code env} does the contain require
* properties or if a property value is invalid
* @throws IOException if an I/O error occurs creating the file system
*/
protected abstract BaseFileSystem
openFileSystem(URI uri, Map env)
throws IOException;
@Override
public final FileSystem getFileSystem(URI uri) {
Object key = uriToCacheKey(checkUri(uri));
FileSystem fs = null;
try {
fs = cache.get(key);
} catch (ExecutionException e) {
// the actual error is reported in the thread calling newFileSystem
throw new FileSystemNotFoundException(uri.toString() + " (creation error)");
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new FileSystemNotFoundException(uri.toString() + " (interruption)");
}
if (fs == null) {
throw new FileSystemNotFoundException(uri.toString());
} else {
return fs;
}
}
@Override
void fileSystemClosed(BaseFileSystem fileSystem) {
cache.remove(uriToCacheKey(fileSystem.uri()));
}
/**
* Checks that {@code uri} is a valid URI for a file system from this
* provider.
*
* @param uri the URI to check
*
* @return the given URI
*
* @throws IllegalArgumentException if the URI is invalid
*/
protected abstract URI checkUri(URI uri);
/**
* Converts {@code uri} into a cache key. By default, this method returns
* the given URI.
*/
protected Object uriToCacheKey(URI uri) {
return uri;
}
}