feat: adding dnsServers option to polykey

[ci skip]

Author: tegefaulkes

src/PolykeyAgent.ts

@@ -99,6 +99,7 @@ type PolykeyAgentOptions = {
     connectionHolePunchIntervalTime: number;
     rpcCallTimeoutTime: number;
     rpcParserBufferSize: number;
+    dnsServers: Array<string> | undefined;
   };
   mdns: {
     groups: Array<string>;
@@ -386,6 +387,7 @@ class PolykeyAgent {
           groups: optionsDefaulted.mdns.groups,
           port: optionsDefaulted.mdns.port,
         },
+        dnsServers: optionsDefaulted.nodes.dnsServers,
         logger: logger.getChild(NodeManager.name),
       });
       discovery = await Discovery.createDiscovery({

src/network/utils.ts

@@ -1,5 +1,5 @@
 import type { PromiseCancellable } from '@matrixai/async-cancellable';
-import type { ContextTimed } from '@matrixai/contexts';
+import type { ContextTimed, ContextTimedInput } from '@matrixai/contexts';
 import type { Address, Host, Hostname, Port } from './types';
 import type { NodeAddress } from '../nodes/types';
 import type { JSONValue } from '../types';
@@ -296,7 +296,7 @@ function isDNSError(e: { code: string }): boolean {
 function resolveHostname(
   hostname: Hostname,
   servers?: Array<string>,
-  ctx?: Partial<ContextTimed>,
+  ctx?: Partial<ContextTimedInput>,
 ): PromiseCancellable<Array<Host>> {
   const f = async (ctx: ContextTimed) => {
     const hosts: Array<Host> = [];
@@ -403,10 +403,14 @@ function resolvesZeroIP(ip: Host): Host {
  * It will also filter out any duplicates.
  * @param addresses
  * @param existingAddresses
+ * @param servers
+ * @param ctx
  */
 async function resolveHostnames(
   addresses: Array<NodeAddress>,
   existingAddresses: Set<string> = new Set(),
+  servers?: Array<string>,
+  ctx?: Partial<ContextTimedInput>,
 ): Promise<Array<[Host, Port]>> {
   const final: Array<[Host, Port]> = [];
   for (const [host, port] of addresses) {
@@ -416,7 +420,7 @@ async function resolveHostnames(
       existingAddresses.add(`${host}|${port}`);
       continue;
     }
-    const resolvedAddresses = await resolveHostname(host);
+    const resolvedAddresses = await resolveHostname(host, servers, ctx);
     for (const resolvedHost of resolvedAddresses) {
       const newAddress: [Host, Port] = [resolvedHost, port];
       if (

src/nodes/NodeManager.ts

@@ -117,6 +117,7 @@ class NodeManager {
     Map<string, [NodeAddress, NodeContactAddressData]>
   > = new Map();
   protected concurrencyLimit = 3;
+  protected dnsServers: Array<string> | undefined = undefined;
 
   protected refreshBucketHandler: TaskHandler = async (
     ctx,
@@ -224,9 +225,12 @@ class NodeManager {
     // Establishing connections to the initial nodes
     const connectionResults = await Promise.allSettled(
       initialNodes.map(async ([nodeIdEncoded, nodeAddress]) => {
-        const resolvedHosts = await networkUtils.resolveHostnames([
-          nodeAddress,
-        ]);
+        const resolvedHosts = await networkUtils.resolveHostnames(
+          [nodeAddress],
+          undefined,
+          this.dnsServers,
+          ctx,
+        );
         if (resolvedHosts.length === 0) {
           throw new nodesErrors.ErrorNodeManagerResolveNodeFailed(
             `Failed to resolve '${nodeAddress[0]}'`,
@@ -329,6 +333,7 @@ class NodeManager {
     retryConnectionsDelayTime = 45_000, // 45 seconds
     nodesConnectionFindLocalTimeoutTime = config.defaultsSystem
       .nodesConnectionFindLocalTimeoutTime,
+    dnsServers,
     logger,
   }: {
     db: DB;
@@ -347,6 +352,7 @@ class NodeManager {
     refreshBucketDelayJitter?: number;
     retryConnectionsDelayTime?: number;
     nodesConnectionFindLocalTimeoutTime?: number;
+    dnsServers?: Array<string>;
     logger?: Logger;
   }) {
     this.logger = logger ?? new Logger(this.constructor.name);
@@ -366,6 +372,12 @@ class NodeManager {
     this.refreshBucketDelayJitter = Math.max(0, refreshBucketDelayJitter);
     this.retryConnectionsDelayTime = retryConnectionsDelayTime;
     this.connectionFindMDNSTimeoutTime = nodesConnectionFindLocalTimeoutTime;
+    if (dnsServers != null) {
+      this.logger.info(
+        `Overriding DNS resolution servers with ${JSON.stringify(dnsServers)}`,
+      );
+    }
+    this.dnsServers = dnsServers;
   }
 
   public async start() {
@@ -843,8 +855,12 @@ class NodeManager {
                 addresses.push([host, port]);
               }
             }
-            const resolvedHosts =
-              await networkUtils.resolveHostnames(addresses);
+            const resolvedHosts = await networkUtils.resolveHostnames(
+              addresses,
+              undefined,
+              this.dnsServers,
+              ctx,
+            );
 
             try {
               await this.nodeConnectionManager.createConnectionMultiple(