diff --git a/.buckconfig b/.buckconfig
new file mode 100644
index 0000000..dd4f476
--- /dev/null
+++ b/.buckconfig
@@ -0,0 +1,15 @@
+[alias]
+  repository-usage = //:repository-usage
+  plugin = //:repository-usage
+  src = //:repository-usage-sources
+
+[java]
+  src_roots = java, resources
+
+[project]
+  ignore = .git
+
+[cache]
+  mode = dir
+  dir = buck-out/cache
+
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..525de60
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,3 @@
+.project
+.classpath
+buck-out
diff --git a/BUCK b/BUCK
new file mode 100644
index 0000000..d894755
--- /dev/null
+++ b/BUCK
@@ -0,0 +1,66 @@
+include_defs('//bucklets/gerrit_plugin.bucklet')
+include_defs('//lib/maven.defs')
+
+DEPS = [
+  ':digester3',
+  ':beanutils',
+  ':logging',
+]
+PROVIDED_DEPS = [
+  '//lib/commons:dbcp',
+  '//lib:gson',
+]
+TEST_DEPS = GERRIT_PLUGIN_API + [
+  ':repository-usage__plugin',
+  '//lib:junit',
+  '//lib:truth',
+]
+
+gerrit_plugin(
+  name = 'repository-usage',
+  srcs = glob(['src/main/java/**/*.java']),
+  resources = glob(['src/main/resources/**/*']),
+  manifest_entries = [
+    'Gerrit-PluginName: repository-usage',
+    'Gerrit-Module: com.googlesource.gerrit.plugins.repositoryuse.Module',
+  ],
+  deps = DEPS,
+  provided_deps = PROVIDED_DEPS,
+)
+
+java_library(
+  name = 'classpath',
+  deps = [':repository-usage__plugin'],
+)
+
+java_test(
+  name = 'repository-usage_tests',
+  srcs = glob(['src/test/java/**/*.java']),
+  labels = ['repository-usage'],
+  source_under_test = [':repository-usage__plugin'],
+  deps = TEST_DEPS,
+)
+
+maven_jar(
+  name = 'digester3',
+  id = 'org.apache.commons:commons-digester3:3.2',
+  sha1 = 'c3f68c5ff25ec5204470fd8fdf4cb8feff5e8a79',
+  license = 'Apache2.0',
+  exclude = ['META-INF/LICENSE.txt', 'META-INF/NOTICE.txt'],
+)
+
+maven_jar(
+  name = 'beanutils',
+  id = 'commons-beanutils:commons-beanutils:1.8.3',
+  sha1 = '686ef3410bcf4ab8ce7fd0b899e832aaba5facf7',
+  license = 'Apache2.0',
+  exclude = ['META-INF/LICENSE.txt', 'META-INF/NOTICE.txt'],
+)
+
+maven_jar(
+  name = 'logging',
+  id = 'commons-logging:commons-logging:1.1.1',
+  sha1 = '5043bfebc3db072ed80fbd362e7caf00e885d8ae',
+  license = 'Apache2.0',
+)
+
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/lib/BUCK b/lib/BUCK
new file mode 100644
index 0000000..f501067
--- /dev/null
+++ b/lib/BUCK
@@ -0,0 +1,27 @@
+include_defs('//bucklets/maven_jar.bucklet')
+
+maven_jar(
+  name = 'junit',
+  id = 'junit:junit:4.10',
+  sha1 = 'e4f1766ce7404a08f45d859fb9c226fc9e41a861',
+  license = 'DO_NOT_DISTRIBUTE',
+  deps = [':hamcrest-core'],
+)
+
+maven_jar(
+  name = 'hamcrest-core',
+  id = 'org.hamcrest:hamcrest-core:1.3',
+  sha1 = '42a25dc3219429f0e5d060061f71acb49bf010a0',
+  license = 'DO_NOT_DISTRIBUTE',
+  visibility = ['//lib:junit'],
+)
+
+maven_jar(
+  name = 'truth',
+  id = 'com.google.truth:truth:0.26',
+  sha1 = 'b5802815625d82f39c33219299771f3d64301b06',
+  license = 'DO_NOT_DISTRIBUTE',
+  deps = [
+    ':junit',
+  ],
+)
diff --git a/lib/gerrit/BUCK b/lib/gerrit/BUCK
new file mode 100644
index 0000000..96d016a
--- /dev/null
+++ b/lib/gerrit/BUCK
@@ -0,0 +1,13 @@
+include_defs('//bucklets/maven_jar.bucklet')
+
+VER = '2.11'
+REPO = MAVEN_CENTRAL
+
+maven_jar(
+  name = 'plugin-api',
+  id = 'com.google.gerrit:gerrit-plugin-api:' + VER,
+  sha1 = 'be80ff991f7b9f8669b7a2a399003ec1ae69ed31',
+  license = 'Apache2.0',
+  attach_source = False,
+  repository = REPO,
+)
diff --git a/src/main/java/com/googlesource/gerrit/plugins/repositoryuse/Config.java b/src/main/java/com/googlesource/gerrit/plugins/repositoryuse/Config.java
new file mode 100644
index 0000000..3722cd8
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/repositoryuse/Config.java
@@ -0,0 +1,108 @@
+// Copyright (C) 2015 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.googlesource.gerrit.plugins.repositoryuse;
+
+import com.google.gerrit.extensions.annotations.PluginName;
+import com.google.gerrit.server.config.PluginConfig;
+import com.google.gerrit.server.config.PluginConfigFactory;
+import com.google.gerrit.server.config.SitePaths;
+import com.google.inject.Inject;
+
+public class Config {
+  public enum Database {
+    H2, POSTGRESQL
+  }
+
+  @Inject
+  private static PluginConfigFactory cfg;
+
+  @Inject
+  @PluginName
+  private static String pluginName;
+
+  @Inject
+  private static SitePaths sitePaths;
+
+  private static boolean configParsed = false;
+  private static boolean refreshAllSubmodules;
+  private static boolean parseManifests;
+  private static Database databaseType;
+  private static String database;
+  private static String databaseHost;
+  private static String databaseUser;
+  private static String databasePassword;
+
+  private static void readConfig() {
+    PluginConfig pc = cfg.getFromGerritConfig(pluginName);
+    refreshAllSubmodules = pc.getBoolean("refreshAllSubmodules", false);
+    parseManifests = pc.getBoolean("parseManifests", true);
+    databaseType = pc.getEnum("databaseType", Database.H2);
+    database = pc.getString("database",
+        sitePaths.site_path.resolve("db/UsageDB").toString());
+    databaseHost = pc.getString("databaseHost", "");
+    databaseUser = pc.getString("databaseUser", "");
+    databasePassword = pc.getString("databasePassword", "");
+    configParsed = true;
+  }
+
+  public static boolean refreshAllSubmodules() {
+    if (!configParsed) {
+      readConfig();
+    }
+    return refreshAllSubmodules;
+  }
+
+  public static boolean parseManifests() {
+    if (!configParsed) {
+      readConfig();
+    }
+    return parseManifests;
+  }
+
+  public static Database getDatabaseType() {
+    if (!configParsed) {
+      readConfig();
+    }
+    return databaseType;
+  }
+
+  public static String getDatabase() {
+    if (!configParsed) {
+      readConfig();
+    }
+    return database;
+  }
+
+  public static String getDatabaseHost() {
+    if (!configParsed) {
+      readConfig();
+    }
+    return databaseHost;
+  }
+
+  public static String getDatabaseUser() {
+    if (!configParsed) {
+      readConfig();
+    }
+    return databaseUser;
+  }
+
+  public static String getDatabasePassword() {
+    if (!configParsed) {
+      readConfig();
+    }
+    return databasePassword;
+  }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/repositoryuse/ManifestParser.java b/src/main/java/com/googlesource/gerrit/plugins/repositoryuse/ManifestParser.java
new file mode 100644
index 0000000..acaa3ee
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/repositoryuse/ManifestParser.java
@@ -0,0 +1,173 @@
+// Copyright (C) 2015 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.googlesource.gerrit.plugins.repositoryuse;
+
+import org.apache.commons.digester3.Digester;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.xml.sax.SAXException;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
+public class ManifestParser {
+  private static final Logger log =
+      LoggerFactory.getLogger(ManifestParser.class);
+  private HashMap<String, String> remotes;
+  private Project defaultProject;
+  private ArrayList<Project> projects;
+
+  public ManifestParser() {
+    remotes = new HashMap<>();
+    defaultProject = new Project(null, null, null);
+    projects = new ArrayList<>();
+  }
+
+  public Map<String, String> parseManifest(byte[] contents) {
+    Digester digester = new Digester();
+    digester.push(this);
+
+    // Add all remote handlers
+    digester.addCallMethod("manifest/remote", "addRemote", 2);
+    digester.addCallParam("manifest/remote", 0, "name");
+    digester.addCallParam("manifest/remote", 1, "fetch");
+
+    // Add all default handlers. This handles both repo format
+    // attributes (remote, revision) and non-standard attributes
+    // (branch, tag, commit-id).
+    digester.addCallMethod("manifest/default", "addDefault", 5);
+    digester.addCallParam("manifest/default", 0, "remote");
+    digester.addCallParam("manifest/default", 1, "revision");
+    digester.addCallParam("manifest/default", 2, "branch");
+    digester.addCallParam("manifest/default", 3, "tag");
+    digester.addCallParam("manifest/default", 4, "commit-id");
+
+    // Add all project handlers. This handles both repo format
+    // attributes (remote, revision) and non-standard attributes
+    // (branch, tag, commit-id).
+    digester.addCallMethod("manifest/project", "addProject", 6);
+    digester.addCallParam("manifest/project", 0, "remote");
+    digester.addCallParam("manifest/project", 1, "name");
+    digester.addCallParam("manifest/project", 2, "revision");
+    digester.addCallParam("manifest/project", 3, "branch");
+    digester.addCallParam("manifest/project", 4, "tag");
+    digester.addCallParam("manifest/project", 5, "commit-id");
+
+
+    InputStream input = new ByteArrayInputStream(contents);
+    try {
+      digester.parse(input);
+    } catch (IOException | SAXException e) {
+      log.warn("Unable to parse manifest", e);
+    }
+    HashMap<String, String> resolvedProjects = new HashMap<>(projects.size());
+    for (Project p : projects) {
+      String uri = null;
+      String revision = null;
+
+      if (p.getRemote() != null) {
+        uri = remotes.get(p.getRemote());
+      }
+
+      if (uri == null && defaultProject.getRemote() != null) {
+        uri = remotes.get(defaultProject.getRemote());
+      }
+
+      if (uri == null && p.getRemote() != null) {
+        uri = p.getRemote();
+      }
+
+      if (uri != null) {
+        uri += "/" + p.getName();
+      }
+
+      if (p.getRevision() != null) {
+        revision = p.getRevision();
+      } else if (defaultProject.getRevision() != null) {
+        revision = defaultProject.getRevision();
+      }
+
+      if (uri != null && revision != null) {
+        resolvedProjects.put(uri, revision);
+      } else {
+        log.warn("Invalid project description in manifest");
+      }
+    }
+    return resolvedProjects;
+  }
+
+  public void addRemote(String name, String fetch) {
+    remotes.put(name, fetch);
+  }
+
+  public void addDefault(String remote, String revision, String branch,
+      String tag, String commitId) {
+    defaultProject =
+        new Project(remote, null, getRevision(revision, branch, tag, commitId));
+  }
+
+  public void addProject(String remote, String name, String revision,
+      String branch, String tag, String commitId) {
+    if (name != null) {
+      projects.add(new Project(remote, name,
+          getRevision(revision, branch, tag, commitId)));
+    } else {
+      log.warn("Project name not specified in manifest");
+    }
+  }
+
+  private String getRevision(String revision, String branch, String tag,
+      String commitId) {
+    if (revision != null) {
+      return revision;
+    } else if (branch != null) {
+      return branch;
+    } else if (tag != null) {
+      return tag;
+    } else if (commitId != null) {
+      return commitId;
+    }
+    return null;
+  }
+
+  public static class Project {
+    private String remote;
+    private String name;
+    private String revision;
+
+    public Project(String remote, String name, String revision) {
+      this.remote = remote;
+      this.name = name;
+      this.revision = revision;
+    }
+
+    public String getRemote() {
+      return remote;
+    }
+
+    public String getName() {
+      return name;
+    }
+
+    public String getRevision() {
+      return revision;
+    }
+  }
+
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/repositoryuse/Module.java b/src/main/java/com/googlesource/gerrit/plugins/repositoryuse/Module.java
new file mode 100644
index 0000000..4c7b822
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/repositoryuse/Module.java
@@ -0,0 +1,42 @@
+// Copyright (C) 2015 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.googlesource.gerrit.plugins.repositoryuse;
+
+import com.google.gerrit.extensions.events.GitReferenceUpdatedListener;
+import com.google.gerrit.extensions.events.LifecycleListener;
+import com.google.gerrit.extensions.registration.DynamicSet;
+import com.google.inject.AbstractModule;
+import com.google.inject.Provides;
+import com.google.inject.Singleton;
+import com.google.inject.internal.UniqueAnnotations;
+
+public class Module extends AbstractModule {
+  @Override
+  protected void configure() {
+    DynamicSet.bind(binder(), GitReferenceUpdatedListener.class)
+        .to(RefUpdateHandler.class);
+    requestStaticInjection(Config.class);
+    requestStaticInjection(Ref.Table.class);
+    requestStaticInjection(Usage.Table.class);
+    bind(LifecycleListener.class).annotatedWith(UniqueAnnotations.create())
+        .to(SQLDriver.class);
+  }
+
+  @Provides
+  @Singleton
+  SQLDriver provideSqlDriver() {
+    return new SQLDriver();
+  }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/repositoryuse/Ref.java b/src/main/java/com/googlesource/gerrit/plugins/repositoryuse/Ref.java
new file mode 100644
index 0000000..58c74d2
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/repositoryuse/Ref.java
@@ -0,0 +1,203 @@
+// Copyright (C) 2015 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.googlesource.gerrit.plugins.repositoryuse;
+
+import com.google.inject.Inject;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+public class Ref {
+  private static final Logger log = LoggerFactory.getLogger(Ref.class);
+  private static Table table = new Table();
+
+  private String project;
+  private String ref;
+  private String commit;
+  private Date lastUpdated;
+
+  public Ref(String project, String ref, String commit) {
+    init(project, ref, commit, new Date());
+  }
+
+  public Ref(String project, String ref, String commit, Date date) {
+    init(project, ref, commit, date);
+  }
+
+  private void init(String project, String ref, String commit, Date date) {
+    this.project = project;
+    this.ref = ref;
+    this.commit = commit;
+    this.lastUpdated = date;
+  }
+
+  public String getProject() {
+    return project;
+  }
+
+  public String getRef() {
+    return ref;
+  }
+
+  public String getCommit() {
+    return commit;
+  }
+
+  public void setCommit(String commit) {
+    this.commit = commit;
+  }
+
+  public Date getLastUpdated() {
+    return lastUpdated;
+  }
+
+  public void save() {
+    lastUpdated = new Date();
+    table.insertOrUpdate(this);
+    log.info(String.format("Saving Ref: %s, %s, %s", project, ref, commit));
+  }
+
+  public void delete() {
+    log.info(String.format("Deleting Ref: %s, %s", project, ref));
+    table.delete(this);
+  }
+
+  public static List<Ref> fetchByProject(String project) {
+    return table.fetchByProject(project);
+  }
+
+  public static Ref fetchByRef(String project, String ref) {
+    List<Ref> tmp = table.fetchByRef(project, ref);
+    if (tmp.size() == 1) {
+      return tmp.get(0);
+    }
+    return null;
+  }
+
+  /*
+   * static interface Table { public void insertOrUpdate(Ref u); public
+   * List<Ref> fetchByProject(String project); public List<Ref>
+   * fetchByRef(String project, String ref); }
+   *
+   * public interface TableFactory { Table create(); }
+   */
+
+  static class Table {
+    private static final String TABLE_NAME = "RefStatus";
+    private static final String PROJECT = "project";
+    private static final String REF = "ref";
+    private static final String COMMIT = "commit";
+    private static final String DATE = "last_update";
+    @Inject
+    private static SQLDriver sql;
+
+    public Table() {
+      // Create the table if it doesn't exist
+      createTable();
+    }
+
+    private void createTable() {
+      StringBuilder query = new StringBuilder();
+      query.append(String.format("CREATE TABLE IF NOT EXISTS %s(", TABLE_NAME));
+      query.append(String.format("%s VARCHAR(1023),", PROJECT));
+      query.append(String.format("%s VARCHAR(255),", REF));
+      query.append(String.format("%s VARCHAR(40),", COMMIT));
+      query.append(String.format("%s TIMESTAMP DEFAULT NOW(),", DATE));
+      query.append(String.format("PRIMARY KEY (%s, %s))", PROJECT, REF));
+      try {
+        sql.execute(query.toString());
+      } catch (SQLException e) {
+        log.error("Unable to create Ref table", e);
+      }
+    }
+
+    public void insertOrUpdate(Ref r) {
+      if (fetchByRef(r.getProject(), r.getRef()).isEmpty()) {
+        String query = "INSERT INTO " + TABLE_NAME + "(" + PROJECT + ", " + REF
+            + ", " + COMMIT + ", " + DATE + ") VALUES (?, ?, ?, "
+            + sql.getDateFormat() + ")";
+        try {
+          sql.execute(query, r.getProject(), r.getRef(), r.getCommit(),
+              sql.getDateAsString(r.getLastUpdated()));
+        } catch (SQLException e) {
+          log.error("Unable to insert reference", e);
+        }
+      } else {
+        String query = "UPDATE " + TABLE_NAME + " SET " + COMMIT + "=?, " + DATE
+            + "=" + sql.getDateFormat() + " WHERE " + PROJECT + "=? AND " + REF
+            + "=?";
+        try {
+          sql.execute(query, r.getCommit(),
+              sql.getDateAsString(r.getLastUpdated()), r.getProject(),
+              r.getRef());
+        } catch (SQLException e) {
+          log.error("Unable to update reference", e);
+        }
+      }
+    }
+
+    public void delete(Ref r) {
+      String query = "DELETE FROM " + TABLE_NAME + " WHERE " + PROJECT
+          + "=? AND " + REF + "=?";
+      try {
+        sql.execute(query, r.getProject(), r.getRef());
+      } catch (SQLException e) {
+        log.error("Unable to delete reference", e);
+      }
+    }
+
+
+    public List<Ref> fetchByProject(String project) {
+      String query = "SELECT " + PROJECT + ", " + REF + ", " + COMMIT + ", "
+          + DATE + " FROM " + TABLE_NAME + " WHERE " + PROJECT + "=?";
+      try {
+        return loadRefs(sql.fetchRows(query, project));
+
+      } catch (SQLException e) {
+        log.error("Unable to execute query", e);
+      }
+      return Collections.emptyList();
+    }
+
+    public List<Ref> fetchByRef(String project, String ref) {
+      String query = "SELECT " + PROJECT + ", " + REF + ", " + COMMIT + ", "
+          + DATE + " FROM " + TABLE_NAME + " WHERE " + PROJECT + "=? AND " + REF
+          + "=?";
+      try {
+        return loadRefs(sql.fetchRows(query, project, ref));
+      } catch (SQLException e) {
+        log.error("Unable to execute query", e);
+      }
+      return Collections.emptyList();
+    }
+
+    private List<Ref> loadRefs(List<Map<String, String>> rows) {
+      List<Ref> result = new ArrayList<>();
+      for (Map<String, String> row : rows) {
+        Ref tmp = new Ref(row.get(PROJECT), row.get(REF), row.get(COMMIT),
+            sql.getStringAsDate(row.get(DATE)));
+        result.add(tmp);
+      }
+      return result;
+    }
+  }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/repositoryuse/RefUpdateHandler.java b/src/main/java/com/googlesource/gerrit/plugins/repositoryuse/RefUpdateHandler.java
new file mode 100644
index 0000000..f3685b2
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/repositoryuse/RefUpdateHandler.java
@@ -0,0 +1,292 @@
+// Copyright (C) 2015 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.googlesource.gerrit.plugins.repositoryuse;
+
+import com.google.gerrit.extensions.events.GitReferenceUpdatedListener;
+import com.google.gerrit.reviewdb.client.Project;
+import com.google.gerrit.server.config.CanonicalWebUrl;
+import com.google.gerrit.server.git.GitRepositoryManager;
+import com.google.inject.Inject;
+
+import org.eclipse.jgit.diff.DiffEntry;
+import org.eclipse.jgit.diff.DiffFormatter;
+import org.eclipse.jgit.diff.RawTextComparator;
+import org.eclipse.jgit.errors.ConfigInvalidException;
+import org.eclipse.jgit.errors.RepositoryNotFoundException;
+import org.eclipse.jgit.lib.Constants;
+import org.eclipse.jgit.lib.FileMode;
+import org.eclipse.jgit.lib.ObjectLoader;
+import org.eclipse.jgit.lib.ObjectReader;
+import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.revwalk.RevCommit;
+import org.eclipse.jgit.revwalk.RevTree;
+import org.eclipse.jgit.revwalk.RevWalk;
+import org.eclipse.jgit.submodule.SubmoduleWalk;
+import org.eclipse.jgit.treewalk.TreeWalk;
+import org.eclipse.jgit.util.io.DisabledOutputStream;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class RefUpdateHandler implements GitReferenceUpdatedListener {
+
+  private static final Logger log =
+      LoggerFactory.getLogger(RefUpdateHandler.class);
+  private final GitRepositoryManager repoManager;
+  private final String serverName;
+
+  @Inject
+  RefUpdateHandler(GitRepositoryManager repoManager,
+      @CanonicalWebUrl String canonicalWebUrl) {
+    this.repoManager = repoManager;
+    if (canonicalWebUrl != null) {
+      try {
+        URL url = new URL(canonicalWebUrl);
+        canonicalWebUrl = url.getHost();
+      } catch (MalformedURLException e) {
+        log.warn("Could not parse canonicalWebUrl", e);
+      }
+    }
+    this.serverName = canonicalWebUrl;
+  }
+
+  @Override
+  public void onGitReferenceUpdated(Event event) {
+    if (event.isDelete() && event.getRefName().startsWith(Constants.R_HEADS)
+        || event.getRefName().startsWith(Constants.R_TAGS)) {
+      // Ref was deleted... clean up any references
+      Ref ref = Ref.fetchByRef(event.getProjectName(), event.getRefName());
+      if (ref != null) {
+        ref.delete();
+      }
+      if (event.getRefName().startsWith(Constants.R_HEADS)) {
+        // Also clean up uses from this ref
+        Usage.deleteByBranch(getCanonicalProject(event.getProjectName()),
+            event.getRefName());
+      }
+    } else if (event.getRefName().startsWith(Constants.R_TAGS)) {
+      Ref updatedRef = new Ref(event.getProjectName(), event.getRefName(),
+          event.getNewObjectId());
+      updatedRef.save();
+    } else if (event.getRefName().startsWith(Constants.R_HEADS)) {
+      Ref updatedRef = new Ref(event.getProjectName(), event.getRefName(),
+          event.getNewObjectId());
+      updatedRef.save();
+      Project.NameKey nameKey = new Project.NameKey(event.getProjectName());
+      try {
+        if (Config.refreshAllSubmodules() || event.isCreate()
+            || isSubmoduleUpdate(event, nameKey)) {
+          Map<String, String> submodules = getSubmodules(event, nameKey);
+          updateProjects(event.getProjectName(), event.getRefName(),
+              submodules);
+        }
+        if (Config.parseManifests()) {
+          parseManifests(event, nameKey);
+        }
+      } catch (IOException e) {
+        log.error(e.getMessage(), e);
+      }
+    }
+  }
+
+  private void parseManifests(Event event, Project.NameKey project)
+      throws RepositoryNotFoundException, IOException {
+    if (event.isDelete()) {
+      return;
+    }
+    try (Repository repo = repoManager.openRepository(project)) {
+      try (RevWalk walk = new RevWalk(repo); TreeWalk tw = new TreeWalk(repo)) {
+        RevCommit commit =
+            walk.parseCommit(repo.resolve(event.getNewObjectId()));
+
+        tw.setRecursive(false);
+        tw.addTree(commit.getTree());
+        ObjectReader or = tw.getObjectReader();
+        while (tw.next()) {
+          String path = tw.getPathString();
+          if (path.endsWith(".xml")) {
+            ManifestParser mp = new ManifestParser();
+            ObjectLoader ol = or.open(tw.getObjectId(0));
+            if (!ol.isLarge()) {
+              Map<String, String> tmp = mp.parseManifest(ol.getBytes());
+              HashMap<String, String> projects = new HashMap<>();
+              for (String key : tmp.keySet()) {
+                projects
+                    .put(
+                        normalizePath(String.format("%s:%s",
+                            event.getProjectName(), path), key, true),
+                    tmp.get(key));
+              }
+              updateProjects(
+                  String.format("%s:%s", event.getProjectName(), path),
+                  event.getRefName(), projects);
+            } else {
+              log.warn(String.format("%s is too large, skipping manifest parse",
+                  tw.getPathString()));
+            }
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Has a submodule been updated?
+   *
+   * @param event the Event
+   * @return True if a submodule update occurred, otherwise False.
+   */
+  private boolean isSubmoduleUpdate(Event event, Project.NameKey project)
+      throws RepositoryNotFoundException, IOException {
+    if (event.isDelete()) {
+      return false;
+    }
+    try (Repository repo = repoManager.openRepository(project)) {
+      try (RevWalk walk = new RevWalk(repo);
+          DiffFormatter df = new DiffFormatter(DisabledOutputStream.INSTANCE)) {
+        RevTree aTree = null;
+        if (!event.isCreate()) {
+          // If this is a new ref, we can't get the original commit.
+          // We can still use the DiffFormatter to give us what changed
+          // by passing null, however.
+          RevCommit aCommit =
+              walk.parseCommit(repo.resolve(event.getOldObjectId()));
+          aTree = aCommit.getTree();
+        }
+        RevCommit bCommit =
+            walk.parseCommit(repo.resolve(event.getNewObjectId()));
+        RevTree bTree = bCommit.getTree();
+
+        df.setRepository(repo);
+        df.setDiffComparator(RawTextComparator.DEFAULT);
+        df.setDetectRenames(true);
+        List<DiffEntry> diffEntries = df.scan(aTree, bTree);
+        for (DiffEntry de : diffEntries) {
+          FileMode oldMode = de.getOldMode();
+          FileMode newMode = de.getNewMode();
+          if ((oldMode != null && oldMode == FileMode.GITLINK)
+              || (newMode != null && newMode == FileMode.GITLINK)) {
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+
+  private Map<String, String> getSubmodules(Event event,
+      Project.NameKey project) throws RepositoryNotFoundException, IOException {
+    HashMap<String, String> submodules = new HashMap<>();
+    try (Repository repo = repoManager.openRepository(project)) {
+      try (RevWalk walk = new RevWalk(repo);
+          SubmoduleWalk sw = new SubmoduleWalk(repo)) {
+        RevCommit commit =
+            walk.parseCommit(repo.resolve(event.getNewObjectId()));
+        sw.setTree(commit.getTree());
+        sw.setRootTree(commit.getTree());
+        while (sw.next()) {
+          submodules.put(
+              normalizePath(event.getProjectName(), sw.getModulesUrl(), false),
+              sw.getObjectId().name());
+        }
+      } catch (ConfigInvalidException e) {
+        log.warn("Invalid .gitmodules configuration while parsing "
+            + event.getProjectName());
+      }
+    }
+    return submodules;
+  }
+
+  private void updateProjects(String project, String branch,
+      Map<String, String> projects) {
+    String canonicalProject = getCanonicalProject(project);
+    List<Usage> uses = Usage.fetchByProject(canonicalProject, branch);
+    for (Usage use : uses) {
+      if (!projects.containsKey(use.getDestination())) {
+        // No longer exists; delete.
+        use.delete();
+      } else {
+        // Update SHA1 here.
+        use.setRef(projects.get(use.getDestination()));
+        use.save();
+        projects.remove(use.getDestination());
+      }
+    }
+    // At this point, submodules only contains new elements.
+    // Create them.
+    for (String key : projects.keySet()) {
+      Usage use = new Usage(canonicalProject, branch, key, projects.get(key));
+      use.save();
+    }
+  }
+
+  private String getCanonicalProject(String project) {
+    String canonicalProject =
+        String.format("https://%s/%s", serverName, project);
+    try {
+      URL url = new URL(canonicalProject);
+      canonicalProject = url.getHost() + url.getPath();
+    } catch (MalformedURLException e) {
+      log.warn("Could not parse project as URL: " + canonicalProject);
+    }
+    return canonicalProject;
+  }
+
+  private String normalizePath(String project, String destination,
+      boolean isManifest) {
+    String originalProject =
+        isManifest ? project.substring(0, project.lastIndexOf(":")) : project;
+
+    // Handle relative and absolute paths on the same server
+    if (destination.startsWith("/")) {
+      if (serverName != null) {
+        destination = serverName + destination;
+      } else {
+        log.warn("Could not parse absolute path; canonicalWebUrl not set");
+      }
+    } else if (destination.startsWith(".")) {
+      if (serverName != null) {
+        Path path = Paths.get(String.format("/%s/%s", project, destination));
+        destination = serverName + path.normalize().toString();
+      } else {
+        log.warn("Could not parse relative path; canonicalWebUrl not set");
+      }
+    } else if (!destination.matches("^[^:]+://.*")) {
+      if (serverName != null) {
+        destination = serverName + "/" + originalProject + "/" + destination;
+      } else {
+        log.warn("Could not parse relative path; canonicalWebURl not set");
+      }
+    }
+
+    try {
+      // Replace the protocol with a known scheme, to avoid angering URL
+      destination = destination.replaceFirst("^[^:]+://", "");
+      URL url = new URL("https://" + destination);
+      destination = url.getHost() + url.getPath();
+    } catch (MalformedURLException e) {
+      log.warn("Could not parse destination as URL: " + destination);
+    }
+    return destination;
+  }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/repositoryuse/SQLDriver.java b/src/main/java/com/googlesource/gerrit/plugins/repositoryuse/SQLDriver.java
new file mode 100644
index 0000000..fdc6252
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/repositoryuse/SQLDriver.java
@@ -0,0 +1,158 @@
+// Copyright (C) 2015 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.googlesource.gerrit.plugins.repositoryuse;
+
+import com.google.gerrit.extensions.events.LifecycleListener;
+
+import com.googlesource.gerrit.plugins.repositoryuse.Config.Database;
+
+import org.apache.commons.dbcp.BasicDataSource;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class SQLDriver implements LifecycleListener {
+  private static final Logger log =
+      LoggerFactory.getLogger(ManifestParser.class);
+  private static final int POOL_SIZE = 5;
+  private static SimpleDateFormat sdf =
+      new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+
+  private BasicDataSource ds;
+
+  public SQLDriver() {
+    ds = new BasicDataSource();
+    try {
+      ds.setDriverClassName(getDriver());
+      ds.setUrl(getDatabaseUrl());
+      ds.setUsername(Config.getDatabaseUser());
+      ds.setPassword(Config.getDatabasePassword());
+      ds.setInitialSize(POOL_SIZE);
+    } catch (Exception e) {
+      log.error("Unable to create database connection", e);
+    }
+  }
+
+  @Override
+  public void start() {
+    // no-op
+  }
+
+  @Override
+  public void stop() {
+    if (ds != null) {
+      try {
+        ds.close();
+      } catch (SQLException e) {
+        log.error("Unable to close connection", e);
+      }
+    }
+  }
+
+  public List<Map<String, String>> fetchRows(String query, String... parameters)
+      throws SQLException {
+    ArrayList<Map<String, String>> result = new ArrayList<>();
+    try (Connection c = ds.getConnection();
+        PreparedStatement s = c.prepareStatement(query)) {
+      int i = 1;
+      for (String param : parameters) {
+        s.setString(i, param);
+        i++;
+      }
+      ResultSet r = s.executeQuery();
+      ResultSetMetaData rsmd = r.getMetaData();
+      while (r.next()) {
+        HashMap<String, String> row = new HashMap<>(rsmd.getColumnCount());
+        for (i = 1; i <= rsmd.getColumnCount(); i++) {
+          row.put(rsmd.getColumnLabel(i).toLowerCase(), r.getString(i));
+        }
+        result.add(row);
+      }
+    }
+    return result;
+  }
+
+  public void execute(String query, String... parameters) throws SQLException {
+    try (Connection c = ds.getConnection();
+        PreparedStatement s = c.prepareStatement(query)) {
+      int i = 1;
+      for (String param : parameters) {
+        s.setString(i, param);
+        i++;
+      }
+      if (!s.execute() && s.getUpdateCount() > 0) {
+        if (c.getAutoCommit() == false) {
+          c.commit();
+        }
+      }
+    }
+  }
+
+  public String getDateAsString(Date date) {
+    if (date != null) {
+      return sdf.format(date);
+    }
+    return sdf.format(new Date());
+  }
+
+  public Date getStringAsDate(String date) {
+    if (date != null) {
+      try {
+        return sdf.parse(date);
+      } catch (ParseException e) {
+        log.warn("Unable to parse date", e);
+      }
+    }
+    return new Date();
+  }
+
+  public String getDateFormat() {
+    if (Config.getDatabaseType() == Database.POSTGRESQL) {
+      return "TO_TIMESTAMP(?, 'YYYY-MM-DD HH24:MI:SS')";
+    }
+    return "?";
+  }
+
+  private String getDriver() throws Exception {
+    if (Config.getDatabaseType() == Database.H2) {
+      return "org.h2.Driver";
+    } else if (Config.getDatabaseType() == Database.POSTGRESQL) {
+      return "org.postgresql.Driver";
+    }
+    throw new Exception("Unsupported database engine");
+  }
+
+  private String getDatabaseUrl() throws Exception {
+    if (Config.getDatabaseType() == Database.H2) {
+      return "jdbc:h2:" + Config.getDatabase();
+    } else if (Config.getDatabaseType() == Database.POSTGRESQL) {
+      return "jdbc:postgresql://" + Config.getDatabaseHost() + "/"
+          + Config.getDatabase();
+    }
+    throw new Exception("Unsupported database engine");
+  }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/repositoryuse/Usage.java b/src/main/java/com/googlesource/gerrit/plugins/repositoryuse/Usage.java
new file mode 100644
index 0000000..5ca49a4
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/repositoryuse/Usage.java
@@ -0,0 +1,272 @@
+// Copyright (C) 2015 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.googlesource.gerrit.plugins.repositoryuse;
+
+import com.google.inject.Inject;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+public class Usage {
+  private static final Logger log = LoggerFactory.getLogger(Usage.class);
+  private static Table table = new Table();
+
+
+  private String project;
+  private String branch;
+  private String destination;
+  private String ref;
+  private String info;
+  private Date lastUpdated;
+
+  public Usage(String project, String branch, String destination, String ref) {
+    init(project, branch, destination, ref, null, new Date());
+  }
+
+  public Usage(String project, String branch, String destination, String ref,
+      String info) {
+    init(project, branch, destination, ref, info, new Date());
+  }
+
+  public Usage(String project, String branch, String destination, String ref,
+      String info, Date date) {
+    init(project, branch, destination, ref, info, date);
+  }
+
+  private void init(String project, String branch, String destination,
+      String ref, String info, Date date) {
+    this.project = project;
+    this.branch = branch;
+    this.destination = destination;
+    this.ref = ref;
+    this.info = info;
+    this.lastUpdated = date;
+  }
+
+  public String getProject() {
+    return project;
+  }
+
+  public String getBranch() {
+    return branch;
+  }
+
+  public String getDestination() {
+    return destination;
+  }
+
+  public String getRef() {
+    return ref;
+  }
+
+  public void setRef(String ref) {
+    this.ref = ref;
+  }
+
+  public String getInfo() {
+    return info;
+  }
+
+  public void setInfo(String info) {
+    this.info = info;
+  }
+
+  public Date getLastUpdated() {
+    return lastUpdated;
+  }
+
+  public void save() {
+    lastUpdated = new Date();
+    table.insertOrUpdate(this);
+    log.info(String.format("Saving Usage: %s, %s, %s, %s", project, branch,
+        destination, ref));
+  }
+
+  public void delete() {
+    table.delete(this);
+    log.info(String.format("Deleting Usage: %s, %s, %s", project, branch,
+        destination));
+  }
+
+  public static List<Usage> fetchByProject(String project) {
+    return table.fetchByProject(project);
+  }
+
+  public static List<Usage> fetchByProject(String project, String branch) {
+    return table.fetchByProject(project, branch);
+  }
+
+  public static List<Usage> fetchByDependency(String dependency) {
+    return table.fetchByDependency(dependency);
+  }
+
+  public static void deleteByBranch(String project, String branch) {
+    table.deleteByBranch(project, branch);
+    log.info(String.format("Deleting all uses: %s, %s", project, branch));
+  }
+
+  static class Table {
+    private static final String TABLE_NAME = "RepoUsage";
+    private static final String PROJECT = "project";
+    private static final String BRANCH = "branch";
+    private static final String DESTINATION = "destination";
+    private static final String REF = "ref";
+    private static final String INFO = "info";
+    private static final String DATE = "last_update";
+    @Inject
+    private static SQLDriver sql;
+
+    public Table() {
+      // Create the table if it doesn't exist
+      createTable();
+    }
+
+    private void createTable() {
+      StringBuilder query = new StringBuilder();
+      query.append(String.format("CREATE TABLE IF NOT EXISTS %s(", TABLE_NAME));
+      query.append(String.format("%s VARCHAR(1023),", PROJECT));
+      query.append(String.format("%s VARCHAR(255),", BRANCH));
+      query.append(String.format("%s VARCHAR(1023),", DESTINATION));
+      query.append(String.format("%s VARCHAR(255),", REF));
+      query.append(String.format("%s VARCHAR(255),", INFO));
+      query.append(String.format("%s TIMESTAMP DEFAULT NOW(),", DATE));
+      query.append(String.format("PRIMARY KEY (%s, %s, %s))", PROJECT, BRANCH,
+          DESTINATION));
+      try {
+        sql.execute(query.toString());
+      } catch (SQLException e) {
+        log.error("Unable to create Usage table", e);
+      }
+    }
+
+    public void insertOrUpdate(Usage u) {
+      if (fetchByProject(u.getProject(), u.getBranch(), u.getDestination())
+          .isEmpty()) {
+        String query = "INSERT INTO " + TABLE_NAME + "(" + PROJECT + ", "
+            + BRANCH + ", " + DESTINATION + ", " + REF + ", " + INFO + ", "
+            + DATE + ") VALUES (?, ?, ?, ?, ?, " + sql.getDateFormat() + ")";
+        try {
+          sql.execute(query, u.getProject(), u.getBranch(), u.getDestination(),
+              u.getRef(), u.getInfo(), sql.getDateAsString(u.getLastUpdated()));
+        } catch (SQLException e) {
+          log.error("Unable to insert usage", e);
+        }
+      } else {
+        String query = "UPDATE " + TABLE_NAME + " SET " + REF + "=?, " + INFO
+            + "=?, " + DATE + "=" + sql.getDateFormat() + " WHERE " + PROJECT
+            + "=? AND " + BRANCH + "=? AND " + DESTINATION + "=?";
+        try {
+          sql.execute(query, u.getRef(), u.getInfo(),
+              sql.getDateAsString(u.getLastUpdated()), u.getProject(),
+              u.getBranch(), u.getDestination());
+        } catch (SQLException e) {
+          log.error("Unable to update usage", e);
+        }
+      }
+    }
+
+    public void delete(Usage u) {
+      String query = "DELETE FROM " + TABLE_NAME + " WHERE " + PROJECT
+          + "=? AND " + BRANCH + "=? AND " + DESTINATION + "=?";
+      try {
+        sql.execute(query, u.getProject(), u.getBranch(), u.getDestination());
+      } catch (SQLException e) {
+        log.error("Unable to delete usage", e);
+      }
+    }
+
+    public void deleteByBranch(String project, String branch) {
+      String query = "DELETE FROM " + TABLE_NAME + " WHERE " + PROJECT
+          + "=? AND " + BRANCH + "=?";
+      try {
+        sql.execute(query, project, branch);
+      } catch (SQLException e) {
+        log.error("Unable to delete usage", e);
+      }
+    }
+
+    public List<Usage> fetchByProject(String project) {
+      String query = "SELECT " + PROJECT + ", " + BRANCH + ", " + DESTINATION
+          + ", " + REF + ", " + INFO + ", " + DATE + " FROM " + TABLE_NAME
+          + " WHERE " + PROJECT + "=?";
+      try {
+        return loadUsage(sql.fetchRows(query, project));
+
+      } catch (SQLException e) {
+        log.error("Unable to execute query", e);
+      }
+      return Collections.emptyList();
+    }
+
+    public List<Usage> fetchByProject(String project, String branch) {
+      String query = "SELECT " + PROJECT + ", " + BRANCH + ", " + DESTINATION
+          + ", " + REF + ", " + INFO + ", " + DATE + " FROM " + TABLE_NAME
+          + " WHERE " + PROJECT + "=? AND " + BRANCH + "=?";
+      try {
+        return loadUsage(sql.fetchRows(query, project, branch));
+
+      } catch (SQLException e) {
+        log.error("Unable to execute query", e);
+      }
+      return Collections.emptyList();
+    }
+
+    public List<Usage> fetchByProject(String project, String branch,
+        String destination) {
+      String query =
+          "SELECT " + PROJECT + ", " + BRANCH + ", " + DESTINATION + ", " + REF
+              + ", " + INFO + ", " + DATE + " FROM " + TABLE_NAME + " WHERE "
+              + PROJECT + "=? AND " + BRANCH + "=? AND " + DESTINATION + "=?";
+      try {
+        return loadUsage(sql.fetchRows(query, project, branch, destination));
+
+      } catch (SQLException e) {
+        log.error("Unable to execute query", e);
+      }
+      return Collections.emptyList();
+    }
+
+    public List<Usage> fetchByDependency(String dependency) {
+      String query = "SELECT " + PROJECT + ", " + BRANCH + ", " + DESTINATION
+          + ", " + REF + ", " + INFO + ", " + DATE + " FROM " + TABLE_NAME
+          + " WHERE " + DESTINATION + "=?";
+      try {
+        return loadUsage(sql.fetchRows(query, dependency));
+
+      } catch (SQLException e) {
+        log.error("Unable to execute query", e);
+      }
+      return Collections.emptyList();
+    }
+
+    private List<Usage> loadUsage(List<Map<String, String>> rows) {
+      List<Usage> result = new ArrayList<>();
+      for (Map<String, String> row : rows) {
+        Usage tmp = new Usage(row.get(PROJECT), row.get(BRANCH),
+            row.get(DESTINATION), row.get(REF), row.get(INFO),
+            sql.getStringAsDate(row.get(DATE)));
+        result.add(tmp);
+      }
+      return result;
+    }
+  }
+}