atomically 1.7.0 → 2.0.0

package/src/utils/fs.ts

@@ -1,51 +0,0 @@
-
-/* IMPORT */
-
-import * as fs from 'fs';
-import {promisify} from 'util';
-import {attemptifyAsync, attemptifySync} from './attemptify';
-import Handlers from './fs_handlers';
-import {retryifyAsync, retryifySync} from './retryify';
-
-/* FS */
-
-const FS = {
-
-  chmodAttempt: attemptifyAsync ( promisify ( fs.chmod ), Handlers.onChangeError ),
-  chownAttempt: attemptifyAsync ( promisify ( fs.chown ), Handlers.onChangeError ),
-  closeAttempt: attemptifyAsync ( promisify ( fs.close ) ),
-  fsyncAttempt: attemptifyAsync ( promisify ( fs.fsync ) ),
-  mkdirAttempt: attemptifyAsync ( promisify ( fs.mkdir ) ),
-  realpathAttempt: attemptifyAsync ( promisify ( fs.realpath ) ),
-  statAttempt: attemptifyAsync ( promisify ( fs.stat ) ),
-  unlinkAttempt: attemptifyAsync ( promisify ( fs.unlink ) ),
-
-  closeRetry: retryifyAsync ( promisify ( fs.close ), Handlers.isRetriableError ),
-  fsyncRetry: retryifyAsync ( promisify ( fs.fsync ), Handlers.isRetriableError ),
-  openRetry: retryifyAsync ( promisify ( fs.open ), Handlers.isRetriableError ),
-  readFileRetry: retryifyAsync ( promisify ( fs.readFile ), Handlers.isRetriableError ),
-  renameRetry: retryifyAsync ( promisify ( fs.rename ), Handlers.isRetriableError ),
-  statRetry: retryifyAsync ( promisify ( fs.stat ), Handlers.isRetriableError ),
-  writeRetry: retryifyAsync ( promisify ( fs.write ), Handlers.isRetriableError ),
-
-  chmodSyncAttempt: attemptifySync ( fs.chmodSync, Handlers.onChangeError ),
-  chownSyncAttempt: attemptifySync ( fs.chownSync, Handlers.onChangeError ),
-  closeSyncAttempt: attemptifySync ( fs.closeSync ),
-  mkdirSyncAttempt: attemptifySync ( fs.mkdirSync ),
-  realpathSyncAttempt: attemptifySync ( fs.realpathSync ),
-  statSyncAttempt: attemptifySync ( fs.statSync ),
-  unlinkSyncAttempt: attemptifySync ( fs.unlinkSync ),
-
-  closeSyncRetry: retryifySync ( fs.closeSync, Handlers.isRetriableError ),
-  fsyncSyncRetry: retryifySync ( fs.fsyncSync, Handlers.isRetriableError ),
-  openSyncRetry: retryifySync ( fs.openSync, Handlers.isRetriableError ),
-  readFileSyncRetry: retryifySync ( fs.readFileSync, Handlers.isRetriableError ),
-  renameSyncRetry: retryifySync ( fs.renameSync, Handlers.isRetriableError ),
-  statSyncRetry: retryifySync ( fs.statSync, Handlers.isRetriableError ),
-  writeSyncRetry: retryifySync ( fs.writeSync, Handlers.isRetriableError )
-
-};
-
-/* EXPORT */
-
-export default FS;

package/src/utils/fs_handlers.ts

@@ -1,45 +0,0 @@
-
-/* IMPORT */
-
-import {IS_USER_ROOT} from '../consts';
-import {Exception} from '../types';
-
-/* FS HANDLERS */
-
-const Handlers = {
-
-  isChangeErrorOk: ( error: Exception ): boolean => { //URL: https://github.com/isaacs/node-graceful-fs/blob/master/polyfills.js#L315-L342
-
-    const {code} = error;
-
-    if ( code === 'ENOSYS' ) return true;
-
-    if ( !IS_USER_ROOT && ( code === 'EINVAL' || code === 'EPERM' ) ) return true;
-
-    return false;
-
-  },
-
-  isRetriableError: ( error: Exception ): boolean => {
-
-    const {code} = error;
-
-    if ( code === 'EMFILE' || code === 'ENFILE' || code === 'EAGAIN' || code === 'EBUSY' || code === 'EACCESS' || code === 'EACCS' || code === 'EPERM' ) return true;
-
-    return false;
-
-  },
-
-  onChangeError: ( error: Exception ): void => {
-
-    if ( Handlers.isChangeErrorOk ( error ) ) return;
-
-    throw error;
-
-  }
-
-};
-
-/* EXPORT */
-
-export default Handlers;

