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

// Copyright 2024 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 static com.google.common.collect.ImmutableListMultimap.toImmutableListMultimap;

import com.google.common.base.Functions;
import com.google.common.collect.ImmutableListMultimap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import com.google.common.collect.Streams;
import com.google.devtools.build.lib.cmdline.Label;
import com.google.devtools.build.lib.events.Event;
import com.google.devtools.build.lib.events.EventHandler;
import com.google.devtools.build.lib.packages.AspectDescriptor;
import com.google.devtools.build.lib.server.FailureDetails.Analysis;
import com.google.devtools.build.lib.server.FailureDetails.Analysis.Code;
import com.google.devtools.build.lib.server.FailureDetails.FailureDetail;
import com.google.devtools.build.lib.skyframe.AbstractSaneAnalysisException;
import com.google.devtools.build.lib.util.DetailedExitCode;
import java.util.Set;
import java.util.stream.Collectors;
import javax.annotation.Nullable;

/**
 * This exception is thrown when a conflict between actions is detected. It contains information
 * about the artifact for which the conflict is found, and data about the two conflicting actions
 * and their owners. Non-final only for {@link WithAspectKeyInfo}.
 */
public sealed class ActionConflictException extends AbstractSaneAnalysisException {
  private final Artifact artifact;
  private final ActionAnalysisMetadata attemptedAction;
  private final boolean isPrefixConflict;

  private static final int MAX_DIFF_ARTIFACTS_TO_REPORT = 5;

  public static ActionConflictException create(
      ActionKeyContext actionKeyContext,
      Artifact artifact,
      ActionAnalysisMetadata previousAction,
      ActionAnalysisMetadata attemptedAction) {
    return new ActionConflictException(
        artifact,
        attemptedAction,
        createDetailedMessage(artifact, actionKeyContext, attemptedAction, previousAction),
        /* isPrefixConflict= */ false);
  }

  /**
   * Exception to indicate that one {@link Action} has an output artifact whose path is a prefix of
   * an output of another action. Since the first path cannot be both a directory and a file, this
   * would lead to an error if both actions were executed in the same build.
   */
  public static ActionConflictException createPrefix(
      Artifact firstArtifact,
      Artifact secondArtifact,
      ActionAnalysisMetadata firstAction,
      ActionAnalysisMetadata secondAction) {
    return new ActionConflictException(
        firstArtifact,
        firstAction,
        createPrefixDetailedMessage(
            firstArtifact,
            secondArtifact,
            firstAction.getOwner().getLabel(),
            secondAction.getOwner().getLabel()),
        /* isPrefixConflict= */ true);
  }

  public static ActionConflictException withAspectKeyInfo(
      ActionConflictException e, ActionLookupKey aspectKey) {
    return new WithAspectKeyInfo(e, aspectKey);
  }

  private ActionConflictException(
      Artifact artifact,
      ActionAnalysisMetadata attemptedAction,
      String message,
      boolean isPrefixConflict) {
    super(message);
    this.artifact = artifact;
    this.attemptedAction = attemptedAction;
    this.isPrefixConflict = isPrefixConflict;
  }

  public Artifact getArtifact() {
    return artifact;
  }

  public ActionAnalysisMetadata getAttemptedAction() {
    return attemptedAction;
  }

  private static String createDetailedMessage(
      Artifact artifact,
      ActionKeyContext actionKeyContext,
      ActionAnalysisMetadata a,
      ActionAnalysisMetadata b) {
    return "file '"
        + artifact.prettyPrint()
        + "' is generated by these conflicting actions:\n"
        + debugSuffix(actionKeyContext, a, b);
  }

  private static String createPrefixDetailedMessage(
      Artifact firstArtifact, Artifact secondArtifact, Label firstOwner, Label secondOwner) {
    return String.format(
        "One of the output paths '%s' (belonging to %s) and '%s' (belonging to %s) is a"
            + " prefix of the other. These actions cannot be simultaneously present; please"
            + " rename one of the output files or build just one of them",
        firstArtifact.getExecPath(), firstOwner, secondArtifact.getExecPath(), secondOwner);
  }

  public void reportTo(EventHandler eventListener) {
    eventListener.handle(Event.error(this.getMessage()));
  }

