तो आप एक फोल्डर से लाखों फाइलें कैसे डिलीट करते हैं?

एक भीड़ निर्देशिका से फ़ाइलों को हटाने के मामले में मैं पर मंत्रमुग्ध कर देना।

मैंने लेख को हार्ड डिस्क के असामान्य अतिप्रवाह या एक फ़ोल्डर से लाखों फ़ाइलों को हटाने का तरीका पढ़ा और बहुत आश्चर्य हुआ। क्या वास्तव में मानक लिनक्स टूलकिट में भीड़ वाली निर्देशिकाओं के साथ काम करने के लिए कोई सरल उपकरण नहीं हैं और आपको सीधे कॉल getdents() रूप में इस तरह के निम्न-स्तरीय तरीकों का सहारा लेने की आवश्यकता है।

उन लोगों के लिए जो समस्या से अवगत नहीं हैं, एक संक्षिप्त विवरण: यदि आपने गलती से एक पदानुक्रम के बिना एक ही निर्देशिका में बड़ी संख्या में फाइलें बनाई हैं - अर्थात। एक ही फ्लैट डायरेक्टरी में पड़ी 5 मिलियन फाइलों से, आप उन्हें जल्दी से डिलीट नहीं कर पाएंगे। इसके अलावा, लिनक्स में सभी उपयोगिताओं को सिद्धांत रूप में नहीं किया जा सकता है - या तो वे प्रोसेसर / एचडीडी को बहुत अधिक लोड करेंगे, या वे बहुत अधिक मेमोरी लेंगे।

इसलिए मैंने समय लिया, एक परीक्षण साइट का आयोजन किया और विभिन्न उपकरणों की कोशिश की, दोनों ने टिप्पणियों में सुझाव दिए और विभिन्न लेखों और अपने स्वयं के पाए।

ट्रेनिंग

चूँकि आप काम करने वाले कंप्यूटर के अपने HDD पर एक भीड़ भरी निर्देशिका बनाने का मन नहीं करते हैं, तो आप इसे हटाने की आवश्यकता महसूस नहीं करते हैं, एक अलग फ़ाइल में एक वर्चुअल FS बनाते हैं और इसे लूप डिवाइस के माध्यम से माउंट करते हैं। सौभाग्य से, लिनक्स पर, यह आसान है।

एक खाली 200GB फ़ाइल बनाएँ

 #!python f = open("sparse", "w") f.seek(1024 * 1024 * 1024 * 200) f.write("\0") 

कई लोग इसके लिए dd उपयोगिता का उपयोग करने की सलाह देते हैं, उदाहरण के लिए dd if=/dev/zero of=disk-image bs=1M count=1M , लेकिन यह अतुलनीय रूप से धीमा काम करता है, और परिणाम, जैसा कि मैं समझता हूं, यह समान है।

फ़ाइल को ext4 में स्वरूपित करें और इसे फ़ाइल सिस्टम के रूप में माउंट करें

 mkfs -t ext4 -q sparse # TODO: less FS size, but change -N option sudo mount sparse /mnt mkdir /mnt/test_dir 

दुर्भाग्य से, मैंने प्रयोग करने के बाद mkfs.ext4 कमांड के -N विकल्प के बारे में सीखा। यह आपको छवि फ़ाइल का आकार बढ़ाए बिना एफएस पर इनोड की संख्या पर सीमा बढ़ाने की अनुमति देता है। लेकिन, दूसरी ओर, मानक सेटिंग्स वास्तविक स्थितियों के करीब हैं।

हम कई खाली फाइलें बनाते हैं (यह कई घंटों तक काम करेगी)

 #!python for i in xrange(0, 13107300): f = open("/mnt/test_dir/{0}_{0}_{0}_{0}".format(i), "w") f.close() if i % 10000 == 0: print i 

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

हम यह सत्यापित करते हैं कि FS पर सभी आयतें समाप्त हो गई हैं।

  $ df -i
 / देव / लूप ०१३० 13२०० १३१० 3२ ३ ३ 100५१ 13 १००% / mnt 

निर्देशिका फ़ाइल का आकार ~ 360Mb

  $ ls -lh / mnt /
 drwxrwxr-x 2 seriy seriy 358M नोव  1 03:11 test_dir 

