memcache

Got rid of separate in-memory caching layer for local repos

Local file repositories now use the regular `CachingModuleComponentRepository`,

but provide in-memory-only versions of the dependency resolution caches

in order to retain the current 'always-refresh' behaviour.

Remove old feature toggle for in-memory metadata caching

Provide in-memory caching for dependency caches

Instead of using a separate `InMemoryCachedModuleComponentRepository`

for in-memory caching of resolution from remote repositories, the

filesystem-backed cache implementations now each have a build-scoped

in-memory cache as well.

This provides more consistent caching behaviour, since any cache-expiry

logic is shared between in-memory and filesystem caches.

For file-backed repositories, we don't use the filesystem-backed cache,

so we continue to use `InMemoryCachedModuleComponentRepository` for

in-memory caching of resolved modules.

Note that this is only a partial fix, as it does not address the

incorrect caching of maven snapshot modules. This is due to the id-based

caching of resolved artifacts, and the fact that different maven

snapshot instances do not have a different unique identifier.

Javadoc for `ModuleComponentReposotory` types

Convert many uses of ModuleVersionSelector -> ModuleComponentSelector

- Uses of ModuleDependency.getRequested() to ModuleDependency.getSelector()

Added a new type `ResolveableArtifact` to use instead of public `ResolvedArtifact` when resolving and visiting the artifacts of a dependency resolution result.

Removed unnecessary synchronization, and use a consistent pattern to protect cached dependency metadata and artifact state.

Create a `ResolvedArtifact` wrapper for each external artifact once per build invocation, rather than once per dependency graph per build invocation.

In-memory caches can be accessed concurrently

This commit replaces the regular hashmaps with concurrent hash maps, as they can be accessed concurrently. It will not prevent the same

value from being computed twice, potentially, but it will prevent incorrect state being stored in the maps (or worse, infinite loops).

Do not discard the in-memory metadata fetching cost cache between invocations

Re-introduce a global cache for locally available metadata, which only stores results if it was actually found

Introduce cache for local metadata availability

This commit adds a cache for local metadata availability. Since we introduced the heuristic to determine if metadata

is available locally, we could hit the persistent store multiple times for the same module during a build, which

introduced a performance regression. This commit adds the ability to cache the answer of availability for a build,

making it possible to do a short check before returning.

Make sure we only pre-emptively download metadata for nodes which are `Selected`

This commit fixes a performance regression due to the fact we were downloading metadata for nodes which might

be excluded or new. It also fixes a problem with the in-memory metadata cache not telling that the metadata was

available locally, introducing lookups on disk when not necesary.

Protect state in `InMemoryArtifactsCache`

Cache the result of component artifact resolutions in memory, as is done for other resolution results.

Reworked the way that a component's artifacts are calculated, so that the artifacts are determined in a single batch rather than once per configuration. All implementations of this calculation were in reality independent of the requested configuration, either using a value from the component's metadata or producing a result that is fixed for all of the component's configurations.

This change avoids duplicating a bunch of work that is only required to be done once, for example, determining the identity of the main artifact for a maven module whose packaging is not 'jar' by performing a HEAD request.

No need to take a defensive copy of module meta-data reused from in memory cache.

Changed some dependency resolution types to use an immutable module meta-data view instead of a mutable view.

We still take defensive copies in a few places, as the implementations are not actually immutable yet.

Rename `o.g.i.c.model.*{MetaData => Metadata}`

Rename `o.g.i.c.e.model.*{MetaData => Metadata}`

Removed a bunch of TODO:DAZ comments that I'm not going to do anytime soon

Introduce ResolverResults#getResolvedArtifacts

+review REVIEW-5515

Renamed ComponentRequestMetaData -> ComponentOverrideMetadata

Start to migrate away from requiring DependencyMetaData when resolving component from id

- Wrap DependencyMetaData with ComponentRequestMetaData to restrict access