src/main/java/com/google/devtools/build/lib/actions/FilesetTraversalParamsFactory.java

// Copyright 2015 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.actions;

import com.google.common.base.Optional;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Ordering;
import com.google.devtools.build.lib.actions.FilesetTraversalParams.DirectTraversal;
import com.google.devtools.build.lib.actions.FilesetTraversalParams.DirectTraversalRoot;
import com.google.devtools.build.lib.actions.FilesetTraversalParams.PackageBoundaryMode;
import com.google.devtools.build.lib.cmdline.Label;
import com.google.devtools.build.lib.packages.FilesetEntry.SymlinkBehavior;
import com.google.devtools.build.lib.util.Fingerprint;
import com.google.devtools.build.lib.util.Preconditions;
import com.google.devtools.build.lib.vfs.Path;
import com.google.devtools.build.lib.vfs.PathFragment;
import com.google.devtools.build.lib.vfs.RootedPath;
import java.util.Objects;
import java.util.Set;
import javax.annotation.Nullable;

/** Factory of {@link FilesetTraversalParams}. */
public final class FilesetTraversalParamsFactory {

  /**
   * Creates parameters for a recursive traversal request in a package.
   *
   * <p>"Recursive" means that a directory is traversed along with all of its subdirectories. Such
   * a traversal is created when FilesetEntry.files is unspecified.
   *
   * @param ownerLabel the rule that created this object
   * @param buildFile path of the BUILD file of the package to traverse
   * @param destPath path in the Fileset's output directory that will be the root of files found
   *     in this directory
   * @param excludes optional; set of files directly under this package's directory to exclude;
   *     files in subdirectories cannot be excluded
   * @param symlinkBehaviorMode what to do with symlinks
   * @param pkgBoundaryMode what to do when the traversal hits a subdirectory that is also a
   *     subpackage (contains a BUILD file)
   */
  public static FilesetTraversalParams recursiveTraversalOfPackage(Label ownerLabel,
      Artifact buildFile, PathFragment destPath, @Nullable Set<String> excludes,
      SymlinkBehavior symlinkBehaviorMode, PackageBoundaryMode pkgBoundaryMode) {
    Preconditions.checkState(buildFile.isSourceArtifact(), "%s", buildFile);
    return new DirectoryTraversalParams(ownerLabel, DirectTraversalRootImpl.forPackage(buildFile),
        true, destPath, excludes, symlinkBehaviorMode, pkgBoundaryMode, true, false);
  }

  /**
   * Creates parameters for a recursive traversal request in a directory.
   *
   * <p>"Recursive" means that a directory is traversed along with all of its subdirectories. Such
   * a traversal is created when FilesetEntry.files is unspecified.
   *
   * @param ownerLabel the rule that created this object
   * @param directoryToTraverse path of the directory to traverse
   * @param destPath path in the Fileset's output directory that will be the root of files found
   *     in this directory
   * @param excludes optional; set of files directly below this directory to exclude; files in
   *     subdirectories cannot be excluded
   * @param symlinkBehaviorMode what to do with symlinks
   * @param pkgBoundaryMode what to do when the traversal hits a subdirectory that is also a
   *     subpackage (contains a BUILD file)
   */
  public static FilesetTraversalParams recursiveTraversalOfDirectory(Label ownerLabel,
      Artifact directoryToTraverse, PathFragment destPath, @Nullable Set<String> excludes,
      SymlinkBehavior symlinkBehaviorMode, PackageBoundaryMode pkgBoundaryMode) {
    return new DirectoryTraversalParams(ownerLabel,
        DirectTraversalRootImpl.forFileOrDirectory(directoryToTraverse), false, destPath,
        excludes, symlinkBehaviorMode, pkgBoundaryMode, true,
        !directoryToTraverse.isSourceArtifact());
  }

  /**
   * Creates parameters for a file traversal request.
   *
   * <p>Such a traversal is created for every entry in FilesetEntry.files, when it is specified.
   *
   * @param ownerLabel the rule that created this object
   * @param fileToTraverse the file to traverse; "traversal" means that if this file is actually a
   *     directory or a symlink to one then it'll be traversed as one
   * @param destPath path in the Fileset's output directory that will be the name of this file's
   *     respective symlink there, or the root of files found (in case this is a directory)
   * @param symlinkBehaviorMode what to do with symlinks
   * @param pkgBoundaryMode what to do when the traversal hits a subdirectory that is also a
   *     subpackage (contains a BUILD file)
   */
  public static FilesetTraversalParams fileTraversal(Label ownerLabel, Artifact fileToTraverse,
      PathFragment destPath, SymlinkBehavior symlinkBehaviorMode,
      PackageBoundaryMode pkgBoundaryMode) {
    return new DirectoryTraversalParams(ownerLabel,
        DirectTraversalRootImpl.forFileOrDirectory(fileToTraverse), false, destPath, null,
        symlinkBehaviorMode, pkgBoundaryMode, false, !fileToTraverse.isSourceArtifact());
  }

