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')
},
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 = {
- getFilename,
- getJPEGName,
+ generateMagnetUri,
+ getVideoFilename,
+ getThumbnailName,
+ getPreviewName,
getTorrentName,
isOwned,
toFormatedJSON,
}
VideoSchema.statics = {
+ generateThumbnailFromBase64,
getDurationFromFile,
listForApi,
- listByUrlAndRemoteId,
- listByUrl,
+ listByHostAndRemoteId,
+ listByHost,
listOwned,
listOwnedByAuthor,
listRemotes,
const tasks = []
if (video.isOwned()) {
- const videoPath = pathUtils.join(constants.CONFIG.STORAGE.VIDEOS_DIR, video.getFilename())
- 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
[ constants.CONFIG.WEBSERVER.WS + '://' + constants.CONFIG.WEBSERVER.HOSTNAME + ':' + constants.CONFIG.WEBSERVER.PORT + '/tracker/socket' ]
],
urlList: [
- constants.CONFIG.WEBSERVER.URL + constants.STATIC_PATHS.WEBSEED + video.getFilename()
+ constants.CONFIG.WEBSERVER.URL + constants.STATIC_PATHS.WEBSEED + video.getVideoFilename()
]
}
if (err) return callback(err)
const parsedTorrent = parseTorrent(torrent)
- parsedTorrent.xs = video.podUrl + constants.STATIC_PATHS.TORRENTS + video.getTorrentName()
- video.magnetUri = magnet.encode(parsedTorrent)
+ video.magnet.infoHash = parsedTorrent.infoHash
callback(null)
})
}
)
- parallel(tasks, next)
- } else {
- generateThumbnailFromBase64(video, video.thumbnail, next)
+ return parallel(tasks, next)
}
+
+ return next()
})
mongoose.model('Video', VideoSchema)
// ------------------------------ METHODS ------------------------------
-function getFilename () {
- return this._id + this.extname
+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 {
+ baseUrlHttp = constants.REMOTE_SCHEME.HTTP + '://' + this.podHost
+ baseUrlWs = constants.REMOTE_SCHEME.WS + '://' + this.podHost
+ }
+
+ const xs = baseUrlHttp + constants.STATIC_PATHS.TORRENTS + this.getTorrentName()
+ const announce = baseUrlWs + '/tracker/socket'
+ const urlList = [ baseUrlHttp + constants.STATIC_PATHS.WEBSEED + this.getVideoFilename() ]
+
+ const magnetHash = {
+ xs,
+ announce,
+ urlList,
+ infoHash: this.magnet.infoHash,
+ name: this.name
+ }
+
+ return magnetUtil.encode(magnetHash)
}
-function getJPEGName () {
+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 () {
- return this._id + '.torrent'
+ const extension = '.torrent'
+
+ if (this.isOwned()) return this._id + extension
+
+ return this.remoteId + extension
}
function isOwned () {
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.getJPEGName(),
+ thumbnailPath: constants.STATIC_PATHS.THUMBNAILS + '/' + this.getThumbnailName(),
createdDate: this.createdDate
}
const self = this
// Convert thumbnail to base64
- const thumbnailPath = pathUtils.join(constants.CONFIG.STORAGE.THUMBNAILS_DIR, this.getJPEGName())
+ 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')
const remoteVideo = {
name: self.name,
description: self.description,
- magnetUri: self.magnetUri,
+ 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 listByUrlAndRemoteId (fromUrl, remoteId, callback) {
- this.find({ podUrl: fromUrl, remoteId: remoteId }, callback)
+function listByHostAndRemoteId (fromHost, remoteId, callback) {
+ this.find({ podHost: fromHost, remoteId: remoteId }, callback)
}
-function listByUrl (fromUrl, callback) {
- this.find({ podUrl: fromUrl }, callback)
+function listByHost (fromHost, callback) {
+ this.find({ podHost: fromHost }, callback)
}
function listOwned (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, 'i')
// ---------------------------------------------------------------------------
function removeThumbnail (video, callback) {
- fs.unlink(constants.CONFIG.STORAGE.THUMBNAILS_DIR + video.getJPEGName(), callback)
+ fs.unlink(constants.CONFIG.STORAGE.THUMBNAILS_DIR + video.getThumbnailName(), callback)
}
function removeFile (video, callback) {
- fs.unlink(constants.CONFIG.STORAGE.VIDEOS_DIR + video.getFilename(), callback)
+ fs.unlink(constants.CONFIG.STORAGE.VIDEOS_DIR + video.getVideoFilename(), callback)
}
function removeTorrent (video, callback) {
function removePreview (video, callback) {
// Same name than video thumnail
- // TODO: refractoring
- fs.unlink(constants.CONFIG.STORAGE.PREVIEWS_DIR + video.getJPEGName(), callback)
+ fs.unlink(constants.CONFIG.STORAGE.PREVIEWS_DIR + video.getPreviewName(), callback)
}
function createPreview (video, videoPath, callback) {
- generateImage(video, videoPath, constants.CONFIG.STORAGE.PREVIEWS_DIR, callback)
+ generateImage(video, videoPath, constants.CONFIG.STORAGE.PREVIEWS_DIR, video.getPreviewName(), callback)
}
function createThumbnail (video, videoPath, callback) {
- generateImage(video, videoPath, constants.CONFIG.STORAGE.THUMBNAILS_DIR, constants.THUMBNAILS_SIZE, callback)
-}
-
-function generateThumbnailFromBase64 (video, thumbnailData, callback) {
- // Creating the thumbnail for this remote video)
-
- const thumbnailName = video.getJPEGName()
- 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)
- })
+ generateImage(video, videoPath, constants.CONFIG.STORAGE.THUMBNAILS_DIR, video.getThumbnailName(), constants.THUMBNAILS_SIZE, callback)
}
-function generateImage (video, videoPath, folder, size, callback) {
- const filename = video.getJPEGName()
+function generateImage (video, videoPath, folder, imageName, size, callback) {
const options = {
- filename,
+ filename: imageName,
count: 1,
folder
}
ffmpeg(videoPath)
.on('error', callback)
.on('end', function () {
- callback(null, filename)
+ callback(null, imageName)
})
.thumbnail(options)
}
projects / github / Chocobozzz / PeerTube.git / blobdiff