): Headers.Builder = builder.addLenient(line)

internal fun addHeaderLenient(
  builder: Headers.Builder,
  name: String,
  value: String,
): Headers.Builder = builder.addLenient(name, value)

internal fun cacheGet(
  cache: Cache,
  request: Request,
): Response? = cache.get(request)

internal fun applyConnectionSpec(
  connectionSpec: ConnectionSpec,
  sslSocket: SSLSocket,
  isFallback: Boolean,

    public Key createKey(Plugin plugin, List<RemoteRepository> repositories, RepositorySystemSession session) {
        return keys.computeIfAbsent(new CacheKey(plugin, repositories, session), k -> k);
    }

    @Override
    public PluginDescriptor get(Key cacheKey) {
        return clone(descriptors.get(cacheKey));
    }

    @Override
    public PluginDescriptor get(Key key, PluginDescriptorSupplier supplier)

        assertNotSame(lr1, lr2);
        assertNotSame(rr1, rr2);

        DefaultMavenMetadataCache.CacheKey k1 =
                new DefaultMavenMetadataCache.CacheKey(a1, false, lr1, Collections.singletonList(rr1));
        DefaultMavenMetadataCache.CacheKey k2 =
                new DefaultMavenMetadataCache.CacheKey(a2, false, lr2, Collections.singletonList(rr2));

        assertEquals(k1.hashCode(), k2.hashCode());
    }

import org.eclipse.aether.repository.WorkspaceRepository;

/**
 */
@Named
@Singleton
public class DefaultPluginArtifactsCache implements PluginArtifactsCache {
    /**
     * CacheKey
     */
    protected static class CacheKey implements Key {
        private final Plugin plugin;

        private final WorkspaceRepository workspace;

        private final LocalRepository localRepo;

 */
class ReactorModelPool {

    private final Map<CacheKey, File> pomFiles = new HashMap<>();

    public File get(String groupId, String artifactId, String version) {
        return pomFiles.get(new CacheKey(groupId, artifactId, version));
    }

    public void put(String groupId, String artifactId, String version, File pomFile) {
        pomFiles.put(new CacheKey(groupId, artifactId, version), pomFile);
    }

 * Default PluginCache implementation. Assumes cached data does not change.
 */
@Named
@Singleton
public class DefaultPluginRealmCache implements PluginRealmCache, Disposable {
    /**
     * CacheKey
     */
    protected static class CacheKey implements Key {

        private final Plugin plugin;

        private final WorkspaceRepository workspace;

        private final LocalRepository localRepo;

@Named
@Singleton
public class DefaultProjectRealmCache implements ProjectRealmCache, Disposable {
    /**
     * CacheKey
     */
    protected static class CacheKey implements Key {

        private final List<? extends ClassRealm> extensionRealms;

        private final int hashCode;

        public CacheKey(List<? extends ClassRealm> extensionRealms) {
            this.extensionRealms =

    /**
     * CacheKey
     */
    protected static class CacheKey implements Key {

        private final List<File> files;

        private final List<Long> timestamps;

        private final List<Long> sizes;

        private final List<String> ids;

        private final int hashCode;

        public CacheKey(List<Artifact> extensionArtifacts) {

import org.eclipse.aether.repository.WorkspaceRepository;

/**
 */
@Named
@Singleton
public class DefaultProjectArtifactsCache implements ProjectArtifactsCache {
    /**
     * CacheKey
     */
    protected static class CacheKey implements Key {

        private final String groupId;

        private final String artifactId;

        private final String version;

  override fun satisfactionFailure(
    call: Call,
    response: Response,
  ) {
    logWithTime("satisfactionFailure: $response")
  }

  override fun cacheHit(
    call: Call,
    response: Response,
  ) {
    logWithTime("cacheHit: $response")
  }

  override fun cacheMiss(call: Call) {
    logWithTime("cacheMiss")
  }

  override fun cacheConditionalHit(
    call: Call,