/** Builds the action as configured. */
public void build() throws InterruptedException {
ImmutableList<Artifact> classpathResources = attributes.getClassPathResources();
Set<String> classPathResourceNames = new HashSet<>();
for (Artifact artifact : classpathResources) {
String name = artifact.getExecPath().getBaseName();
if (!classPathResourceNames.add(name)) {
ruleContext.attributeError(
"classpath_resources",
"entries must have different file names (duplicate: " + name + ")");
return;
}
}
IterablesChain<Artifact> runtimeJars = runtimeJarsBuilder.build();
// TODO(kmb): Consider not using getArchiveInputs, specifically because we don't want/need to
// transform anything but the runtimeClasspath and b/c we currently do it twice here and below
IterablesChain.Builder<Artifact> inputs = IterablesChain.builder();
inputs.add(getArchiveInputs(attributes, derivedJars));
inputs.add(ImmutableList.copyOf(Iterables.transform(runtimeJars, derivedJars)));
if (runfilesMiddleman != null) {
inputs.addElement(runfilesMiddleman);
}
ImmutableList<Artifact> buildInfoArtifacts = ruleContext.getBuildInfo(JavaBuildInfoFactory.KEY);
inputs.add(buildInfoArtifacts);
Iterable<Artifact> runtimeClasspath =
Iterables.transform(
Iterables.concat(runtimeJars, attributes.getRuntimeClassPathForArchive()), derivedJars);
if (launcher != null) {
inputs.addElement(launcher);
}
CommandLine commandLine =
semantics.buildSingleJarCommandLine(
ruleContext.getConfiguration(),
outputJar,
javaStartClass,
deployManifestLines,
buildInfoArtifacts,
classpathResources,
runtimeClasspath,
includeBuildData,
compression,
launcher);
List<String> jvmArgs = ImmutableList.of("-client", SINGLEJAR_MAX_MEMORY);
ResourceSet resourceSet =
ResourceSet.createWithRamCpuIo(/*memoryMb = */ 200.0, /*cpuUsage = */ .2, /*ioUsage=*/ .2);
// If singlejar's name ends with .jar, it is Java application, otherwise it is native.
// TODO(asmundak): once b/28640279 is fixed (that is, the native singlejar is released),
// eliminate this check, allowing only native singlejar.
Artifact singlejar = getSingleJar(ruleContext);
if (singlejar.getFilename().endsWith(".jar")) {
ruleContext.registerAction(
new SpawnAction.Builder()
.addInputs(inputs.build())
.addTransitiveInputs(JavaHelper.getHostJavabaseInputs(ruleContext))
.addOutput(outputJar)
.setResources(resourceSet)
.setJarExecutable(
ruleContext.getHostConfiguration().getFragment(Jvm.class).getJavaExecutable(),
singlejar,
jvmArgs)
.setCommandLine(commandLine)
.alwaysUseParameterFile(ParameterFileType.SHELL_QUOTED)
.setProgressMessage("Building deploy jar " + outputJar.prettyPrint())
.setMnemonic("JavaDeployJar")
.setExecutionInfo(ImmutableMap.of("supports-workers", "1"))
.build(ruleContext));
} else {
ruleContext.registerAction(
new SpawnAction.Builder()
.addInputs(inputs.build())
.addTransitiveInputs(JavaHelper.getHostJavabaseInputs(ruleContext))
.addOutput(outputJar)
.setResources(resourceSet)
.setExecutable(singlejar)
.setCommandLine(commandLine)
.alwaysUseParameterFile(ParameterFileType.SHELL_QUOTED)
.setProgressMessage("Building deploy jar " + outputJar.prettyPrint())
.setMnemonic("JavaDeployJar")
.build(ruleContext));
}
}
@Override
public ConfiguredTarget create(RuleContext ruleContext) throws InterruptedException {
ImmutableList<Artifact> srcJars = ImmutableList.of();
ImmutableList<Artifact> jars = collectJars(ruleContext);
Artifact srcJar = ruleContext.getPrerequisiteArtifact("srcjar", Mode.TARGET);
if (ruleContext.hasErrors()) {
return null;
}
ImmutableList<TransitiveInfoCollection> targets =
ImmutableList.<TransitiveInfoCollection>builder()
.addAll(ruleContext.getPrerequisites("deps", Mode.TARGET))
.addAll(ruleContext.getPrerequisites("exports", Mode.TARGET))
.build();
final JavaCommon common = new JavaCommon(ruleContext, semantics, targets, targets, targets);
semantics.checkRule(ruleContext, common);
// No need for javac options - no compilation happening here.
JavaCompilationHelper helper =
new JavaCompilationHelper(
ruleContext,
semantics,
ImmutableList.<String>of(),
new JavaTargetAttributes.Builder(semantics));
ImmutableMap.Builder<Artifact, Artifact> compilationToRuntimeJarMap = ImmutableMap.builder();
ImmutableList<Artifact> interfaceJars =
processWithIjar(jars, helper, compilationToRuntimeJarMap);
common.setJavaCompilationArtifacts(collectJavaArtifacts(jars, interfaceJars));
CppCompilationContext transitiveCppDeps = common.collectTransitiveCppDeps();
NestedSet<LinkerInput> transitiveJavaNativeLibraries =
common.collectTransitiveJavaNativeLibraries();
boolean neverLink = JavaCommon.isNeverLink(ruleContext);
JavaCompilationArgs javaCompilationArgs =
common.collectJavaCompilationArgs(false, neverLink, compilationArgsFromSources());
JavaCompilationArgs recursiveJavaCompilationArgs =
common.collectJavaCompilationArgs(true, neverLink, compilationArgsFromSources());
NestedSet<Artifact> transitiveJavaSourceJars =
collectTransitiveJavaSourceJars(ruleContext, srcJar);
if (srcJar != null) {
srcJars = ImmutableList.of(srcJar);
}
// The "neverlink" attribute is transitive, so if it is enabled, we don't add any
// runfiles from this target or its dependencies.
Runfiles runfiles =
neverLink
? Runfiles.EMPTY
: new Runfiles.Builder(ruleContext.getWorkspaceName())
// add the jars to the runfiles
.addArtifacts(common.getJavaCompilationArtifacts().getRuntimeJars())
.addTargets(targets, RunfilesProvider.DEFAULT_RUNFILES)
.addRunfiles(ruleContext, RunfilesProvider.DEFAULT_RUNFILES)
.addTargets(targets, JavaRunfilesProvider.TO_RUNFILES)
.add(ruleContext, JavaRunfilesProvider.TO_RUNFILES)
.build();
CcLinkParamsStore ccLinkParamsStore =
new CcLinkParamsStore() {
@Override
protected void collect(
CcLinkParams.Builder builder, boolean linkingStatically, boolean linkShared) {
builder.addTransitiveTargets(
common.targetsTreatedAsDeps(ClasspathType.BOTH),
JavaCcLinkParamsProvider.TO_LINK_PARAMS,
CcLinkParamsProvider.TO_LINK_PARAMS);
}
};
RuleConfiguredTargetBuilder ruleBuilder = new RuleConfiguredTargetBuilder(ruleContext);
NestedSetBuilder<Artifact> filesBuilder = NestedSetBuilder.stableOrder();
filesBuilder.addAll(jars);
semantics.addProviders(
ruleContext,
common,
ImmutableList.<String>of(),
null /* classJar */,
srcJar /* srcJar */,
null /* genJar */,
null /* gensrcJar */,
compilationToRuntimeJarMap.build(),
helper,
filesBuilder,
ruleBuilder);
NestedSet<Artifact> filesToBuild = filesBuilder.build();
JavaSourceInfoProvider javaSourceInfoProvider =
new JavaSourceInfoProvider.Builder()
.setJarFiles(jars)
.setSourceJarsForJarFiles(srcJars)
.build();
NestedSet<Artifact> proguardSpecs = new ProguardLibrary(ruleContext).collectProguardSpecs();
common.addTransitiveInfoProviders(ruleBuilder, filesToBuild, null);
return ruleBuilder
.setFilesToBuild(filesToBuild)
.add(
JavaRuntimeJarProvider.class,
new JavaRuntimeJarProvider(common.getJavaCompilationArtifacts().getRuntimeJars()))
.addSkylarkTransitiveInfo(JavaSkylarkApiProvider.NAME, new JavaSkylarkApiProvider())
.add(JavaNeverlinkInfoProvider.class, new JavaNeverlinkInfoProvider(neverLink))
.add(RunfilesProvider.class, RunfilesProvider.simple(runfiles))
.add(CcLinkParamsProvider.class, new CcLinkParamsProvider(ccLinkParamsStore))
.add(
JavaCompilationArgsProvider.class,
new JavaCompilationArgsProvider(javaCompilationArgs, recursiveJavaCompilationArgs))
.add(
JavaNativeLibraryProvider.class,
new JavaNativeLibraryProvider(transitiveJavaNativeLibraries))
.add(CppCompilationContext.class, transitiveCppDeps)
.add(JavaSourceInfoProvider.class, javaSourceInfoProvider)
.add(
JavaSourceJarsProvider.class,
new JavaSourceJarsProvider(transitiveJavaSourceJars, srcJars))
.add(ProguardSpecProvider.class, new ProguardSpecProvider(proguardSpecs))
.addOutputGroup(JavaSemantics.SOURCE_JARS_OUTPUT_GROUP, transitiveJavaSourceJars)
.addOutputGroup(OutputGroupProvider.HIDDEN_TOP_LEVEL, proguardSpecs)
.build();
}
