Java StandardFileSystemManager类代码示例

import org.apache.commons.vfs2.impl.StandardFileSystemManager; //导入依赖的package包/类
/**
 * @param remoteFile     Location of the file
 * @param destination    New file location
 * @param filePattern    Pattern of the file
 * @param manager        Standard file system manager
 * @param messageContext The message context that is generated for processing the file
 * @throws IOException
 */
private void moveFileWithPattern(FileObject remoteFile, String destination, String filePattern,
                                 StandardFileSystemManager manager, MessageContext messageContext) throws IOException {
    FilePattenMatcher patternMatcher = new FilePattenMatcher(filePattern);
    try {
        if (patternMatcher.validate(remoteFile.getName().getBaseName())) {
            FileObject file = manager.resolveFile(destination, FileConnectorUtils.init(messageContext));
            if (!file.exists()) {
                file.createFolder();
            }
            file = manager.resolveFile(destination + File.separator + remoteFile.getName().getBaseName(),
                    FileConnectorUtils.init(messageContext));
            remoteFile.moveTo(file);
        }
    } catch (IOException e) {
        log.error("Error occurred while moving a file. " + e.getMessage(), e);
    }
}
 

import org.apache.commons.vfs2.impl.StandardFileSystemManager; //导入依赖的package包/类
/**
 * @param source      file location
 * @param destination target file location
 * @param filePattern pattern of the file
 * @param opts        FileSystemOptions
 * @throws IOException
 */
private void copy(FileObject source, String destination, String filePattern, FileSystemOptions opts)
        throws IOException {
    StandardFileSystemManager manager = FileConnectorUtils.getManager();
    FileObject souFile = manager.resolveFile(String.valueOf(source), opts);
    FilePattenMatcher patternMatcher = new FilePattenMatcher(filePattern);
    try {
        if (patternMatcher.validate(source.getName().getBaseName())) {
            String name = source.getName().getBaseName();
            FileObject outFile = manager.resolveFile(destination + File.separator + name, opts);
            outFile.copyFrom(souFile, Selectors.SELECT_ALL);
        }
    } catch (IOException e) {
        log.error("Error occurred while copying a file. " + e.getMessage(), e);
    } finally {
        manager.close();
    }
}
 

import org.apache.commons.vfs2.impl.StandardFileSystemManager; //导入依赖的package包/类
private StandardFileSystemManager initializeStandardFileSystemManager()
{
    if (!logger.isDebugEnabled()) {
        // TODO: change logging format: org.apache.commons.logging.Log
        System.setProperty("org.apache.commons.logging.Log", "org.apache.commons.logging.impl.NoOpLog");
    }
    StandardFileSystemManager manager = new StandardFileSystemManager();
    manager.setClassLoader(SftpUtils.class.getClassLoader());
    try {
        manager.init();
    }
    catch (FileSystemException e) {
        logger.error(e.getMessage());
        throw new ConfigException(e);
    }

    return manager;
}
 

import org.apache.commons.vfs2.impl.StandardFileSystemManager; //导入依赖的package包/类
/**
 * Returns the global filesystem manager
 *
 * @return the global filesystem manager
 */
public static FileSystemManager getFileSystemManager() {
  aLock.readLock().lock();

  try {
    if (fileSystemManager == null) {
      try {
        StandardFileSystemManager fm = new StandardFileSystemManager();
        fm.setCacheStrategy(CacheStrategy.MANUAL);
        fm.init();
        LOGGER.info("Supported schemes: {} ", Joiner.on(", ").join(fm.getSchemes()));
        fileSystemManager = fm;
      } catch (Exception exc) {
        throw new RuntimeException(exc);
      }
    }

    return fileSystemManager;
  } finally {
    aLock.readLock().unlock();
  }
}
 

import org.apache.commons.vfs2.impl.StandardFileSystemManager; //导入依赖的package包/类
/**
 * Move the files
 *
 * @param source      Location of the file
 * @param destination Destination of the file
 * @return return a resultStatus
 */
