Example usage for org.apache.commons.vfs AllFileSelector AllFileSelector

List of usage examples for org.apache.commons.vfs AllFileSelector AllFileSelector

Introduction

In this page you can find the example usage for org.apache.commons.vfs AllFileSelector AllFileSelector.

Prototype

AllFileSelector

Source Link

Usage

From source file:org.codehaus.cargo.container.spi.configuration.StandaloneConfigurationTest.java

/**
 * Test the creation of a config directory when the target directory does not exist yet.
 * @throws Exception If anything goes wrong.
 *///from www  . ja v a2  s  . c om
public void testCreateConfigDirWhenDirectoryDoesNotExist() throws Exception {
    String configDir = "ram:///cargo/testCreateConfigDirWhenDirectoryDoesNotExist";

    FileObject configDirObject = VFS.getManager().resolveFile(configDir);
    FileObject timestampFileObject = configDirObject.resolveFile(".cargo");

    configDirObject.delete(new AllFileSelector());

    TestableAbstractStandaloneConfiguration configuration = new TestableAbstractStandaloneConfiguration(
            configDir);
    configuration.setFileHandler(new VFSFileHandler());
    configuration.setupConfigurationDir();

    assertTrue("Config dir should have been created", configDirObject.exists());
    assertTrue("Cargo timestamp should have existed", timestampFileObject.exists());
}

From source file:org.codehaus.cargo.util.VFSFileHandler.java

/**
 * Copy a directory. {@inheritDoc}//from   ww w .j  a  v  a  2 s.  c  o m
 * @param source Source directory.
 * @param target Destination directory.
 */
@Override
public void copyDirectory(String source, String target) {
    try {
        FileObject sourceObject = getFileSystemManager().resolveFile(source);
        getFileSystemManager().resolveFile(target).copyFrom(sourceObject, new AllFileSelector());
    } catch (FileSystemException e) {
        throw new CargoException("Failed to copy [" + source + "] to [" + target + "]", e);
    }
}

From source file:org.codehaus.cargo.util.VFSFileHandler.java

/**
 * Delete a given path. {@inheritDoc}/*w ww.  j  av a 2  s.co  m*/
 * @param path Path to delete.
 */
@Override
public void delete(String path) {
    try {
        getFileSystemManager().resolveFile(path).delete(new AllFileSelector());
    } catch (FileSystemException e) {
        throw new CargoException("Failed to delete all files and folders from [" + path + "]", e);
    }

}

From source file:org.geoserver.importer.VFSWorker.java

/**
 * Extracts the archive file {@code archiveFile} to {@code targetFolder}; both shall previously
 * exist.//from   w ww  .j a  va  2  s . c  o  m
 */
public void extractTo(File archiveFile, File targetFolder) throws IOException {

    FileSystemManager manager = VFS.getManager();
    String sourceURI = resolveArchiveURI(archiveFile);
    // String targetURI = resolveArchiveURI(targetFolder);
    FileObject source = manager.resolveFile(sourceURI);
    if (manager.canCreateFileSystem(source)) {
        source = manager.createFileSystem(source);
    }
    FileObject target = manager.createVirtualFileSystem(manager.resolveFile(targetFolder.getAbsolutePath()));

    FileSelector selector = new AllFileSelector() {
        @Override
        public boolean includeFile(FileSelectInfo fileInfo) {
            LOGGER.fine("Uncompressing " + fileInfo.getFile().getName().getFriendlyURI());
            return true;
        }
    };
    target.copyFrom(source, selector);
}

From source file:org.jbpm.form.builder.services.impl.fs.FSMenuService.java

protected void writeToURL(URL url, String json) throws FileNotFoundException, IOException {
    if (url.toExternalForm().startsWith("vfs")) {
        FileObject to = VFS.getManager().resolveFile(url.toExternalForm());
        File tmpFile = File.createTempFile("xxFilexx", ".json");
        FileUtils.writeStringToFile(tmpFile, json);
        FileObject from = VFS.getManager().toFileObject(tmpFile);
        to.copyFrom(from, new AllFileSelector());
        FileUtils.deleteQuietly(tmpFile);
    } else {/*w  w w . j  a v  a 2 s .  c  o  m*/
        FileUtils.writeStringToFile(FileUtils.toFile(url), json);
    }
}

From source file:org.jclouds.vfs.provider.blobstore.test.BlobStoreProviderTestCase.java

