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

	dstSetupFn     func(t framework.TestContext, to echo.Target) error
)

// Setup runs the given function in the source deployment context.
//
// For example, given apps a, b, and c in 2 clusters,
// these tests would all run before the context is cleaned up:
//   - a/to_b/from_cluster-1
//   - a/to_b/from_cluster-2
//   - a/to_c/from_cluster-1
//   - a/to_c/from_cluster-2
//   - cleanup...

func GetMatchingPaths(config *config.BugReportConfig, cluster *cluster2.Resources) ([]string, error) {
	paths, err := getMatchingPathsForSpec(config, cluster)
	if err != nil {
		return nil, err
	}
	return sets.SortedList(paths), nil
}

func getMatchingPathsForSpec(config *config.BugReportConfig, cluster *cluster2.Resources) (sets.String, error) {
	return getMatchingPathsForSpecImpl(config, cluster, cluster.Root, nil, sets.New[string]())
}

)

// 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 {

		"SystemNamespace": systemNamespace,
	})
}

// IntermediateCA is an intermediate CA for a single cluster.
type Intermediate struct {
	KeyFile  string
	ConfFile string
	CSRFile  string
	CertFile string
	Root     Root
}

// NewIntermediate creates a new intermediate CA for the given cluster.
func NewIntermediate(workDir, config string, root Root) (Intermediate, error) {
	ca := Intermediate{

// 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
}