private boolean moveFile(String source, String destination, MessageContext messageContext,
                         boolean includeParentDirectory, String filePattern) {
    boolean resultStatus = false;
    StandardFileSystemManager manager = null;
    try {
        manager = FileConnectorUtils.getManager();
        // Create remote object
        FileObject remoteFile = manager.resolveFile(source, FileConnectorUtils.init(messageContext));
        if (remoteFile.exists()) {
            if (remoteFile.getType() == FileType.FILE) {
                fileMove(destination, remoteFile, messageContext, manager);
            } else {
                folderMove(source, destination, filePattern, includeParentDirectory, messageContext, manager);
            }
            resultStatus = true;
            if (log.isDebugEnabled()) {
                log.debug("File move completed from " + source + " to " + destination);
            }
        } else {
            log.error("The file/folder location does not exist.");
            resultStatus = false;
        }
    } catch (IOException e) {
        handleException("Unable to move a file/folder.", e, messageContext);
    } finally {
        if (manager != null) {
            manager.close();
        }
    }
    return resultStatus;
}
 

import org.apache.commons.vfs2.impl.StandardFileSystemManager; //导入依赖的package包/类
/**
 * Move the file
 *
 * @param destination    New location of the folder
 * @param remoteFile     Location of the file
 * @param messageContext The message context that is processed by a handler in the handle method
 * @param manager        Standard file system manager
 */
private void fileMove(String destination, FileObject remoteFile, MessageContext messageContext,
                      StandardFileSystemManager manager) throws IOException {
    FileObject file = manager.resolveFile(destination, FileConnectorUtils.init(messageContext));
    if (FileConnectorUtils.isFolder(file)) {
        if (!file.exists()) {
            file.createFolder();
        }
        file = manager.resolveFile(destination + File.separator + remoteFile.getName().getBaseName(),
                FileConnectorUtils.init(messageContext));
    } else if (!file.exists()) {
        file.createFile();
    }
    remoteFile.moveTo(file);
}
 

import org.apache.commons.vfs2.impl.StandardFileSystemManager; //导入依赖的package包/类
/**
 * Move the folder
 *
 * @param destination            New location of the folder
 * @param source                 Location of the folder
 * @param messageContext         The message context that is processed by a handler in the handle method
 * @param includeParentDirectory Boolean type
 * @param manager                Standard file system manager
 */
private void folderMove(String source, String destination, String filePattern, boolean includeParentDirectory,
                        MessageContext messageContext, StandardFileSystemManager manager) throws IOException {
    FileObject remoteFile = manager.resolveFile(source, FileConnectorUtils.init(messageContext));
    FileObject file = manager.resolveFile(destination, FileConnectorUtils.init(messageContext));
    if (StringUtils.isNotEmpty(filePattern)) {
        FileObject[] children = remoteFile.getChildren();
        for (FileObject child : children) {
            if (child.getType() == FileType.FILE) {
                moveFileWithPattern(child, destination, filePattern, manager, messageContext);
            } else if (child.getType() == FileType.FOLDER) {
                String newSource = source + File.separator + child.getName().getBaseName();
                folderMove(newSource, destination, filePattern, includeParentDirectory, messageContext, manager);
            }
        }
    } else if (includeParentDirectory) {
        file = manager.resolveFile(destination + File.separator + remoteFile.getName().getBaseName(),
                FileConnectorUtils.init(messageContext));
        file.createFolder();
        remoteFile.moveTo(file);
    } else {
        if (!file.exists()) {
            file.createFolder();
        }
        remoteFile.moveTo(file);
        remoteFile.createFolder();
    }
}
 

import org.apache.commons.vfs2.impl.StandardFileSystemManager; //导入依赖的package包/类
protected FileSystemManager fileSystemManager() throws FileSystemException {
    StandardFileSystemManager fsManager = new StandardFileSystemManager();
    fsManager.setClassLoader(DefaultVfsHelper.class.getClassLoader());
    fsManager.init();

    return fsManager;
}
 

import org.apache.commons.vfs2.impl.StandardFileSystemManager; //导入依赖的package包/类
/**
 * Gets the standard file system manager.
 * 
 * @return the standard file system manager
 */
public StandardFileSystemManager getStandardFileSystemManager() {
    if (LOG.isDebugEnabled()) {
        LOG.debug("getStandardFileSystemManager() - entering");
    }

    if (LOG.isDebugEnabled()) {
        LOG.debug("getStandardFileSystemManager() - exiting");
    }
    return standardFileSystemManager;
}
 

import org.apache.commons.vfs2.impl.StandardFileSystemManager; //导入依赖的package包/类
/**
 * Returns the global filesystem manager
 * @return the global filesystem manager
 */