  /**
   * Creates traversal request parameters for a FilesetEntry wrapping another Fileset. If possible,
   * the original {@code nested} is returned to avoid unnecessary object creation. In that case, the
   * {@code ownerLabelForErrorMessages} may be ignored. Since the wrapping traversal could not have
   * an error on its own, any error messages printed will still be correct.
   *
   * @param ownerLabel the rule that created this object
   * @param nested the traversal params that were used for the nested (inner) Fileset
   * @param destDir path in the Fileset's output directory that will be the root of files coming
   *     from the nested Fileset
   * @param excludes optional; set of files directly below (not in a subdirectory of) the nested
   *     Fileset that should be excluded from the outer Fileset
   */
  public static FilesetTraversalParams nestedTraversal(
      Label ownerLabel,
      FilesetTraversalParams nested,
      PathFragment destDir,
      @Nullable Set<String> excludes) {
    if (destDir.segmentCount() == 0 && (excludes == null || excludes.isEmpty())) {
      // Wrapping the traversal here would not lead to a different result: the output location is
      // the same and there are no additional excludes.
      return nested;
    }
    // When srcdir is another Fileset, then files must be null so strip_prefix must also be null.
    return new NestedTraversalParams(ownerLabel, nested, destDir, excludes);
  }

  private abstract static class ParamsCommon implements FilesetTraversalParams {
    private final Label ownerLabelForErrorMessages;
    private final PathFragment destDir;
    private final ImmutableSet<String> excludes;

    ParamsCommon(
        Label ownerLabelForErrorMessages, PathFragment destDir, @Nullable Set<String> excludes) {
      this.ownerLabelForErrorMessages = ownerLabelForErrorMessages;
      this.destDir = destDir;
      if (excludes == null) {
        this.excludes = ImmutableSet.of();
      } else {
        // Order the set for the sake of deterministic fingerprinting.
        this.excludes = ImmutableSet.copyOf(Ordering.natural().immutableSortedCopy(excludes));
      }
    }

    @Override
    public Label getOwnerLabelForErrorMessages() {
      return ownerLabelForErrorMessages;
    }

    @Override
    public Set<String> getExcludedFiles() {
      return excludes;
    }

    @Override
    public PathFragment getDestPath() {
      return destDir;
    }

    protected final void commonFingerprint(Fingerprint fp) {
      fp.addPath(destDir);
      if (!excludes.isEmpty()) {
        fp.addStrings(excludes);
      }
    }

    @Override
    public String toString() {
      return super.toString()
          + "["
          + destDir
          + ", "
          + ownerLabelForErrorMessages
          + ", "
          + excludes
          + "]";
    }

    protected boolean internalEquals(ParamsCommon that) {
      return Objects.equals(this.ownerLabelForErrorMessages, that.ownerLabelForErrorMessages)
          && Objects.equals(this.destDir, that.destDir)
          && Objects.equals(this.excludes, that.excludes);
    }

    protected int internalHashCode() {
      return Objects.hash(ownerLabelForErrorMessages, destDir, excludes);
    }
  }

  private static final class DirectTraversalImpl implements DirectTraversal {
    private final DirectTraversalRoot root;
    private final boolean isPackage;
    private final boolean followSymlinks;
    private final PackageBoundaryMode pkgBoundaryMode;
    private final boolean isRecursive;
    private final boolean isGenerated;

    DirectTraversalImpl(DirectTraversalRoot root, boolean isPackage, boolean followSymlinks,
        PackageBoundaryMode pkgBoundaryMode, boolean isRecursive, boolean isGenerated) {
      this.root = root;
      this.isPackage = isPackage;
      this.followSymlinks = followSymlinks;
      this.pkgBoundaryMode = pkgBoundaryMode;
      this.isRecursive = isRecursive;
      this.isGenerated = isGenerated;
    }

    @Override
    public DirectTraversalRoot getRoot() {
      return root;
    }

    @Override
    public boolean isPackage() {
      return isPackage;
    }

    @Override
    public boolean isRecursive() {
      return isRecursive;
    }

