MavenExecutionRequest request = executionRequestPopulator.populateDefaults(cliRequest.request);
        request.setRepositoryCache(new DefaultRepositoryCache()); // reset caches

        if (cliRequest.request.getRepositoryCache() == null) {
            cliRequest.request.setRepositoryCache(new DefaultRepositoryCache());
        }

        eventSpyDispatcher.onEvent(request);

		newCache.buildUserGroupMemberships()
	}

	cache := store.lock()
	defer store.unlock()

	// We should only update the in-memory cache if there were no changes
	// to the in-memory cache since the disk loading began. If there
	// were changes to the in-memory cache we should wait for the next
	// cycle until we can safely update the in-memory cache.
	//
	// An in-memory cache must be replaced only if we know for sure that the

				err = msgp.WrapError(err, "Info")
				return
			}
		case "Cache":
			var zb0002 uint32
			zb0002, err = dc.ReadMapHeader()
			if err != nil {
				err = msgp.WrapError(err, "Cache")
				return
			}
			if z.Cache == nil {
				z.Cache = make(map[string]dataUsageEntry, zb0002)
			} else if len(z.Cache) > 0 {
				clear(z.Cache)
			}
			for zb0002 > 0 {
				zb0002--
				var za0001 string

			if err == nil {
				cache.Info.replication = replicationConfig{
					Config:  rcfg,
					remotes: tgts,
				}
			}
		}
	}

	// Check if bucket is object locked.
	lr, err := globalBucketObjectLockSys.Get(cache.Info.Name)
	if err != nil {
		scannerLogOnceIf(ctx, err, cache.Info.Name)
		return cache, err
	}

	vcfg, _ := globalBucketVersioningSys.Get(cache.Info.Name)

                /*
                 * NOTE: This is a sanity check of the cache hit. If the cached parent POM was locally resolved, the
                 * child's <relativePath> should point at that parent, too. If it doesn't, we ignore the cache and
                 * resolve externally, to mimic the behavior if the cache didn't exist in the first place. Otherwise,
                 * the cache would obscure a bad POM.
                 */

# Cache pushes are limited to TF's CI system.
common:tf_public_cache_push --config=tf_public_cache --remote_upload_local_results=true --google_default_credentials
# Public cache for macOS builds
common:tf_public_macos_cache --remote_cache="https://storage.googleapis.com/tensorflow-macos-bazel-cache/oct2023" --remote_upload_local_results=false

	// A src.Int63() generates 63 random bits, enough for letterIdxMax characters!
	for i, cache, remain := n-1, src.Int63(), letterIdxMax; i >= 0; {
		if remain == 0 {
			cache, remain = src.Int63(), letterIdxMax
		}
		if idx := int(cache & letterIdxMask); idx < len(letterBytes) {
			b[i] = letterBytes[idx]
			i--
		}
		cache >>= letterIdxBits
		remain--
	}

	return *(*string)(unsafe.Pointer(&b))
}

func (sys *IAMSys) getStoredLDAPPolicyMappingKeys(ctx context.Context, isGroup bool) set.StringSet {
	entityKeysInStorage := set.NewStringSet()
	cache := sys.store.rlock()
	defer sys.store.runlock()
	cachedPolicyMap := cache.iamSTSPolicyMap
	if isGroup {
		cachedPolicyMap = cache.iamGroupPolicyMap
	}
	cachedPolicyMap.Range(func(k string, v MappedPolicy) bool {
		entityKeysInStorage.Add(k)
		return true
	})

// that all buckets are present on all serverPools.
func (z *erasureServerPools) ListBuckets(ctx context.Context, opts BucketOptions) (buckets []BucketInfo, err error) {
	if opts.Cached {
		listBucketsCache.InitOnce(time.Second,
			cachevalue.Opts{ReturnLastGood: true, NoWait: true},
			func(ctx context.Context) ([]BucketInfo, error) {
				ctx, cancel := context.WithTimeout(ctx, 5*time.Second)

github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.9.0/go.mod h1:kUjrAo8bgEwLeZ/CmHqNl3Z/kPm7y6FKfxxK0izYUg4=
github.com/Azure/azure-sdk-for-go/sdk/azidentity/cache v0.3.2 h1:yz1bePFlP5Vws5+8ez6T3HWXPmwOK7Yvq8QxDBD3SKY=
github.com/Azure/azure-sdk-for-go/sdk/azidentity/cache v0.3.2/go.mod h1:Pa9ZNPuoNu/GztvBSKk9J1cDJW6vk/n0zLtV4mgd8N8=
github.com/Azure/azure-sdk-for-go/sdk/internal v1.11.1 h1:FPKJS1T+clwv+OLGt13a8UjqeRuh0O4SJ3lUriThc+4=