Java tutorial
// Copyright 2014 The Bazel Authors. All rights reserved. // // 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.google.devtools.build.lib.packages; import com.google.common.annotations.VisibleForTesting; import com.google.common.collect.HashBasedTable; import com.google.common.collect.ImmutableSet; import com.google.common.collect.ImmutableTable; import com.google.common.collect.Sets; import com.google.common.collect.Table; import com.google.devtools.build.lib.cmdline.Label; import com.google.devtools.build.lib.cmdline.LabelSyntaxException; import com.google.devtools.build.lib.concurrent.ThreadSafety.Immutable; import com.google.devtools.build.lib.concurrent.ThreadSafety.ThreadSafe; import com.google.devtools.build.lib.events.Event; import com.google.devtools.build.lib.events.EventHandler; import com.google.devtools.build.lib.events.Location; import java.util.Collection; import java.util.Collections; import java.util.EnumSet; import java.util.List; import java.util.Set; /** * Support for license and distribution checking. */ @Immutable @ThreadSafe public final class License { private final Set<LicenseType> licenseTypes; private final Set<Label> exceptions; /** * The error that's thrown if a build file contains an invalid license string. */ public static class LicenseParsingException extends Exception { public LicenseParsingException(String s) { super(s); } } /** * LicenseType is the basis of the License lattice - stricter licenses should * be declared before less-strict licenses in the enum. * * <p>Note that the order is important for the purposes of finding the least * restrictive license. */ public enum LicenseType { BY_EXCEPTION_ONLY, RESTRICTED, RESTRICTED_IF_STATICALLY_LINKED, RECIPROCAL, NOTICE, PERMISSIVE, UNENCUMBERED, NONE } /** * Gets the least restrictive license type from the list of licenses declared * for a target. For the purposes of license checking, the license type set of * a declared license can be reduced to its least restrictive member. * * @param types a collection of license types * @return the least restrictive license type */ @VisibleForTesting static LicenseType leastRestrictive(Collection<LicenseType> types) { return types.isEmpty() ? LicenseType.BY_EXCEPTION_ONLY : Collections.max(types); } /** * An instance of LicenseType.None with no exceptions, used for packages * outside of third_party which have no license clause in their BUILD files. */ public static final License NO_LICENSE = new License(ImmutableSet.of(LicenseType.NONE), Collections.<Label>emptySet()); /** * A default instance of Distributions which is used for packages which * have no "distribs" declaration. If nothing is declared, we opt for the * most permissive kind of distribution, which is the internal-only distrib. */ public static final Set<DistributionType> DEFAULT_DISTRIB = Collections.singleton(DistributionType.INTERNAL); /** * The types of distribution that are supported. */ public enum DistributionType { INTERNAL, WEB, CLIENT, EMBEDDED } /** * Parses a set of strings declaring distribution types. * * @param distStrings strings containing distribution declarations from BUILD * files * @return a new, unmodifiable set of DistributionTypes * @throws LicenseParsingException */ public static Set<DistributionType> parseDistributions(Collection<String> distStrings) throws LicenseParsingException { if (distStrings.isEmpty()) { return Collections.unmodifiableSet(EnumSet.of(DistributionType.INTERNAL)); } else { Set<DistributionType> result = EnumSet.noneOf(DistributionType.class); for (String distStr : distStrings) { try { DistributionType dist = DistributionType.valueOf(distStr.toUpperCase()); result.add(dist); } catch (IllegalArgumentException e) { throw new LicenseParsingException("Invalid distribution type '" + distStr + "'"); } } return Collections.unmodifiableSet(result); } } private static final Object MARKER = new Object(); /** * The license incompatibility set. This contains the set of * (Distribution,License) pairs that should generate errors. */ private static Table<DistributionType, LicenseType, Object> LICENSE_INCOMPATIBILIES = createLicenseIncompatibilitySet(); private static Table<DistributionType, LicenseType, Object> createLicenseIncompatibilitySet() { Table<DistributionType, LicenseType, Object> result = HashBasedTable.create(); result.put(DistributionType.CLIENT, LicenseType.RESTRICTED, MARKER); result.put(DistributionType.EMBEDDED, LicenseType.RESTRICTED, MARKER); result.put(DistributionType.INTERNAL, LicenseType.BY_EXCEPTION_ONLY, MARKER); result.put(DistributionType.CLIENT, LicenseType.BY_EXCEPTION_ONLY, MARKER); result.put(DistributionType.WEB, LicenseType.BY_EXCEPTION_ONLY, MARKER); result.put(DistributionType.EMBEDDED, LicenseType.BY_EXCEPTION_ONLY, MARKER); return ImmutableTable.copyOf(result); } /** * The license warning set. This contains the set of * (Distribution,License) pairs that should generate warnings when the user * requests verbose license checking. */ private static Table<DistributionType, LicenseType, Object> LICENSE_WARNINGS = createLicenseWarningsSet(); private static Table<DistributionType, LicenseType, Object> createLicenseWarningsSet() { Table<DistributionType, LicenseType, Object> result = HashBasedTable.create(); result.put(DistributionType.CLIENT, LicenseType.RECIPROCAL, MARKER); result.put(DistributionType.EMBEDDED, LicenseType.RECIPROCAL, MARKER); result.put(DistributionType.CLIENT, LicenseType.NOTICE, MARKER); result.put(DistributionType.EMBEDDED, LicenseType.NOTICE, MARKER); return ImmutableTable.copyOf(result); } private License(Set<LicenseType> licenseTypes, Set<Label> exceptions) { // Defensive copy is done in .of() this.licenseTypes = licenseTypes; this.exceptions = exceptions; } public static License of(Collection<LicenseType> licenses, Collection<Label> exceptions) { Set<LicenseType> licenseSet = ImmutableSet.copyOf(licenses); Set<Label> exceptionSet = ImmutableSet.copyOf(exceptions); if (exceptionSet.isEmpty() && licenseSet.equals(ImmutableSet.of(LicenseType.NONE))) { return License.NO_LICENSE; } return new License(licenseSet, exceptionSet); } /** * Computes a license which can be used to check if a package is compatible * with some kinds of distribution. The list of licenses is scanned for the * least restrictive, and the exceptions are added. * * @param licStrings the list of license strings declared for the package * @throws LicenseParsingException if there are any parsing problems */ public static License parseLicense(List<String> licStrings) throws LicenseParsingException { /* * The semantics of comparison for licenses depends on a stable iteration * order for both license types and exceptions. For licenseTypes, it will be * the comparison order from the enumerated types; for exceptions, it will * be lexicographic order achieved using TreeSets. */ Set<LicenseType> licenseTypes = EnumSet.noneOf(LicenseType.class); Set<Label> exceptions = Sets.newTreeSet(); for (String str : licStrings) { if (str.startsWith("exception=")) { try { Label label = Label.parseAbsolute(str.substring("exception=".length())); exceptions.add(label); } catch (LabelSyntaxException e) { throw new LicenseParsingException(e.getMessage()); } } else { try { licenseTypes.add(LicenseType.valueOf(str.toUpperCase())); } catch (IllegalArgumentException e) { throw new LicenseParsingException("invalid license type: '" + str + "'"); } } } return License.of(licenseTypes, exceptions); } /** * Checks if this license is compatible with distributing a particular target * in some set of distribution modes. * * @param dists the modes of distribution * @param target the target which is being checked, and which will be used for * checking exceptions * @param licensedTarget the target which declared the license being checked. * @param eventHandler a reporter where any licensing issues discovered should be * reported * @param staticallyLinked whether the target is statically linked under this command * @return true if the license is compatible with the distributions */ public boolean checkCompatibility(Set<DistributionType> dists, Target target, Label licensedTarget, EventHandler eventHandler, boolean staticallyLinked) { Location location = (target instanceof Rule) ? ((Rule) target).getLocation() : null; LicenseType leastRestrictiveLicense; if (licenseTypes.contains(LicenseType.RESTRICTED_IF_STATICALLY_LINKED)) { Set<LicenseType> tempLicenses = EnumSet.copyOf(licenseTypes); tempLicenses.remove(LicenseType.RESTRICTED_IF_STATICALLY_LINKED); if (staticallyLinked) { tempLicenses.add(LicenseType.RESTRICTED); } else { tempLicenses.add(LicenseType.UNENCUMBERED); } leastRestrictiveLicense = leastRestrictive(tempLicenses); } else { leastRestrictiveLicense = leastRestrictive(licenseTypes); } for (DistributionType dt : dists) { if (LICENSE_INCOMPATIBILIES.contains(dt, leastRestrictiveLicense)) { if (!exceptions.contains(target.getLabel())) { eventHandler.handle(Event.error(location, "Build target '" + target.getLabel() + "' is not compatible with license '" + this + "' from target '" + licensedTarget + "'")); return false; } } else if (LICENSE_WARNINGS.contains(dt, leastRestrictiveLicense)) { eventHandler.handle( Event.warn(location, "Build target '" + target + "' has a potential licensing issue " + "with a '" + this + "' license from target '" + licensedTarget + "'")); } } return true; } /** * @return an immutable set of {@link LicenseType}s contained in this {@code * License} */ public Set<LicenseType> getLicenseTypes() { return licenseTypes; } /** * @return an immutable set of {@link Label}s that describe exceptions to the * {@code License} */ public Set<Label> getExceptions() { return exceptions; } /** * A simple toString implementation which generates a canonical form of the * license. (The order of license types is guaranteed to be canonical by * EnumSet, and the order of exceptions is guaranteed to be lexicographic * order by TreeSet.) */ @Override public String toString() { if (exceptions.isEmpty()) { return licenseTypes.toString().toLowerCase(); } else { return licenseTypes.toString().toLowerCase() + " with exceptions " + exceptions; } } /** * A simple equals implementation leveraging the support built into Set that * delegates to its contents. */ @Override public boolean equals(Object o) { return o == this || o instanceof License && ((License) o).licenseTypes.equals(this.licenseTypes) && ((License) o).exceptions.equals(this.exceptions); } /** * A simple hashCode implementation leveraging the support built into Set that * delegates to its contents. */ @Override public int hashCode() { return licenseTypes.hashCode() * 43 + exceptions.hashCode(); } }