Merge branch 'stable-3.1' * stable-3.1: Format files with google-java-format Change-Id: I5617d4ebf7b283a334a77c79fdb7379dd1e87896

diff --git a/src/main/java/com/googlesource/gerrit/plugins/its/base/ItsHookModule.java b/src/main/java/com/googlesource/gerrit/plugins/its/base/ItsHookModule.java
index dc6f4a5..8835389 100644
--- a/src/main/java/com/googlesource/gerrit/plugins/its/base/ItsHookModule.java
+++ b/src/main/java/com/googlesource/gerrit/plugins/its/base/ItsHookModule.java

@@ -38,9 +38,11 @@
 import com.googlesource.gerrit.plugins.its.base.workflow.Condition;
 import com.googlesource.gerrit.plugins.its.base.workflow.CreateVersionFromProperty;
 import com.googlesource.gerrit.plugins.its.base.workflow.CustomAction;
+import com.googlesource.gerrit.plugins.its.base.workflow.FireEventOnCommits;
 import com.googlesource.gerrit.plugins.its.base.workflow.ItsRulesProjectCacheImpl;
 import com.googlesource.gerrit.plugins.its.base.workflow.LogEvent;
 import com.googlesource.gerrit.plugins.its.base.workflow.Rule;
+import com.googlesource.gerrit.plugins.its.base.workflow.commit_collector.SinceLastTagCommitCollector;
 import java.nio.file.Path;
 
 public class ItsHookModule extends FactoryModule {
@@ -78,6 +80,8 @@
     factory(AddPropertyToField.Factory.class);
     DynamicMap.mapOf(binder(), CustomAction.class);
     install(ItsRulesProjectCacheImpl.module());
+    factory(FireEventOnCommits.Factory.class);
+    factory(SinceLastTagCommitCollector.Factory.class);
   }
 
   @Provides

diff --git a/src/main/java/com/googlesource/gerrit/plugins/its/base/its/ItsConfig.java b/src/main/java/com/googlesource/gerrit/plugins/its/base/its/ItsConfig.java
index 08f73c5..20c6c4a 100644
--- a/src/main/java/com/googlesource/gerrit/plugins/its/base/its/ItsConfig.java
+++ b/src/main/java/com/googlesource/gerrit/plugins/its/base/its/ItsConfig.java

