1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
|
import * as Bull from 'bull'
import { logger } from '../../../helpers/logger'
import { downloadYoutubeDLVideo } from '../../../helpers/youtube-dl'
import { VideoImportModel } from '../../../models/video/video-import'
import { VideoImportState } from '../../../../shared/models/videos'
import { getDurationFromVideoFile, getVideoFileFPS, getVideoFileResolution } from '../../../helpers/ffmpeg-utils'
import { extname, join } from 'path'
import { VideoFileModel } from '../../../models/video/video-file'
import { renamePromise, statPromise, unlinkPromise } from '../../../helpers/core-utils'
import { CONFIG, sequelizeTypescript } from '../../../initializers'
import { doRequestAndSaveToFile } from '../../../helpers/requests'
import { VideoState } from '../../../../shared'
import { JobQueue } from '../index'
import { federateVideoIfNeeded } from '../../activitypub'
import { VideoModel } from '../../../models/video/video'
import { downloadWebTorrentVideo } from '../../../helpers/webtorrent'
import { getSecureTorrentName } from '../../../helpers/utils'
type VideoImportYoutubeDLPayload = {
type: 'youtube-dl'
videoImportId: number
thumbnailUrl: string
downloadThumbnail: boolean
downloadPreview: boolean
}
type VideoImportTorrentPayload = {
type: 'magnet-uri' | 'torrent-file'
videoImportId: number
}
export type VideoImportPayload = VideoImportYoutubeDLPayload | VideoImportTorrentPayload
async function processVideoImport (job: Bull.Job) {
const payload = job.data as VideoImportPayload
if (payload.type === 'youtube-dl') return processYoutubeDLImport(job, payload)
if (payload.type === 'magnet-uri' || payload.type === 'torrent-file') return processTorrentImport(job, payload)
}
// ---------------------------------------------------------------------------
export {
processVideoImport
}
// ---------------------------------------------------------------------------
async function processTorrentImport (job: Bull.Job, payload: VideoImportTorrentPayload) {
logger.info('Processing torrent video import in job %d.', job.id)
const videoImport = await getVideoImportOrDie(payload.videoImportId)
const options = {
videoImportId: payload.videoImportId,
downloadThumbnail: false,
downloadPreview: false,
generateThumbnail: true,
generatePreview: true
}
const target = {
torrentName: videoImport.torrentName ? getSecureTorrentName(videoImport.torrentName) : undefined,
magnetUri: videoImport.magnetUri
}
return processFile(() => downloadWebTorrentVideo(target), videoImport, options)
}
async function processYoutubeDLImport (job: Bull.Job, payload: VideoImportYoutubeDLPayload) {
logger.info('Processing youtubeDL video import in job %d.', job.id)
const videoImport = await getVideoImportOrDie(payload.videoImportId)
const options = {
videoImportId: videoImport.id,
downloadThumbnail: payload.downloadThumbnail,
downloadPreview: payload.downloadPreview,
thumbnailUrl: payload.thumbnailUrl,
generateThumbnail: false,
generatePreview: false
}
return processFile(() => downloadYoutubeDLVideo(videoImport.targetUrl), videoImport, options)
}
async function getVideoImportOrDie (videoImportId: number) {
const videoImport = await VideoImportModel.loadAndPopulateVideo(videoImportId)
if (!videoImport || !videoImport.Video) {
throw new Error('Cannot import video %s: the video import or video linked to this import does not exist anymore.')
}
return videoImport
}
type ProcessFileOptions = {
videoImportId: number
downloadThumbnail: boolean
downloadPreview: boolean
thumbnailUrl?: string
generateThumbnail: boolean
generatePreview: boolean
}
async function processFile (downloader: () => Promise<string>, videoImport: VideoImportModel, options: ProcessFileOptions) {
let tempVideoPath: string
let videoDestFile: string
let videoFile: VideoFileModel
try {
// Download video from youtubeDL
tempVideoPath = await downloader()
// Get information about this video
const stats = await statPromise(tempVideoPath)
const isAble = await videoImport.User.isAbleToUploadVideo({ size: stats.size })
if (isAble === false) {
throw new Error('The user video quota is exceeded with this video to import.')
}
const { videoFileResolution } = await getVideoFileResolution(tempVideoPath)
const fps = await getVideoFileFPS(tempVideoPath)
const duration = await getDurationFromVideoFile(tempVideoPath)
// Create video file object in database
const videoFileData = {
extname: extname(tempVideoPath),
resolution: videoFileResolution,
size: stats.size,
fps,
videoId: videoImport.videoId
}
videoFile = new VideoFileModel(videoFileData)
// Import if the import fails, to clean files
videoImport.Video.VideoFiles = [ videoFile ]
// Move file
videoDestFile = join(CONFIG.STORAGE.VIDEOS_DIR, videoImport.Video.getVideoFilename(videoFile))
await renamePromise(tempVideoPath, videoDestFile)
tempVideoPath = null // This path is not used anymore
// Process thumbnail
if (options.downloadThumbnail) {
if (options.thumbnailUrl) {
const destThumbnailPath = join(CONFIG.STORAGE.THUMBNAILS_DIR, videoImport.Video.getThumbnailName())
await doRequestAndSaveToFile({ method: 'GET', uri: options.thumbnailUrl }, destThumbnailPath)
} else {
await videoImport.Video.createThumbnail(videoFile)
}
} else if (options.generateThumbnail) {
await videoImport.Video.createThumbnail(videoFile)
}
// Process preview
if (options.downloadPreview) {
if (options.thumbnailUrl) {
const destPreviewPath = join(CONFIG.STORAGE.PREVIEWS_DIR, videoImport.Video.getPreviewName())
await doRequestAndSaveToFile({ method: 'GET', uri: options.thumbnailUrl }, destPreviewPath)
} else {
await videoImport.Video.createPreview(videoFile)
}
} else if (options.generatePreview) {
await videoImport.Video.createPreview(videoFile)
}
// Create torrent
await videoImport.Video.createTorrentAndSetInfoHash(videoFile)
const videoImportUpdated: VideoImportModel = await sequelizeTypescript.transaction(async t => {
// Refresh video
const video = await VideoModel.load(videoImport.videoId, t)
if (!video) throw new Error('Video linked to import ' + videoImport.videoId + ' does not exist anymore.')
videoImport.Video = video
const videoFileCreated = await videoFile.save({ transaction: t })
video.VideoFiles = [ videoFileCreated ]
// Update video DB object
video.duration = duration
video.state = CONFIG.TRANSCODING.ENABLED ? VideoState.TO_TRANSCODE : VideoState.PUBLISHED
const videoUpdated = await video.save({ transaction: t })
// Now we can federate the video (reload from database, we need more attributes)
const videoForFederation = await VideoModel.loadByUUIDAndPopulateAccountAndServerAndTags(video.uuid, t)
await federateVideoIfNeeded(videoForFederation, true, t)
// Update video import object
videoImport.state = VideoImportState.SUCCESS
const videoImportUpdated = await videoImport.save({ transaction: t })
logger.info('Video %s imported.', videoImport.targetUrl)
videoImportUpdated.Video = videoUpdated
return videoImportUpdated
})
// Create transcoding jobs?
if (videoImportUpdated.Video.state === VideoState.TO_TRANSCODE) {
// Put uuid because we don't have id auto incremented for now
const dataInput = {
videoUUID: videoImportUpdated.Video.uuid,
isNewVideo: true
}
await JobQueue.Instance.createJob({ type: 'video-file', payload: dataInput })
}
} catch (err) {
try {
// if (tempVideoPath) await unlinkPromise(tempVideoPath)
} catch (errUnlink) {
logger.warn('Cannot cleanup files after a video import error.', { err: errUnlink })
}
videoImport.error = err.message
videoImport.state = VideoImportState.FAILED
await videoImport.save()
throw err
}
}
|