verdaccio/build/lib/storage.js

A lightweight private npm proxy registry

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _assert = _interopRequireDefault(require("assert"));

var _stream = _interopRequireDefault(require("stream"));

var _lodash = _interopRequireDefault(require("lodash"));

var _async = _interopRequireDefault(require("async"));

var _streams = require("@verdaccio/streams");

var _logger = require("../lib/logger");

var _upStorage = _interopRequireDefault(require("./up-storage"));

var _search = _interopRequireDefault(require("./search"));

var _constants = require("./constants");

var _localStorage = _interopRequireDefault(require("./local-storage"));

var _storageUtils = require("./storage-utils");

var _uplinkUtil = require("./uplink-util");

var _metadataUtils = require("./metadata-utils");

var _utils = require("./utils");

var _configUtils = require("./config-utils");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

class Storage {
  constructor(config) {
    _defineProperty(this, "localStorage", void 0);

    _defineProperty(this, "config", void 0);

    _defineProperty(this, "logger", void 0);

    _defineProperty(this, "uplinks", void 0);

    _defineProperty(this, "filters", void 0);

    this.config = config;
    this.uplinks = (0, _uplinkUtil.setupUpLinks)(config);
    this.logger = _logger.logger.child();
    this.filters = []; // @ts-ignore

    this.localStorage = null;
  }

  init(config, filters = []) {
    this.filters = filters;
    this.localStorage = new _localStorage.default(this.config, _logger.logger);
    return this.localStorage.getSecret(config);
  }
  /**
   *  Add a {name} package to a system
   Function checks if package with the same name is available from uplinks.
   If it isn't, we create package locally
   Used storages: local (write) && uplinks
   */


  async addPackage(name, metadata, callback) {
    try {
      await (0, _storageUtils.checkPackageLocal)(name, this.localStorage);
      await (0, _storageUtils.checkPackageRemote)(name, this._isAllowPublishOffline(), this._syncUplinksMetadata.bind(this));
      await (0, _storageUtils.publishPackage)(name, metadata, this.localStorage);
      callback();
    } catch (err) {
      callback(err);
    }
  }

  _isAllowPublishOffline() {
    return typeof this.config.publish !== 'undefined' && _lodash.default.isBoolean(this.config.publish.allow_offline) && this.config.publish.allow_offline;
  }

  readTokens(filter) {
    return this.localStorage.readTokens(filter);
  }

  saveToken(token) {
    return this.localStorage.saveToken(token);
  }

  deleteToken(user, tokenKey) {
    return this.localStorage.deleteToken(user, tokenKey);
  }
  /**
   * Add a new version of package {name} to a system
   Used storages: local (write)
   */


  addVersion(name, version, metadata, tag, callback) {
    this.localStorage.addVersion(name, version, metadata, tag, callback);
  }
  /**
   * Tags a package version with a provided tag
   Used storages: local (write)
   */


  mergeTags(name, tagHash, callback) {
    this.localStorage.mergeTags(name, tagHash, callback);
  }
  /**
   * Change an existing package (i.e. unpublish one version)
   Function changes a package info from local storage and all uplinks with write access./
   Used storages: local (write)
   */


  changePackage(name, metadata, revision, callback) {
    this.localStorage.changePackage(name, metadata, revision, callback);
  }
  /**
   * Remove a package from a system
   Function removes a package from local storage
   Used storages: local (write)
   */


  removePackage(name, callback) {
    this.localStorage.removePackage(name, callback); // update the indexer

    _search.default.remove(name);
  }
  /**
   Remove a tarball from a system
   Function removes a tarball from local storage.
   Tarball in question should not be linked to in any existing
   versions, i.e. package version should be unpublished first.
   Used storage: local (write)
   */


  removeTarball(name, filename, revision, callback) {
    this.localStorage.removeTarball(name, filename, revision, callback);
  }
  /**
   * Upload a tarball for {name} package
   Function is synchronous and returns a WritableStream
   Used storages: local (write)
   */


  addTarball(name, filename) {
    return this.localStorage.addTarball(name, filename);
  }
  /**
   Get a tarball from a storage for {name} package
   Function is synchronous and returns a ReadableStream
   Function tries to read tarball locally, if it fails then it reads package
   information in order to figure out where we can get this tarball from
   Used storages: local || uplink (just one)
   */


