Java FileSystem类代码示例

import org.apache.commons.vfs2.FileSystem; //导入依赖的package包/类
@Override
public void destroy() {
  LOG.info(Utils.format("Destroying {}", getInfo().getInstanceName()));
  try {
    IOUtils.closeQuietly(currentStream);
    IOUtils.closeQuietly(parser);
    if (remoteDir != null) {
      remoteDir.close();
      FileSystem fs = remoteDir.getFileSystem();
      remoteDir.getFileSystem().getFileSystemManager().closeFileSystem(fs);
    }
  } catch (IOException ex) {
    LOG.warn("Error during destroy", ex);
  } finally {
    remoteDir = null;
    //This forces the use of same RemoteDownloadSource object
    //not to have dangling reference to old stream (which is closed)
    //Also forces to initialize the next in produce call.
    currentStream = null;
    parser = null;
    currentOffset = null;
    next = null;
  }
}
 

import org.apache.commons.vfs2.FileSystem; //导入依赖的package包/类
public FileObject getFile(final FileSystem filesystem, final FileName name)
{
    Map<FileName, Reference<FileObject>> files = getOrCreateFilesystemCache(filesystem);

    lock.lock();
    try
    {
        Reference<FileObject> ref = files.get(name);
        if (ref == null)
        {
            return null;
        }

        FileObject fo = ref.get();
        if (fo == null)
        {
            removeFile(filesystem, name);
        }
        return fo;
    }
    finally
    {
        lock.unlock();
    }
}
 

import org.apache.commons.vfs2.FileSystem; //导入依赖的package包/类
/**
 * Called while the lock is held
 * @param filesystem The file system to close.
 */
private void filesystemClose(FileSystem filesystem)
{
    if (log.isDebugEnabled())
    {
        log.debug("close fs: " + filesystem.getRootName());
    }

    filesystemCache.remove(filesystem);
    if (filesystemCache.size() < 1)
    {
        endThread();
    }
    /* This is not thread-safe as another thread might be opening the file system
    ((DefaultFileSystemManager) getContext().getFileSystemManager())
            ._closeFileSystem(filesystem);
     */
}
 

import org.apache.commons.vfs2.FileSystem; //导入依赖的package包/类
protected Map<FileName, Reference<FileObject>> getOrCreateFilesystemCache(final FileSystem filesystem)
{
    if (filesystemCache.size() < 1)
    {
        startThread();
    }

    Map<FileName, Reference<FileObject>> files;

    do
    {
        files = filesystemCache.get(filesystem);
        if (files != null)
        {
            break;
        }
        files = new HashMap<FileName, Reference<FileObject>>();
    } while (filesystemCache.putIfAbsent(filesystem, files) == null);

    return files;
}
 

import org.apache.commons.vfs2.FileSystem; //导入依赖的package包/类
public FileObject getFile(final FileSystem filesystem, final FileName name)
{
    Map<FileName, FileObject> files = getOrCreateFilesystemCache(filesystem);

    readLock.lock();
    try
    {
        // FileObject fo = (FileObject) files.get(name);
        // System.err.println(">>> " + files.size() + " get:" + name.toString() + " " + fo);

        return files.get(name);
    }
    finally
    {
        readLock.unlock();
    }
}
 

import org.apache.commons.vfs2.FileSystem; //导入依赖的package包/类
public void clear(final FileSystem filesystem)
{
    Map<FileName, FileObject> files = getOrCreateFilesystemCache(filesystem);

    writeLock.lock();
    try
    {
        // System.err.println(">>> clear fs " + filesystem);

        files.clear();

        filesystemCache.remove(filesystem);
    }
    finally
    {
        writeLock.unlock();
    }
}
 

import org.apache.commons.vfs2.FileSystem; //导入依赖的package包/类
public void removeFile(final FileSystem filesystem, final FileName name)
{
    Map<?, ?> files = getOrCreateFilesystemCache(filesystem);

    writeLock.lock();
    try
    {
        // System.err.println(">>> " + files.size() + " remove:" + name.toString());

        files.remove(name);

        if (files.size() < 1)
        {
            filesystemCache.remove(filesystem);
        }
    }
    finally
    {
        writeLock.unlock();
    }
}
 

import org.apache.commons.vfs2.FileSystem; //导入依赖的package包/类
/**
 * Creates a layered file system.
 * @param scheme The protocol to use.
 * @param file a FileObject.
 * @param fileSystemOptions Options to access the FileSystem.
 * @return A FileObject associated with the new FileSystem.
 * @throws FileSystemException if an error occurs.
 */
