maven-proxy 1.1.1 → 1.2.1

package/src/cache/maven-affinity-index.js

@@ -0,0 +1,396 @@
+import fs from "node:fs";
+import path from "node:path";
+
+function toPositiveInt(value, fallback) {
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function toBool(value, fallback) {
+  if (value == null || value === "") {
+    return fallback;
+  }
+
+  return ["1", "true", "yes", "on"].includes(String(value).toLowerCase());
+}
+
+function nowMs() {
+  return Date.now();
+}
+
+function readJsonFile(filePath, fallback) {
+  if (!fs.existsSync(filePath)) {
+    return fallback;
+  }
+
+  try {
+    const text = fs.readFileSync(filePath, "utf8");
+    return JSON.parse(text);
+  } catch {
+    return fallback;
+  }
+}
+
+function serializeSnapshot(positiveMap, negativeMap, conflictMap) {
+  return {
+    version: 1,
+    generatedAt: new Date().toISOString(),
+    positive: [...positiveMap.entries()],
+    negative: [...negativeMap.entries()],
+    conflicts: [...conflictMap.entries()],
+  };
+}
+
+function normalizeRequestPath(pathname) {
+  return String(pathname || "")
+    .replace(/\\/g, "/")
+    .replace(/\/+/g, "/")
+    .replace(/^\/+/, "")
+    .trim();
+}
+
+function buildNegativeScope(urlObj) {
+  if (!urlObj || typeof urlObj !== "object") {
+    return "";
+  }
+
+  const protocol = urlObj.protocol === "https:" ? "https:" : "http:";
+  const host = String(urlObj.host || "").toLowerCase();
+  const pathname = normalizeRequestPath(urlObj.pathname || "");
+  return `${protocol}//${host}/${pathname}`;
+}
+
+function buildNegativeKey(scope, canonicalKey) {
+  return `${String(scope || "").toLowerCase()}|${canonicalKey}`;
+}
+
+export class MavenAffinityIndex {
+  constructor(config) {
+    this.enabled = toBool(config.mavenAffinityEnabled, true);
+    this.indexDir = config.mavenAffinityIndexDir;
+    this.negativeTtlMs = toPositiveInt(config.mavenNegativeCacheTtlMs, 24 * 60 * 60 * 1000);
+    this.flushIntervalMs = toPositiveInt(config.mavenAffinityFlushIntervalMs, 5000);
+    this.maxEventBytes = toPositiveInt(config.mavenAffinityEventMaxBytes, 8 * 1024 * 1024);
+
+    this.snapshotPath = path.join(this.indexDir, "maven-affinity.snapshot.json");
+    this.eventLogPath = path.join(this.indexDir, "maven-affinity.events.log");
+
+    // Positive entries are persistent and have no TTL. They are removed only
+    // when the cache file disappears or a conflict is detected.
+    this.positive = new Map();
+    this.negative = new Map();
+    this.conflicts = new Map();
+
+    this.pendingEvents = [];
+    this.flushTimer = null;
+    this.flushing = false;
+    this.dirtySinceSnapshot = false;
+  }
+
+  async init() {
+    if (!this.enabled) {
+      return;
+    }
+
+    await fs.promises.mkdir(this.indexDir, { recursive: true });
+    this.#loadSnapshot();
+    this.#replayEventLog();
+
+    this.flushTimer = setInterval(() => {
+      this.flush().catch((error) => {
+        console.error(`[affinity] flush failed: ${error.message}`);
+      });
+    }, this.flushIntervalMs);
+
+    if (typeof this.flushTimer.unref === "function") {
+      this.flushTimer.unref();
+    }
+  }
+
+  #loadSnapshot() {
+    const snapshot = readJsonFile(this.snapshotPath, null);
+    if (!snapshot || typeof snapshot !== "object") {
+      return;
+    }
+
+    for (const [key, value] of snapshot.positive || []) {
+      this.positive.set(key, value);
+    }
+
+    const currentTime = nowMs();
+    for (const [key, value] of snapshot.negative || []) {
+      if (value?.expireAt && value.expireAt > currentTime) {
+        this.negative.set(key, value);
+      }
+    }
+
+    for (const [key, value] of snapshot.conflicts || []) {
+      this.conflicts.set(key, value);
+    }
+  }
+
+  #replayEventLog() {
+    if (!fs.existsSync(this.eventLogPath)) {
+      return;
+    }
+
+    let raw = "";
+    try {
+      raw = fs.readFileSync(this.eventLogPath, "utf8");
+    } catch {
+      return;
+    }
+
+    const lines = raw.split(/\r?\n/).filter(Boolean);
+    for (const line of lines) {
+      try {
+        const event = JSON.parse(line);
+        this.#applyEvent(event, false);
+      } catch {
+        // ignore invalid line
+      }
+    }
+  }
+
+  #enqueueEvent(type, payload) {
+    this.pendingEvents.push(JSON.stringify({ t: nowMs(), type, payload }));
+    this.dirtySinceSnapshot = true;
+  }
+
+  #applyEvent(event, append = true) {
+    if (!event || typeof event !== "object") {
+      return;
+    }
+
+    const { type, payload } = event;
+    if (!type || !payload || typeof payload !== "object") {
+      return;
+    }
+
+    if (type === "positive_upsert") {
+      this.positive.set(payload.key, payload.value);
+      if (append) {
+        this.#enqueueEvent(type, payload);
+      }
+      return;
+    }
+
+    if (type === "positive_remove") {
+      this.positive.delete(payload.key);
+      if (append) {
+        this.#enqueueEvent(type, payload);
+      }
+      return;
+    }
+
+    if (type === "negative_upsert") {
+      if (payload.value?.expireAt > nowMs()) {
+        this.negative.set(payload.key, payload.value);
+      } else {
+        this.negative.delete(payload.key);
+      }
+      if (append) {
+        this.#enqueueEvent(type, payload);
+      }
+      return;
+    }
+
+    if (type === "negative_remove") {
+      this.negative.delete(payload.key);
+      if (append) {
+        this.#enqueueEvent(type, payload);
+      }
+      return;
+    }
+
+    if (type === "conflict_set") {
+      this.conflicts.set(payload.key, payload.value);
+      if (append) {
+        this.#enqueueEvent(type, payload);
+      }
+      return;
+    }
+
+    if (type === "conflict_clear") {
+      this.conflicts.delete(payload.key);
+      if (append) {
+        this.#enqueueEvent(type, payload);
+      }
+    }
+  }
+
+  async resolvePreferredCachePath(canonicalKey) {
+    if (!this.enabled || !canonicalKey) {
+      return "";
+    }
+
+    if (this.conflicts.has(canonicalKey)) {
+      return "";
+    }
+
+    const existing = this.positive.get(canonicalKey);
+    if (!existing?.cachePath) {
+      return "";
+    }
+
+    try {
+      const stats = await fs.promises.stat(existing.cachePath);
+      if (!stats.isFile()) {
+        throw new Error("not-file");
+      }
+      return existing.cachePath;
+    } catch {
+      this.#applyEvent({
+        type: "positive_remove",
+        payload: { key: canonicalKey },
+      });
+      return "";
+    }
+  }
+
+  shouldSkipRequest(canonicalKey, urlObj) {
+    const scope = buildNegativeScope(urlObj);
+    if (!this.enabled || !canonicalKey || !scope) {
+      return false;
+    }
+
+    const key = buildNegativeKey(scope, canonicalKey);
+    const entry = this.negative.get(key);
+    if (!entry) {
+      return false;
+    }
+
+    if (entry.expireAt <= nowMs()) {
+      this.#applyEvent({
+        type: "negative_remove",
+        payload: { key },
+      });
+      return false;
+    }
+
+    return true;
+  }
+
+  recordSuccess({ canonicalKey, host, cachePath, fileName, urlObj = null }) {
+    if (!this.enabled || !canonicalKey || !cachePath || !fileName) {
+      return;
+    }
+
+    const previous = this.positive.get(canonicalKey);
+    if (previous && previous.fileName !== fileName) {
+      this.#applyEvent({
+        type: "conflict_set",
+        payload: {
+          key: canonicalKey,
+          value: {
+            reason: "file-name-mismatch",
+            updatedAt: nowMs(),
+            previousFileName: previous.fileName,
+            currentFileName: fileName,
+          },
+        },
+      });
+
+      this.#applyEvent({
+        type: "positive_remove",
+        payload: { key: canonicalKey },
+      });
+      return;
+    }
+
+    this.#applyEvent({
+      type: "positive_upsert",
+      payload: {
+        key: canonicalKey,
+        value: {
+          cachePath,
+          fileName,
+          host: String(host || "").toLowerCase(),
+          updatedAt: nowMs(),
+        },
+      },
+    });
+
+    const successScope = buildNegativeScope(urlObj);
+    if (successScope) {
+      const negativeKey = buildNegativeKey(successScope, canonicalKey);
+      if (this.negative.has(negativeKey)) {
+        this.#applyEvent({
+          type: "negative_remove",
+          payload: { key: negativeKey },
+        });
+      }
+    }
+  }
+
+  recordNegative({ canonicalKey, urlObj, statusCode = 404, ttlMs = this.negativeTtlMs }) {
+    const scope = buildNegativeScope(urlObj);
+    if (!this.enabled || !canonicalKey || !scope) {
+      return;
+    }
+
+    const expireAt = nowMs() + toPositiveInt(ttlMs, this.negativeTtlMs);
+    const key = buildNegativeKey(scope, canonicalKey);
+    this.#applyEvent({
+      type: "negative_upsert",
+      payload: {
+        key,
+        value: {
+          scope,
+          statusCode,
+          expireAt,
+          updatedAt: nowMs(),
+        },
+      },
+    });
+  }
+
+  async flush() {
+    if (!this.enabled || this.flushing) {
+      return;
+    }
+
+    this.flushing = true;
+    try {
+      if (this.pendingEvents.length > 0) {
+        const text = `${this.pendingEvents.join("\n")}\n`;
+        this.pendingEvents = [];
+        await fs.promises.appendFile(this.eventLogPath, text, "utf8");
+      }
+
+      const stats = await fs.promises.stat(this.eventLogPath).catch(() => null);
+      const needsSnapshot = this.dirtySinceSnapshot && (!stats || stats.size >= this.maxEventBytes);
+
+      if (needsSnapshot) {
+        await this.#writeSnapshotAndResetEventLog();
+      }
+    } finally {
+      this.flushing = false;
+    }
+  }
+
+  async #writeSnapshotAndResetEventLog() {
+    const snapshot = serializeSnapshot(this.positive, this.negative, this.conflicts);
+    const tempPath = `${this.snapshotPath}.tmp`;
+    await fs.promises.writeFile(tempPath, `${JSON.stringify(snapshot, null, 2)}\n`, "utf8");
+    await fs.promises.rename(tempPath, this.snapshotPath);
+    await fs.promises.writeFile(this.eventLogPath, "", "utf8");
+    this.dirtySinceSnapshot = false;
+  }
+
+  async destroy() {
+    if (!this.enabled) {
+      return;
+    }
+
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+
+    await this.flush();
+    if (this.dirtySinceSnapshot) {
+      await this.#writeSnapshotAndResetEventLog();
+    }
+  }
+}