  getTarball(name, filename) {
    const readStream = new _streams.ReadTarball({});

    readStream.abort = function () {};

    const self = this; // if someone requesting tarball, it means that we should already have some
    // information about it, so fetching package info is unnecessary
    // trying local first
    // flow: should be IReadTarball

    let localStream = self.localStorage.getTarball(name, filename);
    let isOpen = false;
    localStream.on('error', err => {
      if (isOpen || err.status !== _constants.HTTP_STATUS.NOT_FOUND) {
        return readStream.emit('error', err);
      } // local reported 404


      const err404 = err;
      localStream.abort();
      localStream = null; // we force for garbage collector

      self.localStorage.getPackageMetadata(name, (err, info) => {
        if (_lodash.default.isNil(err) && info._distfiles && _lodash.default.isNil(info._distfiles[filename]) === false) {
          // information about this file exists locally
          serveFile(info._distfiles[filename]);
        } else {
          // we know nothing about this file, trying to get information elsewhere
          self._syncUplinksMetadata(name, info, {}, (err, info) => {
            if (_lodash.default.isNil(err) === false) {
              return readStream.emit('error', err);
            }

            if (_lodash.default.isNil(info._distfiles) || _lodash.default.isNil(info._distfiles[filename])) {
              return readStream.emit('error', err404);
            }

            serveFile(info._distfiles[filename]);
          });
        }
      });
    });
    localStream.on('content-length', function (v) {
      readStream.emit('content-length', v);
    });
    localStream.on('open', function () {
      isOpen = true;
      localStream.pipe(readStream);
    });
    return readStream;
    /**
     * Fetch and cache local/remote packages.
     * @param {Object} file define the package shape
     */

    function serveFile(file) {
      let uplink = null;

      for (const uplinkId in self.uplinks) {
        if ((0, _configUtils.hasProxyTo)(name, uplinkId, self.config.packages)) {
          uplink = self.uplinks[uplinkId];
        }
      }

      if (uplink == null) {
        uplink = new _upStorage.default({
          url: file.url,
          cache: true,
          _autogenerated: true
        }, self.config);
      }

      let savestream = null;

      if (uplink.config.cache) {
        savestream = self.localStorage.addTarball(name, filename);
      }

      let on_open = function () {
        // prevent it from being called twice
        on_open = function () {};

        const rstream2 = uplink.fetchTarball(file.url);
        rstream2.on('error', function (err) {
          if (savestream) {
            savestream.abort();
          }

          savestream = null;
          readStream.emit('error', err);
        });
        rstream2.on('end', function () {
          if (savestream) {
            savestream.done();
          }
        });
        rstream2.on('content-length', function (v) {
          readStream.emit('content-length', v);

          if (savestream) {
            savestream.emit('content-length', v);
          }
        });
        rstream2.pipe(readStream);

        if (savestream) {
          rstream2.pipe(savestream);
        }
      };

      if (savestream) {
        savestream.on('open', function () {
          on_open();
        });
        savestream.on('error', function (err) {
          self.logger.warn({
            err: err,
            fileName: file
          }, 'error saving file @{fileName}: @{err.message}\n@{err.stack}');

          if (savestream) {
            savestream.abort();
          }

          savestream = null;
          on_open();
        });
      } else {
        on_open();
      }
    }
  }
  /**
   Retrieve a package metadata for {name} package
   Function invokes localStorage.getPackage and uplink.get_package for every
   uplink with proxy_access rights against {name} and combines results
   into one json object
   Used storages: local && uplink (proxy_access)
    * @param {object} options
   * @property {string} options.name Package Name
   * @property {object}  options.req Express `req` object
   * @property {boolean} options.keepUpLinkData keep up link info in package meta, last update, etc.
   * @property {function} options.callback Callback for receive data
   */


  getPackage(options) {
    this.localStorage.getPackageMetadata(options.name, (err, data) => {
      if (err && (!err.status || err.status >= _constants.HTTP_STATUS.INTERNAL_ERROR)) {
        // report internal errors right away
        return options.callback(err);
      }

      this._syncUplinksMetadata(options.name, data, {
        req: options.req,
        uplinksLook: options.uplinksLook
      }, function getPackageSynUpLinksCallback(err, result, uplinkErrors) {
        if (err) {
          return options.callback(err);
        }

        (0, _utils.normalizeDistTags)((0, _storageUtils.cleanUpLinksRef)(options.keepUpLinkData, result)); // npm can throw if this field doesn't exist

        result._attachments = {};
        options.callback(null, result, uplinkErrors);
      });
    });
  }
  /**
   Retrieve remote and local packages more recent than {startkey}
   Function streams all packages from all uplinks first, and then
   local packages.
   Note that local packages could override registry ones just because
   they appear in JSON last. That's a trade-off we make to avoid
   memory issues.
   Used storages: local && uplink (proxy_access)
   * @param {*} startkey
   * @param {*} options
   * @return {Stream}
   */


