Rm, cp, mv komutları için bağımsız değişken listesi çok uzun hata

UNIX'te bir dizin altında birkaç yüz PDF'im var. PDF'lerin adları gerçekten uzundur (yaklaşık 60 karakter).

Aşağıdaki komutu kullanarak tüm PDF'leri birlikte silmeye çalıştığımda:

rm -f *.pdf

Aşağıdaki hatayı alıyorum:

/bin/rm: cannot execute [Argument list too long]

Bu hatanın çözümü nedir? Bu hata mvve cpkomutlar için de oluşuyor mu? Evetse, bu komutlar için nasıl çözülür?

Bunun olmasının nedeni, bash'ın yıldız işaretini eşleşen her dosyaya genişletmesi ve çok uzun bir komut satırı üretmesidir.

Bunu dene:

find . -name "*.pdf" -print0 | xargs -0 rm

Uyarı: bu yinelemeli bir aramadır ve alt dizinlerdeki dosyaları da bulur (ve siler). Tack -femin misin onay istemiyoruz yalnızca, rm komutuna.

Komutu özyinelemesiz yapmak için aşağıdakileri yapabilirsiniz:

find . -maxdepth 1 -name "*.pdf" -print0 | xargs -0 rm

Başka bir seçenek de -deletefind'ın bayrağını kullanmaktır :

find . -name "*.pdf" -delete

tl; Dr.

Komut satırı bağımsız değişkeninin boyutuyla ilgili bir çekirdek sınırlamasıdır. forBunun yerine bir döngü kullanın.

Sorunun kaynağı

Bu, sürekli execveve ARG_MAXsabit bir sistem sorunudur . Bununla ilgili çok sayıda belge var (bkz. Adam yürütmek , debian'ın wiki'si ).

Temel olarak, genişletme sınırı aşan bir komut (parametreleriyle birlikte) üretir ARG_MAX. Çekirdekte 2.6.23sınır olarak belirlendi 128 kB. Bu sabit artırıldı ve şu komutu uygulayarak değerini alabilirsiniz:

getconf ARG_MAX
# 2097152 # on 3.5.0-40-generic

Çözüm: forDöngü Kullanma

BashFAQ / 095'tefor önerildiği gibi bir döngü kullanın ve RAM / bellek alanı dışında bir sınır yoktur:

Kuru çalışma beklediğiniz şeyi siler:

for f in *.pdf; do echo rm "$f"; done

Ve yürütün:

for f in *.pdf; do rm "$f"; done

Glob, mermiler arasında güçlü ve tutarlı davranışa sahip olduğundan ( POSIX spesifikasyonunun bir parçası ) da bu taşınabilir bir yaklaşımdır .

Not: Birkaç yorumda belirtildiği gibi, bu, daha karmaşık senaryoları uyarlayabildiğinden, örneğin bir eylemden daha fazlasını yapmak istediği yerlerde gerçekten daha yavaş ancak daha sürdürülebilirdir .

Çözüm: Kullanma find

Eğer ısrar ederseniz, kullanabilirsiniz findama gerçekten xargs kullanmayın o kadar "tehlikeli (kırık, işletilebilir, vs.) girişi olmayan NUL ayrılmış okurken" :

find . -maxdepth 1 -name '*.pdf' -delete 

-maxdepth 1 ... -deleteBunun yerine kullanmak , gerekli sistem çağrılarının harici bir işlem kullanmadan kolayca yürütülmesini -exec rm {} +sağlar find, bu nedenle daha hızlı ( @chepner comment sayesinde ).

Referanslar

• "Bağımsız değişken listesi çok uzun" alıyorum. Parçalar halinde büyük bir listeyi nasıl işleyebilirim? @ yildiz
• execve (2) - Linux kılavuz sayfası (ARG_MAX araması);
• Hata: Bağımsız değişken listesi çok uzun @ Debian'ın wiki'si;
• Alıntılanan bağımsız değişkenleri iletirken neden “/ bin / sh: Bağımsız değişken listesi çok uzun” alıyorum? @ SuperUser

findbir -deleteeylemi var:

find . -maxdepth 1 -name '*.pdf' -delete

Başka bir yanıt, xargskomutları toplu olarak işlemeye zorlamaktır . Örneğin , bir seferde deletedosyalara , dizine girin ve çalıştırın:100cd

echo *.pdf | xargs -n 100 rm

Ya da deneyebilirsiniz:

find . -name '*.pdf' -exec rm -f {} \;

