नोड और त्रुटि: EMFILE, बहुत सारी खुली फाइलें


166

कुछ दिनों के लिए मैंने एक त्रुटि के समाधान के लिए काम किया है

Error: EMFILE, too many open files

ऐसा लगता है कि कई लोगों को एक ही समस्या है। सामान्य उत्तर में फ़ाइल डिस्क्रिप्टर की संख्या बढ़ाना शामिल है। तो, मैंने यह कोशिश की है:

sysctl -w kern.maxfiles=20480,

डिफ़ॉल्ट मान 10240 है। यह मेरी नजर में थोड़ा अजीब है, क्योंकि निर्देशिका में मैं जिस फाइल को संभाल रहा हूं, उसकी संख्या 10240 से कम है। यहां तक ​​कि अजनबी होने के बाद भी, मुझे फाइल डिस्क्रिप्टर की संख्या बढ़ाने के बाद भी वही त्रुटि मिलती है। ।

दूसरा सवाल:

कई खोजों के बाद मुझे "बहुत अधिक खुली फ़ाइलों" समस्या के लिए चारों ओर एक काम मिला:

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

दुर्भाग्य से मैं अभी भी उसी त्रुटि को दूर करता हूं। इस कोड के साथ क्या समस्या है?

एक अंतिम प्रश्न (मैं जावास्क्रिप्ट और नोड के लिए नया हूं), मैं लगभग 5000 दैनिक उपयोगकर्ताओं के लिए बहुत सारे अनुरोधों के साथ एक वेब एप्लिकेशन विकसित करने की प्रक्रिया में हूं। मुझे अजगर और जावा जैसी अन्य भाषाओं के साथ प्रोग्रामिंग में कई वर्षों का अनुभव है। इसलिए मूल रूप से मैंने इस एप्लिकेशन को django या प्ले फ्रेमवर्क के साथ विकसित करने के लिए सोचा। फिर मैंने नोड की खोज की और मुझे कहना चाहिए कि गैर-अवरोधक I / O मॉडल का विचार वास्तव में अच्छा है, आकर्षक, और सभी सबसे तेजी से!

लेकिन मुझे नोड के साथ किस तरह की समस्याओं की उम्मीद करनी चाहिए? क्या यह एक उत्पादन सिद्ध वेब सर्वर है? आपके अनुभव क्या हैं?

जवाबों:


83

जब सुंदर-एफएस काम नहीं करता है ... या आप बस यह समझना चाहते हैं कि रिसाव कहां से आ रहा है। इस प्रक्रिया का पालन करें।

(अगर आपकी समस्या सॉकेट के साथ है तो ग्रेसफुल-एफएस आपकी वैगन को ठीक करने वाला नहीं है।)

मेरे ब्लॉग से लेख: http://www.blakerobertson.com/devlog/2014/1/11/how-to-determine-whats-causing-error-connect-emfile-nodejs.html

कैसे अलग करना है

यह आदेश नोडज प्रक्रियाओं के लिए खुले हैंडल की संख्या को आउटपुट करेगा:

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)
....

ध्यान दें: 1023u (अंतिम पंक्ति) - यह 1024 वीं फ़ाइल का हैंडल है जो डिफ़ॉल्ट अधिकतम है।

अब, अंतिम कॉलम देखें। यह इंगित करता है कि कौन सा संसाधन खुला है। आपको संभवतः समान संसाधन नाम वाली सभी पंक्तियाँ दिखाई देंगी। उम्मीद है, कि अब आपको बताता है कि लीक के लिए आपके कोड में कहां देखना है।

यदि आप कई नोड प्रक्रियाओं को नहीं जानते हैं, तो पहले देखें कि कौन सी प्रक्रिया में पीआईडी ​​12211 है। यह आपको प्रक्रिया बताएगा।

ऊपर मेरे मामले में, मैंने देखा कि बहुत समान आईपी पते का एक गुच्छा था। वे सभी 54.236.3.### IP एड्रेस लुकअप कर रहे थे , मेरे मामले में यह निर्धारित करने में सक्षम था कि यह pubnub संबंधित था।