private FileObject setUpTests(final FileSystemManager manager, String uri)
        throws FileSystemException, IOException {
    FileObject base = manager.resolveFile(uri);
    FileObject writeTests = base.resolveFile("write-tests");
    FileObject readTests = base.resolveFile("read-tests");

    if (base instanceof BlobStoreFileObject) {
        BlobStore blobStore = ((BlobStoreFileObject) base).getBlobStore();
        String container = ((BlobStoreFileObject) base).getContainer();
        blobStore.clearContainer(container);
    } else {//w w w  .jav a2 s.  c o  m
        writeTests.delete(new AllFileSelector());
        readTests.delete(new AllFileSelector());
    }

    writeTests.createFolder();
    readTests.createFolder();
    for (String name : new String[] { "file1.txt", "file%25.txt", "file space.txt" }) {
        writeFile(readTests, name, FILE1_CONTENT);
    }
    writeFile(readTests, "empty.txt", "");
    FileObject dir = readTests.resolveFile("dir1");
    dir.createFolder();
    write3Files(dir);
    for (String subdirName : new String[] { "subdir1", "subdir2", "subdir3" }) {
        FileObject subdir = dir.resolveFile(subdirName);
        subdir.createFolder();
        write3Files(subdir);
    }
    return base;
}

From source file:org.pentaho.di.core.fileinput.FileInputList.java

public static FileInputList createFileList(VariableSpace space, String[] fileName, String[] fileMask,
        String[] excludeFileMask, String[] fileRequired, boolean[] includeSubdirs,
        FileTypeFilter[] fileTypeFilters) {
    FileInputList fileInputList = new FileInputList();

    // Replace possible environment variables...
    final String[] realfile = space.environmentSubstitute(fileName);
    final String[] realmask = space.environmentSubstitute(fileMask);
    final String[] realExcludeMask = space.environmentSubstitute(excludeFileMask);

    for (int i = 0; i < realfile.length; i++) {
        final String onefile = realfile[i];
        final String onemask = realmask[i];
        final String excludeonemask = realExcludeMask[i];
        final boolean onerequired = YES.equalsIgnoreCase(fileRequired[i]);
        final boolean subdirs = includeSubdirs[i];
        final FileTypeFilter filter = ((fileTypeFilters == null || fileTypeFilters[i] == null)
                ? FileTypeFilter.ONLY_FILES
                : fileTypeFilters[i]);//from   www  . ja v a 2 s .c om

        if (Const.isEmpty(onefile)) {
            continue;
        }

        //
        // If a wildcard is set we search for files
        //
        if (!Const.isEmpty(onemask) || !Const.isEmpty(excludeonemask)) {
            try {
                FileObject directoryFileObject = KettleVFS.getFileObject(onefile, space);
                boolean processFolder = true;
                if (onerequired) {
                    if (!directoryFileObject.exists()) {
                        // if we don't find folder..no need to continue
                        fileInputList.addNonExistantFile(directoryFileObject);
                        processFolder = false;
                    } else {
                        if (!directoryFileObject.isReadable()) {
                            fileInputList.addNonAccessibleFile(directoryFileObject);
                            processFolder = false;
                        }
                    }
                }

                // Find all file names that match the wildcard in this directory
                //
                if (processFolder) {
                    if (directoryFileObject != null && directoryFileObject.getType() == FileType.FOLDER) // it's a directory
                    {
                        FileObject[] fileObjects = directoryFileObject.findFiles(new AllFileSelector() {
                            @Override
                            public boolean traverseDescendents(FileSelectInfo info) {
                                return info.getDepth() == 0 || subdirs;
                            }

                            @Override
                            public boolean includeFile(FileSelectInfo info) {
                                // Never return the parent directory of a file list.
                                if (info.getDepth() == 0) {
                                    return false;
                                }

                                FileObject fileObject = info.getFile();
                                try {
                                    if (fileObject != null && filter.isFileTypeAllowed(fileObject.getType())) {
                                        String name = info.getFile().getName().getBaseName();
                                        boolean matches = true;
                                        if (!Const.isEmpty(onemask)) {
                                            matches = Pattern.matches(onemask, name);
                                        }
                                        boolean excludematches = false;
                                        if (!Const.isEmpty(excludeonemask)) {
                                            excludematches = Pattern.matches(excludeonemask, name);
                                        }
                                        return (matches && !excludematches);
                                    }
                                    return false;
                                } catch (IOException ex) {
                                    // Upon error don't process the file.
                                    return false;
                                }
                            }
                        });
                        if (fileObjects != null) {
                            for (int j = 0; j < fileObjects.length; j++) {
                                if (fileObjects[j].exists()) {
                                    fileInputList.addFile(fileObjects[j]);
                                }
                            }
                        }
                        if (Const.isEmpty(fileObjects)) {
                            if (onerequired) {
                                fileInputList.addNonAccessibleFile(directoryFileObject);
                            }
                        }

                        // Sort the list: quicksort, only for regular files
                        fileInputList.sortFiles();
                    } else {
                        FileObject[] children = directoryFileObject.getChildren();
                        for (int j = 0; j < children.length; j++) {
                            // See if the wildcard (regexp) matches...
                            String name = children[j].getName().getBaseName();
                            boolean matches = true;
                            if (!Const.isEmpty(onemask)) {
                                matches = Pattern.matches(onemask, name);
                            }
                            boolean excludematches = false;
                            if (!Const.isEmpty(excludeonemask)) {
                                excludematches = Pattern.matches(excludeonemask, name);
                            }
                            if (matches && !excludematches) {
                                fileInputList.addFile(children[j]);
                            }

                        }
                        // We don't sort here, keep the order of the files in the archive.
                    }
                }
            } catch (Exception e) {
                if (onerequired) {
                    fileInputList.addNonAccessibleFile(new NonAccessibleFileObject(onefile));
                }
                log.logError(Const.getStackTracker(e));
            }
        } else { // A normal file...

            try {
                FileObject fileObject = KettleVFS.getFileObject(onefile, space);
                if (fileObject.exists()) {
                    if (fileObject.isReadable()) {
                        fileInputList.addFile(fileObject);
                    } else {
                        if (onerequired) {
                            fileInputList.addNonAccessibleFile(fileObject);
                        }
                    }
                } else {
                    if (onerequired) {
                        fileInputList.addNonExistantFile(fileObject);
                    }
                }
            } catch (Exception e) {
                if (onerequired) {
                    fileInputList.addNonAccessibleFile(new NonAccessibleFileObject(onefile));
                }
                log.logError(Const.getStackTracker(e));
            }
        }
    }

    return fileInputList;
}

