-->

<toolchains>
  <toolchain>
     <type>jdk</type>
     <provides>
         <version>1.5</version>
         <vendor>sun</vendor>
     </provides>
     <configuration>
        <jdkHome>${env.JAVA_HOME}</jdkHome>
        <toolsJar>lib/tools.jar</toolsJar>
     </configuration>
  </toolchain>
  <toolchain>
     <type>jdk</type>
     <provides>
         <version>1.6</version>
         <vendor>sun</vendor>

      </replaceConfiguration>

# ADR-0005 - Introduce a UI architecture module to the core platform

## Date

2024-02-07

## Context

The Gradle core platform provides many services to the Gradle platforms and builds logic. One such group of services allows logic to interact with the build user, to provide diagnostics, progress information, prompt for questions, and so on. Currently, these services are part of the core platform runtime architecture module.

* **Starlette**:
    * Will have the next best performance, after Uvicorn. In fact, Starlette uses Uvicorn to run. So, it probably can only get "slower" than Uvicorn by having to execute more code.
    * But it provides you the tools to build simple web applications, with routing based on paths, etc.
    * If you are comparing Starlette, compare it against Sanic, Flask, Django, etc. Web frameworks (or microframeworks).
* **FastAPI**:

Integrating other authentication/authorization providers like Google, Facebook, X (Twitter), GitHub, etc. is also possible and relatively easy.

The most complex problem is building an authentication/authorization provider like those, but **FastAPI** gives you the tools to do it easily, while doing the heavy lifting for you.

///

## **FastAPI** utilities { #fastapi-utilities }

        provides.put(type, matcher);
    }

    @Override
    public boolean matchesRequirements(Map<String, String> requirements) {
        for (Map.Entry<String, String> requirement : requirements.entrySet()) {
            String key = requirement.getKey();

            RequirementMatcher matcher = provides.get(key);

            if (matcher == null) {

# MinIO Grid

The MinIO Grid is a package that provides two-way communication between servers.
It uses a single two-way connection to send and receive messages between servers.

It includes built in muxing of concurrent requests as well as congestion handling for streams.

Requests can be "Single Payload" or "Streamed".

Use the MinIO Grid for:

* Small, frequent requests with low latency requirements.

import jakarta.annotation.Resource;

/**
 * Abstract base class for implementing {@link Rule} interfaces.
 * Provides common functionality and properties for crawler rules.
 *
 * <p>
 * This class handles the registration of rules with the {@link RuleManager}
 * and provides getter and setter methods for common properties such as
 * {@code ruleId} and {@code responseProcessor}.
 * </p>
 *
 * <p>

import org.apache.maven.api.Session;
import org.apache.maven.api.annotations.Consumer;
import org.apache.maven.api.annotations.Experimental;
import org.apache.maven.api.annotations.Nonnull;

/**
 * Transporter provider is a service that provides somewhat trivial transport capabilities backed by Maven internals.
 * This API does not try to cover all the requirements out there, just the basic ones, and is intentionally simple.

import java.util.Map;

/**
 * Parameter container class for data store configurations and runtime parameters.
 * This class provides a convenient wrapper around a Map to store and retrieve
 * data store specific parameters with type-safe access methods.
 *
 * <p>The class uses a ParamMap internally which provides case format conversion
 * between camelCase and snake_case parameter names for flexible parameter access.