कमांड संदर्भ

एक प्रक्रिया में कितने खुले हैंडल हैं, यह निर्धारित करने के लिए इस सिंटैक्स का उपयोग करें ...

एक निश्चित पीआईडी ​​के लिए खुली फाइलों की गिनती प्राप्त करने के लिए

मैंने इस कमांड का उपयोग अपने ऐप में विभिन्न घटनाओं को करने के बाद खोली गई फ़ाइलों की संख्या का परीक्षण करने के लिए किया था।

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

आपकी प्रक्रिया की सीमा क्या है?

ulimit -a

जो लाइन आप चाहते हैं वह इस तरह दिखाई देगी:

open files                      (-n) 1024

स्थायी रूप से सीमा बदलें:

  • उबंटू 14.04, नोडज वी। 7.9 पर परीक्षण किया गया

यदि आप कई कनेक्शन खोलने की उम्मीद कर रहे हैं, तो (वेबस्कैट एक अच्छा उदाहरण है), आप स्थायी रूप से सीमा बढ़ा सकते हैं:

  • फ़ाइल: /etc/pam.d/common-session (अंत में जोड़ें)

    session required pam_limits.so
  • फ़ाइल: /etc/security/limits.conf (अंत में जोड़ें, या संपादित करें यदि पहले से मौजूद है)

    root soft  nofile 40000
    root hard  nofile 100000
  • अपने नोडज को पुनः आरंभ करें और ssh से लॉगआउट / लॉगिन करें।

  • यह पुराने NodeJS के लिए काम नहीं कर सकता है जिसे आपको सर्वर को पुनरारंभ करने की आवश्यकता होगी
  • यदि आपका नोड अलग-अलग यूआईडी के साथ चलता है, तो इसके बजाय उपयोग करें।

1
आप खुली फ़ाइलों की सीमा कैसे बदल सकते हैं?
ओम ३।

13
ulimit -n 2048 2048 फ़ाइलों को खोलने की अनुमति देने के लिए
Gaël Barbin

1
यह सबसे वर्णनात्मक और सही उत्तर है। धन्यवाद!
कोस्टानोस

मेरे पास दुर्लभ संख्याएँ हैं। lsof -i -n -P | grep "12843" | wc -l== 4085 लेकिन ulimit -a | grep "open files"== (-n) 1024 कोई सुराग कि मैं अधिकतम सीमा की तुलना में अधिक खोली गई फ़ाइलों को कैसे प्राप्त कर सकता हूं?
कोस्टानोस

1
चूँकि @ blak3r का ब्लॉग नीचे दिखाई देता है, यहाँ वेबैक मशीन पर उनके लेख का लिंक दिया गया है। web.archive.org/web/20140508165434/http://… सुपर सहायक और वास्तव में बहुत अच्छा पढ़ा!
जेम्स

72

graceful-fsइसहाक श्लिटर (node.js अनुचर) द्वारा मॉड्यूल का उपयोग करना शायद सबसे उपयुक्त समाधान है। यदि EMFILE का सामना होता है तो यह वृद्धिशील बैक-ऑफ करता है। इसका उपयोग अंतर्निहित fsमॉड्यूल के लिए ड्रॉप-इन प्रतिस्थापन के रूप में किया जा सकता है ।


2
मुझे बचाया, यह नोड डिफ़ॉल्ट क्यों नहीं है? मुझे समस्या को हल करने के लिए कुछ 3 पार्टी प्लगइन स्थापित करने की आवश्यकता क्यों है?
एंथनी वेबब

7
मुझे लगता है, आम तौर पर बोलना, नोड उपयोगकर्ता के लिए जितना संभव हो उतना उजागर करने की कोशिश करता है। यह सभी को (न सिर्फ नोड कोर डेवलपर्स) इस अपेक्षाकृत कच्चे इंटरफ़ेस के उपयोग से उत्पन्न होने वाली किसी भी समस्या को हल करने का अवसर देता है। उसी समय, समाधान प्रकाशित करना वास्तव में आसान है, और दूसरों द्वारा प्रकाशित उन लोगों को एनपीएम के माध्यम से डाउनलोड करना है। नोड से ही बहुत सारे स्मार्ट की उम्मीद न करें। इसके बजाय, npm पर प्रकाशित पैकेजों में स्मार्ट खोजने की अपेक्षा करें।
Myrne Stol