public static FileSystemManager getFileSystemManager()
{
    aLock.readLock().lock();

    try
    {
        if (fileSystemManager == null)
        {
            try
            {
                StandardFileSystemManager fm = new StandardFileSystemManager();
                fm.setCacheStrategy(CacheStrategy.MANUAL);
                fm.init();
                fileSystemManager = fm;
            }
            catch (Exception exc)
            {
                throw new RuntimeException(exc);
            }
        }

        return fileSystemManager;
    }
    finally
    {
        aLock.readLock().unlock();
    }
}
 

import org.apache.commons.vfs2.impl.StandardFileSystemManager; //导入依赖的package包/类
public VfsTestHelper() throws Exception {
    // setup and initialize VFS
    fsManager = new StandardFileSystemManager() {
        protected void configurePlugins() throws FileSystemException {
            // disable automatic loading of potentially unsupported extensions
        }
    };
    fsManager.setConfiguration(getClass().getResource(VFS_CONF).toString());
    fsManager.init();

    // setup and initialize ivy
    ivy = new Ivy();
    ivy.configure(new File(IVY_CONFIG_FILE));
}
 

import org.apache.commons.vfs2.impl.StandardFileSystemManager; //导入依赖的package包/类
/**
 * Resolves a URI to a file, relative to the project's base directory.
 *
 * @param uri The URI to resolve.
 */
protected FileObject resolveFile(final String uri)
    throws FileSystemException
{
    if (manager == null)
    {
        StandardFileSystemManager mngr = new StandardFileSystemManager();
        mngr.setLogger(new AntLogger());
        mngr.init();
        manager = mngr;
        getProject().addBuildListener(new CloseListener());
    }
    return manager.resolveFile(getProject().getBaseDir(), uri);
}
 

import org.apache.commons.vfs2.impl.StandardFileSystemManager; //导入依赖的package包/类
@Override
protected void setUp() throws Exception
{
    super.setUp();

    // get a full blown, fully functional manager
    fsm = new StandardFileSystemManager();
    fsm.init();
}
 

import org.apache.commons.vfs2.impl.StandardFileSystemManager; //导入依赖的package包/类
@Nonnull
private static FileSystemManager newFileSystemManager() throws FileSystemException {
    StandardFileSystemManager manager = new StandardFileSystemManager();
    manager.setCacheStrategy(CacheStrategy.MANUAL);
    manager.init();
    return manager;
}
 

import org.apache.commons.vfs2.impl.StandardFileSystemManager; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    SourceResolver a = new SourceResolver();
    SourceData data = a.resolveSource(getPath("binkd.cfg.simple1"), getPath("SQAFIX.cfg"), getPath("SQUISH.cfg"), getPath("dmtareas.ini.simple"), "2:5020/1042");

    Converter converter = new Converter();
    TargetData targetData = new TargetData();
    converter.convert(data, targetData);

    List<Link> items = Utils.getItems(targetData.asLinks());
    TestCase.assertEquals(9, items.size());

    Collections.sort(items, new Comparator<Link>() {
        @Override
        public int compare(Link o1, Link o2) {
            return o1.getPassword().compareTo(o2.getPassword());
        }
    });

    StandardFileSystemManager manager = new StandardFileSystemManager();
    manager.init();
    manager.resolveFile("ram://root/file2.txt").createFile();
    fo = manager.resolveFile("ram://root/file2.txt");
    OutputStream os = fo.getContent().getOutputStream();

    out = new OutputStreamWriter(os);

    root = new HashMap<>();
    root.put("links", items);

    List<Subscr> subscrs = Utils.getItems(targetData.asSubscr());
    Collections.sort(subscrs, new SubscrComparator());

    List<Subscr> filesubscrs = Utils.getItems(targetData.asFilesubscr());
    Collections.sort(filesubscrs, new SubscrComparator());

    List<EchoArea> areas = Utils.getItems(targetData.asAreas());
    Collections.sort(areas, new EchoAreaComparator());

    List<EchoArea> fileareas = Utils.getItems(targetData.asFileAreas());
    Collections.sort(areas, new EchoAreaComparator());

    root.put("mainuplink", targetData.getMainUplink());
    root.put("subscr", subscrs.subList(0, 5));
    root.put("filesubscr", filesubscrs);
    root.put("areas", areas.subList(0, 23));
    root.put("fileareas", fileareas);
}