Merge branch 'master' of https://github.com/solid/node-solid-server into fix/#1171

Author: jaxoncreed

bin/lib/cli-utils.js

@@ -1,5 +1,5 @@
 const fs = require('fs-extra')
-const { cyan, bold } = require('colorette')
+const { red, cyan, bold } = require('colorette')
 const { URL } = require('url')
 const LDP = require('../../lib/ldp')
 const AccountManager = require('../../lib/models/account-manager')
@@ -41,7 +41,22 @@ function loadConfig (program, options) {
     const config = JSON.parse(file)
     argv = { ...config, ...argv }
   } catch (err) {
-    // No file exists, not a problem
+    // If config file was specified, but it doesn't exist, stop with error message
+    if (typeof argv['configFile'] !== 'undefined') {
+      if (!fs.existsSync(configFile)) {
+        console.log(red(bold('ERR')), 'Config file ' + configFile + ' doesn\'t exist.')
+        process.exit(1)
+      }
+    }
+
+    // If the file exists, but parsing failed, stop with error message
+    if (fs.existsSync(configFile)) {
+      console.log(red(bold('ERR')), 'config file ' + configFile + ' couldn\'t be parsed: ' + err)
+      process.exit(1)
+    }
+
+    // Legacy behavior - if config file does not exist, start with default
+    // values, but an info message to create a config file.
     console.log(cyan(bold('TIP')), 'create a config.json: `$ solid init`')
   }
 

lib/acl-checker.js

@@ -7,6 +7,8 @@ const aclCheck = require('@solid/acl-check')
 const { URL } = require('url')
 const { promisify } = require('util')
 const fs = require('fs')
+const Url = require('url')
+const httpFetch = require('node-fetch')
 
 const DEFAULT_ACL_SUFFIX = '.acl'
 const ACL = rdf.Namespace('http://www.w3.org/ns/auth/acl#')
