-import { logger } from './logger'
-import { generateVideoImportTmpPath } from './utils'
-import * as WebTorrent from 'webtorrent'
-import { createWriteStream, ensureDir, remove, writeFile } from 'fs-extra'
-import { CONFIG } from '../initializers/config'
-import { dirname, join } from 'path'
import * as createTorrent from 'create-torrent'
-import { promisify2 } from './core-utils'
-import { MVideo } from '@server/typings/models/video/video'
-import { MVideoFile, MVideoFileRedundanciesOpt } from '@server/typings/models/video/video-file'
-import { isStreamingPlaylist, MStreamingPlaylistVideo } from '@server/typings/models/video/video-streaming-playlist'
-import { WEBSERVER } from '@server/initializers/constants'
-import * as parseTorrent from 'parse-torrent'
+import { createWriteStream, ensureDir, remove, writeFile } from 'fs-extra'
import * as magnetUtil from 'magnet-uri'
+import * as parseTorrent from 'parse-torrent'
+import { dirname, join } from 'path'
+import * as WebTorrent from 'webtorrent'
import { isArray } from '@server/helpers/custom-validators/misc'
-import { extractVideo } from '@server/lib/videos'
-import { getTorrentFileName, getVideoFilePath } from '@server/lib/video-paths'
+import { WEBSERVER } from '@server/initializers/constants'
+import { generateTorrentFileName, getVideoFilePath } from '@server/lib/video-paths'
+import { MVideo } from '@server/types/models/video/video'
+import { MVideoFile, MVideoFileRedundanciesOpt } from '@server/types/models/video/video-file'
+import { MStreamingPlaylistVideo } from '@server/types/models/video/video-streaming-playlist'
+import { CONFIG } from '../initializers/config'
+import { promisify2 } from './core-utils'
+import { logger } from './logger'
+import { generateVideoImportTmpPath } from './utils'
+import { extractVideo } from './video'
const createTorrentPromise = promisify2<string, any, any>(createTorrent)
if (torrent.files.length !== 1) {
if (timer) clearTimeout(timer)
- for (let file of torrent.files) {
+ for (const file of torrent.files) {
deleteDownloadedFile({ directoryPath, filepath: file.path })
}
.then(() => rej(new Error('Cannot import torrent ' + torrentId + ': there are multiple files in it')))
}
- file = torrent.files[ 0 ]
+ file = torrent.files[0]
// FIXME: avoid creating another stream when https://github.com/webtorrent/webtorrent/issues/1517 is fixed
const writeStream = createWriteStream(path)
writeStream.on('finish', () => {
if (timer) clearTimeout(timer)
- return safeWebtorrentDestroy(webtorrent, torrentId, { directoryPath, filepath: file.path }, target.torrentName)
+ safeWebtorrentDestroy(webtorrent, torrentId, { directoryPath, filepath: file.path }, target.torrentName)
.then(() => res(path))
+ .catch(err => logger.error('Cannot destroy webtorrent.', { err }))
})
file.createReadStream().pipe(writeStream)
torrent.on('error', err => rej(err))
- timer = setTimeout(async () => {
- return safeWebtorrentDestroy(webtorrent, torrentId, file ? { directoryPath, filepath: file.path } : undefined, target.torrentName)
- .then(() => rej(new Error('Webtorrent download timeout.')))
+ timer = setTimeout(() => {
+ const err = new Error('Webtorrent download timeout.')
+
+ safeWebtorrentDestroy(webtorrent, torrentId, file ? { directoryPath, filepath: file.path } : undefined, target.torrentName)
+ .then(() => rej(err))
+ .catch(destroyErr => {
+ logger.error('Cannot destroy webtorrent.', { err: destroyErr })
+ rej(err)
+ })
+
}, timeout)
})
}
-async function createTorrentAndSetInfoHash (videoOrPlaylist: MVideo | MStreamingPlaylistVideo, videoFile: MVideoFile) {
+async function createTorrentAndSetInfoHash (
+ videoOrPlaylist: MVideo | MStreamingPlaylistVideo,
+ videoFile: MVideoFile
+) {
const video = extractVideo(videoOrPlaylist)
- const { baseUrlHttp } = video.getBaseUrls()
const options = {
// Keep the extname, it's used by the client to stream the file inside a web browser
[ WEBSERVER.WS + '://' + WEBSERVER.HOSTNAME + ':' + WEBSERVER.PORT + '/tracker/socket' ],
[ WEBSERVER.URL + '/tracker/announce' ]
],
- urlList: [ videoOrPlaylist.getVideoFileUrl(videoFile, baseUrlHttp) ]
+ urlList: [ videoFile.getFileUrl(video) ]
}
const torrent = await createTorrentPromise(getVideoFilePath(videoOrPlaylist, videoFile), options)
- const filePath = join(CONFIG.STORAGE.TORRENTS_DIR, getTorrentFileName(videoOrPlaylist, videoFile))
- logger.info('Creating torrent %s.', filePath)
+ const torrentFilename = generateTorrentFileName(videoOrPlaylist, videoFile.resolution)
+ const torrentPath = join(CONFIG.STORAGE.TORRENTS_DIR, torrentFilename)
+ logger.info('Creating torrent %s.', torrentPath)
- await writeFile(filePath, torrent)
+ await writeFile(torrentPath, torrent)
const parsedTorrent = parseTorrent(torrent)
videoFile.infoHash = parsedTorrent.infoHash
+ videoFile.torrentFilename = torrentFilename
}
function generateMagnetUri (
- videoOrPlaylist: MVideo | MStreamingPlaylistVideo,
+ video: MVideo,
videoFile: MVideoFileRedundanciesOpt,
- baseUrlHttp: string,
- baseUrlWs: string
+ trackerUrls: string[]
) {
- const video = isStreamingPlaylist(videoOrPlaylist)
- ? videoOrPlaylist.Video
- : videoOrPlaylist
-
- const xs = videoOrPlaylist.getTorrentUrl(videoFile, baseUrlHttp)
- const announce = videoOrPlaylist.getTrackerUrls(baseUrlHttp, baseUrlWs)
- let urlList = [ videoOrPlaylist.getVideoFileUrl(videoFile, baseUrlHttp) ]
+ const xs = videoFile.getTorrentUrl()
+ const announce = trackerUrls
+ let urlList = [ videoFile.getFileUrl(video) ]
const redundancies = videoFile.RedundancyVideos
if (isArray(redundancies)) urlList = urlList.concat(redundancies.map(r => r.fileUrl))
downloadedFile?: { directoryPath: string, filepath: string },
torrentName?: string
) {
- return new Promise(res => {
+ return new Promise<void>(res => {
webtorrent.destroy(err => {
// Delete torrent file
if (torrentName) {