Example usage for org.apache.commons.io.filefilter DirectoryFileFilter DIRECTORY

List of usage examples for org.apache.commons.io.filefilter DirectoryFileFilter DIRECTORY

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.io.filefilter.*
  5. DirectoryFileFilter
  6. DIRECTORY

Introduction

In this page you can find the example usage for org.apache.commons.io.filefilter DirectoryFileFilter DIRECTORY.

Prototype

IOFileFilter DIRECTORY

To view the source code for org.apache.commons.io.filefilter DirectoryFileFilter DIRECTORY.

Click Source Link

Document

Singleton instance of directory filter.

Usage

From source file:org.jvnet.hudson.plugins.thinbackup.backup.HudsonBackup.java

private void backupRootFolder(String folderName, IOFileFilter fileFilter) throws IOException {
    final File srcDirectory = new File(hudsonHome.getAbsolutePath(), folderName);
    if (srcDirectory.exists() && srcDirectory.isDirectory()) {
        LOGGER.fine(String.format("Backing up %s...", folderName));
        final File destDirectory = new File(backupDirectory.getAbsolutePath(), folderName);
        IOFileFilter filter = FileFilterUtils.and(fileFilter, getFileAgeDiffFilter(), getExcludedFilesFilter());
        filter = FileFilterUtils.or(filter, DirectoryFileFilter.DIRECTORY);
        FileUtils.copyDirectory(srcDirectory, destDirectory, filter);
        LOGGER.fine(String.format("DONE backing up %s.", folderName));
    }/*from   ww  w.jav a 2 s .c o m*/
}

From source file:org.jvnet.hudson.plugins.thinbackup.restore.HudsonRestore.java

private boolean restoreFromDirectories(final String parentDirectory) throws IOException {
    boolean success = false;

    IOFileFilter suffixFilter = FileFilterUtils.and(
            FileFilterUtils.suffixFileFilter(Utils.DIRECTORY_NAME_DATE_FORMAT.format(restoreFromDate)),
            DirectoryFileFilter.DIRECTORY);

    final File[] candidates = new File(parentDirectory).listFiles((FileFilter) suffixFilter);
    if (candidates.length > 1) {
        LOGGER.severe(String.format(
                "More than one backup with date '%s' found. This is not allowed. Aborting restore.",
                Utils.DISPLAY_DATE_FORMAT.format(restoreFromDate)));
    } else if (candidates.length == 1) {
        final File toRestore = candidates[0];
        if (toRestore.getName().startsWith(BackupType.DIFF.toString())) {
            final File referencedFullBackup = Utils.getReferencedFullBackup(toRestore);
            restore(referencedFullBackup);
        }/* ww w. jav  a 2s . c o m*/
        restore(toRestore);
        success = true;
    } else {
        LOGGER.info(String.format(
                "No backup directories with date '%s' found. Will try to find a backup in ZIP files next...",
                Utils.DISPLAY_DATE_FORMAT.format(restoreFromDate)));
    }

    return success;
}

From source file:org.jvnet.hudson.plugins.thinbackup.utils.Utils.java

/**
 * @param parentDir root directory of all backups
 * @param backupType type of backup/*  w w  w. j  ava 2 s  .  c om*/
 * @return an unordered list of backup directories of the given backup type.
 */
public static List<File> getBackupTypeDirectories(final File parentDir, final BackupType backupType) {
    IOFileFilter prefixFilter = FileFilterUtils.and(FileFilterUtils.prefixFileFilter(backupType.toString()),
            DirectoryFileFilter.DIRECTORY);

    final File[] existingDirs = parentDir.listFiles((FilenameFilter) prefixFilter);
    if (existingDirs == null) {
        return Collections.emptyList();
    }

    return Arrays.asList(existingDirs);
}

From source file:org.kawanfw.file.api.client.FileSession.java

/**
 * get the list of files or directories in a directory
 * /*w ww. j  av  a2  s.c o m*/
 * @param pathname
 *            the directory pathname to list
 * @param type
 *            the type of File list to return: LIST_FILES_ONLY or
 *            LIST_DIRECTORIES_ONLY
 * @return the files or directories list
 * 
 * @throws InvalidLoginException
 */