From source file:org.pentaho.di.core.fileinput.FileInputList.java

public static FileInputList createFolderList(VariableSpace space, String[] folderName,
        String[] folderRequired) {
    FileInputList fileInputList = new FileInputList();

    // Replace possible environment variables...
    final String[] realfolder = space.environmentSubstitute(folderName);

    for (int i = 0; i < realfolder.length; i++) {
        final String onefile = realfolder[i];
        final boolean onerequired = YES.equalsIgnoreCase(folderRequired[i]);
        final boolean subdirs = true;
        final FileTypeFilter filter = FileTypeFilter.ONLY_FOLDERS;

        if (Const.isEmpty(onefile)) {
            continue;
        }/*from  w  w w  .j  a v a 2  s. c om*/
        FileObject directoryFileObject = null;

        try {
            // Find all folder names in this directory
            //
            directoryFileObject = KettleVFS.getFileObject(onefile, space);
            if (directoryFileObject != null && directoryFileObject.getType() == FileType.FOLDER) // it's a directory
            {

                FileObject[] fileObjects = directoryFileObject.findFiles(new AllFileSelector() {
                    @Override
                    public boolean traverseDescendents(FileSelectInfo info) {
                        return info.getDepth() == 0 || subdirs;
                    }

                    @Override
                    public boolean includeFile(FileSelectInfo info) {
                        // Never return the parent directory of a file list.
                        if (info.getDepth() == 0) {
                            return false;
                        }

                        FileObject fileObject = info.getFile();
                        try {
                            if (fileObject != null && filter.isFileTypeAllowed(fileObject.getType())) {
                                return true;
                            }
                            return false;
                        } catch (IOException ex) {
                            // Upon error don't process the file.
                            return false;
                        }
                    }
                });
                if (fileObjects != null) {
                    for (int j = 0; j < fileObjects.length; j++) {
                        if (fileObjects[j].exists()) {
                            fileInputList.addFile(fileObjects[j]);
                        }
                    }
                }
                if (Const.isEmpty(fileObjects)) {
                    if (onerequired) {
                        fileInputList.addNonAccessibleFile(directoryFileObject);
                    }
                }

                // Sort the list: quicksort, only for regular files
                fileInputList.sortFiles();
            } else {
                if (onerequired && !directoryFileObject.exists()) {
                    fileInputList.addNonExistantFile(directoryFileObject);
                }
            }
        } catch (Exception e) {
            log.logError(Const.getStackTracker(e));
        } finally {
            try {
                if (directoryFileObject != null) {
                    directoryFileObject.close();
                }
                directoryFileObject = null;
            } catch (Exception e) {
                // Ignore
            }
        }
    }

    return fileInputList;
}

