Use ResourceMapper in ldp#put

Author: rubensworks

lib/handlers/post.js

@@ -54,17 +54,15 @@ function handler (req, res, next) {
     debug('receving multiple files')
 
     const busboy = new Busboy({ headers: req.headers })
-    busboy.on('file', function (fieldname, file, filename, encoding, mimetype) {
+    busboy.on('file', async function (fieldname, file, filename, encoding, mimetype) {
       debug('One file received via multipart: ' + filename)
-      ldp.put(
-        req.hostname,
-        path.join(containerPath, filename),
-        file,
-        function (err) {
-          if (err) {
-            busboy.emit('error', err)
-          }
-        })
+      const { url: putUrl } = await ldp.resourceMapper.mapFileToUrl(
+        { path: ldp.resourceMapper._rootPath + path.join(containerPath, filename), hostname: req.hostname })
+      try {
+        await ldp.put(putUrl, file)
+      } catch (err) {
+        busboy.emit('error', err)
+      }
     })
     busboy.on('error', function (err) {
       debug('Error receiving the file: ' + err.message)

lib/handlers/put.js

@@ -7,16 +7,16 @@ function handler (req, res, next) {
   debug(req.originalUrl)
   res.header('MS-Author-Via', 'SPARQL')
 
-  ldp.put(req.hostname, req.path, req, function (err) {
-    if (err) {
+  ldp.put(req, req)
+    .then(() => {
+      debug('succeded putting the file')
+
+      res.sendStatus(201)
+      return next()
+    })
+    .catch(err => {
       debug('error putting the file:' + err.message)
       err.message = 'Can\'t write file: ' + err.message
       return next(err)
-    }
-
-    debug('succeded putting the file')
-
-    res.sendStatus(201)
-    return next()
-  })
+    })
 }

lib/ldp.js

@@ -191,21 +191,23 @@ class LDP {
       extension = ''
     }
     // TODO: possibly package this in ldp.post
-    ldp.getAvailablePath(host, containerPath, { slug, extension }).then(resourcePath => {
-      debug.handlers('POST -- Will create at: ' + resourcePath)
-      let originalPath = resourcePath
-      if (container) {
-        // Create directory by an LDP PUT to the container's .meta resource
-        resourcePath = path.join(originalPath, ldp.suffixMeta)
-        if (originalPath && !originalPath.endsWith('/')) {
-          originalPath += '/'
+    ldp.getAvailablePath(host, containerPath, { slug, extension })
+      .then(async resourcePath => {
+        debug.handlers('POST -- Will create at: ' + resourcePath)
+        let originalPath = resourcePath
+        if (container) {
+          // Create directory by an LDP PUT to the container's .meta resource
+          resourcePath = path.join(originalPath, ldp.suffixMeta)
+          if (originalPath && !originalPath.endsWith('/')) {
+            originalPath += '/'
+          }
         }
-      }
-      ldp.put(host, resourcePath, stream, function (err) {
-        if (err) callback(err)
+        const { url: putUrl } = await this.resourceMapper.mapFileToUrl(
+          { path: this.resourceMapper._rootPath + resourcePath, hostname: host })
+        await ldp.put(putUrl, stream)
         callback(null, originalPath)
       })
-    })
+      .catch((err) => callback(err))
   }
 
   /**
@@ -226,63 +228,54 @@ class LDP {
    *
    * @return {Promise<Graph>}
    */
-  putGraph (graph, uri, contentType = DEFAULT_CONTENT_TYPE) {
-    return new Promise((resolve, reject) => {
-      let parsedUri = url.parse(uri)
-      let hostname = parsedUri.hostname
-      let path = parsedUri.pathname
-
-      serialize(graph, uri, contentType)
-        .then((content) => {
-          let stream = stringToStream(content)
-
-          this.put(hostname, path, stream, (error) => {
-            if (error) { return reject(error) }
-
-            resolve(graph)
-          })
-        })
-        .catch(reject)
-    })
+  async putGraph (graph, uri, contentType = DEFAULT_CONTENT_TYPE) {
+    const { path } = url.parse(uri)
+    const content = await serialize(graph, uri, contentType)
+    let stream = stringToStream(content)
+    return await this.put(path, stream)
   }
 
-  put (host, resourcePath, stream, callback) {
-    const ldp = this
-    const root = !ldp.multiuser ? ldp.root : ldp.root + host + '/'
-    const filePath = utils.uriToFilename(resourcePath, root, host)
+  async put (url, stream) {
+    const { path: filePath } = await this.resourceMapper.mapUrlToFile({ url })
 
     // PUT requests not supported on containers. Use POST instead
     if (filePath.endsWith('/')) {
-      return callback(error(409,
-        'PUT not supported on containers, use POST instead'))
+      throw error(409,
+        'PUT not supported on containers, use POST instead')
     }
 
     // First check if we are above quota
-    overQuota(root, this.serverUri).then((isOverQuota) => {
-      if (isOverQuota) {
-        return callback(error(413,
-          'User has exceeded their storage quota'))
-      }
+    let isOverQuota
+    try {
+      isOverQuota = await overQuota(this.resourceMapper.rootPath, this.serverUri)
+    } catch (err) {
+      throw error(500, 'Error finding user quota')
+    }
+    if (isOverQuota) {
+      throw error(413, 'User has exceeded their storage quota')
+    }
 
-      // Second, create the enclosing directory, if necessary
-      const dirName = path.dirname(filePath)
-      mkdirp(dirName, (err) => {
-        if (err) {
-          debug.handlers('PUT -- Error creating directory: ' + err)
-          return callback(error(err,
-            'Failed to create the path to the new resource'))
-        }
-        // Directory created, now write the file
-        const file = stream.pipe(fs.createWriteStream(filePath))
-        file.on('error', function () {
-          callback(error(500, 'Error writing data'))
-        })
-        file.on('finish', function () {
-          debug.handlers('PUT -- Wrote data to: ' + filePath)
-          callback(null)
-        })
+    // Second, create the enclosing directory, if necessary
+    const dirName = path.dirname(filePath)
+    try {
+      await promisify(mkdirp)(dirName)
+    } catch (err) {
+      debug.handlers('PUT -- Error creating directory: ' + err)
+      throw error(err,
+        'Failed to create the path to the new resource')
+    }
+
+    // Directory created, now write the file
+    return await new Promise((resolve, reject) => {
+      const file = stream.pipe(fs.createWriteStream(filePath))
+      file.on('error', function () {
+        reject(error(500, 'Error writing data'))
+      })
+      file.on('finish', function () {
+        debug.handlers('PUT -- Wrote data to: ' + filePath)
+        resolve(null)
       })
-    }).catch(() => callback(error(500, 'Error finding user quota')))
+    })
   }
 
   exists (hostname, path, callback) {

lib/resource-mapper.js

@@ -29,6 +29,10 @@ class ResourceMapper {
     }
   }
 
+  get rootPath() {
+    return this._rootPath
+  }
+
   // Maps the request for a given resource and representation format to a server file
   async mapUrlToFile ({ url, contentType, createIfNotExists }) {
     const fullPath = this._getFullPath(url)