BuildPlan plan = calculateLifecycleMappings(projects, "all");
        assertNotNull(plan);
        assertIsSuccessor(plan.requiredStep(p, "before:all"), plan.requiredStep(p, "before:each"));
        assertIsSuccessor(plan.requiredStep(p, "before:all"), plan.requiredStep(c1, "before:all"));
        assertIsSuccessor(plan.requiredStep(p, "before:all"), plan.requiredStep(c2, "before:all"));

 */
class ForceConnectRoutePlanner(
  private val delegate: RealRoutePlanner,
) : RoutePlanner by delegate {
  override fun plan(): RoutePlanner.Plan = delegate.planConnect() // not delegate.plan()

        canceled -> {
          events += "plan $id TCP connect canceled"
          ConnectResult(this, nextPlan = connectTcpNextPlan, throwable = IOException("canceled"))
        }
        connectTcpNextPlan != null -> {
          events += "plan $id needs follow-up"
          ConnectResult(this, nextPlan = connectTcpNextPlan)
        }
        else -> {
          events += "plan $id TCP connected"

{* ../../docs_src/background_tasks/tutorial002.py hl[13,15,22,25] *}

Dans cet exemple, les messages seront écrits dans le fichier `log.txt` après que la réponse soit envoyée.

S'il y avait une `query` (paramètre nommé `q`) dans la requête, alors elle sera écrite dans `log.txt` via une tâche d'arrière-plan.

    while (true) {
      if (routePlanner.isCanceled()) throw IOException("Canceled")

      try {
        val plan = routePlanner.plan()

        if (!plan.isReady) {
          val tcpConnectResult = plan.connectTcp()
          val connectResult =
            when {
              tcpConnectResult.isSuccess -> plan.connectTlsEtc()
              else -> tcpConnectResult
            }

        // There is only a single threadsafe plugin here...
        assertEquals(plan.size() - 1, unSafePlugins.size());
    }

    @Test
    void testFindLastWhenFirst() throws Exception {
        MavenExecutionPlan plan = LifecycleExecutionPlanCalculatorStub.getProjectAExecutionPlan();

        ExecutionPlanItem beerPhase = plan.findLastInPhase(

    if (plan is FailedPlan) return plan.result

    // Connect TCP asynchronously.
    tcpConnectsInFlight += plan
    val taskName = "$okHttpName connect ${routePlanner.address.url.redact()}"
    taskRunner.newQueue().schedule(
      object : Task(taskName) {
        override fun runOnce(): Long {
          val connectResult =
            try {
              plan.connectTcp()

    fun handleSuccess(): RealConnection

    fun cancel()

    /**
     * Returns a plan to attempt if canceling this plan was a mistake! The returned plan is not
     * canceled, even if this plan is canceled.
     */
    fun retry(): Plan?
  }

  /**
   * What to do once a plan has executed.
   *
   * If [nextPlan] is not-null, another attempt should be made by following it. If [throwable] is

    public void writePlan(BuildPlan plan) {
        if (logger.isDebugEnabled()) {
            writePlan(logger::debug, plan);
        }
    }

    public void writePlan(BuildPlan plan, MavenProject project) {
        if (logger.isDebugEnabled()) {
            writePlan(logger::debug, plan, project);
        }
    }

    public void writePlan(Consumer<String> writer, BuildPlan plan) {

        final BuilderCommon builderCommon = getBuilderCommon(logger);
        final MavenExecutionPlan plan =
                builderCommon.resolveBuildPlan(session1, ProjectDependencyGraphStub.A, taskSegment1, new HashSet<>());
        assertEquals(
                LifecycleExecutionPlanCalculatorStub.getProjectAExecutionPlan().size(), plan.size());
    }

    @Test
    void testDefaultBindingPluginsWarning() throws Exception {