सबसे अच्छा और बड़े निर्देशिका फ़ाइलों के हजारों (ubuntu में)

Question

युक्त नष्ट करने के लिए सबसे तेज़ तरीका क्या है मैं की तरह

find <dir> -type f -exec rm {} \; 

आदेशों सबसे अच्छा संस्करण जानते हैं फ़ाइलों की बड़ी राशि (कुल फ़ाइलें निकालने के लिए नहीं , सबफोल्डर सहित)। यदि आपके पास छोटी मात्रा में फाइलें हैं, तो यह अच्छा काम करता है, लेकिन यदि आपके पास सबफ़ोल्डर में 10+ mlns फ़ाइलें हैं, तो यह सर्वर को लटका सकता है।

क्या कोई इस समस्या को हल करने के लिए किसी विशिष्ट लिनक्स कमांड को जानता है?

Answer 1

यहाँ एक उदाहरण है बैश स्क्रिप्ट:

#!/bin/bash 

local LOCKFILE=/tmp/rmHugeNumberOfFiles.lock 

# this process gets ultra-low priority 
ionice -c2 -n7 -p $$ > /dev/null 
if [ $? ]; then 
    echo "Could not set disk IO priority. Exiting..." 
    exit 
fi 
renice +19 -p $$ > /dev/null 
if [ $? ]; then 
    echo "Could not renice process. Exiting..." 
    exit 
fi 

# check if there's an instance running already. If so--exit 
if [ -e ${LOCKFILE} ] && kill -0 `cat ${LOCKFILE}`; then 
    echo "An instance of this script is already running." 
    exit 
fi 

# make sure the lockfile is removed when we exit. Then: claim the lock 
trap "command rm -f -- $LOCKFILE; exit" INT TERM EXIT 
echo $$ > $LOCKFILE 

# also create a tempfile, and make sure that's removed too upon exit 
tmp=$(tempfile) || exit 
trap "command rm -f -- '$tmp'" INT TERM EXIT 



# ---------------------------------------- 
# option 1 
# ---------------------------------------- 
# find your specific files 
find "$1" -type f [INSERT SPECIFIC SEARCH PATTERN HERE] > "$tmp" 
cat $tmp | rm 

# ---------------------------------------- 
# option 2 
# ---------------------------------------- 
command rm -r "$1" 



# remove the lockfile, tempfile 
command rm -f -- "$tmp" $LOCKFILE 

यह स्क्रिप्ट अपनी प्रक्रिया प्राथमिकता निर्धारित करके शुरू होती है और डिस्कओआई प्राथमिकता बहुत कम मानों के लिए प्राथमिकता है, यह सुनिश्चित करने के लिए कि अन्य चल रही प्रक्रियाएं यथासंभव अप्रभावित हैं।

फिर यह सुनिश्चित करता है कि यह केवल ऐसी प्रक्रिया चल रही है।

स्क्रिप्ट का मूल वास्तव में आपकी वरीयता पर निर्भर है। यदि आप सुनिश्चित हैं कि पूरे डीआईआर को अनिश्चित रूप से हटाया जा सकता है (विकल्प 2), ​​या आप find का उपयोग अधिक विशिष्ट फ़ाइल हटाना (विकल्प 1, संभवतः कमांड लाइन विकल्प "$ 2" और ऑनव सुविधा के लिए कर सकते हैं) के लिए कर सकते हैं।

ऊपर कार्यान्वयन में, विकल्प 1 (find) पहले, एक tempfile के लिए सब कुछ आउटपुट ताकि rm समारोह केवल एक बार बजाय find द्वारा पाया प्रत्येक फ़ाइल के बाद कहा जाता है। जब फाइलों की संख्या वास्तव में बड़ी होती है, तो यह महत्वपूर्ण समय बचाने के लिए हो सकती है। डाउनसाइड पर, टेम्पफाइल का आकार एक मुद्दा बन सकता है, लेकिन यह केवल तभी संभव है जब आप सचमुच अरबों फाइलों को हटा रहे हों, प्लस, क्योंकि डिस्कियो की इतनी कम प्राथमिकता है, एक टेम्पफाइल का उपयोग करके rm कुल मिलाकर हो सकता है find (...) -exec rm {} \; विकल्प का उपयोग करने से धीमे रहें। हमेशा की तरह, आपको यह देखने के लिए थोड़ा सा प्रयोग करना चाहिए कि आपकी आवश्यकताओं के अनुरूप सबसे अच्छा क्या है।

संपादित करें: उपयोगकर्ता 946850 द्वारा सुझाए गए अनुसार, आप पूरे tempfile को भी छोड़ सकते हैं और find (...) -print0 | xargs -0 rm का उपयोग कर सकते हैं। इसमें एक बड़ी मेमोरी पदचिह्न है, क्योंकि सभी मिलान करने वाली फ़ाइलों के सभी पूर्ण पथ रैम में डाले जाएंगे जब तक कि find कमांड पूरी तरह से समाप्त नहीं हो जाता है। ऊपर की ओर: tempfile को लिखने के कारण कोई अतिरिक्त फ़ाइल IO नहीं है। कौन सा चयन करना आपके उपयोग-मामले पर निर्भर करता है।

Answer 2

-r (रिकर्सिव) स्विच निर्देशिका के नीचे सबकुछ हटा देता है - उपनिर्देशिका सहित। (आपका आदेश निर्देशिका केवल फ़ाइलों को हटा नहीं है,।)

तुम भी find दृष्टिकोण में तेजी लाने के कर सकते हैं:

find -type f -print0 | xargs -0 rm 

Answer 3

यह अजीब लग सकता है लेकिन:

$ rm -rf <dir> 

Answer 4