@@ -94,16 +94,17 @@
   }
 
   public boolean isEnabled(Project.NameKey projectNK, String refName) {
-    ProjectState projectState = projectCache.get(projectNK);
-    if (projectState == null) {
+    Optional<ProjectState> projectState = projectCache.get(projectNK);
+    if (!projectState.isPresent()) {
       log.error(
           "Failed to check if {} is enabled for project {}: Project not found",
           pluginName,
           projectNK.get());
       return false;
     }
-    return isEnforcedByAnyParentProject(refName, projectState)
-        || (isEnabledForProject(projectState) && isEnabledForBranch(projectState, refName));
+    return isEnforcedByAnyParentProject(refName, projectState.get())
+        || (isEnabledForProject(projectState.get())
+            && isEnabledForBranch(projectState.get(), refName));
   }
 
   private boolean isEnforcedByAnyParentProject(String refName, ProjectState projectState) {
@@ -147,12 +148,14 @@
 
   // Project association
   public Optional<String> getItsProjectName(Project.NameKey projectNK) {
-    ProjectState projectState = projectCache.get(projectNK);
-    if (projectState == null) {
+    Optional<ProjectState> projectState = projectCache.get(projectNK);
+    if (!projectState.isPresent()) {
       return Optional.empty();
     }
     return Optional.ofNullable(
-        pluginCfgFactory.getFromProjectConfig(projectState, pluginName).getString("its-project"));
+        pluginCfgFactory
+            .getFromProjectConfig(projectState.get(), pluginName)
+            .getString("its-project"));
   }
 
   // Issue association --------------------------------------------------------
@@ -266,7 +269,7 @@
   private List<CommentLinkInfo> getCommentLinkInfo(final String commentlinkName) {
     NameKey projectName = currentProjectName.get();
     if (projectName != null) {
-      List<CommentLinkInfo> commentlinks = projectCache.get(projectName).getCommentLinks();
+      List<CommentLinkInfo> commentlinks = projectCache.get(projectName).get().getCommentLinks();
       return commentlinks.stream()
           .filter(input -> input.name.equals(commentlinkName))
           .collect(toList());

diff --git a/src/main/java/com/googlesource/gerrit/plugins/its/base/util/PropertyExtractor.java b/src/main/java/com/googlesource/gerrit/plugins/its/base/util/PropertyExtractor.java
index 926db56..bf9dc0c 100644
--- a/src/main/java/com/googlesource/gerrit/plugins/its/base/util/PropertyExtractor.java
+++ b/src/main/java/com/googlesource/gerrit/plugins/its/base/util/PropertyExtractor.java

@@ -34,6 +34,7 @@
 import com.google.gerrit.server.events.WorkInProgressStateChangedEvent;
 import com.google.inject.Inject;
 import com.googlesource.gerrit.plugins.its.base.workflow.RefEventProperties;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
@@ -230,16 +231,33 @@
       associations = extractFrom((WorkInProgressStateChangedEvent) event, common);
     }
 
-    Set<Map<String, String>> ret = new HashSet<>();
-    if (associations != null) {
-      for (Entry<String, Set<String>> assoc : associations.entrySet()) {
-        Map<String, String> properties = new HashMap<>();
-        properties.put("issue", assoc.getKey());
-        properties.put("association", String.join(" ", assoc.getValue()));
-        properties.putAll(common);
-        ret.add(properties);
-      }
+    Set<Map<String, String>> issuesProperties = extractIssuesProperties(common, associations);
+
+    Map<String, String> projectProperties = new HashMap<>(common);
+    projectProperties.put("source", "gerrit");
+    return new RefEventProperties(projectProperties, issuesProperties);
+  }
+
+  public Set<Map<String, String>> extractIssuesProperties(
+      Map<String, String> commonProperties, Map<String, Set<String>> associations) {
+    if (associations == null) {
+      return Collections.emptySet();
     }
-    return new RefEventProperties(common, ret);
+
+    Set<Map<String, String>> issuesProperties = new HashSet<>();
+    Map<String, String> completedCommonProperties = new HashMap<>(commonProperties);
+    if (!completedCommonProperties.containsKey("source")) {
+      completedCommonProperties.put("source", "its");
+    }
+
+    for (Entry<String, Set<String>> assoc : associations.entrySet()) {
+      Map<String, String> properties = new HashMap<>();
+      properties.put("issue", assoc.getKey());
+      properties.put("association", String.join(" ", assoc.getValue()));
+      properties.putAll(completedCommonProperties);
+      issuesProperties.add(properties);
+    }
+
+    return issuesProperties;
   }
 }

diff --git a/src/main/java/com/googlesource/gerrit/plugins/its/base/workflow/ActionExecutor.java b/src/main/java/com/googlesource/gerrit/plugins/its/base/workflow/ActionExecutor.java
index b8682ad..44f5d73 100644
--- a/src/main/java/com/googlesource/gerrit/plugins/its/base/workflow/ActionExecutor.java
+++ b/src/main/java/com/googlesource/gerrit/plugins/its/base/workflow/ActionExecutor.java

@@ -36,6 +36,7 @@
   private final LogEvent.Factory logEventFactory;
   private final AddPropertyToField.Factory addPropertyToFieldFactory;
   private final CreateVersionFromProperty.Factory createVersionFromPropertyFactory;
+  private final FireEventOnCommits.Factory fireEventOnCommitsFactory;
   private final DynamicMap<CustomAction> customActions;
 
   @Inject
@@ -47,6 +48,7 @@
       LogEvent.Factory logEventFactory,
       AddPropertyToField.Factory addPropertyToFieldFactory,
       CreateVersionFromProperty.Factory createVersionFromPropertyFactory,
+      FireEventOnCommits.Factory fireEventOnCommitsFactory,
       DynamicMap<CustomAction> customActions) {
     this.itsFactory = itsFactory;
     this.addCommentFactory = addCommentFactory;
@@ -55,6 +57,7 @@
     this.logEventFactory = logEventFactory;
     this.addPropertyToFieldFactory = addPropertyToFieldFactory;
     this.createVersionFromPropertyFactory = createVersionFromPropertyFactory;
+    this.fireEventOnCommitsFactory = fireEventOnCommitsFactory;
     this.customActions = customActions;
   }
 
@@ -72,6 +75,8 @@
         return addPropertyToFieldFactory.create();
       case "create-version-from-property":
         return createVersionFromPropertyFactory.create();
+      case "fire-event-on-commits":
+        return fireEventOnCommitsFactory.create();
       default:
         return customActions.get(PluginName.GERRIT, actionName);
     }

diff --git a/src/main/java/com/googlesource/gerrit/plugins/its/base/workflow/FireEventOnCommits.java b/src/main/java/com/googlesource/gerrit/plugins/its/base/workflow/FireEventOnCommits.java
new file mode 100644
index 0000000..7ade76b
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/its/base/workflow/FireEventOnCommits.java