  @Override
  public DetailedExitCode getDetailedExitCode() {
    return DetailedExitCode.of(
        FailureDetail.newBuilder()
            .setMessage(getMessage())
            .setAnalysis(
                Analysis.newBuilder()
                    .setCode(
                        isPrefixConflict ? Code.ARTIFACT_PREFIX_CONFLICT : Code.ACTION_CONFLICT))
            .build());
  }

  private static void addStringDetail(StringBuilder sb, String key, String valueA, String valueB) {
    valueA = valueA != null ? valueA : "(null)";
    valueB = valueB != null ? valueB : "(null)";

    sb.append(key).append(": ").append(valueA);
    if (!valueA.equals(valueB)) {
      sb.append(", ").append(valueB);
    }
    sb.append("\n");
  }

  private static void addListDetail(
      StringBuilder sb, String key, Iterable<Artifact> valueA, Iterable<Artifact> valueB) {
    Set<Artifact> diffA = differenceWithoutOwner(valueA, valueB);
    Set<Artifact> diffB = differenceWithoutOwner(valueB, valueA);

    sb.append(key).append(": ");
    if (diffA.isEmpty() && diffB.isEmpty()) {
      sb.append("are equal\n");
    } else {
      if (!diffA.isEmpty()) {
        sb.append(
            "Attempted action contains artifacts not in previous action (first "
                + MAX_DIFF_ARTIFACTS_TO_REPORT
                + "): \n");
        prettyPrintArtifactDiffs(sb, diffA);
      }

      if (!diffB.isEmpty()) {
        sb.append(
            "Previous action contains artifacts not in attempted action (first "
                + MAX_DIFF_ARTIFACTS_TO_REPORT
                + "): \n");
        prettyPrintArtifactDiffs(sb, diffB);
      }
    }
  }

  /** Returns items in {@code valueA} that are not in {@code valueB}, ignoring the owner. */
  private static Set<Artifact> differenceWithoutOwner(
      Iterable<Artifact> valueA, Iterable<Artifact> valueB) {
    ImmutableSet.Builder<Artifact> diff = new ImmutableSet.Builder<>();

    // Group valueB by exec path for easier checks.
    ImmutableListMultimap<String, Artifact> mapB =
        Streams.stream(valueB)
            .collect(toImmutableListMultimap(Artifact::getExecPathString, Functions.identity()));
    for (Artifact a : valueA) {
      boolean found = false;
      for (Artifact b : mapB.get(a.getExecPathString())) {
        if (a.equalsWithoutOwner(b)) {
          found = true;
          break;
        }
      }
      if (!found) {
        diff.add(a);
      }
    }

    return diff.build();
  }

  /** Pretty print action diffs (at most {@code MAX_DIFF_ARTIFACTS_TO_REPORT} lines). */
  private static void prettyPrintArtifactDiffs(StringBuilder sb, Set<Artifact> diff) {
    for (Artifact artifact : Iterables.limit(diff, MAX_DIFF_ARTIFACTS_TO_REPORT)) {
      sb.append('\t').append(artifact.prettyPrint()).append('\n');
    }
  }

