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
|
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'
export type VideoImportPayload = {
type: 'youtube-dl'
videoImportId: number
thumbnailUrl: string
downloadThumbnail: boolean
downloadPreview: boolean
}
async function processVideoImport (job: Bull.Job) {
const payload = job.data as VideoImportPayload
logger.info('Processing video import in job %d.', job.id)
const videoImport = await VideoImportModel.loadAndPopulateVideo(payload.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.')
}
let tempVideoPath: string
let videoDestFile: string
let videoFile: VideoFileModel
try {
// Download video from youtubeDL
tempVideoPath = await downloadYoutubeDLVideo(videoImport.targetUrl)
// Get information about this video
const { videoFileResolution } = await getVideoFileResolution(tempVideoPath)
const fps = await getVideoFileFPS(tempVideoPath)
const stats = await statPromise(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 (payload.downloadThumbnail) {
if (payload.thumbnailUrl) {
const destThumbnailPath = join(CONFIG.STORAGE.THUMBNAILS_DIR, videoImport.Video.getThumbnailName())
await doRequestAndSaveToFile({ method: 'GET', uri: payload.thumbnailUrl }, destThumbnailPath)
} else {
await videoImport.Video.createThumbnail(videoFile)
}
}
// Process preview
if (payload.downloadPreview) {
if (payload.thumbnailUrl) {
const destPreviewPath = join(CONFIG.STORAGE.PREVIEWS_DIR, videoImport.Video.getPreviewName())
await doRequestAndSaveToFile({ method: 'GET', uri: payload.thumbnailUrl }, destPreviewPath)
} else {
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
}
}
// ---------------------------------------------------------------------------
export {
processVideoImport
}
|
