com.jimuwd.xian.registry-proxy 1.1.17 → 1.1.19

package/dist/server/index.js

@@ -13,7 +13,8 @@ import { gracefulShutdown, registerProcessShutdownHook } from "./gracefullShutdo
 import { writePortFile } from "../port.js";
 import resolveEnvValue from "../utils/resolveEnvValue.js";
 const { readFile } = fsPromises;
-const limiter = new ConcurrencyLimiter(5);
+// 整个registry-proxy server实例 使用的全局限流器
+const LIMITER = new ConcurrencyLimiter(5);
 function removeEndingSlashAndForceStartingSlash(str) {
     if (!str)
         return '/';
@@ -137,8 +138,12 @@ async function loadProxyInfo(proxyConfigPath = './.registry-proxy.yml', localYar
     const basePath = removeEndingSlashAndForceStartingSlash(proxyConfig.basePath);
     return { registries, https, basePath };
 }
+// 有并发限流控制，禁止嵌套调用，否则导致死锁
 async function fetchFromRegistry(registry, targetUrl, reqFromDownstreamClient, limiter) {
-    await limiter.acquire();
+    // 并发限流控制
+    return limiter.run(() => _fetchFromRegistry(registry, targetUrl, reqFromDownstreamClient));
+}
+async function _fetchFromRegistry(registry, targetUrl, reqFromDownstreamClient) {
     try {
         logger.info(`Fetching from upstream: ${targetUrl}`);
         const headersFromDownstreamClient = reqFromDownstreamClient.headers;
@@ -158,10 +163,10 @@ async function fetchFromRegistry(registry, targetUrl, reqFromDownstreamClient, l
             content-type=${response.headers.get('content-type')} content-encoding=${response.headers.get('content-encoding')} content-length=${response.headers.get('content-length')} transfer-encoding=${response.headers.get('transfer-encoding')}`);
             return response;
         }
-        else if (response.status == 301) {
-            // HTTP 301 Permanently Moved.
+        else if (response.status == 301 || response.status == 308) {
+            // HTTP 301 Permanently Moved /  HTTP 308 Permanent Redirect
             logger.info(`${response.status} ${response.statusText} response from upstream ${targetUrl}, moved to location=${response.headers.get('location')}`);
-            // 对于301永久转义响应，registry-proxy 的行为：透传给下游客户端，让客户端自行跳转（提示：这个跳转后的请求将不再走registry-proxy代理了）
+            // 对于301/308永久转义响应，registry-proxy 的行为：透传给下游客户端，让客户端自行跳转（提示：这个跳转后的请求将不再走registry-proxy代理了）
             return response;
         }
         else if (response.status == 302 || response.status == 303 || response.status == 307) {
@@ -174,7 +179,7 @@ async function fetchFromRegistry(registry, targetUrl, reqFromDownstreamClient, l
             if (redirectedLocation) {
                 logger.info(`${response.status} ${response.statusText} response from upstream ${targetUrl}
                 Fetching from redirected location=${redirectedLocation}`);
-                return await fetchFromRegistry(registry, redirectedLocation, reqFromDownstreamClient, limiter);
+                return await _fetchFromRegistry(registry, redirectedLocation, reqFromDownstreamClient);
             }
             else {
                 logger.warn(`${response.status} ${response.statusText} response from upstream ${targetUrl}, but redirect location is empty, skip fetching from ${targetUrl}`);
@@ -194,28 +199,23 @@ async function fetchFromRegistry(registry, targetUrl, reqFromDownstreamClient, l
     }
     catch (e) {
         // Fetch form one of the configured upstream registries failed, this is expected behavior, not error.
-        if (e instanceof Error) {
-            const errCode = e.code;
-            if (errCode === 'ECONNREFUSED') {
-                logger.info(`Upstream ${targetUrl} refused connection [ECONNREFUSED], skip fetching from registry ${registry.normalizedRegistryUrl}`);
-            }
-            else if (errCode === 'ENOTFOUND') {
-                logger.info(`Unknown upstream domain name in ${targetUrl} [ENOTFOUND], skip fetching from registry ${registry.normalizedRegistryUrl}.`);
-            }
-            else {
-                // Other net error code, print log with stacktrace
-                logger.warn(`Failed to fetch from ${targetUrl}, ${e.message}`, e);
-            }
+        const errCode = e?.code;
+        if (errCode === 'ECONNREFUSED') {
+            logger.info(`Upstream ${targetUrl} refused connection [ECONNREFUSED], skip fetching from registry ${registry.normalizedRegistryUrl}`);
+        }
+        else if (errCode === 'ENOTFOUND') {
+            logger.info(`Unknown hostname in upstream url ${targetUrl} [ENOTFOUND], skip fetching from registry ${registry.normalizedRegistryUrl}.`);
+        }
+        else if (errCode === 'EAI_AGAIN') {
+            logger.info(`Could not resolve hostname in upstream url ${targetUrl} [EAI_AGAIN], skip fetching from registry ${registry.normalizedRegistryUrl}.`);
         }
         else {
-            logger.error("Unknown error", e);
+            // Other net error code, print log with stacktrace
+            logger.warn(`Failed to fetch from ${targetUrl}`, e);
         }
         // Return null means skipping current upstream registry.
         return null;
     }
-    finally {
-        limiter.release();
-    }
 }
 async function writeResponseToDownstreamClient(registryInfo, targetUrl, resToDownstreamClient, upstreamResponse, reqFromDownstreamClient, proxyInfo, _proxyPort, registryInfos) {
     logger.debug(() => `Writing upstream registry server ${registryInfo.normalizedRegistryUrl}'s ${upstreamResponse.status}${upstreamResponse.statusText ? (' "' + upstreamResponse.statusText + '"') : ''} response to downstream client.`);
@@ -366,14 +366,14 @@ export async function startProxyServer(proxyConfigPath, localYarnConfigPath, glo
     logger.info('Active registries:', registryInfos.map(r => r.normalizedRegistryUrl));
     logger.info('Proxy base path:', basePathPrefixedWithSlash);
     logger.info('HTTPS:', !!proxyInfo.https);
+    logger.info(`Proxy server request handler rate limit is ${LIMITER.maxConcurrency}`);
     const requestHandler = async (reqFromDownstreamClient, resToDownstreamClient) => {
         const downstreamUserAgent = reqFromDownstreamClient.headers["user-agent"]; // "curl/x.x.x"
         const downstreamIp = getDownstreamClientIp(reqFromDownstreamClient);
         const downstreamRequestedHttpMethod = reqFromDownstreamClient.method; // "GET", "POST", etc.
         const downstreamRequestedHost = reqFromDownstreamClient.headers.host; // "example.com:8080"
         const downstreamRequestedFullPath = reqFromDownstreamClient.url; //  "/some/path?param=1&param=2"
-        logger.info(`Received downstream request from '${downstreamUserAgent}' ${downstreamIp} ${downstreamRequestedHttpMethod} ${downstreamRequestedHost} ${downstreamRequestedFullPath}
-        Proxy server request handler rate limit is ${limiter.maxConcurrency}`);
+        logger.info(`Received downstream request from '${downstreamUserAgent}' ${downstreamIp} ${downstreamRequestedHttpMethod} ${downstreamRequestedHost} ${downstreamRequestedFullPath}`);
         if (!downstreamRequestedFullPath || !downstreamRequestedHost) {
             logger.warn(`400 Invalid Request, downstream ${downstreamUserAgent} req.url is absent or downstream.headers.host is absent.`);
             resToDownstreamClient.writeHead(400).end('Invalid Request');
@@ -403,7 +403,7 @@ export async function startProxyServer(proxyConfigPath, localYarnConfigPath, glo
                 logger.warn(`Downstream ${reqFromDownstreamClient.headers["user-agent"]} request is destroyed, no need to proxy request to upstream ${targetUrl} any more.`);
                 return;
             }
-            const okResponseOrNull = await fetchFromRegistry(targetRegistry, targetUrl, reqFromDownstreamClient, limiter);
+            const okResponseOrNull = await fetchFromRegistry(targetRegistry, targetUrl, reqFromDownstreamClient, LIMITER);
             if (okResponseOrNull) {
                 successfulResponseFromUpstream = okResponseOrNull;
                 break;

package/dist/utils/ConcurrencyLimiter.d.ts

@@ -1,10 +1,12 @@
-export default class ReentrantConcurrencyLimiter {
+/**
+ * 并发控制器
+ * @note 不支持重入，重入可能导致死锁
+ */
+export default class ConcurrencyLimiter {
     readonly maxConcurrency: number;
     private current;
     private queue;
-    private executionStack;
     constructor(maxConcurrency: number);
-    private getContextId;
     acquire(): Promise<void>;
     release(): void;
     run<T>(task: () => Promise<T>): Promise<T>;

package/dist/utils/ConcurrencyLimiter.js

@@ -1,51 +1,38 @@
-export default class ReentrantConcurrencyLimiter {
+/**
+ * 并发控制器
+ * @note 不支持重入，重入可能导致死锁
+ */
+export default class ConcurrencyLimiter {
     maxConcurrency;
     current = 0;
     queue = [];
-    executionStack = [];
     constructor(maxConcurrency) {
         if (maxConcurrency <= 0) {
             throw new Error("maxConcurrency must be positive");
         }
         this.maxConcurrency = maxConcurrency;
     }
-    getContextId() {
-        return Symbol('context');
-    }
     async acquire() {
-        const contextId = this.getContextId();
-        const existingContext = this.executionStack.find(c => c.contextId === contextId);
-        if (existingContext) {
-            existingContext.depth++;
-            return;
-        }
         if (this.current < this.maxConcurrency) {
             this.current++;
-            this.executionStack.push({ contextId, depth: 1 });
             return;
         }
         return new Promise((resolve) => {
-            this.queue.push(() => {
-                this.current++;
-                this.executionStack.push({ contextId, depth: 1 });
-                resolve();
-            });
+            this.queue.push(resolve);
         });
     }
     release() {
-        if (this.executionStack.length === 0) {
+        if (this.current <= 0) {
             throw new Error("release() called without acquire()");
         }
-        const lastContext = this.executionStack[this.executionStack.length - 1];
-        lastContext.depth--;
-        if (lastContext.depth === 0) {
-            this.executionStack.pop();
-            this.current--;
-            if (this.queue.length > 0) {
-                const next = this.queue.shift();
-                if (next)
-                    next();
-            }
+        this.current--;
+        const next = this.queue.shift();
+        if (next) {
+            // 异步执行，避免递归调用栈溢出
+            Promise.resolve().then(() => {
+                this.current++;
+                next();
+            });
         }
     }
     async run(task) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.jimuwd.xian.registry-proxy",
-  "version": "1.1.17",
+  "version": "1.1.19",
   "description": "A lightweight npm registry local proxy with fallback support",
   "type": "module",
   "main": "dist/server/index.js",