अब इस निर्देशिका को विभिन्न तरीकों से अपनी सभी सामग्रियों से हटाने का प्रयास करते हैं।

परीक्षण

प्रत्येक परीक्षण के बाद, फ़ाइल सिस्टम कैश रीसेट करें
sudo sh -c 'sync && echo 1 > /proc/sys/vm/drop_caches'
आदेश में जल्दी से सभी मेमोरी नहीं लेने और समान परिस्थितियों में हटाने की गति की तुलना करें।

Rm -r के माध्यम से निकालना

$ rm -r /mnt/test_dir/
getdents() तहत, कई बार एक पंक्ति (!!!) में getdents() ) कॉल किया getdents() , फिर यह बहुत सारे unlinkat() और एक लूप में कॉल करता है। 30Mb RAM लिया, बढ़ नहीं रहा।
सामग्री को सफलतापूर्वक हटाता है।

  iotop
  7664/4 सेरी 72.70 एम / एस 0.00 बी / एस 0.00% 93.15% आरएम -आर / एमएनटी / टेस्ट_डिर /
  5919/0 रूट 80.77 M / s 16.48 M / s 0.00% 80.68% [लूप 0] 

यानी rm -r /// साथ भीड़ वाली डाइरेक्टरी को हटाना ठीक है।

