socket-function 1.2.17 → 1.2.19

package/index.d.ts

@@ -1008,6 +1008,9 @@ declare module "socket-function/src/https" {
             [key: string]: string | undefined;
         };
         cancel?: Promise<void>;
+        outHeaders?: {
+            [key: string]: string | undefined;
+        };
     }): Promise<Buffer>;
 
 }

package/package.json

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

package/src/https.d.ts

@@ -5,4 +5,7 @@ export declare function httpsRequest(url: string, payload?: Buffer | Buffer[], m
         [key: string]: string | undefined;
     };
     cancel?: Promise<void>;
+    outHeaders?: {
+        [key: string]: string | undefined;
+    };
 }): Promise<Buffer>;

package/src/https.ts

@@ -47,6 +47,8 @@ export function httpsRequest(
     config?: {
         headers?: { [key: string]: string | undefined },
         cancel?: Promise<void>;
+        // Populated with the response headers once they arrive, so the caller can read them.
+        outHeaders?: { [key: string]: string | undefined };
     }
 ): Promise<Buffer> {
     if (isNode()) {
@@ -96,6 +98,12 @@ export function httpsRequest(
                             autoSelectFamily: true,
                         } as https.RequestOptions,
                         async httpResponse => {
+                            if (config?.outHeaders) {
+                                for (let [key, value] of Object.entries(httpResponse.headers)) {
+                                    config.outHeaders[key] = Array.isArray(value) ? value.join(", ") : value;
+                                }
+                            }
+
                             let data: Buffer[] = [];
                             httpResponse.on("data", chunk => {
                                 data.push(chunk);
@@ -158,6 +166,13 @@ export function httpsRequest(
         }
         return new Promise((resolve, reject) => {
             request.onload = () => {
+                if (config?.outHeaders) {
+                    for (let line of request.getAllResponseHeaders().trim().split(/[\r\n]+/)) {
+                        let index = line.indexOf(":");
+                        if (index < 0) continue;
+                        config.outHeaders[line.slice(0, index).trim().toLowerCase()] = line.slice(index + 1).trim();
+                    }
+                }
                 if (!request.status.toString().startsWith("2")) {
                     try {
                         // It should be an error.stack. But if it isn't... just throw the status text...

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