diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..659c9e1
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,18 @@
+# Compiled class file
+*.class
+
+# Log file
+*.log
+
+# IJ
+.idea
+.ijwb/
+
+# Package Files #
+*.jar
+*.war
+*.nar
+*.ear
+*.zip
+*.tar.gz
+*.rar
\ No newline at end of file
diff --git a/BUILD b/BUILD
new file mode 100644
index 0000000..7bd22d4
--- /dev/null
+++ b/BUILD
@@ -0,0 +1,50 @@
+load(
+    "//tools/bzl:plugin.bzl",
+    "PLUGIN_DEPS",
+    "PLUGIN_TEST_DEPS",
+    "gerrit_plugin",
+)
+load("//tools/bzl:junit.bzl", "junit_tests")
+
+gerrit_plugin(
+    name = "replication-status",
+    srcs = glob(["src/main/java/**/*.java"]),
+    manifest_entries = [
+        "Gerrit-PluginName: replication-status",
+        "Gerrit-Module: com.googlesource.gerrit.plugins.replicationstatus.Module",
+        "Implementation-Title: Replication Status",
+        "Implementation-URL: https://gerrit.googlesource.com/plugins/replication-status",
+    ],
+    resources = glob(["src/main/resources/**/*"]),
+    deps = [
+        ":replication-neverlink",
+        "//java/com/google/gerrit/proto",
+        "//plugins/replication-status/proto:replication_status_cache_java_proto",
+        "@error-prone-annotations//jar",
+    ],
+)
+
+junit_tests(
+    name = "replicationstatus_tests",
+    srcs = glob(["src/test/java/**/*.java"]),
+    resources = glob(["src/test/resources/**/*"]),
+    deps = [
+        ":replicationstatus__plugin_test_deps",
+    ],
+)
+
+java_library(
+    name = "replication-neverlink",
+    neverlink = 1,
+    exports = ["//plugins/replication"],
+)
+
+java_library(
+    name = "replicationstatus__plugin_test_deps",
+    testonly = 1,
+    visibility = ["//visibility:public"],
+    exports = PLUGIN_DEPS + PLUGIN_TEST_DEPS + [
+        ":replication-status__plugin",
+        "//plugins/replication",
+    ],
+)
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..261eeb9
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.
diff --git a/README.md b/README.md
index 5f59fa5..a5c70e0 100644
--- a/README.md
+++ b/README.md
@@ -2,3 +2,85 @@
 
 Record and display the repository's replication status without having to dig
 into the Gerrit replication_log
