src/main/java/org/apache/maven/shared/model/fileset/util/FileSetManager.java - maven-file-management - Git at Google

 package org.apache.maven.shared.model.fileset.util;

 /*
  * Copyright 2001-2004 The Apache Software Foundation.
  *
  * Licensed 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.
  */

 import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Set;

 import org.apache.maven.plugin.logging.Log;
 import org.apache.maven.shared.model.fileset.FileSet;
 import org.codehaus.plexus.util.DirectoryScanner;

 /**
  * Provides operations for use with FileSet instances, such as retrieving the included/excluded
  * files, deleting all matching entries, etc.
  *
  * @author jdcasey
  *
  */
 public class FileSetManager
 {

     private static final int DELETE_RETRY_SLEEP_MILLIS = 10;
     private static final String[] EMPTY_STRING_ARRAY = new String[0];

     private final boolean verbose;
     private final Log log;

     /**
      * Create a new manager instance with the supplied log instance and flag for whether to output
      * verbose messages.
      *
      * @param log The mojo log instance
      * @param verbose Whether to output verbose messages
      */
     public FileSetManager( Log log, boolean verbose )
     {
         this.log = log;
         this.verbose = verbose;
     }

     /**
      * Create a new manager instance with the supplied log instance. Verbose flag is set to false.
      *
      * @param log The mojo log instance
      */
     public FileSetManager( Log log )
     {
         this.log = log;
         this.verbose = false;
     }

     /**
      * Create a new manager instance with an empty log. Verbose flag is set to false.
      *
      * @param log The mojo log instance
      */
     public FileSetManager()
     {
         this.log = null;
         this.verbose = false;
     }

     /**
      * Get all the filenames which have been included by the rules in this fileset.
      * @param fileSet The fileset defining rules for inclusion/exclusion, and base directory.
      * @return the array of matching filenames, relative to the basedir of the file-set.
      */
     public String[] getIncludedFiles( FileSet fileSet )
     {
         DirectoryScanner scanner = scan( fileSet );

         if ( scanner != null )
         {
             return scanner.getIncludedFiles();
         }
         else
         {
             return EMPTY_STRING_ARRAY;
         }
     }

     /**
      * Get all the directory names which have been included by the rules in this fileset.
      * @param fileSet The fileset defining rules for inclusion/exclusion, and base directory.
      * @return the array of matching dirnames, relative to the basedir of the file-set.
      */
     public String[] getIncludedDirectories( FileSet fileSet )
     {
         DirectoryScanner scanner = scan( fileSet );

         if ( scanner != null )
         {
             return scanner.getIncludedDirectories();
         }
         else
         {
             return EMPTY_STRING_ARRAY;
         }
     }

     /**
      * Get all the filenames which have been excluded by the rules in this fileset.
      * @param fileSet The fileset defining rules for inclusion/exclusion, and base directory.
      * @return the array of non-matching filenames, relative to the basedir of the file-set.
      */
     public String[] getExcludedFiles( FileSet fileSet )
     {
         DirectoryScanner scanner = scan( fileSet );

         if ( scanner != null )
         {
             return scanner.getExcludedFiles();
         }
         else
         {
             return EMPTY_STRING_ARRAY;
         }
     }

     /**
      * Get all the directory names which have been excluded by the rules in this fileset.
      * @param fileSet The fileset defining rules for inclusion/exclusion, and base directory.
      * @return the array of non-matching dirnames, relative to the basedir of the file-set.
      */
     public String[] getExcludedDirectories( FileSet fileSet )
     {
         DirectoryScanner scanner = scan( fileSet );

         if ( scanner != null )
         {
             return scanner.getExcludedDirectories();
         }
         else
         {
             return EMPTY_STRING_ARRAY;
         }
     }

     /**
      * Delete the matching files and directories for the given file-set definition.
      * @param fileSet The file-set matching rules, along with search base directory
      * @throws IOException If a matching file cannot be deleted
      */
     public void delete( FileSet fileSet ) throws IOException
     {
         Set deletablePaths = findDeletablePaths( fileSet );

         if ( log != null && log.isDebugEnabled() )
         {
             log.debug( "Found deletable paths: " + String.valueOf( deletablePaths ).replace( ',', '\n' ) );
         }

         for ( Iterator it = deletablePaths.iterator(); it.hasNext(); )
         {
             String path = (String) it.next();

             File file = new File( fileSet.getDirectory(), path );

             if ( file.exists() )
             {
                 if ( file.isDirectory() && ( fileSet.isFollowSymlinks() || !isSymlink( file ) ) )
                 {
                     if ( verbose && log != null )
                     {
                         log.info( "Deleting directory: " + file );
                     }

                     removeDir( file, fileSet.isFollowSymlinks() );
                 }
                 else
                 {
                     if ( verbose && log != null )
                     {
                         log.info( "Deleting file: " + file );
                     }

                     if ( !delete( file ) )
                     {
                         throw new IOException( "Failed to delete file: " + file + ". Reason is unknown." );
                     }
                 }
             }
         }
     }

     private boolean isSymlink( File file ) throws IOException
     {
         File parent = file.getParentFile();
         File canonicalFile = file.getCanonicalFile();

         if ( log != null && log.isDebugEnabled() )
         {
             log.debug( "Checking for symlink:\nParent file's canonical path: " + parent.getCanonicalPath()
                 + "\nMy canonical path: " + canonicalFile.getPath() );
         }
         return parent != null && ( !canonicalFile.getName().equals( file.getName() ) || !canonicalFile.getPath().startsWith( parent.getCanonicalPath() ) );
     }

     private Set findDeletablePaths( FileSet fileSet )
     {
         Set includes = findDeletableDirectories( fileSet );
         includes.addAll( findDeletableFiles( fileSet, includes ) );

         return includes;
     }

     private Set findDeletableDirectories( FileSet fileSet )
     {
         if ( verbose && log != null )
         {
             log.info( "Scanning for deletable directories." );
         }

         DirectoryScanner scanner = scan( fileSet );

         if ( scanner == null )
         {
             return Collections.EMPTY_SET;
         }

         String[] includedDirs = scanner.getIncludedDirectories();
         String[] excludedDirs = scanner.getExcludedDirectories();

         Set includes = new HashSet( Arrays.asList( includedDirs ) );
         List excludes = new ArrayList( Arrays.asList( excludedDirs ) );
         List linksForDeletion = new ArrayList();

         if ( !fileSet.isFollowSymlinks() )
         {
             if ( verbose && log != null )
             {
                 log.info( "Adding symbolic link dirs which were previously excluded to the list being deleted." );
             }

             // we need to see which entries were excluded because they're symlinks...
             scanner.setFollowSymlinks( true );
             scanner.scan();

             if ( log != null && log.isDebugEnabled() )
             {
                 log.debug( "Originally marked for delete: " + includes );
                 log.debug( "Marked for preserve (with followSymlinks == false): " + excludes );
             }

             List notSymlinks = Arrays.asList( scanner.getIncludedDirectories() );

             linksForDeletion.addAll( excludes );
             linksForDeletion.retainAll( notSymlinks );

             if ( log != null && log.isDebugEnabled() )
             {
                 log.debug( "Symlinks marked for deletion (originally mismarked): " + linksForDeletion );
             }

             excludes.removeAll( notSymlinks );
         }

         for ( int i = 0; i < excludedDirs.length; i++ )
         {
             String path = excludedDirs[i];

             File excluded = new File( path );

             String parentPath = excluded.getParent();

             while( parentPath != null )
             {
                 if ( log != null && log.isDebugEnabled() )
                 {
                     log.debug( "Verifying path: " + parentPath + " is not present; contains file which is excluded." );
                 }

                 boolean removed = includes.remove( parentPath );

                 if ( removed && log != null && log.isDebugEnabled() )
                 {
                     log.debug( "Path: " + parentPath + " was removed from delete list." );
                 }

                 parentPath = new File( parentPath ).getParent();
             }
         }

         includes.addAll( linksForDeletion );

         return includes;
     }

     private Set findDeletableFiles( FileSet fileSet, Set deletableDirectories )
     {
         if ( verbose && log != null )
         {
             log.info( "Re-scanning for deletable files." );
         }

         DirectoryScanner scanner = scan( fileSet );

         if ( scanner == null )
         {
             return deletableDirectories;
         }

         String[] includedFiles = scanner.getIncludedFiles();
         String[] excludedFiles = scanner.getExcludedFiles();

         Set includes = deletableDirectories;
         includes.addAll( Arrays.asList( includedFiles ) );
         List excludes = new ArrayList( Arrays.asList( excludedFiles ) );
         List linksForDeletion = new ArrayList();

         if ( !fileSet.isFollowSymlinks() )
         {
             if ( verbose && log != null )
             {
                 log.info( "Adding symbolic link files which were previously excluded to the list being deleted." );
             }

             // we need to see which entries were excluded because they're symlinks...
             scanner.setFollowSymlinks( true );
             scanner.scan();

             if ( log != null && log.isDebugEnabled() )
             {
                 log.debug( "Originally marked for delete: " + includes );
                 log.debug( "Marked for preserve (with followSymlinks == false): " + excludes );
             }

             List notSymlinks = Arrays.asList( scanner.getExcludedFiles() );

             linksForDeletion.addAll( excludes );
             linksForDeletion.retainAll( notSymlinks );

             if ( log != null && log.isDebugEnabled() )
             {
                 log.debug( "Symlinks marked for deletion (originally mismarked): " + linksForDeletion );
             }

             excludes.removeAll( notSymlinks );
         }

         for ( int i = 0; i < excludedFiles.length; i++ )
         {
             String path = excludedFiles[i];

             File excluded = new File( path );

             String parentPath = excluded.getParent();

             while( parentPath != null )
             {
                 if ( log != null && log.isDebugEnabled() )
                 {
                     log.debug( "Verifying path: " + parentPath + " is not present; contains file which is excluded." );
                 }

                 boolean removed = includes.remove( parentPath );

                 if ( removed && log != null && log.isDebugEnabled() )
                 {
                     log.debug( "Path: " + parentPath + " was removed from delete list." );
                 }

                 parentPath = new File( parentPath ).getParent();
             }
         }

         includes.addAll( linksForDeletion );

 //        for ( Iterator it = includes.iterator(); it.hasNext(); )
 //        {
 //            String path = (String) it.next();
 //
 //            if ( includes.contains( new File( path ).getParent() ) )
 //            {
 //                it.remove();
 //            }
 //        }

         return includes;
     }

     /**
      * Delete a directory
      *
      * @param dir the directory to delete
      * @param followSymlinks whether to follow symbolic links, or simply delete the link
      */
     private void removeDir( File dir, boolean followSymlinks )
         throws IOException
     {
         String[] list = dir.list();
         if ( list == null )
         {
             list = new String[0];
         }
         for ( int i = 0; i < list.length; i++ )
         {
             String s = list[i];
             File f = new File( dir, s );
             if ( f.isDirectory() && ( followSymlinks || !isSymlink( f ) ) )
             {
                 removeDir( f, followSymlinks );
             }
             else
             {
                 if ( !delete( f ) )
                 {
                     String message = "Unable to delete file " + f.getAbsolutePath();
 // TODO:...
 //                    if ( failOnError )
 //                    {
                         throw new IOException( message );
 //                    }
 //                    else
 //                    {
 //                        getLog().info( message );
 //                    }
                 }
             }
         }

         if ( !delete( dir ) )
         {
             String message = "Unable to delete directory " + dir.getAbsolutePath();
 // TODO:...
 //            if ( failOnError )
 //            {
                 throw new IOException( message );
 //            }
 //            else
 //            {
 //                getLog().info( message );
 //            }
         }
     }

     /**
      * Accommodate Windows bug encountered in both Sun and IBM JDKs.
      * Others possible. If the delete does not work, call System.gc(),
      * wait a little and try again.
      */
     private boolean delete( File f )
     {
         if ( !f.delete() )
         {
             if ( System.getProperty( "os.name" ).toLowerCase().indexOf( "windows" ) > -1 )
             {
                 System.gc();
             }
             try
             {
                 Thread.sleep( DELETE_RETRY_SLEEP_MILLIS );
                 return f.delete();
             }
             catch ( InterruptedException ex )
             {
                 return f.delete();
             }
         }

         return true;
     }

     private DirectoryScanner scan( FileSet fileSet )
     {
         File basedir = new File( fileSet.getDirectory() );
         if ( !basedir.exists() )
         {
             return null;
         }

         DirectoryScanner scanner = new DirectoryScanner();

         String[] includesArray = fileSet.getIncludesArray();
         String[] excludesArray = fileSet.getExcludesArray();

         if ( includesArray.length < 1 && excludesArray.length < 1 )
         {
             scanner.setIncludes( new String[]{ "**" } );
         }
         else
         {
             scanner.setIncludes( includesArray );
             scanner.setExcludes( excludesArray );
         }

         scanner.setBasedir( basedir );
         scanner.setFollowSymlinks( fileSet.isFollowSymlinks() );

         scanner.scan();

         return scanner;
     }

 }
	package org.apache.maven.shared.model.fileset.util;

	/*
	* Copyright 2001-2004 The Apache Software Foundation.
	*
	* Licensed 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.
	*/

	import java.io.File;
	import java.io.IOException;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collections;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Set;

	import org.apache.maven.plugin.logging.Log;
	import org.apache.maven.shared.model.fileset.FileSet;
	import org.codehaus.plexus.util.DirectoryScanner;

	/**
	* Provides operations for use with FileSet instances, such as retrieving the included/excluded
	* files, deleting all matching entries, etc.
	*
	* @author jdcasey
	*
	*/
	public class FileSetManager
	{

	private static final int DELETE_RETRY_SLEEP_MILLIS = 10;
	private static final String[] EMPTY_STRING_ARRAY = new String[0];

	private final boolean verbose;
	private final Log log;

	/**
	* Create a new manager instance with the supplied log instance and flag for whether to output
	* verbose messages.
	*
	* @param log The mojo log instance
	* @param verbose Whether to output verbose messages
	*/
	public FileSetManager( Log log, boolean verbose )
	{
	this.log = log;
	this.verbose = verbose;
	}

	/**
	* Create a new manager instance with the supplied log instance. Verbose flag is set to false.
	*
	* @param log The mojo log instance
	*/
	public FileSetManager( Log log )
	{
	this.log = log;
	this.verbose = false;
	}

	/**
	* Create a new manager instance with an empty log. Verbose flag is set to false.
	*
	* @param log The mojo log instance
	*/
	public FileSetManager()
	{
	this.log = null;
	this.verbose = false;
	}

	/**
	* Get all the filenames which have been included by the rules in this fileset.
	* @param fileSet The fileset defining rules for inclusion/exclusion, and base directory.
	* @return the array of matching filenames, relative to the basedir of the file-set.
	*/
	public String[] getIncludedFiles( FileSet fileSet )
	{
	DirectoryScanner scanner = scan( fileSet );

	if ( scanner != null )
	{
	return scanner.getIncludedFiles();
	}
	else
	{
	return EMPTY_STRING_ARRAY;
	}
	}

	/**
	* Get all the directory names which have been included by the rules in this fileset.
	* @param fileSet The fileset defining rules for inclusion/exclusion, and base directory.
	* @return the array of matching dirnames, relative to the basedir of the file-set.
	*/
	public String[] getIncludedDirectories( FileSet fileSet )
	{
	DirectoryScanner scanner = scan( fileSet );

	if ( scanner != null )
	{
	return scanner.getIncludedDirectories();
	}
	else
	{
	return EMPTY_STRING_ARRAY;
	}
	}

	/**
	* Get all the filenames which have been excluded by the rules in this fileset.
	* @param fileSet The fileset defining rules for inclusion/exclusion, and base directory.
	* @return the array of non-matching filenames, relative to the basedir of the file-set.
	*/
	public String[] getExcludedFiles( FileSet fileSet )
	{
	DirectoryScanner scanner = scan( fileSet );

	if ( scanner != null )
	{
	return scanner.getExcludedFiles();
	}
	else
	{
	return EMPTY_STRING_ARRAY;
	}
	}

	/**
	* Get all the directory names which have been excluded by the rules in this fileset.
	* @param fileSet The fileset defining rules for inclusion/exclusion, and base directory.
	* @return the array of non-matching dirnames, relative to the basedir of the file-set.
	*/
	public String[] getExcludedDirectories( FileSet fileSet )
	{
	DirectoryScanner scanner = scan( fileSet );

	if ( scanner != null )
	{
	return scanner.getExcludedDirectories();
	}
	else
	{
	return EMPTY_STRING_ARRAY;
	}
	}

	/**
	* Delete the matching files and directories for the given file-set definition.
	* @param fileSet The file-set matching rules, along with search base directory
	* @throws IOException If a matching file cannot be deleted
	*/
	public void delete( FileSet fileSet ) throws IOException
	{
	Set deletablePaths = findDeletablePaths( fileSet );

	if ( log != null && log.isDebugEnabled() )
	{
	log.debug( "Found deletable paths: " + String.valueOf( deletablePaths ).replace( ',', '\n' ) );
	}

	for ( Iterator it = deletablePaths.iterator(); it.hasNext(); )
	{
	String path = (String) it.next();

	File file = new File( fileSet.getDirectory(), path );

	if ( file.exists() )
	{
	if ( file.isDirectory() && ( fileSet.isFollowSymlinks() \|\| !isSymlink( file ) ) )
	{
	if ( verbose && log != null )
	{
	log.info( "Deleting directory: " + file );
	}

	removeDir( file, fileSet.isFollowSymlinks() );
	}
	else
	{
	if ( verbose && log != null )
	{
	log.info( "Deleting file: " + file );
	}

	if ( !delete( file ) )
	{
	throw new IOException( "Failed to delete file: " + file + ". Reason is unknown." );
	}
	}
	}
	}
	}

	private boolean isSymlink( File file ) throws IOException
	{
	File parent = file.getParentFile();
	File canonicalFile = file.getCanonicalFile();

	if ( log != null && log.isDebugEnabled() )
	{
	log.debug( "Checking for symlink:\nParent file's canonical path: " + parent.getCanonicalPath()
	+ "\nMy canonical path: " + canonicalFile.getPath() );
	}
	return parent != null && ( !canonicalFile.getName().equals( file.getName() ) \|\| !canonicalFile.getPath().startsWith( parent.getCanonicalPath() ) );
	}

	private Set findDeletablePaths( FileSet fileSet )
	{
	Set includes = findDeletableDirectories( fileSet );
	includes.addAll( findDeletableFiles( fileSet, includes ) );

	return includes;
	}

	private Set findDeletableDirectories( FileSet fileSet )
	{
	if ( verbose && log != null )
	{
	log.info( "Scanning for deletable directories." );
	}

	DirectoryScanner scanner = scan( fileSet );

	if ( scanner == null )
	{
	return Collections.EMPTY_SET;
	}

	String[] includedDirs = scanner.getIncludedDirectories();
	String[] excludedDirs = scanner.getExcludedDirectories();

	Set includes = new HashSet( Arrays.asList( includedDirs ) );
	List excludes = new ArrayList( Arrays.asList( excludedDirs ) );
	List linksForDeletion = new ArrayList();

	if ( !fileSet.isFollowSymlinks() )
	{
	if ( verbose && log != null )
	{
	log.info( "Adding symbolic link dirs which were previously excluded to the list being deleted." );
	}

	// we need to see which entries were excluded because they're symlinks...
	scanner.setFollowSymlinks( true );
	scanner.scan();

	if ( log != null && log.isDebugEnabled() )
	{
	log.debug( "Originally marked for delete: " + includes );
	log.debug( "Marked for preserve (with followSymlinks == false): " + excludes );
	}

	List notSymlinks = Arrays.asList( scanner.getIncludedDirectories() );

	linksForDeletion.addAll( excludes );
	linksForDeletion.retainAll( notSymlinks );

	if ( log != null && log.isDebugEnabled() )
	{
	log.debug( "Symlinks marked for deletion (originally mismarked): " + linksForDeletion );
	}

	excludes.removeAll( notSymlinks );
	}

	for ( int i = 0; i < excludedDirs.length; i++ )
	{
	String path = excludedDirs[i];

	File excluded = new File( path );

	String parentPath = excluded.getParent();

	while( parentPath != null )
	{
	if ( log != null && log.isDebugEnabled() )
	{
	log.debug( "Verifying path: " + parentPath + " is not present; contains file which is excluded." );
	}

	boolean removed = includes.remove( parentPath );

	if ( removed && log != null && log.isDebugEnabled() )
	{
	log.debug( "Path: " + parentPath + " was removed from delete list." );
	}

	parentPath = new File( parentPath ).getParent();
	}
	}

	includes.addAll( linksForDeletion );

	return includes;
	}

	private Set findDeletableFiles( FileSet fileSet, Set deletableDirectories )
	{
	if ( verbose && log != null )
	{
	log.info( "Re-scanning for deletable files." );
	}

	DirectoryScanner scanner = scan( fileSet );

	if ( scanner == null )
	{
	return deletableDirectories;
	}

	String[] includedFiles = scanner.getIncludedFiles();
	String[] excludedFiles = scanner.getExcludedFiles();

	Set includes = deletableDirectories;
	includes.addAll( Arrays.asList( includedFiles ) );
	List excludes = new ArrayList( Arrays.asList( excludedFiles ) );
	List linksForDeletion = new ArrayList();

	if ( !fileSet.isFollowSymlinks() )
	{
	if ( verbose && log != null )
	{
	log.info( "Adding symbolic link files which were previously excluded to the list being deleted." );
	}

	// we need to see which entries were excluded because they're symlinks...
	scanner.setFollowSymlinks( true );
	scanner.scan();

	if ( log != null && log.isDebugEnabled() )
	{
	log.debug( "Originally marked for delete: " + includes );
	log.debug( "Marked for preserve (with followSymlinks == false): " + excludes );
	}

	List notSymlinks = Arrays.asList( scanner.getExcludedFiles() );

	linksForDeletion.addAll( excludes );
	linksForDeletion.retainAll( notSymlinks );

	if ( log != null && log.isDebugEnabled() )
	{
	log.debug( "Symlinks marked for deletion (originally mismarked): " + linksForDeletion );
	}

	excludes.removeAll( notSymlinks );
	}

	for ( int i = 0; i < excludedFiles.length; i++ )
	{
	String path = excludedFiles[i];

	File excluded = new File( path );

	String parentPath = excluded.getParent();

	while( parentPath != null )
	{
	if ( log != null && log.isDebugEnabled() )
	{
	log.debug( "Verifying path: " + parentPath + " is not present; contains file which is excluded." );
	}

	boolean removed = includes.remove( parentPath );

	if ( removed && log != null && log.isDebugEnabled() )
	{
	log.debug( "Path: " + parentPath + " was removed from delete list." );
	}

	parentPath = new File( parentPath ).getParent();
	}
	}

	includes.addAll( linksForDeletion );

	// for ( Iterator it = includes.iterator(); it.hasNext(); )
	// {
	// String path = (String) it.next();
	//
	// if ( includes.contains( new File( path ).getParent() ) )
	// {
	// it.remove();
	// }
	// }

	return includes;
	}

	/**
	* Delete a directory
	*
	* @param dir the directory to delete
	* @param followSymlinks whether to follow symbolic links, or simply delete the link
	*/
	private void removeDir( File dir, boolean followSymlinks )
	throws IOException
	{
	String[] list = dir.list();
	if ( list == null )
	{
	list = new String[0];
	}
	for ( int i = 0; i < list.length; i++ )
	{
	String s = list[i];
	File f = new File( dir, s );
	if ( f.isDirectory() && ( followSymlinks \|\| !isSymlink( f ) ) )
	{
	removeDir( f, followSymlinks );
	}
	else
	{
	if ( !delete( f ) )
	{
	String message = "Unable to delete file " + f.getAbsolutePath();
	// TODO:...
	// if ( failOnError )
	// {
	throw new IOException( message );
	// }
	// else
	// {
	// getLog().info( message );
	// }
	}
	}
	}

	if ( !delete( dir ) )
	{
	String message = "Unable to delete directory " + dir.getAbsolutePath();
	// TODO:...
	// if ( failOnError )
	// {
	throw new IOException( message );
	// }
	// else
	// {
	// getLog().info( message );
	// }
	}
	}

	/**
	* Accommodate Windows bug encountered in both Sun and IBM JDKs.
	* Others possible. If the delete does not work, call System.gc(),
	* wait a little and try again.
	*/
	private boolean delete( File f )
	{
	if ( !f.delete() )
	{
	if ( System.getProperty( "os.name" ).toLowerCase().indexOf( "windows" ) > -1 )
	{
	System.gc();
	}
	try
	{
	Thread.sleep( DELETE_RETRY_SLEEP_MILLIS );
	return f.delete();
	}
	catch ( InterruptedException ex )
	{
	return f.delete();
	}
	}

	return true;
	}

	private DirectoryScanner scan( FileSet fileSet )
	{
	File basedir = new File( fileSet.getDirectory() );
	if ( !basedir.exists() )
	{
	return null;
	}

	DirectoryScanner scanner = new DirectoryScanner();

	String[] includesArray = fileSet.getIncludesArray();
	String[] excludesArray = fileSet.getExcludesArray();

	if ( includesArray.length < 1 && excludesArray.length < 1 )
	{
	scanner.setIncludes( new String[]{ "**" } );
	}
	else
	{
	scanner.setIncludes( includesArray );
	scanner.setExcludes( excludesArray );
	}

	scanner.setBasedir( basedir );
	scanner.setFollowSymlinks( fileSet.isFollowSymlinks() );

	scanner.scan();

	return scanner;
	}

	}