Java tutorial
/* * 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 org.apache.commons.vfs.impl; import java.io.File; import java.net.URLStreamHandler; import java.net.URLStreamHandlerFactory; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import java.lang.reflect.Constructor; import org.apache.commons.logging.Log; import org.apache.commons.vfs.CacheStrategy; import org.apache.commons.vfs.FileContentInfoFactory; import org.apache.commons.vfs.FileName; import org.apache.commons.vfs.FileObject; import org.apache.commons.vfs.FileSystem; import org.apache.commons.vfs.FileSystemConfigBuilder; import org.apache.commons.vfs.FileSystemException; import org.apache.commons.vfs.FileSystemManager; import org.apache.commons.vfs.FileSystemOptions; import org.apache.commons.vfs.FileType; import org.apache.commons.vfs.FilesCache; import org.apache.commons.vfs.NameScope; import org.apache.commons.vfs.VFS; import org.apache.commons.vfs.cache.SoftRefFilesCache; import org.apache.commons.vfs.operations.FileOperationProvider; import org.apache.commons.vfs.provider.AbstractFileName; import org.apache.commons.vfs.provider.AbstractFileProvider; import org.apache.commons.vfs.provider.DefaultURLStreamHandler; import org.apache.commons.vfs.provider.FileProvider; import org.apache.commons.vfs.provider.FileReplicator; import org.apache.commons.vfs.provider.LocalFileProvider; import org.apache.commons.vfs.provider.TemporaryFileStore; import org.apache.commons.vfs.provider.UriParser; import org.apache.commons.vfs.provider.VfsComponent; /** * A default file system manager implementation. * * @author <a href="mailto:adammurdoch@apache.org">Adam Murdoch</a> * @version $Revision$ $Date: 2006-03-30 21:16:24 +0200 (Do, 30 Mrz * 2006) $ */ public class DefaultFileSystemManager implements FileSystemManager { /** * The provider for local files. */ private LocalFileProvider localFileProvider; /** * The default provider. */ private FileProvider defaultProvider; /** * The file replicator to use. */ private FileReplicator fileReplicator; /** * Mapping from URI scheme to FileProvider. */ private final Map providers = new HashMap(); /** * All components used by this manager. */ private final ArrayList components = new ArrayList(); /** * The base file to use for relative URI. */ private FileObject baseFile; /** * The files cache */ private FilesCache filesCache; /** * The cache strategy */ private CacheStrategy fileCacheStrategy; /** * Class which decorates all returned fileObjects */ private Class fileObjectDecorator; private Constructor fileObjectDecoratorConst; /** * The class to use to determine the content-type (mime-type) */ private FileContentInfoFactory fileContentInfoFactory; /** * The logger to use. */ private Log log; /** * The context to pass to providers. */ private final DefaultVfsComponentContext context = new DefaultVfsComponentContext(this); private TemporaryFileStore tempFileStore; private final FileTypeMap map = new FileTypeMap(); private final VirtualFileProvider vfsProvider = new VirtualFileProvider(); private boolean init; /** * Returns the logger used by this manager. */ protected Log getLogger() { return log; } /** * Registers a file system provider. The manager takes care of all lifecycle * management. A provider may be registered multiple times. * * @param urlScheme * The scheme the provider will handle. * @param provider * The provider. */ public void addProvider(final String urlScheme, final FileProvider provider) throws FileSystemException { addProvider(new String[] { urlScheme }, provider); } /** * Registers a file system provider. The manager takes care of all lifecycle * management. A provider may be registered multiple times. * * @param urlSchemes * The schemes the provider will handle. * @param provider * The provider. */ public void addProvider(final String[] urlSchemes, final FileProvider provider) throws FileSystemException { // Warn about duplicate providers for (int i = 0; i < urlSchemes.length; i++) { final String scheme = urlSchemes[i]; if (providers.containsKey(scheme)) { throw new FileSystemException("vfs.impl/multiple-providers-for-scheme.error", scheme); } } // Contextualise the component (if not already) setupComponent(provider); // Add to map for (int i = 0; i < urlSchemes.length; i++) { final String scheme = urlSchemes[i]; providers.put(scheme, provider); } if (provider instanceof LocalFileProvider) { localFileProvider = (LocalFileProvider) provider; } } /** * Returns true if this manager has a provider for a particular scheme. */ public boolean hasProvider(final String scheme) { return providers.containsKey(scheme); } /** * Adds an filename extension mapping. * * @param extension * The file name extension. * @param scheme * The scheme to use for files with this extension. */ public void addExtensionMap(final String extension, final String scheme) { map.addExtension(extension, scheme); } /** * Adds a mime type mapping. * * @param mimeType * The mime type. * @param scheme * The scheme to use for files with this mime type. */ public void addMimeTypeMap(final String mimeType, final String scheme) { map.addMimeType(mimeType, scheme); } /** * Sets the default provider. This is the provider that will handle URI with * unknown schemes. The manager takes care of all lifecycle management. */ public void setDefaultProvider(final FileProvider provider) throws FileSystemException { setupComponent(provider); defaultProvider = provider; } /** * Returns the filesCache implementation used to cache files */ public FilesCache getFilesCache() { return filesCache; } /** * Sets the filesCache implementation used to cache files */ public void setFilesCache(final FilesCache filesCache) throws FileSystemException { if (init) { throw new FileSystemException("vfs.impl/already-inited.error"); } this.filesCache = filesCache; } /** * <p> * Set the cache strategy to use when dealing with file object data. You can * set it only once before the FileSystemManager is initialized. * <p /> * <p> * The default is {@link CacheStrategy#ON_RESOLVE} * </p> * * @throws FileSystemException * if this is not possible. e.g. it is already set. */ public void setCacheStrategy(final CacheStrategy fileCacheStrategy) throws FileSystemException { if (init) { throw new FileSystemException("vfs.impl/already-inited.error"); } this.fileCacheStrategy = fileCacheStrategy; } /** * Get the cache strategy used */ public CacheStrategy getCacheStrategy() { return fileCacheStrategy; } /** * Get the file object decorator used */ public Class getFileObjectDecorator() { return fileObjectDecorator; } /** * The constructor associated to the fileObjectDecorator. * We cache it here for performance reasons. */ public Constructor getFileObjectDecoratorConst() { return fileObjectDecoratorConst; } /** * set a fileObject decorator to be used for ALL returned file objects * * @param fileObjectDecorator must be inherted from {@link DecoratedFileObject} a has to provide a * constructor with a single {@link FileObject} as argument */ public void setFileObjectDecorator(Class fileObjectDecorator) throws FileSystemException { if (init) { throw new FileSystemException("vfs.impl/already-inited.error"); } if (!DecoratedFileObject.class.isAssignableFrom(fileObjectDecorator)) { throw new FileSystemException("vfs.impl/invalid-decorator.error", fileObjectDecorator.getName()); } try { fileObjectDecoratorConst = fileObjectDecorator.getConstructor(new Class[] { FileObject.class }); } catch (NoSuchMethodException e) { throw new FileSystemException("vfs.impl/invalid-decorator.error", fileObjectDecorator.getName(), e); } this.fileObjectDecorator = fileObjectDecorator; } /** * get the fileContentInfoFactory used to determine the infos of a file * content. */ public FileContentInfoFactory getFileContentInfoFactory() { return fileContentInfoFactory; } /** * set the fileContentInfoFactory used to determine the infos of a file * content. */ public void setFileContentInfoFactory(FileContentInfoFactory fileContentInfoFactory) throws FileSystemException { if (init) { throw new FileSystemException("vfs.impl/already-inited.error"); } this.fileContentInfoFactory = fileContentInfoFactory; } /** * Sets the file replicator to use. The manager takes care of all lifecycle * management. */ public void setReplicator(final FileReplicator replicator) throws FileSystemException { setupComponent(replicator); fileReplicator = replicator; } /** * Sets the temporary file store to use. The manager takes care of all * lifecycle management. */ public void setTemporaryFileStore(final TemporaryFileStore tempFileStore) throws FileSystemException { setupComponent(tempFileStore); this.tempFileStore = tempFileStore; } /** * Sets the logger to use. */ public void setLogger(final Log log) { this.log = log; } /** * Initialises a component, if it has not already been initialised. */ private void setupComponent(final Object component) throws FileSystemException { if (!components.contains(component)) { if (component instanceof VfsComponent) { final VfsComponent vfsComponent = (VfsComponent) component; vfsComponent.setLogger(getLogger()); vfsComponent.setContext(context); vfsComponent.init(); } components.add(component); } } /** * Closes a component, if it has not already been closed. */ private void closeComponent(final Object component) { if (component != null && components.contains(component)) { if (component instanceof VfsComponent) { final VfsComponent vfsComponent = (VfsComponent) component; vfsComponent.close(); } components.remove(component); } } /** * Returns the file replicator. * * @return The file replicator. Never returns null. */ public FileReplicator getReplicator() throws FileSystemException { if (fileReplicator == null) { throw new FileSystemException("vfs.impl/no-replicator.error"); } return fileReplicator; } /** * Returns the temporary file store. * * @return The file store. Never returns null. */ public TemporaryFileStore getTemporaryFileStore() throws FileSystemException { if (tempFileStore == null) { throw new FileSystemException("vfs.impl/no-temp-file-store.error"); } return tempFileStore; } /** * Initialises this manager. */ public void init() throws FileSystemException { if (filesCache == null) { // filesCache = new DefaultFilesCache(); filesCache = new SoftRefFilesCache(); } if (fileContentInfoFactory == null) { fileContentInfoFactory = new FileContentInfoFilenameFactory(); } if (fileCacheStrategy == null) { fileCacheStrategy = CacheStrategy.ON_RESOLVE; } setupComponent(filesCache); setupComponent(vfsProvider); init = true; } /** * Closes all files created by this manager, and cleans up any temporary * files. Also closes all providers and the replicator. */ public void close() { if (!init) { return; } // Close the providers. for (Iterator iterator = providers.values().iterator(); iterator.hasNext();) { final Object provider = iterator.next(); closeComponent(provider); } // Close the other components closeComponent(defaultProvider); closeComponent(fileReplicator); closeComponent(tempFileStore); components.clear(); providers.clear(); filesCache.close(); localFileProvider = null; defaultProvider = null; fileReplicator = null; tempFileStore = null; init = false; } /** * Free all resources used by unused filesystems created by this manager. */ public void freeUnusedResources() { if (!init) { return; } // Close the providers. for (Iterator iterator = providers.values().iterator(); iterator.hasNext();) { final AbstractFileProvider provider = (AbstractFileProvider) iterator.next(); provider.freeUnusedResources(); } } /** * Sets the base file to use when resolving relative URI. */ // public void setBaseFile(final FileObject baseFile) public void setBaseFile(final FileObject baseFile) throws FileSystemException { this.baseFile = baseFile; } /** * Sets the base file to use when resolving relative URI. */ public void setBaseFile(final File baseFile) throws FileSystemException { this.baseFile = getLocalFileProvider().findLocalFile(baseFile); } /** * Returns the base file used to resolve relative URI. */ public FileObject getBaseFile() throws FileSystemException { return baseFile; } /** * Locates a file by URI. */ public FileObject resolveFile(final String uri) throws FileSystemException { // return resolveFile(baseFile, uri); return resolveFile(getBaseFile(), uri); } /** * Locate a file by URI, use the FileSystemOptions for file-system creation */ public FileObject resolveFile(final String uri, final FileSystemOptions fileSystemOptions) throws FileSystemException { // return resolveFile(baseFile, uri, fileSystemOptions); return resolveFile(getBaseFile(), uri, fileSystemOptions); } /** * Locates a file by URI. */ public FileObject resolveFile(final File baseFile, final String uri) throws FileSystemException { final FileObject baseFileObj = getLocalFileProvider().findLocalFile(baseFile); return resolveFile(baseFileObj, uri); } /** * Resolves a URI, relative to a base file. */ public FileObject resolveFile(final FileObject baseFile, final String uri) throws FileSystemException { return resolveFile(baseFile, uri, baseFile == null ? null : baseFile.getFileSystem().getFileSystemOptions()); } /** * Resolves a URI, realtive to a base file with specified FileSystem * configuration */ public FileObject resolveFile(final FileObject baseFile, final String uri, final FileSystemOptions fileSystemOptions) throws FileSystemException { final FileObject realBaseFile; if (baseFile != null && VFS.isUriStyle() && baseFile.getName().getType() == FileType.FILE) { realBaseFile = baseFile.getParent(); } else { realBaseFile = baseFile; } // TODO: use resolveName and use this name to resolve the fileObject UriParser.checkUriEncoding(uri); if (uri == null) { throw new IllegalArgumentException(); } // Extract the scheme final String scheme = UriParser.extractScheme(uri); if (scheme != null) { // An absolute URI - locate the provider final FileProvider provider = (FileProvider) providers.get(scheme); if (provider != null) { return provider.findFile(realBaseFile, uri, fileSystemOptions); } // Otherwise, assume a local file } // Handle absolute file names if (localFileProvider != null && localFileProvider.isAbsoluteLocalName(uri)) { return localFileProvider.findLocalFile(uri); } if (scheme != null) { // An unknown scheme - hand it to the default provider if (defaultProvider == null) { throw new FileSystemException("vfs.impl/unknown-scheme.error", new Object[] { scheme, uri }); } return defaultProvider.findFile(realBaseFile, uri, fileSystemOptions); } // Assume a relative name - use the supplied base file if (realBaseFile == null) { throw new FileSystemException("vfs.impl/find-rel-file.error", uri); } return realBaseFile.resolveFile(uri); } /** * Resolves a name, relative to the file. If the supplied name is an * absolute path, then it is resolved relative to the root of the file * system that the file belongs to. If a relative name is supplied, then it * is resolved relative to this file name. */ public FileName resolveName(final FileName root, final String path) throws FileSystemException { return resolveName(root, path, NameScope.FILE_SYSTEM); } /** * Resolves a name, relative to the root. * * @param base * the base filename * @param name * the name * @param scope * the {@link NameScope} * @throws FileSystemException */ public FileName resolveName(final FileName base, final String name, final NameScope scope) throws FileSystemException { final FileName realBase; if (base != null && VFS.isUriStyle() && base.getType() == FileType.FILE) { realBase = base.getParent(); } else { realBase = base; } final StringBuffer buffer = new StringBuffer(name); // Adjust separators UriParser.fixSeparators(buffer); // Determine whether to prepend the base path if (name.length() == 0 || name.charAt(0) != FileName.SEPARATOR_CHAR) { // Supplied path is not absolute if (!VFS.isUriStyle()) { // when using uris the parent already do have the trailing "/" buffer.insert(0, FileName.SEPARATOR_CHAR); } buffer.insert(0, realBase.getPath()); } // // UriParser.canonicalizePath(buffer, 0, name.length()); // Normalise the path FileType fileType = UriParser.normalisePath(buffer); // Check the name is ok final String resolvedPath = buffer.toString(); if (!AbstractFileName.checkName(realBase.getPath(), resolvedPath, scope)) { throw new FileSystemException("vfs.provider/invalid-descendent-name.error", name); } String scheme = realBase.getScheme(); String fullPath = realBase.getRootURI() + resolvedPath; final FileProvider provider = (FileProvider) providers.get(scheme); if (provider != null) { // todo: extend the filename parser to be able to parse // only a pathname and take the missing informations from // the base. Then we can get rid of the string operation. // // String fullPath = base.getRootURI() + // resolvedPath.substring(1); return provider.parseUri(realBase, fullPath); } if (scheme != null) { // An unknown scheme - hand it to the default provider - if possible if (defaultProvider != null) { return defaultProvider.parseUri(realBase, fullPath); } } // todo: avoid fallback to this point // this happens if we have a virtual filesystem (no provider for scheme) return ((AbstractFileName) realBase).createName(resolvedPath, fileType); } /** * resolve the uri to a filename * * @throws FileSystemException */ public FileName resolveURI(String uri) throws FileSystemException { UriParser.checkUriEncoding(uri); if (uri == null) { throw new IllegalArgumentException(); } // Extract the scheme final String scheme = UriParser.extractScheme(uri); if (scheme != null) { // An absolute URI - locate the provider final FileProvider provider = (FileProvider) providers.get(scheme); if (provider != null) { return provider.parseUri(null, uri); } // Otherwise, assume a local file } // Handle absolute file names if (localFileProvider != null && localFileProvider.isAbsoluteLocalName(uri)) { return localFileProvider.parseUri(null, uri); } if (scheme != null) { // An unknown scheme - hand it to the default provider if (defaultProvider == null) { throw new FileSystemException("vfs.impl/unknown-scheme.error", new Object[] { scheme, uri }); } return defaultProvider.parseUri(null, uri); } // Assume a relative name - use the supplied base file if (baseFile == null) { throw new FileSystemException("vfs.impl/find-rel-file.error", uri); } return resolveName(baseFile.getName(), uri, NameScope.FILE_SYSTEM); } /** * Converts a local file into a {@link FileObject}. */ public FileObject toFileObject(final File file) throws FileSystemException { return getLocalFileProvider().findLocalFile(file); } /** * Creates a layered file system. */ public FileObject createFileSystem(final String scheme, final FileObject file) throws FileSystemException { final FileProvider provider = (FileProvider) providers.get(scheme); if (provider == null) { throw new FileSystemException("vfs.impl/unknown-provider.error", new Object[] { scheme, file }); } return provider.createFileSystem(scheme, file, file.getFileSystem().getFileSystemOptions()); } /** * Creates a layered file system. */ public FileObject createFileSystem(final FileObject file) throws FileSystemException { final String scheme = map.getScheme(file); if (scheme == null) { throw new FileSystemException("vfs.impl/no-provider-for-file.error", file); } return createFileSystem(scheme, file); } /** * Determines if a layered file system can be created for a given file. * * @param file * The file to check for. */ public boolean canCreateFileSystem(final FileObject file) throws FileSystemException { return (map.getScheme(file) != null); } /** * Creates a virtual file system. */ public FileObject createVirtualFileSystem(final FileObject rootFile) throws FileSystemException { return vfsProvider.createFileSystem(rootFile); } /** * Creates an empty virtual file system. */ public FileObject createVirtualFileSystem(final String rootUri) throws FileSystemException { return vfsProvider.createFileSystem(rootUri); } /** * Locates the local file provider. */ private LocalFileProvider getLocalFileProvider() throws FileSystemException { if (localFileProvider == null) { throw new FileSystemException("vfs.impl/no-local-file-provider.error"); } return localFileProvider; } /** * Get the URLStreamHandlerFactory. */ public URLStreamHandlerFactory getURLStreamHandlerFactory() { return new VfsStreamHandlerFactory(); } /** * Closes the given filesystem.<br /> * If you use VFS as singleton it is VERY dangerous to call this method */ public void closeFileSystem(FileSystem filesystem) { // inform the cache ... getFilesCache().clear(filesystem); // just in case the cache didnt call _closeFileSystem _closeFileSystem(filesystem); } /** * Closes the given filesystem.<br /> * If you use VFS as singleton it is VERY dangerous to call this method */ public void _closeFileSystem(FileSystem filesystem) { FileProvider provider = (FileProvider) providers.get(filesystem.getRootName().getScheme()); if (provider != null) { ((AbstractFileProvider) provider).closeFileSystem(filesystem); } } /** * This is an internal class because it needs access to the private member * providers. */ final class VfsStreamHandlerFactory implements URLStreamHandlerFactory { public URLStreamHandler createURLStreamHandler(final String protocol) { FileProvider provider = (FileProvider) providers.get(protocol); if (provider != null) { return new DefaultURLStreamHandler(context); } // Route all other calls to the default URLStreamHandlerFactory return new URLStreamHandlerProxy(); } } /** * Get the schemes currently available. */ public String[] getSchemes() { String[] schemes = new String[providers.size()]; providers.keySet().toArray(schemes); return schemes; } /** * Get the capabilities for a given scheme. * * @throws FileSystemException * if the given scheme is not konwn */ public Collection getProviderCapabilities(final String scheme) throws FileSystemException { FileProvider provider = (FileProvider) providers.get(scheme); if (provider == null) { throw new FileSystemException("vfs.impl/unknown-scheme.error", new Object[] { scheme }); } return provider.getCapabilities(); } /** * Get the configuration builder for the given scheme * * @throws FileSystemException * if the given scheme is not konwn */ public FileSystemConfigBuilder getFileSystemConfigBuilder(final String scheme) throws FileSystemException { FileProvider provider = (FileProvider) providers.get(scheme); if (provider == null) { throw new FileSystemException("vfs.impl/unknown-scheme.error", new Object[] { scheme }); } return provider.getConfigBuilder(); } // -- OPERATIONS -- private final Map operationProviders = new HashMap(); /** * Adds the specified FileOperationProvider for the specified scheme. * Several FileOperationProvider's might be registered for the same scheme. * For example, for "file" scheme we can register SvnWsOperationProvider and * CvsOperationProvider. * * @param scheme * @param operationProvider * @throws FileSystemException */ public void addOperationProvider(final String scheme, final FileOperationProvider operationProvider) throws FileSystemException { addOperationProvider(new String[] { scheme }, operationProvider); } /** * @see FileSystemManager#addOperationProvider(String, * org.apache.commons.vfs.operations.FileOperationProvider) * * @param schemes * @param operationProvider * @throws FileSystemException */ public void addOperationProvider(final String[] schemes, final FileOperationProvider operationProvider) throws FileSystemException { for (int i = 0; i < schemes.length; i++) { final String scheme = schemes[i]; if (!operationProviders.containsKey(scheme)) { final List providers = new ArrayList(); operationProviders.put(scheme, providers); } final List providers = (List) operationProviders.get(scheme); if (providers.contains(operationProvider)) { throw new FileSystemException("vfs.operation/operation-provider-already-added.error", scheme); } setupComponent(operationProvider); providers.add(operationProvider); } } /** * @param scheme * the scheme for wich we want to get the list af registered * providers. * * @return the registered FileOperationProviders for the specified scheme. * If there were no providers registered for the scheme, it returns * null. * * @throws FileSystemException */ public FileOperationProvider[] getOperationProviders(final String scheme) throws FileSystemException { List providers = (List) operationProviders.get(scheme); if (providers == null || providers.size() == 0) { return null; } return (FileOperationProvider[]) providers.toArray(new FileOperationProvider[] {}); } }