Erklärung zum Node js-Socket

Ich baue eine Anwendung, die ungefähr eine Million Aufrufe an einen entfernten API-Server durchführt. Kann ich die Anzahl der Verbindungen auf beispielsweise 10 begrenzen? Setze ich maximale Sockets auf 10, reicht das?

Ich versuche zu verstehen, was diese Parameter bewirken:

keepAlive: false,
maxSockets: 999,
maxFreeSockets: 1

In der HTTP-Get-Funktion des Knotens im folgenden Code:

var inputData = [];

for(i=1; i<=5000;i++){
    inputData.push('number' + i);
}

var options = {
    host: "localhost",
    port: 80,
    path: "/text.txt",
    keepAlive: false,
    maxSockets: 999,
    maxFreeSockets: 1
}


var limit = inputData.length;
var counter = 0;

function fetchData(number){

    return new Promise(function(resolve, reject){
        var http = require('http');

        fetch  = function(resp){
            var body = '';
            resp.on('data',function(chunk){
                body += chunk;
            })
            resp.on('end',function(){
                console.log(resp)
                resolve()
            })
            resp.on('error',function(err){
                console.log('error');
            })
        }
        var req = http.request(options, fetch);

        req.end();

    })
}



Promise.all(inputData.map(number => fetchData(number))).then(function(results) {
    console.log('finished');
    connection.end();

})
.catch(function(error) {
    console.log('there wa an error');
    console.log(error);
});

Sie wollen wirklich nicht 1.000.000 Anfragen abfeuern und irgendwie hoffen, dass maxSockets es auf 100 gleichzeitig schafft. Es gibt eine ganze Reihe von Gründen, warum dies keine gute Möglichkeit ist, Dinge zu tun. Stattdessen sollten Sie Ihren eigenen Code verwenden, der die Anzahl der Live-Verbindungen auf jeweils 100 verwaltet.

Dazu gibt es mehrere Möglichkeiten:

1. Schreiben Sie Ihren eigenen Code, der 100 auslöst, und jedes Mal, wenn einer beendet ist, wird der nächste ausgelöst.

2. Verwenden Sie Bluebirds Promise.map() die über eine integrierte Parallelitätsfunktion verfügt, die verwaltet, wie viele gleichzeitig im Flug sind.

3. Verwenden Sie Asyncs async.mapLimit() die über eine integrierte Parallelitätsfunktion verfügt, die verwaltet, wie viele gleichzeitig im Flug sind.

Wenn Sie selbst Code schreiben, um dies zu tun, können Sie Folgendes tun;

function fetchAll() {
    var start = 1;
    var end = 1000000;
    var concurrentMax = 100;
    var concurrentCnt = 0;
    var cntr = start;
    return new Promise(function(resolve, reject) {

        // start up requests until the max concurrent requests are going
        function run() {
            while (cntr < end && concurrentCnt < concurrentMax) {
                ++concurrentCnt;
                fetchData(cntr++).then(function() {
                    --concurrentCnt;
                    run();
                }, function(err) {
                    --concurrentCnt;
                    // decide what to do with error here
                    // to continue processing more requests, call run() here
                    // to stop processing more requests, call reject(err) here
                });
            }
            if (cntr >= end && concurrentCnt === 0) {
                // all requests are done here
                resolve();
            }        
        }

        run();
    });

}

Ich habe mich für die asynchrone Bibliothek entschieden.

Hier ist meine komplette Lösung dafür:

var async = require('async')

var http = require('http');

var inputData = [];

for(i=1; i<=2000;i++){
    inputData.push('number' + i);
}

var options = {
    host: "o2.pl",
    path: "/static/desktop.css?v=0.0.417",
    port: 80
}

function fetchData(number, callback){

    return new Promise(function(resolve, reject){

        fetch  = function(resp){
            var body = '';
            resp.on('data',function(chunk){
                body += chunk;
            })
            process.stdout.write('.')

            callback()

            resp.on('error',function(err){
                console.log('error');
                console.log(err);

            })
        }
        var req = http.request(options, fetch);

        req.end();

    })
}

function foo(item, callback){

    return callback(false, 'foo');
}

async.mapLimit(inputData,100,fetchData,function(err, result){
    console.log('finished');
})

Danke für Ihre Hilfe.