Bir kerede çok sayıda dosyayı silmeye çalışıyorsanız (bugün 485.000'den fazla bir dizini sildim), muhtemelen bu hatayla karşılaşacaksınız:

/bin/rm: Argument list too long.

Sorun bir şey gibi yazarken yani rm -rf *, *“rm-rf dosya1 dosya2 dosya3 file4” ve benzeri gibi her eşleşen dosya listesi ile değiştirilir. Bu argüman listesini saklamak için ayrılmış küçük bir bellek tamponu vardır ve doldurulursa, kabuk programı yürütmez.

Bu sorunu aşmak için, birçok kişi her dosyayı bulmak için find komutunu kullanacak ve bunları tek tek “rm” komutuna aşağıdaki gibi aktaracaktır:

find . -type f -exec rm -v {} \;

Benim sorunum 500.000 dosyayı silmem gerekti ve çok uzun sürüyordu.

Dosyaları silmenin çok daha hızlı bir yoluna rastladım - “find” komutunun içinde “-delete” bayrağı var! İşte ben kullanarak sona erdi:

find . -type f -delete

Bu yöntemi kullanarak, dosyaları yaklaşık 2000 dosya / saniye hızında siliyordum - çok daha hızlı!

Dosya adlarını silerken de gösterebilirsiniz:

find . -type f -print -delete

… Ya da kaç dosyanın silineceğini, daha sonra bunların silinmesinin ne kadar süreceğini gösterin:

root@devel# ls -1 | wc -l && time find . -type f -delete
100000
real    0m3.660s
user    0m0.036s
sys     0m0.552s

bunu deneyebilirsiniz:

for f in *.pdf
do
  rm $f
done

EDIT: ThiefMaster yorum genç kabuk jedis böyle tehlikeli uygulama ifşa etmemem önerir, bu yüzden daha "daha güvenli" bir sürüm ekleyeceğim (birisi "-rf. ..Pdf" dosyası olduğunda bir şeyler korumak uğruna)

echo "# Whooooo" > /tmp/dummy.sh
for f in '*.pdf'
do
   echo "rm -i $f" >> /tmp/dummy.sh
done

Yukarıdakileri çalıştırdıktan sonra, /tmp/dummy.sh dosyasını fav. düzenleyin ve her bir satırda tehlikeli dosya adları olup olmadığını kontrol edin.

Sonra çalışma dizinine dummy.sh komut dosyasını kopyalayın ve çalıştırın.

Bütün bunlar güvenlik nedeniyle.

Bir bash dizisi kullanabilirsiniz:

files=(*.pdf)
for((I=0;I<${#files[@]};I+=1000)); do
    rm -f "${files[@]:I:1000}"
done

Bu şekilde adım başına 1000 dosyalık gruplar halinde silinir.

bu övgüyü kullanabilirsiniz

find -name "*.pdf"  -delete

Rm komutu aynı anda kaldırabilirsiniz dosyaların bir sınırlama vardır.

Rm komutunu birden çok kez kullanarak dosya desenlerinize dayanarak bunları kaldırabilirsiniz :

rm -f A*.pdf
rm -f B*.pdf
rm -f C*.pdf
...
rm -f *.pdf

Bunları find komutuyla da kaldırabilirsiniz :

find . -name "*.pdf" -exec rm {} \;

Boşluklu veya özel karakterli dosya adlarıysa, şunları kullanın:

find -maxdepth 1 -name '*.pdf' -exec rm "{}" \;

Bu cümle, geçerli dizindeki tüm dosyaları (-maxdepth 1) pdf (-name '* .pdf') uzantısıyla arar ve her birini (-exec rm "{}") siler.

{} İfadesi dosyanın adını değiştirir ve "{}" dosya adını boşluklar veya özel karakterler de dahil olmak üzere dize olarak ayarlar.

form kaynak dizini hedefe kopyalarken aynı sorunla karşı karşıyaydım

kaynak dizinde ~ 3 lakcs dosyaları vardı

cp seçeneğini -r ile kullandım ve benim için çalıştı

cp -r abc / def /

argüman listesini çok uzun süre uyarmadan abc'den def'e tüm dosyaları kopyalar

Bunu da deneyin 30/90 günün (+) üzerinde veya 30/90 (-) günlük dosya / klasörlerin altında silmek isterseniz, aşağıdaki ex komutlarını kullanabilirsiniz

Örn: 90 gün boyunca 90 gün boyunca dosya / klasör silindikten sonra hariç tutulur, 91,92 .... 100 gün anlamına gelir

find <path> -type f -mtime +90 -exec rm -rf {} \;

Örn: Yalnızca silmek istediğiniz en son 30 günlük dosyalar için aşağıdaki komutu kullanın (-)

find <path> -type f -mtime -30 -exec rm -rf {} \;

Dosyaları 2 günden fazla gizlemek istiyorsanız

find <path> -type f -mtime +2 -exec gzip {} \;

Dosyaları / klasörleri yalnızca son bir aydan itibaren görmek istiyorsanız. Ör:

find <path> -type f -mtime -30 -exec ls -lrt {} \;

Sadece 30 günden fazla dosya / klasör listeleme Örn:

find <path> -type f -mtime +30 -exec ls -lrt {} \;

find /opt/app/logs -type f -mtime +30 -exec ls -lrt {} \;

ulimitBurada cevap olmadığına şaşırdım . Ne zaman bu problemim olursa, buraya veya buraya geliyorum . Bu çözümün sınırlamaları olduğunu anlıyorum ama ulimit -s 65536benim için sık sık hile yapıyor gibi görünüyor.

Her gün büyüyen geçici resimlerle dolu bir klasörle aynı sorunu yaşadım ve bu komut klasörü temizlememe yardımcı oldu

find . -name "*.png" -mtime +50 -exec rm {} \;

Diğer komutlardaki fark, yalnızca X günden daha eski dosyaları alacak mtime parametresidir (örnek 50 günde)

Bunu birkaç kez kullanarak, gün aralığındaki her yürütmeyi azaltarak, tüm gereksiz dosyaları kaldırabildim

Sadece bunun için bir yol biliyorum. Fikir, sahip olduğunuz pdf dosyaları listesini bir dosyaya aktarmaktır. Sonra bu dosyayı birkaç parçaya bölün. Ardından her bölümde listelenen pdf dosyalarını kaldırın.

ls | grep .pdf > list.txt
wc -l list.txt

wc -l list.txt dosyasının kaç satır içerdiğini saymaktır. Ne kadar uzun olduğu hakkında bir fikriniz olduğunda, onu ikiye, ileriye veya başka bir şeye bölmeye karar verebilirsiniz. Split -l komutunu kullanma Örneğin, her biri 600 satıra bölün.

split -l 600 list.txt

bu xaa, xab, xac adında birkaç dosya oluşturacaktır. Şimdi bu dosyadaki her listeyi rm komutuna "içe aktarmak" için şunu kullanın:

rm $(<xaa)
rm $(<xab)
rm $(<xac)

Kötü ingilizcem için özür dilerim.

Bu problemle birkaç kez karşılaştım. Çözümlerin çoğu, rmsilinmesi gereken her bir dosya için komutu çalıştırır . Bu çok verimsiz:

find . -name "*.pdf" -print0 | xargs -0 rm -rf

Dosya adındaki ilk 4 karaktere göre dosyaları silmek için bir python komut dosyası yazdım:

import os
filedir = '/tmp/' #The directory you wish to run rm on 
filelist = (os.listdir(filedir)) #gets listing of all files in the specified dir
newlist = [] #Makes a blank list named newlist
for i in filelist: 
    if str((i)[:4]) not in newlist: #This makes sure that the elements are unique for newlist
        newlist.append((i)[:4]) #This takes only the first 4 charcters of the folder/filename and appends it to newlist
for i in newlist:
    if 'tmp' in i:  #If statment to look for tmp in the filename/dirname
        print ('Running command rm -rf '+str(filedir)+str(i)+'* : File Count: '+str(len(os.listdir(filedir)))) #Prints the command to be run and a total file count
        os.system('rm -rf '+str(filedir)+str(i)+'*') #Actual shell command
print ('DONE')

Bu benim için çok işe yaradı. Yaklaşık 15 dakika içinde bir klasördeki 2 milyondan fazla geçici dosyayı temizleyebildim. Ben az python bilgisi olan herkes bu kodu manipüle böylece kod biraz dışında tar yorumladı.

Ve bir tane daha:

cd  /path/to/pdf
printf "%s\0" *.[Pp][Dd][Ff] | xargs -0 rm

printfbir kabuk yerleşiktir ve bildiğim kadarıyla hep böyle olmuştur. Şimdi verilenprintf bunun bir kabuk komutu değil (bir yerleşik) olduğu , "argument list too long ... ölümcül hataya .

Böylece, kabuk kabartma desenleri ile güvenle kullanabiliriz *.[Pp][Dd][Ff], sonra ( rm) komutunu kaldırmak için çıkışınıxargs , bu da komut satırında başarısız olmamak için komut satırında yeterli dosya adına uyduğundan emin olur.rm , bu da bir kabuk olan komutun komut.

\0İçinde printfo zamana kadar işlenir wich dosya adları için boş ayırıcı olarak sunulduğunda xargsbunu kullanarak komutu ( -0) ayırıcı olarak, yani rmbeyaz boşluk veya dosya adlarında diğer özel karakterler varken başarısız değil.

Bir geçici klasör oluşturabilir, saklamak istediğiniz tüm dosyaları ve alt klasörleri geçici klasöre taşıyabilir, ardından eski klasörü silebilir ve geçici klasörü eski klasöre yeniden adlandırabilirsiniz.

mkdir testit
cd testit
mkdir big_folder tmp_folder
touch big_folder/file1.pdf
touch big_folder/file2.pdf
mv big_folder/file1,pdf tmp_folder/
rm -r big_folder
mv tmp_folder big_folder

rm -r big_foldertüm dosyaları kaldıracak big_folderkaç olursa olsun. Sadece tutmak istediğiniz tüm dosyalara / klasörlere sahip olduğunuza çok dikkat etmelisiniz, bu durumdafile1.pdf

*.pdfBir dizindeki tümünü silmek için/path/to/dir_with_pdf_files/

mkdir empty_dir        # Create temp empty dir

rsync -avh --delete --include '*.pdf' empty_dir/ /path/to/dir_with_pdf_files/

rsyncJoker karakter kullanarak belirli dosyaları silmek , milyonlarca dosyanız olması durumunda en hızlı çözümdür. Ve aldığınız hata ile ilgilenecektir.

(İsteğe bağlı Adım): KURU ÇALIŞTIR. Silmeden nelerin silineceğini kontrol etmek için. '

rsync -avhn --delete --include '*.pdf' empty_dir/ /path/to/dir_with_pdf_files/

. . .

Daha fazla rsync kesmek için rsync ipuçlarını ve püf noktalarını tıklayın

Çok büyük dosya listeleri (> 1e6) için bu yanıtların çok yavaş olduğunu gördüm. İşte python'da paralel işleme kullanan bir çözüm. Biliyorum, biliyorum, bu linux deđil ... ama burada baţka hiçbirţey çalýţmadý.

(Bu bana saatler kazandırdı)

# delete files
import os as os
import glob
import multiprocessing as mp

directory = r'your/directory'
os.chdir(directory)


files_names = [i for i in glob.glob('*.{}'.format('pdf'))]

# report errors from pool

def callback_error(result):
    print('error', result)

# delete file using system command
def delete_files(file_name):
     os.system('rm -rf ' + file_name)

pool = mp.Pool(12)  
# or use pool = mp.Pool(mp.cpu_count())


if __name__ == '__main__':
    for file_name in files_names:
        print(file_name)
        pool.apply_async(delete_files,[file_name], error_callback=callback_error)

Tüm inode'ları dolduran bir uygulama tarafından oluşturulan milyonlarca işe yaramaz günlük dosyası olduğunda benzer bir sorunla karşılaştım. Ben "bulmak" için başvurdu, tüm dosyaları "bulunan" d bir metin dosyasına aldım ve sonra bunları tek tek kaldırıldı. Bir süre aldı ama işi yaptı!

Xargs kullanmaktan biraz daha güvenli bir sürüm, özyinelemeli değil: ls -p | grep -v '/$' | grep '\.pdf$' | while read file; do rm "$file"; done

Buradaki dizinlerimizi filtrelemek biraz gereksiz çünkü 'rm' onu silmeyecek ve basitlik için kaldırılabilir, ancak neden kesinlikle hata döndürecek bir şey çalıştırıyorsunuz?

GNU parallel ( sudo apt install parallel) kullanmak çok kolay

'{}' İletilen argüman olan çoklu iş parçacıklı komutları çalıştırır

Örneğin

ls /tmp/myfiles* | parallel 'rm {}'

İlk 100 dosyayı kaldırmak için:

rm -rf 'ls | kafa -100 '

Aşağıdaki seçenek bu sorun için basit görünüyor. Bu bilgiyi başka bir iş parçacığından aldım ama bana yardımcı oldu.

for file in /usr/op/data/Software/temp/application/openpages-storage/*; do
    cp "$file" /opt/sw/op-storage/
done

Yukarıdaki komutlardan birini çalıştırmanız yeterlidir.