Some files-generating plugins can generate their files outside of the default directories being deleted by the clean plugin. You should add the location of such files in the clean plugin configuration or change the configuration of those plugins to put their files inside the project.build.directory which is by default, the target directory.
For instance, clean could fail if you already have opened a command line with target as the current dir. Windows locks some ressources and you need to close the handles on these ressources. To skip these errors, you could call clean with the command line parameter -Dmaven.clean.failOnError=false. For more information, refer to Ignoring Errors page.
Sysinternals produced a number of utilities, like Process Explorer or Handle that help you to deal with Windows handles.
null.
* @param link The path to the link, must not be null.
* @return true if the symlink could be created, false otherwise.
*/
public static boolean createSymlink( File target, File link )
{
try
{
Commandline cli = new Commandline();
cli.setExecutable( "ln" );
cli.createArg().setValue( "-s" );
cli.createArg().setFile( target );
cli.createArg().setFile( link );
int code = CommandLineUtils.executeCommandLine( cli, new StreamConsumer()
{
public void consumeLine( String line )
{
System.out.println( line );
}
}, new StreamConsumer()
{
public void consumeLine( String line )
{
System.err.println( line );
}
} );
return 0 == code;
}
catch ( Exception e )
{
return false;
}
}
}
maven-clean-plugin-2.5/src/test/java/org/apache/maven/plugin/clean/CleanMojoTest.java 0000644 0001750 0001750 00000030304 11371275767 030151 0 ustar ebourg ebourg package org.apache.maven.plugin.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.RandomAccessFile;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.testing.AbstractMojoTestCase;
import org.codehaus.plexus.util.FileUtils;
/**
* Test the clean mojo.
*
* @author Vincent Siveton
* @version $Id: CleanMojoTest.java 942398 2010-05-08 14:57:59Z bentmann $
*/
public class CleanMojoTest
extends AbstractMojoTestCase
{
/** {@inheritDoc} */
protected void setUp()
throws Exception
{
super.setUp();
}
/** {@inheritDoc} */
protected void tearDown()
throws Exception
{
super.tearDown();
}
/**
* Tests the simple removal of directories
*
* @throws Exception
*/
public void testBasicClean()
throws Exception
{
String pluginPom = getBasedir() + "/src/test/resources/unit/basic-clean-test/plugin-pom.xml";
// safety
FileUtils.copyDirectory( new File( getBasedir(), "src/test/resources/unit/basic-clean-test" ),
new File( getBasedir(), "target/test-classes/unit/basic-clean-test" ), null, "**/.svn,**/.svn/**" );
CleanMojo mojo = (CleanMojo) lookupMojo( "clean", pluginPom );
assertNotNull( mojo );
mojo.execute();
assertFalse( "Directory exists", checkExists( getBasedir() + "/target/test-classes/unit/"
+ "basic-clean-test/buildDirectory" ) );
assertFalse( "Directory exists", checkExists( getBasedir() + "/target/test-classes/unit/basic-clean-test/"
+ "buildOutputDirectory" ) );
assertFalse( "Directory exists", checkExists( getBasedir() + "/target/test-classes/unit/basic-clean-test/"
+ "buildTestDirectory" ) );
}
/**
* Tests the removal of files and nested directories
*
* @throws Exception
*/
public void testCleanNestedStructure()
throws Exception
{
String pluginPom = getBasedir() + "/src/test/resources/unit/nested-clean-test/plugin-pom.xml";
// safety
FileUtils.copyDirectory( new File( getBasedir(), "src/test/resources/unit/nested-clean-test" ),
new File( getBasedir(), "target/test-classes/unit/nested-clean-test" ), null, "**/.svn,**/.svn/**" );
CleanMojo mojo = (CleanMojo) lookupMojo( "clean", pluginPom );
assertNotNull( mojo );
mojo.execute();
assertFalse( checkExists( getBasedir() + "/target/test-classes/unit/nested-clean-test/target" ) );
assertFalse( checkExists( getBasedir() + "/target/test-classes/unit/nested-clean-test/target/classes" ) );
assertFalse( checkExists( getBasedir() + "/target/test-classes/unit/nested-clean-test/target/test-classes" ) );
}
/**
* Tests that no exception is thrown when all internal variables are empty and that it doesn't
* just remove whats there
*
* @throws Exception
*/
public void testCleanEmptyDirectories()
throws Exception
{
String pluginPom = getBasedir() + "/src/test/resources/unit/empty-clean-test/plugin-pom.xml";
// safety
FileUtils.copyDirectory( new File( getBasedir(), "src/test/resources/unit/empty-clean-test" ),
new File( getBasedir(), "target/test-classes/unit/empty-clean-test" ), null, "**/.svn,**/.svn/**" );
CleanMojo mojo = (CleanMojo) lookupEmptyMojo( "clean", pluginPom );
assertNotNull( mojo );
mojo.execute();
assertTrue( checkExists( getBasedir() + "/target/test-classes/unit/empty-clean-test/testDirectoryStructure" ) );
assertTrue( checkExists( getBasedir() + "/target/test-classes/unit/empty-clean-test/"
+ "testDirectoryStructure/file.txt" ) );
assertTrue( checkExists( getBasedir() + "/target/test-classes/unit/empty-clean-test/"
+ "testDirectoryStructure/outputDirectory" ) );
assertTrue( checkExists( getBasedir() + "/target/test-classes/unit/empty-clean-test/"
+ "testDirectoryStructure/outputDirectory/file.txt" ) );
}
/**
* Tests the removal of files using fileset
*
* @throws Exception
*/
public void testFilesetsClean()
throws Exception
{
String pluginPom = getBasedir() + "/src/test/resources/unit/fileset-clean-test/plugin-pom.xml";
// safety
FileUtils.copyDirectory( new File( getBasedir(), "src/test/resources/unit/fileset-clean-test" ),
new File( getBasedir(), "target/test-classes/unit/fileset-clean-test" ), null, "**/.svn,**/.svn/**" );
CleanMojo mojo = (CleanMojo) lookupMojo( "clean", pluginPom );
assertNotNull( mojo );
mojo.execute();
// fileset 1
assertTrue( checkExists( getBasedir() + "/target/test-classes/unit/fileset-clean-test/target" ) );
assertTrue( checkExists( getBasedir() + "/target/test-classes/unit/fileset-clean-test/target/classes" ) );
assertFalse( checkExists( getBasedir() + "/target/test-classes/unit/fileset-clean-test/target/test-classes" ) );
assertTrue( checkExists( getBasedir() + "/target/test-classes/unit/fileset-clean-test/target/subdir" ) );
assertFalse( checkExists( getBasedir() + "/target/test-classes/unit/fileset-clean-test/target/classes/file.txt" ) );
assertTrue( checkEmpty( getBasedir() + "/target/test-classes/unit/fileset-clean-test/target/classes" ) );
assertTrue( checkEmpty( getBasedir() + "/target/test-classes/unit/fileset-clean-test/target/subdir" ) );
// fileset 2
assertTrue( checkExists( getBasedir() + "/target/test-classes/unit/fileset-clean-test/"
+ "buildOutputDirectory" ) );
assertFalse( checkExists( getBasedir() + "/target/test-classes/unit/fileset-clean-test/"
+ "buildOutputDirectory/file.txt" ) );
}
/**
* Tests the removal of a directory as file
*
* @throws Exception
*/
public void testCleanInvalidDirectory()
throws Exception
{
String pluginPom = getBasedir() + "/src/test/resources/unit/invalid-directory-test/plugin-pom.xml";
// safety
FileUtils.copyDirectory( new File( getBasedir(), "src/test/resources/unit/invalid-directory-test" ),
new File( getBasedir(), "target/test-classes/unit/invalid-directory-test" ), null, "**/.svn,**/.svn/**" );
CleanMojo mojo = (CleanMojo) lookupMojo( "clean", pluginPom );
assertNotNull( mojo );
try
{
mojo.execute();
fail( "Should fail to delete a file treated as a directory" );
}
catch ( MojoExecutionException expected )
{
assertTrue( true );
}
}
/**
* Tests the removal of a missing directory
*
* @throws Exception
*/
public void testMissingDirectory()
throws Exception
{
String pluginPom = getBasedir() + "/src/test/resources/unit/missing-directory-test/plugin-pom.xml";
// safety
FileUtils.copyDirectory( new File( getBasedir(), "src/test/resources/unit/missing-directory-test" ),
new File( getBasedir(), "target/test-classes/unit/missing-directory-test" ), null, "**/.svn,**/.svn/**" );
CleanMojo mojo = (CleanMojo) lookupMojo( "clean", pluginPom );
assertNotNull( mojo );
mojo.execute();
assertFalse( checkExists( getBasedir() + "/target/test-classes/unit/missing-directory-test/does-not-exist" ) );
}
/**
* Test the removal of a locked file on Windows systems.
* null to disable logging.
* @param verbose Whether to perform verbose logging.
*/
public Cleaner( final Log log, boolean verbose )
{
logDebug = ( log == null || !log.isDebugEnabled() ) ? null : new Logger()
{
public void log( CharSequence message )
{
log.debug( message );
}
};
logInfo = ( log == null || !log.isInfoEnabled() ) ? null : new Logger()
{
public void log( CharSequence message )
{
log.info( message );
}
};
logWarn = ( log == null || !log.isWarnEnabled() ) ? null : new Logger()
{
public void log( CharSequence message )
{
log.warn( message );
}
};
logVerbose = verbose ? logInfo : logDebug;
}
/**
* Deletes the specified directories and its contents.
*
* @param basedir The directory to delete, must not be null. Non-existing directories will be silently
* ignored.
* @param selector The selector used to determine what contents to delete, may be null 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 failOnError is true.
*/
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();
delete( file, "", selector, followSymlinks, failOnError, retryOnError );
}
/**
* Deletes the specified file or directory.
*
* @param file The file/directory to delete, must not be null. If followSymlinks is
* false, it is assumed that the parent file is canonical.
* @param pathname The relative pathname of the file, using {@link File#separatorChar}, must not be
* null.
* @param selector The selector used to determine what contents to delete, may be null 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 null.
* @throws IOException If a file/directory could not be deleted and failOnError is true.
*/
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 ) )
{
File canonical = followSymlinks ? file : file.getCanonicalFile();
if ( followSymlinks || file.equals( canonical ) )
{
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 null.
* @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 0 if the file was deleted, 1 otherwise.
* @throws IOException If a file/directory could not be deleted and failOnError is true.
*/
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();
}
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
{
public int failures;
public boolean excluded;
public void update( Result result )
{
failures += result.failures;
excluded |= result.excluded;
}
}
private static interface Logger
{
public void log( CharSequence message );
}
}
maven-clean-plugin-2.5/src/main/java/org/apache/maven/plugin/clean/Selector.java 0000644 0001750 0001750 00000003451 11322421205 027142 0 ustar ebourg ebourg package org.apache.maven.plugin.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.
*/
/**
* Determines whether a path is selected for deletion. The pathnames used for method parameters will be relative to some
* base directory and use {@link java.io.File#separatorChar} as separator.
*
* @author Benjamin Bentmann
*/
interface Selector
{
/**
* Determines whether a path is selected for deletion.
*
* @param pathname The pathname to test, must not be null.
* @return true if the given path is selected for deletion, false otherwise.
*/
boolean isSelected( String pathname );
/**
* Determines whether a directory could contain selected paths.
*
* @param pathname The directory pathname to test, must not be null.
* @return true if the given directory might contain selected paths, false if the
* directory will definitively not contain selected paths..
*/
boolean couldHoldSelected( String pathname );
}
maven-clean-plugin-2.5/src/main/java/org/apache/maven/plugin/clean/CleanMojo.java 0000644 0001750 0001750 00000020116 11460606631 027241 0 ustar ebourg ebourg package org.apache.maven.plugin.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 org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import java.io.File;
import java.io.IOException;
/**
* Goal which cleans the build.
*
* This attempts to clean a project's working directory of the files that
* were generated at build-time. By default, it discovers and deletes the
* directories configured in project.build.directory,
* project.build.outputDirectory,
* project.build.testOutputDirectory, and
* project.reporting.outputDirectory.
Files outside the default may also be included in the deletion by
* configuring the filesets tag.
-X).
*
* @parameter expression="${clean.verbose}"
* @since 2.1
*/
private Boolean verbose;
/**
* The list of file sets to delete, in addition to the default directories. For example:
*
* <filesets>
* <fileset>
* <directory>src/main/generated</directory>
* <followSymlinks>false</followSymlinks>
* <useDefaultExcludes>true</useDefaultExcludes>
* <includes>
* <include>*.java</include>
* </includes>
* <excludes>
* <exclude>Template*</exclude>
* </excludes>
* </fileset>
* </filesets>
*
*
* @parameter
* @since 2.1
*/
private Fileset[] filesets;
/**
* Sets whether the plugin should follow symbolic links while deleting files from the default output directories of
* the project. Not following symlinks requires more IO operations and heap memory, regardless whether symlinks are
* actually present. So projects with a huge output directory that knowingly does not contain symlinks can improve
* performance by setting this parameter to true.
*
* @parameter expression="${clean.followSymLinks}" default-value="false"
* @since 2.1
*/
private boolean followSymLinks;
/**
* Disables the plugin execution.
*
* @parameter expression="${clean.skip}" default-value="false"
* @since 2.2
*/
private boolean skip;
/**
* Indicates whether the build will continue even if there are clean errors.
*
* @parameter expression="${maven.clean.failOnError}" default-value="true"
* @since 2.2
*/
private boolean failOnError;
/**
* Indicates whether the plugin should undertake additional attempts (after a short delay) to delete a file if the
* first attempt failed. This is meant to help deleting files that are temporarily locked by third-party tools like
* virus scanners or search indexing.
*
* @parameter expression="${maven.clean.retryOnError}" default-value="true"
* @since 2.4.2
*/
private boolean retryOnError;
/**
* Disables the deletion of the default output directories configured for a project. If set to true,
* only the files/directories selected via the parameter {@link #filesets} will be deleted.
*
* @parameter expression="${clean.excludeDefaultDirectories}" default-value="false"
* @since 2.3
*/
private boolean excludeDefaultDirectories;
/**
* Deletes file-sets in the following project build directory order: (source) directory, output directory, test
* directory, report directory, and then the additional file-sets.
*
* @see org.apache.maven.plugin.Mojo#execute()
* @throws MojoExecutionException When a directory failed to get deleted.
*/
public void execute()
throws MojoExecutionException
{
if ( skip )
{
getLog().info( "Clean is skipped." );
return;
}
Cleaner cleaner = new Cleaner( getLog(), isVerbose() );
try
{
File[] directories = getDirectories();
for ( int i = 0; i < directories.length; i++ )
{
File directory = directories[i];
if ( directory != null )
{
cleaner.delete( directory, null, followSymLinks, failOnError, retryOnError );
}
}
if ( filesets != null )
{
for ( int i = 0; i < filesets.length; i++ )
{
Fileset fileset = filesets[i];
if ( fileset.getDirectory() == null )
{
throw new MojoExecutionException( "Missing base directory for " + fileset );
}
GlobSelector selector =
new GlobSelector( fileset.getIncludes(), fileset.getExcludes(), fileset.isUseDefaultExcludes() );
cleaner.delete( fileset.getDirectory(), selector, fileset.isFollowSymlinks(), failOnError,
retryOnError );
}
}
}
catch ( IOException e )
{
throw new MojoExecutionException( "Failed to clean project: " + e.getMessage(), e );
}
}
/**
* Indicates whether verbose output is enabled.
*
* @return true if verbose output is enabled, false otherwise.
*/
private boolean isVerbose()
{
return ( verbose != null ) ? verbose.booleanValue() : getLog().isDebugEnabled();
}
/**
* Gets the directories to clean (if any). The returned array may contain null entries.
*
* @return The directories to clean or an empty array if none, never null.
*/
private File[] getDirectories()
{
File[] directories;
if ( excludeDefaultDirectories )
{
directories = new File[0];
}
else
{
directories = new File[] { directory, outputDirectory, testOutputDirectory, reportDirectory };
}
return directories;
}
}
maven-clean-plugin-2.5/src/main/java/org/apache/maven/plugin/clean/Fileset.java 0000644 0001750 0001750 00000005173 11460604662 026775 0 ustar ebourg ebourg package org.apache.maven.plugin.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.util.Arrays;
/**
* Customizes the string representation of
* org.apache.maven.shared.model.fileset.FileSet to return the
* included and excluded files from the file-set's directory. Specifically,
* "file-set: [directory] (included: [included files],
* excluded: [excluded files])"
*
* @version $Id: Fileset.java 1026633 2010-10-23 16:13:38Z bentmann $
* @since 2.1
*/
public class Fileset
{
private File directory;
private String[] includes;
private String[] excludes;
private boolean followSymlinks;
private boolean useDefaultExcludes;
public File getDirectory()
{
return directory;
}
public String[] getIncludes()
{
return ( includes != null ) ? includes : new String[0];
}
public String[] getExcludes()
{
return ( excludes != null ) ? excludes : new String[0];
}
public boolean isFollowSymlinks()
{
return followSymlinks;
}
public boolean isUseDefaultExcludes()
{
return useDefaultExcludes;
}
/**
* Retrieves the included and excluded files from this file-set's directory.
* Specifically, "file-set: [directory] (included:
* [included files], excluded: [excluded files])"
*
* @return The included and excluded files from this file-set's directory.
* Specifically, "file-set: [directory] (included:
* [included files], excluded: [excluded files])"
* @see java.lang.Object#toString()
*/
public String toString()
{
return "file set: " + getDirectory() + " (included: " + Arrays.asList( getIncludes() ) + ", excluded: "
+ Arrays.asList( getExcludes() ) + ")";
}
}