  // See also Actions.canBeShared()
  private static String debugSuffix(
      ActionKeyContext actionKeyContext, ActionAnalysisMetadata a, ActionAnalysisMetadata b) {
    // Note: the error message reveals to users the names of intermediate files that are not
    // documented in the BUILD language.  This error-reporting logic is rather elaborate but it
    // does help to diagnose some tricky situations.
    StringBuilder sb = new StringBuilder();
    ActionOwner aOwner = a.getOwner();
    ActionOwner bOwner = b.getOwner();
    boolean aNull = aOwner == null;
    boolean bNull = bOwner == null;

    addStringDetail(
        sb,
        "Label",
        aNull ? null : Label.print(aOwner.getLabel()),
        bNull ? null : Label.print(bOwner.getLabel()));
    if ((!aNull && !aOwner.getAspectDescriptors().isEmpty())
        || (!bNull && !bOwner.getAspectDescriptors().isEmpty())) {
      addStringDetail(sb, "Aspects", aspectDescriptor(aOwner), aspectDescriptor(bOwner));
    }
    addStringDetail(
        sb,
        "RuleClass",
        aNull ? null : aOwner.getTargetKind(),
        bNull ? null : bOwner.getTargetKind());
    addStringDetail(
        sb,
        "JavaActionClass",
        aNull ? null : a.getClass().toString(),
        bNull ? null : b.getClass().toString());
    addStringDetail(
        sb,
        "Configuration",
        aNull ? null : aOwner.getConfigurationChecksum(),
        bNull ? null : bOwner.getConfigurationChecksum());
    addStringDetail(sb, "Mnemonic", a.getMnemonic(), b.getMnemonic());
    try {
      addStringDetail(
          sb,
          "Action key",
          a.getKey(actionKeyContext, /* artifactExpander= */ null),
          b.getKey(actionKeyContext, /* artifactExpander= */ null));
    } catch (InterruptedException e) {
      // Only for debugging - skip the key and carry on.
      addStringDetail(sb, "Action key", "<elided due to interrupt>", "<elided due to interrupt>");
      Thread.currentThread().interrupt();
    }

    if ((a instanceof ActionExecutionMetadata) && (b instanceof ActionExecutionMetadata)) {
      addStringDetail(
          sb,
          "Progress message",
          ((ActionExecutionMetadata) a).getProgressMessage(),
          ((ActionExecutionMetadata) b).getProgressMessage());
      addStringDetail(
          sb,
          "Action describeKey",
          ((ActionExecutionMetadata) a).describeKey(),
          ((ActionExecutionMetadata) b).describeKey());
    }

    Artifact aPrimaryInput = a.getPrimaryInput();
    Artifact bPrimaryInput = b.getPrimaryInput();
    addStringDetail(
        sb,
        "PrimaryInput",
        aPrimaryInput == null ? null : aPrimaryInput.toString(),
        bPrimaryInput == null ? null : bPrimaryInput.toString());
    addStringDetail(
        sb, "PrimaryOutput", a.getPrimaryOutput().toString(), b.getPrimaryOutput().toString());

    // Only add list details if the primary input of A matches the input of B. Otherwise
    // the above information is enough and list diff detail is not needed.
    if ((aPrimaryInput == null && bPrimaryInput == null)
        || (aPrimaryInput != null
            && bPrimaryInput != null
            && aPrimaryInput.toString().equals(bPrimaryInput.toString()))) {
      Artifact aPrimaryOutput = a.getPrimaryOutput();
      Artifact bPrimaryOutput = b.getPrimaryOutput();
      if (!aPrimaryOutput.equalsWithoutOwner(bPrimaryOutput)) {
        sb.append("Primary outputs are different: ")
            .append(System.identityHashCode(aPrimaryOutput))
            .append(", ")
            .append(System.identityHashCode(bPrimaryOutput))
            .append('\n');
      }
      ArtifactOwner aArtifactOwner = aPrimaryOutput.getArtifactOwner();
      ArtifactOwner bArtifactOwner = bPrimaryOutput.getArtifactOwner();
      addStringDetail(
          sb, "Owner information", aArtifactOwner.toString(), bArtifactOwner.toString());
      addListDetail(
          sb, "MandatoryInputs", a.getMandatoryInputs().toList(), b.getMandatoryInputs().toList());
      addListDetail(sb, "Outputs", a.getOutputs(), b.getOutputs());
    }

    return sb.toString();
  }

  @Nullable
  private static String aspectDescriptor(ActionOwner owner) {
    return owner == null
        ? null
        : owner.getAspectDescriptors().stream()
            .map(AspectDescriptor::getDescription)
            .collect(Collectors.joining(",", "[", "]"));
  }

  @Nullable
  public ActionLookupKey getAspectKey() {
    return null;
  }

  /**
   * For skymeld.
   *
   * <p>We need to forward the AspectKey along so that it's available for the final conflict report.
   */
  private static final class WithAspectKeyInfo extends ActionConflictException {
    private final ActionLookupKey aspectKey;

    private WithAspectKeyInfo(ActionConflictException e, ActionLookupKey aspectKey) {
      super(e.artifact, e.attemptedAction, e.getMessage(), e.isPrefixConflict);
      this.aspectKey = aspectKey;
    }

    @Override
    public ActionLookupKey getAspectKey() {
      return aspectKey;
    }
  }
}