src/main/java/com/google/devtools/build/lib/packages/License.java - bazel - Git at Google

 // 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();
   }
 }
	// 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();
	}
	}