  search(startkey, options) {
    const self = this; // stream to write a tarball

    const stream = new _stream.default.PassThrough({
      objectMode: true
    });

    _async.default.eachSeries(Object.keys(this.uplinks), function (up_name, cb) {
      // shortcut: if `local=1` is supplied, don't call uplinks
      if (options.req.query.local !== undefined) {
        return cb();
      } // search by keyword for each uplink


      const lstream = self.uplinks[up_name].search(options); // join streams

      lstream.pipe(stream, {
        end: false
      });
      lstream.on('error', function (err) {
        self.logger.error({
          err: err
        }, 'uplink error: @{err.message}');
        cb();

        cb = function () {};
      });
      lstream.on('end', function () {
        cb();

        cb = function () {};
      });

      stream.abort = function () {
        if (lstream.abort) {
          lstream.abort();
        }

        cb();

        cb = function () {};
      };
    }, // executed after all series
    function () {
      // attach a local search results
      const lstream = self.localStorage.search(startkey, options);

      stream.abort = function () {
        lstream.abort();
      };

      lstream.pipe(stream, {
        end: true
      });
      lstream.on('error', function (err) {
        self.logger.error({
          err: err
        }, 'search error: @{err.message}');
        stream.end();
      });
    });

    return stream;
  }
  /**
   * Retrieve only private local packages
   * @param {*} callback
   */


  getLocalDatabase(callback) {
    const self = this;
    this.localStorage.storagePlugin.get((err, locals) => {
      if (err) {
        callback(err);
      }

      const packages = [];

      const getPackage = function (itemPkg) {
        self.localStorage.getPackageMetadata(locals[itemPkg], function (err, pkgMetadata) {
          if (_lodash.default.isNil(err)) {
            const latest = pkgMetadata[_constants.DIST_TAGS].latest;

            if (latest && pkgMetadata.versions[latest]) {
              const version = pkgMetadata.versions[latest];
              const timeList = pkgMetadata.time;
              const time = timeList[latest]; // @ts-ignore

              version.time = time; // Add for stars api
              // @ts-ignore

              version.users = pkgMetadata.users;
              packages.push(version);
            } else {
              self.logger.warn({
                package: locals[itemPkg]
              }, 'package @{package} does not have a "latest" tag?');
            }
          }

          if (itemPkg >= locals.length - 1) {
            callback(null, packages);
          } else {
            getPackage(itemPkg + 1);
          }
        });
      };

      if (locals.length) {
        getPackage(0);
      } else {
        callback(null, []);
      }
    });
  }
  /**
   * Function fetches package metadata from uplinks and synchronizes it with local data
   if package is available locally, it MUST be provided in pkginfo
   returns callback(err, result, uplink_errors)
   */