private List<String> listFilesOrDirectories(String pathname, int type) throws InvalidLoginException {

    pathname = PathUtil.rewriteToUnixSyntax(pathname);

    RemoteFile theRemoteFile = new RemoteFile(remoteSession, pathname);

    FileFilter fileFilter = null;

    if (type == LIST_FILES_ONLY) {
        fileFilter = FileFileFilter.FILE;
    } else if (type == LIST_DIRECTORIES_ONLY) {
        fileFilter = DirectoryFileFilter.DIRECTORY;
    } else {
        throw new IllegalArgumentException(Tag.PRODUCT_PRODUCT_FAIL
                + " Invalid type. Msust be LIST_FILES_ONLY or LIST_DIRECTORIES_ONLY. Is: " + type);
    }

    RemoteFile[] remoteFiles = theRemoteFile.listFiles(fileFilter);

    if (remoteFiles == null) {
        return null;
    }

    List<String> filenameList = new ArrayList<String>();
    for (RemoteFile remoteFileItem : remoteFiles) {
        filenameList.add(remoteFileItem.getName());
    }

    return filenameList;
}

From source file:org.kawanfw.file.test.api.client.nio.DeleteAllNio.java

/**
 * @param remoteSession/*from   w  w w .j a  v a  2  s .c  om*/
 *            the Awake FILE Session
 * 
 * @throws IllegalArgumentException
 * @throws InvalidLoginException
 * @throws FileNotFoundException
 * @throws UnknownHostException
 * @throws ConnectException
 * @throws InterruptedException
 * @throws RemoteException
 * @throws IOException
 */
public void test(RemoteSession remoteSession)
        throws IllegalArgumentException, InvalidLoginException, FileNotFoundException, UnknownHostException,
        ConnectException, InterruptedException, RemoteException, IOException {

    // Create a remote directory;
    MessageDisplayer.display("");
    System.out
            .println("Deleting remote files list in /" + TestParms.MYDIR1 + " with RemoteFiles.listFiles()...");

    FileFilter fileFilter = DirectoryFileFilter.DIRECTORY;
    RemoteFile[] remoteFileArray = new RemoteFile(remoteSession, "/" + TestParms.MYDIR1).listFiles(fileFilter);

    if (remoteFileArray != null) {
        for (RemoteFile remoteFile : remoteFileArray) {
            remoteFile.delete();
            MessageDisplayer.display(remoteFile + " deleted.");
        }
    }

    MessageDisplayer.display("");
    System.out
            .println("Deleting remote files list in /" + TestParms.MYDIR3 + " with RemoteFiles.listFiles()...");

    fileFilter = DirectoryFileFilter.DIRECTORY;
    remoteFileArray = new RemoteFile(remoteSession, "/" + TestParms.MYDIR3).listFiles(fileFilter);

    if (remoteFileArray != null) {
        for (RemoteFile remoteFile : remoteFileArray) {
            remoteFile.delete();
            MessageDisplayer.display(remoteFile + " deleted.");
        }
    }

    boolean deleted = new RemoteFile(remoteSession, "/" + TestParms.MYDIR1).delete();
    boolean deleted3 = new RemoteFile(remoteSession, "/" + TestParms.MYDIR3).delete();

    if (deleted) {
        MessageDisplayer.display(TestParms.MYDIR1 + " deleted : " + deleted);
    }

    if (deleted3) {
        MessageDisplayer.display(TestParms.MYDIR3 + " deleted : " + deleted);
    }

}

From source file:org.kawanfw.file.test.api.client.nio.MkdirsRemoteNio.java

/**
 * /*w  ww . j  av a2  s .c  o m*/
 * @param remoteSession the Awake FILE Session
 * 
 * @throws IllegalArgumentException
 * @throws InvalidLoginException
 * @throws UnknownHostException
 * @throws ConnectException
 * @throws RemoteException
 * @throws IOException
 */
