Add QuotaBackend and QuotaEnforcer extension point
In a recent discussion on the mailing list we agreed that Gerrit-core
would benefit from a mechanism to enforce various kinds of quotas.
As there is no gold-standard for quota checking and there are vastly
different quotas that one might want to enforce (HTTP-QPS,
number-of-projects, numBytesPerProject to name just a few) we provide
this as an extension point for plugins.
This commit implements the extension point in core using AutoValue
requests and responses to keep the interface as stable as possible. We
abstract away from this interface by implementing QuotaBackend and
DefaultQuotaBackend to centralize the plugin calling, provide a fluent
API for Gerrit-core to interact with and be able to provide a different
implementation that doesn't require plugins in tests and other settings
that might have such a need. The returned QuotaResponse.Aggregated
object offers throwing methods to assert that all quota checks passed
and eliminate try-catch-throw boiler-plate in callers.
Decoupling QuotaBackend from QuotaEnforcer also makes it so that we can
improve the fluent interface as we get more callers to make it easy to
use while keeping QuotaEnforcer stable to break as little plugins as
possible.
In the following paragraphs, I'll outline a bit of the thoughts that
went into the design of the interfaces:
For QuotaEnforcer, we don't want to throw exceptions, but have rich
return types instead. One reason is that the general Java world is
moving into the direction of UncheckedExceptions, another reason is that
we can be richer in expressing what happened in a returned object.
QuotaRequestContext contains all state besides the quota group and the
number of tokens we want to deduct. This is because this state might
change and be extended in the future. In this case we want existing
plugins to remain compatible.
Why are we passing Change.Id, Account.Id and Project.NameKey as Java
objects to plugins instead of just encompassing them as IdStrings in
the quota group (/projects/my-project/create)?
Mainly because we don't want plugins to have to parse this back into an
identifier they can use which would be wasteful and add complexity.
Why are we passing these at all?
There are uses cases where it matters which top-level entity the request
is for. For example: Limiting the number of bytes per project. We want
to support these as well.
Why is QuotaEnforcer offering a refill mechanism?
We offer a refill mechanism that basically tries to roll-back the last
quota request. This is only triggered when one of the QuotaEnforcers
denied the request, but other succeed. In this case, the succeeded ones
might have deducted quota for the request, even though others did not
and we let the request fail because of a lack of quota. In this case
we want to try to undo the action. This is best-effort and plugins
can choose not to do refilling.
Why is QuotaBackend *not* offering a refill mechanism?
We don't want to pollute core-Gerrit with try-catch-finally blocks that
refill quota. This is a design decision to keep the code simple. An
action in Gerrit that failed after it passed a quota check will have
deducted quota. Most QuotaEnforcer implementations are refilling, so
this is only a cosmetic issue that vanishes fast. Overall, we see the
QuotaBackend as a monolith, that can support internal rollbacks without
offering this mechanism to external callers.
In subsequent commits, we want to add quota checks to Gerrit-core and
adapt the Quota Plugin to use the new system instead of other hooks as
it does right now.
We will also provide tests where applicable.
Change-Id: I0ac9d4de583871f92040db55f0df29465029ad55
diff --git a/Documentation/dev-plugins.txt b/Documentation/dev-plugins.txt
index d7bd8b3..39a8d61 100644
--- a/Documentation/dev-plugins.txt
+++ b/Documentation/dev-plugins.txt
@@ -2660,6 +2660,94 @@
are met, but marked as `OK`. If the requirements were not displayed, reviewers
would need to use their precious time to manually check that they were met.
+[[quota-enforcer]]
+== Quota Enforcer
+
+Gerrit provides an extension point that allows a plugin to enforce quota.
+link:quota.html[This documentation page] has a list of all quota requests that
+Gerrit core issues. Plugins can choose to respond to all or just a subset of
+requests. Some implementations might want to keep track of user quota in buckets,
+others might just check against instance or project state to enforce limits on how
+many projects can be created or how large a repository can become.
+
+Checking against instance state can be racy for concurrent requests as the server does not
+refill tokens if the action fails in a later stage (e.g. database failure). If
+plugins want to guarantee an absolute maximum on a resource, they have to do their own
+book-keeping.
+
+[source, java]
+----
+import com.google.server.quota.QuotaEnforcer;
+
+class ProjectLimiter implements QuotaEnforcer {
+ private final long maxNumberOfProjects = 100;
+ @Override
+ QuotaResponse requestTokens(String quotaGroup, QuotaRequestContext ctx, long numTokens) {
+ if (!"/projects/create".equals(quotaGroup)) {
+ return QuotaResponse.noOp();
+ }
+ // No deduction because we always check against the instance state (racy but fine for
+ // this plugin)
+ if (currentNumberOfProjects() + numTokens > maxNumberOfProjects) {
+ return QuotaResponse.error("too many projects");
+ }
+ return QuotaResponse.ok();
+ }
+
+ @Override
+ QuotaResponse dryRun(String quotaGroup, QuotaRequestContext ctx, long numTokens) {
+ // Since we are not keeping any state in this enforcer, we can simply call requestTokens().
+ return requestTokens(quotaGroup, ctx, numTokens);
+ }
+
+ void refill(String quotaGroup, QuotaRequestContext ctx, long numTokens) {
+ // No-op
+ }
+}
+----
+
+[source, java]
+----
+import com.google.server.quota.QuotaEnforcer;
+
+class ApiQpsEnforcer implements QuotaEnforcer {
+ // AutoRefillingPerUserBuckets is a imaginary bucket implementation that could be based on
+ // a loading cache or a commonly used bucketing algorithm.
+ private final AutoRefillingPerUserBuckets<CurrentUser, Long> buckets;
+ @Override
+ QuotaResponse requestTokens(String quotaGroup, QuotaRequestContext ctx, long numTokens) {
+ if (!quotaGroup.startsWith("/restapi/")) {
+ return QuotaResponse.noOp();
+ }
+ boolean success = buckets.deduct(ctx.user(), numTokens);
+ if (!success) {
+ return QuotaResponse.error("user sent too many qps, please wait for 5 minutes");
+ }
+ return QuotaResponse.ok();
+ }
+
+ @Override
+ QuotaResponse dryRun(String quotaGroup, QuotaRequestContext ctx, long numTokens) {
+ if (!quotaGroup.startsWith("/restapi/")) {
+ return QuotaResponse.noOp();
+ }
+ boolean success = buckets.checkOnly(ctx.user(), numTokens);
+ if (!success) {
+ return QuotaResponse.error("user sent too many qps, please wait for 5 minutes");
+ }
+ return QuotaResponse.ok();
+ }
+
+ @Override
+ void refill(String quotaGroup, QuotaRequestContext ctx, long numTokens) {
+ if (!quotaGroup.startsWith("/restapi/")) {
+ return;
+ }
+ buckets.add(ctx.user(), numTokens);
+ }
+}
+----
+
== SEE ALSO
diff --git a/Documentation/index.txt b/Documentation/index.txt
index 6011158..557cf90 100644
--- a/Documentation/index.txt
+++ b/Documentation/index.txt
@@ -85,6 +85,7 @@
.. link:js-api.html[JavaScript Plugin API]
.. link:config-validation.html[Validation Interfaces]
.. link:dev-stars.html[Starring Changes]
+.. link:quota.html[Quota Enforcement]
. link:dev-design.html[System Design]
. link:i18n-readme.html[i18n Support]
diff --git a/Documentation/quota.txt b/Documentation/quota.txt
new file mode 100644
index 0000000..611bba8
--- /dev/null
+++ b/Documentation/quota.txt
@@ -0,0 +1,25 @@
+= Gerrit Code Review - Quota
+
+Gerrit does not provide out of the box quota enforcement. However, it does
+support an extension mechanism for plugins to hook into to provide this
+functionality. The most prominent plugin is the
+link:https://gerrit.googlesource.com/plugins/quota/[Quota Plugin].
+
+This documentation is intended to be read by plugin developers. It contains all
+quota requests implemented in Gerrit-core as well as the metadata that they have
+associated.
+
+== Quota Groups
+
+The following quota groups are defined in core Gerrit:
+
+=== REST API
+
+TODO(hiesel,luca.milanesio,matthias.sohn,david.pursehouse): Add more :)
+
+GERRIT
+------
+Part of link:index.html[Gerrit Code Review]
+
+SEARCHBOX
+---------
diff --git a/java/com/google/gerrit/server/config/GerritGlobalModule.java b/java/com/google/gerrit/server/config/GerritGlobalModule.java
index b4f9cc7..b26e875 100644
--- a/java/com/google/gerrit/server/config/GerritGlobalModule.java
+++ b/java/com/google/gerrit/server/config/GerritGlobalModule.java
@@ -170,6 +170,7 @@
import com.google.gerrit.server.query.change.ChangeQueryBuilder;
import com.google.gerrit.server.query.change.ChangeQueryProcessor;
import com.google.gerrit.server.query.change.ConflictsCacheImpl;
+import com.google.gerrit.server.quota.QuotaEnforcer;
import com.google.gerrit.server.restapi.change.SuggestReviewers;
import com.google.gerrit.server.restapi.group.GroupModule;
import com.google.gerrit.server.rules.DefaultSubmitRule;
@@ -394,6 +395,7 @@
DynamicItem.itemOf(binder(), MergeSuperSetComputation.class);
DynamicItem.itemOf(binder(), ProjectNameLockManager.class);
DynamicSet.setOf(binder(), SubmitRule.class);
+ DynamicSet.setOf(binder(), QuotaEnforcer.class);
DynamicMap.mapOf(binder(), MailFilter.class);
bind(MailFilter.class).annotatedWith(Exports.named("ListMailFilter")).to(ListMailFilter.class);
diff --git a/java/com/google/gerrit/server/quota/DefaultQuotaBackend.java b/java/com/google/gerrit/server/quota/DefaultQuotaBackend.java
new file mode 100644
index 0000000..8aa86b1
--- /dev/null
+++ b/java/com/google/gerrit/server/quota/DefaultQuotaBackend.java
@@ -0,0 +1,149 @@
+// Copyright (C) 2018 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.gerrit.server.quota;
+
+import static com.google.common.base.Preconditions.checkState;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.flogger.FluentLogger;
+import com.google.gerrit.reviewdb.client.Account;
+import com.google.gerrit.reviewdb.client.Change;
+import com.google.gerrit.reviewdb.client.Project.NameKey;
+import com.google.gerrit.server.CurrentUser;
+import com.google.gerrit.server.plugincontext.PluginSetContext;
+import com.google.gerrit.server.plugincontext.PluginSetEntryContext;
+import java.util.ArrayList;
+import java.util.List;
+import javax.inject.Inject;
+import javax.inject.Provider;
+import javax.inject.Singleton;
+
+@Singleton
+public class DefaultQuotaBackend implements QuotaBackend {
+ private static final FluentLogger logger = FluentLogger.forEnclosingClass();
+
+ private final Provider<CurrentUser> userProvider;
+ private final PluginSetContext<QuotaEnforcer> quotaEnforcers;
+
+ @Inject
+ DefaultQuotaBackend(
+ Provider<CurrentUser> userProvider, PluginSetContext<QuotaEnforcer> quotaEnforcers) {
+ this.userProvider = userProvider;
+ this.quotaEnforcers = quotaEnforcers;
+ }
+
+ @Override
+ public WithUser currentUser() {
+ return new WithUser(quotaEnforcers, userProvider.get());
+ }
+
+ @Override
+ public WithUser user(CurrentUser user) {
+ return new WithUser(quotaEnforcers, user);
+ }
+
+ private static QuotaResponse.Aggregated request(
+ PluginSetContext<QuotaEnforcer> quotaEnforcers,
+ String quotaGroup,
+ QuotaRequestContext requestContext,
+ long numTokens,
+ boolean deduct) {
+ checkState(numTokens > 0, "numTokens must be a positive, non-zero long");
+
+ // PluginSets can change their content when plugins (de-)register. Copy the currently registered
+ // plugins so that we can iterate twice on a stable list.
+ List<PluginSetEntryContext<QuotaEnforcer>> enforcers = ImmutableList.copyOf(quotaEnforcers);
+ List<QuotaResponse> responses = new ArrayList<>(enforcers.size());
+ for (PluginSetEntryContext<QuotaEnforcer> enforcer : enforcers) {
+ try {
+ if (deduct) {
+ responses.add(enforcer.call(p -> p.requestTokens(quotaGroup, requestContext, numTokens)));
+ } else {
+ responses.add(enforcer.call(p -> p.dryRun(quotaGroup, requestContext, numTokens)));
+ }
+ } catch (RuntimeException e) {
+ logger.atSevere().withCause(e).log("exception while enforcing quota");
+ responses.add(QuotaResponse.error(e.getMessage()));
+ }
+ }
+
+ if (deduct && responses.stream().anyMatch(r -> r.status().isError())) {
+ // Roll back the quota request for all enforcers that deducted the quota (= the request
+ // succeeded). Don't touch failed enforcers as the interface contract said that failed
+ // requests should not be deducted.
+ for (int i = 0; i < responses.size(); i++) {
+ if (responses.get(i).status().isOk()) {
+ enforcers.get(i).run(p -> p.refill(quotaGroup, requestContext, numTokens));
+ }
+ }
+ }
+
+ logger.atFine().log(
+ "Quota request for %s with %s (deduction=%s) for %s token returned %s",
+ quotaGroup,
+ requestContext,
+ deduct ? "(deduction=yes)" : "(deduction=no)",
+ numTokens,
+ responses);
+ return new AutoValue_QuotaResponse_Aggregated(ImmutableList.copyOf(responses));
+ }
+
+ static class WithUser extends WithResource implements QuotaBackend.WithUser {
+ WithUser(PluginSetContext<QuotaEnforcer> quotaEnforcers, CurrentUser user) {
+ super(quotaEnforcers, QuotaRequestContext.builder().user(user).build());
+ }
+
+ @Override
+ public QuotaBackend.WithResource account(Account.Id account) {
+ QuotaRequestContext ctx = requestContext.toBuilder().account(account).build();
+ return new WithResource(quotaEnforcers, ctx);
+ }
+
+ @Override
+ public QuotaBackend.WithResource project(NameKey project) {
+ QuotaRequestContext ctx = requestContext.toBuilder().project(project).build();
+ return new WithResource(quotaEnforcers, ctx);
+ }
+
+ @Override
+ public QuotaBackend.WithResource change(Change.Id change, NameKey project) {
+ QuotaRequestContext ctx = requestContext.toBuilder().change(change).project(project).build();
+ return new WithResource(quotaEnforcers, ctx);
+ }
+ }
+
+ static class WithResource implements QuotaBackend.WithResource {
+ protected final QuotaRequestContext requestContext;
+ protected final PluginSetContext<QuotaEnforcer> quotaEnforcers;
+
+ private WithResource(
+ PluginSetContext<QuotaEnforcer> quotaEnforcers, QuotaRequestContext quotaRequestContext) {
+ this.quotaEnforcers = quotaEnforcers;
+ this.requestContext = quotaRequestContext;
+ }
+
+ @Override
+ public QuotaResponse.Aggregated requestTokens(String quotaGroup, long numTokens) {
+ return DefaultQuotaBackend.request(
+ quotaEnforcers, quotaGroup, requestContext, numTokens, true);
+ }
+
+ @Override
+ public QuotaResponse.Aggregated dryRun(String quotaGroup, long numTokens) {
+ return DefaultQuotaBackend.request(
+ quotaEnforcers, quotaGroup, requestContext, numTokens, false);
+ }
+ }
+}
diff --git a/java/com/google/gerrit/server/quota/QuotaBackend.java b/java/com/google/gerrit/server/quota/QuotaBackend.java
new file mode 100644
index 0000000..d4dc46d
--- /dev/null
+++ b/java/com/google/gerrit/server/quota/QuotaBackend.java
@@ -0,0 +1,86 @@
+// Copyright (C) 2018 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.gerrit.server.quota;
+
+import com.google.gerrit.reviewdb.client.Account;
+import com.google.gerrit.reviewdb.client.Change;
+import com.google.gerrit.reviewdb.client.Project;
+import com.google.gerrit.server.CurrentUser;
+import com.google.inject.ImplementedBy;
+
+/**
+ * Backend interface to perform quota requests on. By default, this interface is backed by {@link
+ * DefaultQuotaBackend} which calls all plugins that implement {@link QuotaEnforcer}. A different
+ * implementation might be bound in tests. Plugins are not supposed to implement this interface, but
+ * bind a {@link QuotaEnforcer} implementation instead.
+ *
+ * <p>All quota requests require a quota group and a user. Enriching them with a top-level entity
+ * {@code Change, Project, Account} is optional but should be done if the request is targeted.
+ *
+ * <p>Example usage:
+ *
+ * <pre>
+ * quotaBackend.currentUser().project(projectName).requestToken("/projects/create").throwOnError();
+ * quotaBackend.user(user).requestToken("/restapi/config/put").throwOnError();
+ * QuotaResponse.Aggregated result = quotaBackend.currentUser().account(accountId).requestToken("/restapi/accounts/emails/validate");
+ * QuotaResponse.Aggregated result = quotaBackend.currentUser().project(projectName).requestTokens("/projects/git/upload", numBytesInPush);
+ * </pre>
+ *
+ * <p>All quota groups must be documented in {@code quota.txt} and detail the metadata that is
+ * provided (i.e. the parameters used to scope down the quota request).
+ */
+@ImplementedBy(DefaultQuotaBackend.class)
+public interface QuotaBackend {
+ /** Constructs a request for the current user. */
+ WithUser currentUser();
+
+ /**
+ * See {@link #currentUser()}. Use this method only if you can't guarantee that the request is for
+ * the current user (e.g. impersonation).
+ */
+ WithUser user(CurrentUser user);
+
+ /**
+ * An interface capable of issuing quota requests. Scope can be futher reduced by providing a
+ * top-level entity.
+ */
+ interface WithUser extends WithResource {
+ /** Scope the request down to an account. */
+ WithResource account(Account.Id account);
+
+ /** Scope the request down to a project. */
+ WithResource project(Project.NameKey project);
+
+ /** Scope the request down to a change. */
+ WithResource change(Change.Id change, Project.NameKey project);
+ }
+
+ /** An interface capable of issuing quota requests. */
+ interface WithResource {
+ /** Issues a single quota request for {@code 1} token. */
+ default QuotaResponse.Aggregated requestToken(String quotaGroup) {
+ return requestTokens(quotaGroup, 1);
+ }
+
+ /** Issues a single quota request for {@code numTokens} tokens. */
+ QuotaResponse.Aggregated requestTokens(String quotaGroup, long numTokens);
+
+ /**
+ * Issues a single quota request for {@code numTokens} tokens but signals the implementations
+ * not to deduct any quota yet. Can be used to do pre-flight requests where necessary
+ */
+ QuotaResponse.Aggregated dryRun(String quotaGroup, long tokens);
+ }
+}
diff --git a/java/com/google/gerrit/server/quota/QuotaEnforcer.java b/java/com/google/gerrit/server/quota/QuotaEnforcer.java
new file mode 100644
index 0000000..9c55e11
--- /dev/null
+++ b/java/com/google/gerrit/server/quota/QuotaEnforcer.java
@@ -0,0 +1,72 @@
+// Copyright (C) 2018 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.gerrit.server.quota;
+
+import com.google.gerrit.extensions.annotations.ExtensionPoint;
+
+/**
+ * Allows plugins to enforce different types of quota.
+ *
+ * <p>Enforcing quotas can be helpful in many scenarios. For example:
+ *
+ * <ul>
+ * <li>Reducing the number of QPS a user can send to Gerrit on the REST API
+ * <li>Limiting the size of a repository (project)
+ * <li>Limiting the number of changes in a repository
+ * <li>Limiting the number of actions that have the potential for spam, abuse or flooding if not
+ * limited
+ * </ul>
+ *
+ * This endpoint gives plugins the capability to enforce any of these limits. The server will ask
+ * all plugins that registered this endpoint and collect all results. In case {@link
+ * #requestTokens(String, QuotaRequestContext, long)} was called and one or more plugins returned an
+ * erroneous result, the server will call {@link #refill(String, QuotaRequestContext, long)} on all
+ * plugins with the same parameters. Plugins that deducted tokens in the {@link
+ * #requestTokens(String, QuotaRequestContext, long)} call can refill them so that users don't get
+ * charged any quota for failed requests.
+ *
+ * <p>Not all implementations will need to deduct quota on {@link #requestTokens(String,
+ * QuotaRequestContext, long)}}. Implementations that work on top of instance-attributes, such as
+ * the number of projects per instance can choose not to keep any state and always check how many
+ * existing projects there are and if adding the inquired number would exceed the limit. In this
+ * case, {@link #requestTokens(String, QuotaRequestContext, long)} and {@link #dryRun(String,
+ * QuotaRequestContext, long)} share the same implementation and {@link #refill(String,
+ * QuotaRequestContext, long)} is a no-op.
+ */
+@ExtensionPoint
+public interface QuotaEnforcer {
+ /**
+ * Checks if there is at least {@code numTokens} quota to fulfil the request. Bucket-based
+ * implementations can deduct the inquired number of tokens from the bucket.
+ */
+ QuotaResponse requestTokens(String quotaGroup, QuotaRequestContext ctx, long numTokens);
+
+ /**
+ * Checks if there is at least {@code numTokens} quota to fulfil the request. This is a pre-flight
+ * request, implementations should not deduct tokens from a bucket, yet.
+ */
+ QuotaResponse dryRun(String quotaGroup, QuotaRequestContext ctx, long numTokens);
+
+ /**
+ * A previously requested and deducted quota has to be refilled (if possible) because the request
+ * failed other quota checks. Implementations can choose to leave this a no-op in case they are
+ * the first line of defence (e.g. always deduct HTTP quota even if the request failed for other
+ * quota issues so that the user gets throttled).
+ *
+ * <p>Will not be called if the {@link #requestTokens(String, QuotaRequestContext, long)} call
+ * returned {@link QuotaResponse.Status#NO_OP}.
+ */
+ void refill(String quotaGroup, QuotaRequestContext ctx, long numTokens);
+}
diff --git a/java/com/google/gerrit/server/quota/QuotaException.java b/java/com/google/gerrit/server/quota/QuotaException.java
new file mode 100644
index 0000000..56877b2
--- /dev/null
+++ b/java/com/google/gerrit/server/quota/QuotaException.java
@@ -0,0 +1,27 @@
+// Copyright (C) 2018 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.gerrit.server.quota;
+
+import com.google.gerrit.extensions.restapi.RestApiException;
+
+/**
+ * Exception that was encountered while checking if there is sufficient quota to fulfil the request.
+ * Can be propagated directly to the REST API.
+ */
+public class QuotaException extends RestApiException {
+ public QuotaException(String reason) {
+ super(reason);
+ }
+}
diff --git a/java/com/google/gerrit/server/quota/QuotaRequestContext.java b/java/com/google/gerrit/server/quota/QuotaRequestContext.java
new file mode 100644
index 0000000..90b501c
--- /dev/null
+++ b/java/com/google/gerrit/server/quota/QuotaRequestContext.java
@@ -0,0 +1,54 @@
+// Copyright (C) 2018 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.gerrit.server.quota;
+
+import com.google.auto.value.AutoValue;
+import com.google.gerrit.reviewdb.client.Account;
+import com.google.gerrit.reviewdb.client.Change;
+import com.google.gerrit.reviewdb.client.Project;
+import com.google.gerrit.server.AnonymousUser;
+import com.google.gerrit.server.CurrentUser;
+import java.util.Optional;
+
+@AutoValue
+public abstract class QuotaRequestContext {
+
+ public static Builder builder() {
+ return new AutoValue_QuotaRequestContext.Builder().user(new AnonymousUser());
+ }
+
+ public abstract CurrentUser user();
+
+ public abstract Optional<Project.NameKey> project();
+
+ public abstract Optional<Change.Id> change();
+
+ public abstract Optional<Account.Id> account();
+
+ public abstract Builder toBuilder();
+
+ @AutoValue.Builder
+ public abstract static class Builder {
+ public abstract QuotaRequestContext.Builder user(CurrentUser user);
+
+ public abstract QuotaRequestContext.Builder account(Account.Id account);
+
+ public abstract QuotaRequestContext.Builder project(Project.NameKey project);
+
+ public abstract QuotaRequestContext.Builder change(Change.Id change);
+
+ public abstract QuotaRequestContext build();
+ }
+}
diff --git a/java/com/google/gerrit/server/quota/QuotaResponse.java b/java/com/google/gerrit/server/quota/QuotaResponse.java
new file mode 100644
index 0000000..c239aaf
--- /dev/null
+++ b/java/com/google/gerrit/server/quota/QuotaResponse.java
@@ -0,0 +1,113 @@
+// Copyright (C) 2018 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.gerrit.server.quota;
+
+import static com.google.common.collect.ImmutableList.toImmutableList;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.base.Strings;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Streams;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+@AutoValue
+public abstract class QuotaResponse {
+ public enum Status {
+ /** The quota requests succeeded. */
+ OK,
+
+ /**
+ * The quota succeeded, but was a no-op because the plugin does not enforce this quota group
+ * (equivalent to OK, but relevant for debugging).
+ */
+ NO_OP,
+
+ /**
+ * The requested quota could not be allocated. This status code is not used to indicate
+ * processing failures as these are propagated as {@code RuntimeException}s.
+ */
+ ERROR;
+
+ public boolean isOk() {
+ return this == OK;
+ }
+
+ public boolean isError() {
+ return this == ERROR;
+ }
+ }
+
+ public static QuotaResponse ok() {
+ return new AutoValue_QuotaResponse.Builder().status(Status.OK).build();
+ }
+
+ public static QuotaResponse noOp() {
+ return new AutoValue_QuotaResponse.Builder().status(Status.NO_OP).build();
+ }
+
+ public static QuotaResponse error(String message) {
+ return new AutoValue_QuotaResponse.Builder().status(Status.ERROR).message(message).build();
+ }
+
+ public abstract Status status();
+
+ public abstract Optional<String> message();
+
+ @AutoValue.Builder
+ public abstract static class Builder {
+ public abstract QuotaResponse.Builder status(Status status);
+
+ public abstract QuotaResponse.Builder message(String message);
+
+ public abstract QuotaResponse build();
+ }
+
+ @AutoValue
+ public abstract static class Aggregated {
+ protected abstract ImmutableList<QuotaResponse> responses();
+
+ public boolean hasError() {
+ return responses().stream().anyMatch(r -> r.status().isError());
+ }
+
+ public ImmutableList<QuotaResponse> all() {
+ return responses();
+ }
+
+ public ImmutableList<QuotaResponse> ok() {
+ return responses().stream().filter(r -> r.status().isOk()).collect(toImmutableList());
+ }
+
+ public ImmutableList<QuotaResponse> error() {
+ return responses().stream().filter(r -> r.status().isError()).collect(toImmutableList());
+ }
+
+ public String errorMessage() {
+ return error()
+ .stream()
+ .map(QuotaResponse::message)
+ .flatMap(Streams::stream)
+ .collect(Collectors.joining(", "));
+ }
+
+ public void throwOnError() throws QuotaException {
+ String errorMessage = errorMessage();
+ if (!Strings.isNullOrEmpty(errorMessage)) {
+ throw new QuotaException(errorMessage);
+ }
+ }
+ }
+}