5
यह ठीक है अगर यह आपका अपना कोड है, लेकिन बहुत सारे npm मॉड्यूल इसका उपयोग नहीं करते हैं।
उपराष्ट्रपति

1
इस मॉड्यूल ने मेरे सभी मुद्दों को हल किया! मैं मानता हूं कि नोड अभी भी थोड़ा कच्चा प्रतीत होता है, लेकिन मुख्यतः क्योंकि यह समझना बहुत कठिन है कि इतने कम प्रलेखन के साथ क्या गलत हो रहा है और ज्ञात मुद्दों के लिए सही समाधान स्वीकार किए जाते हैं।
साइडलॉसन

आप इसे कैसे npm करते हैं? मैं नियमित fs के बजाय इसे अपने कोड में कैसे संयोजित करूं?
अविराम नेतनल

11

मुझे यकीन नहीं है कि यह किसी की मदद करेगा, मैंने बहुत सारी निर्भरता वाले एक बड़े प्रोजेक्ट पर काम करना शुरू कर दिया, जिसने मुझे एक ही त्रुटि दी। मेरे सहयोगी ने मुझे watchmanकाढ़ा का उपयोग करने के लिए स्थापित करने का सुझाव दिया और मेरे लिए यह समस्या तय की।

brew update
brew install watchman

26 जून 2019 को संपादित करें: पहरेदार के लिए जीथब लिंक


इससे मुझे कम से कम मदद मिली। एक प्रतिक्रिया-मूल परियोजना पर बंडलर या तो फाइलों को मूल रूप से खोल सकता है (या अगर यह स्थापित है) चौकीदार का उपयोग इसे उस तरीके से करने के लिए करें जो ऑपरेटिंग सिस्टम के लिए अच्छा है। तो यह एक बड़ी मदद हो सकती है - यह macOS के लिए भी प्रतिक्रिया-मूलक CLI क्विकस्टार्ट में दर्ज़ है: facebook.github.io/react-native/docs/getting-started.html - cheers!
माइक हार्डी

7

मैं आज इस समस्या में भाग गया, और इसके लिए कोई अच्छा समाधान नहीं मिला, मैंने इसे संबोधित करने के लिए एक मॉड्यूल बनाया। मैं @ fbartho के स्निपेट से प्रेरित था, लेकिन fs मॉड्यूल को ओवरराइट करने से बचना चाहता था।

मैंने जो मॉड्यूल लिखा है वह फ़ाइलक्यु है , और आप इसे 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
        }
    });
});

7

आप बहुत सारी फाइलें पढ़ रहे हैं। नोड फ़ाइलों को असिंक्रोनस रूप से पढ़ता है, यह एक ही बार में सभी फ़ाइलों को पढ़ रहा होगा। तो आप शायद 10240 की सीमा पढ़ रहे हैं।

देखें कि क्या यह काम करता है:

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

6

हम सभी की तरह, आप अतुल्यकालिक I / O के शिकार हैं। अतुल्यकालिक कॉल के साथ, यदि आप बहुत सारी फ़ाइलों के आसपास लूप करते हैं, तो Node.js प्रत्येक फ़ाइल को पढ़ने के लिए एक फ़ाइल विवरणक खोलना शुरू कर देगा और तब तक कार्रवाई का इंतजार करेगा जब तक आप इसे बंद नहीं करते।

फ़ाइल डिस्क्रिप्टर तब तक खुला रहता है जब तक कि इसे पढ़ने के लिए आपके सर्वर पर संसाधन उपलब्ध न हो। भले ही आपकी फाइलें छोटी हों और पढ़ना या अपडेट करना तेज़ हो, इसमें कुछ समय लगता है, लेकिन एक ही समय में आपका लूप नई फ़ाइलों को खोलने के लिए बंद नहीं होता है। इसलिए यदि आपके पास बहुत अधिक फाइलें हैं, तो सीमा जल्द ही पूरी हो जाएगी और आपको एक सुंदर ईएमआईएमआर मिलेगा

