Refactor to use storage backends

components/handlers/del_attachment.js

+'use strict';
+
+const { FileNotFoundError } = require('../errors');
+const logging = require('../logging').getWrapperForModule('del_attachment');
+
+/**
+ * Created route handler for deleting attachments
+ * @param {Storage} storage - File storage
+ * @return {Function} Express handler
+ */
+module.exports = function (storage) {
+  return function (request, response) {
+    let hash = request.params.hash;
+
+    let sendResponse = () => {
+      response.sendStatus(200);
+    };
+
+    let handleError = (error) => {
+      if (error instanceof FileNotFoundError) {
+        response.sendStatus(404);
+      } else {
+        response.sendStatus(500);
+        logging.error(error);
+      }
+    };
+
+    return storage
+      .delete(hash)
+      .then(sendResponse)
+      .catch(handleError);
+  };
+};

components/handlers/download.js

+'use strict';
+
+const Promise = require('bluebird');
+
+const { FileNotFoundError } = require('../errors');
+const logging = request('../logging').getWrapperForModule('download');
+
+/**
+ * Creates route handler for /<base-url>/:hash/:filename.
+ * @param {Storage} storage - Storage to use for serving files
+ * @param {Metadata} metadataStorage - Metadata storage
+ * @param {Object} options - options (with CACHE_DURATION field)
+ * @return {Function} Express handler
+ */
+module.exports = function (storage, metadataStorage, options) {
+  const CACHE_DURATION = options.CACHE_DURATION;
+  return function (request, response) {
+    let hash = request.params.hash;
+
+    let getStream = (record) => {
+      return Promise.join(Promise.resolve(record), storage.get(hash));
+    };
+
+    let sendResponse = (record, stream) => {
+      response.writeHead(200, {
+        'Cache-Control': `private, max-age=${CACHE_DURATION}`,
+        'Content-Type': record.mimetype || 'application/octet-stream',
+        'Last-Modified': new Date().toUTCString(),
+      });
+
+      stream.pipe(response);
+    };
+
+    let send304Response = (mtime) => {
+      response.writeHead(304, {
+        'Last-Modified': mtime,
+      });
+
+      response.end();
+    };
+
+    let handleError = (error) => {
+      if (error instanceof FileNotFoundError) {
+        response.sendStatus(404);
+      } else {
+        response.sendStatus(500);
+        logging.error(error);
+      }
+    };
+
+    let modifiedSince = request.headers['if-modified-since'];
+    if (modifiedSince) {
+      return send304Response(Number(modifiedSince));
+    } else {
+      return metadataStorage
+        .getRecord(hash)
+        .then(getStream)
+        .spread(sendResponse)
+        .catch(handleError);
+    }
+  }
+};

components/handlers/download_thumb.js

+'use strict';
+
+const Promise = require('bluebird');
+
+const FileNotFoundError = require('../errors').FileNotFoundError;
+const logging = require('../logging').getWrapperForModule('download_thumb');
+
+/**
+ * Creates route handler for /<base-url>/thumb/:size/:hash.
+ * @param {Thumbnail} thumbnail - Thumbnail storage
+ * @param {Metadata} metadataStorage - Metadata storage
+ * @param {Object} options - Options (with CACHE_DURATION field)
+ * @return {Function} Express handler
+ */
+module.exports = function (thumbnail, metadataStorage, options) {
+  const CACHE_DURATION = options.CACHE_DURATION;
+  return function (request, response) {
+    let size = Number(request.params.size);
+    let hash = request.params.hash;
+
+    let getStream = (record) => {
+      return Promise.join(Promise.resolve(record), thumbnail.serve(hash, size));
+    };
+
+    let sendResponse = (record, stream) => {
+      response.writeHead(200, {
+        'Cache-Control': `private, max-age=${CACHE_DURATION}`,
+        'Content-Type': 'image/jpeg',
+        'Last-Modified': Date.now(),
+      });
+
+      stream.pipe(response);
+    };
+
+    let send304Response = (mtime) => {
+      response.writeHead(304, {
+        'Last-Modified': mtime,
+      });
+
+      response.end();
+    };
+
+    let handleError = (error) => {
+      if (error instanceof FileNotFoundError) {
+        response.sendStatus(404);
+      } else {
+        response.sendStatus(500);
+        logging.error(error);
+      }
+    };
+
+    let modifiedSince = request.headers['if-modified-since'];
+    if (modifiedSince) {
+      return send304Response(Number(modifiedSince));
+    } else {
+      return metadataStorage
+        .getRecord(hash)
+        .then(getStream)
+        .spread(sendResponse)
+        .catch(handleError);
+    }
+  }
+};