package/src/common/console-log-file.js

@@ -4,45 +4,75 @@ import { DailyLogFile } from "./daily-log-file.js";
 const MIRROR_INSTALLED = Symbol.for("maven-proxy.console-log-file.installed");
 const GLOBAL_ERROR_HOOK_INSTALLED = Symbol.for("maven-proxy.global-error-hook.installed");
 
-function mirrorConsoleMethod({ level, originalMethod, logFile }) {
+function mirrorConsoleMethod({
+  level,
+  originalMethod,
+  appLogFile,
+  errorLogFile,
+  outputToConsole,
+}) {
   return (...args) => {
-    originalMethod(...args);
+    if (outputToConsole) {
+      originalMethod(...args);
+    }
 
     const line = `[${new Date().toISOString()}] [${level}] ${util.format(...args)}`;
-    logFile.appendLine(line).catch((error) => {
+    appLogFile.appendLine(line).catch((error) => {
       process.stderr.write(`[maven-proxy] write console log failed: ${error.message}\n`);
     });
+
+    if (level === "ERROR") {
+      errorLogFile.appendLine(line).catch((error) => {
+        process.stderr.write(`[maven-proxy] write error log failed: ${error.message}\n`);
+      });
+    }
   };
 }
 
-export function installConsoleLogFileMirror({ logDir, retentionDays = 7 }) {
+export function installConsoleLogFileMirror({
+  logDir,
+  retentionDays = 7,
+  outputToConsole = true,
+}) {
   if (globalThis[MIRROR_INSTALLED]) {
     return;
   }
   globalThis[MIRROR_INSTALLED] = true;
 
-  const logFile = new DailyLogFile({
+  const appLogFile = new DailyLogFile({
+    logDir,
+    filePrefix: "app",
+    retentionDays,
+  });
+
+  const errorLogFile = new DailyLogFile({
     logDir,
-    filePrefix: "console",
+    filePrefix: "error",
     retentionDays,
   });
 
   console.log = mirrorConsoleMethod({
     level: "INFO",
     originalMethod: console.log.bind(console),
-    logFile,
+    appLogFile,
+    errorLogFile,
+    outputToConsole,
   });
 
   console.warn = mirrorConsoleMethod({
     level: "WARN",
     originalMethod: console.warn.bind(console),
-    logFile,
+    appLogFile,
+    errorLogFile,
+    outputToConsole,
   });
 
   console.error = mirrorConsoleMethod({
     level: "ERROR",
     originalMethod: console.error.bind(console),
-    logFile,
+    appLogFile,
+    errorLogFile,
+    outputToConsole,
   });
 }
 

package/src/common/maven-canonical.js

@@ -0,0 +1,151 @@
+function safeDecode(pathname) {
+  try {
+    return decodeURIComponent(pathname || "/");
+  } catch {
+    return pathname || "/";
+  }
+}
+
+function escapeRegex(value) {
+  return String(value || "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function normalizePathname(pathname) {
+  return String(pathname || "")
+    .replace(/\\/g, "/")
+    .replace(/^\/+/, "")
+    .replace(/\/+/g, "/")
+    .trim();
+}
+
+function stripKnownPrefixes(relativePath) {
+  const raw = normalizePathname(relativePath);
+  if (!raw) {
+    return [];
+  }
+
+  const candidates = new Set([raw]);
+
+  if (raw.toLowerCase().startsWith("maven2/")) {
+    candidates.add(raw.slice("maven2/".length));
+  }
+
+  if (raw.toLowerCase().startsWith("m2/")) {
+    candidates.add(raw.slice("m2/".length));
+  }
+
+  const maven2Marker = raw.toLowerCase().indexOf("/maven2/");
+  if (maven2Marker >= 0) {
+    candidates.add(raw.slice(maven2Marker + "/maven2/".length));
+  }
+
+  const m2Marker = raw.toLowerCase().indexOf("/m2/");
+  if (m2Marker >= 0) {
+    candidates.add(raw.slice(m2Marker + "/m2/".length));
+  }
+
+  const patterns = [
+    /^repository\/[^/]+\/(.+)$/i,
+    /^artifactory\/[^/]+\/(.+)$/i,
+    /^nexus\/content\/repositories\/[^/]+\/(.+)$/i,
+    /^repositories\/[^/]+\/(.+)$/i,
+  ];
+
+  for (const pattern of patterns) {
+    const match = raw.match(pattern);
+    if (match?.[1]) {
+      candidates.add(match[1]);
+    }
+  }
+
+  const normalizedCandidates = [...candidates].map((item) => normalizePathname(item)).filter(Boolean);
+  normalizedCandidates.sort((left, right) => left.split("/").length - right.split("/").length);
+  return normalizedCandidates;
+}
+
+function isSafePathSegment(segment) {
+  return /^[A-Za-z0-9_.+-]+$/.test(String(segment || ""));
+}
+
+function isReleaseVersion(version) {
+  return !String(version || "").toUpperCase().endsWith("-SNAPSHOT");
+}
+
+function matchReleaseFileName(artifact, version, fileName) {
+  if (/-SNAPSHOT(?=\.|-)/i.test(fileName)) {
+    return false;
+  }
+
+  const escapedArtifact = escapeRegex(artifact);
+  const escapedVersion = escapeRegex(version);
+  const pattern = new RegExp(
+    `^${escapedArtifact}-${escapedVersion}(?:-[A-Za-z0-9_.+:-]+)?\\.(pom|jar|module|aar|war)(?:\\.(sha1|sha256|sha512|md5|asc))?$`,
+    "i",
+  );
+
+  return pattern.test(fileName);
+}
+
+function tryParseCandidate(relativePath) {
+  const normalized = normalizePathname(relativePath);
+  const parts = normalized.split("/").filter(Boolean);
+  if (parts.length < 4) {
+    return null;
+  }
+
+  const fileName = parts[parts.length - 1];
+  const version = parts[parts.length - 2];
+  const artifact = parts[parts.length - 3];
+  const groupParts = parts.slice(0, -3);
+
+  if (!artifact || !version || !fileName || groupParts.length === 0) {
+    return null;
+  }
+
+  if (!isSafePathSegment(artifact) || !isSafePathSegment(version) || !isSafePathSegment(fileName)) {
+    return null;
+  }
+
+  if (!groupParts.every((segment) => isSafePathSegment(segment))) {
+    return null;
+  }
+
+  if (!isReleaseVersion(version)) {
+    return null;
+  }
+
+  if (!matchReleaseFileName(artifact, version, fileName)) {
+    return null;
+  }
+
+  const groupPath = groupParts.join("/");
+  const canonicalPath = `${groupPath}/${artifact}/${version}/${fileName}`;
+
+  return {
+    canonicalPath,
+    canonicalKey: canonicalPath,
+    groupPath,
+    artifact,
+    version,
+    fileName,
+    isRelease: true,
+  };
+}
+
+export function parseMavenReleaseCanonical(urlObj) {
+  if (!urlObj || typeof urlObj !== "object") {
+    return null;
+  }
+
+  const decodedPath = safeDecode(urlObj.pathname || "/");
+  const candidates = stripKnownPrefixes(decodedPath);
+
+  for (const candidate of candidates) {
+    const parsed = tryParseCandidate(candidate);
+    if (parsed) {
+      return parsed;
+    }
+  }
+
+  return null;
+}

package/src/config/config.js

@@ -6,7 +6,7 @@ import { detectJavaHome } from "../common/java-home.js";
 
 const cwd = process.cwd();
 const userConfigDir = path.resolve(os.homedir(), "maven-proxy");
-const defaultUserConfigPath = path.join(userConfigDir, "config");
+const defaultUserConfigPath = path.join(userConfigDir, "config.properties");
 
 function normalizeConfigMode(value) {
   const normalized = String(value || "").trim().toLowerCase();
@@ -55,8 +55,7 @@ function resolveConfigFilePath(configMode) {
 
   if (configMode === "development") {
     const devCandidates = [
-      path.resolve(cwd, ".env"),
-      path.resolve(cwd, ".evn"),
+      path.resolve(cwd, "config.properties"),
     ];
 
     for (const candidate of devCandidates) {
@@ -181,6 +180,13 @@ const defaultMavenRepoDomains = [
 
 const cacheDir = path.resolve(configBaseDir, process.env.CACHE_DIR || "data/cache");
 
+const multiThreadMinSizeBytes = Math.max(0, toInt(process.env.MULTI_THREAD_MIN_SIZE_MB, 1)) * 1024 * 1024;
+const downloadTimeoutMs = Math.max(1, toInt(process.env.DOWNLOAD_TIMEOUT_SECONDS, 60)) * 1000;
+const outboundKeepAliveMsecs = Math.max(1, toInt(process.env.OUTBOUND_KEEP_ALIVE_SECONDS, 1)) * 1000;
+const mavenNegativeCacheTtlMs = Math.max(1, toInt(process.env.MAVEN_NEGATIVE_CACHE_TTL_HOURS, 24)) * 60 * 60 * 1000;
+const mavenAffinityFlushIntervalMs = Math.max(1, toInt(process.env.MAVEN_AFFINITY_FLUSH_INTERVAL_SECONDS, 5)) * 1000;
+const mavenAffinityEventMaxBytes = Math.max(1, toInt(process.env.MAVEN_AFFINITY_EVENT_MAX_MB, 8)) * 1024 * 1024;
+
 export const config = {
   configMode,
   configBaseDir,
@@ -198,10 +204,21 @@ export const config = {
   mavenRepoDomains: toList(process.env.MAVEN_REPO_DOMAINS, [...new Set(defaultMavenRepoDomains)]),
   multiThreadDomains: toList(process.env.MULTI_THREAD_DOMAINS, ["repo1.maven.org"]),
   multiThreadCount: Math.max(1, toInt(process.env.MULTI_THREAD_COUNT, 4)),
-  multiThreadMinSizeBytes: Math.max(0, toInt(process.env.MULTI_THREAD_MIN_SIZE_BYTES, 1024 * 1024)),
-  downloadTimeoutMs: Math.max(1000, toInt(process.env.DOWNLOAD_TIMEOUT_MS, 60000)),
+  multiThreadMinSizeBytes,
+  downloadTimeoutMs,
+  outboundKeepAlive: toBool(process.env.OUTBOUND_KEEP_ALIVE, true),
+  outboundKeepAliveMsecs,
+  outboundMaxSockets: Math.max(1, toInt(process.env.OUTBOUND_MAX_SOCKETS, 64)),
+  outboundMaxFreeSockets: Math.max(1, toInt(process.env.OUTBOUND_MAX_FREE_SOCKETS, 16)),
+  mavenAffinityEnabled: toBool(process.env.MAVEN_AFFINITY_ENABLED, true),
+  mavenAffinityIndexDir: path.resolve(cacheDir, process.env.MAVEN_AFFINITY_INDEX_DIR || ".index"),
+  mavenNegativeCacheTtlMs,
+  mavenAffinityFlushIntervalMs,
+  mavenAffinityEventMaxBytes,
   downloadLogDir: path.resolve(configBaseDir, process.env.DOWNLOAD_LOG_DIR || "data/logs/downloads"),
   logRetentionDays: Math.max(1, toInt(process.env.LOG_RETENTION_DAYS, 7)),
+  logToStdout: toBool(process.env.LOG_TO_STDOUT, true),
+  logConnectEvents: toBool(process.env.LOG_CONNECT_EVENTS, false),
   certDir: path.resolve(configBaseDir, process.env.CERT_DIR || "data/certs"),
   rootCertPath: path.resolve(configBaseDir, process.env.ROOT_CERT_PATH || "data/certs/root-ca.crt"),
   rootKeyPath: path.resolve(configBaseDir, process.env.ROOT_KEY_PATH || "data/certs/root-ca.key.pem"),
@@ -214,7 +231,7 @@ export const config = {
   javaHome: javaHomeResolution.javaHome,
   javaHomeSource: javaHomeResolution.source,
   javaHomeConfigured: javaHomeResolution.configuredJavaHome || "",
-  httpsPassthroughForUnmatched: toBool(process.env.HTTPS_PASSTHROUGH_FOR_UNMATCHED, true),
+  httpsPassthroughForUnmatched: toBool(process.env.HTTPS_PASSTHROUGH_FOR_UNMATCHED, false),
   upstreamProxyUrl: normalizeProxyUrl(process.env.UPSTREAM_PROXY_URL || process.env.ALL_PROXY || process.env.all_proxy || ""),
   upstreamHttpProxyUrl: normalizeProxyUrl(process.env.UPSTREAM_HTTP_PROXY_URL || process.env.HTTP_PROXY || process.env.http_proxy || ""),
   upstreamHttpsProxyUrl: normalizeProxyUrl(process.env.UPSTREAM_HTTPS_PROXY_URL || process.env.HTTPS_PROXY || process.env.https_proxy || ""),