// controlPlaneTopology maps each cluster to the cluster that runs its control plane. For replicated control
	// plane cases (where each cluster has its own control plane), the cluster will map to itself (e.g. 0->0).
	controlPlaneTopology clusterTopology

	// networkTopology is used for the initial assignment of networks to each cluster.
	// The source of truth clusters' networks is the Cluster instances themselves, rather than this field.

	subsetClusters := b.applyDestinationRule(defaultCluster)
	out := make([]*cluster.Cluster, 0, 1+len(subsetClusters))
	if defaultCluster != nil {
		out = append(out, defaultCluster)
	}
	return append(out, subsetClusters...)
}

// edsCluster creates a simple cluster to read endpoints from ads/eds.
func edsCluster(name string) *cluster.Cluster {
	return &cluster.Cluster{
		Name:                 name,

			}
			gatewayAddresses := map[string]gwAddr{}
			for _, cluster := range t.Clusters() {
				if _, ok := gatewayAddresses[cluster.NetworkName()]; ok {
					continue
				}
				ips, ports := i.EastWestGatewayFor(cluster).AddressesForPort(15443)
				if ips != nil {
					gatewayAddresses[cluster.NetworkName()] = gwAddr{ips[0], ports[0]}
				}
			}
			if len(t.Clusters().Networks()) != len(gatewayAddresses) {

	CreateTmpDirectory(prefix string) (string, error)

	// ConfigKube returns a Context that writes config to the provided clusters. If
	// no clusters are provided, writes to all clusters in the mesh.
	ConfigKube(clusters ...cluster.Cluster) config.Factory

	// ConfigIstio returns a Context that writes config to all Istio config clusters.
	ConfigIstio() config.Factory

	// RecordTraceEvent records an event. This is later saved to trace.yaml for analysis

				ctx.Skipf("no gateway for %s", fromCluster.StableName())
			}
			testFn(ctx, gwIngress, dst)
		}
		if len(ctx.Clusters()) == 1 {
			doTest(ctx, ctx.Clusters()[0], dstInstances)
		} else {
			t.fromEachCluster(ctx, func(ctx framework.TestContext, c cluster.Cluster) {
				doTest(ctx, c, dstInstances)
			})
		}
	})
}

func (t *T) RunViaIngress(testFn ingressTest) {

		}
		getClusterResourcesCancel()
	}()
	resources, err := cluster2.GetClusterResources(clusterResourcesCtx, clientset, config)
	if err != nil {
		return err
	}
	logRuntime(curTime, "Done collecting cluster resource")

	dumpRevisionsAndVersions(ctx, resources, config.IstioNamespace, config.DryRun)

	log.Infof("Cluster resource tree:\n\n%s\n\n", resources)

	return c.api[c.clusters.Default().Name()]
}

func (c *kubeComponent) APIForCluster(cluster cluster.Cluster) prometheusApiV1.API {
	return c.api[cluster.Name()]
}

func (c *kubeComponent) RawQuery(cluster cluster.Cluster, promQL string) (model.Value, error) {
	scopes.Framework.Debugf("Query running: %s", promQL)

	v, _, err := c.api[cluster.Name()].Query(context.Background(), promQL, time.Now())

type configFactory struct {
	ctx      resource.Context
	clusters []cluster.Cluster
	prefix   string
}

func newConfigFactory(ctx resource.Context, clusters cluster.Clusters) config.Factory {
	if len(clusters) == 0 {
		clusters = ctx.Clusters()
	}
	return &configFactory{
		ctx:      ctx,
		clusters: clusters,
	}
}

// GlobalYAMLWrites records how many YAMLs we have applied from all sources.

type Environment interface {
	Resource

	EnvironmentName() string

	// Clusters in this Environment. There will always be at least one.
	Clusters() cluster.Clusters

	// AllClusters in this Environment, including external control planes.
	AllClusters() cluster.Clusters
	IsMultiCluster() bool
	IsMultiNetwork() bool

		// upstream cluster will use HTTP 1.1, if incoming traffic use HTTP2,
		// the upstream cluster will use HTTP2.
		cb.setUseDownstreamProtocol(cluster)
	}
}

// normalizeClusters normalizes clusters to avoid duplicate clusters. This should be called
// at the end before adding the cluster to list of clusters.
func (cb *ClusterBuilder) normalizeClusters(clusters []*discovery.Resource) []*discovery.Resource {