components/handlers/upload.js

+'use strict';
+
+const fs = require('fs-extra');
+const multiparty = require('multiparty');
+const Promise = require('bluebird');
+
+const logging = require('../logging').getWrapperForModule('upload');
+
+Promise.promisifyAll(multiparty, {
+  multiArgs: true,
+});
+
+/**
+ * Creates route handler for uploading.
+ * @param {Storage} storage - Storage to use for serving files
+ * @param {Metadata} metadataStorage - Metadata storage
+ * @param {Object} options - Options (with MAX_FILE_SIZE field)
+ * @return {Function} Express handler
+ */
+module.exports = function (storage, metadataStorage, options) {
+  const MAX_FILE_SIZE = options.MAX_FILE_SIZE;
+  return function (request, response) {
+    let file;
+    let filename;
+    let mimetype;
+    let hash;
+    let size;
+    let tmpPath;
+
+    let parseForm = () => {
+      let form = new multiparty.Form();
+
+      return form.parseAsync(request).spread((fields, files) => {
+        if (typeof files.file !== 'object' || typeof files.file[0] !== 'object')
+          throw new Error('Invalid input');
+
+        file = files.file[0];
+        filename = file.originalFilename;
+        mimetype = file.headers['content-type'] || 'text/plain';
+        size = file.size;
+        tmpPath = file.path;
+
+        if (size > MAX_FILE_SIZE) throw new Error('File is too big');
+      });
+    };
+
+    let uploadToIpfs = () => {
+      return storage.add(file);
+    };
+
+    let addMetadata = (result) => {
+      result = result[0];
+      hash = result.hash;
+
+      return metadataStorage.addRecord(hash, mimetype, size);
+    };
+
+    let deleteFile = () => {
+      return fs.unlink(tmpPath);
+    };
+
+    let sendResponse = () => {
+      response.json({
+        id: hash,
+        filename: filename,
+        mime: mimetype,
+      });
+    };
+
+    let handleError = (error) => {
+      response.sendStatus(500);
+      logging.error(error);
+    };
+
+    return parseForm()
+      .then(uploadToIpfs)
+      .then(addMetadata)
+      .then(sendResponse)
+      .catch(handleError)
+      .then(deleteFile)
+      .catch((error) => logging.error(error));
+  };
+};
+
+module.exports = upload;

components/settings.js

-/* global appRoot */
-
 'use strict';
 
 const fs = require('fs');
-const path = require('path');
 
 /**
  * Parses JSON from project root to array.
@@ -14,7 +11,7 @@ function parseJson() {
 
   try {
     parsedJson = JSON.parse(
-      fs.readFileSync(path.join(appRoot, 'config.json'), {encoding: 'utf8'})
+      fs.readFileSync('config.json', {encoding: 'utf8'})
     );
   } catch (error) {
     if (error instanceof SyntaxError) {

components/storage-backends/ipfs.js

@@ -2,15 +2,14 @@ const fs = require('fs');
 const ipfsAPI = require('ipfs-api');
 const path = require('path');
 
-const FileNotFoundError = require('../errors').FileNotFoundError;
+const { FileNotFoundError } = require('../errors');
 const logging = require('../logging').getWrapperForModule('ipfs');
-const settings = require('../settings');
 
 /**
  * Represents an interface to interact with IPFS daemon to download and upload
  * attachments.
  */
