@lblod/mu-auth-sudo 0.5.1 → 0.6.0

package/README.md

@@ -1,5 +1,5 @@
 # mu-auth-sudo
-NPM package for a sparql client for mu.semte.ch that overrules access rights in queries through a mu-auth-sudo header.
+NPM package for a SPARQL client for mu.semte.ch that overrules access rights in queries through a mu-auth-sudo header.
 
 ## Usage
 ```
@@ -13,7 +13,7 @@ import { querySudo as query, updateSudo as update } from '@lblod/mu-auth-sudo';
 
 //Examples
 
-// To run a normal query
+// To run a regular query
 
 const queryString = `SELECT * FROM { GRAPH ?g { ?s ?p ?o. } } LIMIT 1`;
 await query(queryString);
@@ -24,9 +24,11 @@ const updateString = `INSERT DATA { GRAPH <http://foo> { <http://bar> <http://ba
 const extraHeaders = { 'mu-call-scope-id':  'http://foo/bar', 'other-info'; 'hello' };
 await update(updateString, extraHeaders);
 
-// With custom sparqlEndpoint (this should be exceptional, make sure you know what you're doing)
+// With custom connection options (this should be exceptional, make sure you know what you're doing)
 
-await update(updateString, extraHeaders, 'http://the.sparql.endpoint/sparql');
+const connectionOptions = { sparqlEndpoint: 'http://the.custom.endpoint/sparql', mayRetry: true };
+
+await update(updateString, extraHeaders, connectionOptions);
 ```
 
 ## Logging
@@ -39,3 +41,13 @@ The verbosity of logging can be configured as in the [javascript template](https
 - `DEBUG_AUTH_HEADERS`: Debugging of [mu-authorization](https://github.com/mu-semtech/mu-authorization) access-control related headers (default `true`)
 
 Following values are considered true: [`"true"`, `"TRUE"`, `"1"`].
+
+## Retrying
+You can tweak system-wide retry parameters. These should be considered internal, but tweaking them may help in extreme scenarios. Use with extreme caution.
+
+- `SUDO_QUERY_RETRY`: System-wide configuration to enable the retry-mechanism (default `'false'`).
+                        Warning: this overules eventual source-code specifications (i.e. `connectionOptions = { mayRetry: false }`), so make sure you know what you're doing.
+- `SUDO_QUERY_RETRY_MAX_ATTEMPTS`: Specfiy the number of max retry attempts (default: 5)
+- `SUDO_QUERY_RETRY_FOR_HTTP_STATUS_CODES`: Specify what returned HTTP status from the database are allowed for retry. (default: `''`). Overriding this list should be considered case by case.
+- `SUDO_QUERY_RETRY_FOR_CONNECTION_ERRORS`: Specify what connection errors are allowed for retry. (default: `'ECONNRESET,ETIMEDOUT,EAI_AGAIN'`)
+- `SUDO_QUERY_RETRY_TIMEOUT_INCREMENT_FACTOR`: Specify the factor applied to the timeout before the next attempt. Check implementation to see how it is calculated. (default: `'0.3'`)

package/dist/auth-sudo.js

@@ -21,11 +21,24 @@ var LOG_SPARQL_QUERIES = process.env.LOG_SPARQL_QUERIES != undefined ? _envVar2.
 var LOG_SPARQL_UPDATES = process.env.LOG_SPARQL_UPDATES != undefined ? _envVar2.default.get('LOG_SPARQL_UPDATES').asBool() : _envVar2.default.get('LOG_SPARQL_ALL').asBool();
 var DEBUG_AUTH_HEADERS = _envVar2.default.get('DEBUG_AUTH_HEADERS').asBool();
 
+// The following configuration options are considered optional, but may be overriden as a temporary workaround for issues. Thus, a last resort.
+var RETRY = _envVar2.default.get('SUDO_QUERY_RETRY').default('false').asBool();
+var RETRY_MAX_ATTEMPTS = _envVar2.default.get('SUDO_QUERY_RETRY_MAX_ATTEMPTS').default('5').asInt();
+var RETRY_FOR_HTTP_STATUS_CODES = _envVar2.default.get('SUDO_QUERY_RETRY_FOR_HTTP_STATUS_CODES').default('').asArray();
+var RETRY_FOR_CONNECTION_ERRORS = _envVar2.default.get('SUDO_QUERY_RETRY_FOR_CONNECTION_ERRORS').default('ECONNRESET,ETIMEDOUT,EAI_AGAIN').asArray();
+var RETRY_TIMEOUT_INCREMENT_FACTOR = _envVar2.default.get('SUDO_QUERY_RETRY_TIMEOUT_INCREMENT_FACTOR').default('0.3').asFloat();
+
 function sudoSparqlClient() {
   var extraHeaders = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var sparqlEndpoint = arguments[1];
+  var connectionOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+
+  var sparqlEndpoint = process.env.MU_SPARQL_ENDPOINT;
+
+  if (connectionOptions) {
+    sparqlEndpoint = connectionOptions.sparqlEndpoint || sparqlEndpoint;
+  }
 
-  sparqlEndpoint = sparqlEndpoint || process.env.MU_SPARQL_ENDPOINT;
   var options = {
     requestDefaults: {
       headers: {
@@ -75,29 +88,56 @@ function sudoSparqlClient() {
 
 async function executeRawQuery(queryString) {
   var extraHeaders = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var sparqlEndpoint = arguments[2];
+  var connectionOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  var attempt = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
 
 
   if (LOG_SPARQL_QUERIES) {
     console.log(queryString);
   }
 
-  var response = await sudoSparqlClient(extraHeaders, sparqlEndpoint).query(queryString).executeRaw();
-  return maybeParseJSON(response.body);
+  try {
+
+    var response = await sudoSparqlClient(extraHeaders, connectionOptions).query(queryString).executeRaw();
+    return maybeParseJSON(response.body);
+  } catch (ex) {
+
+    if (mayRetry(ex, attempt, connectionOptions)) {
+
+      attempt += 1;
+
+      var sleepTime = nextAttemptTimeout(attempt);
+      console.log('Sleeping ' + sleepTime + ' ms before next attempt');
+      await new Promise(function (r) {
+        return setTimeout(r, sleepTime);
+      });
+
+      return await executeRawQuery(queryString, extraHeaders, connectionOptions, attempt);
+    } else {
+      console.log('Failed Query:\n                  ' + queryString);
+      throw ex;
+    }
+  }
 }
 
 function querySudo(queryString) {
   var extraHeaders = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var sparqlEndpoint = arguments[2];
+  var connectionOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
 
-  return executeRawQuery(queryString, extraHeaders, sparqlEndpoint);
+  if (LOG_SPARQL_QUERIES) {
+    console.log(queryString);
+  }
+  return executeRawQuery(queryString, extraHeaders, connectionOptions);
 }
 
 function updateSudo(queryString) {
   var extraHeaders = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var sparqlEndpoint = arguments[2];
+  var connectionOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
 
-  return executeRawQuery(queryString, extraHeaders, sparqlEndpoint);
+  if (LOG_SPARQL_UPDATES) {
+    console.log(queryString);
+  }
+  return executeRawQuery(queryString, extraHeaders, connectionOptions);
 }
 
 function maybeParseJSON(body) {
@@ -109,6 +149,34 @@ function maybeParseJSON(body) {
   }
 }
 
+function mayRetry(error, attempt) {
+  var connectionOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+
+
+  console.log('Checking retry allowed for error: ' + error + ' and attempt: ' + attempt);
+
+  var mayRetry = false;
+
+  if (!(RETRY || connectionOptions.mayRetry)) {
+    mayRetry = false;
+  } else if (attempt < RETRY_MAX_ATTEMPTS) {
+    if (error.code && RETRY_FOR_CONNECTION_ERRORS.includes(error.code)) {
+      mayRetry = true;
+    } else if (error.httpStatus && RETRY_FOR_HTTP_STATUS_CODES.includes('' + error.httpStatus)) {
+      mayRetry = true;
+    }
+  }
+
+  console.log('Retry allowed? ' + mayRetry);
+
+  return mayRetry;
+}
+
+function nextAttemptTimeout(attempt) {
+  //expected to be milliseconds
+  return Math.round(Math.exp(RETRY_TIMEOUT_INCREMENT_FACTOR * attempt + 10));
+}
+
 var _exports = {
   querySudo: querySudo,
   updateSudo: updateSudo

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lblod/mu-auth-sudo",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "this package provides an alternative sparql client for the mu-javascript-template that has sudo rights.",
   "main": "dist/auth-sudo.js",
   "scripts": {