Knoten und Fehler: EMFILE, zu viele offene Dateien

Für einige Tage suchte ich nach einer funktionierenden Lösung um einen Fehler

Error: EMFILE, too many open files

Es scheint, dass viele Leute das gleiche problem haben. Die übliche Antwort umfasst die Erhöhung der Anzahl der Datei-Deskriptoren. So, ich hab das versucht:

sysctl -w kern.maxfiles=20480

Der Standardwert ist 10.240. Dies ist ein wenig seltsam, in meinen Augen, weil die Anzahl der Dateien, die ich bin-handling in das Verzeichnis ist unter 10240. Noch seltsamer, ich habe immer noch die gleiche Fehlermeldung erhalten, nachdem ich erhöht habe sich die Anzahl von Datei-Deskriptoren.

Zweite Frage:

Nach einigen Recherchen fand ich eine Arbeit, um für die "too many open files" problem:

var requestBatches = {};
function batchingReadFile(filename, callback) {
  //First check to see if there is already a batch
  if (requestBatches.hasOwnProperty(filename)) {
    requestBatches[filename].push(callback);
    return;
  }

  //Otherwise start a new one and make a real request
  var batch = requestBatches[filename] = [callback];
  FS.readFile(filename, onRealRead);

  //Flush out the batch on complete
  function onRealRead() {
    delete requestBatches[filename];
    for (var i = 0, l = batch.length; i < l; i++) {
      batch[i].apply(null, arguments);
    }
  }
}

function printFile(file){
    console.log(file);
}

dir = "/Users/xaver/Downloads/xaver/xxx/xxx/"

var files = fs.readdirSync(dir);

