Set<Artifact> getResolvedArtifactsFromUnresolvedDependencies(
List<Dependency> unresolvedDependencies, boolean resolveTransitively)
throws MojoExecutionException {
final Set<Artifact> resolvedArtifacts = new HashSet<Artifact>();
// Artifact mojoArtifact = this.artifactFactory.createBuildArtifact(project.getGroupId(),
// project.getArtifactId(), project.getVersion(), "pom");
/*
* Resolve each artifact. This will get all transitive artifacts AND eliminate conflicts.
*/
final Set<Artifact> unresolvedArtifacts;
// for (Dependency d : unresolvedDependencies)
// System.out.println("dependency: " + d.toString());
try {
unresolvedArtifacts =
MavenMetadataSource.createArtifacts(
this.artifactFactory, unresolvedDependencies, null, null, null);
// for (Artifact artifact : unresolvedArtifacts) {
// System.out.println("unresolved " + artifact.toString());
// }
if (resolveTransitively) {
ArtifactResolutionResult artifacts =
artifactResolver.resolveTransitively(
unresolvedArtifacts,
project.getArtifact(),
remoteRepositories,
localRepository,
artifactMetadataSource);
resolvedArtifacts.addAll(artifacts.getArtifacts());
} else {
// resolve each artifact individually
for (Artifact artifact : unresolvedArtifacts) {
artifactResolver.resolve(artifact, remoteRepositories, localRepository);
resolvedArtifacts.add(artifact);
}
}
} catch (Exception e) {
throw new MojoExecutionException("Unable to complete configuring the build settings", e);
}
for (Artifact artifact : resolvedArtifacts) {
System.out.println("matched " + artifact.toString());
}
return resolvedArtifacts;
}
@SuppressWarnings("unchecked")
private void prepareArtifacts() {
try {
// TODO: do only if artifacts are not resolved
Set<Artifact> artifacts = new LinkedHashSet<Artifact>();
Map<String, Artifact> managedVersions = createManagedVersionMap();
List<ResolutionListener> listeners = new ArrayList<ResolutionListener>();
ArtifactResolutionResult resolveResult =
artifactCollector.collect(
getAllArtifacts(),
project.getArtifact(),
managedVersions,
session.getLocalRepository(),
project.getRemoteArtifactRepositories(),
artifactMetadataSource,
null,
listeners);
for (ResolutionNode node : (Set<ResolutionNode>) resolveResult.getArtifactResolutionNodes()) {
if (!isReactorProject(node.getArtifact())) {
artifactResolver.resolve(
node.getArtifact(), node.getRemoteRepositories(), session.getLocalRepository());
artifacts.add(node.getArtifact());
} else {
addProjectReferenceArtifact(node.getArtifact());
}
}
this.artifacts = artifacts;
} catch (Exception e) {
getLog().debug("[WarSync] " + e.getMessage(), e);
getLog().error("[WarSync] " + e.getMessage());
}
}
/**
* Merge WsdlOptions that point to the same file by adding the extraargs to the first option and
* deleting the second from the options list
*
* @param options
*/
@SuppressWarnings("unchecked")
private Artifact resolveRemoteWsdlArtifact(List<?> remoteRepos, Artifact artifact)
throws MojoExecutionException {
/**
* First try to find the artifact in the reactor projects of the maven session. So an artifact
* that is not yet built can be resolved
*/
List<MavenProject> rProjects = mavenSession.getSortedProjects();
for (MavenProject rProject : rProjects) {
if (artifact.getGroupId().equals(rProject.getGroupId())
&& artifact.getArtifactId().equals(rProject.getArtifactId())
&& artifact.getVersion().equals(rProject.getVersion())) {
Set<Artifact> artifacts = rProject.getArtifacts();
for (Artifact pArtifact : artifacts) {
if ("wadl".equals(pArtifact.getType())) {
return pArtifact;
}
}
}
}
/** If this did not work resolve the artifact using the artifactResolver */
try {
artifactResolver.resolve(artifact, remoteRepos, localRepository);
} catch (ArtifactResolutionException e) {
throw new MojoExecutionException("Error downloading wsdl artifact.", e);
} catch (ArtifactNotFoundException e) {
throw new MojoExecutionException("Resource can not be found.", e);
}
return artifact;
}
/**
* Returns <code>true</code> if the update should be applied.
*
* @param artifact The artifact.
* @param currentVersion The current version of the artifact.
* @param updateVersion The proposed new version of the artifact.
* @return <code>true</code> if the update should be applied.
* @since 1.0-alpha-1
*/
protected boolean shouldApplyUpdate(
Artifact artifact, String currentVersion, ArtifactVersion updateVersion) {
getLog().debug("Proposal is to update from " + currentVersion + " to " + updateVersion);
if (updateVersion == null) {
getLog().warn("Not updating version: could not resolve any versions");
return false;
}
artifact.setVersion(updateVersion.toString());
try {
resolver.resolveAlways(artifact, remoteArtifactRepositories, localRepository);
} catch (ArtifactResolutionException e) {
getLog().warn("Not updating version: could not resolve " + artifact.toString(), e);
return false;
} catch (ArtifactNotFoundException e) {
getLog().warn("Not updating version: could not find " + artifact.toString(), e);
return false;
}
if (currentVersion.equals(updateVersion.toString())) {
getLog().info("Current version of " + artifact.toString() + " is the latest.");
return false;
}
return true;
}
/**
* Get a resolved Artifact from the coordinates provided
*
* @return the artifact, which has been resolved.
* @throws MojoExecutionException
*/
protected Artifact getArtifact(
String groupId, String artifactId, String version, String type, String classifier)
throws MojoExecutionException {
Artifact artifact;
VersionRange vr;
try {
vr = VersionRange.createFromVersionSpec(version);
} catch (InvalidVersionSpecificationException e) {
vr = VersionRange.createFromVersion(version);
}
if (StringUtils.isEmpty(classifier)) {
artifact =
factory.createDependencyArtifact(
groupId, artifactId, vr, type, null, Artifact.SCOPE_COMPILE);
} else {
artifact =
factory.createDependencyArtifact(
groupId, artifactId, vr, type, classifier, Artifact.SCOPE_COMPILE);
}
try {
resolver.resolve(artifact, remoteRepos, local);
} catch (ArtifactResolutionException e) {
throw new MojoExecutionException("Unable to resolve artifact.", e);
} catch (ArtifactNotFoundException e) {
throw new MojoExecutionException("Unable to find artifact.", e);
}
return artifact;
}
protected File[] getGwtUserJar() throws MojoExecutionException {
checkGwtUserVersion();
Artifact gwtUserArtifact = getArtifact("com.google.gwt", "gwt-user");
Set<Artifact> artifacts = new HashSet<Artifact>();
ArtifactResolutionResult result = null;
try {
result =
resolver.resolveTransitively(
artifacts,
gwtUserArtifact,
remoteRepositories,
localRepository,
artifactMetadataSource);
} catch (ArtifactResolutionException e) {
throw new MojoExecutionException("Failed to resolve artifact", e);
} catch (ArtifactNotFoundException e) {
throw new MojoExecutionException("Failed to resolve artifact", e);
}
Collection<Artifact> resolved = result.getArtifacts();
int i = 0;
// FIXME gwt 2.3.0 don't declare dependency on javax.validation, should be fix in next release
File[] files = new File[resolved.size() + 1 + 2];
files[i++] = gwtUserArtifact.getFile();
for (Artifact artifact : resolved) {
files[i++] = artifact.getFile();
}
files[i++] = getArtifact("javax.validation", "validation-api").getFile();
files[i++] = getArtifact("javax.validation", "validation-api", "sources").getFile();
return files;
}
@SuppressWarnings("unchecked")
private Collection<Artifact> getNonTransitivePlugins(Set<Artifact> projectArtifacts)
throws MojoExecutionException {
Collection<Artifact> deps = new LinkedHashSet<Artifact>();
for (Artifact artifact : projectArtifacts) {
Artifact pomArtifact =
artifactFactory.createArtifact(
artifact.getGroupId(),
artifact.getArtifactId(),
artifact.getVersion(),
artifact.getClassifier(),
"pom");
Set<Artifact> result;
try {
MavenProject pomProject =
mavenProjectBuilder.buildFromRepository(
pomArtifact, remoteRepositories, localRepository);
Set<Artifact> artifacts = pomProject.createArtifacts(artifactFactory, null, null);
artifacts = filterOutSystemDependencies(artifacts);
ArtifactResolutionResult arr =
resolver.resolveTransitively(
artifacts,
pomArtifact,
localRepository,
remoteRepositories,
artifactMetadataSource,
null);
result = arr.getArtifacts();
} catch (Exception e) {
throw new MojoExecutionException(
"Failed to resolve non-transitive deps " + e.getMessage(), e);
}
LinkedHashSet<Artifact> plugins = new LinkedHashSet<Artifact>();
plugins.addAll(filtterArtifacts(result, getFilters(null, null, "nexus-plugin", null)));
plugins.addAll(filtterArtifacts(result, getFilters(null, null, "zip", "bundle")));
plugins.addAll(getNonTransitivePlugins(plugins));
if (!plugins.isEmpty()) {
getLog()
.debug(
"Adding non-transitive dependencies for: "
+ artifact
+ " -\n"
+ plugins.toString().replace(',', '\n'));
}
deps.addAll(plugins);
}
return deps;
}
protected Artifact resolve(Artifact artifact) throws MojoExecutionException {
if (!artifact.isResolved()) {
try {
resolver.resolve(artifact, remoteRepositories, localRepository);
} catch (AbstractArtifactResolutionException e) {
throw new MojoExecutionException("Unable to resolve artifact: " + artifact, e);
}
}
return artifact;
}
protected void addMvn2CompatResults(
MavenProject project,
List<Exception> exceptions,
List<ResolutionListener> listeners,
ArtifactRepository localRepository,
Collection<MavenExecutionResult> executionResults) {
ArtifactResolutionRequest resolutionRequest = new ArtifactResolutionRequest();
resolutionRequest.setArtifactDependencies(project.getDependencyArtifacts());
resolutionRequest.setArtifact(project.getArtifact());
resolutionRequest.setManagedVersionMap(project.getManagedVersionMap());
resolutionRequest.setLocalRepository(localRepository);
resolutionRequest.setRemoteRepositories(project.getRemoteArtifactRepositories());
resolutionRequest.setListeners(listeners);
resolutionRequest.setResolveRoot(false);
resolutionRequest.setResolveTransitively(true);
ArtifactResolver resolver = getComponent(ArtifactResolver.class);
ArtifactResolutionResult result = resolver.resolve(resolutionRequest);
project.setArtifacts(result.getArtifacts());
executionResults.add(new MavenExecutionResult(project, exceptions));
}
protected Artifact resolve(
String groupId, String artifactId, String version, String type, String classifier)
throws MojoExecutionException {
// return project.getArtifactMap().get( groupId + ":" + artifactId );
Artifact artifact =
artifactFactory.createArtifactWithClassifier(
groupId, artifactId, version, type, classifier);
try {
resolver.resolve(artifact, remoteRepositories, localRepository);
} catch (ArtifactNotFoundException e) {
throw new MojoExecutionException("artifact not found - " + e.getMessage(), e);
} catch (ArtifactResolutionException e) {
throw new MojoExecutionException("artifact resolver problem - " + e.getMessage(), e);
}
return artifact;
}
/**
* Resolves dependencies of a bundle <code>groupId:artifactId:version</code>
*
* @param groupId
* @param artifactId
* @param version
*/
@SuppressWarnings("unchecked")
public ArtifactResolutionResult resolve(
final String groupId, final String artifactId, final String version) {
// final Artifact artifact = artifactFactory.createDependencyArtifact(groupId, artifactId,
// VersionRange.createFromVersion(version), type, "", scope);
final Artifact pomArtifact = getPomArtifact(groupId, artifactId, version);
try {
// load the pom as a MavenProject and get all of the dependencies for the project
final MavenProject project = loadPomAsProject(projectBuilder, pomArtifact);
final List dependencies = project.getDependencies();
// make Artifacts of all the dependencies and the project itself
final Set<Artifact> dependencyArtifacts =
MavenMetadataSource.createArtifacts(artifactFactory, dependencies, null, null, null);
dependencyArtifacts.add(project.getArtifact());
// create listener for monitoring the resolution process
final List<RuntimeResolutionListener> listeners = new ArrayList<RuntimeResolutionListener>();
listeners.add(new RuntimeResolutionListener());
// resolve all dependencies transitively to obtain a comprehensive list of jars
final ArtifactResolutionResult result =
artifactResolver.resolveTransitively(
dependencyArtifacts,
pomArtifact,
Collections.EMPTY_MAP,
localRepository,
remoteRepositories,
metadataSource,
null,
listeners);
if (debug) {
for (final Object o : result.getArtifactResolutionNodes()) {
System.out.println(o.toString());
}
}
return result;
} catch (final Exception e) {
throw new RuntimeException("Dependency Resolver failed", e);
}
}
private Set<Artifact> resolveExecutableDependencies(Artifact executablePomArtifact)
throws MojoExecutionException {
Set<Artifact> executableDependencies;
try {
MavenProject executableProject =
this.projectBuilder.buildFromRepository(
executablePomArtifact, this.remoteRepositories, this.localRepository);
// get all of the dependencies for the executable project
List<Artifact> dependencies = CastUtils.cast(executableProject.getDependencies());
// make Artifacts of all the dependencies
Set<Artifact> dependencyArtifacts =
CastUtils.cast(
MavenMetadataSource.createArtifacts(
this.artifactFactory, dependencies, null, null, null));
// not forgetting the Artifact of the project itself
dependencyArtifacts.add(executableProject.getArtifact());
// resolve all dependencies transitively to obtain a comprehensive
// list of assemblies
ArtifactResolutionResult result =
artifactResolver.resolveTransitively(
dependencyArtifacts,
executablePomArtifact,
Collections.EMPTY_MAP,
this.localRepository,
this.remoteRepositories,
metadataSource,
null,
Collections.EMPTY_LIST);
executableDependencies = CastUtils.cast(result.getArtifacts());
} catch (Exception ex) {
throw new MojoExecutionException(
"Encountered problems resolving dependencies of the executable "
+ "in preparation for its execution.",
ex);
}
return executableDependencies;
}
/**
* @param isPom <code>true</code> to lookup the <code>maven-model</code> artifact jar, <code>false
* </code> to lookup the <code>maven-settings</code> artifact jar.
* @return the <code>org.apache.maven:maven-model|maven-settings</code> artifact jar file for this
* current HelpPlugin pom.
* @throws MojoExecutionException if any
* @throws ProjectBuildingException if any
* @throws ArtifactResolutionException if any
* @throws ArtifactNotFoundException if any
*/
private File getArtifactFile(boolean isPom)
throws MojoExecutionException, ProjectBuildingException, ArtifactResolutionException,
ArtifactNotFoundException {
@SuppressWarnings("unchecked")
List<Dependency> dependencies = getHelpPluginPom().getDependencies();
for (Dependency depependency : dependencies) {
if (!(depependency.getGroupId().equals("org.apache.maven"))) {
continue;
}
if (isPom) {
if (!(depependency.getArtifactId().equals("maven-model"))) {
continue;
}
} else {
if (!(depependency.getArtifactId().equals("maven-settings"))) {
continue;
}
}
Artifact mavenArtifact =
getArtifact(
depependency.getGroupId()
+ ":"
+ depependency.getArtifactId()
+ ":"
+ depependency.getVersion());
resolver.resolveAlways(mavenArtifact, remoteRepositories, localRepository);
return mavenArtifact.getFile();
}
throw new MojoExecutionException(
"Unable to find the 'org.apache.maven:"
+ (isPom ? "maven-model" : "maven-settings")
+ "' artifact");
}
/**
* Create the transitive classpath.
*
* @return The dependent artifacts.
* @throws MojoExecutionException If the classpath can't be found.
*/
public Set transitivelyResolvePomDependencies() throws MojoExecutionException {
// make Artifacts of all the dependencies
Set dependencyArtifacts;
try {
dependencyArtifacts =
MavenMetadataSource.createArtifacts(artifactFactory, dependencies, null, null, null);
} catch (InvalidDependencyVersionException e) {
throw new MojoExecutionException("Invalid dependency", e);
}
// not forgetting the Artifact of the project itself
dependencyArtifacts.add(project.getArtifact());
List listeners = Collections.EMPTY_LIST;
// resolve all dependencies transitively to obtain a comprehensive list
// of jars
ArtifactResolutionResult result;
try {
result =
artifactResolver.resolveTransitively(
dependencyArtifacts,
project.getArtifact(),
Collections.EMPTY_MAP,
localRepository,
remoteRepositories,
metadataSource,
null,
listeners);
} catch (ArtifactResolutionException e) {
throw new MojoExecutionException("Unable to resolve Artifact.", e);
} catch (ArtifactNotFoundException e) {
throw new MojoExecutionException("Unable to resolve Artifact.", e);
}
return result.getArtifacts();
}
/**
* Tests if a Filter is installed correctly, also if createSourcesJar is set to true.
*
* @throws Exception
*/
public void testShadeWithFilter() throws Exception {
ShadeMojo mojo = new ShadeMojo();
// set createSourcesJar = true
Field createSourcesJar = ShadeMojo.class.getDeclaredField("createSourcesJar");
createSourcesJar.setAccessible(true);
createSourcesJar.set(mojo, Boolean.TRUE);
// configure artifactFactory for mojo
ArtifactFactory artifactFactory = (ArtifactFactory) lookup(ArtifactFactory.ROLE);
Field artifactFactoryField = ShadeMojo.class.getDeclaredField("artifactFactory");
artifactFactoryField.setAccessible(true);
artifactFactoryField.set(mojo, artifactFactory);
// configure artifactResolver (mocked) for mojo
ArtifactResolver mockArtifactResolver =
new DefaultArtifactResolver() {
public void resolve(
Artifact artifact, List<ArtifactRepository> remoteRepos, ArtifactRepository repo)
throws ArtifactResolutionException, ArtifactNotFoundException {
// artifact is resolved
artifact.setResolved(true);
// set file
artifact.setFile(
new File(
artifact.getArtifactId()
+ "-"
+ artifact.getVersion()
+ (artifact.getClassifier() != null ? "-" + artifact.getClassifier() : "")
+ ".jar"));
}
};
Field artifactResolverField = ShadeMojo.class.getDeclaredField("artifactResolver");
artifactResolverField.setAccessible(true);
artifactResolverField.set(mojo, mockArtifactResolver);
// create and configure MavenProject
MavenProject project = new MavenProject();
ArtifactHandler artifactHandler = (ArtifactHandler) lookup(ArtifactHandler.ROLE);
Artifact artifact =
new DefaultArtifact(
"org.apache.myfaces.core",
"myfaces-impl",
VersionRange.createFromVersion("2.0.1-SNAPSHOT"),
"compile",
"jar",
null,
artifactHandler);
mockArtifactResolver.resolve(artifact, null, null); // setFile and setResolved
project.setArtifact(artifact);
Field projectField = ShadeMojo.class.getDeclaredField("project");
projectField.setAccessible(true);
projectField.set(mojo, project);
// create and configure the ArchiveFilter
ArchiveFilter archiveFilter = new ArchiveFilter();
Field archiveFilterArtifact = ArchiveFilter.class.getDeclaredField("artifact");
archiveFilterArtifact.setAccessible(true);
archiveFilterArtifact.set(archiveFilter, "org.apache.myfaces.core:myfaces-impl");
// add ArchiveFilter to mojo
Field filtersField = ShadeMojo.class.getDeclaredField("filters");
filtersField.setAccessible(true);
filtersField.set(mojo, new ArchiveFilter[] {archiveFilter});
// invoke getFilters()
Method getFilters = ShadeMojo.class.getDeclaredMethod("getFilters", new Class[0]);
getFilters.setAccessible(true);
List<Filter> filters = (List<Filter>) getFilters.invoke(mojo);
// assertions - there must be one filter
assertEquals(1, filters.size());
// the filter must be able to filter the binary and the sources jar
Filter filter = filters.get(0);
assertTrue(filter.canFilter(new File("myfaces-impl-2.0.1-SNAPSHOT.jar"))); // binary jar
assertTrue(
filter.canFilter(new File("myfaces-impl-2.0.1-SNAPSHOT-sources.jar"))); // sources jar
}
private void executeServerDeploy(final Wagon wagon) throws MojoExecutionException {
// alpha|nuclei|beta|electron|gamma|production deployment goes through scpexe
try {
if (ensureNoLocalModifications()) {
@SuppressWarnings("unchecked")
final List<ArtifactItem> theArtifactItems = getProcessedArtifactItems(stripVersion);
for (ArtifactItem item : theArtifactItems) {
final Artifact artifact =
factory.createArtifactWithClassifier(
item.getGroupId(),
item.getArtifactId(),
item.getVersion(),
item.getType(),
profile);
resolver.resolve(artifact, getRemoteRepos(), getLocal());
final String sesamSite = project.getProperties().getProperty("sesam.site");
final String destName = null != sesamSite ? sesamSite : project.getBuild().getFinalName();
// tag the code
final boolean tagOnDeploy =
Boolean.parseBoolean(
System.getProperty(
TAG_ON_DEPLOY, project.getProperties().getProperty("tag.on.deploy")));
if (tagOnDeploy && !Boolean.getBoolean(DRY_RUN)) {
tagDeploy();
}
// do the upload
getLog()
.info(
"Uploading "
+ artifact.getFile().getAbsolutePath()
+ " to "
+ wagon.getRepository().getUrl()
+ '/'
+ destName
+ ".war");
if (!Boolean.getBoolean(DRY_RUN)) {
wagon.put(artifact.getFile(), destName + ".war");
}
// update the version.txt
getLog().info("Updating " + wagon.getRepository().getUrl() + "/version.txt");
if (Boolean.getBoolean(DRY_RUN)) {
final StringWriter sb = new StringWriter();
final BufferedWriter w = new BufferedWriter(sb);
updateArtifactEntry(new BufferedReader(new StringReader("")), w);
w.flush();
getLog().info("version.txt entry will be \n" + sb.toString());
} else {
updateVersionFile(wagon);
}
}
}
} catch (TransferFailedException ex) {
getLog().error(ex);
throw new MojoExecutionException("transfer failed", ex);
} catch (ResourceDoesNotExistException ex) {
getLog().error(ex);
throw new MojoExecutionException("resource does not exist", ex);
} catch (AuthorizationException ex) {
getLog().error(ex);
throw new MojoExecutionException("authorisation exception", ex);
} catch (ArtifactNotFoundException ex) {
getLog().error(ex);
throw new MojoExecutionException("artifact not found", ex);
} catch (ArtifactResolutionException ex) {
getLog().error(ex);
throw new MojoExecutionException("artifact resolution exception", ex);
} catch (ScmException ex) {
getLog().error(ex);
throw new MojoExecutionException("scm exception", ex);
} catch (ComponentLookupException ex) {
getLog().error(ex);
throw new MojoExecutionException("failed to lookup ScmManager", ex);
} catch (IOException ex) {
getLog().error(ex);
throw new MojoExecutionException("IOException", ex);
}
}
@Override
public void execute(final EnforcerRuleHelper helper) throws EnforcerRuleException {
final MavenProject project;
try {
project = (MavenProject) helper.evaluate("${project}");
} catch (ExpressionEvaluationException e) {
throw new EnforcerRuleException("Failed to access ${project} variable", e);
}
final String type = project.getArtifact().getType();
if (!AbstractEnforcerRule.JAR_ARTIFACT_TYPE.equals(type)) {
helper
.getLog()
.debug("Skipping non " + AbstractEnforcerRule.JAR_ARTIFACT_TYPE + " artifact.");
return;
}
final Artifact previousArtifact;
final Artifact currentArtifact = project.getArtifact();
validateArtifact(currentArtifact);
final Version current = Version.parse(currentArtifact.getVersion());
final File currentJar = currentArtifact.getFile();
try {
final ArtifactRepository localRepository =
(ArtifactRepository) helper.evaluate("${localRepository}");
final String version;
if (this.previousVersion != null) {
version = this.previousVersion;
helper.getLog().info("Version specified as <" + version + ">");
} else {
final ArtifactMetadataSource artifactMetadataSource =
(ArtifactMetadataSource) helper.getComponent(ArtifactMetadataSource.class);
final List<ArtifactVersion> availableVersions =
getAvailableReleasedVersions(artifactMetadataSource, project, localRepository);
final List<ArtifactVersion> availablePreviousVersions =
filterNonPreviousVersions(availableVersions, current);
if (availablePreviousVersions.isEmpty()) {
helper
.getLog()
.warn("No previously released version. Backward compatibility check not performed.");
return;
}
version = availablePreviousVersions.iterator().next().toString();
helper
.getLog()
.info(
"Version deduced as <"
+ version
+ "> (among all availables: "
+ availablePreviousVersions
+ ")");
}
final ArtifactFactory artifactFactory =
(ArtifactFactory) helper.getComponent(ArtifactFactory.class);
previousArtifact =
artifactFactory.createArtifact(
project.getGroupId(), project.getArtifactId(), version, null, type);
final ArtifactResolver resolver =
(ArtifactResolver) helper.getComponent(ArtifactResolver.class);
resolver.resolve(previousArtifact, project.getRemoteArtifactRepositories(), localRepository);
validateArtifact(previousArtifact);
} catch (Exception e) {
helper.getLog().warn("Exception while accessing artifacts; skipping check.", e);
return;
}
final Version previous = Version.parse(previousArtifact.getVersion());
final File previousJar = previousArtifact.getFile();
helper.getLog().info("Using <" + previousJar + "> as previous JAR");
helper.getLog().info("Using <" + currentJar + "> as current JAR");
try {
final Comparer comparer =
new Comparer(
previousJar,
currentJar,
extractFilters(this.includes),
extractFilters(this.excludes));
final Delta delta = comparer.diff();
enforce(helper, delta, previous, current);
} catch (IOException e) {
throw new EnforcerRuleException("Exception while checking compatibility: " + e.toString(), e);
}
}
public void execute() throws MojoExecutionException, MojoFailureException {
if (this.skip) {
getLog().info("skip execution");
return;
}
// project.addAttachedArtifact( );
File warExecFile = new File(buildDirectory, finalName);
if (warExecFile.exists()) {
warExecFile.delete();
}
File execWarJar = new File(buildDirectory, finalName);
FileOutputStream execWarJarOutputStream = null;
ArchiveOutputStream os = null;
File tmpPropertiesFile = null;
File tmpManifestFile = null;
FileOutputStream tmpPropertiesFileOutputStream = null;
PrintWriter tmpManifestWriter = null;
try {
tmpPropertiesFile = new File(buildDirectory, "war-exec.properties");
if (tmpPropertiesFile.exists()) {
tmpPropertiesFile.delete();
}
tmpPropertiesFile.getParentFile().mkdirs();
tmpManifestFile = new File(buildDirectory, "war-exec.manifest");
if (tmpManifestFile.exists()) {
tmpManifestFile.delete();
}
tmpPropertiesFileOutputStream = new FileOutputStream(tmpPropertiesFile);
execWarJar.getParentFile().mkdirs();
execWarJar.createNewFile();
execWarJarOutputStream = new FileOutputStream(execWarJar);
tmpManifestWriter = new PrintWriter(tmpManifestFile);
// store :
// * wars in the root: foo.war
// * tomcat jars
// * file tomcat.standalone.properties with possible values :
// * useServerXml=true/false to use directly the one provided
// * enableNaming=true/false
// * wars=foo.war|contextpath;bar.war ( |contextpath is optionnal if empty use the war name
// )
// * accessLogValveFormat=
// * connectorhttpProtocol: HTTP/1.1 or org.apache.coyote.http11.Http11NioProtocol
// * optionnal: conf/ with usual tomcat configuration files
// * MANIFEST with Main-Class
Properties properties = new Properties();
properties.put(
Tomcat7Runner.ARCHIVE_GENERATION_TIMESTAMP_KEY,
Long.toString(System.currentTimeMillis()));
properties.put(Tomcat7Runner.ENABLE_NAMING_KEY, Boolean.toString(enableNaming));
properties.put(Tomcat7Runner.ACCESS_LOG_VALVE_FORMAT_KEY, accessLogValveFormat);
properties.put(Tomcat7Runner.HTTP_PROTOCOL_KEY, connectorHttpProtocol);
os =
new ArchiveStreamFactory()
.createArchiveOutputStream(ArchiveStreamFactory.JAR, execWarJarOutputStream);
if ("war".equals(project.getPackaging())) {
os.putArchiveEntry(new JarArchiveEntry(StringUtils.removeStart(path, "/") + ".war"));
IOUtils.copy(new FileInputStream(projectArtifact.getFile()), os);
os.closeArchiveEntry();
properties.put(Tomcat7Runner.WARS_KEY, StringUtils.removeStart(path, "/") + ".war|" + path);
} else if (warRunDependencies != null && !warRunDependencies.isEmpty()) {
for (WarRunDependency warRunDependency : warRunDependencies) {
if (warRunDependency.dependency != null) {
Dependency dependency = warRunDependency.dependency;
Artifact artifact =
artifactFactory.createArtifactWithClassifier(
dependency.getGroupId(),
dependency.getArtifactId(),
dependency.getVersion(),
dependency.getType(),
dependency.getClassifier());
artifactResolver.resolve(artifact, this.remoteRepos, this.local);
File warFileToBundle = new File(resolvePluginWorkDir(), artifact.getFile().getName());
FileUtils.copyFile(artifact.getFile(), warFileToBundle);
if (warRunDependency.contextXml != null) {
warFileToBundle = addContextXmlToWar(warRunDependency.contextXml, warFileToBundle);
}
final String warFileName = artifact.getFile().getName();
os.putArchiveEntry(new JarArchiveEntry(warFileName));
IOUtils.copy(new FileInputStream(warFileToBundle), os);
os.closeArchiveEntry();
String propertyWarValue = properties.getProperty(Tomcat7Runner.WARS_KEY);
String contextPath =
StringUtils.isEmpty(warRunDependency.contextPath)
? "/"
: warRunDependency.contextPath;
if (propertyWarValue != null) {
properties.put(
Tomcat7Runner.WARS_KEY, propertyWarValue + ";" + warFileName + "|" + contextPath);
} else {
properties.put(Tomcat7Runner.WARS_KEY, warFileName + "|" + contextPath);
}
}
}
}
if (serverXml != null && serverXml.exists()) {
os.putArchiveEntry(new JarArchiveEntry("conf/server.xml"));
IOUtils.copy(new FileInputStream(serverXml), os);
os.closeArchiveEntry();
properties.put(Tomcat7Runner.USE_SERVER_XML_KEY, Boolean.TRUE.toString());
} else {
properties.put(Tomcat7Runner.USE_SERVER_XML_KEY, Boolean.FALSE.toString());
}
os.putArchiveEntry(new JarArchiveEntry("conf/web.xml"));
IOUtils.copy(getClass().getResourceAsStream("/conf/web.xml"), os);
os.closeArchiveEntry();
properties.store(tmpPropertiesFileOutputStream, "created by Apache Tomcat Maven plugin");
tmpPropertiesFileOutputStream.flush();
tmpPropertiesFileOutputStream.close();
os.putArchiveEntry(new JarArchiveEntry(Tomcat7RunnerCli.STAND_ALONE_PROPERTIES_FILENAME));
IOUtils.copy(new FileInputStream(tmpPropertiesFile), os);
os.closeArchiveEntry();
// add tomcat classes
for (Artifact pluginArtifact : pluginArtifacts) {
if (StringUtils.equals("org.apache.tomcat", pluginArtifact.getGroupId())
|| StringUtils.equals("org.apache.tomcat.embed", pluginArtifact.getGroupId())
|| StringUtils.equals("org.eclipse.jdt.core.compiler", pluginArtifact.getGroupId())
|| StringUtils.equals("commons-cli", pluginArtifact.getArtifactId())
|| StringUtils.equals("tomcat7-war-runner", pluginArtifact.getArtifactId())) {
JarFile jarFile = new JarFile(pluginArtifact.getFile());
extractJarToArchive(jarFile, os);
}
}
// add extra dependencies
if (extraDependencies != null && !extraDependencies.isEmpty()) {
for (Dependency dependency : extraDependencies) {
// String groupId, String artifactId, String version, String scope, String type
Artifact artifact =
artifactFactory.createArtifact(
dependency.getGroupId(),
dependency.getArtifactId(),
dependency.getVersion(),
dependency.getScope(),
dependency.getType());
artifactResolver.resolve(artifact, this.remoteRepos, this.local);
JarFile jarFile = new JarFile(artifact.getFile());
extractJarToArchive(jarFile, os);
}
}
Manifest manifest = new Manifest();
Manifest.Attribute mainClassAtt = new Manifest.Attribute();
mainClassAtt.setName("Main-Class");
mainClassAtt.setValue(mainClass);
manifest.addConfiguredAttribute(mainClassAtt);
manifest.write(tmpManifestWriter);
tmpManifestWriter.flush();
tmpManifestWriter.close();
os.putArchiveEntry(new JarArchiveEntry("META-INF/MANIFEST.MF"));
IOUtils.copy(new FileInputStream(tmpManifestFile), os);
os.closeArchiveEntry();
if (attachArtifact) {
// MavenProject project, String artifactType, String artifactClassifier, File artifactFile
projectHelper.attachArtifact(
project, attachArtifactClassifierType, attachArtifactClassifier, execWarJar);
}
if (extraResources != null) {
for (ExtraResource extraResource : extraResources) {
DirectoryScanner directoryScanner = new DirectoryScanner();
directoryScanner.setBasedir(extraResource.getDirectory());
directoryScanner.addDefaultExcludes();
directoryScanner.setExcludes(toStringArray(extraResource.getExcludes()));
directoryScanner.setIncludes(toStringArray(extraResource.getIncludes()));
directoryScanner.scan();
for (String includeFile : directoryScanner.getIncludedFiles()) {
getLog().debug("include file:" + includeFile);
os.putArchiveEntry(new JarArchiveEntry(includeFile));
IOUtils.copy(
new FileInputStream(new File(extraResource.getDirectory(), includeFile)), os);
os.closeArchiveEntry();
}
}
}
if (tomcatConfigurationFilesDirectory != null && tomcatConfigurationFilesDirectory.exists()) {
// Because its the tomcat default dir for configs
String aConfigOutputDir = "conf/";
copyDirectoryContentIntoArchive(tomcatConfigurationFilesDirectory, aConfigOutputDir, os);
}
} catch (ManifestException e) {
throw new MojoExecutionException(e.getMessage(), e);
} catch (IOException e) {
throw new MojoExecutionException(e.getMessage(), e);
} catch (ArchiveException e) {
throw new MojoExecutionException(e.getMessage(), e);
} catch (ArtifactNotFoundException e) {
throw new MojoExecutionException(e.getMessage(), e);
} catch (ArtifactResolutionException e) {
throw new MojoExecutionException(e.getMessage(), e);
} finally {
IOUtils.closeQuietly(os);
IOUtils.closeQuietly(tmpManifestWriter);
IOUtils.closeQuietly(execWarJarOutputStream);
IOUtils.closeQuietly(tmpPropertiesFileOutputStream);
}
}