* timeout. Because networks can fail during an exchange, it is possible that the remote server
   * accepted the request before the failure.
   */
  fun onFailure(
    call: Call,
    e: IOException,
  )

  /**
   * Called when the HTTP response was successfully returned by the remote server. The callback may

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.repository;

import java.io.IOException;

/**
 * Signals a failure to store files within the local repository.
 *
 */
@Deprecated
public class LocalRepositoryNotAccessibleException extends IOException {

    public LocalRepositoryNotAccessibleException(String message, Throwable cause) {

 *    crashes the application on Android and prints a stacktrace on the JVM. (Crash reporting
 *    libraries may customize this behavior.)
 *
 * A good way to signal a failure is with a synthetic HTTP response:
 *
 * ```kotlin
 *   @Throws(IOException::class)
 *   override fun intercept(chain: Interceptor.Chain): Response {
 *     if (myConfig.isInvalid()) {
 *       return Response.Builder()

    void overlapsThrowsCifsException() throws Exception {
        when(locator.overlaps(any())).thenThrow(new CIFSException("Simulated failure"));

        CIFSException ex = assertThrows(CIFSException.class, () -> locator.overlaps(other));
        assertTrue(ex.getMessage().contains("Simulated failure"));

        verify(locator).overlaps(other);
        verifyNoMoreInteractions(locator);
    }

    }

    /**
     * Installs a plugin with the specified name and version.
     *
     * @param body the plugin installation data containing name and version
     * @return JSON response indicating success or failure
     */
    // POST /api/admin/plugin
    @Execute
    public JsonResponse<ApiResult> post$index(final InstallBody body) {
        validateApi(body, messages -> {});

type tierMetrics struct {
	sync.RWMutex  // protects requestsCount only
	requestsCount map[string]struct {
		success int64
		failure int64
	}
	histogram *prometheus.HistogramVec
}

var globalTierMetrics = tierMetrics{
	requestsCount: make(map[string]struct {
		success int64
		failure int64
	}),
	histogram: prometheus.NewHistogramVec(prometheus.HistogramOpts{
		Name:    "tier_ttlb_seconds",

						}
						stopFn(version.Size, err)
						failure = true
						decomLogIf(ctx, err)
						continue
					}
					stopFn(version.Size, nil)
					failure = false
					break
				}
				if ignore {
					continue
				}
				z.poolMetaMutex.Lock()
				z.poolMeta.CountItem(idx, version.Size, failure)
				z.poolMetaMutex.Unlock()
				if failure {
					break // break out on first error
				}

 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.crawler.exception;

/**
 * The crawler login failure exception.
 * This exception is thrown when the crawler fails to login to a website.
 *
 */
public class CrawlerLoginFailureException extends CrawlerSystemException {
    private static final long serialVersionUID = 1L;

   *     problem or timeout. Because networks can fail during an exchange, it is possible that the
   *     remote server accepted the request before the failure.
   * @throws IllegalStateException when the call has already been executed.
   */
  @Throws(IOException::class)
  fun execute(): Response

  /**
   * Schedules the request to be executed at some point in the future.

     */
    @Nonnull
    Optional<Boolean> relaxedChecksums();

    /**
     * Indicates whether Maven should stop at the first failure in a multi-module build.
     *
     * @return an {@link Optional} containing true if Maven should stop at the first failure, false if not, or empty if not specified
     */
    @Nonnull
    Optional<Boolean> failFast();

    /**