Объяснение сокета Node js

Question

Я создаю приложение, которое будет делать около миллиона вызовов на удаленный сервер API. Смогу ли я ограничить количество подключений, например, до 10? Устанавливаю ли я максимальное количество розеток на 10?

Я пытаюсь понять, что делают эти параметры:

keepAlive: false,
maxSockets: 999,
maxFreeSockets: 1

В узле http получить функцию, в следующем коде:

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);
});

Answer 1

Вы действительно не хотите запускать 1000 000 запросов и надеетесь, что maxSockets управляет им до 100 одновременно. Есть целый ряд причин, почему это не лучший способ сделать что-то. Вместо этого вы должны использовать свой собственный код, который управляет количеством активных соединений до 100 одновременно.

Есть несколько способов сделать это:

1. Напишите свой собственный код, который запускает 100, а затем каждый раз, когда один заканчивается, он запускает следующий.

2. Используйте Bluebird's Promise.map() которая имеет встроенную функцию параллелизма, которая управляет количеством пассажиров одновременно.

3. Используйте Async async.mapLimit() которая имеет встроенную функцию параллелизма, которая управляет количеством пассажиров одновременно.

Что касается написания кода самостоятельно, вы можете сделать что-то вроде этого;

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();
    });

}

Answer 2

Я решил использовать асинхронную библиотеку.

Вот мое полное решение этого:

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');
})

Спасибо за помощь.