public void test(RemoteSession remoteSession) throws IllegalArgumentException, InvalidLoginException,
        UnknownHostException, ConnectException, RemoteException, IOException {

    // Create a remote directory
    MessageDisplayer.display("");
    MessageDisplayer.display("creating 3 remote directories with RemoteFile.mkdirs()...");

    new RemoteFile(remoteSession, "/" + TestParms.MYDIR1).mkdirs();
    new RemoteFile(remoteSession, "/" + TestParms.MYDIR2).mkdirs();
    new RemoteFile(remoteSession, "/" + TestParms.MYDIR3).mkdirs();
    new RemoteFile(remoteSession, "/" + TestParms.MYDIR4).mkdirs();

    // TestReload if the directory really exists
    MessageDisplayer.display(
            "Testing remote directories list with RemoteFile.listFiles(DirectoryFileFilter.DIRECTOR()...");
    FileFilter fileFilter = DirectoryFileFilter.DIRECTORY;
    RemoteFile[] remoteFileArray = new RemoteFile(remoteSession, "/").listFiles(fileFilter);

    List<String> directories = new ArrayList<String>();

    for (RemoteFile remoteFile : remoteFileArray) {
        if (remoteFile.toString().contains(TestParms.MYDIR1))
            directories.add(remoteFile.getName());
        if (remoteFile.toString().contains(TestParms.MYDIR2))
            directories.add(remoteFile.getName());
        if (remoteFile.toString().contains(TestParms.MYDIR3))
            directories.add(remoteFile.getName());
        if (remoteFile.toString().contains(TestParms.MYDIR4))
            directories.add(remoteFile.getName());
    }

    Assert.assertTrue("directories contains " + TestParms.MYDIR1, directories.contains(TestParms.MYDIR1));
    Assert.assertTrue("directories contains " + TestParms.MYDIR2, directories.contains(TestParms.MYDIR2));
    Assert.assertTrue("directories contains " + TestParms.MYDIR3, directories.contains(TestParms.MYDIR3));
    Assert.assertTrue("directories contains " + TestParms.MYDIR4, directories.contains(TestParms.MYDIR4));

    MessageDisplayer.display("Remote directories: " + directories);
    MessageDisplayer.display("");

    // Try to delete the directory
    MessageDisplayer.display("Testing remote directory delete with deleteRemoteFile()...");
    new RemoteFile(remoteSession, "/" + TestParms.MYDIR2).delete();

    fileFilter = DirectoryFileFilter.DIRECTORY;
    remoteFileArray = new RemoteFile(remoteSession, "/").listFiles(fileFilter);

    //Assert.assertEquals("2 directories exists now", directories.size(), 2);

    Assert.assertTrue("directory exists " + TestParms.MYDIR1,
            new RemoteFile(remoteSession, "/" + TestParms.MYDIR1).exists());
    Assert.assertFalse("directory doe NOT exists " + TestParms.MYDIR2,
            new RemoteFile(remoteSession, "/" + TestParms.MYDIR2).exists());
    Assert.assertTrue("directory exists " + TestParms.MYDIR3,
            new RemoteFile(remoteSession, "/" + TestParms.MYDIR3).exists());

    MessageDisplayer.display(TestParms.MYDIR2 + " deleted!");
    for (RemoteFile remoteFile : remoteFileArray) {
        MessageDisplayer.display("Remote directory: " + remoteFile);
        if (remoteFile.toString().contains("//AVG")) {
            Assert.assertTrue("is directory ", remoteFile.isDirectory());
        }

    }
}

From source file:org.kawanfw.file.test.run.filter.BuiltInFilterTest.java

/**
 * @throws MalformedURLException// w ww .j ava 2  s . co m
 * @throws UnknownHostException
 * @throws ConnectException
 * @throws SocketException
 * @throws InvalidLoginException
 * @throws RemoteException
 * @throws IOException
 * @throws SecurityException
 */
