com.jimuwd.xian.registry-proxy 1.0.66 → 1.0.68

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
-import { Server as HttpServer } from 'http';
-import { Server as HttpsServer } from 'https';
+import { Server as HttpServer } from 'node:http';
+import { Server as HttpsServer } from 'node:https';
 export declare function startProxyServer(proxyConfigPath?: string, localYarnConfigPath?: string, globalYarnConfigPath?: string, port?: number): Promise<HttpServer | HttpsServer>;

package/dist/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { createServer } from 'http';
-import { createServer as createHttpsServer } from 'https';
+import http, { createServer } from 'node:http';
+import https, { createServer as createHttpsServer } from 'node:https';
 import { promises as fsPromises, readFileSync } from 'fs';
 import { load } from 'js-yaml';
 import fetch from 'node-fetch';
@@ -34,7 +34,7 @@ class ConcurrencyLimiter {
         }
     }
 }
-const limiter = new ConcurrencyLimiter(1000);
+const limiter = new ConcurrencyLimiter(10);
 function removeEndingSlashAndForceStartingSlash(str) {
     if (!str)
         return '/';
@@ -160,7 +160,7 @@ async function fetchFromRegistry(registry, targetUrl, limiter) {
         limiter.release();
     }
 }
-async function writeResponseToDownstreamClient(registryInfo, targetUrl, resToDownstreamClient, upstreamResponse, downstreamReq, proxyInfo, proxyPort, registryInfos) {
+async function writeResponseToDownstreamClient(registryInfo, targetUrl, resToDownstreamClient, upstreamResponse, reqFromDownstreamClient, proxyInfo, proxyPort, registryInfos) {
     if (!upstreamResponse.ok)
         throw new Error("Only 2xx upstream response is supported");
     try {
@@ -183,7 +183,7 @@ async function writeResponseToDownstreamClient(registryInfo, targetUrl, resToDow
             // JSON 处理逻辑
             const data = await upstreamResponse.json();
             if (data.versions) {
-                const host = downstreamReq.headers.host || `localhost:${proxyPort}`;
+                const host = reqFromDownstreamClient.headers.host || `localhost:${proxyPort}`;
                 const baseUrl = `${proxyInfo.https ? 'https' : 'http'}://${host}${proxyInfo.basePath === '/' ? '' : proxyInfo.basePath}`;
                 for (const versionKey in data.versions) {
                     const packageVersion = data.versions[versionKey];
@@ -206,13 +206,24 @@ async function writeResponseToDownstreamClient(registryInfo, targetUrl, resToDow
             else {
                 // write back to client
                 resToDownstreamClient.writeHead(upstreamResponse.status, safeHeaders);
-                // stop transfer if client is closed accidentally.
+                // clean up when server if client is closed accidentally.
                 const cleanup = () => {
-                    downstreamReq.off('close', cleanup);
-                    logger.warn(`Downstream client closed accidentally, stop pipe from upstream ${targetUrl} to downstream client.`);
+                    reqFromDownstreamClient.off('close', cleanup);
+                    logger.warn(`Downstream client closed connection accidentally, stop pipe from upstream ${targetUrl} to downstream client.`);
                     upstreamResponse.body?.unpipe();
+                    resToDownstreamClient.destroy();
+                    reqFromDownstreamClient.destroy();
+                };
+                reqFromDownstreamClient.on('close', cleanup);
+                // clean up when server closes connection to downstream client.
+                const cleanup0 = () => {
+                    resToDownstreamClient.off('close', cleanup0);
+                    logger.info(`Downstream client closed connection, destroy connection, upstream url is ${targetUrl}`);
+                    /*upstreamResponse.body?.unpipe(); 代理服务器主动关闭与客户端的连接，不需要此时对接管道已经断开了，没必要重复断开*/
+                    resToDownstreamClient.destroy();
+                    reqFromDownstreamClient.destroy();
                 };
-                downstreamReq.on('close', cleanup);
+                resToDownstreamClient.on('close', cleanup0);
                 // write back body data (chunked probably)
                 // pipe upstream body to downstream client
                 upstreamResponse.body.pipe(resToDownstreamClient, { end: false });
@@ -222,16 +233,15 @@ async function writeResponseToDownstreamClient(registryInfo, targetUrl, resToDow
                     logger.info(`Upstream server ${targetUrl} response.body ended.`);
                     resToDownstreamClient.end();
                 })
+                    // connection will be closed automatically when all chunk data is transferred.
                     .on('close', () => {
-                    const errMsg = `Upstream server ${targetUrl} closed connection while transferring data.`;
-                    logger.error(errMsg);
-                    // resToDownstreamClient.destroy(new Error(errMsg));
-                    resToDownstreamClient.destroy();
+                    logger.info(`Upstream server ${targetUrl} closed connection.`);
                 })
                     .on('error', (err) => {
                     const errMsg = `Stream error: ${err.message}`;
                     logger.error(errMsg);
                     resToDownstreamClient.destroy(new Error(errMsg, { cause: err, }));
+                    reqFromDownstreamClient.destroy(new Error(errMsg, { cause: err, }));
                 });
             }
         }
@@ -306,10 +316,16 @@ export async function startProxyServer(proxyConfigPath, localYarnConfigPath, glo
             cert: readFileSync(certPath),
         };
         server = createHttpsServer(httpsOptions, requestHandler);
+        logger.info("Proxy server's maxSockets is", https.globalAgent.maxSockets);
     }
     else {
         server = createServer(requestHandler);
+        logger.info("Proxy server's maxSockets is", http.globalAgent.maxSockets);
     }
+    logger.info(`Proxy server's initial maxConnections is ${server.maxConnections}, adjusting to 10000`);
+    server.maxConnections = 10000;
+    logger.info(`Proxy server's initial timeout is ${server.timeout}, adjusting to 60000ms`);
+    server.timeout = 60000;
     const promisedServer = new Promise((resolve, reject) => {
         server.on('error', (err) => {
             if (err.code === 'EADDRINUSE') {

package/package.json

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