Correctly migrate to fs-extra

6 files changed, 15 insertions, 36 deletions

diff --git a/server/helpers/captions-utils.ts b/server/helpers/captions-utils.ts
index 20c9fe5aa..660dce65c 100644
--- a/server/helpers/captions-utils.ts
+++ b/server/helpers/captions-utils.ts
@@ -1,9 +1,8 @@
-import { renamePromise, unlinkPromise } from './core-utils'
 import { join } from 'path'
 import { CONFIG } from '../initializers'
 import { VideoCaptionModel } from '../models/video/video-caption'
 import * as srt2vtt from 'srt-to-vtt'
-import { createReadStream, createWriteStream } from 'fs-extra'
+import { createReadStream, createWriteStream, remove, rename } from 'fs-extra'
 
 async function moveAndProcessCaptionFile (physicalFile: { filename: string, path: string }, videoCaption: VideoCaptionModel) {
   const videoCaptionsDir = CONFIG.STORAGE.CAPTIONS_DIR
@@ -12,9 +11,9 @@ async function moveAndProcessCaptionFile (physicalFile: { filename: string, path
   // Convert this srt file to vtt
   if (physicalFile.path.endsWith('.srt')) {
     await convertSrtToVtt(physicalFile.path, destination)
-    await unlinkPromise(physicalFile.path)
+    await remove(physicalFile.path)
   } else { // Just move the vtt file
-    await renamePromise(physicalFile.path, destination)
+    await rename(physicalFile.path, destination)
   }
 
   // This is important in case if there is another attempt in the retry process
diff --git a/server/helpers/core-utils.ts b/server/helpers/core-utils.ts
index 9830d41a8..f5ef187fe 100644
--- a/server/helpers/core-utils.ts
+++ b/server/helpers/core-utils.ts
@@ -6,7 +6,6 @@
 import * as bcrypt from 'bcrypt'
 import * as createTorrent from 'create-torrent'
 import { createHash, pseudoRandomBytes } from 'crypto'
-import { copyFile, readdir, readFile, rename, stat, Stats, unlink, writeFile, mkdirp } from 'fs-extra'
 import { isAbsolute, join } from 'path'
 import * as pem from 'pem'
 import * as rimraf from 'rimraf'
@@ -168,14 +167,6 @@ function promisify2WithVoid<T, U> (func: (arg1: T, arg2: U, cb: (err: any) => vo
   }
 }
 
-const copyFilePromise = promisify2WithVoid<string, string>(copyFile)
-const readFileBufferPromise = promisify1<string, Buffer>(readFile)
-const unlinkPromise = promisify1WithVoid<string>(unlink)
-const renamePromise = promisify2WithVoid<string, string>(rename)
-const writeFilePromise = promisify2WithVoid<string, any>(writeFile)
-const readdirPromise = promisify1<string, string[]>(readdir)
-const mkdirpPromise = promisify1<string, string>(mkdirp)
-// we cannot modify the Promise types, so we should make the promisify instance check mkdirp
 const pseudoRandomBytesPromise = promisify1<number, Buffer>(pseudoRandomBytes)
 const createPrivateKey = promisify1<number, { key: string }>(pem.createPrivateKey)
 const getPublicKey = promisify1<string, { publicKey: string }>(pem.getPublicKey)
@@ -183,8 +174,6 @@ const bcryptComparePromise = promisify2<any, string, boolean>(bcrypt.compare)
 const bcryptGenSaltPromise = promisify1<number, string>(bcrypt.genSalt)
 const bcryptHashPromise = promisify2<any, string | number, string>(bcrypt.hash)
 const createTorrentPromise = promisify2<string, any, any>(createTorrent)
-const rimrafPromise = promisify1WithVoid<string>(rimraf)
-const statPromise = promisify1<string, Stats>(stat)
 
 // ---------------------------------------------------------------------------
 
@@ -202,20 +191,11 @@ export {
   promisify0,
   promisify1,
 
-  copyFilePromise,
-  readdirPromise,
-  readFileBufferPromise,
-  unlinkPromise,
-  renamePromise,
-  writeFilePromise,
-  mkdirpPromise,
   pseudoRandomBytesPromise,
   createPrivateKey,
   getPublicKey,
   bcryptComparePromise,
   bcryptGenSaltPromise,
   bcryptHashPromise,
-  createTorrentPromise,
-  rimrafPromise,
-  statPromise
+  createTorrentPromise
 }
diff --git a/server/helpers/ffmpeg-utils.ts b/server/helpers/ffmpeg-utils.ts
index 8936005e0..7c45f3632 100644
--- a/server/helpers/ffmpeg-utils.ts
+++ b/server/helpers/ffmpeg-utils.ts
@@ -1,11 +1,11 @@
 import * as ffmpeg from 'fluent-ffmpeg'
 import { join } from 'path'
 import { VideoResolution } from '../../shared/models/videos'
-import { CONFIG, VIDEO_TRANSCODING_FPS, FFMPEG_NICE } from '../initializers'
-import { unlinkPromise } from './core-utils'
+import { CONFIG, FFMPEG_NICE, VIDEO_TRANSCODING_FPS } from '../initializers'
 import { processImage } from './image-utils'
 import { logger } from './logger'
 import { checkFFmpegEncoders } from '../initializers/checker'
+import { remove } from 'fs-extra'
 
 function computeResolutionsToTranscode (videoFileHeight: number) {
   const resolutionsEnabled: number[] = []
@@ -90,7 +90,7 @@ async function generateImageFromVideoFile (fromPath: string, folder: string, ima
     logger.error('Cannot generate image from video %s.', fromPath, { err })
 
     try {
-      await unlinkPromise(pendingImagePath)
+      await remove(pendingImagePath)
     } catch (err) {
       logger.debug('Cannot remove pending image path after generation error.', { err })
     }
diff --git a/server/helpers/image-utils.ts b/server/helpers/image-utils.ts
index 0065f4210..3eaa674ed 100644
--- a/server/helpers/image-utils.ts
+++ b/server/helpers/image-utils.ts
@@ -1,6 +1,6 @@
 import 'multer'
 import * as sharp from 'sharp'
-import { unlinkPromise } from './core-utils'
+import { remove } from 'fs-extra'
 
 async function processImage (
   physicalFile: { path: string },
@@ -11,7 +11,7 @@ async function processImage (
     .resize(newSize.width, newSize.height)
     .toFile(destination)
 
-  await unlinkPromise(physicalFile.path)
+  await remove(physicalFile.path)
 }
 
 // ---------------------------------------------------------------------------
diff --git a/server/helpers/utils.ts b/server/helpers/utils.ts
index 703e57887..a1ed8e72d 100644
--- a/server/helpers/utils.ts
+++ b/server/helpers/utils.ts
@@ -2,13 +2,14 @@ import { ResultList } from '../../shared'
 import { CONFIG } from '../initializers'
 import { ActorModel } from '../models/activitypub/actor'
 import { ApplicationModel } from '../models/application/application'
-import { pseudoRandomBytesPromise, sha256, unlinkPromise } from './core-utils'
+import { pseudoRandomBytesPromise, sha256 } from './core-utils'
 import { logger } from './logger'
 import { join } from 'path'
 import { Instance as ParseTorrent } from 'parse-torrent'
+import { remove } from 'fs-extra'
 
 function deleteFileAsync (path: string) {
-  unlinkPromise(path)
+  remove(path)
     .catch(err => logger.error('Cannot delete the file %s asynchronously.', path, { err }))
 }
 
diff --git a/server/helpers/webtorrent.ts b/server/helpers/webtorrent.ts
index 1c0d00d70..1c0cc7058 100644
--- a/server/helpers/webtorrent.ts
+++ b/server/helpers/webtorrent.ts
@@ -1,10 +1,9 @@
 import { logger } from './logger'
 import { generateVideoTmpPath } from './utils'
 import * as WebTorrent from 'webtorrent'
-import { createWriteStream } from 'fs-extra'
+import { createWriteStream, remove } from 'fs-extra'
 import { CONFIG } from '../initializers'
 import { join } from 'path'
-import { unlinkPromise } from './core-utils'
 
 function downloadWebTorrentVideo (target: { magnetUri: string, torrentName: string }) {
   const id = target.magnetUri || target.torrentName
@@ -29,11 +28,11 @@ function downloadWebTorrentVideo (target: { magnetUri: string, torrentName: stri
           if (err) return rej(err)
 
           if (target.torrentName) {
-            unlinkPromise(torrentId)
+            remove(torrentId)
               .catch(err => logger.error('Cannot remove torrent %s in webtorrent download.', torrentId, { err }))
           }
 
-          unlinkPromise(join(CONFIG.STORAGE.VIDEOS_DIR, file.name))
+          remove(join(CONFIG.STORAGE.VIDEOS_DIR, file.name))
             .catch(err => logger.error('Cannot remove torrent file %s in webtorrent download.', file.name, { err }))
 
           res(path)