networkManager: &networkManager{
					clusterID: c.ctl.cluster,
					network:   c.ctl.network,
				},
				opts: Options{ClusterID: c.ctl.cluster},
			}
			eb := cc.NewEndpointBuilderFromMetadata(c.proxy)

			assert.Equal(t, eb.labels, c.expected)
		})
	}
}

type testController struct {
	locality string
	cluster  cluster2.ID
	network  network.ID

	framework.NewTest(t).
		Run(func(t framework.TestContext) {
			testNS := apps.EchoNamespace.Namespace

			t.ConfigIstio().YAML(testNS.Name(), POLICY).ApplyOrFail(t)

			for _, cluster := range t.Clusters() {
				t.NewSubTest(fmt.Sprintf("From %s", cluster.StableName())).Run(func(t framework.TestContext) {
					verify := func(ctx framework.TestContext, from echo.Instance, to echo.Instances, s scheme.Instance, success bool) {
						want := "success"

		labelSelector: cfg.LabelSelector,
		env:           ctx.Environment().(*kube.Environment),
		cluster:       ctx.Clusters().GetOrDefault(cfg.Cluster),
		caller:        common.NewCaller(),
	}
	return c
}

type ingressImpl struct {
	service       types.NamespacedName
	labelSelector string

	env     *kube.Environment
	cluster cluster.Cluster
	caller  *common.Caller
}

func (c *ingressImpl) Close() error {

apiVersion: release-notes/v2
kind: feature
area: traffic-management

releaseNotes:
- |
  **Added** an experimental feature to enable cluster creation on worker threads inline during requests.
  This will save memory and CPU cycles in cases where there are lots of inactive clusters and > 1 worker thread.

		ctx:    ctx,
	}
	id := ctx.TrackResource(n)
	n.id = id

	if err := n.forEachCluster(func(_ int, c cluster.Cluster) error {
		return n.createInCluster(c, cfg)
	}); err != nil {
		return nil, err
	}

	return n, nil
}

func (n *kubeNamespace) createInCluster(c cluster.Cluster, cfg Config) error {
	if _, err := c.Kube().CoreV1().Namespaces().Create(context.TODO(), &corev1.Namespace{

CreateVerifyClusteringPass();

// Creates a pass that forms clusters from operations of the same
// `_replication_info` attribute.
std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>>
CreateTPUClusterFormationPass(bool strict_clusters = false);

// Creates a pass that extracts outside compilation (Host ops inside device
// cluster) at head/tail of Device cluster to run before/after XLA computation.

func (a *KubeJWTAuthenticator) getKubeClient(clusterID cluster.ID) kubernetes.Interface {
	// first match local/primary cluster
	// or if clusterID is not sent (we assume that its a single cluster)
	if a.clusterID == clusterID || clusterID == "" {
		return a.kubeClient
	}

	// secondly try other remote clusters
	if a.remoteKubeClientGetter != nil {
		if res := a.remoteKubeClientGetter(clusterID); res != nil {
			return res
		}
	}

          // we see more cases needing cluster scoping in the future.
          /*edge_filter=*/nullptr);
}

// This preserves the parallelism between pipeline stages.  For example, below
// is a typical pattern of input pipelining in Tensorflow and this heuristic
// ensures Node_X and Node_Y are put into different clusters.  Without the
// heuristic, they may be put into the same cluster and it can introduce

		// Compare if service has mixed mode like headless and clusterIP
		if !addedHeadless && (firstService.ClusterIP == corev1.ClusterIPNone) != (service.ClusterIP == corev1.ClusterIPNone) {
			addedHeadless = true
			for c := range services {
				inconsistentClusters.Insert(c.String())
			}
			inconsistentReasons.Insert("service has mixed mode like headless and clusterIP")
		}

		// Compare service types

    {{ else }}
      "id": "projects/{{ .gcp_project_number }}/networks/default/nodes/{{ .nodeID}}",
    {{ end }}
    "cluster": "{{ .cluster }}",
    "locality": {
      {{ if .region }}
      "region": "{{ .region }}",
      {{ end }}
      {{ if .zone }}
      "zone": "{{ .zone }}",
      {{ end }}
      {{ if .sub_zone }}