for (i in files){
    filename = dir + files[i];
    console.log(filename);
    batchingReadFile(filename, printFile);

Leider habe ich noch immer erhalten die gleichen Fehler.
Was ist falsch an diesem code?

Eine Letzte Frage (ich bin neu in der javascript-und node), ich bin in den Prozess der Erstellung einer web -
Anwendung mit einer Menge von Anforderungen für über 5000 Benutzer pro Tag. Ich habe viele Jahre Erfahrung in der
Programmierung mit anderen Sprachen wie python und java. also ursprünglich dachte ich developp diese Anwendung mit django oder play framework. Dann entdeckte ich Knoten und ich muss sagen, dass die Idee der nicht blockierenden I/O Modell ist wirklich schön, verführerisch und vor allem sehr schnell!

Aber welche Probleme sollte ich erwarten, mit Knoten? Ist es eine Produktion bewährten web-server? Was sind Eure Erfahrungen?

InformationsquelleAutor der Frage xaverras | 2012-01-22

  1. 64

    Wenn anmutig-fs funktioniert nicht... oder Sie wollen einfach nur, um zu verstehen, wo das Leck herkommt. Diesen Prozess zu Folgen.

    (z.B. anmutig-fs ist nicht gonna reparieren Ihren Wagen, wenn Sie Ihr Problem mit sockets.)

    Aus Meinem Blog-Artikel: http://www.blakerobertson.com/devlog/2014/1/11/how-to-determine-whats-causing-error-connect-emfile-nodejs.html

    Wie Zu Isolieren

    Dieser Befehl gibt die Anzahl der offenen handles für nodejs Prozesse:


    lsof -i -n -P | grep nodejs

    COMMAND     PID    USER   FD   TYPE    DEVICE SIZE/OFF NODE NAME
...
nodejs    12211    root 1012u  IPv4 151317015      0t0  TCP 10.101.42.209:40371->54.236.3.170:80 (ESTABLISHED)
nodejs    12211    root 1013u  IPv4 151279902      0t0  TCP 10.101.42.209:43656->54.236.3.172:80 (ESTABLISHED)
nodejs    12211    root 1014u  IPv4 151317016      0t0  TCP 10.101.42.209:34450->54.236.3.168:80 (ESTABLISHED)
nodejs    12211    root 1015u  IPv4 151289728      0t0  TCP 10.101.42.209:52691->54.236.3.173:80 (ESTABLISHED)
nodejs    12211    root 1016u  IPv4 151305607      0t0  TCP 10.101.42.209:47707->54.236.3.172:80 (ESTABLISHED)
nodejs    12211    root 1017u  IPv4 151289730      0t0  TCP 10.101.42.209:45423->54.236.3.171:80 (ESTABLISHED)
nodejs    12211    root 1018u  IPv4 151289731      0t0  TCP 10.101.42.209:36090->54.236.3.170:80 (ESTABLISHED)
nodejs    12211    root 1019u  IPv4 151314874      0t0  TCP 10.101.42.209:49176->54.236.3.172:80 (ESTABLISHED)
nodejs    12211    root 1020u  IPv4 151289768      0t0  TCP 10.101.42.209:45427->54.236.3.171:80 (ESTABLISHED)
nodejs    12211    root 1021u  IPv4 151289769      0t0  TCP 10.101.42.209:36094->54.236.3.170:80 (ESTABLISHED)
nodejs    12211    root 1022u  IPv4 151279903      0t0  TCP 10.101.42.209:43836->54.236.3.171:80 (ESTABLISHED)
nodejs    12211    root 1023u  IPv4 151281403      0t0  TCP 10.101.42.209:43930->54.236.3.172:80 (ESTABLISHED)
....

    Bemerken: 1023u (Letzte Zeile) - das ist die 1024th handle der Datei, die die standardmäßige maximale.

    Nun, Schauen Sie in die Letzte Spalte. Gibt an, welche Ressource geöffnet ist. Sie werden wahrscheinlich sehen, eine Reihe von Linien, alle mit demselben Ressourcen-Namen. Bleibt zu hoffen, dass jetzt erzählt Sie, wo in Ihrem code nach dem Leck.

    Wenn Sie nicht wissen, mehrere Knoten Verfahren, zuerst die lookup-Prozess hat die pid-12211. Das wird Ihnen sagen, die verarbeiten.

    In meinem Fall oben, ich bemerkte, dass es gab eine Reihe von sehr ähnlichen IP-Adressen. Sie waren alle 54.236.3.### By doing ip-Adresse lookups, war in der Lage, um zu bestimmen, in meinem Fall war es pubnub Verwandte.

    Command Reference

    Verwenden Sie die folgende syntax, um zu bestimmen, wie viele offene handles ein Prozess öffnet...

    Um die Anzahl der geöffneten Dateien für eine bestimmte pid

    Nutzte ich das Befehl zum testen der Anzahl der Dateien, die geöffnet wurden, nachdem Sie verschiedene Ereignisse in meinem app.

    lsof -i -n -P | grep "8465" | wc -l

    # lsof -i -n -P | grep "nodejs.*8465" | wc -l
28
# lsof -i -n -P | grep "nodejs.*8465" | wc -l
31
# lsof -i -n -P | grep "nodejs.*8465" | wc -l
34

    Was ist Ihr Prozess-limit?


    ulimit -a

    Die Zeile, die Sie wollen wird wie folgt Aussehen:

    open files (-n) 1024

    Dauerhaft ändern Sie den Grenzwert:

    • getestet auf Ubuntu 14.04, nodejs v. 7.9

    Im Falle dass, wenn Sie erwarten, es zu öffnen viele verbindungen (websockets ist ein gutes Beispiel), können Sie dauerhaft den Grenzwert erhöhen:

    • Datei: /etc/pam.d/common-session (an das Ende)

      session required pam_limits.so

    • Datei: /etc/security/limits.conf (fügen Sie an das Ende, oder Bearbeiten, wenn bereits vorhanden)

      root soft  nofile 40000
root hard  nofile 100000

    • starten Sie Ihren nodejs und logout/login aus ssh.

    • dies funktioniert möglicherweise nicht für ältere NodeJS müssen Sie die server-Neustart
    • verwenden statt, wenn Sie Ihre Knoten läuft mit unterschiedlicher uid.

    InformationsquelleAutor der Antwort blak3r

  2. 63

    Mithilfe der graceful-fs Modul von Isaac Schlüter (node.js Betreuer) ist wahrscheinlich die am besten geeignete Lösung. Es macht inkrementelle back-off, wenn EMFILE ist aufgetreten. Es kann verwendet werden, als ein drop-in-Ersatz für den integrierten fs Modul.

    InformationsquelleAutor der Antwort Myrne Stol

  3. 6

    Ich lief in dieses problem heute, und finden keine gute Lösung für Sie, ich habe ein Modul, um es anzugehen. Ich war inspiriert von @fbartho das snippet, wollte aber vermeiden, das überschreiben der fs-Modul.

    Modul ich geschrieben habe, ist Filequeueund Sie verwenden es genau wie fs:

    var Filequeue = require('filequeue');
var fq = new Filequeue(200); //max number of files to open at once

fq.readdir('/Users/xaver/Downloads/xaver/xxx/xxx/', function(err, files) {
    if(err) {
        throw err;
    }
    files.forEach(function(file) {
        fq.readFile('/Users/xaver/Downloads/xaver/xxx/xxx/' + file, function(err, data) {
            //do something here
        }
    });
});

    InformationsquelleAutor der Antwort Trey Griffith

  4. 4

    Du liest zu viele Dateien. Knoten liest Dateien asynchron, werde es Lesen, und alle Dateien auf einmal. Also bist du wahrscheinlich Lesen die 10240 begrenzen.

    Sehen, ob das funktioniert:

    var fs = require('fs')
var events = require('events')
var util = require('util')
var path = require('path')

var FsPool = module.exports = function(dir) {
    events.EventEmitter.call(this)
    this.dir = dir;
    this.files = [];
    this.active = [];
    this.threads = 1;
    this.on('run', this.runQuta.bind(this))
};
//So will act like an event emitter
util.inherits(FsPool, events.EventEmitter);

FsPool.prototype.runQuta = function() {
    if(this.files.length === 0 && this.active.length === 0) {
        return this.emit('done');
    }
    if(this.active.length < this.threads) {
        var name = this.files.shift()

        this.active.push(name)
        var fileName = path.join(this.dir, name);
        var self = this;
        fs.stat(fileName, function(err, stats) {
            if(err)
                throw err;
            if(stats.isFile()) {
                fs.readFile(fileName, function(err, data) {
                    if(err)
                        throw err;
                    self.active.splice(self.active.indexOf(name), 1)
                    self.emit('file', name, data);
                    self.emit('run');

                });
            } else {
                self.active.splice(self.active.indexOf(name), 1)
                self.emit('dir', name);
                self.emit('run');
            }
        });
    }
    return this
};
FsPool.prototype.init = function() {
    var dir = this.dir;
    var self = this;
    fs.readdir(dir, function(err, files) {
        if(err)
            throw err;
        self.files = files
        self.emit('run');
    })
    return this
};
var fsPool = new FsPool(__dirname)

fsPool.on('file', function(fileName, fileData) {
    console.log('file name: ' + fileName)
    console.log('file data: ', fileData.toString('utf8'))

})
fsPool.on('dir', function(dirName) {
    console.log('dir name: ' + dirName)

})
fsPool.on('done', function() {
    console.log('done')
});
fsPool.init()

    InformationsquelleAutor der Antwort Tim P.

  5. 2

    Ich gerade fertig mit schreiben, ein kleines code-snippet, dieses problem zu lösen mich, alle anderen Lösungen erscheinen übrigens auch im Schwergewicht und verlangen, dass Sie ändern Ihre Programmstruktur.

    Diese Lösung nur Stände, alle fs.readFile oder fs.writeFile aufruft, so dass es nicht mehr als eine bestimmte Anzahl im Flug zu einem bestimmten Zeitpunkt. 

    //Queuing reads and writes, so your nodejs script doesn't overwhelm system limits catastrophically
global.maxFilesInFlight = 100; //Set this value to some number safeish for your system
var origRead = fs.readFile;
var origWrite = fs.writeFile;

var activeCount = 0;
var pending = [];

var wrapCallback = function(cb){
    return function(){
        activeCount--;
        cb.apply(this,Array.prototype.slice.call(arguments));
        if (activeCount < global.maxFilesInFlight && pending.length){
            console.log("Processing Pending read/write");
            pending.shift()();
        }
    };
};
fs.readFile = function(){
    var args = Array.prototype.slice.call(arguments);
    if (activeCount < global.maxFilesInFlight){
        if (args[1] instanceof Function){
            args[1] = wrapCallback(args[1]);
        } else if (args[2] instanceof Function) {
            args[2] = wrapCallback(args[2]);
        }
        activeCount++;
        origRead.apply(fs,args);
    } else {
        console.log("Delaying read:",args[0]);
        pending.push(function(){
            fs.readFile.apply(fs,args);
        });
    }
};

fs.writeFile = function(){
    var args = Array.prototype.slice.call(arguments);
    if (activeCount < global.maxFilesInFlight){
        if (args[1] instanceof Function){
            args[1] = wrapCallback(args[1]);
        } else if (args[2] instanceof Function) {
            args[2] = wrapCallback(args[2]);
        }
        activeCount++;
        origWrite.apply(fs,args);
    } else {
        console.log("Delaying write:",args[0]);
        pending.push(function(){
            fs.writeFile.apply(fs,args);
        });
    }
};

    InformationsquelleAutor der Antwort fbartho

  6. 1

    Mit Dudelsack, müssen Sie nur ändern 

    FS.readFile(filename, onRealRead);

    =>

    var bagpipe = new Bagpipe(10);

bagpipe.push(FS.readFile, filename, onRealRead))

    Den Dudelsack helfen, begrenzen Sie die parallele. mehr details: https://github.com/JacksonTian/bagpipe

    InformationsquelleAutor der Antwort user1837639

  7. 1

    Hatte das gleiche problem beim ausführen der nodemon - Befehl ein, so reduzierte ich die Namen der Dateien öffnen in sublime text und der Fehler verschwand.

    InformationsquelleAutor der Antwort Buhiire Keneth

  8. 1

    Wie alle von uns, Sie sind ein weiteres Opfer der asynchrone I/O. Mit asynchronen aufrufen, wenn Sie die Schleife, um eine Menge von Dateien, Node.js starten Sie zum öffnen einer Datei-Deskriptor für jede Datei zu Lesen und dann warten, bis Sie es schließen.

    Datei-Deskriptor bleibt geöffnet, bis die Ressource verfügbar ist auf Ihrem server, um es zu Lesen. Auch wenn die Dateien klein sind und Lesen oder aktualisieren, ist schnell, es dauert einige Zeit, aber in der gleichen Zeit, die Ihre Schleife nicht beenden, um neue Dateien Deskriptor. Also, wenn Sie zu viele Dateien, die Grenze wird bald erreicht man ein schönes EMFILE.

    Gibt es eine Lösung, die Schaffung einer Warteschlange, um diesen Effekt zu vermeiden.

    Dank Leute, die schrieb Asynces ist eine sehr nützliche Funktion. Es gibt eine Methode namens Async.Warteschlangeerstellen Sie eine neue Warteschlange mit einem limit und dann fügen Sie Dateinamen in der Warteschlange.

    Hinweis: Wenn Sie zum öffnen von vielen Dateien, wäre es eine gute Idee, um zu speichern, welche Dateien derzeit geöffnet sind und nicht erneut Sie unendlich.

    const fs = require('fs')
const async = require("async")

var q = async.queue(function(task, callback) {
    console.log(task.filename);
    fs.readFile(task.filename,"utf-8",function (err, data_read) {
            callback(err,task.filename,data_read);
        }
    );
}, 4);

var files = [1,2,3,4,5,6,7,8,9,10]

for (var file in files) {
    q.push({filename:file+".txt"}, function (err,filename,res) {
        console.log(filename + " read");
    });
}

    Können Sie sehen, dass jede Datei zur Warteschlange Hinzugefügt (console.log-Dateiname), aber nur, wenn die aktuelle Warteschlange ist unter der Grenze, die Sie zuvor festgelegt haben.

    async.queue Holen Sie sich Informationen über die Verfügbarkeit der Warteschlange durch einen Rückruf, dieser callback wird nur aufgerufen, wenn die Daten-Datei gelesen wird und jede Aktion, die Sie tun müssen, ist erreicht. (siehe Methode fileRead)

    Damit Sie nicht überfordert werden, indem Dateien Deskriptor.

    > node ./queue.js
0.txt
    1.txt
2.txt
0.txt read
3.txt
3.txt read
4.txt
2.txt read
5.txt
4.txt read
6.txt
5.txt read
7.txt
    1.txt read (biggest file than other)
8.txt
6.txt read
9.txt
7.txt read
8.txt read
9.txt read

    InformationsquelleAutor der Antwort Plaute

  9. 0

    cwait ist eine Allgemeine Lösung für die Begrenzung der gleichzeitigen Ausführung von Funktionen, die Rendite verspricht.

    In deinem Fall der code könnte etwa so Aussehen:

    var Promise = require('bluebird');
var cwait = require('cwait');

//Allow max. 10 concurrent file reads.
var queue = new cwait.TaskQueue(Promise, 10);
var read = queue.wrap(Promise.promisify(batchingReadFile));

Promise.map(files, function(filename) {
    console.log(filename);
    return(read(filename));
})

    InformationsquelleAutor der Antwort jjrv

  10. 0

    Ich bin nicht sicher, ob das wird helfen, jemand, ich arbeite an einem großen Projekt mit vielen Abhängigkeiten, die warf mir der gleiche Fehler. Mein Kollege schlug mir vor, zu installieren watchman mit brauen und dass es dieses problem für mich. 

    brew update
brew install watchman

    InformationsquelleAutor der Antwort OwlyMoly

Schreibe einen Kommentar