@@ -0,0 +1,89 @@
+// Copyright (C) 2018 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.its.base.workflow;
+
+import com.google.inject.Inject;
+import com.googlesource.gerrit.plugins.its.base.its.ItsFacade;
+import com.googlesource.gerrit.plugins.its.base.util.IssueExtractor;
+import com.googlesource.gerrit.plugins.its.base.util.PropertyExtractor;
+import com.googlesource.gerrit.plugins.its.base.workflow.commit_collector.CommitCollector;
+import java.io.IOException;
+import java.util.Collection;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/** Fires the triggering event on collected past commits */
+public class FireEventOnCommits extends ProjectAction {
+
+  public interface Factory {
+    FireEventOnCommits create();
+  }
+
+  private final PropertyExtractor propertyExtractor;
+  private final IssueExtractor issueExtractor;
+  private final RuleBase ruleBase;
+  private final ActionExecutor actionExecutor;
+  private final FireEventOnCommitsParametersExtractor parametersExtractor;
+
+  @Inject
+  public FireEventOnCommits(
+      PropertyExtractor propertyExtractor,
+      IssueExtractor issueExtractor,
+      RuleBase ruleBase,
+      ActionExecutor actionExecutor,
+      FireEventOnCommitsParametersExtractor parametersExtractor) {
+    this.propertyExtractor = propertyExtractor;
+    this.issueExtractor = issueExtractor;
+    this.ruleBase = ruleBase;
+    this.actionExecutor = actionExecutor;
+    this.parametersExtractor = parametersExtractor;
+  }
+
+  @Override
+  public void execute(
+      ItsFacade its, String itsProject, ActionRequest actionRequest, Map<String, String> properties)
+      throws IOException {
+    Optional<FireEventOnCommitsParameters> extractedParameters =
+        parametersExtractor.extract(actionRequest, properties);
+    if (!extractedParameters.isPresent()) {
+      return;
+    }
+
+    CommitCollector commitCollector = extractedParameters.get().getCommitCollector();
+    String projectName = extractedParameters.get().getProjectName();
+
+    Set<Map<String, String>> issuesProperties =
+        commitCollector.collect(properties).stream()
+            .map(commitId -> issueExtractor.getIssueIds(projectName, commitId))
+            .flatMap(Stream::of)
+            .map(
+                associations -> propertyExtractor.extractIssuesProperties(properties, associations))
+            .flatMap(Collection::stream)
+            .collect(Collectors.toSet());
+
+    issuesProperties.forEach(this::doExecute);
+  }
+
+  private void doExecute(Map<String, String> issueProperties) {
+    Collection<ActionRequest> actions = ruleBase.actionRequestsFor(issueProperties);
+    if (actions.isEmpty()) {
+      return;
+    }
+    actionExecutor.executeOnIssue(actions, issueProperties);
+  }
+}

diff --git a/src/main/java/com/googlesource/gerrit/plugins/its/base/workflow/FireEventOnCommitsParameters.java b/src/main/java/com/googlesource/gerrit/plugins/its/base/workflow/FireEventOnCommitsParameters.java
new file mode 100644
index 0000000..d6ee4db
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/its/base/workflow/FireEventOnCommitsParameters.java

@@ -0,0 +1,41 @@
+// Copyright (C) 2018 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.its.base.workflow;
+
+import com.googlesource.gerrit.plugins.its.base.workflow.commit_collector.CommitCollector;
+
+/** Parameters needed by {@link FireEventOnCommits} action */
+public class FireEventOnCommitsParameters {
+
+  private final CommitCollector commitCollector;
+  private final String projectName;
+
+  public FireEventOnCommitsParameters(CommitCollector commitCollector, String projectName) {
+    this.commitCollector = commitCollector;
+    this.projectName = projectName;
+  }
+
+  /**
+   * @return The collector that will be used to collect the commits on which the event will be fired
+   */
+  public CommitCollector getCommitCollector() {
+    return commitCollector;
+  }
+
+  /** @return The name of the project from which the commits will be collected */
+  public String getProjectName() {
+    return projectName;
+  }
+}

diff --git a/src/main/java/com/googlesource/gerrit/plugins/its/base/workflow/FireEventOnCommitsParametersExtractor.java b/src/main/java/com/googlesource/gerrit/plugins/its/base/workflow/FireEventOnCommitsParametersExtractor.java
new file mode 100644
index 0000000..d7ae586
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/its/base/workflow/FireEventOnCommitsParametersExtractor.java

@@ -0,0 +1,78 @@
+// Copyright (C) 2018 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.its.base.workflow;
+
+import com.google.common.base.Strings;
+import com.googlesource.gerrit.plugins.its.base.workflow.commit_collector.CommitCollector;
+import com.googlesource.gerrit.plugins.its.base.workflow.commit_collector.SinceLastTagCommitCollector;
+import java.util.Arrays;
+import java.util.Map;
+import java.util.Optional;
+import javax.inject.Inject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class FireEventOnCommitsParametersExtractor {
+
+  private static final Logger log =
+      LoggerFactory.getLogger(FireEventOnCommitsParametersExtractor.class);
+
+  private final SinceLastTagCommitCollector.Factory sinceLastTagCommitCollectorFactory;
+
+  @Inject
+  public FireEventOnCommitsParametersExtractor(
+      SinceLastTagCommitCollector.Factory sinceLastTagCommitCollectorFactory) {
+    this.sinceLastTagCommitCollectorFactory = sinceLastTagCommitCollectorFactory;
+  }
+
+  private CommitCollector getCommitCollector(String name) {
+    switch (name) {
+      case "since-last-tag":
+        return sinceLastTagCommitCollectorFactory.create();
+      default:
+        return null;
+    }
+  }
+
+  /**
+   * @return The parameters needed by {@link FireEventOnCommits}. Empty if the parameters could not
+   *     be extracted.
+   */
+  public Optional<FireEventOnCommitsParameters> extract(
+      ActionRequest actionRequest, Map<String, String> properties) {
+    String[] parameters = actionRequest.getParameters();
+    if (parameters.length != 1) {
+      log.error(
+          "Wrong number of received parameters. Received parameters are {}. Only one parameter is expected, the collector name.",
+          Arrays.toString(parameters));
+      return Optional.empty();
+    }
+
+    String collectorName = parameters[0];
+    if (Strings.isNullOrEmpty(collectorName)) {
+      log.error("Received collector name is blank");
+      return Optional.empty();
+    }
+
+    CommitCollector commitCollector = getCommitCollector(collectorName);
+    if (commitCollector == null) {
+      log.error("No commit collector found for name {}", collectorName);
+      return Optional.empty();
+    }
+
+    String projectName = properties.get("project");
+    return Optional.of(new FireEventOnCommitsParameters(commitCollector, projectName));
+  }
+}

