मैं एक निश्चित मात्रा में डिस्क स्थान उपयोग के साथ चुनिंदा उपयोगकर्ताओं को कैसे खोज सकता हूं?

Question

मैं /home/निर्देशिका में दिखाए गए सभी उपयोगकर्ताओं को खोजना चाहता हूं जिनकी डिस्क खपत 500 एमबी से अधिक है। निम्न आदेश अपेक्षित रूप से कार्य करता है।

cd /home/ && du */ -hs
68K     ajay/
902M    john/
250M    websites/

उपरोक्त उदाहरण से, केवल 902M john/वापस लौटाया जाना चाहिए।

मैं findकमांड आउटपुट को समान परिणाम कैसे बना सकता हूं ?

Comments

मैं एक समाधान ढूंढ रहा हूं जो "खोज" कमांड के साथ काम करेगा।

— शांतनुओ

कोई विशेष कारण आप इस कार्य के लिए खोज करना चाहते हैं? मैं सिर्फ cd / home / && du * / -ms करता हूँ | awk '$ 1> 500 {प्रिंट $ 0}'

— vtest

क्या आप कृपया इसे उत्तर के रूप में पोस्ट कर सकते हैं? यह काम करने लगता है। लेकिन मुझे मानव पठनीय डिस्क खपत आंकड़ा कैसे मिलता है?

— शांतनुओ

Answer 1

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

du -sm */ | sort -k1,1n | awk '$1 > 500 { sub(/$/, "M", $1); print $0 }'

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

Answer 2

यकीन नहीं है कि आप ऐसा कुछ क्यों चाहते हैं find, इसलिए यहां एक स्क्रिप्ट है जो वह करता है जो आप पूछते हैं bash(लेकिन खोजने की तरह काम नहीं करता है):

max_size=$((500*1024))
cd /home/ && du -ks */ | while read size user ; do
  if [ $size -gt $max_size ] ; then
    echo "${user%/} exceeds quota"
  fi
done

उदाहरण: (छोटे आकार के साथ):

$ du -sk */
2948    a/
4       a b/
640     b/
48      qt/

$ du -ks */ | while read size user ; do if [ $size -gt 600 ] ; then echo "${user%/} exceeds quota" ; fi ; done
a exceeds quota
b exceeds quota

${user%/}बस अतिरिक्त prettyness के लिए स्लैश निकाल देता है।

Comments

पहला उदाहरण उम्मीद के मुताबिक काम किया। दूसरे आदेश के मामले में, $ आकार को पाठ के रूप में माना जाता है और संख्या के रूप में नहीं।

— शांतनुओ

@ शांतनुओ: मैं उस टिप्पणी को नहीं समझता। ऊपर एक ही लिपि है।

— चटाई

@ शांतनुओ आपका खोल क्या है? मैट ने लिखा कि उनका जवाब है bash।

— डैनियल बेक

Answer 3

यह dirउन फ़ाइलों की परवाह किए बिना प्रत्येक उपयोगकर्ता की फ़ाइलों के लिए डिस्क उपयोग (kb में) प्रिंट करेगा :

find dir -printf "%u %b\n" | perl -n -e '@l = split; $sum{$l[0]} += $l[1]; END { foreach(sort(keys(%sum))) { print "$_ ",$sum{$_}/2," KiB\n"; }}'

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

Answer 4

उत्तर के रूप में पोस्टिंग।

मैंने लगातार आउटपुट प्राप्त करने के लिए डु-एमएमएस का उपयोग किया है जिसे अतिरिक्त हस्तक्षेप के बिना awk द्वारा संसाधित किया जा सकता है। आप सही हैं कि मानव पठनीय आउटपुट बेहतर है, इसलिए अंतिम आउटपुट उसके लिए एक बार फिर से संसाधित हो जाता है।

#!/bin/bash

######################################################################
#  AUTHOR: Joe Negron - LOGIC Wizards ~ NYC
#  LICENSE: BuyMe-a-Drinkware: Dual BSD or GPL (pick one)
#  USAGE: byteMe (bytes)
#  ABSTRACT: Converts a numeric parameter to a human readable format.
#  URL: http://www.logicwizards.net/2010/10/19/byteme-a-simple-binary-metrics-bash-script-howto-convert-bytes-into-kb-mb-gb-etc-using-bash-bc/
######################################################################
function byteMe() { # Divides by 2^10 until < 1024 and then append metric suffix
declare -a METRIC=('B' 'KB' 'MB' 'GB' 'TB' 'XB' 'PB') # Array of suffixes
MAGNITUDE=0  # magnitude of 2^10
PRECISION="scale=1" # change this numeric value to inrease decimal precision
UNITS=`echo $1 | tr -d ','`  # numeric arg val (in bytes) to be converted
while [ ${UNITS/.*} -ge 1024 ] # compares integers (b/c no floats in bash)
  do
   UNITS=`echo "$PRECISION; $UNITS/1024" | bc` # floating point math via `bc`
   ((MAGNITUDE++)) # increments counter for array pointer
  done
echo -n "$UNITS${METRIC[$MAGNITUDE]}"
}

cd /home/ && du */ -bs | awk '$1 > 500 { print $0 }' | while read LINE; do
    SIZE=$(echo "$LINE" | cut -f 1)
    HRSIZE=$(byteMe "$SIZE")
    DIR=$(echo "$LINE" | cut -f 2)
    printf "%8s %s\n" "$HRSIZE" "$DIR"
done

टिप्पणियाँ:

1. बश फ़ंक्शन को googling द्वारा पाया गया (टिप्पणियां देखें)
2. मैंने du -ms को du -bs में बदल दिया है , इस प्रकार यह बाइट स्वीकार करने वाले रूपांतरण फ़ंक्शन का उपयोग करना संभव बनाता है।
3. 500MB सीमा अभी भी हार्डकोड है। इसे तर्क के रूप में स्वीकार करने के लिए स्क्रिप्ट को संशोधित करने के लिए स्वतंत्र महसूस करें।