}
			cds, lds, eds, rds, ecds := getSyncStatus(&clientConfig)
			cp := multixds.CpInfo(dr)
			fullStatus = append(fullStatus, &xdsWriterStatus{
				proxyID:               clientConfig.GetNode().GetId(),
				clusterID:             meta.ClusterID.String(),
				istiodID:              cp.ID,
				istiodVersion:         meta.IstioVersion,
				clusterStatus:         cds,
				listenerStatus:        lds,
				routeStatus:           rds,

JC <******@****.***> 1706895400 -0800

		"Reduced redundancy storage class parity")
	configStandardParityMD = NewGaugeMD(configStandardParity,
		"Standard storage class parity")
)

// loadClusterConfigMetrics - `MetricsLoaderFn` for cluster config
// such as standard and RRS parity.
func loadClusterConfigMetrics(ctx context.Context, m MetricValues, c *metricsCache) error {
	clusterDriveMetrics, err := c.clusterDriveMetrics.Get()
	if err != nil {

	return sa, nil
}

type fakeClientImpl struct {
	kube.CLIClient
	clusterID cluster.ID
}

func (f *fakeClientImpl) ClusterID() cluster.ID {
	return f.clusterID
}

func addStore(sa *local.IstiodAnalyzer, clusterName string, yamls []string) error {
	client := &fakeClientImpl{
		CLIClient: kube.NewFakeClient(),
		clusterID: cluster.ID(clusterName),
	}
	// Gather test files

      cluster.constraints = std::move(member.constraints);

    // Add operation to the cluster.
    if (auto op = member.source.dyn_cast<Operation *>())
      cluster.operations.emplace_back(op);
  }

  llvm::SmallVector<Cluster> clusters;
  for (auto &kv : root_clusters) {
    Cluster &cluster = kv.getSecond();
    // Skip degenerate clusters formed by a single basic block argument.

	proxyClusterSecrets, err := s.secrets.ForCluster(proxy.Metadata.ClusterID)
	if err != nil {
		log.Warnf("proxy %s is from an unknown cluster, cannot retrieve certificates: %v", proxy.ID, err)
		pilotSDSCertificateErrors.Increment()
		return nil, model.DefaultXdsLogDetails, nil
	}
	configClusterSecrets, err := s.secrets.ForCluster(s.configCluster)
	if err != nil {

// reads ServiceImport in the cluster in order to extract the ClusterSet VIP and generate a
// synthetic service for the MCS host (i.e. clusterset.local). The aggregate.Controller will then
// merge together the MCS services from all the clusters, filling out the full map of Cluster IPs.
//
// The synthetic MCS service is a copy of the real k8s Service (e.g. cluster.local) with the same

		"Count of offline drives in the cluster")
	healthDrivesOnlineCountMD = NewGaugeMD(healthDrivesOnlineCount,
		"Count of online drives in the cluster")
	healthDrivesCountMD = NewGaugeMD(healthDrivesCount,
		"Count of all drives in the cluster")
)

// loadClusterHealthDriveMetrics - `MetricsLoaderFn` for cluster storage drive metrics
// such as online, offline and total drives.

)

// loadClusterNotificationMetrics - `MetricsLoaderFn` for cluster notification metrics.
func loadClusterNotificationMetrics(_ context.Context, m MetricValues, _ *metricsCache) error {
	if globalEventNotifier == nil {
		return nil
	}

	nstats := globalEventNotifier.targetList.Stats()

{{- end }}
{{- end }}
spec:
{{- if .IPFamilies }}
  ipFamilies: [ {{ .IPFamilies }} ]
{{- end }}
{{- if .IPFamilyPolicy }}
  ipFamilyPolicy: {{ .IPFamilyPolicy }}
{{- end }}
{{- if .Headless }}
  clusterIP: None
{{- end }}
  ports:
{{- range $i, $p := .ServicePorts }}
  - name: {{ $p.Name }}
    port: {{ $p.ServicePort }}
    targetPort: {{ $p.WorkloadPort }}
{{- end }}
  selector: