java/com/google/gerrit/plugins/codeowners/backend/CodeOwnerApprovalCheckInput.java - plugins/code-owners - Git at Google

 // Copyright (C) 2022 The Android Open Source Project
 //
 // 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.gerrit.plugins.codeowners.backend;

 import static com.google.common.collect.ImmutableMap.toImmutableMap;
 import static com.google.common.collect.ImmutableSet.toImmutableSet;
 import static com.google.common.collect.ImmutableSetMultimap.toImmutableSetMultimap;
 import static java.util.Comparator.comparing;

 import com.google.auto.value.AutoValue;
 import com.google.auto.value.extension.memoized.Memoized;
 import com.google.common.base.Predicate;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableMultimap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.ImmutableSetMultimap;
 import com.google.common.collect.ImmutableSortedSet;
 import com.google.common.flogger.FluentLogger;
 import com.google.gerrit.entities.Account;
 import com.google.gerrit.entities.PatchSet;
 import com.google.gerrit.entities.PatchSetApproval;
 import com.google.gerrit.metrics.Timer0;
 import com.google.gerrit.plugins.codeowners.backend.config.CodeOwnersPluginProjectConfigSnapshot;
 import com.google.gerrit.plugins.codeowners.backend.config.RequiredApproval;
 import com.google.gerrit.plugins.codeowners.metrics.CodeOwnerMetrics;
 import com.google.gerrit.server.approval.ApprovalsUtil;
 import com.google.gerrit.server.notedb.ChangeNotes;
 import com.google.gerrit.server.notedb.ReviewerStateInternal;
 import com.google.gerrit.server.util.LabelVote;
 import com.google.inject.Inject;
 import com.google.inject.assistedinject.Assisted;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Optional;

 /**
  * Input for {@link CodeOwnerApprovalCheck}.
  *
  * <p>Provides all data that is needed to check the code owner approvals on a change.
  */
 @AutoValue
 public abstract class CodeOwnerApprovalCheckInput {
   private static final FluentLogger logger = FluentLogger.forEnclosingClass();

   /**
    * Gets the IDs of the accounts of all reviewers that can possibly code owner approve the change
    * (if they are code owners).
    *
    * <p>If self approvals are ignored the patch set uploader is filtered out since in this case the
    * patch set uploader cannot approve the change even if they are a code owner.
    */
   public abstract ImmutableSet<Account.Id> reviewers();

   /**
    * Gets the IDs of the accounts that have an approval on the current patch set that possibly
    * counts as code owner approval (if they are code owners).
    *
    * <p>If self approvals are ignored the patch set uploader is filtered out since in this case the
    * approval of the patch set uploader is ignored even if they are a code owner.
    */
   public abstract ImmutableSet<Account.Id> approvers();

   /**
    * Gets a map of previous patch sets to the IDs of the accounts that have an approval on that
    * patch set that is sticky and possibly counts as code owner approval (if they are code owners).
    *
    * <p>If self approvals are ignored the patch set uploader is filtered out for all patch sets
    * since in this case the approval of the patch set uploader is ignored even if they are a code
    * owner.
    */
   public abstract ImmutableMultimap<PatchSet.Id, Account.Id> approversFromPreviousPatchSets();

   @Memoized
   public ImmutableSortedSet<PatchSet.Id> previouslyApprovedPatchSetsInReverseOrder() {
     return ImmutableSortedSet.orderedBy(comparing(PatchSet.Id::get).reversed())
         .addAll(approversFromPreviousPatchSets().keySet())
         .build();
   }

   /**
    * Account from which an implicit code owner approval should be assumed.
    *
    * @see CodeOwnersPluginProjectConfigSnapshot#areImplicitApprovalsEnabled()
    * @return the account of the change owner if implicit approvals are enabled, otherwise {@link
    *     Optional#empty()}
    */
   public abstract Optional<Account.Id> implicitApprover();

   /**
    * Gets the approvals from the current patch set that count as code owner overrides.
    *
    * <p>If self approvals are ignored an override of the patch set uploader is filtered out since it
    * doesn't count as code owner override.
    */
   public abstract ImmutableSet<PatchSetApproval> overrides();

   /** Gets the configured global code owners. */
   public abstract CodeOwnerResolverResult globalCodeOwners();

   /** Gets the policy that defines who owns paths for which no code owners are defined. */
   public abstract FallbackCodeOwners fallbackCodeOwners();

   /**
    * Whether all code owners should be checked. *
    *
    * <p>If {@code true} {@link PathCodeOwnerStatus#owners()} are expected to be set in {@link
    * PathCodeOwnerStatus} instances that are created by {@link CodeOwnerApprovalCheck}.
    */
   public abstract boolean checkAllOwners();

   /**
    * Creates a {@link CodeOwnerApprovalCheckInput} instance for computing the paths in a change that
    * are owned by the given accounts.
    *
    * @param codeOwnersConfig the code-owners plugin configuration
    * @param codeOwnerResolver the {@link CodeOwnerResolver} that should be used to resolve the
    *     configured global code owners
    * @param changeNotes the notes of the change for which owned paths should be computed
    * @param accounts the accounts for which the owned paths should be computed
    * @return the created {@link CodeOwnerApprovalCheckInput} instance
    */
   public static CodeOwnerApprovalCheckInput createForComputingOwnedPaths(
       CodeOwnersPluginProjectConfigSnapshot codeOwnersConfig,
       CodeOwnerResolver codeOwnerResolver,
       ChangeNotes changeNotes,
       ImmutableSet<Account.Id> accounts) {
     CodeOwnerResolverResult globalCodeOwners =
         codeOwnerResolver.resolveGlobalCodeOwners(changeNotes.getProjectName());
     logger.atFine().log("global code owners = %s", globalCodeOwners);

     FallbackCodeOwners fallbackCodeOwners = codeOwnersConfig.getFallbackCodeOwners();
     logger.atFine().log("fallbackCodeOwner = %s", fallbackCodeOwners);

     return create(
         /* reviewers= */ ImmutableSet.of(),
         /* approvers= */ accounts,
         /* approversFromPreviousPatchSets= */ ImmutableMultimap.of(),
         // Do not check for implicit approvals since implicit approvals of other users
         // should be ignored. For the given account we do not need to check for
         // implicit approvals since all owned files are already covered by the
         // explicit approval.
         /* implicitApprover= */ Optional.empty(),
         /* overrides= */ ImmutableSet.of(),
         globalCodeOwners,
         fallbackCodeOwners,
         /* checkAllOwners= */ true);
   }

   /**
    * Creates a {@link CodeOwnerApprovalCheckInput} instance.
    *
    * @param reviewers the reviewers that can possibly code owner approve the change (if they are
    *     code owners)
    * @param approvers the accounts that have an approval on the current patch set that possibly
    *     counts as code owner approval (if they are code owners)
    * @param implicitApprover account from which an implicit code owner approval should be assumed
    * @param overrides the approvals from the current patch set that count as code owner overrides
    * @param globalCodeOwners the configured global code owners
    * @param fallbackCodeOwners the policy that defines who owns paths for which no code owners are
    *     defined
    * @param checkAllOwners Whether all code owners are checked. If {@code true} {@link
    *     PathCodeOwnerStatus#owners()} will be set in the the {@link PathCodeOwnerStatus} instances
    *     that are created by {@link CodeOwnerApprovalCheck}. Checking all owners means that no
    *     shortcuts can be applied, hence checking the code owner approvals with {@code
    *     checkAllOwners=true} is more expensive.
    * @return the created {@link CodeOwnerApprovalCheckInput} instance
    */
   private static CodeOwnerApprovalCheckInput create(
       ImmutableSet<Account.Id> reviewers,
       ImmutableSet<Account.Id> approvers,
       ImmutableMultimap<PatchSet.Id, Account.Id> approversFromPreviousPatchSets,
       Optional<Account.Id> implicitApprover,
       ImmutableSet<PatchSetApproval> overrides,
       CodeOwnerResolverResult globalCodeOwners,
       FallbackCodeOwners fallbackCodeOwners,
       boolean checkAllOwners) {
     return new AutoValue_CodeOwnerApprovalCheckInput(
         reviewers,
         approvers,
         approversFromPreviousPatchSets,
         implicitApprover,
         overrides,
         globalCodeOwners,
         fallbackCodeOwners,
         checkAllOwners);
   }

   /**
    * Class to load all inputs that are required for checking the code owner approvals on a change.
    */
   public static class Loader {
     /** Factory to create the {@link Loader} with injected dependencies. */
     interface Factory {
       Loader create(
           CodeOwnersPluginProjectConfigSnapshot codeOwnersConfig,
           CodeOwnerResolver codeOwnerResolver,
           ChangeNotes changeNotes);
     }

     private final ApprovalsUtil approvalsUtil;
     private final CodeOwnerMetrics codeOwnerMetrics;
     private final CodeOwnersPluginProjectConfigSnapshot codeOwnersConfig;
     private final CodeOwnerResolver codeOwnerResolver;
     private final ChangeNotes changeNotes;

     @Inject
     Loader(
         ApprovalsUtil approvalsUtil,
         CodeOwnerMetrics codeOwnerMetrics,
         @Assisted CodeOwnersPluginProjectConfigSnapshot codeOwnersConfig,
         @Assisted CodeOwnerResolver codeOwnerResolver,
         @Assisted ChangeNotes changeNotes) {
       this.approvalsUtil = approvalsUtil;
       this.codeOwnerMetrics = codeOwnerMetrics;
       this.codeOwnersConfig = codeOwnersConfig;
       this.codeOwnerResolver = codeOwnerResolver;
       this.changeNotes = changeNotes;
     }

     CodeOwnerApprovalCheckInput load() {
       logger.atFine().log(
           "requiredApproval = %s, overrideApprovals = %s",
           codeOwnersConfig.getRequiredApproval().formatForLogging(),
           RequiredApproval.formatForLogging(codeOwnersConfig.getOverrideApprovals()));
       return CodeOwnerApprovalCheckInput.create(
           getReviewers(),
           getApprovers(),
           getApproversFromPreviousPatchSets(),
           getImplicitApprover(),
           getOverrides(),
           getGlobalCodeOwners(),
           getFallbackCodeOwners(),
           /* checkAllOwners= */ false);
     }

     /**
      * Gets the IDs of the accounts of all reviewers that can possibly code owner approve the change
      * (if they are code owners).
      *
      * <p>If self approvals are ignored the patch set uploader is filtered out since in this case
      * the patch set uploader cannot approve the change even if they are a code owner.
      */
     private ImmutableSet<Account.Id> getReviewers() {
       ImmutableSet<Account.Id> reviewerAccountIds =
           changeNotes.getReviewers().byState(ReviewerStateInternal.REVIEWER);
       RequiredApproval requiredApproval = codeOwnersConfig.getRequiredApproval();
       Account.Id patchSetUploader = changeNotes.getCurrentPatchSet().uploader();
       if (requiredApproval.labelType().isIgnoreSelfApproval()
           && reviewerAccountIds.contains(patchSetUploader)) {
         logger.atFine().log(
             "Removing patch set uploader %s from reviewers since the label of the required"
                 + " approval (%s) is configured to ignore self approvals",
             patchSetUploader, requiredApproval.labelType());
         return filterOutAccount(reviewerAccountIds, patchSetUploader);
       }
       logger.atFine().log("reviewers = %s", reviewerAccountIds);
       return reviewerAccountIds;
     }

     /**
      * Gets the IDs of the accounts that have an approval on the current patch set that possibly
      * counts as code owner approval (if they are code owners).
      *
      * <p>If self approvals are ignored the patch set uploader is filtered out since in this case
      * the approval of the patch set uploader is ignored even if they are a code owner.
      */
     private ImmutableSet<Account.Id> getApprovers() {
       ImmutableList<PatchSetApproval> currentPatchSetApprovals =
           getCurrentPatchSetApprovals(changeNotes);
       RequiredApproval requiredApproval = codeOwnersConfig.getRequiredApproval();
       ImmutableSet<Account.Id> approverAccountIds =
           currentPatchSetApprovals.stream()
               .filter(requiredApproval::isApprovedBy)
               .map(PatchSetApproval::accountId)
               .collect(toImmutableSet());
       Account.Id patchSetUploader = changeNotes.getCurrentPatchSet().uploader();
       if (requiredApproval.labelType().isIgnoreSelfApproval()
           && approverAccountIds.contains(patchSetUploader)) {
         logger.atFine().log(
             "Removing patch set uploader %s from approvers since the label of the required"
                 + " approval (%s) is configured to ignore self approvals",
             patchSetUploader, requiredApproval.labelType());
         return filterOutAccount(approverAccountIds, patchSetUploader);
       }
       logger.atFine().log("approvers = %s", approverAccountIds);
       return approverAccountIds;
     }

     private Optional<Account.Id> getImplicitApprover() {
       Account.Id changeOwner = changeNotes.getChange().getOwner();
       Account.Id patchSetUploader = changeNotes.getCurrentPatchSet().uploader();
       boolean implicitApprovalConfig = codeOwnersConfig.areImplicitApprovalsEnabled();
       boolean enableImplicitApproval =
           implicitApprovalConfig && changeOwner.equals(patchSetUploader);
       logger.atFine().log(
           "changeOwner = %d, patchSetUploader = %d, implict approval config = %s\n"
               + "=> implicit approval is %s",
           changeOwner.get(),
           patchSetUploader.get(),
           implicitApprovalConfig,
           enableImplicitApproval ? "enabled" : "disabled");
       return enableImplicitApproval ? Optional.of(changeOwner) : Optional.empty();
     }

     /**
      * Gets a map of previous patch sets to the IDs of the accounts that have an approval on that
      * patch set that is sticky and possibly counts as code owner approval (if they are code
      * owners).
      *
      * <p>If self approvals are ignored the patch set uploader is filtered out for all patch sets
      * since in this case the approval of the patch set uploader is ignored even if they are a code
      * owner.
      */
     private ImmutableMultimap<PatchSet.Id, Account.Id> getApproversFromPreviousPatchSets() {
       if (!codeOwnersConfig.areStickyApprovalsEnabled()) {
         logger.atFine().log("sticky approvals are disabled");
         return ImmutableMultimap.of();
       }

       // Filter out approvals on the current patch set, since here we are only interested in code
       // owner approvals on previous patch sets that should be considered as sticky.
       PatchSet.Id currentPatchSetId = changeNotes.getCurrentPatchSet().id();
       ImmutableSetMultimap<PatchSet.Id, Account.Id> approversFromPreviousPatchSets =
           getLastCodeOwnerApprovalsByAccount().values().stream()
               .filter(psa -> psa.patchSetId().get() < currentPatchSetId.get())
               .collect(
                   toImmutableSetMultimap(
                       PatchSetApproval::patchSetId, PatchSetApproval::accountId));
       logger.atFine().log(
           "sticky approvals are enabled, approversFromPreviousPatchSets=%s",
           approversFromPreviousPatchSets);
       return approversFromPreviousPatchSets;
     }

     /**
      * Returns the last code owner approvals by account.
      *
      * <p>The returned map contains for each user their last approval on the change that counts as a
      * code owner approval. Approvals that are invalidated by code owner votes on newer patch sets
      * are filtered out.
      */
     private ImmutableMap<Account.Id, PatchSetApproval> getLastCodeOwnerApprovalsByAccount() {
       RequiredApproval requiredApproval = codeOwnersConfig.getRequiredApproval();

       Map<Account.Id, PatchSetApproval> lastCodeOwnerVotesByAccount = new HashMap<>();
       ImmutableSetMultimap<PatchSet.Id, PatchSetApproval> allCodeOwnerApprovals =
           changeNotes.getApprovals().all().entries().stream()
               // Only look at approvals on the label that is configured for code owner approvals.
               .filter(e -> e.getValue().label().equals(requiredApproval.labelType().getName()))
               .collect(toImmutableSetMultimap(Map.Entry::getKey, Map.Entry::getValue));
       logger.atFine().log("allCodeOwnerApprovals=%s", allCodeOwnerApprovals);
       // Iterate over the patch sets in reverse order (latest patch set first).
       for (PatchSet.Id patchSetId : getPatchSetIdsInReverseOrder()) {
         // Only store the code owner approval if we didn't find a code owner approval for that
         // account on a newer patch set yet.
         // If a code owner approval on a newer patch set exist, it invalidated the code owner
         // approval on the older patch set and we can ignore it.
         allCodeOwnerApprovals
             .get(patchSetId)
             .forEach(psa -> lastCodeOwnerVotesByAccount.putIfAbsent(psa.accountId(), psa));
       }

       ImmutableMap<Account.Id, PatchSetApproval> lastCodeOwnerApprovalsByAccount =
           lastCodeOwnerVotesByAccount.entrySet().stream()
               // Remove all approvals which do not count as a code owner approval because the voting
               // value is insufficient.
               .filter(e -> requiredApproval.isApprovedBy(e.getValue()))
               .filter(filterOutSelfApprovalsIfSelfApprovalsAreIgnored())
               .collect(toImmutableMap(Map.Entry::getKey, Map.Entry::getValue));
       logger.atFine().log(
           "lastCodeOwnerApprovalsByAccount=%s, lastCodeOwnerVotesByAccount=%s",
           lastCodeOwnerApprovalsByAccount, lastCodeOwnerVotesByAccount);
       return lastCodeOwnerApprovalsByAccount;
     }

     /**
      * Creates a filter that filters out self approvals by the patch set uploader if self approvals
      * are ignored
      */
     private Predicate<Map.Entry<Account.Id, PatchSetApproval>>
         filterOutSelfApprovalsIfSelfApprovalsAreIgnored() {
       RequiredApproval requiredApproval = codeOwnersConfig.getRequiredApproval();
       if (!requiredApproval.labelType().isIgnoreSelfApproval()) {
         logger.atFine().log("s");
         return e -> true;
       }

       Account.Id patchSetUploader = changeNotes.getCurrentPatchSet().uploader();
       return e -> {
         if (e.getKey().equals(patchSetUploader)) {
           logger.atFine().log(
               "Removing approvals of the patch set uploader %s since the label of the required"
                   + " approval (%s) is configured to ignore self approvals",
               patchSetUploader, requiredApproval.labelType());
           return false;
         }
         return true;
       };
     }

     private ImmutableSortedSet<PatchSet.Id> getPatchSetIdsInReverseOrder() {
       return ImmutableSortedSet.orderedBy(comparing(PatchSet.Id::get).reversed())
           .addAll(changeNotes.getPatchSets().keySet())
           .build();
     }

     /**
      * Gets the approvals from the current patch set that count as code owner overrides.
      *
      * <p>If self approvals are ignored an override of the patch set uploader is filtered out since
      * it doesn't count as code owner override.
      */
     private ImmutableSet<PatchSetApproval> getOverrides() {
       ImmutableList<PatchSetApproval> currentPatchSetApprovals =
           getCurrentPatchSetApprovals(changeNotes);
       ImmutableSortedSet<RequiredApproval> overrideApprovals =
           codeOwnersConfig.getOverrideApprovals();
       ImmutableSet<RequiredApproval> overrideApprovalsThatIgnoreSelfApprovals =
           overrideApprovals.stream()
               .filter(overrideApproval -> overrideApproval.labelType().isIgnoreSelfApproval())
               .collect(toImmutableSet());
       Account.Id patchSetUploader = changeNotes.getCurrentPatchSet().uploader();
       ImmutableSet<PatchSetApproval> overrides =
           currentPatchSetApprovals.stream()
               .filter(
                   approval -> {
                     // If the approval is from the patch set uploader and if it matches any of the
                     // labels
                     // for which self approvals are ignored, filter it out.
                     if (approval.accountId().equals(patchSetUploader)
                         && overrideApprovalsThatIgnoreSelfApprovals.stream()
                             .anyMatch(
                                 requiredApproval ->
                                     requiredApproval
                                         .labelType()
                                         .getLabelId()
                                         .equals(approval.key().labelId()))) {
                       logger.atFine().log(
                           "Filtered out self-override %s of patch set uploader",
                           LabelVote.create(approval.label(), approval.value()));
                       return false;
                     }
                     return true;
                   })
               .filter(
                   patchSetApproval ->
                       overrideApprovals.stream()
                           .anyMatch(
                               overrideApproval -> overrideApproval.isApprovedBy(patchSetApproval)))
               .collect(toImmutableSet());
       logger.atFine().log("hasOverride = %s (overrides = %s)", !overrides.isEmpty(), overrides);
       return overrides;
     }

     private CodeOwnerResolverResult getGlobalCodeOwners() {
       CodeOwnerResolverResult globalCodeOwners =
           codeOwnerResolver.resolveGlobalCodeOwners(changeNotes.getProjectName());
       logger.atFine().log("global code owners = %s", globalCodeOwners);
       return globalCodeOwners;
     }

     private FallbackCodeOwners getFallbackCodeOwners() {
       FallbackCodeOwners fallbackCodeOwners = codeOwnersConfig.getFallbackCodeOwners();
       logger.atFine().log("fallbackCodeOwners = %s", fallbackCodeOwners);
       return fallbackCodeOwners;
     }

     private ImmutableList<PatchSetApproval> getCurrentPatchSetApprovals(ChangeNotes changeNotes) {
       try (Timer0.Context ctx = codeOwnerMetrics.computePatchSetApprovals.start()) {
         return ImmutableList.copyOf(
             approvalsUtil.byPatchSet(changeNotes, changeNotes.getCurrentPatchSet().id()));
       }
     }

     private static ImmutableSet<Account.Id> filterOutAccount(
         ImmutableSet<Account.Id> accountIds, Account.Id accountIdToFilterOut) {
       return accountIds.stream()
           .filter(accountId -> !accountId.equals(accountIdToFilterOut))
           .collect(toImmutableSet());
     }
   }
 }
	// Copyright (C) 2022 The Android Open Source Project
	//
	// 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.gerrit.plugins.codeowners.backend;

	import static com.google.common.collect.ImmutableMap.toImmutableMap;
	import static com.google.common.collect.ImmutableSet.toImmutableSet;
	import static com.google.common.collect.ImmutableSetMultimap.toImmutableSetMultimap;
	import static java.util.Comparator.comparing;

	import com.google.auto.value.AutoValue;
	import com.google.auto.value.extension.memoized.Memoized;
	import com.google.common.base.Predicate;
	import com.google.common.collect.ImmutableList;
	import com.google.common.collect.ImmutableMap;
	import com.google.common.collect.ImmutableMultimap;
	import com.google.common.collect.ImmutableSet;
	import com.google.common.collect.ImmutableSetMultimap;
	import com.google.common.collect.ImmutableSortedSet;
	import com.google.common.flogger.FluentLogger;
	import com.google.gerrit.entities.Account;
	import com.google.gerrit.entities.PatchSet;
	import com.google.gerrit.entities.PatchSetApproval;
	import com.google.gerrit.metrics.Timer0;
	import com.google.gerrit.plugins.codeowners.backend.config.CodeOwnersPluginProjectConfigSnapshot;
	import com.google.gerrit.plugins.codeowners.backend.config.RequiredApproval;
	import com.google.gerrit.plugins.codeowners.metrics.CodeOwnerMetrics;
	import com.google.gerrit.server.approval.ApprovalsUtil;
	import com.google.gerrit.server.notedb.ChangeNotes;
	import com.google.gerrit.server.notedb.ReviewerStateInternal;
	import com.google.gerrit.server.util.LabelVote;
	import com.google.inject.Inject;
	import com.google.inject.assistedinject.Assisted;
	import java.util.HashMap;
	import java.util.Map;
	import java.util.Optional;

	/**
	* Input for {@link CodeOwnerApprovalCheck}.
	*
	* <p>Provides all data that is needed to check the code owner approvals on a change.
	*/
	@AutoValue
	public abstract class CodeOwnerApprovalCheckInput {
	private static final FluentLogger logger = FluentLogger.forEnclosingClass();

	/**
	* Gets the IDs of the accounts of all reviewers that can possibly code owner approve the change
	* (if they are code owners).
	*
	* <p>If self approvals are ignored the patch set uploader is filtered out since in this case the
	* patch set uploader cannot approve the change even if they are a code owner.
	*/
	public abstract ImmutableSet<Account.Id> reviewers();

	/**
	* Gets the IDs of the accounts that have an approval on the current patch set that possibly
	* counts as code owner approval (if they are code owners).
	*
	* <p>If self approvals are ignored the patch set uploader is filtered out since in this case the
	* approval of the patch set uploader is ignored even if they are a code owner.
	*/
	public abstract ImmutableSet<Account.Id> approvers();

	/**
	* Gets a map of previous patch sets to the IDs of the accounts that have an approval on that
	* patch set that is sticky and possibly counts as code owner approval (if they are code owners).
	*
	* <p>If self approvals are ignored the patch set uploader is filtered out for all patch sets
	* since in this case the approval of the patch set uploader is ignored even if they are a code
	* owner.
	*/
	public abstract ImmutableMultimap<PatchSet.Id, Account.Id> approversFromPreviousPatchSets();

	@Memoized
	public ImmutableSortedSet<PatchSet.Id> previouslyApprovedPatchSetsInReverseOrder() {
	return ImmutableSortedSet.orderedBy(comparing(PatchSet.Id::get).reversed())
	.addAll(approversFromPreviousPatchSets().keySet())
	.build();
	}

	/**
	* Account from which an implicit code owner approval should be assumed.
	*
	* @see CodeOwnersPluginProjectConfigSnapshot#areImplicitApprovalsEnabled()
	* @return the account of the change owner if implicit approvals are enabled, otherwise {@link
	* Optional#empty()}
	*/
	public abstract Optional<Account.Id> implicitApprover();

	/**
	* Gets the approvals from the current patch set that count as code owner overrides.
	*
	* <p>If self approvals are ignored an override of the patch set uploader is filtered out since it
	* doesn't count as code owner override.
	*/
	public abstract ImmutableSet<PatchSetApproval> overrides();

	/** Gets the configured global code owners. */
	public abstract CodeOwnerResolverResult globalCodeOwners();

	/** Gets the policy that defines who owns paths for which no code owners are defined. */
	public abstract FallbackCodeOwners fallbackCodeOwners();

	/**
	* Whether all code owners should be checked. *
	*
	* <p>If {@code true} {@link PathCodeOwnerStatus#owners()} are expected to be set in {@link
	* PathCodeOwnerStatus} instances that are created by {@link CodeOwnerApprovalCheck}.
	*/
	public abstract boolean checkAllOwners();

	/**
	* Creates a {@link CodeOwnerApprovalCheckInput} instance for computing the paths in a change that
	* are owned by the given accounts.
	*
	* @param codeOwnersConfig the code-owners plugin configuration
	* @param codeOwnerResolver the {@link CodeOwnerResolver} that should be used to resolve the
	* configured global code owners
	* @param changeNotes the notes of the change for which owned paths should be computed
	* @param accounts the accounts for which the owned paths should be computed
	* @return the created {@link CodeOwnerApprovalCheckInput} instance
	*/
	public static CodeOwnerApprovalCheckInput createForComputingOwnedPaths(
	CodeOwnersPluginProjectConfigSnapshot codeOwnersConfig,
	CodeOwnerResolver codeOwnerResolver,
	ChangeNotes changeNotes,
	ImmutableSet<Account.Id> accounts) {
	CodeOwnerResolverResult globalCodeOwners =
	codeOwnerResolver.resolveGlobalCodeOwners(changeNotes.getProjectName());
	logger.atFine().log("global code owners = %s", globalCodeOwners);

	FallbackCodeOwners fallbackCodeOwners = codeOwnersConfig.getFallbackCodeOwners();
	logger.atFine().log("fallbackCodeOwner = %s", fallbackCodeOwners);

	return create(
	/* reviewers= */ ImmutableSet.of(),
	/* approvers= */ accounts,
	/* approversFromPreviousPatchSets= */ ImmutableMultimap.of(),
	// Do not check for implicit approvals since implicit approvals of other users
	// should be ignored. For the given account we do not need to check for
	// implicit approvals since all owned files are already covered by the
	// explicit approval.
	/* implicitApprover= */ Optional.empty(),
	/* overrides= */ ImmutableSet.of(),
	globalCodeOwners,
	fallbackCodeOwners,
	/* checkAllOwners= */ true);
	}

	/**
	* Creates a {@link CodeOwnerApprovalCheckInput} instance.
	*
	* @param reviewers the reviewers that can possibly code owner approve the change (if they are
	* code owners)
	* @param approvers the accounts that have an approval on the current patch set that possibly
	* counts as code owner approval (if they are code owners)
	* @param implicitApprover account from which an implicit code owner approval should be assumed
	* @param overrides the approvals from the current patch set that count as code owner overrides
	* @param globalCodeOwners the configured global code owners
	* @param fallbackCodeOwners the policy that defines who owns paths for which no code owners are
	* defined
	* @param checkAllOwners Whether all code owners are checked. If {@code true} {@link
	* PathCodeOwnerStatus#owners()} will be set in the the {@link PathCodeOwnerStatus} instances
	* that are created by {@link CodeOwnerApprovalCheck}. Checking all owners means that no
	* shortcuts can be applied, hence checking the code owner approvals with {@code
	* checkAllOwners=true} is more expensive.
	* @return the created {@link CodeOwnerApprovalCheckInput} instance
	*/
	private static CodeOwnerApprovalCheckInput create(
	ImmutableSet<Account.Id> reviewers,
	ImmutableSet<Account.Id> approvers,
	ImmutableMultimap<PatchSet.Id, Account.Id> approversFromPreviousPatchSets,
	Optional<Account.Id> implicitApprover,
	ImmutableSet<PatchSetApproval> overrides,
	CodeOwnerResolverResult globalCodeOwners,
	FallbackCodeOwners fallbackCodeOwners,
	boolean checkAllOwners) {
	return new AutoValue_CodeOwnerApprovalCheckInput(
	reviewers,
	approvers,
	approversFromPreviousPatchSets,
	implicitApprover,
	overrides,
	globalCodeOwners,
	fallbackCodeOwners,
	checkAllOwners);
	}

	/**
	* Class to load all inputs that are required for checking the code owner approvals on a change.
	*/
	public static class Loader {
	/** Factory to create the {@link Loader} with injected dependencies. */
	interface Factory {
	Loader create(
	CodeOwnersPluginProjectConfigSnapshot codeOwnersConfig,
	CodeOwnerResolver codeOwnerResolver,
	ChangeNotes changeNotes);
	}

	private final ApprovalsUtil approvalsUtil;
	private final CodeOwnerMetrics codeOwnerMetrics;
	private final CodeOwnersPluginProjectConfigSnapshot codeOwnersConfig;
	private final CodeOwnerResolver codeOwnerResolver;
	private final ChangeNotes changeNotes;

	@Inject
	Loader(
	ApprovalsUtil approvalsUtil,
	CodeOwnerMetrics codeOwnerMetrics,
	@Assisted CodeOwnersPluginProjectConfigSnapshot codeOwnersConfig,
	@Assisted CodeOwnerResolver codeOwnerResolver,
	@Assisted ChangeNotes changeNotes) {
	this.approvalsUtil = approvalsUtil;
	this.codeOwnerMetrics = codeOwnerMetrics;
	this.codeOwnersConfig = codeOwnersConfig;
	this.codeOwnerResolver = codeOwnerResolver;
	this.changeNotes = changeNotes;
	}

	CodeOwnerApprovalCheckInput load() {
	logger.atFine().log(
	"requiredApproval = %s, overrideApprovals = %s",
	codeOwnersConfig.getRequiredApproval().formatForLogging(),
	RequiredApproval.formatForLogging(codeOwnersConfig.getOverrideApprovals()));
	return CodeOwnerApprovalCheckInput.create(
	getReviewers(),
	getApprovers(),
	getApproversFromPreviousPatchSets(),
	getImplicitApprover(),
	getOverrides(),
	getGlobalCodeOwners(),
	getFallbackCodeOwners(),
	/* checkAllOwners= */ false);
	}

	/**
	* Gets the IDs of the accounts of all reviewers that can possibly code owner approve the change
	* (if they are code owners).
	*
	* <p>If self approvals are ignored the patch set uploader is filtered out since in this case
	* the patch set uploader cannot approve the change even if they are a code owner.
	*/
	private ImmutableSet<Account.Id> getReviewers() {
	ImmutableSet<Account.Id> reviewerAccountIds =
	changeNotes.getReviewers().byState(ReviewerStateInternal.REVIEWER);
	RequiredApproval requiredApproval = codeOwnersConfig.getRequiredApproval();
	Account.Id patchSetUploader = changeNotes.getCurrentPatchSet().uploader();
	if (requiredApproval.labelType().isIgnoreSelfApproval()
	&& reviewerAccountIds.contains(patchSetUploader)) {
	logger.atFine().log(
	"Removing patch set uploader %s from reviewers since the label of the required"
	+ " approval (%s) is configured to ignore self approvals",
	patchSetUploader, requiredApproval.labelType());
	return filterOutAccount(reviewerAccountIds, patchSetUploader);
	}
	logger.atFine().log("reviewers = %s", reviewerAccountIds);
	return reviewerAccountIds;
	}

	/**
	* Gets the IDs of the accounts that have an approval on the current patch set that possibly
	* counts as code owner approval (if they are code owners).
	*
	* <p>If self approvals are ignored the patch set uploader is filtered out since in this case
	* the approval of the patch set uploader is ignored even if they are a code owner.
	*/
	private ImmutableSet<Account.Id> getApprovers() {
	ImmutableList<PatchSetApproval> currentPatchSetApprovals =
	getCurrentPatchSetApprovals(changeNotes);
	RequiredApproval requiredApproval = codeOwnersConfig.getRequiredApproval();
	ImmutableSet<Account.Id> approverAccountIds =
	currentPatchSetApprovals.stream()
	.filter(requiredApproval::isApprovedBy)
	.map(PatchSetApproval::accountId)
	.collect(toImmutableSet());
	Account.Id patchSetUploader = changeNotes.getCurrentPatchSet().uploader();
	if (requiredApproval.labelType().isIgnoreSelfApproval()
	&& approverAccountIds.contains(patchSetUploader)) {
	logger.atFine().log(
	"Removing patch set uploader %s from approvers since the label of the required"
	+ " approval (%s) is configured to ignore self approvals",
	patchSetUploader, requiredApproval.labelType());
	return filterOutAccount(approverAccountIds, patchSetUploader);
	}
	logger.atFine().log("approvers = %s", approverAccountIds);
	return approverAccountIds;
	}

	private Optional<Account.Id> getImplicitApprover() {
	Account.Id changeOwner = changeNotes.getChange().getOwner();
	Account.Id patchSetUploader = changeNotes.getCurrentPatchSet().uploader();
	boolean implicitApprovalConfig = codeOwnersConfig.areImplicitApprovalsEnabled();
	boolean enableImplicitApproval =
	implicitApprovalConfig && changeOwner.equals(patchSetUploader);
	logger.atFine().log(
	"changeOwner = %d, patchSetUploader = %d, implict approval config = %s\n"
	+ "=> implicit approval is %s",
	changeOwner.get(),
	patchSetUploader.get(),
	implicitApprovalConfig,
	enableImplicitApproval ? "enabled" : "disabled");
	return enableImplicitApproval ? Optional.of(changeOwner) : Optional.empty();
	}

	/**
	* Gets a map of previous patch sets to the IDs of the accounts that have an approval on that
	* patch set that is sticky and possibly counts as code owner approval (if they are code
	* owners).
	*
	* <p>If self approvals are ignored the patch set uploader is filtered out for all patch sets
	* since in this case the approval of the patch set uploader is ignored even if they are a code
	* owner.
	*/
	private ImmutableMultimap<PatchSet.Id, Account.Id> getApproversFromPreviousPatchSets() {
	if (!codeOwnersConfig.areStickyApprovalsEnabled()) {
	logger.atFine().log("sticky approvals are disabled");
	return ImmutableMultimap.of();
	}

	// Filter out approvals on the current patch set, since here we are only interested in code
	// owner approvals on previous patch sets that should be considered as sticky.
	PatchSet.Id currentPatchSetId = changeNotes.getCurrentPatchSet().id();
	ImmutableSetMultimap<PatchSet.Id, Account.Id> approversFromPreviousPatchSets =
	getLastCodeOwnerApprovalsByAccount().values().stream()
	.filter(psa -> psa.patchSetId().get() < currentPatchSetId.get())
	.collect(
	toImmutableSetMultimap(
	PatchSetApproval::patchSetId, PatchSetApproval::accountId));
	logger.atFine().log(
	"sticky approvals are enabled, approversFromPreviousPatchSets=%s",
	approversFromPreviousPatchSets);
	return approversFromPreviousPatchSets;
	}

	/**
	* Returns the last code owner approvals by account.
	*
	* <p>The returned map contains for each user their last approval on the change that counts as a
	* code owner approval. Approvals that are invalidated by code owner votes on newer patch sets
	* are filtered out.
	*/
	private ImmutableMap<Account.Id, PatchSetApproval> getLastCodeOwnerApprovalsByAccount() {
	RequiredApproval requiredApproval = codeOwnersConfig.getRequiredApproval();

	Map<Account.Id, PatchSetApproval> lastCodeOwnerVotesByAccount = new HashMap<>();
	ImmutableSetMultimap<PatchSet.Id, PatchSetApproval> allCodeOwnerApprovals =
	changeNotes.getApprovals().all().entries().stream()
	// Only look at approvals on the label that is configured for code owner approvals.
	.filter(e -> e.getValue().label().equals(requiredApproval.labelType().getName()))
	.collect(toImmutableSetMultimap(Map.Entry::getKey, Map.Entry::getValue));
	logger.atFine().log("allCodeOwnerApprovals=%s", allCodeOwnerApprovals);
	// Iterate over the patch sets in reverse order (latest patch set first).
	for (PatchSet.Id patchSetId : getPatchSetIdsInReverseOrder()) {
	// Only store the code owner approval if we didn't find a code owner approval for that
	// account on a newer patch set yet.
	// If a code owner approval on a newer patch set exist, it invalidated the code owner
	// approval on the older patch set and we can ignore it.
	allCodeOwnerApprovals
	.get(patchSetId)
	.forEach(psa -> lastCodeOwnerVotesByAccount.putIfAbsent(psa.accountId(), psa));
	}

	ImmutableMap<Account.Id, PatchSetApproval> lastCodeOwnerApprovalsByAccount =
	lastCodeOwnerVotesByAccount.entrySet().stream()
	// Remove all approvals which do not count as a code owner approval because the voting
	// value is insufficient.
	.filter(e -> requiredApproval.isApprovedBy(e.getValue()))
	.filter(filterOutSelfApprovalsIfSelfApprovalsAreIgnored())
	.collect(toImmutableMap(Map.Entry::getKey, Map.Entry::getValue));
	logger.atFine().log(
	"lastCodeOwnerApprovalsByAccount=%s, lastCodeOwnerVotesByAccount=%s",
	lastCodeOwnerApprovalsByAccount, lastCodeOwnerVotesByAccount);
	return lastCodeOwnerApprovalsByAccount;
	}

	/**
	* Creates a filter that filters out self approvals by the patch set uploader if self approvals
	* are ignored
	*/
	private Predicate<Map.Entry<Account.Id, PatchSetApproval>>
	filterOutSelfApprovalsIfSelfApprovalsAreIgnored() {
	RequiredApproval requiredApproval = codeOwnersConfig.getRequiredApproval();
	if (!requiredApproval.labelType().isIgnoreSelfApproval()) {
	logger.atFine().log("s");
	return e -> true;
	}

	Account.Id patchSetUploader = changeNotes.getCurrentPatchSet().uploader();
	return e -> {
	if (e.getKey().equals(patchSetUploader)) {
	logger.atFine().log(
	"Removing approvals of the patch set uploader %s since the label of the required"
	+ " approval (%s) is configured to ignore self approvals",
	patchSetUploader, requiredApproval.labelType());
	return false;
	}
	return true;
	};
	}

	private ImmutableSortedSet<PatchSet.Id> getPatchSetIdsInReverseOrder() {
	return ImmutableSortedSet.orderedBy(comparing(PatchSet.Id::get).reversed())
	.addAll(changeNotes.getPatchSets().keySet())
	.build();
	}

	/**
	* Gets the approvals from the current patch set that count as code owner overrides.
	*
	* <p>If self approvals are ignored an override of the patch set uploader is filtered out since
	* it doesn't count as code owner override.
	*/
	private ImmutableSet<PatchSetApproval> getOverrides() {
	ImmutableList<PatchSetApproval> currentPatchSetApprovals =
	getCurrentPatchSetApprovals(changeNotes);
	ImmutableSortedSet<RequiredApproval> overrideApprovals =
	codeOwnersConfig.getOverrideApprovals();
	ImmutableSet<RequiredApproval> overrideApprovalsThatIgnoreSelfApprovals =
	overrideApprovals.stream()
	.filter(overrideApproval -> overrideApproval.labelType().isIgnoreSelfApproval())
	.collect(toImmutableSet());
	Account.Id patchSetUploader = changeNotes.getCurrentPatchSet().uploader();
	ImmutableSet<PatchSetApproval> overrides =
	currentPatchSetApprovals.stream()
	.filter(
	approval -> {
	// If the approval is from the patch set uploader and if it matches any of the
	// labels
	// for which self approvals are ignored, filter it out.
	if (approval.accountId().equals(patchSetUploader)
	&& overrideApprovalsThatIgnoreSelfApprovals.stream()
	.anyMatch(
	requiredApproval ->
	requiredApproval
	.labelType()
	.getLabelId()
	.equals(approval.key().labelId()))) {
	logger.atFine().log(
	"Filtered out self-override %s of patch set uploader",
	LabelVote.create(approval.label(), approval.value()));
	return false;
	}
	return true;
	})
	.filter(
	patchSetApproval ->
	overrideApprovals.stream()
	.anyMatch(
	overrideApproval -> overrideApproval.isApprovedBy(patchSetApproval)))
	.collect(toImmutableSet());
	logger.atFine().log("hasOverride = %s (overrides = %s)", !overrides.isEmpty(), overrides);
	return overrides;
	}

	private CodeOwnerResolverResult getGlobalCodeOwners() {
	CodeOwnerResolverResult globalCodeOwners =
	codeOwnerResolver.resolveGlobalCodeOwners(changeNotes.getProjectName());
	logger.atFine().log("global code owners = %s", globalCodeOwners);
	return globalCodeOwners;
	}

	private FallbackCodeOwners getFallbackCodeOwners() {
	FallbackCodeOwners fallbackCodeOwners = codeOwnersConfig.getFallbackCodeOwners();
	logger.atFine().log("fallbackCodeOwners = %s", fallbackCodeOwners);
	return fallbackCodeOwners;
	}

	private ImmutableList<PatchSetApproval> getCurrentPatchSetApprovals(ChangeNotes changeNotes) {
	try (Timer0.Context ctx = codeOwnerMetrics.computePatchSetApprovals.start()) {
	return ImmutableList.copyOf(
	approvalsUtil.byPatchSet(changeNotes, changeNotes.getCurrentPatchSet().id()));
	}
	}

	private static ImmutableSet<Account.Id> filterOutAccount(
	ImmutableSet<Account.Id> accountIds, Account.Id accountIdToFilterOut) {
	return accountIds.stream()
	.filter(accountId -> !accountId.equals(accountIdToFilterOut))
	.collect(toImmutableSet());
	}
	}
	}