public void doIt(RemoteSession remoteSession)
        throws MalformedURLException, UnknownHostException, ConnectException, SocketException,
        InvalidLoginException, RemoteException, IOException, SecurityException {

    RemoteFile file = new RemoteFile(remoteSession, "/");

    // List all text files in out root directory
    // using an Apache Commons FileFiter

    AndFileFilter andFileFilter = new AndFileFilter();
    andFileFilter.addFileFilter(new SuffixFileFilter(".txt"));

    RemoteFile[] files = file.listFiles((FileFilter) andFileFilter);
    for (RemoteFile remoteFile : files) {
        MessageDisplayer.display("Remote text file: " + remoteFile);
    }

    MessageDisplayer.display();
    MessageDisplayer.display("file.listFiles( new SuffixFileFilter(\".txt\") " + file);
    MessageDisplayer.display("RemoteFile [] files.length: " + files.length);
    for (int i = 0; i < files.length; i++) {
        Assert.assertTrue("file is file", files[i].isFile());
        Assert.assertTrue("file is a text file", files[i].toString().endsWith(".txt"));
        MessageDisplayer.display(files[i]);

    }

    FileFilter fileFilter = FileFileFilter.FILE;

    files = file.listFiles(fileFilter);
    MessageDisplayer.display();
    MessageDisplayer.display("file.listFiles(FileFileFilter.FILE) " + file);
    if (files == null) {
        MessageDisplayer.display("remote directory is empty: " + file);
    } else {
        MessageDisplayer.display("RemoteFile [] files.length: " + files.length);
        for (int i = 0; i < files.length; i++) {
            MessageDisplayer.display(files[i]);
            Assert.assertTrue("file is non-directory", files[i].isFile());
        }
    }

    fileFilter = DirectoryFileFilter.DIRECTORY;

    files = file.listFiles(fileFilter);
    MessageDisplayer.display();
    MessageDisplayer.display("file.listFiles(DirectoryFileFilter.DIRECTORY) " + file);
    if (files == null) {
        MessageDisplayer.display("remote directory is empty: " + file);
    } else {
        MessageDisplayer.display("RemoteFile [] files.length: " + files.length);
        for (int i = 0; i < files.length; i++) {
            Assert.assertTrue("file is directory", files[i].isDirectory());
            MessageDisplayer.display(files[i]);
        }
    }

    MessageDisplayer.display();

    // Force huge filter test
    andFileFilter = new AndFileFilter();
    int cpt = 0;
    while (cpt < 500) {
        cpt++;
        andFileFilter.addFileFilter(new SuffixFileFilter(".txt"));
    }

    String serialFilterBase64 = new ClassSerializer<FileFilter>().toBase64(andFileFilter);
    System.out.println("serialFilterBase64 size: " + (serialFilterBase64.length() / 1024) + " Kb.");

    files = file.listFiles((FileFilter) andFileFilter);
    for (RemoteFile remoteFile : files) {
        MessageDisplayer.display("Remote text file with huge FileFilter: " + remoteFile);
    }

    MessageDisplayer.display();
    MessageDisplayer.display("file.listFiles( new SuffixFileFilter(\".txt\") " + file);
    MessageDisplayer.display("RemoteFile [] files.length: " + files.length);
    for (int i = 0; i < files.length; i++) {
        Assert.assertTrue("file is file", files[i].isFile());
        Assert.assertTrue("file is a text file", files[i].toString().endsWith(".txt"));
        MessageDisplayer.display(files[i]);

    }

    MessageDisplayer.display();
    System.out.println("serialFilterBase64 size: " + (serialFilterBase64.length() / 1024) + " Kb.");

    String[] filesStr = file.list((FilenameFilter) andFileFilter);
    for (String fileStr : filesStr) {
        MessageDisplayer.display("Remote text file with huge FilenameFilter: " + fileStr);
    }

    MessageDisplayer.display();
    MessageDisplayer.display("file.list( new SuffixFileFilter(\".txt\") " + file);
    MessageDisplayer.display("String [] filesStr: " + filesStr.length);
    for (int i = 0; i < filesStr.length; i++) {
        Assert.assertTrue("file is a text file", filesStr[i].endsWith(".txt"));
        MessageDisplayer.display(filesStr[i]);

    }

}

From source file:org.kawanfw.file.test.run.remotefiles.RemoteFileTest.java

/**
 * TestReload the methods that apply to directories only
 * @throws IOException /*from   w  w  w .j  av a  2s  .c  om*/
 * @throws ClassNotFoundException 
 * 
 * @throws Exception
 */