diff --git a/src/main/java/com/googlesource/gerrit/plugins/its/base/workflow/ItsRulesProjectCacheImpl.java b/src/main/java/com/googlesource/gerrit/plugins/its/base/workflow/ItsRulesProjectCacheImpl.java
index 72fe43f..4dc46d3 100644
--- a/src/main/java/com/googlesource/gerrit/plugins/its/base/workflow/ItsRulesProjectCacheImpl.java
+++ b/src/main/java/com/googlesource/gerrit/plugins/its/base/workflow/ItsRulesProjectCacheImpl.java

@@ -98,7 +98,10 @@
 
     @Override
     public List<Rule> load(String projectName) throws IOException {
-      ProjectState project = projectCache.checkedGet(Project.nameKey(projectName));
+      ProjectState project =
+          projectCache
+              .get(Project.nameKey(projectName))
+              .orElseThrow(() -> new IOException("Can't load " + projectName));
       List<Rule> projectRules = readRulesFrom(project);
       if (projectRules.isEmpty()) {
         for (ProjectState parent : project.parents()) {

diff --git a/src/main/java/com/googlesource/gerrit/plugins/its/base/workflow/RefEventProperties.java b/src/main/java/com/googlesource/gerrit/plugins/its/base/workflow/RefEventProperties.java
index 30940bb..01b6395 100644
--- a/src/main/java/com/googlesource/gerrit/plugins/its/base/workflow/RefEventProperties.java
+++ b/src/main/java/com/googlesource/gerrit/plugins/its/base/workflow/RefEventProperties.java

@@ -14,7 +14,6 @@
 
 package com.googlesource.gerrit.plugins.its.base.workflow;
 
-import java.util.Collections;
 import java.util.Map;
 import java.util.Set;
 
@@ -31,8 +30,8 @@
    */
   public RefEventProperties(
       Map<String, String> projectProperties, Set<Map<String, String>> issuesProperties) {
-    this.projectProperties = Collections.unmodifiableMap(projectProperties);
-    this.issuesProperties = Collections.unmodifiableSet(issuesProperties);
+    this.projectProperties = projectProperties;
+    this.issuesProperties = issuesProperties;
   }
 
   /** @return Properties of the ref event */

diff --git a/src/main/java/com/googlesource/gerrit/plugins/its/base/workflow/commit_collector/CommitCollector.java b/src/main/java/com/googlesource/gerrit/plugins/its/base/workflow/commit_collector/CommitCollector.java
new file mode 100644
index 0000000..73ea110
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/its/base/workflow/commit_collector/CommitCollector.java

@@ -0,0 +1,24 @@
+// Copyright (C) 2018 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.its.base.workflow.commit_collector;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+
+/** Collects commits based on the event properties provided in input */
+public interface CommitCollector {
+  List<String> collect(Map<String, String> properties) throws IOException;
+}

diff --git a/src/main/java/com/googlesource/gerrit/plugins/its/base/workflow/commit_collector/SinceLastTagCommitCollector.java b/src/main/java/com/googlesource/gerrit/plugins/its/base/workflow/commit_collector/SinceLastTagCommitCollector.java
new file mode 100644
index 0000000..d8f1ec1
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/its/base/workflow/commit_collector/SinceLastTagCommitCollector.java

@@ -0,0 +1,97 @@
+// Copyright (C) 2018 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.its.base.workflow.commit_collector;
+
+import com.google.gerrit.entities.Project;
+import com.google.gerrit.server.git.GitRepositoryManager;
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import javax.inject.Inject;
+import org.eclipse.jgit.errors.IncorrectObjectTypeException;
+import org.eclipse.jgit.lib.Constants;
+import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.revwalk.RevCommit;
+import org.eclipse.jgit.revwalk.RevObject;
+import org.eclipse.jgit.revwalk.RevTag;
+import org.eclipse.jgit.revwalk.RevWalk;
+
+/** Collects all commits between the last tag and HEAD */
+public class SinceLastTagCommitCollector implements CommitCollector {
+
+  public interface Factory {
+    SinceLastTagCommitCollector create();
+  }
+
+  private final GitRepositoryManager repoManager;
+
+  @Inject
+  public SinceLastTagCommitCollector(GitRepositoryManager repoManager) {
+    this.repoManager = repoManager;
+  }
+
+  @Override
+  public List<String> collect(Map<String, String> properties) throws IOException {
+    String projectName = properties.get("project");
+    String revision = properties.get("revision");
+
+    try (Repository repo = repoManager.openRepository(Project.nameKey(projectName))) {
+      return collect(repo, revision);
+    }
+  }
+
+  private List<String> collect(Repository repo, String currentRevision) throws IOException {
+    try (RevWalk revWalk = new RevWalk(repo)) {
+      RevCommit currentCommit = revWalk.parseCommit(repo.resolve(currentRevision));
+      revWalk.markStart(currentCommit);
+      List<String> commitIds = new ArrayList<>();
+      for (RevCommit commit : revWalk) {
+        if (!currentCommit.getId().equals(commit.getId()) && isTagged(repo, commit)) {
+          break;
+        }
+        commitIds.add(ObjectId.toString(commit.getId()));
+      }
+      return commitIds;
+    }
+  }
+
+  /** @return True if {@code commit} is tagged */
+  private boolean isTagged(Repository repo, RevCommit commit) throws IOException {
+    ObjectId commitId = commit.getId();
+    try (RevWalk revWalk = new RevWalk(repo)) {
+      return repo.getRefDatabase().getRefsByPrefix(Constants.R_TAGS).stream()
+          .map(Ref::getObjectId)
+          .map(
+              refObjectId -> {
+                try {
+                  return revWalk.parseTag(refObjectId);
+                } catch (IncorrectObjectTypeException e) {
+                  return null;
+                } catch (IOException e) {
+                  throw new UncheckedIOException(e);
+                }
+              })
+          .filter(Objects::nonNull)
+          .map(RevTag::getObject)
+          .map(RevObject::getId)
+          .anyMatch(commitId::equals);
+    }
+  }
+}

diff --git a/src/main/resources/Documentation/config-rulebase-common.md b/src/main/resources/Documentation/config-rulebase-common.md
index d232e57..50e1023 100644
--- a/src/main/resources/Documentation/config-rulebase-common.md
+++ b/src/main/resources/Documentation/config-rulebase-common.md

@@ -574,6 +574,13 @@
 `uploaderUsername`
 : username of the user that uploaded this patch set.
 
+### Common properties for all events
+
+`source`
+: source of the event that triggered the action. Can be `its` or `gerrit`.
+  `its` sourced events are fired by its actions. e.g. `fire-event-on-commits` action fires `its` sourced events.
+  `gerrit` sourced events are directly fired by the Gerrit event system.
+
 ## Actions
 
 Lines of the form
@@ -693,6 +700,26 @@
   action = create-version-from-property ref
 ```
 
+### Action: fire-event-on-commits
+
+The `fire-event-on-commits` action start by collecting commits using a collector then fire the event
+on each collected commit.
+
+This is useful when you want to trigger rules on a multiple past commits.
+
+Available collectors are:
+- `since-last-tag`: Collects all commits between the current ref and previous tag
+
+To avoid to trigger issue actions twice for the same event, you should condition your rule on
+the event property `source`.
+
+Example:
+
+```
+  action = fire-event-on-commits since-last-tag
+```
+
+
 ### Action: log-event
 
 The `log-event` action appends the event's properties to Gerrit's log.

diff --git a/src/test/java/com/googlesource/gerrit/plugins/its/base/its/ItsConfigTest.java b/src/test/java/com/googlesource/gerrit/plugins/its/base/its/ItsConfigTest.java
index 3379908..34068bb 100644
--- a/src/test/java/com/googlesource/gerrit/plugins/its/base/its/ItsConfigTest.java
+++ b/src/test/java/com/googlesource/gerrit/plugins/its/base/its/ItsConfigTest.java

@@ -56,8 +56,8 @@
       String enabled, String itsProject, String parentEnabled, String[] branches) {
     ProjectState projectState = mock(ProjectState.class);
 
-    when(projectCache.get(Project.nameKey("testProject"))).thenReturn(projectState);
-    when(projectCache.get(Project.nameKey("parentProject"))).thenReturn(projectState);
+    when(projectCache.get(Project.nameKey("testProject"))).thenReturn(Optional.of(projectState));
+    when(projectCache.get(Project.nameKey("parentProject"))).thenReturn(Optional.of(projectState));
 
     Iterable<ProjectState> parents;
     if (parentEnabled == null) {

diff --git a/src/test/java/com/googlesource/gerrit/plugins/its/base/util/PropertyExtractorTest.java b/src/test/java/com/googlesource/gerrit/plugins/its/base/util/PropertyExtractorTest.java
index ac7ea92..d4f0605 100644
--- a/src/test/java/com/googlesource/gerrit/plugins/its/base/util/PropertyExtractorTest.java
+++ b/src/test/java/com/googlesource/gerrit/plugins/its/base/util/PropertyExtractorTest.java

@@ -41,6 +41,7 @@
 import com.google.inject.Guice;
 import com.google.inject.Injector;
 import com.googlesource.gerrit.plugins.its.base.testutil.LoggingMockingTestCase;
+import com.googlesource.gerrit.plugins.its.base.workflow.RefEventProperties;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
@@ -374,13 +375,30 @@
       when(issueExtractor.getIssueIds("testProject", "testRevision")).thenReturn(issueMap);
     }
 
-    Set<Map<String, String>> actual = propertyExtractor.extractFrom(event).getIssuesProperties();
+    RefEventProperties refEventProperties = propertyExtractor.extractFrom(event);
+
+    Map<String, String> actualProjectProperties = refEventProperties.getProjectProperties();
+
+    Map<String, String> expectedProjectProperties =
+        ImmutableMap.<String, String>builder()
+            .put("itsName", "ItsTestName")
+            .put("event", "com.google.gerrit.server.events." + className)
+            .put("event-type", type)
+            .put("source", "gerrit")
+            .putAll(common)
+            .build();
+
+    assertEquals(
+        "Project properties do not match", expectedProjectProperties, actualProjectProperties);
+
+    Set<Map<String, String>> actualIssuesProperties = refEventProperties.getIssuesProperties();
 
     Map<String, String> propertiesIssue4711 =
         ImmutableMap.<String, String>builder()
             .put("itsName", "ItsTestName")
             .put("event", "com.google.gerrit.server.events." + className)
             .put("event-type", type)
+            .put("source", "its")
             .put("association", "body anywhere")
             .put("issue", "4711")
             .putAll(common)
@@ -390,15 +408,17 @@
             .put("itsName", "ItsTestName")
             .put("event", "com.google.gerrit.server.events." + className)
             .put("event-type", type)
+            .put("source", "its")
             .put("association", "anywhere footer")
             .put("issue", "42")
             .putAll(common)
             .build();
-    Set<Map<String, String>> expected = new HashSet<>();
-    expected.add(propertiesIssue4711);
-    expected.add(propertiesIssue42);
+    Set<Map<String, String>> expectedIssuesProperties = new HashSet<>();
+    expectedIssuesProperties.add(propertiesIssue4711);
+    expectedIssuesProperties.add(propertiesIssue42);
 
-    assertEquals("Properties do not match", expected, actual);
+    assertEquals(
+        "Issues properties do not match", expectedIssuesProperties, actualIssuesProperties);
   }
 
   @Override

diff --git a/src/test/java/com/googlesource/gerrit/plugins/its/base/workflow/ActionExecutorTest.java b/src/test/java/com/googlesource/gerrit/plugins/its/base/workflow/ActionExecutorTest.java
index 5b8c43f..822602b 100644
--- a/src/test/java/com/googlesource/gerrit/plugins/its/base/workflow/ActionExecutorTest.java
+++ b/src/test/java/com/googlesource/gerrit/plugins/its/base/workflow/ActionExecutorTest.java

@@ -48,6 +48,7 @@
   private LogEvent.Factory logEventFactory;
   private AddPropertyToField.Factory addPropertyToFieldFactory;
   private CreateVersionFromProperty.Factory createVersionFromPropertyFactory;
+  private FireEventOnCommits.Factory fireEventOnCommitsFactory;
   private CustomAction customAction;
 
   private Map<String, String> properties =
@@ -212,7 +213,8 @@
 
     CreateVersionFromProperty createVersionFromProperty = mock(CreateVersionFromProperty.class);
     when(createVersionFromPropertyFactory.create()).thenReturn(createVersionFromProperty);
-    when(itsFacadeFactory.getFacade(Project.nameKey(properties.get("project")))).thenReturn(its);
+    when(itsFacadeFactory.getFacade(Project.nameKey(projectProperties.get("project"))))
+        .thenReturn(its);
 
     ActionExecutor actionExecutor = createActionExecutor();
     actionExecutor.executeOnProject(Collections.singleton(actionRequest), projectProperties);
@@ -237,6 +239,21 @@
     verify(addPropertyToField).execute(its, "4711", actionRequest, properties);
   }
 
+  public void testFireEventOnCommitsDelegation() throws IOException {
+    ActionRequest actionRequest = mock(ActionRequest.class);
+    when(actionRequest.getName()).thenReturn("fire-event-on-commits");
+
+    FireEventOnCommits fireEventOnCommits = mock(FireEventOnCommits.class);
+    when(fireEventOnCommitsFactory.create()).thenReturn(fireEventOnCommits);
+    when(itsFacadeFactory.getFacade(Project.nameKey(projectProperties.get("project"))))
+        .thenReturn(its);
+
+    ActionExecutor actionExecutor = createActionExecutor();
+    actionExecutor.executeOnProject(Collections.singleton(actionRequest), projectProperties);
+
+    verify(fireEventOnCommits).execute(its, "itsTestProject", actionRequest, projectProperties);
+  }
+
   public void testExecuteIssueCustomAction() throws IOException {
     when(customAction.getType()).thenReturn(ActionType.ISSUE);
 
@@ -304,6 +321,9 @@
       createVersionFromPropertyFactory = mock(CreateVersionFromProperty.Factory.class);
       bind(CreateVersionFromProperty.Factory.class).toInstance(createVersionFromPropertyFactory);
 
+      fireEventOnCommitsFactory = mock(FireEventOnCommits.Factory.class);
+      bind(FireEventOnCommits.Factory.class).toInstance(fireEventOnCommitsFactory);
+
       DynamicMap.mapOf(binder(), CustomAction.class);
       customAction = mock(CustomAction.class);
 

diff --git a/src/test/java/com/googlesource/gerrit/plugins/its/base/workflow/FireEventOnCommitsParametersExtractorTest.java b/src/test/java/com/googlesource/gerrit/plugins/its/base/workflow/FireEventOnCommitsParametersExtractorTest.java
new file mode 100644
index 0000000..c99bf33
--- /dev/null
+++ b/src/test/java/com/googlesource/gerrit/plugins/its/base/workflow/FireEventOnCommitsParametersExtractorTest.java

@@ -0,0 +1,102 @@
+// Copyright (C) 2018 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.its.base.workflow;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import com.google.gerrit.extensions.config.FactoryModule;
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+import com.googlesource.gerrit.plugins.its.base.workflow.commit_collector.SinceLastTagCommitCollector;
+import java.util.Collections;
+import java.util.Optional;
+import junit.framework.TestCase;
+
+public class FireEventOnCommitsParametersExtractorTest extends TestCase {
+
+  private static final String SINCE_LAST_TAG_COLLECTOR = "since-last-tag";
+
+  private SinceLastTagCommitCollector.Factory sinceLastTagCommitCollectorFactory;
+  private FireEventOnCommitsParametersExtractor extractor;
+
+  @Override
+  public void setUp() throws Exception {
+    super.setUp();
+    Injector injector = Guice.createInjector(new TestModule());
+    extractor = injector.getInstance(FireEventOnCommitsParametersExtractor.class);
+  }
+
+  private class TestModule extends FactoryModule {
+    @Override
+    protected void configure() {
+      sinceLastTagCommitCollectorFactory = mock(SinceLastTagCommitCollector.Factory.class);
+      bind(SinceLastTagCommitCollector.Factory.class)
+          .toInstance(sinceLastTagCommitCollectorFactory);
+    }
+  }
+
+  public void testNoParameter() {
+    testWrongNumberOfReceivedParameters(new String[] {});
+  }
+
+  public void testTwoParameters() {
+    testWrongNumberOfReceivedParameters(
+        new String[] {SINCE_LAST_TAG_COLLECTOR, SINCE_LAST_TAG_COLLECTOR});
+  }
+
+  private void testWrongNumberOfReceivedParameters(String[] parameters) {
+    ActionRequest actionRequest = mock(ActionRequest.class);
+    when(actionRequest.getParameters()).thenReturn(parameters);
+
+    Optional<FireEventOnCommitsParameters> extractedParameters =
+        extractor.extract(actionRequest, Collections.emptyMap());
+    assertFalse(extractedParameters.isPresent());
+  }
+
+  public void testBlankCollectorName() {
+    ActionRequest actionRequest = mock(ActionRequest.class);
+    when(actionRequest.getParameters()).thenReturn(new String[] {""});
+
+    Optional<FireEventOnCommitsParameters> extractedParameters =
+        extractor.extract(actionRequest, Collections.emptyMap());
+    assertFalse(extractedParameters.isPresent());
+  }
+
+  public void testUnknownCollectorName() {
+    ActionRequest actionRequest = mock(ActionRequest.class);
+    when(actionRequest.getParameters()).thenReturn(new String[] {"foo"});
+
+    Optional<FireEventOnCommitsParameters> extractedParameters =
+        extractor.extract(actionRequest, Collections.emptyMap());
+    assertFalse(extractedParameters.isPresent());
+  }
+
+  public void testSinceLastTagCollector() {
+    ActionRequest actionRequest = mock(ActionRequest.class);
+    when(actionRequest.getParameters()).thenReturn(new String[] {SINCE_LAST_TAG_COLLECTOR});
+
+    SinceLastTagCommitCollector collector = mock(SinceLastTagCommitCollector.class);
+    when(sinceLastTagCommitCollectorFactory.create()).thenReturn(collector);
+
+    Optional<FireEventOnCommitsParameters> extractedParameters =
+        extractor.extract(actionRequest, Collections.singletonMap("project", "testProject"));
+    if (!extractedParameters.isPresent()) {
+      fail();
+    }
+    assertEquals(collector, extractedParameters.get().getCommitCollector());
+    assertEquals("testProject", extractedParameters.get().getProjectName());
+  }
+}

diff --git a/src/test/java/com/googlesource/gerrit/plugins/its/base/workflow/FireEventOnCommitsTest.java b/src/test/java/com/googlesource/gerrit/plugins/its/base/workflow/FireEventOnCommitsTest.java
new file mode 100644
index 0000000..e80081d
--- /dev/null
+++ b/src/test/java/com/googlesource/gerrit/plugins/its/base/workflow/FireEventOnCommitsTest.java

@@ -0,0 +1,115 @@
+// Copyright (C) 2018 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.its.base.workflow;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Maps;
+import com.google.gerrit.extensions.config.FactoryModule;
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+import com.googlesource.gerrit.plugins.its.base.its.ItsFacade;
+import com.googlesource.gerrit.plugins.its.base.util.IssueExtractor;
+import com.googlesource.gerrit.plugins.its.base.util.PropertyExtractor;
+import com.googlesource.gerrit.plugins.its.base.workflow.commit_collector.SinceLastTagCommitCollector;
+import java.io.IOException;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import junit.framework.TestCase;
+
+public class FireEventOnCommitsTest extends TestCase {
+
+  private static final String ITS_PROJECT = "test-project";
+  private static final String COMMIT = "1234";
+  private static final String PROJECT = "testProject";
+
+  private Injector injector;
+  private ItsFacade its;
+  private PropertyExtractor propertyExtractor;
+  private IssueExtractor issueExtractor;
+  private RuleBase ruleBase;
+  private ActionExecutor actionExecutor;
+  private FireEventOnCommitsParametersExtractor parametersExtractor;
+
+  @Override
+  public void setUp() throws Exception {
+    super.setUp();
+    injector = Guice.createInjector(new TestModule());
+  }
+
+  private class TestModule extends FactoryModule {
+    @Override
+    protected void configure() {
+      its = mock(ItsFacade.class);
+      bind(ItsFacade.class).toInstance(its);
+
+      propertyExtractor = mock(PropertyExtractor.class);
+      bind(PropertyExtractor.class).toInstance(propertyExtractor);
+
+      ruleBase = mock(RuleBase.class);
+      bind(RuleBase.class).toInstance(ruleBase);
+
+      issueExtractor = mock(IssueExtractor.class);
+      bind(IssueExtractor.class).toInstance(issueExtractor);
+
+      actionExecutor = mock(ActionExecutor.class);
+      bind(ActionExecutor.class).toInstance(actionExecutor);
+
+      parametersExtractor = mock(FireEventOnCommitsParametersExtractor.class);
+      bind(FireEventOnCommitsParametersExtractor.class).toInstance(parametersExtractor);
+    }
+  }
+
+  public void testHappyPath() throws IOException {
+    Map<String, String> properties = ImmutableMap.of("project", PROJECT);
+
+    FireEventOnCommitsParameters parameters = mock(FireEventOnCommitsParameters.class);
+    SinceLastTagCommitCollector collector = mock(SinceLastTagCommitCollector.class);
+    when(parameters.getCommitCollector()).thenReturn(collector);
+    when(parameters.getProjectName()).thenReturn(PROJECT);
+
+    ActionRequest actionRequest = mock(ActionRequest.class);
+    when(parametersExtractor.extract(actionRequest, properties))
+        .thenReturn(Optional.of(parameters));
+    when(collector.collect(properties)).thenReturn(Collections.singletonList(COMMIT));
+
+    Map<String, Set<String>> associations = Maps.newHashMap();
+    when(issueExtractor.getIssueIds(PROJECT, COMMIT)).thenReturn(associations);
+
+    Set<Map<String, String>> issuesProperties = ImmutableSet.of(properties);
+    when(propertyExtractor.extractIssuesProperties(properties, associations))
+        .thenReturn(issuesProperties);
+
+    ActionRequest subActionRequest = mock(ActionRequest.class);
+    Collection<ActionRequest> subActionRequests = Collections.singleton(subActionRequest);
+    when(ruleBase.actionRequestsFor(properties)).thenReturn(subActionRequests);
+
+    FireEventOnCommits fireEventOnCommits = createFireEventOnCommits();
+    fireEventOnCommits.execute(its, ITS_PROJECT, actionRequest, properties);
+
+    verify(actionExecutor).executeOnIssue(subActionRequests, properties);
+  }
+
+  private FireEventOnCommits createFireEventOnCommits() {
+    return injector.getInstance(FireEventOnCommits.class);
+  }
+}

diff --git a/src/test/java/com/googlesource/gerrit/plugins/its/base/workflow/ItsRulesProjectCacheTest.java b/src/test/java/com/googlesource/gerrit/plugins/its/base/workflow/ItsRulesProjectCacheTest.java
index 6b83097..592722c 100644
--- a/src/test/java/com/googlesource/gerrit/plugins/its/base/workflow/ItsRulesProjectCacheTest.java
+++ b/src/test/java/com/googlesource/gerrit/plugins/its/base/workflow/ItsRulesProjectCacheTest.java

@@ -36,6 +36,7 @@
 import java.io.IOException;
 import java.util.Collection;
 import java.util.List;
+import java.util.Optional;
 import org.eclipse.jgit.lib.Config;
 
 public class ItsRulesProjectCacheTest extends LoggingMockingTestCase {
@@ -90,7 +91,7 @@
     ProjectLevelConfig projectLevelConfigPlugin = mock(ProjectLevelConfig.class);
     when(projectLevelConfigPlugin.get()).thenReturn(new Config());
     when(projectState.getConfig(RuleBaseKind.ITS.fileName)).thenReturn(projectLevelConfigPlugin);
-    when(projectCache.checkedGet(Project.nameKey(TEST_PROJECT))).thenReturn(projectState);
+    when(projectCache.get(Project.nameKey(TEST_PROJECT))).thenReturn(Optional.of(projectState));
     when(rulesConfigReader.getRulesFromConfig(any(Config.class)))
         .thenReturn(ImmutableList.of(rule1))
         .thenReturn(ImmutableList.of());
@@ -132,7 +133,7 @@
     when(parentProjectState.getConfig(RuleBaseKind.ITS.fileName))
         .thenReturn(parentProjectConfigPlugin);
     when(projectState.parents()).thenReturn(FluentIterable.of(parentProjectState));
-    when(projectCache.checkedGet(Project.nameKey(TEST_PROJECT))).thenReturn(projectState);
+    when(projectCache.get(Project.nameKey(TEST_PROJECT))).thenReturn(Optional.of(projectState));
 
     when(rulesConfigReader.getRulesFromConfig(any(Config.class)))
         .thenReturn(ImmutableList.of())