From source file:org.pentaho.di.job.entries.dostounix.JobEntryDosToUnix.java

private boolean processFileFolder(String sourcefilefoldername, String wildcard, int convertion, Job parentJob,
        Result result) {/*from ww  w  . j  av  a2 s . c  o m*/
    boolean entrystatus = false;
    FileObject sourcefilefolder = null;
    FileObject CurrentFile = null;

    // Get real source file and wilcard
    String realSourceFilefoldername = environmentSubstitute(sourcefilefoldername);
    if (Const.isEmpty(realSourceFilefoldername)) {
        logError(BaseMessages.getString(PKG, "JobDosToUnix.log.FileFolderEmpty", sourcefilefoldername));
        // Update Errors
        updateErrors();

        return entrystatus;
    }
    String realWildcard = environmentSubstitute(wildcard);

    try {
        sourcefilefolder = KettleVFS.getFileObject(realSourceFilefoldername);

        if (sourcefilefolder.exists()) {
            if (isDetailed()) {
                logDetailed(BaseMessages.getString(PKG, "JobDosToUnix.Log.FileExists",
                        sourcefilefolder.toString()));
            }
            if (sourcefilefolder.getType() == FileType.FILE) {
                entrystatus = convertOneFile(sourcefilefolder, convertion, result, parentJob);

            } else if (sourcefilefolder.getType() == FileType.FOLDER) {
                FileObject[] fileObjects = sourcefilefolder.findFiles(new AllFileSelector() {
                    public boolean traverseDescendents(FileSelectInfo info) {
                        return info.getDepth() == 0 || include_subfolders;
                    }

                    public boolean includeFile(FileSelectInfo info) {

                        FileObject fileObject = info.getFile();
                        try {
                            if (fileObject == null) {
                                return false;
                            }
                            if (fileObject.getType() != FileType.FILE) {
                                return false;
                            }
                        } catch (Exception ex) {
                            // Upon error don't process the file.
                            return false;
                        } finally {
                            if (fileObject != null) {
                                try {
                                    fileObject.close();
                                } catch (IOException ex) { /* Ignore */
                                }
                            }

                        }
                        return true;
                    }
                });

                if (fileObjects != null) {
                    for (int j = 0; j < fileObjects.length && !parentJob.isStopped(); j++) {
                        if (successConditionBroken) {
                            if (!successConditionBrokenExit) {
                                logError(BaseMessages.getString(PKG,
                                        "JobDosToUnix.Error.SuccessConditionbroken", "" + nrAllErrors));
                                successConditionBrokenExit = true;
                            }
                            return false;
                        }
                        // Fetch files in list one after one ...
                        CurrentFile = fileObjects[j];

                        if (!CurrentFile.getParent().toString().equals(sourcefilefolder.toString())) {
                            // Not in the Base Folder..Only if include sub folders
                            if (include_subfolders) {
                                if (GetFileWildcard(CurrentFile.toString(), realWildcard)) {
                                    convertOneFile(CurrentFile, convertion, result, parentJob);
                                }
                            }

                        } else {
                            // In the base folder
                            if (GetFileWildcard(CurrentFile.toString(), realWildcard)) {
                                convertOneFile(CurrentFile, convertion, result, parentJob);
                            }
                        }
                    }
                }
            } else {
                logError(BaseMessages.getString(PKG, "JobDosToUnix.Error.UnknowFileFormat",
                        sourcefilefolder.toString()));
                // Update Errors
                updateErrors();
            }
        } else {
            logError(BaseMessages.getString(PKG, "JobDosToUnix.Error.SourceFileNotExists",
                    realSourceFilefoldername));
            // Update Errors
            updateErrors();
        }
    } catch (Exception e) {
        logError(BaseMessages.getString(PKG, "JobDosToUnix.Error.Exception.Processing",
                realSourceFilefoldername.toString(), e.getMessage()));
        // Update Errors
        updateErrors();
    } finally {
        if (sourcefilefolder != null) {
            try {
                sourcefilefolder.close();
            } catch (IOException ex) {
                /* Ignore */
            }

        }
        if (CurrentFile != null) {
            try {
                CurrentFile.close();
            } catch (IOException ex) { /* Ignore */
            }
        }
    }
    return entrystatus;
}