public void testListMethods() throws IOException, ClassNotFoundException {

    MessageDisplayer.display("");

    String[] filenames = file.list();
    MessageDisplayer.display();
    MessageDisplayer.display("file.list() " + file);
    if (filenames == null) {
        MessageDisplayer.display("remote directory is empty: " + file);
    } else {
        MessageDisplayer.display("filenames.length: " + filenames.length);
        for (int i = 0; i < filenames.length; i++) {
            MessageDisplayer.display(filenames[i]);
        }
    }

    RemoteFile[] files = file.listFiles();
    MessageDisplayer.display();
    MessageDisplayer.display("file.listFiles() " + file);
    if (files == null) {
        MessageDisplayer.display("remote directory is empty: " + file);
    } else {
        MessageDisplayer.display("RemoteFile [] files.length: " + files.length);
        for (int i = 0; i < files.length; i++) {
            MessageDisplayer.display(files[i]);
        }
    }

    FilenameFilter filenameFilter = DirectoryFileFilter.DIRECTORY;

    filenames = file.list(filenameFilter);
    MessageDisplayer.display();
    MessageDisplayer.display("file.list(DirectoryFileFilter.DIRECTORY) " + file);
    if (filenames == null) {
        MessageDisplayer.display("remote directory is empty: " + file);
    } else {
        MessageDisplayer.display("filenames.length: " + filenames.length);
        for (int i = 0; i < filenames.length; i++) {
            MessageDisplayer.display(filenames[i]);
        }
    }

    FileFilter fileFilter = FileFileFilter.FILE;
    files = file.listFiles(fileFilter);
    MessageDisplayer.display();
    MessageDisplayer.display("file.listFiles(FileFileFilter.FILE) " + file);
    if (files == null) {
        MessageDisplayer.display("remote directory is empty: " + file);
    } else {
        MessageDisplayer.display("RemoteFile [] files.length: " + files.length);
        for (int i = 0; i < files.length; i++) {
            MessageDisplayer.display(files[i]);
        }
    }

    fileFilter = DirectoryFileFilter.DIRECTORY;

    files = file.listFiles(fileFilter);
    MessageDisplayer.display();
    MessageDisplayer.display("file.listFiles(DirectoryFileFilter.DIRECTORY) " + file);
    if (files == null) {
        MessageDisplayer.display("remote directory is empty: " + file);
    } else {
        MessageDisplayer.display("RemoteFile [] files.length: " + files.length);
        for (int i = 0; i < files.length; i++) {
            MessageDisplayer.display(files[i]);
        }
    }

    filenameFilter = DirectoryFileFilter.DIRECTORY;
    files = file.listFiles(filenameFilter);
    MessageDisplayer.display();
    MessageDisplayer.display("file.listFiles(filenameFilter) " + file);
    if (files == null) {
        MessageDisplayer.display("remote directory is empty: " + file);
    } else {
        MessageDisplayer.display("RemoteFile [] files.length: " + files.length);
        for (int i = 0; i < files.length; i++) {
            MessageDisplayer.display(files[i]);
        }
    }

    boolean bypass = true;
    if (bypass) {
        System.err.println("WARNING: tests on remote file filters are bypassed!");
        return;
    }

    FilenameFilter theFilenameFilter = new TheFilenameFilter();
    FileFilter theFileFilter = new TheFileFilter();

    filenames = file.list(theFilenameFilter);
    MessageDisplayer.display();
    MessageDisplayer.display("file.list(theFilenameFilter) " + file);
    if (filenames == null) {
        MessageDisplayer.display("remote directory is empty: " + file);
    } else {
        MessageDisplayer.display("filenames.length: " + filenames.length);
        for (int i = 0; i < filenames.length; i++) {
            MessageDisplayer.display(filenames[i]);
        }
    }

    files = file.listFiles(theFilenameFilter);
    MessageDisplayer.display();
    MessageDisplayer.display("file.listFiles(theFilenameFilter) " + file);
    if (files == null) {
        MessageDisplayer.display("remote directory is empty: " + file);
    } else {
        MessageDisplayer.display("RemoteFile [] files.length: " + files.length);
        for (int i = 0; i < files.length; i++) {
            MessageDisplayer.display(files[i]);
        }
    }

    files = file.listFiles(theFileFilter);
    MessageDisplayer.display();
    MessageDisplayer.display("file.listFiles(theFileFilter) " + file);
    if (files == null) {
        MessageDisplayer.display("remote directory is empty: " + file);
    } else {
        MessageDisplayer.display("RemoteFile [] files.length: " + files.length);
        for (int i = 0; i < files.length; i++) {
            MessageDisplayer.display(files[i]);
        }
    }

    MyFileFilter myFileFilter = new MyFileFilter();

    files = file.listFiles(myFileFilter);
    MessageDisplayer.display();
    MessageDisplayer.display("file.listFiles(MyFileFilter) " + file);
    if (files == null) {
        MessageDisplayer.display("remote directory is empty: " + file);
    } else {
        MessageDisplayer.display("RemoteFile [] files.length: " + files.length);
        for (int i = 0; i < files.length; i++) {
            MessageDisplayer.display(files[i]);
        }
    }
}