@Override
public synchronized FileObject createFileSystem(final String scheme,
                                                final FileObject file,
                                                final FileSystemOptions fileSystemOptions)
    throws FileSystemException
{
    // Check if cached
    final FileName rootName = file.getName();
    FileSystem fs = findFileSystem(rootName, null);
    if (fs == null)
    {
        // Create the file system
        fs = doCreateFileSystem(scheme, file, fileSystemOptions);
        addFileSystem(rootName, fs);
    }
    return fs.getRoot();
}
 

import org.apache.commons.vfs2.FileSystem; //导入依赖的package包/类
/**
 * Close the FileSystem.
 * @param filesystem The FileSystem to close.
 */
public void closeFileSystem(final FileSystem filesystem)
{
    AbstractFileSystem fs = (AbstractFileSystem) filesystem;

    synchronized (this)
    {
        if (fs.getCacheKey() != null)
        {
            fileSystems.remove(fs.getCacheKey());
        }
    }

    removeComponent(fs);
    fs.close();
}
 

import org.apache.commons.vfs2.FileSystem; //导入依赖的package包/类
/**
 * Checks ancestors are created when a junction is created.
 */
public void testAncestors() throws Exception
{
    final FileSystem fs = getManager().createVirtualFileSystem("vfs://").getFileSystem();
    final FileObject baseDir = getBaseDir();

    // Make sure the file at the junction point and its ancestors do not exist
    FileObject file = fs.resolveFile("/a/b");
    assertFalse(file.exists());
    file = file.getParent();
    assertFalse(file.exists());
    file = file.getParent();
    assertFalse(file.exists());

    // Add the junction
    fs.addJunction("/a/b", baseDir);

    // Make sure the file at the junction point and its ancestors exist
    file = fs.resolveFile("/a/b");
    assertTrue("Does not exist", file.exists());
    file = file.getParent();
    assertTrue("Does not exist", file.exists());
    file = file.getParent();
    assertTrue("Does not exist", file.exists());
}
 

import org.apache.commons.vfs2.FileSystem; //导入依赖的package包/类
@Override
public HadoopFileSystem getHDFSFileSystem() throws FileSystemException {
  if (fs == null) {
    Configuration conf = new Configuration();
    conf.set("fs.maprfs.impl", MapRFileProvider.FS_MAPR_IMPL);

    GenericFileName rootName = (GenericFileName) getRootName();
    String url = rootName.getScheme() + "://" + rootName.getHostName().trim();
    if (rootName.getPort() != MapRFileNameParser.DEFAULT_PORT) {
      url += ":" + rootName.getPort();
    }
    url += "/";
    conf.set("fs.default.name", url);
    setFileSystemOptions( getFileSystemOptions(), conf );
    try {
      fs = new HadoopFileSystemImpl( org.apache.hadoop.fs.FileSystem.get(conf) );
    } catch (Throwable t) {
      throw new FileSystemException("Could not get MapR FileSystem for " + url, t);
    }
  }
  return fs;
}
 

import org.apache.commons.vfs2.FileSystem; //导入依赖的package包/类
/**
 * Checks to see if the file can be written to.
 * 
 * @param fileInfo
 *            the File to check
 * 
 * @return {@code true} if the file can be written to, otherwise
 *         {@code false}.
 */
@Override
public boolean accept(final FileSelectInfo fileInfo) {
    try {
        final FileSystem fileSystem = fileInfo.getFile().getFileSystem();
        if (fileInfo.getFile().exists()) {
            if (!fileSystem.hasCapability(Capability.WRITE_CONTENT)) {
                return false;
            }
            return fileInfo.getFile().isWriteable();
        } else {
            if (!fileSystem.hasCapability(Capability.CREATE)) {
                return false;
            }
            return fileInfo.getFile().getParent().isWriteable();
        }
    } catch (final FileSystemException ex) {
        throw new RuntimeException(ex);
    }
}
 

import org.apache.commons.vfs2.FileSystem; //导入依赖的package包/类
protected void close() {
	FileSystem fs = null;
	if(this.root != null) {
		fs = this.root.getFileSystem();
		this.fsManager.closeFileSystem(fs);
		this.root = null;
	}
}
 

import org.apache.commons.vfs2.FileSystem; //导入依赖的package包/类
/**
 * Creates the filesystem.
 */
@Override
protected FileSystem doCreateFileSystem(final FileName name, final FileSystemOptions fileSystemOptions)
    throws FileSystemException
{
    return new NfsFileSystem(name, fileSystemOptions);
}
 

import org.apache.commons.vfs2.FileSystem; //导入依赖的package包/类
public static FileSystem getBaseFileSystem() {
    try {
        return getFileSystemManager().getBaseFile().getFileSystem();
    } catch (final FileSystemException e) {
        throw new IllegalStateException(e);
    }
}