//   that will run on unknown devices (because the unknown XLA backend may not
//   support every operation supported by CPU).
// - Let BuildXlaOpsPass successfully infer a compilation device for a cluster
//   that contains nodes placed on both the CPU and on unknown devices.  In this
//   case it is the responsibility of the optimization pass that injected the

	}
	return workloads, waypointServices
}

// filterWaypointOutboundServices is used to determine the set of outbound clusters we need to build for waypoints.
// Waypoints typically only have inbound clusters, except in cases where we have a route from
// a service owned by the waypoint to a service not owned by the waypoint.
// It looks at:

	comp := m.constructor(cluster)
	m.mu.Lock()
	defer m.mu.Unlock()
	m.clusters[cluster.ID] = comp
	return comp
}

func (m *Component[T]) clusterUpdated(cluster *Cluster) ComponentConstraint {
	// Build outside of the lock, in case its slow
	comp := m.constructor(cluster)
	old, f := m.clusters[cluster.ID]
	m.mu.Lock()
	m.clusters[cluster.ID] = comp
	m.mu.Unlock()

spec:
  gateways: [missing-gw]
  hosts:
  - reviews
  http:
  - route:
    - destination:
        host: reviews
`).ApplyOrFail(t)
			istioCtl := istioctl.NewOrFail(t, t, istioctl.Config{Cluster: t.Clusters().Default()})
			istioCtl.InvokeOrFail(t, []string{"x", "wait", "-v", "VirtualService", "reviews." + ns.Name()})
		})
}

func TestAnalysisWritesStatus(t *testing.T) {
	// nolint: staticcheck

	syncSuccessesMD                          = NewCounterMD(syncSuccesses, "Number of successful IAM data syncs since server start.")
)

// loadClusterIAMMetrics - `MetricsLoaderFn` for cluster IAM metrics.
func loadClusterIAMMetrics(_ context.Context, m MetricValues, _ *metricsCache) error {
	m.Set(lastSyncDurationMillis, float64(atomic.LoadUint64(&globalIAMSys.LastRefreshDurationMilliseconds)))

	usageTotalBytesMD = NewGaugeMD(usageTotalBytes,
		"Total cluster usage in bytes")
	usageObjectsCountMD = NewGaugeMD(usageObjectsCount,
		"Total cluster objects count")
	usageVersionsCountMD = NewGaugeMD(usageVersionsCount,
		"Total cluster object versions (including delete markers) count")
	usageDeleteMarkersCountMD = NewGaugeMD(usageDeleteMarkersCount,
		"Total cluster delete markers count")
	usageBucketsCountMD = NewGaugeMD(usageBucketsCount,

issue:
- https://github.com/istio/enhancements/issues/173
releaseNotes:
- |

)

// Controller maintains a timestamp value configmap `kube-apiserver-legacy-service-account-token-tracking`
// in `kube-system` to indicates if the tracking for legacy tokens is enabled in
// the cluster. For HA clusters, the configmap will be eventually created after
// all controller instances have enabled the feature. When disabling this
// feature, existing configmap will be deleted.
type Controller struct {

// to extract kube context
type Filenamer interface {
	Filename() string
}

func newKube(ctx resource.Context, config Config) (Instance, error) {
	fn, ok := ctx.Clusters().GetOrDefault(config.Cluster).(Filenamer)
	if !ok {
		return nil, fmt.Errorf("cluster does not support fetching kube config")
	}
	n := &kubeComponent{
		config:     config,
		kubeconfig: fn.Filename(),
	}

	return n, nil
}

	}
	return f.Name
}

func (f FakeEnvironment) AllClusters() cluster.Clusters {
	res := cluster.Clusters{}
	allClusters := make(cluster.Map)

	for i := 0; i < f.NumClusters; i++ {
		topo := cluster.NewTopology(cluster.Config{
			Name:               fmt.Sprintf("cluster-%d", i),
			PrimaryClusterName: fmt.Sprintf("cluster-%d", i),
			ConfigClusterName:  fmt.Sprintf("cluster-%d", i),
		}, allClusters)
		c := &kube.Cluster{Topology: topo}