diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..72f041f
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,6 @@
+/.classpath
+/.primary_build_tool
+/.project
+/.settings/
+/bazel-*
+/eclipse-out/
diff --git a/BUILD b/BUILD
new file mode 100644
index 0000000..98aa1c2
--- /dev/null
+++ b/BUILD
@@ -0,0 +1,91 @@
+load("//tools/bzl:junit.bzl", "junit_tests")
+load(
+    "//tools/bzl:plugin.bzl",
+    "PLUGIN_TEST_DEPS",
+    "gerrit_plugin",
+)
+
+CONDUCTOR_DEPS = [
+    "@postgresql//jar",
+    "@dbcp//jar",
+    "@pool//jar",
+]
+
+EXECUTOR_DEPS = CONDUCTOR_DEPS + [
+    "@jgit//jar",
+    "@javaewah//jar",
+    "@guava//jar",
+    "@guice//jar",
+    "@guice-assistedinject//jar",
+    "@javax_inject//jar",
+    "@aopalliance//jar",
+    "@slf4j-api//jar",
+    "@log4j-slf4j-impl//jar",
+    "@log4j-api//jar",
+    "@log4j-core//jar",
+    "@retry//jar",
+]
+
+gerrit_plugin(
+    name = "gc-conductor",
+    srcs = glob(
+        ["src/main/java/**/*.java"],
+        exclude = ["**/executor/**"],
+    ),
+    manifest_entries = [
+        "Gerrit-PluginName: gc-conductor",
+        "Gerrit-Module: com.ericsson.gerrit.plugins.gcconductor.evaluator.EvaluatorModule",
+        "Gerrit-SshModule: com.ericsson.gerrit.plugins.gcconductor.command.SshModule",
+        "Implementation-Title: gc-conductor plugin",
+        "Implementation-URL: https://gerrit-review.googlesource.com/admin/repos/plugins/gc-conductor",
+        "Implementation-Vendor: Ericsson",
+    ],
+    resources = glob(
+        ["src/main/resources/**/*"],
+        exclude = ["src/main/resources/log4j2.xml"],
+    ),
+    deps = CONDUCTOR_DEPS,
+)
+
+java_library(
+    name = "gc-executor_lib",
+    srcs = glob([
+        "src/main/java/com/ericsson/gerrit/plugins/gcconductor/*.java",
+        "src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/*.java",
+        "src/main/java/com/ericsson/gerrit/plugins/gcconductor/postgresqueue/*.java",
+    ]),
+    resources = glob([
+        "bin/**/*",
+        "src/main/resources/log4j2.xml",
+    ]),
+    deps = EXECUTOR_DEPS,
+)
+
+java_binary(
+    name = "gc-executor",
+    main_class = "com.ericsson.gerrit.plugins.gcconductor.executor.GcExecutor",
+    runtime_deps = [":gc-executor_lib"],
+)
+
+junit_tests(
+    name = "gc_conductor_tests",
+    srcs = glob(["src/test/java/**/*.java"]),
+    resources = glob(["src/test/resources/**/*"]),
+    tags = ["gc-conductor"],
+    deps = [
+        ":gc-conductor__plugin_test_deps",
+    ],
+)
+
+java_library(
+    name = "gc-conductor__plugin_test_deps",
+    testonly = 1,
+    visibility = ["//visibility:public"],
+    exports = EXECUTOR_DEPS + PLUGIN_TEST_DEPS + [
+        ":gc-conductor__plugin",
+        ":gc-executor_lib",
+        "@byte-buddy//jar",
+        "@mockito//jar",
+        "@objenesis//jar",
+    ],
+)
diff --git a/WORKSPACE b/WORKSPACE
new file mode 100644
index 0000000..b90b611
--- /dev/null
+++ b/WORKSPACE
@@ -0,0 +1,30 @@
+workspace(name = "gc_executor")
+
+load("//:bazlets.bzl", "load_bazlets")
+
+load_bazlets(
+    commit = "11ce7521051ca73598d099aa8a396c9ffe932a74",
+    #local_path = "/home/ehugare/workspaces/bazlets",
+)
+
+#Snapshot Plugin API
+#load(
+#    "@com_googlesource_gerrit_bazlets//:gerrit_api_maven_local.bzl",
+#    "gerrit_api_maven_local",
+#)
+
+# Load snapshot Plugin API
+#gerrit_api_maven_local()
+
+# Release Plugin API
+load(
+    "@com_googlesource_gerrit_bazlets//:gerrit_api.bzl",
+    "gerrit_api",
+)
+
+# Load release Plugin API
+gerrit_api()
+
+load("//:external_plugin_deps.bzl", "external_plugin_deps")
+
+external_plugin_deps()
diff --git a/bazlets.bzl b/bazlets.bzl
new file mode 100644
index 0000000..f97b72c
--- /dev/null
+++ b/bazlets.bzl
@@ -0,0 +1,16 @@
+NAME = "com_googlesource_gerrit_bazlets"
+
+def load_bazlets(
+        commit,
+        local_path = None):
+    if not local_path:
+        native.git_repository(
+            name = NAME,
+            remote = "https://gerrit.googlesource.com/bazlets",
+            commit = commit,
+        )
+    else:
+        native.local_repository(
+            name = NAME,
+            path = local_path,
+        )
diff --git a/bin/gc_ctl b/bin/gc_ctl
new file mode 100755
index 0000000..fcbd38c
--- /dev/null
+++ b/bin/gc_ctl
@@ -0,0 +1,120 @@
+#!/bin/bash
+#
+# controlling script for gc-executor
+export LC_ALL="en_US.UTF-8"
+
+# assume that the current script is in the bin folder
+readonly SERVICE_HOME=$(dirname "$(dirname "$(readlink -f "$0")")")
+readonly SERVICE_NAME=gc-executor
+readonly CONFIG=${SERVICE_HOME}/gc.config
+readonly PATH_TO_JAR="${SERVICE_HOME}/${SERVICE_NAME}.jar"
+readonly PID_FILE="${SERVICE_HOME}/bin/${SERVICE_NAME}-pid"
+
+usage() {
+  me=$(basename "$0")
+  echo "Usage: $me {start|stop [--now]|restart [--now]|status|check}" >&2
+  exit 1
+}
+
+is_running() {
+  [[ -f ${PID_FILE} && $(cat "${PID_FILE}") == $(pgrep -f "${SERVICE_NAME}.jar") ]]
+}
+
+get_config() {
+  if [[ -f "${CONFIG}" ]]; then
+    git config --file "${CONFIG}" "$1" "$2"
+  fi
+}
+
+start() {
+  echo "Starting ${SERVICE_NAME} ..."
+  if is_running; then
+    echo "${SERVICE_NAME} is already running"
+  else
+    java_home=$(get_config --get jvm.javaHome)
+    if [[ -z "${java_home}" ]]; then
+      java_home="/opt/gerrit/jdk8"
+    fi
+    java_options=($(get_config --get-all jvm.javaOptions))
+
+    nohup "${java_home}/bin/java" "${java_options[@]}" -DconfigFile="${CONFIG}" \
+      -jar "${PATH_TO_JAR}" > "${SERVICE_HOME}"/startup.log 2>&1&
+    echo "${!}" > "${PID_FILE}"
+    echo "${SERVICE_NAME} started"
+  fi
+}
+
+stop(){
+  if is_running; then
+    PID=$(cat "${PID_FILE}");
+    echo -n "${SERVICE_NAME} stopping ..."
+    kill "${kill_options}" "${PID}";
+    # wait for the process to die
+    while kill -0 "${PID}" >/dev/null 2>&1; do
+      sleep 1
+      echo -n "."
+    done
+    echo -e "\n${SERVICE_NAME} stopped"
+    rm -f "${PID_FILE}"
+  else
+    echo "${SERVICE_NAME} is not running"
+  fi
+}
+
+restart(){
+  stop
+  start
+}
+
+status(){
+  if is_running; then
+    echo "${SERVICE_NAME} is up."
+  else
+    echo "Looks like ${SERVICE_NAME} is down!"
+  fi
+}
+
+check(){
+  tail -100f /opt/gerrit/review_site/logs/gc/gc.log
+}
+
+main(){
+  action=$1
+  shift
+  kill_options="-TERM"
+
+  while [[ $# -gt 0 ]]; do
+    case "$1" in
+    --now)
+      kill_options="-KILL"
+      shift
+      ;;
+    *)
+      usage
+    esac
+  done
+
+  case "${action}" in
+    start)
+      start
+      ;;
+    stop)
+      stop
+      ;;
+    restart)
+      restart
+      ;;
+    status)
+      status
+      ;;
+    check)
+      check
+      ;;
+    *)
+      echo "${action} is not a known command."
+      usage
+  esac
+  exit 0
+}
+
+main "$@"
diff --git a/external_plugin_deps.bzl b/external_plugin_deps.bzl
new file mode 100644
index 0000000..d98226d
--- /dev/null
+++ b/external_plugin_deps.bzl
@@ -0,0 +1,115 @@
+load("//tools/bzl:maven_jar.bzl", "maven_jar")
+
+def external_plugin_deps():
+    maven_jar(
+        name = "mockito",
+        artifact = "org.mockito:mockito-core:2.20.1",
+        sha1 = "a0f57a2efd118bd0f4735cb213f76874cb87b78b",
+    )
+
+    maven_jar(
+        name = "byte-buddy",
+        artifact = "net.bytebuddy:byte-buddy:1.8.15",
+        sha1 = "cb36fe3c70ead5fcd016856a7efff908402d86b8",
+    )
+
+    maven_jar(
+        name = "objenesis",
+        artifact = "org.objenesis:objenesis:2.6",
+        sha1 = "639033469776fd37c08358c6b92a4761feb2af4b",
+    )
+
+    maven_jar(
+        name = "slf4j-api",
+        artifact = "org.slf4j:slf4j-api:1.7.25",
+        sha1 = "da76ca59f6a57ee3102f8f9bd9cee742973efa8a",
+    )
+
+    LOG4J2_VERS = "2.11.1"
+
+    maven_jar(
+        name = "log4j-slf4j-impl",
+        artifact = "org.apache.logging.log4j:log4j-slf4j-impl:" + LOG4J2_VERS,
+        sha1 = "4b41b53a3a2d299ce381a69d165381ca19f62912",
+    )
+
+    maven_jar(
+        name = "log4j-core",
+        artifact = "org.apache.logging.log4j:log4j-core:" + LOG4J2_VERS,
+        sha1 = "592a48674c926b01a9a747c7831bcd82a9e6d6e4",
+    )
+
+    maven_jar(
+        name = "log4j-api",
+        artifact = "org.apache.logging.log4j:log4j-api:" + LOG4J2_VERS,
+        sha1 = "268f0fe4df3eefe052b57c87ec48517d64fb2a10",
+    )
+
+    maven_jar(
+        name = "postgresql",
+        artifact = "org.postgresql:postgresql:42.2.4",
+        sha1 = "dff98730c28a4b3a3263f0cf4abb9a3392f815a7",
+    )
+
+    maven_jar(
+        name = "dbcp",
+        artifact = "commons-dbcp:commons-dbcp:1.4",
+        sha1 = "30be73c965cc990b153a100aaaaafcf239f82d39",
+    )
+
+    maven_jar(
+        name = "pool",
+        artifact = "commons-pool:commons-pool:1.5.5",
+        sha1 = "7d8ffbdc47aa0c5a8afe5dc2aaf512f369f1d19b",
+    )
+
+    maven_jar(
+        name = "guava",
+        artifact = "com.google.guava:guava:25.1-jre",
+        sha1 = "6c57e4b22b44e89e548b5c9f70f0c45fe10fb0b4",
+    )
+
+    GUICE_VERS = "4.2.0"
+
+    maven_jar(
+        name = "guice",
+        artifact = "com.google.inject:guice:" + GUICE_VERS,
+        sha1 = "25e1f4c1d528a1cffabcca0d432f634f3132f6c8",
+    )
+
+    maven_jar(
+        name = "guice-assistedinject",
+        artifact = "com.google.inject.extensions:guice-assistedinject:" + GUICE_VERS,
+        sha1 = "e7270305960ad7db56f7e30cb9df6be9ff1cfb45",
+    )
+
+    maven_jar(
+        name = "aopalliance",
+        artifact = "aopalliance:aopalliance:1.0",
+        sha1 = "0235ba8b489512805ac13a8f9ea77a1ca5ebe3e8",
+    )
+
+    maven_jar(
+        name = "javax_inject",
+        artifact = "javax.inject:javax.inject:1",
+        sha1 = "6975da39a7040257bd51d21a231b76c915872d38",
+    )
+
+    maven_jar(
+        name = "jgit",
+        artifact =
+            "org.eclipse.jgit:org.eclipse.jgit:4.7.2.201807261330-r",
+        sha1 = "6c08ef848fa5f7d5d49776fa25ec24d738ee457d",
+    )
+
+    maven_jar(
+        name = "javaewah",
+        artifact = "com.googlecode.javaewah:JavaEWAH:1.1.6",
+        sha1 = "94ad16d728b374d65bd897625f3fbb3da223a2b6",
+    )
+
+    maven_jar(
+        name = "retry",
+        artifact = "tech.huffman.re-retrying:re-retrying:3.0.0",
+        sha1 = "bd3ce1aaafc0f357354e76890f0a8199a0f42f3a",
+    )
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/CommonConfig.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/CommonConfig.java
new file mode 100644
index 0000000..4081ed0
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/CommonConfig.java
@@ -0,0 +1,114 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License"),
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor;
+
+import com.google.common.base.Strings;
+import org.eclipse.jgit.lib.Config;
+
+/** Database configuration parameters. */
+public abstract class CommonConfig {
+
+  public static final String DB_URL_KEY = "databaseUrl";
+  public static final String DB_NAME_KEY = "databaseName";
+  public static final String DB_URL_OPTIONS_KEY = "databaseUrlOptions";
+  public static final String DB_USERNAME_KEY = "username";
+  public static final String DB_PASS_KEY = "password";
+  public static final String PACKED_KEY = "packed";
+  public static final String LOOSE_KEY = "loose";
+
+  public static final String DEFAULT_DB_URL = "jdbc:postgresql://localhost:5432/";
+  public static final String DEFAULT_DB_NAME = "gc";
+  public static final String DEFAULT_DB_USERNAME = DEFAULT_DB_NAME;
+  public static final String DEFAULT_DB_PASSWORD = DEFAULT_DB_NAME;
+  public static final int PACKED_DEFAULT = 40;
+  public static final int LOOSE_DEFAULT = 400;
+
+  private final String databaseUrl;
+  private final String databaseName;
+  private final String databaseUrlOptions;
+  private final String username;
+  private final String password;
+  private final int packed;
+  private final int loose;
+
+  /**
+   * Create CommonConfig from the specified parameters.
+   *
+   * @param databaseUrl The database server URL.
+   * @param databaseName The database name.
+   * @param databaseUrlOptions The database URL options.
+   * @param username The database server username.
+   * @param password The password of the database server user.
+   * @param loose The number of loose objects to consider a repo dirty
+   * @param packed The number of packs to consider a repo dirty
+   */
+  public CommonConfig(
+      String databaseUrl,
+      String databaseName,
+      String databaseUrlOptions,
+      String username,
+      String password,
+      int packed,
+      int loose) {
+    this.databaseUrl = databaseUrl.replaceFirst("/?$", "/");
+    this.databaseName = databaseName;
+    this.databaseUrlOptions = databaseUrlOptions;
+    this.username = username;
+    this.password = password;
+    this.packed = packed;
+    this.loose = loose;
+  }
+
+  /** @return the database server URL. */
+  public String getDatabaseUrl() {
+    return databaseUrl;
+  }
+
+  /** @return the database name. */
+  public String getDatabaseName() {
+    return databaseName;
+  }
+
+  /** @return the database URL options or empty if none. */
+  public String getDatabaseUrlOptions() {
+    return databaseUrlOptions;
+  }
+
+  /** @return the database server username. */
+  public String getUsername() {
+    return username;
+  }
+
+  /** @return the password of the database server user. */
+  public String getPassword() {
+    return password;
+  }
+
+  /** @return the number of pack file threshold. */
+  public int getPackedThreshold() {
+    return packed;
+  }
+
+  /** @return the number of loose objects threshold. */
+  public int getLooseThreshold() {
+    return loose;
+  }
+
+  protected static String getString(
+      Config config, String section, String subsection, String key, String defaultValue) {
+    String value = config.getString(section, subsection, key);
+    return Strings.isNullOrEmpty(value) ? defaultValue : value;
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/CommonModule.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/CommonModule.java
new file mode 100644
index 0000000..8606427
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/CommonModule.java
@@ -0,0 +1,68 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor;
+
+import com.ericsson.gerrit.plugins.gcconductor.postgresqueue.PostgresModule;
+import com.google.inject.AbstractModule;
+import com.google.inject.Binding;
+import com.google.inject.Injector;
+import com.google.inject.Provides;
+import com.google.inject.Singleton;
+import com.google.inject.TypeLiteral;
+import com.google.inject.assistedinject.FactoryModuleBuilder;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.List;
+
+/** Module containing common bindings to evaluator and executor */
+public class CommonModule extends AbstractModule {
+
+  private Class<? extends CommonConfig> commonConfig;
+
+  public CommonModule(Class<? extends CommonConfig> commonConfig) {
+    this.commonConfig = commonConfig;
+  }
+
+  @Override
+  protected void configure() {
+    install(new PostgresModule(commonConfig));
+    install(new FactoryModuleBuilder().build(EvaluationTask.Factory.class));
+  }
+
+  @Provides
+  @Singleton
+  @Hostname
+  String provideHostname() throws Exception {
+    ProcessBuilder builder = new ProcessBuilder("hostname", "-s");
+    builder.redirectErrorStream(true);
+    Process process = builder.start();
+    process.waitFor();
+    try (BufferedReader buffer =
+        new BufferedReader(new InputStreamReader(process.getInputStream()))) {
+      return buffer.readLine();
+    }
+  }
+
+  @Provides
+  List<ShutdownListener> provideShutdownListeners(Injector injector) {
+    List<ShutdownListener> listeners = new ArrayList<>();
+    for (Binding<ShutdownListener> shutdownListenerBinding :
+        injector.findBindingsByType(new TypeLiteral<ShutdownListener>() {})) {
+      listeners.add(shutdownListenerBinding.getProvider().get());
+    }
+    return listeners;
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/EvaluationTask.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/EvaluationTask.java
new file mode 100644
index 0000000..2bbade5
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/EvaluationTask.java
@@ -0,0 +1,230 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.inject.Inject;
+import com.google.inject.assistedinject.Assisted;
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import org.eclipse.jgit.errors.RepositoryNotFoundException;
+import org.eclipse.jgit.internal.storage.file.FileRepository;
+import org.eclipse.jgit.internal.storage.file.GC;
+import org.eclipse.jgit.internal.storage.file.GC.RepoStatistics;
+import org.eclipse.jgit.lib.Constants;
+import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.lib.RefDatabase;
+import org.eclipse.jgit.lib.RepositoryCache;
+import org.eclipse.jgit.lib.RepositoryCache.FileKey;
+import org.eclipse.jgit.revwalk.ObjectWalk;
+import org.eclipse.jgit.revwalk.RevObject;
+import org.eclipse.jgit.util.FS;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/** Evaluate the dirtiness of a repository. */
+public class EvaluationTask implements Runnable {
+  private static final Logger log = LoggerFactory.getLogger(EvaluationTask.class);
+
+  private final CommonConfig cfg;
+  private final GcQueue queue;
+  private final String hostname;
+
+  private String repositoryPath;
+
+  public interface Factory {
+    /**
+     * Instantiates EvaluationTask objects.
+     *
+     * @param repositoryPath path to the repository to consider.
+     * @return an instance of EvaluationTask.
+     */
+    EvaluationTask create(String repositoryPath);
+  }
+
+  /**
+   * Creates an EvaluationTask object.
+   *
+   * @param cfg The configuration where to read from dirtiness settings
+   * @param queue The queue to add the repository to be garbage collected
+   * @param hostname The hostname where the repository is evaluated.
+   * @param repositoryPath Path to the repository to evaluate.
+   */
+  @Inject
+  public EvaluationTask(
+      CommonConfig cfg, GcQueue queue, @Hostname String hostname, @Assisted String repositoryPath) {
+    this.cfg = cfg;
+    this.queue = queue;
+    this.hostname = hostname;
+    this.repositoryPath = repositoryPath;
+  }
+
+  @Override
+  public void run() {
+    if (!isAlreadyInQueue() && isDirty()) {
+      insertRepository();
+    }
+  }
+
+  private boolean isAlreadyInQueue() {
+    try {
+      return queue.contains(repositoryPath);
+    } catch (GcQueueException e) {
+      log.error("Error checking if repository is already in queue {}", repositoryPath, e);
+      return true;
+    }
+  }
+
+  private boolean isDirty() {
+    try (FileRepository repository =
+        (FileRepository)
+            RepositoryCache.open(FileKey.exact(new File(repositoryPath), FS.DETECTED))) {
+      RepoStatistics statistics = new GC(repository).getStatistics();
+      if (statistics.numberOfPackFiles >= cfg.getPackedThreshold()) {
+        log.debug(
+            "The number of packs ({}) exceeds the configured limit of {}",
+            statistics.numberOfPackFiles,
+            cfg.getPackedThreshold());
+        return true;
+      }
+      long looseObjects = statistics.numberOfLooseObjects;
+      int looseThreshold = cfg.getLooseThreshold();
+      if (looseObjects >= looseThreshold) {
+        long referencedLooseObjects = 0;
+        long unreferencedLooseObjects = 0;
+        long duration = 0;
+        long start = System.currentTimeMillis();
+        unreferencedLooseObjects = getUnreferencedLooseObjectsCount(repository);
+        duration = System.currentTimeMillis() - start;
+        referencedLooseObjects = looseObjects - unreferencedLooseObjects;
+        log.debug(
+            "{} of {} loose objects in repository {} were unreferenced. Evaluating unreferenced objects took {}ms.",
+            unreferencedLooseObjects,
+            looseObjects,
+            repositoryPath,
+            duration);
+        return referencedLooseObjects >= looseThreshold;
+      }
+    } catch (RepositoryNotFoundException rnfe) {
+      log.debug("Repository no longer exist, aborting evaluation.");
+    } catch (IOException e) {
+      log.error("Error gathering '{}' statistics.", repositoryPath, e);
+    }
+    return false;
+  }
+
+  @VisibleForTesting
+  int getUnreferencedLooseObjectsCount(FileRepository repo) throws IOException {
+    File objects = repo.getObjectsDirectory();
+    String[] fanout = objects.list();
+    if (fanout == null || fanout.length == 0) {
+      return 0;
+    }
+    Set<ObjectId> unreferencedCandidates = getUnreferencedCandidates(objects, fanout);
+    if (unreferencedCandidates.isEmpty()) {
+      return 0;
+    }
+    try (ObjectWalk walk = new ObjectWalk(repo)) {
+      for (Ref ref : getAllRefs(repo)) {
+        walk.markStart(walk.parseAny(ref.getObjectId()));
+      }
+      removeReferenced(unreferencedCandidates, walk);
+    }
+    return unreferencedCandidates.size();
+  }
+
+  private Set<ObjectId> getUnreferencedCandidates(File objects, String[] fanout) {
+    Set<ObjectId> candidates = new HashSet<>();
+    for (String dir : fanout) {
+      if (dir.length() != 2) {
+        continue;
+      }
+      File[] entries = new File(objects, dir).listFiles();
+      if (entries != null) {
+        addCandidates(candidates, dir, entries);
+      }
+    }
+    return candidates;
+  }
+
+  private void addCandidates(Set<ObjectId> candidates, String dir, File[] entries) {
+    for (File f : entries) {
+      String fileName = f.getName();
+      if (fileName.length() != Constants.OBJECT_ID_STRING_LENGTH - 2) {
+        continue;
+      }
+      try {
+        ObjectId id = ObjectId.fromString(dir + fileName);
+        candidates.add(id);
+      } catch (IllegalArgumentException notAnObject) {
+        // ignoring the file that does not represent loose object
+      }
+    }
+  }
+
+  private Collection<Ref> getAllRefs(FileRepository repo) throws IOException {
+    RefDatabase refdb = repo.getRefDatabase();
+    Collection<Ref> refs = refdb.getRefs(RefDatabase.ALL).values();
+    List<Ref> addl = refdb.getAdditionalRefs();
+    if (!addl.isEmpty()) {
+      List<Ref> all = new ArrayList<>(refs.size() + addl.size());
+      all.addAll(refs);
+      // add additional refs which start with refs/
+      for (Ref r : addl) {
+        if (r.getName().startsWith(Constants.R_REFS)) {
+          all.add(r);
+        }
+      }
+      return all;
+    }
+    return refs;
+  }
+
+  private void removeReferenced(Set<ObjectId> id2File, ObjectWalk w) throws IOException {
+    RevObject ro = w.next();
+    while (ro != null) {
+      if (id2File.remove(ro.getId()) && id2File.isEmpty()) {
+        return;
+      }
+      ro = w.next();
+    }
+    ro = w.nextObject();
+    while (ro != null) {
+      if (id2File.remove(ro.getId()) && id2File.isEmpty()) {
+        return;
+      }
+      ro = w.nextObject();
+    }
+  }
+
+  private void insertRepository() {
+    try {
+      queue.add(repositoryPath, hostname);
+    } catch (GcQueueException e) {
+      log.error("Error adding repository in queue {}", repositoryPath, e);
+    }
+  }
+
+  @Override
+  public String toString() {
+    return "Evaluate if repository need GC: " + repositoryPath;
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/GcQueue.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/GcQueue.java
new file mode 100644
index 0000000..cc2560e
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/GcQueue.java
@@ -0,0 +1,107 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor;
+
+import com.google.inject.Singleton;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Queue that holds Git repositories to be Gc'ed.
+ *
+ * <p>Implementations of this interface should be registered in Guice as {@link Singleton}.
+ */
+public interface GcQueue {
+
+  /**
+   * Add repository to the queue.
+   *
+   * <p>Repositories are unique in the queue. This method is idempotent, adding an already existing
+   * repository will neither add it again nor throw an exception.
+   *
+   * @param repository The path to the repository.
+   * @param queuedFrom The hostname from which the repository is queued from.
+   * @throws GcQueueException if an error occur while adding the repository.
+   */
+  void add(String repository, String queuedFrom) throws GcQueueException;
+
+  /**
+   * Pick a repository from the queue.
+   *
+   * <p>If the queue contains an already picked repository by the specified executor, will return
+   * that repository.
+   *
+   * @param executor The name of the executor to assign repository to.
+   * @param queuedForLongerThan Only pick repository that were in the queue for longer than
+   *     specified number of seconds.
+   * @param queuedFrom If specified, only pick repository if queued from the specified hostname.
+   * @return RepositoryInfo representing the repository if any, otherwise return <code>null</code>.
+   * @throws GcQueueException if an error occur while picking a repository.
+   */
+  RepositoryInfo pick(String executor, long queuedForLongerThan, Optional<String> queuedFrom)
+      throws GcQueueException;
+
+  /**
+   * Unpick a repository from the queue.
+   *
+   * @param repository The path to the repository to unpick.
+   * @throws GcQueueException if an error occur while unpicking the repository.
+   */
+  void unpick(String repository) throws GcQueueException;
+
+  /**
+   * Remove a repository from the queue.
+   *
+   * @param repository The path to the repository to remove.
+   * @throws GcQueueException if an error occur while removing the repository.
+   */
+  void remove(String repository) throws GcQueueException;
+
+  /**
+   * Returns <code>true</code> if the queue contains the specified repository.
+   *
+   * @param repository The path to the repository.
+   * @return <code>true</code> if the queue contains the specified repository, otherwise <code>false
+   *     </code>.
+   * @throws GcQueueException if an error occur which checking if the repository is in the queue.
+   */
+  boolean contains(String repository) throws GcQueueException;
+
+  /**
+   * Reset all repositories queuedFrom to the specified hostname.
+   *
+   * @param queuedFrom The hostname to set queuedFrom to for every repository.
+   * @throws GcQueueException if an error occur while resetting queuedFrom.
+   */
+  void resetQueuedFrom(String queuedFrom) throws GcQueueException;
+
+  /**
+   * Returns list of repositories with their queuedAt timestamp, queuedFrom hostname and their
+   * associated executor, if any. The repositories are orderer from the oldest to the newest
+   * inserted.
+   *
+   * @return list of RepositoryInfo.
+   * @throws GcQueueException if an error occur while listing the repositories.
+   */
+  List<RepositoryInfo> list() throws GcQueueException;
+
+  /**
+   * Bump an existing repository to the top of the queue.
+   *
+   * @param repository The path to the repository.
+   * @throws GcQueueException if an error occurs while bumping the sequence of a repository.
+   */
+  void bumpToFirst(String repository) throws GcQueueException;
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/GcQueueException.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/GcQueueException.java
new file mode 100644
index 0000000..90702e1
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/GcQueueException.java
@@ -0,0 +1,35 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor;
+
+/**
+ * Indicates that an error happened while interacting with the GcQueue.
+ *
+ * <p>Specific GcQueue implementation errors can be retrieved by calling getCause().
+ */
+public class GcQueueException extends Exception {
+
+  private static final long serialVersionUID = 1L;
+
+  /**
+   * Constructs an {@code GcQueueException} with the specified detail message and cause.
+   *
+   * @param message The detail message
+   * @param cause The cause (underlying exception) that explains why the error occurred.
+   */
+  public GcQueueException(String message, Throwable cause) {
+    super(message, cause);
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/Hostname.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/Hostname.java
new file mode 100644
index 0000000..fd76130
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/Hostname.java
@@ -0,0 +1,23 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+package com.ericsson.gerrit.plugins.gcconductor;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import com.google.inject.BindingAnnotation;
+import java.lang.annotation.Retention;
+
+@Retention(RUNTIME)
+@BindingAnnotation
+public @interface Hostname {}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/RepositoryInfo.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/RepositoryInfo.java
new file mode 100644
index 0000000..a7eedec
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/RepositoryInfo.java
@@ -0,0 +1,53 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor;
+
+import java.sql.Timestamp;
+
+/** Information about a queued repository. */
+public class RepositoryInfo {
+
+  private final String path;
+  private final Timestamp queuedAt;
+  private final String executor;
+  private final String queuedFrom;
+
+  public RepositoryInfo(String path, Timestamp queuedAt, String executor, String queuedFrom) {
+    this.path = path;
+    this.queuedAt = queuedAt;
+    this.executor = executor;
+    this.queuedFrom = queuedFrom;
+  }
+
+  /** @return the path to the repository. */
+  public String getPath() {
+    return path;
+  }
+
+  /** @return the time the repository was queued at. */
+  public Timestamp getQueuedAt() {
+    return queuedAt;
+  }
+
+  /** @return the executor running gc on the repository or <code>null</code> if none. */
+  public String getExecutor() {
+    return executor;
+  }
+
+  /** @return the hostname that inserted the repository in the queue. */
+  public String getQueuedFrom() {
+    return queuedFrom;
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/ShutdownListener.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/ShutdownListener.java
new file mode 100644
index 0000000..e3db5e3
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/ShutdownListener.java
@@ -0,0 +1,22 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor;
+
+/** Implement this interface to be notified on shutdown. */
+public interface ShutdownListener {
+
+  /** Called on shutdown. */
+  void onShutdown();
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/ShutdownNotifier.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/ShutdownNotifier.java
new file mode 100644
index 0000000..f6bea89
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/ShutdownNotifier.java
@@ -0,0 +1,39 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor;
+
+import com.google.common.collect.Lists;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.util.List;
+
+/** Responsible to notify all {@link ShutdownListener} */
+@Singleton
+public class ShutdownNotifier {
+
+  private final List<ShutdownListener> listeners;
+
+  @Inject
+  public ShutdownNotifier(List<ShutdownListener> listeners) {
+    this.listeners = listeners;
+  }
+
+  /** Notify all {@link ShutdownListener}. */
+  public void notifyAllListeners() {
+    for (ShutdownListener listener : Lists.reverse(listeners)) {
+      listener.onShutdown();
+    }
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/command/AddToQueue.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/command/AddToQueue.java
new file mode 100644
index 0000000..d9fe107
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/command/AddToQueue.java
@@ -0,0 +1,117 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.command;
+
+import static com.google.gerrit.sshd.CommandMetaData.Mode.MASTER_OR_SLAVE;
+
+import com.ericsson.gerrit.plugins.gcconductor.GcQueue;
+import com.ericsson.gerrit.plugins.gcconductor.GcQueueException;
+import com.ericsson.gerrit.plugins.gcconductor.Hostname;
+import com.google.gerrit.common.data.GlobalCapability;
+import com.google.gerrit.extensions.annotations.RequiresCapability;
+import com.google.gerrit.reviewdb.client.Project;
+import com.google.gerrit.server.git.GitRepositoryManager;
+import com.google.gerrit.server.git.LocalDiskRepositoryManager;
+import com.google.gerrit.server.project.ProjectCache;
+import com.google.gerrit.sshd.AdminHighPriorityCommand;
+import com.google.gerrit.sshd.CommandMetaData;
+import com.google.gerrit.sshd.SshCommand;
+import com.google.inject.Inject;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import org.eclipse.jgit.lib.Constants;
+import org.eclipse.jgit.lib.RepositoryCache.FileKey;
+import org.eclipse.jgit.util.FS;
+import org.kohsuke.args4j.Argument;
+import org.kohsuke.args4j.Option;
+
+@AdminHighPriorityCommand
+@RequiresCapability(GlobalCapability.ADMINISTRATE_SERVER)
+@CommandMetaData(
+    name = "add-to-queue",
+    description = "Add a repository to gc queue",
+    runsAt = MASTER_OR_SLAVE)
+final class AddToQueue extends SshCommand {
+  @Argument(index = 0, required = true, metaVar = "REPOSITORY")
+  private String repository;
+
+  @Option(name = "--first", usage = "add repository as first priority in GC queue")
+  private boolean first;
+
+  @Inject private GcQueue queue;
+
+  @Inject @Hostname private String hostName;
+
+  @Inject private GitRepositoryManager gitRepositoryManager;
+
+  @Inject private ProjectCache projectCache;
+
+  @Override
+  protected void run() throws UnloggedFailure {
+    try {
+      Path repositoryPath = Paths.get(repository);
+      if (repositoryPath.toFile().exists()) {
+        repositoryPath = repositoryPath.toRealPath();
+      }
+      if (!FileKey.isGitRepository(repositoryPath.toFile(), FS.DETECTED)) {
+        repositoryPath = resolvePath();
+      }
+      repository = repositoryPath.toString();
+      queue.add(repository, hostName);
+      if (first) {
+        queue.bumpToFirst(repository);
+      }
+      stdout.println(String.format("%s was added to GC queue", repository));
+    } catch (IOException | GcQueueException e) {
+      throw die(e);
+    }
+  }
+
+  private Path resolvePath() throws UnloggedFailure {
+    if (!(gitRepositoryManager instanceof LocalDiskRepositoryManager)) {
+      throw die("Unable to resolve path to " + repository);
+    }
+    String projectName = extractFrom(repository);
+    Project.NameKey nameKey = new Project.NameKey(projectName);
+    if (projectCache.get(nameKey) == null) {
+      throw die(String.format("Repository %s not found", repository));
+    }
+    LocalDiskRepositoryManager localDiskRepositoryManager =
+        (LocalDiskRepositoryManager) gitRepositoryManager;
+    try {
+      return localDiskRepositoryManager
+          .getBasePath(nameKey)
+          .resolve(projectName.concat(Constants.DOT_GIT_EXT))
+          .toRealPath();
+    } catch (IOException e) {
+      throw die(e);
+    }
+  }
+
+  private String extractFrom(String path) {
+    String name = path;
+    if (name.startsWith("/")) {
+      name = name.substring(1);
+    }
+    if (name.endsWith("/")) {
+      name = name.substring(0, name.length() - 1);
+    }
+    if (name.endsWith(Constants.DOT_GIT_EXT)) {
+      name = name.substring(0, name.indexOf(Constants.DOT_GIT_EXT));
+    }
+    return name;
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/command/BumpToFirst.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/command/BumpToFirst.java
new file mode 100644
index 0000000..5f25fba
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/command/BumpToFirst.java
@@ -0,0 +1,52 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.command;
+
+import static com.google.gerrit.sshd.CommandMetaData.Mode.MASTER_OR_SLAVE;
+
+import com.ericsson.gerrit.plugins.gcconductor.GcQueue;
+import com.ericsson.gerrit.plugins.gcconductor.GcQueueException;
+import com.google.gerrit.common.data.GlobalCapability;
+import com.google.gerrit.extensions.annotations.RequiresCapability;
+import com.google.gerrit.sshd.AdminHighPriorityCommand;
+import com.google.gerrit.sshd.CommandMetaData;
+import com.google.gerrit.sshd.SshCommand;
+import com.google.inject.Inject;
+import org.kohsuke.args4j.Argument;
+
+@AdminHighPriorityCommand
+@RequiresCapability(GlobalCapability.ADMINISTRATE_SERVER)
+@CommandMetaData(
+    name = "bump-to-first",
+    description = "Bumps a repository to first priority for GC",
+    runsAt = MASTER_OR_SLAVE)
+final class BumpToFirst extends SshCommand {
+  @Argument(index = 0, required = true, metaVar = "REPOSITORY")
+  private String repository;
+
+  @Inject private GcQueue queue;
+
+  @Override
+  protected void run() throws UnloggedFailure {
+    try {
+      if (!queue.contains(repository)) {
+        throw die(String.format("%s is not in the queue", repository));
+      }
+      queue.bumpToFirst(repository);
+    } catch (GcQueueException e) {
+      throw die(e);
+    }
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/command/SetQueuedFrom.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/command/SetQueuedFrom.java
new file mode 100644
index 0000000..56b70b8
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/command/SetQueuedFrom.java
@@ -0,0 +1,50 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.command;
+
+import static com.google.gerrit.sshd.CommandMetaData.Mode.MASTER_OR_SLAVE;
+
+import com.ericsson.gerrit.plugins.gcconductor.GcQueue;
+import com.ericsson.gerrit.plugins.gcconductor.GcQueueException;
+import com.google.gerrit.common.data.GlobalCapability;
+import com.google.gerrit.extensions.annotations.RequiresCapability;
+import com.google.gerrit.sshd.AdminHighPriorityCommand;
+import com.google.gerrit.sshd.CommandMetaData;
+import com.google.gerrit.sshd.SshCommand;
+import com.google.inject.Inject;
+import org.kohsuke.args4j.Argument;
+
+@AdminHighPriorityCommand
+@RequiresCapability(GlobalCapability.ADMINISTRATE_SERVER)
+@CommandMetaData(
+    name = "set-queued-from",
+    description = "Set queued from for all unassigned repositories",
+    runsAt = MASTER_OR_SLAVE)
+final class SetQueuedFrom extends SshCommand {
+
+  @Argument(index = 0, required = true, metaVar = "HOSTAME")
+  private String hostname;
+
+  @Inject private GcQueue queue;
+
+  @Override
+  protected void run() throws UnloggedFailure {
+    try {
+      queue.resetQueuedFrom(hostname);
+    } catch (GcQueueException e) {
+      throw die(e);
+    }
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/command/ShowQueue.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/command/ShowQueue.java
new file mode 100644
index 0000000..fe41af0
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/command/ShowQueue.java
@@ -0,0 +1,91 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.command;
+
+import static com.google.gerrit.sshd.CommandMetaData.Mode.MASTER_OR_SLAVE;
+
+import com.ericsson.gerrit.plugins.gcconductor.GcQueue;
+import com.ericsson.gerrit.plugins.gcconductor.RepositoryInfo;
+import com.google.common.base.Strings;
+import com.google.gerrit.common.TimeUtil;
+import com.google.gerrit.common.data.GlobalCapability;
+import com.google.gerrit.extensions.annotations.RequiresCapability;
+import com.google.gerrit.sshd.AdminHighPriorityCommand;
+import com.google.gerrit.sshd.CommandMetaData;
+import com.google.gerrit.sshd.SshCommand;
+import com.google.inject.Inject;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.List;
+
+@AdminHighPriorityCommand
+@RequiresCapability(GlobalCapability.ADMINISTRATE_SERVER)
+@CommandMetaData(name = "show-queue", description = "Show GC queue", runsAt = MASTER_OR_SLAVE)
+final class ShowQueue extends SshCommand {
+
+  @Inject private GcQueue queue;
+
+  @Override
+  protected void run() throws UnloggedFailure {
+    try {
+      List<RepositoryInfo> repositories = queue.list();
+
+      // Find width of executor and queuedFrom column. Typical executor names
+      // consist of 11 characters hostname suffixed by "-n" and typical queued
+      // from hostname consist of 11 characters
+      int executorColumnWidth = 13;
+      int queuedFromColumnWidth = 11;
+      for (RepositoryInfo repositoryInfo : repositories) {
+        if (repositoryInfo.getExecutor() != null) {
+          executorColumnWidth =
+              Math.max(executorColumnWidth, repositoryInfo.getExecutor().length());
+        }
+        queuedFromColumnWidth =
+            Math.max(queuedFromColumnWidth, repositoryInfo.getQueuedFrom().length());
+      }
+
+      String format = "%-12s %-" + executorColumnWidth + "s %-" + queuedFromColumnWidth + "s %s\n";
+      stdout.print(String.format(format, "Queued At", "Executor", "Queued From", "Repository"));
+      stdout.print(
+          "------------------------------------------------------------------------------\n");
+      for (RepositoryInfo repositoryInfo : repositories) {
+        stdout.print(
+            String.format(
+                format,
+                queuedAt(repositoryInfo.getQueuedAt()),
+                Strings.nullToEmpty(repositoryInfo.getExecutor()),
+                repositoryInfo.getQueuedFrom(),
+                repositoryInfo.getPath()));
+      }
+      stdout.print(
+          "------------------------------------------------------------------------------\n");
+      stdout.print(
+          "  "
+              + repositories.size()
+              + " repositor"
+              + (repositories.size() > 1 ? "ies" : "y")
+              + "\n");
+    } catch (Exception e) {
+      throw die(e);
+    }
+  }
+
+  private static String queuedAt(Date when) {
+    if (TimeUtil.nowMs() - when.getTime() < 24 * 60 * 60 * 1000L) {
+      return new SimpleDateFormat("HH:mm:ss.SSS").format(when);
+    }
+    return new SimpleDateFormat("MMM-dd HH:mm").format(when);
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/command/SshModule.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/command/SshModule.java
new file mode 100644
index 0000000..7940bba
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/command/SshModule.java
@@ -0,0 +1,28 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.command;
+
+import com.google.gerrit.sshd.PluginCommandModule;
+
+class SshModule extends PluginCommandModule {
+
+  @Override
+  protected void configureCommands() {
+    command(SetQueuedFrom.class);
+    command(ShowQueue.class);
+    command(AddToQueue.class);
+    command(BumpToFirst.class);
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/evaluator/Evaluator.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/evaluator/Evaluator.java
new file mode 100644
index 0000000..69e0a37
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/evaluator/Evaluator.java
@@ -0,0 +1,126 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.evaluator;
+
+import com.ericsson.gerrit.plugins.gcconductor.EvaluationTask;
+import com.google.gerrit.extensions.events.GitReferenceUpdatedListener;
+import com.google.gerrit.reviewdb.client.Project;
+import com.google.gerrit.server.config.GerritServerConfig;
+import com.google.gerrit.server.git.GitRepositoryManager;
+import com.google.gerrit.server.git.validators.UploadValidationListener;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.io.IOException;
+import java.util.Collection;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+import org.eclipse.jgit.errors.RepositoryNotFoundException;
+import org.eclipse.jgit.lib.Config;
+import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.storage.pack.PackStatistics;
+import org.eclipse.jgit.transport.PostUploadHook;
+import org.eclipse.jgit.transport.UploadPack;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@Singleton
+class Evaluator implements UploadValidationListener, PostUploadHook, GitReferenceUpdatedListener {
+  private static final Logger log = LoggerFactory.getLogger(Evaluator.class);
+  private static final ThreadLocal<String> uploadRepositoryPath = new ThreadLocal<String>() {};
+
+  private final ScheduledThreadPoolExecutor executor;
+  private final EvaluationTask.Factory evaluationTaskFactory;
+  private final GitRepositoryManager repoManager;
+  private final Map<String, Long> timestamps;
+
+  private long expireTime;
+
+  @Inject
+  Evaluator(
+      @EvaluatorExecutor ScheduledThreadPoolExecutor executor,
+      EvaluationTask.Factory evaluationTaskFactory,
+      GitRepositoryManager repoManager,
+      EvaluatorConfig config,
+      @GerritServerConfig Config gerritConfig) {
+    this.executor = executor;
+    this.evaluationTaskFactory = evaluationTaskFactory;
+    this.repoManager = repoManager;
+    this.expireTime = config.getExpireTimeRecheck();
+
+    int threads =
+        gerritConfig.getInt(
+            "receive", null, "threadPoolSize", Runtime.getRuntime().availableProcessors());
+    timestamps = new ConcurrentHashMap<>(10000, 0.75f, threads);
+  }
+
+  @Override
+  public void onPreUpload(
+      Repository repository,
+      Project project,
+      String remoteHost,
+      UploadPack up,
+      Collection<? extends ObjectId> wants,
+      Collection<? extends ObjectId> haves) {
+    uploadRepositoryPath.set(repository.getDirectory().getAbsolutePath());
+  }
+
+  @Override
+  public void onBeginNegotiate(
+      Repository repository,
+      Project project,
+      String remoteHost,
+      UploadPack up,
+      Collection<? extends ObjectId> wants,
+      int cntOffered) {
+    // Do nothing
+  }
+
+  @Override
+  public void onPostUpload(PackStatistics stats) {
+    String repositoryPath = uploadRepositoryPath.get();
+    if (repositoryPath != null && needsCheck(repositoryPath)) {
+      executor.execute(evaluationTaskFactory.create(repositoryPath));
+      uploadRepositoryPath.remove();
+    }
+  }
+
+  @Override
+  public void onGitReferenceUpdated(Event event) {
+    String projectName = event.getProjectName();
+    Project.NameKey projectNameKey = new Project.NameKey(projectName);
+    try (Repository repository = repoManager.openRepository(projectNameKey)) {
+      String repositoryPath = repository.getDirectory().getAbsolutePath();
+      if (needsCheck(repositoryPath)) {
+        executor.execute(evaluationTaskFactory.create(repositoryPath));
+      }
+    } catch (RepositoryNotFoundException e) {
+      log.error("Project not found {}", projectName, e);
+    } catch (IOException e) {
+      log.error("Error getting repository for project {}", projectName, e);
+    }
+  }
+
+  private boolean needsCheck(String repositoryPath) {
+    long now = System.currentTimeMillis();
+    if (!timestamps.containsKey(repositoryPath)
+        || now >= timestamps.get(repositoryPath) + expireTime) {
+      timestamps.put(repositoryPath, now);
+      return true;
+    }
+    return false;
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/evaluator/EvaluatorConfig.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/evaluator/EvaluatorConfig.java
new file mode 100644
index 0000000..acb3600
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/evaluator/EvaluatorConfig.java
@@ -0,0 +1,63 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.evaluator;
+
+import com.ericsson.gerrit.plugins.gcconductor.CommonConfig;
+import com.google.common.base.Strings;
+import com.google.gerrit.server.config.ConfigUtil;
+import com.google.gerrit.server.config.PluginConfig;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.util.concurrent.TimeUnit;
+
+/** Holds configuration values of the plugin. */
+@Singleton
+public class EvaluatorConfig extends CommonConfig {
+  static final String THREAD_POOL_KEY = "threadPoolSize";
+  static final String EXPIRE_TIME_RECHECK_KEY = "expireTimeRecheck";
+
+  static final int THREAD_POOL_DEFAULT = 4;
+  static final String EXPIRE_TIME_RECHECK_DEFAULT = "60s";
+
+  private final int threadPoolSize;
+  private final long expireTimeRecheck;
+
+  @Inject
+  EvaluatorConfig(PluginConfig cfg) {
+    super(
+        cfg.getString(DB_URL_KEY, DEFAULT_DB_URL),
+        cfg.getString(DB_NAME_KEY, DEFAULT_DB_NAME),
+        Strings.nullToEmpty(cfg.getString(DB_URL_OPTIONS_KEY)),
+        cfg.getString(DB_USERNAME_KEY, DEFAULT_DB_USERNAME),
+        cfg.getString(DB_PASS_KEY, DEFAULT_DB_PASSWORD),
+        cfg.getInt(PACKED_KEY, PACKED_DEFAULT),
+        cfg.getInt(LOOSE_KEY, LOOSE_DEFAULT));
+    threadPoolSize = cfg.getInt(THREAD_POOL_KEY, THREAD_POOL_DEFAULT);
+
+    String expireTimeRecheckString =
+        cfg.getString(EXPIRE_TIME_RECHECK_KEY, EXPIRE_TIME_RECHECK_DEFAULT);
+    expireTimeRecheck = ConfigUtil.getTimeUnit(expireTimeRecheckString, -1, TimeUnit.MILLISECONDS);
+  }
+
+  /** @return the number of threads to use for the plugin evaluation tasks. */
+  public int getThreadPoolSize() {
+    return threadPoolSize;
+  }
+
+  /** @return the time to wait before re-evaluating the same repository. */
+  public long getExpireTimeRecheck() {
+    return expireTimeRecheck;
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/evaluator/EvaluatorExecutor.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/evaluator/EvaluatorExecutor.java
new file mode 100644
index 0000000..6f029f0
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/evaluator/EvaluatorExecutor.java
@@ -0,0 +1,24 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.evaluator;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import com.google.inject.BindingAnnotation;
+import java.lang.annotation.Retention;
+
+@Retention(RUNTIME)
+@BindingAnnotation
+@interface EvaluatorExecutor {}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/evaluator/EvaluatorExecutorProvider.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/evaluator/EvaluatorExecutorProvider.java
new file mode 100644
index 0000000..7cf13af
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/evaluator/EvaluatorExecutorProvider.java
@@ -0,0 +1,46 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.evaluator;
+
+import com.ericsson.gerrit.plugins.gcconductor.ShutdownListener;
+import com.google.gerrit.extensions.annotations.PluginName;
+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;
+
+@Singleton
+class EvaluatorExecutorProvider implements Provider<ScheduledThreadPoolExecutor>, ShutdownListener {
+  private WorkQueue.Executor executor;
+
+  @Inject
+  EvaluatorExecutorProvider(
+      WorkQueue workQueue, @PluginName String pluginName, EvaluatorConfig config) {
+    executor = workQueue.createQueue(config.getThreadPoolSize(), "[" + pluginName + " plugin]");
+  }
+
+  @Override
+  public void onShutdown() {
+    executor.shutdownNow();
+    executor.unregisterWorkQueue();
+    executor = null;
+  }
+
+  @Override
+  public ScheduledThreadPoolExecutor get() {
+    return executor;
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/evaluator/EvaluatorModule.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/evaluator/EvaluatorModule.java
new file mode 100644
index 0000000..8ef2a6b
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/evaluator/EvaluatorModule.java
@@ -0,0 +1,56 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.evaluator;
+
+import com.ericsson.gerrit.plugins.gcconductor.CommonModule;
+import com.ericsson.gerrit.plugins.gcconductor.ShutdownListener;
+import com.google.gerrit.extensions.annotations.PluginName;
+import com.google.gerrit.extensions.events.GitReferenceUpdatedListener;
+import com.google.gerrit.extensions.registration.DynamicSet;
+import com.google.gerrit.lifecycle.LifecycleModule;
+import com.google.gerrit.server.config.PluginConfig;
+import com.google.gerrit.server.config.PluginConfigFactory;
+import com.google.gerrit.server.git.validators.UploadValidationListener;
+import com.google.inject.Provides;
+import com.google.inject.internal.UniqueAnnotations;
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+import org.eclipse.jgit.transport.PostUploadHook;
+
+/** Configures bindings of the evaluator. */
+public class EvaluatorModule extends LifecycleModule {
+  @Override
+  protected void configure() {
+    install(new CommonModule(EvaluatorConfig.class));
+    listener().to(OnPluginLoadUnload.class);
+
+    bind(ScheduledThreadPoolExecutor.class)
+        .annotatedWith(EvaluatorExecutor.class)
+        .toProvider(EvaluatorExecutorProvider.class);
+    bind(ShutdownListener.class)
+        .annotatedWith(UniqueAnnotations.create())
+        .to(EvaluatorExecutorProvider.class);
+
+    bind(Evaluator.class);
+    DynamicSet.bind(binder(), UploadValidationListener.class).to(Evaluator.class);
+    DynamicSet.bind(binder(), PostUploadHook.class).to(Evaluator.class);
+    DynamicSet.bind(binder(), GitReferenceUpdatedListener.class).to(Evaluator.class);
+    bind(EvaluatorConfig.class);
+  }
+
+  @Provides
+  PluginConfig providePluginConfig(PluginConfigFactory config, @PluginName String pluginName) {
+    return config.getFromGerritConfig(pluginName, true);
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/evaluator/OnPluginLoadUnload.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/evaluator/OnPluginLoadUnload.java
new file mode 100644
index 0000000..d2de252
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/evaluator/OnPluginLoadUnload.java
@@ -0,0 +1,39 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.evaluator;
+
+import com.ericsson.gerrit.plugins.gcconductor.ShutdownNotifier;
+import com.google.gerrit.extensions.events.LifecycleListener;
+import com.google.inject.Inject;
+
+class OnPluginLoadUnload implements LifecycleListener {
+
+  private final ShutdownNotifier shutdownNotifier;
+
+  @Inject
+  OnPluginLoadUnload(ShutdownNotifier shutdownNotifier) {
+    this.shutdownNotifier = shutdownNotifier;
+  }
+
+  @Override
+  public void start() {
+    // nothing to do, only stop method is needed for now
+  }
+
+  @Override
+  public void stop() {
+    shutdownNotifier.notifyAllListeners();
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/CancellableProgressMonitor.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/CancellableProgressMonitor.java
new file mode 100644
index 0000000..3f5a419
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/CancellableProgressMonitor.java
@@ -0,0 +1,31 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.executor;
+
+import org.eclipse.jgit.lib.EmptyProgressMonitor;
+
+class CancellableProgressMonitor extends EmptyProgressMonitor {
+
+  private boolean cancelled = false;
+
+  void cancel() {
+    cancelled = true;
+  }
+
+  @Override
+  public boolean isCancelled() {
+    return cancelled;
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/ConfigUtil.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/ConfigUtil.java
new file mode 100644
index 0000000..03b8fd1
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/ConfigUtil.java
@@ -0,0 +1,122 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.executor;
+
+import java.util.concurrent.TimeUnit;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import org.eclipse.jgit.lib.Config;
+
+class ConfigUtil {
+
+  private ConfigUtil() {}
+
+  /**
+   * Parse a numerical time unit, such as "1 minute", from the configuration.
+   *
+   * @param config the configuration file to read.
+   * @param section section the key is in.
+   * @param setting name of the setting to read.
+   * @param defaultValue default value to return if no value was set in the configuration file.
+   * @param wantUnit the units of {@code defaultValue} and the return value, as well as the units to
+   *     assume if the value does not contain an indication of the units.
+   * @return the setting, or {@code defaultValue} if not set, expressed in {@code units}.
+   */
+  public static long getTimeUnit(
+      Config config, String section, String setting, long defaultValue, final TimeUnit wantUnit) {
+    String value = config.getString(section, null, setting);
+    if (value == null) {
+      return defaultValue;
+    }
+
+    String s = value.trim();
+    if (s.length() == 0) {
+      return defaultValue;
+    }
+
+    if (s.startsWith("-") /* negative */) {
+      throw notTimeUnit(section, setting, value);
+    }
+
+    try {
+      return getTimeUnit(s, defaultValue, wantUnit);
+    } catch (IllegalArgumentException notTime) {
+      throw notTimeUnit(section, setting, value);
+    }
+  }
+
+  /**
+   * Parse a numerical time unit, such as "1 minute", from a string.
+   *
+   * @param valueString the string to parse.
+   * @param defaultValue default value to return if no value was set in the configuration file.
+   * @param wantUnit the units of {@code defaultValue} and the return value, as well as the units to
+   *     assume if the value does not contain an indication of the units.
+   * @return the setting, or {@code defaultValue} if not set, expressed in {@code units}.
+   */
+  public static long getTimeUnit(String valueString, long defaultValue, TimeUnit wantUnit) {
+    Matcher m = Pattern.compile("^(0|[1-9][0-9]*)\\s*(.*)$").matcher(valueString);
+    if (!m.matches()) {
+      return defaultValue;
+    }
+
+    String digits = m.group(1);
+    String unitName = m.group(2).trim();
+
+    TimeUnit inputUnit;
+    int inputMul;
+
+    if (match(unitName, "h", "hour", "hours")) {
+      inputUnit = TimeUnit.HOURS;
+      inputMul = 1;
+    } else if ("".equals(unitName) || match(unitName, "d", "day", "days")) {
+      inputUnit = TimeUnit.DAYS;
+      inputMul = 1;
+    } else if (match(unitName, "w", "week", "weeks")) {
+      inputUnit = TimeUnit.DAYS;
+      inputMul = 7;
+    } else if (match(unitName, "mon", "month", "months")) {
+      inputUnit = TimeUnit.DAYS;
+      inputMul = 30;
+    } else {
+      throw notTimeUnit(valueString);
+    }
+
+    try {
+      return wantUnit.convert(Long.parseLong(digits) * inputMul, inputUnit);
+    } catch (NumberFormatException nfe) {
+      throw notTimeUnit(valueString);
+    }
+  }
+
+  private static boolean match(String a, String... cases) {
+    for (String b : cases) {
+      if (b.equalsIgnoreCase(a)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  private static IllegalArgumentException notTimeUnit(
+      String section, String setting, String valueString) {
+    return new IllegalArgumentException(
+        "Invalid time unit value: " + section + "." + setting + " = " + valueString);
+  }
+
+  private static IllegalArgumentException notTimeUnit(String val) {
+    return new IllegalArgumentException("Invalid time unit value: " + val);
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/ExecutorConfig.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/ExecutorConfig.java
new file mode 100644
index 0000000..f339302
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/ExecutorConfig.java
@@ -0,0 +1,160 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.executor;
+
+import static java.time.ZoneId.systemDefault;
+
+import com.ericsson.gerrit.plugins.gcconductor.CommonConfig;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Strings;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.time.DayOfWeek;
+import java.time.Duration;
+import java.time.LocalTime;
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeParseException;
+import java.time.temporal.ChronoUnit;
+import java.util.Locale;
+import java.util.Optional;
+import java.util.concurrent.TimeUnit;
+import org.eclipse.jgit.lib.Config;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@Singleton
+class ExecutorConfig extends CommonConfig {
+  private static final Logger log = LoggerFactory.getLogger(ExecutorConfig.class);
+
+  static final String CORE_SECTION = "core";
+  static final String DB_SECTION = "db";
+  static final String EVALUATION_SECTION = "evaluation";
+
+  static final String DELAY_KEY = "delay";
+  static final String EXECUTOR_KEY = "executors";
+  static final String PICK_OWN_HOST_KEY = "pickOwnHostOnly";
+  static final String REPOS_PATH_KEY = "repositoriesPath";
+  static final String INTERVAL_KEY = "interval";
+  static final String START_TIME_KEY = "startTime";
+
+  static final String EMPTY = "";
+  static final int DEFAULT_EXECUTORS = 2;
+  static final int DEFAULT_DELAY = 0;
+  static final String DEFAULT_REPOS_PATH = "/opt/gerrit/repos";
+  static final long DEFAULT_INTERVAL = -1;
+  static final long DEFAULT_INITIAL_DELAY = -1;
+
+  private final int delay;
+  private final int executors;
+  private final boolean pickOwnHostOnly;
+  private final String repositoriesPath;
+  private final long interval;
+  private final long initialDelay;
+
+  @Inject
+  ExecutorConfig(Config config) {
+    super(
+        getString(config, DB_SECTION, null, DB_URL_KEY, DEFAULT_DB_URL),
+        getString(config, DB_SECTION, null, DB_NAME_KEY, DEFAULT_DB_NAME),
+        Strings.nullToEmpty(getString(config, DB_SECTION, null, DB_URL_OPTIONS_KEY, EMPTY)),
+        getString(config, DB_SECTION, null, DB_USERNAME_KEY, DEFAULT_DB_USERNAME),
+        getString(config, DB_SECTION, null, DB_PASS_KEY, DEFAULT_DB_PASSWORD),
+        config.getInt(EVALUATION_SECTION, PACKED_KEY, PACKED_DEFAULT),
+        config.getInt(EVALUATION_SECTION, LOOSE_KEY, LOOSE_DEFAULT));
+    delay = config.getInt(CORE_SECTION, DELAY_KEY, DEFAULT_DELAY);
+    executors = config.getInt(CORE_SECTION, EXECUTOR_KEY, DEFAULT_EXECUTORS);
+    pickOwnHostOnly = config.getBoolean(CORE_SECTION, PICK_OWN_HOST_KEY, true);
+    repositoriesPath =
+        getString(config, EVALUATION_SECTION, null, REPOS_PATH_KEY, DEFAULT_REPOS_PATH);
+    interval = interval(config, EVALUATION_SECTION, INTERVAL_KEY);
+    initialDelay =
+        initialDelay(
+            config.getString(EVALUATION_SECTION, null, START_TIME_KEY),
+            ZonedDateTime.now(systemDefault()),
+            interval);
+  }
+
+  int getExecutors() {
+    return executors;
+  }
+
+  boolean isPickOwnHostOnly() {
+    return pickOwnHostOnly;
+  }
+
+  int getDelay() {
+    return delay;
+  }
+
+  String getRepositoriesPath() {
+    return repositoriesPath;
+  }
+
+  long getInitialDelay() {
+    return initialDelay;
+  }
+
+  long getInterval() {
+    return interval;
+  }
+
+  private long interval(Config rc, String section, String key) {
+    try {
+      return ConfigUtil.getTimeUnit(rc, section, key, DEFAULT_INTERVAL, TimeUnit.MILLISECONDS);
+    } catch (IllegalArgumentException e) {
+      log.debug("Invalid {}.{} setting. Periodic evaluation disabled", section, key, e);
+      return DEFAULT_INTERVAL;
+    }
+  }
+
+  @VisibleForTesting
+  long initialDelay(String start, ZonedDateTime now, long interval) {
+    if (start == null) {
+      return DEFAULT_INITIAL_DELAY;
+    }
+    try {
+      DateTimeFormatter formatter = DateTimeFormatter.ofPattern("[E ]HH:mm").withLocale(Locale.US);
+      LocalTime firstStartTime = LocalTime.parse(start, formatter);
+      ZonedDateTime startTime = now.with(firstStartTime);
+      Optional<DayOfWeek> dayOfWeek = getDayOfWeek(start, formatter);
+      if (dayOfWeek.isPresent()) {
+        startTime = startTime.with(dayOfWeek.get());
+      }
+      startTime = startTime.truncatedTo(ChronoUnit.MINUTES);
+      long firstDelay = Duration.between(now, startTime).toMillis() % interval;
+      if (firstDelay <= 0) {
+        firstDelay += interval;
+      }
+      return firstDelay;
+    } catch (DateTimeParseException e) {
+      log.debug(
+          "Invalid value {} for {} setting. Periodic evaluation disabled",
+          start,
+          START_TIME_KEY,
+          e);
+      return DEFAULT_INITIAL_DELAY;
+    }
+  }
+
+  private Optional<DayOfWeek> getDayOfWeek(String start, DateTimeFormatter formatter) {
+    try {
+      return Optional.of(formatter.parse(start, DayOfWeek::from));
+    } catch (DateTimeParseException ignored) {
+      // Day of week is an optional parameter.
+      return Optional.empty();
+    }
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/ExecutorModule.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/ExecutorModule.java
new file mode 100644
index 0000000..9ca5c5c
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/ExecutorModule.java
@@ -0,0 +1,64 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.executor;
+
+import com.ericsson.gerrit.plugins.gcconductor.CommonModule;
+import com.ericsson.gerrit.plugins.gcconductor.Hostname;
+import com.ericsson.gerrit.plugins.gcconductor.ShutdownListener;
+import com.google.inject.AbstractModule;
+import com.google.inject.Provides;
+import com.google.inject.Singleton;
+import com.google.inject.assistedinject.FactoryModuleBuilder;
+import com.google.inject.internal.UniqueAnnotations;
+import java.util.Optional;
+import org.eclipse.jgit.lib.Config;
+
+/** Configures bindings of the executor. */
+class ExecutorModule extends AbstractModule {
+
+  private final Config config;
+
+  ExecutorModule(Config config) {
+    this.config = config;
+  }
+
+  @Override
+  protected void configure() {
+    install(new CommonModule(ExecutorConfig.class));
+    bind(RuntimeShutdown.class);
+    bind(Config.class).toInstance(config);
+    bind(ExecutorConfig.class);
+    install(new FactoryModuleBuilder().build(GcWorker.Factory.class));
+    bind(ShutdownListener.class).annotatedWith(UniqueAnnotations.create()).to(GcExecutor.class);
+    bind(CancellableProgressMonitor.class);
+    bind(GarbageCollector.class);
+    bind(ScheduledEvaluator.class);
+    bind(ScheduledEvaluationTask.class);
+  }
+
+  @Provides
+  @Singleton
+  @QueuedFrom
+  Optional<String> wasQueuedFrom(ExecutorConfig config, @Hostname String hostname) {
+    return config.isPickOwnHostOnly() ? Optional.of(hostname) : Optional.empty();
+  }
+
+  @Provides
+  @Singleton
+  @QueuedForLongerThan
+  int queuedForLongerThan(ExecutorConfig config) {
+    return config.getDelay();
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/GarbageCollector.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/GarbageCollector.java
new file mode 100644
index 0000000..bc825d0
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/GarbageCollector.java
@@ -0,0 +1,50 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.executor;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.concurrent.Callable;
+import org.eclipse.jgit.api.Git;
+import org.eclipse.jgit.api.errors.GitAPIException;
+import org.eclipse.jgit.lib.ProgressMonitor;
+
+class GarbageCollector implements Callable<Boolean> {
+  private String repositoryPath;
+  private ProgressMonitor pm;
+
+  void setRepositoryPath(String repositoryPath) {
+    this.repositoryPath = repositoryPath;
+  }
+
+  void setPm(ProgressMonitor pm) {
+    this.pm = pm;
+  }
+
+  @Override
+  public Boolean call() throws Exception {
+    try (Git git = Git.open(new File(repositoryPath))) {
+      git.gc()
+          .setAggressive(true)
+          .setPreserveOldPacks(true)
+          .setPrunePreserved(true)
+          .setProgressMonitor(pm)
+          .call();
+      return true;
+    } catch (GitAPIException e) {
+      throw new IOException(e);
+    }
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/GcExecutor.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/GcExecutor.java
new file mode 100644
index 0000000..e0fb506
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/GcExecutor.java
@@ -0,0 +1,151 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.executor;
+
+import com.ericsson.gerrit.plugins.gcconductor.GcQueue;
+import com.ericsson.gerrit.plugins.gcconductor.GcQueueException;
+import com.ericsson.gerrit.plugins.gcconductor.Hostname;
+import com.ericsson.gerrit.plugins.gcconductor.RepositoryInfo;
+import com.ericsson.gerrit.plugins.gcconductor.ShutdownListener;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.inject.Guice;
+import com.google.inject.Inject;
+import com.google.inject.Injector;
+import com.google.inject.Singleton;
+import com.google.inject.Stage;
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import org.apache.logging.log4j.LogManager;
+import org.eclipse.jgit.errors.ConfigInvalidException;
+import org.eclipse.jgit.lib.Config;
+import org.eclipse.jgit.storage.file.FileBasedConfig;
+import org.eclipse.jgit.util.FS;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@Singleton
+class GcExecutor implements ShutdownListener {
+  private static final Logger log = LoggerFactory.getLogger(GcExecutor.class);
+
+  static final String CONFIG_FILE_PROPERTY = "configFile";
+
+  private final List<GcWorker> workers = new ArrayList<>();
+
+  private final GcQueue queue;
+
+  private final String hostname;
+
+  @Inject
+  GcExecutor(
+      GcQueue queue,
+      ExecutorConfig config,
+      GcWorker.Factory gcWorkerFactory,
+      ScheduledEvaluator scheduledEvaluator,
+      @Hostname String hostname) {
+    this.hostname = hostname;
+    this.queue = queue;
+    unpickRepositories(queue, hostname);
+    startExecutors(config, gcWorkerFactory, hostname);
+    scheduleEvaluation(config, scheduledEvaluator);
+  }
+
+  private void unpickRepositories(GcQueue queue, String hostname) {
+    try {
+      for (RepositoryInfo queuedRepo : queue.list()) {
+        String executor = queuedRepo.getExecutor();
+        if (executor != null && executor.startsWith(hostname)) {
+          queue.unpick(queuedRepo.getPath());
+        }
+      }
+    } catch (GcQueueException e) {
+      log.error("Failed to clear assigned repositories {}", e.getMessage(), e);
+    }
+  }
+
+  private void startExecutors(
+      ExecutorConfig config, GcWorker.Factory gcWorkerFactory, String hostname) {
+    log.info("Starting executors...");
+    synchronized (this) {
+      for (int i = 0; i < config.getExecutors(); i++) {
+        GcWorker worker = gcWorkerFactory.create(hostname + "-" + i);
+        worker.start();
+        workers.add(worker);
+      }
+    }
+  }
+
+  private void scheduleEvaluation(ExecutorConfig config, ScheduledEvaluator scheduledEvaluator) {
+    if (shouldScheduleEvaluation(config)) {
+      scheduledEvaluator.scheduleWith(config.getInitialDelay(), config.getInterval());
+    }
+  }
+
+  private boolean shouldScheduleEvaluation(ExecutorConfig config) {
+    return config.getInitialDelay() > 0 && config.getInterval() > 0;
+  }
+
+  @Override
+  public void onShutdown() {
+    log.info("Shutting down executors...");
+    synchronized (this) {
+      for (GcWorker worker : workers) {
+        worker.shutdown();
+      }
+      for (GcWorker worker : workers) {
+        try {
+          worker.join(1_000);
+        } catch (InterruptedException e) {
+          log.warn("Wait for executors to shutdown interrupted");
+          Thread.currentThread().interrupt();
+        }
+      }
+      unpickRepositories(queue, hostname);
+    }
+    log.info("Executors shut down OK.");
+  }
+
+  public static void main(String[] args) {
+    try {
+      final Injector injector =
+          Guice.createInjector(Stage.PRODUCTION, new ExecutorModule(loadConfig()));
+      // get the GcExecutor class to force start up
+      injector.getInstance(GcExecutor.class);
+      injector.getInstance(RuntimeShutdown.class).waitFor();
+    } catch (Throwable t) {
+      log.error("Uncaught error:", t);
+    }
+    LogManager.shutdown();
+  }
+
+  @VisibleForTesting
+  static Config loadConfig() {
+    String configPath = System.getProperty(CONFIG_FILE_PROPERTY);
+    if (configPath != null) {
+      FileBasedConfig config = new FileBasedConfig(new File(configPath), FS.DETECTED);
+      try {
+        config.load();
+        return config;
+      } catch (IOException | ConfigInvalidException e) {
+        log.error(
+            "Unable to load configuration from file {}. Default values will be used.",
+            configPath,
+            e);
+      }
+    }
+    return new Config();
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/GcWorker.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/GcWorker.java
new file mode 100644
index 0000000..14ea8fc
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/GcWorker.java
@@ -0,0 +1,149 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.executor;
+
+import com.ericsson.gerrit.plugins.gcconductor.GcQueue;
+import com.ericsson.gerrit.plugins.gcconductor.GcQueueException;
+import com.ericsson.gerrit.plugins.gcconductor.RepositoryInfo;
+import com.github.rholder.retry.Retryer;
+import com.github.rholder.retry.RetryerBuilder;
+import com.github.rholder.retry.StopStrategies;
+import com.github.rholder.retry.WaitStrategies;
+import com.google.inject.Inject;
+import com.google.inject.assistedinject.Assisted;
+import java.util.Optional;
+import java.util.concurrent.TimeUnit;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+class GcWorker extends Thread {
+  private static final Logger log = LoggerFactory.getLogger(GcWorker.class);
+
+  private final GcQueue queue;
+  private final GarbageCollector gc;
+  private final Optional<String> queuedFrom;
+  private final int queuedForLongerThan;
+  private final String name;
+  private final CancellableProgressMonitor cpm;
+  private final Retryer<Boolean> retryer =
+      RetryerBuilder.<Boolean>newBuilder()
+          .retryIfException()
+          .retryIfRuntimeException()
+          .withWaitStrategy(WaitStrategies.fixedWait(5, TimeUnit.SECONDS))
+          .withStopStrategy(StopStrategies.stopAfterAttempt(3))
+          .build();
+
+  interface Factory {
+    GcWorker create(String name);
+  }
+
+  @Inject
+  GcWorker(
+      GcQueue queue,
+      GarbageCollector gc,
+      CancellableProgressMonitor cpm,
+      @QueuedFrom Optional<String> queuedFrom,
+      @QueuedForLongerThan int queuedForLongerThan,
+      @Assisted String name) {
+    this.queue = queue;
+    this.gc = gc;
+    this.cpm = cpm;
+    this.queuedFrom = queuedFrom;
+    this.queuedForLongerThan = queuedForLongerThan;
+    this.name = name;
+    setName(name);
+  }
+
+  @Override
+  public void run() {
+    while (!cpm.isCancelled()) {
+      String repoPath = pickRepository();
+      if (repoPath != null) {
+        runGc(repoPath);
+      } else {
+        log.debug("No repository picked, going to sleep");
+        try {
+          Thread.sleep(5000);
+        } catch (InterruptedException e) {
+          log.debug("Gc task was interrupted while waiting to pick a repository");
+          Thread.currentThread().interrupt();
+          return;
+        }
+      }
+    }
+  }
+
+  private String pickRepository() {
+    try {
+      RepositoryInfo repoInfo = queue.pick(name, queuedForLongerThan, queuedFrom);
+      if (repoInfo != null) {
+        return repoInfo.getPath();
+      }
+    } catch (GcQueueException e) {
+      log.error("Unable to pick repository from the queue", e);
+    }
+    return null;
+  }
+
+  private void runGc(String repoPath) {
+    try {
+      log.info("Starting gc on repository {}", repoPath);
+      gc.setRepositoryPath(repoPath);
+      gc.setPm(cpm);
+      retryer.call(gc);
+      log.info("Gc completed on repository {}", repoPath);
+    } catch (Throwable e) {
+      if (!cpm.isCancelled()) {
+        log.error(
+            "Gc failed on repository {}. Error Message: {} Cause: {}: {}",
+            repoPath,
+            e.getMessage(),
+            e.getCause(),
+            e.getCause().getStackTrace(),
+            e);
+      }
+    } finally {
+      if (cpm.isCancelled()) {
+        log.warn("Gc on repository {} was cancelled", repoPath);
+        unpickRepository(repoPath);
+      } else {
+        removeRepoFromQueue(repoPath);
+      }
+    }
+  }
+
+  void shutdown() {
+    cpm.cancel();
+    this.interrupt();
+  }
+
+  private void unpickRepository(String repoPath) {
+    try {
+      queue.unpick(repoPath);
+      log.debug("Executor was removed for repository {}", repoPath);
+    } catch (GcQueueException e) {
+      log.error("Unable to remove executor for repository {}", repoPath, e);
+    }
+  }
+
+  private void removeRepoFromQueue(String repoPath) {
+    try {
+      queue.remove(repoPath);
+      log.debug("Repository {} was removed", repoPath);
+    } catch (GcQueueException e) {
+      log.error("Unable to remove repository {} from the queue", repoPath, e);
+    }
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/QueuedForLongerThan.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/QueuedForLongerThan.java
new file mode 100644
index 0000000..48f636c
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/QueuedForLongerThan.java
@@ -0,0 +1,24 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.executor;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import com.google.inject.BindingAnnotation;
+import java.lang.annotation.Retention;
+
+@Retention(RUNTIME)
+@BindingAnnotation
+@interface QueuedForLongerThan {}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/QueuedFrom.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/QueuedFrom.java
new file mode 100644
index 0000000..ee4c7ed
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/QueuedFrom.java
@@ -0,0 +1,24 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.executor;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import com.google.inject.BindingAnnotation;
+import java.lang.annotation.Retention;
+
+@Retention(RUNTIME)
+@BindingAnnotation
+@interface QueuedFrom {}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/RuntimeShutdown.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/RuntimeShutdown.java
new file mode 100644
index 0000000..2766a1e
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/RuntimeShutdown.java
@@ -0,0 +1,72 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.executor;
+
+import com.ericsson.gerrit.plugins.gcconductor.ShutdownNotifier;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@Singleton
+class RuntimeShutdown {
+  private static final Logger log = LoggerFactory.getLogger(RuntimeShutdown.class);
+
+  private final ShutdownHook hook;
+  private final ShutdownNotifier shutdownNotifier;
+
+  @Inject
+  RuntimeShutdown(ShutdownNotifier shutdownNotifier) {
+    this.shutdownNotifier = shutdownNotifier;
+    hook = new ShutdownHook();
+    Runtime.getRuntime().addShutdownHook(hook);
+  }
+
+  public void waitFor() {
+    hook.waitForShutdown();
+  }
+
+  private class ShutdownHook extends Thread {
+    private boolean completed;
+
+    ShutdownHook() {
+      setName("ShutdownCallback");
+    }
+
+    @Override
+    public void run() {
+      log.debug("Graceful shutdown requested");
+      shutdownNotifier.notifyAllListeners();
+      log.debug("Shutdown complete");
+      synchronized (this) {
+        completed = true;
+        notifyAll();
+      }
+    }
+
+    void waitForShutdown() {
+      synchronized (this) {
+        while (!completed) {
+          try {
+            wait();
+          } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            return;
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/ScheduledEvaluationTask.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/ScheduledEvaluationTask.java
new file mode 100644
index 0000000..cc0e837
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/ScheduledEvaluationTask.java
@@ -0,0 +1,103 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.executor;
+
+import com.ericsson.gerrit.plugins.gcconductor.EvaluationTask;
+import com.google.inject.Inject;
+import com.google.inject.ProvisionException;
+import com.google.inject.Singleton;
+import java.io.IOException;
+import java.nio.file.FileVisitOption;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.SimpleFileVisitor;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.SortedSet;
+import java.util.TreeSet;
+import org.eclipse.jgit.lib.RepositoryCache.FileKey;
+import org.eclipse.jgit.util.FS;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@Singleton
+class ScheduledEvaluationTask implements Runnable {
+  private static final Logger log = LoggerFactory.getLogger(ScheduledEvaluationTask.class);
+
+  private final EvaluationTask.Factory evaluationTaskFactory;
+  private final Path repositoriesPath;
+
+  @Inject
+  public ScheduledEvaluationTask(
+      EvaluationTask.Factory evaluationTaskFactory, ExecutorConfig config) {
+    this.evaluationTaskFactory = evaluationTaskFactory;
+    try {
+      repositoriesPath = Paths.get(config.getRepositoriesPath()).normalize().toRealPath();
+    } catch (IOException e) {
+      log.error("Failed to resolve repositoriesPath.", e);
+      throw new ProvisionException("Failed to resolve repositoriesPath: " + e.getMessage());
+    }
+  }
+
+  @Override
+  public void run() {
+    for (String repositoryPath : repositories()) {
+      if (Thread.currentThread().isInterrupted()) {
+        return;
+      }
+      evaluationTaskFactory.create(repositoryPath).run();
+    }
+  }
+
+  private Collection<String> repositories() {
+    ProjectVisitor visitor = new ProjectVisitor(repositoriesPath);
+    try {
+      Files.walkFileTree(
+          visitor.startFolder,
+          EnumSet.of(FileVisitOption.FOLLOW_LINKS),
+          Integer.MAX_VALUE,
+          visitor);
+    } catch (IOException e) {
+      log.error("Error walking repository tree {}", visitor.startFolder.toAbsolutePath(), e);
+    }
+    return Collections.unmodifiableSortedSet(visitor.found);
+  }
+
+  class ProjectVisitor extends SimpleFileVisitor<Path> {
+    private final SortedSet<String> found = new TreeSet<>();
+    private Path startFolder;
+
+    private ProjectVisitor(Path startFolder) {
+      this.startFolder = startFolder;
+    }
+
+    @Override
+    public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) {
+      if (!dir.equals(startFolder) && isRepo(dir)) {
+        found.add(dir.toString());
+        return FileVisitResult.SKIP_SUBTREE;
+      }
+      return FileVisitResult.CONTINUE;
+    }
+
+    private boolean isRepo(Path p) {
+      return FileKey.isGitRepository(p.toFile(), FS.DETECTED);
+    }
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/ScheduledEvaluator.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/ScheduledEvaluator.java
new file mode 100644
index 0000000..7997e40
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/executor/ScheduledEvaluator.java
@@ -0,0 +1,51 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.executor;
+
+import com.ericsson.gerrit.plugins.gcconductor.ShutdownListener;
+import com.google.common.util.concurrent.ThreadFactoryBuilder;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.TimeUnit;
+
+@Singleton
+class ScheduledEvaluator implements ShutdownListener {
+
+  private final ScheduledEvaluationTask evaluationTask;
+
+  private ScheduledThreadPoolExecutor scheduledExecutor;
+
+  @Inject
+  public ScheduledEvaluator(ScheduledEvaluationTask evaluationTask) {
+    this.evaluationTask = evaluationTask;
+  }
+
+  public void scheduleWith(long initialDelay, long interval) {
+    ThreadFactory threadFactory =
+        new ThreadFactoryBuilder().setNameFormat("ScheduledEvaluator-%d").build();
+    scheduledExecutor = new ScheduledThreadPoolExecutor(1, threadFactory);
+    scheduledExecutor.scheduleAtFixedRate(
+        evaluationTask, initialDelay, interval, TimeUnit.MILLISECONDS);
+  }
+
+  @Override
+  public void onShutdown() {
+    if (scheduledExecutor != null) {
+      scheduledExecutor.shutdownNow();
+    }
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/postgresqueue/DatabaseConstants.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/postgresqueue/DatabaseConstants.java
new file mode 100644
index 0000000..0b66cf3
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/postgresqueue/DatabaseConstants.java
@@ -0,0 +1,145 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License"),
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.postgresqueue;
+
+import static java.lang.String.format;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.Optional;
+import org.apache.commons.dbcp.BasicDataSource;
+
+final class DatabaseConstants {
+
+  static final String DRIVER = "org.postgresql.Driver";
+  static final String INITIAL_DATABASE = "postgres";
+
+  private static final String REPOSITORIES_TABLE = "repositories";
+  static final String REPOSITORY = "repository";
+  static final String EXECUTOR = "executor";
+  private static final String SEQUENCE = "sequence";
+  static final String QUEUED_AT = "queued_at";
+  static final String HOSTNAME = "hostname";
+
+  static final String CREATE_OR_UPDATE_SCHEMA =
+      "DO"
+          + " $$"
+          + " BEGIN"
+          + " CREATE TABLE IF NOT EXISTS "
+          + REPOSITORIES_TABLE
+          + "("
+          + REPOSITORY
+          + " VARCHAR(4096) PRIMARY KEY, "
+          + SEQUENCE
+          + " BIGSERIAL UNIQUE, "
+          + QUEUED_AT
+          + " TIMESTAMP WITHOUT TIME ZONE DEFAULT localtimestamp, "
+          + EXECUTOR
+          + " VARCHAR(258), "
+          + HOSTNAME
+          + " VARCHAR(255) NOT NULL);"
+          // This section is temporary to support migrating live, next version will
+          // drop the executor tables, only drop the foreign key for now.
+          + " IF EXISTS ("
+          + "     SELECT constraint_name FROM information_schema.table_constraints"
+          + "     WHERE table_name='"
+          + REPOSITORIES_TABLE
+          + "'"
+          + "     AND constraint_name='repositories_executor_fkey')"
+          + " THEN"
+          + "     ALTER TABLE "
+          + REPOSITORIES_TABLE
+          + " DROP CONSTRAINT repositories_executor_fkey;"
+          + " END IF;"
+          + " END "
+          + " $$";
+
+  private static final String SELECT_REPOSITORIES = "SELECT * FROM " + REPOSITORIES_TABLE;
+
+  static final String SELECT_REPOSITORIES_ORDERED = SELECT_REPOSITORIES + " ORDER BY " + SEQUENCE;
+
+  private DatabaseConstants() {}
+
+  static final String databaseExists(String name) {
+    return "SELECT 1 from pg_database WHERE datname='" + name + "'";
+  }
+
+  static final String createDatabase(String name) {
+    return "CREATE DATABASE " + name;
+  }
+
+  static final String dropDatabase(String name) {
+    return "DROP DATABASE " + name;
+  }
+
+  static final String select(String repository) {
+    return SELECT_REPOSITORIES + " WHERE " + REPOSITORY + "='" + repository + "'";
+  }
+
+  static final String insert(String repository, String hostname) {
+    return format(
+        "INSERT INTO %s (%s,%s) SELECT '%s','%s' WHERE NOT EXISTS (%s)",
+        REPOSITORIES_TABLE, REPOSITORY, HOSTNAME, repository, hostname, select(repository));
+  }
+
+  static final String delete(String repository) {
+    return "DELETE FROM " + REPOSITORIES_TABLE + " WHERE " + REPOSITORY + "='" + repository + "'";
+  }
+
+  static final String updateExecutor(
+      String executor, long queuedForLongerThan, Optional<String> queuedFrom) {
+    return format(
+        "UPDATE %s SET %s='%s' WHERE %s IN (SELECT %s FROM %s WHERE (%s is null OR %s='' OR %s='%s') AND age(localtimestamp, queued_at) > '%s' %s ORDER BY %s LIMIT 1 FOR UPDATE OF %s) RETURNING *",
+        REPOSITORIES_TABLE,
+        EXECUTOR,
+        executor,
+        REPOSITORY,
+        REPOSITORY,
+        REPOSITORIES_TABLE,
+        EXECUTOR,
+        EXECUTOR,
+        EXECUTOR,
+        executor,
+        queuedForLongerThan,
+        (queuedFrom.isPresent() ? " AND '" + queuedFrom.get() + "' LIKE hostname||'%'" : ""),
+        SEQUENCE,
+        REPOSITORIES_TABLE);
+  }
+
+  static final String updateQueuedFrom(String hostname) {
+    return format(
+        "UPDATE %s SET %s='%s' WHERE %s is NULL", REPOSITORIES_TABLE, HOSTNAME, hostname, EXECUTOR);
+  }
+
+  static final String clearExecutor(String repository) {
+    return format(
+        "UPDATE %s SET %s=NULL WHERE %s='%s'",
+        REPOSITORIES_TABLE, EXECUTOR, REPOSITORY, repository);
+  }
+
+  static final String bumpRepository(String repository) {
+    return format(
+        "UPDATE %s SET %s=(SELECT min(%s) FROM %s) -1 WHERE %s='%s'",
+        REPOSITORIES_TABLE, SEQUENCE, SEQUENCE, REPOSITORIES_TABLE, REPOSITORY, repository);
+  }
+
+  static boolean executeStatement(BasicDataSource ds, String query) throws SQLException {
+    try (Connection conn = ds.getConnection();
+        Statement stat = conn.createStatement()) {
+      return stat.execute(query);
+    }
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/postgresqueue/PostgresModule.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/postgresqueue/PostgresModule.java
new file mode 100644
index 0000000..24ceba9
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/postgresqueue/PostgresModule.java
@@ -0,0 +1,110 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.postgresqueue;
+
+import static com.ericsson.gerrit.plugins.gcconductor.postgresqueue.DatabaseConstants.DRIVER;
+import static com.ericsson.gerrit.plugins.gcconductor.postgresqueue.DatabaseConstants.INITIAL_DATABASE;
+import static com.ericsson.gerrit.plugins.gcconductor.postgresqueue.DatabaseConstants.createDatabase;
+import static com.ericsson.gerrit.plugins.gcconductor.postgresqueue.DatabaseConstants.databaseExists;
+import static com.ericsson.gerrit.plugins.gcconductor.postgresqueue.DatabaseConstants.executeStatement;
+
+import com.ericsson.gerrit.plugins.gcconductor.CommonConfig;
+import com.ericsson.gerrit.plugins.gcconductor.GcQueue;
+import com.ericsson.gerrit.plugins.gcconductor.ShutdownListener;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.inject.AbstractModule;
+import com.google.inject.Inject;
+import com.google.inject.Provides;
+import com.google.inject.Singleton;
+import com.google.inject.internal.UniqueAnnotations;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import org.apache.commons.dbcp.BasicDataSource;
+
+/** Configures bindings of the Postgres queue implementation. */
+public class PostgresModule extends AbstractModule {
+
+  private static final long EVICT_IDLE_TIME_MS = 1000L * 60;
+  private Class<? extends CommonConfig> commonConfig;
+
+  public PostgresModule(Class<? extends CommonConfig> commonConfig) {
+    this.commonConfig = commonConfig;
+  }
+
+  @Override
+  protected void configure() {
+    bind(CommonConfig.class).to(commonConfig);
+    bind(GcQueue.class).to(PostgresQueue.class);
+    bind(ShutdownListener.class)
+        .annotatedWith(UniqueAnnotations.create())
+        .to(DatabaseAccessCleanUp.class);
+  }
+
+  /**
+   * Provide access to the gc database. Database will be created if it does not exist.
+   *
+   * @param cfg The database configuration
+   * @return BasicDataSource to access gc database.
+   * @throws SQLException If an error occur while creating the database.
+   */
+  @Provides
+  @Singleton
+  BasicDataSource provideGcDatabaseAccess(CommonConfig cfg) throws SQLException {
+    BasicDataSource adminDataSource = createDataSource(cfg, INITIAL_DATABASE);
+    try (Connection conn = adminDataSource.getConnection();
+        Statement stat = conn.createStatement();
+        ResultSet resultSet = stat.executeQuery(databaseExists(cfg.getDatabaseName()))) {
+      if (!resultSet.next()) {
+        executeStatement(adminDataSource, createDatabase(cfg.getDatabaseName()));
+      }
+    } finally {
+      adminDataSource.close();
+    }
+    return createDataSource(cfg, cfg.getDatabaseName());
+  }
+
+  private static BasicDataSource createDataSource(CommonConfig cfg, String database) {
+    BasicDataSource ds = new BasicDataSource();
+    ds.setDriverClassName(DRIVER);
+    ds.setUrl(cfg.getDatabaseUrl() + database + cfg.getDatabaseUrlOptions());
+    ds.setUsername(cfg.getUsername());
+    ds.setPassword(cfg.getPassword());
+    ds.setMinEvictableIdleTimeMillis(EVICT_IDLE_TIME_MS);
+    ds.setTimeBetweenEvictionRunsMillis(EVICT_IDLE_TIME_MS / 2);
+    return ds;
+  }
+
+  /** Close the database access when plugin is unloaded */
+  @VisibleForTesting
+  static class DatabaseAccessCleanUp implements ShutdownListener {
+    private final BasicDataSource dataSource;
+
+    @Inject
+    public DatabaseAccessCleanUp(BasicDataSource dataSource) {
+      this.dataSource = dataSource;
+    }
+
+    @Override
+    public void onShutdown() {
+      try {
+        dataSource.close();
+      } catch (SQLException e) {
+        throw new RuntimeException("Failed to close database connection: " + e.getMessage(), e);
+      }
+    }
+  }
+}
diff --git a/src/main/java/com/ericsson/gerrit/plugins/gcconductor/postgresqueue/PostgresQueue.java b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/postgresqueue/PostgresQueue.java
new file mode 100644
index 0000000..d2dca5a
--- /dev/null
+++ b/src/main/java/com/ericsson/gerrit/plugins/gcconductor/postgresqueue/PostgresQueue.java
@@ -0,0 +1,161 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.postgresqueue;
+
+import static com.ericsson.gerrit.plugins.gcconductor.postgresqueue.DatabaseConstants.CREATE_OR_UPDATE_SCHEMA;
+import static com.ericsson.gerrit.plugins.gcconductor.postgresqueue.DatabaseConstants.EXECUTOR;
+import static com.ericsson.gerrit.plugins.gcconductor.postgresqueue.DatabaseConstants.HOSTNAME;
+import static com.ericsson.gerrit.plugins.gcconductor.postgresqueue.DatabaseConstants.QUEUED_AT;
+import static com.ericsson.gerrit.plugins.gcconductor.postgresqueue.DatabaseConstants.REPOSITORY;
+import static com.ericsson.gerrit.plugins.gcconductor.postgresqueue.DatabaseConstants.SELECT_REPOSITORIES_ORDERED;
+import static com.ericsson.gerrit.plugins.gcconductor.postgresqueue.DatabaseConstants.bumpRepository;
+import static com.ericsson.gerrit.plugins.gcconductor.postgresqueue.DatabaseConstants.clearExecutor;
+import static com.ericsson.gerrit.plugins.gcconductor.postgresqueue.DatabaseConstants.delete;
+import static com.ericsson.gerrit.plugins.gcconductor.postgresqueue.DatabaseConstants.executeStatement;
+import static com.ericsson.gerrit.plugins.gcconductor.postgresqueue.DatabaseConstants.insert;
+import static com.ericsson.gerrit.plugins.gcconductor.postgresqueue.DatabaseConstants.select;
+import static com.ericsson.gerrit.plugins.gcconductor.postgresqueue.DatabaseConstants.updateExecutor;
+import static com.ericsson.gerrit.plugins.gcconductor.postgresqueue.DatabaseConstants.updateQueuedFrom;
+
+import com.ericsson.gerrit.plugins.gcconductor.GcQueue;
+import com.ericsson.gerrit.plugins.gcconductor.GcQueueException;
+import com.ericsson.gerrit.plugins.gcconductor.RepositoryInfo;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import org.apache.commons.dbcp.BasicDataSource;
+
+@Singleton
+public class PostgresQueue implements GcQueue {
+
+  private final BasicDataSource dataSource;
+
+  @Inject
+  public PostgresQueue(BasicDataSource dataSource) throws SQLException {
+    this.dataSource = dataSource;
+    executeStatement(dataSource, CREATE_OR_UPDATE_SCHEMA);
+  }
+
+  @Override
+  public void add(String repository, String queuedFrom) throws GcQueueException {
+    try {
+      executeStatement(dataSource, insert(repository, queuedFrom));
+    } catch (SQLException e) {
+      if (!"23505".equals(e.getSQLState())) {
+        // UNIQUE CONSTRAINT violation means repository is already in the queue
+        throw new GcQueueException("Failed to add repository " + repository, e);
+      }
+    }
+  }
+
+  @Override
+  public RepositoryInfo pick(String executor, long queuedForLongerThan, Optional<String> queuedFrom)
+      throws GcQueueException {
+    try (Connection conn = dataSource.getConnection();
+        Statement stat = conn.createStatement();
+        ResultSet resultSet =
+            stat.executeQuery(updateExecutor(executor, queuedForLongerThan, queuedFrom))) {
+      if (resultSet.next()) {
+        return toRepositoryInfo(resultSet);
+      }
+    } catch (SQLException e) {
+      throw new GcQueueException("Failed to pick repository", e);
+    }
+    return null;
+  }
+
+  @Override
+  public void unpick(String repository) throws GcQueueException {
+    try {
+      executeStatement(dataSource, clearExecutor(repository));
+    } catch (SQLException e) {
+      throw new GcQueueException("Failed to unpick repository " + repository, e);
+    }
+  }
+
+  @Override
+  public void remove(String repository) throws GcQueueException {
+    try {
+      executeStatement(dataSource, delete(repository));
+    } catch (SQLException e) {
+      throw new GcQueueException("Failed to remove repository " + repository, e);
+    }
+  }
+
+  @Override
+  public boolean contains(String repository) throws GcQueueException {
+    try (Connection conn = dataSource.getConnection();
+        Statement stat = conn.createStatement();
+        ResultSet resultSet = stat.executeQuery(select(repository))) {
+      if (resultSet.next()) {
+        return true;
+      }
+    } catch (SQLException e) {
+      throw new GcQueueException("Failed to check if queue contains repository " + repository, e);
+    }
+    return false;
+  }
+
+  @Override
+  public void resetQueuedFrom(String queuedFrom) throws GcQueueException {
+    try {
+      executeStatement(dataSource, updateQueuedFrom(queuedFrom));
+    } catch (SQLException e) {
+      throw new GcQueueException("Failed to reset queuedFrom", e);
+    }
+  }
+
+  @Override
+  public List<RepositoryInfo> list() throws GcQueueException {
+    try (Connection conn = dataSource.getConnection();
+        Statement stat = conn.createStatement();
+        ResultSet resultSet = stat.executeQuery(SELECT_REPOSITORIES_ORDERED)) {
+      List<RepositoryInfo> repositories = new ArrayList<>();
+      while (resultSet.next()) {
+        repositories.add(toRepositoryInfo(resultSet));
+      }
+      return repositories;
+    } catch (SQLException e) {
+      throw new GcQueueException("Failed to list repositories ", e);
+    }
+  }
+
+  @Override
+  public void bumpToFirst(String repository) throws GcQueueException {
+    try {
+      executeStatement(dataSource, bumpRepository(repository));
+    } catch (SQLException e) {
+      throw new GcQueueException("Failed to update repository priority ", e);
+    }
+  }
+
+  private RepositoryInfo toRepositoryInfo(ResultSet resultSet) throws SQLException {
+    int repositoryColumn = resultSet.findColumn(REPOSITORY);
+    int queuedAtColumn = resultSet.findColumn(QUEUED_AT);
+    int executorColumn = resultSet.findColumn(EXECUTOR);
+    int hostnameColumn = resultSet.findColumn(HOSTNAME);
+    return new RepositoryInfo(
+        resultSet.getString(repositoryColumn),
+        resultSet.getTimestamp(queuedAtColumn),
+        resultSet.getString(executorColumn),
+        resultSet.getString(hostnameColumn));
+  }
+}
diff --git a/src/main/resources/Documentation/about.md b/src/main/resources/Documentation/about.md
new file mode 100644
index 0000000..870a2ad
--- /dev/null
+++ b/src/main/resources/Documentation/about.md
@@ -0,0 +1,37 @@
+This plugin provides an automated way of detecting, managing and cleaning up
+(garbage collecting) the 'dirty' repositories in a Gerrit instance.
+
+It has two components: gc-conductor and gc-executor.
+
+gc-conductor is a Gerrit plugin deployed in the plugins folder of a Gerrit site.
+Its main function is to evaluate the dirtiness of repositories and add them to a
+queue of repositories to be garbage collected. This queue is maintained as a
+database in a postgresql server.
+
+gc-executor is a runnable jar that picks up the repositories from the queue and
+performs the garbage collection operation on them. gc-executor can be deployed
+in the same machine that hosts the Gerrit application or in a different machine
+that has access to the repositories and the postgresql server holding the queue.
+
+Instructions to build gc-conductor and gc-executor can be found in the
+[build documentation][build]. For configuring the two components, see the
+[configuration file][config].
+
+The plugin also provides SSH commands to help managing the repositories queue:
+
+* _add-to-queue_ allows to manually add a repository to the queue.
+* _bump-to-first_ increases the priority of a repository by promoting it to the
+   front of the queue.
+* _show-queue_ shows the list of repositories in the queue.
+* _set-queued-from_ allows to change the identifier of the Gerrit instance that
+  added the repository to the queue. This command is mainly useful in the context
+  of an active-passive redundant configuration when the gc-executor runs in the
+  same machine as the Gerrit application: by default in these cases, gc-executor
+  only picks the repositories that have been added to the queue by the Gerrit
+  instance running in the same host. If one of the executors goes down, it can be
+  helpful to be able to change the _set_queued_from_ field, so that the running
+  one can pick up repositories that were not initially added to the queue by its
+  corresponding Gerrit instance.
+
+[build]: build.html
+[config]: config.html
diff --git a/src/main/resources/Documentation/build.md b/src/main/resources/Documentation/build.md
new file mode 100644
index 0000000..e6e9ec1
--- /dev/null
+++ b/src/main/resources/Documentation/build.md
@@ -0,0 +1,113 @@
+Build
+=====
+
+This plugin is built with Bazel and two build modes are supported:
+
+* Standalone
+* In Gerrit tree.
+
+Standalone build mode is recommended, as this mode doesn't require local Gerrit
+tree to exist.
+
+## Build standalone
+
+To build the plugin, issue the following command:
+
+```
+  bazel build @PLUGIN@
+```
+
+The output is created in
+
+```
+  bazel-genfiles/@PLUGIN@.jar
+```
+
+To package the plugin sources run:
+
+```
+  bazel build lib@PLUGIN@__plugin-src.jar
+```
+
+The output is created in:
+
+```
+  bazel-bin/lib@PLUGIN@__plugin-src.jar
+```
+
+To execute the tests run:
+
+```
+  bazel test //...
+```
+
+This project can be imported into the Eclipse IDE. Execute:
+
+```
+  ./tools/eclipse/project.py
+```
+
+to generate the required files and then import the project.
+
+
+To build the executor, issue the following command:
+
+```
+  bazel build gc-executor_deploy.jar
+```
+
+The output is created in:
+
+```
+  /bazel-bin/gc-executor_deploy.jar
+```
+
+This jar should be renamed to gc-executor.jar before deployment.
+
+## Build in Gerrit tree
+
+Clone or link this plugin to the plugins directory of Gerrit's
+source tree. Put the external dependency Bazel build file into
+the Gerrit /plugins directory, replacing the existing empty one.
+
+```
+  cd gerrit/plugins
+  rm external_plugin_deps.bzl
+  ln -s @PLUGIN@/external_plugin_deps.bzl .
+```
+
+From Gerrit source tree issue the command:
+
+```
+  bazel build plugins/@PLUGIN@
+```
+
+The output is created in
+
+```
+  bazel-genfiles/plugins/@PLUGIN@/@PLUGIN@.jar
+```
+
+To execute the tests run:
+
+```
+  bazel test --test_tag_filters=@PLUGIN@
+```
+
+or filtering using the comma separated tags:
+
+````
+  bazel test --test_tag_filters=@PLUGIN@ --strict_java_deps=off //...
+````
+
+This project can be imported into the Eclipse IDE.
+Add the plugin name to the `CUSTOM_PLUGINS` set in
+Gerrit core in `tools/bzl/plugins.bzl`, and execute:
+
+```
+  ./tools/eclipse/project.py
+```
+
+[Back to @PLUGIN@ documentation index][index]
+
+[index]: index.html
diff --git a/src/main/resources/Documentation/cmd-add-to-queue.md b/src/main/resources/Documentation/cmd-add-to-queue.md
new file mode 100644
index 0000000..326174f
--- /dev/null
+++ b/src/main/resources/Documentation/cmd-add-to-queue.md
@@ -0,0 +1,58 @@
+add-to-queue
+=====================
+
+NAME
+----
+add-to-queue - Add a repository to the GC queue
+
+SYNOPSIS
+--------
+>     ssh -p @SSH_PORT@ @SSH_HOST@ @PLUGIN@ add-to-queue <REPOSITORY> [--first]
+
+DESCRIPTION
+-----------
+Add a repository to the GC queue.
+
+An absolute path to the repository (including the .git suffix) or the project
+name are accepted. A symlink pointing to a repository is also admitted.
+
+Adding a repository to the GC queue is an idempotent operation, i.e., executing
+the command multiple times only add the repository to the queue once.
+
+ACCESS
+------
+Any user who has configured an SSH key and has been granted the
+`Administrate Server` global capability.
+
+SCRIPTING
+---------
+This command is intended to be used in a script.
+
+OPTIONS
+---------
+`--first`
+:	Add repository as first priority in GC queue.
+
+EXAMPLES
+--------
+Absolute path to a repository:
+
+```
+$ ssh -p @SSH_PORT@ @SSH_HOST@ @PLUGIN@ add-to-queue /repos/my/repo.git
+```
+
+Symlink pointing to a repository:
+
+```
+$ ssh -p @SSH_PORT@ @SSH_HOST@ @PLUGIN@ add-to-queue /opt/gerrit/repos/my/repo.git
+```
+
+Name of the project:
+
+```
+$ ssh -p @SSH_PORT@ @SSH_HOST@ @PLUGIN@ add-to-queue my/repo
+```
+
+GERRIT
+------
+Part of [Gerrit Code Review](../../../Documentation/index.html)
diff --git a/src/main/resources/Documentation/cmd-bump-to-first.md b/src/main/resources/Documentation/cmd-bump-to-first.md
new file mode 100644
index 0000000..f05b932
--- /dev/null
+++ b/src/main/resources/Documentation/cmd-bump-to-first.md
@@ -0,0 +1,27 @@
+bump-to-first
+=====================
+
+NAME
+----
+bump-to-first - Update a repository to be first priority in GC queue.
+
+SYNOPSIS
+--------
+>     ssh -p @SSH_PORT@ @SSH_HOST@ @PLUGIN@ bump-to-first <REPOSITORY>
+
+DESCRIPTION
+-----------
+Update a repository to be first priority in GC queue.
+
+ACCESS
+------
+Any user who has configured an SSH key and has been granted the
+`Administrate Server` global capability.
+
+SCRIPTING
+---------
+This command is intended to be used in a script.
+
+GERRIT
+------
+Part of [Gerrit Code Review](../../../Documentation/index.html)
diff --git a/src/main/resources/Documentation/cmd-set-queued-from.md b/src/main/resources/Documentation/cmd-set-queued-from.md
new file mode 100644
index 0000000..09293f2
--- /dev/null
+++ b/src/main/resources/Documentation/cmd-set-queued-from.md
@@ -0,0 +1,27 @@
+set-queued-from
+=====================
+
+NAME
+----
+set-queued-from - Set queued from for all unassigned repositories
+
+SYNOPSIS
+--------
+>     ssh -p @SSH_PORT@ @SSH_HOST@ @PLUGIN@ set-queued-from <HOSTNAME>
+
+DESCRIPTION
+-----------
+Set queued from for all unassigned repositories.
+
+ACCESS
+------
+Any user who has configured an SSH key and has been granted the
+`Administrate Server` global capability.
+
+SCRIPTING
+---------
+This command is intended to be used in a script.
+
+GERRIT
+------
+Part of [Gerrit Code Review](../../../Documentation/index.html)
diff --git a/src/main/resources/Documentation/cmd-show-queue.md b/src/main/resources/Documentation/cmd-show-queue.md
new file mode 100644
index 0000000..ab20a85
--- /dev/null
+++ b/src/main/resources/Documentation/cmd-show-queue.md
@@ -0,0 +1,28 @@
+show-queue
+=====================
+
+NAME
+----
+show-queue - Show GC queue
+
+SYNOPSIS
+--------
+>     ssh -p @SSH_PORT@ @SSH_HOST@ @PLUGIN@ show-queue
+
+DESCRIPTION
+-----------
+Display repositories in gc queue and the executor handling the repository.
+
+ACCESS
+------
+Any user who has configured an SSH key and has been granted the
+`Administrate Server` global capability.
+
+SCRIPTING
+---------
+This command is intended to be used on a need basis by the admins but could also
+be used in a script.
+
+GERRIT
+------
+Part of [Gerrit Code Review](../../../Documentation/index.html)
diff --git a/src/main/resources/Documentation/config.md b/src/main/resources/Documentation/config.md
new file mode 100644
index 0000000..e0049aa
--- /dev/null
+++ b/src/main/resources/Documentation/config.md
@@ -0,0 +1,190 @@
+@PLUGIN@ Configuration
+======================
+
+gc-conductor uses a postgresql database to manage the queue of repositories that
+need to be garbage collected. The following commands can be used on the postgresql
+database host to create the configured username/password; superuser is required:
+
+```
+  sudo /etc/init.d/postgresql start
+  sudo su - postgres
+  createuser -P -s -e username
+```
+
+File `gerrit.config`
+--------------------
+
+`plugin.@PLUGIN@.packed`
+:  Packed threshold. By default, `40`.
+
+`plugin.@PLUGIN@.loose`
+:  Loose threshold. By default, `400`.
+
+`plugin.@PLUGIN@.databaseUrl`
+:  Database url. By default, `jdbc:postgresql://localhost:5432/`.
+
+`plugin.@PLUGIN@.databaseName`
+:  Database name. By default, `gc`.
+
+`plugin.@PLUGIN@.databaseUrlOptions`
+:  jdbc option properties to append to the database URL, example
+`?ssl=true&loglevel=org.postgresql.Driver.DEBUG`. Empty by default.
+
+`plugin.@PLUGIN@.username`
+:  Database username. By default, `gc`.
+
+`plugin.@PLUGIN@.password`
+:  Database password. By default, `gc`.
+
+`plugin.@PLUGIN@.threadPoolSize`
+:  Thread pool size. By default, `4`.
+
+`plugin.@PLUGIN@.expireTimeRecheck`
+:  Time before a check is considered expired. By default, `60s`.
+
+GC executor
+--------------------
+
+GC executor is packaged as a runnable java jar. The [build documentation][build]
+details the steps to build gc-executor.jar. Once built, gc-executor.jar is deployed
+to the node charged of doing the garbage collection (GC) process.
+
+The configuration can be passed to the gc executor jar by using:
+
+```
+  java -DconfigFile=/path/to/config_file.config -jar executor.jar
+```
+
+### File `gc.config`
+
+The file `gc.config` is a Git-style config file that controls several settings for
+gc executor. The contents of the `gc.config` file are cached at startup. If this
+file is modified, gc executor needs to be restarted in order to be able to use the
+new values.
+
+
+#### Sample `gc.config`:
+
+```
+[jvm]
+  javaHome = /opt/gerrit/jdk8
+  javaOptions = -Xrunjdwp:transport=dt_socket,address=localhost:8788,server=y,suspend=n
+  javaOptions = -Xms1g
+  javaOptions = -Xmx32g
+  javaOptions = -XX:+UseG1GC
+  javaOptions = -XX:MaxGCPauseMillis=2000
+[core]
+  executors = 2
+  pickOwnHostOnly = false
+  delay = 0
+
+[db]
+  databaseUrl = jdbc:postgresql://same_host_as_plugin:5432/
+  databaseName = testDb
+  databaseUrlOptions = ?ssl=true
+  username = testUser
+  password = testPass
+
+[evaluation]
+  packed = 40
+  loose = 400
+  repositoriesPath = /path/to/repositories
+  startTime = Sat 22:00
+  interval = 1 week
+```
+
+#### Section `jvm`
+
+`jvm.javaHome`
+:       Location of java. By default /opt/gerrit/jdk8
+
+`jvm.javaOptions`
+:       Options to pass along to the Java runtime. If multiple values are
+configured, they are passed in order on the command line, separated by spaces.
+
+#### Section `core`
+
+`core.executors`
+:       Number of executors. By default, 2.
+
+`core.pickOwnHostOnly`
+:       Whether to pick repositories added to queue from same host only or not.
+By default, true.
+
+`core.delay`
+:       minimal delay in seconds a repository must be in queue before it can be
+picked. By default, 0.
+
+#### Section `db`
+
+`db.databaseUrl`
+:  Database URL. By default, `jdbc:postgresql://localhost:5432/`.
+
+`db.databaseName`
+:       Database name. By default, `gc`.
+
+`db.databaseUrlOptions`
+:  jdbc option properties to append to the database URL. For example,
+`?ssl=true&loglevel=org.postgresql.Driver.DEBUG`. Empty by default.
+
+`db.username`
+:       Username to connect to the database. By default, `gc`.
+
+`db.password`
+:       Password associated to that username. By default, `gc`.
+
+It is important to note here that the parameters used in this section should be
+the same used in `gerrit.config` to define the database settings.
+
+#### Section `evaluation`
+
+This section allows to configure dirtiness evaluation for a list of repositories.
+
+`evaluation.packed`
+:       number of pack files in a repository for it to be considered dirty. By
+default, 40.
+
+`evaluation.loose`
+:       number of loose objects in a repository for it to be considered dirty.
+By default, 400.
+
+`evaluation.repositoriesPath`
+:       path to the repositories to be evaluated for dirtiness. By default,
+/opt/gerrit/repos.
+
+`evaluation.startTime`
+:       start time to define the first execution of the repositories dirtiness
+evaluation. Expressed as &lt;day of week> &lt;hours>:&lt;minutes>. By default,
+disabled.
+
+This setting should be expressed using the following time units:
+
+  * &lt;day of week> : Mon, Tue, Wed, Thu, Fri, Sat, Sun
+  * &lt;hours> : 00-23
+  * &lt;minutes> : 00-59
+
+`evaluation.interval`
+:       interval for periodic repetition of dirtiness evaluation. By default,
+disabled.
+
+The following suffixes are supported to define the time unit for the interval:
+
+ * h, hour, hours
+ * d, day, days
+ * w, week, weeks (1 week is treated as 7 days)
+ * mon, month, months (1 month is treated as 30 days)
+
+If no time unit is specified, days are assumed.
+
+### GC execution
+
+Executors can be started/stopped using gcctl.sh script.
+
+```
+  /opt/gerrit/gc-conductor/gcctl.sh {start|stop|restart|status|check}
+```
+
+[Back to @PLUGIN@ documentation index][index]
+
+[build]: build.html
+[index]: index.html
diff --git a/src/main/resources/log4j2.xml b/src/main/resources/log4j2.xml
new file mode 100644
index 0000000..7f63ec5
--- /dev/null
+++ b/src/main/resources/log4j2.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Configuration status="WARN" shutdownHook="disable">
+	<Properties>
+		<Property name="log.path">/opt/gerrit/review_site/logs/gc</Property>
+	</Properties>
+	<Appenders>
+		<RollingFile name="RollingFile" fileName="${log.path}/gc.log"
+			filePattern="${log.path}/gc.log.%d{yyyy-MM-dd}.gz"
+			ignoreExceptions="false">
+			<PatternLayout
+				pattern="%d{yyy-MM-dd HH:mm:ss.SSS} %-5level %logger{1} - %t - %msg%n" />
+			<Policies>
+				<TimeBasedTriggeringPolicy interval="1" modulate="true" />
+				<SizeBasedTriggeringPolicy size="30 MB" />
+			</Policies>
+		</RollingFile>
+	</Appenders>
+	<Loggers>
+		<Logger name="com.ericsson.gerrit.plugins.gcconductor" level="info" />
+		<Root level="error">
+			<AppenderRef ref="RollingFile" />
+		</Root>
+	</Loggers>
+</Configuration>
\ No newline at end of file
diff --git a/src/test/java/com/ericsson/gerrit/plugins/gcconductor/EvaluationTaskTest.java b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/EvaluationTaskTest.java
new file mode 100644
index 0000000..8106a71
--- /dev/null
+++ b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/EvaluationTaskTest.java
@@ -0,0 +1,175 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.ericsson.gerrit.plugins.gcconductor.evaluator.EvaluatorConfig;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Comparator;
+import org.eclipse.jgit.api.Git;
+import org.eclipse.jgit.api.ResetCommand.ResetType;
+import org.eclipse.jgit.internal.storage.file.FileRepository;
+import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.revwalk.RevCommit;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class EvaluationTaskTest {
+
+  @Rule public TemporaryFolder dir = new TemporaryFolder();
+
+  private static final String SOME_HOSTNAME = "hostname";
+
+  @Mock private EvaluatorConfig cfg;
+  @Mock private GcQueue queue;
+
+  private EvaluationTask task;
+  private Repository repository;
+  private String repositoryPath;
+
+  @Before
+  public void setUp() throws Exception {
+    repository = createRepository("someRepo.git");
+    repositoryPath = repository.getDirectory().getAbsolutePath();
+    task = new EvaluationTask(cfg, queue, SOME_HOSTNAME, repositoryPath);
+  }
+
+  @Test
+  public void dirtyRepositoryObjectsShouldBeAddedToTheQueue() throws Exception {
+    when(cfg.getPackedThreshold()).thenReturn(1);
+    addFileTo(repository);
+    when(queue.contains(repositoryPath)).thenReturn(false);
+    task = new EvaluationTask(cfg, queue, SOME_HOSTNAME, repositoryPath);
+    task.run();
+    verify(queue).add(repositoryPath, SOME_HOSTNAME);
+  }
+
+  @Test
+  public void dirtyRepositoryPacksShouldBeAddedToTheQueue() throws Exception {
+    when(cfg.getPackedThreshold()).thenReturn(1);
+    when(queue.contains(repositoryPath)).thenReturn(false);
+    addFileTo(repository);
+    gc(repository);
+    task = new EvaluationTask(cfg, queue, SOME_HOSTNAME, repositoryPath);
+    task.run();
+    verify(queue).add(repositoryPath, SOME_HOSTNAME);
+  }
+
+  @Test
+  public void repositoryShouldNotBeAddedIfAlreadyInQueue() throws Exception {
+    when(queue.contains(repositoryPath)).thenReturn(true);
+    task.run();
+    verify(queue, never()).add(repositoryPath, SOME_HOSTNAME);
+  }
+
+  @Test
+  public void cleanRepositoryShouldNotBeAddedToQueue() throws Exception {
+    when(cfg.getLooseThreshold()).thenReturn(1);
+    when(cfg.getPackedThreshold()).thenReturn(1);
+    when(queue.contains(repositoryPath)).thenReturn(false);
+    task.run();
+    verify(queue, never()).add(repositoryPath, SOME_HOSTNAME);
+  }
+
+  @Test
+  public void queueThrowsErrorCheckingIfRepositoryExists() throws Exception {
+    doThrow(new GcQueueException("some message", new Throwable()))
+        .when(queue)
+        .contains(repositoryPath);
+    task.run();
+    verify(queue, never()).add(repositoryPath, SOME_HOSTNAME);
+  }
+
+  @Test
+  public void queueThrowsErrorInsertingRepository() throws Exception {
+    when(queue.contains(repositoryPath)).thenReturn(false);
+    doThrow(new GcQueueException("some message", new Throwable()))
+        .when(queue)
+        .add(repositoryPath, SOME_HOSTNAME);
+    task.run();
+  }
+
+  @Test
+  public void repositoryNoLongerExist() throws Exception {
+    when(queue.contains(repositoryPath)).thenReturn(false);
+    dir.delete();
+    task.run();
+    verify(queue, never()).add(repositoryPath, SOME_HOSTNAME);
+  }
+
+  @Test
+  public void toStringReturnsProperMessage() {
+    assertThat(task.toString()).isEqualTo("Evaluate if repository need GC: " + repositoryPath);
+  }
+
+  @Test
+  public void noUnreferencedObjects() throws Exception {
+    addFileTo(repository);
+    FileRepository fileRepository = (FileRepository) repository;
+    assertThat(task.getUnreferencedLooseObjectsCount(fileRepository)).isEqualTo(0);
+  }
+
+  @Test
+  public void unreferencedObjectsCountShouldBeOne() throws Exception {
+    try (Git git = new Git(repository)) {
+      RevCommit initialCommit = git.commit().setMessage("initial commit").call();
+      addFileTo(repository);
+      git.reset().setMode(ResetType.HARD).setRef(initialCommit.getName()).call();
+    }
+    FileRepository fileRepository = (FileRepository) repository;
+    removeReflog(fileRepository.getDirectory());
+    assertThat(task.getUnreferencedLooseObjectsCount(fileRepository)).isEqualTo(1);
+  }
+
+  private void removeReflog(File directory) throws IOException {
+    Path logs = directory.toPath().resolve("logs");
+    Files.walk(logs).sorted(Comparator.reverseOrder()).map(Path::toFile).forEach(File::delete);
+  }
+
+  private Repository createRepository(String repoName) throws Exception {
+    File repo = dir.newFolder(repoName);
+    try (Git git = Git.init().setDirectory(repo).call()) {
+      return git.getRepository();
+    }
+  }
+
+  private void addFileTo(Repository repository) throws Exception {
+    try (Git git = new Git(repository)) {
+      new File(repository.getDirectory().getParent(), "test");
+      git.add().addFilepattern("test").call();
+      git.commit().setMessage("Add test file").call();
+    }
+  }
+
+  private void gc(Repository repository) throws Exception {
+    try (Git git = new Git(repository)) {
+      git.gc().setAggressive(true).call();
+    }
+  }
+}
diff --git a/src/test/java/com/ericsson/gerrit/plugins/gcconductor/RepositoryInfoTest.java b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/RepositoryInfoTest.java
new file mode 100644
index 0000000..ba78afc
--- /dev/null
+++ b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/RepositoryInfoTest.java
@@ -0,0 +1,51 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import java.sql.Timestamp;
+import org.junit.Test;
+
+public class RepositoryInfoTest {
+
+  @Test
+  public void shouldReturnPath() {
+    String path = "/path/someRepo.git";
+    RepositoryInfo repoInfo = new RepositoryInfo(path, null, null, null);
+    assertThat(repoInfo.getPath()).isEqualTo(path);
+  }
+
+  @Test
+  public void shouldReturnQueuedAt() {
+    Timestamp time = new Timestamp(System.currentTimeMillis());
+    RepositoryInfo repoInfo = new RepositoryInfo(null, time, null, null);
+    assertThat(repoInfo.getQueuedAt()).isEqualTo(time);
+  }
+
+  @Test
+  public void shouldReturnExecutor() {
+    String executor = "someHost-1";
+    RepositoryInfo repoInfo = new RepositoryInfo(null, null, executor, null);
+    assertThat(repoInfo.getExecutor()).isEqualTo(executor);
+  }
+
+  @Test
+  public void shouldReturnQueuedFrom() {
+    String hostname = "someHost-2";
+    RepositoryInfo repoInfo = new RepositoryInfo(null, null, null, hostname);
+    assertThat(repoInfo.getQueuedFrom()).isEqualTo(hostname);
+  }
+}
diff --git a/src/test/java/com/ericsson/gerrit/plugins/gcconductor/ShutdownNotifierTest.java b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/ShutdownNotifierTest.java
new file mode 100644
index 0000000..59f3498
--- /dev/null
+++ b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/ShutdownNotifierTest.java
@@ -0,0 +1,39 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import com.google.common.collect.Lists;
+import java.util.ArrayList;
+import org.junit.Test;
+
+public class ShutdownNotifierTest {
+
+  @Test
+  public void testNolistener() {
+    ShutdownNotifier notifier = new ShutdownNotifier(new ArrayList<>());
+    notifier.notifyAllListeners();
+  }
+
+  @Test
+  public void testWithlisteners() {
+    ShutdownListener listenerMock = mock(ShutdownListener.class);
+    ShutdownNotifier notifier = new ShutdownNotifier(Lists.newArrayList(listenerMock));
+    notifier.notifyAllListeners();
+    verify(listenerMock).onShutdown();
+  }
+}
diff --git a/src/test/java/com/ericsson/gerrit/plugins/gcconductor/evaluator/EvaluatorConfigTest.java b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/evaluator/EvaluatorConfigTest.java
new file mode 100644
index 0000000..c63f248
--- /dev/null
+++ b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/evaluator/EvaluatorConfigTest.java
@@ -0,0 +1,129 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.evaluator;
+
+import static com.ericsson.gerrit.plugins.gcconductor.CommonConfig.DB_NAME_KEY;
+import static com.ericsson.gerrit.plugins.gcconductor.CommonConfig.DB_PASS_KEY;
+import static com.ericsson.gerrit.plugins.gcconductor.CommonConfig.DB_URL_KEY;
+import static com.ericsson.gerrit.plugins.gcconductor.CommonConfig.DB_URL_OPTIONS_KEY;
+import static com.ericsson.gerrit.plugins.gcconductor.CommonConfig.DB_USERNAME_KEY;
+import static com.ericsson.gerrit.plugins.gcconductor.CommonConfig.DEFAULT_DB_NAME;
+import static com.ericsson.gerrit.plugins.gcconductor.CommonConfig.DEFAULT_DB_PASSWORD;
+import static com.ericsson.gerrit.plugins.gcconductor.CommonConfig.DEFAULT_DB_URL;
+import static com.ericsson.gerrit.plugins.gcconductor.CommonConfig.DEFAULT_DB_USERNAME;
+import static com.ericsson.gerrit.plugins.gcconductor.CommonConfig.LOOSE_DEFAULT;
+import static com.ericsson.gerrit.plugins.gcconductor.CommonConfig.LOOSE_KEY;
+import static com.ericsson.gerrit.plugins.gcconductor.CommonConfig.PACKED_DEFAULT;
+import static com.ericsson.gerrit.plugins.gcconductor.CommonConfig.PACKED_KEY;
+import static com.ericsson.gerrit.plugins.gcconductor.evaluator.EvaluatorConfig.EXPIRE_TIME_RECHECK_DEFAULT;
+import static com.ericsson.gerrit.plugins.gcconductor.evaluator.EvaluatorConfig.EXPIRE_TIME_RECHECK_KEY;
+import static com.ericsson.gerrit.plugins.gcconductor.evaluator.EvaluatorConfig.THREAD_POOL_DEFAULT;
+import static com.ericsson.gerrit.plugins.gcconductor.evaluator.EvaluatorConfig.THREAD_POOL_KEY;
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.when;
+
+import com.google.gerrit.server.config.ConfigUtil;
+import com.google.gerrit.server.config.PluginConfig;
+import java.util.concurrent.TimeUnit;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class EvaluatorConfigTest {
+
+  private static final int PACKED_NOT_DEFAULT = 41;
+  private static final int LOOSE_NOT_DEFAULT = 401;
+  private static final String URL_NOT_DEFAULT = "jdbc:postgresql:test/";
+  private static final String DATABASE_NAME_NOT_DEFAULT = "jdbc:postgresql:test/";
+  private static final String URL_OPTION_NOT_DEFAULT = "?someOption=false";
+  private static final String USER_NOT_DEFAULT = "user";
+  private static final String PASS_NOT_DEFAULT = "pass";
+  private static final int THREAD_POOL_NOT_DEFAULT = 5;
+  private static final String EXPIRE_TIME_RECHECK_NOT_DEFAULT = "10s";
+  private static final boolean USING_DEFAULT_VALUES = true;
+  private static final boolean USING_CUSTOM_VALUES = false;
+
+  @Mock private PluginConfig pluginConfigMock;
+  private EvaluatorConfig configuration;
+
+  @Test
+  public void testValuesNotPresentInGerritConfig() {
+    buildMocks(USING_DEFAULT_VALUES);
+    assertThat(configuration.getPackedThreshold()).isEqualTo(PACKED_DEFAULT);
+    assertThat(configuration.getLooseThreshold()).isEqualTo(LOOSE_DEFAULT);
+    assertThat(configuration.getDatabaseUrl()).isEqualTo(DEFAULT_DB_URL);
+    assertThat(configuration.getDatabaseName()).isEqualTo(DEFAULT_DB_NAME);
+    assertThat(configuration.getDatabaseUrlOptions()).isEmpty();
+    assertThat(configuration.getUsername()).isEqualTo(DEFAULT_DB_USERNAME);
+    assertThat(configuration.getPassword()).isEqualTo(DEFAULT_DB_PASSWORD);
+    assertThat(configuration.getThreadPoolSize()).isEqualTo(THREAD_POOL_DEFAULT);
+    assertThat(configuration.getExpireTimeRecheck())
+        .isEqualTo(convertTimeUnitStringToMilliseconds(EXPIRE_TIME_RECHECK_DEFAULT));
+  }
+
+  @Test
+  public void testValuesPresentInGerritConfig() {
+    buildMocks(USING_CUSTOM_VALUES);
+    assertThat(configuration.getPackedThreshold()).isEqualTo(PACKED_NOT_DEFAULT);
+    assertThat(configuration.getLooseThreshold()).isEqualTo(LOOSE_NOT_DEFAULT);
+    assertThat(configuration.getDatabaseUrl()).isEqualTo(URL_NOT_DEFAULT);
+    assertThat(configuration.getDatabaseName()).isEqualTo(DATABASE_NAME_NOT_DEFAULT);
+    assertThat(configuration.getDatabaseUrlOptions()).isEqualTo(URL_OPTION_NOT_DEFAULT);
+    assertThat(configuration.getUsername()).isEqualTo(USER_NOT_DEFAULT);
+    assertThat(configuration.getPassword()).isEqualTo(PASS_NOT_DEFAULT);
+    assertThat(configuration.getThreadPoolSize()).isEqualTo(THREAD_POOL_NOT_DEFAULT);
+    assertThat(configuration.getExpireTimeRecheck())
+        .isEqualTo(convertTimeUnitStringToMilliseconds(EXPIRE_TIME_RECHECK_NOT_DEFAULT));
+  }
+
+  @Test
+  public void testDatabaseUrlAlwaysEndWithSlash() {
+    when(pluginConfigMock.getString(EXPIRE_TIME_RECHECK_KEY, EXPIRE_TIME_RECHECK_DEFAULT))
+        .thenReturn(EXPIRE_TIME_RECHECK_DEFAULT);
+    when(pluginConfigMock.getString(DB_URL_KEY, DEFAULT_DB_URL)).thenReturn("someUrl");
+
+    configuration = new EvaluatorConfig(pluginConfigMock);
+    assertThat(configuration.getDatabaseUrl()).isEqualTo("someUrl/");
+  }
+
+  private void buildMocks(boolean useDefaults) {
+    when(pluginConfigMock.getInt(PACKED_KEY, PACKED_DEFAULT))
+        .thenReturn(useDefaults ? PACKED_DEFAULT : PACKED_NOT_DEFAULT);
+    when(pluginConfigMock.getInt(LOOSE_KEY, LOOSE_DEFAULT))
+        .thenReturn(useDefaults ? LOOSE_DEFAULT : LOOSE_NOT_DEFAULT);
+    when(pluginConfigMock.getString(DB_URL_KEY, DEFAULT_DB_URL))
+        .thenReturn(useDefaults ? DEFAULT_DB_URL : URL_NOT_DEFAULT);
+    when(pluginConfigMock.getString(DB_NAME_KEY, DEFAULT_DB_NAME))
+        .thenReturn(useDefaults ? DEFAULT_DB_NAME : DATABASE_NAME_NOT_DEFAULT);
+    when(pluginConfigMock.getString(DB_URL_OPTIONS_KEY))
+        .thenReturn(useDefaults ? null : URL_OPTION_NOT_DEFAULT);
+    when(pluginConfigMock.getString(DB_USERNAME_KEY, DEFAULT_DB_USERNAME))
+        .thenReturn(useDefaults ? DEFAULT_DB_USERNAME : USER_NOT_DEFAULT);
+    when(pluginConfigMock.getString(DB_PASS_KEY, DEFAULT_DB_PASSWORD))
+        .thenReturn(useDefaults ? DEFAULT_DB_PASSWORD : PASS_NOT_DEFAULT);
+    when(pluginConfigMock.getInt(THREAD_POOL_KEY, THREAD_POOL_DEFAULT))
+        .thenReturn(useDefaults ? THREAD_POOL_DEFAULT : THREAD_POOL_NOT_DEFAULT);
+    when(pluginConfigMock.getString(EXPIRE_TIME_RECHECK_KEY, EXPIRE_TIME_RECHECK_DEFAULT))
+        .thenReturn(useDefaults ? EXPIRE_TIME_RECHECK_DEFAULT : EXPIRE_TIME_RECHECK_NOT_DEFAULT);
+
+    configuration = new EvaluatorConfig(pluginConfigMock);
+  }
+
+  private long convertTimeUnitStringToMilliseconds(String string) {
+    return ConfigUtil.getTimeUnit(string, -1, TimeUnit.MILLISECONDS);
+  }
+}
diff --git a/src/test/java/com/ericsson/gerrit/plugins/gcconductor/evaluator/EvaluatorTest.java b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/evaluator/EvaluatorTest.java
new file mode 100644
index 0000000..356e8cf
--- /dev/null
+++ b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/evaluator/EvaluatorTest.java
@@ -0,0 +1,150 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.evaluator;
+
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.ericsson.gerrit.plugins.gcconductor.EvaluationTask;
+import com.ericsson.gerrit.plugins.gcconductor.EvaluationTask.Factory;
+import com.google.gerrit.extensions.events.GitReferenceUpdatedListener;
+import com.google.gerrit.reviewdb.client.Project;
+import com.google.gerrit.server.git.GitRepositoryManager;
+import java.io.File;
+import java.io.IOException;
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+import org.eclipse.jgit.errors.RepositoryNotFoundException;
+import org.eclipse.jgit.lib.Config;
+import org.eclipse.jgit.lib.Repository;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class EvaluatorTest {
+  private static final String REPOSITORY_PATH = "/path/someRepo.git";
+  private static final Project.NameKey NAME_KEY = new Project.NameKey("testProject");
+
+  @Mock private EvaluationTask task;
+  @Mock private GitReferenceUpdatedListener.Event event;
+  @Mock private GitRepositoryManager repoManager;
+  @Mock private Repository repository;
+  @Mock private ScheduledThreadPoolExecutor executor;
+  @Mock private EvaluatorConfig config;
+  @Mock private Config gerritConfig;
+
+  private Evaluator evaluator;
+
+  @Before
+  public void createEvaluator() {
+    when(event.getProjectName()).thenReturn(NAME_KEY.get());
+    task = new EvaluationTask(null, null, null, REPOSITORY_PATH);
+    when(repository.getDirectory()).thenReturn(new File(REPOSITORY_PATH));
+    Factory eventTaskFactory = mock(Factory.class);
+    when(eventTaskFactory.create(REPOSITORY_PATH)).thenReturn(task);
+    when(config.getExpireTimeRecheck()).thenReturn(0L);
+    when(gerritConfig.getInt(
+            "receive", null, "threadPoolSize", Runtime.getRuntime().availableProcessors()))
+        .thenReturn(1);
+    evaluator = new Evaluator(executor, eventTaskFactory, repoManager, config, gerritConfig);
+  }
+
+  @Test
+  public void onPostUploadShouldCreateTaskOnlyIfPreUploadCalled() {
+    evaluator.onPreUpload(repository, null, null, null, null, null);
+    evaluator.onPostUpload(null);
+    verify(executor).execute(task);
+  }
+
+  @Test
+  public void onPostUploadShouldNotCreateTaskIfRepositoryIsNull() {
+    File fileMock = mock(File.class);
+    when(fileMock.getAbsolutePath()).thenReturn(null);
+    when(repository.getDirectory()).thenReturn(fileMock);
+    evaluator.onPreUpload(repository, null, null, null, null, null);
+    evaluator.onPostUpload(null);
+    verify(executor, never()).execute(task);
+  }
+
+  @Test
+  public void onPostUploadShouldNotCreateTaskRepoIsNull() {
+    evaluator.onPreUpload(repository, null, null, null, null, null);
+    evaluator.onPostUpload(null);
+    evaluator.onPostUpload(null);
+    verify(executor, times(1)).execute(task);
+  }
+
+  @Test
+  public void onPostUploadShouldCreateTaskExpired() {
+    evaluator.onPreUpload(repository, null, null, null, null, null);
+    evaluator.onPostUpload(null);
+    evaluator.onPreUpload(repository, null, null, null, null, null);
+    evaluator.onPostUpload(null);
+    verify(executor, times(2)).execute(task);
+  }
+
+  @Test
+  public void onPostUploadShouldNotCreateTaskNotExpired() {
+    when(config.getExpireTimeRecheck()).thenReturn(1000L);
+    Factory eventTaskFactory = mock(Factory.class);
+    when(eventTaskFactory.create(REPOSITORY_PATH)).thenReturn(task);
+    evaluator = new Evaluator(executor, eventTaskFactory, repoManager, config, gerritConfig);
+    evaluator.onPreUpload(repository, null, null, null, null, null);
+    evaluator.onPostUpload(null);
+    evaluator.onPreUpload(repository, null, null, null, null, null);
+    evaluator.onPostUpload(null);
+    verify(executor, times(1)).execute(task);
+  }
+
+  @Test
+  public void onGitReferenceUpdatedShouldCreateTaskExpired() throws Exception {
+    when(repoManager.openRepository(NAME_KEY)).thenReturn(repository);
+    evaluator.onGitReferenceUpdated(event);
+    evaluator.onGitReferenceUpdated(event);
+    verify(executor, times(2)).execute(task);
+  }
+
+  @Test
+  public void onGitReferenceUpdatedShouldNotCreateTaskNotExpired() throws Exception {
+    when(repoManager.openRepository(NAME_KEY)).thenReturn(repository);
+    when(config.getExpireTimeRecheck()).thenReturn(1000L);
+    Factory eventTaskFactory = mock(Factory.class);
+    when(eventTaskFactory.create(REPOSITORY_PATH)).thenReturn(task);
+    evaluator = new Evaluator(executor, eventTaskFactory, repoManager, config, gerritConfig);
+    evaluator.onGitReferenceUpdated(event);
+    evaluator.onGitReferenceUpdated(event);
+    verify(executor, times(1)).execute(task);
+  }
+
+  @Test
+  public void onGitReferenceUpdatedThrowsRepositoryNotFoundException() throws Exception {
+    doThrow(new RepositoryNotFoundException("")).when(repoManager).openRepository(NAME_KEY);
+    evaluator.onGitReferenceUpdated(event);
+    verify(executor, never()).execute(task);
+  }
+
+  @Test
+  public void onGitReferenceUpdatedThrowsIOException() throws Exception {
+    doThrow(new IOException()).when(repoManager).openRepository(NAME_KEY);
+    evaluator.onGitReferenceUpdated(event);
+    verify(executor, never()).execute(task);
+  }
+}
diff --git a/src/test/java/com/ericsson/gerrit/plugins/gcconductor/evaluator/OnPluginLoadUnloadTest.java b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/evaluator/OnPluginLoadUnloadTest.java
new file mode 100644
index 0000000..17f92f2
--- /dev/null
+++ b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/evaluator/OnPluginLoadUnloadTest.java
@@ -0,0 +1,47 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.evaluator;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
+
+import com.ericsson.gerrit.plugins.gcconductor.ShutdownNotifier;
+import org.junit.Before;
+import org.junit.Test;
+
+public class OnPluginLoadUnloadTest {
+
+  private OnPluginLoadUnload onPluginLoadUnload;
+  private ShutdownNotifier shutdownNotifierMock;
+
+  @Before
+  public void setUp() {
+    shutdownNotifierMock = mock(ShutdownNotifier.class);
+    onPluginLoadUnload = new OnPluginLoadUnload(shutdownNotifierMock);
+  }
+
+  @Test
+  public void testStart() {
+    onPluginLoadUnload.start();
+    verifyZeroInteractions(shutdownNotifierMock);
+  }
+
+  @Test
+  public void testStop() {
+    onPluginLoadUnload.stop();
+    verify(shutdownNotifierMock).notifyAllListeners();
+  }
+}
diff --git a/src/test/java/com/ericsson/gerrit/plugins/gcconductor/executor/CancellableProgressMonitorTest.java b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/executor/CancellableProgressMonitorTest.java
new file mode 100644
index 0000000..b235a29
--- /dev/null
+++ b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/executor/CancellableProgressMonitorTest.java
@@ -0,0 +1,35 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.executor;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import org.junit.Test;
+
+public class CancellableProgressMonitorTest {
+
+  @Test
+  public void shouldReturnTrueIfThreadIsInterrupted() {
+    CancellableProgressMonitor cpm = new CancellableProgressMonitor();
+    cpm.cancel();
+    assertThat(cpm.isCancelled()).isTrue();
+  }
+
+  @Test
+  public void shouldReturnFalseIfThreadIsNotInterrupted() {
+    CancellableProgressMonitor cpm = new CancellableProgressMonitor();
+    assertThat(cpm.isCancelled()).isFalse();
+  }
+}
diff --git a/src/test/java/com/ericsson/gerrit/plugins/gcconductor/executor/ConfigUtilTest.java b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/executor/ConfigUtilTest.java
new file mode 100644
index 0000000..c99201a
--- /dev/null
+++ b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/executor/ConfigUtilTest.java
@@ -0,0 +1,114 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.executor;
+
+import static com.google.common.truth.Truth.assertThat;
+import static java.util.concurrent.TimeUnit.DAYS;
+import static java.util.concurrent.TimeUnit.HOURS;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.when;
+
+import java.util.concurrent.TimeUnit;
+import org.eclipse.jgit.lib.Config;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ConfigUtilTest {
+
+  private static final int DEFAULT_VALUE = 1;
+
+  @Mock private Config config;
+
+  @Test
+  public void testGetTimeShouldReturnValue() {
+    when(config.getString("", null, "")).thenReturn("1 WEEK");
+    assertThat(ConfigUtil.getTimeUnit(config, "", "", DEFAULT_VALUE, DAYS)).isEqualTo(7);
+  }
+
+  @Test
+  public void testGetTimeShouldReturnDefault() {
+    when(config.getString("", null, "")).thenReturn(null);
+    assertThat(ConfigUtil.getTimeUnit(config, "", "", DEFAULT_VALUE, DAYS))
+        .isEqualTo(DEFAULT_VALUE);
+
+    when(config.getString("", null, "")).thenReturn("");
+    assertThat(ConfigUtil.getTimeUnit(config, "", "", DEFAULT_VALUE, DAYS))
+        .isEqualTo(DEFAULT_VALUE);
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void testGetTimeThrowsExceptionIfNegativeValue() {
+    when(config.getString("", null, "")).thenReturn("-1");
+    assertThat(ConfigUtil.getTimeUnit(config, "", "", DEFAULT_VALUE, DAYS))
+        .isEqualTo(DEFAULT_VALUE);
+
+    when(config.getString("", null, "")).thenReturn("");
+    assertThat(ConfigUtil.getTimeUnit(config, "", "", DEFAULT_VALUE, DAYS))
+        .isEqualTo(DEFAULT_VALUE);
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void testGetTimeThrowsExceptionIfBadTimeUnit() {
+    when(config.getString("", null, "")).thenReturn("1s");
+    assertThat(ConfigUtil.getTimeUnit(config, "", "", DEFAULT_VALUE, DAYS))
+        .isEqualTo(DEFAULT_VALUE);
+  }
+
+  @Test
+  public void testTimeUnit() {
+    assertEquals(ms(5, HOURS), parse("5h"));
+    assertEquals(ms(1, HOURS), parse("1hour"));
+    assertEquals(ms(48, HOURS), parse("48hours"));
+
+    assertEquals(ms(5, HOURS), parse("5 h"));
+    assertEquals(ms(1, HOURS), parse("1 hour"));
+    assertEquals(ms(48, HOURS), parse("48 hours"));
+    assertEquals(ms(48, HOURS), parse("48 \t \r hours"));
+
+    assertEquals(ms(4, DAYS), parse("4 d"));
+    assertEquals(ms(1, DAYS), parse("1day"));
+    assertEquals(ms(14, DAYS), parse("14days"));
+
+    assertEquals(ms(7, DAYS), parse("1 w"));
+    assertEquals(ms(7, DAYS), parse("1week"));
+    assertEquals(ms(14, DAYS), parse("2w"));
+    assertEquals(ms(14, DAYS), parse("2weeks"));
+
+    assertEquals(ms(30, DAYS), parse("1 mon"));
+    assertEquals(ms(30, DAYS), parse("1month"));
+    assertEquals(ms(60, DAYS), parse("2mon"));
+    assertEquals(ms(60, DAYS), parse("2months"));
+
+    assertEquals(ms(60, DAYS), parse("60"));
+    assertEquals(ms(1, MILLISECONDS), parse(""));
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void testUnsupportedTimeUnit() {
+    parse("1 min");
+  }
+
+  private static long ms(int cnt, TimeUnit unit) {
+    return MILLISECONDS.convert(cnt, unit);
+  }
+
+  private static long parse(String string) {
+    return ConfigUtil.getTimeUnit(string, 1, MILLISECONDS);
+  }
+}
diff --git a/src/test/java/com/ericsson/gerrit/plugins/gcconductor/executor/ExecutorConfigTest.java b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/executor/ExecutorConfigTest.java
new file mode 100644
index 0000000..198eca9
--- /dev/null
+++ b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/executor/ExecutorConfigTest.java
@@ -0,0 +1,169 @@
+package com.ericsson.gerrit.plugins.gcconductor.executor;
+
+import static com.ericsson.gerrit.plugins.gcconductor.CommonConfig.DB_NAME_KEY;
+import static com.ericsson.gerrit.plugins.gcconductor.CommonConfig.DB_PASS_KEY;
+import static com.ericsson.gerrit.plugins.gcconductor.CommonConfig.DB_URL_KEY;
+import static com.ericsson.gerrit.plugins.gcconductor.CommonConfig.DB_URL_OPTIONS_KEY;
+import static com.ericsson.gerrit.plugins.gcconductor.CommonConfig.DB_USERNAME_KEY;
+import static com.ericsson.gerrit.plugins.gcconductor.CommonConfig.DEFAULT_DB_NAME;
+import static com.ericsson.gerrit.plugins.gcconductor.CommonConfig.DEFAULT_DB_PASSWORD;
+import static com.ericsson.gerrit.plugins.gcconductor.CommonConfig.DEFAULT_DB_URL;
+import static com.ericsson.gerrit.plugins.gcconductor.CommonConfig.DEFAULT_DB_USERNAME;
+import static com.ericsson.gerrit.plugins.gcconductor.CommonConfig.LOOSE_DEFAULT;
+import static com.ericsson.gerrit.plugins.gcconductor.CommonConfig.LOOSE_KEY;
+import static com.ericsson.gerrit.plugins.gcconductor.CommonConfig.PACKED_DEFAULT;
+import static com.ericsson.gerrit.plugins.gcconductor.CommonConfig.PACKED_KEY;
+import static com.ericsson.gerrit.plugins.gcconductor.executor.ExecutorConfig.CORE_SECTION;
+import static com.ericsson.gerrit.plugins.gcconductor.executor.ExecutorConfig.DB_SECTION;
+import static com.ericsson.gerrit.plugins.gcconductor.executor.ExecutorConfig.DEFAULT_DELAY;
+import static com.ericsson.gerrit.plugins.gcconductor.executor.ExecutorConfig.DEFAULT_EXECUTORS;
+import static com.ericsson.gerrit.plugins.gcconductor.executor.ExecutorConfig.DEFAULT_INITIAL_DELAY;
+import static com.ericsson.gerrit.plugins.gcconductor.executor.ExecutorConfig.DEFAULT_INTERVAL;
+import static com.ericsson.gerrit.plugins.gcconductor.executor.ExecutorConfig.DEFAULT_REPOS_PATH;
+import static com.ericsson.gerrit.plugins.gcconductor.executor.ExecutorConfig.DELAY_KEY;
+import static com.ericsson.gerrit.plugins.gcconductor.executor.ExecutorConfig.EMPTY;
+import static com.ericsson.gerrit.plugins.gcconductor.executor.ExecutorConfig.EVALUATION_SECTION;
+import static com.ericsson.gerrit.plugins.gcconductor.executor.ExecutorConfig.EXECUTOR_KEY;
+import static com.ericsson.gerrit.plugins.gcconductor.executor.ExecutorConfig.INTERVAL_KEY;
+import static com.ericsson.gerrit.plugins.gcconductor.executor.ExecutorConfig.PICK_OWN_HOST_KEY;
+import static com.ericsson.gerrit.plugins.gcconductor.executor.ExecutorConfig.REPOS_PATH_KEY;
+import static com.ericsson.gerrit.plugins.gcconductor.executor.ExecutorConfig.START_TIME_KEY;
+import static com.google.common.truth.Truth.assertThat;
+import static java.util.concurrent.TimeUnit.DAYS;
+import static java.util.concurrent.TimeUnit.HOURS;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static java.util.concurrent.TimeUnit.MINUTES;
+
+import java.time.LocalDateTime;
+import java.time.Month;
+import java.time.ZoneOffset;
+import java.time.ZonedDateTime;
+import java.util.concurrent.TimeUnit;
+import org.eclipse.jgit.lib.Config;
+import org.junit.Before;
+import org.junit.Test;
+
+public class ExecutorConfigTest {
+  private static final String CUSTOM_REPOS_PATH = "/other/path/to/repos";
+  private static final String CUSTOM_DB_URL = "customDbUrl/";
+  private static final String CUSTOM_DB_NAME = "customDbName";
+  private static final String URL_OPTIONS = "urlOptions";
+  private static final String CUSTOM_DB_USER = "customDbUser";
+  private static final String CUSTOM_DB_PASS = "customDbPass";
+  private static final int CUSTOM_DELAY = 5;
+  private static final int CUSTOM_EXECUTORS = 10;
+  private static final int CUSTOM_PACKED = 41;
+  private static final int CUSTOM_LOOSE = 401;
+  private static final int ONE_DAY_AS_MS = 86_400_000;
+
+  // Friday June 13, 2014 10:00 UTC
+  private static final ZonedDateTime NOW =
+      LocalDateTime.of(2014, Month.JUNE, 13, 10, 0, 0).atOffset(ZoneOffset.UTC).toZonedDateTime();
+
+  private Config config;
+  private ExecutorConfig executorConfig;
+
+  @Before
+  public void setUp() {
+    config = new Config();
+  }
+
+  @Test
+  public void shouldSetDefaultValues() {
+    executorConfig = new ExecutorConfig(config);
+
+    assertThat(executorConfig.getDatabaseUrl()).isEqualTo(DEFAULT_DB_URL);
+    assertThat(executorConfig.getDatabaseName()).isEqualTo(DEFAULT_DB_NAME);
+    assertThat(executorConfig.getDatabaseUrlOptions()).isEqualTo(EMPTY);
+    assertThat(executorConfig.getUsername()).isEqualTo(DEFAULT_DB_USERNAME);
+    assertThat(executorConfig.getPassword()).isEqualTo(DEFAULT_DB_PASSWORD);
+    assertThat(executorConfig.getDelay()).isEqualTo(DEFAULT_DELAY);
+    assertThat(executorConfig.getExecutors()).isEqualTo(DEFAULT_EXECUTORS);
+    assertThat(executorConfig.isPickOwnHostOnly()).isEqualTo(true);
+    assertThat(executorConfig.getLooseThreshold()).isEqualTo(LOOSE_DEFAULT);
+    assertThat(executorConfig.getPackedThreshold()).isEqualTo(PACKED_DEFAULT);
+    assertThat(executorConfig.getRepositoriesPath()).isEqualTo(DEFAULT_REPOS_PATH);
+    assertThat(executorConfig.getInterval()).isEqualTo(DEFAULT_INTERVAL);
+    assertThat(executorConfig.getInitialDelay()).isEqualTo(DEFAULT_INITIAL_DELAY);
+  }
+
+  @Test
+  public void shouldReadValuesFromConfig() {
+    config.setString(DB_SECTION, null, DB_URL_KEY, CUSTOM_DB_URL);
+    config.setString(DB_SECTION, null, DB_NAME_KEY, CUSTOM_DB_NAME);
+    config.setString(DB_SECTION, null, DB_URL_OPTIONS_KEY, URL_OPTIONS);
+    config.setString(DB_SECTION, null, DB_USERNAME_KEY, CUSTOM_DB_USER);
+    config.setString(DB_SECTION, null, DB_PASS_KEY, CUSTOM_DB_PASS);
+    config.setInt(CORE_SECTION, null, DELAY_KEY, CUSTOM_DELAY);
+    config.setInt(CORE_SECTION, null, EXECUTOR_KEY, CUSTOM_EXECUTORS);
+    config.setBoolean(CORE_SECTION, null, PICK_OWN_HOST_KEY, false);
+    config.setInt(EVALUATION_SECTION, null, LOOSE_KEY, CUSTOM_LOOSE);
+    config.setInt(EVALUATION_SECTION, null, PACKED_KEY, CUSTOM_PACKED);
+    config.setString(EVALUATION_SECTION, null, REPOS_PATH_KEY, CUSTOM_REPOS_PATH);
+    config.setString(EVALUATION_SECTION, null, INTERVAL_KEY, "1 day");
+    config.setString(EVALUATION_SECTION, null, START_TIME_KEY, "Sun 00:00");
+    executorConfig = new ExecutorConfig(config);
+
+    assertThat(executorConfig.getDatabaseUrl()).isEqualTo(CUSTOM_DB_URL);
+    assertThat(executorConfig.getDatabaseName()).isEqualTo(CUSTOM_DB_NAME);
+    assertThat(executorConfig.getDatabaseUrlOptions()).isEqualTo(URL_OPTIONS);
+    assertThat(executorConfig.getUsername()).isEqualTo(CUSTOM_DB_USER);
+    assertThat(executorConfig.getPassword()).isEqualTo(CUSTOM_DB_PASS);
+    assertThat(executorConfig.getDelay()).isEqualTo(CUSTOM_DELAY);
+    assertThat(executorConfig.getExecutors()).isEqualTo(CUSTOM_EXECUTORS);
+    assertThat(executorConfig.isPickOwnHostOnly()).isEqualTo(false);
+    assertThat(executorConfig.getLooseThreshold()).isEqualTo(CUSTOM_LOOSE);
+    assertThat(executorConfig.getPackedThreshold()).isEqualTo(CUSTOM_PACKED);
+    assertThat(executorConfig.getRepositoriesPath()).isEqualTo(CUSTOM_REPOS_PATH);
+    assertThat(executorConfig.getInterval()).isEqualTo(ONE_DAY_AS_MS);
+    assertThat(executorConfig.getInitialDelay()).isAtLeast(1L);
+  }
+
+  @Test
+  public void shouldParseTimeOnly() {
+    config.setString(EVALUATION_SECTION, null, INTERVAL_KEY, "1 hour");
+    config.setString(EVALUATION_SECTION, null, START_TIME_KEY, "15:00");
+    executorConfig = new ExecutorConfig(config);
+
+    assertThat(executorConfig.getInitialDelay()).isAtLeast(1L);
+  }
+
+  @Test
+  public void shouldUseDefaultValuesIfConfigInvalid() {
+    config.setString(EVALUATION_SECTION, null, INTERVAL_KEY, "1 x");
+    config.setString(EVALUATION_SECTION, null, START_TIME_KEY, "123 ab:cd");
+    executorConfig = new ExecutorConfig(config);
+
+    assertThat(executorConfig.getInterval()).isEqualTo(DEFAULT_INTERVAL);
+    assertThat(executorConfig.getInitialDelay()).isEqualTo(DEFAULT_INITIAL_DELAY);
+  }
+
+  @Test
+  public void checkInitialDelayGivesExpectedTime() {
+    assertThat(initialDelayFor("11:00", "1h")).isEqualTo(ms(1, HOURS));
+    assertThat(initialDelayFor("05:30", "1h")).isEqualTo(ms(30, MINUTES));
+    assertThat(initialDelayFor("13:59", "1h")).isEqualTo(ms(59, MINUTES));
+
+    assertThat(initialDelayFor("11:00", "1d")).isEqualTo(ms(1, HOURS));
+    assertThat(initialDelayFor("05:30", "1d")).isEqualTo(ms(19, HOURS) + ms(30, MINUTES));
+    assertThat(initialDelayFor("Sat 10:00", "1d")).isEqualTo(ms(1, DAYS));
+    assertThat(initialDelayFor("Mon 09:00", "1d")).isEqualTo(ms(23, HOURS));
+
+    assertThat(initialDelayFor("11:00", "1w")).isEqualTo(ms(1, HOURS));
+    assertThat(initialDelayFor("05:30", "1w"))
+        .isEqualTo(ms(7, DAYS) - ms(4, HOURS) - ms(30, MINUTES));
+    assertThat(initialDelayFor("Fri 11:00", "1w")).isEqualTo(ms(1, HOURS));
+    assertThat(initialDelayFor("Mon 11:00", "1w")).isEqualTo(ms(3, DAYS) + ms(1, HOURS));
+  }
+
+  private long initialDelayFor(String startTime, String interval) {
+    config.setString(EVALUATION_SECTION, null, INTERVAL_KEY, interval);
+    config.setString(EVALUATION_SECTION, null, START_TIME_KEY, startTime);
+    executorConfig = new ExecutorConfig(config);
+    return executorConfig.initialDelay(startTime, NOW, executorConfig.getInterval());
+  }
+
+  private long ms(int cnt, TimeUnit unit) {
+    return MILLISECONDS.convert(cnt, unit);
+  }
+}
diff --git a/src/test/java/com/ericsson/gerrit/plugins/gcconductor/executor/ExecutorModuleTest.java b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/executor/ExecutorModuleTest.java
new file mode 100644
index 0000000..f4d3cef
--- /dev/null
+++ b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/executor/ExecutorModuleTest.java
@@ -0,0 +1,63 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.executor;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.when;
+
+import com.google.inject.Binder;
+import java.util.Optional;
+import org.eclipse.jgit.lib.Config;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ExecutorModuleTest {
+  @Mock private Binder binder;
+  @Mock private ExecutorConfig execCfg;
+  @Mock private Config config;
+
+  private ExecutorModule executorModule;
+
+  @Before
+  public void setUp() {
+    executorModule = new ExecutorModule(config);
+  }
+
+  @Test
+  public void testWasQueuedFrom() {
+    String host = "hostname";
+    when(execCfg.isPickOwnHostOnly()).thenReturn(true);
+    Optional<String> wasQueuedFrom = executorModule.wasQueuedFrom(execCfg, host);
+    if (!wasQueuedFrom.isPresent()) {
+      fail("wasQueued from is empty");
+    }
+    assertThat(wasQueuedFrom.get()).isEqualTo(host);
+
+    when(execCfg.isPickOwnHostOnly()).thenReturn(false);
+    wasQueuedFrom = executorModule.wasQueuedFrom(execCfg, host);
+    assertThat(wasQueuedFrom.isPresent()).isFalse();
+  }
+
+  @Test
+  public void testQueuedForLongerThan() {
+    when(execCfg.getDelay()).thenReturn(5);
+    assertThat(executorModule.queuedForLongerThan(execCfg)).isEqualTo(5);
+  }
+}
diff --git a/src/test/java/com/ericsson/gerrit/plugins/gcconductor/executor/GCTest.java b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/executor/GCTest.java
new file mode 100644
index 0000000..6d08f55
--- /dev/null
+++ b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/executor/GCTest.java
@@ -0,0 +1,73 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.executor;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import java.io.File;
+import java.io.IOException;
+import org.eclipse.jgit.api.Git;
+import org.eclipse.jgit.internal.storage.file.FileRepository;
+import org.eclipse.jgit.internal.storage.file.GC;
+import org.eclipse.jgit.internal.storage.file.GC.RepoStatistics;
+import org.eclipse.jgit.lib.ProgressMonitor;
+import org.eclipse.jgit.lib.Repository;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+public class GCTest {
+
+  @Rule public TemporaryFolder dir = new TemporaryFolder();
+
+  @Test
+  public void testGc() throws Exception {
+    Repository repository = createRepository("repoTest");
+    RepoStatistics stats = computeFor(repository);
+    assertThat(stats.numberOfLooseObjects).isEqualTo(0);
+
+    addFileTo(repository);
+    stats = computeFor(repository);
+    assertThat(stats.numberOfLooseObjects).isEqualTo(2);
+    ProgressMonitor cpm = new CancellableProgressMonitor();
+    GarbageCollector gc = new GarbageCollector();
+    gc.setRepositoryPath(repository.getDirectory().getAbsolutePath());
+    gc.setPm(cpm);
+
+    assertThat(gc.call()).isTrue();
+    stats = computeFor(repository);
+    assertThat(stats.numberOfLooseObjects).isEqualTo(0);
+    assertThat(stats.numberOfPackedRefs).isEqualTo(1);
+  }
+
+  private Repository createRepository(String repoName) throws Exception {
+    File repo = dir.newFolder(repoName);
+    try (Git git = Git.init().setDirectory(repo).call()) {
+      return git.getRepository();
+    }
+  }
+
+  private void addFileTo(Repository repository) throws Exception {
+    try (Git git = new Git(repository)) {
+      new File(repository.getDirectory().getParent(), "test");
+      git.add().addFilepattern("test").call();
+      git.commit().setMessage("Add test file").call();
+    }
+  }
+
+  private RepoStatistics computeFor(Repository repository) throws IOException {
+    return new GC((FileRepository) repository).getStatistics();
+  }
+}
diff --git a/src/test/java/com/ericsson/gerrit/plugins/gcconductor/executor/GcExecutorTest.java b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/executor/GcExecutorTest.java
new file mode 100644
index 0000000..4c74510
--- /dev/null
+++ b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/executor/GcExecutorTest.java
@@ -0,0 +1,183 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.executor;
+
+import static com.ericsson.gerrit.plugins.gcconductor.executor.GcExecutor.CONFIG_FILE_PROPERTY;
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.when;
+
+import com.ericsson.gerrit.plugins.gcconductor.GcQueue;
+import com.ericsson.gerrit.plugins.gcconductor.GcQueueException;
+import com.ericsson.gerrit.plugins.gcconductor.RepositoryInfo;
+import com.google.common.collect.ImmutableList;
+import java.io.File;
+import java.nio.file.Files;
+import java.nio.file.StandardOpenOption;
+import org.eclipse.jgit.lib.Config;
+import org.eclipse.jgit.storage.file.FileBasedConfig;
+import org.eclipse.jgit.util.FS;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class GcExecutorTest {
+
+  private static final String HOSTNAME = "hostname";
+  private static final String EXECUTOR = "hostname-0";
+  private static final String REPOSITORY = "repository";
+
+  @Mock private ExecutorConfig config;
+  @Mock GcWorker.Factory gcWorkerFactory;
+  @Mock private GcWorker gcWorker;
+  @Mock private GcQueue gcQueue;
+  @Mock private ScheduledEvaluator scheduledEvaluator;
+
+  @Rule public TemporaryFolder testTempFolder = new TemporaryFolder();
+
+  @Test
+  public void testGcExecutor() {
+    when(config.getExecutors()).thenReturn(1);
+    when(gcWorkerFactory.create(EXECUTOR)).thenReturn(gcWorker);
+    GcExecutor gcExecutor =
+        new GcExecutor(gcQueue, config, gcWorkerFactory, scheduledEvaluator, HOSTNAME);
+    verify(gcWorker).start();
+    gcExecutor.onShutdown();
+    verify(gcWorker).shutdown();
+  }
+
+  @Test
+  public void testLeftOverReposAreUnpickedWhenStarting() throws Exception {
+    when(config.getExecutors()).thenReturn(1);
+    when(gcWorkerFactory.create(EXECUTOR)).thenReturn(gcWorker);
+    when(gcQueue.list())
+        .thenReturn(ImmutableList.of(new RepositoryInfo(REPOSITORY, null, EXECUTOR, HOSTNAME)));
+    GcExecutor gcExecutor =
+        new GcExecutor(gcQueue, config, gcWorkerFactory, scheduledEvaluator, HOSTNAME);
+    verify(gcQueue).unpick(REPOSITORY);
+    verify(gcWorker).start();
+    gcExecutor.onShutdown();
+    verify(gcWorker).shutdown();
+  }
+
+  @Test
+  public void testUnassignedReposAreNotUnpickedWhenStarting() throws Exception {
+    when(config.getExecutors()).thenReturn(1);
+    when(gcWorkerFactory.create(EXECUTOR)).thenReturn(gcWorker);
+    when(gcQueue.list())
+        .thenReturn(ImmutableList.of(new RepositoryInfo(REPOSITORY, null, null, HOSTNAME)));
+    GcExecutor gcExecutor =
+        new GcExecutor(gcQueue, config, gcWorkerFactory, scheduledEvaluator, HOSTNAME);
+    verify(gcQueue, never()).unpick(REPOSITORY);
+    verify(gcWorker).start();
+    gcExecutor.onShutdown();
+    verify(gcWorker).shutdown();
+  }
+
+  @Test
+  public void testExecutorDoesNotUnpickNotOwnedRepo() throws Exception {
+    when(config.getExecutors()).thenReturn(1);
+    when(gcWorkerFactory.create(EXECUTOR)).thenReturn(gcWorker);
+    when(gcQueue.list())
+        .thenReturn(
+            ImmutableList.of(
+                new RepositoryInfo(REPOSITORY, null, "another executor", "another hostname")));
+    GcExecutor gcExecutor =
+        new GcExecutor(gcQueue, config, gcWorkerFactory, scheduledEvaluator, HOSTNAME);
+    verify(gcQueue, never()).unpick(REPOSITORY);
+    verify(gcWorker).start();
+    gcExecutor.onShutdown();
+    verify(gcWorker).shutdown();
+  }
+
+  @Test
+  public void testQueueThrowsExceptionUnpickingAtStart() throws Exception {
+    when(config.getExecutors()).thenReturn(1);
+    when(gcWorkerFactory.create(EXECUTOR)).thenReturn(gcWorker);
+    doThrow(new GcQueueException("", new Throwable())).when(gcQueue).list();
+    GcExecutor gcExecutor =
+        new GcExecutor(gcQueue, config, gcWorkerFactory, scheduledEvaluator, HOSTNAME);
+    verify(gcQueue, never()).unpick(REPOSITORY);
+    verify(gcWorker).start();
+    gcExecutor.onShutdown();
+    verify(gcWorker).shutdown();
+  }
+
+  @Test
+  public void testScheduledEvaluationIsConfigured() throws Exception {
+    when(config.getExecutors()).thenReturn(1);
+    when(config.getInitialDelay()).thenReturn(1L);
+    when(config.getInterval()).thenReturn(1L);
+    when(gcWorkerFactory.create(EXECUTOR)).thenReturn(gcWorker);
+    when(gcQueue.list())
+        .thenReturn(ImmutableList.of(new RepositoryInfo(REPOSITORY, null, null, HOSTNAME)));
+    GcExecutor gcExecutor =
+        new GcExecutor(gcQueue, config, gcWorkerFactory, scheduledEvaluator, HOSTNAME);
+    verify(gcWorker).start();
+    verify(scheduledEvaluator).scheduleWith(1L, 1L);
+    gcExecutor.onShutdown();
+    verify(gcWorker).shutdown();
+  }
+
+  @Test
+  public void testScheduledEvaluationBothParametersRequired() throws Exception {
+    when(config.getExecutors()).thenReturn(1);
+    when(config.getInitialDelay()).thenReturn(1L);
+    when(gcWorkerFactory.create(EXECUTOR)).thenReturn(gcWorker);
+    when(gcQueue.list())
+        .thenReturn(ImmutableList.of(new RepositoryInfo(REPOSITORY, null, null, HOSTNAME)));
+    GcExecutor gcExecutor =
+        new GcExecutor(gcQueue, config, gcWorkerFactory, scheduledEvaluator, HOSTNAME);
+    verify(gcWorker).start();
+    verifyZeroInteractions(scheduledEvaluator);
+    gcExecutor.onShutdown();
+    verify(gcWorker).shutdown();
+  }
+
+  @Test
+  public void testloadConfigWhenNotSpecified() {
+    Config config = GcExecutor.loadConfig();
+    assertThat(config.toText()).isEmpty();
+  }
+
+  @Test
+  public void testloadConfigFromWhenSpecifiedByProperty() throws Exception {
+    File configFile = testTempFolder.newFile();
+    FileBasedConfig specifiedConfig = new FileBasedConfig(configFile, FS.DETECTED);
+    specifiedConfig.setString("otherSection", null, "otherKey", "otherValue");
+    specifiedConfig.save();
+    System.setProperty(CONFIG_FILE_PROPERTY, configFile.getAbsolutePath());
+    Config config = GcExecutor.loadConfig();
+    assertThat(config.toText()).isEqualTo(specifiedConfig.toText());
+    System.clearProperty(CONFIG_FILE_PROPERTY);
+  }
+
+  @Test
+  public void shouldReturnEmptyConfigIfAnErrorOccur() throws Exception {
+    File file = testTempFolder.newFile();
+    Files.write(file.toPath(), "[section]\n invalid!@$@#%#$".getBytes(), StandardOpenOption.CREATE);
+    System.setProperty(CONFIG_FILE_PROPERTY, file.getAbsolutePath());
+    Config config = GcExecutor.loadConfig();
+    assertThat(config.toText()).isEmpty();
+    System.clearProperty(CONFIG_FILE_PROPERTY);
+  }
+}
diff --git a/src/test/java/com/ericsson/gerrit/plugins/gcconductor/executor/GcWorkerTest.java b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/executor/GcWorkerTest.java
new file mode 100644
index 0000000..c9b8e5d
--- /dev/null
+++ b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/executor/GcWorkerTest.java
@@ -0,0 +1,144 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.executor;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.when;
+
+import com.ericsson.gerrit.plugins.gcconductor.GcQueue;
+import com.ericsson.gerrit.plugins.gcconductor.GcQueueException;
+import com.ericsson.gerrit.plugins.gcconductor.RepositoryInfo;
+import java.io.IOException;
+import java.util.Optional;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class GcWorkerTest {
+  private static final String EXEC_NAME = Thread.currentThread().getName();
+  private static final String REPO_PATH = "repo";
+  private static final String HOSTNAME = "hostname";
+  private static final Optional<String> QUEUED_FROM = Optional.empty();
+
+  @Mock private GcQueue queue;
+  @Mock private GarbageCollector garbageCollector;
+  @Mock private CancellableProgressMonitor cpm;
+
+  private RepositoryInfo repoInfo;
+
+  private GcWorker gcTask;
+
+  @Before
+  public void setUp() {
+    Thread.interrupted(); // reset the flag
+    repoInfo = new RepositoryInfo(REPO_PATH, null, EXEC_NAME, HOSTNAME);
+    gcTask = new GcWorker(queue, garbageCollector, cpm, QUEUED_FROM, 0, EXEC_NAME);
+  }
+
+  @Test
+  public void shouldPickAndRemoveRepository() throws Exception {
+    when(queue.pick(EXEC_NAME, 0, QUEUED_FROM)).thenReturn(repoInfo);
+    when(cpm.isCancelled()).thenReturn(false).thenReturn(false).thenReturn(true);
+    gcTask.run();
+    verify(garbageCollector).call();
+    verify(queue).remove(REPO_PATH);
+    cpm.cancel();
+  }
+
+  @Test
+  public void noRepositoryPicked() throws Exception {
+    when(cpm.isCancelled()).thenReturn(false).thenReturn(true);
+    gcTask.run();
+    verifyZeroInteractions(garbageCollector);
+    verify(queue, never()).remove(any(String.class));
+    verify(queue, never()).unpick(any(String.class));
+  }
+
+  @Test
+  public void interruptedWhenWaitingToPickRepository() throws Exception {
+    when(cpm.isCancelled()).thenReturn(false).thenReturn(true);
+    Thread t = new Thread(() -> gcTask.run());
+    t.start();
+    t.interrupt();
+    verifyZeroInteractions(garbageCollector);
+    verify(queue, never()).remove(any(String.class));
+    verify(queue, never()).unpick(any(String.class));
+  }
+
+  @Test
+  public void gcFailsOnRepository() throws Exception {
+    when(cpm.isCancelled()).thenReturn(false).thenReturn(false).thenReturn(false).thenReturn(true);
+    when(queue.pick(EXEC_NAME, 0, QUEUED_FROM)).thenReturn(repoInfo);
+    doThrow(new IOException()).when(garbageCollector).call();
+    gcTask.run();
+    verify(queue).remove(REPO_PATH);
+    verify(queue, never()).unpick(any(String.class));
+  }
+
+  @Test
+  public void queueThrowsExceptionWhenPickingRepository() throws Exception {
+    when(cpm.isCancelled()).thenReturn(false).thenReturn(true);
+    doThrow(new GcQueueException("", new Throwable())).when(queue).pick(EXEC_NAME, 0, QUEUED_FROM);
+    gcTask.run();
+    verifyZeroInteractions(garbageCollector);
+    verify(queue, never()).remove(any(String.class));
+    verify(queue, never()).unpick(any(String.class));
+  }
+
+  @Test
+  public void gcRepositoryIsInterrupted() throws Exception {
+    when(cpm.isCancelled()).thenReturn(false).thenReturn(true).thenReturn(true).thenReturn(true);
+    when(queue.pick(EXEC_NAME, 0, QUEUED_FROM)).thenReturn(repoInfo);
+    doThrow(new IOException()).when(garbageCollector).call();
+    gcTask.run();
+    verify(queue).unpick(REPO_PATH);
+    verify(queue, never()).remove(REPO_PATH);
+  }
+
+  @Test
+  public void queueThrowsExceptionWhenRemovingRepository() throws Exception {
+    when(cpm.isCancelled()).thenReturn(false).thenReturn(false).thenReturn(true);
+    when(queue.pick(EXEC_NAME, 0, QUEUED_FROM)).thenReturn(repoInfo);
+    doThrow(new GcQueueException("", new Throwable())).when(queue).remove(REPO_PATH);
+    gcTask.run();
+    verify(garbageCollector).call();
+    verify(queue).remove(REPO_PATH);
+    verify(queue, never()).unpick(REPO_PATH);
+  }
+
+  @Test
+  public void queueThrowsExceptionWhenUnpickingRepository() throws Exception {
+    when(cpm.isCancelled()).thenReturn(false).thenReturn(true).thenReturn(true).thenReturn(true);
+    when(queue.pick(EXEC_NAME, 0, QUEUED_FROM)).thenReturn(repoInfo);
+    doThrow(new IOException()).when(garbageCollector).call();
+    doThrow(new GcQueueException("", new Throwable())).when(queue).unpick(REPO_PATH);
+    gcTask.run();
+    verify(queue).unpick(REPO_PATH);
+    verify(queue, never()).remove(REPO_PATH);
+  }
+
+  @Test
+  public void callingShutdownSetsCancellableToTrue() {
+    gcTask.shutdown();
+    verify(cpm).cancel();
+  }
+}
diff --git a/src/test/java/com/ericsson/gerrit/plugins/gcconductor/executor/ScheduledEvaluationTaskTest.java b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/executor/ScheduledEvaluationTaskTest.java
new file mode 100644
index 0000000..c560fbf
--- /dev/null
+++ b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/executor/ScheduledEvaluationTaskTest.java
@@ -0,0 +1,90 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.executor;
+
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.when;
+
+import com.ericsson.gerrit.plugins.gcconductor.EvaluationTask;
+import com.ericsson.gerrit.plugins.gcconductor.EvaluationTask.Factory;
+import com.google.inject.ProvisionException;
+import java.io.File;
+import org.eclipse.jgit.api.Git;
+import org.eclipse.jgit.lib.Repository;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ScheduledEvaluationTaskTest {
+
+  @Rule public TemporaryFolder dir = new TemporaryFolder();
+
+  @Mock private ExecutorConfig config;
+  @Mock private Factory evaluationTaskFactory;
+  @Mock private EvaluationTask evaluationTask;
+
+  private ScheduledEvaluationTask periodicEvaluator;
+
+  @Before
+  public void setUp() {
+    when(config.getRepositoriesPath()).thenReturn(dir.getRoot().getAbsolutePath());
+    periodicEvaluator = new ScheduledEvaluationTask(evaluationTaskFactory, config);
+  }
+
+  @Test(expected = ProvisionException.class)
+  public void shouldThrowAnExceptionOnInvalidrepositoryPath() {
+    when(config.getRepositoriesPath()).thenReturn("unexistingPath");
+    periodicEvaluator = new ScheduledEvaluationTask(evaluationTaskFactory, config);
+  }
+
+  @Test
+  public void shouldAddRepository() throws Exception {
+    Repository repository = createRepository("repoTest");
+    when(evaluationTaskFactory.create(repository.getDirectory().getAbsolutePath()))
+        .thenReturn(evaluationTask);
+    periodicEvaluator.run();
+    verify(evaluationTask).run();
+  }
+
+  @Test
+  public void shouldNotAddFolderIfNotRepository() throws Exception {
+    File notARepo = dir.newFolder("notRepository");
+    periodicEvaluator.run();
+    verify(evaluationTaskFactory, never()).create(notARepo.getAbsolutePath());
+  }
+
+  @Test
+  public void shouldHonorInterruption() throws Exception {
+    createRepository("repoTest");
+    Thread t = new Thread(() -> periodicEvaluator.run());
+    t.start();
+    t.interrupt();
+    verifyZeroInteractions(evaluationTaskFactory);
+  }
+
+  private Repository createRepository(String repoName) throws Exception {
+    File repo = dir.newFolder(repoName);
+    try (Git git = Git.init().setDirectory(repo).call()) {
+      return git.getRepository();
+    }
+  }
+}
diff --git a/src/test/java/com/ericsson/gerrit/plugins/gcconductor/executor/ScheduledEvaluatorTest.java b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/executor/ScheduledEvaluatorTest.java
new file mode 100644
index 0000000..f04cdf3
--- /dev/null
+++ b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/executor/ScheduledEvaluatorTest.java
@@ -0,0 +1,48 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.executor;
+
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
+
+import java.util.concurrent.TimeUnit;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ScheduledEvaluatorTest {
+
+  @Mock private ScheduledEvaluationTask evaluationTask;
+
+  private ScheduledEvaluator scheduledEvaluator;
+
+  @Test
+  public void testScheduleWith() throws Exception {
+    scheduledEvaluator = new ScheduledEvaluator(evaluationTask);
+    scheduledEvaluator.scheduleWith(1, 2000);
+    TimeUnit.MILLISECONDS.sleep(100);
+    verify(evaluationTask).run();
+    scheduledEvaluator.onShutdown();
+  }
+
+  @Test
+  public void testOnShutdown() {
+    scheduledEvaluator = new ScheduledEvaluator(evaluationTask);
+    scheduledEvaluator.onShutdown();
+    verifyZeroInteractions(evaluationTask);
+  }
+}
diff --git a/src/test/java/com/ericsson/gerrit/plugins/gcconductor/postgresqueue/PostgresModuleTest.java b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/postgresqueue/PostgresModuleTest.java
new file mode 100644
index 0000000..fa2593f
--- /dev/null
+++ b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/postgresqueue/PostgresModuleTest.java
@@ -0,0 +1,88 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.postgresqueue;
+
+import static com.ericsson.gerrit.plugins.gcconductor.postgresqueue.TestUtil.configMockFor;
+import static com.ericsson.gerrit.plugins.gcconductor.postgresqueue.TestUtil.deleteDatabase;
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+
+import com.ericsson.gerrit.plugins.gcconductor.evaluator.EvaluatorConfig;
+import com.ericsson.gerrit.plugins.gcconductor.postgresqueue.PostgresModule.DatabaseAccessCleanUp;
+import java.sql.SQLException;
+import org.apache.commons.dbcp.BasicDataSource;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+public class PostgresModuleTest {
+
+  private static final String TEST_DATABASE_NAME = "gc_test_module";
+  private EvaluatorConfig configMock;
+  private PostgresModule module;
+  private BasicDataSource dataSource;
+
+  @Before
+  public void setUp() throws SQLException {
+    configMock = configMockFor(TEST_DATABASE_NAME);
+    module = new PostgresModule(null);
+    dataSource = module.provideGcDatabaseAccess(configMock);
+  }
+
+  @After
+  public void tearDown() throws SQLException {
+    if (dataSource != null) {
+      dataSource.close();
+    }
+    deleteDatabase(TEST_DATABASE_NAME);
+  }
+
+  @Test
+  public void shouldCreateGcDatabase() {
+    assertThat(dataSource).isNotNull();
+    assertThat(dataSource.isClosed()).isFalse();
+  }
+
+  @Test
+  public void shouldNotComplainsIfGcDatabaseAlreadyExists() throws SQLException {
+    dataSource.close();
+    dataSource = module.provideGcDatabaseAccess(configMock);
+    assertThat(dataSource).isNotNull();
+    assertThat(dataSource.isClosed()).isFalse();
+  }
+
+  @Test(expected = SQLException.class)
+  public void shouldFailIfDatabaseNameIsInvalid() throws SQLException {
+    module.provideGcDatabaseAccess(configMockFor("invalid!@#$@$%^-name"));
+  }
+
+  @Test
+  public void shouldCloseDatabaseAccessOnStop() {
+    DatabaseAccessCleanUp dbCleanUp = new DatabaseAccessCleanUp(dataSource);
+    assertThat(dataSource).isNotNull();
+    assertThat(dataSource.isClosed()).isFalse();
+    dbCleanUp.onShutdown();
+    assertThat(dataSource.isClosed()).isTrue();
+  }
+
+  @Test(expected = RuntimeException.class)
+  public void shouldThrowExceptionIfFailsToCloseDatabaseAccess() throws SQLException {
+    BasicDataSource dataSouceMock = mock(BasicDataSource.class);
+    doThrow(new SQLException("somme error")).when(dataSouceMock).close();
+    DatabaseAccessCleanUp dbCleanUp = new DatabaseAccessCleanUp(dataSouceMock);
+    dbCleanUp.onShutdown();
+  }
+}
diff --git a/src/test/java/com/ericsson/gerrit/plugins/gcconductor/postgresqueue/PostgresQueueTest.java b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/postgresqueue/PostgresQueueTest.java
new file mode 100644
index 0000000..2b60076
--- /dev/null
+++ b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/postgresqueue/PostgresQueueTest.java
@@ -0,0 +1,496 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.postgresqueue;
+
+import static com.ericsson.gerrit.plugins.gcconductor.postgresqueue.TestUtil.configMockFor;
+import static com.ericsson.gerrit.plugins.gcconductor.postgresqueue.TestUtil.deleteDatabase;
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import com.ericsson.gerrit.plugins.gcconductor.GcQueueException;
+import com.ericsson.gerrit.plugins.gcconductor.RepositoryInfo;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.sql.Timestamp;
+import java.util.Optional;
+import java.util.concurrent.TimeUnit;
+import org.apache.commons.dbcp.BasicDataSource;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+public class PostgresQueueTest {
+
+  private static final String TEST_DATABASE_NAME = "gc_test_queue";
+  private BasicDataSource dataSource;
+  private PostgresQueue queue;
+
+  @Before
+  public void setUp() throws SQLException {
+    dataSource =
+        new PostgresModule(null).provideGcDatabaseAccess(configMockFor(TEST_DATABASE_NAME));
+    queue = new PostgresQueue(dataSource);
+  }
+
+  @After
+  public void tearDown() throws SQLException {
+    if (dataSource != null) {
+      dataSource.close();
+    }
+    deleteDatabase(TEST_DATABASE_NAME);
+  }
+
+  @Test
+  public void shouldCreateSchemaOnInit() throws GcQueueException {
+    assertThat(queue.list()).isEmpty();
+  }
+
+  @Test(expected = SQLException.class)
+  public void shouldThrowExceptionIfFailsToCreateSchemaOnInit() throws Exception {
+    BasicDataSource dataSouceMock = mock(BasicDataSource.class);
+    when(dataSouceMock.getConnection()).thenThrow(new SQLException("some message"));
+    queue = new PostgresQueue(dataSouceMock);
+  }
+
+  @Test
+  public void testAddContainsAndRemove() throws GcQueueException {
+    String repoPath = "/some/path/to/some/repository";
+    String hostname = "someHostname";
+
+    assertThat(queue.list()).isEmpty();
+    assertThat(queue.contains(repoPath)).isFalse();
+
+    queue.add(repoPath, hostname);
+    assertThat(queue.list().size()).isEqualTo(1);
+    assertThat(queue.contains(repoPath)).isTrue();
+
+    queue.add(repoPath, hostname);
+    assertThat(queue.list().size()).isEqualTo(1);
+    assertThat(queue.contains(repoPath)).isTrue();
+
+    String repoPath2 = "/some/path/to/some/repository2";
+    String hostname2 = "someHostname2";
+
+    queue.add(repoPath2, hostname2);
+    assertThat(queue.list().size()).isEqualTo(2);
+    assertThat(queue.contains(repoPath)).isTrue();
+    assertThat(queue.contains(repoPath2)).isTrue();
+
+    queue.remove(repoPath2);
+    assertThat(queue.list().size()).isEqualTo(1);
+    assertThat(queue.contains(repoPath)).isTrue();
+    assertThat(queue.contains(repoPath2)).isFalse();
+
+    queue.remove(repoPath);
+    assertThat(queue.list().size()).isEqualTo(0);
+    assertThat(queue.contains(repoPath)).isFalse();
+
+    queue.remove(repoPath);
+    assertThat(queue.list().size()).isEqualTo(0);
+    assertThat(queue.contains(repoPath)).isFalse();
+  }
+
+  @Test(expected = GcQueueException.class)
+  public void testAddThatFailsWhenGettingConnection() throws Exception {
+    queue = new PostgresQueue(createDataSourceThatFailsWhenGettingConnection());
+    queue.add("repo", "hostname");
+  }
+
+  @Test(expected = GcQueueException.class)
+  public void testAddThatFailsWhenCreatingStatement() throws Exception {
+    queue = new PostgresQueue(createDataSourceThatFailsWhenCreatingStatement());
+    queue.add("repo", "hostname");
+  }
+
+  @Test(expected = GcQueueException.class)
+  public void testAddThatFailsWhenExecutingQuery() throws Exception {
+    queue = new PostgresQueue(createDataSourceThatFailsWhenExecutingQuery());
+    queue.add("repo", "hostname");
+  }
+
+  @Test(expected = GcQueueException.class)
+  public void testContainsThatFailsWhenGettingConnection() throws Exception {
+    queue = new PostgresQueue(createDataSourceThatFailsWhenGettingConnection());
+    queue.contains("repo");
+  }
+
+  @Test(expected = GcQueueException.class)
+  public void testContainsThatFailsWhenCreatingStatement() throws Exception {
+    queue = new PostgresQueue(createDataSourceThatFailsWhenCreatingStatement());
+    queue.contains("repo");
+  }
+
+  @Test(expected = GcQueueException.class)
+  public void testContainsThatFailsWhenExecutingQuery() throws Exception {
+    queue = new PostgresQueue(createDataSourceThatFailsWhenExecutingQuery());
+    queue.contains("repo");
+  }
+
+  @Test(expected = GcQueueException.class)
+  public void testContainsThatFailsWhenIteratingResults() throws Exception {
+    queue = new PostgresQueue(createDataSourceThatFailsWhenIteratingResults());
+    queue.contains("repo");
+  }
+
+  @Test(expected = GcQueueException.class)
+  public void testRemoveThatFailsWhenGettingConnection() throws Exception {
+    queue = new PostgresQueue(createDataSourceThatFailsWhenGettingConnection());
+    queue.remove("repo");
+  }
+
+  @Test(expected = GcQueueException.class)
+  public void testRemoveThatFailsWhenCreatingStatement() throws Exception {
+    queue = new PostgresQueue(createDataSourceThatFailsWhenCreatingStatement());
+    queue.remove("repo");
+  }
+
+  @Test(expected = GcQueueException.class)
+  public void testRemoveThatFailsWhenExecutingQuery() throws Exception {
+    queue = new PostgresQueue(createDataSourceThatFailsWhenExecutingQuery());
+    queue.remove("repo");
+  }
+
+  @Test
+  public void testList() throws GcQueueException {
+    String repoPath = "/some/path/to/some/repository.git";
+    String repoPath2 = "/some/path/to/some/repository2.git";
+    String hostname = "hostname";
+    String executor = "hostname-1";
+
+    assertThat(queue.list()).isEmpty();
+    Timestamp before = new Timestamp(System.currentTimeMillis());
+    queue.add(repoPath, hostname);
+    queue.add(repoPath2, hostname);
+    queue.pick(executor, 0, Optional.empty());
+
+    assertThat(queue.list().size()).isEqualTo(2);
+
+    assertThat(queue.list().get(0).getPath()).isEqualTo(repoPath);
+    assertThat(queue.list().get(0).getExecutor()).isEqualTo(executor);
+    assertThat(queue.list().get(0).getQueuedAt()).isAtLeast(before);
+    assertThat(queue.list().get(0).getQueuedAt())
+        .isAtMost(new Timestamp(System.currentTimeMillis()));
+    assertThat(queue.list().get(0).getQueuedFrom()).isEqualTo(hostname);
+
+    assertThat(queue.list().get(1).getPath()).isEqualTo(repoPath2);
+    assertThat(queue.list().get(1).getExecutor()).isNull();
+    assertThat(queue.list().get(1).getQueuedAt()).isAtLeast(queue.list().get(0).getQueuedAt());
+    assertThat(queue.list().get(1).getQueuedAt())
+        .isAtMost(new Timestamp(System.currentTimeMillis()));
+    assertThat(queue.list().get(1).getQueuedFrom()).isEqualTo(hostname);
+  }
+
+  @Test(expected = GcQueueException.class)
+  public void testListThatFailsWhenGettingConnection() throws Exception {
+    queue = new PostgresQueue(createDataSourceThatFailsWhenGettingConnection());
+    queue.list();
+  }
+
+  @Test(expected = GcQueueException.class)
+  public void testListThatFailsWhenCreatingStatement() throws Exception {
+    queue = new PostgresQueue(createDataSourceThatFailsWhenCreatingStatement());
+    queue.list();
+  }
+
+  @Test(expected = GcQueueException.class)
+  public void testListThatFailsWhenExecutingQuery() throws Exception {
+    queue = new PostgresQueue(createDataSourceThatFailsWhenExecutingQuery());
+    queue.list();
+  }
+
+  @Test(expected = GcQueueException.class)
+  public void testListThatFailsWhenIteratingResults() throws Exception {
+    queue = new PostgresQueue(createDataSourceThatFailsWhenIteratingResults());
+    queue.list();
+  }
+
+  @Test
+  public void testPick() throws GcQueueException {
+    String repoPath = "/some/path/to/some/repository";
+    String hostname = "someHostname";
+    String executor = "someExecutor";
+    String executor2 = "someExecutor2";
+
+    // queue is empty nothing to pick
+    assertThat(queue.list()).isEmpty();
+    assertThat(queue.pick(executor, 0, Optional.empty())).isNull();
+
+    // queue contains 1 repository, should pick that one
+    queue.add(repoPath, hostname);
+    RepositoryInfo picked = queue.pick(executor, 0, Optional.empty());
+    assertThat(picked).isNotNull();
+    assertThat(picked.getPath()).isEqualTo(repoPath);
+    assertThat(picked.getExecutor()).isEqualTo(executor);
+
+    // queue contains 1 already picked repository, should pick same one
+    picked = queue.pick(executor, 0, Optional.empty());
+    assertThat(picked).isNotNull();
+    assertThat(picked.getPath()).isEqualTo(repoPath);
+    assertThat(picked.getExecutor()).isEqualTo(executor);
+
+    // queue contains 1 already picked repository, nothing to pick for other
+    // executors
+    assertThat(queue.pick(executor2, 0, Optional.empty())).isNull();
+  }
+
+  @Test
+  public void testPickRepositoriesInOrder() throws GcQueueException {
+    String repositoryFormat = "my/path%s.git";
+    for (int i = 0; i < 100; i++) {
+      queue.add(String.format(repositoryFormat, i), "someHostname");
+    }
+    for (int i = 0; i < 100; i++) {
+      String pickedRepo = queue.pick("someExecutor", 0, Optional.empty()).getPath();
+      assertThat(pickedRepo).isEqualTo(String.format(repositoryFormat, i));
+      queue.remove(pickedRepo);
+    }
+  }
+
+  @Test
+  public void testPickInQueueForLongerThan() throws GcQueueException, InterruptedException {
+    String repoPath = "/some/path/to/some/repository";
+    String hostname = "someHostname";
+    String executor = "someExecutor";
+
+    // pick repository older than 10 seconds, nothing to pick
+    queue.add(repoPath, hostname);
+    assertThat(queue.pick(executor, 10, Optional.empty())).isNull();
+    assertThat(queue.list().get(0).getExecutor()).isNull();
+
+    // make 2 seconds elapse and pick repository older than 1 second, should pick one
+    TimeUnit.SECONDS.sleep((2));
+    RepositoryInfo picked = queue.pick(executor, 1, Optional.empty());
+    assertThat(picked.getPath()).isEqualTo(repoPath);
+    assertThat(picked.getExecutor()).isEqualTo(executor);
+  }
+
+  @Test
+  public void testPickQueuedFrom() throws GcQueueException {
+    String repoPath = "/some/path/to/some/repository";
+    String hostname = "hostname";
+    String otherHostname = "otherHostname";
+    String executor = "hostname-1";
+
+    // pick repository queued from otherHostname, nothing to pick
+    queue.add(repoPath, hostname);
+    assertThat(queue.pick(executor, 0, Optional.of(otherHostname))).isNull();
+    assertThat(queue.list().get(0).getExecutor()).isNull();
+
+    // pick repository queued from hostname, should pick one
+    RepositoryInfo picked = queue.pick(executor, 0, Optional.of(hostname));
+    assertThat(picked.getPath()).isEqualTo(repoPath);
+    assertThat(picked.getExecutor()).isEqualTo(executor);
+  }
+
+  @Test(expected = GcQueueException.class)
+  public void testPickThatFailsWhenGettingConnection() throws Exception {
+    queue = new PostgresQueue(createDataSourceThatFailsWhenGettingConnection());
+    queue.pick("executor", 0, Optional.empty());
+  }
+
+  @Test(expected = GcQueueException.class)
+  public void testPickThatFailsWhenCreatingStatement() throws Exception {
+    queue = new PostgresQueue(createDataSourceThatFailsWhenCreatingStatement());
+    queue.pick("executor", 0, Optional.empty());
+  }
+
+  @Test(expected = GcQueueException.class)
+  public void testPickThatFailsWhenExecutingQuery() throws Exception {
+    queue = new PostgresQueue(createDataSourceThatFailsWhenExecutingQuery());
+    queue.pick("executor", 0, Optional.empty());
+  }
+
+  @Test(expected = GcQueueException.class)
+  public void testPickThatFailsWhenIteratingResults() throws Exception {
+    queue = new PostgresQueue(createDataSourceThatFailsWhenIteratingResults());
+    queue.pick("executor", 0, Optional.empty());
+  }
+
+  @Test
+  public void testUnpick() throws GcQueueException {
+    String repoPath = "/some/path/to/some/repository";
+    String hostname = "someHostname";
+    String executor = "someExecutor";
+
+    // queue contains 1 repository, should pick that one
+    queue.add(repoPath, hostname);
+    RepositoryInfo picked = queue.pick(executor, 0, Optional.empty());
+    assertThat(picked.getPath()).isEqualTo(repoPath);
+    assertThat(picked.getExecutor()).isEqualTo(executor);
+
+    queue.unpick(repoPath);
+    // unpick repo so should pick that one again
+    queue.unpick(repoPath);
+    picked = queue.pick(executor, 0, Optional.empty());
+    assertThat(picked.getPath()).isEqualTo(repoPath);
+    assertThat(picked.getExecutor()).isEqualTo(executor);
+  }
+
+  @Test(expected = GcQueueException.class)
+  public void testUnpickThatFailsWhenGettingConnection() throws Exception {
+    queue = new PostgresQueue(createDataSourceThatFailsWhenGettingConnection());
+    queue.unpick("/some/path/to/some/repository.git");
+  }
+
+  @Test(expected = GcQueueException.class)
+  public void testUnpickFailsWhenCreatingStatement() throws Exception {
+    queue = new PostgresQueue(createDataSourceThatFailsWhenCreatingStatement());
+    queue.unpick("/some/path/to/some/repository.git");
+  }
+
+  @Test(expected = GcQueueException.class)
+  public void testUnpickThatFailsWhenExecutingQuery() throws Exception {
+    queue = new PostgresQueue(createDataSourceThatFailsWhenExecutingQuery());
+    queue.unpick("/some/path/to/some/repository.git");
+  }
+
+  @Test
+  public void testResetQueuedFrom() throws GcQueueException {
+    String repoPath = "/some/path/to/some/repository";
+    String repoPath2 = "/some/path/to/some/repository2";
+    String hostname = "hostname";
+    String otherHostname = "otherHostname";
+
+    queue.add(repoPath, hostname);
+    queue.add(repoPath2, hostname);
+    assertThat(queue.list().get(0).getQueuedFrom()).isEqualTo(hostname);
+    assertThat(queue.list().get(1).getQueuedFrom()).isEqualTo(hostname);
+
+    queue.resetQueuedFrom(otherHostname);
+    assertThat(queue.list().get(0).getQueuedFrom()).isEqualTo(otherHostname);
+    assertThat(queue.list().get(1).getQueuedFrom()).isEqualTo(otherHostname);
+  }
+
+  @Test(expected = GcQueueException.class)
+  public void testResetQueuedFromThatFailsWhenGettingConnection() throws Exception {
+    queue = new PostgresQueue(createDataSourceThatFailsWhenGettingConnection());
+    queue.resetQueuedFrom("someHostname");
+  }
+
+  @Test(expected = GcQueueException.class)
+  public void testResetQueuedFromFailsWhenCreatingStatement() throws Exception {
+    queue = new PostgresQueue(createDataSourceThatFailsWhenCreatingStatement());
+    queue.resetQueuedFrom("someHostname");
+  }
+
+  @Test(expected = GcQueueException.class)
+  public void testResetQueuedFromThatFailsWhenExecutingQuery() throws Exception {
+    queue = new PostgresQueue(createDataSourceThatFailsWhenExecutingQuery());
+    queue.resetQueuedFrom("someHostname");
+  }
+
+  @Test
+  public void testBumpToFirst() throws GcQueueException {
+    String repoPath = "/some/path/to/some/repository";
+    String repoPath2 = "/some/path/to/some/repository2";
+    String repoPath3 = "/some/path/to/some/repository3";
+    String hostname = "hostname";
+
+    // Queue contains 1 repository, bumping should have no effect
+    queue.add(repoPath, hostname);
+    assertThat(queue.list().get(0).getPath()).isEqualTo(repoPath);
+    queue.bumpToFirst(repoPath);
+    assertThat(queue.list().get(0).getPath()).isEqualTo(repoPath);
+
+    // Queue has 3 repositories, should be able to change their order
+    queue.add(repoPath2, hostname);
+    queue.add(repoPath3, hostname);
+    assertThat(queue.list().get(1).getPath()).isEqualTo(repoPath2);
+    assertThat(queue.list().get(2).getPath()).isEqualTo(repoPath3);
+
+    // repoPath3 should be first, all other repositories should be shifted down
+    queue.bumpToFirst(repoPath3);
+    assertThat(queue.list().get(0).getPath()).isEqualTo(repoPath3);
+    assertThat(queue.list().get(1).getPath()).isEqualTo(repoPath);
+    assertThat(queue.list().get(2).getPath()).isEqualTo(repoPath2);
+
+    // Bumping a repository that is already first priority should have no effect
+    queue.bumpToFirst(repoPath3);
+    assertThat(queue.list().get(0).getPath()).isEqualTo(repoPath3);
+    assertThat(queue.list().get(1).getPath()).isEqualTo(repoPath);
+    assertThat(queue.list().get(2).getPath()).isEqualTo(repoPath2);
+  }
+
+  @Test(expected = GcQueueException.class)
+  public void testBumpToFirstThatFailsWhenGettingConnection() throws Exception {
+    queue = new PostgresQueue(createDataSourceThatFailsWhenGettingConnection());
+    queue.bumpToFirst("someHostname");
+  }
+
+  @Test(expected = GcQueueException.class)
+  public void testBumpToFirstFailsWhenCreatingStatement() throws Exception {
+    queue = new PostgresQueue(createDataSourceThatFailsWhenCreatingStatement());
+    queue.bumpToFirst("someHostname");
+  }
+
+  @Test(expected = GcQueueException.class)
+  public void testBumpToFirstThatFailsWhenExecutingQuery() throws Exception {
+    queue = new PostgresQueue(createDataSourceThatFailsWhenExecutingQuery());
+    queue.bumpToFirst("someHostname");
+  }
+
+  private BasicDataSource createDataSourceThatFailsWhenGettingConnection() throws SQLException {
+    BasicDataSource dataSouceMock = mock(BasicDataSource.class);
+    Connection connectionMock = mock(Connection.class);
+    Statement statementMock = mock(Statement.class);
+
+    when(dataSouceMock.getConnection()).thenReturn(connectionMock).thenThrow(new SQLException());
+    when(connectionMock.createStatement()).thenReturn(statementMock);
+
+    return dataSouceMock;
+  }
+
+  private BasicDataSource createDataSourceThatFailsWhenCreatingStatement() throws SQLException {
+    BasicDataSource dataSouceMock = mock(BasicDataSource.class);
+    Connection connectionMock = mock(Connection.class);
+    Statement statementMock = mock(Statement.class);
+
+    when(dataSouceMock.getConnection()).thenReturn(connectionMock);
+    when(connectionMock.createStatement()).thenReturn(statementMock).thenThrow(new SQLException());
+
+    return dataSouceMock;
+  }
+
+  private BasicDataSource createDataSourceThatFailsWhenExecutingQuery() throws SQLException {
+    BasicDataSource dataSouceMock = mock(BasicDataSource.class);
+    Connection connectionMock = mock(Connection.class);
+    Statement statementMock = mock(Statement.class);
+
+    when(dataSouceMock.getConnection()).thenReturn(connectionMock);
+    when(connectionMock.createStatement()).thenReturn(statementMock);
+    when(statementMock.execute(anyString())).thenReturn(true).thenThrow(new SQLException());
+    when(statementMock.executeQuery(anyString())).thenThrow(new SQLException());
+
+    return dataSouceMock;
+  }
+
+  private BasicDataSource createDataSourceThatFailsWhenIteratingResults() throws SQLException {
+    BasicDataSource dataSouceMock = mock(BasicDataSource.class);
+    Connection connectionMock = mock(Connection.class);
+    Statement statementMock = mock(Statement.class);
+    ResultSet resultSetMock = mock(ResultSet.class);
+
+    when(dataSouceMock.getConnection()).thenReturn(connectionMock);
+    when(connectionMock.createStatement()).thenReturn(statementMock);
+    when(statementMock.executeQuery(anyString())).thenReturn(resultSetMock);
+    when(resultSetMock.next()).thenThrow(new SQLException());
+
+    return dataSouceMock;
+  }
+}
diff --git a/src/test/java/com/ericsson/gerrit/plugins/gcconductor/postgresqueue/TestUtil.java b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/postgresqueue/TestUtil.java
new file mode 100644
index 0000000..023f9cd
--- /dev/null
+++ b/src/test/java/com/ericsson/gerrit/plugins/gcconductor/postgresqueue/TestUtil.java
@@ -0,0 +1,63 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.ericsson.gerrit.plugins.gcconductor.postgresqueue;
+
+import static com.ericsson.gerrit.plugins.gcconductor.postgresqueue.DatabaseConstants.DRIVER;
+import static com.ericsson.gerrit.plugins.gcconductor.postgresqueue.DatabaseConstants.INITIAL_DATABASE;
+import static com.ericsson.gerrit.plugins.gcconductor.postgresqueue.DatabaseConstants.dropDatabase;
+import static com.ericsson.gerrit.plugins.gcconductor.postgresqueue.DatabaseConstants.executeStatement;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import com.ericsson.gerrit.plugins.gcconductor.evaluator.EvaluatorConfig;
+import java.sql.SQLException;
+import org.apache.commons.dbcp.BasicDataSource;
+import org.junit.Test;
+
+public class TestUtil {
+
+  private static final String DATABASE_SERVER_URL = "jdbc:postgresql://localhost:5432/";
+  private static final String DEFAULT_USER_AND_PASSWORD = "gc";
+
+  static EvaluatorConfig configMockFor(String databaseName) {
+    EvaluatorConfig configMock = mock(EvaluatorConfig.class);
+    when(configMock.getDatabaseUrl()).thenReturn(DATABASE_SERVER_URL);
+    when(configMock.getDatabaseUrlOptions()).thenReturn("");
+    when(configMock.getDatabaseName()).thenReturn(databaseName);
+    when(configMock.getUsername()).thenReturn(DEFAULT_USER_AND_PASSWORD);
+    when(configMock.getPassword()).thenReturn(DEFAULT_USER_AND_PASSWORD);
+    return configMock;
+  }
+
+  static void deleteDatabase(String databaseName) throws SQLException {
+    BasicDataSource ds = new BasicDataSource();
+    try {
+      ds.setDriverClassName(DRIVER);
+      ds.setUrl(DATABASE_SERVER_URL + INITIAL_DATABASE);
+      ds.setUsername(DEFAULT_USER_AND_PASSWORD);
+      ds.setPassword(DEFAULT_USER_AND_PASSWORD);
+      executeStatement(ds, dropDatabase(databaseName));
+    } finally {
+      ds.close();
+    }
+  }
+
+  @Test
+  public void fakeTest() {
+    // Hackish way of avoiding bazel test mark this class as failed
+    // because of the lack of executable methods
+    return;
+  }
+}
diff --git a/tools/bazel.rc b/tools/bazel.rc
new file mode 100644
index 0000000..4ed16cf
--- /dev/null
+++ b/tools/bazel.rc
@@ -0,0 +1,2 @@
+build --workspace_status_command=./tools/workspace-status.sh
+test --build_tests_only
diff --git a/tools/bzl/BUILD b/tools/bzl/BUILD
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tools/bzl/BUILD
diff --git a/tools/bzl/classpath.bzl b/tools/bzl/classpath.bzl
new file mode 100644
index 0000000..d5764f7
--- /dev/null
+++ b/tools/bzl/classpath.bzl
@@ -0,0 +1,4 @@
+load(
+    "@com_googlesource_gerrit_bazlets//tools:classpath.bzl",
+    "classpath_collector",
+)
diff --git a/tools/bzl/junit.bzl b/tools/bzl/junit.bzl
new file mode 100644
index 0000000..3af7e58
--- /dev/null
+++ b/tools/bzl/junit.bzl
@@ -0,0 +1,4 @@
+load(
+    "@com_googlesource_gerrit_bazlets//tools:junit.bzl",
+    "junit_tests",
+)
diff --git a/tools/bzl/maven_jar.bzl b/tools/bzl/maven_jar.bzl
new file mode 100644
index 0000000..2eabedb
--- /dev/null
+++ b/tools/bzl/maven_jar.bzl
@@ -0,0 +1 @@
+load("@com_googlesource_gerrit_bazlets//tools:maven_jar.bzl", "maven_jar")
diff --git a/tools/bzl/plugin.bzl b/tools/bzl/plugin.bzl
new file mode 100644
index 0000000..0b25d23
--- /dev/null
+++ b/tools/bzl/plugin.bzl
@@ -0,0 +1,6 @@
+load(
+    "@com_googlesource_gerrit_bazlets//:gerrit_plugin.bzl",
+    "PLUGIN_DEPS",
+    "PLUGIN_TEST_DEPS",
+    "gerrit_plugin",
+)
diff --git a/tools/eclipse/BUILD b/tools/eclipse/BUILD
new file mode 100644
index 0000000..35a7598
--- /dev/null
+++ b/tools/eclipse/BUILD
@@ -0,0 +1,9 @@
+load("//tools/bzl:classpath.bzl", "classpath_collector")
+
+classpath_collector(
+    name = "main_classpath_collect",
+    testonly = 1,
+    deps = [
+        "//:gc-conductor__plugin_test_deps",
+    ],
+)
diff --git a/tools/eclipse/project.sh b/tools/eclipse/project.sh
new file mode 100755
index 0000000..2c64166
--- /dev/null
+++ b/tools/eclipse/project.sh
@@ -0,0 +1,16 @@
+#!/bin/bash
+# Copyright (C) 2017 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+`bazel query @com_googlesource_gerrit_bazlets//tools/eclipse:project --output location | sed s/BUILD:.*//`project.py -n gc-conductor -r .
diff --git a/tools/sonar/sonar.sh b/tools/sonar/sonar.sh
new file mode 100755
index 0000000..8df06d3
--- /dev/null
+++ b/tools/sonar/sonar.sh
@@ -0,0 +1,16 @@
+#!/bin/bash
+# Copyright (C) 2018 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+`bazel query @com_googlesource_gerrit_bazlets//tools/sonar:sonar --output location | sed s/BUILD:.*//`sonar.py
diff --git a/tools/workspace-status.sh b/tools/workspace-status.sh
new file mode 100755
index 0000000..00630d2
--- /dev/null
+++ b/tools/workspace-status.sh
@@ -0,0 +1,17 @@
+#!/bin/bash
+
+# This script will be run by bazel when the build process starts to
+# generate key-value information that represents the status of the
+# workspace. The output should be like
+#
+# KEY1 VALUE1
+# KEY2 VALUE2
+#
+# If the script exits with non-zero code, it's considered as a failure
+# and the output will be discarded.
+
+function rev() {
+  cd $1 && git describe --always --match "v[0-9].*" --dirty
+}
+
+echo STABLE_BUILD_GC-CONDUCTOR_LABEL "$(rev .)"