import okhttp3.Call
import okhttp3.Callback
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.Response

class AsynchronousGet {
  private val client = OkHttpClient()

  fun run() {
    val request =
      Request
        .Builder()
        .url("http://publicobject.com/helloworld.txt")
        .build()

    client.newCall(request).enqueue(
      object : Callback {
        override fun onFailure(

                        });
    }

    /**
     * Creates a search condition for the OpenSearch request.
     *
     * @param query the search query string
     * @param params the search request parameters
     * @param userBean the optional user bean for access control
     * @return the search condition for the request
     */

     * Get the value for the key 'rate.limit.requests.per.window'. <br>
     * The value is, e.g. 100 <br>
     * comment: Maximum number of requests allowed per window.
     * @return The value of found property. (NotNull: if not found, exception but basically no way)
     */
    String getRateLimitRequestsPerWindow();

    /**
     * Get the value for the key 'rate.limit.requests.per.window' as {@link Integer}. <br>

	public static synthetic fun delete$default (Lokhttp3/Request$Builder;Lokhttp3/RequestBody;ILjava/lang/Object;)Lokhttp3/Request$Builder;
	public fun get ()Lokhttp3/Request$Builder;
	public final fun gzip ()Lokhttp3/Request$Builder;
	public fun head ()Lokhttp3/Request$Builder;
	public fun header (Ljava/lang/String;Ljava/lang/String;)Lokhttp3/Request$Builder;
	public fun headers (Lokhttp3/Headers;)Lokhttp3/Request$Builder;

     * for the specified servlet request.
     *
     * @param tc the CIFS context to use
     *
     * @param req
     *            The request being serviced.
     * @param resp
     *            The response.
     * @param challenge
     *            The domain controller challenge.
     * @return credentials passed in the servlet request
     * @throws IOException

A "middleware" is a function that works with every **request** before it is processed by any specific *path operation*. And also with every **response** before returning it.

* It takes each **request** that comes to your application.
* It can then do something to that **request** or run any needed code.
* Then it passes the **request** to be processed by the rest of the application (by some *path operation*).

Ce risque et cette attaque sont surtout pertinents lorsque l’application s’exécute sur le réseau local et que c’est la seule protection supposée.

## Autoriser les requêtes sans Content-Type { #allowing-requests-without-content-type }

Si vous devez prendre en charge des clients qui n’envoient pas d’en-tête `Content-Type`, vous pouvez désactiver la vérification stricte en définissant `strict_content_type=False` :

	flag.DurationVar(&expiryDuration, "e", 0, "Request a duration of validity for the generated credential")
	flag.StringVar(&bucketToList, "b", "", "Bucket to list (defaults to username)")
	flag.StringVar(&sessionPolicyFile, "s", "", "File containing session policy to apply to the STS request")
}

func main() {
	flag.Parse()
	if minioUsername == "" || minioPassword == "" {

	"github.com/minio/minio/internal/pubsub"
)

// TraceParamsKey allows to pass trace parameters to the request via context.
// This is only needed when un-typed requests are used.
// MSS, map[string]string types are preferred, but any struct with exported fields will work.
type TraceParamsKey struct{}

// traceRequests adds request tracing to the connection.
func (c *Connection) traceRequests(p *pubsub.PubSub[madmin.TraceInfo, madmin.TraceType]) {

        assertNotNull(builder);

        DefaultSettingsBuildingRequest request = new DefaultSettingsBuildingRequest();
        request.setSystemProperties(System.getProperties());
        request.setUserSettingsFile(getSettings("simple"));

        SettingsBuildingResult result = builder.build(request);
        assertNotNull(result);
        assertNotNull(result.getEffectiveSettings());
    }