-class Ipfs {
+class IpfsStorage {
   /**
    * constructor for Ipfs class.
    */
@@ -80,4 +79,4 @@ class Ipfs {
   }
 }
 
-module.exports = Ipfs;
+module.exports = IpfsStorage;

components/thumbnail.js

@@ -6,7 +6,6 @@ const Promise = require('bluebird');
 const sharp = require('sharp');
 
 const FileNotFoundError = require('./errors').FileNotFoundError;
-const Ipfs = require('./ipfs');
 const logging = require('./logging').getWrapperForModule('thumbnail');
 const settings = require('./settings');
 
@@ -21,11 +20,10 @@ class Thumbnail {
   /**
    * Constructor for Thumbnail class.
    */
-  constructor() {
+  constructor (storage) {
     this.cache = settings.thumbnails.cache;
     this.sizes = settings.thumbnails.sizes;
-
-    this.ipfs = new Ipfs();
+    this.storage = storage;
 
     if (this.cache) {
       logging.verbose('Thumbnail cache enabled');
@@ -36,7 +34,7 @@ class Thumbnail {
 
   /**
    * Concatenates pieces to return path to directory for thumbnail.
-   * @param  {String} hash IPFS hash.
+   * @param  {String} hash File hash.
    * @param  {Number} size Size of thumbnail.
    * @return {String}      Path to directory for thumbnail.
    */
@@ -44,12 +42,13 @@ class Thumbnail {
     // QmABHA5h..., 128 => /path/128/AB/
     return path.join(settings.thumbnails.path,
                      String(size),
+                     hash.slice(0, 2),
                      hash.slice(2, 4));
   }
 
   /**
    * Concatenates pieces to return path to thumbnail.
-   * @param  {String} hash IPFS hash.
+   * @param  {String} hash File hash.
    * @param  {Number} size Size of thumbnail.
    * @return {String}      Path to thumbnail.
    */
@@ -61,7 +60,7 @@ class Thumbnail {
 
   /**
    * Serves thumbnail.
-   * @param  {String} hash IPFS hash.
+   * @param  {String} hash File hash.
    * @param  {Number} size Size of thumbnail.
    * @return {Promise}     Stream of thumbnail.
    */
@@ -69,8 +68,8 @@ class Thumbnail {
     if (this.sizes.indexOf(size) == -1) size = THUMB_DIMENSIONS;
 
     let core = function(hash, size) {
-      logging.verbose(`Getting original image for ${hash} from IPFS`);
-      return this.ipfs.serve(hash).then((stream) => {
+      logging.verbose(`Getting original image for ${hash} from storage`);
+      return this.storage.get(hash).then((stream) => {
         return this.create(stream, hash, size).then((stream) => {
           logging.verbose(`Created ${size}x${size} thumbnail for ${hash}`);
           return stream;
@@ -116,7 +115,7 @@ class Thumbnail {
   /**
    * Creates thumbnail for image.
    * @param  {Stream}  inputStream Stream of image.
-   * @param  {String}  hash        IPFS hash of thumbnail.
+   * @param  {String}  hash        Hash of thumbnail.
    * @param  {Number}  size        Size of thumbnail.
    * @return {Promise}             Stream of thumbnail.
    */

test/ipfs.js

@@ -6,21 +6,22 @@ const chai = require('chai');
 const path = require('path');
 const Readable = require('stream').Readable;
 
-const Ipfs = require('../components/ipfs');
+const settings = require('../components/settings');
+const IpfsStorage = require('../components/storage-backends/ipfs');
 
 chai.should();
 chai.use(require('chai-string'));
 
 // ipfs daemon must be running
 describe('Ipfs', () => {
-  const ipfs = new Ipfs();
+  const ipfs = new IpfsStorage(settings.ipfs.url);
 
-  describe('#serve(hash)', () => {
+  describe('#get(hash)', () => {
     // hash of 'cat.png' must exist
     const hash = 'QmTeHHV878utbtigQ8FeNPJ1rNqNXEPHTN9KWwF78hMYpf';
 
     it('should return stream', (done) => {
-      ipfs.serve(hash).then((stream) => {
+      ipfs.get(hash).then((stream) => {
         stream.should.be.an.instanceof(Readable);
         stream._read.should.be.a('function');
         stream._readableState.should.be.an('object');
@@ -31,15 +32,16 @@ describe('Ipfs', () => {
     });
   });
 
-  describe('#upload(file)', () => {
+  describe('#add(file)', () => {
     // file 'cat.png' must be in the test directory
     const file = {
       path: path.join(__dirname, 'cat.png'),
       originalFilename: 'cat.png',
     };
 
-    it('should return hash', (done) => {
-      ipfs.upload(file).then((hash) => {
+    it('should return hash', function (done) {
+      this.timeout(30000);
+      ipfs.add(file).then((hash) => {
         hash = hash[0].hash;
         hash.should.startWith('Qm');
         hash.should.have.length(46);

test/thumbnail.js

@@ -6,6 +6,7 @@ const path = require('path');
 const Promise = require('bluebird');
 
 const settings = require('../components/settings');
+const IpfsStorage = require('../components/storage-backends/ipfs');
 const Thumbnail = require('../components/thumbnail');
 
 chai.should();
@@ -13,16 +14,12 @@ Promise.promisifyAll(fs);
 
 // ipfs daemon and redis must be running
 describe('Thumbnail', () => {
-  const thumbnail = new Thumbnail();
+  const thumbnail = new Thumbnail(new IpfsStorage(settings.ipfs.url));
 
   // hash must exist
   const hash = 'QmTP9aq4Af53gRSCfPZJPCQrJt6J7dWyu9xoypG1ToFBBK';
   const size = Number(
-    settings.thumbnails.sizes[
-      Math.floor(
-        Math.random() * settings.thumbnails.sizes.length
-      )
-    ]
+    settings.thumbnails.sizes[0]
   );
 
   describe('#serve(hash, size)', () => {