earliestBlockedUntil() {
+ return this.earliestBlockedUntil;
+ }
+
+ /**
+ * Check if this entry has expired.
+ * An entry is expired if blockedUntil has passed.
+ *
+ * @return true if expired
+ */
+ public boolean isExpired() {
+ if (this.earliestBlockedUntil.isPresent()) {
+ return Instant.now().isAfter(this.earliestBlockedUntil.get());
+ }
+ // No blocked versions - check if max TTL has passed since creation
+ return Duration.between(this.createdAt, Instant.now()).compareTo(this.maxTtl) > 0;
+ }
+
+ /**
+ * Calculate TTL in nanoseconds for Caffeine expiry.
+ * If versions are blocked: TTL = earliestBlockedUntil - now
+ * If no versions blocked: TTL = maxTtl (release dates don't change)
+ *
+ * @return TTL in nanoseconds
+ */
+ public long ttlNanos() {
+ if (this.earliestBlockedUntil.isPresent()) {
+ final Duration remaining = Duration.between(Instant.now(), this.earliestBlockedUntil.get());
+ if (remaining.isNegative() || remaining.isZero()) {
+ // Already expired - use minimum TTL
+ return MIN_TTL.toNanos();
+ }
+ return remaining.toNanos();
+ }
+ // No blocked versions - cache for max TTL
+ return this.maxTtl.toNanos();
+ }
+
+ /**
+ * Calculate TTL in seconds for L2 cache.
+ *
+ * @return TTL in seconds
+ */
+ public long ttlSeconds() {
+ return Math.max(MIN_TTL.getSeconds(), this.ttlNanos() / 1_000_000_000L);
+ }
+
+ /**
+ * Create entry for metadata with no blocked versions.
+ * Uses maximum TTL since release dates don't change.
+ *
+ * @param data Filtered metadata bytes
+ * @param maxTtl Maximum TTL
+ * @return Cache entry
+ */
+ public static CacheEntry noBlockedVersions(final byte[] data, final Duration maxTtl) {
+ return new CacheEntry(data, Optional.empty(), maxTtl);
+ }
+
+ /**
+ * Create entry for metadata with blocked versions.
+ * TTL is set to expire when the earliest block expires.
+ *
+ * @param data Filtered metadata bytes
+ * @param earliestBlockedUntil When the earliest block expires
+ * @param maxTtl Maximum TTL (used as fallback)
+ * @return Cache entry
+ */
+ public static CacheEntry withBlockedVersions(
+ final byte[] data,
+ final Instant earliestBlockedUntil,
+ final Duration maxTtl
+ ) {
+ return new CacheEntry(data, Optional.of(earliestBlockedUntil), maxTtl);
+ }
+ }
+}
diff --git a/artipie-core/src/main/java/com/artipie/cooldown/metadata/FilteredMetadataCacheConfig.java b/artipie-core/src/main/java/com/artipie/cooldown/metadata/FilteredMetadataCacheConfig.java
new file mode 100644
index 000000000..5b9a1273b
--- /dev/null
+++ b/artipie-core/src/main/java/com/artipie/cooldown/metadata/FilteredMetadataCacheConfig.java
@@ -0,0 +1,333 @@
+/*
+ * The MIT License (MIT) Copyright (c) 2020-2023 artipie.com
+ * https://github.com/artipie/artipie/blob/master/LICENSE.txt
+ */
+package com.artipie.cooldown.metadata;
+
+import com.amihaiemil.eoyaml.YamlMapping;
+import java.time.Duration;
+
+/**
+ * Configuration for FilteredMetadataCache (cooldown metadata caching).
+ *
+ * Example YAML configuration in artipie.yaml:
+ *
+ * meta:
+ * caches:
+ * cooldown-metadata:
+ * ttl: 24h
+ * maxSize: 5000
+ * valkey:
+ * enabled: true
+ * l1MaxSize: 500
+ * l1Ttl: 5m
+ * l2Ttl: 24h
+ *
+ *
+ * For large NPM metadata (3-38MB per package), consider:
+ *
+ * - Reducing l1MaxSize to avoid memory pressure
+ * - Setting l1MaxSize to 0 for L2-only mode (Valkey only)
+ *
+ *
+ * @since 1.18.22
+ */
+public final class FilteredMetadataCacheConfig {
+
+ /**
+ * Default TTL for cache entries (24 hours).
+ */
+ public static final Duration DEFAULT_TTL = Duration.ofHours(24);
+
+ /**
+ * Default maximum L1 cache size (5,000 packages).
+ */
+ public static final int DEFAULT_MAX_SIZE = 5_000;
+
+ /**
+ * Default L1 TTL when L2 is enabled (5 minutes).
+ */
+ public static final Duration DEFAULT_L1_TTL = Duration.ofMinutes(5);
+
+ /**
+ * Default L2 TTL (24 hours).
+ */
+ public static final Duration DEFAULT_L2_TTL = Duration.ofHours(24);
+
+ /**
+ * Default L1 max size when L2 enabled (500 - reduced for large metadata).
+ */
+ public static final int DEFAULT_L1_MAX_SIZE = 500;
+
+ /**
+ * Default L2 max size (not enforced by Valkey, informational only).
+ */
+ public static final int DEFAULT_L2_MAX_SIZE = 100_000;
+
+ /**
+ * Global instance (singleton).
+ */
+ private static volatile FilteredMetadataCacheConfig instance;
+
+ /**
+ * TTL for single-tier or fallback.
+ */
+ private final Duration ttl;
+
+ /**
+ * Max size for single-tier.
+ */
+ private final int maxSize;
+
+ /**
+ * Whether Valkey L2 is enabled.
+ */
+ private final boolean valkeyEnabled;
+
+ /**
+ * L1 cache max size.
+ */
+ private final int l1MaxSize;
+
+ /**
+ * L1 cache TTL.
+ */
+ private final Duration l1Ttl;
+
+ /**
+ * L2 cache TTL.
+ */
+ private final Duration l2Ttl;
+
+ /**
+ * L2 cache max size (informational, not enforced by Valkey).
+ */
+ private final int l2MaxSize;
+
+ /**
+ * Default constructor with sensible defaults.
+ */
+ public FilteredMetadataCacheConfig() {
+ this(DEFAULT_TTL, DEFAULT_MAX_SIZE, false,
+ DEFAULT_L1_MAX_SIZE, DEFAULT_L1_TTL, DEFAULT_L2_TTL, DEFAULT_L2_MAX_SIZE);
+ }
+
+ /**
+ * Full constructor.
+ * @param ttl Default TTL
+ * @param maxSize Default max size (single-tier)
+ * @param valkeyEnabled Whether L2 is enabled
+ * @param l1MaxSize L1 max size (0 for L2-only mode)
+ * @param l1Ttl L1 TTL
+ * @param l2Ttl L2 TTL
+ * @param l2MaxSize L2 max size (informational)
+ */
+ public FilteredMetadataCacheConfig(
+ final Duration ttl,
+ final int maxSize,
+ final boolean valkeyEnabled,
+ final int l1MaxSize,
+ final Duration l1Ttl,
+ final Duration l2Ttl,
+ final int l2MaxSize
+ ) {
+ this.ttl = ttl;
+ this.maxSize = maxSize;
+ this.valkeyEnabled = valkeyEnabled;
+ this.l1MaxSize = l1MaxSize;
+ this.l1Ttl = l1Ttl;
+ this.l2Ttl = l2Ttl;
+ this.l2MaxSize = l2MaxSize;
+ }
+
+ /**
+ * Get default TTL.
+ * @return TTL duration
+ */
+ public Duration ttl() {
+ return this.ttl;
+ }
+
+ /**
+ * Get max size for single-tier cache.
+ * @return Max size
+ */
+ public int maxSize() {
+ return this.maxSize;
+ }
+
+ /**
+ * Check if Valkey L2 is enabled.
+ * @return True if two-tier caching is enabled
+ */
+ public boolean isValkeyEnabled() {
+ return this.valkeyEnabled;
+ }
+
+ /**
+ * Get L1 max size.
+ * A value of 0 indicates L2-only mode (no in-memory caching).
+ * @return L1 max size
+ */
+ public int l1MaxSize() {
+ return this.l1MaxSize;
+ }
+
+ /**
+ * Get L1 TTL.
+ * @return L1 TTL
+ */
+ public Duration l1Ttl() {
+ return this.l1Ttl;
+ }
+
+ /**
+ * Get L2 TTL.
+ * @return L2 TTL
+ */
+ public Duration l2Ttl() {
+ return this.l2Ttl;
+ }
+
+ /**
+ * Get L2 max size.
+ * @return L2 max size
+ */
+ public int l2MaxSize() {
+ return this.l2MaxSize;
+ }
+
+ /**
+ * Check if L2-only mode is enabled (l1MaxSize == 0 and valkey enabled).
+ * @return True if L2-only mode
+ */
+ public boolean isL2OnlyMode() {
+ return this.valkeyEnabled && this.l1MaxSize == 0;
+ }
+
+ /**
+ * Initialize global instance from YAML.
+ * Should be called once at startup.
+ * @param caches The caches YAML mapping from artipie.yaml
+ */
+ public static void initialize(final YamlMapping caches) {
+ if (instance == null) {
+ synchronized (FilteredMetadataCacheConfig.class) {
+ if (instance == null) {
+ instance = fromYaml(caches);
+ }
+ }
+ }
+ }
+
+ /**
+ * Get the global instance.
+ * @return Global config (defaults if not initialized)
+ */
+ public static FilteredMetadataCacheConfig getInstance() {
+ if (instance == null) {
+ return new FilteredMetadataCacheConfig();
+ }
+ return instance;
+ }
+
+ /**
+ * Reset for testing.
+ */
+ public static void reset() {
+ instance = null;
+ }
+
+ /**
+ * Parse configuration from YAML.
+ * @param caches The caches YAML mapping
+ * @return Parsed config
+ */
+ public static FilteredMetadataCacheConfig fromYaml(final YamlMapping caches) {
+ if (caches == null) {
+ return new FilteredMetadataCacheConfig();
+ }
+ final YamlMapping cooldownMetadata = caches.yamlMapping("cooldown-metadata");
+ if (cooldownMetadata == null) {
+ return new FilteredMetadataCacheConfig();
+ }
+
+ final Duration ttl = parseDuration(cooldownMetadata.string("ttl"), DEFAULT_TTL);
+ final int maxSize = parseInt(cooldownMetadata.string("maxSize"), DEFAULT_MAX_SIZE);
+
+ // Check for valkey sub-config
+ final YamlMapping valkey = cooldownMetadata.yamlMapping("valkey");
+ if (valkey != null && "true".equalsIgnoreCase(valkey.string("enabled"))) {
+ return new FilteredMetadataCacheConfig(
+ ttl,
+ maxSize,
+ true,
+ parseInt(valkey.string("l1MaxSize"), DEFAULT_L1_MAX_SIZE),
+ parseDuration(valkey.string("l1Ttl"), DEFAULT_L1_TTL),
+ parseDuration(valkey.string("l2Ttl"), DEFAULT_L2_TTL),
+ parseInt(valkey.string("l2MaxSize"), DEFAULT_L2_MAX_SIZE)
+ );
+ }
+
+ return new FilteredMetadataCacheConfig(ttl, maxSize, false,
+ DEFAULT_L1_MAX_SIZE, DEFAULT_L1_TTL, DEFAULT_L2_TTL, DEFAULT_L2_MAX_SIZE);
+ }
+
+ /**
+ * Parse duration string (e.g., "24h", "7d", "5m").
+ * @param value Duration string
+ * @param defaultVal Default value
+ * @return Parsed duration
+ */
+ private static Duration parseDuration(final String value, final Duration defaultVal) {
+ if (value == null || value.isEmpty()) {
+ return defaultVal;
+ }
+ try {
+ final String trimmed = value.trim().toLowerCase();
+ if (trimmed.endsWith("d")) {
+ return Duration.ofDays(Long.parseLong(trimmed.substring(0, trimmed.length() - 1)));
+ } else if (trimmed.endsWith("h")) {
+ return Duration.ofHours(Long.parseLong(trimmed.substring(0, trimmed.length() - 1)));
+ } else if (trimmed.endsWith("m")) {
+ return Duration.ofMinutes(Long.parseLong(trimmed.substring(0, trimmed.length() - 1)));
+ } else if (trimmed.endsWith("s")) {
+ return Duration.ofSeconds(Long.parseLong(trimmed.substring(0, trimmed.length() - 1)));
+ }
+ return Duration.ofSeconds(Long.parseLong(trimmed));
+ } catch (final NumberFormatException ex) {
+ return defaultVal;
+ }
+ }
+
+ /**
+ * Parse integer string.
+ * @param value Integer string
+ * @param defaultVal Default value
+ * @return Parsed integer
+ */
+ private static int parseInt(final String value, final int defaultVal) {
+ if (value == null || value.isEmpty()) {
+ return defaultVal;
+ }
+ try {
+ return Integer.parseInt(value.trim());
+ } catch (final NumberFormatException ex) {
+ return defaultVal;
+ }
+ }
+
+ @Override
+ public String toString() {
+ if (this.valkeyEnabled) {
+ return String.format(
+ "FilteredMetadataCacheConfig{ttl=%s, valkeyEnabled=true, l1MaxSize=%d, l1Ttl=%s, l2Ttl=%s, l2Only=%s}",
+ this.ttl, this.l1MaxSize, this.l1Ttl, this.l2Ttl, this.isL2OnlyMode()
+ );
+ }
+ return String.format(
+ "FilteredMetadataCacheConfig{ttl=%s, maxSize=%d, valkeyEnabled=false}",
+ this.ttl, this.maxSize
+ );
+ }
+}
diff --git a/artipie-core/src/main/java/com/artipie/cooldown/metadata/MetadataAwareInspector.java b/artipie-core/src/main/java/com/artipie/cooldown/metadata/MetadataAwareInspector.java
new file mode 100644
index 000000000..39ddd508c
--- /dev/null
+++ b/artipie-core/src/main/java/com/artipie/cooldown/metadata/MetadataAwareInspector.java
@@ -0,0 +1,49 @@
+/*
+ * The MIT License (MIT) Copyright (c) 2020-2023 artipie.com
+ * https://github.com/artipie/artipie/blob/master/LICENSE.txt
+ */
+package com.artipie.cooldown.metadata;
+
+import java.time.Instant;
+import java.util.Map;
+
+/**
+ * Extension interface for {@link com.artipie.cooldown.CooldownInspector} implementations
+ * that can accept preloaded release dates from metadata.
+ *
+ * When metadata contains release timestamps (e.g., NPM's {@code time} object),
+ * the cooldown metadata service can preload these dates into the inspector.
+ * This avoids additional upstream HTTP requests when evaluating cooldown for versions.
+ *
+ * Inspectors implementing this interface should:
+ *
+ * - Store preloaded dates in a thread-safe manner
+ * - Check preloaded dates first in {@code releaseDate()} before hitting upstream
+ * - Clear preloaded dates after processing to avoid stale data
+ *
+ *
+ * @since 1.0
+ */
+public interface MetadataAwareInspector {
+
+ /**
+ * Preload release dates extracted from metadata.
+ * Called by the cooldown metadata service before evaluating versions.
+ *
+ * @param releaseDates Map of version string → release timestamp
+ */
+ void preloadReleaseDates(Map releaseDates);
+
+ /**
+ * Clear preloaded release dates.
+ * Called after metadata processing is complete.
+ */
+ void clearPreloadedDates();
+
+ /**
+ * Check if release dates are currently preloaded.
+ *
+ * @return {@code true} if preloaded dates are available
+ */
+ boolean hasPreloadedDates();
+}
diff --git a/artipie-core/src/main/java/com/artipie/cooldown/metadata/MetadataFilter.java b/artipie-core/src/main/java/com/artipie/cooldown/metadata/MetadataFilter.java
new file mode 100644
index 000000000..4b1415610
--- /dev/null
+++ b/artipie-core/src/main/java/com/artipie/cooldown/metadata/MetadataFilter.java
@@ -0,0 +1,45 @@
+/*
+ * The MIT License (MIT) Copyright (c) 2020-2023 artipie.com
+ * https://github.com/artipie/artipie/blob/master/LICENSE.txt
+ */
+package com.artipie.cooldown.metadata;
+
+import java.util.Set;
+
+/**
+ * Filters blocked versions from parsed metadata.
+ * Each adapter implements this to remove blocked versions from its metadata format.
+ *
+ * Implementations must:
+ *
+ * - Remove blocked versions from version lists/objects
+ * - Remove associated data (timestamps, checksums, download URLs) for blocked versions
+ * - Preserve all other metadata unchanged
+ *
+ *
+ * @param Type of parsed metadata object (must match {@link MetadataParser})
+ * @since 1.0
+ */
+public interface MetadataFilter {
+
+ /**
+ * Filter blocked versions from metadata.
+ * Returns a new or modified metadata object with blocked versions removed.
+ *
+ * @param metadata Parsed metadata object
+ * @param blockedVersions Set of version strings to remove
+ * @return Filtered metadata (may be same instance if mutable, or new instance)
+ */
+ T filter(T metadata, Set blockedVersions);
+
+ /**
+ * Update the "latest" version tag in metadata.
+ * Called when the current latest version is blocked and needs to be updated
+ * to point to the highest unblocked version.
+ *
+ * @param metadata Filtered metadata object
+ * @param newLatest New latest version string
+ * @return Updated metadata (may be same instance if mutable, or new instance)
+ */
+ T updateLatest(T metadata, String newLatest);
+}
diff --git a/artipie-core/src/main/java/com/artipie/cooldown/metadata/MetadataParseException.java b/artipie-core/src/main/java/com/artipie/cooldown/metadata/MetadataParseException.java
new file mode 100644
index 000000000..a8cd60ab0
--- /dev/null
+++ b/artipie-core/src/main/java/com/artipie/cooldown/metadata/MetadataParseException.java
@@ -0,0 +1,34 @@
+/*
+ * The MIT License (MIT) Copyright (c) 2020-2023 artipie.com
+ * https://github.com/artipie/artipie/blob/master/LICENSE.txt
+ */
+package com.artipie.cooldown.metadata;
+
+/**
+ * Exception thrown when metadata parsing fails.
+ *
+ * @since 1.0
+ */
+public final class MetadataParseException extends RuntimeException {
+
+ private static final long serialVersionUID = 1L;
+
+ /**
+ * Constructor with message.
+ *
+ * @param message Error message
+ */
+ public MetadataParseException(final String message) {
+ super(message);
+ }
+
+ /**
+ * Constructor with message and cause.
+ *
+ * @param message Error message
+ * @param cause Underlying cause
+ */
+ public MetadataParseException(final String message, final Throwable cause) {
+ super(message, cause);
+ }
+}
diff --git a/artipie-core/src/main/java/com/artipie/cooldown/metadata/MetadataParser.java b/artipie-core/src/main/java/com/artipie/cooldown/metadata/MetadataParser.java
new file mode 100644
index 000000000..d65c347ca
--- /dev/null
+++ b/artipie-core/src/main/java/com/artipie/cooldown/metadata/MetadataParser.java
@@ -0,0 +1,61 @@
+/*
+ * The MIT License (MIT) Copyright (c) 2020-2023 artipie.com
+ * https://github.com/artipie/artipie/blob/master/LICENSE.txt
+ */
+package com.artipie.cooldown.metadata;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Parses package metadata from raw bytes into a structured representation.
+ * Each adapter implements this for its specific metadata format (JSON, XML, HTML, text).
+ *
+ * The type parameter {@code T} represents the parsed metadata structure:
+ *
+ * - NPM/Composer: Jackson {@code JsonNode}
+ * - Maven: DOM {@code Document}
+ * - PyPI: Jsoup {@code Document}
+ * - Go: {@code List}
+ *
+ *
+ * @param Type of parsed metadata object
+ * @since 1.0
+ */
+public interface MetadataParser {
+
+ /**
+ * Parse raw metadata bytes into structured representation.
+ *
+ * @param bytes Raw metadata bytes
+ * @return Parsed metadata object
+ * @throws MetadataParseException If parsing fails
+ */
+ T parse(byte[] bytes) throws MetadataParseException;
+
+ /**
+ * Extract all version strings from parsed metadata.
+ * Versions should be returned in their natural order from the metadata
+ * (typically newest first for NPM/Composer, or as listed for Maven).
+ *
+ * @param metadata Parsed metadata object
+ * @return List of all version strings
+ */
+ List extractVersions(T metadata);
+
+ /**
+ * Get the "latest" version tag if the format supports it.
+ * For NPM this is {@code dist-tags.latest}, for Maven it's {@code }.
+ *
+ * @param metadata Parsed metadata object
+ * @return Latest version if present, empty otherwise
+ */
+ Optional getLatestVersion(T metadata);
+
+ /**
+ * Get the content type for this metadata format.
+ *
+ * @return MIME content type (e.g., "application/json", "application/xml")
+ */
+ String contentType();
+}
diff --git a/artipie-core/src/main/java/com/artipie/cooldown/metadata/MetadataRequestDetector.java b/artipie-core/src/main/java/com/artipie/cooldown/metadata/MetadataRequestDetector.java
new file mode 100644
index 000000000..02df3ed02
--- /dev/null
+++ b/artipie-core/src/main/java/com/artipie/cooldown/metadata/MetadataRequestDetector.java
@@ -0,0 +1,47 @@
+/*
+ * The MIT License (MIT) Copyright (c) 2020-2023 artipie.com
+ * https://github.com/artipie/artipie/blob/master/LICENSE.txt
+ */
+package com.artipie.cooldown.metadata;
+
+import java.util.Optional;
+
+/**
+ * Detects whether an HTTP request path is a metadata request (vs artifact download).
+ * Each adapter implements this interface to identify metadata endpoints for its package format.
+ *
+ * Examples:
+ *
+ * - NPM: {@code /lodash} is metadata, {@code /lodash/-/lodash-4.17.21.tgz} is artifact
+ * - Maven: {@code .../maven-metadata.xml} is metadata, {@code .../artifact-1.0.jar} is artifact
+ * - PyPI: {@code /simple/requests/} is metadata
+ * - Go: {@code /@v/list} is metadata
+ *
+ *
+ * @since 1.0
+ */
+public interface MetadataRequestDetector {
+
+ /**
+ * Check if the given request path is a metadata request.
+ *
+ * @param path Request path (e.g., "/lodash", "/simple/requests/")
+ * @return {@code true} if this is a metadata request, {@code false} if artifact download
+ */
+ boolean isMetadataRequest(String path);
+
+ /**
+ * Extract package name from a metadata request path.
+ *
+ * @param path Request path
+ * @return Package name if this is a metadata request, empty otherwise
+ */
+ Optional extractPackageName(String path);
+
+ /**
+ * Get the repository type this detector handles.
+ *
+ * @return Repository type identifier (e.g., "npm", "maven", "pypi")
+ */
+ String repoType();
+}
diff --git a/artipie-core/src/main/java/com/artipie/cooldown/metadata/MetadataRewriteException.java b/artipie-core/src/main/java/com/artipie/cooldown/metadata/MetadataRewriteException.java
new file mode 100644
index 000000000..b300d3af7
--- /dev/null
+++ b/artipie-core/src/main/java/com/artipie/cooldown/metadata/MetadataRewriteException.java
@@ -0,0 +1,34 @@
+/*
+ * The MIT License (MIT) Copyright (c) 2020-2023 artipie.com
+ * https://github.com/artipie/artipie/blob/master/LICENSE.txt
+ */
+package com.artipie.cooldown.metadata;
+
+/**
+ * Exception thrown when metadata rewriting/serialization fails.
+ *
+ * @since 1.0
+ */
+public final class MetadataRewriteException extends RuntimeException {
+
+ private static final long serialVersionUID = 1L;
+
+ /**
+ * Constructor with message.
+ *
+ * @param message Error message
+ */
+ public MetadataRewriteException(final String message) {
+ super(message);
+ }
+
+ /**
+ * Constructor with message and cause.
+ *
+ * @param message Error message
+ * @param cause Underlying cause
+ */
+ public MetadataRewriteException(final String message, final Throwable cause) {
+ super(message, cause);
+ }
+}
diff --git a/artipie-core/src/main/java/com/artipie/cooldown/metadata/MetadataRewriter.java b/artipie-core/src/main/java/com/artipie/cooldown/metadata/MetadataRewriter.java
new file mode 100644
index 000000000..ae6dab07f
--- /dev/null
+++ b/artipie-core/src/main/java/com/artipie/cooldown/metadata/MetadataRewriter.java
@@ -0,0 +1,31 @@
+/*
+ * The MIT License (MIT) Copyright (c) 2020-2023 artipie.com
+ * https://github.com/artipie/artipie/blob/master/LICENSE.txt
+ */
+package com.artipie.cooldown.metadata;
+
+/**
+ * Serializes filtered metadata back to bytes for HTTP response.
+ * Each adapter implements this to serialize its metadata format.
+ *
+ * @param Type of parsed metadata object (must match {@link MetadataParser} and {@link MetadataFilter})
+ * @since 1.0
+ */
+public interface MetadataRewriter {
+
+ /**
+ * Serialize filtered metadata to bytes.
+ *
+ * @param metadata Filtered metadata object
+ * @return Serialized bytes ready for HTTP response
+ * @throws MetadataRewriteException If serialization fails
+ */
+ byte[] rewrite(T metadata) throws MetadataRewriteException;
+
+ /**
+ * Get the HTTP Content-Type header value for this metadata format.
+ *
+ * @return Content-Type value (e.g., "application/json", "application/xml", "text/html")
+ */
+ String contentType();
+}
diff --git a/artipie-core/src/main/java/com/artipie/cooldown/metadata/NoopCooldownMetadataService.java b/artipie-core/src/main/java/com/artipie/cooldown/metadata/NoopCooldownMetadataService.java
new file mode 100644
index 000000000..1f8d1d5dd
--- /dev/null
+++ b/artipie-core/src/main/java/com/artipie/cooldown/metadata/NoopCooldownMetadataService.java
@@ -0,0 +1,64 @@
+/*
+ * The MIT License (MIT) Copyright (c) 2020-2023 artipie.com
+ * https://github.com/artipie/artipie/blob/master/LICENSE.txt
+ */
+package com.artipie.cooldown.metadata;
+
+import com.artipie.cooldown.CooldownInspector;
+
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+
+/**
+ * No-op implementation of {@link CooldownMetadataService}.
+ * Returns raw metadata unchanged. Used when cooldown is disabled.
+ *
+ * @since 1.0
+ */
+public final class NoopCooldownMetadataService implements CooldownMetadataService {
+
+ /**
+ * Singleton instance.
+ */
+ public static final NoopCooldownMetadataService INSTANCE = new NoopCooldownMetadataService();
+
+ /**
+ * Private constructor.
+ */
+ private NoopCooldownMetadataService() {
+ }
+
+ @Override
+ public CompletableFuture filterMetadata(
+ final String repoType,
+ final String repoName,
+ final String packageName,
+ final byte[] rawMetadata,
+ final MetadataParser parser,
+ final MetadataFilter filter,
+ final MetadataRewriter rewriter,
+ final Optional inspector
+ ) {
+ // Return raw metadata unchanged
+ return CompletableFuture.completedFuture(rawMetadata);
+ }
+
+ @Override
+ public void invalidate(
+ final String repoType,
+ final String repoName,
+ final String packageName
+ ) {
+ // No-op
+ }
+
+ @Override
+ public void invalidateAll(final String repoType, final String repoName) {
+ // No-op
+ }
+
+ @Override
+ public String stats() {
+ return "NoopCooldownMetadataService[disabled]";
+ }
+}
diff --git a/artipie-core/src/main/java/com/artipie/cooldown/metadata/ReleaseDateProvider.java b/artipie-core/src/main/java/com/artipie/cooldown/metadata/ReleaseDateProvider.java
new file mode 100644
index 000000000..2ae94ce61
--- /dev/null
+++ b/artipie-core/src/main/java/com/artipie/cooldown/metadata/ReleaseDateProvider.java
@@ -0,0 +1,35 @@
+/*
+ * The MIT License (MIT) Copyright (c) 2020-2023 artipie.com
+ * https://github.com/artipie/artipie/blob/master/LICENSE.txt
+ */
+package com.artipie.cooldown.metadata;
+
+import java.time.Instant;
+import java.util.Map;
+
+/**
+ * Optional extension for {@link MetadataParser} implementations that can extract
+ * release dates directly from metadata.
+ *
+ * Some package formats include release timestamps in their metadata:
+ *
+ * - NPM: {@code time} object with version → ISO timestamp
+ * - Composer: {@code time} field in version objects
+ *
+ *
+ * When a parser implements this interface, the cooldown metadata service can
+ * preload release dates into inspectors, avoiding additional upstream HTTP requests.
+ *
+ * @param Type of parsed metadata object (must match {@link MetadataParser})
+ * @since 1.0
+ */
+public interface ReleaseDateProvider {
+
+ /**
+ * Extract release dates from parsed metadata.
+ *
+ * @param metadata Parsed metadata object
+ * @return Map of version string → release timestamp (may be empty, never null)
+ */
+ Map releaseDates(T metadata);
+}
diff --git a/artipie-core/src/main/java/com/artipie/cooldown/metadata/VersionComparators.java b/artipie-core/src/main/java/com/artipie/cooldown/metadata/VersionComparators.java
new file mode 100644
index 000000000..616a79908
--- /dev/null
+++ b/artipie-core/src/main/java/com/artipie/cooldown/metadata/VersionComparators.java
@@ -0,0 +1,184 @@
+/*
+ * The MIT License (MIT) Copyright (c) 2020-2023 artipie.com
+ * https://github.com/artipie/artipie/blob/master/LICENSE.txt
+ */
+package com.artipie.cooldown.metadata;
+
+import java.util.Comparator;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Version comparators for different package formats.
+ * Used to sort versions and determine the "latest" unblocked version.
+ *
+ * @since 1.0
+ */
+public final class VersionComparators {
+
+ /**
+ * Pattern for semantic versioning: major.minor.patch[-prerelease][+build].
+ * Prerelease and build metadata can contain alphanumeric, hyphens, and dots.
+ */
+ private static final Pattern SEMVER = Pattern.compile(
+ "^v?(\\d+)(?:\\.(\\d+))?(?:\\.(\\d+))?(?:-([\\w.\\-]+))?(?:\\+([\\w.\\-]+))?$"
+ );
+
+ /**
+ * Private constructor.
+ */
+ private VersionComparators() {
+ }
+
+ /**
+ * Semantic version comparator (NPM, Composer style).
+ * Compares major.minor.patch numerically, then prerelease lexically.
+ * Versions without prerelease are considered newer than those with prerelease.
+ *
+ * @return Comparator that orders versions from oldest to newest
+ */
+ public static Comparator semver() {
+ return (v1, v2) -> {
+ final Matcher m1 = SEMVER.matcher(v1);
+ final Matcher m2 = SEMVER.matcher(v2);
+ final boolean match1 = m1.matches();
+ final boolean match2 = m2.matches();
+ // Handle non-semver versions consistently to maintain transitivity:
+ // - semver versions sort before non-semver versions
+ // - non-semver versions sort lexically among themselves
+ if (!match1 && !match2) {
+ // Both non-semver: lexical comparison
+ return v1.compareTo(v2);
+ }
+ if (!match1) {
+ // v1 is non-semver, v2 is semver: v1 sorts after v2
+ return 1;
+ }
+ if (!match2) {
+ // v1 is semver, v2 is non-semver: v1 sorts before v2
+ return -1;
+ }
+ // Both semver: compare numerically
+ // Compare major
+ int cmp = compareNumeric(m1.group(1), m2.group(1));
+ if (cmp != 0) {
+ return cmp;
+ }
+ // Compare minor
+ cmp = compareNumeric(m1.group(2), m2.group(2));
+ if (cmp != 0) {
+ return cmp;
+ }
+ // Compare patch
+ cmp = compareNumeric(m1.group(3), m2.group(3));
+ if (cmp != 0) {
+ return cmp;
+ }
+ // Compare prerelease: no prerelease > has prerelease
+ final String pre1 = m1.group(4);
+ final String pre2 = m2.group(4);
+ if (pre1 == null && pre2 == null) {
+ return 0;
+ }
+ if (pre1 == null) {
+ return 1; // v1 is release, v2 is prerelease → v1 > v2
+ }
+ if (pre2 == null) {
+ return -1; // v1 is prerelease, v2 is release → v1 < v2
+ }
+ return pre1.compareTo(pre2);
+ };
+ }
+
+ /**
+ * Maven version comparator.
+ * Handles Maven's version ordering rules (numeric segments, qualifiers).
+ *
+ * @return Comparator that orders versions from oldest to newest
+ */
+ public static Comparator maven() {
+ // Simplified Maven comparator - handles common cases
+ return (v1, v2) -> {
+ final String[] parts1 = v1.split("[.-]");
+ final String[] parts2 = v2.split("[.-]");
+ final int len = Math.max(parts1.length, parts2.length);
+ for (int i = 0; i < len; i++) {
+ final String p1 = i < parts1.length ? parts1[i] : "0";
+ final String p2 = i < parts2.length ? parts2[i] : "0";
+ // Try numeric comparison first
+ try {
+ final long n1 = Long.parseLong(p1);
+ final long n2 = Long.parseLong(p2);
+ if (n1 != n2) {
+ return Long.compare(n1, n2);
+ }
+ } catch (NumberFormatException e) {
+ // Fall back to string comparison for qualifiers
+ final int cmp = compareQualifier(p1, p2);
+ if (cmp != 0) {
+ return cmp;
+ }
+ }
+ }
+ return 0;
+ };
+ }
+
+ /**
+ * Simple lexical comparator.
+ * Useful for Go modules and other formats with simple version strings.
+ *
+ * @return Comparator that orders versions lexically
+ */
+ public static Comparator lexical() {
+ return String::compareTo;
+ }
+
+ /**
+ * Compare numeric strings, treating null/empty as 0.
+ * Uses Long to handle version numbers that exceed Integer.MAX_VALUE.
+ */
+ private static int compareNumeric(final String s1, final String s2) {
+ final long n1 = s1 == null || s1.isEmpty() ? 0L : Long.parseLong(s1);
+ final long n2 = s2 == null || s2.isEmpty() ? 0L : Long.parseLong(s2);
+ return Long.compare(n1, n2);
+ }
+
+ /**
+ * Compare Maven qualifiers.
+ * Order: alpha < beta < milestone < rc < snapshot < "" (release) < sp
+ */
+ private static int compareQualifier(final String q1, final String q2) {
+ return Integer.compare(qualifierRank(q1), qualifierRank(q2));
+ }
+
+ /**
+ * Get rank for Maven qualifier.
+ */
+ private static int qualifierRank(final String qualifier) {
+ final String lower = qualifier.toLowerCase();
+ if (lower.startsWith("alpha") || lower.equals("a")) {
+ return 1;
+ }
+ if (lower.startsWith("beta") || lower.equals("b")) {
+ return 2;
+ }
+ if (lower.startsWith("milestone") || lower.equals("m")) {
+ return 3;
+ }
+ if (lower.startsWith("rc") || lower.startsWith("cr")) {
+ return 4;
+ }
+ if (lower.equals("snapshot")) {
+ return 5;
+ }
+ if (lower.isEmpty() || lower.equals("final") || lower.equals("ga") || lower.equals("release")) {
+ return 6;
+ }
+ if (lower.startsWith("sp")) {
+ return 7;
+ }
+ // Unknown qualifier - treat as release equivalent
+ return 6;
+ }
+}
diff --git a/artipie-core/src/main/java/com/artipie/cooldown/metadata/package-info.java b/artipie-core/src/main/java/com/artipie/cooldown/metadata/package-info.java
new file mode 100644
index 000000000..7693894b2
--- /dev/null
+++ b/artipie-core/src/main/java/com/artipie/cooldown/metadata/package-info.java
@@ -0,0 +1,40 @@
+/*
+ * The MIT License (MIT) Copyright (c) 2020-2023 artipie.com
+ * https://github.com/artipie/artipie/blob/master/LICENSE.txt
+ */
+
+/**
+ * Cooldown metadata filtering infrastructure.
+ *
+ * This package provides the core infrastructure for filtering package metadata
+ * to remove blocked versions before serving to clients. This enables "version fallback"
+ * where clients automatically resolve to older, unblocked versions.
+ *
+ * Key Components
+ *
+ * - {@link com.artipie.cooldown.metadata.CooldownMetadataService} - Main service interface
+ * - {@link com.artipie.cooldown.metadata.MetadataParser} - Parse metadata from bytes
+ * - {@link com.artipie.cooldown.metadata.MetadataFilter} - Filter blocked versions
+ * - {@link com.artipie.cooldown.metadata.MetadataRewriter} - Serialize filtered metadata
+ * - {@link com.artipie.cooldown.metadata.FilteredMetadataCache} - Cache filtered metadata
+ *
+ *
+ * Per-Adapter Implementation
+ * Each adapter (NPM, Maven, PyPI, etc.) implements:
+ *
+ * - {@link com.artipie.cooldown.metadata.MetadataRequestDetector} - Detect metadata requests
+ * - {@link com.artipie.cooldown.metadata.MetadataParser} - Parse format-specific metadata
+ * - {@link com.artipie.cooldown.metadata.MetadataFilter} - Filter format-specific metadata
+ * - {@link com.artipie.cooldown.metadata.MetadataRewriter} - Serialize format-specific metadata
+ *
+ *
+ * Performance Targets
+ *
+ * - P99 latency: < 200ms for metadata filtering
+ * - Cache hit rate: > 90%
+ * - Throughput: 1,500 requests/second
+ *
+ *
+ * @since 1.0
+ */
+package com.artipie.cooldown.metadata;
diff --git a/artipie-core/src/main/java/com/artipie/cooldown/metrics/CooldownMetrics.java b/artipie-core/src/main/java/com/artipie/cooldown/metrics/CooldownMetrics.java
new file mode 100644
index 000000000..9a290138e
--- /dev/null
+++ b/artipie-core/src/main/java/com/artipie/cooldown/metrics/CooldownMetrics.java
@@ -0,0 +1,379 @@
+/*
+ * The MIT License (MIT) Copyright (c) 2020-2023 artipie.com
+ * https://github.com/artipie/artipie/blob/master/LICENSE.txt
+ */
+package com.artipie.cooldown.metrics;
+
+import com.artipie.metrics.MicrometerMetrics;
+import io.micrometer.core.instrument.Counter;
+import io.micrometer.core.instrument.Gauge;
+import io.micrometer.core.instrument.MeterRegistry;
+import io.micrometer.core.instrument.Timer;
+
+import java.time.Duration;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.Supplier;
+
+/**
+ * Metrics for cooldown functionality.
+ * Provides comprehensive observability for cooldown operations.
+ *
+ * Metric naming convention: {@code artipie.cooldown.*}
+ *
+ * Metrics emitted:
+ *
+ * - Counters:
+ *
+ * - {@code artipie.cooldown.versions.blocked} - versions blocked count
+ * - {@code artipie.cooldown.versions.allowed} - versions allowed count
+ * - {@code artipie.cooldown.cache.hits} - cache hits (L1/L2)
+ * - {@code artipie.cooldown.cache.misses} - cache misses
+ * - {@code artipie.cooldown.all_blocked} - all versions blocked events
+ * - {@code artipie.cooldown.invalidations} - cache invalidations
+ *
+ * - Gauges:
+ *
+ * - {@code artipie.cooldown.cache.size} - current cache size
+ * - {@code artipie.cooldown.active_blocks} - active blocks count
+ *
+ * - Timers:
+ *
+ * - {@code artipie.cooldown.metadata.filter.duration} - metadata filtering duration
+ * - {@code artipie.cooldown.evaluate.duration} - per-version evaluation duration
+ * - {@code artipie.cooldown.cache.load.duration} - cache load duration
+ *
+ *
+ *
+ * @since 1.0
+ */
+public final class CooldownMetrics {
+
+ /**
+ * Singleton instance.
+ */
+ private static volatile CooldownMetrics instance;
+
+ /**
+ * Meter registry.
+ */
+ private final MeterRegistry registry;
+
+ /**
+ * Active blocks gauge values per repo.
+ */
+ private final Map activeBlocksGauges;
+
+ /**
+ * All-blocked packages count (packages where ALL versions are blocked).
+ */
+ private final AtomicLong allBlockedPackages;
+
+ /**
+ * Cache size supplier (set by FilteredMetadataCache).
+ */
+ private volatile Supplier cacheSizeSupplier;
+
+ /**
+ * Private constructor.
+ *
+ * @param registry Meter registry
+ */
+ private CooldownMetrics(final MeterRegistry registry) {
+ this.registry = registry;
+ this.activeBlocksGauges = new ConcurrentHashMap<>();
+ this.allBlockedPackages = new AtomicLong(0);
+ this.cacheSizeSupplier = () -> 0L;
+
+ // Register cache size gauge - uses 'this' reference to prevent GC
+ Gauge.builder("artipie.cooldown.cache.size", this, m -> m.cacheSizeSupplier.get().doubleValue())
+ .description("Current cooldown metadata cache size")
+ .register(registry);
+
+ // Register global active_blocks gauge - always emits, computes total from per-repo gauges
+ // Uses 'this' reference to prevent GC and ensure gauge is never stale
+ Gauge.builder("artipie.cooldown.active_blocks", this, CooldownMetrics::computeTotalActiveBlocks)
+ .description("Total active cooldown blocks across all repositories")
+ .register(registry);
+
+ // Register all_blocked gauge - tracks packages where ALL versions are blocked
+ // Persisted in database, loaded on startup, always emits current value
+ Gauge.builder("artipie.cooldown.all_blocked", this.allBlockedPackages, AtomicLong::doubleValue)
+ .description("Number of packages where all versions are blocked")
+ .register(registry);
+ }
+
+ /**
+ * Get or create singleton instance.
+ *
+ * @return CooldownMetrics instance, or null if MicrometerMetrics not initialized
+ */
+ public static CooldownMetrics getInstance() {
+ if (instance == null) {
+ synchronized (CooldownMetrics.class) {
+ if (instance == null && MicrometerMetrics.isInitialized()) {
+ instance = new CooldownMetrics(MicrometerMetrics.getInstance().getRegistry());
+ }
+ }
+ }
+ return instance;
+ }
+
+ /**
+ * Check if metrics are available.
+ *
+ * @return true if metrics can be recorded
+ */
+ public static boolean isAvailable() {
+ return getInstance() != null;
+ }
+
+ /**
+ * Set cache size supplier for gauge.
+ *
+ * @param supplier Supplier returning current cache size
+ */
+ public void setCacheSizeSupplier(final Supplier supplier) {
+ this.cacheSizeSupplier = supplier;
+ }
+
+ // ==================== Counters ====================
+
+ /**
+ * Record blocked version.
+ *
+ * @param repoType Repository type
+ * @param repoName Repository name
+ */
+ public void recordVersionBlocked(final String repoType, final String repoName) {
+ Counter.builder("artipie.cooldown.versions.blocked")
+ .description("Number of versions blocked by cooldown")
+ .tag("repo_type", repoType)
+ .tag("repo_name", repoName)
+ .register(this.registry)
+ .increment();
+ }
+
+ /**
+ * Record allowed version.
+ *
+ * @param repoType Repository type
+ * @param repoName Repository name
+ */
+ public void recordVersionAllowed(final String repoType, final String repoName) {
+ Counter.builder("artipie.cooldown.versions.allowed")
+ .description("Number of versions allowed by cooldown")
+ .tag("repo_type", repoType)
+ .tag("repo_name", repoName)
+ .register(this.registry)
+ .increment();
+ }
+
+ /**
+ * Record cache hit.
+ *
+ * @param tier Cache tier (l1 or l2)
+ */
+ public void recordCacheHit(final String tier) {
+ Counter.builder("artipie.cooldown.cache.hits")
+ .description("Cooldown cache hits")
+ .tag("tier", tier)
+ .register(this.registry)
+ .increment();
+ }
+
+ /**
+ * Record cache miss.
+ */
+ public void recordCacheMiss() {
+ Counter.builder("artipie.cooldown.cache.misses")
+ .description("Cooldown cache misses")
+ .register(this.registry)
+ .increment();
+ }
+
+ /**
+ * Set all-blocked packages count (loaded from database on startup).
+ *
+ * @param count Current count of packages with all versions blocked
+ */
+ public void setAllBlockedPackages(final long count) {
+ this.allBlockedPackages.set(count);
+ }
+
+ /**
+ * Increment all-blocked packages count (called when all versions become blocked).
+ */
+ public void incrementAllBlocked() {
+ this.allBlockedPackages.incrementAndGet();
+ }
+
+ /**
+ * Decrement all-blocked packages count (called when a package is unblocked).
+ */
+ public void decrementAllBlocked() {
+ final long current = this.allBlockedPackages.decrementAndGet();
+ if (current < 0) {
+ this.allBlockedPackages.set(0);
+ }
+ }
+
+ /**
+ * Record cache invalidation.
+ *
+ * @param repoType Repository type
+ * @param reason Invalidation reason (unblock, expire, manual)
+ */
+ public void recordInvalidation(final String repoType, final String reason) {
+ Counter.builder("artipie.cooldown.invalidations")
+ .description("Cooldown cache invalidations")
+ .tag("repo_type", repoType)
+ .tag("reason", reason)
+ .register(this.registry)
+ .increment();
+ }
+
+ // ==================== Gauges ====================
+
+ /**
+ * Update active blocks count for a repository (used on startup to load from DB).
+ *
+ * @param repoType Repository type
+ * @param repoName Repository name
+ * @param count Current active blocks count
+ */
+ public void updateActiveBlocks(final String repoType, final String repoName, final long count) {
+ final String key = repoType + ":" + repoName;
+ this.getOrCreateRepoGauge(repoType, repoName, key).set(count);
+ }
+
+ /**
+ * Increment active blocks for a repository (O(1), no DB query).
+ *
+ * @param repoType Repository type
+ * @param repoName Repository name
+ */
+ public void incrementActiveBlocks(final String repoType, final String repoName) {
+ final String key = repoType + ":" + repoName;
+ this.getOrCreateRepoGauge(repoType, repoName, key).incrementAndGet();
+ }
+
+ /**
+ * Decrement active blocks for a repository (O(1), no DB query).
+ *
+ * @param repoType Repository type
+ * @param repoName Repository name
+ */
+ public void decrementActiveBlocks(final String repoType, final String repoName) {
+ final String key = repoType + ":" + repoName;
+ final AtomicLong gauge = this.activeBlocksGauges.get(key);
+ if (gauge != null) {
+ final long val = gauge.decrementAndGet();
+ if (val < 0) {
+ gauge.set(0);
+ }
+ }
+ }
+
+ /**
+ * Get or create per-repo gauge.
+ */
+ private AtomicLong getOrCreateRepoGauge(final String repoType, final String repoName, final String key) {
+ return this.activeBlocksGauges.computeIfAbsent(key, k -> {
+ final AtomicLong newGauge = new AtomicLong(0);
+ Gauge.builder("artipie.cooldown.active_blocks.repo", newGauge, AtomicLong::doubleValue)
+ .description("Number of active cooldown blocks per repository")
+ .tag("repo_type", repoType)
+ .tag("repo_name", repoName)
+ .register(this.registry);
+ return newGauge;
+ });
+ }
+
+ /**
+ * Compute total active blocks across all repositories.
+ * Called by Micrometer on each scrape - ensures gauge always emits.
+ *
+ * @return Total active blocks count
+ */
+ private double computeTotalActiveBlocks() {
+ return this.activeBlocksGauges.values().stream()
+ .mapToLong(AtomicLong::get)
+ .sum();
+ }
+
+ // ==================== Timers ====================
+
+ /**
+ * Record metadata filtering duration.
+ *
+ * @param repoType Repository type
+ * @param durationMs Duration in milliseconds
+ * @param versionsTotal Total versions in metadata
+ * @param versionsBlocked Number of blocked versions
+ */
+ public void recordFilterDuration(
+ final String repoType,
+ final long durationMs,
+ final int versionsTotal,
+ final int versionsBlocked
+ ) {
+ Timer.builder("artipie.cooldown.metadata.filter.duration")
+ .description("Cooldown metadata filtering duration")
+ .tag("repo_type", repoType)
+ .tag("versions_bucket", versionsBucket(versionsTotal))
+ .register(this.registry)
+ .record(durationMs, TimeUnit.MILLISECONDS);
+ }
+
+ /**
+ * Record per-version evaluation duration.
+ *
+ * @param repoType Repository type
+ * @param durationMs Duration in milliseconds
+ * @param blocked Whether version was blocked
+ */
+ public void recordEvaluateDuration(
+ final String repoType,
+ final long durationMs,
+ final boolean blocked
+ ) {
+ Timer.builder("artipie.cooldown.evaluate.duration")
+ .description("Per-version cooldown evaluation duration")
+ .tag("repo_type", repoType)
+ .tag("result", blocked ? "blocked" : "allowed")
+ .register(this.registry)
+ .record(durationMs, TimeUnit.MILLISECONDS);
+ }
+
+ /**
+ * Record cache load duration.
+ *
+ * @param durationMs Duration in milliseconds
+ */
+ public void recordCacheLoadDuration(final long durationMs) {
+ Timer.builder("artipie.cooldown.cache.load.duration")
+ .description("Cooldown cache load duration on miss")
+ .register(this.registry)
+ .record(durationMs, TimeUnit.MILLISECONDS);
+ }
+
+ /**
+ * Get versions bucket for histogram.
+ */
+ private static String versionsBucket(final int versions) {
+ if (versions <= 10) {
+ return "1-10";
+ } else if (versions <= 50) {
+ return "11-50";
+ } else if (versions <= 200) {
+ return "51-200";
+ } else if (versions <= 500) {
+ return "201-500";
+ } else {
+ return "500+";
+ }
+ }
+}
diff --git a/artipie-core/src/main/java/com/artipie/cooldown/metrics/package-info.java b/artipie-core/src/main/java/com/artipie/cooldown/metrics/package-info.java
new file mode 100644
index 000000000..6f371242e
--- /dev/null
+++ b/artipie-core/src/main/java/com/artipie/cooldown/metrics/package-info.java
@@ -0,0 +1,19 @@
+/*
+ * The MIT License (MIT) Copyright (c) 2020-2023 artipie.com
+ * https://github.com/artipie/artipie/blob/master/LICENSE.txt
+ */
+
+/**
+ * Cooldown metrics for observability.
+ *
+ * This package provides Micrometer-based metrics for cooldown functionality:
+ *
+ * - {@link com.artipie.cooldown.metrics.CooldownMetrics} - Central metrics facade
+ *
+ *
+ * All metrics use the prefix {@code artipie.cooldown.*} and are designed to be
+ * visualized in Grafana dashboards.
+ *
+ * @since 1.0
+ */
+package com.artipie.cooldown.metrics;
diff --git a/artipie-core/src/main/java/com/artipie/http/ArtipieHttpException.java b/artipie-core/src/main/java/com/artipie/http/ArtipieHttpException.java
index 819ad3db9..94f9b8e51 100644
--- a/artipie-core/src/main/java/com/artipie/http/ArtipieHttpException.java
+++ b/artipie-core/src/main/java/com/artipie/http/ArtipieHttpException.java
@@ -5,17 +5,17 @@
package com.artipie.http;
import com.artipie.ArtipieException;
-import com.artipie.http.rs.RsStatus;
import com.google.common.collect.ImmutableMap;
+
+import java.io.Serial;
import java.util.Map;
/**
* Base HTTP exception for Artipie endpoints.
- * @since 1.0
*/
-@SuppressWarnings("PMD.OnlyOneConstructorShouldDoInitialization")
public final class ArtipieHttpException extends ArtipieException {
+ @Serial
private static final long serialVersionUID = -16695752893817954L;
/**
@@ -94,7 +94,7 @@ public ArtipieHttpException(final RsStatus status, final String message) {
* @param cause Of the error
*/
public ArtipieHttpException(final RsStatus status, final String message,
- final Throwable cause) {
+ final Throwable cause) {
super(message, cause);
this.code = status;
}
@@ -112,7 +112,7 @@ public RsStatus status() {
* @param status HTTP status code for error
* @return Meaning string for this code
*/
- private static String meaning(final RsStatus status) {
- return ArtipieHttpException.MEANINGS.getOrDefault(status.code(), "Unknown");
+ private static String meaning(RsStatus status) {
+ return ArtipieHttpException.MEANINGS.getOrDefault(status.asString(), "Unknown");
}
}
diff --git a/artipie-core/src/main/java/com/artipie/http/Connection.java b/artipie-core/src/main/java/com/artipie/http/Connection.java
deleted file mode 100644
index cd0861954..000000000
--- a/artipie-core/src/main/java/com/artipie/http/Connection.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * The MIT License (MIT) Copyright (c) 2020-2023 artipie.com
- * https://github.com/artipie/artipie/blob/master/LICENSE.txt
- */
-package com.artipie.http;
-
-import com.artipie.http.rs.RsStatus;
-import java.nio.ByteBuffer;
-import java.util.Map;
-import java.util.concurrent.CompletionStage;
-import org.reactivestreams.Publisher;
-
-/**
- * The http connection.
- * @since 0.1
- */
-public interface Connection {
-
- /**
- * Respond on connection.
- * @param status The http status code.
- * @param headers The http response headers.
- * @param body The http response body.
- * @return Completion stage for accepting HTTP response.
- */
- CompletionStage accept(RsStatus status, Headers headers, Publisher body);
-
- /**
- * Respond on connection.
- * @param status The http status code.
- * @param headers The http response headers.
- * @param body The http response body.
- * @return Completion stage for accepting HTTP response.
- * @deprecated Use {@link Connection#accept(RsStatus, Headers, Publisher)}.
- */
- @Deprecated
- default CompletionStage accept(
- RsStatus status,
- Iterable> headers,
- Publisher body
- ) {
- return this.accept(status, new Headers.From(headers), body);
- }
-}
diff --git a/artipie-core/src/main/java/com/artipie/http/Headers.java b/artipie-core/src/main/java/com/artipie/http/Headers.java
index a1472f0ac..afba1bbb2 100644
--- a/artipie-core/src/main/java/com/artipie/http/Headers.java
+++ b/artipie-core/src/main/java/com/artipie/http/Headers.java
@@ -5,187 +5,139 @@
package com.artipie.http;
import com.artipie.http.headers.Header;
-import com.google.common.collect.Iterables;
+
+import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
+import java.util.List;
import java.util.Map;
-import java.util.Spliterator;
-import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
/**
* HTTP request headers.
- *
- * @since 0.8
- * @checkstyle InterfaceIsTypeCheck (2 lines)
*/
-public interface Headers extends Iterable> {
-
- /**
- * Empty headers.
- */
- Headers EMPTY = new From(Collections.emptyList());
-
- /**
- * {@link Headers} created from something.
- *
- * @since 0.8
- */
- final class From implements Headers {
-
- /**
- * Origin headers.
- */
- private final Iterable> origin;
-
- /**
- * Ctor.
- *
- * @param name Header name.
- * @param value Header value.
- */
- public From(final String name, final String value) {
- this(new Header(name, value));
- }
+public class Headers implements Iterable {
- /**
- * Ctor.
- *
- * @param origin Origin headers.
- * @param name Additional header name.
- * @param value Additional header value.
- */
- public From(
- final Iterable> origin,
- final String name, final String value
- ) {
- this(origin, new Header(name, value));
- }
+ public static Headers EMPTY = new Headers(Collections.emptyList());
- /**
- * Ctor.
- *
- * @param header Header.
- */
- public From(final Map.Entry header) {
- this(Collections.singleton(header));
- }
+ public static Headers from(String name, String value) {
+ return from(new Header(name, value));
+ }
- /**
- * Ctor.
- *
- * @param origin Origin headers.
- * @param additional Additional headers.
- */
- public From(
- final Iterable> origin,
- final Map.Entry additional
- ) {
- this(origin, Collections.singleton(additional));
- }
+ public static Headers from(Header header) {
+ List list = new ArrayList<>();
+ list.add(header);
+ return new Headers(list);
+ }
- /**
- * Ctor.
- *
- * @param origin Origin headers.
- */
- @SafeVarargs
- public From(final Map.Entry... origin) {
- this(Arrays.asList(origin));
- }
+ public static Headers from(Iterable> multiMap) {
+ return new Headers(
+ StreamSupport.stream(multiMap.spliterator(), false)
+ .map(Header::new)
+ .toList()
+ );
+ }
- /**
- * Ctor.
- *
- * @param origin Origin headers.
- * @param additional Additional headers.
- */
- @SafeVarargs
- public From(
- final Iterable> origin,
- final Map.Entry... additional
- ) {
- this(origin, Arrays.asList(additional));
- }
+ @SafeVarargs
+ public static Headers from(Map.Entry... entries) {
+ return new Headers(Arrays.stream(entries).map(Header::new).toList());
+ }
- /**
- * Ctor.
- *
- * @param origin Origin headers.
- * @param additional Additional headers.
- */
- public From(
- final Iterable> origin,
- final Iterable> additional
- ) {
- this(Iterables.concat(origin, additional));
- }
+ private final List headers;
- /**
- * Ctor.
- *
- * @param origin Origin headers.
- */
- public From(final Iterable> origin) {
- this.origin = origin;
- }
+ public Headers() {
+ this.headers = new ArrayList<>();
+ }
- @Override
- public Iterator> iterator() {
- return this.origin.iterator();
- }
+ public Headers(List headers) {
+ this.headers = headers;
+ }
- @Override
- public void forEach(final Consumer> action) {
- this.origin.forEach(action);
- }
+ public Headers add(String name, String value) {
+ headers.add(new Header(name, value));
+ return this;
+ }
- @Override
- public Spliterator> spliterator() {
- return this.origin.spliterator();
+ public Headers add(Header header, boolean overwrite) {
+ if (overwrite) {
+ headers.removeIf(h -> h.getKey().equals(header.getKey()));
}
+ headers.add(header);
+ return this;
}
- /**
- * Abstract decorator for {@link Headers}.
- * @since 0.10
- */
- abstract class Wrap implements Headers {
+ public Headers add(Header header) {
+ headers.add(header);
+ return this;
+ }
- /**
- * Origin headers.
- */
- private final Iterable> origin;
+ public Headers add(Map.Entry entry) {
+ return add(entry.getKey(), entry.getValue());
+ }
- /**
- * Ctor.
- * @param origin Origin headers
- */
- protected Wrap(final Iterable> origin) {
- this.origin = origin;
- }
+ public Headers addAll(Headers src) {
+ headers.addAll(src.headers);
+ return this;
+ }
- /**
- * Ctor.
- * @param origin Origin headers
- */
- protected Wrap(final Header... origin) {
- this(Arrays.asList(origin));
- }
+ public Headers copy() {
+ return new Headers(new ArrayList<>(headers));
+ }
- @Override
- public final Iterator> iterator() {
- return this.origin.iterator();
- }
+ public boolean isEmpty() {
+ return headers.isEmpty();
+ }
- @Override
- public final void forEach(final Consumer> action) {
- this.origin.forEach(action);
- }
+ public List values(String name) {
+ return headers.stream()
+ .filter(h -> h.getKey().equalsIgnoreCase(name))
+ .map(Header::getValue)
+ .toList();
+ }
- @Override
- public final Spliterator> spliterator() {
- return this.origin.spliterator();
+ public List find(String name) {
+ return headers.stream()
+ .filter(h -> h.getKey().equalsIgnoreCase(name))
+ .toList();
+ }
+
+ public Header single(String name) {
+ List res = find(name);
+ if (res.isEmpty()) {
+ throw new IllegalStateException("Header '" + name + "' is not found");
+ }
+ if (res.size() > 1) {
+ throw new IllegalStateException("Too many headers '" + name + "' are found");
}
+ return res.getFirst();
+ }
+
+ @Override
+ public Iterator iterator() {
+ return headers.iterator();
+ }
+
+ public Stream stream() {
+ return headers.stream();
+ }
+
+ public List asList() {
+ return new ArrayList<>(headers);
+ }
+
+ public String asString() {
+ return headers.stream()
+ .map(h -> h.getKey() + '=' + h.getValue())
+ .collect(Collectors.joining(";"));
+ }
+
+ @Override
+ public String toString() {
+ return "Headers{" +
+ "headers=" + headers +
+ '}';
}
}
diff --git a/artipie-core/src/main/java/com/artipie/http/RangeSpec.java b/artipie-core/src/main/java/com/artipie/http/RangeSpec.java
new file mode 100644
index 000000000..7c8cbfe5f
--- /dev/null
+++ b/artipie-core/src/main/java/com/artipie/http/RangeSpec.java
@@ -0,0 +1,139 @@
+/*
+ * The MIT License (MIT) Copyright (c) 2020-2023 artipie.com
+ * https://github.com/artipie/artipie/blob/master/LICENSE.txt
+ */
+package com.artipie.http;
+
+import java.util.Optional;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * HTTP Range header parser and validator.
+ * Supports byte ranges in format: "bytes=start-end"
+ *
+ * @since 1.0
+ */
+public final class RangeSpec {
+
+ /**
+ * Pattern for parsing Range header: "bytes=start-end"
+ */
+ private static final Pattern RANGE_PATTERN = Pattern.compile("bytes=(\\d+)-(\\d*)");
+
+ /**
+ * Start byte (inclusive).
+ */
+ private final long start;
+
+ /**
+ * End byte (inclusive), -1 means to end of file.
+ */
+ private final long end;
+
+ /**
+ * Constructor.
+ * @param start Start byte (inclusive)
+ * @param end End byte (inclusive), -1 for end of file
+ */
+ public RangeSpec(final long start, final long end) {
+ this.start = start;
+ this.end = end;
+ }
+
+ /**
+ * Parse Range header.
+ * @param header Range header value (e.g., "bytes=0-1023")
+ * @return RangeSpec if valid, empty otherwise
+ */
+ public static Optional parse(final String header) {
+ if (header == null || header.isEmpty()) {
+ return Optional.empty();
+ }
+
+ final Matcher matcher = RANGE_PATTERN.matcher(header.trim());
+ if (!matcher.matches()) {
+ return Optional.empty();
+ }
+
+ try {
+ final long start = Long.parseLong(matcher.group(1));
+ final long end;
+
+ final String endStr = matcher.group(2);
+ if (endStr == null || endStr.isEmpty()) {
+ end = -1; // To end of file
+ } else {
+ end = Long.parseLong(endStr);
+ }
+
+ if (start < 0 || (end != -1 && end < start)) {
+ return Optional.empty();
+ }
+
+ return Optional.of(new RangeSpec(start, end));
+ } catch (NumberFormatException e) {
+ return Optional.empty();
+ }
+ }
+
+ /**
+ * Check if range is valid for given file size.
+ * @param fileSize Total file size in bytes
+ * @return True if valid
+ */
+ public boolean isValid(final long fileSize) {
+ if (this.start >= fileSize) {
+ return false;
+ }
+ if (this.end != -1 && this.end >= fileSize) {
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * Get start byte position.
+ * @return Start byte (inclusive)
+ */
+ public long start() {
+ return this.start;
+ }
+
+ /**
+ * Get end byte position for given file size.
+ * @param fileSize Total file size
+ * @return End byte (inclusive)
+ */
+ public long end(final long fileSize) {
+ return this.end == -1 ? fileSize - 1 : this.end;
+ }
+
+ /**
+ * Get length of range for given file size.
+ * @param fileSize Total file size
+ * @return Number of bytes in range
+ */
+ public long length(final long fileSize) {
+ return end(fileSize) - this.start + 1;
+ }
+
+ /**
+ * Format as Content-Range header value.
+ * @param fileSize Total file size
+ * @return Content-Range header value (e.g., "bytes 0-1023/2048")
+ */
+ public String toContentRange(final long fileSize) {
+ return String.format(
+ "bytes %d-%d/%d",
+ this.start,
+ end(fileSize),
+ fileSize
+ );
+ }
+
+ @Override
+ public String toString() {
+ return String.format("bytes=%d-%s", this.start, this.end == -1 ? "" : this.end);
+ }
+}
diff --git a/artipie-core/src/main/java/com/artipie/http/Response.java b/artipie-core/src/main/java/com/artipie/http/Response.java
index 1a6768975..2844cb1a9 100644
--- a/artipie-core/src/main/java/com/artipie/http/Response.java
+++ b/artipie-core/src/main/java/com/artipie/http/Response.java
@@ -4,55 +4,16 @@
*/
package com.artipie.http;
-import com.artipie.http.rs.StandardRs;
-import java.util.concurrent.CompletionStage;
+import com.artipie.asto.Content;
-/**
- * HTTP response.
- * @see RFC2616
- * @since 0.1
- */
-public interface Response {
-
- /**
- * Empty response.
- * @deprecated Use {@link StandardRs#EMPTY}.
- */
- @Deprecated
- Response EMPTY = StandardRs.EMPTY;
-
- /**
- * Send the response.
- *
- * @param connection Connection to send the response to
- * @return Completion stage for sending response to the connection.
- */
- CompletionStage send(Connection connection);
-
- /**
- * Abstract decorator for Response.
- *
- * @since 0.9
- */
- abstract class Wrap implements Response {
-
- /**
- * Origin response.
- */
- private final Response response;
-
- /**
- * Ctor.
- *
- * @param response Response.
- */
- protected Wrap(final Response response) {
- this.response = response;
- }
+public record Response(RsStatus status, Headers headers, Content body) {
- @Override
- public final CompletionStage send(final Connection connection) {
- return this.response.send(connection);
- }
+ @Override
+ public String toString() {
+ return "Response{" +
+ "status=" + status +
+ ", headers=" + headers +
+ ", hasBody=" + body.size().map(s -> s > 0).orElse(false) +
+ '}';
}
}
diff --git a/artipie-core/src/main/java/com/artipie/http/ResponseBuilder.java b/artipie-core/src/main/java/com/artipie/http/ResponseBuilder.java
new file mode 100644
index 000000000..1aad820ad
--- /dev/null
+++ b/artipie-core/src/main/java/com/artipie/http/ResponseBuilder.java
@@ -0,0 +1,290 @@
+/*
+ * The MIT License (MIT) Copyright (c) 2020-2023 artipie.com
+ * https://github.com/artipie/artipie/blob/master/LICENSE.txt
+ */
+package com.artipie.http;
+
+import com.artipie.asto.Content;
+import com.artipie.http.headers.ContentLength;
+import com.artipie.http.headers.ContentType;
+import com.artipie.http.headers.Header;
+import org.reactivestreams.Publisher;
+
+import javax.json.JsonStructure;
+import java.nio.ByteBuffer;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.util.concurrent.CompletableFuture;
+
+public class ResponseBuilder {
+
+ public static ResponseBuilder from(RsStatus status) {
+ return new ResponseBuilder(status);
+ }
+
+ public static ResponseBuilder ok() {
+ return new ResponseBuilder(RsStatus.OK);
+ }
+
+ public static ResponseBuilder created() {
+ return new ResponseBuilder(RsStatus.CREATED);
+ }
+
+ public static ResponseBuilder accepted() {
+ return new ResponseBuilder(RsStatus.ACCEPTED);
+ }
+
+ public static ResponseBuilder temporaryRedirect() {
+ return new ResponseBuilder(RsStatus.TEMPORARY_REDIRECT);
+ }
+
+ public static ResponseBuilder proxyAuthenticationRequired() {
+ return new ResponseBuilder(RsStatus.PROXY_AUTHENTICATION_REQUIRED);
+ }
+
+ public static ResponseBuilder movedPermanently() {
+ return new ResponseBuilder(RsStatus.MOVED_PERMANENTLY);
+ }
+
+ public static ResponseBuilder notFound() {
+ return new ResponseBuilder(RsStatus.NOT_FOUND);
+ }
+
+ public static ResponseBuilder noContent() {
+ return new ResponseBuilder(RsStatus.NO_CONTENT);
+ }
+
+ public static ResponseBuilder unavailable() {
+ return new ResponseBuilder(RsStatus.SERVICE_UNAVAILABLE);
+ }
+
+ public static ResponseBuilder unauthorized() {
+ return new ResponseBuilder(RsStatus.UNAUTHORIZED);
+ }
+
+ public static ResponseBuilder forbidden() {
+ return new ResponseBuilder(RsStatus.FORBIDDEN);
+ }
+
+ public static ResponseBuilder methodNotAllowed() {
+ return new ResponseBuilder(RsStatus.METHOD_NOT_ALLOWED);
+ }
+
+ public static ResponseBuilder badRequest() {
+ return new ResponseBuilder(RsStatus.BAD_REQUEST);
+ }
+
+ public static ResponseBuilder badRequest(Throwable error) {
+ return new ResponseBuilder(RsStatus.BAD_REQUEST)
+ .body(errorBody(error));
+ }
+
+ public static ResponseBuilder payloadTooLarge() {
+ return new ResponseBuilder(RsStatus.REQUEST_TOO_LONG);
+ }
+
+ public static ResponseBuilder internalError() {
+ return new ResponseBuilder(RsStatus.INTERNAL_ERROR);
+ }
+
+ public static ResponseBuilder internalError(Throwable error) {
+ return new ResponseBuilder(RsStatus.INTERNAL_ERROR)
+ .body(errorBody(error));
+ }
+
+ public static ResponseBuilder partialContent() {
+ return new ResponseBuilder(RsStatus.PARTIAL_CONTENT);
+ }
+
+ public static ResponseBuilder rangeNotSatisfiable() {
+ return new ResponseBuilder(RsStatus.REQUESTED_RANGE_NOT_SATISFIABLE);
+ }
+
+ public static ResponseBuilder gatewayTimeout() {
+ return new ResponseBuilder(RsStatus.GATEWAY_TIMEOUT);
+ }
+
+ public static ResponseBuilder serviceUnavailable(String message) {
+ return new ResponseBuilder(RsStatus.SERVICE_UNAVAILABLE)
+ .textBody(message);
+ }
+
+ private static byte[] errorBody(Throwable error) {
+ StringBuilder res = new StringBuilder();
+ res.append(error.getMessage()).append('\n');
+ Throwable cause = error.getCause();
+ if (cause != null) {
+ res.append(cause.getMessage()).append('\n');
+ if (cause.getSuppressed() != null) {
+ for (final Throwable suppressed : cause.getSuppressed()) {
+ res.append(suppressed.getMessage()).append('\n');
+ }
+ }
+ }
+ return res.toString().getBytes();
+ }
+
+ private final RsStatus status;
+ private Headers headers;
+ private Content body;
+
+ ResponseBuilder(RsStatus status) {
+ this.status = status;
+ this.headers = new Headers();
+ this.body = Content.EMPTY;
+ }
+
+ public ResponseBuilder headers(Headers headers) {
+ this.headers = headers.copy();
+ return this;
+ }
+
+ public ResponseBuilder header(String name, String val) {
+ this.headers.add(name, val);
+ return this;
+ }
+
+ public ResponseBuilder header(Header header) {
+ this.headers.add(header, false);
+ return this;
+ }
+
+ public ResponseBuilder header(Header header, boolean overwrite) {
+ this.headers.add(header, overwrite);
+ return this;
+ }
+
+ public ResponseBuilder body(Publisher body) {
+ return body(new Content.From(body));
+ }
+
+ public ResponseBuilder body(Content body) {
+ this.body = body;
+ this.body.size().ifPresent(val -> header(new ContentLength(val), true));
+ return this;
+ }
+
+ public ResponseBuilder body(byte[] body) {
+ return this.body(new Content.From(body));
+ }
+
+ public ResponseBuilder textBody(String text) {
+ return textBody(text, StandardCharsets.UTF_8);
+ }
+
+ public ResponseBuilder textBody(String text, Charset charset) {
+ this.body = new Content.From(text.getBytes(charset));
+ this.headers.add(ContentType.text(charset))
+ .add(new ContentLength(body.size().orElseThrow()));
+ return this;
+ }
+
+ public ResponseBuilder jsonBody(JsonStructure json) {
+ return jsonBody(json, StandardCharsets.UTF_8);
+ }
+
+ public ResponseBuilder jsonBody(String json) {
+ return jsonBody(json, StandardCharsets.UTF_8);
+ }
+
+ public ResponseBuilder jsonBody(JsonStructure json, Charset charset) {
+ return jsonBody(json.toString(), charset);
+ }
+
+ public ResponseBuilder jsonBody(String json, Charset charset) {
+ this.body = new Content.From(json.getBytes(charset));
+ headers.add(ContentType.json(charset))
+ .add(new ContentLength(body.size().orElseThrow())
+ );
+ return this;
+ }
+
+ public ResponseBuilder yamlBody(String yaml) {
+ return yamlBody(yaml, StandardCharsets.UTF_8);
+ }
+
+ public ResponseBuilder yamlBody(String yaml, Charset charset) {
+ this.body = new Content.From(yaml.getBytes(charset));
+ this.headers.add(ContentType.yaml(charset))
+ .add(new ContentLength(body.size().orElseThrow()));
+ return this;
+ }
+
+ public ResponseBuilder htmlBody(String html, Charset charset) {
+ this.body = new Content.From(html.getBytes(charset));
+ this.headers.add(ContentType.html(charset))
+ .add(new ContentLength(body.size().orElseThrow()));
+ return this;
+ }
+
+ public Response build() {
+ if (headers.isEmpty() && body == Content.EMPTY) {
+ return switch (status) {
+ case CONTINUE -> RSP_CONTINUE;
+ case OK -> RSP_OK;
+ case CREATED -> RSP_CREATED;
+ case ACCEPTED -> RSP_ACCEPTED;
+ case NO_CONTENT -> RSP_NO_CONTENT;
+ case MOVED_PERMANENTLY -> RSP_MOVED_PERMANENTLY;
+ case MOVED_TEMPORARILY -> RSP_MOVED_TEMPORARILY;
+ case NOT_MODIFIED -> RSP_NOT_MODIFIED;
+ case TEMPORARY_REDIRECT -> RSP_TEMPORARY_REDIRECT;
+ case PROXY_AUTHENTICATION_REQUIRED -> RSP_PROXY_AUTH_REQUIRED;
+ case BAD_REQUEST -> RSP_BAD_REQUEST;
+ case UNAUTHORIZED -> RSP_UNAUTHORIZED;
+ case FORBIDDEN -> RSP_FORBIDDEN;
+ case NOT_FOUND -> RSP_NOT_FOUND;
+ case METHOD_NOT_ALLOWED -> RSP_METHOD_NOT_ALLOWED;
+ case REQUEST_TIMEOUT -> RSP_REQUEST_TIMEOUT;
+ case CONFLICT -> RSP_CONFLICT;
+ case LENGTH_REQUIRED -> RSP_LENGTH_REQUIRED;
+ case PRECONDITION_FAILED -> RSP_PRECONDITION_FAILED;
+ case REQUEST_TOO_LONG -> RSP_REQUEST_TOO_LONG;
+ case REQUESTED_RANGE_NOT_SATISFIABLE -> RSP_REQUESTED_RANGE_NOT_SATISFIABLE;
+ case EXPECTATION_FAILED -> RSP_EXPECTATION_FAILED;
+ case TOO_MANY_REQUESTS -> RSP_TOO_MANY_REQUESTS;
+ case INTERNAL_ERROR -> RSP_INTERNAL_ERROR;
+ case NOT_IMPLEMENTED -> RSP_NOT_IMPLEMENTED;
+ case SERVICE_UNAVAILABLE -> RSP_SERVICE_UNAVAILABLE;
+ case PARTIAL_CONTENT -> RSP_PARTIAL_CONTENT;
+ case GATEWAY_TIMEOUT -> RSP_GATEWAY_TIMEOUT;
+ };
+ }
+ return new Response(status, new UnmodifiableHeaders(headers.asList()), body);
+ }
+
+ public CompletableFuture completedFuture() {
+ return CompletableFuture.completedFuture(build());
+ }
+
+ private final static Response RSP_OK = new Response(RsStatus.OK, Headers.EMPTY, Content.EMPTY);
+ private final static Response RSP_NOT_FOUND = new Response(RsStatus.NOT_FOUND, Headers.EMPTY, Content.EMPTY);
+ private final static Response RSP_PROXY_AUTH_REQUIRED =
+ new Response(RsStatus.PROXY_AUTHENTICATION_REQUIRED, Headers.EMPTY, Content.EMPTY);
+ private final static Response RSP_CONTINUE = new Response(RsStatus.CONTINUE, Headers.EMPTY, Content.EMPTY);
+ private final static Response RSP_CREATED = new Response(RsStatus.CREATED, Headers.EMPTY, Content.EMPTY);
+ private final static Response RSP_ACCEPTED = new Response(RsStatus.ACCEPTED, Headers.EMPTY, Content.EMPTY);
+ private final static Response RSP_NO_CONTENT = new Response(RsStatus.NO_CONTENT, Headers.EMPTY, Content.EMPTY);
+ private final static Response RSP_MOVED_PERMANENTLY = new Response(RsStatus.MOVED_PERMANENTLY, Headers.EMPTY, Content.EMPTY);
+ private final static Response RSP_MOVED_TEMPORARILY = new Response(RsStatus.MOVED_TEMPORARILY, Headers.EMPTY, Content.EMPTY);
+ private final static Response RSP_NOT_MODIFIED = new Response(RsStatus.NOT_MODIFIED, Headers.EMPTY, Content.EMPTY);
+ private final static Response RSP_TEMPORARY_REDIRECT = new Response(RsStatus.TEMPORARY_REDIRECT, Headers.EMPTY, Content.EMPTY);
+ private final static Response RSP_BAD_REQUEST = new Response(RsStatus.BAD_REQUEST, Headers.EMPTY, Content.EMPTY);
+ private final static Response RSP_UNAUTHORIZED = new Response(RsStatus.UNAUTHORIZED, Headers.EMPTY, Content.EMPTY);
+ private final static Response RSP_FORBIDDEN = new Response(RsStatus.FORBIDDEN, Headers.EMPTY, Content.EMPTY);
+ private final static Response RSP_METHOD_NOT_ALLOWED = new Response(RsStatus.METHOD_NOT_ALLOWED, Headers.EMPTY, Content.EMPTY);
+ private final static Response RSP_REQUEST_TIMEOUT = new Response(RsStatus.REQUEST_TIMEOUT, Headers.EMPTY, Content.EMPTY);
+ private final static Response RSP_CONFLICT = new Response(RsStatus.CONFLICT, Headers.EMPTY, Content.EMPTY);
+ private final static Response RSP_LENGTH_REQUIRED = new Response(RsStatus.LENGTH_REQUIRED, Headers.EMPTY, Content.EMPTY);
+ private final static Response RSP_PRECONDITION_FAILED =
+ new Response(RsStatus.PRECONDITION_FAILED, Headers.EMPTY, Content.EMPTY);
+ private final static Response RSP_REQUEST_TOO_LONG = new Response(RsStatus.REQUEST_TOO_LONG, Headers.EMPTY, Content.EMPTY);
+ private final static Response RSP_REQUESTED_RANGE_NOT_SATISFIABLE = new Response(RsStatus.REQUESTED_RANGE_NOT_SATISFIABLE, Headers.EMPTY, Content.EMPTY);
+ private final static Response RSP_EXPECTATION_FAILED = new Response(RsStatus.EXPECTATION_FAILED, Headers.EMPTY, Content.EMPTY);
+ private final static Response RSP_TOO_MANY_REQUESTS = new Response(RsStatus.TOO_MANY_REQUESTS, Headers.EMPTY, Content.EMPTY);
+ private final static Response RSP_INTERNAL_ERROR = new Response(RsStatus.INTERNAL_ERROR, Headers.EMPTY, Content.EMPTY);
+ private final static Response RSP_NOT_IMPLEMENTED = new Response(RsStatus.NOT_IMPLEMENTED, Headers.EMPTY, Content.EMPTY);
+ private final static Response RSP_SERVICE_UNAVAILABLE = new Response(RsStatus.SERVICE_UNAVAILABLE, Headers.EMPTY, Content.EMPTY);
+ private final static Response RSP_PARTIAL_CONTENT = new Response(RsStatus.PARTIAL_CONTENT, Headers.EMPTY, Content.EMPTY);
+ private final static Response RSP_GATEWAY_TIMEOUT = new Response(RsStatus.GATEWAY_TIMEOUT, Headers.EMPTY, Content.EMPTY);
+}
diff --git a/artipie-core/src/main/java/com/artipie/http/ResponseException.java b/artipie-core/src/main/java/com/artipie/http/ResponseException.java
new file mode 100644
index 000000000..d84260970
--- /dev/null
+++ b/artipie-core/src/main/java/com/artipie/http/ResponseException.java
@@ -0,0 +1,34 @@
+/*
+ * The MIT License (MIT) Copyright (c) 2020-2023 artipie.com
+ * https://github.com/artipie/artipie/blob/master/LICENSE.txt
+ */
+package com.artipie.http;
+
+/**
+ * Runtime exception carrying pre-built HTTP response.
+ *
+ * @since 1.0
+ */
+public final class ResponseException extends RuntimeException {
+
+ private final Response response;
+
+ /**
+ * Ctor.
+ *
+ * @param response Response to return
+ */
+ public ResponseException(final Response response) {
+ super(response.toString());
+ this.response = response;
+ }
+
+ /**
+ * Exception response.
+ *
+ * @return Response
+ */
+ public Response response() {
+ return this.response;
+ }
+}
diff --git a/artipie-core/src/main/java/com/artipie/http/ResponseUtils.java b/artipie-core/src/main/java/com/artipie/http/ResponseUtils.java
new file mode 100644
index 000000000..4a10aeefb
--- /dev/null
+++ b/artipie-core/src/main/java/com/artipie/http/ResponseUtils.java
@@ -0,0 +1,124 @@
+/*
+ * The MIT License (MIT) Copyright (c) 2020-2023 artipie.com
+ * https://github.com/artipie/artipie/blob/master/LICENSE.txt
+ */
+package com.artipie.http;
+
+import java.util.concurrent.CompletableFuture;
+
+/**
+ * Utility methods for Response handling to prevent memory leaks.
+ *
+ * These utilities ensure response bodies are properly consumed
+ * even when the response is discarded (e.g., 404s, race conditions).
+ * This prevents Vert.x HTTP server request leaks where the active
+ * request counter never decrements.
+ *
+ * @since 1.0
+ */
+public final class ResponseUtils {
+
+ /**
+ * Private constructor to prevent instantiation.
+ */
+ private ResponseUtils() {
+ }
+
+ /**
+ * Consume response body and discard it.
+ * Used when response is not needed (e.g., lost parallel race, 404 in multi-repo lookup).
+ *
+ * CRITICAL: Always consume response bodies before discarding
+ * to prevent Vert.x request leaks. Vert.x keeps requests "active" until
+ * the body Publisher is fully consumed or canceled.
+ *
+ * @param response Response to consume and discard
+ * @return CompletableFuture that completes when body is consumed
+ */
+ public static CompletableFuture consumeAndDiscard(final Response response) {
+ return response.body().asBytesFuture().thenApply(ignored -> null);
+ }
+
+ /**
+ * Consume response body and return a 404 response.
+ * Used in error handling where we need to consume the error response
+ * body before returning 404 to the client.
+ *
+ * @param response Response to consume
+ * @return CompletableFuture that resolves to 404
+ */
+ public static CompletableFuture consumeAndReturn404(final Response response) {
+ return response.body().asBytesFuture().thenApply(ignored ->
+ ResponseBuilder.notFound().build()
+ );
+ }
+
+ /**
+ * Consume response body and return a custom response.
+ * Used when we need to consume the body but return a different response.
+ *
+ * @param response Response whose body should be consumed
+ * @param replacement Response to return after consumption
+ * @return CompletableFuture that resolves to replacement
+ */
+ public static CompletableFuture consumeAndReturn(
+ final Response response,
+ final Response replacement
+ ) {
+ return response.body().asBytesFuture().thenApply(ignored -> replacement);
+ }
+
+ /**
+ * Consume response body and throw an exception.
+ * Used when converting error responses to exceptions (e.g., upstream failures).
+ *
+ * CRITICAL: Must consume body BEFORE throwing exception
+ * to prevent Vert.x request leaks on error paths.
+ *
+ * @param response Response to consume
+ * @param exception Exception to throw after consumption
+ * @param Return type (will never actually return, always throws)
+ * @return CompletableFuture that fails with exception after consuming body
+ */
+ public static CompletableFuture consumeAndFail(
+ final Response response,
+ final Throwable exception
+ ) {
+ return response.body().asBytesFuture().thenCompose(ignored ->
+ CompletableFuture.failedFuture(exception)
+ );
+ }
+
+ /**
+ * Check if response indicates success and consume if not.
+ * Common pattern for proxy implementations that only care about successful responses.
+ *
+ * @param response Response to check
+ * @return CompletableFuture - true if success (body NOT consumed),
+ * false if not success (body consumed)
+ */
+ public static CompletableFuture isSuccessOrConsume(final Response response) {
+ if (response.status().success()) {
+ return CompletableFuture.completedFuture(true);
+ }
+ return response.body().asBytesFuture().thenApply(ignored -> false);
+ }
+
+ /**
+ * Consume body only if condition is true, otherwise pass through.
+ * Used in conditional logic where response might be used or discarded.
+ *
+ * @param response Response to potentially consume
+ * @param shouldConsume Whether to consume the body
+ * @return CompletableFuture - same response if not consumed, null if consumed
+ */
+ public static CompletableFuture consumeIf(
+ final Response response,
+ final boolean shouldConsume
+ ) {
+ if (shouldConsume) {
+ return response.body().asBytesFuture().thenApply(ignored -> null);
+ }
+ return CompletableFuture.completedFuture(response);
+ }
+}
diff --git a/artipie-core/src/main/java/com/artipie/http/rs/RsStatus.java b/artipie-core/src/main/java/com/artipie/http/RsStatus.java
similarity index 59%
rename from artipie-core/src/main/java/com/artipie/http/rs/RsStatus.java
rename to artipie-core/src/main/java/com/artipie/http/RsStatus.java
index bbc060e03..edfff24e5 100644
--- a/artipie-core/src/main/java/com/artipie/http/rs/RsStatus.java
+++ b/artipie-core/src/main/java/com/artipie/http/RsStatus.java
@@ -2,134 +2,147 @@
* The MIT License (MIT) Copyright (c) 2020-2023 artipie.com
* https://github.com/artipie/artipie/blob/master/LICENSE.txt
*/
-package com.artipie.http.rs;
+package com.artipie.http;
+
+
+import org.apache.hc.core5.http.HttpStatus;
import java.util.stream.Stream;
-import javax.annotation.Nullable;
/**
* HTTP response status code.
* See RFC 2616 6.1.1 Status Code and Reason Phrase
- *
- * @since 0.4
*/
public enum RsStatus {
/**
* Status Continue.
*/
- CONTINUE("100"),
+ CONTINUE(HttpStatus.SC_CONTINUE),
/**
* OK.
*/
- OK("200"),
+ OK(HttpStatus.SC_OK),
/**
* Created.
*/
- CREATED("201"),
+ CREATED(HttpStatus.SC_CREATED),
/**
* Accepted.
*/
- ACCEPTED("202"),
+ ACCEPTED(HttpStatus.SC_ACCEPTED),
/**
* No Content.
*/
- NO_CONTENT("204"),
+ NO_CONTENT(HttpStatus.SC_NO_CONTENT),
+ /**
+ * Partial Content (206) - Range request.
+ */
+ PARTIAL_CONTENT(HttpStatus.SC_PARTIAL_CONTENT),
/**
* Moved Permanently.
*/
- MOVED_PERMANENTLY("301"),
+ MOVED_PERMANENTLY(HttpStatus.SC_MOVED_PERMANENTLY),
/**
* Found.
*/
- FOUND("302"),
+ MOVED_TEMPORARILY(HttpStatus.SC_MOVED_TEMPORARILY),
/**
* Not Modified.
*/
- NOT_MODIFIED("304"),
+ NOT_MODIFIED(HttpStatus.SC_NOT_MODIFIED),
/**
* Temporary Redirect.
*/
- @SuppressWarnings("PMD.LongVariable")
- TEMPORARY_REDIRECT("307"),
+ TEMPORARY_REDIRECT(HttpStatus.SC_TEMPORARY_REDIRECT),
+ /**
+ * Proxy Authentication Required.
+ */
+ PROXY_AUTHENTICATION_REQUIRED(HttpStatus.SC_PROXY_AUTHENTICATION_REQUIRED),
/**
* Bad Request.
*/
- BAD_REQUEST("400"),
+ BAD_REQUEST(HttpStatus.SC_BAD_REQUEST),
/**
* Unauthorized.
*/
- UNAUTHORIZED("401"),
+ UNAUTHORIZED(HttpStatus.SC_UNAUTHORIZED),
/**
* Forbidden.
*/
- FORBIDDEN("403"),
+ FORBIDDEN(HttpStatus.SC_FORBIDDEN),
/**
* Not Found.
*/
- NOT_FOUND("404"),
+ NOT_FOUND(HttpStatus.SC_NOT_FOUND),
/**
* Method Not Allowed.
*/
@SuppressWarnings("PMD.LongVariable")
- METHOD_NOT_ALLOWED("405"),
+ METHOD_NOT_ALLOWED(HttpStatus.SC_METHOD_NOT_ALLOWED),
/**
* Request Time-out.
*/
- REQUEST_TIMEOUT("408"),
+ REQUEST_TIMEOUT(HttpStatus.SC_REQUEST_TIMEOUT),
/**
* Conflict.
*/
- CONFLICT("409"),
+ CONFLICT(HttpStatus.SC_CONFLICT),
/**
* Length Required.
*/
- LENGTH_REQUIRED("411"),
+ LENGTH_REQUIRED(HttpStatus.SC_LENGTH_REQUIRED),
+ /**
+ * Precondition Failed.
+ */
+ PRECONDITION_FAILED(HttpStatus.SC_PRECONDITION_FAILED),
/**
* Payload Too Large.
*/
- PAYLOAD_TOO_LARGE("413"),
+ REQUEST_TOO_LONG(HttpStatus.SC_REQUEST_TOO_LONG),
/**
* Requested Range Not Satisfiable.
*/
- BAD_RANGE("416"),
+ REQUESTED_RANGE_NOT_SATISFIABLE(HttpStatus.SC_REQUESTED_RANGE_NOT_SATISFIABLE),
/**
* Status
* Expectation Failed.
*/
- EXPECTATION_FAILED("417"),
- /**
- * Misdirected Request.
- */
- MISDIRECTED_REQUEST("421"),
+ EXPECTATION_FAILED(HttpStatus.SC_EXPECTATION_FAILED),
/**
* Too Many Requests.
*/
- TOO_MANY_REQUESTS("429"),
+ TOO_MANY_REQUESTS(HttpStatus.SC_TOO_MANY_REQUESTS),
/**
* Internal Server Error.
*/
- INTERNAL_ERROR("500"),
+ INTERNAL_ERROR(HttpStatus.SC_INTERNAL_SERVER_ERROR),
/**
* Not Implemented.
*/
- NOT_IMPLEMENTED("501"),
+ NOT_IMPLEMENTED(HttpStatus.SC_NOT_IMPLEMENTED),
/**
* Service Unavailable.
*/
- UNAVAILABLE("503");
+ SERVICE_UNAVAILABLE(HttpStatus.SC_SERVICE_UNAVAILABLE),
+ /**
+ * Gateway Timeout (504).
+ */
+ GATEWAY_TIMEOUT(HttpStatus.SC_GATEWAY_TIMEOUT);
/**
* Code value.
*/
- private final String string;
+ private final int code;
/**
- * Ctor.
- *
- * @param string Code value.
+ * @param code Code value.
*/
- RsStatus(final String string) {
- this.string = string;
+ RsStatus(int code) {
+ this.code = code;
+ }
+
+ public int code(){
+ return code;
}
/**
@@ -137,14 +150,13 @@ public enum RsStatus {
*
* @return Code as 3-digit string.
*/
- public String code() {
- return this.string;
+ public String asString() {
+ return String.valueOf(this.code);
}
/**
* Checks whether the RsStatus is an informational group (1xx).
* @return True if the RsStatus is 1xx, otherwise - false.
- * @since 0.16
*/
public boolean information() {
return this.firstSymbol('1');
@@ -153,7 +165,6 @@ public boolean information() {
/**
* Checks whether the RsStatus is a successful group (2xx).
* @return True if the RsStatus is 2xx, otherwise - false.
- * @since 0.16
*/
public boolean success() {
return this.firstSymbol('2');
@@ -162,7 +173,6 @@ public boolean success() {
/**
* Checks whether the RsStatus is a redirection.
* @return True if the RsStatus is 3xx, otherwise - false.
- * @since 0.16
*/
public boolean redirection() {
return this.firstSymbol('3');
@@ -171,7 +181,6 @@ public boolean redirection() {
/**
* Checks whether the RsStatus is a client error.
* @return True if the RsStatus is 4xx, otherwise - false.
- * @since 0.16
*/
public boolean clientError() {
return this.firstSymbol('4');
@@ -180,7 +189,6 @@ public boolean clientError() {
/**
* Checks whether the RsStatus is a server error.
* @return True if the RsStatus is 5xx, otherwise - false.
- * @since 0.16
*/
public boolean serverError() {
return this.firstSymbol('5');
@@ -189,7 +197,6 @@ public boolean serverError() {
/**
* Checks whether the RsStatus is an error.
* @return True if the RsStatus is an error, otherwise - false.
- * @since 0.16
*/
public boolean error() {
return this.clientError() || this.serverError();
@@ -199,53 +206,14 @@ public boolean error() {
* Checks whether the first character matches the symbol.
* @param symbol Symbol to check
* @return True if the first character matches the symbol, otherwise - false.
- * @since 0.16
*/
private boolean firstSymbol(final char symbol) {
- return this.string.charAt(0) == symbol;
+ return asString().charAt(0) == symbol;
}
- /**
- * Searches {@link RsStatus} instance by response code.
- * @since 0.11
- */
- public static class ByCode {
-
- /**
- * Status code.
- */
- private final String code;
-
- /**
- * Ctor.
- * @param code Code
- */
- public ByCode(@Nullable final String code) {
- this.code = code;
- }
-
- /**
- * Ctor.
- * @param code Code
- */
- public ByCode(final int code) {
- this(String.valueOf(code));
- }
-
- /**
- * Searches RsStatus by code.
- * @return RsStatus instance if found
- * @throws IllegalArgumentException If RsStatus is not found
- */
- public RsStatus find() {
- return Stream.of(RsStatus.values())
- .filter(status -> status.code().equals(this.code))
- .findAny()
- .orElseThrow(
- () -> new IllegalArgumentException(
- String.format("Unknown status code: `%s`", this.code)
- )
- );
- }
+ public static RsStatus byCode(int code) {
+ return Stream.of(RsStatus.values())
+ .filter(s -> s.code == code).findFirst()
+ .orElseThrow(() -> new IllegalArgumentException("Unsupported status code: " + code));
}
}
diff --git a/artipie-core/src/main/java/com/artipie/http/Slice.java b/artipie-core/src/main/java/com/artipie/http/Slice.java
index 61bb25fa0..99cb01d0d 100644
--- a/artipie-core/src/main/java/com/artipie/http/Slice.java
+++ b/artipie-core/src/main/java/com/artipie/http/Slice.java
@@ -4,9 +4,10 @@
*/
package com.artipie.http;
-import java.nio.ByteBuffer;
-import java.util.Map;
-import org.reactivestreams.Publisher;
+import com.artipie.asto.Content;
+import com.artipie.http.rq.RequestLine;
+
+import java.util.concurrent.CompletableFuture;
/**
* Arti-pie slice.
@@ -15,28 +16,21 @@
* Each Artipie adapter implements this interface to expose
* repository HTTP API.
* Artipie main module joins all slices together into solid web server.
- *
- * @since 0.1
*/
public interface Slice {
/**
* Respond to a http request.
- * @param line The request line
+ *
+ * @param line The request line
* @param headers The request headers
- * @param body The request body
+ * @param body The request body
* @return The response.
*/
- Response response(
- String line,
- Iterable> headers,
- Publisher body
- );
+ CompletableFuture response(RequestLine line, Headers headers, Content body);
/**
* SliceWrap is a simple decorative envelope for Slice.
- *
- * @since 0.7
*/
abstract class Wrap implements Slice {
@@ -46,8 +40,6 @@ abstract class Wrap implements Slice {
private final Slice slice;
/**
- * Ctor.
- *
* @param slice Slice.
*/
protected Wrap(final Slice slice) {
@@ -55,10 +47,7 @@ protected Wrap(final Slice slice) {
}
@Override
- public final Response response(
- final String line,
- final Iterable> headers,
- final Publisher body) {
+ public final CompletableFuture response(RequestLine line, Headers headers, Content body) {
return this.slice.response(line, headers, body);
}
}
diff --git a/artipie-core/src/main/java/com/artipie/http/UnmodifiableHeaders.java b/artipie-core/src/main/java/com/artipie/http/UnmodifiableHeaders.java
new file mode 100644
index 000000000..baff6eb64
--- /dev/null
+++ b/artipie-core/src/main/java/com/artipie/http/UnmodifiableHeaders.java
@@ -0,0 +1,46 @@
+/*
+ * The MIT License (MIT) Copyright (c) 2020-2023 artipie.com
+ * https://github.com/artipie/artipie/blob/master/LICENSE.txt
+ */
+package com.artipie.http;
+
+import com.artipie.http.headers.Header;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Unmodifiable list of HTTP request headers.
+ */
+public class UnmodifiableHeaders extends Headers {
+
+ UnmodifiableHeaders(List headers) {
+ super(Collections.unmodifiableList(headers));
+ }
+
+ @Override
+ public Headers add(String name, String value) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public Headers add(Header header, boolean overwrite) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public Headers add(Header header) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public Headers add(Map.Entry entry) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public Headers addAll(Headers src) {
+ throw new UnsupportedOperationException();
+ }
+}
diff --git a/artipie-core/src/main/java/com/artipie/http/async/AsyncResponse.java b/artipie-core/src/main/java/com/artipie/http/async/AsyncResponse.java
deleted file mode 100644
index 02f24a0ca..000000000
--- a/artipie-core/src/main/java/com/artipie/http/async/AsyncResponse.java
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * The MIT License (MIT) Copyright (c) 2020-2023 artipie.com
- * https://github.com/artipie/artipie/blob/master/LICENSE.txt
- */
-package com.artipie.http.async;
-
-import com.artipie.http.Connection;
-import com.artipie.http.Response;
-import hu.akarnokd.rxjava2.interop.SingleInterop;
-import io.reactivex.Single;
-import java.util.concurrent.CompletionStage;
-
-/**
- * Async response from {@link CompletionStage}.
- * @since 0.6
- */
-public final class AsyncResponse implements Response {
-
- /**
- * Source stage.
- */
- private final CompletionStage future;
-
- /**
- * Response from {@link Single}.
- * @param single Single
- */
- public AsyncResponse(final Single single) {
- this(single.to(SingleInterop.get()));
- }
-
- /**
- * Response from {@link CompletionStage}.
- * @param future Stage
- */
- public AsyncResponse(final CompletionStage future) {
- this.future = future;
- }
-
- @Override
- public CompletionStage send(final Connection connection) {
- return this.future.thenCompose(rsp -> rsp.send(connection));
- }
-
- @Override
- public String toString() {
- return String.format(
- "(%s: %s)",
- this.getClass().getSimpleName(),
- this.future.toString()
- );
- }
-}
diff --git a/artipie-core/src/main/java/com/artipie/http/async/AsyncSlice.java b/artipie-core/src/main/java/com/artipie/http/async/AsyncSlice.java
deleted file mode 100644
index 3ec2ee924..000000000
--- a/artipie-core/src/main/java/com/artipie/http/async/AsyncSlice.java
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * The MIT License (MIT) Copyright (c) 2020-2023 artipie.com
- * https://github.com/artipie/artipie/blob/master/LICENSE.txt
- */
-
-package com.artipie.http.async;
-
-import com.artipie.http.Response;
-import com.artipie.http.Slice;
-import java.nio.ByteBuffer;
-import java.util.Map;
-import java.util.concurrent.CompletionStage;
-import org.reactivestreams.Publisher;
-
-/**
- * Asynchronous {@link Slice} implementation.
- *
- * This slice encapsulates {@link CompletionStage} of {@link Slice} and returns {@link Response}.
- *
- * @since 0.4
- */
-public final class AsyncSlice implements Slice {
-
- /**
- * Async slice.
- */
- private final CompletionStage slice;
-
- /**
- * Ctor.
- * @param slice Async slice.
- */
- public AsyncSlice(final CompletionStage slice) {
- this.slice = slice;
- }
-
- @Override
- public Response response(
- final String line,
- final Iterable> headers,
- final Publisher body
- ) {
- return new AsyncResponse(
- this.slice.thenApply(target -> target.response(line, headers, body))
- );
- }
-}
diff --git a/artipie-core/src/main/java/com/artipie/http/async/package-info.java b/artipie-core/src/main/java/com/artipie/http/async/package-info.java
deleted file mode 100644
index b2db94a2a..000000000
--- a/artipie-core/src/main/java/com/artipie/http/async/package-info.java
+++ /dev/null
@@ -1,11 +0,0 @@
-/*
- * The MIT License (MIT) Copyright (c) 2020-2023 artipie.com
- * https://github.com/artipie/artipie/blob/master/LICENSE.txt
- */
-
-/**
- * Async implementations of {@link com.artipie.http.Slice}, {@link com.artipie.http.Response}, etc.
- * @since 0.4
- */
-package com.artipie.http.async;
-
diff --git a/artipie-core/src/main/java/com/artipie/http/auth/AuthLoader.java b/artipie-core/src/main/java/com/artipie/http/auth/AuthLoader.java
index 5982c5a5a..7e13e89cc 100644
--- a/artipie-core/src/main/java/com/artipie/http/auth/AuthLoader.java
+++ b/artipie-core/src/main/java/com/artipie/http/auth/AuthLoader.java
@@ -66,7 +66,6 @@ public String getFactoryName(final Class clazz) {
.map(inst -> ((ArtipieAuthFactory) inst).value())
.findFirst()
.orElseThrow(
- // @checkstyle LineLengthCheck (1 lines)
() -> new ArtipieException("Annotation 'ArtipieAuthFactory' should have a not empty value")
);
}
diff --git a/artipie-core/src/main/java/com/artipie/http/auth/AuthScheme.java b/artipie-core/src/main/java/com/artipie/http/auth/AuthScheme.java
index d4a464cc7..12ece41cf 100644
--- a/artipie-core/src/main/java/com/artipie/http/auth/AuthScheme.java
+++ b/artipie-core/src/main/java/com/artipie/http/auth/AuthScheme.java
@@ -4,7 +4,9 @@
*/
package com.artipie.http.auth;
-import java.util.Map;
+import com.artipie.http.Headers;
+import com.artipie.http.rq.RequestLine;
+
import java.util.Objects;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
@@ -12,16 +14,7 @@
/**
* Authentication scheme such as Basic, Bearer etc.
- *
- * @since 0.17
- * @checkstyle JavadocMethodCheck (500 lines)
- * @checkstyle JavadocVariableCheck (500 lines)
- * @checkstyle AvoidInlineConditionalsCheck (500 lines)
- * @checkstyle OperatorWrapCheck (500 lines)
- * @checkstyle StringLiteralsConcatenationCheck (500 lines)
*/
-@SuppressWarnings({"PMD.ProhibitPublicStaticMethods",
- "PMD.ConstructorOnlyInitializesOrCallOtherConstructors"})
public interface AuthScheme {
/**
@@ -43,7 +36,7 @@ public String challenge() {
* @param line Request line.
* @return Authentication result.
*/
- CompletionStage authenticate(Iterable> headers, String line);
+ CompletionStage authenticate(Headers headers, RequestLine line);
/**
* Authenticate HTTP request by its headers.
@@ -51,8 +44,8 @@ public String challenge() {
* @param headers Request headers.
* @return Authentication result.
*/
- default CompletionStage authenticate(Iterable> headers) {
- return this.authenticate(headers, "");
+ default CompletionStage authenticate(Headers headers) {
+ return this.authenticate(headers, null);
}
/**
@@ -209,8 +202,7 @@ public Fake() {
@Override
public CompletionStage authenticate(
- final Iterable> headers,
- final String line
+ Headers headers, RequestLine line
) {
return CompletableFuture.completedFuture(
AuthScheme.result(this.usr, this.chllng)
diff --git a/artipie-core/src/main/java/com/artipie/http/auth/Authentication.java b/artipie-core/src/main/java/com/artipie/http/auth/Authentication.java
index 9fc0dc43f..c07667452 100644
--- a/artipie-core/src/main/java/com/artipie/http/auth/Authentication.java
+++ b/artipie-core/src/main/java/com/artipie/http/auth/Authentication.java
@@ -5,22 +5,17 @@
package com.artipie.http.auth;
import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
-import java.util.stream.Stream;
/**
* Authentication mechanism to verify user.
- * @since 0.8
*/
public interface Authentication {
- /**
- * Resolve anyone as an anonymous user.
- */
- Authentication ANONYMOUS = (name, pswd) -> Optional.of(AuthUser.ANONYMOUS);
-
/**
* Find user by credentials.
* @param username Username
@@ -29,6 +24,24 @@ public interface Authentication {
*/
Optional user(String username, String password);
+ /**
+ * Check if this authentication provider can handle the given username.
+ * Used for domain-based routing to avoid trying providers that don't apply.
+ * @param username Username to check
+ * @return True if this provider should attempt authentication for this user
+ */
+ default boolean canHandle(final String username) {
+ return true; // Default: handle all users
+ }
+
+ /**
+ * Get configured user domain patterns for this provider.
+ * @return Collection of domain patterns (empty means handle all)
+ */
+ default Collection userDomains() {
+ return Collections.emptyList();
+ }
+
/**
* Abstract decorator for Authentication.
*
@@ -54,6 +67,16 @@ protected Wrap(final Authentication auth) {
public final Optional user(final String username, final String password) {
return this.auth.user(username, password);
}
+
+ @Override
+ public boolean canHandle(final String username) {
+ return this.auth.canHandle(username);
+ }
+
+ @Override
+ public Collection
-All Rest API endpoints require JWT authentication token to be passed in `Authentification` header.
+All Rest API endpoints require JWT authentication token to be passed in `Authorization: Bearer 
-[](http://t.me/artipie)
-
-[](https://www.elegantobjects.org)
-[](https://www.jetbrains.com/idea/)
-
-[](http://www.javadoc.io/doc/com.artipie/artipie)
-[](https://github.com/artipie/artipie/blob/master/LICENSE.txt)
-[](https://app.codecov.io/gh/artipie/artipie)
-[](https://hitsofcode.com/view/github/artipie/artipie)
-
-
-[](http://www.0pdd.com/p?name=artipie/artipie)
-
-Artipie is a binary artifact management tool, similar to
-[Artifactory](https://jfrog.com/artifactory/),
-[Nexus](https://www.sonatype.com/product-nexus-repository),
-[Archiva](https://archiva.apache.org/),
-[ProGet](https://inedo.com/proget),
-and many others.
-The following set of features makes Artipie unique among all others:
-
- * It is open source ([MIT license](https://github.com/artipie/artipie/blob/master/LICENSE.txt))
- * It is horizontally scalable, you can add servers easily
- * It is written in reactive Java (using [Vert.x](https://vertx.io/))
- * It supports
- [Maven](https://github.com/artipie/artipie/wiki/maven),
- [Docker](https://github.com/artipie/artipie/wiki/docker),
- [Rubygems](https://github.com/artipie/artipie/wiki/gem),
- [Go](https://github.com/artipie/artipie/wiki/go),
- [Helm](https://github.com/artipie/artipie/wiki/helm),
- [Npm](https://github.com/artipie/artipie/wiki/npm),
- [NuGet](https://github.com/artipie/artipie/wiki/nuget),
- [Composer](https://github.com/artipie/artipie/wiki/composer),
- [Pip](https://github.com/artipie/artipie/wiki/pypi),
- [Rpm](https://github.com/artipie/artipie/wiki/rpm),
- [Debian](https://github.com/artipie/artipie/wiki/debian),
- [Anaconda](https://github.com/artipie/artipie/wiki/anaconda)
- and [others](https://github.com/artipie/artipie/wiki/Configuration-Repository#supported-repository-types)
- * It is database-free
- * It can host the data in the file system, [Amazon S3](https://aws.amazon.com/s3/) or in a storage defined by user
- * Its quality of Java code is extraordinary high :)
-
-Learn more about Artipie in our [Wiki](https://github.com/artipie/artipie/wiki).
-
-**Publications about Artipie:**
-- [An Easy Way to Get Your Own Binary Repository](https://dzone.com/articles/easy-way-to-get-your-own-binary-repository#)
-- [Private Remote Maven Repository With Artipie](https://dzone.com/articles/private-remote-maven-repository-with-artipie-1)
-- [Deployment of NPM Repositories with Artipie](https://dev.to/andpopov/deployment-of-npm-repositories-with-artipie-30co)
-- [How I use Artipie, a PyPI repo](https://opensource.com/article/22/12/python-package-index-repository-artipie)
-- [Готовим приватные репозитории с помощью Artipie](https://habr.com/ru/post/687394/)
-
-
-# Quickstart
-
-Artipie is distributed as Docker container and as fat `jar`. The `jar` file can be downloaded on the
-GitHub [release page](https://github.com/artipie/artipie/releases) and here is a
-[Wiki page](https://github.com/artipie/artipie/wiki#how-to-start-artipie-service-with-a-maven-proxy-repository) describing how to start it.
-The fastest way to start Artipie is by using Docker container. First, make sure you have already installed [Docker Engine](https://docs.docker.com/get-docker/).
-Then, open command line and instruct Docker Engine to run Artipie container:
+# Artipie - Enterprise Binary Artifact Management (Auto1 Fork)
+
+[](LICENSE.txt)
+[](https://openjdk.org/)
+
+> **Auto1 Fork**: This is a production-hardened fork of the original [Artipie](https://github.com/artipie/artipie) project, significantly enhanced for enterprise-scale deployments. It includes performance optimizations, security features, and operational improvements developed for high-traffic production workloads.
+
+## What is Artipie?
+
+Artipie is a **binary artifact management platform** similar to [JFrog Artifactory](https://jfrog.com/artifactory/), [Sonatype Nexus](https://www.sonatype.com/product-nexus-repository), and [Apache Archiva](https://archiva.apache.org/). It provides a unified solution for hosting, proxying, and managing software packages across multiple ecosystems.
+
+### Key Features (Auto1 Fork)
+
+| Feature | Description |
+|---------|-------------|
+| **High Performance** | Built on reactive Java with [Vert.x](https://vertx.io/) for non-blocking I/O |
+| **Multi-Format Support** | 16+ package manager types in a single deployment |
+| **Supply Chain Security** | Cooldown system blocks fresh package versions to prevent attacks |
+| **Enterprise Auth** | OAuth/OIDC integration (Keycloak, Okta with MFA), JWT, RBAC |
+| **Cloud-Native Storage** | Optimized S3-compatible storage with memory-efficient streaming |
+| **Observability** | Prometheus metrics, ECS JSON structured logging, Elastic APM |
+| **Dynamic Configuration** | Create, update, delete repositories at runtime via REST API |
+| **Production-Ready** | Docker Compose stack with PostgreSQL, Valkey (Redis), Nginx, monitoring |
+
+### Fork-Specific Enhancements
+
+- **Cooldown System**: Configurable delay on new package versions (supply chain attack prevention)
+- **Okta OIDC Integration**: Full Okta authentication with MFA support (TOTP + push)
+- **S3 Performance**: Memory-optimized streaming, retry improvements, connection pooling
+- **File Descriptor Optimization**: High ulimit settings for many concurrent connections
+- **ECS JSON Logging**: Structured logging compatible with Elasticsearch/Kibana
+- **Docker Proxy Improvements**: Streaming optimization, timeout handling, multi-platform support
+- **NPM Proxy Deduplication**: Request deduplication for high-concurrency scenarios
+
+## Supported Repository Types
+
+| Type | Local | Proxy | Group | Description |
+|------|:-----:|:-----:|:-----:|-------------|
+| **Maven** | Yes | Yes | Yes | Java artifacts and dependencies |
+| **Gradle** | Yes | Yes | Yes | Gradle artifacts and plugins |
+| **Docker** | Yes | Yes | Yes | Container images registry |
+| **NPM** | Yes | Yes | Yes | JavaScript packages |
+| **PyPI** | Yes | Yes | Yes | Python packages |
+| **Go** | Yes | Yes | Yes | Go modules |
+| **Composer (PHP)** | Yes | Yes | Yes | PHP packages |
+| **Files** | Yes | Yes | Yes | Generic binary files |
+| **Gem** | Yes | — | Yes | Ruby gems |
+| **NuGet** | Yes | — | — | .NET packages |
+| **Helm** | Yes | — | — | Kubernetes charts |
+| **RPM** | Yes | — | — | Red Hat/CentOS packages |
+| **Debian** | Yes | — | — | Debian/Ubuntu packages |
+| **Conda** | Yes | — | — | Data science packages |
+| **Conan** | Yes | — | — | C/C++ packages |
+| **HexPM** | Yes | — | — | Elixir/Erlang packages |
+
+**Repository Modes:**
+- **Local**: Host your own packages (read/write)
+- **Proxy**: Cache packages from upstream registries with cooldown protection
+- **Group**: Aggregate multiple local and/or proxy repositories
+
+## Quick Start
+
+### Using Docker
```bash
-docker run -it -p 8080:8080 -p 8086:8086 artipie/artipie:latest
-```
-
-It'll start a new Docker container with latest Artipie version, the command includes mapping of two
-ports: on port `8080` repositories are served and on port `8086` Artipie Rest API and Swagger
-documentation is provided.
-A new image generate default configuration, prints a list of running repositories, test
-credentials and a link to the [Swagger](https://swagger.io/) documentation to console. To check
-existing repositories using Artipie Rest API:
-- go to Swagger documentation page `http://localhost:8086/api/index-org.html`,
-choose "Auth token" in "Select a definition" list,
-- generate and copy authentication token for user `artipie/artipie`,
-- switch to "Repositories" definition, press "Authorize" button and paste the token
-- then perform `GET /api/v1/repository/list` request.
-Response should be a json list with three default repositories:
-```json
-[
- "artipie/my-bin",
- "artipie/my-docker",
- "artipie/my-maven"
-]
+docker run -d \
+ --name artipie \
+ -p 8080:8080 \
+ -p 8086:8086 \
+ --ulimit nofile=1048576:1048576 \
+ artipie/artipie:latest
+```
+
+**Ports:**
+- `8080`: Repository endpoints
+- `8086`: REST API and Swagger documentation
+
+**Default Credentials:**
+- Username: `artipie`
+- Password: `artipie`
+
+### Verify Installation
+
+```bash
+# Check health
+curl http://localhost:8080/.health
+
+# Check version
+curl http://localhost:8080/.version
+
+# Open Swagger UI
+open http://localhost:8086/api/index.html
+```
+
+## Production Deployment (Recommended)
+
+For production, use the Docker Compose stack which includes all required services:
+
+```bash
+cd artipie-main/docker-compose
+
+# Copy and configure environment
+cp .env.example .env
+# Edit .env with your settings
+
+# Start all services
+docker-compose up -d
```
-Artipie server side (repositories) is served on `8080` port and is available on URI
-`http://localhost:8080/{username}/{reponame}`, where `{username}` is the name
-of the user and `{reponame}` is the name of the repository. Let's put some text data into binary repository:
-```commandline
-curl -X PUT -d 'Hello world!' http://localhost:8080/artipie/my-bin/test.txt
+
+### Included Services
+
+| Service | Port | Description |
+|---------|------|-------------|
+| **Artipie** | 8081 (via nginx) | Repository endpoints |
+| **Artipie API** | 8086 | REST API, Swagger docs |
+| **PostgreSQL** | 5432 | Artifact metadata, cooldown state |
+| **Valkey (Redis)** | 6379 | Caching layer |
+| **Keycloak** | 8080 | OAuth/OIDC authentication |
+| **Nginx** | 8081, 8443 | Reverse proxy with TLS |
+| **Prometheus** | 9090 | Metrics collection |
+| **Grafana** | 3000 | Dashboards and alerting |
+
+### Production Configuration
+
+The Docker Compose setup includes production-ready defaults:
+
+```yaml
+# docker-compose.yaml (artipie service)
+cpus: 4
+mem_limit: 6gb
+ulimits:
+ nofile:
+ soft: 1048576
+ hard: 1048576
+ nproc:
+ soft: 65536
+ hard: 65536
```
-With this request we added file `test.txt` containing text "Hello world!" into repository. Let's check
-it's really there:
-```commandline
-curl -X GET http://localhost:8080/artipie/my-bin/test.txt
+
+### Environment Variables
+
+Key environment variables (see [.env.example](artipie-main/docker-compose/.env.example) for complete list):
+
+```bash
+# Artipie
+ARTIPIE_VERSION=1.20.12
+ARTIPIE_USER_NAME=artipie
+ARTIPIE_USER_PASS=changeme
+
+# JVM (optimized for high concurrency)
+JVM_ARGS=-Xms3g -Xmx4g -XX:+UseG1GC ...
+
+# AWS/S3 (for S3 storage backend)
+AWS_PROFILE=your_profile_name
+AWS_REGION=eu-west-1
+
+# Okta OIDC (optional)
+OKTA_ISSUER=https://your-org.okta.com
+OKTA_CLIENT_ID=your_client_id
+OKTA_CLIENT_SECRET=your_client_secret
+
+# Database
+POSTGRES_USER=artipie
+POSTGRES_PASSWORD=changeme
```
-"Hello world!" should be printed in console.
-Do dive in dipper into Artipie configuration, features, explore repositories and storages settings,
-please, address our [Wiki](https://github.com/artipie/artipie/wiki).
+## Configuration
-Default server configuration in Docker Container refers to `/var/artipie/repos` to look up for
-repository configurations. You may want to mount local configurations `