X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server%2Fmodels%2Fvideo.js;h=330067cdfa6e892776692f1787fd70efe22f2ea4;hb=437cf8b531652a4b101ec279dea7661e8dfb8cda;hp=98f43a06de86ed03baec25b49019a61fe0b474a5;hpb=1a42c9e2c0fb64cdbebd81b311736e752f591e0a;p=github%2FChocobozzz%2FPeerTube.git

diff --git a/server/models/video.js b/server/models/video.js
index 98f43a06d..330067cdf 100644
--- a/server/models/video.js
+++ b/server/models/video.js
@@ -1,37 +1,36 @@
 'use strict'
 
-const config = require('config')
-const each = require('async/each')
+const createTorrent = require('create-torrent')
 const ffmpeg = require('fluent-ffmpeg')
 const fs = require('fs')
+const magnetUtil = require('magnet-uri')
 const parallel = require('async/parallel')
+const parseTorrent = require('parse-torrent')
 const pathUtils = require('path')
 const mongoose = require('mongoose')
 
 const constants = require('../initializers/constants')
-const customValidators = require('../helpers/custom-validators')
+const customVideosValidators = require('../helpers/custom-validators').videos
 const logger = require('../helpers/logger')
-const utils = require('../helpers/utils')
-const webtorrent = require('../lib/webtorrent')
-
-const http = config.get('webserver.https') === true ? 'https' : 'http'
-const host = config.get('webserver.host')
-const port = config.get('webserver.port')
-const uploadsDir = pathUtils.join(__dirname, '..', '..', config.get('storage.uploads'))
-const thumbnailsDir = pathUtils.join(__dirname, '..', '..', config.get('storage.thumbnails'))
+const modelUtils = require('./utils')
 
 // ---------------------------------------------------------------------------
 
 // TODO: add indexes on searchable columns
 const VideoSchema = mongoose.Schema({
   name: String,
-  filename: String,
+  extname: {
+    type: String,
+    enum: [ '.mp4', '.webm', '.ogv' ]
+  },
+  remoteId: mongoose.Schema.Types.ObjectId,
   description: String,
-  magnetUri: String,
-  podUrl: String,
+  magnet: {
+    infoHash: String
+  },
+  podHost: String,
   author: String,
   duration: Number,
-  thumbnail: String,
   tags: [ String ],
   createdDate: {
     type: Date,
@@ -39,35 +38,35 @@ const VideoSchema = mongoose.Schema({
   }
 })
 
-VideoSchema.path('name').validate(customValidators.isVideoNameValid)
-VideoSchema.path('description').validate(customValidators.isVideoDescriptionValid)
-VideoSchema.path('magnetUri').validate(customValidators.isVideoMagnetUriValid)
-VideoSchema.path('podUrl').validate(customValidators.isVideoPodUrlValid)
-VideoSchema.path('author').validate(customValidators.isVideoAuthorValid)
-VideoSchema.path('duration').validate(customValidators.isVideoDurationValid)
-// The tumbnail can be the path or the data in base 64
-// The pre save hook will convert the base 64 data in a file on disk and replace the thumbnail key by the filename
-VideoSchema.path('thumbnail').validate(function (value) {
-  return customValidators.isVideoThumbnailValid(value) || customValidators.isVideoThumbnail64Valid(value)
-})
-VideoSchema.path('tags').validate(customValidators.isVideoTagsValid)
+VideoSchema.path('name').validate(customVideosValidators.isVideoNameValid)
+VideoSchema.path('description').validate(customVideosValidators.isVideoDescriptionValid)
+VideoSchema.path('podHost').validate(customVideosValidators.isVideoPodHostValid)
+VideoSchema.path('author').validate(customVideosValidators.isVideoAuthorValid)
+VideoSchema.path('duration').validate(customVideosValidators.isVideoDurationValid)
+VideoSchema.path('tags').validate(customVideosValidators.isVideoTagsValid)
 
 VideoSchema.methods = {
-  isOwned: isOwned,
-  toFormatedJSON: toFormatedJSON,
-  toRemoteJSON: toRemoteJSON
+  generateMagnetUri,
+  getVideoFilename,
+  getThumbnailName,
+  getPreviewName,
+  getTorrentName,
+  isOwned,
+  toFormatedJSON,
+  toRemoteJSON
 }
 
 VideoSchema.statics = {
-  getDurationFromFile: getDurationFromFile,
-  list: list,
-  listByUrlAndMagnet: listByUrlAndMagnet,
-  listByUrls: listByUrls,
-  listOwned: listOwned,
-  listRemotes: listRemotes,
-  load: load,
-  search: search,
-  seedAllExisting: seedAllExisting
+  generateThumbnailFromBase64,
+  getDurationFromFile,
+  listForApi,
+  listByHostAndRemoteId,
+  listByHost,
+  listOwned,
+  listOwnedByAuthor,
+  listRemotes,
+  load,
+  search
 }
 
 VideoSchema.pre('remove', function (next) {
@@ -87,6 +86,9 @@ VideoSchema.pre('remove', function (next) {
       },
       function (callback) {
         removeTorrent(video, callback)
+      },
+      function (callback) {
+        removePreview(video, callback)
       }
     )
   }
@@ -99,43 +101,107 @@ VideoSchema.pre('save', function (next) {
   const tasks = []
 
   if (video.isOwned()) {
-    const videoPath = pathUtils.join(uploadsDir, video.filename)
-    this.podUrl = http + '://' + host + ':' + port
+    const videoPath = pathUtils.join(constants.CONFIG.STORAGE.VIDEOS_DIR, video.getVideoFilename())
+    this.podHost = constants.CONFIG.WEBSERVER.HOST
 
     tasks.push(
+      // TODO: refractoring
       function (callback) {
-        seed(videoPath, callback)
+        const options = {
+          announceList: [
+            [ constants.CONFIG.WEBSERVER.WS + '://' + constants.CONFIG.WEBSERVER.HOSTNAME + ':' + constants.CONFIG.WEBSERVER.PORT + '/tracker/socket' ]
+          ],
+          urlList: [
+            constants.CONFIG.WEBSERVER.URL + constants.STATIC_PATHS.WEBSEED + video.getVideoFilename()
+          ]
+        }
+
+        createTorrent(videoPath, options, function (err, torrent) {
+          if (err) return callback(err)
+
+          fs.writeFile(constants.CONFIG.STORAGE.TORRENTS_DIR + video.getTorrentName(), torrent, function (err) {
+            if (err) return callback(err)
+
+            const parsedTorrent = parseTorrent(torrent)
+            video.magnet.infoHash = parsedTorrent.infoHash
+
+            callback(null)
+          })
+        })
       },
       function (callback) {
-        createThumbnail(videoPath, callback)
+        createThumbnail(video, videoPath, callback)
+      },
+      function (callback) {
+        createPreview(video, videoPath, callback)
       }
     )
 
-    parallel(tasks, function (err, results) {
-      if (err) return next(err)
+    return parallel(tasks, next)
+  }
 
-      video.magnetUri = results[0].magnetURI
-      video.thumbnail = results[1]
+  return next()
+})
 
-      return next()
-    })
+mongoose.model('Video', VideoSchema)
+
+// ------------------------------ METHODS ------------------------------
+
+function generateMagnetUri () {
+  let baseUrlHttp, baseUrlWs
+
+  if (this.isOwned()) {
+    baseUrlHttp = constants.CONFIG.WEBSERVER.URL
+    baseUrlWs = constants.CONFIG.WEBSERVER.WS + '://' + constants.CONFIG.WEBSERVER.HOSTNAME + ':' + constants.CONFIG.WEBSERVER.PORT
   } else {
-    generateThumbnailFromBase64(video.thumbnail, function (err, thumbnailName) {
-      if (err) return next(err)
+    baseUrlHttp = constants.REMOTE_SCHEME.HTTP + '://' + this.podHost
+    baseUrlWs = constants.REMOTE_SCHEME.WS + '://' + this.podHost
+  }
 
-      video.thumbnail = thumbnailName
+  const xs = baseUrlHttp + constants.STATIC_PATHS.TORRENTS + this.getTorrentName()
+  const announce = baseUrlWs + '/tracker/socket'
+  const urlList = [ baseUrlHttp + constants.STATIC_PATHS.WEBSEED + this.getVideoFilename() ]
 
-      return next()
-    })
+  const magnetHash = {
+    xs,
+    announce,
+    urlList,
+    infoHash: this.magnet.infoHash,
+    name: this.name
   }
-})
 
-mongoose.model('Video', VideoSchema)
+  return magnetUtil.encode(magnetHash)
+}
 
-// ------------------------------ METHODS ------------------------------
+function getVideoFilename () {
+  if (this.isOwned()) return this._id + this.extname
+
+  return this.remoteId + this.extname
+}
+
+function getThumbnailName () {
+  // We always have a copy of the thumbnail
+  return this._id + '.jpg'
+}
+
+function getPreviewName () {
+  const extension = '.jpg'
+
+  if (this.isOwned()) return this._id + extension
+
+  return this.remoteId + extension
+}
+
+function getTorrentName () {
+  const extension = '.torrent'
+
+  if (this.isOwned()) return this._id + extension
+
+  return this.remoteId + extension
+}
 
 function isOwned () {
-  return this.filename !== null
+  return this.remoteId === null
 }
 
 function toFormatedJSON () {
@@ -143,13 +209,13 @@ function toFormatedJSON () {
     id: this._id,
     name: this.name,
     description: this.description,
-    podUrl: this.podUrl.replace(/^https?:\/\//, ''),
+    podHost: this.podHost,
     isLocal: this.isOwned(),
-    magnetUri: this.magnetUri,
+    magnetUri: this.generateMagnetUri(),
     author: this.author,
     duration: this.duration,
     tags: this.tags,
-    thumbnailPath: constants.THUMBNAILS_STATIC_PATH + '/' + this.thumbnail,
+    thumbnailPath: constants.STATIC_PATHS.THUMBNAILS + '/' + this.getThumbnailName(),
     createdDate: this.createdDate
   }
 
@@ -160,7 +226,8 @@ function toRemoteJSON (callback) {
   const self = this
 
   // Convert thumbnail to base64
-  fs.readFile(pathUtils.join(thumbnailsDir, this.thumbnail), function (err, thumbnailData) {
+  const thumbnailPath = pathUtils.join(constants.CONFIG.STORAGE.THUMBNAILS_DIR, this.getThumbnailName())
+  fs.readFile(thumbnailPath, function (err, thumbnailData) {
     if (err) {
       logger.error('Cannot read the thumbnail of the video')
       return callback(err)
@@ -169,14 +236,14 @@ function toRemoteJSON (callback) {
     const remoteVideo = {
       name: self.name,
       description: self.description,
-      magnetUri: self.magnetUri,
-      filename: null,
+      magnet: self.magnet,
+      remoteId: self._id,
       author: self.author,
       duration: self.duration,
       thumbnailBase64: new Buffer(thumbnailData).toString('base64'),
       tags: self.tags,
       createdDate: self.createdDate,
-      podUrl: self.podUrl
+      extname: self.extname
     }
 
     return callback(null, remoteVideo)
@@ -185,6 +252,18 @@ function toRemoteJSON (callback) {
 
 // ------------------------------ STATICS ------------------------------
 
+function generateThumbnailFromBase64 (video, thumbnailData, callback) {
+  // Creating the thumbnail for a remote video
+
+  const thumbnailName = video.getThumbnailName()
+  const thumbnailPath = constants.CONFIG.STORAGE.THUMBNAILS_DIR + thumbnailName
+  fs.writeFile(thumbnailPath, thumbnailData, { encoding: 'base64' }, function (err) {
+    if (err) return callback(err)
+
+    return callback(null, thumbnailName)
+  })
+}
+
 function getDurationFromFile (videoPath, callback) {
   ffmpeg.ffprobe(videoPath, function (err, metadata) {
     if (err) return callback(err)
@@ -193,26 +272,30 @@ function getDurationFromFile (videoPath, callback) {
   })
 }
 
-function list (start, count, sort, callback) {
+function listForApi (start, count, sort, callback) {
   const query = {}
-  return findWithCount.call(this, query, start, count, sort, callback)
+  return modelUtils.listForApiWithCount.call(this, query, start, count, sort, callback)
 }
 
-function listByUrlAndMagnet (fromUrl, magnetUri, callback) {
-  this.find({ podUrl: fromUrl, magnetUri: magnetUri }, callback)
+function listByHostAndRemoteId (fromHost, remoteId, callback) {
+  this.find({ podHost: fromHost, remoteId: remoteId }, callback)
 }
 
-function listByUrls (fromUrls, callback) {
-  this.find({ podUrl: { $in: fromUrls } }, callback)
+function listByHost (fromHost, callback) {
+  this.find({ podHost: fromHost }, callback)
 }
 
 function listOwned (callback) {
-  // If filename is not null this is *our* video
-  this.find({ filename: { $ne: null } }, callback)
+  // If remoteId is null this is *our* video
+  this.find({ remoteId: null }, callback)
+}
+
+function listOwnedByAuthor (author, callback) {
+  this.find({ remoteId: null, author: author }, callback)
 }
 
 function listRemotes (callback) {
-  this.find({ filename: null }, callback)
+  this.find({ remoteId: { $ne: null } }, callback)
 }
 
 function load (id, callback) {
@@ -222,100 +305,64 @@ function load (id, callback) {
 function search (value, field, start, count, sort, callback) {
   const query = {}
   // Make an exact search with the magnet
-  if (field === 'magnetUri' || field === 'tags') {
+  if (field === 'magnetUri') {
+    const infoHash = magnetUtil.decode(value).infoHash
+    query.magnet = {
+      infoHash
+    }
+  } else if (field === 'tags') {
     query[field] = value
   } else {
-    query[field] = new RegExp(value)
+    query[field] = new RegExp(value, 'i')
   }
 
-  findWithCount.call(this, query, start, count, sort, callback)
-}
-
-function seedAllExisting (callback) {
-  listOwned.call(this, function (err, videos) {
-    if (err) return callback(err)
-
-    each(videos, function (video, callbackEach) {
-      const videoPath = pathUtils.join(uploadsDir, video.filename)
-      seed(videoPath, callbackEach)
-    }, callback)
-  })
+  modelUtils.listForApiWithCount.call(this, query, start, count, sort, callback)
 }
 
 // ---------------------------------------------------------------------------
 
-function findWithCount (query, start, count, sort, callback) {
-  const self = this
-
-  parallel([
-    function (asyncCallback) {
-      self.find(query).skip(start).limit(count).sort(sort).exec(asyncCallback)
-    },
-    function (asyncCallback) {
-      self.count(query, asyncCallback)
-    }
-  ], function (err, results) {
-    if (err) return callback(err)
-
-    const videos = results[0]
-    const totalVideos = results[1]
-    return callback(null, videos, totalVideos)
-  })
-}
-
 function removeThumbnail (video, callback) {
-  fs.unlink(thumbnailsDir + video.thumbnail, callback)
+  fs.unlink(constants.CONFIG.STORAGE.THUMBNAILS_DIR + video.getThumbnailName(), callback)
 }
 
 function removeFile (video, callback) {
-  fs.unlink(uploadsDir + video.filename, callback)
+  fs.unlink(constants.CONFIG.STORAGE.VIDEOS_DIR + video.getVideoFilename(), callback)
 }
 
-// Maybe the torrent is not seeded, but we catch the error to don't stop the removing process
 function removeTorrent (video, callback) {
-  try {
-    webtorrent.remove(video.magnetUri, callback)
-  } catch (err) {
-    logger.warn('Cannot remove the torrent from WebTorrent', { err: err })
-    return callback(null)
-  }
+  fs.unlink(constants.CONFIG.STORAGE.TORRENTS_DIR + video.getTorrentName(), callback)
 }
 
-function createThumbnail (videoPath, callback) {
-  const filename = pathUtils.basename(videoPath) + '.jpg'
-  ffmpeg(videoPath)
-    .on('error', callback)
-    .on('end', function () {
-      callback(null, filename)
-    })
-    .thumbnail({
-      count: 1,
-      folder: thumbnailsDir,
-      size: constants.THUMBNAILS_SIZE,
-      filename: filename
-    })
+function removePreview (video, callback) {
+  // Same name than video thumnail
+  fs.unlink(constants.CONFIG.STORAGE.PREVIEWS_DIR + video.getPreviewName(), callback)
 }
 
-function seed (path, callback) {
-  logger.info('Seeding %s...', path)
-
-  webtorrent.seed(path, function (torrent) {
-    logger.info('%s seeded (%s).', path, torrent.magnetURI)
+function createPreview (video, videoPath, callback) {
+  generateImage(video, videoPath, constants.CONFIG.STORAGE.PREVIEWS_DIR, video.getPreviewName(), callback)
+}
 
-    return callback(null, torrent)
-  })
+function createThumbnail (video, videoPath, callback) {
+  generateImage(video, videoPath, constants.CONFIG.STORAGE.THUMBNAILS_DIR, video.getThumbnailName(), constants.THUMBNAILS_SIZE, callback)
 }
 
-function generateThumbnailFromBase64 (data, callback) {
-  // Creating the thumbnail for this remote video
-  utils.generateRandomString(16, function (err, randomString) {
-    if (err) return callback(err)
+function generateImage (video, videoPath, folder, imageName, size, callback) {
+  const options = {
+    filename: imageName,
+    count: 1,
+    folder
+  }
 
-    const thumbnailName = randomString + '.jpg'
-    fs.writeFile(thumbnailsDir + thumbnailName, data, { encoding: 'base64' }, function (err) {
-      if (err) return callback(err)
+  if (!callback) {
+    callback = size
+  } else {
+    options.size = size
+  }
 
-      return callback(null, thumbnailName)
+  ffmpeg(videoPath)
+    .on('error', callback)
+    .on('end', function () {
+      callback(null, imageName)
     })
-  })
+    .thumbnail(options)
 }