From source file:org.pentaho.di.job.entries.evalfilesmetrics.JobEntryEvalFilesMetrics.java

private void ProcessFileFolder(String sourcefilefoldername, String wildcard, String includeSubfolders,
        Job parentJob, Result result) {

    FileObject sourcefilefolder = null;
    FileObject CurrentFile = null;

    // Get real source file and wildcard
    String realSourceFilefoldername = environmentSubstitute(sourcefilefoldername);
    if (Const.isEmpty(realSourceFilefoldername)) {
        // Filename is empty!
        logError(BaseMessages.getString(PKG, "JobEvalFilesMetrics.log.FileFolderEmpty"));
        incrementErrors();/*from  w w w.java 2s.  c o m*/
        return;
    }
    String realWildcard = environmentSubstitute(wildcard);
    final boolean include_subfolders = YES.equalsIgnoreCase(includeSubfolders);

    try {
        sourcefilefolder = KettleVFS.getFileObject(realSourceFilefoldername);

        if (sourcefilefolder.exists()) {
            // File exists
            if (isDetailed()) {
                logDetailed(BaseMessages.getString(PKG, "JobEvalFilesMetrics.Log.FileExists",
                        sourcefilefolder.toString()));
            }

            if (sourcefilefolder.getType() == FileType.FILE) {
                // We deals here with a file
                // let's get file size
                getFileSize(sourcefilefolder, result, parentJob);

            } else if (sourcefilefolder.getType() == FileType.FOLDER) {
                // We have a folder
                // we will fetch and extract files
                FileObject[] fileObjects = sourcefilefolder.findFiles(new AllFileSelector() {
                    public boolean traverseDescendents(FileSelectInfo info) {
                        return info.getDepth() == 0 || include_subfolders;
                    }

                    public boolean includeFile(FileSelectInfo info) {
                        FileObject fileObject = info.getFile();
                        try {
                            if (fileObject == null) {
                                return false;
                            }
                            if (fileObject.getType() != FileType.FILE) {
                                return false;
                            }
                        } catch (Exception ex) {
                            // Upon error don't process the file.
                            return false;
                        } finally {
                            if (fileObject != null) {
                                try {
                                    fileObject.close();
                                } catch (IOException ex) { /* Ignore */
                                }
                            }
                        }
                        return true;
                    }
                });

                if (fileObjects != null) {
                    for (int j = 0; j < fileObjects.length && !parentJob.isStopped(); j++) {
                        // Fetch files in list one after one ...
                        CurrentFile = fileObjects[j];

                        if (!CurrentFile.getParent().toString().equals(sourcefilefolder.toString())) {
                            // Not in the Base Folder..Only if include sub folders
                            if (include_subfolders) {
                                if (GetFileWildcard(CurrentFile.getName().getBaseName(), realWildcard)) {
                                    getFileSize(CurrentFile, result, parentJob);
                                }
                            }
                        } else {
                            // In the base folder
                            if (GetFileWildcard(CurrentFile.getName().getBaseName(), realWildcard)) {
                                getFileSize(CurrentFile, result, parentJob);
                            }
                        }
                    }
                }
            } else {
                incrementErrors();
                logError(BaseMessages.getString(PKG, "JobEvalFilesMetrics.Error.UnknowFileFormat",
                        sourcefilefolder.toString()));
            }
        } else {
            incrementErrors();
            logError(BaseMessages.getString(PKG, "JobEvalFilesMetrics.Error.SourceFileNotExists",
                    realSourceFilefoldername));
        }
    } catch (Exception e) {
        incrementErrors();
        logError(BaseMessages.getString(PKG, "JobEvalFilesMetrics.Error.Exception.Processing",
                realSourceFilefoldername.toString(), e.getMessage()));

    } finally {
        if (sourcefilefolder != null) {
            try {
                sourcefilefolder.close();
            } catch (IOException ex) { /* Ignore */
            }

        }
        if (CurrentFile != null) {
            try {
                CurrentFile.close();
            } catch (IOException ex) { /* Ignore */
            }
        }
    }
}