  _syncUplinksMetadata(name, packageInfo, options, callback) {
    let found = true;
    const self = this;
    const upLinks = [];
    const hasToLookIntoUplinks = _lodash.default.isNil(options.uplinksLook) || options.uplinksLook;

    if (!packageInfo) {
      found = false;
      packageInfo = (0, _storageUtils.generatePackageTemplate)(name);
    }

    for (const uplink in this.uplinks) {
      if ((0, _configUtils.hasProxyTo)(name, uplink, this.config.packages) && hasToLookIntoUplinks) {
        upLinks.push(this.uplinks[uplink]);
      }
    }

    _async.default.map(upLinks, (upLink, cb) => {
      const _options = Object.assign({}, options);

      const upLinkMeta = packageInfo._uplinks[upLink.upname];

      if ((0, _utils.isObject)(upLinkMeta)) {
        const fetched = upLinkMeta.fetched;

        if (fetched && Date.now() - fetched < upLink.maxage) {
          return cb();
        }

        _options.etag = upLinkMeta.etag;
      }

      upLink.getRemoteMetadata(name, _options, (err, upLinkResponse, eTag) => {
        if (err && err.remoteStatus === 304) {
          upLinkMeta.fetched = Date.now();
        }

        if (err || !upLinkResponse) {
          return cb(null, [err || _utils.ErrorCode.getInternalError('no data')]);
        }

        try {
          (0, _utils.validateMetadata)(upLinkResponse, name);
        } catch (err) {
          self.logger.error({
            sub: 'out',
            err: err
          }, 'package.json validating error @{!err.message}\n@{err.stack}');
          return cb(null, [err]);
        }

        packageInfo._uplinks[upLink.upname] = {
          etag: eTag,
          fetched: Date.now()
        };
        packageInfo.time = (0, _storageUtils.mergeUplinkTimeIntoLocal)(packageInfo, upLinkResponse);
        (0, _uplinkUtil.updateVersionsHiddenUpLink)(upLinkResponse.versions, upLink);

        try {
          (0, _metadataUtils.mergeVersions)(packageInfo, upLinkResponse);
        } catch (err) {
          self.logger.error({
            sub: 'out',
            err: err
          }, 'package.json parsing error @{!err.message}\n@{err.stack}');
          return cb(null, [err]);
        } // if we got to this point, assume that the correct package exists
        // on the uplink


        found = true;
        cb();
      });
    }, // @ts-ignore
    (err, upLinksErrors) => {
      (0, _assert.default)(!err && Array.isArray(upLinksErrors)); // Check for connection timeout or reset errors with uplink(s)
      // (these should be handled differently from the package not being found)

      if (!found) {
        let uplinkTimeoutError;

        for (let i = 0; i < upLinksErrors.length; i++) {
          if (upLinksErrors[i]) {
            for (let j = 0; j < upLinksErrors[i].length; j++) {
              if (upLinksErrors[i][j]) {
                const code = upLinksErrors[i][j].code;

                if (code === 'ETIMEDOUT' || code === 'ESOCKETTIMEDOUT' || code === 'ECONNRESET') {
                  uplinkTimeoutError = true;
                  break;
                }
              }
            }
          }
        }

        if (uplinkTimeoutError) {
          return callback(_utils.ErrorCode.getServiceUnavailable(), null, upLinksErrors);
        }

        return callback(_utils.ErrorCode.getNotFound(_constants.API_ERROR.NO_PACKAGE), null, upLinksErrors);
      }

      if (upLinks.length === 0) {
        return callback(null, packageInfo);
      }

      self.localStorage.updateVersions(name, packageInfo, async (err, packageJsonLocal) => {
        if (err) {
          return callback(err);
        } // Any error here will cause a 404, like an uplink error. This is likely the right thing to do
        // as a broken filter is a security risk.


        const filterErrors = []; // This MUST be done serially and not in parallel as they modify packageJsonLocal

        for (const filter of self.filters) {
          try {
            // These filters can assume it's save to modify packageJsonLocal and return it directly for
            // performance (i.e. need not be pure)
            packageJsonLocal = await filter.filter_metadata(packageJsonLocal);
          } catch (err) {
            filterErrors.push(err);
          }
        }

        callback(null, packageJsonLocal, _lodash.default.concat(upLinksErrors, filterErrors));
      });
    });
  }
  /**
   * Set a hidden value for each version.
   * @param {Array} versions list of version
   * @param {String} upLink uplink name
   * @private
   */


  _updateVersionsHiddenUpLink(versions, upLink) {
    for (const i in versions) {
      if (Object.prototype.hasOwnProperty.call(versions, i)) {
        const version = versions[i]; // holds a "hidden" value to be used by the package storage.
        // $FlowFixMe

        version[Symbol.for('__verdaccio_uplink')] = upLink.upname;
      }
    }
  }

}

