feat(rule): add retry option (#123)

* feat(rule): add `retry` option

The default retry count is `3`.

* fix

* feat(rule): implement exponential retry

* docs: update

Author: azu

ReadMe.md

@@ -64,7 +64,8 @@ The default options are:
       "baseURI": null,
       "ignore": [],
       "preferGET": [],
-      "ignoreRedirects": false
+      "ignoreRedirects": false,
+      "retry": 3
     }
   }
 }
@@ -132,6 +133,11 @@ Example:
 This rule checks for redirects (3xx status codes) and consider's them an error by default.
 To ignore redirects during checks, set this value to `false`.
 
+### retry
+
+This rule checks the url with retry.
+The default max retry count is `3`.
+
 ## Tests
 
 ```

src/no-dead-link.js

@@ -13,7 +13,8 @@ const DEFAULT_OPTIONS = {
   baseURI: null, // {String|null} a base URI to resolve relative URIs.
   ignore: [], // {Array<String>} URIs to be skipped from availability checks.
   preferGET: [], // {Array<String>} origins to prefer GET over HEAD.
-  concurrency: 8 // concurrency count of linting link
+  concurrency: 8, // {number} Concurrency count of  linting link,
+  retry: 3, // {number} Max retry count
 };
 
 // Adopted from http://stackoverflow.com/a/3809435/951517
@@ -69,13 +70,33 @@ function isIgnored(uri, ignore = []) {
   return ignore.some((pattern) => minimatch(uri, pattern));
 }
 
+/**
+ * wait for ms and resolve the promise
+ * @param ms
+ * @returns {Promise<any>}
+ */
+function waitTimeMs(ms) {
+  return new Promise(resolve => {
+    setTimeout(resolve, ms);
+  });
+}
+
 /**
  * Checks if a given URI is alive or not.
+ *
+ * Normally, this method following strategiry about retry
+ *
+ * 1. Head
+ * 2. Get
+ * 3. Get
+ *
  * @param {string} uri
  * @param {string} method
+ * @param {number} maxRetryCount
+ * @param {number} currentRetryCount
  * @return {{ ok: boolean, redirect?: string, message: string }}
  */
-async function isAliveURI(uri, method = 'HEAD') {
+async function isAliveURI(uri, method = 'HEAD', maxRetryCount = 3, currentRetryCount = 0) {
   const { host } = URL.parse(uri);
   const opts = {
     method,
@@ -115,10 +136,17 @@ async function isAliveURI(uri, method = 'HEAD') {
       };
     }
 
-    if (!res.ok && method === 'HEAD') {
-      return isAliveURI(uri, 'GET');
+    if (!res.ok && method === 'HEAD' && currentRetryCount < maxRetryCount) {
+      return isAliveURI(uri, 'GET', maxRetryCount, currentRetryCount + 1);
     }
 
+    // try to fetch again if not reach max retry count
+    if (currentRetryCount < maxRetryCount) {
+      // exponential retry
+      // 0ms -> 100ms -> 200ms -> 400ms -> 800ms ...
+      await waitTimeMs((currentRetryCount ** 2) * 100);
+      return isAliveURI(uri, 'GET', maxRetryCount, currentRetryCount + 1);
+    }
     return {
       ok: res.ok,
       message: `${res.status} ${res.statusText}`,
@@ -127,8 +155,8 @@ async function isAliveURI(uri, method = 'HEAD') {
     // Retry with `GET` method if the request failed
     // as some servers don't accept `HEAD` requests but are OK with `GET` requests.
     // https://github.com/textlint-rule/textlint-rule-no-dead-link/pull/86
-    if (method === 'HEAD') {
-      return isAliveURI(uri, 'GET');
+    if (method === 'HEAD' && currentRetryCount < maxRetryCount) {
+      return isAliveURI(uri, 'GET', maxRetryCount, currentRetryCount + 1);
     }
 
     return {
@@ -169,8 +197,9 @@ function reporter(context, options = {}) {
    * @param {TextLintNode} node TextLintNode the URI belongs to.
    * @param {string} uri a URI string to be linted.
    * @param {number} index column number the URI is located at.
+   * @param {number} maxRetryCount retry count of linting
    */
-  const lint = async ({ node, uri, index }) => {
+  const lint = async ({ node, uri, index }, maxRetryCount) => {
     if (isIgnored(uri, opts.ignore)) {
       return;
     }
@@ -209,12 +238,11 @@ function reporter(context, options = {}) {
 
     const result = isLocal(uri)
       ? await isAliveLocalFile(uri)
-      : await memorizedIsAliveURI(uri, method);
+      : await memorizedIsAliveURI(uri, method, maxRetryCount);
     const { ok, redirected, redirectTo, message } = result;
 
     if (!ok) {
       const lintMessage = `${uri} is dead. (${message})`;
-
       report(node, new RuleError(lintMessage, { index }));
     } else if (redirected && !opts.ignoreRedirects) {
       const lintMessage = `${uri} is redirected to ${redirectTo}. (${message})`;
@@ -276,9 +304,9 @@ function reporter(context, options = {}) {
     },
 
     [`${context.Syntax.Document}:exit`]() {
-      const linkTasks = URIs.map((item) => () => lint(item));
+      const linkTasks = URIs.map((item) => () => lint(item, opts.retry));
       return pAll(linkTasks, {
-        concurrency: opts.concurrency
+        concurrency: opts.concurrency,
       });
     },
   };