com.jimuwd.xian.registry-proxy 1.0.108 → 1.0.111

package/dist/index.d.ts

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
 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>;
+export declare function startProxyServer(proxyConfigPath?: string, localYarnConfigPath?: string, globalYarnConfigPath?: string, port?: number): Promise<{
+    serverIpv6: HttpServer | HttpsServer;
+    serverIpv4: HttpServer | HttpsServer;
+}>;

package/dist/index.js

@@ -130,14 +130,17 @@ async function fetchFromRegistry(registry, targetUrl, reqFromDownstreamClient, l
             mergedHeaders.host = upstreamHost;
         }
         const response = await fetch(targetUrl, { headers: mergedHeaders });
-        logger.info(`
-        Response from upstream ${targetUrl}: ${response.status} ${response.statusText} 
-        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.ok ? response : null;
+        if (response.ok) {
+            logger.debug(`Success response from upstream ${targetUrl}: ${response.status} ${response.statusText}
+            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 {
+            logger.info(`Failure response from upstream ${targetUrl}: ${response.status} ${response.statusText} 
+            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')}
+            body=${await response.text()}`);
+            return null;
+        }
     }
     catch (e) {
         if (e instanceof Error) {
@@ -250,7 +253,7 @@ async function writeResponseToDownstreamClient(registryInfo, targetUrl, resToDow
                 // pipe upstream body to downstream client
                 upstreamResponse.body.pipe(resToDownstreamClient, { end: true });
                 upstreamResponse.body
-                    .on('data', (chunk) => logger.info(`Chunk transferred from ${targetUrl} to downstream client size=${chunk.length}`))
+                    .on('data', (chunk) => logger.debug(`Chunk transferred from ${targetUrl} to downstream client size=${chunk.length}`))
                     .on('end', () => {
                     logger.info(`Upstream server ${targetUrl} response.body ended.`);
                     // resToDownstreamClient.end();
@@ -296,6 +299,7 @@ function getDownstreamClientIp(req) {
     // 直接连接时，取 socket.remoteAddress
     return req.socket.remoteAddress;
 }
+// 同时启动ipv6,ipv4监听，比如当客户端访问http://localhost:port时，无论客户端DNS解析到IPV4-127.0.0.1还是IPV6-::1地址，咱server都能轻松应对！
 export async function startProxyServer(proxyConfigPath, localYarnConfigPath, globalYarnConfigPath, port = 0) {
     const proxyInfo = await loadProxyInfo(proxyConfigPath, localYarnConfigPath, globalYarnConfigPath);
     const registryInfos = proxyInfo.registries;
@@ -303,6 +307,7 @@ 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);
+    // the real port server is listening on if configured port is empty or 0
     let proxyPort;
     const requestHandler = async (reqFromDownstreamClient, resToDownstreamClient) => {
         const downstreamUserAgent = reqFromDownstreamClient.headers["user-agent"]; // "curl/x.x.x"
@@ -355,7 +360,9 @@ export async function startProxyServer(proxyConfigPath, localYarnConfigPath, glo
             resToDownstreamClient.writeHead(404).end('All upstream registries failed');
         }
     };
-    let server;
+    // 同时启动ipv6,ipv4监听，比如当客户端访问http://localhost:port时，无论客户端DNS解析到IPV4-127.0.0.1还是IPV6-::1地址，咱server都能轻松应对！
+    let serverIpv6;
+    let serverIpv4;
     if (proxyInfo.https) {
         const { key, cert } = proxyInfo.https;
         const keyPath = resolvePath(key);
@@ -372,40 +379,57 @@ export async function startProxyServer(proxyConfigPath, localYarnConfigPath, glo
             key: readFileSync(keyPath),
             cert: readFileSync(certPath),
         };
-        server = createHttpsServer(httpsOptions, requestHandler);
+        serverIpv6 = createHttpsServer(httpsOptions, requestHandler);
+        serverIpv4 = createHttpsServer(httpsOptions, requestHandler);
         logger.info("Proxy server's maxSockets is", https.globalAgent.maxSockets);
     }
     else {
-        server = createServer(requestHandler);
+        serverIpv6 = createServer(requestHandler);
+        serverIpv4 = 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;
+    // server参数暂时写死
+    const serverMaxConnections = 10000;
+    const serverTimeoutMs = 60000;
+    logger.info(`Proxy server's initial maxConnections is ${serverIpv4.maxConnections}, adjusting to ${serverMaxConnections}`);
+    serverIpv6.maxConnections = serverMaxConnections;
+    serverIpv4.maxConnections = serverMaxConnections;
+    logger.info(`Proxy server's initial timeout is ${serverIpv4.timeout}, adjusting to ${serverTimeoutMs}ms`);
+    serverIpv6.timeout = serverTimeoutMs;
+    serverIpv4.timeout = serverTimeoutMs;
     const promisedServer = new Promise((resolve, reject) => {
-        server.on('error', (err) => {
+        const errHandler = (err) => {
             if (err.code === 'EADDRINUSE') {
                 logger.error(`Port ${port} is in use, please specify a different port or free it.`);
                 process.exit(1);
             }
             logger.error('Server error:', err);
             reject(err);
-        });
-        server.on('connection', (socket) => {
+        };
+        const connectionHandler = (socket) => {
             logger.info("Server on connection");
             socket.setTimeout(60000);
             socket.setKeepAlive(true, 30000);
-        });
-        // ipv4和ipv6双栈支持
-        server.listen(port, '::', () => {
-            const address = server.address();
-            proxyPort = address.port;
+        };
+        // 嵌套的回调函数，在ipv6监听器启动之后会被回调调用
+        const nestedListener = () => {
             const portFile = join(process.env.PROJECT_ROOT || process.cwd(), '.registry-proxy-port');
-            writeFile(portFile, proxyPort.toString()).catch(e => logger.error('Failed to write port file:', e));
-            logger.info(`Proxy server running on ${proxyInfo.https ? 'https' : 'http'}://127.0.0.1:${proxyPort}${basePathPrefixedWithSlash === '/' ? '' : basePathPrefixedWithSlash}`);
-            resolve(server);
-        });
+            writeFile(portFile, proxyPort.toString()).catch(e => logger.error(`Failed to write port file: ${portFile}`, e));
+            logger.info(`Proxy server running on ${proxyInfo.https ? 'https' : 'http'}://localhost:${proxyPort}${basePathPrefixedWithSlash === '/' ? '' : basePathPrefixedWithSlash}`);
+            resolve({ serverIpv6, serverIpv4, });
+        };
+        const listenerCallback = () => {
+            const address = serverIpv6.address();
+            proxyPort = address.port;
+            // 前面已经监听了ipv6端口，追加监听Ipv4同端口号
+            serverIpv4.listen(proxyPort, '0.0.0.0', nestedListener);
+        };
+        serverIpv6.on('error', errHandler);
+        serverIpv4.on('error', errHandler);
+        serverIpv6.on('connection', connectionHandler);
+        serverIpv4.on('connection', connectionHandler);
+        // 为了代理服务器的健壮性，先启动ipv6监听，然后再在其回调函数中启动ipv4监听
+        serverIpv6.listen(port, '::', listenerCallback);
     });
     return promisedServer;
 }

package/package.json

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