server/helpers/core-utils.ts

   1 /*
   2   Different from 'utils' because we don't not import other PeerTube modules.
   3   Useful to avoid circular dependencies.
   4 */
   5
   6 import { join } from 'path'
   7 import { pseudoRandomBytes } from 'crypto'
   8 import {
   9   readdir,
  10   readFile,
  11   rename,
  12   unlink,
  13   writeFile,
  14   access
  15 } from 'fs'
  16 import * as mkdirp from 'mkdirp'
  17 import * as bcrypt from 'bcrypt'
  18 import * as createTorrent from 'create-torrent'
  19 import * as rimraf from 'rimraf'
  20 import * as openssl from 'openssl-wrapper'
  21 import * as Promise from 'bluebird'
  22
  23 function isTestInstance () {
  24   return process.env.NODE_ENV === 'test'
  25 }
  26
  27 function root () {
  28   // We are in /helpers/utils.js
  29   const paths = [ __dirname, '..', '..' ]
  30
  31   // We are under /dist directory
  32   if (process.mainModule.filename.endsWith('.ts') === false) {
  33     paths.push('..')
  34   }
  35
  36   return join.apply(null, paths)
  37 }
  38
  39 function promisify0<A> (func: (cb: (err: any, result: A) => void) => void): () => Promise<A> {
  40   return function promisified (): Promise<A> {
  41     return new Promise<A>((resolve: (arg: A) => void, reject: (err: any) => void) => {
  42       func.apply(null, [ (err: any, res: A) => err ? reject(err) : resolve(res) ])
  43     })
  44   }
  45 }
  46
  47 // Thanks to https://gist.github.com/kumasento/617daa7e46f13ecdd9b2
  48 function promisify1<T, A> (func: (arg: T, cb: (err: any, result: A) => void) => void): (arg: T) => Promise<A> {
  49   return function promisified (arg: T): Promise<A> {
  50     return new Promise<A>((resolve: (arg: A) => void, reject: (err: any) => void) => {
  51       func.apply(null, [ arg, (err: any, res: A) => err ? reject(err) : resolve(res) ])
  52     })
  53   }
  54 }
  55
  56 function promisify1WithVoid<T> (func: (arg: T, cb: (err: any) => void) => void): (arg: T) => Promise<void> {
  57   return function promisified (arg: T): Promise<void> {
  58     return new Promise<void>((resolve: () => void, reject: (err: any) => void) => {
  59       func.apply(null, [ arg, (err: any) => err ? reject(err) : resolve() ])
  60     })
  61   }
  62 }
  63
  64 function promisify2<T, U, A> (func: (arg1: T, arg2: U, cb: (err: any, result: A) => void) => void): (arg1: T, arg2: U) => Promise<A> {
  65   return function promisified (arg1: T, arg2: U): Promise<A> {
  66     return new Promise<A>((resolve: (arg: A) => void, reject: (err: any) => void) => {
  67       func.apply(null, [ arg1, arg2, (err: any, res: A) => err ? reject(err) : resolve(res) ])
  68     })
  69   }
  70 }
  71
  72 function promisify2WithVoid<T, U> (func: (arg1: T, arg2: U, cb: (err: any) => void) => void): (arg1: T, arg2: U) => Promise<void> {
  73   return function promisified (arg1: T, arg2: U): Promise<void> {
  74     return new Promise<void>((resolve: () => void, reject: (err: any) => void) => {
  75       func.apply(null, [ arg1, arg2, (err: any) => err ? reject(err) : resolve() ])
  76     })
  77   }
  78 }
  79
  80 const readFilePromise = promisify2<string, string, string>(readFile)
  81 const readFileBufferPromise = promisify1<string, Buffer>(readFile)
  82 const unlinkPromise = promisify1WithVoid<string>(unlink)
  83 const renamePromise = promisify2WithVoid<string, string>(rename)
  84 const writeFilePromise = promisify2WithVoid<string, any>(writeFile)
  85 const readdirPromise = promisify1<string, string[]>(readdir)
  86 const mkdirpPromise = promisify1<string, string>(mkdirp)
  87 const pseudoRandomBytesPromise = promisify1<number, Buffer>(pseudoRandomBytes)
  88 const accessPromise = promisify1WithVoid<string|Buffer>(access)
  89 const opensslExecPromise = promisify2WithVoid<string, any>(openssl.exec)
  90 const bcryptComparePromise = promisify2<any, string, boolean>(bcrypt.compare)
  91 const bcryptGenSaltPromise = promisify1<number, string>(bcrypt.genSalt)
  92 const bcryptHashPromise = promisify2<any, string|number, string>(bcrypt.hash)
  93 const createTorrentPromise = promisify2<string, any, any>(createTorrent)
  94 const rimrafPromise = promisify1WithVoid<string>(rimraf)
  95
  96 // ---------------------------------------------------------------------------
  97
  98 export {
  99   isTestInstance,
 100   root,
 101
 102   promisify0,
 103   promisify1,
 104   readdirPromise,
 105   readFilePromise,
 106   readFileBufferPromise,
 107   unlinkPromise,
 108   renamePromise,
 109   writeFilePromise,
 110   mkdirpPromise,
 111   pseudoRandomBytesPromise,
 112   accessPromise,
 113   opensslExecPromise,
 114   bcryptComparePromise,
 115   bcryptGenSaltPromise,
 116   bcryptHashPromise,
 117   createTorrentPromise,
 118   rimrafPromise
 119 }