Store multiple resolution copies of every uploaded image

creator-node/package.json

@@ -39,7 +39,9 @@
  "shortid": "^2.2.14",
  "umzug": "^2.2.0",
  "uuid": "3.3.2",
- "lodash": "^4.17.15"
+ "lodash": "^4.17.15",
+ "jimp": "^0.6.1",
+ "exif-parser": "^0.1.12"
  },
  "devDependencies": {
  "mocha": "^5.2.0",

creator-node/sequelize/migrations/20190711143402-add_uuid_to_users.js

@@ -201,30 +201,6 @@ async function insertUUIDs (queryInterface, t) {
  await queryInterface.sequelize.query(`UPDATE "AudiusUsers" SET "audiusUserUUID" = '${uuid()}' WHERE "id" = '${audiusUser.id}'`, { transaction: t })
  }
 
- // Script to fill in file type in the future
- // const files = (await queryInterface.sequelize.query(`SELECT * FROM "Files";`, { transaction: t }))[0]
- // for (let file of files) {
- // // track
- // // picture
- // // metadata
- // let type
- // if (file.sourceFile) {
- // type = 'track'
- // }
- // else {
- // console.log(file.multihash)
- // let respData = (await axios.get(`https://creatornode.audius.co/ipfs/${file.multihash}`)).data
- // try {
- // JSON.parse(JSON.stringify(respData))
- // type = 'metadata'
- // }
- // catch(e){
- // type = 'picture'
- // }
- // }
- // await queryInterface.sequelize.query(`UPDATE "Files" SET "type" = '${type}' WHERE "id" = '${file.id}'`, { transaction: t })
- // }
-
  // associate AudiusUsers table with cnodeUserUUID
  await queryInterface.sequelize.query(`
  UPDATE "AudiusUsers"

creator-node/sequelize/migrations/20190827175430-add-types-to-files.js

@@ -0,0 +1,76 @@
+'use strict'
+module.exports = {
+ up: async (queryInterface, Sequelize) => {
+ const t = await queryInterface.sequelize.transaction()
+ try {
+ const userMetadataFileUUIDSet = new Set(
+ ((await queryInterface.sequelize.query(`SELECT "metadataFileUUID" FROM "AudiusUsers" WHERE "metadataFileUUID" IS NOT NULL;`, { transaction: t }))[0]).map(obj => obj.metadataFileUUID)
+ )
+ const userCoverArtFileUUIDSet = new Set(
+ ((await queryInterface.sequelize.query(`SELECT "coverArtFileUUID" FROM "AudiusUsers" WHERE "coverArtFileUUID" IS NOT NULL;`, { transaction: t }))[0]).map(obj => obj.coverArtFileUUID)
+ )
+ const userProfilePicFileUUIDSet = new Set(
+ ((await queryInterface.sequelize.query(`SELECT "profilePicFileUUID" FROM "AudiusUsers" WHERE "profilePicFileUUID" IS NOT NULL;`, { transaction: t }))[0]).map(obj => obj.profilePicFileUUID)
+ )
+ const trackMetadataFileUUIDSet = new Set(
+ ((await queryInterface.sequelize.query(`SELECT "metadataFileUUID" FROM "Tracks" WHERE "metadataFileUUID" IS NOT NULL;`, { transaction: t }))[0]).map(obj => obj.metadataFileUUID)
+ )
+ const trackCoverArtFileUUIDSet = new Set(
+ ((await queryInterface.sequelize.query(`SELECT "coverArtFileUUID" FROM "Tracks" WHERE "coverArtFileUUID" IS NOT NULL;`, { transaction: t }))[0]).map(obj => obj.coverArtFileUUID)
+ )
+
+ // Populate type for all files
+ const files = (await queryInterface.sequelize.query(`SELECT * FROM "Files";`, { transaction: t }))[0]
+ let orphanedFiles = [] // no types
+ let corruptedFiles = [] // multiple types
+ let trackFiles = []
+ let metadataFiles = []
+ let imageFiles = []
+
+ for (let file of files) {
+ let type = null
+ const fileUUID = file.fileUUID
+
+ // Determine type of file
+ if (file.sourceFile) {
+ type = 'track'
+ trackFiles.push(file)
+ }
+ if (userMetadataFileUUIDSet.has(fileUUID) || trackMetadataFileUUIDSet.has(fileUUID)) {
+ if (type != null) {
+ corruptedFiles.push(file)
+ }
+ type = 'metadata'
+ metadataFiles.push(file)
+ }
+ if (userCoverArtFileUUIDSet.has(fileUUID) || userProfilePicFileUUIDSet.has(fileUUID) || trackCoverArtFileUUIDSet.has(fileUUID)) {
+ if (type != null) {
+ corruptedFiles.push(file)
+ }
+ type = 'image'
+ imageFiles.push(file)
+ }
+ if (type == null) {
+ orphanedFiles.push(file)
+ }
+ // Write file type to DB
+ await queryInterface.sequelize.query(
+ `UPDATE "Files" SET "type" = '${type}' WHERE "fileUUID" = '${fileUUID}'`,
+ { transaction: t }
+ )
+ }
+ console.log('num orphaned files', orphanedFiles.length)
+ console.log('num corrupted files', corruptedFiles.length)
+ console.log(`num track files ${trackFiles.length}`)
+ console.log(`num metadata files ${metadataFiles.length}`)
+ console.log(`num image files ${imageFiles.length}`)
+
+ await t.commit()
+ } catch (e) {
+ await t.rollback()
+ }
+ },
+ down: async (queryInterface, Sequelize) => {
+ await queryInterface.removeColumn('Files', 'type')
+ }
+}

creator-node/src/fileManager.js

@@ -9,8 +9,8 @@ const getUuid = require('uuid/v4')
 const config = require('./config')
 const models = require('./models')
 
-const maxAudioFileSize = parseInt(config.get('maxAudioFileSizeBytes')) // Default = 1,000,000,000 bytes = 1GB
-const maxMemoryFileSize = parseInt(config.get('maxMemoryFileSizeBytes')) // Default = 100,000,000 bytes = 100MB
+const MAX_AUDIO_FILE_SIZE = parseInt(config.get('maxAudioFileSizeBytes')) // Default = 1,000,000,000 bytes = 1GB
+const MAX_MEMORY_FILE_SIZE = parseInt(config.get('maxMemoryFileSizeBytes')) // Default = 100,000,000 bytes = 100MB
 
 const ALLOWED_UPLOAD_FILE_EXTENSIONS = config.get('allowedUploadFileExtensions') // default set in config.json
 const AUDIO_MIME_TYPE_REGEX = /audio\/(.*)/
@@ -21,7 +21,7 @@ const AUDIO_MIME_TYPE_REGEX = /audio\/(.*)/
  * @dev - only call this function when file is not already stored to disk
  * - if it is, then use saveFileToIPFSFromFS()
  */
-async function saveFileFromBuffer (req, buffer) {
+async function saveFileFromBuffer (req, buffer, fileType) {
  // make sure user has authenticated before saving file
  if (!req.userId) {
  throw new Error('User must be authenticated to save a file')
@@ -39,16 +39,15 @@ async function saveFileFromBuffer (req, buffer) {
  await ipfs.pin.add(multihash)
 
  // add reference to file to database
-let file = await models.File.findOrCreate({ where:
+const file = (await models.File.findOrCreate({ where:
  {
  cnodeUserUUID: req.userId,
  multihash: multihash,
  sourceFile: req.fileName,
- storagePath: dstPath
+ storagePath: dstPath,
+ type: fileType
  }
- })
-
- file = file[0].dataValues
+ }))[0].dataValues
 
  req.logger.info('\nAdded file:', multihash, 'file id', file.fileUUID)
  return { multihash: multihash, fileUUID: file.fileUUID }
@@ -60,7 +59,7 @@ async function saveFileFromBuffer (req, buffer) {
  * - Re-save file to disk under multihash.
  * - Save reference to file in DB.
  */
-async function saveFileToIPFSFromFS (req, srcPath) {
+async function saveFileToIPFSFromFS (req, srcPath, fileType) {
  // make sure user has authenticated before saving file
  if (!req.userId) throw new Error('User must be authenticated to save a file')
 
@@ -81,7 +80,8 @@ async function saveFileToIPFSFromFS (req, srcPath) {
  cnodeUserUUID: req.userId,
  multihash: multihash,
  sourceFile: req.fileName,
- storagePath: dstPath
+ storagePath: dstPath,
+ type: fileType
  }
  }))[0].dataValues
 
@@ -195,7 +195,7 @@ function removeTrackFolder (req, fileDir) {
 // Simple in-memory storage for metadata/generic files
 const memoryStorage = multer.memoryStorage()
 const upload = multer({
- limits: { fileSize: maxMemoryFileSize },
+ limits: { fileSize: MAX_MEMORY_FILE_SIZE },
  storage: memoryStorage
 })
 
@@ -223,9 +223,7 @@ const trackDiskStorage = multer.diskStorage({
 
 const trackFileUpload = multer({
  storage: trackDiskStorage,
- limits: {
- fileSize: maxAudioFileSize
- },
+ limits: { fileSize: MAX_AUDIO_FILE_SIZE },
  fileFilter: function (req, file, cb) {
  // the function should call `cb` with a boolean to indicate if the file should be accepted
  if (ALLOWED_UPLOAD_FILE_EXTENSIONS.includes(getFileExtension(file.originalname).slice(1)) && AUDIO_MIME_TYPE_REGEX.test(file.mimetype)) {

creator-node/src/models/file.js

@@ -30,6 +30,13 @@ module.exports = (sequelize, DataTypes) => {
  storagePath: { // format: '/file_storage/__multihash__
  type: DataTypes.TEXT,
  allowNull: false
+ },
+ type: {
+ type: DataTypes.STRING(16),
+ allowNull: true,
+ validate: {
+ isIn: [['track', 'metadata', 'image', 'dir']]
+ }
  }
  }, {})
 

creator-node/src/resizeImage.js

@@ -0,0 +1,99 @@
+const Jimp = require('jimp')
+const ExifParser = require('exif-parser')
+
+const MAX_HEIGHT = 6000 // No image should be taller than this.
+const COLOR_WHITE = 0xFFFFFFFF
+const IMAGE_QUALITY = 90
+const MIME_TYPE_JPEG = 'image/jpeg'
+
+/**
+ * Returns an image that's been resized, cropped into a square, converted into JPEG, and compressed.
+ * @param {Object} req
+ * @param {string} imageBuffer the buffer of the image to use
+ * @param {number} maxWidth max width of the returned image (default is 1,000px)
+ * @param {boolean} square whether or not to square the image
+ * @return {Buffer} the converted image
+ * @dev TODO - replace with child node process bc need for speed
+ */
+async function resizeImage (req, imageBuffer, maxWidth, square) {
+ // eslint-disable-next-line
+ let exif
+ let time = Date.now()
+ req.logger.info(`resize image ${maxWidth} - start`)
+ try {
+ exif = ExifParser.create(imageBuffer).parse()
+ req.logger.info(`resize image ${maxWidth} - create time ${Date.now() - time}`)
+ time = Date.now()
+ } catch (error) {
+ req.logger.error(error)
+ exif = null
+ }
+
+ let img = await Jimp.read(imageBuffer)
+ req.logger.info(`resize image ${maxWidth} - read time ${Date.now() - time}`)
+
+ img = _exifRotate(img, exif)
+ img.background(COLOR_WHITE)
+ let width = img.bitmap.width
+ let height = img.bitmap.height
+
+ if (square) {
+ // If both sides are larger than maxWidth, resizing must occur
+ if (width > maxWidth && height > maxWidth) {
+ width > height ? img.resize(Jimp.AUTO, maxWidth) : img.resize(maxWidth, Jimp.AUTO)
+ }
+ // Crop the image to be square
+ let min = Math.min(img.bitmap.width, img.bitmap.height)
+ img.cover(min, min)
+ } else {
+ // Resize to max width and crop at crazy height
+ if (width > maxWidth) {
+ img.resize(maxWidth, Jimp.AUTO)
+ }
+ img.cover(img.bitmap.width, Math.min(img.bitmap.height, MAX_HEIGHT))
+ }
+
+ // Very high quality, decent size reduction
+ img.quality(IMAGE_QUALITY)
+
+ return img.getBufferAsync(MIME_TYPE_JPEG)
+}
+
+// Copied directly from Jimp.
+// https://github.com/oliver-moran/jimp/blob/12248941fd481121dc5372f6a8154f01930c8d0f/packages/core/src/utils/image-bitmap.js#L31
+function _exifRotate (img, exif) {
+ if (exif && exif.tags && exif.tags.Orientation) {
+ switch (exif.tags.Orientation) {
+ case 1: // Horizontal (normal)
+ // do nothing
+ break
+ case 2: // Mirror horizontal
+ img.mirror(true, false)
+ break
+ case 3: // Rotate 180
+ img.rotate(180, false)
+ break
+ case 4: // Mirror vertical
+ img.mirror(false, true)
+ break
+ case 5: // Mirror horizontal and rotate 270 CW
+ img.rotate(-90, false).mirror(true, false)
+ break
+ case 6: // Rotate 90 CW
+ img.rotate(-90, false)
+ break
+ case 7: // Mirror horizontal and rotate 90 CW
+ img.rotate(90, false).mirror(true, false)
+ break
+ case 8: // Rotate 270 CW
+ img.rotate(-270, false)
+ break
+ default:
+ break
+ }
+ }
+
+ return img
+}
+
+module.exports = resizeImage