Optimize markdown renderer

[github/Chocobozzz/PeerTube.git] / server / helpers / webtorrent.ts

diff --git a/server/helpers/webtorrent.ts b/server/helpers/webtorrent.ts
index 813ebc2361f77965c129df369acfc8b318e868d1..68d532c48995a2f5efde250c233aec100f800594 100644 (file)
--- a/server/helpers/webtorrent.ts
+++ b/server/helpers/webtorrent.ts
@@ -1,10 +1,11 @@
-import * as bencode from 'bencode'
-import * as createTorrent from 'create-torrent'
+import { decode, encode } from 'bencode'
+import createTorrent from 'create-torrent'
 import { createWriteStream, ensureDir, readFile, remove, writeFile } from 'fs-extra'
-import * as magnetUtil from 'magnet-uri'
-import * as parseTorrent from 'parse-torrent'
+import magnetUtil from 'magnet-uri'
+import parseTorrent from 'parse-torrent'
 import { dirname, join } from 'path'
-import * as WebTorrent from 'webtorrent'
+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'
@@ -12,17 +13,17 @@ 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 { sha1 } from '@shared/extra-utils'
 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)
 
-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)
@@ -33,9 +34,9 @@ async function downloadWebTorrentVideo (target: { magnetUri: string, torrentName
 
   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 => {
@@ -94,13 +95,13 @@ function createTorrentAndSetInfoHash (videoOrPlaylist: MVideo | MStreamingPlayli
 
   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: buildAnnounceList(),
     urlList: buildUrlList(video, videoFile)
   }
 
-  return VideoPathManager.Instance.makeAvailableVideoFile(videoOrPlaylist, videoFile, async videoPath => {
+  return VideoPathManager.Instance.makeAvailableVideoFile(videoFile.withVideoOrPlaylist(videoOrPlaylist), async videoPath => {
     const torrentContent = await createTorrentPromise(videoPath, options)
 
     const torrentFilename = generateTorrentFileName(videoOrPlaylist, videoFile.resolution)
@@ -120,28 +121,32 @@ function createTorrentAndSetInfoHash (videoOrPlaylist: MVideo | MStreamingPlayli
   })
 }
 
-async function updateTorrentUrls (videoOrPlaylist: MVideo | MStreamingPlaylistVideo, videoFile: MVideoFile) {
+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 = bencode.decode(torrentContent)
+  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 URLs %s -> %s.', oldTorrentPath, newTorrentPath)
+  logger.info('Updating torrent metadata %s -> %s.', oldTorrentPath, newTorrentPath)
 
-  await writeFile(newTorrentPath, bencode.encode(decoded))
+  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 (
@@ -171,7 +176,7 @@ function generateMagnetUri (
 
 export {
   createTorrentPromise,
-  updateTorrentUrls,
+  updateTorrentMetadata,
   createTorrentAndSetInfoHash,
   generateMagnetUri,
   downloadWebTorrentVideo
@@ -180,7 +185,7 @@ export {
 // ---------------------------------------------------------------------------
 
 function safeWebtorrentDestroy (
-  webtorrent: WebTorrent.Instance,
+  webtorrent: Instance,
   torrentId: string,
   downloadedFile?: { directoryPath: string, filepath: string },
   torrentName?: string
@@ -226,3 +231,7 @@ function buildAnnounceList () {
 function buildUrlList (video: MVideo, videoFile: MVideoFile) {
   return [ videoFile.getFileUrl(video) ]
 }
+
+function buildInfoName (video: MVideo, videoFile: MVideoFile) {
+  return `${video.name} ${videoFile.resolution}p${videoFile.extname}`
+}