सार : एक कहानी कैसे जल्दी और खूबसूरती से प्रक्रिया में सूचीबद्ध करता है एक शेल में, xargs पर थोड़ा मैनुअल और प्रोग्रामिंग या प्रशासन के दर्शन के बारे में बहुत सारा पानी।

थोड़ा एसईओ अनुकूलन: करी, लैम्ब्डा फ़ंक्शन, फ़ंक्शन की संरचना, नक्शा, सूची को फ़िल्टर करना, शेल में सेट के साथ काम करना।

उदाहरण

सिस्टम प्रशासक अक्सर खुद को ऐसी स्थिति में पाते हैं जहां आपको एक प्रोग्राम का आउटपुट लेने की जरूरत होती है, और प्रत्येक आउटपुट एलिमेंट पर एक अलग प्रोग्राम लागू होता है। या एक भी नहीं। एक अजीब (और बेकार) उदाहरण के रूप में, हम निम्नलिखित लेते हैं: आपको सभी निष्पादन योग्य फ़ाइलों के कुल आकार की गणना करने की आवश्यकता है जो वर्तमान में सिस्टम पर चल रहे सभी गतिशील पुस्तकालयों के साथ उपयोग करते हैं।

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

गीत

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

एक और इस तरह दिखता है:
सूची में एक फ़ंक्शन पर लागू करें जो सूची के प्रत्येक तत्व पर लागू होता है, यदि यह तत्व एक गैर-रिक्त स्ट्रिंग है और इस नाम के साथ फ़ाइल आकार शून्य नहीं है, तो राशि में जोड़ें।

यहां तक ​​कि शब्दों से पता चलता है कि दूसरा विकल्प छोटा है।

प्रोग्रामिंग भाषाओं के अभिव्यंजक साधनों को ध्यान में रखते हुए, निर्माण प्राप्त किए जाते हैं जो कि सामान्य चक्रों की समस्याओं से भरे और रहित होते हैं - लूप्स, चक्र से गलत निकास, आदि।

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

निर्णय डेटा

समस्या को हल करने के लिए, हमें चलने वाली प्रक्रियाओं की एक सूची प्राप्त करने की आवश्यकता है। यह लगता है की तुलना में आसान है - सभी प्रक्रियाओं / खरीद / [0-9] + में हैं। अगला, हमें बाइनरी के लिए पथों की आवश्यकता है। और यह भी सरल है: परमाणु खरीद को छोड़कर सभी प्रक्रियाओं के लिए / proc / PID / exe, प्रक्रिया के लिए पथ को इंगित करता है। अगला कार्य: हमें फ़ाइल के लिए पुस्तकालयों की सूची चाहिए। यह ldd कमांड द्वारा किया जाता है, जो फ़ाइल पथ की अपेक्षा करता है और पुस्तकालयों की सूची प्रदर्शित करता है। अगला प्रश्न प्रौद्योगिकी है और सिर्लिंक के चारों ओर घूमना - हमें स्टॉप तक लाइब्रेरी सिम्लिंक्स से गुजरने की आवश्यकता है, और फिर प्रत्येक फाइलों के आकार की गणना करें।

इस प्रकार, कार्य का एक उच्च-स्तरीय विवरण इस तरह दिखता है: निष्पादन योग्य फ़ाइलों और पुस्तकालयों की सूची लें, और उनमें से प्रत्येक के लिए आकार का पता लगाएं।

ध्यान दें कि इस प्रक्रिया में, निष्पादन योग्य फ़ाइलों की सूची का उपयोग दो बार किया जाएगा - एक बार "अपने आप से", दूसरी बार - प्रत्येक फ़ाइल के पुस्तकालयों की सूची प्राप्त करने के लिए।

इंपीरियल निर्णय

(अतिरंजना और विवरण छोड़ना)

