| /* |
| * Copyright 2012-present Facebook, Inc. |
| * |
| * Licensed 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 com.facebook.buck.java; |
| |
| import com.facebook.buck.event.MissingSymbolEvent; |
| import com.facebook.buck.log.Logger; |
| import com.facebook.buck.model.BuildTarget; |
| import com.facebook.buck.rules.RuleKey; |
| import com.facebook.buck.step.ExecutionContext; |
| import com.facebook.buck.util.ClassLoaderCache; |
| import com.facebook.buck.util.HumanReadableException; |
| import com.google.common.annotations.VisibleForTesting; |
| import com.google.common.base.Function; |
| import com.google.common.base.Functions; |
| import com.google.common.base.Joiner; |
| import com.google.common.base.Optional; |
| import com.google.common.base.Preconditions; |
| import com.google.common.base.Splitter; |
| import com.google.common.collect.FluentIterable; |
| import com.google.common.collect.ImmutableList; |
| import com.google.common.collect.ImmutableSet; |
| import com.google.common.collect.Iterables; |
| import com.google.common.collect.Lists; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.PrintWriter; |
| import java.io.Writer; |
| import java.net.MalformedURLException; |
| import java.net.URL; |
| import java.net.URLClassLoader; |
| import java.nio.file.Path; |
| import java.nio.file.Paths; |
| import java.util.Enumeration; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Set; |
| import java.util.zip.ZipEntry; |
| import java.util.zip.ZipFile; |
| |
| import javax.annotation.Nullable; |
| import javax.annotation.processing.Processor; |
| import javax.tools.Diagnostic; |
| import javax.tools.DiagnosticCollector; |
| import javax.tools.JavaCompiler; |
| import javax.tools.JavaFileManager; |
| import javax.tools.JavaFileObject; |
| import javax.tools.StandardJavaFileManager; |
| import javax.tools.ToolProvider; |
| |
| /** |
| * Command used to compile java libraries with a variety of ways to handle dependencies. |
| * <p> |
| * If {@code buildDependencies} is set to |
| * {@link com.facebook.buck.rules.BuildDependencies#FIRST_ORDER_ONLY}, this class will invoke javac |
| * using {@code declaredClasspathEntries} for the classpath. If {@code buildDependencies} is set to |
| * {@link com.facebook.buck.rules.BuildDependencies#TRANSITIVE}, this class will invoke javac using |
| * {@code transitiveClasspathEntries} for the classpath. If {@code buildDependencies} is set to |
| * {@link com.facebook.buck.rules.BuildDependencies#WARN_ON_TRANSITIVE}, this class will first |
| * compile using {@code declaredClasspathEntries}, and should that fail fall back to |
| * {@code transitiveClasspathEntries} but warn the developer about which dependencies were in |
| * the transitive classpath but not in the declared classpath. |
| */ |
| public class Jsr199Javac implements Javac { |
| |
| private static final Logger LOG = Logger.get(Jsr199Javac.class); |
| private static final JavacVersion VERSION = new JavacVersion() { |
| @Override |
| public String getVersionString() { |
| return "in memory"; |
| } |
| }; |
| |
| @Override |
| public JavacVersion getVersion() { |
| return VERSION; |
| } |
| |
| private Optional<Path> javacJar; |
| |
| /** |
| * @param javacJar If absent, use the system compiler. Otherwise, load the compiler from this |
| * path. |
| */ |
| Jsr199Javac(Optional<Path> javacJar) { |
| // XXX: maybe we can accept a Provider<JavaCompiler> or just a JavaCompiler instance. |
| this.javacJar = javacJar; |
| } |
| |
| @VisibleForTesting |
| public Optional<Path> getJavacJar() { |
| return javacJar; |
| } |
| |
| @Override |
| public String getDescription( |
| ExecutionContext context, |
| ImmutableList<String> options, |
| ImmutableSet<Path> javaSourceFilePaths, |
| Optional<Path> pathToSrcsList) { |
| StringBuilder builder = new StringBuilder("javac "); |
| Joiner.on(" ").appendTo(builder, options); |
| builder.append(" "); |
| |
| if (pathToSrcsList.isPresent()) { |
| builder.append("@").append(pathToSrcsList.get()); |
| } else { |
| Joiner.on(" ").appendTo(builder, javaSourceFilePaths); |
| } |
| |
| return builder.toString(); |
| } |
| |
| @Override |
| public String getShortName() { |
| return "javac"; |
| } |
| |
| @Override |
| public boolean isUsingWorkspace() { |
| return false; |
| } |
| |
| @Override |
| public RuleKey.Builder appendToRuleKey(RuleKey.Builder builder, String key) { |
| return builder.setReflectively(key + ".javac", "jsr199") |
| .setReflectively(key + ".javac.version", "in-memory") |
| .setReflectively(key + ".javacjar", javacJar); |
| } |
| |
| @Override |
| public int buildWithClasspath( |
| ExecutionContext context, |
| BuildTarget invokingRule, |
| ImmutableList<String> options, |
| ImmutableSet<Path> javaSourceFilePaths, |
| Optional<Path> pathToSrcsList, |
| Optional<Path> workingDirectory) { |
| JavaCompiler compiler; |
| |
| if (javacJar.isPresent()) { |
| ClassLoaderCache classLoaderCache = context.getClassLoaderCache(); |
| ClassLoader compilerClassLoader = classLoaderCache.getClassLoaderForClassPath( |
| ClassLoader.getSystemClassLoader(), |
| ImmutableList.of(javacJar.get())); |
| try { |
| compiler = (JavaCompiler) |
| compilerClassLoader.loadClass("com.sun.tools.javac.api.JavacTool") |
| .newInstance(); |
| } catch (ClassNotFoundException | IllegalAccessException | InstantiationException ex) { |
| throw new RuntimeException(ex); |
| } |
| } else { |
| synchronized (ToolProvider.class) { |
| // ToolProvider has no synchronization internally, so if we don't synchronize from the |
| // outside we could wind up loading the compiler classes multiple times from different |
| // class loaders. |
| compiler = ToolProvider.getSystemJavaCompiler(); |
| } |
| |
| if (compiler == null) { |
| throw new HumanReadableException( |
| "No system compiler found. Did you install the JRE instead of the JDK?"); |
| } |
| } |
| |
| StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null); |
| Iterable<? extends JavaFileObject> compilationUnits = ImmutableSet.of(); |
| try { |
| compilationUnits = createCompilationUnits( |
| fileManager, |
| context.getProjectFilesystem().getAbsolutifier(), |
| javaSourceFilePaths); |
| } catch (IOException e) { |
| close(fileManager, compilationUnits); |
| e.printStackTrace(context.getStdErr()); |
| return 1; |
| } |
| |
| if (pathToSrcsList.isPresent()) { |
| // write javaSourceFilePaths to classes file |
| // for buck user to have a list of all .java files to be compiled |
| // since we do not print them out to console in case of error |
| try { |
| context.getProjectFilesystem().writeLinesToPath( |
| FluentIterable.from(javaSourceFilePaths) |
| .transform(Functions.toStringFunction()) |
| .transform(ARGFILES_ESCAPER), |
| pathToSrcsList.get()); |
| } catch (IOException e) { |
| close(fileManager, compilationUnits); |
| context.logError( |
| e, |
| "Cannot write list of .java files to compile to %s file! Terminating compilation.", |
| pathToSrcsList.get()); |
| return 1; |
| } |
| } |
| |
| DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>(); |
| List<String> classNamesForAnnotationProcessing = ImmutableList.of(); |
| Writer compilerOutputWriter = new PrintWriter(context.getStdErr()); |
| JavaCompiler.CompilationTask compilationTask = compiler.getTask( |
| compilerOutputWriter, |
| fileManager, |
| diagnostics, |
| options, |
| classNamesForAnnotationProcessing, |
| compilationUnits); |
| |
| // Ensure annotation processors are loaded from their own classloader. If we don't do this, |
| // then the evidence suggests that they get one polluted with Buck's own classpath, which |
| // means that libraries that have dependencies on different versions of Buck's deps may choke |
| // with novel errors that don't occur on the command line. |
| ProcessorBundle bundle = null; |
| boolean isSuccess; |
| |
| try { |
| bundle = prepareProcessors( |
| compiler.getClass().getClassLoader(), |
| invokingRule, |
| options); |
| compilationTask.setProcessors(bundle.processors); |
| |
| // Invoke the compilation and inspect the result. |
| isSuccess = compilationTask.call(); |
| } finally { |
| close(fileManager, compilationUnits); |
| } |
| |
| if (isSuccess) { |
| return 0; |
| } else { |
| if (context.getVerbosity().shouldPrintStandardInformation()) { |
| int numErrors = 0; |
| int numWarnings = 0; |
| for (Diagnostic<? extends JavaFileObject> diagnostic : diagnostics.getDiagnostics()) { |
| Diagnostic.Kind kind = diagnostic.getKind(); |
| if (kind == Diagnostic.Kind.ERROR) { |
| ++numErrors; |
| handleMissingSymbolError(invokingRule, diagnostic, context); |
| } else if (kind == Diagnostic.Kind.WARNING || |
| kind == Diagnostic.Kind.MANDATORY_WARNING) { |
| ++numWarnings; |
| } |
| |
| context.getStdErr().println(diagnostic); |
| } |
| |
| if (numErrors > 0 || numWarnings > 0) { |
| context.getStdErr().printf("Errors: %d. Warnings: %d.\n", numErrors, numWarnings); |
| } |
| } |
| return 1; |
| } |
| } |
| |
| private void close( |
| JavaFileManager fileManager, |
| Iterable<? extends JavaFileObject> compilationUnits) { |
| try { |
| fileManager.close(); |
| } catch (IOException e) { |
| LOG.warn(e, "Unable to close java filemanager. We may be leaking memory."); |
| } |
| |
| for (JavaFileObject unit : compilationUnits) { |
| if (!(unit instanceof ZipEntryJavaFileObject)) { |
| continue; |
| } |
| try { |
| ((ZipEntryJavaFileObject) unit).close(); |
| } catch (IOException e) { |
| LOG.warn(e, "Unable to close zipfile. We may be leaking memory."); |
| } |
| } |
| } |
| |
| private ProcessorBundle prepareProcessors( |
| ClassLoader compilerClassLoader, |
| @Nullable BuildTarget target, |
| List<String> options) { |
| String processorClassPath = null; |
| String processorNames = null; |
| |
| Iterator<String> iterator = options.iterator(); |
| while (iterator.hasNext()) { |
| String curr = iterator.next(); |
| if ("-processorpath".equals(curr) && iterator.hasNext()) { |
| processorClassPath = iterator.next(); |
| } else if ("-processor".equals(curr) && iterator.hasNext()) { |
| processorNames = iterator.next(); |
| } |
| } |
| |
| ProcessorBundle processorBundle = new ProcessorBundle(); |
| if (processorClassPath == null || processorNames == null) { |
| return processorBundle; |
| } |
| |
| // N.B. You might think that we could avoid some overhead by using the same classloader every |
| // time we create an instance of annotation processor. In an ideal world, that would work well, |
| // but many annotation processors aren't thread-safe, and they store state in class-static |
| // variables. In the interest of maximum safety, we'll create a new ClassLoader every time we |
| // need an annotation processor. |
| |
| Iterable<String> rawPaths = Splitter.on(File.pathSeparator) |
| .omitEmptyStrings() |
| .split(processorClassPath); |
| URL[] urls = FluentIterable.from(rawPaths) |
| .transform( |
| new Function<String, URL>() { |
| @Override |
| public URL apply(String pathRelativeToProjectRoot) { |
| try { |
| return Paths.get(pathRelativeToProjectRoot).toUri().toURL(); |
| } catch (MalformedURLException e) { |
| // The paths we're being given should have all been resolved from the file |
| // system already. We'd need to be unfortunate to get here. Bubble up a runtime |
| // exception. |
| throw new RuntimeException(e); |
| } |
| } |
| }) |
| .toArray(URL.class); |
| processorBundle.classLoader = new URLClassLoader( |
| urls, |
| compilerClassLoader); |
| |
| Iterable<String> names = Splitter.on(",") |
| .trimResults() |
| .omitEmptyStrings() |
| .split(processorNames); |
| for (String name : names) { |
| try { |
| LOG.debug("Loading %s from own classloader", name); |
| |
| Class<? extends Processor> aClass = |
| Preconditions.checkNotNull(processorBundle.classLoader) |
| .loadClass(name) |
| .asSubclass(Processor.class); |
| processorBundle.processors.add(aClass.newInstance()); |
| } catch (ReflectiveOperationException e) { |
| // If this happens, then the build is really in trouble. Better warn the user. |
| throw new HumanReadableException( |
| "%s: javac unable to load annotation processor: %s", |
| target != null ? target.getFullyQualifiedName() : "unknown target", |
| name); |
| } |
| } |
| |
| return processorBundle; |
| } |
| |
| private Iterable<? extends JavaFileObject> createCompilationUnits( |
| StandardJavaFileManager fileManager, |
| Function<Path, Path> absolutifier, |
| Set<Path> javaSourceFilePaths) throws IOException { |
| List<JavaFileObject> compilationUnits = Lists.newArrayList(); |
| for (Path path : javaSourceFilePaths) { |
| if (path.toString().endsWith(".java")) { |
| // For an ordinary .java file, create a corresponding JavaFileObject. |
| Iterable<? extends JavaFileObject> javaFileObjects = fileManager.getJavaFileObjects( |
| absolutifier.apply(path).toFile()); |
| compilationUnits.add(Iterables.getOnlyElement(javaFileObjects)); |
| } else if (path.toString().endsWith(SRC_ZIP)) { |
| // For a Zip of .java files, create a JavaFileObject for each .java entry. |
| ZipFile zipFile = new ZipFile(absolutifier.apply(path).toFile()); |
| for (Enumeration<? extends ZipEntry> entries = zipFile.entries(); |
| entries.hasMoreElements(); |
| ) { |
| ZipEntry entry = entries.nextElement(); |
| if (!entry.getName().endsWith(".java")) { |
| continue; |
| } |
| |
| compilationUnits.add(new ZipEntryJavaFileObject(zipFile, entry)); |
| } |
| } |
| } |
| return compilationUnits; |
| } |
| |
| private void handleMissingSymbolError( |
| BuildTarget invokingRule, |
| Diagnostic<? extends JavaFileObject> diagnostic, |
| ExecutionContext context) { |
| JavacErrorParser javacErrorParser = new JavacErrorParser( |
| context.getProjectFilesystem(), |
| context.getJavaPackageFinder()); |
| Optional<String> symbol = |
| javacErrorParser.getMissingSymbolFromCompilerError(diagnostic.toString()); |
| if (!symbol.isPresent()) { |
| // This error wasn't related to a missing symbol, as far as we can tell. |
| return; |
| } |
| MissingSymbolEvent event = MissingSymbolEvent.create( |
| invokingRule, |
| symbol.get(), |
| MissingSymbolEvent.SymbolType.Java); |
| context.getBuckEventBus().post(event); |
| } |
| |
| private static class ProcessorBundle { |
| @Nullable |
| public ClassLoader classLoader; |
| public List<Processor> processors = Lists.newArrayList(); |
| } |
| } |