From source file:org.kie.guvnor.m2repo.backend.server.GuvnorM2Repository.java

/**
 * Finds files within the repository with the given filters.
 *
 * @param filters filter to apply when finding files. The filter is used to create a wildcard matcher, ie., "*fileter*.*", in which "*" is
 * to represent a multiple wildcard characters.
 * @return an collection of java.io.File with the matching files
 *///ww  w  . j  a v a2 s  .  c o  m
public Collection<File> listFiles(String filters) {
    String wildcard = "*.jar";
    if (filters != null) {
        wildcard = "*" + filters + "*.jar";
    }
    Collection<File> files = FileUtils.listFiles(new File(M2_REPO_ROOT),
            new WildcardFileFilter(wildcard, IOCase.INSENSITIVE), DirectoryFileFilter.DIRECTORY);

    return files;
}

From source file:org.lamport.tla.toolbox.tool.tlc.model.Model.java

public Model snapshot() throws CoreException {
    // Create a copy of the underlying launch configuration.
    final Model snapshot = copy(getName() + SNAP_SHOT + System.currentTimeMillis());

    // Snapshot the model's markers as well (e.g. the information about errors, see hasErrors()).
    final IMarker[] markers = getMarkers();
    for (IMarker iMarker : markers) {
        snapshot.setMarker(iMarker.getAttributes(), iMarker.getType());
    }/*  w w  w.j  av  a  2  s.  c  o m*/

    // Set the snapshot to be locked? Do we want the user to be able to run it again?
    //       snapshot.setLocked(true);

    /*
     * Snapshot (copy) the model folder which include the TLC output as well as the version
     * of the spec and module overwrites with which TLC ran.
     */
    final IPath snapshotPath = getSpec().getProject().getFolder(snapshot.getName()).getLocation();
    final IPath modelFolder = getSpec().getProject().getFolder(this.getName()).getLocation();
    // Use non-Eclipse API instead of modelFolder.copy(snapshotFolder, false,
    // monitor which supports a non-recursive copy. A recursive copy includes the
    // states/ directory leftover from TLC which waste quite some space and might
    // take some time to copy.
    try {
        FileUtils.copyDirectory(modelFolder.toFile(), snapshotPath.toFile(),
                new NotFileFilter(DirectoryFileFilter.DIRECTORY));

        // Rename .dot file name because hasStateGraphDump checks if a .dot file exists
        // that matches the name of the model.
        if (hasStateGraphDump()) {
            final IPath oldDotFile = getSpec().getProject()
                    .getFolder(snapshot.getName() + File.separator + this.getName() + ".dot").getLocation();
            final IPath newDotFile = getSpec().getProject()
                    .getFolder(snapshot.getName() + File.separator + snapshot.getName() + ".dot").getLocation();
            FileUtils.moveFile(oldDotFile.toFile(), newDotFile.toFile());
        }

        // Now that we've had a successful save, prune any snapshots, starting with the oldest, in order to assure the
        // cardinality no greater than snapshotKeepCount.
        pruneOldestSnapshots();

        // Refresh the snapshot folder after having copied files without using the
        // Eclipse resource API. Otherwise, the resource API does not see the files
        // which e.g. results in an incomplete model deletion or hasStateGraphDump
        // incorrectly returning false.
        snapshot.getFolder().refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());
    } catch (IOException e) {
        throw new CoreException(new Status(Status.ERROR, TLCActivator.PLUGIN_ID, e.getMessage(), e));
    }

    return snapshot;
}