get_exe_list(){ for a in `ls /proc/*; do readlink -f $a/exe; done } get_lib(){ for a in `cat `; do ldd $a done |awk '{print $3}' } calc(){ sum=0 sum=$(( $sum + `for a in $(cat); do du -b $a|awk '{print $1}'; done` )) } exe_list=`get_exe_list|sort -u` lib_list=`for a in $exe_list; do get_lib $a;done|sort -u` size=$(( calc_size $exe_list + calc_size $lib_list)) echo $size 

घृणित, सही? यह, हम ध्यान देते हैं, कि पिल्स के सही फ़िल्टरिंग के लिए रेगेक्सपी के बिना (हमें noxistent / proc / mdstat / exe पढ़ने की कोशिश करने की आवश्यकता नहीं है) और त्रुटियों के कई मामलों को संभालने के बिना।

सूचियों

हम कार्य के बारे में जानते हैं। चूंकि हमारे इनपुट डेटा सजातीय फाइलें हैं, इसलिए हम उन्हें बस एक सूची के रूप में पेश कर सकते हैं और उन्हें उसी तरह से संसाधित कर सकते हैं। कैप्सूल मैं कोड के "नहीं लिखा" लिखेंगे।

भाग एक: डबल सूची प्रसंस्करण

हम थोड़ा धोखा देते हैं, और सूची को डुप्लिकेट करने के लिए stderr का उपयोग करते हैं।

 (EXE_LIST |tee /dev/stderr|LIB_LIST) 2>&1 | CALC 

यह कोड क्या करता है? EXE_LIST का अलिखित भाग सिस्टम में एक exe सूची बनाता है। टी इस सूची को लेता है, stderr को लिखता है (स्ट्रीम नंबर 2) और stdout को लिखता है (स्ट्रीम नंबर 1)। थ्रेड # 1 LIB_LIST को दिया गया है। इसके बाद, हम सभी तीन कमांड (ब्रैकेट) के आउटपुट को stderr के साथ जोड़ते हैं और इसे एक सूची के रूप में stdout में डालते हैं और इसे CALC को पास करते हैं।

अब हमें EXE_LIST करने की आवश्यकता है

भाग दो: फ़िल्टरिंग सूची

(लगभग। सिस्टम में _all_ प्रक्रियाओं को देखने के लिए, आपको एक रूट होने की आवश्यकता है)।

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

तो: find /proc/ -maxdepth 2 -name "exe" -ls
हमें थ्रेड्स को अनदेखा करने के लिए मैक्सडेप की आवश्यकता है, हमें एलएस के आउटपुट के समान एक निष्कर्ष मिलता है। हमें इसे फ़िल्टर करने की आवश्यकता है।

इसलिए, हम EXE_LIST में सुधार करते हैं:

 find /proc/ -name "exe" -ls 2>/dev/null|awk '{print $13}' 

अवलोकन: हम डेटा संचारित करने के लिए stderr का उपयोग करेंगे, इसलिए हमें सभी प्रकार के परमाणु धागे के साथ समस्याओं के बारे में बाढ़ का पता लगाने की आवश्यकता नहीं है।

भाग तीन: LIB_LIST

यह सरल है: हस्तांतरित प्रत्येक फ़ाइल के लिए, हमें ldd का उपयोग करने की आवश्यकता है, और फिर आउटपुट को कंघी करें।

 xargs -n 32 -P 4 ldd 2>/dev/null|grep "/"|awk '{print $3}' 

क्या दिलचस्प है? हम एक समय में अधिकतम 32 फ़ाइलों तक सीमित करते हैं, और समानांतर में 4 ldd कतारें चलाते हैं (हाँ, हमारे पास इस तरह का एक होमग्राउंड हडप है)। -पी विकल्प आपको ldd के प्रदर्शन को समानांतर करने की अनुमति देता है, जो हमें मल्टी-कोर मशीनों और अच्छे डिस्क पर कुछ गति को बढ़ावा देगा (fopping इस मामले में है, लेकिन अगर हम ldd की तुलना में कुछ धीमी गति से कर रहे हैं, तो समानांतरवाद एक मोक्ष हो सकता है ... )।

भाग चार: CALC

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

रीडलिंक जोड़ें। और वह, संक्रमण, एक समय में एक पैरामीटर चाहता है। लेकिन एक विकल्प -f है, जो हमें बहुत प्रयास करेगा - यह फ़ाइल का नाम दिखाएगा, चाहे वह कोई सिमिलिंक हो या केवल एक फ़ाइल।

| xargs -n 1 -P 16 readlink -f | Sort -u

... इसलिए, हम डु का उपयोग करके आकार का निर्धारण करेंगे। ध्यान दें कि हम यहाँ -सी विकल्प का उपयोग कर सकते हैं, जो संख्याओं को बताता है और एक उत्तर देता है, लेकिन प्रशिक्षण पाठ्यक्रम में हम सरल तरीकों की तलाश नहीं कर रहे हैं। तो, मुहले के बिना।

| xargs -n 32 -P 4 du -b | awk '{sum + = $ 1} END {प्रिंटफ "% i \ n", sum}'

हमें सॉर्ट -यू की आवश्यकता क्यों है? तथ्य यह है कि हमारे पास बहुत सारे पुनरावृत्ति होंगे। हमें सूची से अद्वितीय मानों का चयन करने की आवश्यकता है, अर्थात् सूची को एक सेट में बदल दें। यह भोली विधि के साथ किया जाता है: हम सूची को सॉर्ट करते हैं और कहते हैं, सॉर्ट करते समय दोहराए गए लाइनों को बाहर फेंक दें।

एक-लाइनर, भयानक

हम सब कुछ एक साथ लिखते हैं:

(ढूँढें / proc /name exe -ls 2> / dev / null | awk '{प्रिंट $ 13}' | tee / dev / stderr | xargs -n 32 -P 4 ldd 2> / dev / null। grep /। awk '{प्रिंट $ 3}') 2> & 1 | सॉर्ट -यू | xargs -n 1 -P 16 readlink -f | xargs -n 32 -P 4 du -b | awk '{sum + = $ 1} END {प्रिंट योग "}

(मैंने इस डरावने में कच्चा टैग नहीं लगाया, ताकि लाइन स्वचालित रूप से लपेटी जाए, ताकि आप आरएसएस को फाड़ न सकें, मुझे प्यार करें।)

बेशक, यह इस बात से बेहतर नहीं है कि शुरुआत में क्या दिया गया था। भय और आतंक, एक शब्द में। हालांकि, अगर आप 98 के स्तर के गुरु हैं और 99 वें स्विंग करते हैं, तो ऐसे सिंगल-लाइन खिलाड़ी कार्य की सामान्य शैली हो सकते हैं ...

हालांकि, 10 वें स्तर पर हमले के लिए वापस।

निर्णय देखने का

हम इसे काटना चाहते हैं। कोड के पठनीय और डीबग किए गए टुकड़ों के लिए। साने। टिप्पणी की।

इसलिए, लेखन के प्रारंभिक रूप पर वापस जाएँ: (EXE_LIST | tee / dev / stderr | LIB_LIST) 2> & 1 | CALC

पठनीय? खैर, शायद हाँ।

यह पता लगाना रहता है कि कैसे EXE_LIST को ठीक से लिखना है

विकल्प एक: कार्यों का उपयोग करना:

 EXE_LIST (){ find /proc/ -name "exe" -ls 2>/dev/null|awk '{print $13}' } LIB_LIST (){ xargs -n 32 -P 4 ldd 2>/dev/null|grep /|awk '{print $3}' } CALC (){ sort -u|xargs -n 1 -P 16 readlink -f|xargs -n 32 -P 4 du -b|awk '{sum+=$1}END{print sum}' } (EXE_LIST |tee /dev/stderr|LIB_LIST) 2>&1 | CALC 

और थोड़ा कार्यात्मक बड़प्पन:

 EXE_LIST () ( find /proc/ -name "exe" -ls 2>/dev/null|awk '{print $13}' ) LIB_LIST () ( xargs -n 32 -P 4 ldd 2>/dev/null|grep / |awk '{print $3}' ) CALC() ( sort -u|xargs -n 1 -P 16 readlink -f|xargs -n 32 -P 4 du -b|awk '{sum+=$1}END{print sum}' ) (EXE_LIST |tee /dev/stderr|LIB_LIST) 2>&1 | CALC 

बेशक, एफएनपी के शुद्धतावादी कहेंगे कि कोई प्रकार का अनुमान नहीं है, उन पर कोई नियंत्रण नहीं है, कोई आलसी गणना नहीं है, और सामान्य तौर पर, इस सूची को एक कार्यात्मक शैली - पागलपन और पोर्नोग्राफी में प्रसंस्करण मानते हैं।

हालांकि, यह कोड है, यह काम करता है, लिखना आसान है। यह एक वास्तविक उत्पाद वातावरण नहीं है, लेकिन यह आसानी से एक उपकरण हो सकता है जो तीन घंटे के नीरस काम से तीन मिनट की दिलचस्प प्रोग्रामिंग को छोड़ देता है। यह सिस्टम व्यवस्थापक की बारीकियों है।

मुख्य बात जो मैं दिखाना चाहता था: शेल में अनुक्रम के प्रसंस्करण के लिए एक कार्यात्मक दृष्टिकोण एक प्रत्यक्ष प्रवाह से अधिक पठनीय और कम भारी कोड देता है। और यह तेजी से काम करता है, वैसे (xargs concurrency के कारण)।

scalabilty

"शेल हडुप" का एक और विकास गन्न समानताएं उपयोगिता है, जो समानांतर में कई सर्वरों पर कोड को निष्पादित करने की अनुमति देता है।