+
+Consumes replication events and updates a cache with the latest replication
+status of specific refs to specific remotes.
+
+The cache information is then exposed via a project's resource REST endpoint:
+
+```bash
+curl -v --user <user> '<gerrit-server>/a/projects/<project-name>/remotes/<remote-url>/replication-status'
+```
+
+* <project-name>: an (url-encoded) project repository
+* <remote-url>: an (url-encoded) remote URL for the replication
+
+For instance, to assess the replication status of the project `some/project` to
+the
+`https://github.com/some/project.git` URL, the following endpoint should be
+called:
+
+```bash
+curl -v --user <user> '<gerrit-server>/a/projects/some%2Fproject/remotes/https%3A%2F%2Fgithub.com%2Fsome%2Fproject.git/replication-status'
+```
+
+A payload, similar to this may be returned:
+
+```
+{
+  "remotes": {
+    "https://github.com/some/project.git": {
+      "status": {
+        "refs/changes/01/1/meta": {
+          "status": "SUCCEEDED",
+          "when": 1626688830
+        },
+        "refs/changes/03/3/meta": {
+          "status": "SUCCEEDED",
+          "when": 1626688854
+        },
+        "refs/changes/03/3/1": {
+          "status": "SUCCEEDED",
+          "when": 1626688854
+        },
+        "refs/changes/02/2/1": {
+          "status": "SUCCEEDED",
+          "when": 1626688844
+        },
+        "refs/changes/02/2/meta": {
+          "status": "SUCCEEDED",
+          "when": 1626688844
+        },
+        "refs/changes/01/1/1": {
+          "status": "SUCCEEDED",
+          "when": 1626688830
+        }
+      }
+    }
+  },
+  "status": "OK",
+  "project": "some/project"
+}
+```
+
+### HTTP status
+
+The endpoint returns different HTTP response code depending on the result:
+
+* 200 OK - The endpoint was called successfully, and a payload returned
+* 404 Not Found - Project was not found
+* 500 Failure - An unexpected server error occurred
+* 403 Forbidden - The user has no permission to query the endpoint. Only
+  Administrators and project owners are allowed
+
+### Overall status
+
+The REST-API response shows a `status` field, which shows the overall
+replication-status of the projects for the specified remote.
+
+- `OK` - all the refs have successfully replicated
+- `FAILED` - Some refs have not replicated successfully
+
+### TODO
+
+* Does not consume pull-replication events.
diff --git a/proto/BUILD b/proto/BUILD
new file mode 100644
index 0000000..c8e0c74
--- /dev/null
+++ b/proto/BUILD
@@ -0,0 +1,13 @@
+load("@rules_java//java:defs.bzl", "java_proto_library")
+load("@rules_proto//proto:defs.bzl", "proto_library")
+
+proto_library(
+    name = "replication_status_cache_proto",
+    srcs = ["cache.proto"],
+)
+
+java_proto_library(
+    name = "replication_status_cache_java_proto",
+    visibility = ["//visibility:public"],
+    deps = [":replication_status_cache_proto"],
+)
diff --git a/proto/cache.proto b/proto/cache.proto
new file mode 100644
index 0000000..6206ac0
--- /dev/null
+++ b/proto/cache.proto
@@ -0,0 +1,36 @@
+// Copyright (C) 2021 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.
+
+syntax = "proto3";
+
+package replicationstatus.cache;
+
+option java_package = "com.googlesource.gerrit.plugins.replicationstatus.proto";
+
+// Serialized form of com.googlesource.gerrit.plugins.replicationstatus.ReplicationStatus.Key.
+// Next ID: 4
+message ReplicationStatusKeyProto {
+  string project = 1;
+  string remote = 2;
+  string ref = 3;
+}
+
+// Serialized form of com.googlesource.gerrit.plugins.replicationstatus.ReplicationStatus.
+// Next ID: 3
+message ReplicationStatusProto {
+  int64 when = 1;
+  string status = 2;
+}
+
+
diff --git a/src/main/java/com/googlesource/gerrit/plugins/replicationstatus/EventHandler.java b/src/main/java/com/googlesource/gerrit/plugins/replicationstatus/EventHandler.java
new file mode 100644
index 0000000..580a85a
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/replicationstatus/EventHandler.java
@@ -0,0 +1,64 @@
+// Copyright (C) 2021 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.replicationstatus;
+
+import static com.googlesource.gerrit.plugins.replicationstatus.ReplicationStatus.ReplicationStatusResult;
+
+import com.google.common.cache.Cache;
+import com.google.gerrit.common.Nullable;
+import com.google.gerrit.entities.Project;
+import com.google.gerrit.server.config.GerritInstanceId;
+import com.google.gerrit.server.events.Event;
+import com.google.gerrit.server.events.EventListener;
+import com.google.inject.Inject;
+import com.google.inject.name.Named;
+import com.googlesource.gerrit.plugins.replication.RefReplicatedEvent;
+
+class EventHandler implements EventListener {
+  private final Cache<ReplicationStatus.Key, ReplicationStatus> replicationStatusCache;
+  private final String nodeInstanceId;
+
+  @Inject
+  EventHandler(
+      @Named(ReplicationStatus.CACHE_NAME)
+          Cache<ReplicationStatus.Key, ReplicationStatus> replicationStatusCache,
+      @Nullable @GerritInstanceId String nodeInstanceId) {
+    this.replicationStatusCache = replicationStatusCache;
+    this.nodeInstanceId = nodeInstanceId;
+  }
+
+  @Override
+  public void onEvent(Event event) {
+    if (shouldConsume(event)) {
+      if (event instanceof RefReplicatedEvent) {
+        RefReplicatedEvent replEvent = (RefReplicatedEvent) event;
+
+        ReplicationStatus.Key cacheKey =
+            ReplicationStatus.Key.create(
+                Project.nameKey(replEvent.project), replEvent.targetNode, replEvent.ref);
+
+        replicationStatusCache.put(
+            cacheKey,
+            ReplicationStatus.create(
+                ReplicationStatusResult.fromString(replEvent.status), replEvent.eventCreatedOn));
+      }
+    }
+  }
+
+  private boolean shouldConsume(Event event) {
+    return nodeInstanceId == null && event.instanceId == null
+        || nodeInstanceId != null && nodeInstanceId.equals(event.instanceId);
+  }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/replicationstatus/Module.java b/src/main/java/com/googlesource/gerrit/plugins/replicationstatus/Module.java
new file mode 100644
index 0000000..9109e55
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/replicationstatus/Module.java
@@ -0,0 +1,28 @@
+// Copyright (C) 2021 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.replicationstatus;
+
+import com.google.gerrit.extensions.registration.DynamicSet;
+import com.google.gerrit.lifecycle.LifecycleModule;
+import com.google.gerrit.server.events.EventListener;
+
+class Module extends LifecycleModule {
+  @Override
+  protected void configure() {
+    DynamicSet.bind(binder(), EventListener.class).to(EventHandler.class);
+    install(new ReplicationStatusApiModule());
+    install(new ReplicationStatusCacheModule());
+  }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/replicationstatus/ProjectReplicationStatus.java b/src/main/java/com/googlesource/gerrit/plugins/replicationstatus/ProjectReplicationStatus.java
new file mode 100644
index 0000000..a2c35eb
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/replicationstatus/ProjectReplicationStatus.java
@@ -0,0 +1,39 @@
+// Copyright (C) 2021 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.replicationstatus;
+
+import com.google.auto.value.AutoValue;
+import java.util.Map;
+
+@AutoValue
+public abstract class ProjectReplicationStatus {
+  static ProjectReplicationStatus create(
+      Map<String, RemoteReplicationStatus> remotes,
+      ProjectReplicationStatusResult status,
+      String project) {
+    return new AutoValue_ProjectReplicationStatus(remotes, status, project);
+  }
+
+  public abstract Map<String, RemoteReplicationStatus> remotes();
+
+  public abstract ProjectReplicationStatusResult status();
+
+  public abstract String project();
+
+  enum ProjectReplicationStatusResult {
+    FAILED,
+    OK;
+  }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/replicationstatus/RemoteReplicationStatus.java b/src/main/java/com/googlesource/gerrit/plugins/replicationstatus/RemoteReplicationStatus.java
new file mode 100644
index 0000000..f567e5e
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/replicationstatus/RemoteReplicationStatus.java
@@ -0,0 +1,27 @@
+// Copyright (C) 2021 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.replicationstatus;
+
+import com.google.auto.value.AutoValue;
+import java.util.Map;
+
+@AutoValue
+public abstract class RemoteReplicationStatus {
+  static RemoteReplicationStatus create(Map<String, ReplicationStatus> status) {
+    return new AutoValue_RemoteReplicationStatus(status);
+  }
+
+  public abstract Map<String, ReplicationStatus> status();
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/replicationstatus/ReplicationStatus.java b/src/main/java/com/googlesource/gerrit/plugins/replicationstatus/ReplicationStatus.java
new file mode 100644
index 0000000..438edc2
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/replicationstatus/ReplicationStatus.java
@@ -0,0 +1,123 @@
+// Copyright (C) 2021 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.replicationstatus;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.flogger.FluentLogger;
+import com.google.gerrit.entities.Project;
+import com.google.gerrit.proto.Protos;
+import com.google.gerrit.server.cache.serialize.CacheSerializer;
+import com.googlesource.gerrit.plugins.replicationstatus.proto.Cache;
+
+@AutoValue
+public abstract class ReplicationStatus {
+  static final String CACHE_NAME = "replication_status";
+  private static final FluentLogger logger = FluentLogger.forEnclosingClass();
+
+  static ReplicationStatus create(ReplicationStatusResult status, long when) {
+    return new AutoValue_ReplicationStatus(status, when);
+  }
+
+  public abstract ReplicationStatusResult status();
+
+  public abstract long when();
+
+  public boolean isFailure() {
+    return status().isFailure();
+  }
+
+  @AutoValue
+  public abstract static class Key {
+    static ReplicationStatus.Key create(Project.NameKey projectName, String remote, String ref) {
+      return new AutoValue_ReplicationStatus_Key(projectName, remote, ref);
+    }
+
+    abstract Project.NameKey projectName();
+
+    abstract String remote();
+
+    abstract String ref();
+
+    enum Serializer implements CacheSerializer<ReplicationStatus.Key> {
+      INSTANCE;
+
+      @Override
+      public byte[] serialize(ReplicationStatus.Key object) {
+        return Protos.toByteArray(
+            Cache.ReplicationStatusKeyProto.newBuilder()
+                .setProject(object.projectName().get())
+                .setRemote(object.remote())
+                .setRef(object.ref())
+                .build());
+      }
+
+      @Override
+      public ReplicationStatus.Key deserialize(byte[] in) {
+        Cache.ReplicationStatusKeyProto proto =
+            Protos.parseUnchecked(Cache.ReplicationStatusKeyProto.parser(), in);
+        return ReplicationStatus.Key.create(
+            Project.nameKey(proto.getProject()), proto.getRemote(), proto.getRef());
+      }
+    }
+  }
+
+  enum Serializer implements CacheSerializer<ReplicationStatus> {
+    INSTANCE;
+
+    @Override
+    public byte[] serialize(ReplicationStatus object) {
+      return Protos.toByteArray(
+          Cache.ReplicationStatusProto.newBuilder()
+              .setWhen(object.when())
+              .setStatus(object.status().name())
+              .build());
+    }
+
+    @Override
+    public ReplicationStatus deserialize(byte[] in) {
+      Cache.ReplicationStatusProto proto =
+          Protos.parseUnchecked(Cache.ReplicationStatusProto.parser(), in);
+
+      return ReplicationStatus.create(
+          ReplicationStatus.ReplicationStatusResult.valueOf(proto.getStatus()), proto.getWhen());
+    }
+  }
+
+  enum ReplicationStatusResult {
+    FAILED,
+    NOT_ATTEMPTED,
+    SUCCEEDED,
+    UNKNOWN;
+
+    static ReplicationStatusResult fromString(String result) {
+      switch (result.toLowerCase()) {
+        case "succeeded":
+          return SUCCEEDED;
+        case "not_attempted":
+          return NOT_ATTEMPTED;
+        case "failed":
+          return FAILED;
+        default:
+          logger.atSevere().log(
+              "Could not parse result into a valid replication status: %", result);
+          return UNKNOWN;
+      }
+    }
+
+    public boolean isFailure() {
+      return this == FAILED || this == UNKNOWN;
+    }
+  }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/replicationstatus/ReplicationStatusAction.java b/src/main/java/com/googlesource/gerrit/plugins/replicationstatus/ReplicationStatusAction.java
new file mode 100644
index 0000000..7691897
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/replicationstatus/ReplicationStatusAction.java
@@ -0,0 +1,105 @@
+// Copyright (C) 2021 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.replicationstatus;
+
+import static com.googlesource.gerrit.plugins.replicationstatus.ReplicationStatus.CACHE_NAME;
+
+import com.google.common.cache.Cache;
+import com.google.gerrit.entities.Project;
+import com.google.gerrit.extensions.restapi.AuthException;
+import com.google.gerrit.extensions.restapi.BadRequestException;
+import com.google.gerrit.extensions.restapi.ResourceConflictException;
+import com.google.gerrit.extensions.restapi.Response;
+import com.google.gerrit.extensions.restapi.RestReadView;
+import com.google.gerrit.server.git.GitRepositoryManager;
+import com.google.gerrit.server.permissions.GlobalPermission;
+import com.google.gerrit.server.permissions.PermissionBackend;
+import com.google.gerrit.server.permissions.PermissionBackendException;
+import com.google.gerrit.server.permissions.ProjectPermission;
+import com.google.inject.Inject;
+import com.google.inject.name.Named;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import org.eclipse.jgit.errors.RepositoryNotFoundException;
+import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.lib.Repository;
+
+class ReplicationStatusAction implements RestReadView<ReplicationStatusProjectRemoteResource> {
+  private final PermissionBackend permissionBackend;
+  private final GitRepositoryManager repoManager;
+  private final Cache<ReplicationStatus.Key, ReplicationStatus> replicationStatusCache;
+
+  @Inject
+  ReplicationStatusAction(
+      PermissionBackend permissionBackend,
+      GitRepositoryManager repoManager,
+      @Named(CACHE_NAME) Cache<ReplicationStatus.Key, ReplicationStatus> replicationStatusCache) {
+    this.permissionBackend = permissionBackend;
+    this.repoManager = repoManager;
+    this.replicationStatusCache = replicationStatusCache;
+  }
+
+  @Override
+  public Response<ProjectReplicationStatus> apply(ReplicationStatusProjectRemoteResource resource)
+      throws AuthException, PermissionBackendException, BadRequestException,
+          ResourceConflictException, IOException {
+
+    Project.NameKey projectNameKey = resource.getProjectNameKey();
+    String remoteURL = resource.getRemoteUrl();
+
+    checkIsOwnerOrAdmin(projectNameKey);
+
+    ProjectReplicationStatus.ProjectReplicationStatusResult overallStatus =
+        ProjectReplicationStatus.ProjectReplicationStatusResult.OK;
+    Map<String, RemoteReplicationStatus> remoteStatuses = new HashMap<>();
+    try (Repository git = repoManager.openRepository(projectNameKey)) {
+
+      Map<String, ReplicationStatus> refStatuses = new HashMap<>();
+      for (Ref r : git.getRefDatabase().getRefs()) {
+        ReplicationStatus replicationStatus =
+            replicationStatusCache.getIfPresent(
+                ReplicationStatus.Key.create(projectNameKey, remoteURL, r.getName()));
+
+        if (replicationStatus != null) {
+          refStatuses.put(r.getName(), replicationStatus);
+          if (replicationStatus.isFailure()) {
+            overallStatus = ProjectReplicationStatus.ProjectReplicationStatusResult.FAILED;
+          }
+        }
+      }
+      remoteStatuses.put(remoteURL, RemoteReplicationStatus.create(refStatuses));
+
+      ProjectReplicationStatus projectStatus =
+          ProjectReplicationStatus.create(remoteStatuses, overallStatus, projectNameKey.get());
+
+      return Response.ok(projectStatus);
+
+    } catch (RepositoryNotFoundException e) {
+      throw new BadRequestException(
+          String.format("Project %s does not exist", projectNameKey.get()));
+    }
+  }
+
+  private void checkIsOwnerOrAdmin(Project.NameKey project) throws AuthException {
+    if (!permissionBackend.currentUser().testOrFalse(GlobalPermission.ADMINISTRATE_SERVER)
+        && !permissionBackend
+            .currentUser()
+            .project(project)
+            .testOrFalse(ProjectPermission.WRITE_CONFIG)) {
+      throw new AuthException("Administrate Server or Project owner required");
+    }
+  }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/replicationstatus/ReplicationStatusApiModule.java b/src/main/java/com/googlesource/gerrit/plugins/replicationstatus/ReplicationStatusApiModule.java
new file mode 100644
index 0000000..adecc6d
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/replicationstatus/ReplicationStatusApiModule.java
@@ -0,0 +1,33 @@
+// Copyright (C) 2021 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.replicationstatus;
+
+import static com.google.gerrit.server.project.ProjectResource.PROJECT_KIND;
+import static com.googlesource.gerrit.plugins.replicationstatus.ReplicationStatusProjectRemoteResource.REPLICATION_STATUS_PROJECT_REMOTE_KIND;
+
+import com.google.gerrit.extensions.registration.DynamicMap;
+import com.google.gerrit.extensions.restapi.RestApiModule;
+import com.google.inject.Scopes;
+
+class ReplicationStatusApiModule extends RestApiModule {
+  @Override
+  protected void configure() {
+    bind(ReplicationStatusAction.class).in(Scopes.SINGLETON);
+    DynamicMap.mapOf(binder(), REPLICATION_STATUS_PROJECT_REMOTE_KIND);
+    child(PROJECT_KIND, "remotes").to(ReplicationStatusProjectRemoteCollection.class);
+    get(REPLICATION_STATUS_PROJECT_REMOTE_KIND, "replication-status")
+        .to(ReplicationStatusAction.class);
+  }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/replicationstatus/ReplicationStatusCacheModule.java b/src/main/java/com/googlesource/gerrit/plugins/replicationstatus/ReplicationStatusCacheModule.java
new file mode 100644
index 0000000..fa5a472
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/replicationstatus/ReplicationStatusCacheModule.java
@@ -0,0 +1,29 @@
+// Copyright (C) 2021 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.replicationstatus;
+
+import com.google.gerrit.server.cache.CacheModule;
+
+public class ReplicationStatusCacheModule extends CacheModule {
+
+  @Override
+  protected void configure() {
+    persist(ReplicationStatus.CACHE_NAME, ReplicationStatus.Key.class, ReplicationStatus.class)
+        .version(1)
+        .diskLimit(-1)
+        .keySerializer(ReplicationStatus.Key.Serializer.INSTANCE)
+        .valueSerializer(ReplicationStatus.Serializer.INSTANCE);
+  }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/replicationstatus/ReplicationStatusProjectRemoteCollection.java b/src/main/java/com/googlesource/gerrit/plugins/replicationstatus/ReplicationStatusProjectRemoteCollection.java
new file mode 100644
index 0000000..a8c0b0c
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/replicationstatus/ReplicationStatusProjectRemoteCollection.java
@@ -0,0 +1,58 @@
+// Copyright (C) 2021 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.replicationstatus;
+
+import com.google.gerrit.entities.Project;
+import com.google.gerrit.extensions.registration.DynamicMap;
+import com.google.gerrit.extensions.restapi.ChildCollection;
+import com.google.gerrit.extensions.restapi.IdString;
+import com.google.gerrit.extensions.restapi.NotImplementedException;
+import com.google.gerrit.extensions.restapi.ResourceNotFoundException;
+import com.google.gerrit.extensions.restapi.RestApiException;
+import com.google.gerrit.extensions.restapi.RestView;
+import com.google.gerrit.server.project.ProjectResource;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+
+@Singleton
+public class ReplicationStatusProjectRemoteCollection
+    implements ChildCollection<ProjectResource, ReplicationStatusProjectRemoteResource> {
+  private final DynamicMap<RestView<ReplicationStatusProjectRemoteResource>> views;
+
+  @Inject
+  ReplicationStatusProjectRemoteCollection(
+      DynamicMap<RestView<ReplicationStatusProjectRemoteResource>> views) {
+    this.views = views;
+  }
+
+  @Override
+  public RestView<ProjectResource> list() throws RestApiException {
+    throw new NotImplementedException();
+  }
+
+  @Override
+  public ReplicationStatusProjectRemoteResource parse(ProjectResource parent, IdString id)
+      throws ResourceNotFoundException, Exception {
+    Project.NameKey projectNameKey = parent.getNameKey();
+    String remoteURL = id.get();
+
+    return new ReplicationStatusProjectRemoteResource(projectNameKey, remoteURL, remoteURL);
+  }
+
+  @Override
+  public DynamicMap<RestView<ReplicationStatusProjectRemoteResource>> views() {
+    return views;
+  }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/replicationstatus/ReplicationStatusProjectRemoteResource.java b/src/main/java/com/googlesource/gerrit/plugins/replicationstatus/ReplicationStatusProjectRemoteResource.java
new file mode 100644
index 0000000..77b81cd
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/replicationstatus/ReplicationStatusProjectRemoteResource.java
@@ -0,0 +1,49 @@
+// Copyright (C) 2021 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.replicationstatus;
+
+import com.google.gerrit.entities.Project;
+import com.google.gerrit.extensions.restapi.RestResource;
+import com.google.gerrit.extensions.restapi.RestView;
+import com.google.inject.TypeLiteral;
+
+public class ReplicationStatusProjectRemoteResource implements RestResource {
+  public static final TypeLiteral<RestView<ReplicationStatusProjectRemoteResource>>
+      REPLICATION_STATUS_PROJECT_REMOTE_KIND =
+          new TypeLiteral<RestView<ReplicationStatusProjectRemoteResource>>() {};
+
+  private final Project.NameKey projectNameKey;
+  private final String remote;
+  private final String remoteURL;
+
+  public ReplicationStatusProjectRemoteResource(
+      Project.NameKey projectNameKey, String remote, String remoteURL) {
+    this.projectNameKey = projectNameKey;
+    this.remote = remote;
+    this.remoteURL = remoteURL;
+  }
+
+  public Project.NameKey getProjectNameKey() {
+    return projectNameKey;
+  }
+
+  public String getRemote() {
+    return remote;
+  }
+
+  public String getRemoteUrl() {
+    return remoteURL;
+  }
+}
diff --git a/src/main/resources/Documentation/build.md b/src/main/resources/Documentation/build.md
new file mode 100644
index 0000000..9d5193b
--- /dev/null
+++ b/src/main/resources/Documentation/build.md
@@ -0,0 +1,33 @@
+# Build
+
+This plugin is built with Bazel in-tree build.
+
+## Build in Gerrit tree
+
+Create a symbolic link of the repository source to the Gerrit source tree
+/plugins/replication-status directory.
+
+Example:
+
+```shell
+git clone https://gerrit.googlesource.com/gerrit
+git clone https://gerrit.googlesource.com/plugins/replication-status
+cd gerrit/plugins ln -s ../../replication-status replication-status
+```
+
+From the Gerrit source tree issue the command
+
+```shell
+bazelisk build plugins/replication-status
+```
+
+The jar file is created
+under `basel-bin/plugins/replication-status/replication-status.jar`
+
+To execute the tests run
+
+```shell
+bazelisk test plugins/replication-status/...
+```
+
+from the Gerrit source tree.
\ No newline at end of file
diff --git a/src/main/resources/Documentation/config.md b/src/main/resources/Documentation/config.md
new file mode 100644
index 0000000..aa01313
--- /dev/null
+++ b/src/main/resources/Documentation/config.md
@@ -0,0 +1,45 @@
+# Config
+
+The plugin itself has no specific configuration, however some Gerrit specific
+settings are relevant.
+
+## Cache
+
+This plugin relies on a cache to store replication status information, the
+global cache configuration settings apply.
+
+Please look at
+the [gerrit cache documentation](https://gerrit-review.googlesource.com/Documentation/config-gerrit.html#cache)
+for more information on this.
+
+In particular:
+
+* To define the lifespan of replication-status entries in the cache, look at
+  the [maxAge](https://gerrit-review.googlesource.com/Documentation/config-gerrit.html#cache.name.maxAge)
+  documentation. *Default*: store forever with no expire
+
+* To define how much disk space the replication-status cache can take, look at
+  the [diskLimit](https://gerrit-review.googlesource.com/Documentation/config-gerrit.html#cache.name.diskLimit)
+  documentation. *Default*: disk storage for the cache is disabled
+
+To modify this cache behaviour add the following stanza to the `gerrit.config`,
+for example:
+
+```
+[cache "replication-status.replication_status"]
+   diskLimit = 52428800 # 50 Mb
+   maxAge = 1 day
+```
+
+## Gerrit instanceId
+
+This plugin will try to discriminate among events produced by the current
+instances versus events produced by different instances.
+
+If the gerrit node running this plugin has
+the [gerrit.instanceId]([gerrit.instanceId](https://gerrit-review.googlesource.com/Documentation/config-gerrit.html#gerrit.instanceId))
+set to a specific value, it will only consume events that match it.
+
+On the other hand, if the `gerrit.instanceId` is not defined, only events that _
+do not_ have instanceId set will be consumed, as events exhibiting different
+instanceId values must have been generated by different gerrit nodes.
diff --git a/src/test/java/com/googlesource/gerrit/plugins/replicationstatus/ReplicationStatusIT.java b/src/test/java/com/googlesource/gerrit/plugins/replicationstatus/ReplicationStatusIT.java
new file mode 100644
index 0000000..493fdbd
--- /dev/null
+++ b/src/test/java/com/googlesource/gerrit/plugins/replicationstatus/ReplicationStatusIT.java
@@ -0,0 +1,290 @@
+// Copyright (C) 2021 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.replicationstatus;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.gerrit.acceptance.testsuite.project.TestProjectUpdate.allow;
+import static com.google.gerrit.extensions.restapi.Url.encode;
+import static com.googlesource.gerrit.plugins.replication.ReplicationState.RefPushResult;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.gerrit.acceptance.LightweightPluginDaemonTest;
+import com.google.gerrit.acceptance.RestResponse;
+import com.google.gerrit.acceptance.TestAccount;
+import com.google.gerrit.acceptance.TestPlugin;
+import com.google.gerrit.acceptance.config.GerritConfig;
+import com.google.gerrit.acceptance.testsuite.project.ProjectOperations;
+import com.google.gerrit.common.Nullable;
+import com.google.gerrit.entities.AccessSection;
+import com.google.gerrit.entities.AccountGroup;
+import com.google.gerrit.entities.Permission;
+import com.google.gerrit.entities.Project;
+import com.google.gerrit.extensions.api.groups.GroupInput;
+import com.google.gerrit.extensions.restapi.RestApiException;
+import com.google.gerrit.httpd.restapi.RestApiServlet;
+import com.google.gerrit.server.config.SitePaths;
+import com.google.gson.Gson;
+import com.google.inject.Inject;
+import com.googlesource.gerrit.plugins.replication.RefReplicatedEvent;
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.util.Collections;
+import org.eclipse.jgit.lib.Constants;
+import org.eclipse.jgit.transport.RemoteRefUpdate;
+import org.junit.Before;
+import org.junit.Test;
+
+@TestPlugin(
+    name = "replication-status",
+    sysModule = "com.googlesource.gerrit.plugins.replicationstatus.Module")
+public class ReplicationStatusIT extends LightweightPluginDaemonTest {
+  private static final String REF_MASTER = Constants.R_HEADS + Constants.MASTER;
+  private static final String REMOTE = "ssh://some.remote.host";
+
+  private static final Gson gson = newGson();
+
+  @Inject protected SitePaths sitePaths;
+  @Inject private ProjectOperations projectOperations;
+
+  private EventHandler eventHandler;
+
+  @Before
+  public void setUp() throws IOException {
+    eventHandler = plugin.getSysInjector().getInstance(EventHandler.class);
+  }
+
+  @Test
+  @GerritConfig(name = "gerrit.instanceId", value = "testInstanceId-1")
+  public void shouldBeOKSuccessForAdminUsers() throws Exception {
+    RestResponse result = adminRestSession.get(endpoint(project, REMOTE));
+    result.assertOK();
+
+    assertThat(contentWithoutMagicJson(result)).isEqualTo(emptyReplicationStatus(project, REMOTE));
+  }
+
+  @Test
+  @GerritConfig(name = "gerrit.instanceId", value = "testInstanceId-1")
+  public void shouldBeOKSuccessForProjectOwners() throws Exception {
+    makeProjectOwner(user, project);
+    RestResponse result = userRestSession.get(endpoint(project, REMOTE));
+    result.assertOK();
+
+    assertThat(contentWithoutMagicJson(result)).isEqualTo(emptyReplicationStatus(project, REMOTE));
+  }
+
+  @Test
+  @GerritConfig(name = "gerrit.instanceId", value = "testInstanceId-1")
+  public void shouldBeForbiddenForNonProjectOwners() throws Exception {
+    RestResponse result = userRestSession.get(endpoint(project, REMOTE));
+    result.assertForbidden();
+
+    assertThat(result.getEntityContent()).contains("Administrate Server or Project owner required");
+  }
+
+  @Test
+  @GerritConfig(name = "gerrit.instanceId", value = "testInstanceId-1")
+  public void shouldBeForbiddenForAnonymousUsers() throws Exception {
+    RestResponse result = anonymousRestSession.get(endpoint(project, REMOTE));
+    result.assertForbidden();
+
+    assertThat(result.getEntityContent()).contains("Administrate Server or Project owner required");
+  }
+
+  @Test
+  @GerritConfig(name = "gerrit.instanceId", value = "testInstanceId-1")
+  public void shouldNotReportStatusOfReplicationsGeneratedOnDifferentNodes() throws Exception {
+    eventHandler.onEvent(
+        successReplicatedEvent("testInstanceId-2", System.currentTimeMillis(), REMOTE));
+
+    RestResponse result = adminRestSession.get(endpoint(project, REMOTE));
+    result.assertOK();
+
+    assertThat(contentWithoutMagicJson(result)).isEqualTo(emptyReplicationStatus(project, REMOTE));
+  }
+
+  @Test
+  @GerritConfig(name = "gerrit.instanceId", value = "testInstanceId-1")
+  public void shouldReturnSuccessfulProjectReplicationStatus() throws Exception {
+    long eventCreatedOn = System.currentTimeMillis();
+
+    eventHandler.onEvent(successReplicatedEvent("testInstanceId-1", eventCreatedOn, REMOTE));
+    RestResponse result = adminRestSession.get(endpoint(project, REMOTE));
+
+    result.assertOK();
+    assertThat(contentWithoutMagicJson(result))
+        .isEqualTo(successReplicationStatus(REMOTE, project, eventCreatedOn));
+  }
+
+  @Test
+  public void shouldConsumeEventsThatHaveNoInstanceId() throws Exception {
+    long eventCreatedOn = System.currentTimeMillis();
+
+    eventHandler.onEvent(successReplicatedEvent(null, eventCreatedOn, REMOTE));
+    RestResponse result = adminRestSession.get(endpoint(project, REMOTE));
+
+    result.assertOK();
+    assertThat(contentWithoutMagicJson(result))
+        .isEqualTo(successReplicationStatus(REMOTE, project, eventCreatedOn));
+  }
+
+  @Test
+  public void shouldNotConsumeEventsWhenNodeInstanceIdIsNullButEventHasIt() throws Exception {
+    eventHandler.onEvent(
+        successReplicatedEvent("testInstanceId-2", System.currentTimeMillis(), REMOTE));
+
+    RestResponse result = adminRestSession.get(endpoint(project, REMOTE));
+    result.assertOK();
+
+    assertThat(contentWithoutMagicJson(result)).isEqualTo(emptyReplicationStatus(project, REMOTE));
+  }
+
+  @Test
+  public void shouldConsumeEventsWhenBothNodeAndEventHaveNoInstanceId() throws Exception {
+    long eventCreatedOn = System.currentTimeMillis();
+
+    eventHandler.onEvent(successReplicatedEvent(null, eventCreatedOn, REMOTE));
+    RestResponse result = adminRestSession.get(endpoint(project, REMOTE));
+
+    result.assertOK();
+    assertThat(contentWithoutMagicJson(result))
+        .isEqualTo(successReplicationStatus(REMOTE, project, eventCreatedOn));
+  }
+
+  @Test
+  @GerritConfig(name = "gerrit.instanceId", value = "testInstanceId-1")
+  public void shouldShowFailedInPayloadWhenRefCouldntBeReplicated() throws Exception {
+    long eventCreatedOn = System.currentTimeMillis();
+
+    eventHandler.onEvent(failedReplicatedEvent("testInstanceId-1", eventCreatedOn, REMOTE));
+    RestResponse result = adminRestSession.get(endpoint(project, REMOTE));
+
+    result.assertOK();
+    assertThat(contentWithoutMagicJson(result))
+        .isEqualTo(failedReplicationStatus(REMOTE, project, eventCreatedOn));
+  }
+
+  private String contentWithoutMagicJson(RestResponse response) throws IOException {
+    return response.getEntityContent().substring(RestApiServlet.JSON_MAGIC.length);
+  }
+
+  private AccountGroup.UUID createGroup(String name, TestAccount member) throws RestApiException {
+    GroupInput groupInput = new GroupInput();
+    groupInput.name = name(name);
+    groupInput.members = Collections.singletonList(String.valueOf(member.id().get()));
+    return AccountGroup.uuid(gApi.groups().create(groupInput).get().id);
+  }
+
+  private void makeProjectOwner(TestAccount user, Project.NameKey project) throws RestApiException {
+    projectOperations
+        .project(project)
+        .forUpdate()
+        .add(
+            allow(Permission.OWNER)
+                .ref(AccessSection.ALL)
+                .group(createGroup("projectOwners", user)))
+        .update();
+  }
+
+  private RefReplicatedEvent replicatedEvent(
+      @Nullable String instanceId,
+      long when,
+      String ref,
+      String remote,
+      RefPushResult status,
+      RemoteRefUpdate.Status refStatus) {
+    RefReplicatedEvent replicatedEvent =
+        new RefReplicatedEvent(project.get(), ref, remote, status, refStatus);
+    replicatedEvent.instanceId = instanceId;
+    replicatedEvent.eventCreatedOn = when;
+
+    return replicatedEvent;
+  }
+
+  private RefReplicatedEvent successReplicatedEvent(
+      @Nullable String instanceId, long when, String remoteUrl) {
+
+    return replicatedEvent(
+        instanceId,
+        when,
+        REF_MASTER,
+        remoteUrl,
+        RefPushResult.SUCCEEDED,
+        RemoteRefUpdate.Status.OK);
+  }
+
+  private RefReplicatedEvent failedReplicatedEvent(
+      @Nullable String instanceId, long when, String remoteUrl) {
+
+    return replicatedEvent(
+        instanceId,
+        when,
+        REF_MASTER,
+        remoteUrl,
+        RefPushResult.FAILED,
+        RemoteRefUpdate.Status.REJECTED_NONFASTFORWARD);
+  }
+
+  private static String endpoint(Project.NameKey project, String remote) {
+    return String.format(
+        "/projects/%s/remotes/%s/replication-status", project.get(), encode(remote));
+  }
+
+  private String emptyReplicationStatus(Project.NameKey project, String remoteUrl)
+      throws URISyntaxException {
+    return gson.toJson(
+        ProjectReplicationStatus.create(
+            ImmutableMap.of(remoteUrl, RemoteReplicationStatus.create(Collections.emptyMap())),
+            ProjectReplicationStatus.ProjectReplicationStatusResult.OK,
+            project.get()));
+  }
+
+  private String successReplicationStatus(String remote, Project.NameKey project, long when)
+      throws URISyntaxException {
+    return projectReplicationStatus(
+        remote,
+        project,
+        when,
+        ProjectReplicationStatus.ProjectReplicationStatusResult.OK,
+        ReplicationStatus.ReplicationStatusResult.SUCCEEDED);
+  }
+
+  private String failedReplicationStatus(String remote, Project.NameKey project, long when)
+      throws URISyntaxException {
+    return projectReplicationStatus(
+        remote,
+        project,
+        when,
+        ProjectReplicationStatus.ProjectReplicationStatusResult.FAILED,
+        ReplicationStatus.ReplicationStatusResult.FAILED);
+  }
+
+  private String projectReplicationStatus(
+      String remoteUrl,
+      Project.NameKey project,
+      long when,
+      ProjectReplicationStatus.ProjectReplicationStatusResult projectReplicationStatusResult,
+      ReplicationStatus.ReplicationStatusResult replicationStatusResult)
+      throws URISyntaxException {
+    return gson.toJson(
+        ProjectReplicationStatus.create(
+            ImmutableMap.of(
+                remoteUrl,
+                RemoteReplicationStatus.create(
+                    ImmutableMap.of(
+                        REF_MASTER, ReplicationStatus.create(replicationStatusResult, when)))),
+            projectReplicationStatusResult,
+            project.get()));
+  }
+}