server/models/video.js

   1 'use strict'
   2
   3 const config = require('config')
   4 const createTorrent = require('create-torrent')
   5 const ffmpeg = require('fluent-ffmpeg')
   6 const fs = require('fs')
   7 const parallel = require('async/parallel')
   8 const parseTorrent = require('parse-torrent')
   9 const pathUtils = require('path')
  10 const magnet = require('magnet-uri')
  11 const mongoose = require('mongoose')
  12
  13 const constants = require('../initializers/constants')
  14 const customVideosValidators = require('../helpers/custom-validators').videos
  15 const logger = require('../helpers/logger')
  16 const modelUtils = require('./utils')
  17 const utils = require('../helpers/utils')
  18
  19 const http = config.get('webserver.https') === true ? 'https' : 'http'
  20 const host = config.get('webserver.host')
  21 const port = config.get('webserver.port')
  22 const uploadsDir = pathUtils.join(__dirname, '..', '..', config.get('storage.uploads'))
  23 const thumbnailsDir = pathUtils.join(__dirname, '..', '..', config.get('storage.thumbnails'))
  24 const torrentsDir = pathUtils.join(__dirname, '..', '..', config.get('storage.torrents'))
  25 const webseedBaseUrl = http + '://' + host + ':' + port + constants.STATIC_PATHS.WEBSEED
  26
  27 // ---------------------------------------------------------------------------
  28
  29 // TODO: add indexes on searchable columns
  30 const VideoSchema = mongoose.Schema({
  31   name: String,
  32   filename: String,
  33   description: String,
  34   magnetUri: String,
  35   podUrl: String,
  36   author: String,
  37   duration: Number,
  38   thumbnail: String,
  39   tags: [ String ],
  40   createdDate: {
  41     type: Date,
  42     default: Date.now
  43   }
  44 })
  45
  46 VideoSchema.path('name').validate(customVideosValidators.isVideoNameValid)
  47 VideoSchema.path('description').validate(customVideosValidators.isVideoDescriptionValid)
  48 VideoSchema.path('magnetUri').validate(customVideosValidators.isVideoMagnetUriValid)
  49 VideoSchema.path('podUrl').validate(customVideosValidators.isVideoPodUrlValid)
  50 VideoSchema.path('author').validate(customVideosValidators.isVideoAuthorValid)
  51 VideoSchema.path('duration').validate(customVideosValidators.isVideoDurationValid)
  52 // The tumbnail can be the path or the data in base 64
  53 // The pre save hook will convert the base 64 data in a file on disk and replace the thumbnail key by the filename
  54 VideoSchema.path('thumbnail').validate(function (value) {
  55   return customVideosValidators.isVideoThumbnailValid(value) || customVideosValidators.isVideoThumbnail64Valid(value)
  56 })
  57 VideoSchema.path('tags').validate(customVideosValidators.isVideoTagsValid)
  58
  59 VideoSchema.methods = {
  60   isOwned,
  61   toFormatedJSON,
  62   toRemoteJSON
  63 }
  64
  65 VideoSchema.statics = {
  66   getDurationFromFile,
  67   listForApi,
  68   listByUrlAndMagnet,
  69   listByUrls,
  70   listOwned,
  71   listOwnedByAuthor,
  72   listRemotes,
  73   load,
  74   search
  75 }
  76
  77 VideoSchema.pre('remove', function (next) {
  78   const video = this
  79   const tasks = []
  80
  81   tasks.push(
  82     function (callback) {
  83       removeThumbnail(video, callback)
  84     }
  85   )
  86
  87   if (video.isOwned()) {
  88     tasks.push(
  89       function (callback) {
  90         removeFile(video, callback)
  91       },
  92       function (callback) {
  93         removeTorrent(video, callback)
  94       }
  95     )
  96   }
  97
  98   parallel(tasks, next)
  99 })
 100
 101 VideoSchema.pre('save', function (next) {
 102   const video = this
 103   const tasks = []
 104
 105   if (video.isOwned()) {
 106     const videoPath = pathUtils.join(constants.CONFIG.STORAGE.UPLOAD_DIR, video.filename)
 107     this.podUrl = constants.CONFIG.WEBSERVER.URL
 108
 109     tasks.push(
 110       // TODO: refractoring
 111       function (callback) {
 112         createTorrent(videoPath, { announceList: [ [ 'ws://' + host + ':' + port + '/tracker/socket' ] ], urlList: [ webseedBaseUrl + video.filename ] }, function (err, torrent) {
 113           if (err) return callback(err)
 114
 115           fs.writeFile(torrentsDir + video.filename + '.torrent', torrent, function (err) {
 116             if (err) return callback(err)
 117
 118             const parsedTorrent = parseTorrent(torrent)
 119             parsedTorrent.xs = video.podUrl + constants.STATIC_PATHS.TORRENTS + video.filename + '.torrent'
 120             video.magnetUri = magnet.encode(parsedTorrent)
 121
 122             callback(null)
 123           })
 124         })
 125       },
 126       function (callback) {
 127         createThumbnail(videoPath, callback)
 128       }
 129     )
 130
 131     parallel(tasks, function (err, results) {
 132       if (err) return next(err)
 133
 134       video.thumbnail = results[1]
 135
 136       return next()
 137     })
 138   } else {
 139     generateThumbnailFromBase64(video.thumbnail, function (err, thumbnailName) {
 140       if (err) return next(err)
 141
 142       video.thumbnail = thumbnailName
 143
 144       return next()
 145     })
 146   }
 147 })
 148
 149 mongoose.model('Video', VideoSchema)
 150
 151 // ------------------------------ METHODS ------------------------------
 152
 153 function isOwned () {
 154   return this.filename !== null
 155 }
 156
 157 function toFormatedJSON () {
 158   const json = {
 159     id: this._id,
 160     name: this.name,
 161     description: this.description,
 162     podUrl: this.podUrl.replace(/^https?:\/\//, ''),
 163     isLocal: this.isOwned(),
 164     magnetUri: this.magnetUri,
 165     author: this.author,
 166     duration: this.duration,
 167     tags: this.tags,
 168     thumbnailPath: constants.STATIC_PATHS.THUMBNAILS + '/' + this.thumbnail,
 169     createdDate: this.createdDate
 170   }
 171
 172   return json
 173 }
 174
 175 function toRemoteJSON (callback) {
 176   const self = this
 177
 178   // Convert thumbnail to base64
 179   fs.readFile(pathUtils.join(constants.CONFIG.STORAGE.THUMBNAILS_DIR, this.thumbnail), function (err, thumbnailData) {
 180     if (err) {
 181       logger.error('Cannot read the thumbnail of the video')
 182       return callback(err)
 183     }
 184
 185     const remoteVideo = {
 186       name: self.name,
 187       description: self.description,
 188       magnetUri: self.magnetUri,
 189       filename: null,
 190       author: self.author,
 191       duration: self.duration,
 192       thumbnailBase64: new Buffer(thumbnailData).toString('base64'),
 193       tags: self.tags,
 194       createdDate: self.createdDate,
 195       podUrl: self.podUrl
 196     }
 197
 198     return callback(null, remoteVideo)
 199   })
 200 }
 201
 202 // ------------------------------ STATICS ------------------------------
 203
 204 function getDurationFromFile (videoPath, callback) {
 205   ffmpeg.ffprobe(videoPath, function (err, metadata) {
 206     if (err) return callback(err)
 207
 208     return callback(null, Math.floor(metadata.format.duration))
 209   })
 210 }
 211
 212 function listForApi (start, count, sort, callback) {
 213   const query = {}
 214   return modelUtils.listForApiWithCount.call(this, query, start, count, sort, callback)
 215 }
 216
 217 function listByUrlAndMagnet (fromUrl, magnetUri, callback) {
 218   this.find({ podUrl: fromUrl, magnetUri: magnetUri }, callback)
 219 }
 220
 221 function listByUrls (fromUrls, callback) {
 222   this.find({ podUrl: { $in: fromUrls } }, callback)
 223 }
 224
 225 function listOwned (callback) {
 226   // If filename is not null this is *our* video
 227   this.find({ filename: { $ne: null } }, callback)
 228 }
 229
 230 function listOwnedByAuthor (author, callback) {
 231   this.find({ filename: { $ne: null }, author: author }, callback)
 232 }
 233
 234 function listRemotes (callback) {
 235   this.find({ filename: null }, callback)
 236 }
 237
 238 function load (id, callback) {
 239   this.findById(id, callback)
 240 }
 241
 242 function search (value, field, start, count, sort, callback) {
 243   const query = {}
 244   // Make an exact search with the magnet
 245   if (field === 'magnetUri' || field === 'tags') {
 246     query[field] = value
 247   } else {
 248     query[field] = new RegExp(value)
 249   }
 250
 251   modelUtils.listForApiWithCount.call(this, query, start, count, sort, callback)
 252 }
 253
 254 // ---------------------------------------------------------------------------
 255
 256 function removeThumbnail (video, callback) {
 257   fs.unlink(constants.CONFIG.STORAGE.THUMBNAILS_DIR + video.thumbnail, callback)
 258 }
 259
 260 function removeFile (video, callback) {
 261   fs.unlink(constants.CONFIG.STORAGE.UPLOAD_DIR + video.filename, callback)
 262 }
 263
 264 // Maybe the torrent is not seeded, but we catch the error to don't stop the removing process
 265 function removeTorrent (video, callback) {
 266   fs.unlink(torrentsDir + video.filename + '.torrent')
 267 }
 268
 269 function createThumbnail (videoPath, callback) {
 270   const filename = pathUtils.basename(videoPath) + '.jpg'
 271   ffmpeg(videoPath)
 272     .on('error', callback)
 273     .on('end', function () {
 274       callback(null, filename)
 275     })
 276     .thumbnail({
 277       count: 1,
 278       folder: constants.CONFIG.STORAGE.THUMBNAILS_DIR,
 279       size: constants.THUMBNAILS_SIZE,
 280       filename: filename
 281     })
 282 }
 283
 284 function generateThumbnailFromBase64 (data, callback) {
 285   // Creating the thumbnail for this remote video
 286   utils.generateRandomString(16, function (err, randomString) {
 287     if (err) return callback(err)
 288
 289     const thumbnailName = randomString + '.jpg'
 290     fs.writeFile(constants.CONFIG.STORAGE.THUMBNAILS_DIR + thumbnailName, data, { encoding: 'base64' }, function (err) {
 291       if (err) return callback(err)
 292
 293       return callback(null, thumbnailName)
 294     })
 295   })
 296 }