socket-function 1.2.17 → 1.2.18

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "1.2.17",
+	"version": "1.2.18",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {

package/src/networking.ts

@@ -1,13 +1,15 @@
 import net from "net";
 import { lazy } from "./caching";
 import { httpsRequest } from "./https";
+import { dnsCacheLookup } from "./dnsCache";
 import { measureWrap } from "./profiling/measure";
 
 export const testTCPIsListening = measureWrap(async function testTCPIsListening(host: string, port: number): Promise<boolean> {
     // We need to establish a TCP connection, then close it? Yeah... so it is
     //  not even a SocketFunction call, because it can't be, because that woule be TLS,
     //  which we can't do with an ip!
-    let socket = net.connect({ host, port });
+    // Resolve through our DNS cache rather than getaddrinfo, to avoid glibc's sticky failure cache.
+    let socket = net.connect({ host, port, lookup: dnsCacheLookup });
     return new Promise((resolve) => {
         socket.on("connect", () => {
             socket.end();

package/src/upreal.ts

@@ -1,7 +1,7 @@
 import * as fs from "fs";
 import * as path from "path";
-import * as https from "https";
 import { spawn } from "child_process";
+import { httpsRequest } from "./https";
 
 // Dependency sections in package.json that upreal is willing to update, in the order we search them.
 const DEP_SECTIONS = [
@@ -86,18 +86,9 @@ async function getLatestVersion(packageName: string): Promise<string> {
         : encodeURIComponent(packageName);
     let url = `https://registry.npmjs.org/${encodedName}/latest`;
 
-    let body = await new Promise<string>((resolve, reject) => {
-        https.get(url, res => {
-            if (res.statusCode !== 200) {
-                res.resume();
-                reject(new Error(`Registry returned ${res.statusCode} for ${url}`));
-                return;
-            }
-            let chunks: Buffer[] = [];
-            res.on("data", chunk => chunks.push(chunk));
-            res.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
-        }).on("error", reject);
-    });
+    // Via httpsRequest so registry lookups go through the DNS cache (and its re-resolve/retry), rather
+    //  than getaddrinfo, which caches certain failures forever.
+    let body = (await httpsRequest(url)).toString("utf8");
 
     let parsed = JSON.parse(body) as { version?: string };
     if (!parsed.version) {

package/src/websocketFactory.ts

@@ -3,6 +3,7 @@ import { isNode } from "./misc";
 import { SenderInterface } from "./CallFactory";
 import { getTrustedCertificates } from "./certStore";
 import { getNodeIdLocation } from "./nodeCache";
+import { dnsCacheLookup } from "./dnsCache";
 import debugbreak from "debugbreak";
 import { SocketFunction } from "../SocketFunction";
 import type * as ws from "ws";
@@ -44,7 +45,13 @@ export function createWebsocketFactory(): WebsocketFactory {
             const ws = require("ws") as typeof import("ws");
             let webSocket = new ws.WebSocket(`wss://${address}:${port}`, proposedProtocols, {
                 ca: getTrustedCertificates(),
-            });
+                // Resolve through our DNS cache instead of getaddrinfo, to avoid glibc's sticky failure
+                //  cache. ws forwards these to the underlying tls/https connect. We don't get httpsRequest's
+                //  connection-level re-resolve+retry here, but the DNS-level retries, positive cache, and
+                //  negative cache still apply, and CallFactory's reconnect picks up a re-resolved address.
+                lookup: dnsCacheLookup,
+                autoSelectFamily: true,
+            } as ws.ClientOptions);
 
             // NOTE: Little setup is done here, because Sometimes websockets are created here,
             //      and sometimes via incoming connections, We should do most setup in