Google Git
Sign in
apache / maven-war-plugin / refs/heads/master / . / src / main / java / org / apache / maven / plugins / war / AbstractWarMojo.java
blob: fbee01412a7baae9fb5c315e66be32577a87e7a0 [file] [log] [blame]
/*
* 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.
*/
package org.apache.maven.plugins.war;
import java.io.File;
import java.io.IOException;
import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.List;
import org.apache.maven.archiver.MavenArchiveConfiguration;
import org.apache.maven.artifact.factory.ArtifactFactory;
import org.apache.maven.execution.MavenSession;
import org.apache.maven.model.Resource;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugin.logging.Log;
import org.apache.maven.plugins.annotations.Component;
import org.apache.maven.plugins.annotations.Parameter;
import org.apache.maven.plugins.war.overlay.OverlayManager;
import org.apache.maven.plugins.war.packaging.CopyUserManifestTask;
import org.apache.maven.plugins.war.packaging.OverlayPackagingTask;
import org.apache.maven.plugins.war.packaging.WarPackagingContext;
import org.apache.maven.plugins.war.packaging.WarPackagingTask;
import org.apache.maven.plugins.war.packaging.WarProjectPackagingTask;
import org.apache.maven.plugins.war.util.WebappStructure;
import org.apache.maven.project.MavenProject;
import org.apache.maven.shared.filtering.FilterWrapper;
import org.apache.maven.shared.filtering.MavenFileFilter;
import org.apache.maven.shared.filtering.MavenFilteringException;
import org.apache.maven.shared.filtering.MavenResourcesExecution;
import org.apache.maven.shared.filtering.MavenResourcesFiltering;
import org.apache.maven.shared.utils.StringUtils;
import org.codehaus.plexus.archiver.Archiver;
import org.codehaus.plexus.archiver.jar.JarArchiver;
import org.codehaus.plexus.archiver.manager.ArchiverManager;
/**
* Contains common jobs for WAR mojos.
*/
public abstract class AbstractWarMojo extends AbstractMojo {
private static final String META_INF = "META-INF";
private static final String WEB_INF = "WEB-INF";
/**
* Whether or not to fail the build if the <code>web.xml</code> file is missing. Set to <code>false</code> if you
* want your WAR built without a <code>web.xml</code> file. This may be useful if you are building an overlay that
* has no web.xml file.
* <p>
* Starting with <b>3.1.0</b>, this property defaults to <code>false</code> if the project depends on the Servlet
* 3.0 API or newer.
*
* @since 2.1-alpha-2
*/
@Parameter
protected Boolean failOnMissingWebXml;
/**
* The Maven project.
*/
@Parameter(defaultValue = "${project}", readonly = true, required = true)
private MavenProject project;
/**
* The directory containing compiled classes.
*/
@Parameter(defaultValue = "${project.build.outputDirectory}", required = true, readonly = true)
private File classesDirectory;
/**
* Whether a JAR file will be created for the classes in the webapp. Using this optional configuration parameter
* will make the compiled classes to be archived into a JAR file in <code>/WEB-INF/lib/</code> and the classes
* directory will then be excluded from the webapp <code>/WEB-INF/classes/</code>.
*
* @since 2.0.1
*/
@Parameter(defaultValue = "false")
private boolean archiveClasses;
/**
* The encoding to use when copying filtered web resources.
*
* @since 2.3
*/
@Parameter(defaultValue = "${project.build.sourceEncoding}")
private String resourceEncoding;
/**
* The character encoding to use when reading and writing filtered properties files.
* If not specified, it will default to the value of the "resourceEncoding" parameter.
*
* @since 3.4.0
*/
@Parameter
protected String propertiesEncoding;
/**
* The JAR archiver needed for archiving the classes directory into a JAR file under WEB-INF/lib.
*/
@Component(role = Archiver.class, hint = "jar")
private JarArchiver jarArchiver;
/**
* The directory where the webapp is built.
*/
@Parameter(defaultValue = "${project.build.directory}/${project.build.finalName}", required = true)
private File webappDirectory;
/**
* Single directory for extra files to include in the WAR. This is where you place your JSP files.
*/
@Parameter(defaultValue = "${basedir}/src/main/webapp", required = true)
private File warSourceDirectory;
/**
* The list of webResources we want to transfer.
*/
@Parameter
private Resource[] webResources;
/**
* Filters (property files) to include during the interpolation of the pom.xml.
*/
@Parameter
private List<String> filters;
/**
* <p>
* Set of delimiters for expressions to filter within the resources. These delimiters are specified in the form
* 'beginToken*endToken'. If no '*' is given, the delimiter is assumed to be the same for start and end.
* </p>
* <p>
* So, the default filtering delimiters might be specified as:
* </p>
*
* <pre>
* &lt;delimiters&gt;
* &lt;delimiter&gt;${*}&lt;/delimiter&gt;
* &lt;delimiter&gt;@&lt;/delimiter&gt;
* &lt;/delimiters&gt;
* </pre>
* <p>
* Since the '@' delimiter is the same on both ends, we don't need to specify '@*@' (though we can).
* </p>
*
* @since 3.0.0
*/
@Parameter
private LinkedHashSet<String> delimiters;
/**
* Use default delimiters in addition to custom delimiters, if any.
*
* @since 3.0.0
*/
@Parameter(defaultValue = "true")
private boolean useDefaultDelimiters;
/**
* The path to the web.xml file to use.
*/
@Parameter
private File webXml;
/**
* The path to a configuration file for the servlet container. Note that the file name may be different for
* different servlet containers. Apache Tomcat uses a configuration file named context.xml. The file will be copied
* to the META-INF directory.
*/
@Parameter
private File containerConfigXML;
/**
* Directory to unpack dependent WARs into if needed.
*/
@Parameter(defaultValue = "${project.build.directory}/war/work", required = true)
private File workDirectory;
/**
* The file name mapping to use when copying libraries and TLDs. If no file mapping is set (default) the files are
* copied with their standard names.
*
* @since 2.1-alpha-1
*/
@Parameter
private String outputFileNameMapping;
/**
*/
@Component(role = ArtifactFactory.class)
private ArtifactFactory artifactFactory;
/**
* To look up Archiver/UnArchiver implementations.
*/
@Component(role = ArchiverManager.class)
private ArchiverManager archiverManager;
/**
*/
@Component(role = MavenFileFilter.class, hint = "default")
private MavenFileFilter mavenFileFilter;
/**
*/
@Component(role = MavenResourcesFiltering.class, hint = "default")
private MavenResourcesFiltering mavenResourcesFiltering;
/**
* The comma separated list of tokens to include when copying the content of the warSourceDirectory.
*/
@Parameter(defaultValue = "**")
private String warSourceIncludes;
/**
* The comma separated list of tokens to exclude when copying the content of the warSourceDirectory.
*/
@Parameter
private String warSourceExcludes;
/**
* The comma separated list of tokens to include when doing a WAR overlay. Default is
* {@link org.apache.maven.plugins.war.Overlay#DEFAULT_INCLUDES}
*
*/
@Parameter
private String dependentWarIncludes = StringUtils.join(Overlay.DEFAULT_INCLUDES, ",");
/**
* The comma separated list of tokens to exclude when doing a WAR overlay. Default is
* {@link org.apache.maven.plugins.war.Overlay#DEFAULT_EXCLUDES}
*
*/
@Parameter
private String dependentWarExcludes = StringUtils.join(Overlay.DEFAULT_EXCLUDES, ",");
/**
* The overlays to apply. Each &lt;overlay&gt; element may contain:
* <ul>
* <li>id (defaults to {@code currentBuild})</li>
* <li>groupId (if this and artifactId are null, then the current project is treated as its own overlay)</li>
* <li>artifactId (see above)</li>
* <li>classifier</li>
* <li>type</li>
* <li>includes (a list of string patterns)</li>
* <li>excludes (a list of string patterns)</li>
* <li>filtered (defaults to false)</li>
* <li>skip (defaults to false)</li>
* <li>targetPath (defaults to root of webapp structure)</li>
* </ul>
*
* @since 2.1-alpha-1
*/
@Parameter
private List<Overlay> overlays = new ArrayList<>();
/**
* A list of file extensions that should not be filtered. <b>Will be used when filtering webResources and
* overlays.</b>
*
* @since 2.1-alpha-2
*/
@Parameter
private List<String> nonFilteredFileExtensions;
/**
* @since 2.1-alpha-2
*/
@Parameter(defaultValue = "${session}", readonly = true, required = true)
private MavenSession session;
/**
* To filter deployment descriptors. <b>Disabled by default.</b>
*
* @since 2.1-alpha-2
*/
@Parameter(defaultValue = "false")
private boolean filteringDeploymentDescriptors;
/**
* To escape interpolated values with Windows path <code>c:\foo\bar</code> will be replaced with
* <code>c:\\foo\\bar</code>.
*
* @since 2.1-alpha-2
*/
@Parameter(defaultValue = "false")
private boolean escapedBackslashesInFilePath;
/**
* Expression preceded with this String won't be interpolated. <code>\${foo}</code> will be replaced with
* <code>${foo}</code>.
*
* @since 2.1-beta-1
*/
@Parameter
protected String escapeString;
/**
* Indicates if zip archives (jar,zip etc) being added to the war should be compressed again. Compressing again can
* result in smaller archive size, but gives noticeably longer execution time.
*
* @since 2.3
*/
@Parameter(defaultValue = "true")
private boolean recompressZippedFiles;
/**
* @since 2.4
*/
@Parameter(defaultValue = "false")
private boolean includeEmptyDirectories;
/**
* Stop searching endToken at the end of line
*
* @since 2.4
*/
@Parameter(defaultValue = "false")
private boolean supportMultiLineFiltering;
/**
* use jvmChmod rather that cli chmod and forking process
*
* @since 2.4
*/
@Parameter(defaultValue = "true")
private boolean useJvmChmod;
/**
* The archive configuration to use. See <a href="http://maven.apache.org/shared/maven-archiver/index.html">Maven
* Archiver Reference</a>.
*/
@Parameter
private MavenArchiveConfiguration archive = new MavenArchiveConfiguration();
/**
* Timestamp for reproducible output archive entries, either formatted as ISO 8601
* <code>yyyy-MM-dd'T'HH:mm:ssXXX</code> or as an int representing seconds since the epoch (like
* <a href="https://reproducible-builds.org/docs/source-date-epoch/">SOURCE_DATE_EPOCH</a>).
*
* @since 3.3.0
*/
@Parameter(defaultValue = "${project.build.outputTimestamp}")
protected String outputTimestamp;
/**
* Path prefix for resources that will be checked against outdated content.
*
* Starting with <b>3.3.2</b>, if a value of "/" is specified the entire
* webappDirectory will be checked, i.e. the "/" signifies "root".
*
* @since 3.3.1
*/
@Parameter(defaultValue = "WEB-INF/lib/")
private String outdatedCheckPath;
private final Overlay currentProjectOverlay = Overlay.createInstance();
/**
* @return The current overlay.
*/
public Overlay getCurrentProjectOverlay() {
return currentProjectOverlay;
}
/**
* Returns a string array of the excludes to be used when copying the content of the WAR source directory.
*
* @return an array of tokens to exclude
*/
protected String[] getExcludes() {
List<String> excludeList = new ArrayList<>();
if (warSourceExcludes != null && !warSourceExcludes.isEmpty()) {
excludeList.addAll(Arrays.asList(StringUtils.split(warSourceExcludes, ",")));
}
// if webXML is specified, omit the one in the source directory
if (webXml != null && StringUtils.isNotEmpty(webXml.getName())) {
excludeList.add("**/" + WEB_INF + "/web.xml");
}
// if contextXML is specified, omit the one in the source directory
if (containerConfigXML != null && StringUtils.isNotEmpty(containerConfigXML.getName())) {
excludeList.add("**/" + META_INF + "/" + containerConfigXML.getName());
}
return excludeList.toArray(new String[excludeList.size()]);
}
/**
* Returns a string array of the includes to be used when assembling/copying the WAR.
*
* @return an array of tokens to include
*/
protected String[] getIncludes() {
return StringUtils.split(StringUtils.defaultString(warSourceIncludes), ",");
}
/**
* Returns a string array of the excludes to be used when adding dependent WAR as an overlay onto this WAR.
*
* @return an array of tokens to exclude
*/
protected String[] getDependentWarExcludes() {
return StringUtils.split(StringUtils.defaultString(dependentWarExcludes), ",");
}
/**
* Returns a string array of the includes to be used when adding dependent WARs as an overlay onto this WAR.
*
* @return an array of tokens to include
*/
protected String[] getDependentWarIncludes() {
return StringUtils.split(StringUtils.defaultString(dependentWarIncludes), ",");
}
/**
* @param webapplicationDirectory The web application directory.
* @throws MojoExecutionException In case of failure.
* @throws MojoFailureException In case of failure.
*/
public void buildExplodedWebapp(File webapplicationDirectory) throws MojoExecutionException, MojoFailureException {
webapplicationDirectory.mkdirs();
try {
buildWebapp(project, webapplicationDirectory);
} catch (IOException e) {
throw new MojoExecutionException("Could not build webapp", e);
}
}
/**
* Builds the webapp for the specified project with the new packaging task thingy.
* Classes, libraries and tld files are copied to the {@code webappDirectory} during this phase.
*
* @param mavenProject the maven project
* @param webapplicationDirectory the target directory
* @throws MojoExecutionException if an error occurred while packaging the webapp
* @throws MojoFailureException if an unexpected error occurred while packaging the webapp
* @throws IOException if an error occurred while copying the files
*/
public void buildWebapp(MavenProject mavenProject, File webapplicationDirectory)
throws MojoExecutionException, MojoFailureException, IOException {
WebappStructure structure = new WebappStructure(mavenProject.getDependencies());
// CHECKSTYLE_OFF: LineLength
final long startTime = System.currentTimeMillis();
getLog().info("Assembling webapp [" + mavenProject.getArtifactId() + "] in [" + webapplicationDirectory + "]");
final OverlayManager overlayManager = new OverlayManager(
overlays, mavenProject, getDependentWarIncludes(), getDependentWarExcludes(), currentProjectOverlay);
// CHECKSTYLE_ON: LineLength
List<FilterWrapper> defaultFilterWrappers;
try {
MavenResourcesExecution mavenResourcesExecution = new MavenResourcesExecution();
mavenResourcesExecution.setEscapeString(escapeString);
mavenResourcesExecution.setSupportMultiLineFiltering(supportMultiLineFiltering);
mavenResourcesExecution.setMavenProject(mavenProject);
// if these are NOT set, just use the defaults, which are '${*}' and '@'.
mavenResourcesExecution.setDelimiters(delimiters, useDefaultDelimiters);
if (nonFilteredFileExtensions != null) {
mavenResourcesExecution.setNonFilteredFileExtensions(nonFilteredFileExtensions);
}
if (filters == null) {
filters = getProject().getBuild().getFilters();
}
mavenResourcesExecution.setFilters(filters);
mavenResourcesExecution.setEscapedBackslashesInFilePath(escapedBackslashesInFilePath);
mavenResourcesExecution.setMavenSession(this.session);
mavenResourcesExecution.setEscapeString(this.escapeString);
mavenResourcesExecution.setSupportMultiLineFiltering(supportMultiLineFiltering);
defaultFilterWrappers = mavenFileFilter.getDefaultFilterWrappers(mavenResourcesExecution);
} catch (MavenFilteringException e) {
getLog().error("fail to build filtering wrappers " + e.getMessage());
throw new MojoExecutionException(e.getMessage(), e);
}
final WarPackagingContext context = new DefaultWarPackagingContext(
webapplicationDirectory,
structure,
overlayManager,
defaultFilterWrappers,
getNonFilteredFileExtensions(),
filteringDeploymentDescriptors,
this.artifactFactory,
resourceEncoding,
propertiesEncoding,
useJvmChmod,
failOnMissingWebXml,
outputTimestamp);
final List<WarPackagingTask> packagingTasks = getPackagingTasks(overlayManager);
for (WarPackagingTask warPackagingTask : packagingTasks) {
warPackagingTask.performPackaging(context);
}
getLog().debug("Webapp assembled in [" + (System.currentTimeMillis() - startTime) + " msecs]");
}
/**
* Returns a {@code List} of the {@link org.apache.maven.plugins.war.packaging.WarPackagingTask}
* instances to invoke to perform the packaging.
*
* @param overlayManager the overlay manager
* @return the list of packaging tasks
* @throws MojoExecutionException if the packaging tasks could not be built
*/
private List<WarPackagingTask> getPackagingTasks(OverlayManager overlayManager) throws MojoExecutionException {
final List<WarPackagingTask> packagingTasks = new ArrayList<>();
packagingTasks.add(new CopyUserManifestTask());
final List<Overlay> resolvedOverlays = overlayManager.getOverlays();
for (Overlay overlay : resolvedOverlays) {
if (overlay.isCurrentProject()) {
packagingTasks.add(
new WarProjectPackagingTask(webResources, webXml, containerConfigXML, currentProjectOverlay));
} else {
packagingTasks.add(new OverlayPackagingTask(overlay, currentProjectOverlay));
}
}
return packagingTasks;
}
/**
* WarPackagingContext default implementation
*/
private class DefaultWarPackagingContext implements WarPackagingContext {
private final ArtifactFactory artifactFactory;
private final String resourceEncoding;
private final String propertiesEncoding;
private final WebappStructure webappStructure;
private final File webappDirectory;
private final OverlayManager overlayManager;
private final List<FilterWrapper> filterWrappers;
private List<String> nonFilteredFileExtensions;
private boolean filteringDeploymentDescriptors;
private boolean useJvmChmod;
private final Boolean failOnMissingWebXml;
private final Collection<String> outdatedResources;
private final String outputTimestamp;
/**
* @param webappDirectory The web application directory.
* @param webappStructure The web app structure.
* @param overlayManager The overlay manager.
* @param filterWrappers The filter wrappers
* @param nonFilteredFileExtensions The non filtered file extensions.
* @param filteringDeploymentDescriptors The filtering deployment descriptors.
* @param artifactFactory The artifact factory.
* @param resourceEncoding The resource encoding.
* @param propertiesEncoding The encoding to use for properties files.
* @param useJvmChmod use Jvm chmod or not.
* @param failOnMissingWebXml Flag to check whether we should ignore missing web.xml or not
* @param outputTimestamp the output timestamp for reproducible archive creation
*/
DefaultWarPackagingContext(
final File webappDirectory,
final WebappStructure webappStructure,
final OverlayManager overlayManager,
List<FilterWrapper> filterWrappers,
List<String> nonFilteredFileExtensions,
boolean filteringDeploymentDescriptors,
ArtifactFactory artifactFactory,
String resourceEncoding,
String propertiesEncoding,
boolean useJvmChmod,
final Boolean failOnMissingWebXml,
String outputTimestamp) {
this.webappDirectory = webappDirectory;
this.webappStructure = webappStructure;
this.overlayManager = overlayManager;
this.filterWrappers = filterWrappers;
this.artifactFactory = artifactFactory;
this.filteringDeploymentDescriptors = filteringDeploymentDescriptors;
this.nonFilteredFileExtensions =
nonFilteredFileExtensions == null ? Collections.emptyList() : nonFilteredFileExtensions;
this.resourceEncoding = resourceEncoding;
this.propertiesEncoding = propertiesEncoding;
// This is kinda stupid but if we loop over the current overlays and we request the path structure
// it will register it. This will avoid wrong warning messages in a later phase
for (String overlayId : overlayManager.getOverlayIds()) {
webappStructure.getStructure(overlayId);
}
this.useJvmChmod = useJvmChmod;
this.failOnMissingWebXml = failOnMissingWebXml;
if (!webappDirectory.exists()) {
outdatedResources = Collections.emptyList();
} else if (getWarSourceDirectory().toPath().equals(webappDirectory.toPath())) {
getLog().info("Can't detect outdated resources when running inplace goal");
outdatedResources = Collections.emptyList();
} else if (session.getStartTime() == null) {
// MWAR-439: this should never happen, but has happened in some integration context...
getLog().warn("Can't detect outdated resources because unexpected session.getStartTime() == null");
outdatedResources = Collections.emptyList();
} else {
outdatedResources = new ArrayList<>();
try {
if ('\\' == File.separatorChar) {
if (!checkAllPathsForOutdated()) {
outdatedCheckPath = outdatedCheckPath.replace('/', '\\');
}
}
Files.walkFileTree(webappDirectory.toPath(), new SimpleFileVisitor<Path>() {
@Override
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
if (file.toFile().lastModified()
< session.getStartTime().getTime()) {
String path = webappDirectory
.toPath()
.relativize(file)
.toString();
if (checkAllPathsForOutdated() || path.startsWith(outdatedCheckPath)) {
outdatedResources.add(path);
}
}
return super.visitFile(file, attrs);
}
});
} catch (IOException e) {
getLog().warn("Can't detect outdated resources", e);
}
}
this.outputTimestamp = outputTimestamp;
}
protected boolean checkAllPathsForOutdated() {
return outdatedCheckPath.equals("/");
}
@Override
public MavenProject getProject() {
return project;
}
@Override
public File getWebappDirectory() {
return webappDirectory;
}
@Override
public File getClassesDirectory() {
return classesDirectory;
}
@Override
public Log getLog() {
return AbstractWarMojo.this.getLog();
}
@Override
public String getOutputFileNameMapping() {
return outputFileNameMapping;
}
@Override
public File getWebappSourceDirectory() {
return warSourceDirectory;
}
@Override
public String[] getWebappSourceIncludes() {
return getIncludes();
}
@Override
public String[] getWebappSourceExcludes() {
return getExcludes();
}
@Override
public boolean isWebappSourceIncludeEmptyDirectories() {
return includeEmptyDirectories;
}
@Override
public boolean archiveClasses() {
return archiveClasses;
}
@Override
public File getOverlaysWorkDirectory() {
return workDirectory;
}
@Override
public ArchiverManager getArchiverManager() {
return archiverManager;
}
@Override
public MavenArchiveConfiguration getArchive() {
return archive;
}
@Override
public JarArchiver getJarArchiver() {
return jarArchiver;
}
@Override
public List<String> getFilters() {
return filters;
}
@Override
public WebappStructure getWebappStructure() {
return webappStructure;
}
@Override
public List<String> getOwnerIds() {
return overlayManager.getOverlayIds();
}
@Override
public MavenFileFilter getMavenFileFilter() {
return mavenFileFilter;
}
@Override
public List<FilterWrapper> getFilterWrappers() {
return filterWrappers;
}
@Override
public boolean isNonFilteredExtension(String fileName) {
return !mavenResourcesFiltering.filteredFileExtension(fileName, nonFilteredFileExtensions);
}
@Override
public boolean isFilteringDeploymentDescriptors() {
return filteringDeploymentDescriptors;
}
@Override
public ArtifactFactory getArtifactFactory() {
return this.artifactFactory;
}
@Override
public MavenSession getSession() {
return session;
}
@Override
public String getResourceEncoding() {
return resourceEncoding;
}
@Override
public String getPropertiesEncoding() {
return propertiesEncoding;
}
@Override
public boolean isUseJvmChmod() {
return useJvmChmod;
}
@Override
public Boolean isFailOnMissingWebXml() {
return failOnMissingWebXml;
}
@Override
public void addResource(String resource) {
outdatedResources.remove(resource.replace('/', File.separatorChar));
}
@Override
public void deleteOutdatedResources() {
for (String resource : outdatedResources) {
getLog().info("deleting outdated resource " + resource);
new File(getWebappDirectory(), resource).delete();
}
}
@Override
public String getOutputTimestamp() {
return outputTimestamp;
}
}
/**
* @return The Maven Project.
*/
public MavenProject getProject() {
return project;
}
/**
* @param project The project to be set.
*/
public void setProject(MavenProject project) {
this.project = project;
}
/**
* @return the classes directory.
*/
public File getClassesDirectory() {
return classesDirectory;
}
/**
* @param classesDirectory The classes directory to be set.
*/
public void setClassesDirectory(File classesDirectory) {
this.classesDirectory = classesDirectory;
}
/**
* @return {@link #webappDirectory}
*/
public File getWebappDirectory() {
return webappDirectory;
}
/**
* @param webappDirectory The web application directory.
*/
public void setWebappDirectory(File webappDirectory) {
this.webappDirectory = webappDirectory;
}
/**
* @return {@link #warSourceDirectory}
*/
public File getWarSourceDirectory() {
return warSourceDirectory;
}
/**
* @param warSourceDirectory {@link #warSourceDirectory}
*/
public void setWarSourceDirectory(File warSourceDirectory) {
this.warSourceDirectory = warSourceDirectory;
}
/**
* @return The {@link #webXml}
*/
public File getWebXml() {
return webXml;
}
/**
* @param webXml The {@link #webXml}
*/
public void setWebXml(File webXml) {
this.webXml = webXml;
}
/**
* @return {@link #containerConfigXML}
*/
public File getContainerConfigXML() {
return containerConfigXML;
}
/**
* @param containerConfigXML {@link #containerConfigXML}
*/
public void setContainerConfigXML(File containerConfigXML) {
this.containerConfigXML = containerConfigXML;
}
/**
* @return {@link #outputFileNameMapping}
*/
public String getOutputFileNameMapping() {
return outputFileNameMapping;
}
/**
* @param outputFileNameMapping {@link #outputFileNameMapping}
*/
public void setOutputFileNameMapping(String outputFileNameMapping) {
this.outputFileNameMapping = outputFileNameMapping;
}
/**
* @return {@link #overlays}
*/
public List<Overlay> getOverlays() {
return overlays;
}
/**
* @param overlays {@link #overlays}
*/
public void setOverlays(List<Overlay> overlays) {
this.overlays = overlays;
}
/**
* @param overlay add {@link #overlays}.
*/
public void addOverlay(Overlay overlay) {
overlays.add(overlay);
}
/**
* @return {@link #archiveClasses}
*/
public boolean isArchiveClasses() {
return archiveClasses;
}
/**
* @param archiveClasses {@link #archiveClasses}
*/
public void setArchiveClasses(boolean archiveClasses) {
this.archiveClasses = archiveClasses;
}
/**
* @return {@link JarArchiver}
*/
public JarArchiver getJarArchiver() {
return jarArchiver;
}
/**
* @param jarArchiver {@link JarArchiver}
*/
public void setJarArchiver(JarArchiver jarArchiver) {
this.jarArchiver = jarArchiver;
}
/**
* @return {@link #webResources}.
*/
public Resource[] getWebResources() {
return webResources;
}
/**
* @param webResources {@link #webResources}.
*/
public void setWebResources(Resource[] webResources) {
this.webResources = webResources;
}
/**
* @return {@link #filters}
*/
public List<String> getFilters() {
return filters;
}
/**
* @param filters {@link #filters}
*/
public void setFilters(List<String> filters) {
this.filters = filters;
}
/**
* @return {@link #workDirectory}
*/
public File getWorkDirectory() {
return workDirectory;
}
/**
* @param workDirectory {@link #workDirectory}
*/
public void setWorkDirectory(File workDirectory) {
this.workDirectory = workDirectory;
}
/**
* @return {@link #warSourceIncludes}
*/
public String getWarSourceIncludes() {
return warSourceIncludes;
}
/**
* @param warSourceIncludes {@link #warSourceIncludes}
*/
public void setWarSourceIncludes(String warSourceIncludes) {
this.warSourceIncludes = warSourceIncludes;
}
/**
* @return {@link #warSourceExcludes}
*/
public String getWarSourceExcludes() {
return warSourceExcludes;
}
/**
* @param warSourceExcludes {@link #warSourceExcludes}
*/
public void setWarSourceExcludes(String warSourceExcludes) {
this.warSourceExcludes = warSourceExcludes;
}
/**
* @return {@link #archive}
*/
public MavenArchiveConfiguration getArchive() {
return archive;
}
/**
* @return {@link #nonFilteredFileExtensions}
*/
public List<String> getNonFilteredFileExtensions() {
return nonFilteredFileExtensions;
}
/**
* @param nonFilteredFileExtensions {@link #nonFilteredFileExtensions}
*/
public void setNonFilteredFileExtensions(List<String> nonFilteredFileExtensions) {
this.nonFilteredFileExtensions = nonFilteredFileExtensions;
}
/**
* @return {@link #artifactFactory}
*/
public ArtifactFactory getArtifactFactory() {
return this.artifactFactory;
}
/**
* @param artifactFactory {@link #artifactFactory}
*/
public void setArtifactFactory(ArtifactFactory artifactFactory) {
this.artifactFactory = artifactFactory;
}
/**
* @return {@link #session}
*/
protected MavenSession getSession() {
return this.session;
}
/**
* @return {@link #recompressZippedFiles}
*/
protected boolean isRecompressZippedFiles() {
return recompressZippedFiles;
}
/**
* @return {@link #includeEmptyDirectories}
*/
protected boolean isIncludeEmptyDirectories() {
return includeEmptyDirectories;
}
}