| // Copyright (C) 2016 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.googlesource.gerrit.plugins.task; |
| |
| import com.google.gerrit.entities.Change; |
| import com.google.gerrit.exceptions.StorageException; |
| import com.google.gerrit.extensions.api.access.PluginPermission; |
| import com.google.gerrit.extensions.common.PluginDefinedInfo; |
| import com.google.gerrit.index.query.QueryParseException; |
| import com.google.gerrit.server.DynamicOptions.BeanProvider; |
| import com.google.gerrit.server.change.ChangePluginDefinedInfoFactory; |
| import com.google.gerrit.server.permissions.PermissionBackend; |
| import com.google.gerrit.server.query.change.ChangeData; |
| import com.google.inject.Inject; |
| import com.googlesource.gerrit.plugins.task.TaskConfig.Task; |
| import com.googlesource.gerrit.plugins.task.TaskTree.Node; |
| import com.googlesource.gerrit.plugins.task.cli.PatchSetArgument; |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.EnumSet; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Optional; |
| import java.util.Set; |
| import org.eclipse.jgit.errors.ConfigInvalidException; |
| |
| public class TaskPluginDefinedInfoFactory implements ChangePluginDefinedInfoFactory { |
| public static final TaskPath MISSING_VIEW_PATH_CAPABILITY = |
| new TaskPath( |
| String.format( |
| "Can't perform operation, need %s capability", ViewPathsCapability.VIEW_PATHS)); |
| |
| public enum Status { |
| INVALID, |
| UNKNOWN, |
| DUPLICATE, |
| WAITING, |
| READY, |
| PASS, |
| FAIL; |
| } |
| |
| public static class Statistics { |
| public long numberOfChanges; |
| public long numberOfChangeNodes; |
| public long numberOfDuplicates; |
| public long numberOfNodes; |
| public long numberOfTaskPluginAttributes; |
| public Object predicateCache; |
| public Object matchCache; |
| public Preloader.Statistics preloader; |
| public TaskTree.Statistics treeCaches; |
| } |
| |
| public static class TaskAttribute { |
| public static class Statistics { |
| public boolean isApplicableRefreshRequired; |
| public boolean isSubNodeReloadRequired; |
| public boolean isTaskRefreshNeeded; |
| public Boolean hasUnfilterableSubNodes; |
| public Object nodesByBranchCache; |
| public Object properties; |
| } |
| |
| public Boolean applicable; |
| public Map<String, String> exported; |
| public Boolean hasPass; |
| public String hint; |
| public Boolean inProgress; |
| public TaskPath path; |
| public String name; |
| public Integer change; |
| public Status status; |
| public List<TaskAttribute> subTasks; |
| public Long evaluationMilliSeconds; |
| public Statistics statistics; |
| |
| public TaskAttribute(String name) { |
| this.name = name; |
| } |
| } |
| |
| public static class TaskPluginAttribute extends PluginDefinedInfo { |
| public List<TaskAttribute> roots = new ArrayList<>(); |
| public Statistics queryStatistics; |
| } |
| |
| protected final String pluginName; |
| protected final TaskTree definitions; |
| protected final PredicateCache predicateCache; |
| protected final boolean hasViewPathsCapability; |
| protected final TaskPath.Factory taskPathFactory; |
| protected final TaskConfigCache taskConfigCache; |
| |
| protected Modules.MyOptions options; |
| protected TaskPluginAttribute lastTaskPluginAttribute; |
| protected Statistics statistics; |
| |
| @Inject |
| public TaskPluginDefinedInfoFactory( |
| String pluginName, |
| TaskTree.Factory taskTreeFactory, |
| PredicateCache predicateCache, |
| PermissionBackend permissionBackend, |
| TaskPath.Factory taskPathFactory, |
| TaskConfigCache taskConfigCache) { |
| this.pluginName = pluginName; |
| this.definitions = taskTreeFactory.create(taskConfigCache); |
| this.predicateCache = predicateCache; |
| this.hasViewPathsCapability = |
| permissionBackend |
| .currentUser() |
| .testOrFalse(new PluginPermission(this.pluginName, ViewPathsCapability.VIEW_PATHS)); |
| this.taskPathFactory = taskPathFactory; |
| this.taskConfigCache = taskConfigCache; |
| } |
| |
| @Override |
| public Map<Change.Id, PluginDefinedInfo> createPluginDefinedInfos( |
| Collection<ChangeData> cds, BeanProvider beanProvider, String plugin) { |
| Map<Change.Id, PluginDefinedInfo> pluginInfosByChange = new HashMap<>(); |
| options = (Modules.MyOptions) beanProvider.getDynamicBean(plugin); |
| if (options.all || options.onlyApplicable || options.onlyInvalid) { |
| initStatistics(); |
| for (PatchSetArgument psa : options.patchSetArguments) { |
| taskConfigCache.masquerade(psa); |
| } |
| cds.forEach(cd -> pluginInfosByChange.put(cd.getId(), createWithExceptions(cd))); |
| if (lastTaskPluginAttribute != null) { |
| lastTaskPluginAttribute.queryStatistics = getStatistics(pluginInfosByChange); |
| } |
| } |
| return pluginInfosByChange; |
| } |
| |
| protected PluginDefinedInfo createWithExceptions(ChangeData c) { |
| TaskPluginAttribute a = new TaskPluginAttribute(); |
| try { |
| for (Node root : definitions.getRootNodes(c)) { |
| if (root instanceof Node.Invalid) { |
| a.roots.add(invalid()); |
| } else { |
| if (options.shouldFilterRoot(root.task.name())) { |
| continue; |
| } |
| new AttributeFactory(root).create().ifPresent(t -> a.roots.add(t)); |
| } |
| } |
| } catch (ConfigInvalidException | IOException | StorageException e) { |
| a.roots.add(invalid()); |
| } |
| |
| if (a.roots.isEmpty()) { |
| return null; |
| } |
| lastTaskPluginAttribute = a; |
| return a; |
| } |
| |
| protected class AttributeFactory { |
| public Node node; |
| protected Task task; |
| protected TaskAttribute attribute; |
| |
| protected AttributeFactory(Node node) { |
| this.node = node; |
| this.task = node.task; |
| attribute = new TaskAttribute(task.name()); |
| if (options.includeStatistics) { |
| statistics.numberOfNodes++; |
| if (node.isChange()) { |
| statistics.numberOfChangeNodes++; |
| } |
| if (node.isDuplicate) { |
| statistics.numberOfDuplicates++; |
| } |
| attribute.statistics = new TaskAttribute.Statistics(); |
| attribute.statistics.properties = node.propertiesStatistics; |
| } |
| } |
| |
| public Optional<TaskAttribute> create() { |
| try { |
| if (options.evaluationTime) { |
| attribute.evaluationMilliSeconds = millis(); |
| } |
| |
| boolean applicable; |
| try { |
| applicable = node.match(task.applicable); |
| } catch (QueryParseException e) { |
| return Optional.of(invalid()); |
| } |
| if (!task.isVisible) { |
| if (!node.isTrusted() || (!applicable && !options.onlyApplicable)) { |
| return Optional.of(unknown()); |
| } |
| } |
| |
| if (applicable || !options.onlyApplicable) { |
| if (node.isChange()) { |
| attribute.change = node.getChangeData().getId().get(); |
| } |
| attribute.hasPass = !node.isDuplicate && (task.pass != null || task.fail != null); |
| if (!node.isDuplicate) { |
| attribute.subTasks = getSubTasks(); |
| } |
| attribute.status = getStatus(); |
| if (options.onlyInvalid && !isValidQueries()) { |
| attribute.status = Status.INVALID; |
| } |
| if (options.includePaths) { |
| if (hasViewPathsCapability) { |
| attribute.path = taskPathFactory.create(node.taskKey); |
| } else { |
| attribute.path = MISSING_VIEW_PATH_CAPABILITY; |
| } |
| } |
| boolean groupApplicable = attribute.status != null; |
| |
| if (groupApplicable || !options.onlyApplicable) { |
| if (!options.onlyInvalid |
| || attribute.status == Status.INVALID |
| || attribute.subTasks != null) { |
| if (!options.onlyApplicable) { |
| attribute.applicable = applicable; |
| } |
| if (!node.isDuplicate) { |
| if (task.inProgress != null) { |
| attribute.inProgress = node.matchOrNull(task.inProgress); |
| } |
| attribute.exported = task.exported.isEmpty() ? null : task.exported; |
| } |
| attribute.hint = getHint(attribute.status, task); |
| |
| if (options.evaluationTime) { |
| attribute.evaluationMilliSeconds = millis() - attribute.evaluationMilliSeconds; |
| } |
| addStatistics(attribute.statistics); |
| return Optional.of(attribute); |
| } |
| } |
| } |
| } catch (IOException | RuntimeException | ConfigInvalidException e) { |
| return Optional.of(invalid()); // bad applicability query |
| } |
| return Optional.empty(); |
| } |
| |
| protected TaskAttribute invalid() { |
| TaskAttribute invalid = TaskPluginDefinedInfoFactory.invalid(); |
| if (task.isVisible) { |
| invalid.name = task.name(); |
| } |
| return invalid; |
| } |
| |
| public void addStatistics(TaskAttribute.Statistics statistics) { |
| if (statistics != null) { |
| statistics.isApplicableRefreshRequired = node.properties.isApplicableRefreshRequired(); |
| statistics.isSubNodeReloadRequired = node.properties.isSubNodeReloadRequired(); |
| statistics.isTaskRefreshNeeded = node.properties.isTaskRefreshRequired(); |
| if (!statistics.isSubNodeReloadRequired) { |
| statistics.hasUnfilterableSubNodes = node.hasUnfilterableSubNodes; |
| } |
| if (node.nodesByBranch != null) { |
| statistics.nodesByBranchCache = node.nodesByBranch.getStatistics(); |
| } |
| } |
| } |
| |
| protected Status getStatusWithExceptions() throws StorageException, QueryParseException { |
| if (node.isDuplicate) { |
| return Status.DUPLICATE; |
| } |
| if (isAllNull(task.pass, task.fail, attribute.subTasks)) { |
| // A leaf def has no defined subdefs. |
| boolean hasDefinedSubtasks = |
| !(task.subTasks.isEmpty() |
| && task.subTasksFiles.isEmpty() |
| && task.subTasksExternals.isEmpty() |
| && task.subTasksFactories.isEmpty()); |
| if (hasDefinedSubtasks) { |
| // Remove 'Grouping" tasks (tasks with subtasks but no PASS |
| // or FAIL criteria) from the output if none of their subtasks |
| // are applicable. i.e. grouping tasks only really apply if at |
| // least one of their subtasks apply. |
| return null; |
| } |
| // A leaf configuration without a PASS or FAIL criteria is a |
| // missconfiguration. Either someone forgot to add subtasks, or |
| // they forgot to add a PASS or FAIL criteria. |
| return Status.INVALID; |
| } |
| |
| if (task.fail != null) { |
| if (node.match(task.fail)) { |
| // A FAIL definition is meant to be a hard blocking criteria |
| // (like a CodeReview -2). Thus, if hard blocked, it is |
| // irrelevant what the subtask states, or the PASS criteria are. |
| // |
| // It is also important that FAIL be useable to indicate that |
| // the task has actually executed. Thus subtask status, |
| // including a subtask FAIL should not appear as a FAIL on the |
| // parent task. This means that this is should be the only path |
| // to make a task have a FAIL status. |
| return Status.FAIL; |
| } |
| } |
| |
| if (attribute.subTasks != null |
| && !isAll(attribute.subTasks, EnumSet.of(Status.PASS, Status.DUPLICATE))) { |
| // It is possible for a subtask's PASS criteria to change while |
| // a parent task is executing, or even after the parent task |
| // completes. This can result in the parent PASS criteria being |
| // met while one or more of its subtasks no longer meets its PASS |
| // criteria (the subtask may now even meet a FAIL criteria). We |
| // never want the parent task to reflect a PASS criteria in these |
| // cases, thus we can safely return here without ever evaluating |
| // the task's PASS criteria. |
| return Status.WAITING; |
| } |
| |
| if (task.pass != null && !node.match(task.pass)) { |
| // Non-leaf tasks with no PASS criteria are supported in order |
| // to support "grouping tasks" (tasks with no function aside from |
| // organizing tasks). A task without a PASS criteria, cannot ever |
| // be expected to execute (how would you know if it has?), thus a |
| // pass criteria is required to possibly even be considered for |
| // READY. |
| return Status.READY; |
| } |
| |
| return Status.PASS; |
| } |
| |
| protected Status getStatus() { |
| try { |
| return getStatusWithExceptions(); |
| } catch (QueryParseException | RuntimeException e) { |
| return Status.INVALID; |
| } |
| } |
| |
| protected List<TaskAttribute> getSubTasks() |
| throws IOException, StorageException, ConfigInvalidException { |
| List<TaskAttribute> subTasks = new ArrayList<>(); |
| for (Node subNode : |
| options.onlyApplicable ? node.getApplicableSubNodes() : node.getSubNodes()) { |
| if (subNode instanceof Node.Invalid) { |
| subTasks.add(TaskPluginDefinedInfoFactory.invalid()); |
| } else { |
| new AttributeFactory(subNode).create().ifPresent(t -> subTasks.add(t)); |
| } |
| } |
| if (subTasks.isEmpty()) { |
| return null; |
| } |
| return subTasks; |
| } |
| |
| protected boolean isValidQueries() { |
| try { |
| node.match(task.inProgress); |
| node.match(task.fail); |
| node.match(task.pass); |
| return true; |
| } catch (QueryParseException | RuntimeException e) { |
| return false; |
| } |
| } |
| } |
| |
| protected long millis() { |
| return System.nanoTime() / 1000000; |
| } |
| |
| public void initStatistics() { |
| if (options.includeStatistics) { |
| statistics = new Statistics(); |
| definitions.predicateCache.initStatistics(options.summaryCount); |
| definitions.matchCache.initStatistics(options.summaryCount); |
| definitions.preloader.initStatistics(options.summaryCount); |
| definitions.initStatistics(options.summaryCount); |
| } |
| } |
| |
| public Statistics getStatistics(Map<Change.Id, PluginDefinedInfo> pluginInfosByChange) { |
| if (statistics != null) { |
| statistics.numberOfChanges = pluginInfosByChange.size(); |
| statistics.numberOfTaskPluginAttributes = |
| pluginInfosByChange.values().stream().filter(tpa -> tpa != null).count(); |
| statistics.predicateCache = definitions.predicateCache.getStatistics(); |
| statistics.matchCache = definitions.matchCache.getStatistics(); |
| statistics.preloader = definitions.preloader.getStatistics(); |
| statistics.treeCaches = definitions.getStatistics(); |
| } |
| return statistics; |
| } |
| |
| protected static TaskAttribute invalid() { |
| // For security reasons, do not expose the task name without knowing |
| // the visibility which is derived from its applicability. |
| TaskAttribute a = unknown(); |
| a.status = Status.INVALID; |
| return a; |
| } |
| |
| protected static TaskAttribute unknown() { |
| TaskAttribute a = new TaskAttribute("UNKNOWN"); |
| a.status = Status.UNKNOWN; |
| return a; |
| } |
| |
| protected static String getHint(Status status, Task def) { |
| if (status != null) { |
| switch (status) { |
| case READY: |
| return def.readyHint; |
| case FAIL: |
| return def.failHint; |
| case DUPLICATE: |
| return "Duplicate task is non blocking and empty to break the loop"; |
| default: |
| } |
| } |
| return null; |
| } |
| |
| public static boolean isAllNull(Object... vals) { |
| for (Object val : vals) { |
| if (val != null) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| protected static boolean isAll(Iterable<TaskAttribute> atts, Set<Status> states) { |
| for (TaskAttribute att : atts) { |
| if (!states.contains(att.status)) { |
| return false; |
| } |
| } |
| return true; |
| } |
| } |
