-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 { decode, encode } from 'bencode'
+import createTorrent from 'create-torrent'
+import { createWriteStream, ensureDir, readFile, remove, writeFile } from 'fs-extra'
+import magnetUtil from 'magnet-uri'
+import parseTorrent from 'parse-torrent'
import { dirname, join } from 'path'
-import * as createTorrent from 'create-torrent'
-import { promisify2 } from './core-utils'
+import { pipeline } from 'stream'
+import WebTorrent, { Instance, TorrentFile } from 'webtorrent'
+import { isArray } from '@server/helpers/custom-validators/misc'
+import { WEBSERVER } from '@server/initializers/constants'
+import { generateTorrentFileName } from '@server/lib/paths'
+import { VideoPathManager } from '@server/lib/video-path-manager'
import { MVideo } from '@server/types/models/video/video'
import { MVideoFile, MVideoFileRedundanciesOpt } from '@server/types/models/video/video-file'
-import { isStreamingPlaylist, MStreamingPlaylistVideo } from '@server/types/models/video/video-streaming-playlist'
-import { WEBSERVER } from '@server/initializers/constants'
-import * as parseTorrent from 'parse-torrent'
-import * as magnetUtil from 'magnet-uri'
-import { isArray } from '@server/helpers/custom-validators/misc'
-import { getTorrentFileName, getVideoFilePath } from '@server/lib/video-paths'
-import { extractVideo } from '@server/helpers/video'
+import { MStreamingPlaylistVideo } from '@server/types/models/video/video-streaming-playlist'
+import { CONFIG } from '../initializers/config'
+import { promisify2, sha1 } from './core-utils'
+import { logger } from './logger'
+import { generateVideoImportTmpPath } from './utils'
+import { extractVideo } from './video'
const createTorrentPromise = promisify2<string, any, any>(createTorrent)
-async function downloadWebTorrentVideo (target: { magnetUri: string, torrentName?: string }, timeout: number) {
- const id = target.magnetUri || target.torrentName
+async function downloadWebTorrentVideo (target: { uri: string, torrentName?: string }, timeout: number) {
+ const id = target.uri || target.torrentName
let timer
const path = generateVideoImportTmpPath(id)
return new Promise<string>((res, rej) => {
const webtorrent = new WebTorrent()
- let file: WebTorrent.TorrentFile
+ let file: TorrentFile
- const torrentId = target.magnetUri || join(CONFIG.STORAGE.TORRENTS_DIR, target.torrentName)
+ const torrentId = target.uri || join(CONFIG.STORAGE.TORRENTS_DIR, target.torrentName)
const options = { path: directoryPath }
const torrent = webtorrent.add(torrentId, options, torrent => {
.then(() => rej(new Error('Cannot import torrent ' + torrentId + ': there are multiple files in it')))
}
+ logger.debug('Got torrent from webtorrent %s.', id, { infoHash: torrent.infoHash })
+
file = torrent.files[0]
// FIXME: avoid creating another stream when https://github.com/webtorrent/webtorrent/issues/1517 is fixed
.catch(err => logger.error('Cannot destroy webtorrent.', { err }))
})
- file.createReadStream().pipe(writeStream)
+ pipeline(
+ file.createReadStream(),
+ writeStream,
+ err => {
+ if (err) rej(err)
+ }
+ )
})
torrent.on('error', err => rej(err))
})
}
-async function createTorrentAndSetInfoHash (videoOrPlaylist: MVideo | MStreamingPlaylistVideo, videoFile: MVideoFile) {
+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
- name: `${video.name} ${videoFile.resolution}p${videoFile.extname}`,
+ name: buildInfoName(video, videoFile),
createdBy: 'PeerTube',
- announceList: [
- [ WEBSERVER.WS + '://' + WEBSERVER.HOSTNAME + ':' + WEBSERVER.PORT + '/tracker/socket' ],
- [ WEBSERVER.URL + '/tracker/announce' ]
- ],
- urlList: [ videoOrPlaylist.getVideoFileUrl(videoFile, baseUrlHttp) ]
+ announceList: buildAnnounceList(),
+ urlList: buildUrlList(video, videoFile)
}
- const torrent = await createTorrentPromise(getVideoFilePath(videoOrPlaylist, videoFile), options)
+ return VideoPathManager.Instance.makeAvailableVideoFile(videoFile.withVideoOrPlaylist(videoOrPlaylist), async videoPath => {
+ const torrentContent = await createTorrentPromise(videoPath, options)
+
+ const torrentFilename = generateTorrentFileName(videoOrPlaylist, videoFile.resolution)
+ const torrentPath = join(CONFIG.STORAGE.TORRENTS_DIR, torrentFilename)
+ logger.info('Creating torrent %s.', torrentPath)
- const filePath = join(CONFIG.STORAGE.TORRENTS_DIR, getTorrentFileName(videoOrPlaylist, videoFile))
- logger.info('Creating torrent %s.', filePath)
+ await writeFile(torrentPath, torrentContent)
- await writeFile(filePath, torrent)
+ // Remove old torrent file if it existed
+ if (videoFile.hasTorrent()) {
+ await remove(join(CONFIG.STORAGE.TORRENTS_DIR, videoFile.torrentFilename))
+ }
- const parsedTorrent = parseTorrent(torrent)
- videoFile.infoHash = parsedTorrent.infoHash
+ const parsedTorrent = parseTorrent(torrentContent)
+ videoFile.infoHash = parsedTorrent.infoHash
+ videoFile.torrentFilename = torrentFilename
+ })
+}
+
+async function updateTorrentMetadata (videoOrPlaylist: MVideo | MStreamingPlaylistVideo, videoFile: MVideoFile) {
+ const video = extractVideo(videoOrPlaylist)
+
+ const oldTorrentPath = join(CONFIG.STORAGE.TORRENTS_DIR, videoFile.torrentFilename)
+
+ const torrentContent = await readFile(oldTorrentPath)
+ const decoded = decode(torrentContent)
+
+ decoded['announce-list'] = buildAnnounceList()
+ decoded.announce = decoded['announce-list'][0][0]
+
+ decoded['url-list'] = buildUrlList(video, videoFile)
+
+ decoded.info.name = buildInfoName(video, videoFile)
+ decoded['creation date'] = Math.ceil(Date.now() / 1000)
+
+ const newTorrentFilename = generateTorrentFileName(videoOrPlaylist, videoFile.resolution)
+ const newTorrentPath = join(CONFIG.STORAGE.TORRENTS_DIR, newTorrentFilename)
+
+ logger.info('Updating torrent metadata %s -> %s.', oldTorrentPath, newTorrentPath)
+
+ await writeFile(newTorrentPath, encode(decoded))
+ await remove(join(CONFIG.STORAGE.TORRENTS_DIR, videoFile.torrentFilename))
+
+ videoFile.torrentFilename = newTorrentFilename
+ videoFile.infoHash = sha1(encode(decoded.info))
}
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))
export {
createTorrentPromise,
+ updateTorrentMetadata,
createTorrentAndSetInfoHash,
generateMagnetUri,
downloadWebTorrentVideo
// ---------------------------------------------------------------------------
function safeWebtorrentDestroy (
- webtorrent: WebTorrent.Instance,
+ webtorrent: Instance,
torrentId: string,
downloadedFile?: { directoryPath: string, filepath: string },
torrentName?: string
) {
- return new Promise(res => {
+ return new Promise<void>(res => {
webtorrent.destroy(err => {
// Delete torrent file
if (torrentName) {
remove(toRemovePath)
.catch(err => logger.error('Cannot remove torrent file %s in webtorrent download.', toRemovePath, { err }))
}
+
+function buildAnnounceList () {
+ return [
+ [ WEBSERVER.WS + '://' + WEBSERVER.HOSTNAME + ':' + WEBSERVER.PORT + '/tracker/socket' ],
+ [ WEBSERVER.URL + '/tracker/announce' ]
+ ]
+}
+
+function buildUrlList (video: MVideo, videoFile: MVideoFile) {
+ return [ videoFile.getFileUrl(video) ]
+}
+
+function buildInfoName (video: MVideo, videoFile: MVideoFile) {
+ return `${video.name} ${videoFile.resolution}p${videoFile.extname}`
+}
projects / github / Chocobozzz / PeerTube.git / blobdiff