एक उपाय है, इस प्रभाव से बचने के लिए एक कतार बनाना।

Async लिखने वाले लोगों के लिए धन्यवाद , इसके लिए एक बहुत उपयोगी कार्य है। एक विधि है, जिसे असिन्यूकेयू कहा जाता है , आप एक सीमा के साथ एक नई कतार बनाते हैं और फिर फ़ाइल नाम को कतार में जोड़ते हैं।

नोट: यदि आपको कई फाइलें खोलनी हैं, तो यह एक अच्छा विचार होगा कि कौन सी फाइलें वर्तमान में खुली हैं और उन्हें असीम रूप से फिर से खोलना नहीं है।

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

आप देख सकते हैं कि प्रत्येक फ़ाइल को कतार (कंसोल.लॉग फ़ाइल नाम) में जोड़ा जाता है, लेकिन केवल तब जब वर्तमान कतार आपके द्वारा पहले निर्धारित सीमा के तहत हो।

async.queue को कॉलबैक के माध्यम से कतार की उपलब्धता के बारे में जानकारी मिलती है, इस कॉलबैक को केवल उस समय कहा जाता है जब डेटा फ़ाइल पढ़ी जाती है और आपको जो भी कार्रवाई करनी होती है वह हासिल की जाती है। (फाइल रीड विधि देखें)

तो आप फ़ाइलों के विवरणकर्ता से अभिभूत नहीं हो सकते।

> 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

3

मैंने अभी इस समस्या को हल करने के लिए कोड का एक छोटा सा स्निपेट लिखना समाप्त कर दिया है, अन्य सभी समाधान बहुत अधिक वजन वाले हैं और आपको अपना प्रोग्राम संरचना बदलने की आवश्यकता है।

यह समाधान बस किसी भी fs.readFile या fs.writeFile कॉल को रोकता है ताकि किसी भी समय उड़ान में निर्धारित संख्या से अधिक न हो।

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

यू को जीथब पर इसके लिए एक रेपो बनाना चाहिए।
निक

यह बहुत अच्छा काम करता है अगर ग्रेसफुल-एफएस आपके लिए काम नहीं कर रहा है।
Ceekay

3

मैंने ऊपर दिए गए सभी सामानों को एक ही समस्या के लिए बताया लेकिन कुछ भी काम नहीं किया। मैंने कोशिश की नीचे यह 100% काम किया। साधारण विन्यास बदलता है।

विकल्प 1 सेट सीमा (यह ज्यादातर समय काम नहीं करेगा)

user@ubuntu:~$ ulimit -n 65535

उपलब्ध सीमा की जाँच करें

user@ubuntu:~$ ulimit -n
1024

विकल्प 2 उपलब्ध सीमा को 65535 कहने के लिए बढ़ाना

user@ubuntu:~$ sudo nano /etc/sysctl.conf

इसमें निम्न पंक्ति जोड़ें

fs.file-max = 65535

नए कॉन्फिगर के साथ रिफ्रेश करने के लिए इसे चलाएं

user@ubuntu:~$ sudo sysctl -p

निम्न फ़ाइल को संपादित करें

user@ubuntu:~$ sudo vim /etc/security/limits.conf

इसमें निम्न पंक्तियाँ जोड़ें

root soft     nproc          65535    
root hard     nproc          65535   
root soft     nofile         65535   
root hard     nofile         65535

निम्न फ़ाइल को संपादित करें

user@ubuntu:~$ sudo vim /etc/pam.d/common-session

इस लाइन को इसमें जोड़ें

session required pam_limits.so

लॉगआउट और लॉगिन करें और निम्न कमांड का प्रयास करें

user@ubuntu:~$ ulimit -n
65535

विकल्प 3 बस नीचे दी गई लाइन को जोड़ें

DefaultLimitNOFILE=65535

/etc/systemd/system.conf और /etc/systemd/user.conf पर


