<span style="color: green;">INFO</span>:     Waiting for application startup.
<span style="color: green;">INFO</span>:     Application startup complete.
```

</div>

/// note

La commande `uvicorn main:app` fait référence à :

* `main` : le fichier `main.py` (le module Python).
* `app` : l'objet créé dans `main.py` via la ligne `app = FastAPI()`.

```

In a given setup, there are `n` MinIO instances talking to `m` KES servers but only `1` central KMS. The most simple setup consists of `1` MinIO server or cluster talking to `1` KMS via `1` KES server.

The main difference between various MinIO-KMS deployments is the KMS implementation. The following table helps you select the right option for your use case:

          <version>1.0.0+</version>
          <type>String</type>
          <description>Reference the invocation phase of the Mojo.</description>
        </field>
        <field>
          <name>executeGoal</name>
          <version>1.0.0+</version>
          <type>String</type>
          <description>Reference the invocation goal of the Mojo.</description>
        </field>
        <field>

		References: []Reference{
			{"Refer", "User", "UserReferID", "user_profiles", "", true},
			{"UserRefer", "Profile", "ProfileRefer", "user_profiles", "", false},
		},
	}, Relation{
		Name: "Profiles2", Type: schema.Many2Many, Schema: "User", FieldSchema: "Profile",
		JoinTable: JoinTable{Name: "user_profiles2", Table: "user_profiles2"},
		References: []Reference{

/** Implementation of an {@link Optional} containing a reference. */
@GwtCompatible
final class Present<T> extends Optional<T> {
  private final T reference;

  Present(T reference) {
    this.reference = reference;
  }

  @Override
  public boolean isPresent() {
    return true;
  }

  @Override
  public T get() {
    return reference;
  }

  @Override
  public T or(T defaultValue) {

platforms/documentation/docs/src/docs/userguide/reference/core-plugins/distribution_plugin.adoc         @gradle/bt-docs-reviewers @gradle/bt-jvm
platforms/documentation/docs/src/docs/userguide/reference/core-plugins/ear_plugin.adoc                  @gradle/bt-docs-reviewers @gradle/bt-jvm

   */
  private boolean finalizeReference(Reference<?> reference, Method finalizeReferentMethod) {
    /*
     * This is for the benefit of phantom references. Weak and soft references will have already
     * been cleared by this point.
     */
    reference.clear();

    if (reference == frqReference) {
      /*
       * The client no longer has a reference to the FinalizableReferenceQueue. We can stop.
       */

  public void testDifference_minSize() {
    assertMinSize(difference(emptySet(), emptySet()), 0);
    assertMinSize(difference(setSize(2), setSize(3)), 0);
    assertMinSize(difference(setSize(3), setSize(2)), 1);
    assertMinSize(difference(setSizeRange(10, 20), setSizeRange(1, 2)), 8);
    assertMinSize(difference(setSizeRange(1, 2), setSizeRange(10, 20)), 0);
    assertMinSize(difference(setSizeRange(10, 20), setSizeRange(11, 12)), 0);

        void executeAndCompare(ListIterator<E> reference, Iterator<E> target) {
          internalExecuteAndCompare(reference, target, NEXT_METHOD);
        }
      };
  Stimulus<E, Iterator<E>> remove =
      new Stimulus<E, Iterator<E>>("remove") {
        @Override
        void executeAndCompare(ListIterator<E> reference, Iterator<E> target) {
          internalExecuteAndCompare(reference, target, REMOVE_METHOD);
        }
      };

        Instant monotonic = MonotonicClock.now();
        Instant system = Instant.now();

        // The difference should be relatively small (allow for 1 second max)
        Duration difference = Duration.between(monotonic, system).abs();
        assertTrue(difference.getSeconds() <= 1, "Monotonic time should be reasonably aligned with system time");
    }