@@ -156,7 +158,7 @@ class ACLChecker {
     return new ACLChecker(resource, {
       agentOrigin: req.get('origin'),
       // host: req.get('host'),
-      fetch: fetchFromLdp(ldp.resourceMapper),
+      fetch: fetchLocalOrRemote(ldp.resourceMapper, ldp.serverUri),
       fetchGraph: (uri, options) => {
         // first try loading from local fs
         return ldp.getGraph(uri, options.contentType)
@@ -178,17 +180,27 @@ class ACLChecker {
  *   - `callback(null, graph)` with the parsed RDF graph of the fetched resource
  * @return {Function} Returns a `fetch(uri, callback)` handler
  */
-function fetchFromLdp (mapper) {
+function fetchLocalOrRemote (mapper, serverUri) {
   return async function fetch (url, graph = rdf.graph()) {
     // Convert the URL into a filename
-    let path, contentType
-    try {
-      ({ path, contentType } = await mapper.mapUrlToFile({ url }))
-    } catch (err) {
-      throw new HTTPError(404, err)
+    let body, path, contentType
+
+    if (Url.parse(url).host.includes(Url.parse(serverUri).host)) {
+      // Fetch the acl from local
+      try {
+        ({ path, contentType } = await mapper.mapUrlToFile({ url }))
+      } catch (err) {
+        throw new HTTPError(404, err)
+      }
+      // Read the file from disk
+      body = await promisify(fs.readFile)(path, { 'encoding': 'utf8' })
+    } else {
+      // Fetch the acl from the internet
+      const response = await httpFetch(url)
+      body = await response.text()
+      contentType = response.headers.get('content-type')
     }
-    // Read the file from disk
-    const body = await promisify(fs.readFile)(path, { 'encoding': 'utf8' })
+
     // Parse the file as Turtle
     rdf.parse(body, graph, url, contentType)
     return graph

lib/handlers/patch.js

@@ -11,7 +11,7 @@ const $rdf = require('rdflib')
 const crypto = require('crypto')
 const overQuota = require('../utils').overQuota
 const getContentType = require('../utils').getContentType
-const { lock } = require('proper-lockfile')
+const withLock = require('../lock')
 
 // Patch parsers by request body content type
 const PATCH_PARSERS = {
@@ -25,7 +25,6 @@ const DEFAULT_FOR_NEW_CONTENT_TYPE = 'text/turtle'
 async function patchHandler (req, res, next) {
   debug(`PATCH -- ${req.originalUrl}`)
   res.header('MS-Author-Via', 'SPARQL')
-  let releaseLock
   try {
     // Obtain details of the target resource
     const ldp = req.app.locals.ldp
@@ -65,19 +64,16 @@ async function patchHandler (req, res, next) {
     }
 
     // Patch the graph and write it back to the file
-    releaseLock = await lock(path, { retries: 10, realpath: false })
-    const graph = await readGraph(resource)
-    await applyPatch(patchObject, graph, url)
-    const result = await writeGraph(graph, resource, ldp.resourceMapper.rootPath, ldp.serverUri)
+    const result = await withLock(path, { mustExist: false }, async () => {
+      const graph = await readGraph(resource)
+      await applyPatch(patchObject, graph, url)
+      return writeGraph(graph, resource, ldp.resourceMapper.rootPath, ldp.serverUri)
+    })
 
     // Send the result to the client
     res.send(result)
   } catch (err) {
     return next(err)
-  } finally {
-    if (releaseLock) {
-      await releaseLock()
-    }
   }
   return next()
 }

lib/ldp.js

@@ -18,7 +18,7 @@ const parse = require('./utils').parse
 const fetch = require('node-fetch')
 const { promisify } = require('util')
 const URI = require('urijs')
-const { lock } = require('proper-lockfile')
+const withLock = require('./lock')
 
 const RDF_MIME_TYPES = new Set([
   'text/turtle',            // .ttl
@@ -78,17 +78,11 @@ class LDP {
   }
 
   async readResource (url) {
-    let releaseLock
     try {
       const { path } = await this.resourceMapper.mapUrlToFile({ url })
-      releaseLock = await lock(path, { retries: 10 })
-      return await promisify(fs.readFile)(path, {encoding: 'utf8'})
+      return await withLock(path, () => promisify(fs.readFile)(path, {encoding: 'utf8'}))
     } catch (err) {
       throw error(err.status, err.message)
-    } finally {
-      if (releaseLock) {
-        await releaseLock()
-      }
     }
   }
 
@@ -244,24 +238,16 @@ class LDP {
     }
 
     // Directory created, now write the file
-    let releaseLock
-    try {
-      releaseLock = await lock(path, { retries: 10, realpath: false })
-      return await new Promise((resolve, reject) => {
-        const file = stream.pipe(fs.createWriteStream(path))
-        file.on('error', function () {
-          reject(error(500, 'Error writing data'))
-        })
-        file.on('finish', function () {
-          debug.handlers('PUT -- Wrote data to: ' + path)
-          resolve()
-        })
+    return withLock(path, { mustExist: false }, () => new Promise((resolve, reject) => {
+      const file = stream.pipe(fs.createWriteStream(path))
+      file.on('error', function () {
+        reject(error(500, 'Error writing data'))
       })
-    } finally {
-      if (releaseLock) {
-        await releaseLock()
-      }
-    }
+      file.on('finish', function () {
+        debug.handlers('PUT -- Wrote data to: ' + path)
+        resolve()
+      })
+    }))
   }
 
   async exists (hostname, path, searchIndex = true) {
@@ -379,26 +365,18 @@ class LDP {
         chunksize = (end - start) + 1
         contentRange = 'bytes ' + start + '-' + end + '/' + total
       }
-      let releaseLock
-      try {
-        releaseLock = await lock(path, { retries: 10 })
-        return await new Promise((resolve, reject) => {
-          const stream = fs.createReadStream(path, start && end ? {start, end} : {})
-          stream
-            .on('error', function (err) {
-              debug.handlers(`GET -- error reading ${path}: ${err.message}`)
-              return reject(error(err, "Can't read file " + err))
-            })
-            .on('open', function () {
-              debug.handlers(`GET -- Reading ${path}`)
-              return resolve({ stream, contentType, container: false, contentRange, chunksize })
-            })
-        })
-      } finally {
-        if (releaseLock) {
-          await releaseLock()
-        }
-      }
+      return withLock(path, () => new Promise((resolve, reject) => {
+        const stream = fs.createReadStream(path, start && end ? {start, end} : {})
+        stream
+          .on('error', function (err) {
+            debug.handlers(`GET -- error reading ${path}: ${err.message}`)
+            return reject(error(err, "Can't read file " + err))
+          })
+          .on('open', function () {
+            debug.handlers(`GET -- Reading ${path}`)
+            return resolve({ stream, contentType, container: false, contentRange, chunksize })
+          })
+      }))
     }
   }
 
@@ -447,17 +425,11 @@ class LDP {
   }
 
   async deleteResource (path) {
-    let releaseLock
     try {
-      releaseLock = await lock(path, { retries: 10 })
-      return await promisify(fs.unlink)(path)
+      return await withLock(path, { mustExist: false }, () => promisify(fs.unlink)(path))
     } catch (err) {
       debug.container('DELETE -- unlink() error: ' + err)
       throw error(err, 'Failed to delete resource')
-    } finally {
-      if (releaseLock) {
-        await releaseLock()
-      }
     }
   }
 

lib/lock.js

@@ -0,0 +1,31 @@
+const { lock } = require('proper-lockfile')
+
+const staleSeconds = 30
+
+// Obtains a lock on the path, and maintains it until the callback finishes
+function withLock (path, options = {}, callback = options) {
+  return new Promise(async (resolve, reject) => {
+    let releaseLock, result
+    try {
+      // Obtain the lock
+      releaseLock = await lock(path, {
+        retries: 10,
+        update: 1000,
+        stale: staleSeconds * 1000,
+        realpath: !!options.mustExist,
+        onCompromised: () =>
+          reject(new Error(`The file at ${path} was not updated within ${staleSeconds}s.`))
+      })
+      // Hold on to the lock until the callback's returned promise resolves
+      result = await callback()
+    } catch (error) {
+      reject(error)
+    // Ensure the lock is always released
+    } finally {
+      await releaseLock()
+    }
+    resolve(result)
+  })
+}
+
+module.exports = withLock