zgrzyt 2.1.1 → 2.2.1

package/Readme.md

@@ -36,6 +36,7 @@ zgrzyt --force
 ; list of potential servers configured for this domain CNAME record
 servers[]=alfa.example.net
 servers[]=beta.example.net
+ipv6=true          ; by default ipv4 is true and ipv6 is false
 
 [cloudflare]
 ; cloudflare API token
@@ -51,7 +52,7 @@ method=HEAD        ; optional, HTTP method used by zgrzyt
 ```
 
 If `api.domain` is not specified its value is deduced from `api.url`.
-If `api.method` is not specified zgrzyt will send `HEAD` requests to poll the servers. `api.method` can be set to `GET` if needed. `retry` and `timeout` can be either configured globally or separately for each API.
+If `api.method` is not specified zgrzyt will send `HEAD` requests to poll the servers. `api.method` can be set to `GET` if needed. `retry`, `timeout`, `ipv4`, and `ipv6` can be either configured globally or separately for each API.
 
 ### Multiple checks
 

package/lib/check.js

@@ -23,25 +23,39 @@ export {
 };
 
 async function checkService(server, api) {
-  const address = await resolve(server);
-  debug('Resolved %s to %s', server, address);
-  const ok = await checkApi(api, address);
+  const { ipv4 = true, ipv6 = false } = api;
+  const addresses = await resolve(server, { ipv4, ipv6 });
+  if (debug.enabled) {
+    debug('Resolved %s to %s', server, addresses.map(a => a.address).join(', '));
+  }
+  const oks = await Promise.all(addresses.map(a => checkApi(api, a)));
+  // collate results
+  const ok = oks.every(ok => ok);
   const health = await updateHealth(api, server, ok);
   return {
-    address,
+    address: addresses[0].address,
     server,
     health,
     ok
   };
 }
 
-async function checkApi({ url, timeout, method = 'HEAD', headers = {}, retry = 2, family = 4 }, address) {
+async function checkApi(api, { address, family }) {
+
+  const {
+    url,
+    method = 'HEAD',
+    timeout = 5000,
+    headers = {}
+  } = api;
+
   debug('Checking %s on %s with timeout %dms', url, address, timeout);
 
   const { protocol } = new URL(url);
   const { request } = 'https:' === protocol ? https : http;
 
   let result;
+  let retry = api.retry || 3;
   do {
     result = await makeRequest();
     if (result) {
@@ -54,15 +68,15 @@ async function checkApi({ url, timeout, method = 'HEAD', headers = {}, retry = 2
 
   function makeRequest() {
     return new Promise(resolve => request(url, {
-        method,
-        family,
-        lookup,
-        timeout,
-        headers: {
-          'User-Agent': USER_AGENT,
-          ...headers
-        }
-      })
+      method,
+      family,
+      lookup,
+      timeout,
+      headers: {
+        'User-Agent': USER_AGENT,
+        ...headers
+      }
+    })
       .on('timeout', function () {
         debug('Timeout for %s on %s', url, address);
         this.destroy(new Error('Request timeout.'));
@@ -82,7 +96,11 @@ async function checkApi({ url, timeout, method = 'HEAD', headers = {}, retry = 2
   }
 
   function lookup(domain, options, fn) {
-    fn(null, address, family);
+    debug('lookup', domain, address, options);
+    if (options.all) {
+      address = [address];
+    }
+    setImmediate(fn, null, address, options.family);
   }
 }
 

package/lib/cloudflare.js

@@ -1,29 +1,66 @@
-import got from 'got';
 import makeDebug from 'debug';
 
 const debug = makeDebug('zgrzyt:cloudflare');
 
 export default client;
 
+/* global AbortController, fetch, URLSearchParams */
+
 class CloudflareError extends Error {
   constructor(errors) {
     super(`Cloudflare API error: ${errors[0].message}`);
   }
 }
 
-function client({ token, timeout = 4000, retry = 2 }) {
-  const cf = got.extend({
-    prefixUrl: 'https://api.cloudflare.com/client/v4',
-    resolveBodyOnly: true,
-    responseType: 'json',
-    timeout: { request: timeout },
-    retry: { limit: retry },
-    headers: {
-      'Authorization': `Bearer ${token}`
+function makeFetch({ token, timeout, retry }) {
+  const authorization = `Bearer ${token}`;
+  return {
+    put: (...args) => retryFetch('PUT', ...args),
+    get: (...args) => retryFetch('GET', ...args)
+  };
+
+  async function retryFetch(...args) {
+    while (true) {
+      try {
+        return await doFetch(...args);
+      } catch (err) {
+        if (--retry <= 0) {
+          throw err;
+        }
+      }
+    }
+  }
+
+  async function doFetch(method, command, { searchParams, json }) {
+    const controller = new AbortController();
+    const id = setTimeout(() => controller.abort(), timeout);
+    const url = new URL(command, 'https://api.cloudflare.com/client/v4/');
+    if (searchParams) {
+      url.search = new URLSearchParams(searchParams);
+    }
+    const options = {
+      method,
+      headers: { authorization },
+      signal: controller.signal
+    };
+    if (json) {
+      options.headers['Content-Type'] = 'application/json';
+      options.body = JSON.stringify(json);
     }
-  });
+    const res = await fetch(url, options);
+    clearTimeout(id);
+    return res.json();
+  }
+}
+
+function client({ token, timeout = 4000, retry = 2 }) {
+  const cf = makeFetch({ token, timeout, retry });
   const cacheZones = Object.create(null);
   let pZones;
+  return {
+    switchToService,
+    listRecords
+  };
 
   async function switchToService(zoneName, domain, good) {
     const zone = await getZone(zoneName);
@@ -128,9 +165,4 @@ function client({ token, timeout = 4000, retry = 2 }) {
 
     return success;
   }
-
-  return {
-    switchToService,
-    listRecords
-  };
 }

package/lib/config.js

@@ -53,6 +53,8 @@ function prepareConfig(config) {
     const retry = parseInt(api.retry || config.retry, 10) || 2;
     const force = 'force' in api ? api.force : config.force;
     const repair = parseInt(api.repair || config.repair, 10) || 5;
+    const ipv6 = Boolean(api.ipv6 ?? config.ipv6);
+    const ipv4 = Boolean(api.ipv4 ?? config.ipv4 ?? true);
 
     const { servers } = api.cluster in cluster ? cluster[api.cluster] : config;
     if (!servers || !servers.length) {
@@ -78,6 +80,8 @@ function prepareConfig(config) {
         timeout,
         retry,
         domain,
+        ipv4,
+        ipv6,
         zone
       },
       client,

package/lib/dns.js

@@ -1,22 +1,48 @@
 import { Resolver } from 'node:dns/promises';
 import makeDebug from 'debug';
 
-const resolver = new Resolver();
 const debug = makeDebug('dns:zgrzyt');
 
 const cache = Object.create(null);
 
-export function resolve(domain) {
+const resolver = new Resolver();
+
+/**
+ * Resolve domain to IP addresses
+ *
+ * @param {String} domain
+ * @param { ipv4, ipv6 } type of addresses to resolve
+ * @returns {Promise<Array<{address: String, family: String}>>} list of resolved addresses
+ */
+export async function resolve(domain, { ipv4, ipv6 }) {
   let p = cache[domain];
   if (!p) {
     cache[domain] = p = doResolve(domain);
   }
-  return p;
+  const addresses = await p;
+  return addresses.filter(
+    a => (a.family === 4 && ipv4) || (a.family === 6 && ipv6)
+  );
 }
 
+const RRTYPE_TO_FAMILY = {
+  A: 4,
+  AAAA: 6
+};
+
 async function doResolve(domain) {
   debug('Resolving %s', domain);
-  // const r6 = await resolver.resolve6(domain);
-  const [addr4] = await resolver.resolve4(domain);
-  return addr4;
+
+  const addresses = await Promise.all(['A', 'AAAA'].map(resolveWithFamily));
+  return addresses.flat();
+
+  async function resolveWithFamily(rrtype) {
+    try {
+      const addresses = await resolver.resolve(domain, rrtype);
+      return addresses.map(address => ({ address, family: RRTYPE_TO_FAMILY[rrtype] }));
+    } catch (error) {
+      debug('Failed to resolve %s with type %s: %s', domain, rrtype, error);
+      return [];
+    }
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zgrzyt",
-  "version": "2.1.1",
+  "version": "2.2.1",
   "description": "Poor man's load balancing DNS switcher.",
   "type": "module",
   "author": {
@@ -27,7 +27,6 @@
   },
   "dependencies": {
     "debug": "~4",
-    "got": "~14",
     "parse-domain": "~8",
     "rc": "^1.2.8",
     "sprintfjs": "^1.2.16"
@@ -43,4 +42,4 @@
     "lib",
     "bin"
   ]
-}
+}