मैं इन आदेशों में से हर एक की कोशिश की, लेकिन समस्या यह मैं था कि हटाने की प्रक्रिया डिस्क ताला लगा दिया गया था, और तब से कोई अन्य प्रोसेस उस तक पहुँच सकता है, वहाँ डिस्क बनाने पर पहुँचने का प्रयास प्रक्रियाओं का एक बड़ा pileup था समस्या बदतर है। "Iotop" चलाएं और देखें कि आपकी प्रक्रिया कितनी डिस्क IO उपयोग कर रही है।

यहां मेरी समस्या हल करने वाली पाइथन लिपि है।यह एक समय में 500 फाइलों को हटा देता है, फिर दूसरी प्रक्रियाओं को अपना व्यवसाय करने के लिए 2 सेकंड ब्रेक लेता है, फिर भी जारी रहता है।

import os, os.path 
import time 

for root, dirs, files in os.walk('/dir/to/delete/files'): 
    i = 0 
    file_num = 0 
    for f in files: 
     fullpath = os.path.join(root, f) 
     i = i + 1 
     file_num = file_num + 1 
     os.remove(fullpath) 
     if i%500 == 1: 
      time.sleep(2) 
      print "Deleted %i files" % file_num 

आशा है कि इससे कुछ लोगों की मदद मिलेगी।

Answer 5

आप (मेरे मामले में कई जबरदस्ती शाखाओं में) एक बहुत बड़ी फ़ाइल पेड़ पर अंतरिक्ष की सीमा मुद्दे से निपटने के, कि कभी कभी फांसी पर लटका दिया जा रहा है की जरूरत है, जबकि खोज चल रहा है और इस प्रक्रिया को नष्ट -

यहाँ एक स्क्रिप्ट है कि मैं को दैनिक अनुसूची सभी निर्देशिकाओं पाया विशिष्ट फ़ाइल ("ChangesLog.txt"), और फिर क्रमबद्ध साथ सभी निर्देशिकाओं कि से अधिक उम्र के 2 दिनों कर रहे हैं, और सबसे पहले मिलने वाला निर्देशिका निकालें (प्रत्येक अनुसूची हो सकता है एक नया मैच):

bash -c "echo @echo Creating Cleanup_Branch.cmd on %COMPUTERNAME% - %~dp0 > Cleanup_Branch.cmd" 
bash -c "echo -n 'bash -c \"find ' >> Cleanup_Branch.cmd" 
rm -f dirToDelete.txt 
rem cd. > dirToDelete.txt 
bash -c "find .. -maxdepth 9 -regex ".+ChangesLog.txt" -exec echo {} >> dirToDelete.txt \; & pid=$!; sleep 100; kill $pid " 
sed -e 's/\(.*\)\/.*/\1/' -e 's/^./"&/;s/.$/&" /' dirToDelete.txt | tr '\n' ' ' >> Cleanup_Branch.cmd 
bash -c "echo -n '-maxdepth 0 -type d -mtime +2 | xargs -r ls -trd | head -n1 | xargs -t rm -Rf' >> Cleanup_Branch.cmd" 
bash -c 'echo -n \" >> Cleanup_Branch.cmd' 
call Cleanup_Branch.cmd 

नोट आवश्यकताएँ:

1. , "ChangesLog.txt" के साथ ही उन निर्देशिकाओं को हटाया जा रहा है क्योंकि अन्य पुराने निर्देशिका को हटाया नहीं जाना चाहिए।
2. cygwin सीधे में OS कमांड कॉलिंग, क्योंकि अन्यथा यह Windows डिफ़ॉल्ट आज्ञाओं का इस्तेमाल किया।
3. निर्देशिका एकत्रित बाहरी पाठ फ़ाइल में को सहेजें परिणाम मिल जाए, के बाद से कभी कभी खोजने प्रक्रिया फांसी पर लटका दिया गया है क्रम में नष्ट करने के लिए,।
4. पृष्ठभूमि प्रक्रिया का उपयोग कर पृष्ठभूमि प्रक्रिया को सेट करने के लिए का उपयोग करके ढूंढने की प्रक्रिया में टाइमआउट सेट करना।
5. निर्देशिका सबसे पुराने छंटाई पहले हटाने की प्राथमिकता के लिए।

Answer 6

यदि आपके पास खोजने का एक उचित आधुनिक संस्करण है (4.2.3 या इससे अधिक) तो आप -डिल्ड ध्वज का उपयोग कर सकते हैं।

find <dir> -type f -delete 

आप संस्करण 4.2.12 या अधिक से अधिक है, तो आप xargs शैली कमांड लाइन \+ -exec संशोधक के माध्यम से स्टैकिंग का लाभ ले सकते। इस तरह आप प्रत्येक फ़ाइल के लिए /bin/rm की एक अलग प्रति नहीं चलाते हैं।

find <dir> -type f -exec rm {} \+ 

Answer 7

पिछले आदेश अच्छे हैं।

rm -rf directory/ भी एक फ़ोल्डर में फ़ाइलों की अरब के लिए तेजी से काम करता है। मैंने कोशिश की।

Answer 8

तुम एक खाली निर्देशिका बनाने और निर्देशिका जो आप खाली करने के लिए जरूरत के लिए यह rsync कर सकते हैं। आप समय के लिए बाहर और बाहर स्मृति मुद्दा

Answer 9

आप जितनी जल्दी हो सके फ़ाइलों के टन हटाना चाहते हैं, तो रोक सकता है, इस प्रयास करें:

find . -type f -print0 | xargs -P 0 -0 rm -f

नोट -P विकल्प xargs उपयोग प्रक्रियाओं के रूप में कई कर देगा यथासंभव।