]>
Commit | Line | Data |
---|---|---|
1 | 'use strict' | |
2 | ||
3 | const config = require('config') | |
4 | const createTorrent = require('create-torrent') | |
5 | const ffmpeg = require('fluent-ffmpeg') | |
6 | const fs = require('fs') | |
7 | const parallel = require('async/parallel') | |
8 | const parseTorrent = require('parse-torrent') | |
9 | const pathUtils = require('path') | |
10 | const magnet = require('magnet-uri') | |
11 | const mongoose = require('mongoose') | |
12 | ||
13 | const constants = require('../initializers/constants') | |
14 | const customVideosValidators = require('../helpers/custom-validators').videos | |
15 | const logger = require('../helpers/logger') | |
16 | const modelUtils = require('./utils') | |
17 | const utils = require('../helpers/utils') | |
18 | ||
19 | const http = config.get('webserver.https') === true ? 'https' : 'http' | |
20 | const host = config.get('webserver.host') | |
21 | const port = config.get('webserver.port') | |
22 | const webseedBaseUrl = http + '://' + host + ':' + port + constants.STATIC_PATHS.WEBSEED | |
23 | ||
24 | // --------------------------------------------------------------------------- | |
25 | ||
26 | // TODO: add indexes on searchable columns | |
27 | const VideoSchema = mongoose.Schema({ | |
28 | name: String, | |
29 | filename: String, | |
30 | description: String, | |
31 | magnetUri: String, | |
32 | podUrl: String, | |
33 | author: String, | |
34 | duration: Number, | |
35 | thumbnail: String, | |
36 | tags: [ String ], | |
37 | createdDate: { | |
38 | type: Date, | |
39 | default: Date.now | |
40 | } | |
41 | }) | |
42 | ||
43 | VideoSchema.path('name').validate(customVideosValidators.isVideoNameValid) | |
44 | VideoSchema.path('description').validate(customVideosValidators.isVideoDescriptionValid) | |
45 | VideoSchema.path('magnetUri').validate(customVideosValidators.isVideoMagnetUriValid) | |
46 | VideoSchema.path('podUrl').validate(customVideosValidators.isVideoPodUrlValid) | |
47 | VideoSchema.path('author').validate(customVideosValidators.isVideoAuthorValid) | |
48 | VideoSchema.path('duration').validate(customVideosValidators.isVideoDurationValid) | |
49 | // The tumbnail can be the path or the data in base 64 | |
50 | // The pre save hook will convert the base 64 data in a file on disk and replace the thumbnail key by the filename | |
51 | VideoSchema.path('thumbnail').validate(function (value) { | |
52 | return customVideosValidators.isVideoThumbnailValid(value) || customVideosValidators.isVideoThumbnail64Valid(value) | |
53 | }) | |
54 | VideoSchema.path('tags').validate(customVideosValidators.isVideoTagsValid) | |
55 | ||
56 | VideoSchema.methods = { | |
57 | isOwned, | |
58 | toFormatedJSON, | |
59 | toRemoteJSON | |
60 | } | |
61 | ||
62 | VideoSchema.statics = { | |
63 | getDurationFromFile, | |
64 | listForApi, | |
65 | listByUrlAndMagnet, | |
66 | listByUrls, | |
67 | listOwned, | |
68 | listOwnedByAuthor, | |
69 | listRemotes, | |
70 | load, | |
71 | search | |
72 | } | |
73 | ||
74 | VideoSchema.pre('remove', function (next) { | |
75 | const video = this | |
76 | const tasks = [] | |
77 | ||
78 | tasks.push( | |
79 | function (callback) { | |
80 | removeThumbnail(video, callback) | |
81 | } | |
82 | ) | |
83 | ||
84 | if (video.isOwned()) { | |
85 | tasks.push( | |
86 | function (callback) { | |
87 | removeFile(video, callback) | |
88 | }, | |
89 | function (callback) { | |
90 | removeTorrent(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.UPLOAD_DIR, video.filename) | |
104 | this.podUrl = constants.CONFIG.WEBSERVER.URL | |
105 | ||
106 | tasks.push( | |
107 | // TODO: refractoring | |
108 | function (callback) { | |
109 | createTorrent(videoPath, { announceList: [ [ 'ws://' + host + ':' + port + '/tracker/socket' ] ], urlList: [ webseedBaseUrl + video.filename ] }, function (err, torrent) { | |
110 | if (err) return callback(err) | |
111 | ||
112 | fs.writeFile(constants.CONFIG.STORAGE.TORRENTS_DIR + video.filename + '.torrent', torrent, function (err) { | |
113 | if (err) return callback(err) | |
114 | ||
115 | const parsedTorrent = parseTorrent(torrent) | |
116 | parsedTorrent.xs = video.podUrl + constants.STATIC_PATHS.TORRENTS + video.filename + '.torrent' | |
117 | video.magnetUri = magnet.encode(parsedTorrent) | |
118 | ||
119 | callback(null) | |
120 | }) | |
121 | }) | |
122 | }, | |
123 | function (callback) { | |
124 | createThumbnail(videoPath, callback) | |
125 | } | |
126 | ) | |
127 | ||
128 | parallel(tasks, function (err, results) { | |
129 | if (err) return next(err) | |
130 | ||
131 | video.thumbnail = results[1] | |
132 | ||
133 | return next() | |
134 | }) | |
135 | } else { | |
136 | generateThumbnailFromBase64(video.thumbnail, function (err, thumbnailName) { | |
137 | if (err) return next(err) | |
138 | ||
139 | video.thumbnail = thumbnailName | |
140 | ||
141 | return next() | |
142 | }) | |
143 | } | |
144 | }) | |
145 | ||
146 | mongoose.model('Video', VideoSchema) | |
147 | ||
148 | // ------------------------------ METHODS ------------------------------ | |
149 | ||
150 | function isOwned () { | |
151 | return this.filename !== null | |
152 | } | |
153 | ||
154 | function toFormatedJSON () { | |
155 | const json = { | |
156 | id: this._id, | |
157 | name: this.name, | |
158 | description: this.description, | |
159 | podUrl: this.podUrl.replace(/^https?:\/\//, ''), | |
160 | isLocal: this.isOwned(), | |
161 | magnetUri: this.magnetUri, | |
162 | author: this.author, | |
163 | duration: this.duration, | |
164 | tags: this.tags, | |
165 | thumbnailPath: constants.STATIC_PATHS.THUMBNAILS + '/' + this.thumbnail, | |
166 | createdDate: this.createdDate | |
167 | } | |
168 | ||
169 | return json | |
170 | } | |
171 | ||
172 | function toRemoteJSON (callback) { | |
173 | const self = this | |
174 | ||
175 | // Convert thumbnail to base64 | |
176 | fs.readFile(pathUtils.join(constants.CONFIG.STORAGE.THUMBNAILS_DIR, this.thumbnail), function (err, thumbnailData) { | |
177 | if (err) { | |
178 | logger.error('Cannot read the thumbnail of the video') | |
179 | return callback(err) | |
180 | } | |
181 | ||
182 | const remoteVideo = { | |
183 | name: self.name, | |
184 | description: self.description, | |
185 | magnetUri: self.magnetUri, | |
186 | filename: null, | |
187 | author: self.author, | |
188 | duration: self.duration, | |
189 | thumbnailBase64: new Buffer(thumbnailData).toString('base64'), | |
190 | tags: self.tags, | |
191 | createdDate: self.createdDate, | |
192 | podUrl: self.podUrl | |
193 | } | |
194 | ||
195 | return callback(null, remoteVideo) | |
196 | }) | |
197 | } | |
198 | ||
199 | // ------------------------------ STATICS ------------------------------ | |
200 | ||
201 | function getDurationFromFile (videoPath, callback) { | |
202 | ffmpeg.ffprobe(videoPath, function (err, metadata) { | |
203 | if (err) return callback(err) | |
204 | ||
205 | return callback(null, Math.floor(metadata.format.duration)) | |
206 | }) | |
207 | } | |
208 | ||
209 | function listForApi (start, count, sort, callback) { | |
210 | const query = {} | |
211 | return modelUtils.listForApiWithCount.call(this, query, start, count, sort, callback) | |
212 | } | |
213 | ||
214 | function listByUrlAndMagnet (fromUrl, magnetUri, callback) { | |
215 | this.find({ podUrl: fromUrl, magnetUri: magnetUri }, callback) | |
216 | } | |
217 | ||
218 | function listByUrls (fromUrls, callback) { | |
219 | this.find({ podUrl: { $in: fromUrls } }, callback) | |
220 | } | |
221 | ||
222 | function listOwned (callback) { | |
223 | // If filename is not null this is *our* video | |
224 | this.find({ filename: { $ne: null } }, callback) | |
225 | } | |
226 | ||
227 | function listOwnedByAuthor (author, callback) { | |
228 | this.find({ filename: { $ne: null }, author: author }, callback) | |
229 | } | |
230 | ||
231 | function listRemotes (callback) { | |
232 | this.find({ filename: null }, callback) | |
233 | } | |
234 | ||
235 | function load (id, callback) { | |
236 | this.findById(id, callback) | |
237 | } | |
238 | ||
239 | function search (value, field, start, count, sort, callback) { | |
240 | const query = {} | |
241 | // Make an exact search with the magnet | |
242 | if (field === 'magnetUri' || field === 'tags') { | |
243 | query[field] = value | |
244 | } else { | |
245 | query[field] = new RegExp(value) | |
246 | } | |
247 | ||
248 | modelUtils.listForApiWithCount.call(this, query, start, count, sort, callback) | |
249 | } | |
250 | ||
251 | // --------------------------------------------------------------------------- | |
252 | ||
253 | function removeThumbnail (video, callback) { | |
254 | fs.unlink(constants.CONFIG.STORAGE.THUMBNAILS_DIR + video.thumbnail, callback) | |
255 | } | |
256 | ||
257 | function removeFile (video, callback) { | |
258 | fs.unlink(constants.CONFIG.STORAGE.UPLOAD_DIR + video.filename, callback) | |
259 | } | |
260 | ||
261 | // Maybe the torrent is not seeded, but we catch the error to don't stop the removing process | |
262 | function removeTorrent (video, callback) { | |
263 | fs.unlink(constants.CONFIG.STORAGE.TORRENTS_DIR + video.filename + '.torrent', callback) | |
264 | } | |
265 | ||
266 | function createThumbnail (videoPath, callback) { | |
267 | const filename = pathUtils.basename(videoPath) + '.jpg' | |
268 | ffmpeg(videoPath) | |
269 | .on('error', callback) | |
270 | .on('end', function () { | |
271 | callback(null, filename) | |
272 | }) | |
273 | .thumbnail({ | |
274 | count: 1, | |
275 | folder: constants.CONFIG.STORAGE.THUMBNAILS_DIR, | |
276 | size: constants.THUMBNAILS_SIZE, | |
277 | filename: filename | |
278 | }) | |
279 | } | |
280 | ||
281 | function generateThumbnailFromBase64 (data, callback) { | |
282 | // Creating the thumbnail for this remote video | |
283 | utils.generateRandomString(16, function (err, randomString) { | |
284 | if (err) return callback(err) | |
285 | ||
286 | const thumbnailName = randomString + '.jpg' | |
287 | fs.writeFile(constants.CONFIG.STORAGE.THUMBNAILS_DIR + thumbnailName, data, { encoding: 'base64' }, function (err) { | |
288 | if (err) return callback(err) | |
289 | ||
290 | return callback(null, thumbnailName) | |
291 | }) | |
292 | }) | |
293 | } |