All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.google.gerrit.server.ExceptionHook Maven / Gradle / Ivy

There is a newer version: 3.10.1
Show newest version
// Copyright (C) 2019 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;

import static java.util.Objects.requireNonNull;

import com.google.auto.value.AutoValue;
import com.google.common.collect.ImmutableList;
import com.google.gerrit.common.Nullable;
import com.google.gerrit.extensions.annotations.ExtensionPoint;
import java.util.Optional;

/**
 * Allows implementors to control how certain exceptions should be handled.
 *
 * 

This interface is intended to be implemented for cluster setups with multiple primary nodes to * control the behavior for handling exceptions that are thrown by a lower layer that handles the * consensus and synchronization between different server nodes. E.g. if an operation fails because * consensus for a Git update could not be achieved (e.g. due to slow responding server nodes) this * interface can be used to retry the request instead of failing it immediately. */ @ExtensionPoint public interface ExceptionHook { /** * Whether an operation should be retried if it failed with the given throwable. * *

Only affects operations that are executed with {@link * com.google.gerrit.server.update.RetryHelper}. * *

Should return {@code true} only for exceptions that are caused by temporary issues where a * retry of the operation has a chance to succeed. * *

If {@code false} is returned the operation is still retried once to capture a trace, unless * {@link #skipRetryWithTrace(String, String, Throwable)} skips the auto-retry. * *

If multiple exception hooks are registered, the operation is retried if any of them returns * {@code true} from this method. * * @param throwable throwable that was thrown while executing the operation * @param actionType the type of the action for which the exception occurred * @param actionName the name of the action for which the exception occurred * @return whether the operation should be retried */ default boolean shouldRetry(String actionType, String actionName, Throwable throwable) { return false; } /** * Whether auto-retrying of an operation with tracing should be skipped for the given throwable. * *

Only affects operations that are executed with {@link * com.google.gerrit.server.update.RetryHelper}. * *

This method is only called for exceptions for which the operation should not be retried * ({@link #shouldRetry(String, String, Throwable)} returned {@code false}). * *

By default this method returns {@code false}, so that by default traces for unexpected * exceptions are captured, which allows to investigate them. * *

Implementors may use this method to skip retry with tracing for exceptions that occur due to * known causes that are permanent and where a trace is not needed for the investigation. For * example, if an operation fails because persisted data is corrupt, it makes no sense to retry * the operation with a trace, because the trace will not help with fixing the corrupt data. * *

This method is only invoked if retry with tracing is enabled on the server ({@code * retry.retryWithTraceOnFailure} in {@code gerrit.config} is set to {@code true}). * *

If multiple exception hooks are registered, retrying with tracing is skipped if any of them * returns {@code true} from this method. * * @param throwable throwable that was thrown while executing the operation * @param actionType the type of the action for which the exception occurred * @param actionName the name of the action for which the exception occurred * @return whether auto-retrying of an operation with tracing should be skipped for the given * throwable */ default boolean skipRetryWithTrace(String actionType, String actionName, Throwable throwable) { return false; } /** * Formats the cause of an exception for use in metrics. * *

This method allows implementors to group exceptions that have the same cause into one metric * bucket. * *

If multiple exception hooks return a value from this method, the value from the exception * hook that is registered first is used. * * @param throwable the exception cause * @return formatted cause or {@link Optional#empty()} if no formatting was done */ default Optional formatCause(Throwable throwable) { return Optional.empty(); } /** * Returns messages that should be returned to the user. * *

These messages are included into the HTTP response that is sent to the user. * *

If multiple exception hooks return a value from this method, all the values are included * into the HTTP response (in the order in which the exception hooks are registered). * * @param throwable throwable that was thrown while executing an operation * @param traceId ID of the trace if this request was traced, otherwise {@code null} * @return error messages that should be returned to the user, {@link Optional#empty()} if no * message should be returned to the user */ default ImmutableList getUserMessages(Throwable throwable, @Nullable String traceId) { return ImmutableList.of(); } /** * Returns the HTTP status that should be returned to the user. * *

Implementors may use this method to change the status for certain exceptions (e.g. using * this method it would be possible to return {@code 503 Lock failure} for {@link * com.google.gerrit.git.LockFailureException}s instead of {@code 500 Internal server error}). * *

If no value is returned ({@link Optional#empty()}) it means that this exception hook doesn't * want to change the default response code for the given exception which is {@code 500 Internal * Server Error}, but is fine if other exception hook implementation do so. * *

If multiple exception hooks return a value from this method, the value from exception hook * that is registered first is used. * *

{@link #getUserMessages(Throwable, String)} allows to define which additional messages * should be included into the body of the HTTP response. * * @param throwable throwable that was thrown while executing an operation * @return HTTP status that should be returned to the user, {@link Optional#empty()} if the * exception should result in {@code 500 Internal Server Error} */ default Optional getStatus(Throwable throwable) { return Optional.empty(); } @AutoValue public abstract class Status { public abstract int statusCode(); public abstract String statusMessage(); public static Status create(int statusCode, String statusMessage) { return new AutoValue_ExceptionHook_Status( statusCode, requireNonNull(statusMessage, "statusMessage")); } } }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy