X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server%2Fhelpers%2Fwebtorrent.ts;h=5fe4c1165c24fdd37f183f4a23a601e48fc4b083;hb=0bae66632a8767f3d5aca080af314bcab56e1889;hp=73418aa0a903b42a2bb5b8b1e80255c209a17178;hpb=90a8bd305de4153ec21137a73ff482dcc2e3e19b;p=github%2FChocobozzz%2FPeerTube.git

diff --git a/server/helpers/webtorrent.ts b/server/helpers/webtorrent.ts
index 73418aa0a..5fe4c1165 100644
--- a/server/helpers/webtorrent.ts
+++ b/server/helpers/webtorrent.ts
@@ -1,19 +1,23 @@
+import * as bencode from 'bencode'
 import * as createTorrent from 'create-torrent'
-import { createWriteStream, ensureDir, remove, writeFile } from 'fs-extra'
+import { createWriteStream, ensureDir, readFile, 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 { WEBSERVER } from '@server/initializers/constants'
-import { generateTorrentFileName, getVideoFilePath } from '@server/lib/video-paths'
-import { MVideo, MVideoWithHost } from '@server/types/models/video/video'
+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 { 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'
+import { pipeline } from 'stream'
 
 const createTorrentPromise = promisify2<string, any, any>(createTorrent)
 
@@ -46,6 +50,8 @@ async function downloadWebTorrentVideo (target: { magnetUri: string, torrentName
           .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, files: torrent.files })
+
       file = torrent.files[0]
 
       // FIXME: avoid creating another stream when https://github.com/webtorrent/webtorrent/issues/1517 is fixed
@@ -58,7 +64,11 @@ async function downloadWebTorrentVideo (target: { magnetUri: string, torrentName
           .catch(err => logger.error('Cannot destroy webtorrent.', { err }))
       })
 
-      file.createReadStream().pipe(writeStream)
+      pipeline(
+        file.createReadStream(),
+        writeStream,
+        err => rej(err)
+      )
     })
 
     torrent.on('error', err => rej(err))
@@ -77,46 +87,68 @@ async function downloadWebTorrentVideo (target: { magnetUri: string, torrentName
   })
 }
 
-// FIXME: refactor/merge videoOrPlaylist and video arguments
-async function createTorrentAndSetInfoHash (
-  videoOrPlaylist: MVideo | MStreamingPlaylistVideo,
-  video: MVideoWithHost,
-  videoFile: MVideoFile
-) {
+function createTorrentAndSetInfoHash (videoOrPlaylist: MVideo | MStreamingPlaylistVideo, videoFile: MVideoFile) {
+  const video = extractVideo(videoOrPlaylist)
+
   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}`,
     createdBy: 'PeerTube',
-    announceList: [
-      [ WEBSERVER.WS + '://' + WEBSERVER.HOSTNAME + ':' + WEBSERVER.PORT + '/tracker/socket' ],
-      [ WEBSERVER.URL + '/tracker/announce' ]
-    ],
-    urlList: [ videoFile.getFileUrl(video) ]
+    announceList: buildAnnounceList(),
+    urlList: buildUrlList(video, videoFile)
   }
 
-  const torrent = await createTorrentPromise(getVideoFilePath(videoOrPlaylist, videoFile), options)
+  return VideoPathManager.Instance.makeAvailableVideoFile(videoOrPlaylist, videoFile, 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 torrentFilename = generateTorrentFileName(videoOrPlaylist, videoFile.resolution)
+    const torrentPath = join(CONFIG.STORAGE.TORRENTS_DIR, torrentFilename)
+    logger.info('Creating torrent %s.', torrentPath)
 
-  await writeFile(torrentPath, torrent)
+    await writeFile(torrentPath, torrentContent)
 
-  const parsedTorrent = parseTorrent(torrent)
-  videoFile.infoHash = parsedTorrent.infoHash
-  videoFile.torrentFilename = torrentFilename
+    // Remove old torrent file if it existed
+    if (videoFile.hasTorrent()) {
+      await remove(join(CONFIG.STORAGE.TORRENTS_DIR, videoFile.torrentFilename))
+    }
+
+    const parsedTorrent = parseTorrent(torrentContent)
+    videoFile.infoHash = parsedTorrent.infoHash
+    videoFile.torrentFilename = torrentFilename
+  })
+}
+
+async function updateTorrentUrls (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 = bencode.decode(torrentContent)
+
+  decoded['announce-list'] = buildAnnounceList()
+  decoded.announce = decoded['announce-list'][0][0]
+
+  decoded['url-list'] = buildUrlList(video, videoFile)
+
+  const newTorrentFilename = generateTorrentFileName(videoOrPlaylist, videoFile.resolution)
+  const newTorrentPath = join(CONFIG.STORAGE.TORRENTS_DIR, newTorrentFilename)
+
+  logger.info('Updating torrent URLs %s -> %s.', oldTorrentPath, newTorrentPath)
+
+  await writeFile(newTorrentPath, bencode.encode(decoded))
+  await remove(join(CONFIG.STORAGE.TORRENTS_DIR, videoFile.torrentFilename))
+
+  videoFile.torrentFilename = newTorrentFilename
 }
 
-// FIXME: merge/refactor videoOrPlaylist and video arguments
 function generateMagnetUri (
-  videoOrPlaylist: MVideo | MStreamingPlaylistVideo,
-  video: MVideoWithHost,
+  video: MVideo,
   videoFile: MVideoFileRedundanciesOpt,
-  baseUrlHttp: string,
-  baseUrlWs: string
+  trackerUrls: string[]
 ) {
   const xs = videoFile.getTorrentUrl()
-  const announce = videoOrPlaylist.getTrackerUrls(baseUrlHttp, baseUrlWs)
+  const announce = trackerUrls
   let urlList = [ videoFile.getFileUrl(video) ]
 
   const redundancies = videoFile.RedundancyVideos
@@ -137,6 +169,7 @@ function generateMagnetUri (
 
 export {
   createTorrentPromise,
+  updateTorrentUrls,
   createTorrentAndSetInfoHash,
   generateMagnetUri,
   downloadWebTorrentVideo
@@ -180,3 +213,14 @@ function deleteDownloadedFile (downloadedFile: { directoryPath: string, filepath
   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) ]
+}