'use strict'
-const config = require('config')
-const eachLimit = require('async/eachLimit')
+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 customVideosValidators = require('../helpers/custom-validators').videos
const logger = require('../helpers/logger')
const modelUtils = require('./utils')
-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'))
// ---------------------------------------------------------------------------
// 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 = {
- isOwned: isOwned,
- toFormatedJSON: toFormatedJSON,
- toRemoteJSON: toRemoteJSON
+ generateMagnetUri,
+ getVideoFilename,
+ getThumbnailName,
+ getPreviewName,
+ getTorrentName,
+ isOwned,
+ toFormatedJSON,
+ toRemoteJSON
}
VideoSchema.statics = {
- getDurationFromFile: getDurationFromFile,
- listForApi: listForApi,
- listByUrlAndMagnet: listByUrlAndMagnet,
- listByUrls: listByUrls,
- listOwned: listOwned,
- listOwnedByAuthor: listOwnedByAuthor,
- listRemotes: listRemotes,
- load: load,
- search: search,
- seedAllExisting: seedAllExisting
+ generateThumbnailFromBase64,
+ getDurationFromFile,
+ listForApi,
+ listByHostAndRemoteId,
+ listByHost,
+ listOwned,
+ listOwnedByAuthor,
+ listRemotes,
+ load,
+ search
}
VideoSchema.pre('remove', function (next) {
},
function (callback) {
removeTorrent(video, callback)
+ },
+ function (callback) {
+ removePreview(video, callback)
}
)
}
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)
+ }
+
+ return next()
+})
- video.magnetUri = results[0].magnetURI
- 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.THUMBNAILS_STATIC_PATH + '/' + this.thumbnail,
+ thumbnailPath: constants.STATIC_PATHS.THUMBNAILS + '/' + this.getThumbnailName(),
createdDate: this.createdDate
}
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)
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
+ podHost: self.podHost
}
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)
function listForApi (start, count, sort, callback) {
const query = {}
- return modelUtils.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({ 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.findWithCount.call(this, query, start, count, sort, callback)
-}
-
-function seedAllExisting (callback) {
- listOwned.call(this, function (err, videos) {
- if (err) return callback(err)
-
- eachLimit(videos, constants.SEEDS_IN_PARALLEL, function (video, callbackEach) {
- const videoPath = pathUtils.join(uploadsDir, video.filename)
- seed(videoPath, callbackEach)
- }, callback)
- })
+ modelUtils.listForApiWithCount.call(this, query, start, count, sort, callback)
}
// ---------------------------------------------------------------------------
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)
}
projects / github / Chocobozzz / PeerTube.git / blobdiff