    @Override
    public boolean isGenerated() {
      return isGenerated;
    }

    @Override
    public boolean isFollowingSymlinks() {
      return followSymlinks;
    }

    @Override
    public PackageBoundaryMode getPackageBoundaryMode() {
      return pkgBoundaryMode;
    }

    void fingerprint(Fingerprint fp) {
      fp.addPath(root.asRootedPath().asPath());
      fp.addBoolean(isPackage);
      fp.addBoolean(followSymlinks);
      fp.addBoolean(isRecursive);
      fp.addBoolean(isGenerated);
      pkgBoundaryMode.fingerprint(fp);
    }
  }

  private static final class DirectoryTraversalParams extends ParamsCommon {
    private final DirectTraversalImpl traversal;

    DirectoryTraversalParams(Label ownerLabel,
        DirectTraversalRoot root,
        boolean isPackage,
        PathFragment destPath,
        @Nullable Set<String> excludes,
        SymlinkBehavior symlinkBehaviorMode,
        PackageBoundaryMode pkgBoundaryMode,
        boolean isRecursive,
        boolean isGenerated) {
      super(ownerLabel, destPath, excludes);
      traversal = new DirectTraversalImpl(root, isPackage,
          symlinkBehaviorMode == SymlinkBehavior.DEREFERENCE, pkgBoundaryMode, isRecursive,
          isGenerated);
    }

    @Override
    public Optional<DirectTraversal> getDirectTraversal() {
      return Optional.<DirectTraversal>of(traversal);
    }

    @Override
    public Optional<FilesetTraversalParams> getNestedTraversal() {
      return Optional.absent();
    }

    @Override
    public void fingerprint(Fingerprint fp) {
      commonFingerprint(fp);
      traversal.fingerprint(fp);
    }

    @Override
    public int hashCode() {
      return 37 * super.internalHashCode() + Objects.hashCode(traversal);
    }

    @Override
    public boolean equals(Object obj) {
      if (this == obj) {
        return true;
      }
      if (!(obj instanceof DirectoryTraversalParams)) {
        return false;
      }
      DirectoryTraversalParams that = (DirectoryTraversalParams) obj;
      return Objects.equals(this.traversal, that.traversal) && internalEquals(that);
    }
  }

  private static final class NestedTraversalParams extends ParamsCommon {
    private final FilesetTraversalParams nested;

    NestedTraversalParams(
        Label ownerLabel,
        FilesetTraversalParams nested,
        PathFragment destDir,
        @Nullable Set<String> excludes) {
      super(ownerLabel, destDir, excludes);
      this.nested = nested;
    }

    @Override
    public Optional<DirectTraversal> getDirectTraversal() {
      return Optional.absent();
    }

    @Override
    public Optional<FilesetTraversalParams> getNestedTraversal() {
      return Optional.of(nested);
    }

    @Override
    public void fingerprint(Fingerprint fp) {
      commonFingerprint(fp);
      nested.fingerprint(fp);
    }

    @Override
    public int hashCode() {
      return 37 * super.internalHashCode() + Objects.hashCode(nested);
    }

    @Override
    public boolean equals(Object obj) {
      if (this == obj) {
        return true;
      }
      if (!(obj instanceof NestedTraversalParams)) {
        return false;
      }
      NestedTraversalParams that = (NestedTraversalParams) obj;
      return Objects.equals(this.nested, that.nested) && internalEquals(that);
    }
  }

  private static final class DirectTraversalRootImpl implements DirectTraversalRoot {
    private final Path rootDir;
    private final PathFragment relativeDir;

    static DirectTraversalRoot forPackage(Artifact buildFile) {
      return new DirectTraversalRootImpl(buildFile.getRoot().getPath(),
          buildFile.getRootRelativePath().getParentDirectory());
    }

    static DirectTraversalRoot forFileOrDirectory(Artifact fileOrDirectory) {
      return new DirectTraversalRootImpl(fileOrDirectory.getRoot().getPath(),
          fileOrDirectory.getRootRelativePath());
    }

    private DirectTraversalRootImpl(Path rootDir, PathFragment relativeDir) {
      this.rootDir = rootDir;
      this.relativeDir = relativeDir;
    }

    @Override
    public Path getRootPart() {
      return rootDir;
    }

    @Override
    public PathFragment getRelativePart() {
      return relativeDir;
    }

    @Override
    public RootedPath asRootedPath() {
      return RootedPath.toRootedPath(rootDir, relativeDir);
    }
  }
}