विकल्प 2 बल्कि लंबा है, और उम्मीद है कि विकल्प 3 काम करते हैं, लेकिन यह मेरे ubuntu 18 के लिए नहीं है
यूजीन

1

बैगपाइप के साथ, आपको बस बदलाव की जरूरत है

FS.readFile(filename, onRealRead);

=>

var bagpipe = new Bagpipe(10);

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

बैगपाइप आपको समानांतर को सीमित करने में मदद करता है। अधिक जानकारी: https://github.com/JacksonTian/bagpipe


यह सब चीनी या अन्य एशियाई भाषा पर है। क्या अंग्रेजी में कोई दस्तावेज लिखा गया है?
फतह अर्सलान

@FatihArslan अंग्रेजी डॉक अब उपलब्ध है।
user1837639

1

नोडमॉन कमांड चलाते समय भी यही समस्या थी, इसलिए मैंने उदात्त पाठ में खुली फाइलों के नाम को कम कर दिया और त्रुटि गायब हो गई।


मैं भी, EMFILEत्रुटियों को प्राप्त कर रहा था और परीक्षण और त्रुटि के माध्यम से देखा गया कि कुछ उदात्त खिड़कियों को बंद करने से समस्या हल हो गई। मैं अभी भी नहीं जानता कि क्यों। मैंने ulimit -n 2560अपने .bash_profile में जोड़ने का प्रयास किया, लेकिन इससे समस्या हल नहीं हुई। क्या इसके बजाय परमाणु को बदलने की आवश्यकता है ?
Qodesmith

1

@ Blak3r के उत्तर पर बिल्डिंग, यहां थोड़ा आशुलिपि है जिसका उपयोग मैं अन्य निदान में मदद करता हूं:

यदि आप एक Node.js स्क्रिप्ट को डीबग करने का प्रयास कर रहे हैं जो फ़ाइल डिस्क्रिप्टर से बाहर चल रही है, तो आपको lsofप्रश्न में नोड प्रक्रिया द्वारा उपयोग किए गए आउटपुट देने के लिए एक पंक्ति है :

openFiles = child_process.execSync(`lsof -p ${process.pid}`);

यह समकालिक रूप से चलेगा lsof वर्तमान में चल रहे Node.js प्रक्रिया द्वारा फ़िल्टर्ड रूप से फ़िल्टर किया और बफर के माध्यम से परिणाम लौटाएगा।

फिर console.log(openFiles.toString())बफर को स्ट्रिंग में बदलने और परिणाम लॉग करने के लिए उपयोग करें।


0

cwait किसी भी फ़ंक्शंस के समवर्ती निष्पादन को सीमित करने के लिए एक सामान्य समाधान है जो वादे वापस करता है।

आपके मामले में कोड कुछ इस तरह हो सकता है:

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

0

के लिए nodemon उपयोगकर्ताओं: बस का उपयोग --ignore समस्या को हल करने के लिए ध्वज।

उदाहरण:

nodemon app.js --ignore node_modules/ --ignore data/

0

नवीनतम का उपयोग करें fs-extra

मेरे पास Ubuntu16 (और 18) फ़ाइल (सॉकेट-डिस्क्रिप्टर स्पेस lsof |wc -l) के साथ (गिनती के साथ ) काफी समस्या थी। प्रयुक्त fs-extraसंस्करण 8.1.09.0.0"त्रुटि: EMFILE, बहुत अधिक खुली फ़ाइलों" के अपडेट के बाद गायब हो गया।

मैंने विविध ओएस पर विविध समस्याओं का अनुभव किया है। फाइलसिस्टम स्पष्ट रूप से तुच्छ नहीं हैं।


0

मेरे पास यह मुद्दा था, और मैंने इसे चलाकर हल npm updateकिया और यह काम किया।

कुछ मामलों में आपको नोड_मॉडल हटाने की आवश्यकता हो सकती है rm -rf node_modules/


0

मैंने चौकीदार स्थापित करना, सीमा बदलना आदि किया और यह गुल्प में काम नहीं आया।

Iterm2 को फिर से शुरू करना वास्तव में मदद करता है।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.