maven-proxy 1.1.1 → 1.2.1

package/src/index.js

@@ -7,14 +7,63 @@ import { startProxyServer } from "./proxy/proxy-server.js";
 import { startRepoServer } from "./repo/repo-server.js";
 import { getTrustStoreCommands } from "./cert/truststore-utils.js";
 import { UpstreamProxyManager } from "./proxy/upstream-proxy.js";
+import { MavenAffinityIndex } from "./cache/maven-affinity-index.js";
 import { installConsoleLogFileMirror, installGlobalErrorLogging } from "./common/console-log-file.js";
 
 installConsoleLogFileMirror({
   logDir: config.downloadLogDir,
   retentionDays: config.logRetentionDays,
+  outputToConsole: config.logToStdout,
 });
 installGlobalErrorLogging();
 
+function startupInfo(message) {
+  if (!config.logToStdout) {
+    process.stdout.write(`${message}\n`);
+  }
+  console.log(message);
+}
+
+function startupError(message, error = null) {
+  if (!config.logToStdout) {
+    process.stderr.write(`${message}\n`);
+    if (error) {
+      process.stderr.write(`${error?.stack || error?.message || String(error)}\n`);
+    }
+  }
+  if (error) {
+    console.error(message, error);
+  } else {
+    console.error(message);
+  }
+}
+
+async function waitForServerListening(server, name) {
+  if (server?.listening) {
+    return;
+  }
+
+  await new Promise((resolve, reject) => {
+    const onListening = () => {
+      cleanup();
+      resolve();
+    };
+
+    const onError = (error) => {
+      cleanup();
+      reject(new Error(`${name} listen failed: ${error.message}`));
+    };
+
+    const cleanup = () => {
+      server.off("listening", onListening);
+      server.off("error", onError);
+    };
+
+    server.once("listening", onListening);
+    server.once("error", onError);
+  });
+}
+
 async function main() {
   await fs.promises.mkdir(config.cacheDir, { recursive: true });
   await fs.promises.mkdir(config.mavenCacheDir, { recursive: true });
@@ -34,6 +83,8 @@ async function main() {
   }
 
   const upstreamProxyManager = new UpstreamProxyManager(config, matchesDomain);
+  const mavenAffinityIndex = new MavenAffinityIndex(config);
+  await mavenAffinityIndex.init();
 
   const downloader = new Downloader(config, matchesDomain, upstreamProxyManager);
 
@@ -43,44 +94,64 @@ async function main() {
     downloader,
     matchesDomain,
     upstreamProxyManager,
+    mavenAffinityIndex,
   );
   const repoServer = startRepoServer(config, downloader);
 
+  await Promise.all([
+    waitForServerListening(proxyServer, "proxy server"),
+    waitForServerListening(repoServer, "repo server"),
+  ]);
+
   const trustCommands = getTrustStoreCommands(config);
 
-  console.log("[maven-proxy] started");
-  console.log(`[maven-proxy] config mode: ${config.configMode}`);
-  console.log(`[maven-proxy] config file: ${config.loadedConfigFile || "(none)"}`);
-  console.log(`[maven-proxy] config base: ${config.configBaseDir}`);
+  startupInfo("[maven-proxy] started");
+  startupInfo(`[maven-proxy] config mode: ${config.configMode}`);
+  startupInfo(`[maven-proxy] config file: ${config.loadedConfigFile || "(none)"}`);
+  startupInfo(`[maven-proxy] config base: ${config.configBaseDir}`);
   if (config.configMode === "user") {
-    console.log(`[maven-proxy] default user config: ${config.defaultUserConfigPath}`);
+    startupInfo(`[maven-proxy] default user config: ${config.defaultUserConfigPath}`);
   }
-  console.log(`[maven-proxy] proxy port: ${config.proxyPort}`);
-  console.log(`[maven-proxy] repo  port: ${config.repoPort}`);
-  console.log(`[maven-proxy] cache dir : ${config.cacheDir}`);
-  console.log(`[maven-proxy] cache maven: ${config.mavenCacheDir}`);
-  console.log(`[maven-proxy] cache npm  : ${config.npmCacheDir}`);
-  console.log(`[maven-proxy] cache other: ${config.genericCacheDir}`);
-  console.log(`[maven-proxy] download log: ${config.downloadLogDir}`);
-  console.log(`[maven-proxy] log retention days: ${config.logRetentionDays}`);
-  console.log(`[maven-proxy] root cert : ${config.rootCertPath}`);
-  console.log(`[maven-proxy] repo fallback repos: ${(config.repoFallbackRepos || []).join(",") || "(none)"}`);
+  startupInfo(`[maven-proxy] proxy port: ${config.proxyPort}`);
+  startupInfo(`[maven-proxy] repo  port: ${config.repoPort}`);
+  startupInfo(`[maven-proxy] cache dir : ${config.cacheDir}`);
+  startupInfo(`[maven-proxy] cache maven: ${config.mavenCacheDir}`);
+  startupInfo(`[maven-proxy] cache npm  : ${config.npmCacheDir}`);
+  startupInfo(`[maven-proxy] cache other: ${config.genericCacheDir}`);
+  startupInfo(`[maven-proxy] log dir: ${config.downloadLogDir}`);
+  startupInfo(`[maven-proxy] log retention days: ${config.logRetentionDays}`);
+  startupInfo(`[maven-proxy] log to stdout: ${config.logToStdout}`);
+  startupInfo(`[maven-proxy] log connect events: ${config.logConnectEvents}`);
+  startupInfo(`[maven-proxy] outbound keep-alive: ${config.outboundKeepAlive}`);
+  startupInfo(`[maven-proxy] outbound keepAlive(seconds): ${config.outboundKeepAliveMsecs / 1000}`);
+  startupInfo(`[maven-proxy] outbound maxSockets: ${config.outboundMaxSockets}`);
+  startupInfo(`[maven-proxy] outbound maxFreeSockets: ${config.outboundMaxFreeSockets}`);
+  startupInfo(`[maven-proxy] maven affinity enabled: ${config.mavenAffinityEnabled}`);
+  startupInfo(`[maven-proxy] maven affinity index dir: ${config.mavenAffinityIndexDir}`);
+  startupInfo(`[maven-proxy] maven negative cache ttl(hours): ${config.mavenNegativeCacheTtlMs / (60 * 60 * 1000)}`);
+  startupInfo(`[maven-proxy] maven affinity flush interval(seconds): ${config.mavenAffinityFlushIntervalMs / 1000}`);
+  startupInfo(`[maven-proxy] maven affinity event max(MB): ${config.mavenAffinityEventMaxBytes / (1024 * 1024)}`);
+  startupInfo(`[maven-proxy] root cert : ${config.rootCertPath}`);
+  startupInfo(`[maven-proxy] repo fallback repos: ${(config.repoFallbackRepos || []).join(",") || "(none)"}`);
   if (config.upstreamProxyUrl || config.upstreamHttpProxyUrl || config.upstreamHttpsProxyUrl) {
-    console.log(`[maven-proxy] upstream proxy (generic): ${config.upstreamProxyUrl || "(none)"}`);
-    console.log(`[maven-proxy] upstream proxy (http)   : ${config.upstreamHttpProxyUrl || "(none)"}`);
-    console.log(`[maven-proxy] upstream proxy (https)  : ${config.upstreamHttpsProxyUrl || "(none)"}`);
-    console.log(`[maven-proxy] upstream no-proxy       : ${(config.upstreamNoProxyDomains || []).join(",") || "(none)"}`);
-    console.log(`[maven-proxy] upstream ignore-domains : ${(config.upstreamIgnoreDomains || []).join(",") || "(none)"}`);
+    startupInfo(`[maven-proxy] upstream proxy (generic): ${config.upstreamProxyUrl || "(none)"}`);
+    startupInfo(`[maven-proxy] upstream proxy (http)   : ${config.upstreamHttpProxyUrl || "(none)"}`);
+    startupInfo(`[maven-proxy] upstream proxy (https)  : ${config.upstreamHttpsProxyUrl || "(none)"}`);
+    startupInfo(`[maven-proxy] upstream no-proxy       : ${(config.upstreamNoProxyDomains || []).join(",") || "(none)"}`);
+    startupInfo(`[maven-proxy] upstream ignore-domains : ${(config.upstreamIgnoreDomains || []).join(",") || "(none)"}`);
   }
-  console.log("[maven-proxy] trust store command (copy):");
-  console.log(trustCommands.copyCmd);
-  console.log("[maven-proxy] trust store command (import):");
-  console.log(trustCommands.importCmd);
+  startupInfo("[maven-proxy] trust store command (copy):");
+  startupInfo(trustCommands.copyCmd);
+  startupInfo("[maven-proxy] trust store command (import):");
+  startupInfo(trustCommands.importCmd);
+  startupInfo(`[maven-proxy] startup success: proxy=127.0.0.1:${config.proxyPort}, repo=127.0.0.1:${config.repoPort}`);
 
   const shutdown = () => {
     proxyServer.close();
     mitmHttpServer.close();
     repoServer.close();
+    upstreamProxyManager.destroy();
+    void mavenAffinityIndex.destroy();
   };
 
   process.on("SIGINT", shutdown);
@@ -88,6 +159,6 @@ async function main() {
 }
 
 main().catch((error) => {
-  console.error("[maven-proxy] fatal error:", error);
+  startupError("[maven-proxy] fatal error:", error);
   process.exit(1);
 });

package/src/proxy/proxy-connect-handler.js

@@ -20,7 +20,9 @@ async function openConnectUpstreamSocket(targetHost, targetPort, timeoutMs, upst
     upstreamProxyManager.hasProxyFor("https:", targetHost);
 
   if (useUpstreamProxy) {
-    console.log(`[proxy] CONNECT via upstream target=${targetHost}:${targetPort}`);
+    if (upstreamProxyManager?.config?.logConnectEvents) {
+      console.log(`[proxy] CONNECT via upstream target=${targetHost}:${targetPort}`);
+    }
     const tunnel = await upstreamProxyManager.createConnectTunnel(targetHost, targetPort, timeoutMs);
     return {
       upstreamSocket: tunnel.socket,
@@ -81,9 +83,13 @@ async function handlePassThroughConnect(clientSocket, head, targetHost, targetPo
 }
 
 async function handleMitmConnect(clientSocket, head, targetHost, certManager, mitmHttpServer) {
-  console.log(`[proxy] MITM prepare ${targetHost}`);
+  if (certManager?.config?.logConnectEvents) {
+    console.log(`[proxy] MITM prepare ${targetHost}`);
+  }
   const leaf = await certManager.getOrCreateLeaf(targetHost);
-  console.log(`[proxy] MITM cert ready ${targetHost}`);
+  if (certManager?.config?.logConnectEvents) {
+    console.log(`[proxy] MITM cert ready ${targetHost}`);
+  }
 
   await new Promise((resolve, reject) => {
     writeTunnelResponse(clientSocket, "HTTP/1.1 200 Connection Established", (error) => {
@@ -94,7 +100,9 @@ async function handleMitmConnect(clientSocket, head, targetHost, certManager, mi
       resolve();
     });
   });
-  console.log(`[proxy] MITM tunnel established ${targetHost}`);
+  if (certManager?.config?.logConnectEvents) {
+    console.log(`[proxy] MITM tunnel established ${targetHost}`);
+  }
 
   const tlsSocket = new tls.TLSSocket(clientSocket, {
     isServer: true,
@@ -138,7 +146,9 @@ export function attachConnectHandler(server, {
       config.enableHttpsProxy &&
       matchesDomain(host, config.httpsMitmDomains);
 
-    console.log(`[proxy] CONNECT ${host}:${port} mitm=${mitmEnabled}`);
+    if (config.logConnectEvents) {
+      console.log(`[proxy] CONNECT ${host}:${port} mitm=${mitmEnabled}`);
+    }
 
     if (!mitmEnabled) {
       if (!config.httpsPassthroughForUnmatched) {

package/src/proxy/proxy-http-handler.js

@@ -4,6 +4,7 @@ import https from "node:https";
 import path from "node:path";
 import { getCacheFilePath } from "../cache/cache-path.js";
 import { detectPackageEcosystem } from "../common/ecosystem.js";
+import { parseMavenReleaseCanonical } from "../common/maven-canonical.js";
 
 const LOCAL_FS_ERROR_CODES = new Set([
   "EACCES",
@@ -79,6 +80,12 @@ function sendErrorText(res, statusCode, message, context = "proxy") {
   sendText(res, statusCode, message);
 }
 
+export function isPositiveAffinityEligible(fileName) {
+  const lower = String(fileName || "").toLowerCase();
+  const base = lower.replace(/\.(sha1|sha256|sha512|md5|asc)$/i, "");
+  return /\.(jar|aar|war)$/i.test(base);
+}
+
 function buildUrl(req, forcedProtocol = null) {
   const raw = req.url || "/";
   if (/^https?:\/\//i.test(raw)) {
@@ -158,7 +165,13 @@ function forwardDirectRequest(req, res, urlObj, timeoutMs, upstreamProxyManager
   req.pipe(upstreamReq);
 }
 
-export function createHttpRequestHandler({ config, downloader, upstreamProxyManager = null, matchesDomain }) {
+export function createHttpRequestHandler({
+  config,
+  downloader,
+  upstreamProxyManager = null,
+  matchesDomain,
+  mavenAffinityIndex = null,
+}) {
   return async function handleHttpRequestPath(req, res, forcedProtocol = null) {
     let urlObj;
     try {
@@ -176,12 +189,18 @@ export function createHttpRequestHandler({ config, downloader, upstreamProxyMana
     }
 
     let cachePath;
+    let ecosystem;
+    let canonical = null;
     try {
-      const ecosystem = detectPackageEcosystem(urlObj, config, matchesDomain);
+      ecosystem = detectPackageEcosystem(urlObj, config, matchesDomain);
       cachePath = getCacheFilePath(config.cacheDir, urlObj, {
         ecosystem,
         includeHost: ecosystem !== "maven",
       });
+
+      if (ecosystem === "maven" && mavenAffinityIndex?.enabled) {
+        canonical = parseMavenReleaseCanonical(urlObj);
+      }
     } catch (error) {
       const message = `Invalid cache path: ${error.message}`;
       sendErrorText(res, 400, message, "proxy");
@@ -190,16 +209,58 @@ export function createHttpRequestHandler({ config, downloader, upstreamProxyMana
 
     const existing = await statIfFile(cachePath);
     if (existing) {
+      console.log(`[proxy] local cache hit host=${urlObj.hostname} path=${urlObj.pathname}`);
       await serveFile(res, req, cachePath);
       return;
     }
 
+    if (canonical && mavenAffinityIndex) {
+      if (isPositiveAffinityEligible(canonical.fileName)) {
+        const preferredPath = await mavenAffinityIndex.resolvePreferredCachePath(canonical.canonicalKey);
+        if (preferredPath) {
+          console.log(`[proxy] affinity hit canonical=${canonical.canonicalKey} host=${urlObj.hostname}`);
+          await serveFile(res, req, preferredPath);
+          return;
+        }
+      }
+
+      if (mavenAffinityIndex.shouldSkipRequest(canonical.canonicalKey, urlObj)) {
+        console.log(`[proxy] affinity negative skip canonical=${canonical.canonicalKey} host=${urlObj.hostname}`);
+        sendText(res, 404, "Not Found");
+        return;
+      }
+    }
+
     try {
+      console.log(`[proxy] local cache miss host=${urlObj.hostname} path=${urlObj.pathname}`);
       await fs.promises.mkdir(path.dirname(cachePath), { recursive: true });
       await downloader.ensureCached(urlObj, cachePath, req.headers);
+
+      if (canonical && mavenAffinityIndex && isPositiveAffinityEligible(canonical.fileName)) {
+        mavenAffinityIndex.recordSuccess({
+          canonicalKey: canonical.canonicalKey,
+          host: urlObj.hostname,
+          cachePath,
+          fileName: canonical.fileName,
+          urlObj,
+        });
+      }
+
       res.setHeader("x-cache", "MISS");
       await serveFile(res, req, cachePath);
     } catch (error) {
+      if (
+        canonical &&
+        mavenAffinityIndex &&
+        (error.statusCode === 404 || error.statusCode === 410)
+      ) {
+        mavenAffinityIndex.recordNegative({
+          canonicalKey: canonical.canonicalKey,
+          urlObj,
+          statusCode: error.statusCode,
+        });
+      }
+
       if (isLocalFsWriteError(error)) {
         if (!error.statusCode) {
           error.statusCode = 500;

package/src/proxy/proxy-server.js

@@ -12,12 +12,20 @@ function sendErrorText(res, statusCode, message) {
   sendText(res, statusCode, message);
 }
 
-export function startProxyServer(config, certManager, downloader, matchesDomain, upstreamProxyManager = null) {
+export function startProxyServer(
+  config,
+  certManager,
+  downloader,
+  matchesDomain,
+  upstreamProxyManager = null,
+  mavenAffinityIndex = null,
+) {
   const handleHttpRequestPath = createHttpRequestHandler({
     config,
     downloader,
     upstreamProxyManager,
     matchesDomain,
+    mavenAffinityIndex,
   });
   const mitmHttpServer = createMitmHttpServer(handleHttpRequestPath);
 

package/src/proxy/upstream-proxy.js

@@ -1,7 +1,23 @@
+import http from "node:http";
+import https from "node:https";
 import net from "node:net";
 import tls from "node:tls";
 import { ProxyAgent } from "proxy-agent";
 
+function toPositiveInt(value, fallback) {
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function buildAgentOptions(config) {
+  return {
+    keepAlive: Boolean(config.outboundKeepAlive),
+    keepAliveMsecs: toPositiveInt(config.outboundKeepAliveMsecs, 1000),
+    maxSockets: toPositiveInt(config.outboundMaxSockets, 64),
+    maxFreeSockets: toPositiveInt(config.outboundMaxFreeSockets, 16),
+  };
+}
+
 function normalizeHostname(hostname) {
   return String(hostname || "")
     .trim()
@@ -64,6 +80,12 @@ export class UpstreamProxyManager {
     this.config = config;
     this.matchesDomain = matchesDomain;
     this.agentCache = new Map();
+    this.directHttpAgent = new http.Agent(buildAgentOptions(config));
+    this.directHttpsAgent = new https.Agent(buildAgentOptions(config));
+  }
+
+  getDirectAgentForProtocol(protocol) {
+    return protocol === "https:" ? this.directHttpsAgent : this.directHttpAgent;
   }
 
   shouldBypass(hostname) {
@@ -111,17 +133,21 @@ export class UpstreamProxyManager {
   }
 
   getAgentForUrl(urlObj) {
-    const proxyUrl = this.getProxyUrlFor(urlObj.protocol, urlObj.hostname);
+    const protocol = urlObj?.protocol === "https:" ? "https:" : "http:";
+    const hostname = String(urlObj?.hostname || "");
+    const proxyUrl = this.getProxyUrlFor(protocol, hostname);
+
     if (!proxyUrl) {
-      return undefined;
+      return this.getDirectAgentForProtocol(protocol);
     }
 
-    const cacheKey = `${proxyUrl}`;
+    const cacheKey = `proxy:${proxyUrl}`;
     if (!this.agentCache.has(cacheKey)) {
       // proxy-agent v6 expects resolver-style options for deterministic proxy routing.
       this.agentCache.set(
         cacheKey,
         new ProxyAgent({
+          ...buildAgentOptions(this.config),
           getProxyForUrl: () => proxyUrl,
         }),
       );
@@ -134,6 +160,18 @@ export class UpstreamProxyManager {
     return Boolean(this.getProxyUrlFor(protocol, hostname));
   }
 
+  destroy() {
+    for (const agent of this.agentCache.values()) {
+      if (typeof agent?.destroy === "function") {
+        agent.destroy();
+      }
+    }
+
+    this.agentCache.clear();
+    this.directHttpAgent.destroy();
+    this.directHttpsAgent.destroy();
+  }
+
   async createConnectTunnel(targetHost, targetPort, timeoutMs) {
     const proxyUrlText = this.getProxyUrlFor("https:", targetHost);
     if (!proxyUrlText) {

package/src/common/download-log-writer.js

@@ -1,27 +0,0 @@
-import { DailyLogFile } from "./daily-log-file.js";
-
-export class DownloadLogWriter {
-  constructor(logDir, retentionDays = 7) {
-    this.logFile = new DailyLogFile({
-      logDir,
-      filePrefix: "download",
-      retentionDays,
-    });
-  }
-
-  async append(event, url, details = {}) {
-    const record = {
-      time: new Date().toISOString(),
-      event,
-      url,
-      ...details,
-    };
-    await this.logFile.appendLine(JSON.stringify(record));
-  }
-
-  write(event, url, details = {}) {
-    this.append(event, url, details).catch((error) => {
-      console.warn(`[downloader] write download log failed: ${error.message}`);
-    });
-  }
-}