package/src/utils/retryify.ts

@@ -1,78 +0,0 @@
-
-/* IMPORT */
-
-import {Exception, FN} from '../types';
-import RetryfyQueue from './retryify_queue';
-
-/* RETRYIFY */
-
-const retryifyAsync = <T extends FN> ( fn: T, isRetriableError: FN<[Exception], boolean | void> ): FN<[number], T> => {
-
-  return function ( timestamp: number ) {
-
-    return function attempt () {
-
-      return RetryfyQueue.schedule ().then ( cleanup => {
-
-        return fn.apply ( undefined, arguments ).then ( result => {
-
-          cleanup ();
-
-          return result;
-
-        }, error => {
-
-          cleanup ();
-
-          if ( Date.now () >= timestamp ) throw error;
-
-          if ( isRetriableError ( error ) ) {
-
-            const delay = Math.round ( 100 + ( 400 * Math.random () ) ),
-                  delayPromise = new Promise ( resolve => setTimeout ( resolve, delay ) );
-
-            return delayPromise.then ( () => attempt.apply ( undefined, arguments ) );
-
-          }
-
-          throw error;
-
-        });
-
-      });
-
-    } as T;
-
-  };
-
-};
-
-const retryifySync = <T extends FN> ( fn: T, isRetriableError: FN<[Exception], boolean | void> ): FN<[number], T> => {
-
-  return function ( timestamp: number ) {
-
-    return function attempt () {
-
-      try {
-
-        return fn.apply ( undefined, arguments );
-
-      } catch ( error ) {
-
-        if ( Date.now () > timestamp ) throw error;
-
-        if ( isRetriableError ( error ) ) return attempt.apply ( undefined, arguments );
-
-        throw error;
-
-      }
-
-    } as T;
-
-  };
-
-};
-
-/* EXPORT */
-
-export {retryifyAsync, retryifySync};

package/src/utils/retryify_queue.ts

@@ -1,95 +0,0 @@
-
-/* IMPORT */
-
-import {LIMIT_FILES_DESCRIPTORS} from '../consts';
-
-/* RETRYIFY QUEUE */
-
-const RetryfyQueue = {
-
-  interval: 25,
-  intervalId: <NodeJS.Timeout | undefined> undefined,
-  limit: LIMIT_FILES_DESCRIPTORS,
-  queueActive: new Set<Function> (),
-  queueWaiting: new Set<Function> (),
-
-  init: (): void => {
-
-    if ( RetryfyQueue.intervalId ) return;
-
-    RetryfyQueue.intervalId = setInterval ( RetryfyQueue.tick, RetryfyQueue.interval );
-
-  },
-
-  reset: (): void => {
-
-    if ( !RetryfyQueue.intervalId ) return;
-
-    clearInterval ( RetryfyQueue.intervalId );
-
-    delete RetryfyQueue.intervalId;
-
-  },
-
-  add: ( fn: Function ): void => {
-
-    RetryfyQueue.queueWaiting.add ( fn );
-
-    if ( RetryfyQueue.queueActive.size < ( RetryfyQueue.limit / 2 ) ) { // Active queue not under preassure, executing immediately
-
-      RetryfyQueue.tick ();
-
-    } else {
-
-      RetryfyQueue.init ();
-
-    }
-
-  },
-
-  remove: ( fn: Function ): void => {
-
-    RetryfyQueue.queueWaiting.delete ( fn );
-
-    RetryfyQueue.queueActive.delete ( fn );
-
-  },
-
-  schedule: (): Promise<Function> => {
-
-    return new Promise ( resolve => {
-
-      const cleanup = () => RetryfyQueue.remove ( resolver );
-
-      const resolver = () => resolve ( cleanup );
-
-      RetryfyQueue.add ( resolver );
-
-    });
-
-  },
-
-  tick: (): void => {
-
-    if ( RetryfyQueue.queueActive.size >= RetryfyQueue.limit ) return;
-
-    if ( !RetryfyQueue.queueWaiting.size ) return RetryfyQueue.reset ();
-
-    for ( const fn of RetryfyQueue.queueWaiting ) {
-
-      if ( RetryfyQueue.queueActive.size >= RetryfyQueue.limit ) break;
-
-      RetryfyQueue.queueWaiting.delete ( fn );
-      RetryfyQueue.queueActive.add ( fn );
-
-      fn ();
-
-    }
-
-  }
-
-};
-
-/* EXPORT */
-
-export default RetryfyQueue;