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 magnet = require('magnet-uri')
const mongoose = require('mongoose')
const constants = require('../initializers/constants')
const customVideosValidators = require('../helpers/custom-validators').videos
const logger = require('../helpers/logger')
const modelUtils = require('./utils')
-const utils = require('../helpers/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,
VideoSchema.path('name').validate(customVideosValidators.isVideoNameValid)
VideoSchema.path('description').validate(customVideosValidators.isVideoDescriptionValid)
-VideoSchema.path('magnetUri').validate(customVideosValidators.isVideoMagnetUriValid)
-VideoSchema.path('podUrl').validate(customVideosValidators.isVideoPodUrlValid)
+VideoSchema.path('podHost').validate(customVideosValidators.isVideoPodHostValid)
VideoSchema.path('author').validate(customVideosValidators.isVideoAuthorValid)
VideoSchema.path('duration').validate(customVideosValidators.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 customVideosValidators.isVideoThumbnailValid(value) || customVideosValidators.isVideoThumbnail64Valid(value)
-})
VideoSchema.path('tags').validate(customVideosValidators.isVideoTagsValid)
VideoSchema.methods = {
+ generateMagnetUri,
+ getVideoFilename,
+ getThumbnailName,
+ getPreviewName,
+ getTorrentName,
isOwned,
toFormatedJSON,
toRemoteJSON
}
VideoSchema.statics = {
+ generateThumbnailFromBase64,
getDurationFromFile,
listForApi,
- listByUrlAndMagnet,
- listByUrls,
+ listByHostAndRemoteId,
+ listByHost,
listOwned,
listOwnedByAuthor,
listRemotes,
},
function (callback) {
removeTorrent(video, callback)
+ },
+ function (callback) {
+ removePreview(video, callback)
}
)
}
const tasks = []
if (video.isOwned()) {
- const videoPath = pathUtils.join(constants.CONFIG.STORAGE.UPLOAD_DIR, video.filename)
- this.podUrl = constants.CONFIG.WEBSERVER.URL
+ const videoPath = pathUtils.join(constants.CONFIG.STORAGE.VIDEOS_DIR, video.getVideoFilename())
+ this.podHost = constants.CONFIG.WEBSERVER.HOST
tasks.push(
// TODO: refractoring
function (callback) {
const options = {
announceList: [
- [ constants.CONFIG.WEBSERVER.WS + '://' + constants.CONFIG.WEBSERVER.HOST + ':' + constants.CONFIG.WEBSERVER.PORT + '/tracker/socket' ]
+ [ constants.CONFIG.WEBSERVER.WS + '://' + constants.CONFIG.WEBSERVER.HOSTNAME + ':' + constants.CONFIG.WEBSERVER.PORT + '/tracker/socket' ]
],
urlList: [
- constants.CONFIG.WEBSERVER.URL + constants.STATIC_PATHS.WEBSEED + video.filename
+ 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.filename + '.torrent', torrent, function (err) {
+ fs.writeFile(constants.CONFIG.STORAGE.TORRENTS_DIR + video.getTorrentName(), torrent, function (err) {
if (err) return callback(err)
const parsedTorrent = parseTorrent(torrent)
- parsedTorrent.xs = video.podUrl + constants.STATIC_PATHS.TORRENTS + video.filename + '.torrent'
- video.magnetUri = magnet.encode(parsedTorrent)
+ 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)
+ }
+
+ return next()
+})
- video.thumbnail = results[1]
+mongoose.model('Video', VideoSchema)
- return next()
- })
+// ------------------------------ 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 () {
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.STATIC_PATHS.THUMBNAILS + '/' + this.thumbnail,
+ thumbnailPath: constants.STATIC_PATHS.THUMBNAILS + '/' + this.getThumbnailName(),
createdDate: this.createdDate
}
const self = this
// Convert thumbnail to base64
- fs.readFile(pathUtils.join(constants.CONFIG.STORAGE.THUMBNAILS_DIR, 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)
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)
// ------------------------------ 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)
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({ filename: { $ne: null }, author: 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) {
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')
}
modelUtils.listForApiWithCount.call(this, query, start, count, sort, callback)
// ---------------------------------------------------------------------------
function removeThumbnail (video, callback) {
- fs.unlink(constants.CONFIG.STORAGE.THUMBNAILS_DIR + video.thumbnail, callback)
+ fs.unlink(constants.CONFIG.STORAGE.THUMBNAILS_DIR + video.getThumbnailName(), callback)
}
function removeFile (video, callback) {
- fs.unlink(constants.CONFIG.STORAGE.UPLOAD_DIR + 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) {
- fs.unlink(constants.CONFIG.STORAGE.TORRENTS_DIR + video.filename + '.torrent', callback)
+ 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: constants.CONFIG.STORAGE.THUMBNAILS_DIR,
- 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 generateThumbnailFromBase64 (data, callback) {
- // Creating the thumbnail for this remote video
- utils.generateRandomString(16, function (err, randomString) {
- if (err) return callback(err)
+function createPreview (video, videoPath, callback) {
+ generateImage(video, videoPath, constants.CONFIG.STORAGE.PREVIEWS_DIR, video.getPreviewName(), callback)
+}
- const thumbnailName = randomString + '.jpg'
- fs.writeFile(constants.CONFIG.STORAGE.THUMBNAILS_DIR + thumbnailName, data, { encoding: 'base64' }, function (err) {
- if (err) return callback(err)
+function createThumbnail (video, videoPath, callback) {
+ generateImage(video, videoPath, constants.CONFIG.STORAGE.THUMBNAILS_DIR, video.getThumbnailName(), constants.THUMBNAILS_SIZE, callback)
+}
- return callback(null, thumbnailName)
+function generateImage (video, videoPath, folder, imageName, size, callback) {
+ const options = {
+ filename: imageName,
+ count: 1,
+ folder
+ }
+
+ if (!callback) {
+ callback = size
+ } else {
+ options.size = size
+ }
+
+ ffmpeg(videoPath)
+ .on('error', callback)
+ .on('end', function () {
+ callback(null, imageName)
})
- })
+ .thumbnail(options)
}