Add ability to delete a specific video file

7 files changed, 202 insertions, 122 deletions

diff --git a/server/lib/activitypub/videos/shared/abstract-builder.ts b/server/lib/activitypub/videos/shared/abstract-builder.ts
index f299ba4fd..c0b92c93d 100644
--- a/server/lib/activitypub/videos/shared/abstract-builder.ts
+++ b/server/lib/activitypub/videos/shared/abstract-builder.ts
@@ -1,4 +1,4 @@
-import { Transaction } from 'sequelize/types'
+import { CreationAttributes, Transaction } from 'sequelize/types'
 import { deleteAllModels, filterNonExistingModels } from '@server/helpers/database-utils'
 import { logger, LoggerTagsFn } from '@server/helpers/logger'
 import { updatePlaceholderThumbnail, updateVideoMiniatureFromUrl } from '@server/lib/thumbnail'
@@ -7,7 +7,15 @@ import { VideoCaptionModel } from '@server/models/video/video-caption'
 import { VideoFileModel } from '@server/models/video/video-file'
 import { VideoLiveModel } from '@server/models/video/video-live'
 import { VideoStreamingPlaylistModel } from '@server/models/video/video-streaming-playlist'
-import { MStreamingPlaylistFilesVideo, MThumbnail, MVideoCaption, MVideoFile, MVideoFullLight, MVideoThumbnail } from '@server/types/models'
+import {
+  MStreamingPlaylistFiles,
+  MStreamingPlaylistFilesVideo,
+  MThumbnail,
+  MVideoCaption,
+  MVideoFile,
+  MVideoFullLight,
+  MVideoThumbnail
+} from '@server/types/models'
 import { ActivityTagObject, ThumbnailType, VideoObject, VideoStreamingPlaylistType } from '@shared/models'
 import { getOrCreateAPActor } from '../../actors'
 import { checkUrlsSameHost } from '../../url'
@@ -125,38 +133,39 @@ export abstract class APVideoAbstractBuilder {
     // Remove video playlists that do not exist anymore
     await deleteAllModels(filterNonExistingModels(video.VideoStreamingPlaylists || [], newStreamingPlaylists), t)
 
+    const oldPlaylists = video.VideoStreamingPlaylists
     video.VideoStreamingPlaylists = []
 
     for (const playlistAttributes of streamingPlaylistAttributes) {
       const streamingPlaylistModel = await this.insertOrReplaceStreamingPlaylist(playlistAttributes, t)
       streamingPlaylistModel.Video = video
 
-      await this.setStreamingPlaylistFiles(video, streamingPlaylistModel, playlistAttributes.tagAPObject, t)
+      await this.setStreamingPlaylistFiles(oldPlaylists, streamingPlaylistModel, playlistAttributes.tagAPObject, t)
 
       video.VideoStreamingPlaylists.push(streamingPlaylistModel)
     }
   }
 
