src/main/java/org/apache/maven/plugins/clean/Cleaner.java - maven-clean-plugin - Git at Google

 package org.apache.maven.plugins.clean;

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you 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.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.StandardCopyOption;
 import java.util.ArrayDeque;
 import java.util.Deque;

 import org.apache.maven.execution.ExecutionListener;
 import org.apache.maven.execution.MavenSession;
 import org.apache.maven.plugin.logging.Log;
 import org.apache.maven.shared.utils.Os;
 import org.eclipse.aether.SessionData;

 import static org.apache.maven.plugins.clean.CleanMojo.FAST_MODE_BACKGROUND;
 import static org.apache.maven.plugins.clean.CleanMojo.FAST_MODE_DEFER;

 /**
  * Cleans directories.
  *
  * @author Benjamin Bentmann
  */
 class Cleaner
 {

     private static final boolean ON_WINDOWS = Os.isFamily( Os.FAMILY_WINDOWS );

     private static final String LAST_DIRECTORY_TO_DELETE = Cleaner.class.getName() + ".lastDirectoryToDelete";

     /**
      * The maven session.  This is typically non-null in a real run, but it can be during unit tests.
      */
     private final MavenSession session;

     private final Logger logDebug;

     private final Logger logInfo;

     private final Logger logVerbose;

     private final Logger logWarn;

     private final File fastDir;

     private final String fastMode;

     /**
      * Creates a new cleaner.
      * @param log The logger to use, may be <code>null</code> to disable logging.
      * @param verbose Whether to perform verbose logging.
      * @param fastMode The fast deletion mode
      */
     Cleaner( MavenSession session, final Log log, boolean verbose, File fastDir, String fastMode )
     {
         logDebug = ( log == null || !log.isDebugEnabled() ) ? null : log::debug;

         logInfo = ( log == null || !log.isInfoEnabled() ) ? null : log::info;

         logWarn = ( log == null || !log.isWarnEnabled() ) ? null : log::warn;

         logVerbose = verbose ? logInfo : logDebug;

         this.session = session;
         this.fastDir = fastDir;
         this.fastMode = fastMode;
     }

     /**
      * Deletes the specified directories and its contents.
      *
      * @param basedir The directory to delete, must not be <code>null</code>. Non-existing directories will be silently
      *            ignored.
      * @param selector The selector used to determine what contents to delete, may be <code>null</code> to delete
      *            everything.
      * @param followSymlinks Whether to follow symlinks.
      * @param failOnError Whether to abort with an exception in case a selected file/directory could not be deleted.
      * @param retryOnError Whether to undertake additional delete attempts in case the first attempt failed.
      * @throws IOException If a file/directory could not be deleted and <code>failOnError</code> is <code>true</code>.
      */
     public void delete( File basedir, Selector selector, boolean followSymlinks, boolean failOnError,
                         boolean retryOnError )
         throws IOException
     {
         if ( !basedir.isDirectory() )
         {
             if ( !basedir.exists() )
             {
                 if ( logDebug != null )
                 {
                     logDebug.log( "Skipping non-existing directory " + basedir );
                 }
                 return;
             }
             throw new IOException( "Invalid base directory " + basedir );
         }

         if ( logInfo != null )
         {
             logInfo.log( "Deleting " + basedir + ( selector != null ? " (" + selector + ")" : "" ) );
         }

         File file = followSymlinks ? basedir : basedir.getCanonicalFile();

         if ( selector == null && !followSymlinks && fastDir != null && session != null )
         {
             // If anything wrong happens, we'll just use the usual deletion mechanism
             if ( fastDelete( file ) )
             {
                 return;
             }
         }

         delete( file, "", selector, followSymlinks, failOnError, retryOnError );
     }

     private boolean fastDelete( File baseDirFile )
     {
         Path baseDir = baseDirFile.toPath();
         Path fastDir = this.fastDir.toPath();
         // Handle the case where we use ${maven.multiModuleProjectDirectory}/target/.clean for example
         if ( fastDir.toAbsolutePath().startsWith( baseDir.toAbsolutePath() ) )
         {
             try
             {
                 String prefix = baseDir.getFileName().toString() + ".";
                 Path tmpDir = Files.createTempDirectory( baseDir.getParent(), prefix );
                 try
                 {
                     Files.move( baseDir, tmpDir, StandardCopyOption.REPLACE_EXISTING );
                     if ( session != null )
                     {
                         session.getRepositorySession().getData().set( LAST_DIRECTORY_TO_DELETE, baseDir.toFile() );
                     }
                     baseDir = tmpDir;
                 }
                 catch ( IOException e )
                 {
                     Files.delete( tmpDir );
                     throw e;
                 }
             }
             catch ( IOException e )
             {
                 if ( logDebug != null )
                 {
                     // TODO: this Logger interface cannot log exceptions and needs refactoring
                     logDebug.log( "Unable to fast delete directory: " + e );
                 }
                 return false;
             }
         }
         // Create fastDir and the needed parents if needed
         try
         {
             if ( !Files.isDirectory( fastDir ) )
             {
                 Files.createDirectories( fastDir );
             }
         }
         catch ( IOException e )
         {
             if ( logDebug != null )
             {
                 // TODO: this Logger interface cannot log exceptions and needs refactoring
                 logDebug.log( "Unable to fast delete directory as the path "
                         + fastDir + " does not point to a directory or cannot be created: " + e );
             }
             return false;
         }

         try
         {
             Path tmpDir = Files.createTempDirectory( fastDir, "" );
             Path dstDir = tmpDir.resolve( baseDir.getFileName() );
             // Note that by specifying the ATOMIC_MOVE, we expect an exception to be thrown
             // if the path leads to a directory on another mountpoint.  If this is the case
             // or any other exception occurs, an exception will be thrown in which case
             // the method will return false and the usual deletion will be performed.
             Files.move( baseDir, dstDir, StandardCopyOption.ATOMIC_MOVE );
             BackgroundCleaner.delete( this, tmpDir.toFile(), fastMode );
             return true;
         }
         catch ( IOException e )
         {
             if ( logDebug != null )
             {
                 // TODO: this Logger interface cannot log exceptions and needs refactoring
                 logDebug.log( "Unable to fast delete directory: " + e );
             }
             return false;
         }
     }

     /**
      * Deletes the specified file or directory.
      *
      * @param file The file/directory to delete, must not be <code>null</code>. If <code>followSymlinks</code> is
      *            <code>false</code>, it is assumed that the parent file is canonical.
      * @param pathname The relative pathname of the file, using {@link File#separatorChar}, must not be
      *            <code>null</code>.
      * @param selector The selector used to determine what contents to delete, may be <code>null</code> to delete
      *            everything.
      * @param followSymlinks Whether to follow symlinks.
      * @param failOnError Whether to abort with an exception in case a selected file/directory could not be deleted.
      * @param retryOnError Whether to undertake additional delete attempts in case the first attempt failed.
      * @return The result of the cleaning, never <code>null</code>.
      * @throws IOException If a file/directory could not be deleted and <code>failOnError</code> is <code>true</code>.
      */
     private Result delete( File file, String pathname, Selector selector, boolean followSymlinks, boolean failOnError,
                            boolean retryOnError )
         throws IOException
     {
         Result result = new Result();

         boolean isDirectory = file.isDirectory();

         if ( isDirectory )
         {
             if ( selector == null || selector.couldHoldSelected( pathname ) )
             {
                 final boolean isSymlink = Files.isSymbolicLink( file.toPath() );
                 File canonical = followSymlinks ? file : file.getCanonicalFile();
                 if ( followSymlinks || !isSymlink )
                 {
                     String[] filenames = canonical.list();
                     if ( filenames != null )
                     {
                         String prefix = pathname.length() > 0 ? pathname + File.separatorChar : "";
                         for ( int i = filenames.length - 1; i >= 0; i-- )
                         {
                             String filename = filenames[i];
                             File child = new File( canonical, filename );
                             result.update( delete( child, prefix + filename, selector, followSymlinks, failOnError,
                                                    retryOnError ) );
                         }
                     }
                 }
                 else if ( logDebug != null )
                 {
                     logDebug.log( "Not recursing into symlink " + file );
                 }
             }
             else if ( logDebug != null )
             {
                 logDebug.log( "Not recursing into directory without included files " + file );
             }
         }

         if ( !result.excluded && ( selector == null || selector.isSelected( pathname ) ) )
         {
             if ( logVerbose != null )
             {
                 if ( isDirectory )
                 {
                     logVerbose.log( "Deleting directory " + file );
                 }
                 else if ( file.exists() )
                 {
                     logVerbose.log( "Deleting file " + file );
                 }
                 else
                 {
                     logVerbose.log( "Deleting dangling symlink " + file );
                 }
             }
             result.failures += delete( file, failOnError, retryOnError );
         }
         else
         {
             result.excluded = true;
         }

         return result;
     }

     /**
      * Deletes the specified file, directory. If the path denotes a symlink, only the link is removed, its target is
      * left untouched.
      *
      * @param file The file/directory to delete, must not be <code>null</code>.
      * @param failOnError Whether to abort with an exception in case the file/directory could not be deleted.
      * @param retryOnError Whether to undertake additional delete attempts in case the first attempt failed.
      * @return <code>0</code> if the file was deleted, <code>1</code> otherwise.
      * @throws IOException If a file/directory could not be deleted and <code>failOnError</code> is <code>true</code>.
      */
     private int delete( File file, boolean failOnError, boolean retryOnError )
         throws IOException
     {
         if ( !file.delete() )
         {
             boolean deleted = false;

             if ( retryOnError )
             {
                 if ( ON_WINDOWS )
                 {
                     // try to release any locks held by non-closed files
                     System.gc();
                 }

                 final int[] delays = { 50, 250, 750 };
                 for ( int i = 0; !deleted && i < delays.length; i++ )
                 {
                     try
                     {
                         Thread.sleep( delays[i] );
                     }
                     catch ( InterruptedException e )
                     {
                         // ignore
                     }
                     deleted = file.delete() || !file.exists();
                 }
             }
             else
             {
                 deleted = !file.exists();
             }

             if ( !deleted )
             {
                 if ( failOnError )
                 {
                     throw new IOException( "Failed to delete " + file );
                 }
                 else
                 {
                     if ( logWarn != null )
                     {
                         logWarn.log( "Failed to delete " + file );
                     }
                     return 1;
                 }
             }
         }

         return 0;
     }

     private static class Result
     {

         private int failures;

         private boolean excluded;

         public void update( Result result )
         {
             failures += result.failures;
             excluded |= result.excluded;
         }

     }

     private interface Logger
     {

         void log( CharSequence message );

     }

     private static class BackgroundCleaner extends Thread
     {

         private static BackgroundCleaner instance;

         private final Deque<File> filesToDelete = new ArrayDeque<>();

         private final Cleaner cleaner;

         private final String fastMode;

         private static final int NEW = 0;
         private static final int RUNNING = 1;
         private static final int STOPPED = 2;

         private int status = NEW;

         public static void delete( Cleaner cleaner, File dir, String fastMode )
         {
             synchronized ( BackgroundCleaner.class )
             {
                 if ( instance == null || !instance.doDelete( dir ) )
                 {
                     instance = new BackgroundCleaner( cleaner, dir, fastMode );
                 }
             }
         }

         static void sessionEnd()
         {
             synchronized ( BackgroundCleaner.class )
             {
                 if ( instance != null )
                 {
                     instance.doSessionEnd();
                 }
             }
         }

         private BackgroundCleaner( Cleaner cleaner, File dir, String fastMode )
         {
             super( "mvn-background-cleaner" );
             this.cleaner = cleaner;
             this.fastMode = fastMode;
             init( cleaner.fastDir, dir );
         }

         public void run()
         {
             while ( true )
             {
                 File basedir = pollNext();
                 if ( basedir == null )
                 {
                     break;
                 }
                 try
                 {
                     cleaner.delete( basedir, "", null, false, false, true );
                 }
                 catch ( IOException e )
                 {
                     // do not display errors
                 }
             }
         }

         synchronized void init( File fastDir, File dir )
         {
             if ( fastDir.isDirectory() )
             {
                 File[] children = fastDir.listFiles();
                 if ( children != null && children.length > 0 )
                 {
                     for ( File child : children )
                     {
                         doDelete( child );
                     }
                 }
             }
             doDelete( dir );
         }

         synchronized File pollNext()
         {
             File basedir = filesToDelete.poll();
             if ( basedir == null )
             {
                 if ( cleaner.session != null )
                 {
                     SessionData data = cleaner.session.getRepositorySession().getData();
                     File lastDir = ( File ) data.get( LAST_DIRECTORY_TO_DELETE );
                     if ( lastDir != null )
                     {
                         data.set( LAST_DIRECTORY_TO_DELETE, null );
                         return lastDir;
                     }
                 }
                 status = STOPPED;
                 notifyAll();
             }
             return basedir;
         }

         synchronized boolean doDelete( File dir )
         {
             if ( status == STOPPED )
             {
                 return false;
             }
             filesToDelete.add( dir );
             if ( status == NEW && FAST_MODE_BACKGROUND.equals( fastMode ) )
             {
                 status = RUNNING;
                 notifyAll();
                 start();
             }
             wrapExecutionListener();
             return true;
         }

         /**
          * If this has not been done already, we wrap the ExecutionListener inside a proxy
          * which simply delegates call to the previous listener.  When the session ends, it will
          * also call {@link BackgroundCleaner#sessionEnd()}.
          * There's no clean API to do that properly as this is a very unusual use case for a plugin
          * to outlive its main execution.
          */
         private void wrapExecutionListener()
         {
             ExecutionListener executionListener = cleaner.session.getRequest().getExecutionListener();
             if ( executionListener == null
                     || !Proxy.isProxyClass( executionListener.getClass() )
                     || !( Proxy.getInvocationHandler( executionListener ) instanceof SpyInvocationHandler ) )
             {
                 ExecutionListener listener = ( ExecutionListener ) Proxy.newProxyInstance(
                         ExecutionListener.class.getClassLoader(),
                         new Class[] { ExecutionListener.class },
                         new SpyInvocationHandler( executionListener ) );
                 cleaner.session.getRequest().setExecutionListener( listener );
             }
         }

         synchronized void doSessionEnd()
         {
             if ( status != STOPPED )
             {
                 if ( status == NEW )
                 {
                     start();
                 }
                 if ( !FAST_MODE_DEFER.equals( fastMode ) )
                 {
                     try
                     {
                         cleaner.logInfo.log( "Waiting for background file deletion" );
                         while ( status != STOPPED )
                         {
                             wait();
                         }
                     }
                     catch ( InterruptedException e )
                     {
                         // ignore
                     }
                 }
             }
         }

     }

     static class SpyInvocationHandler implements InvocationHandler
     {
         private final ExecutionListener delegate;

         SpyInvocationHandler( ExecutionListener delegate )
         {
             this.delegate = delegate;
         }

         @Override
         public Object invoke( Object proxy, Method method, Object[] args ) throws Throwable
         {
             if ( "sessionEnded".equals( method.getName() ) )
             {
                 BackgroundCleaner.sessionEnd();
             }
             if ( delegate != null )
             {
                 return method.invoke( delegate, args );
             }
             return null;
         }

     }

 }
	package org.apache.maven.plugins.clean;

	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you 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.lang.reflect.InvocationHandler;
	import java.lang.reflect.Method;
	import java.lang.reflect.Proxy;
	import java.nio.file.Files;
	import java.nio.file.Path;
	import java.nio.file.StandardCopyOption;
	import java.util.ArrayDeque;
	import java.util.Deque;

	import org.apache.maven.execution.ExecutionListener;
	import org.apache.maven.execution.MavenSession;
	import org.apache.maven.plugin.logging.Log;
	import org.apache.maven.shared.utils.Os;
	import org.eclipse.aether.SessionData;

	import static org.apache.maven.plugins.clean.CleanMojo.FAST_MODE_BACKGROUND;
	import static org.apache.maven.plugins.clean.CleanMojo.FAST_MODE_DEFER;

	/**
	* Cleans directories.
	*
	* @author Benjamin Bentmann
	*/
	class Cleaner
	{

	private static final boolean ON_WINDOWS = Os.isFamily( Os.FAMILY_WINDOWS );

	private static final String LAST_DIRECTORY_TO_DELETE = Cleaner.class.getName() + ".lastDirectoryToDelete";

	/**
	* The maven session. This is typically non-null in a real run, but it can be during unit tests.
	*/
	private final MavenSession session;

	private final Logger logDebug;

	private final Logger logInfo;

	private final Logger logVerbose;

	private final Logger logWarn;

	private final File fastDir;

	private final String fastMode;

	/**
	* Creates a new cleaner.
	* @param log The logger to use, may be <code>null</code> to disable logging.
	* @param verbose Whether to perform verbose logging.
	* @param fastMode The fast deletion mode
	*/
	Cleaner( MavenSession session, final Log log, boolean verbose, File fastDir, String fastMode )
	{
	logDebug = ( log == null \|\| !log.isDebugEnabled() ) ? null : log::debug;

	logInfo = ( log == null \|\| !log.isInfoEnabled() ) ? null : log::info;

	logWarn = ( log == null \|\| !log.isWarnEnabled() ) ? null : log::warn;

	logVerbose = verbose ? logInfo : logDebug;

	this.session = session;
	this.fastDir = fastDir;
	this.fastMode = fastMode;
	}

	/**
	* Deletes the specified directories and its contents.
	*
	* @param basedir The directory to delete, must not be <code>null</code>. Non-existing directories will be silently
	* ignored.
	* @param selector The selector used to determine what contents to delete, may be <code>null</code> to delete
	* everything.
	* @param followSymlinks Whether to follow symlinks.
	* @param failOnError Whether to abort with an exception in case a selected file/directory could not be deleted.
	* @param retryOnError Whether to undertake additional delete attempts in case the first attempt failed.
	* @throws IOException If a file/directory could not be deleted and <code>failOnError</code> is <code>true</code>.
	*/
	public void delete( File basedir, Selector selector, boolean followSymlinks, boolean failOnError,
	boolean retryOnError )
	throws IOException
	{
	if ( !basedir.isDirectory() )
	{
	if ( !basedir.exists() )
	{
	if ( logDebug != null )
	{
	logDebug.log( "Skipping non-existing directory " + basedir );
	}
	return;
	}
	throw new IOException( "Invalid base directory " + basedir );
	}

	if ( logInfo != null )
	{
	logInfo.log( "Deleting " + basedir + ( selector != null ? " (" + selector + ")" : "" ) );
	}

	File file = followSymlinks ? basedir : basedir.getCanonicalFile();

	if ( selector == null && !followSymlinks && fastDir != null && session != null )
	{
	// If anything wrong happens, we'll just use the usual deletion mechanism
	if ( fastDelete( file ) )
	{
	return;
	}
	}

	delete( file, "", selector, followSymlinks, failOnError, retryOnError );
	}

	private boolean fastDelete( File baseDirFile )
	{
	Path baseDir = baseDirFile.toPath();
	Path fastDir = this.fastDir.toPath();
	// Handle the case where we use ${maven.multiModuleProjectDirectory}/target/.clean for example
	if ( fastDir.toAbsolutePath().startsWith( baseDir.toAbsolutePath() ) )
	{
	try
	{
	String prefix = baseDir.getFileName().toString() + ".";
	Path tmpDir = Files.createTempDirectory( baseDir.getParent(), prefix );
	try
	{
	Files.move( baseDir, tmpDir, StandardCopyOption.REPLACE_EXISTING );
	if ( session != null )
	{
	session.getRepositorySession().getData().set( LAST_DIRECTORY_TO_DELETE, baseDir.toFile() );
	}
	baseDir = tmpDir;
	}
	catch ( IOException e )
	{
	Files.delete( tmpDir );
	throw e;
	}
	}
	catch ( IOException e )
	{
	if ( logDebug != null )
	{
	// TODO: this Logger interface cannot log exceptions and needs refactoring
	logDebug.log( "Unable to fast delete directory: " + e );
	}
	return false;
	}
	}
	// Create fastDir and the needed parents if needed
	try
	{
	if ( !Files.isDirectory( fastDir ) )
	{
	Files.createDirectories( fastDir );
	}
	}
	catch ( IOException e )
	{
	if ( logDebug != null )
	{
	// TODO: this Logger interface cannot log exceptions and needs refactoring
	logDebug.log( "Unable to fast delete directory as the path "
	+ fastDir + " does not point to a directory or cannot be created: " + e );
	}
	return false;
	}

	try
	{
	Path tmpDir = Files.createTempDirectory( fastDir, "" );
	Path dstDir = tmpDir.resolve( baseDir.getFileName() );
	// Note that by specifying the ATOMIC_MOVE, we expect an exception to be thrown
	// if the path leads to a directory on another mountpoint. If this is the case
	// or any other exception occurs, an exception will be thrown in which case
	// the method will return false and the usual deletion will be performed.
	Files.move( baseDir, dstDir, StandardCopyOption.ATOMIC_MOVE );
	BackgroundCleaner.delete( this, tmpDir.toFile(), fastMode );
	return true;
	}
	catch ( IOException e )
	{
	if ( logDebug != null )
	{
	// TODO: this Logger interface cannot log exceptions and needs refactoring
	logDebug.log( "Unable to fast delete directory: " + e );
	}
	return false;
	}
	}

	/**
	* Deletes the specified file or directory.
	*
	* @param file The file/directory to delete, must not be <code>null</code>. If <code>followSymlinks</code> is
	* <code>false</code>, it is assumed that the parent file is canonical.
	* @param pathname The relative pathname of the file, using {@link File#separatorChar}, must not be
	* <code>null</code>.
	* @param selector The selector used to determine what contents to delete, may be <code>null</code> to delete
	* everything.
	* @param followSymlinks Whether to follow symlinks.
	* @param failOnError Whether to abort with an exception in case a selected file/directory could not be deleted.
	* @param retryOnError Whether to undertake additional delete attempts in case the first attempt failed.
	* @return The result of the cleaning, never <code>null</code>.
	* @throws IOException If a file/directory could not be deleted and <code>failOnError</code> is <code>true</code>.
	*/
	private Result delete( File file, String pathname, Selector selector, boolean followSymlinks, boolean failOnError,
	boolean retryOnError )
	throws IOException
	{
	Result result = new Result();

	boolean isDirectory = file.isDirectory();

	if ( isDirectory )
	{
	if ( selector == null \|\| selector.couldHoldSelected( pathname ) )
	{
	final boolean isSymlink = Files.isSymbolicLink( file.toPath() );
	File canonical = followSymlinks ? file : file.getCanonicalFile();
	if ( followSymlinks \|\| !isSymlink )
	{
	String[] filenames = canonical.list();
	if ( filenames != null )
	{
	String prefix = pathname.length() > 0 ? pathname + File.separatorChar : "";
	for ( int i = filenames.length - 1; i >= 0; i-- )
	{
	String filename = filenames[i];
	File child = new File( canonical, filename );
	result.update( delete( child, prefix + filename, selector, followSymlinks, failOnError,
	retryOnError ) );
	}
	}
	}
	else if ( logDebug != null )
	{
	logDebug.log( "Not recursing into symlink " + file );
	}
	}
	else if ( logDebug != null )
	{
	logDebug.log( "Not recursing into directory without included files " + file );
	}
	}

	if ( !result.excluded && ( selector == null \|\| selector.isSelected( pathname ) ) )
	{
	if ( logVerbose != null )
	{
	if ( isDirectory )
	{
	logVerbose.log( "Deleting directory " + file );
	}
	else if ( file.exists() )
	{
	logVerbose.log( "Deleting file " + file );
	}
	else
	{
	logVerbose.log( "Deleting dangling symlink " + file );
	}
	}
	result.failures += delete( file, failOnError, retryOnError );
	}
	else
	{
	result.excluded = true;
	}

	return result;
	}

	/**
	* Deletes the specified file, directory. If the path denotes a symlink, only the link is removed, its target is
	* left untouched.
	*
	* @param file The file/directory to delete, must not be <code>null</code>.
	* @param failOnError Whether to abort with an exception in case the file/directory could not be deleted.
	* @param retryOnError Whether to undertake additional delete attempts in case the first attempt failed.
	* @return <code>0</code> if the file was deleted, <code>1</code> otherwise.
	* @throws IOException If a file/directory could not be deleted and <code>failOnError</code> is <code>true</code>.
	*/
	private int delete( File file, boolean failOnError, boolean retryOnError )
	throws IOException
	{
	if ( !file.delete() )
	{
	boolean deleted = false;

	if ( retryOnError )
	{
	if ( ON_WINDOWS )
	{
	// try to release any locks held by non-closed files
	System.gc();
	}

	final int[] delays = { 50, 250, 750 };
	for ( int i = 0; !deleted && i < delays.length; i++ )
	{
	try
	{
	Thread.sleep( delays[i] );
	}
	catch ( InterruptedException e )
	{
	// ignore
	}
	deleted = file.delete() \|\| !file.exists();
	}
	}
	else
	{
	deleted = !file.exists();
	}

	if ( !deleted )
	{
	if ( failOnError )
	{
	throw new IOException( "Failed to delete " + file );
	}
	else
	{
	if ( logWarn != null )
	{
	logWarn.log( "Failed to delete " + file );
	}
	return 1;
	}
	}
	}

	return 0;
	}

	private static class Result
	{

	private int failures;

	private boolean excluded;

	public void update( Result result )
	{
	failures += result.failures;
	excluded \|= result.excluded;
	}

	}

	private interface Logger
	{

	void log( CharSequence message );

	}

	private static class BackgroundCleaner extends Thread
	{

	private static BackgroundCleaner instance;

	private final Deque<File> filesToDelete = new ArrayDeque<>();

	private final Cleaner cleaner;

	private final String fastMode;

	private static final int NEW = 0;
	private static final int RUNNING = 1;
	private static final int STOPPED = 2;

	private int status = NEW;

	public static void delete( Cleaner cleaner, File dir, String fastMode )
	{
	synchronized ( BackgroundCleaner.class )
	{
	if ( instance == null \|\| !instance.doDelete( dir ) )
	{
	instance = new BackgroundCleaner( cleaner, dir, fastMode );
	}
	}
	}

	static void sessionEnd()
	{
	synchronized ( BackgroundCleaner.class )
	{
	if ( instance != null )
	{
	instance.doSessionEnd();
	}
	}
	}

	private BackgroundCleaner( Cleaner cleaner, File dir, String fastMode )
	{
	super( "mvn-background-cleaner" );
	this.cleaner = cleaner;
	this.fastMode = fastMode;
	init( cleaner.fastDir, dir );
	}

	public void run()
	{
	while ( true )
	{
	File basedir = pollNext();
	if ( basedir == null )
	{
	break;
	}
	try
	{
	cleaner.delete( basedir, "", null, false, false, true );
	}
	catch ( IOException e )
	{
	// do not display errors
	}
	}
	}

	synchronized void init( File fastDir, File dir )
	{
	if ( fastDir.isDirectory() )
	{
	File[] children = fastDir.listFiles();
	if ( children != null && children.length > 0 )
	{
	for ( File child : children )
	{
	doDelete( child );
	}
	}
	}
	doDelete( dir );
	}

	synchronized File pollNext()
	{
	File basedir = filesToDelete.poll();
	if ( basedir == null )
	{
	if ( cleaner.session != null )
	{
	SessionData data = cleaner.session.getRepositorySession().getData();
	File lastDir = ( File ) data.get( LAST_DIRECTORY_TO_DELETE );
	if ( lastDir != null )
	{
	data.set( LAST_DIRECTORY_TO_DELETE, null );
	return lastDir;
	}
	}
	status = STOPPED;
	notifyAll();
	}
	return basedir;
	}

	synchronized boolean doDelete( File dir )
	{
	if ( status == STOPPED )
	{
	return false;
	}
	filesToDelete.add( dir );
	if ( status == NEW && FAST_MODE_BACKGROUND.equals( fastMode ) )
	{
	status = RUNNING;
	notifyAll();
	start();
	}
	wrapExecutionListener();
	return true;
	}

	/**
	* If this has not been done already, we wrap the ExecutionListener inside a proxy
	* which simply delegates call to the previous listener. When the session ends, it will
	* also call {@link BackgroundCleaner#sessionEnd()}.
	* There's no clean API to do that properly as this is a very unusual use case for a plugin
	* to outlive its main execution.
	*/
	private void wrapExecutionListener()
	{
	ExecutionListener executionListener = cleaner.session.getRequest().getExecutionListener();
	if ( executionListener == null
	\|\| !Proxy.isProxyClass( executionListener.getClass() )
	\|\| !( Proxy.getInvocationHandler( executionListener ) instanceof SpyInvocationHandler ) )
	{
	ExecutionListener listener = ( ExecutionListener ) Proxy.newProxyInstance(
	ExecutionListener.class.getClassLoader(),
	new Class[] { ExecutionListener.class },
	new SpyInvocationHandler( executionListener ) );
	cleaner.session.getRequest().setExecutionListener( listener );
	}
	}

	synchronized void doSessionEnd()
	{
	if ( status != STOPPED )
	{
	if ( status == NEW )
	{
	start();
	}
	if ( !FAST_MODE_DEFER.equals( fastMode ) )
	{
	try
	{
	cleaner.logInfo.log( "Waiting for background file deletion" );
	while ( status != STOPPED )
	{
	wait();
	}
	}
	catch ( InterruptedException e )
	{
	// ignore
	}
	}
	}
	}

	}

	static class SpyInvocationHandler implements InvocationHandler
	{
	private final ExecutionListener delegate;

	SpyInvocationHandler( ExecutionListener delegate )
	{
	this.delegate = delegate;
	}

	@Override
	public Object invoke( Object proxy, Method method, Object[] args ) throws Throwable
	{
	if ( "sessionEnded".equals( method.getName() ) )
	{
	BackgroundCleaner.sessionEnd();
	}
	if ( delegate != null )
	{
	return method.invoke( delegate, args );
	}
	return null;
	}

	}

	}