private Path extractIfRequired(final Path buildDir)
throws MojoFailureException, MojoExecutionException {
if (jbossHome != null) {
// we do not need to download WildFly
return Paths.get(jbossHome);
}
final String artifact =
ArtifactNameSplitter.of(this.artifact)
.setArtifactId(artifactId)
.setClassifier(classifier)
.setGroupId(groupId)
.setPackaging(packaging)
.setVersion(version)
.asString();
final Path result = artifactResolver.resolve(project, artifact).toPath();
final Path target = buildDir.resolve(WILDFLY_DIR);
// Delete the target if it exists
if (Files.exists(target)) {
try {
Archives.deleteDirectory(target);
} catch (IOException e) {
throw new MojoFailureException("Could not delete target directory: " + target, e);
}
}
try {
Archives.unzip(result, target);
final Iterator<Path> iterator = Files.newDirectoryStream(target).iterator();
if (iterator.hasNext()) return iterator.next();
} catch (IOException e) {
throw new MojoFailureException("Artifact was not successfully extracted: " + result, e);
}
throw new MojoFailureException("Artifact was not successfully extracted: " + result);
}
@Test
public void testThatOriginalBuildParamsDepsDoNotPropagateToArchive() {
SourcePathResolver pathResolver = new SourcePathResolver(new BuildRuleResolver());
// Create an `Archive` rule using build params with an existing dependency,
// as if coming from a `TargetNode` which had declared deps. These should *not*
// propagate to the `Archive` rule, since it only cares about dependencies generating
// it's immediate inputs.
BuildRule dep =
new FakeBuildRule(
BuildRuleParamsFactory.createTrivialBuildRuleParams(
BuildTargetFactory.newInstance("//:fake")),
pathResolver);
BuildTarget target = BuildTargetFactory.newInstance("//:archive");
BuildRuleParams params =
new FakeBuildRuleParamsBuilder(BuildTargetFactory.newInstance("//:dummy"))
.setDeps(ImmutableSortedSet.of(dep))
.build();
Archive archive =
Archives.createArchiveRule(
pathResolver, target, params, DEFAULT_ARCHIVER, DEFAULT_OUTPUT, DEFAULT_INPUTS);
// Verify that the archive rules dependencies are empty.
assertEquals(archive.getDeps(), ImmutableSortedSet.<BuildRule>of());
}
@Test
public void testThatBuildTargetSourcePathDepsAndPathsArePropagated() {
BuildRuleResolver resolver = new BuildRuleResolver();
BuildTarget target = BuildTargetFactory.newInstance("//foo:bar");
BuildRuleParams params = BuildRuleParamsFactory.createTrivialBuildRuleParams(target);
// Create a couple of genrules to generate inputs for an archive rule.
Genrule genrule1 =
(Genrule)
GenruleBuilder.newGenruleBuilder(BuildTargetFactory.newInstance("//:genrule"))
.setOut("foo/bar.o")
.build(resolver);
Genrule genrule2 =
(Genrule)
GenruleBuilder.newGenruleBuilder(BuildTargetFactory.newInstance("//:genrule2"))
.setOut("foo/test.o")
.build(resolver);
// Build the archive using a normal input the outputs of the genrules above.
Archive archive =
Archives.createArchiveRule(
new SourcePathResolver(resolver),
target,
params,
DEFAULT_ARCHIVER,
DEFAULT_OUTPUT,
ImmutableList.<SourcePath>of(
new TestSourcePath("simple.o"),
new BuildTargetSourcePath(genrule1.getBuildTarget()),
new BuildTargetSourcePath(genrule2.getBuildTarget())));
// Verify that the archive dependencies include the genrules providing the
// SourcePath inputs.
assertEquals(ImmutableSortedSet.<BuildRule>of(genrule1, genrule2), archive.getDeps());
}