-  private async insertOrReplaceStreamingPlaylist (attributes: VideoStreamingPlaylistModel['_creationAttributes'], t: Transaction) {
+  private async insertOrReplaceStreamingPlaylist (attributes: CreationAttributes<VideoStreamingPlaylistModel>, t: Transaction) {
     const [ streamingPlaylist ] = await VideoStreamingPlaylistModel.upsert(attributes, { returning: true, transaction: t })
 
     return streamingPlaylist as MStreamingPlaylistFilesVideo
   }
 
-  private getStreamingPlaylistFiles (video: MVideoFullLight, type: VideoStreamingPlaylistType) {
-    const playlist = video.VideoStreamingPlaylists.find(s => s.type === type)
+  private getStreamingPlaylistFiles (oldPlaylists: MStreamingPlaylistFiles[], type: VideoStreamingPlaylistType) {
+    const playlist = oldPlaylists.find(s => s.type === type)
     if (!playlist) return []
 
     return playlist.VideoFiles
   }
 
   private async setStreamingPlaylistFiles (
-    video: MVideoFullLight,
+    oldPlaylists: MStreamingPlaylistFiles[],
     playlistModel: MStreamingPlaylistFilesVideo,
     tagObjects: ActivityTagObject[],
     t: Transaction
   ) {
-    const oldStreamingPlaylistFiles = this.getStreamingPlaylistFiles(video, playlistModel.type)
+    const oldStreamingPlaylistFiles = this.getStreamingPlaylistFiles(oldPlaylists || [], playlistModel.type)
 
     const newVideoFiles: MVideoFile[] = getFileAttributesFromUrl(playlistModel, tagObjects).map(a => new VideoFileModel(a))
 
diff --git a/server/lib/hls.ts b/server/lib/hls.ts
index 43043315b..20754219f 100644
--- a/server/lib/hls.ts
+++ b/server/lib/hls.ts
@@ -1,7 +1,8 @@
 import { close, ensureDir, move, open, outputJSON, read, readFile, remove, stat, writeFile } from 'fs-extra'
 import { flatten, uniq } from 'lodash'
+import PQueue from 'p-queue'
 import { basename, dirname, join } from 'path'
-import { MStreamingPlaylistFilesVideo, MVideo, MVideoUUID } from '@server/types/models'
+import { MStreamingPlaylist, MStreamingPlaylistFilesVideo, MVideo } from '@server/types/models'
 import { sha256 } from '@shared/extra-utils'
 import { VideoStorage } from '@shared/models'
 import { getAudioStreamCodec, getVideoStreamCodec, getVideoStreamDimensionsInfo } from '../helpers/ffmpeg'
@@ -14,7 +15,7 @@ import { sequelizeTypescript } from '../initializers/database'
 import { VideoFileModel } from '../models/video/video-file'
 import { VideoStreamingPlaylistModel } from '../models/video/video-streaming-playlist'
 import { storeHLSFile } from './object-storage'
-import { getHlsResolutionPlaylistFilename } from './paths'
+import { generateHLSMasterPlaylistFilename, generateHlsSha256SegmentsFilename, getHlsResolutionPlaylistFilename } from './paths'
 import { VideoPathManager } from './video-path-manager'
 
 async function updateStreamingPlaylistsInfohashesIfNeeded () {
@@ -33,80 +34,123 @@ async function updateStreamingPlaylistsInfohashesIfNeeded () {
   }
 }
 
-async function updateMasterHLSPlaylist (video: MVideo, playlist: MStreamingPlaylistFilesVideo) {
-  const masterPlaylists: string[] = [ '#EXTM3U', '#EXT-X-VERSION:3' ]
+async function updatePlaylistAfterFileChange (video: MVideo, playlist: MStreamingPlaylist) {
+  let playlistWithFiles = await updateMasterHLSPlaylist(video, playlist)
+  playlistWithFiles = await updateSha256VODSegments(video, playlist)
 
-  for (const file of playlist.VideoFiles) {
-    const playlistFilename = getHlsResolutionPlaylistFilename(file.filename)
+  // Refresh playlist, operations can take some time
+  playlistWithFiles = await VideoStreamingPlaylistModel.loadWithVideoAndFiles(playlist.id)
+  playlistWithFiles.assignP2PMediaLoaderInfoHashes(video, playlistWithFiles.VideoFiles)
+  await playlistWithFiles.save()
 
-    await VideoPathManager.Instance.makeAvailableVideoFile(file.withVideoOrPlaylist(playlist), async videoFilePath => {
-      const size = await getVideoStreamDimensionsInfo(videoFilePath)
+  video.setHLSPlaylist(playlistWithFiles)
+}
 
-      const bandwidth = 'BANDWIDTH=' + video.getBandwidthBits(file)
-      const resolution = `RESOLUTION=${size?.width || 0}x${size?.height || 0}`
+// ---------------------------------------------------------------------------
 
-      let line = `#EXT-X-STREAM-INF:${bandwidth},${resolution}`
-      if (file.fps) line += ',FRAME-RATE=' + file.fps
+// Avoid concurrency issues when updating streaming playlist files
+const playlistFilesQueue = new PQueue({ concurrency: 1 })
 
-      const codecs = await Promise.all([
-        getVideoStreamCodec(videoFilePath),
-        getAudioStreamCodec(videoFilePath)
-      ])
+function updateMasterHLSPlaylist (video: MVideo, playlistArg: MStreamingPlaylist): Promise<MStreamingPlaylistFilesVideo> {
+  return playlistFilesQueue.add(async () => {
+    const playlist = await VideoStreamingPlaylistModel.loadWithVideoAndFiles(playlistArg.id)
 
-      line += `,CODECS="${codecs.filter(c => !!c).join(',')}"`
+    const masterPlaylists: string[] = [ '#EXTM3U', '#EXT-X-VERSION:3' ]
 
-      masterPlaylists.push(line)
-      masterPlaylists.push(playlistFilename)
-    })
-  }
+    for (const file of playlist.VideoFiles) {
+      const playlistFilename = getHlsResolutionPlaylistFilename(file.filename)
+
+      await VideoPathManager.Instance.makeAvailableVideoFile(file.withVideoOrPlaylist(playlist), async videoFilePath => {
+        const size = await getVideoStreamDimensionsInfo(videoFilePath)
+
+        const bandwidth = 'BANDWIDTH=' + video.getBandwidthBits(file)
+        const resolution = `RESOLUTION=${size?.width || 0}x${size?.height || 0}`
+
+        let line = `#EXT-X-STREAM-INF:${bandwidth},${resolution}`
+        if (file.fps) line += ',FRAME-RATE=' + file.fps
+
+        const codecs = await Promise.all([
+          getVideoStreamCodec(videoFilePath),
+          getAudioStreamCodec(videoFilePath)
+        ])
 
-  await VideoPathManager.Instance.makeAvailablePlaylistFile(playlist, playlist.playlistFilename, async masterPlaylistPath => {
+        line += `,CODECS="${codecs.filter(c => !!c).join(',')}"`
+
+        masterPlaylists.push(line)
+        masterPlaylists.push(playlistFilename)
+      })
+    }
+
+    if (playlist.playlistFilename) {
+      await video.removeStreamingPlaylistFile(playlist, playlist.playlistFilename)
+    }
+    playlist.playlistFilename = generateHLSMasterPlaylistFilename(video.isLive)
+
+    const masterPlaylistPath = VideoPathManager.Instance.getFSHLSOutputPath(video, playlist.playlistFilename)
     await writeFile(masterPlaylistPath, masterPlaylists.join('\n') + '\n')
 
     if (playlist.storage === VideoStorage.OBJECT_STORAGE) {
-      await storeHLSFile(playlist, playlist.playlistFilename, masterPlaylistPath)
+      playlist.playlistUrl = await storeHLSFile(playlist, playlist.playlistFilename)
+      await remove(masterPlaylistPath)
     }
+
+    return playlist.save()
   })
 }
 
-async function updateSha256VODSegments (video: MVideoUUID, playlist: MStreamingPlaylistFilesVideo) {
-  const json: { [filename: string]: { [range: string]: string } } = {}
+// ---------------------------------------------------------------------------
+
+async function updateSha256VODSegments (video: MVideo, playlistArg: MStreamingPlaylist): Promise<MStreamingPlaylistFilesVideo> {
+  return playlistFilesQueue.add(async () => {
+    const json: { [filename: string]: { [range: string]: string } } = {}
 
-  // For all the resolutions available for this video
-  for (const file of playlist.VideoFiles) {
-    const rangeHashes: { [range: string]: string } = {}
-    const fileWithPlaylist = file.withVideoOrPlaylist(playlist)
+    const playlist = await VideoStreamingPlaylistModel.loadWithVideoAndFiles(playlistArg.id)
 
-    await VideoPathManager.Instance.makeAvailableVideoFile(fileWithPlaylist, videoPath => {
+    // For all the resolutions available for this video
+    for (const file of playlist.VideoFiles) {
+      const rangeHashes: { [range: string]: string } = {}
+      const fileWithPlaylist = file.withVideoOrPlaylist(playlist)
 
-      return VideoPathManager.Instance.makeAvailableResolutionPlaylistFile(fileWithPlaylist, async resolutionPlaylistPath => {
-        const playlistContent = await readFile(resolutionPlaylistPath)
-        const ranges = getRangesFromPlaylist(playlistContent.toString())
+      await VideoPathManager.Instance.makeAvailableVideoFile(fileWithPlaylist, videoPath => {
 
-        const fd = await open(videoPath, 'r')
-        for (const range of ranges) {
-          const buf = Buffer.alloc(range.length)
-          await read(fd, buf, 0, range.length, range.offset)
+        return VideoPathManager.Instance.makeAvailableResolutionPlaylistFile(fileWithPlaylist, async resolutionPlaylistPath => {
+          const playlistContent = await readFile(resolutionPlaylistPath)
+          const ranges = getRangesFromPlaylist(playlistContent.toString())
 
-          rangeHashes[`${range.offset}-${range.offset + range.length - 1}`] = sha256(buf)
-        }
-        await close(fd)
+          const fd = await open(videoPath, 'r')
+          for (const range of ranges) {
+            const buf = Buffer.alloc(range.length)
+            await read(fd, buf, 0, range.length, range.offset)
 
-        const videoFilename = file.filename
-        json[videoFilename] = rangeHashes
+            rangeHashes[`${range.offset}-${range.offset + range.length - 1}`] = sha256(buf)
+          }
+          await close(fd)
+
+          const videoFilename = file.filename
+          json[videoFilename] = rangeHashes
+        })
       })
-    })
-  }
+    }
 
-  const outputPath = VideoPathManager.Instance.getFSHLSOutputPath(video, playlist.segmentsSha256Filename)
-  await outputJSON(outputPath, json)
+    if (playlist.segmentsSha256Filename) {
+      await video.removeStreamingPlaylistFile(playlist, playlist.segmentsSha256Filename)
+    }
+    playlist.segmentsSha256Filename = generateHlsSha256SegmentsFilename(video.isLive)
 
-  if (playlist.storage === VideoStorage.OBJECT_STORAGE) {
-    await storeHLSFile(playlist, playlist.segmentsSha256Filename)
-    await remove(outputPath)
-  }
+    const outputPath = VideoPathManager.Instance.getFSHLSOutputPath(video, playlist.segmentsSha256Filename)
+    await outputJSON(outputPath, json)
+
+    if (playlist.storage === VideoStorage.OBJECT_STORAGE) {
+      playlist.segmentsSha256Url = await storeHLSFile(playlist, playlist.segmentsSha256Filename)
+      await remove(outputPath)
+    }
+
+    return playlist.save()
+  })
 }
 
+// ---------------------------------------------------------------------------
+
 async function buildSha256Segment (segmentPath: string) {
   const buf = await readFile(segmentPath)
   return sha256(buf)
@@ -190,7 +234,8 @@ export {
   updateSha256VODSegments,
   buildSha256Segment,
   downloadPlaylistSegments,
-  updateStreamingPlaylistsInfohashesIfNeeded
+  updateStreamingPlaylistsInfohashesIfNeeded,
+  updatePlaylistAfterFileChange
 }
 
 // ---------------------------------------------------------------------------
diff --git a/server/lib/job-queue/handlers/video-file-import.ts b/server/lib/job-queue/handlers/video-file-import.ts
index 1c600e2a7..71c5444af 100644
--- a/server/lib/job-queue/handlers/video-file-import.ts
+++ b/server/lib/job-queue/handlers/video-file-import.ts
@@ -55,7 +55,7 @@ async function updateVideoFile (video: MVideoFullLight, inputFilePath: string) {
 
   if (currentVideoFile) {
     // Remove old file and old torrent
-    await video.removeWebTorrentFileAndTorrent(currentVideoFile)
+    await video.removeWebTorrentFile(currentVideoFile)
     // Remove the old video file from the array
     video.VideoFiles = video.VideoFiles.filter(f => f !== currentVideoFile)
 
diff --git a/server/lib/job-queue/handlers/video-studio-edition.ts b/server/lib/job-queue/handlers/video-studio-edition.ts
index 434d0ffe8..735150d57 100644
--- a/server/lib/job-queue/handlers/video-studio-edition.ts
+++ b/server/lib/job-queue/handlers/video-studio-edition.ts
@@ -9,6 +9,7 @@ import { generateWebTorrentVideoFilename } from '@server/lib/paths'
 import { VideoTranscodingProfilesManager } from '@server/lib/transcoding/default-transcoding-profiles'
 import { isAbleToUploadVideo } from '@server/lib/user'
 import { addOptimizeOrMergeAudioJob } from '@server/lib/video'
+import { removeHLSPlaylist, removeWebTorrentFile } from '@server/lib/video-file'
 import { VideoPathManager } from '@server/lib/video-path-manager'
 import { approximateIntroOutroAdditionalSize } from '@server/lib/video-studio'
 import { UserModel } from '@server/models/user/user'
@@ -27,12 +28,12 @@ import {
 } from '@shared/extra-utils'
 import {
   VideoStudioEditionPayload,
-  VideoStudioTaskPayload,
+  VideoStudioTask,
   VideoStudioTaskCutPayload,
   VideoStudioTaskIntroPayload,
   VideoStudioTaskOutroPayload,
-  VideoStudioTaskWatermarkPayload,
-  VideoStudioTask
+  VideoStudioTaskPayload,
+  VideoStudioTaskWatermarkPayload
 } from '@shared/models'
 import { logger, loggerTagsFactory } from '../../../helpers/logger'
 
@@ -89,7 +90,6 @@ async function processVideoStudioEdition (job: Job) {
   await move(editionResultPath, outputPath)
 
   await createTorrentAndSetInfoHashFromPath(video, newFile, outputPath)
-
   await removeAllFiles(video, newFile)
 
   await newFile.save()
@@ -197,18 +197,12 @@ async function buildNewFile (video: MVideoId, path: string) {
 }
 
 async function removeAllFiles (video: MVideoWithAllFiles, webTorrentFileException: MVideoFile) {
-  const hls = video.getHLSPlaylist()
-
-  if (hls) {
-    await video.removeStreamingPlaylistFiles(hls)
-    await hls.destroy()
-  }
+  await removeHLSPlaylist(video)
 
   for (const file of video.VideoFiles) {
     if (file.id === webTorrentFileException.id) continue
 
-    await video.removeWebTorrentFileAndTorrent(file)
-    await file.destroy()
+    await removeWebTorrentFile(video, file.id)
   }
 }
 
diff --git a/server/lib/job-queue/handlers/video-transcoding.ts b/server/lib/job-queue/handlers/video-transcoding.ts
index 5afca65ca..1b34ced14 100644
--- a/server/lib/job-queue/handlers/video-transcoding.ts
+++ b/server/lib/job-queue/handlers/video-transcoding.ts
@@ -149,7 +149,7 @@ async function onHlsPlaylistGeneration (video: MVideoFullLight, user: MUser, pay
   if (payload.isMaxQuality && payload.autoDeleteWebTorrentIfNeeded && CONFIG.TRANSCODING.WEBTORRENT.ENABLED === false) {
     // Remove webtorrent files if not enabled
     for (const file of video.VideoFiles) {
-      await video.removeWebTorrentFileAndTorrent(file)
+      await video.removeWebTorrentFile(file)
       await file.destroy()
     }
 
diff --git a/server/lib/transcoding/transcoding.ts b/server/lib/transcoding/transcoding.ts
index 69a973fbd..924141d1c 100644
--- a/server/lib/transcoding/transcoding.ts
+++ b/server/lib/transcoding/transcoding.ts
@@ -5,9 +5,8 @@ import { toEven } from '@server/helpers/core-utils'
 import { retryTransactionWrapper } from '@server/helpers/database-utils'
 import { createTorrentAndSetInfoHash } from '@server/helpers/webtorrent'
 import { sequelizeTypescript } from '@server/initializers/database'
-import { MStreamingPlaylistFilesVideo, MVideo, MVideoFile, MVideoFullLight } from '@server/types/models'
+import { MVideo, MVideoFile, MVideoFullLight } from '@server/types/models'
 import { VideoResolution, VideoStorage } from '../../../shared/models/videos'
-import { VideoStreamingPlaylistType } from '../../../shared/models/videos/video-streaming-playlist.type'
 import {
   buildFileMetadata,
   canDoQuickTranscode,
@@ -18,17 +17,10 @@ import {
   TranscodeVODOptionsType
 } from '../../helpers/ffmpeg'
 import { CONFIG } from '../../initializers/config'
-import { P2P_MEDIA_LOADER_PEER_VERSION } from '../../initializers/constants'
 import { VideoFileModel } from '../../models/video/video-file'
 import { VideoStreamingPlaylistModel } from '../../models/video/video-streaming-playlist'
-import { updateMasterHLSPlaylist, updateSha256VODSegments } from '../hls'
-import {
-  generateHLSMasterPlaylistFilename,
-  generateHlsSha256SegmentsFilename,
-  generateHLSVideoFilename,
-  generateWebTorrentVideoFilename,
-  getHlsResolutionPlaylistFilename
-} from '../paths'
+import { updatePlaylistAfterFileChange } from '../hls'
+import { generateHLSVideoFilename, generateWebTorrentVideoFilename, getHlsResolutionPlaylistFilename } from '../paths'
 import { VideoPathManager } from '../video-path-manager'
 import { VideoTranscodingProfilesManager } from './default-transcoding-profiles'
 
@@ -260,7 +252,7 @@ async function onWebTorrentVideoFileTranscoding (
   await createTorrentAndSetInfoHash(video, videoFile)
 
   const oldFile = await VideoFileModel.loadWebTorrentFile({ videoId: video.id, fps: videoFile.fps, resolution: videoFile.resolution })
-  if (oldFile) await video.removeWebTorrentFileAndTorrent(oldFile)
+  if (oldFile) await video.removeWebTorrentFile(oldFile)
 
   await VideoFileModel.customUpsert(videoFile, 'video', undefined)
   video.VideoFiles = await video.$get('VideoFiles')
@@ -314,35 +306,15 @@ async function generateHlsPlaylistCommon (options: {
   await transcodeVOD(transcodeOptions)
 
   // Create or update the playlist
-  const { playlist, oldPlaylistFilename, oldSegmentsSha256Filename } = await retryTransactionWrapper(() => {
+  const playlist = await retryTransactionWrapper(() => {
     return sequelizeTypescript.transaction(async transaction => {
-      const playlist = await VideoStreamingPlaylistModel.loadOrGenerate(video, transaction)
-
-      const oldPlaylistFilename = playlist.playlistFilename
-      const oldSegmentsSha256Filename = playlist.segmentsSha256Filename
-
-      playlist.playlistFilename = generateHLSMasterPlaylistFilename(video.isLive)
-      playlist.segmentsSha256Filename = generateHlsSha256SegmentsFilename(video.isLive)
-
-      playlist.p2pMediaLoaderInfohashes = []
-      playlist.p2pMediaLoaderPeerVersion = P2P_MEDIA_LOADER_PEER_VERSION
-
-      playlist.type = VideoStreamingPlaylistType.HLS
-
-      await playlist.save({ transaction })
-
-      return { playlist, oldPlaylistFilename, oldSegmentsSha256Filename }
+      return VideoStreamingPlaylistModel.loadOrGenerate(video, transaction)
     })
   })
 
-  if (oldPlaylistFilename) await video.removeStreamingPlaylistFile(playlist, oldPlaylistFilename)
-  if (oldSegmentsSha256Filename) await video.removeStreamingPlaylistFile(playlist, oldSegmentsSha256Filename)
-
-  // Build the new playlist file
-  const extname = extnameUtil(videoFilename)
   const newVideoFile = new VideoFileModel({
     resolution,
-    extname,
+    extname: extnameUtil(videoFilename),
     size: 0,
     filename: videoFilename,
     fps: -1,
@@ -350,8 +322,6 @@ async function generateHlsPlaylistCommon (options: {
   })
 
   const videoFilePath = VideoPathManager.Instance.getFSVideoFileOutputPath(playlist, newVideoFile)
-
-  // Move files from tmp transcoded directory to the appropriate place
   await ensureDir(VideoPathManager.Instance.getFSHLSOutputPath(video))
 
   // Move playlist file
@@ -369,21 +339,14 @@ async function generateHlsPlaylistCommon (options: {
   await createTorrentAndSetInfoHash(playlist, newVideoFile)
 
   const oldFile = await VideoFileModel.loadHLSFile({ playlistId: playlist.id, fps: newVideoFile.fps, resolution: newVideoFile.resolution })
-  if (oldFile) await video.removeStreamingPlaylistVideoFile(playlist, oldFile)
+  if (oldFile) {
+    await video.removeStreamingPlaylistVideoFile(playlist, oldFile)
+    await oldFile.destroy()
+  }
 
   const savedVideoFile = await VideoFileModel.customUpsert(newVideoFile, 'streaming-playlist', undefined)
 
-  const playlistWithFiles = playlist as MStreamingPlaylistFilesVideo
-  playlistWithFiles.VideoFiles = await playlist.$get('VideoFiles')
-  playlist.assignP2PMediaLoaderInfoHashes(video, playlistWithFiles.VideoFiles)
-  playlist.storage = VideoStorage.FILE_SYSTEM
-
-  await playlist.save()
-
-  video.setHLSPlaylist(playlist)
-
-  await updateMasterHLSPlaylist(video, playlistWithFiles)
-  await updateSha256VODSegments(video, playlistWithFiles)
+  await updatePlaylistAfterFileChange(video, playlist)
 
   return { resolutionPlaylistPath, videoFile: savedVideoFile }
 }
diff --git a/server/lib/video-file.ts b/server/lib/video-file.ts
new file mode 100644
index 000000000..2ab7190f1
--- /dev/null
+++ b/server/lib/video-file.ts
@@ -0,0 +1,69 @@
+import { logger } from '@server/helpers/logger'
+import { MVideoWithAllFiles } from '@server/types/models'
+import { lTags } from './object-storage/shared'
+
+async function removeHLSPlaylist (video: MVideoWithAllFiles) {
+  const hls = video.getHLSPlaylist()
+  if (!hls) return
+
+  await video.removeStreamingPlaylistFiles(hls)
+  await hls.destroy()
+
+  video.VideoStreamingPlaylists = video.VideoStreamingPlaylists.filter(p => p.id !== hls.id)
+}
+
+async function removeHLSFile (video: MVideoWithAllFiles, fileToDeleteId: number) {
+  logger.info('Deleting HLS file %d of %s.', fileToDeleteId, video.url, lTags(video.uuid))
+
+  const hls = video.getHLSPlaylist()
+  const files = hls.VideoFiles
+
+  if (files.length === 1) {
+    await removeHLSPlaylist(video)
+    return undefined
+  }
+
+  const toDelete = files.find(f => f.id === fileToDeleteId)
+  await video.removeStreamingPlaylistVideoFile(video.getHLSPlaylist(), toDelete)
+  await toDelete.destroy()
+
+  hls.VideoFiles = hls.VideoFiles.filter(f => f.id !== toDelete.id)
+
+  return hls
+}
+
+// ---------------------------------------------------------------------------
+
+async function removeAllWebTorrentFiles (video: MVideoWithAllFiles) {
+  for (const file of video.VideoFiles) {
+    await video.removeWebTorrentFile(file)
+    await file.destroy()
+  }
+
+  video.VideoFiles = []
+
+  return video
+}
+
+async function removeWebTorrentFile (video: MVideoWithAllFiles, fileToDeleteId: number) {
+  const files = video.VideoFiles
+
+  if (files.length === 1) {
+    return removeAllWebTorrentFiles(video)
+  }
+
+  const toDelete = files.find(f => f.id === fileToDeleteId)
+  await video.removeWebTorrentFile(toDelete)
+  await toDelete.destroy()
+
+  video.VideoFiles = files.filter(f => f.id !== toDelete.id)
+
+  return video
+}
+
+export {
+  removeHLSPlaylist,
+  removeHLSFile,
+  removeAllWebTorrentFiles,
+  removeWebTorrentFile
+}