TypeScript async.eachLimit函数代码示例

    .then(function (paths: string[]) {

      let requiredArray: any[] = new Array();

      async.eachLimit(paths, 1, function (path: string, next: Function) {

        if (path.indexOf('.') !== -1) {

          let requiredItem: any = require(path);

          if (requiredItem && requiredItem.default) {

            requiredArray.push(requiredItem.default);

          }

        }

        return next();

      }, function () {

        deferred.resolve(requiredArray);

      });

    });

    deleteKongConsumers: function (deleteList: DeleteConsumerItem[], callback: ErrorCallback) {
        debug('deleteKongConsumers()');

        async.eachLimit(deleteList, MAX_PARALLEL_CALLS, function (deleteItem: DeleteConsumerItem, callback) {
            const consumerId = deleteItem.kongConsumer.consumer.id;
            info(`Deleting consumer with ID ${consumerId}`);
            utils.kongDeleteConsumer(consumerId, callback);
        }, callback);
    },

 wicked.getApis(function (err, apiList) {
     if (err)
         return callback(err);
     // Get the group list from wicked
     const groups = utils.getGroups().groups;
     // HACK_SCOPES: Make the scope lists Kong compatible (wicked has more info than Kong)
     for (let i = 0; i < apiList.apis.length; ++i) {
         // HACK_SCOPES: This cast is needed to allow changing the scopes to a simple string array (instead of the structure wicked uses).
         const api = apiList.apis[i] as any;
         if (api.auth === 'oauth2' && api.settings) {
             if (api.settings.scopes) {
                 const newScopes = [];
                 for (let scope in api.settings.scopes) {
                     // Take only the keys.
                     newScopes.push(scope);
                 }
                 api.settings.scopes = newScopes;
             } else {
                 api.settings.scopes = [];
             }
             // Now also add the groups as scopes.
             for (let g = 0; g < groups.length; ++g) {
                 api.settings.scopes.push(`wicked:${groups[g].id}`);
             }
             // HACK_PASSTHROUGH_REFRESH: For APIs with passthrough scopes and passthrough users,
             // refresh tokens are created via the "password" grant; this means we must allow it in Kong as well.
             {
                 const _api = api as WickedApi;
                 if (_api.passthroughUsers && _api.passthroughScopeUrl) {
                     _api.settings.enable_password_grant = true;
                 }
             }
         }
     }
     // Enrich apiList with the configuration.
     async.eachLimit(apiList.apis, MAX_PARALLEL_CALLS, function (apiDef: ApiDescription, callback) {
         wicked.getApiConfig(apiDef.id, function (err, apiConfig: KongApiConfig) {
             if (err)
                 return callback(err);
             apiDef.config = checkApiConfig(apiConfig);
             return callback(null);
         });
     }, function (err) {
         if (err)
             return callback(err);
         _actualApis = apiList;
         _actualApisDate = now;
         return callback(null, apiList);
     });
 });

  const doExport = () => {
    exportWindow.webContents.removeListener("did-finish-load", doExport);
    exportWindow.webContents.send("setText", { title: "Superpowers — Exporting...", text: "Exporting..." });

    exportWindow.setProgressBar(0);
    let progress = 0;
    const progressMax = data.files.length;
    const buildPath = `/builds/${data.projectId}/${data.buildId}`;
    const systemsPath = "/systems/";

    async.eachLimit(data.files, 10, (file: string, cb: (err: Error) => any) => {

      let outputFilename = file;
      if (startsWith(outputFilename, buildPath)) {
        // Project build files are served on the build port
        outputFilename = outputFilename.substr(buildPath.length);
        file = `${data.baseURL}:${data.buildPort}${file}`;
      } else {
        // Other files are served on the main port
        file = `${data.baseURL}:${data.mainPort}${file}`;

        if (startsWith(outputFilename, systemsPath)) {
          // Output system files at the root
          outputFilename = outputFilename.substr(outputFilename.indexOf("/", systemsPath.length));
        }
      }
      outputFilename = outputFilename.replace(/\//g, path.sep);

      const outputPath = `${data.outputFolder}${outputFilename}`;
      exportWindow.webContents.send("setText", { text: outputPath });

      http.get(file, (response) => {
        mkdirp(path.dirname(outputPath), (err: Error) => {
          const localFile = fs.createWriteStream(outputPath);
          localFile.on("finish", () => {
            progress++;
            exportWindow.setProgressBar(progress / progressMax);
            cb(null);
          });
          response.pipe(localFile);
        });
      }).on("error", cb);
    } , (err: Error) => {
      exportWindow.setProgressBar(-1);
      if (err != null) { alert(err); return; }
      exportWindow.webContents.send("setText", { title: "Superpowers — Exported", text: "Exported to ", showItemInFolder: { text: data.outputFolder, target: data.outputFolder } } );
    });
  };

  function startExport() {
    exportWindow.webContents.removeListener("did-finish-load", startExport);
    exportWindow.webContents.send("set-export-status", { title: "Superpowers — Exporting...", text: "Exporting..." });

    let isFolderEmpty = false;
    try { isFolderEmpty = fs.readdirSync(options.outputFolder).length === 0; }
    catch (e) { exportWindow.webContents.send("set-export-status", { text: `Error while checking if output folder is empty: ${e.message}` }); return; }
    if (!isFolderEmpty) { exportWindow.webContents.send("set-export-status", { text: "Output folder must be empty." }); return; }

    exportWindow.setProgressBar(0);
    let progress = 0;
    const progressMax = options.files.length;
    const buildPath = `/builds/${options.projectId}/${options.buildId}`;
    const systemsPath = "/systems/";

    async.eachLimit(options.files, 10, processFile, onExportFinished);

    function processFile(file: string, cb: (err: Error) => any) {
      let outputFilename = file;
      if (startsWith(outputFilename, buildPath)) {
        // Project build files are served on the build port
        outputFilename = outputFilename.substr(buildPath.length);
        file = `${options.baseURL}:${options.buildPort}${file}`;
      } else {
        // Other files are served on the main port
        file = `${options.baseURL}:${options.mainPort}${file}`;

        if (startsWith(outputFilename, systemsPath)) {
          // Output system files at the root
          outputFilename = outputFilename.substr(outputFilename.indexOf("/", systemsPath.length));
        }
      }
      outputFilename = outputFilename.replace(/\//g, path.sep);

      const outputPath = `${options.outputFolder}${outputFilename}`;
      exportWindow.webContents.send("set-export-status", { text: outputPath });

      http.get(file, (response) => {
        mkdirp(path.dirname(outputPath), (err: Error) => {
          const localFile = fs.createWriteStream(outputPath);
          localFile.on("finish", () => { progress++; exportWindow.setProgressBar(progress / progressMax); cb(null); });
          response.pipe(localFile);
        });
      }).on("error", cb);
    }
  }

 utils.kongGetAllConsumers(function (err, allConsumers) {
     if (err)
         return callback(err);
     const kongConsumerInfos: ConsumerInfo[] = [];
     async.eachLimit(allConsumers.data, MAX_PARALLEL_CALLS, function (kongConsumer: KongConsumer, callback) {
         enrichConsumerInfo(kongConsumer, function (err, consumerInfo) {
             if (err)
                 return callback(err);
             kongConsumerInfos.push(consumerInfo);
             return callback(null);
         });
     }, function (err) {
         if (err)
             return callback(err);
         return callback(null, kongConsumerInfos);
     });
 });

        }],
        'subscriptions': [(callback) => {
            repo.getSubscriptions(uid, callback);
        }],
        'saveData': ['user', 'friends', 'subscriptions', (callback, results) => {
            fs.writeFile(tempFolder + uid + '.json', JSON.stringify(results), 'utf-8', callback);
        }],
        'profile': ['saveData', (callback, results) => {
            var profile = createProfile(results);
            callback(null, profile);
        }],
        'saveProfile': ['profile', (callback, results) => {
            fs.writeFile(tempFolder + uid + '-profile.json', JSON.stringify(results.profile), 'utf-8', callback);
        }]
    }, finalCallback);
}

/** Run */
var allData = [];
async.eachLimit(selections.humans, 10, function (uid, callback) {
    collectProfileData(uid, function (err, result) {
        logger.debug('Done: ', uid);
        allData.push(result.profile);
        callback(err, result);
    });
}, function (err) {
    if (err) {
        return logger.error(err);
    }
    logger.debug('Data: ', allData.length);
});