com.jimuwd.xian.registry-proxy 1.0.97 → 1.0.99

package/dist/index.js

@@ -8,32 +8,8 @@ import { homedir } from 'os';
 import { join, resolve } from 'path';
 import { URL } from 'url';
 import logger from "./utils/logger.js";
+import ConcurrencyLimiter from "./utils/ConcurrencyLimiter.js";
 const { readFile, writeFile } = fsPromises;
-class ConcurrencyLimiter {
-    maxConcurrency;
-    current = 0;
-    queue = [];
-    constructor(maxConcurrency) {
-        this.maxConcurrency = maxConcurrency;
-    }
-    async acquire() {
-        if (this.current < this.maxConcurrency) {
-            this.current++;
-            return Promise.resolve();
-        }
-        return new Promise((resolve) => {
-            this.queue.push(resolve);
-        });
-    }
-    release() {
-        this.current--;
-        const next = this.queue.shift();
-        if (next) {
-            this.current++;
-            next();
-        }
-    }
-}
 const limiter = new ConcurrencyLimiter(Infinity);
 function removeEndingSlashAndForceStartingSlash(str) {
     if (!str)
@@ -208,33 +184,34 @@ async function writeResponseToDownstreamClient(registryInfo, targetUrl, resToDow
             // 默认是 connection: keep-alive 和 keep-alive: timeout=5，这里直接给它咔嚓掉
             resToDownstreamClient.setHeader('Connection', 'close');
             resToDownstreamClient.removeHeader('Keep-Alive');
-            resToDownstreamClient.setHeader('content-type', 'application/json');
+            resToDownstreamClient.setHeader('content-type', contentType);
             resToDownstreamClient.setHeader('content-length', Buffer.byteLength(bodyData));
             logger.info(`Response to downstream client headers`, JSON.stringify(resToDownstreamClient.getHeaders()), targetUrl);
             resToDownstreamClient.writeHead(upstreamResponse.status).end(bodyData);
         }
         else if (contentType.includes('application/octet-stream')) { // 二进制流处理
             logger.info("Write application/octet-stream response from upstream to downstream", targetUrl);
-            // 准备通用响应头信息
-            const safeHeaders = {};
-            // 复制所有可能需要的头信息（不包含安全相关的敏感头信息，如access-control-allow-origin、set-cookie、server、strict-transport-security等，这意味着代理服务器向下游客户端屏蔽了这些认证等安全数据）
-            // 也不能包含cf-cache-status、cf-ray（Cloudflare 特有字段）可能干扰客户端解析。
-            const headersToCopy = ['cache-control', 'connection', 'content-type', 'content-encoding', 'content-length', 'date', 'etag', 'last-modified', 'transfer-encoding', 'vary',];
-            headersToCopy.forEach(header => {
-                const value = upstreamResponse.headers.get(header);
-                if (value)
-                    safeHeaders[header] = value;
-            });
-            if (!safeHeaders['content-type'])
-                safeHeaders['content-type'] = 'application/octet-stream';
             if (!upstreamResponse.body) {
                 logger.error(`Empty response body from upstream ${targetUrl}`);
                 resToDownstreamClient.writeHead(502).end('Empty Upstream Response');
             }
             else {
                 // write back to client
+                // 准备通用响应头信息
+                const safeHeaders = { 'content-type': contentType };
+                // 复制所有可能需要的头信息（不包含安全相关的敏感头信息，如access-control-allow-origin、set-cookie、server、strict-transport-security等，这意味着代理服务器向下游客户端屏蔽了这些认证等安全数据）
+                // 也不能包含cf-cache-status、cf-ray（Cloudflare 特有字段）可能干扰客户端解析。
+                const headersToCopy = ['cache-control', 'connection', 'content-encoding', 'content-length', 'date', 'etag', 'last-modified', 'transfer-encoding', 'vary',];
+                headersToCopy.forEach(header => {
+                    const value = upstreamResponse.headers.get(header);
+                    if (value)
+                        safeHeaders[header] = value;
+                });
+                // 必须使用 ServerResponse.setHeaders(safeHeaders)来覆盖现有headers而不是ServerResponse.writeHead(status,headers)来合并headers！
+                // 这个坑害我浪费很久事件来调试！
+                resToDownstreamClient.setHeaders(safeHeaders);
                 logger.info(`Response to downstream client headers`, JSON.stringify(safeHeaders), targetUrl);
-                resToDownstreamClient.writeHead(upstreamResponse.status, safeHeaders);
+                resToDownstreamClient.writeHead(upstreamResponse.status);
                 // stop pipe when req from client is closed accidentally.
                 const cleanup = () => {
                     reqFromDownstreamClient.off('close', cleanup);
@@ -274,9 +251,14 @@ async function writeResponseToDownstreamClient(registryInfo, targetUrl, resToDow
         else {
             logger.warn(`Write unsupported content-type=${contentType} response from upstream to downstream ${targetUrl}`);
             const bodyData = await upstreamResponse.text();
-            const safeHeaders = { 'content-type': contentType, 'content-length': Buffer.byteLength(bodyData) };
-            logger.info(`Response to downstream client headers`, JSON.stringify(safeHeaders), targetUrl);
-            resToDownstreamClient.writeHead(upstreamResponse.status, safeHeaders).end(bodyData);
+            resToDownstreamClient.removeHeader('Transfer-Encoding');
+            // 默认是 connection: keep-alive 和 keep-alive: timeout=5，这里直接给它咔嚓掉
+            resToDownstreamClient.setHeader('Connection', 'close');
+            resToDownstreamClient.removeHeader('Keep-Alive');
+            resToDownstreamClient.setHeader('content-type', contentType);
+            resToDownstreamClient.setHeader('content-length', Buffer.byteLength(bodyData));
+            logger.info(`Response to downstream client headers`, JSON.stringify(resToDownstreamClient.getHeaders()), targetUrl);
+            resToDownstreamClient.writeHead(upstreamResponse.status).end(bodyData);
         }
     }
     catch (err) {
@@ -309,7 +291,8 @@ export async function startProxyServer(proxyConfigPath, localYarnConfigPath, glo
         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 ${downstreamUserAgent} ${downstreamIp} ${downstreamRequestedHttpMethod} ${downstreamRequestedHost} ${downstreamRequestedFullPath}`);
+        logger.info(`Received downstream request from '${downstreamUserAgent}' ${downstreamIp} ${downstreamRequestedHttpMethod} ${downstreamRequestedHost} ${downstreamRequestedFullPath}
+        Proxy server request handler rate limit is ${limiter.maxConcurrency}`);
         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');

package/dist/utils/ConcurrencyLimiter.d.ts

@@ -0,0 +1,9 @@
+export default class ConcurrencyLimiter {
+    readonly maxConcurrency: number;
+    private current;
+    private queue;
+    constructor(maxConcurrency: number);
+    acquire(): Promise<void>;
+    release(): void;
+    run<T>(task: () => Promise<T>): Promise<T>;
+}

package/dist/utils/ConcurrencyLimiter.js

@@ -0,0 +1,43 @@
+export default class ConcurrencyLimiter {
+    maxConcurrency;
+    current = 0;
+    queue = [];
+    constructor(maxConcurrency) {
+        if (maxConcurrency <= 0) {
+            throw new Error("maxConcurrency must be positive");
+        }
+        this.maxConcurrency = maxConcurrency;
+    }
+    async acquire() {
+        if (this.current < this.maxConcurrency) {
+            this.current++;
+            return;
+        }
+        return new Promise((resolve) => {
+            this.queue.push(resolve);
+        });
+    }
+    release() {
+        if (this.current <= 0) {
+            throw new Error("release() called without acquire()");
+        }
+        this.current--;
+        const next = this.queue.shift();
+        if (next) {
+            // 异步执行，避免递归调用栈溢出
+            Promise.resolve().then(() => {
+                this.current++;
+                next();
+            });
+        }
+    }
+    async run(task) {
+        await this.acquire();
+        try {
+            return await task();
+        }
+        finally {
+            this.release();
+        }
+    }
+}

package/package.json

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