var _default = Storage;
exports.default = _default;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/lib/storage.ts"],"names":["Storage","constructor","config","uplinks","logger","child","filters","localStorage","init","LocalStorage","getSecret","addPackage","name","metadata","callback","_isAllowPublishOffline","_syncUplinksMetadata","bind","err","publish","_","isBoolean","allow_offline","readTokens","filter","saveToken","token","deleteToken","user","tokenKey","addVersion","version","tag","mergeTags","tagHash","changePackage","revision","removePackage","Search","remove","removeTarball","filename","addTarball","getTarball","readStream","ReadTarball","abort","self","localStream","isOpen","on","status","HTTP_STATUS","NOT_FOUND","emit","err404","getPackageMetadata","info","isNil","_distfiles","serveFile","v","pipe","file","uplink","uplinkId","packages","ProxyStorage","url","cache","_autogenerated","savestream","on_open","rstream2","fetchTarball","done","warn","fileName","getPackage","options","data","INTERNAL_ERROR","req","uplinksLook","getPackageSynUpLinksCallback","result","uplinkErrors","keepUpLinkData","_attachments","search","startkey","stream","Stream","PassThrough","objectMode","async","eachSeries","Object","keys","up_name","cb","query","local","undefined","lstream","end","error","getLocalDatabase","storagePlugin","get","locals","itemPkg","pkgMetadata","latest","DIST_TAGS","versions","timeList","time","users","push","package","length","packageInfo","found","upLinks","hasToLookIntoUplinks","map","upLink","_options","assign","upLinkMeta","_uplinks","upname","fetched","Date","now","maxage","etag","getRemoteMetadata","upLinkResponse","eTag","remoteStatus","ErrorCode","getInternalError","sub","upLinksErrors","Array","isArray","uplinkTimeoutError","i","j","code","getServiceUnavailable","getNotFound","API_ERROR","NO_PACKAGE","updateVersions","packageJsonLocal","filterErrors","filter_metadata","concat","_updateVersionsHiddenUpLink","prototype","hasOwnProperty","call","Symbol","for"],"mappings":"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","sourcesContent":["import assert from 'assert';\nimport Stream from 'stream';\nimport _ from 'lodash';\nimport async, { AsyncResultArrayCallback } from 'async';\nimport { ReadTarball } from '@verdaccio/streams';\nimport {\n  IReadTarball,\n  IUploadTarball,\n  Versions,\n  Package,\n  Config,\n  MergeTags,\n  Version,\n  DistFile,\n  Callback,\n  Logger\n} from '@verdaccio/types';\nimport { GenericBody, TokenFilter, Token } from '@verdaccio/types';\nimport { VerdaccioError } from '@verdaccio/commons-api';\nimport {\n  IStorage,\n  IProxy,\n  IStorageHandler,\n  ProxyList,\n  StringValue,\n  IGetPackageOptions,\n  ISyncUplinks,\n  IPluginFilters\n} from '../../types';\nimport { logger } from '../lib/logger';\nimport ProxyStorage from './up-storage';\nimport Search from './search';\nimport { API_ERROR, HTTP_STATUS, DIST_TAGS } from './constants';\nimport LocalStorage from './local-storage';\nimport {\n  checkPackageLocal,\n  publishPackage,\n  checkPackageRemote,\n  cleanUpLinksRef,\n  mergeUplinkTimeIntoLocal,\n  generatePackageTemplate\n} from './storage-utils';\nimport { setupUpLinks, updateVersionsHiddenUpLink } from './uplink-util';\nimport { mergeVersions } from './metadata-utils';\nimport { ErrorCode, normalizeDistTags, validateMetadata, isObject } from './utils';\nimport { hasProxyTo } from './config-utils';\n\nclass Storage implements IStorageHandler {\n  public localStorage: IStorage;\n  public config: Config;\n  public logger: Logger;\n  public uplinks: ProxyList;\n  public filters: IPluginFilters;\n\n  public constructor(config: Config) {\n    this.config = config;\n    this.uplinks = setupUpLinks(config);\n    this.logger = logger.child();\n    this.filters = [];\n    // @ts-ignore\n    this.localStorage = null;\n  }\n\n  public init(config: Config, filters: IPluginFilters = []): Promise<string> {\n    this.filters = filters;\n    this.localStorage = new LocalStorage(this.config, logger);\n\n    return this.localStorage.getSecret(config);\n  }\n\n  /**\n   *  Add a {name} package to a system\n   Function checks if package with the same name is available from uplinks.\n   If it isn't, we create package locally\n   Used storages: local (write) && uplinks\n   */\n  public async addPackage(name: string, metadata: any, callback: Function): Promise<void> {\n    try {\n      await checkPackageLocal(name, this.localStorage);\n      await checkPackageRemote(\n        name,\n        this._isAllowPublishOffline(),\n        this._syncUplinksMetadata.bind(this)\n      );\n      await publishPackage(name, metadata, this.localStorage as IStorage);\n      callback();\n    } catch (err) {\n      callback(err);\n    }\n  }\n\n  private _isAllowPublishOffline(): boolean {\n    return (\n      typeof this.config.publish !== 'undefined' &&\n      _.isBoolean(this.config.publish.allow_offline) &&\n      this.config.publish.allow_offline\n    );\n  }\n\n  public readTokens(filter: TokenFilter): Promise<Token[]> {\n    return this.localStorage.readTokens(filter);\n  }\n\n  public saveToken(token: Token): Promise<void> {\n    return this.localStorage.saveToken(token);\n  }\n\n  public deleteToken(user: string, tokenKey: string): Promise<any> {\n    return this.localStorage.deleteToken(user, tokenKey);\n  }\n\n  /**\n   * Add a new version of package {name} to a system\n   Used storages: local (write)\n   */\n  public addVersion(\n    name: string,\n    version: string,\n    metadata: Version,\n    tag: StringValue,\n    callback: Callback\n  ): void {\n    this.localStorage.addVersion(name, version, metadata, tag, callback);\n  }\n\n  /**\n   * Tags a package version with a provided tag\n   Used storages: local (write)\n   */\n  public mergeTags(name: string, tagHash: MergeTags, callback: Callback): void {\n    this.localStorage.mergeTags(name, tagHash, callback);\n  }\n\n  /**\n   * Change an existing package (i.e. unpublish one version)\n   Function changes a package info from local storage and all uplinks with write access./\n   Used storages: local (write)\n   */\n  public changePackage(\n    name: string,\n    metadata: Package,\n    revision: string,\n    callback: Callback\n  ): void {\n    this.localStorage.changePackage(name, metadata, revision, callback);\n  }\n\n  /**\n   * Remove a package from a system\n   Function removes a package from local storage\n   Used storages: local (write)\n   */\n  public removePackage(name: string, callback: Callback): void {\n    this.localStorage.removePackage(name, callback);\n    // update the indexer\n    Search.remove(name);\n  }\n\n  /**\n   Remove a tarball from a system\n   Function removes a tarball from local storage.\n   Tarball in question should not be linked to in any existing\n   versions, i.e. package version should be unpublished first.\n   Used storage: local (write)\n   */\n  public removeTarball(name: string, filename: string, revision: string, callback: Callback): void {\n    this.localStorage.removeTarball(name, filename, revision, callback);\n  }\n\n  /**\n   * Upload a tarball for {name} package\n   Function is synchronous and returns a WritableStream\n   Used storages: local (write)\n   */\n  public addTarball(name: string, filename: string): IUploadTarball {\n    return this.localStorage.addTarball(name, filename);\n  }\n\n  /**\n   Get a tarball from a storage for {name} package\n   Function is synchronous and returns a ReadableStream\n   Function tries to read tarball locally, if it fails then it reads package\n   information in order to figure out where we can get this tarball from\n   Used storages: local || uplink (just one)\n   */\n  public getTarball(name: string, filename: string): IReadTarball {\n    const readStream = new ReadTarball({});\n    readStream.abort = function () {};\n\n    const self = this;\n\n    // if someone requesting tarball, it means that we should already have some\n    // information about it, so fetching package info is unnecessary\n\n    // trying local first\n    // flow: should be IReadTarball\n    let localStream: any = self.localStorage.getTarball(name, filename);\n    let isOpen = false;\n    localStream.on('error', (err): any => {\n      if (isOpen || err.status !== HTTP_STATUS.NOT_FOUND) {\n        return readStream.emit('error', err);\n      }\n\n      // local reported 404\n      const err404 = err;\n      localStream.abort();\n      localStream = null; // we force for garbage collector\n      self.localStorage.getPackageMetadata(name, (err, info: Package): void => {\n        if (_.isNil(err) && info._distfiles && _.isNil(info._distfiles[filename]) === false) {\n          // information about this file exists locally\n          serveFile(info._distfiles[filename]);\n        } else {\n          // we know nothing about this file, trying to get information elsewhere\n          self._syncUplinksMetadata(name, info, {}, (err, info: Package): any => {\n            if (_.isNil(err) === false) {\n              return readStream.emit('error', err);\n            }\n            if (_.isNil(info._distfiles) || _.isNil(info._distfiles[filename])) {\n              return readStream.emit('error', err404);\n         