diff --git a/.buckconfig b/.buckconfig
index 4c18a27..5c0ead0 100644
--- a/.buckconfig
+++ b/.buckconfig
@@ -1,13 +1,15 @@
 [alias]
-  evict-cache = //:evict-cache
-  plugin = //:evict-cache
-  src = //:evict-cache-sources
+  high-availability = //:high-availability
+  plugin = //:high-availability
+  src = //:high-availability-sources
 
 [java]
+  jar_spool_mode = direct_to_jar
   src_roots = java, resources
 
 [project]
-  ignore = .git
+  ignore = .git, eclipse-out/
+  parallel_parsing = true
 
 [cache]
   mode = dir
diff --git a/.gitignore b/.gitignore
index b37f9a6..c27e17f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,4 @@
-/.buckd
+/.buckd/
 /.buckversion
 /.classpath
 /.project
@@ -6,4 +6,4 @@
 /.watchmanconfig
 /buck-out/
 /bucklets
-/eclipse-out
+/eclipse-out/
diff --git a/BUCK b/BUCK
index acdb2af..dcbf446 100644
--- a/BUCK
+++ b/BUCK
@@ -5,38 +5,30 @@
 SOURCES = glob(['src/main/java/**/*.java'])
 RESOURCES = glob(['src/main/resources/**/*'])
 
-DEPS = [
+TEST_DEPS = GERRIT_PLUGIN_API + GERRIT_TESTS + [
+  ':high-availability__plugin',
+  ':mockito',
   ':wiremock',
 ]
 
-PROVIDED_DEPS = GERRIT_TESTS + [
-  '//lib:gson',
-]
-
-TEST_DEPS = GERRIT_PLUGIN_API + PROVIDED_DEPS + DEPS + [
-  ':evict-cache__plugin',
-  ':mockito',
-]
-
 gerrit_plugin(
-  name = 'evict-cache',
+  name = 'high-availability',
   srcs = SOURCES,
   resources = RESOURCES,
   manifest_entries = [
-    'Gerrit-PluginName: evict-cache',
+    'Gerrit-PluginName: high-availability',
     'Gerrit-ApiType: plugin',
-    'Gerrit-Module: com.ericsson.gerrit.plugins.evictcache.Module',
-    'Gerrit-HttpModule: com.ericsson.gerrit.plugins.evictcache.HttpModule',
-    'Implementation-Title: evict-cache plugin',
-    'Implementation-URL: https://gerrit-review.googlesource.com/#/admin/projects/plugins/evict-cache',
+    'Gerrit-Module: com.ericsson.gerrit.plugins.highavailability.Module',
+    'Gerrit-HttpModule: com.ericsson.gerrit.plugins.highavailability.HttpModule',
+    'Implementation-Title: high-availability plugin',
+    'Implementation-URL: https://gerrit-review.googlesource.com/#/admin/projects/plugins/high-availability',
     'Implementation-Vendor: Ericsson',
   ],
-  provided_deps = PROVIDED_DEPS,
-  deps = DEPS,
+  provided_deps = GERRIT_TESTS,
 )
 
 java_sources(
-  name = 'evict-cache-sources',
+  name = 'high-availability-sources',
   srcs = SOURCES + RESOURCES,
 )
 
@@ -46,9 +38,9 @@
 )
 
 java_test(
-  name = 'evict-cache_tests',
+  name = 'high-availability_tests',
   srcs = glob(['src/test/java/**/*.java']),
-  labels = ['evict-cache'],
+  labels = ['high-availability'],
   deps = TEST_DEPS,
 )
 
@@ -64,7 +56,7 @@
   name = 'mockito',
   id = 'org.mockito:mockito-core:2.5.0',
   sha1 = 'be28d46a52c7f2563580adeca350145e9ce916f8',
