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

// loadClusterIAMMetrics - `MetricsLoaderFn` for cluster IAM metrics.

if [ "$#" == 0 ]; then
    echo "usage: $0 <api_dir>..."
    exit 1
fi

kube::protoc::check_protoc

for api; do
    # This can't use `git ls-files` because it runs in a container without the
    # .git dir synced.
    protos=()
    kube::util::read-array protos < <( \
        find "${api}" -type f -name "api.proto")

    if [ "${#protos[@]}" == 0 ]; then
        echo "ERROR: no 'api.proto' files under '${api}'"
        exit 1

	//   and the bookmark event is send when the state is synced
	//   to a `resourceVersion` at least as fresh as the one provided by the ListOptions.
	//   If `resourceVersion` is unset, this is interpreted as "consistent read" and the
	//   bookmark event is send when the state is synced at least to the moment
	//   when request started being processed.

 */

package org.gradle.api.internal.artifacts.ivyservice.ivyresolve.strategy;

import org.gradle.util.internal.VersionNumber;

/**
 * A parsed version.
 *
 * This should be synced with {@link VersionNumber} and {@link org.gradle.util.GradleVersion} at some point.
 */
public interface Version {
    /**
     * Returns the original {@link String} representation of the version.
     */

	if fv.LessThan(mv) {
		log.Infof("CRD %v version %v is below minimum version %v, ignoring", crd.Name, fv, mv)
		return false
	}
	return true
}

// HasSynced returns whether the underlying cache has synced and the callback has been called at least once.
func (c *crdWatcher) HasSynced() bool {
	return c.queue.HasSynced()
}

// Run starts the controller. This must be called.

Laura Kassovic <******@****.***> 1701107622 -0800

// registerHandlerAsBatched is a helper to register the provided handler as a batched handler. This allows collections to
// only implement RegisterBatch.
func registerHandlerAsBatched[T any](c internalCollection[T], f func(o Event[T])) Syncer {
	return c.RegisterBatch(func(events []Event[T], initialSync bool) {
		for _, o := range events {
			f(o)
		}
	}, true)
}

// castEvent converts an Event[I] to Event[O].

	_ = x[SyncFuncExt-30]
	_ = x[SyncVarExt-31]
	_ = x[SyncTypeExt-32]
	_ = x[SyncPragma-33]
	_ = x[SyncExprList-34]
	_ = x[SyncExprs-35]
	_ = x[SyncExpr-36]
	_ = x[SyncExprType-37]
	_ = x[SyncAssign-38]
	_ = x[SyncOp-39]
	_ = x[SyncFuncLit-40]
	_ = x[SyncCompLit-41]
	_ = x[SyncDecl-42]
	_ = x[SyncFuncBody-43]
	_ = x[SyncOpenScope-44]
	_ = x[SyncCloseScope-45]
	_ = x[SyncCloseAnotherScope-46]
	_ = x[SyncDeclNames-47]

	key, quit := q.queue.Get()
	if quit {
		// We are done, signal to exit the queue
		return false
	}

	// We got the sync signal. This is not a real event, so we exit early after signaling we are synced
	if key == defaultSyncSignal {
		q.log.Debugf("synced")
		q.initialSync.Store(true)
		return true
	}

	q.log.Debugf("handling update: %v", formatKey(key))

func (m *InformerManager) GetTrustAnchorsByName(name string, allowMissing bool) ([]byte, error) {
	if !m.ctbInformer.HasSynced() {
		return nil, fmt.Errorf("ClusterTrustBundle informer has not yet synced")
	}

	cacheKey := cacheKeyType{ctbName: name}

	if cachedAnchors, ok := m.normalizationCache.Get(cacheKey); ok {
		return cachedAnchors.([]byte), nil
	}

	ctb, err := m.ctbLister.Get(name)