Rm ./* के माध्यम से हटाना

$ rm /mnt/test_dir/*
शेल की एक बाल प्रक्रिया शुरू करता है, जो 600MB तक बढ़ गया है , ^C लिए nailed ^C कुछ भी डिलीट नहीं किया।
जाहिर है, तारांकन द्वारा glob को शेल द्वारा ही संसाधित किया जाता है, मेमोरी में संचित किया जाता है और पूरी निर्देशिका के बाद rm कमांड को पास किया जाता है।

ढूँढें -exec के माध्यम से अनइंस्टॉल करें

$ find /mnt/test_dir/ -type f -exec rm -v {} \;
getdents() तहत, यह केवल getdents() कहता है। the ^C द्वारा nailed की find प्रक्रिया 600MB तक बढ़ गई ^C कुछ भी डिलीट नहीं किया।
शेल में * के समान कार्य करता है - पहले मेमोरी में एक पूरी सूची बनाता है।

खोज-के माध्यम से हटाना

$ find /mnt/test_dir/ -type f -delete
600MB तक बढ़ गया, ^C द्वारा nailed ^C कुछ भी डिलीट नहीं किया।
पिछले कमांड के समान। और यह बेहद अद्भुत है! मैंने शुरू में इस टीम पर अपनी उम्मीदें लगाईं।

Ls -f और xargs के माध्यम से निकालना

$ cd /mnt/test_dir/ ; ls -f . | xargs -n 100 rm
-f विकल्प कहता है कि आपको फाइलों की सूची को क्रमबद्ध करने की आवश्यकता नहीं है।
प्रक्रियाओं का एक पदानुक्रम बनाता है:

  |  - एलएस 212 केबी
  |  - xargs 108Kb
     |  - rm 130Kb # rm पर pid लगातार बदल रहा है 

सफलतापूर्वक हटाता है।

  iotop # बहुत कूदता है
  ५ ९ १ ९ हो / ० रूट ५. M / एम / एस ६.२ / एम / एस ०.००%% ९ .१५% [लूप ०] 

इस स्थिति में ls -f find तुलना में अधिक पर्याप्त रूप से व्यवहार करता है और अनावश्यक रूप से स्मृति में फ़ाइलों की सूची जमा नहीं करता है। ls बिना मापदंडों (जैसे find ) - फ़ाइलों की पूरी सूची को मेमोरी में पढ़ता है। जाहिर है छँटाई के लिए। लेकिन यह विधि खराब है क्योंकि यह लगातार rm कहती है, जो एक अतिरिक्त उपरि बनाता है।
एक अन्य तरीका इस प्रकार है - आप किसी फ़ाइल में ls -f के आउटपुट को रीडायरेक्ट कर सकते हैं और फिर इस सूची से निर्देशिका की सामग्री को हटा सकते हैं।

पर्ल रीडडीर के माध्यम से अनइंस्टॉल करें

$ perl -e 'chdir "/mnt/test_dir/" or die; opendir D, "."; while ($n = readdir D) { unlink $n }' $ perl -e 'chdir "/mnt/test_dir/" or die; opendir D, "."; while ($n = readdir D) { unlink $n }' ( यहां चुना गया )
getdents() तहत strace यह getdents() एक बार कॉल getdents() , फिर कई बार unlink() और इसी तरह लूप में करता है। यह बढ़ते हुए नहीं, मेमोरी की 380Kb ले गया।
सफलतापूर्वक हटाता है।

  iotop
  7591/4 सेरी 13.74 M / s 0.00 B / s 0.00% 98.95% perl -e chdi ...
  ५ ९ १ ९ हो / ० रूट ११.१ M मेसर्स १४३8. / / K / s ०.००% ९ ३. %५% [लूप ०] 

यह पता चला है कि रीडिर का उपयोग करना काफी संभव है?

सी प्रोग्राम रीडिर + अनलिंक के माध्यम से अनइंस्टॉल करें

 //file: cleandir.c #include <dirent.h> #include <sys/types.h> #include <unistd.h> int main(int argc, char *argv[]) { struct dirent *entry; DIR *dp; chdir("/mnt/test_dir"); dp = opendir("."); while( (entry = readdir(dp)) != NULL ) { if ( strcmp(entry->d_name, ".") && strcmp(entry->d_name, "..") ){ unlink(entry->d_name); // maybe unlinkat ? } } } 

$ gcc -o cleandir cleandir.c
$ ./cleandir
getdents() तहत strace यह getdents() एक बार कॉल getdents() , फिर कई बार unlink() और इसी तरह लूप में करता है। यह 128Kb मेमोरी लेता है , बढ़ता नहीं है।
सफलतापूर्वक हटाता है।

  iotop:
  7565/4 सेरी 11.70 M / s 0.00 B / s 0.00% 98.88% ./cleandir
  ५ ९ १ ९ हो / ० रूट १२.९ / एम / एस १०3 ९ .२३ के / एस ०.००% ९ २.४२% [लूप ०] 

फिर से, हम आश्वस्त हैं कि यदि आप मेमोरी में परिणाम जमा नहीं करते हैं और फ़ाइलों को तुरंत हटाते हैं तो readdir का उपयोग करना काफी सामान्य है।

निष्कर्ष

• आप लाखों फ़ाइलों वाली निर्देशिकाओं को हटाने के लिए readdir() + unlink() फ़ंक्शन के संयोजन का उपयोग कर सकते हैं।
• व्यवहार में, rm -r /my/dir/ , के रूप में उपयोग करना बेहतर है यह अधिक चतुराई से काम करता है - पहले मेमोरी में फ़ाइलों की अपेक्षाकृत छोटी सूची बनाता है, readdir() कई बार कॉल करता है, और फिर इस सूची से फ़ाइलों को हटा देता है। यह आपको हटाए जाने की गति को बढ़ाने की तुलना में पढ़ने और लिखने पर लोड को अधिक आसानी से वैकल्पिक करने की अनुमति देता है।
• सिस्टम पर लोड को कम करने के लिए, nice या ionice साथ संयोजन में उपयोग करें। या स्क्रिप्टिंग भाषाओं का उपयोग करें और छोरों में छोटी नींद () डालें। या ls -l माध्यम से फ़ाइलों की एक सूची तैयार करें और इसे एक धीमी पाइप के माध्यम से पास करें।
• इंटरनेट पर लिखी जाने वाली हर बात पर यकीन न करें! विभिन्न ब्लॉग अक्सर इस समस्या पर चर्चा करते हैं, और नियमित रूप से टूटे हुए समाधानों का सुझाव देते हैं।

पुनश्च: दुर्भाग्य से, मुझे निर्देशिका के पुनरावृत्ति पढ़ने के लिए पायथन कार्यों में नहीं मिला, जिसे मैं बहुत आश्चर्यचकित था; os.listdir () और os.walk () पूरी निर्देशिका पढ़ें। यहां तक ​​कि PHP में भी रीडिर है ।