* @param execution a execution object.
     */
    public void removeExecution(Execution execution) {
        getExecutions().remove(execution);
    } // -- void removeExecution( Execution )

    /**
     * Set configuration to pass to all goals run in this phase.
     *
     * @param configuration a configuration object.
     */
    public void setConfiguration(Object configuration) {
        this.configuration = configuration;

```

////

Now the client will get the same *HTTP 500 Internal Server Error* response, but the server will have our custom `InternalError` in the logs. 😎

## Execution of dependencies with `yield`

The sequence of execution is more or less like this diagram. Time flows from top to bottom. And each column is one of the parts interacting or executing code.

```mermaid
sequenceDiagram

        </field>
        <field>
          <name>executions</name>
          <version>1.0.0+</version>
          <description>The goals to execute within the phase.</description>
          <association>
            <type>Execution</type>
            <multiplicity>*</multiplicity>
          </association>
        </field>
        <field>
          <name>configuration</name>

// Creates a new TensorFlow function. A Function is an execution context, and as
// such it can trace operations through TF_ExecuteOperation. After completing
// tracing, a function can be obtained by TF_FinalizeFunction.
TF_ExecutionContext* TF_CreateFunction(const char* fn_name, TF_Status* status);

// Creates a context for eager execution of operations.
TF_ExecutionContext* TF_NewEagerExecutionContext(TFE_ContextOptions*,

  protected AbstractExecutionThreadService() {}

  /**
   * Start the service. This method is invoked on the execution thread.
   *
   * <p>By default this method does nothing.
   */
  protected void startUp() throws Exception {}

  /**
   * Run the service. This method is invoked on the execution thread. Implementations must respond
   * to stop requests. You could poll for lifecycle changes in a work loop:
   *

# Exécuter un serveur manuellement - Uvicorn

La principale chose dont vous avez besoin pour exécuter une application **FastAPI** sur une machine serveur distante est un programme serveur ASGI tel que **Uvicorn**.

Il existe 3 principales alternatives :

* <a href="https://www.uvicorn.org/" class="external-link" target="_blank">Uvicorn</a> : un serveur ASGI haute performance.

import org.apache.maven.execution.BuildResumptionAnalyzer;
import org.apache.maven.execution.BuildResumptionDataRepository;
import org.apache.maven.execution.BuildResumptionPersistenceException;
import org.apache.maven.execution.DefaultMavenExecutionResult;
import org.apache.maven.execution.ExecutionEvent;
import org.apache.maven.execution.MavenExecutionRequest;
import org.apache.maven.execution.MavenExecutionResult;

# Tâches d'arrière-plan

Vous pouvez définir des tâches d'arrière-plan qui seront exécutées après avoir retourné une réponse.

Ceci est utile pour les opérations qui doivent avoir lieu après une requête, mais où le client n'a pas réellement besoin d'attendre que l'opération soit terminée pour recevoir une réponse.

Cela comprend, par exemple :

* Les notifications par email envoyées après l'exécution d'une action :

        if (delegate.isDone()) {
          // If the delegate is already done, run the execution list immediately on the current
          // thread.
          executionList.execute();
          return;
        }

        // TODO(lukes): handle RejectedExecutionException
        adapterExecutor.execute(
            () -> {
              try {
                /*

            Defines a default phase to bind a Mojo execution to if the user does not explicitly set a phase in the POM.
            <p><b>Note:</b> This will not automagically make a Mojo run when the plugin declaration is added
            to the POM. It merely enables the user to omit the {@code <phase>} element from the
            surrounding {@code <execution>} element.</p>
          </description>
        </field>