server/models/video.js

   1 'use strict'
   2
   3 const createTorrent = require('create-torrent')
   4 const ffmpeg = require('fluent-ffmpeg')
   5 const fs = require('fs')
   6 const magnetUtil = require('magnet-uri')
   7 const parallel = require('async/parallel')
   8 const parseTorrent = require('parse-torrent')
   9 const pathUtils = require('path')
  10 const mongoose = require('mongoose')
  11
  12 const constants = require('../initializers/constants')
  13 const customVideosValidators = require('../helpers/custom-validators').videos
  14 const logger = require('../helpers/logger')
  15 const modelUtils = require('./utils')
  16
  17 // ---------------------------------------------------------------------------
  18
  19 // TODO: add indexes on searchable columns
  20 const VideoSchema = mongoose.Schema({
  21   name: String,
  22   extname: {
  23     type: String,
  24     enum: [ '.mp4', '.webm', '.ogv' ]
  25   },
  26   remoteId: mongoose.Schema.Types.ObjectId,
  27   description: String,
  28   magnet: {
  29     infoHash: String
  30   },
  31   podHost: String,
  32   author: String,
  33   duration: Number,
  34   tags: [ String ],
  35   createdDate: {
  36     type: Date,
  37     default: Date.now
  38   }
  39 })
  40
  41 VideoSchema.path('name').validate(customVideosValidators.isVideoNameValid)
  42 VideoSchema.path('description').validate(customVideosValidators.isVideoDescriptionValid)
  43 VideoSchema.path('podHost').validate(customVideosValidators.isVideoPodHostValid)
  44 VideoSchema.path('author').validate(customVideosValidators.isVideoAuthorValid)
  45 VideoSchema.path('duration').validate(customVideosValidators.isVideoDurationValid)
  46 VideoSchema.path('tags').validate(customVideosValidators.isVideoTagsValid)
  47
  48 VideoSchema.methods = {
  49   generateMagnetUri,
  50   getVideoFilename,
  51   getThumbnailName,
  52   getPreviewName,
  53   getTorrentName,
  54   isOwned,
  55   toFormatedJSON,
  56   toRemoteJSON
  57 }
  58
  59 VideoSchema.statics = {
  60   getDurationFromFile,
  61   listForApi,
  62   listByHostAndRemoteId,
  63   listByHost,
  64   listOwned,
  65   listOwnedByAuthor,
  66   listRemotes,
  67   load,
  68   search
  69 }
  70
  71 VideoSchema.pre('remove', function (next) {
  72   const video = this
  73   const tasks = []
  74
  75   tasks.push(
  76     function (callback) {
  77       removeThumbnail(video, callback)
  78     }
  79   )
  80
  81   if (video.isOwned()) {
  82     tasks.push(
  83       function (callback) {
  84         removeFile(video, callback)
  85       },
  86       function (callback) {
  87         removeTorrent(video, callback)
  88       },
  89       function (callback) {
  90         removePreview(video, callback)
  91       }
  92     )
  93   }
  94
  95   parallel(tasks, next)
  96 })
  97
  98 VideoSchema.pre('save', function (next) {
  99   const video = this
 100   const tasks = []
 101
 102   if (video.isOwned()) {
 103     const videoPath = pathUtils.join(constants.CONFIG.STORAGE.VIDEOS_DIR, video.getVideoFilename())
 104     this.podHost = constants.CONFIG.WEBSERVER.HOST
 105
 106     tasks.push(
 107       // TODO: refractoring
 108       function (callback) {
 109         const options = {
 110           announceList: [
 111             [ constants.CONFIG.WEBSERVER.WS + '://' + constants.CONFIG.WEBSERVER.HOSTNAME + ':' + constants.CONFIG.WEBSERVER.PORT + '/tracker/socket' ]
 112           ],
 113           urlList: [
 114             constants.CONFIG.WEBSERVER.URL + constants.STATIC_PATHS.WEBSEED + video.getVideoFilename()
 115           ]
 116         }
 117
 118         createTorrent(videoPath, options, function (err, torrent) {
 119           if (err) return callback(err)
 120
 121           fs.writeFile(constants.CONFIG.STORAGE.TORRENTS_DIR + video.getTorrentName(), torrent, function (err) {
 122             if (err) return callback(err)
 123
 124             const parsedTorrent = parseTorrent(torrent)
 125             video.magnet.infoHash = parsedTorrent.infoHash
 126
 127             callback(null)
 128           })
 129         })
 130       },
 131       function (callback) {
 132         createThumbnail(video, videoPath, callback)
 133       },
 134       function (callback) {
 135         createPreview(video, videoPath, callback)
 136       }
 137     )
 138
 139     parallel(tasks, next)
 140   } else {
 141     generateThumbnailFromBase64(video, video.thumbnail, next)
 142   }
 143 })
 144
 145 mongoose.model('Video', VideoSchema)
 146
 147 // ------------------------------ METHODS ------------------------------
 148
 149 function generateMagnetUri () {
 150   let baseUrlHttp, baseUrlWs
 151
 152   if (this.isOwned()) {
 153     baseUrlHttp = constants.CONFIG.WEBSERVER.URL
 154     baseUrlWs = constants.CONFIG.WEBSERVER.WS + '://' + constants.CONFIG.WEBSERVER.HOSTNAME + ':' + constants.CONFIG.WEBSERVER.PORT
 155   } else {
 156     baseUrlHttp = constants.REMOTE_SCHEME.HTTP + '://' + this.podHost
 157     baseUrlWs = constants.REMOTE_SCHEME.WS + this.podHost
 158   }
 159
 160   const xs = baseUrlHttp + constants.STATIC_PATHS.TORRENTS + this.getTorrentName()
 161   const announce = baseUrlWs + '/tracker/socket'
 162   const urlList = [ baseUrlHttp + constants.STATIC_PATHS.WEBSEED + this.getVideoFilename() ]
 163
 164   const magnetHash = {
 165     xs,
 166     announce,
 167     urlList,
 168     infoHash: this.magnet.infoHash,
 169     name: this.name
 170   }
 171
 172   return magnetUtil.encode(magnetHash)
 173 }
 174
 175 function getVideoFilename () {
 176   if (this.isOwned()) return this._id + this.extname
 177
 178   return this.remoteId + this.extname
 179 }
 180
 181 function getThumbnailName () {
 182   // We always have a copy of the thumbnail
 183   return this._id + '.jpg'
 184 }
 185
 186 function getPreviewName () {
 187   const extension = '.jpg'
 188
 189   if (this.isOwned()) return this._id + extension
 190
 191   return this.remoteId + extension
 192 }
 193
 194 function getTorrentName () {
 195   const extension = '.torrent'
 196
 197   if (this.isOwned()) return this._id + extension
 198
 199   return this.remoteId + extension
 200 }
 201
 202 function isOwned () {
 203   return this.remoteId === null
 204 }
 205
 206 function toFormatedJSON () {
 207   const json = {
 208     id: this._id,
 209     name: this.name,
 210     description: this.description,
 211     podHost: this.podHost,
 212     isLocal: this.isOwned(),
 213     magnetUri: this.generateMagnetUri(),
 214     author: this.author,
 215     duration: this.duration,
 216     tags: this.tags,
 217     thumbnailPath: constants.STATIC_PATHS.THUMBNAILS + '/' + this.getThumbnailName(),
 218     createdDate: this.createdDate
 219   }
 220
 221   return json
 222 }
 223
 224 function toRemoteJSON (callback) {
 225   const self = this
 226
 227   // Convert thumbnail to base64
 228   const thumbnailPath = pathUtils.join(constants.CONFIG.STORAGE.THUMBNAILS_DIR, this.getThumbnailName())
 229   fs.readFile(thumbnailPath, function (err, thumbnailData) {
 230     if (err) {
 231       logger.error('Cannot read the thumbnail of the video')
 232       return callback(err)
 233     }
 234
 235     const remoteVideo = {
 236       name: self.name,
 237       description: self.description,
 238       magnet: self.magnet,
 239       remoteId: self._id,
 240       author: self.author,
 241       duration: self.duration,
 242       thumbnailBase64: new Buffer(thumbnailData).toString('base64'),
 243       tags: self.tags,
 244       createdDate: self.createdDate,
 245       podHost: self.podHost
 246     }
 247
 248     return callback(null, remoteVideo)
 249   })
 250 }
 251
 252 // ------------------------------ STATICS ------------------------------
 253
 254 function getDurationFromFile (videoPath, callback) {
 255   ffmpeg.ffprobe(videoPath, function (err, metadata) {
 256     if (err) return callback(err)
 257
 258     return callback(null, Math.floor(metadata.format.duration))
 259   })
 260 }
 261
 262 function listForApi (start, count, sort, callback) {
 263   const query = {}
 264   return modelUtils.listForApiWithCount.call(this, query, start, count, sort, callback)
 265 }
 266
 267 function listByHostAndRemoteId (fromHost, remoteId, callback) {
 268   this.find({ podHost: fromHost, remoteId: remoteId }, callback)
 269 }
 270
 271 function listByHost (fromHost, callback) {
 272   this.find({ podHost: fromHost }, callback)
 273 }
 274
 275 function listOwned (callback) {
 276   // If remoteId is null this is *our* video
 277   this.find({ remoteId: null }, callback)
 278 }
 279
 280 function listOwnedByAuthor (author, callback) {
 281   this.find({ remoteId: null, author: author }, callback)
 282 }
 283
 284 function listRemotes (callback) {
 285   this.find({ remoteId: { $ne: null } }, callback)
 286 }
 287
 288 function load (id, callback) {
 289   this.findById(id, callback)
 290 }
 291
 292 function search (value, field, start, count, sort, callback) {
 293   const query = {}
 294   // Make an exact search with the magnet
 295   if (field === 'magnetUri') {
 296     const infoHash = magnetUtil.decode(value).infoHash
 297     query.magnet = {
 298       infoHash
 299     }
 300   } else if (field === 'tags') {
 301     query[field] = value
 302   } else {
 303     query[field] = new RegExp(value, 'i')
 304   }
 305
 306   modelUtils.listForApiWithCount.call(this, query, start, count, sort, callback)
 307 }
 308
 309 // ---------------------------------------------------------------------------
 310
 311 function removeThumbnail (video, callback) {
 312   fs.unlink(constants.CONFIG.STORAGE.THUMBNAILS_DIR + video.getThumbnailName(), callback)
 313 }
 314
 315 function removeFile (video, callback) {
 316   fs.unlink(constants.CONFIG.STORAGE.VIDEOS_DIR + video.getVideoFilename(), callback)
 317 }
 318
 319 function removeTorrent (video, callback) {
 320   fs.unlink(constants.CONFIG.STORAGE.TORRENTS_DIR + video.getTorrentName(), callback)
 321 }
 322
 323 function removePreview (video, callback) {
 324   // Same name than video thumnail
 325   fs.unlink(constants.CONFIG.STORAGE.PREVIEWS_DIR + video.getPreviewName(), callback)
 326 }
 327
 328 function createPreview (video, videoPath, callback) {
 329   generateImage(video, videoPath, constants.CONFIG.STORAGE.PREVIEWS_DIR, video.getPreviewName(), callback)
 330 }
 331
 332 function createThumbnail (video, videoPath, callback) {
 333   generateImage(video, videoPath, constants.CONFIG.STORAGE.THUMBNAILS_DIR, video.getThumbnailName(), constants.THUMBNAILS_SIZE, callback)
 334 }
 335
 336 function generateThumbnailFromBase64 (video, thumbnailData, callback) {
 337   // Creating the thumbnail for this remote video)
 338
 339   const thumbnailName = video.getThumbnailName()
 340   const thumbnailPath = constants.CONFIG.STORAGE.THUMBNAILS_DIR + thumbnailName
 341   fs.writeFile(thumbnailPath, thumbnailData, { encoding: 'base64' }, function (err) {
 342     if (err) return callback(err)
 343
 344     return callback(null, thumbnailName)
 345   })
 346 }
 347
 348 function generateImage (video, videoPath, folder, imageName, size, callback) {
 349   const options = {
 350     filename: imageName,
 351     count: 1,
 352     folder
 353   }
 354
 355   if (!callback) {
 356     callback = size
 357   } else {
 358     options.size = size
 359   }
 360
 361   ffmpeg(videoPath)
 362     .on('error', callback)
 363     .on('end', function () {
 364       callback(null, imageName)
 365     })
 366     .thumbnail(options)
 367 }