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
|
import { Job } from 'bullmq'
import { extractVideo } from '@server/helpers/video'
import { createTorrentAndSetInfoHash, updateTorrentMetadata } from '@server/helpers/webtorrent'
import { VideoPathManager } from '@server/lib/video-path-manager'
import { VideoModel } from '@server/models/video/video'
import { VideoFileModel } from '@server/models/video/video-file'
import { VideoStreamingPlaylistModel } from '@server/models/video/video-streaming-playlist'
import { ManageVideoTorrentPayload } from '@shared/models'
import { logger } from '../../../helpers/logger'
async function processManageVideoTorrent (job: Job) {
const payload = job.data as ManageVideoTorrentPayload
logger.info('Processing torrent in job %s.', job.id)
if (payload.action === 'create') return doCreateAction(payload)
if (payload.action === 'update-metadata') return doUpdateMetadataAction(payload)
}
// ---------------------------------------------------------------------------
export {
processManageVideoTorrent
}
// ---------------------------------------------------------------------------
async function doCreateAction (payload: ManageVideoTorrentPayload & { action: 'create' }) {
const [ video, file ] = await Promise.all([
loadVideoOrLog(payload.videoId),
loadFileOrLog(payload.videoFileId)
])
if (!video || !file) return
const fileMutexReleaser = await VideoPathManager.Instance.lockFiles(video.uuid)
try {
await createTorrentAndSetInfoHash(video, file)
// Refresh videoFile because the createTorrentAndSetInfoHash could be long
const refreshedFile = await VideoFileModel.loadWithVideo(file.id)
// File does not exist anymore, remove the generated torrent
if (!refreshedFile) return file.removeTorrent()
refreshedFile.infoHash = file.infoHash
refreshedFile.torrentFilename = file.torrentFilename
await refreshedFile.save()
} finally {
fileMutexReleaser()
}
}
async function doUpdateMetadataAction (payload: ManageVideoTorrentPayload & { action: 'update-metadata' }) {
const [ video, streamingPlaylist, file ] = await Promise.all([
loadVideoOrLog(payload.videoId),
loadStreamingPlaylistOrLog(payload.streamingPlaylistId),
loadFileOrLog(payload.videoFileId)
])
if ((!video && !streamingPlaylist) || !file) return
const extractedVideo = extractVideo(video || streamingPlaylist)
const fileMutexReleaser = await VideoPathManager.Instance.lockFiles(extractedVideo.uuid)
try {
await updateTorrentMetadata(video || streamingPlaylist, file)
await file.save()
} finally {
fileMutexReleaser()
}
}
async function loadVideoOrLog (videoId: number) {
if (!videoId) return undefined
const video = await VideoModel.load(videoId)
if (!video) {
logger.debug('Do not process torrent for video %d: does not exist anymore.', videoId)
}
return video
}
async function loadStreamingPlaylistOrLog (streamingPlaylistId: number) {
if (!streamingPlaylistId) return undefined
const streamingPlaylist = await VideoStreamingPlaylistModel.loadWithVideo(streamingPlaylistId)
if (!streamingPlaylist) {
logger.debug('Do not process torrent for streaming playlist %d: does not exist anymore.', streamingPlaylistId)
}
return streamingPlaylist
}
async function loadFileOrLog (videoFileId: number) {
if (!videoFileId) return undefined
const file = await VideoFileModel.load(videoFileId)
if (!file) {
logger.debug('Do not process torrent for file %d: does not exist anymore.', videoFileId)
}
return file
}
|
