/**
     * Adds an entry task to the execution plan. If called multiple times then execution plan follows the method invocation order.
     *
     */
    void addEntryTask(Task task);

    /**
     * Adds entry tasks to the execution plan. No ordering can be assumed between the elements of the target collection. If called multiple times then execution plan follows the method invocation order.
     */

// limitations under the License.

package model

import (
	core "github.com/envoyproxy/go-control-plane/envoy/config/core/v3"
	rbacpb "github.com/envoyproxy/go-control-plane/envoy/config/rbac/v3"
	routepb "github.com/envoyproxy/go-control-plane/envoy/config/route/v3"
	matcher "github.com/envoyproxy/go-control-plane/envoy/type/matcher/v3"
)

func principalAny() *rbacpb.Principal {
	return &rbacpb.Principal{

type ControlPlaneOptions struct {
	// Revision is the istio.io/rev control plane revision
	Revision string
}

// AttachControlPlaneFlags attaches control-plane flags to a Cobra command.
// (Currently just --revision)
func (o *ControlPlaneOptions) AttachControlPlaneFlags(cmd *cobra.Command) {
	cmd.PersistentFlags().StringVarP(&o.Revision, "revision", "r", "",
		"Control plane revision")

# 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 :

kube-system        coredns-5dd5756b68-mgjn9                             10.244.0.2  ambient-control-plane None                                TCP
kube-system        coredns-5dd5756b68-nzlpw                             10.244.0.3  ambient-control-plane None                                TCP
local-path-storage local-path-provisioner-6f8956fb48-vvnpn              10.244.0.4  ambient-control-plane None                                TCP

    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
            }

apiVersion: release-notes/v2
kind: bug-fix
area: istioctl
releaseNotes:
  - |

    /**
     * Returns the node for the supplied task that is part of this execution plan.
     *
     * @throws IllegalStateException When no node for the supplied task is part of this execution plan.
     */
    TaskNode getNode(Task task);

    /**
     * Returns the number of work items in the plan.
     */
    int size();

    /**
     * An immutable snapshot of the set of scheduled nodes.
     */

	ControllerManagerExtraArgs = "controller-manager-extra-args"

	// ControlPlaneEndpoint flag sets a stable IP address or DNS name for the control plane.
	ControlPlaneEndpoint = "control-plane-endpoint"

	// DryRun flag instructs kubeadm to don't apply any changes; just output what would be done.
	DryRun = "dry-run"

// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build !plan9
// +build !plan9

package main

// void start(void);
import "C"

func init() {
	register("CgoExternalThreadPanic", CgoExternalThreadPanic)
}

func CgoExternalThreadPanic() {
	C.start()
	select {}
}

//export gopanic
func gopanic() {