-  license = 'MIT',
+  license = 'DO_NOT_DISTRIBUTE',
   deps = [
     ':byte-buddy',
     ':objenesis',
diff --git a/lib/BUCK b/lib/BUCK
deleted file mode 100644
index 8892994..0000000
--- a/lib/BUCK
+++ /dev/null
@@ -1,8 +0,0 @@
-include_defs('//bucklets/maven_jar.bucklet')
-
-maven_jar(
-  name = 'gson',
-  id = 'com.google.code.gson:gson:2.1',
-  sha1 = '2e66da15851f9f5b5079228f856c2f090ba98c38',
-  license = 'Apache2.0',
-)
diff --git a/lib/gerrit/BUCK b/lib/gerrit/BUCK
index f6c68a4..8a21820 100644
--- a/lib/gerrit/BUCK
+++ b/lib/gerrit/BUCK
@@ -1,21 +1,21 @@
 include_defs('//bucklets/maven_jar.bucklet')
 
-VER = '2.13.3'
+VER = '2.13.6'
 REPO = MAVEN_CENTRAL
 
 maven_jar(
-  name = 'plugin-api',
-  id = 'com.google.gerrit:gerrit-plugin-api:' + VER,
-  sha1 = '78df190269b0d5a4bc4f61ab3a66a49252b779eb',
+  name = 'acceptance-framework',
+  id = 'com.google.gerrit:gerrit-acceptance-framework:' + VER,
+  sha1 = '53a5ffbc3ce6842b7145fd11abcc1dc8503b124f',
   license = 'Apache2.0',
   attach_source = False,
   repository = REPO,
 )
 
 maven_jar(
-  name = 'acceptance-framework',
-  id = 'com.google.gerrit:gerrit-acceptance-framework:' + VER,
-  sha1 = '76eceefa7e31c6945513c36c4d106066d1df3e63',
+  name = 'plugin-api',
+  id = 'com.google.gerrit:gerrit-plugin-api:' + VER,
+  sha1 = '1a5d650c72ebc36f4ad522d5481d5ed690bec8bf',
   license = 'Apache2.0',
   attach_source = False,
   repository = REPO,
diff --git a/src/main/java/com/ericsson/gerrit/plugins/evictcache/Configuration.java b/src/main/java/com/ericsson/gerrit/plugins/evictcache/Configuration.java
deleted file mode 100644
index e342f88..0000000
--- a/src/main/java/com/ericsson/gerrit/plugins/evictcache/Configuration.java
+++ /dev/null
@@ -1,86 +0,0 @@
-// Copyright (C) 2015 Ericsson
-//
-// 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.ericsson.gerrit.plugins.evictcache;
-
-import com.google.common.base.CharMatcher;
-import com.google.common.base.Strings;
-import com.google.gerrit.extensions.annotations.PluginName;
-import com.google.gerrit.server.config.PluginConfig;
-import com.google.gerrit.server.config.PluginConfigFactory;
-import com.google.inject.Inject;
-import com.google.inject.Singleton;
-
-@Singleton
-class Configuration {
-  private static final int DEFAULT_TIMEOUT_MS = 5000;
-  private static final int DEFAULT_MAX_TRIES = 5;
-  private static final int DEFAULT_RETRY_INTERVAL = 1000;
-  private static final int DEFAULT_THREAD_POOL_SIZE = 1;
-
-  private final String url;
-  private final String user;
-  private final String password;
-  private final int connectionTimeout;
-  private final int socketTimeout;
-  private final int maxTries;
-  private final int retryInterval;
-  private final int threadPoolSize;
-
-  @Inject
-  Configuration(PluginConfigFactory config,
-      @PluginName String pluginName) {
-    PluginConfig cfg = config.getFromGerritConfig(pluginName, true);
-    url = Strings.nullToEmpty(cfg.getString("url"));
-    user = Strings.nullToEmpty(cfg.getString("user"));
-    password = Strings.nullToEmpty(cfg.getString("password"));
-    connectionTimeout = cfg.getInt("connectionTimeout", DEFAULT_TIMEOUT_MS);
-    socketTimeout = cfg.getInt("socketTimeout", DEFAULT_TIMEOUT_MS);
-    maxTries = cfg.getInt("maxTries", DEFAULT_MAX_TRIES);
-    retryInterval = cfg.getInt("retryInterval", DEFAULT_RETRY_INTERVAL);
-    threadPoolSize = cfg.getInt("threadPoolSize", DEFAULT_THREAD_POOL_SIZE);
-  }
-
-  int getConnectionTimeout() {
-    return connectionTimeout;
-  }
-
-  int getMaxTries() {
-    return maxTries;
-  }
-
-  int getRetryInterval() {
-    return retryInterval;
-  }
-
-  int getSocketTimeout() {
-    return socketTimeout;
-  }
-
-  String getUrl() {
-    return CharMatcher.is('/').trimTrailingFrom(url);
-  }
-
-  String getUser() {
-    return user;
-  }
-
-  String getPassword() {
-    return password;
-  }
-
-  int getThreadPoolSize() {
-    return threadPoolSize;
-  }
-}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheExecutor.java b/src/main/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheExecutor.java
deleted file mode 100644
index 8106f55..0000000
--- a/src/main/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheExecutor.java
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright (C) 2015 Ericsson
-//
-// 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.ericsson.gerrit.plugins.evictcache;
-
-import static java.lang.annotation.RetentionPolicy.RUNTIME;
-
-import com.google.inject.BindingAnnotation;
-
-import java.lang.annotation.Retention;
-
-@Retention(RUNTIME)
-@BindingAnnotation
-@interface EvictCacheExecutor {
-}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/evictcache/HttpSession.java b/src/main/java/com/ericsson/gerrit/plugins/evictcache/HttpSession.java
deleted file mode 100644
index 35fbd65..0000000
--- a/src/main/java/com/ericsson/gerrit/plugins/evictcache/HttpSession.java
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright (C) 2015 Ericsson
-//
-// 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.ericsson.gerrit.plugins.evictcache;
-
-import com.google.common.net.MediaType;
-import com.google.inject.Inject;
-
-import com.ericsson.gerrit.plugins.evictcache.CacheResponseHandler.CacheResult;
-
-import org.apache.http.client.methods.HttpPost;
-import org.apache.http.entity.StringEntity;
-import org.apache.http.impl.client.CloseableHttpClient;
-
-import java.io.IOException;
-
-class HttpSession {
-  private final CloseableHttpClient httpClient;
-  private final String url;
-
-  @Inject
-  HttpSession(CloseableHttpClient httpClient,
-      @SyncUrl String url) {
-    this.httpClient = httpClient;
-    this.url = url;
-  }
-
-  CacheResult post(String endpoint, String json) throws IOException {
-    HttpPost post = new HttpPost(url + endpoint);
-    StringEntity params = new StringEntity(json.trim());
-    post.addHeader("Content-Type", MediaType.JSON_UTF_8.toString());
-    post.addHeader("Accept", MediaType.JSON_UTF_8.toString());
-    post.setEntity(params);
-    return httpClient.execute(post, new CacheResponseHandler());
-  }
-}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/evictcache/Module.java b/src/main/java/com/ericsson/gerrit/plugins/evictcache/Module.java
deleted file mode 100644
index 28ba756..0000000
--- a/src/main/java/com/ericsson/gerrit/plugins/evictcache/Module.java
+++ /dev/null
@@ -1,49 +0,0 @@
-// Copyright (C) 2015 Ericsson
-//
-// 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.ericsson.gerrit.plugins.evictcache;
-
-import com.google.gerrit.extensions.registration.DynamicSet;
-import com.google.gerrit.lifecycle.LifecycleModule;
-import com.google.gerrit.server.cache.CacheRemovalListener;
-import com.google.inject.Provides;
-import com.google.inject.Scopes;
-
-import org.apache.http.impl.client.CloseableHttpClient;
-
-import java.util.concurrent.ScheduledThreadPoolExecutor;
-
-class Module extends LifecycleModule {
-
-  @Override
-  protected void configure() {
-    bind(CloseableHttpClient.class).toProvider(HttpClientProvider.class)
-        .in(Scopes.SINGLETON);
-    bind(Configuration.class);
-    bind(HttpSession.class);
-    bind(RestSession.class);
-    bind(ScheduledThreadPoolExecutor.class)
-        .annotatedWith(EvictCacheExecutor.class)
-        .toProvider(EvictCacheExecutorProvider.class);
-    listener().to(EvictCacheExecutorProvider.class);
-    DynamicSet.bind(binder(), CacheRemovalListener.class).to(
-        EvictCacheHandler.class);
-  }
-
-  @Provides
-  @SyncUrl
-  String syncUrl(Configuration config) {
-    return config.getUrl();
-  }
-}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/evictcache/RestSession.java b/src/main/java/com/ericsson/gerrit/plugins/evictcache/RestSession.java
deleted file mode 100644
index 1295ce2..0000000
--- a/src/main/java/com/ericsson/gerrit/plugins/evictcache/RestSession.java
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright (C) 2015 Ericsson
-//
-// 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.ericsson.gerrit.plugins.evictcache;
-
-import com.google.common.base.Joiner;
-import com.google.gerrit.extensions.annotations.PluginName;
-import com.google.inject.Inject;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.IOException;
-
-class RestSession {
-  private static final Logger log = LoggerFactory.getLogger(RestSession.class);
-  private static final String EVICT = "evict";
-  private final HttpSession httpSession;
-  private final String pluginName;
-
-  @Inject
-  RestSession(HttpSession httpClient,
-      @PluginName String pluginName) {
-    this.httpSession = httpClient;
-    this.pluginName = pluginName;
-  }
-
-  boolean evict(String sourceName, String cacheName, Object key) {
-    try {
-      String json = GsonParser.toJson(cacheName, key);
-      String buildEndpoint = buildEndpoint(pluginName, sourceName, cacheName);
-      return httpSession
-          .post(buildEndpoint, json)
-          .isSuccessful();
-    } catch (IOException e) {
-      log.error("Error trying to evict for cache " + cacheName, e);
-      return false;
-    }
-  }
-
-  private String buildEndpoint(String pluginName, String sourceName,
-      String cacheName) {
-    return Joiner.on("/").join("/plugins", pluginName, sourceName, EVICT, cacheName);
-  }
-}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/highavailability/Configuration.java b/src/main/java/com/ericsson/gerrit/plugins/highavailability/Configuration.java
new file mode 100644
index 0000000..13f202d
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/highavailability/Configuration.java
@@ -0,0 +1,116 @@
+// Copyright (C) 2015 Ericsson
+//
+// 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.ericsson.gerrit.plugins.highavailability;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.CharMatcher;
+import com.google.common.base.Strings;
+import com.google.gerrit.extensions.annotations.PluginName;
+import com.google.gerrit.server.config.PluginConfig;
+import com.google.gerrit.server.config.PluginConfigFactory;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+
+@Singleton
+public class Configuration {
+  private static final Logger log = LoggerFactory.getLogger(Configuration.class);
+
+  private static final int DEFAULT_TIMEOUT_MS = 5000;
+  private static final int DEFAULT_MAX_TRIES = 5;
+  private static final int DEFAULT_RETRY_INTERVAL = 1000;
+  private static final int DEFAULT_THREAD_POOL_SIZE = 1;
+
+  private final String url;
+  private final String user;
+  private final String password;
+  private final int connectionTimeout;
+  private final int socketTimeout;
+  private final int maxTries;
+  private final int retryInterval;
+  private final int indexThreadPoolSize;
+  private final int eventThreadPoolSize;
+  private final int cacheThreadPoolSize;
+
+  @Inject
+  Configuration(PluginConfigFactory config,
+      @PluginName String pluginName) {
+    PluginConfig cfg = config.getFromGerritConfig(pluginName, true);
+    url = Strings.nullToEmpty(cfg.getString("url"));
+    user = Strings.nullToEmpty(cfg.getString("user"));
+    password = Strings.nullToEmpty(cfg.getString("password"));
+    connectionTimeout = getInt(cfg, "connectionTimeout", DEFAULT_TIMEOUT_MS);
+    socketTimeout = getInt(cfg, "socketTimeout", DEFAULT_TIMEOUT_MS);
+    maxTries = getInt(cfg, "maxTries", DEFAULT_MAX_TRIES);
+    retryInterval = getInt(cfg, "retryInterval", DEFAULT_RETRY_INTERVAL);
+    indexThreadPoolSize =
+        getInt(cfg, "indexThreadPoolSize", DEFAULT_THREAD_POOL_SIZE);
+    eventThreadPoolSize =
+        getInt(cfg, "eventThreadPoolSize", DEFAULT_THREAD_POOL_SIZE);
+    cacheThreadPoolSize =
+        getInt(cfg, "cacheThreadPoolSize", DEFAULT_THREAD_POOL_SIZE);
+  }
+
+  private int getInt(PluginConfig cfg, String name, int defaultValue) {
+    try {
+      return cfg.getInt(name, defaultValue);
+    } catch (IllegalArgumentException e) {
+      log.error(String.format(
+          "invalid value for %s; using default value %d", name, defaultValue));
+      return defaultValue;
+    }
+  }
+
+  public int getConnectionTimeout() {
+    return connectionTimeout;
+  }
+
+  public int getMaxTries() {
+    return maxTries;
+  }
+
+  public int getRetryInterval() {
+    return retryInterval;
+  }
+
+  public int getSocketTimeout() {
+    return socketTimeout;
+  }
+
+  public String getUrl() {
+    return CharMatcher.is('/').trimTrailingFrom(url);
+  }
+
+  public String getUser() {
+    return user;
+  }
+
+  public String getPassword() {
+    return password;
+  }
+
+  public int getIndexThreadPoolSize() {
+    return indexThreadPoolSize;
+  }
+
+  public int getEventThreadPoolSize() {
+    return eventThreadPoolSize;
+  }
+
+  public int getCacheThreadPoolSize() {
+    return cacheThreadPoolSize;
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/evictcache/HttpModule.java b/src/main/java/com/ericsson/gerrit/plugins/highavailability/HttpModule.java
similarity index 78%
rename from src/main/java/com/ericsson/gerrit/plugins/evictcache/HttpModule.java
rename to src/main/java/com/ericsson/gerrit/plugins/highavailability/HttpModule.java
index 27cf205..4a83e92 100644
--- a/src/main/java/com/ericsson/gerrit/plugins/evictcache/HttpModule.java
+++ b/src/main/java/com/ericsson/gerrit/plugins/highavailability/HttpModule.java
@@ -12,13 +12,15 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package com.ericsson.gerrit.plugins.evictcache;
+package com.ericsson.gerrit.plugins.highavailability;
 
 import com.google.gerrit.httpd.plugins.HttpPluginModule;
 
+import com.ericsson.gerrit.plugins.highavailability.forwarder.rest.RestForwarderServletModule;
+
 class HttpModule extends HttpPluginModule {
   @Override
   protected void configureServlets() {
-    serve("/gerrit/evict/*").with(EvictCacheRestApiServlet.class);
+    install(new RestForwarderServletModule());
   }
 }
diff --git a/src/main/java/com/ericsson/gerrit/plugins/highavailability/Module.java b/src/main/java/com/ericsson/gerrit/plugins/highavailability/Module.java
new file mode 100644
index 0000000..8481974
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/highavailability/Module.java
@@ -0,0 +1,35 @@
+// Copyright (C) 2015 Ericsson
+//
+// 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.ericsson.gerrit.plugins.highavailability;
+
+import com.google.gerrit.lifecycle.LifecycleModule;
+import com.google.inject.Scopes;
+
+import com.ericsson.gerrit.plugins.highavailability.cache.CacheModule;
+import com.ericsson.gerrit.plugins.highavailability.event.EventModule;
+import com.ericsson.gerrit.plugins.highavailability.forwarder.rest.RestForwarderModule;
+import com.ericsson.gerrit.plugins.highavailability.index.IndexModule;
+
+class Module extends LifecycleModule {
+
+  @Override
+  protected void configure() {
+    bind(Configuration.class).in(Scopes.SINGLETON);
+    install(new RestForwarderModule());
+    install(new EventModule());
+    install(new IndexModule());
+    install(new CacheModule());
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheHandler.java b/src/main/java/com/ericsson/gerrit/plugins/highavailability/cache/CacheEvictionHandler.java
similarity index 71%
rename from src/main/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheHandler.java
rename to src/main/java/com/ericsson/gerrit/plugins/highavailability/cache/CacheEvictionHandler.java
index fe8dc3a..89229fc 100644
--- a/src/main/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheHandler.java
+++ b/src/main/java/com/ericsson/gerrit/plugins/highavailability/cache/CacheEvictionHandler.java
@@ -12,24 +12,27 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package com.ericsson.gerrit.plugins.evictcache;
+package com.ericsson.gerrit.plugins.highavailability.cache;
 
 import com.google.common.cache.RemovalNotification;
 import com.google.gerrit.server.cache.CacheRemovalListener;
 import com.google.inject.Inject;
 
+import com.ericsson.gerrit.plugins.highavailability.forwarder.Context;
+import com.ericsson.gerrit.plugins.highavailability.forwarder.Forwarder;
+
 import java.util.concurrent.ScheduledThreadPoolExecutor;
 import java.util.regex.Pattern;
 
-class EvictCacheHandler<K, V> implements CacheRemovalListener<K, V> {
+class CacheEvictionHandler<K, V> implements CacheRemovalListener<K, V> {
   private final ScheduledThreadPoolExecutor executor;
-  private final RestSession restSession;
+  private final Forwarder forwarder;
   private final Pattern pattern;
 
   @Inject
-  EvictCacheHandler(RestSession restSession,
-      @EvictCacheExecutor ScheduledThreadPoolExecutor executor) {
-    this.restSession = restSession;
+  CacheEvictionHandler(Forwarder forwarder,
+      @CacheExecutor ScheduledThreadPoolExecutor executor) {
+    this.forwarder = forwarder;
     this.executor = executor;
     pattern = Pattern.compile(
         "^accounts.*|^groups.*|ldap_groups|ldap_usernames|^project.*|sshkeys|web_sessions");
@@ -40,8 +43,7 @@
       RemovalNotification<K, V> notification) {
     if (!Context.isForwardedEvent() && !notification.wasEvicted()
         && isSynchronized(cacheName)) {
-      executor.execute(
-          new EvictCacheTask(pluginName, cacheName, notification.getKey()));
+      executor.execute(new CacheEvictionTask(cacheName, notification.getKey()));
     }
   }
 
@@ -49,20 +51,18 @@
     return pattern.matcher(cacheName).matches();
   }
 
-  class EvictCacheTask implements Runnable {
-    private String pluginName;
+  class CacheEvictionTask implements Runnable {
     private String cacheName;
     private Object key;
 
-    EvictCacheTask(String pluginName, String cacheName, Object key) {
-      this.pluginName = pluginName;
+    CacheEvictionTask(String cacheName, Object key) {
       this.cacheName = cacheName;
       this.key = key;
     }
 
     @Override
     public void run() {
-      restSession.evict(pluginName, cacheName, key);
+      forwarder.evict(cacheName, key);
     }
 
     @Override
diff --git a/src/main/java/com/ericsson/gerrit/plugins/evictcache/SyncUrl.java b/src/main/java/com/ericsson/gerrit/plugins/highavailability/cache/CacheExecutor.java
similarity index 89%
copy from src/main/java/com/ericsson/gerrit/plugins/evictcache/SyncUrl.java
copy to src/main/java/com/ericsson/gerrit/plugins/highavailability/cache/CacheExecutor.java
index 14c2880..bd3dd40 100644
--- a/src/main/java/com/ericsson/gerrit/plugins/evictcache/SyncUrl.java
+++ b/src/main/java/com/ericsson/gerrit/plugins/highavailability/cache/CacheExecutor.java
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package com.ericsson.gerrit.plugins.evictcache;
+package com.ericsson.gerrit.plugins.highavailability.cache;
 
 import static java.lang.annotation.RetentionPolicy.RUNTIME;
 
@@ -22,5 +22,5 @@
 
 @Retention(RUNTIME)
 @BindingAnnotation
-@interface SyncUrl {
+@interface CacheExecutor {
 }
diff --git a/src/main/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheExecutorProvider.java b/src/main/java/com/ericsson/gerrit/plugins/highavailability/cache/CacheExecutorProvider.java
similarity index 78%
copy from src/main/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheExecutorProvider.java
copy to src/main/java/com/ericsson/gerrit/plugins/highavailability/cache/CacheExecutorProvider.java
index e1de403..c427d17 100644
--- a/src/main/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheExecutorProvider.java
+++ b/src/main/java/com/ericsson/gerrit/plugins/highavailability/cache/CacheExecutorProvider.java
@@ -12,28 +12,28 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package com.ericsson.gerrit.plugins.evictcache;
+package com.ericsson.gerrit.plugins.highavailability.cache;
 
-import com.google.gerrit.extensions.annotations.PluginName;
 import com.google.gerrit.extensions.events.LifecycleListener;
 import com.google.gerrit.server.git.WorkQueue;
 import com.google.inject.Inject;
 import com.google.inject.Provider;
 import com.google.inject.Singleton;
 
+import com.ericsson.gerrit.plugins.highavailability.Configuration;
+
 import java.util.concurrent.ScheduledThreadPoolExecutor;
 
 @Singleton
-class EvictCacheExecutorProvider
+class CacheExecutorProvider
     implements Provider<ScheduledThreadPoolExecutor>, LifecycleListener {
   private WorkQueue.Executor executor;
 
   @Inject
-  EvictCacheExecutorProvider(WorkQueue workQueue,
-      @PluginName String pluginName,
+  CacheExecutorProvider(WorkQueue workQueue,
       Configuration config) {
-    executor = workQueue.createQueue(config.getThreadPoolSize(),
-        "Evict cache [" + pluginName + " plugin]");
+    executor = workQueue.createQueue(config.getCacheThreadPoolSize(),
+        "Forward-cache-eviction-event");
   }
 
   @Override
diff --git a/src/main/java/com/ericsson/gerrit/plugins/highavailability/cache/CacheModule.java b/src/main/java/com/ericsson/gerrit/plugins/highavailability/cache/CacheModule.java
new file mode 100644
index 0000000..671264b
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/highavailability/cache/CacheModule.java
@@ -0,0 +1,34 @@
+// Copyright (C) 2015 Ericsson
+//
+// 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.ericsson.gerrit.plugins.highavailability.cache;
+
+import com.google.gerrit.extensions.registration.DynamicSet;
+import com.google.gerrit.lifecycle.LifecycleModule;
+import com.google.gerrit.server.cache.CacheRemovalListener;
+
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+
+public class CacheModule extends LifecycleModule {
+
+  @Override
+  protected void configure() {
+    bind(ScheduledThreadPoolExecutor.class)
+        .annotatedWith(CacheExecutor.class)
+        .toProvider(CacheExecutorProvider.class);
+    listener().to(CacheExecutorProvider.class);
+    DynamicSet.bind(binder(), CacheRemovalListener.class).to(
+        CacheEvictionHandler.class);
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/highavailability/cache/Constants.java b/src/main/java/com/ericsson/gerrit/plugins/highavailability/cache/Constants.java
new file mode 100644
index 0000000..12f92bd
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/highavailability/cache/Constants.java
@@ -0,0 +1,28 @@
+// Copyright (C) 2015 Ericsson
+//
+// 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.ericsson.gerrit.plugins.highavailability.cache;
+
+public final class Constants {
+
+  public static final String PROJECT_LIST = "project_list";
+  public static final String ACCOUNTS = "accounts";
+  public static final String GROUPS = "groups";
+  public static final String GROUPS_BYINCLUDE = "groups_byinclude";
+  public static final String GROUPS_MEMBERS = "groups_members";
+  public static final String PROJECTS = "projects";
+
+  private Constants() {
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/evictcache/SyncUrl.java b/src/main/java/com/ericsson/gerrit/plugins/highavailability/event/EventExecutor.java
similarity index 89%
rename from src/main/java/com/ericsson/gerrit/plugins/evictcache/SyncUrl.java
rename to src/main/java/com/ericsson/gerrit/plugins/highavailability/event/EventExecutor.java
index 14c2880..b204220 100644
--- a/src/main/java/com/ericsson/gerrit/plugins/evictcache/SyncUrl.java
+++ b/src/main/java/com/ericsson/gerrit/plugins/highavailability/event/EventExecutor.java
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package com.ericsson.gerrit.plugins.evictcache;
+package com.ericsson.gerrit.plugins.highavailability.event;
 
 import static java.lang.annotation.RetentionPolicy.RUNTIME;
 
@@ -22,5 +22,5 @@
 
 @Retention(RUNTIME)
 @BindingAnnotation
-@interface SyncUrl {
+@interface EventExecutor {
 }
diff --git a/src/main/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheExecutorProvider.java b/src/main/java/com/ericsson/gerrit/plugins/highavailability/event/EventExecutorProvider.java
similarity index 78%
rename from src/main/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheExecutorProvider.java
rename to src/main/java/com/ericsson/gerrit/plugins/highavailability/event/EventExecutorProvider.java
index e1de403..6a6c3c3 100644
--- a/src/main/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheExecutorProvider.java
+++ b/src/main/java/com/ericsson/gerrit/plugins/highavailability/event/EventExecutorProvider.java
@@ -12,28 +12,28 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package com.ericsson.gerrit.plugins.evictcache;
+package com.ericsson.gerrit.plugins.highavailability.event;
 
-import com.google.gerrit.extensions.annotations.PluginName;
 import com.google.gerrit.extensions.events.LifecycleListener;
 import com.google.gerrit.server.git.WorkQueue;
 import com.google.inject.Inject;
 import com.google.inject.Provider;
 import com.google.inject.Singleton;
 
+import com.ericsson.gerrit.plugins.highavailability.Configuration;
+
 import java.util.concurrent.ScheduledThreadPoolExecutor;
 
 @Singleton
-class EvictCacheExecutorProvider
+class EventExecutorProvider
     implements Provider<ScheduledThreadPoolExecutor>, LifecycleListener {
   private WorkQueue.Executor executor;
 
   @Inject
-  EvictCacheExecutorProvider(WorkQueue workQueue,
-      @PluginName String pluginName,
+  EventExecutorProvider(WorkQueue workQueue,
       Configuration config) {
-    executor = workQueue.createQueue(config.getThreadPoolSize(),
-        "Evict cache [" + pluginName + " plugin]");
+    executor = workQueue.createQueue(config.getEventThreadPoolSize(),
+        "Forward-stream-event");
   }
 
   @Override
diff --git a/src/main/java/com/ericsson/gerrit/plugins/highavailability/event/EventHandler.java b/src/main/java/com/ericsson/gerrit/plugins/highavailability/event/EventHandler.java
new file mode 100644
index 0000000..c4716d3
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/highavailability/event/EventHandler.java
@@ -0,0 +1,67 @@
+// Copyright (C) 2015 Ericsson
+//
+// 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.ericsson.gerrit.plugins.highavailability.event;
+
+import com.google.gerrit.common.EventListener;
+import com.google.gerrit.extensions.annotations.PluginName;
+import com.google.gerrit.server.events.Event;
+import com.google.gerrit.server.events.ProjectEvent;
+import com.google.inject.Inject;
+
+import com.ericsson.gerrit.plugins.highavailability.forwarder.Context;
+import com.ericsson.gerrit.plugins.highavailability.forwarder.Forwarder;
+
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+
+class EventHandler implements EventListener {
+  private final ScheduledThreadPoolExecutor executor;
+  private final Forwarder forwarder;
+  private final String pluginName;
+
+  @Inject
+  EventHandler(Forwarder forwarder,
+      @EventExecutor ScheduledThreadPoolExecutor executor,
+      @PluginName String pluginName) {
+    this.forwarder = forwarder;
+    this.executor = executor;
+    this.pluginName = pluginName;
+  }
+
+  @Override
+  public void onEvent(Event event) {
+    if (!Context.isForwardedEvent() && event instanceof ProjectEvent) {
+      executor.execute(new EventTask(event));
+    }
+  }
+
+  class EventTask implements Runnable {
+    private Event event;
+
+    EventTask(Event event) {
+      this.event = event;
+    }
+
+    @Override
+    public void run() {
+      forwarder.send(event);
+    }
+
+    @Override
+    public String toString() {
+      return String.format("[%s] Send event '%s' to target instance",
+          pluginName, event.type);
+    }
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/highavailability/event/EventModule.java b/src/main/java/com/ericsson/gerrit/plugins/highavailability/event/EventModule.java
new file mode 100644
index 0000000..76b68f2
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/highavailability/event/EventModule.java
@@ -0,0 +1,36 @@
+// Copyright (C) 2015 Ericsson
+//
+// 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.ericsson.gerrit.plugins.highavailability.event;
+
+import com.google.gerrit.common.EventDispatcher;
+import com.google.gerrit.common.EventListener;
+import com.google.gerrit.extensions.registration.DynamicItem;
+import com.google.gerrit.extensions.registration.DynamicSet;
+import com.google.gerrit.lifecycle.LifecycleModule;
+
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+
+public class EventModule extends LifecycleModule {
+
+  @Override
+  protected void configure() {
+    bind(ScheduledThreadPoolExecutor.class)
+        .annotatedWith(EventExecutor.class)
+        .toProvider(EventExecutorProvider.class);
+    listener().to(EventExecutorProvider.class);
+    DynamicSet.bind(binder(), EventListener.class).to(EventHandler.class);
+    DynamicItem.bind(binder(), EventDispatcher.class).to(ForwardedAwareEventBroker.class);
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/highavailability/event/ForwardedAwareEventBroker.java b/src/main/java/com/ericsson/gerrit/plugins/highavailability/event/ForwardedAwareEventBroker.java
new file mode 100644
index 0000000..e099343
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/highavailability/event/ForwardedAwareEventBroker.java
@@ -0,0 +1,48 @@
+// Copyright (C) 2016 Ericsson
+//
+// 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.ericsson.gerrit.plugins.highavailability.event;
+
+import com.google.gerrit.common.EventBroker;
+import com.google.gerrit.common.EventListener;
+import com.google.gerrit.common.UserScopedEventListener;
+import com.google.gerrit.extensions.registration.DynamicSet;
+import com.google.gerrit.reviewdb.server.ReviewDb;
+import com.google.gerrit.server.events.Event;
+import com.google.gerrit.server.notedb.ChangeNotes.Factory;
+import com.google.gerrit.server.project.ProjectCache;
+import com.google.inject.Inject;
+import com.google.inject.Provider;
+
+import com.ericsson.gerrit.plugins.highavailability.forwarder.Context;
+
+class ForwardedAwareEventBroker extends EventBroker {
+
+  @Inject
+  ForwardedAwareEventBroker(DynamicSet<UserScopedEventListener> listeners,
+      DynamicSet<EventListener> unrestrictedListeners,
+      ProjectCache projectCache,
+      Factory notesFactory,
+      Provider<ReviewDb> dbProvider) {
+    super(listeners, unrestrictedListeners, projectCache, notesFactory,
+        dbProvider);
+  }
+
+  @Override
+  protected void fireEventForUnrestrictedListeners(Event event) {
+    if (!Context.isForwardedEvent()) {
+      super.fireEventForUnrestrictedListeners(event);
+    }
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/evictcache/Context.java b/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/Context.java
similarity index 78%
rename from src/main/java/com/ericsson/gerrit/plugins/evictcache/Context.java
rename to src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/Context.java
index 0b0519b..3651e73 100644
--- a/src/main/java/com/ericsson/gerrit/plugins/evictcache/Context.java
+++ b/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/Context.java
@@ -12,12 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package com.ericsson.gerrit.plugins.evictcache;
+package com.ericsson.gerrit.plugins.highavailability.forwarder;
 
 /**
  * Allows to tag a forwarded event to avoid infinitely looping events.
  */
-class Context {
+public class Context {
   private static final ThreadLocal<Boolean> FORWARDED_EVENT =
       new ThreadLocal<Boolean>() {
         @Override
@@ -29,15 +29,15 @@
   private Context() {
   }
 
-  static Boolean isForwardedEvent() {
+  public static Boolean isForwardedEvent() {
     return FORWARDED_EVENT.get();
   }
 
-  static void setForwardedEvent() {
-    FORWARDED_EVENT.set(true);
+  public static void setForwardedEvent(Boolean b) {
+    FORWARDED_EVENT.set(b);
   }
 
-  static void unsetForwardedEvent() {
+  public static void unsetForwardedEvent() {
     FORWARDED_EVENT.remove();
   }
 }
diff --git a/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/Forwarder.java b/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/Forwarder.java
new file mode 100644
index 0000000..0d1a0bb
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/Forwarder.java
@@ -0,0 +1,56 @@
+// Copyright (C) 2017 Ericsson
+//
+// 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.ericsson.gerrit.plugins.highavailability.forwarder;
+
+import com.google.gerrit.server.events.Event;
+
+/**
+ * Forward indexing, stream events and cache evictions to the other master
+ */
+public interface Forwarder {
+
+  /**
+   * Forward a change indexing event to the other master.
+   *
+   * @param changeId the change to index.
+   * @return true if successful, otherwise false.
+   */
+  boolean indexChange(int changeId);
+
+  /**
+   * Forward a delete change from index event to the other master.
+   *
+   * @param changeId the change to remove from the index.
+   * @return rue if successful, otherwise false.
+   */
+  boolean deleteChangeFromIndex(int changeId);
+
+  /**
+   * Forward a stream event to the other master.
+   *
+   * @param event the event to forward.
+   * @return true if successful, otherwise false.
+   */
+  boolean send(Event event);
+
+  /**
+   * Forward a cache eviction event to the other master.
+   *
+   * @param cacheName the name of the cache to evict an entry from.
+   * @param key the key identifying the entry to evict from the cache.
+   * @return true if successful, otherwise false.
+   */
+  boolean evict(String cacheName, Object key);
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheRestApiServlet.java b/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/CacheRestApiServlet.java
similarity index 82%
rename from src/main/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheRestApiServlet.java
rename to src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/CacheRestApiServlet.java
index bb4f0ba..ed5e593 100644
--- a/src/main/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheRestApiServlet.java
+++ b/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/CacheRestApiServlet.java
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package com.ericsson.gerrit.plugins.evictcache;
+package com.ericsson.gerrit.plugins.highavailability.forwarder.rest;
 
 import static javax.servlet.http.HttpServletResponse.SC_BAD_REQUEST;
 import static javax.servlet.http.HttpServletResponse.SC_NO_CONTENT;
@@ -23,6 +23,9 @@
 import com.google.inject.Inject;
 import com.google.inject.Singleton;
 
+import com.ericsson.gerrit.plugins.highavailability.cache.Constants;
+import com.ericsson.gerrit.plugins.highavailability.forwarder.Context;
+
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -35,18 +38,17 @@
 import javax.servlet.http.HttpServletResponse;
 
 @Singleton
-class EvictCacheRestApiServlet extends HttpServlet {
+class CacheRestApiServlet extends HttpServlet {
   private static final int CACHENAME_INDEX = 1;
   private static final long serialVersionUID = -1L;
-  private static final String SOURCE_NAME = "gerrit";
-  private static final String PROJECT_LIST = "project_list";
+  private static final String GERRIT = "gerrit";
   private static final Logger logger =
-      LoggerFactory.getLogger(EvictCacheRestApiServlet.class);
+      LoggerFactory.getLogger(CacheRestApiServlet.class);
 
   private final DynamicMap<Cache<?, ?>> cacheMap;
 
   @Inject
-  EvictCacheRestApiServlet(DynamicMap<Cache<?, ?>> cacheMap) {
+  CacheRestApiServlet(DynamicMap<Cache<?, ?>> cacheMap) {
     this.cacheMap = cacheMap;
   }
 
@@ -60,8 +62,8 @@
       String cacheName = params.get(CACHENAME_INDEX);
       String json = req.getReader().readLine();
       Object key = GsonParser.fromJson(cacheName, json);
-      Cache<?, ?> cache = cacheMap.get(SOURCE_NAME, cacheName);
-      Context.setForwardedEvent();
+      Cache<?, ?> cache = cacheMap.get(GERRIT, cacheName);
+      Context.setForwardedEvent(true);
       evictCache(cache, cacheName, key);
       rsp.setStatus(SC_NO_CONTENT);
     } catch (IOException e) {
@@ -82,7 +84,7 @@
   }
 
   private void evictCache(Cache<?, ?> cache, String cacheName, Object key) {
-    if (PROJECT_LIST.equals(cacheName)) {
+    if (Constants.PROJECT_LIST.equals(cacheName)) {
       // One key is holding the list of projects
       cache.invalidateAll();
     } else {
diff --git a/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/EventRestApiServlet.java b/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/EventRestApiServlet.java
new file mode 100644
index 0000000..eb8e53e
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/EventRestApiServlet.java
@@ -0,0 +1,104 @@
+// Copyright (C) 2015 Ericsson
+//
+// 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.ericsson.gerrit.plugins.highavailability.forwarder.rest;
+
+import static com.google.common.net.MediaType.JSON_UTF_8;
+import static javax.servlet.http.HttpServletResponse.SC_BAD_REQUEST;
+import static javax.servlet.http.HttpServletResponse.SC_NOT_FOUND;
+import static javax.servlet.http.HttpServletResponse.SC_NO_CONTENT;
+import static javax.servlet.http.HttpServletResponse.SC_UNSUPPORTED_MEDIA_TYPE;
+
+import com.google.common.base.Supplier;
+import com.google.common.io.CharStreams;
+import com.google.common.net.MediaType;
+import com.google.gerrit.common.EventDispatcher;
+import com.google.gerrit.server.events.Event;
+import com.google.gerrit.server.events.EventDeserializer;
+import com.google.gerrit.server.events.SupplierDeserializer;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gwtorm.server.OrmException;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+
+import com.ericsson.gerrit.plugins.highavailability.forwarder.Context;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@Singleton
+class EventRestApiServlet extends HttpServlet {
+  private static final long serialVersionUID = -1L;
+  private static final Logger logger = LoggerFactory
+      .getLogger(EventRestApiServlet.class);
+
+  private final EventDispatcher dispatcher;
+
+  @Inject
+  EventRestApiServlet(EventDispatcher dispatcher) {
+    this.dispatcher = dispatcher;
+  }
+
+  @Override
+  protected void doPost(HttpServletRequest req, HttpServletResponse rsp)
+      throws IOException, ServletException {
+    rsp.setContentType("text/plain");
+    rsp.setCharacterEncoding("UTF-8");
+    try {
+      Context.setForwardedEvent(true);
+      if (!MediaType.parse(req.getContentType()).is(JSON_UTF_8)) {
+        sendError(rsp, SC_UNSUPPORTED_MEDIA_TYPE,
+            "Expecting " + JSON_UTF_8.toString() + " content type");
+        return;
+      }
+      Event event = getEventFromRequest(req);
+      dispatcher.postEvent(event);
+      rsp.setStatus(SC_NO_CONTENT);
+    } catch (OrmException e) {
+      logger.debug("Error trying to find a change ", e);
+      sendError(rsp, SC_NOT_FOUND, "Change not found\n");
+    } catch (IOException e) {
+      logger.error("Unable to re-trigger event", e);
+      sendError(rsp, SC_BAD_REQUEST, e.getMessage());
+    } finally {
+      Context.unsetForwardedEvent();
+    }
+  }
+
+  private Event getEventFromRequest(HttpServletRequest req) throws IOException {
+    String jsonEvent = CharStreams.toString(req.getReader());
+    Gson gson = new GsonBuilder()
+        .registerTypeAdapter(Event.class, new EventDeserializer())
+        .registerTypeAdapter(Supplier.class, new SupplierDeserializer())
+        .create();
+    return gson.fromJson(jsonEvent, Event.class);
+  }
+
+  private static void sendError(HttpServletResponse rsp, int statusCode,
+      String message) {
+    try {
+      rsp.sendError(statusCode, message);
+    } catch (IOException e) {
+      logger.error("Failed to send error messsage: " + e.getMessage(), e);
+    }
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/evictcache/SyncUrl.java b/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/ForwardUrl.java
similarity index 88%
copy from src/main/java/com/ericsson/gerrit/plugins/evictcache/SyncUrl.java
copy to src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/ForwardUrl.java
index 14c2880..72ab757 100644
--- a/src/main/java/com/ericsson/gerrit/plugins/evictcache/SyncUrl.java
+++ b/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/ForwardUrl.java
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package com.ericsson.gerrit.plugins.evictcache;
+package com.ericsson.gerrit.plugins.highavailability.forwarder.rest;
 
 import static java.lang.annotation.RetentionPolicy.RUNTIME;
 
@@ -22,5 +22,5 @@
 
 @Retention(RUNTIME)
 @BindingAnnotation
-@interface SyncUrl {
+@interface ForwardUrl {
 }
diff --git a/src/main/java/com/ericsson/gerrit/plugins/evictcache/GsonParser.java b/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/GsonParser.java
similarity index 77%
rename from src/main/java/com/ericsson/gerrit/plugins/evictcache/GsonParser.java
rename to src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/GsonParser.java
index d752c06..650bc28 100644
--- a/src/main/java/com/ericsson/gerrit/plugins/evictcache/GsonParser.java
+++ b/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/GsonParser.java
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package com.ericsson.gerrit.plugins.evictcache;
+package com.ericsson.gerrit.plugins.highavailability.forwarder.rest;
 
 import com.google.common.base.Strings;
 import com.google.gerrit.reviewdb.client.Account;
@@ -20,12 +20,9 @@
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 
+import com.ericsson.gerrit.plugins.highavailability.cache.Constants;
+
 final class GsonParser {
-  private static final String ACCOUNTS = "accounts";
-  private static final String GROUPS = "groups";
-  private static final String GROUPS_BYINCLUDE = "groups_byinclude";
-  private static final String GROUPS_MEMBERS = "groups_members";
-  private static final String PROJECT_LIST = "project_list";
 
   private GsonParser() {
   }
@@ -35,19 +32,19 @@
     Object key;
     // Need to add a case for 'adv_bases'
     switch (cacheName) {
-      case ACCOUNTS:
+      case Constants.ACCOUNTS:
         key = gson.fromJson(Strings.nullToEmpty(json).trim(), Account.Id.class);
         break;
-      case GROUPS:
+      case Constants.GROUPS:
         key = gson.fromJson(Strings.nullToEmpty(json).trim(),
             AccountGroup.Id.class);
         break;
-      case GROUPS_BYINCLUDE:
-      case GROUPS_MEMBERS:
+      case Constants.GROUPS_BYINCLUDE:
+      case Constants.GROUPS_MEMBERS:
         key = gson.fromJson(Strings.nullToEmpty(json).trim(),
             AccountGroup.UUID.class);
         break;
-      case PROJECT_LIST:
+      case Constants.PROJECT_LIST:
         key = gson.fromJson(Strings.nullToEmpty(json), Object.class);
         break;
       default:
@@ -61,17 +58,17 @@
     String json;
     // Need to add a case for 'adv_bases'
     switch (cacheName) {
-      case ACCOUNTS:
+      case Constants.ACCOUNTS:
         json = gson.toJson(key, Account.Id.class);
         break;
-      case GROUPS:
+      case Constants.GROUPS:
         json = gson.toJson(key, AccountGroup.Id.class);
         break;
-      case GROUPS_BYINCLUDE:
-      case GROUPS_MEMBERS:
+      case Constants.GROUPS_BYINCLUDE:
+      case Constants.GROUPS_MEMBERS:
         json = gson.toJson(key, AccountGroup.UUID.class);
         break;
-      case PROJECT_LIST:
+      case Constants.PROJECT_LIST:
       default:
         json = gson.toJson(key);
     }
diff --git a/src/main/java/com/ericsson/gerrit/plugins/evictcache/HttpClientProvider.java b/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/HttpClientProvider.java
similarity index 91%
rename from src/main/java/com/ericsson/gerrit/plugins/evictcache/HttpClientProvider.java
rename to src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/HttpClientProvider.java
index df42800..7e4eb28 100644
--- a/src/main/java/com/ericsson/gerrit/plugins/evictcache/HttpClientProvider.java
+++ b/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/HttpClientProvider.java
@@ -12,11 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package com.ericsson.gerrit.plugins.evictcache;
+package com.ericsson.gerrit.plugins.highavailability.forwarder.rest;
 
 import com.google.inject.Inject;
 import com.google.inject.Provider;
-import com.google.inject.Singleton;
+
+import com.ericsson.gerrit.plugins.highavailability.Configuration;
 
 import org.apache.http.HttpResponse;
 import org.apache.http.auth.AuthScope;
@@ -29,6 +30,7 @@
 import org.apache.http.conn.HttpClientConnectionManager;
 import org.apache.http.conn.socket.ConnectionSocketFactory;
 import org.apache.http.conn.socket.PlainConnectionSocketFactory;
+import org.apache.http.conn.ssl.NoopHostnameVerifier;
 import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
 import org.apache.http.impl.client.BasicCredentialsProvider;
 import org.apache.http.impl.client.CloseableHttpClient;
@@ -44,26 +46,22 @@
 import java.security.NoSuchAlgorithmException;
 import java.security.cert.X509Certificate;
 
-import javax.net.ssl.HostnameVerifier;
 import javax.net.ssl.SSLContext;
 import javax.net.ssl.SSLException;
-import javax.net.ssl.SSLSession;
 import javax.net.ssl.TrustManager;
 import javax.net.ssl.X509TrustManager;
 
 /**
  * Provides an HTTP client with SSL capabilities.
  */
-@Singleton
 class HttpClientProvider implements Provider<CloseableHttpClient> {
-  private static final Logger log =
-      LoggerFactory.getLogger(HttpClientProvider.class);
+  private static final Logger log = LoggerFactory
+      .getLogger(HttpClientProvider.class);
   private static final int CONNECTIONS_PER_ROUTE = 100;
   // Up to 2 target instances with the max number of connections per host:
   private static final int MAX_CONNECTIONS = 2 * CONNECTIONS_PER_ROUTE;
 
   private static final int ERROR_CODES = 500;
-
   private static final int MAX_CONNECTION_INACTIVITY = 10000;
 
   private final Configuration cfg;
@@ -138,7 +136,7 @@
   }
 
   private void logRetry(String cause) {
-    log.warn("Retrying request to '" + cfg.getUrl() + "' Cause: " + cause);
+    log.debug("Retrying request to '" + cfg.getUrl() + "' Cause: " + cause);
   }
 
   private HttpClientConnectionManager customConnectionManager() {
@@ -155,7 +153,7 @@
 
   private SSLConnectionSocketFactory buildSslSocketFactory() {
     return new SSLConnectionSocketFactory(buildSslContext(),
-        new DummyHostnameVerifier());
+        NoopHostnameVerifier.INSTANCE);
   }
 
   private SSLContext buildSslContext() {
@@ -195,12 +193,4 @@
       // no check
     }
   }
-
-  private static class DummyHostnameVerifier implements HostnameVerifier {
-    @Override
-    public boolean verify(String hostname, SSLSession session) {
-      // always accept
-      return true;
-    }
-  }
-}
\ No newline at end of file
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/evictcache/CacheResponseHandler.java b/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/HttpResponseHandler.java
similarity index 76%
rename from src/main/java/com/ericsson/gerrit/plugins/evictcache/CacheResponseHandler.java
rename to src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/HttpResponseHandler.java
index 768ee72..ad98f2e 100644
--- a/src/main/java/com/ericsson/gerrit/plugins/evictcache/CacheResponseHandler.java
+++ b/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/HttpResponseHandler.java
@@ -12,11 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package com.ericsson.gerrit.plugins.evictcache;
+package com.ericsson.gerrit.plugins.highavailability.forwarder.rest;
 
 import static javax.servlet.http.HttpServletResponse.SC_NO_CONTENT;
 
-import com.ericsson.gerrit.plugins.evictcache.CacheResponseHandler.CacheResult;
+import com.ericsson.gerrit.plugins.highavailability.forwarder.rest.HttpResponseHandler.HttpResult;
 
 import org.apache.http.HttpEntity;
 import org.apache.http.HttpResponse;
@@ -27,13 +27,13 @@
 
 import java.io.IOException;
 
-class CacheResponseHandler implements ResponseHandler<CacheResult> {
+class HttpResponseHandler implements ResponseHandler<HttpResult> {
 
-  static class CacheResult {
+  static class HttpResult {
     private boolean successful;
     private String message;
 
-    CacheResult(boolean successful, String message) {
+    HttpResult(boolean successful, String message) {
       this.successful = successful;
       this.message = message;
     }
@@ -48,11 +48,11 @@
   }
 
   private static final Logger log =
-      LoggerFactory.getLogger(CacheResponseHandler.class);
+      LoggerFactory.getLogger(HttpResponseHandler.class);
 
   @Override
-  public CacheResult handleResponse(HttpResponse response) {
-    return new CacheResult(isSuccessful(response), parseResponse(response));
+  public HttpResult handleResponse(HttpResponse response) {
+    return new HttpResult(isSuccessful(response), parseResponse(response));
   }
 
   private boolean isSuccessful(HttpResponse response) {
diff --git a/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/HttpSession.java b/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/HttpSession.java
new file mode 100644
index 0000000..574dd82
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/HttpSession.java
@@ -0,0 +1,59 @@
+// Copyright (C) 2015 Ericsson
+//
+// 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.ericsson.gerrit.plugins.highavailability.forwarder.rest;
+
+import com.google.common.base.Strings;
+import com.google.common.net.MediaType;
+import com.google.inject.Inject;
+
+import com.ericsson.gerrit.plugins.highavailability.forwarder.rest.HttpResponseHandler.HttpResult;
+
+import org.apache.http.client.methods.HttpDelete;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.entity.StringEntity;
+import org.apache.http.impl.client.CloseableHttpClient;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+
+class HttpSession {
+  private final CloseableHttpClient httpClient;
+  private final String url;
+
+  @Inject
+  HttpSession(CloseableHttpClient httpClient,
+      @ForwardUrl String url) {
+    this.httpClient = httpClient;
+    this.url = url;
+  }
+
+  HttpResult post(String endpoint) throws IOException {
+    return post(endpoint, null);
+  }
+
+  HttpResult post(String endpoint, String content) throws IOException {
+    HttpPost post = new HttpPost(url + endpoint);
+    if (!Strings.isNullOrEmpty(content)) {
+      post.addHeader("Content-Type", MediaType.JSON_UTF_8.toString());
+      post.setEntity(new StringEntity(content, StandardCharsets.UTF_8));
+    }
+    return httpClient.execute(post, new HttpResponseHandler());
+  }
+
+  HttpResult delete(String endpoint) throws IOException {
+    return httpClient.execute(new HttpDelete(url + endpoint),
+        new HttpResponseHandler());
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/IndexRestApiServlet.java b/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/IndexRestApiServlet.java
new file mode 100644
index 0000000..0a6761e
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/IndexRestApiServlet.java
@@ -0,0 +1,149 @@
+// Copyright (C) 2015 Ericsson
+//
+// 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.ericsson.gerrit.plugins.highavailability.forwarder.rest;
+
+import static javax.servlet.http.HttpServletResponse.SC_CONFLICT;
+import static javax.servlet.http.HttpServletResponse.SC_NOT_FOUND;
+import static javax.servlet.http.HttpServletResponse.SC_NO_CONTENT;
+
+import com.google.gerrit.reviewdb.client.Change;
+import com.google.gerrit.reviewdb.server.ReviewDb;
+import com.google.gerrit.server.index.change.ChangeIndexer;
+import com.google.gwtorm.server.OrmException;
+import com.google.gwtorm.server.SchemaFactory;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+
+import com.ericsson.gerrit.plugins.highavailability.forwarder.Context;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@Singleton
+class IndexRestApiServlet extends HttpServlet {
+  private static final long serialVersionUID = -1L;
+  private static final Logger logger =
+      LoggerFactory.getLogger(IndexRestApiServlet.class);
+  private static final Map<Change.Id, AtomicInteger> changeIdLocks =
+      new HashMap<>();
+
+  private final ChangeIndexer indexer;
+  private final SchemaFactory<ReviewDb> schemaFactory;
+
+  @Inject
+  IndexRestApiServlet(ChangeIndexer indexer,
+      SchemaFactory<ReviewDb> schemaFactory) {
+    this.indexer = indexer;
+    this.schemaFactory = schemaFactory;
+  }
+
+  @Override
+  protected void doPost(HttpServletRequest req, HttpServletResponse rsp)
+      throws IOException, ServletException {
+    process(req, rsp, "index");
+  }
+
+  @Override
+  protected void doDelete(HttpServletRequest req, HttpServletResponse rsp)
+      throws IOException, ServletException {
+    process(req, rsp, "delete");
+  }
+
+  private void process(HttpServletRequest req, HttpServletResponse rsp,
+      String operation) {
+    rsp.setContentType("text/plain");
+    rsp.setCharacterEncoding("UTF-8");
+    String path = req.getPathInfo();
+    String changeId = path.substring(path.lastIndexOf('/') + 1);
+    Change.Id id = Change.Id.parse(changeId);
+    try {
+      Context.setForwardedEvent(true);
+      index(id, operation);
+      rsp.setStatus(SC_NO_CONTENT);
+    } catch (IOException e) {
+      sendError(rsp,SC_CONFLICT, e.getMessage());
+      logger.error("Unable to update index", e);
+    } catch (OrmException e) {
+      String msg = "Error trying to find a change \n";
+      sendError(rsp,SC_NOT_FOUND, msg);
+      logger.debug(msg, e);
+    } finally {
+      Context.unsetForwardedEvent();
+    }
+  }
+
+  private static void sendError(HttpServletResponse rsp, int statusCode,
+      String message) {
+    try {
+      rsp.sendError(statusCode, message);
+    } catch (IOException e) {
+      logger.error("Failed to send error messsage: " + e.getMessage(), e);
+    }
+  }
+
+  private void index(Change.Id id, String operation)
+      throws IOException, OrmException {
+    AtomicInteger changeIdLock = getAndIncrementChangeIdLock(id);
+    synchronized (changeIdLock) {
+      if ("index".equals(operation)) {
+        try (ReviewDb db = schemaFactory.open()) {
+          Change change = db.changes().get(id);
+          if (change == null) {
+            indexer.delete(id);
+            return;
+          }
+          indexer.index(db, change);
+        }
+        logger.debug("Change {} successfully indexed", id);
+      }
+      if ("delete".equals(operation)) {
+        indexer.delete(id);
+        logger.debug("Change {} successfully deleted from index", id);
+      }
+    }
+    if (changeIdLock.decrementAndGet() == 0) {
+      removeChangeIdLock(id);
+    }
+  }
+
+  private AtomicInteger getAndIncrementChangeIdLock(Change.Id id) {
+    synchronized (changeIdLocks) {
+      AtomicInteger changeIdLock = changeIdLocks.get(id);
+      if (changeIdLock == null) {
+        changeIdLock = new AtomicInteger(1);
+        changeIdLocks.put(id, changeIdLock);
+      } else {
+        changeIdLock.incrementAndGet();
+      }
+      return changeIdLock;
+    }
+  }
+
+  private void removeChangeIdLock(Change.Id id) {
+    synchronized (changeIdLocks) {
+      changeIdLocks.remove(id);
+    }
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/RestForwarder.java b/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/RestForwarder.java
new file mode 100644
index 0000000..75481b3
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/RestForwarder.java
@@ -0,0 +1,114 @@
+// Copyright (C) 2015 Ericsson
+//
+// 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.ericsson.gerrit.plugins.highavailability.forwarder.rest;
+
+import com.google.common.base.Joiner;
+import com.google.common.base.Supplier;
+import com.google.gerrit.extensions.annotations.PluginName;
+import com.google.gerrit.server.events.Event;
+import com.google.gerrit.server.events.SupplierSerializer;
+import com.google.gson.GsonBuilder;
+import com.google.inject.Inject;
+
+import com.ericsson.gerrit.plugins.highavailability.forwarder.Forwarder;
+import com.ericsson.gerrit.plugins.highavailability.forwarder.rest.HttpResponseHandler.HttpResult;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+
+class RestForwarder implements Forwarder {
+  private static final Logger log =
+      LoggerFactory.getLogger(RestForwarder.class);
+
+  private final HttpSession httpSession;
+  private final String pluginName;
+
+  @Inject
+  RestForwarder(HttpSession httpClient,
+      @PluginName String pluginName) {
+    this.httpSession = httpClient;
+    this.pluginName = pluginName;
+  }
+
+  @Override
+  public boolean indexChange(int changeId) {
+    try {
+      HttpResult result = httpSession.post(buildEndpoint(changeId));
+      if (result.isSuccessful()) {
+        return true;
+      }
+      log.error("Unable to index change {}. Cause: {}", changeId,
+          result.getMessage());
+    } catch (IOException e) {
+      log.error("Error trying to index change " + changeId, e);
+    }
+    return false;
+  }
+
+  @Override
+  public boolean deleteChangeFromIndex(int changeId) {
+    try {
+      HttpResult result = httpSession.delete(buildEndpoint(changeId));
+      if (result.isSuccessful()) {
+        return true;
+      }
+      log.error("Unable to delete from index change {}. Cause: {}", changeId,
+          result.getMessage());
+    } catch (IOException e) {
+      log.error("Error trying to delete from index change " + changeId, e);
+    }
+    return false;
+  }
+
+  private String buildEndpoint(int changeId) {
+    return Joiner.on("/").join("/plugins", pluginName, "index", changeId);
+  }
+
+  @Override
+  public boolean send(Event event) {
+    String serializedEvent = new GsonBuilder()
+        .registerTypeAdapter(Supplier.class, new SupplierSerializer()).create()
+        .toJson(event);
+    try {
+      HttpResult result =
+          httpSession.post(Joiner.on("/").join("/plugins", pluginName, "event"),
+              serializedEvent);
+      if (result.isSuccessful()) {
+        return true;
+      }
+      log.error(
+          "Unable to send event '" + event.type + "' " + result.getMessage());
+    } catch (IOException e) {
+      log.error("Error trying to send event " + event.type, e);
+    }
+    return false;
+  }
+
+  @Override
+  public boolean evict(String cacheName, Object key) {
+    try {
+      String json = GsonParser.toJson(cacheName, key);
+      return httpSession
+          .post(Joiner.on("/").join("/plugins", pluginName, "cache", cacheName),
+              json)
+          .isSuccessful();
+    } catch (IOException e) {
+      log.error("Error trying to evict for cache " + cacheName, e);
+      return false;
+    }
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/RestForwarderModule.java b/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/RestForwarderModule.java
new file mode 100644
index 0000000..e9a57f9
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/RestForwarderModule.java
@@ -0,0 +1,41 @@
+// Copyright (C) 2017 Ericsson
+//
+// 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.ericsson.gerrit.plugins.highavailability.forwarder.rest;
+
+import com.google.gerrit.lifecycle.LifecycleModule;
+import com.google.inject.Provides;
+import com.google.inject.Scopes;
+
+import com.ericsson.gerrit.plugins.highavailability.Configuration;
+import com.ericsson.gerrit.plugins.highavailability.forwarder.Forwarder;
+
+import org.apache.http.impl.client.CloseableHttpClient;
+
+public class RestForwarderModule extends LifecycleModule {
+
+  @Override
+  protected void configure() {
+    bind(CloseableHttpClient.class).toProvider(HttpClientProvider.class)
+        .in(Scopes.SINGLETON);
+    bind(HttpSession.class);
+    bind(Forwarder.class).to(RestForwarder.class);
+  }
+
+  @Provides
+  @ForwardUrl
+  String forwardUrl(Configuration config) {
+    return config.getUrl();
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/evictcache/HttpModule.java b/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/RestForwarderServletModule.java
similarity index 66%
copy from src/main/java/com/ericsson/gerrit/plugins/evictcache/HttpModule.java
copy to src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/RestForwarderServletModule.java
index 27cf205..71b9bf0 100644
--- a/src/main/java/com/ericsson/gerrit/plugins/evictcache/HttpModule.java
+++ b/src/main/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/RestForwarderServletModule.java
@@ -1,4 +1,4 @@
-// Copyright (C) 2015 Ericsson
+// Copyright (C) 2017 Ericsson
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -12,13 +12,15 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package com.ericsson.gerrit.plugins.evictcache;
+package com.ericsson.gerrit.plugins.highavailability.forwarder.rest;
 
 import com.google.gerrit.httpd.plugins.HttpPluginModule;
 
-class HttpModule extends HttpPluginModule {
+public class RestForwarderServletModule extends HttpPluginModule {
   @Override
   protected void configureServlets() {
-    serve("/gerrit/evict/*").with(EvictCacheRestApiServlet.class);
+    serveRegex("/index/\\d+$").with(IndexRestApiServlet.class);
+    serve("/event").with(EventRestApiServlet.class);
+    serve("/cache/*").with(CacheRestApiServlet.class);
   }
 }
diff --git a/src/main/java/com/ericsson/gerrit/plugins/highavailability/index/IndexEventHandler.java b/src/main/java/com/ericsson/gerrit/plugins/highavailability/index/IndexEventHandler.java
new file mode 100644
index 0000000..36a5c82
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/highavailability/index/IndexEventHandler.java
@@ -0,0 +1,104 @@
+// Copyright (C) 2015 Ericsson
+//
+// 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.ericsson.gerrit.plugins.highavailability.index;
+
+import com.google.common.base.Objects;
+import com.google.gerrit.extensions.annotations.PluginName;
+import com.google.gerrit.extensions.events.ChangeIndexedListener;
+import com.google.inject.Inject;
+
+import com.ericsson.gerrit.plugins.highavailability.forwarder.Context;
+import com.ericsson.gerrit.plugins.highavailability.forwarder.Forwarder;
+
+import java.util.Collections;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executor;
+
+class IndexEventHandler implements ChangeIndexedListener {
+  private final Executor executor;
+  private final Forwarder forwarder;
+  private final String pluginName;
+  private final Set<IndexTask> queuedTasks = Collections
+      .newSetFromMap(new ConcurrentHashMap<IndexTask, Boolean>());
+
+  @Inject
+  IndexEventHandler(@IndexExecutor Executor executor,
+      @PluginName String pluginName,
+      Forwarder forwarder) {
+    this.forwarder = forwarder;
+    this.executor = executor;
+    this.pluginName = pluginName;
+  }
+
+  @Override
+  public void onChangeIndexed(int id) {
+    executeIndexTask(id, false);
+  }
+
+  @Override
+  public void onChangeDeleted(int id) {
+    executeIndexTask(id, true);
+  }
+
+  private void executeIndexTask(int id, boolean deleted) {
+    if (!Context.isForwardedEvent()) {
+      IndexTask indexTask = new IndexTask(id, deleted);
+      if (queuedTasks.add(indexTask)) {
+        executor.execute(indexTask);
+      }
+    }
+  }
+
+  class IndexTask implements Runnable {
+    private int changeId;
+    private boolean deleted;
+
+    IndexTask(int changeId, boolean deleted) {
+      this.changeId = changeId;
+      this.deleted = deleted;
+    }
+
+    @Override
+    public void run() {
+      queuedTasks.remove(this);
+      if (deleted) {
+        forwarder.deleteChangeFromIndex(changeId);
+      } else {
+        forwarder.indexChange(changeId);
+      }
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hashCode(changeId, deleted);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+      if (!(obj instanceof IndexTask)) {
+        return false;
+      }
+      IndexTask other = (IndexTask) obj;
+      return changeId == other.changeId && deleted == other.deleted;
+    }
+
+    @Override
+    public String toString() {
+      return String.format("[%s] Index change %s in target instance",
+          pluginName, changeId);
+    }
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/evictcache/SyncUrl.java b/src/main/java/com/ericsson/gerrit/plugins/highavailability/index/IndexExecutor.java
similarity index 89%
copy from src/main/java/com/ericsson/gerrit/plugins/evictcache/SyncUrl.java
copy to src/main/java/com/ericsson/gerrit/plugins/highavailability/index/IndexExecutor.java
index 14c2880..e6c20bd 100644
--- a/src/main/java/com/ericsson/gerrit/plugins/evictcache/SyncUrl.java
+++ b/src/main/java/com/ericsson/gerrit/plugins/highavailability/index/IndexExecutor.java
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package com.ericsson.gerrit.plugins.evictcache;
+package com.ericsson.gerrit.plugins.highavailability.index;
 
 import static java.lang.annotation.RetentionPolicy.RUNTIME;
 
@@ -22,5 +22,5 @@
 
 @Retention(RUNTIME)
 @BindingAnnotation
-@interface SyncUrl {
+@interface IndexExecutor {
 }
diff --git a/src/main/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheExecutorProvider.java b/src/main/java/com/ericsson/gerrit/plugins/highavailability/index/IndexExecutorProvider.java
similarity index 65%
copy from src/main/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheExecutorProvider.java
copy to src/main/java/com/ericsson/gerrit/plugins/highavailability/index/IndexExecutorProvider.java
index e1de403..73aa3be 100644
--- a/src/main/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheExecutorProvider.java
+++ b/src/main/java/com/ericsson/gerrit/plugins/highavailability/index/IndexExecutorProvider.java
@@ -12,33 +12,32 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package com.ericsson.gerrit.plugins.evictcache;
+package com.ericsson.gerrit.plugins.highavailability.index;
 
-import com.google.gerrit.extensions.annotations.PluginName;
 import com.google.gerrit.extensions.events.LifecycleListener;
 import com.google.gerrit.server.git.WorkQueue;
 import com.google.inject.Inject;
 import com.google.inject.Provider;
 import com.google.inject.Singleton;
 
-import java.util.concurrent.ScheduledThreadPoolExecutor;
+import com.ericsson.gerrit.plugins.highavailability.Configuration;
+
+import java.util.concurrent.Executor;
 
 @Singleton
-class EvictCacheExecutorProvider
-    implements Provider<ScheduledThreadPoolExecutor>, LifecycleListener {
+class IndexExecutorProvider implements Provider<Executor>,
+    LifecycleListener {
   private WorkQueue.Executor executor;
 
   @Inject
-  EvictCacheExecutorProvider(WorkQueue workQueue,
-      @PluginName String pluginName,
-      Configuration config) {
-    executor = workQueue.createQueue(config.getThreadPoolSize(),
-        "Evict cache [" + pluginName + " plugin]");
+  IndexExecutorProvider(WorkQueue workQueue, Configuration config) {
+    executor = workQueue.createQueue(config.getIndexThreadPoolSize(),
+        "Forward-index-event");
   }
 
   @Override
   public void start() {
-    // do nothing
+    //do nothing
   }
 
   @Override
@@ -49,7 +48,7 @@
   }
 
   @Override
-  public ScheduledThreadPoolExecutor get() {
+  public Executor get() {
     return executor;
   }
 }
diff --git a/src/main/java/com/ericsson/gerrit/plugins/highavailability/index/IndexModule.java b/src/main/java/com/ericsson/gerrit/plugins/highavailability/index/IndexModule.java
new file mode 100644
index 0000000..7e8b116
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/highavailability/index/IndexModule.java
@@ -0,0 +1,34 @@
+// Copyright (C) 2017 Ericsson
+//
+// 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.ericsson.gerrit.plugins.highavailability.index;
+
+import com.google.gerrit.extensions.events.ChangeIndexedListener;
+import com.google.gerrit.extensions.registration.DynamicSet;
+import com.google.gerrit.lifecycle.LifecycleModule;
+
+import java.util.concurrent.Executor;
+
+public class IndexModule extends LifecycleModule {
+
+  @Override
+  protected void configure() {
+    bind(Executor.class)
+        .annotatedWith(IndexExecutor.class)
+        .toProvider(IndexExecutorProvider.class);
+    listener().to(IndexExecutorProvider.class);
+    DynamicSet.bind(binder(), ChangeIndexedListener.class).to(
+        IndexEventHandler.class);
+  }
+}
diff --git a/src/main/resources/Documentation/about.md b/src/main/resources/Documentation/about.md
index a5adccc..f0f371b 100644
--- a/src/main/resources/Documentation/about.md
+++ b/src/main/resources/Documentation/about.md
@@ -1,10 +1,22 @@
-The @PLUGIN@ plugin allows to synchronize the eviction of caches between two
-Gerrit instances sharing the same repositories and database.
+The @PLUGIN@ plugin allows to synchronize eviction of caches, secondary indexes
+and stream events between two Gerrit instances sharing the same git repositories
+and database. The plugin needs to be installed in both instances.
 
-The plugin needs to be installed in both instances and every time a cache
-eviction occurs in one of the instances, the other instance's cache is updated.
+Every time a cache eviction occurs in one of the instances, the other instance's
+cache is updated.
+
 This way, both caches are kept synchronized.
 
-For this synchronization to work, http must be enabled in both instances and the
-plugin must be configured with valid credentials. For further information, refer
-to [config](config.md) documentation.
+Every time the secondary index is modified in one of the instances, i.e., a
+change is added, updated or removed from the index, the other instance index is
+updated accordingly. This way, both indexes are kept synchronized.
+
+Every time a stream event occurs in one of the instances (see [more events info]
+(https://gerrit-review.googlesource.com/Documentation/cmd-stream-events.html#events)),
+the event is forwarded to the other instance which re-plays it. This way, the
+output of the stream-events command is the same, no matter what instance a
+client is connected to.
+
+For this to work, http must be enabled in both instances and the plugin
+must be configured with valid credentials. For further information, refer to
+[config](config.md) documentation.
diff --git a/src/main/resources/Documentation/build.md b/src/main/resources/Documentation/build.md
index b5b5ed7..3babed2 100644
--- a/src/main/resources/Documentation/build.md
+++ b/src/main/resources/Documentation/build.md
@@ -103,4 +103,4 @@
 
 [Back to @PLUGIN@ documentation index][index]
 
-[index]: index.html
\ No newline at end of file
+[index]: index.html
diff --git a/src/main/resources/Documentation/config.md b/src/main/resources/Documentation/config.md
index da544a7..e3865fd 100644
--- a/src/main/resources/Documentation/config.md
+++ b/src/main/resources/Documentation/config.md
@@ -1,13 +1,17 @@
 @PLUGIN@ Configuration
 =========================
 
-In order for the synchronization to work, the @PLUGIN@ plugin must be installed
-in both instances and the following fields should be specified in the
-corresponding Gerrit configuration file:
+The @PLUGIN@ plugin must be installed in both instances and the following fields
+should be specified in the corresponding Gerrit configuration file:
 
 File 'gerrit.config'
 --------------------
 
+[plugin "@PLUGIN@"]
+:  url = target_instance_url
+:  user = username
+:  password = password
+
 plugin.@PLUGIN@.url
 :   Specify the URL for the secondary (target) instance.
 
@@ -16,11 +20,11 @@
 
 plugin.@PLUGIN@.password
 :   Password to connect to the secondary (target) instance. This value can
-    also be defined in secure.config.
+     also be defined in secure.config.
 
-@PLUGIN@ plugin uses REST API calls to synchronize cache evictions in the target
-instance. It is possible to customize the parameters of the underlying http client
-doing these calls by specifying the following fields:
+@PLUGIN@ plugin uses REST API calls to keep the target instance in-sync. It
+is possible to customize the parameters of the underlying http client doing these
+calls by specifying the following fields:
 
 @PLUGIN@.connectionTimeout
 :   Maximum interval of time in milliseconds the plugin waits for a connection
@@ -32,15 +36,23 @@
     the default value is set to 5000ms.
 
 @PLUGIN@.maxTries
-:   Maximum number of times the plugin should attempt to evict the cache in the
-    target instance. Setting this value to 0 will disable retries. When not
-    specified, the default value is 5. After this number of failed tries, an error
-    is logged so that admins can flush the cache manually.
+:   Maximum number of times the plugin should attempt when calling a REST API in
+    the target instance. Setting this value to 0 will disable retries. When not
+    specified, the default value is 5. After this number of failed tries, an
+    error is logged.
 
 @PLUGIN@.retryInterval
 :   The interval of time in milliseconds between the subsequent auto-retries.
     When not specified, the default value is set to 1000ms.
 
-@PLUGIN@.threadPoolSize
-:   Maximum number of threads used to send cache evictions to the target instance.
+@PLUGIN@.indexThreadPoolSize
+:   Maximum number of threads used to send index events to the target instance.
     Defaults to 1.
+
+@PLUGIN@.eventThreadPoolSize
+:   Maximum number of threads used to send stream events to the target instance.
+    Defaults to 1.
+
+@PLUGIN@.cacheThreadPoolSize
+:   Maximum number of threads used to send cache evictions to the target instance.
+    Defaults to 1.
\ No newline at end of file
diff --git a/src/test/java/com/ericsson/gerrit/plugins/evictcache/Constants.java b/src/test/java/com/ericsson/gerrit/plugins/evictcache/Constants.java
deleted file mode 100644
index f7ba16c..0000000
--- a/src/test/java/com/ericsson/gerrit/plugins/evictcache/Constants.java
+++ /dev/null
@@ -1,32 +0,0 @@
-// Copyright (C) 2015 Ericsson
-//
-// 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.ericsson.gerrit.plugins.evictcache;
-
-final class Constants {
-
-  private Constants() {
-  }
-
-  static final String URL = "http://localhost:18888";
-  static final String ENDPOINT_BASE = "/plugins/evict-cache/gerrit/evict/";
-  static final String PROJECT_LIST = "project_list";
-  static final String ACCOUNTS = "accounts";
-  static final String GROUPS = "groups";
-  static final String GROUPS_BYINCLUDE = "groups_byinclude";
-  static final String GROUPS_MEMBERS = "groups_members";
-  static final String DEFAULT = "projects";
-
-  static final int PORT = 18888;
-}
diff --git a/src/test/java/com/ericsson/gerrit/plugins/evictcache/ContextTest.java b/src/test/java/com/ericsson/gerrit/plugins/evictcache/ContextTest.java
deleted file mode 100644
index f7f51b6..0000000
--- a/src/test/java/com/ericsson/gerrit/plugins/evictcache/ContextTest.java
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright (C) 2015 Ericsson
-//
-// 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.ericsson.gerrit.plugins.evictcache;
-
-import static com.google.common.truth.Truth.assertThat;
-
-import org.junit.Test;
-
-public class ContextTest {
-
-  @Test
-  public void testInitialValueNotNull() throws Exception {
-    assertThat(Context.isForwardedEvent()).isNotNull();
-    assertThat(Context.isForwardedEvent()).isFalse();
-  }
-
-  @Test
-  public void testSetForwardedEvent() throws Exception {
-    Context.setForwardedEvent();
-    try {
-      assertThat(Context.isForwardedEvent()).isTrue();
-    } finally {
-      Context.unsetForwardedEvent();
-    }
-  }
-
-  @Test
-  public void testUnsetForwardedEvent() throws Exception {
-    Context.setForwardedEvent();
-    Context.unsetForwardedEvent();
-    assertThat(Context.isForwardedEvent()).isFalse();
-  }
-}
diff --git a/src/test/java/com/ericsson/gerrit/plugins/evictcache/RestSessionTest.java b/src/test/java/com/ericsson/gerrit/plugins/evictcache/RestSessionTest.java
deleted file mode 100644
index 731792b..0000000
--- a/src/test/java/com/ericsson/gerrit/plugins/evictcache/RestSessionTest.java
+++ /dev/null
@@ -1,124 +0,0 @@
-// Copyright (C) 2015 Ericsson
-//
-// 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.ericsson.gerrit.plugins.evictcache;
-
-import static com.google.common.truth.Truth.assertThat;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-import com.google.common.base.Joiner;
-import com.google.gerrit.reviewdb.client.Account;
-import com.google.gerrit.reviewdb.client.AccountGroup;
-
-import com.ericsson.gerrit.plugins.evictcache.CacheResponseHandler.CacheResult;
-
-import org.junit.Test;
-
-import java.io.IOException;
-
-public class RestSessionTest {
-  private static final String EVICT = "evict";
-  private static final String SOURCE_NAME = "gerrit";
-  private static final String PLUGIN_NAME = "evict-cache";
-  private static final String EMPTY_JSON = "{}";
-  private static final String EMPTY_JSON2 = "\"{}\"";
-  private static final String ID_RESPONSE = "{\"id\":0}";
-  private static final boolean OK_RESPONSE = true;
-  private static final boolean FAIL_RESPONSE = false;
-  private static final boolean THROW_EXCEPTION = true;
-  private static final boolean DO_NOT_THROW_EXCEPTION = false;
-
-  private RestSession restClient;
-
-  @Test
-  public void testEvictCacheOK() throws Exception {
-    setupMocks(Constants.DEFAULT, EMPTY_JSON2, OK_RESPONSE,
-        DO_NOT_THROW_EXCEPTION);
-    assertThat(restClient.evict(SOURCE_NAME, Constants.DEFAULT, EMPTY_JSON))
-        .isTrue();
-  }
-
-  @Test
-  public void testEvictAccountsOK() throws Exception {
-    setupMocks(Constants.ACCOUNTS, ID_RESPONSE, OK_RESPONSE,
-        DO_NOT_THROW_EXCEPTION);
-    assertThat(restClient.evict(SOURCE_NAME, Constants.ACCOUNTS,
-        mock(Account.Id.class))).isTrue();
-  }
-
-  @Test
-  public void testEvictGroupsOK() throws Exception {
-    setupMocks(Constants.GROUPS, ID_RESPONSE, OK_RESPONSE,
-        DO_NOT_THROW_EXCEPTION);
-    assertThat(restClient.evict(SOURCE_NAME, Constants.GROUPS,
-        mock(AccountGroup.Id.class))).isTrue();
-  }
-
-  @Test
-  public void testEvictGroupsByIncludeOK() throws Exception {
-    setupMocks(Constants.GROUPS_BYINCLUDE, EMPTY_JSON, OK_RESPONSE,
-        DO_NOT_THROW_EXCEPTION);
-    assertThat(restClient.evict(SOURCE_NAME, Constants.GROUPS_BYINCLUDE,
-        mock(AccountGroup.UUID.class))).isTrue();
-  }
-
-  @Test
-  public void testEvictGroupsMembersOK() throws Exception {
-    setupMocks(Constants.GROUPS_MEMBERS, EMPTY_JSON, OK_RESPONSE,
-        DO_NOT_THROW_EXCEPTION);
-    assertThat(restClient.evict(SOURCE_NAME, Constants.GROUPS_MEMBERS,
-        mock(AccountGroup.UUID.class))).isTrue();
-  }
-
-  @Test
-  public void testEvictProjectListOK() throws Exception {
-    setupMocks(Constants.PROJECT_LIST, EMPTY_JSON, OK_RESPONSE,
-        DO_NOT_THROW_EXCEPTION);
-    assertThat(
-        restClient.evict(SOURCE_NAME, Constants.PROJECT_LIST, new Object()))
-            .isTrue();
-  }
-
-  @Test
-  public void testEvictCacheFailed() throws Exception {
-    setupMocks(Constants.DEFAULT, EMPTY_JSON2, FAIL_RESPONSE,
-        DO_NOT_THROW_EXCEPTION);
-    assertThat(restClient.evict(SOURCE_NAME, Constants.DEFAULT, EMPTY_JSON))
-        .isFalse();
-  }
-
-  @Test
-  public void testEvictCacheThrowsException() throws Exception {
-    setupMocks(Constants.DEFAULT, EMPTY_JSON2, FAIL_RESPONSE, THROW_EXCEPTION);
-    assertThat(restClient.evict(SOURCE_NAME, Constants.DEFAULT, EMPTY_JSON))
-        .isFalse();
-  }
-
-  private void setupMocks(String cacheName, String json, boolean ok,
-      boolean exception) throws IOException {
-    String request = Joiner.on("/").join("/plugins", PLUGIN_NAME, SOURCE_NAME,
-        EVICT, cacheName);
-    HttpSession httpSession = mock(HttpSession.class);
-    if (exception) {
-      doThrow(new IOException()).when(httpSession).post(request, json);
-    } else {
-      CacheResult result = new CacheResult(ok, "Error");
-      when(httpSession.post(request, json)).thenReturn(result);
-    }
-
-    restClient = new RestSession(httpSession, PLUGIN_NAME);
-  }
-}
diff --git a/src/test/java/com/ericsson/gerrit/plugins/evictcache/ConfigurationTest.java b/src/test/java/com/ericsson/gerrit/plugins/highavailability/ConfigurationTest.java
similarity index 69%
rename from src/test/java/com/ericsson/gerrit/plugins/evictcache/ConfigurationTest.java
rename to src/test/java/com/ericsson/gerrit/plugins/highavailability/ConfigurationTest.java
index 88ddc54..f9225c3 100644
--- a/src/test/java/com/ericsson/gerrit/plugins/evictcache/ConfigurationTest.java
+++ b/src/test/java/com/ericsson/gerrit/plugins/highavailability/ConfigurationTest.java
@@ -12,9 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package com.ericsson.gerrit.plugins.evictcache;
+package com.ericsson.gerrit.plugins.highavailability;
 
 import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.when;
 
 import com.google.gerrit.server.config.PluginConfig;
@@ -44,7 +46,7 @@
   @Mock
   private PluginConfig configMock;
   private Configuration configuration;
-  private String pluginName = "evict-cache";
+  private String pluginName = "high-availability";
 
   @Before
   public void setUp() throws Exception {
@@ -62,7 +64,12 @@
     assertThat(configuration.getSocketTimeout()).isEqualTo(TIMEOUT);
     assertThat(configuration.getMaxTries()).isEqualTo(MAX_TRIES);
     assertThat(configuration.getRetryInterval()).isEqualTo(RETRY_INTERVAL);
-    assertThat(configuration.getThreadPoolSize()).isEqualTo(THREAD_POOL_SIZE);
+    assertThat(configuration.getIndexThreadPoolSize())
+        .isEqualTo(THREAD_POOL_SIZE);
+    assertThat(configuration.getEventThreadPoolSize())
+        .isEqualTo(THREAD_POOL_SIZE);
+    assertThat(configuration.getCacheThreadPoolSize())
+        .isEqualTo(THREAD_POOL_SIZE);
   }
 
   @Test
@@ -75,7 +82,9 @@
     assertThat(configuration.getSocketTimeout()).isEqualTo(0);
     assertThat(configuration.getMaxTries()).isEqualTo(0);
     assertThat(configuration.getRetryInterval()).isEqualTo(0);
-    assertThat(configuration.getThreadPoolSize()).isEqualTo(0);
+    assertThat(configuration.getIndexThreadPoolSize()).isEqualTo(0);
+    assertThat(configuration.getEventThreadPoolSize()).isEqualTo(0);
+    assertThat(configuration.getCacheThreadPoolSize()).isEqualTo(0);
   }
 
   @Test
@@ -87,6 +96,21 @@
     assertThat(configuration.getUrl()).isEqualTo(URL);
   }
 
+  @Test
+  public void testIllegalArgumentExceptionReturnDefaultValue() throws Exception {
+    when(configMock.getInt(anyString(), anyInt()))
+        .thenThrow(new IllegalArgumentException("some message"));
+
+    configuration = new Configuration(cfgFactoryMock, pluginName);
+    assertThat(configuration.getConnectionTimeout()).isEqualTo(5000);
+    assertThat(configuration.getSocketTimeout()).isEqualTo(5000);
+    assertThat(configuration.getMaxTries()).isEqualTo(5);
+    assertThat(configuration.getRetryInterval()).isEqualTo(1000);
+    assertThat(configuration.getIndexThreadPoolSize()).isEqualTo(1);
+    assertThat(configuration.getEventThreadPoolSize()).isEqualTo(1);
+    assertThat(configuration.getCacheThreadPoolSize()).isEqualTo(1);
+  }
+
   private void buildMocks(boolean values) {
     when(configMock.getString("url")).thenReturn(values ? URL : null);
     when(configMock.getString("user")).thenReturn(values ? USER : null);
@@ -99,7 +123,11 @@
         .thenReturn(values ? MAX_TRIES : 0);
     when(configMock.getInt("retryInterval", RETRY_INTERVAL))
         .thenReturn(values ? RETRY_INTERVAL : 0);
-    when(configMock.getInt("threadPoolSize", THREAD_POOL_SIZE))
+    when(configMock.getInt("indexThreadPoolSize", THREAD_POOL_SIZE))
+        .thenReturn(values ? THREAD_POOL_SIZE : 0);
+    when(configMock.getInt("eventThreadPoolSize", THREAD_POOL_SIZE))
+        .thenReturn(values ? THREAD_POOL_SIZE : 0);
+    when(configMock.getInt("cacheThreadPoolSize", THREAD_POOL_SIZE))
         .thenReturn(values ? THREAD_POOL_SIZE : 0);
 
     configuration = new Configuration(cfgFactoryMock, pluginName);
diff --git a/src/test/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheIT.java b/src/test/java/com/ericsson/gerrit/plugins/highavailability/cache/CacheEvictionIT.java
similarity index 80%
rename from src/test/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheIT.java
rename to src/test/java/com/ericsson/gerrit/plugins/highavailability/cache/CacheEvictionIT.java
index b44ac31..0c8ba85 100644
--- a/src/test/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheIT.java
+++ b/src/test/java/com/ericsson/gerrit/plugins/highavailability/cache/CacheEvictionIT.java
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package com.ericsson.gerrit.plugins.evictcache;
+package com.ericsson.gerrit.plugins.highavailability.cache;
 
 import static com.github.tomakehurst.wiremock.client.WireMock.aResponse;
 import static com.github.tomakehurst.wiremock.client.WireMock.givenThat;
@@ -26,6 +26,7 @@
 import com.google.gerrit.acceptance.NoHttpd;
 import com.google.gerrit.acceptance.PluginDaemonTest;
 
+import com.ericsson.gerrit.plugins.highavailability.cache.Constants;
 import com.github.tomakehurst.wiremock.http.Request;
 import com.github.tomakehurst.wiremock.http.RequestListener;
 import com.github.tomakehurst.wiremock.http.Response;
@@ -38,19 +39,18 @@
 import java.util.concurrent.TimeUnit;
 
 @NoHttpd
-public class EvictCacheIT extends PluginDaemonTest {
+public class CacheEvictionIT extends PluginDaemonTest {
 
   @Rule
-  public WireMockRule wireMockRule = new WireMockRule(Constants.PORT);
+  public WireMockRule wireMockRule = new WireMockRule(18888);
 
   @Test
   @GerritConfigs({
-      @GerritConfig(name = "plugin.evict-cache.url", value = Constants.URL),
-      @GerritConfig(name = "plugin.evict-cache.user", value = "admin")
-  })
+      @GerritConfig(name = "plugin.high-availability.url", value = "http://localhost:18888"),
+      @GerritConfig(name = "plugin.high-availability.user", value = "admin")})
   public void flushAndSendPost() throws Exception {
     final String flushRequest =
-        Constants.ENDPOINT_BASE + Constants.PROJECT_LIST;
+        "/plugins/high-availability/cache/" + Constants.PROJECT_LIST;
     wireMockRule.addMockServiceRequestListener(new RequestListener() {
       @Override
       public void requestReceived(Request request, Response response) {
@@ -67,7 +67,7 @@
     adminSshSession
         .exec("gerrit flush-caches --cache " + Constants.PROJECT_LIST);
     synchronized (flushRequest) {
-      flushRequest.wait(TimeUnit.SECONDS.toMillis(2));
+      flushRequest.wait(TimeUnit.SECONDS.toMillis(5));
     }
     verify(postRequestedFor(urlEqualTo(flushRequest)));
   }
diff --git a/src/test/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheExecutorProviderTest.java b/src/test/java/com/ericsson/gerrit/plugins/highavailability/cache/CacheExecutorProviderTest.java
similarity index 64%
copy from src/test/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheExecutorProviderTest.java
copy to src/test/java/com/ericsson/gerrit/plugins/highavailability/cache/CacheExecutorProviderTest.java
index a01b187..21e6cab 100644
--- a/src/test/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheExecutorProviderTest.java
+++ b/src/test/java/com/ericsson/gerrit/plugins/highavailability/cache/CacheExecutorProviderTest.java
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package com.ericsson.gerrit.plugins.evictcache;
+package com.ericsson.gerrit.plugins.highavailability.cache;
 
 import static com.google.common.truth.Truth.assertThat;
 import static org.mockito.Mockito.mock;
@@ -21,6 +21,8 @@
 
 import com.google.gerrit.server.git.WorkQueue;
 
+import com.ericsson.gerrit.plugins.highavailability.Configuration;
+
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -28,37 +30,36 @@
 import org.mockito.junit.MockitoJUnitRunner;
 
 @RunWith(MockitoJUnitRunner.class)
-public class EvictCacheExecutorProviderTest {
-  private static final String PLUGIN_NAME = "evict-cache";
+public class CacheExecutorProviderTest {
 
   @Mock
   private WorkQueue.Executor executorMock;
-  private EvictCacheExecutorProvider evictCacheExecutorProvider;
+  private CacheExecutorProvider cacheExecutorProvider;
 
   @Before
   public void setUp() throws Exception {
     WorkQueue workQueueMock = mock(WorkQueue.class);
-    when(workQueueMock.createQueue(4,
-        "Evict cache [" + PLUGIN_NAME + " plugin]")).thenReturn(executorMock);
+    when(workQueueMock.createQueue(4, "Forward-cache-eviction-event"))
+        .thenReturn(executorMock);
     Configuration configMock = mock(Configuration.class);
-    when(configMock.getThreadPoolSize()).thenReturn(4);
+    when(configMock.getCacheThreadPoolSize()).thenReturn(4);
 
-    evictCacheExecutorProvider =
-        new EvictCacheExecutorProvider(workQueueMock, PLUGIN_NAME, configMock);
+    cacheExecutorProvider =
+        new CacheExecutorProvider(workQueueMock, configMock);
   }
 
   @Test
   public void shouldReturnExecutor() throws Exception {
-    assertThat(evictCacheExecutorProvider.get()).isEqualTo(executorMock);
+    assertThat(cacheExecutorProvider.get()).isEqualTo(executorMock);
   }
 
   @Test
   public void testStop() throws Exception {
-    evictCacheExecutorProvider.start();
-    assertThat(evictCacheExecutorProvider.get()).isEqualTo(executorMock);
-    evictCacheExecutorProvider.stop();
+    cacheExecutorProvider.start();
+    assertThat(cacheExecutorProvider.get()).isEqualTo(executorMock);
+    cacheExecutorProvider.stop();
     verify(executorMock).shutdown();
     verify(executorMock).unregisterWorkQueue();
-    assertThat(evictCacheExecutorProvider.get()).isNull();
+    assertThat(cacheExecutorProvider.get()).isNull();
   }
 }
diff --git a/src/test/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheExecutorProviderTest.java b/src/test/java/com/ericsson/gerrit/plugins/highavailability/event/EventExecutorProviderTest.java
similarity index 62%
copy from src/test/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheExecutorProviderTest.java
copy to src/test/java/com/ericsson/gerrit/plugins/highavailability/event/EventExecutorProviderTest.java
index a01b187..085ca0a 100644
--- a/src/test/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheExecutorProviderTest.java
+++ b/src/test/java/com/ericsson/gerrit/plugins/highavailability/event/EventExecutorProviderTest.java
@@ -1,4 +1,4 @@
-// Copyright (C) 2015 Ericsson
+// Copyright (C) 2016 Ericsson
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package com.ericsson.gerrit.plugins.evictcache;
+package com.ericsson.gerrit.plugins.highavailability.event;
 
 import static com.google.common.truth.Truth.assertThat;
 import static org.mockito.Mockito.mock;
@@ -21,6 +21,9 @@
 
 import com.google.gerrit.server.git.WorkQueue;
 
+import com.ericsson.gerrit.plugins.highavailability.Configuration;
+import com.ericsson.gerrit.plugins.highavailability.event.EventExecutorProvider;
+
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -28,37 +31,35 @@
 import org.mockito.junit.MockitoJUnitRunner;
 
 @RunWith(MockitoJUnitRunner.class)
-public class EvictCacheExecutorProviderTest {
-  private static final String PLUGIN_NAME = "evict-cache";
-
+public class EventExecutorProviderTest {
   @Mock
   private WorkQueue.Executor executorMock;
-  private EvictCacheExecutorProvider evictCacheExecutorProvider;
+  private EventExecutorProvider eventsExecutorProvider;
 
   @Before
   public void setUp() throws Exception {
     WorkQueue workQueueMock = mock(WorkQueue.class);
-    when(workQueueMock.createQueue(4,
-        "Evict cache [" + PLUGIN_NAME + " plugin]")).thenReturn(executorMock);
+    when(workQueueMock.createQueue(4, "Forward-stream-event"))
+        .thenReturn(executorMock);
     Configuration configMock = mock(Configuration.class);
-    when(configMock.getThreadPoolSize()).thenReturn(4);
+    when(configMock.getEventThreadPoolSize()).thenReturn(4);
 
-    evictCacheExecutorProvider =
-        new EvictCacheExecutorProvider(workQueueMock, PLUGIN_NAME, configMock);
+    eventsExecutorProvider =
+        new EventExecutorProvider(workQueueMock, configMock);
   }
 
   @Test
   public void shouldReturnExecutor() throws Exception {
-    assertThat(evictCacheExecutorProvider.get()).isEqualTo(executorMock);
+    assertThat(eventsExecutorProvider.get()).isEqualTo(executorMock);
   }
 
   @Test
   public void testStop() throws Exception {
-    evictCacheExecutorProvider.start();
-    assertThat(evictCacheExecutorProvider.get()).isEqualTo(executorMock);
-    evictCacheExecutorProvider.stop();
+    eventsExecutorProvider.start();
+    assertThat(eventsExecutorProvider.get()).isEqualTo(executorMock);
+    eventsExecutorProvider.stop();
     verify(executorMock).shutdown();
     verify(executorMock).unregisterWorkQueue();
-    assertThat(evictCacheExecutorProvider.get()).isNull();
+    assertThat(eventsExecutorProvider.get()).isNull();
   }
 }
diff --git a/src/test/java/com/ericsson/gerrit/plugins/highavailability/event/EventHandlerTest.java b/src/test/java/com/ericsson/gerrit/plugins/highavailability/event/EventHandlerTest.java
new file mode 100644
index 0000000..07ab3c5
--- /dev/null
+++ b/src/test/java/com/ericsson/gerrit/plugins/highavailability/event/EventHandlerTest.java
@@ -0,0 +1,98 @@
+// Copyright (C) 2015 Ericsson
+//
+// 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.ericsson.gerrit.plugins.highavailability.event;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
+
+import com.google.gerrit.server.events.Event;
+import com.google.gerrit.server.events.RefEvent;
+
+import com.ericsson.gerrit.plugins.highavailability.forwarder.Context;
+import com.ericsson.gerrit.plugins.highavailability.forwarder.Forwarder;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+
+@RunWith(MockitoJUnitRunner.class)
+public class EventHandlerTest {
+  private static final String PLUGIN_NAME = "high-availability";
+
+  private Event event;
+  private EventHandler eventHandler;
+  @Mock
+  private Forwarder forwarder;
+
+  @Test
+  public void testRightEventAndNotForwarded() throws Exception {
+    setUpMocks(true);
+    eventHandler.onEvent(event);
+    verify(forwarder).send(event);
+  }
+
+  @Test
+  public void testRightEventIsForwarded() throws Exception {
+    setUpMocks(true);
+    Context.setForwardedEvent(true);
+    eventHandler.onEvent(event);
+    Context.unsetForwardedEvent();
+    verifyZeroInteractions(forwarder);
+  }
+
+  @Test
+  public void testBadEventAndNotForwarded() throws Exception {
+    setUpMocks(false);
+    eventHandler.onEvent(event);
+    verifyZeroInteractions(forwarder);
+  }
+
+  @Test
+  public void testBadEventAndItIsForwarded() throws Exception {
+    setUpMocks(false);
+    Context.setForwardedEvent(true);
+    eventHandler.onEvent(event);
+    Context.unsetForwardedEvent();
+    verifyZeroInteractions(forwarder);
+  }
+
+  private void setUpMocks(boolean rightEvent) {
+    ScheduledThreadPoolExecutor pool = new PoolMock(1);
+    if (rightEvent) {
+      event = mock(RefEvent.class);
+    } else {
+      event = mock(Event.class);
+    }
+    eventHandler = new EventHandler(forwarder, pool, PLUGIN_NAME);
+  }
+
+  private class PoolMock extends ScheduledThreadPoolExecutor {
+    PoolMock(int corePoolSize) {
+      super(corePoolSize);
+    }
+
+    @Override
+    public void execute(Runnable command) {
+      assertThat(command.toString()).isEqualTo(String.format(
+          "[%s] Send event '%s' to target instance", PLUGIN_NAME, null));
+      command.run();
+    }
+  }
+}
diff --git a/src/test/java/com/ericsson/gerrit/plugins/highavailability/event/ForwardedAwareEventBrokerTest.java b/src/test/java/com/ericsson/gerrit/plugins/highavailability/event/ForwardedAwareEventBrokerTest.java
new file mode 100644
index 0000000..713f7ef
--- /dev/null
+++ b/src/test/java/com/ericsson/gerrit/plugins/highavailability/event/ForwardedAwareEventBrokerTest.java
@@ -0,0 +1,61 @@
+// Copyright (C) 2016 Ericsson
+//
+// 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.ericsson.gerrit.plugins.highavailability.event;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
+
+import com.google.gerrit.common.EventListener;
+import com.google.gerrit.extensions.registration.DynamicSet;
+import com.google.gerrit.server.events.Event;
+
+import com.ericsson.gerrit.plugins.highavailability.event.ForwardedAwareEventBroker;
+import com.ericsson.gerrit.plugins.highavailability.forwarder.Context;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class ForwardedAwareEventBrokerTest {
+
+  private EventListener listenerMock;
+  private ForwardedAwareEventBroker broker;
+  private Event event = new Event(null) {};
+
+  @Before
+  public void setUp() {
+    listenerMock = mock(EventListener.class);
+    DynamicSet<EventListener> listeners = DynamicSet.emptySet();
+    listeners.add(listenerMock);
+    broker = new ForwardedAwareEventBroker(null, listeners, null, null, null);
+  }
+
+  @Test
+  public void shouldDispatchEvent() {
+    broker.fireEventForUnrestrictedListeners(event);
+    verify(listenerMock).onEvent(event);
+  }
+
+  @Test
+  public void shouldNotDispatchForwardedEvents() {
+    Context.setForwardedEvent(true);
+    try {
+      broker.fireEventForUnrestrictedListeners(event);
+    } finally {
+      Context.unsetForwardedEvent();
+    }
+    verifyZeroInteractions(listenerMock);
+  }
+}
diff --git a/src/test/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheRestApiServletTest.java b/src/test/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/CacheRestApiServletTest.java
similarity index 90%
rename from src/test/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheRestApiServletTest.java
rename to src/test/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/CacheRestApiServletTest.java
index 3db1f75..4813a7d 100644
--- a/src/test/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheRestApiServletTest.java
+++ b/src/test/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/CacheRestApiServletTest.java
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package com.ericsson.gerrit.plugins.evictcache;
+package com.ericsson.gerrit.plugins.highavailability.forwarder.rest;
 
 import static javax.servlet.http.HttpServletResponse.SC_BAD_REQUEST;
 import static javax.servlet.http.HttpServletResponse.SC_NO_CONTENT;
@@ -24,6 +24,8 @@
 import com.google.common.cache.Cache;
 import com.google.gerrit.extensions.registration.DynamicMap;
 
+import com.ericsson.gerrit.plugins.highavailability.cache.Constants;
+
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -37,7 +39,7 @@
 import javax.servlet.http.HttpServletResponse;
 
 @RunWith(MockitoJUnitRunner.class)
-public class EvictCacheRestApiServletTest {
+public class CacheRestApiServletTest {
   @Mock
   private HttpServletRequest request;
   @Mock
@@ -46,11 +48,11 @@
   private BufferedReader reader;
   @Mock
   private DynamicMap<Cache<?, ?>> cacheMap;
-  private EvictCacheRestApiServlet servlet;
+  private CacheRestApiServlet servlet;
 
   @Before
   public void setUp() {
-    servlet = new EvictCacheRestApiServlet(cacheMap);
+    servlet = new CacheRestApiServlet(cacheMap);
   }
 
   @Test
@@ -86,7 +88,7 @@
 
   @Test
   public void evictDefault() throws Exception {
-    configureMocksFor(Constants.DEFAULT);
+    configureMocksFor(Constants.PROJECTS);
     verifyResponseIsOK();
   }
 
@@ -119,7 +121,7 @@
     when(request.getPathInfo()).thenReturn("/" + cacheName);
     when(request.getReader()).thenReturn(reader);
 
-    if (Constants.DEFAULT.equals(cacheName)) {
+    if (Constants.PROJECTS.equals(cacheName)) {
       when(reader.readLine()).thenReturn("abc");
     } else if (Constants.GROUPS_BYINCLUDE.equals(cacheName)
         || Constants.GROUPS_MEMBERS.equals(cacheName)) {
diff --git a/src/test/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/EventRestApiServletTest.java b/src/test/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/EventRestApiServletTest.java
new file mode 100644
index 0000000..27d46b7
--- /dev/null
+++ b/src/test/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/EventRestApiServletTest.java
@@ -0,0 +1,149 @@
+// Copyright (C) 2016 Ericsson
+//
+// 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.ericsson.gerrit.plugins.highavailability.forwarder.rest;
+
+import static com.google.common.net.MediaType.JSON_UTF_8;
+import static javax.servlet.http.HttpServletResponse.SC_BAD_REQUEST;
+import static javax.servlet.http.HttpServletResponse.SC_NOT_FOUND;
+import static javax.servlet.http.HttpServletResponse.SC_NO_CONTENT;
+import static javax.servlet.http.HttpServletResponse.SC_UNSUPPORTED_MEDIA_TYPE;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.net.MediaType;
+import com.google.gerrit.common.EventDispatcher;
+import com.google.gerrit.reviewdb.client.Project;
+import com.google.gerrit.server.events.EventTypes;
+import com.google.gerrit.server.events.RefEvent;
+import com.google.gwtorm.client.KeyUtil;
+import com.google.gwtorm.server.OrmException;
+import com.google.gwtorm.server.StandardKeyEncoder;
+
+import com.ericsson.gerrit.plugins.highavailability.forwarder.rest.EventRestApiServlet;
+
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.StringReader;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@RunWith(MockitoJUnitRunner.class)
+public class EventRestApiServletTest {
+  private static final String ERR_MSG = "some Error";
+
+  @Mock
+  private EventDispatcher dispatcher;
+  @Mock
+  private HttpServletRequest req;
+  @Mock
+  private HttpServletResponse rsp;
+  private EventRestApiServlet eventRestApiServlet;
+
+  @BeforeClass
+  public static void setup() {
+    EventTypes.register(RefReplicationDoneEvent.TYPE,
+        RefReplicationDoneEvent.class);
+    KeyUtil.setEncoderImpl(new StandardKeyEncoder());
+  }
+
+  @Before
+  public void createEventsRestApiServlet() throws Exception {
+    eventRestApiServlet = new EventRestApiServlet(dispatcher);
+    when(req.getContentType()).thenReturn(MediaType.JSON_UTF_8.toString());
+  }
+
+  @Test
+  public void testDoPostRefReplicationDoneEvent() throws Exception {
+    String event = "{\"project\":\"gerrit/some-project\",\"ref\":"
+        + "\"refs/changes/76/669676/2\",\"nodesCount\":1,\"type\":"
+        + "\"ref-replication-done\",\"eventCreatedOn\":1451415011}";
+    when(req.getReader())
+        .thenReturn(new BufferedReader(new StringReader(event)));
+    dispatcher.postEvent(any(RefReplicationDoneEvent.class));
+    eventRestApiServlet.doPost(req, rsp);
+    verify(rsp).setStatus(SC_NO_CONTENT);
+  }
+
+  @Test
+  public void testDoPostDispatcherFailure() throws Exception {
+    String event = "{\"project\":\"gerrit/some-project\",\"ref\":"
+        + "\"refs/changes/76/669676/2\",\"nodesCount\":1,\"type\":"
+        + "\"ref-replication-done\",\"eventCreatedOn\":1451415011}";
+    when(req.getReader())
+        .thenReturn(new BufferedReader(new StringReader(event)));
+    doThrow(new OrmException(ERR_MSG)).when(dispatcher)
+        .postEvent(any(RefReplicationDoneEvent.class));
+    eventRestApiServlet.doPost(req, rsp);
+    verify(rsp).sendError(SC_NOT_FOUND, "Change not found\n");
+  }
+
+  @Test
+  public void testDoPostBadRequest() throws Exception {
+    doThrow(new IOException(ERR_MSG)).when(req).getReader();
+    eventRestApiServlet.doPost(req, rsp);
+    verify(rsp).sendError(SC_BAD_REQUEST, ERR_MSG);
+  }
+
+  @Test
+  public void testDoPostWrongMediaType() throws Exception {
+    when(req.getContentType())
+        .thenReturn(MediaType.APPLICATION_XML_UTF_8.toString());
+    eventRestApiServlet.doPost(req, rsp);
+    verify(rsp).sendError(SC_UNSUPPORTED_MEDIA_TYPE,
+        "Expecting " + JSON_UTF_8.toString() + " content type");
+  }
+
+  @Test
+  public void testDoPostErrorWhileSendingErrorMessage() throws Exception {
+    doThrow(new IOException(ERR_MSG)).when(req).getReader();
+    doThrow(new IOException("someOtherError")).when(rsp)
+        .sendError(SC_BAD_REQUEST, ERR_MSG);
+    eventRestApiServlet.doPost(req, rsp);
+  }
+
+  static class RefReplicationDoneEvent extends RefEvent {
+    public static final String TYPE = "ref-replication-done";
+    public final String project;
+    public final String ref;
+    public final int nodesCount;
+
+    public RefReplicationDoneEvent(String project, String ref, int nodesCount) {
+      super(TYPE);
+      this.project = project;
+      this.ref = ref;
+      this.nodesCount = nodesCount;
+    }
+
+    @Override
+    public Project.NameKey getProjectNameKey() {
+      return new Project.NameKey(project);
+    }
+
+    @Override
+    public String getRefName() {
+      return ref;
+    }
+  }
+}
diff --git a/src/test/java/com/ericsson/gerrit/plugins/evictcache/GsonParserTest.java b/src/test/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/GsonParserTest.java
similarity index 86%
rename from src/test/java/com/ericsson/gerrit/plugins/evictcache/GsonParserTest.java
rename to src/test/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/GsonParserTest.java
index 638456d..b72c21a 100644
--- a/src/test/java/com/ericsson/gerrit/plugins/evictcache/GsonParserTest.java
+++ b/src/test/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/GsonParserTest.java
@@ -12,13 +12,15 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package com.ericsson.gerrit.plugins.evictcache;
+package com.ericsson.gerrit.plugins.highavailability.forwarder.rest;
 
 import static com.google.common.truth.Truth.assertThat;
 
 import com.google.gerrit.reviewdb.client.Account;
 import com.google.gerrit.reviewdb.client.AccountGroup;
 
+import com.ericsson.gerrit.plugins.highavailability.cache.Constants;
+
 import org.junit.Test;
 
 public class GsonParserTest {
@@ -52,8 +54,9 @@
   @Test
   public void StringParse() {
     String key = "key";
-    String json = GsonParser.toJson(Constants.DEFAULT, key);
-    assertThat(key).isEqualTo(GsonParser.fromJson(Constants.DEFAULT, json));
+    String json = GsonParser.toJson(Constants.PROJECTS, key);
+    assertThat(key)
+        .isEqualTo(GsonParser.fromJson(Constants.PROJECTS, json));
   }
 
   @Test
diff --git a/src/test/java/com/ericsson/gerrit/plugins/evictcache/HttpClientProviderTest.java b/src/test/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/HttpClientProviderTest.java
similarity index 80%
rename from src/test/java/com/ericsson/gerrit/plugins/evictcache/HttpClientProviderTest.java
rename to src/test/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/HttpClientProviderTest.java
index e64cf7c..8c01516 100644
--- a/src/test/java/com/ericsson/gerrit/plugins/evictcache/HttpClientProviderTest.java
+++ b/src/test/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/HttpClientProviderTest.java
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package com.ericsson.gerrit.plugins.evictcache;
+package com.ericsson.gerrit.plugins.highavailability.forwarder.rest;
 
 import static com.google.common.truth.Truth.assertThat;
 import static org.mockito.Mockito.when;
@@ -22,6 +22,8 @@
 import com.google.inject.Injector;
 import com.google.inject.Scopes;
 
+import com.ericsson.gerrit.plugins.highavailability.Configuration;
+
 import org.apache.http.impl.client.CloseableHttpClient;
 import org.junit.Before;
 import org.junit.Test;
@@ -49,12 +51,14 @@
   @Test
   public void testGet() throws Exception {
     Injector injector = Guice.createInjector(new TestModule());
-    CloseableHttpClient httpClient1 =
-        injector.getInstance(CloseableHttpClient.class);
-    assertThat(httpClient1).isNotNull();
-    CloseableHttpClient httpClient2 =
-        injector.getInstance(CloseableHttpClient.class);
-    assertThat(httpClient1).isEqualTo(httpClient2);
+    try (CloseableHttpClient httpClient1 =
+        injector.getInstance(CloseableHttpClient.class)) {
+      assertThat(httpClient1).isNotNull();
+      try (CloseableHttpClient httpClient2 =
+          injector.getInstance(CloseableHttpClient.class)) {
+        assertThat(httpClient1).isEqualTo(httpClient2);
+      }
+    }
   }
 
   class TestModule extends LifecycleModule {
diff --git a/src/test/java/com/ericsson/gerrit/plugins/evictcache/CacheResponseHandlerTest.java b/src/test/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/HttpResponseHandlerTest.java
similarity index 83%
rename from src/test/java/com/ericsson/gerrit/plugins/evictcache/CacheResponseHandlerTest.java
rename to src/test/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/HttpResponseHandlerTest.java
index 8e94727..b612770 100644
--- a/src/test/java/com/ericsson/gerrit/plugins/evictcache/CacheResponseHandlerTest.java
+++ b/src/test/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/HttpResponseHandlerTest.java
@@ -12,13 +12,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package com.ericsson.gerrit.plugins.evictcache;
+package com.ericsson.gerrit.plugins.highavailability.forwarder.rest;
 
 import static com.google.common.truth.Truth.assertThat;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
-import com.ericsson.gerrit.plugins.evictcache.CacheResponseHandler.CacheResult;
+import com.ericsson.gerrit.plugins.highavailability.forwarder.rest.HttpResponseHandler.HttpResult;
 
 import org.apache.http.HttpResponse;
 import org.apache.http.StatusLine;
@@ -28,23 +28,23 @@
 
 import java.io.UnsupportedEncodingException;
 
-public class CacheResponseHandlerTest {
+public class HttpResponseHandlerTest {
   private static final int ERROR = 400;
   private static final int OK = 204;
   private static final String EMPTY_ENTITY = "";
   private static final String ERROR_ENTITY = "Error";
 
-  private CacheResponseHandler handler;
+  private HttpResponseHandler handler;
 
   @Before
   public void setUp() throws Exception {
-    handler = new CacheResponseHandler();
+    handler = new HttpResponseHandler();
   }
 
   @Test
   public void testIsSuccessful() throws Exception {
     HttpResponse response = setupMocks(OK, EMPTY_ENTITY);
-    CacheResult result = handler.handleResponse(response);
+    HttpResult result = handler.handleResponse(response);
     assertThat(result.isSuccessful()).isTrue();
     assertThat(result.getMessage()).isEmpty();
   }
@@ -52,7 +52,7 @@
   @Test
   public void testIsNotSuccessful() throws Exception {
     HttpResponse response = setupMocks(ERROR, ERROR_ENTITY);
-    CacheResult result = handler.handleResponse(response);
+    HttpResult result = handler.handleResponse(response);
     assertThat(result.isSuccessful()).isFalse();
     assertThat(result.getMessage()).contains(ERROR_ENTITY);
   }
diff --git a/src/test/java/com/ericsson/gerrit/plugins/evictcache/HttpSessionTest.java b/src/test/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/HttpSessionTest.java
similarity index 64%
rename from src/test/java/com/ericsson/gerrit/plugins/evictcache/HttpSessionTest.java
rename to src/test/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/HttpSessionTest.java
index f45e52d..7b556b7 100644
--- a/src/test/java/com/ericsson/gerrit/plugins/evictcache/HttpSessionTest.java
+++ b/src/test/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/HttpSessionTest.java
@@ -12,23 +12,25 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package com.ericsson.gerrit.plugins.evictcache;
+package com.ericsson.gerrit.plugins.highavailability.forwarder.rest;
 
 import static com.github.tomakehurst.wiremock.client.WireMock.aResponse;
+import static com.github.tomakehurst.wiremock.client.WireMock.delete;
+import static com.github.tomakehurst.wiremock.client.WireMock.equalTo;
 import static com.github.tomakehurst.wiremock.client.WireMock.post;
-import static com.github.tomakehurst.wiremock.client.WireMock.stubFor;
 import static com.github.tomakehurst.wiremock.client.WireMock.urlEqualTo;
 import static com.google.common.truth.Truth.assertThat;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
-import com.ericsson.gerrit.plugins.evictcache.CacheResponseHandler.CacheResult;
+import com.ericsson.gerrit.plugins.highavailability.Configuration;
+import com.ericsson.gerrit.plugins.highavailability.forwarder.rest.HttpResponseHandler.HttpResult;
 import com.github.tomakehurst.wiremock.http.Fault;
 import com.github.tomakehurst.wiremock.junit.WireMockRule;
 import com.github.tomakehurst.wiremock.stubbing.Scenario;
 
 import org.junit.Before;
-import org.junit.Rule;
+import org.junit.ClassRule;
 import org.junit.Test;
 
 import java.net.SocketTimeoutException;
@@ -42,8 +44,8 @@
   private static final int NOT_FOUND = 404;
   private static final int UNAUTHORIZED = 401;
 
-  private static final String ENDPOINT = Constants.ENDPOINT_BASE + "cache";
-  private static final String EMPTYJSON = "{}";
+  private static final String ENDPOINT = "/plugins/high-availability/index/1";
+  private static final String BODY = "SerializedEvent";
   private static final String ERROR_MESSAGE = "Error message";
   private static final String REQUEST_MADE = "Request made";
   private static final String SECOND_TRY = "Second try";
@@ -53,13 +55,14 @@
 
   private HttpSession httpSession;
 
-  @Rule
-  public WireMockRule wireMockRule = new WireMockRule(Constants.PORT);
+  @ClassRule
+  public static WireMockRule wireMockRule = new WireMockRule(0);
 
   @Before
   public void setUp() throws Exception {
+    String url = "http://localhost:" + wireMockRule.port();
     Configuration cfg = mock(Configuration.class);
-    when(cfg.getUrl()).thenReturn(Constants.URL);
+    when(cfg.getUrl()).thenReturn(url);
     when(cfg.getUser()).thenReturn("user");
     when(cfg.getPassword()).thenReturn("pass");
     when(cfg.getMaxTries()).thenReturn(MAX_TRIES);
@@ -68,22 +71,40 @@
     when(cfg.getRetryInterval()).thenReturn(RETRY_INTERVAL);
 
     httpSession =
-        new HttpSession(new HttpClientProvider(cfg).get(), Constants.URL);
+        new HttpSession(new HttpClientProvider(cfg).get(), url);
+    wireMockRule.resetRequests();
   }
 
   @Test
-  public void testResponseOK() throws Exception {
-    stubFor(post(urlEqualTo(ENDPOINT)).willReturn(aResponse().withStatus(OK)));
-    assertThat(httpSession.post(ENDPOINT, EMPTYJSON).isSuccessful()).isTrue();
+  public void testPostResponseOK() throws Exception {
+    wireMockRule.givenThat(post(urlEqualTo(ENDPOINT))
+        .willReturn(aResponse().withStatus(OK)));
+
+    assertThat(httpSession.post(ENDPOINT).isSuccessful()).isTrue();
+  }
+
+  @Test
+  public void testPostResponseWithContentOK() throws Exception {
+    wireMockRule.givenThat(post(urlEqualTo(ENDPOINT))
+        .withRequestBody(equalTo(BODY)).willReturn(aResponse().withStatus(OK)));
+    assertThat(httpSession.post(ENDPOINT, BODY).isSuccessful()).isTrue();
+  }
+
+  @Test
+  public void testDeleteResponseOK() throws Exception {
+    wireMockRule.givenThat(delete(urlEqualTo(ENDPOINT))
+        .willReturn(aResponse().withStatus(OK)));
+
+    assertThat(httpSession.delete(ENDPOINT).isSuccessful()).isTrue();
   }
 
   @Test
   public void testNotAuthorized() throws Exception {
     String expected = "unauthorized";
-    stubFor(post(urlEqualTo(ENDPOINT)).willReturn(
-        aResponse().withStatus(UNAUTHORIZED).withBody(expected)));
+    wireMockRule.givenThat(post(urlEqualTo(ENDPOINT))
+        .willReturn(aResponse().withStatus(UNAUTHORIZED).withBody(expected)));
 
-    CacheResult result = httpSession.post(ENDPOINT, EMPTYJSON);
+    HttpResult result = httpSession.post(ENDPOINT);
     assertThat(result.isSuccessful()).isFalse();
     assertThat(result.getMessage()).isEqualTo(expected);
   }
@@ -91,46 +112,46 @@
   @Test
   public void testNotFound() throws Exception {
     String expected = "not found";
-    stubFor(post(urlEqualTo(ENDPOINT)).willReturn(
-        aResponse().withStatus(NOT_FOUND).withBody(expected)));
+    wireMockRule.givenThat(post(urlEqualTo(ENDPOINT))
+        .willReturn(aResponse().withStatus(NOT_FOUND).withBody(expected)));
 
-    CacheResult result = httpSession.post(ENDPOINT, EMPTYJSON);
+    HttpResult result = httpSession.post(ENDPOINT);
     assertThat(result.isSuccessful()).isFalse();
     assertThat(result.getMessage()).isEqualTo(expected);
   }
 
   @Test
   public void testBadResponseRetryThenOK() throws Exception {
-    stubFor(post(urlEqualTo(ENDPOINT)).inScenario(RETRY_AT_ERROR)
+    wireMockRule.givenThat(post(urlEqualTo(ENDPOINT)).inScenario(RETRY_AT_ERROR)
         .whenScenarioStateIs(Scenario.STARTED).willSetStateTo(REQUEST_MADE)
         .willReturn(aResponse().withStatus(ERROR)));
-    stubFor(post(urlEqualTo(ENDPOINT)).inScenario(RETRY_AT_ERROR)
+    wireMockRule.givenThat(post(urlEqualTo(ENDPOINT)).inScenario(RETRY_AT_ERROR)
         .whenScenarioStateIs(REQUEST_MADE)
         .willReturn(aResponse().withStatus(OK)));
 
-    assertThat(httpSession.post(ENDPOINT, EMPTYJSON).isSuccessful()).isTrue();
+    assertThat(httpSession.post(ENDPOINT).isSuccessful()).isTrue();
   }
 
   @Test
   public void testBadResponseRetryThenGiveUp() throws Exception {
-    stubFor(post(urlEqualTo(ENDPOINT)).willReturn(
-        aResponse().withStatus(ERROR).withBody(ERROR_MESSAGE)));
+    wireMockRule.givenThat(post(urlEqualTo(ENDPOINT))
+        .willReturn(aResponse().withStatus(ERROR).withBody(ERROR_MESSAGE)));
 
-    assertThat(httpSession.post(ENDPOINT, EMPTYJSON).isSuccessful()).isFalse();
-    assertThat(httpSession.post(ENDPOINT, EMPTYJSON).getMessage())
-        .isEqualTo(ERROR_MESSAGE);
+    HttpResult result = httpSession.post(ENDPOINT);
+    assertThat(result.isSuccessful()).isFalse();
+    assertThat(result.getMessage()).isEqualTo(ERROR_MESSAGE);
   }
 
   @Test
   public void testRetryAfterDelay() throws Exception {
-    stubFor(post(urlEqualTo(ENDPOINT)).inScenario(RETRY_AT_DELAY)
+    wireMockRule.givenThat(post(urlEqualTo(ENDPOINT)).inScenario(RETRY_AT_DELAY)
         .whenScenarioStateIs(Scenario.STARTED).willSetStateTo(REQUEST_MADE)
         .willReturn(aResponse().withStatus(ERROR).withFixedDelay(TIMEOUT / 2)));
-    stubFor(post(urlEqualTo(ENDPOINT)).inScenario(RETRY_AT_DELAY)
+    wireMockRule.givenThat(post(urlEqualTo(ENDPOINT)).inScenario(RETRY_AT_DELAY)
         .whenScenarioStateIs(REQUEST_MADE)
         .willReturn(aResponse().withStatus(OK)));
 
-    assertThat(httpSession.post(ENDPOINT, EMPTYJSON).isSuccessful()).isTrue();
+    assertThat(httpSession.post(ENDPOINT).isSuccessful()).isTrue();
   }
 
   @Test
@@ -148,7 +169,7 @@
         .whenScenarioStateIs(THIRD_TRY)
         .willReturn(aResponse().withStatus(OK)));
 
-    assertThat(httpSession.post(ENDPOINT, EMPTYJSON).isSuccessful()).isTrue();
+    assertThat(httpSession.post(ENDPOINT).isSuccessful()).isTrue();
   }
 
   @Test(expected = SocketTimeoutException.class)
@@ -166,23 +187,23 @@
         .whenScenarioStateIs(THIRD_TRY)
         .willReturn(aResponse().withFixedDelay(TIMEOUT)));
 
-    httpSession.post(ENDPOINT, EMPTYJSON);
+    httpSession.post(ENDPOINT);
   }
 
   @Test
   public void testGiveUpAtTimeout() throws Exception {
-    stubFor(post(urlEqualTo(ENDPOINT)).inScenario(RETRY_AT_DELAY)
+    wireMockRule.givenThat(post(urlEqualTo(ENDPOINT)).inScenario(RETRY_AT_DELAY)
         .whenScenarioStateIs(Scenario.STARTED).willSetStateTo(REQUEST_MADE)
         .willReturn(aResponse().withStatus(ERROR).withFixedDelay(TIMEOUT)));
 
-    assertThat(httpSession.post(ENDPOINT, EMPTYJSON).isSuccessful()).isFalse();
+    assertThat(httpSession.post(ENDPOINT).isSuccessful()).isFalse();
   }
 
   @Test
   public void testResponseWithMalformedResponse() throws Exception {
-    stubFor(post(urlEqualTo(ENDPOINT)).willReturn(
-        aResponse().withFault(Fault.MALFORMED_RESPONSE_CHUNK)));
+    wireMockRule.givenThat(post(urlEqualTo(ENDPOINT))
+        .willReturn(aResponse().withFault(Fault.MALFORMED_RESPONSE_CHUNK)));
 
-    assertThat(httpSession.post(ENDPOINT, EMPTYJSON).isSuccessful()).isFalse();
+    assertThat(httpSession.post(ENDPOINT).isSuccessful()).isFalse();
   }
 }
diff --git a/src/test/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/IndexRestApiServletTest.java b/src/test/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/IndexRestApiServletTest.java
new file mode 100644
index 0000000..3aa7009
--- /dev/null
+++ b/src/test/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/IndexRestApiServletTest.java
@@ -0,0 +1,169 @@
+// Copyright (C) 2016 Ericsson
+//
+// 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.ericsson.gerrit.plugins.highavailability.forwarder.rest;
+
+import static javax.servlet.http.HttpServletResponse.SC_CONFLICT;
+import static javax.servlet.http.HttpServletResponse.SC_NOT_FOUND;
+import static javax.servlet.http.HttpServletResponse.SC_NO_CONTENT;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.when;
+
+import com.google.gerrit.common.TimeUtil;
+import com.google.gerrit.reviewdb.client.Change;
+import com.google.gerrit.reviewdb.server.ChangeAccess;
+import com.google.gerrit.reviewdb.server.ReviewDb;
+import com.google.gerrit.server.index.change.ChangeIndexer;
+import com.google.gwtorm.client.KeyUtil;
+import com.google.gwtorm.server.OrmException;
+import com.google.gwtorm.server.SchemaFactory;
+import com.google.gwtorm.server.StandardKeyEncoder;
+
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.io.IOException;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@RunWith(MockitoJUnitRunner.class)
+public class IndexRestApiServletTest {
+  private static final boolean CHANGE_EXISTS = true;
+  private static final boolean CHANGE_DOES_NOT_EXIST = false;
+  private static final boolean DO_NOT_THROW_IO_EXCEPTION = false;
+  private static final boolean DO_NOT_THROW_ORM_EXCEPTION = false;
+  private static final boolean THROW_IO_EXCEPTION = true;
+  private static final boolean THROW_ORM_EXCEPTION = true;
+  private static final String CHANGE_NUMBER = "1";
+
+  @Mock
+  private ChangeIndexer indexer;
+  @Mock
+  private SchemaFactory<ReviewDb> schemaFactory;
+  @Mock
+  private ReviewDb db;
+  @Mock
+  private HttpServletRequest req;
+  @Mock
+  private HttpServletResponse rsp;
+  private Change.Id id;
+  private Change change;
+  private IndexRestApiServlet indexRestApiServlet;
+
+  @BeforeClass
+  public static void setup() {
+    KeyUtil.setEncoderImpl(new StandardKeyEncoder());
+  }
+
+  @Before
+  public void setUpMocks() {
+    indexRestApiServlet = new IndexRestApiServlet(indexer, schemaFactory);
+    id = Change.Id.parse(CHANGE_NUMBER);
+    when(req.getPathInfo()).thenReturn("/index/" + CHANGE_NUMBER);
+    change = new Change(null, id, null, null, TimeUtil.nowTs());
+  }
+
+  @Test
+  public void changeIsIndexed() throws Exception {
+    setupPostMocks(CHANGE_EXISTS);
+    indexRestApiServlet.doPost(req, rsp);
+    verify(indexer, times(1)).index(db, change);
+    verify(rsp).setStatus(SC_NO_CONTENT);
+  }
+
+  @Test
+  public void changeToIndexDoNotExist() throws Exception {
+    setupPostMocks(CHANGE_DOES_NOT_EXIST);
+    indexRestApiServlet.doPost(req, rsp);
+    verify(indexer, times(1)).delete(id);
+    verify(rsp).setStatus(SC_NO_CONTENT);
+  }
+
+  @Test
+  public void schemaThrowsExceptionWhenLookingUpForChange() throws Exception {
+    setupPostMocks(CHANGE_EXISTS, THROW_ORM_EXCEPTION);
+    indexRestApiServlet.doPost(req, rsp);
+    verify(rsp).sendError(SC_NOT_FOUND, "Error trying to find a change \n");
+  }
+
+  @Test
+  public void indexerThrowsIOExceptionTryingToIndexChange() throws Exception {
+    setupPostMocks(CHANGE_EXISTS, DO_NOT_THROW_ORM_EXCEPTION,
+        THROW_IO_EXCEPTION);
+    indexRestApiServlet.doPost(req, rsp);
+    verify(rsp).sendError(SC_CONFLICT, "io-error");
+  }
+
+  @Test
+  public void changeIsDeletedFromIndex() throws Exception {
+    indexRestApiServlet.doDelete(req, rsp);
+    verify(indexer, times(1)).delete(id);
+    verify(rsp).setStatus(SC_NO_CONTENT);
+  }
+
+  @Test
+  public void indexerThrowsExceptionTryingToDeleteChange() throws Exception {
+    doThrow(new IOException("io-error")).when(indexer).delete(id);
+    indexRestApiServlet.doDelete(req, rsp);
+    verify(rsp).sendError(SC_CONFLICT, "io-error");
+  }
+
+  @Test
+  public void sendErrorThrowsIOException() throws Exception {
+    doThrow(new IOException("someError")).when(rsp).sendError(SC_NOT_FOUND,
+        "Error trying to find a change \n");
+    setupPostMocks(CHANGE_EXISTS, THROW_ORM_EXCEPTION);
+    indexRestApiServlet.doPost(req, rsp);
+    verify(rsp).sendError(SC_NOT_FOUND, "Error trying to find a change \n");
+    verifyZeroInteractions(indexer);
+  }
+
+  private void setupPostMocks(boolean changeExist) throws Exception {
+    setupPostMocks(changeExist, DO_NOT_THROW_ORM_EXCEPTION,
+        DO_NOT_THROW_IO_EXCEPTION);
+  }
+
+  private void setupPostMocks(boolean changeExist, boolean ormException)
+      throws OrmException, IOException {
+    setupPostMocks(changeExist, ormException, DO_NOT_THROW_IO_EXCEPTION);
+  }
+
+  private void setupPostMocks(boolean changeExist, boolean ormException,
+      boolean ioException) throws OrmException, IOException {
+    if (ormException) {
+      doThrow(new OrmException("")).when(schemaFactory).open();
+    } else {
+      when(schemaFactory.open()).thenReturn(db);
+      ChangeAccess ca = mock(ChangeAccess.class);
+      when(db.changes()).thenReturn(ca);
+      if (changeExist) {
+        when(ca.get(id)).thenReturn(change);
+        if (ioException) {
+          doThrow(new IOException("io-error")).when(indexer).index(db, change);
+        }
+      } else {
+        when(ca.get(id)).thenReturn(null);
+      }
+    }
+  }
+}
diff --git a/src/test/java/com/ericsson/gerrit/plugins/evictcache/ModuleTest.java b/src/test/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/RestForwarderModuleTest.java
similarity index 72%
rename from src/test/java/com/ericsson/gerrit/plugins/evictcache/ModuleTest.java
rename to src/test/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/RestForwarderModuleTest.java
index 479ed90..ceedd2f 100644
--- a/src/test/java/com/ericsson/gerrit/plugins/evictcache/ModuleTest.java
+++ b/src/test/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/RestForwarderModuleTest.java
@@ -12,23 +12,24 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package com.ericsson.gerrit.plugins.evictcache;
+package com.ericsson.gerrit.plugins.highavailability.forwarder.rest;
 
 import static com.google.common.truth.Truth.assertThat;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
+import com.ericsson.gerrit.plugins.highavailability.Configuration;
+
 import org.junit.Test;
 
-public class ModuleTest {
+public class RestForwarderModuleTest {
 
   @Test
-  public void testSyncUrlProvider() {
+  public void testForwardUrlProvider() {
     Configuration configMock = mock(Configuration.class);
     String expected = "someUrl";
     when(configMock.getUrl()).thenReturn(expected);
-
-    Module module = new Module();
-    assertThat(module.syncUrl(configMock)).isEqualTo(expected);
+    RestForwarderModule module = new RestForwarderModule();
+    assertThat(module.forwardUrl(configMock)).isEqualTo(expected);
   }
 }
diff --git a/src/test/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/RestForwarderTest.java b/src/test/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/RestForwarderTest.java
new file mode 100644
index 0000000..72e2462
--- /dev/null
+++ b/src/test/java/com/ericsson/gerrit/plugins/highavailability/forwarder/rest/RestForwarderTest.java
@@ -0,0 +1,232 @@
+// Copyright (C) 2015 Ericsson
+//
+// 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.ericsson.gerrit.plugins.highavailability.forwarder.rest;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import com.google.common.base.Joiner;
+import com.google.gerrit.reviewdb.client.Account;
+import com.google.gerrit.reviewdb.client.AccountGroup;
+import com.google.gerrit.server.events.Event;
+import com.google.gson.GsonBuilder;
+
+import com.ericsson.gerrit.plugins.highavailability.cache.Constants;
+import com.ericsson.gerrit.plugins.highavailability.forwarder.rest.HttpResponseHandler.HttpResult;
+
+import org.junit.Test;
+
+import java.io.IOException;
+
+public class RestForwarderTest {
+  private static final String PLUGIN_NAME = "high-availability";
+  private static final String EMPTY_MSG = "";
+  private static final String ERROR_MSG = "Error";
+  private static final String EXCEPTION_MSG = "Exception";
+  private static final boolean SUCCESSFUL = true;
+  private static final boolean FAILED = false;
+  private static final boolean DO_NOT_THROW_EXCEPTION = false;
+  private static final boolean THROW_EXCEPTION = true;
+
+  //Index
+  private static final int CHANGE_NUMBER = 1;
+  private static final String DELETE_OP = "delete";
+  private static final String INDEX_OP = "index";
+
+  //Evict cache
+  private static final String EMPTY_JSON = "{}";
+  private static final String EMPTY_JSON2 = "\"{}\"";
+  private static final String ID_JSON = "{\"id\":0}";
+
+  private RestForwarder restForwarder;
+
+  @Test
+  public void testIndexChangeOK() throws Exception {
+    setUpMocksForIndex(INDEX_OP, SUCCESSFUL, EMPTY_MSG, DO_NOT_THROW_EXCEPTION);
+    assertThat(restForwarder.indexChange(CHANGE_NUMBER)).isTrue();
+  }
+
+  @Test
+  public void testIndexChangeFailed() throws Exception {
+    setUpMocksForIndex(INDEX_OP, FAILED, ERROR_MSG, DO_NOT_THROW_EXCEPTION);
+    assertThat(restForwarder.indexChange(CHANGE_NUMBER)).isFalse();
+  }
+
+  @Test
+  public void testIndexChangeThrowsException() throws Exception {
+    setUpMocksForIndex(INDEX_OP, FAILED, EXCEPTION_MSG, THROW_EXCEPTION);
+    assertThat(restForwarder.indexChange(CHANGE_NUMBER)).isFalse();
+  }
+
+  @Test
+  public void testChangeDeletedFromIndexOK() throws Exception {
+    setUpMocksForIndex(DELETE_OP, SUCCESSFUL, EMPTY_MSG,
+        DO_NOT_THROW_EXCEPTION);
+    assertThat(restForwarder.deleteChangeFromIndex(CHANGE_NUMBER)).isTrue();
+  }
+
+  @Test
+  public void testChangeDeletedFromIndexFailed() throws Exception {
+    setUpMocksForIndex(DELETE_OP, FAILED, ERROR_MSG, DO_NOT_THROW_EXCEPTION);
+    assertThat(restForwarder.deleteChangeFromIndex(CHANGE_NUMBER)).isFalse();
+  }
+
+  @Test
+  public void testChangeDeletedFromThrowsException() throws Exception {
+    setUpMocksForIndex(DELETE_OP, FAILED, EXCEPTION_MSG, THROW_EXCEPTION);
+    assertThat(restForwarder.deleteChangeFromIndex(CHANGE_NUMBER)).isFalse();
+  }
+
+  private void setUpMocksForIndex(String operation,
+      boolean isOperationSuccessful, String msg, boolean exception)
+      throws Exception {
+    String request =
+        Joiner.on("/").join("/plugins", PLUGIN_NAME, INDEX_OP, CHANGE_NUMBER);
+    HttpSession httpSession = mock(HttpSession.class);
+    if (exception) {
+      if (operation.equals(INDEX_OP)) {
+        doThrow(new IOException()).when(httpSession).post(request);
+      } else {
+        doThrow(new IOException()).when(httpSession).delete(request);
+      }
+    } else {
+      HttpResult result = new HttpResult(isOperationSuccessful, msg);
+      if (operation.equals(INDEX_OP)) {
+        when(httpSession.post(request)).thenReturn(result);
+      } else {
+        when(httpSession.delete(request)).thenReturn(result);
+      }
+    }
+    restForwarder = new RestForwarder(httpSession, PLUGIN_NAME);
+  }
+
+  @Test
+  public void testEventSentOK() throws Exception {
+    Event event = setUpMocksForEvent(SUCCESSFUL, EMPTY_MSG, DO_NOT_THROW_EXCEPTION);
+    assertThat(restForwarder.send(event)).isTrue();
+  }
+
+  @Test
+  public void testEventSentFailed() throws Exception {
+    Event event = setUpMocksForEvent(FAILED, ERROR_MSG, DO_NOT_THROW_EXCEPTION);
+    assertThat(restForwarder.send(event)).isFalse();
+  }
+
+  @Test
+  public void testEventSentThrowsException() throws Exception {
+    Event event = setUpMocksForEvent(FAILED, EXCEPTION_MSG, THROW_EXCEPTION);
+    assertThat(restForwarder.send(event)).isFalse();
+  }
+
+  private Event setUpMocksForEvent(boolean isOperationSuccessful, String msg,
+      boolean exception) throws Exception {
+    Event event = new EventTest();
+    String content = new GsonBuilder().create().toJson(event);
+    HttpSession httpSession = mock(HttpSession.class);
+    String request = Joiner.on("/").join("/plugins", PLUGIN_NAME, "event");
+    if (exception) {
+      doThrow(new IOException()).when(httpSession).post(request, content);
+    } else {
+      HttpResult result = new HttpResult(isOperationSuccessful, msg);
+      when(httpSession.post(request, content)).thenReturn(result);
+    }
+    restForwarder = new RestForwarder(httpSession, PLUGIN_NAME);
+    return event;
+  }
+
+  private class EventTest extends Event {
+    public EventTest() {
+      super("test-event");
+    }
+  }
+
+  @Test
+  public void testEvictCacheOK() throws Exception {
+    setupMocksForCache(Constants.PROJECTS, EMPTY_JSON2, SUCCESSFUL,
+        DO_NOT_THROW_EXCEPTION);
+    assertThat(restForwarder.evict(Constants.PROJECTS, EMPTY_JSON)).isTrue();
+  }
+
+  @Test
+  public void testEvictAccountsOK() throws Exception {
+    setupMocksForCache(Constants.ACCOUNTS, ID_JSON, SUCCESSFUL,
+        DO_NOT_THROW_EXCEPTION);
+    assertThat(restForwarder.evict(Constants.ACCOUNTS, mock(Account.Id.class)))
+        .isTrue();
+  }
+
+  @Test
+  public void testEvictGroupsOK() throws Exception {
+    setupMocksForCache(Constants.GROUPS, ID_JSON, SUCCESSFUL,
+        DO_NOT_THROW_EXCEPTION);
+    assertThat(
+        restForwarder.evict(Constants.GROUPS, mock(AccountGroup.Id.class)))
+            .isTrue();
+  }
+
+  @Test
+  public void testEvictGroupsByIncludeOK() throws Exception {
+    setupMocksForCache(Constants.GROUPS_BYINCLUDE, EMPTY_JSON, SUCCESSFUL,
+        DO_NOT_THROW_EXCEPTION);
+    assertThat(restForwarder.evict(Constants.GROUPS_BYINCLUDE,
+        mock(AccountGroup.UUID.class))).isTrue();
+  }
+
+  @Test
+  public void testEvictGroupsMembersOK() throws Exception {
+    setupMocksForCache(Constants.GROUPS_MEMBERS, EMPTY_JSON, SUCCESSFUL,
+        DO_NOT_THROW_EXCEPTION);
+    assertThat(restForwarder.evict(Constants.GROUPS_MEMBERS,
+        mock(AccountGroup.UUID.class))).isTrue();
+  }
+
+  @Test
+  public void testEvictProjectListOK() throws Exception {
+    setupMocksForCache(Constants.PROJECT_LIST, EMPTY_JSON, SUCCESSFUL,
+        DO_NOT_THROW_EXCEPTION);
+    assertThat(restForwarder.evict(Constants.PROJECT_LIST, new Object()))
+        .isTrue();
+  }
+
+  @Test
+  public void testEvictCacheFailed() throws Exception {
+    setupMocksForCache(Constants.PROJECTS, EMPTY_JSON2, FAILED,
+        DO_NOT_THROW_EXCEPTION);
+    assertThat(restForwarder.evict(Constants.PROJECTS, EMPTY_JSON)).isFalse();
+  }
+
+  @Test
+  public void testEvictCacheThrowsException() throws Exception {
+    setupMocksForCache(Constants.PROJECTS, EMPTY_JSON2, FAILED,
+        THROW_EXCEPTION);
+    assertThat(restForwarder.evict(Constants.PROJECTS, EMPTY_JSON)).isFalse();
+  }
+
+  private void setupMocksForCache(String cacheName, String json,
+      boolean isOperationSuccessful, boolean exception) throws IOException {
+    String request =
+        Joiner.on("/").join("/plugins", PLUGIN_NAME, "cache", cacheName);
+    HttpSession httpSession = mock(HttpSession.class);
+    if (exception) {
+      doThrow(new IOException()).when(httpSession).post(request, json);
+    } else {
+      HttpResult result = new HttpResult(isOperationSuccessful, "Error");
+      when(httpSession.post(request, json)).thenReturn(result);
+    }
+    restForwarder = new RestForwarder(httpSession, PLUGIN_NAME);
+  }
+}
diff --git a/src/test/java/com/ericsson/gerrit/plugins/highavailability/index/IndexEventHandlerTest.java b/src/test/java/com/ericsson/gerrit/plugins/highavailability/index/IndexEventHandlerTest.java
new file mode 100644
index 0000000..aa4c365
--- /dev/null
+++ b/src/test/java/com/ericsson/gerrit/plugins/highavailability/index/IndexEventHandlerTest.java
@@ -0,0 +1,129 @@
+// Copyright (C) 2015 Ericsson
+//
+// 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.ericsson.gerrit.plugins.highavailability.index;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
+
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.gerrit.reviewdb.client.Change;
+import com.google.gerrit.server.git.WorkQueue.Executor;
+import com.google.gwtorm.client.KeyUtil;
+import com.google.gwtorm.server.StandardKeyEncoder;
+
+import com.ericsson.gerrit.plugins.highavailability.forwarder.Context;
+import com.ericsson.gerrit.plugins.highavailability.forwarder.Forwarder;
+import com.ericsson.gerrit.plugins.highavailability.index.IndexEventHandler.IndexTask;
+
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class IndexEventHandlerTest {
+  private static final String PLUGIN_NAME = "high-availability";
+  private static final int CHANGE_ID = 1;
+
+  private IndexEventHandler indexEventHandler;
+  @Mock
+  private Forwarder forwarder;
+  private Change.Id id;
+
+  @BeforeClass
+  public static void setUp() {
+    KeyUtil.setEncoderImpl(new StandardKeyEncoder());
+  }
+
+  @Before
+  public void setUpMocks() {
+    id = Change.Id.parse(Integer.toString(CHANGE_ID));
+    indexEventHandler = new IndexEventHandler(MoreExecutors.directExecutor(),
+        PLUGIN_NAME, forwarder);
+  }
+
+  @Test
+  public void shouldIndexInRemoteOnChangeIndexedEvent() throws Exception {
+    indexEventHandler.onChangeIndexed(id.get());
+    verify(forwarder).indexChange(CHANGE_ID);
+  }
+
+  @Test
+  public void shouldDeleteFromIndexInRemoteOnChangeDeletedEvent()
+      throws Exception {
+    indexEventHandler.onChangeDeleted(id.get());
+    verify(forwarder).deleteChangeFromIndex(CHANGE_ID);
+  }
+
+  @Test
+  public void shouldNotCallRemoteWhenEventIsForwarded() throws Exception {
+    Context.setForwardedEvent(true);
+    indexEventHandler.onChangeIndexed(id.get());
+    indexEventHandler.onChangeDeleted(id.get());
+    Context.unsetForwardedEvent();
+    verifyZeroInteractions(forwarder);
+  }
+
+  @Test
+  public void duplicateEventOfAQueuedEventShouldGetDiscarded() {
+    Executor poolMock = mock(Executor.class);
+    indexEventHandler =
+        new IndexEventHandler(poolMock, PLUGIN_NAME, forwarder);
+    indexEventHandler.onChangeIndexed(id.get());
+    indexEventHandler.onChangeIndexed(id.get());
+    verify(poolMock, times(1))
+        .execute(indexEventHandler.new IndexTask(CHANGE_ID, false));
+  }
+
+  @Test
+  public void testIndexTaskToString() throws Exception {
+    IndexTask indexTask =
+        indexEventHandler.new IndexTask(CHANGE_ID, false);
+    assertThat(indexTask.toString()).isEqualTo(String.format(
+        "[%s] Index change %s in target instance", PLUGIN_NAME, CHANGE_ID));
+  }
+
+  @Test
+  public void testIndexTaskHashCodeAndEquals() {
+    IndexTask task = indexEventHandler.new IndexTask(CHANGE_ID, false);
+
+    assertThat(task.equals(task)).isTrue();
+    assertThat(task.hashCode()).isEqualTo(task.hashCode());
+
+    IndexTask identicalTask =
+        indexEventHandler.new IndexTask(CHANGE_ID, false);
+    assertThat(task.equals(identicalTask)).isTrue();
+    assertThat(task.hashCode()).isEqualTo(identicalTask.hashCode());
+
+    assertThat(task.equals(null)).isFalse();
+    assertThat(task.equals("test")).isFalse();
+    assertThat(task.hashCode()).isNotEqualTo("test".hashCode());
+
+    IndexTask differentChangeIdTask =
+        indexEventHandler.new IndexTask(123, false);
+    assertThat(task.equals(differentChangeIdTask)).isFalse();
+    assertThat(task.hashCode()).isNotEqualTo(differentChangeIdTask.hashCode());
+
+    IndexTask removeTask =
+        indexEventHandler.new IndexTask(CHANGE_ID, true);
+    assertThat(task.equals(removeTask)).isFalse();
+    assertThat(task.hashCode()).isNotEqualTo(removeTask.hashCode());
+  }
+}
diff --git a/src/test/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheExecutorProviderTest.java b/src/test/java/com/ericsson/gerrit/plugins/highavailability/index/IndexExecutorProviderTest.java
similarity index 64%
rename from src/test/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheExecutorProviderTest.java
rename to src/test/java/com/ericsson/gerrit/plugins/highavailability/index/IndexExecutorProviderTest.java
index a01b187..3db194b 100644
--- a/src/test/java/com/ericsson/gerrit/plugins/evictcache/EvictCacheExecutorProviderTest.java
+++ b/src/test/java/com/ericsson/gerrit/plugins/highavailability/index/IndexExecutorProviderTest.java
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package com.ericsson.gerrit.plugins.evictcache;
+package com.ericsson.gerrit.plugins.highavailability.index;
 
 import static com.google.common.truth.Truth.assertThat;
 import static org.mockito.Mockito.mock;
@@ -21,6 +21,8 @@
 
 import com.google.gerrit.server.git.WorkQueue;
 
+import com.ericsson.gerrit.plugins.highavailability.Configuration;
+
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -28,37 +30,35 @@
 import org.mockito.junit.MockitoJUnitRunner;
 
 @RunWith(MockitoJUnitRunner.class)
-public class EvictCacheExecutorProviderTest {
-  private static final String PLUGIN_NAME = "evict-cache";
-
+public class IndexExecutorProviderTest {
   @Mock
   private WorkQueue.Executor executorMock;
-  private EvictCacheExecutorProvider evictCacheExecutorProvider;
+  private IndexExecutorProvider indexExecutorProvider;
 
   @Before
   public void setUp() throws Exception {
+    executorMock = mock(WorkQueue.Executor.class);
     WorkQueue workQueueMock = mock(WorkQueue.class);
-    when(workQueueMock.createQueue(4,
-        "Evict cache [" + PLUGIN_NAME + " plugin]")).thenReturn(executorMock);
+    when(workQueueMock.createQueue(4, "Forward-index-event"))
+        .thenReturn(executorMock);
     Configuration configMock = mock(Configuration.class);
-    when(configMock.getThreadPoolSize()).thenReturn(4);
-
-    evictCacheExecutorProvider =
-        new EvictCacheExecutorProvider(workQueueMock, PLUGIN_NAME, configMock);
+    when(configMock.getIndexThreadPoolSize()).thenReturn(4);
+    indexExecutorProvider =
+        new IndexExecutorProvider(workQueueMock, configMock);
   }
 
   @Test
   public void shouldReturnExecutor() throws Exception {
-    assertThat(evictCacheExecutorProvider.get()).isEqualTo(executorMock);
+    assertThat(indexExecutorProvider.get()).isEqualTo(executorMock);
   }
 
   @Test
   public void testStop() throws Exception {
-    evictCacheExecutorProvider.start();
-    assertThat(evictCacheExecutorProvider.get()).isEqualTo(executorMock);
-    evictCacheExecutorProvider.stop();
+    indexExecutorProvider.start();
+    assertThat(indexExecutorProvider.get()).isEqualTo(executorMock);
+    indexExecutorProvider.stop();
     verify(executorMock).shutdown();
     verify(executorMock).unregisterWorkQueue();
-    assertThat(evictCacheExecutorProvider.get()).isNull();
+    assertThat(indexExecutorProvider.get()).isNull();
   }
 }