बैश पर स्क्रिप्ट लिखने के लिए ट्रिक्स। # २

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

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

• समान दिनांक / समय वाली फाइलें पहले से मौजूद नहीं हैं (यह -u विकल्प के साथ cp कमांड के साथ प्राप्त की जा सकती है)
• गंतव्य निर्देशिका में, सभी फ़ाइलें और निर्देशिकाएँ जो स्रोत में नहीं हैं नष्ट हो जाती हैं
• स्क्रिप्ट न केवल स्थानीय रूप से, बल्कि दूरस्थ कंप्यूटर पर भी डेटा को सिंक्रनाइज़ कर सकती है

दूसरे शब्दों में, रिसीवर में हमें वही मिलता है जो स्रोत में होता है, और यह सबसे इष्टतम तरीके से होता है। यह एक अत्यंत उपयोगी दृष्टिकोण है, उदाहरण के लिए, जब समय-समय पर बाहरी ड्राइव पर बड़ी मात्रा में डेटा की बचत होती है। केवल नया कॉपी किया जाता है, और जो बदल गया है, जबकि स्रोत में हटाए गए फाइलें रिसीवर में भी हटा दी जाती हैं। इसके अलावा, एक्सेस अधिकार, सेलिनक्स विशेषताएँ और विस्तारित फ़ाइल विशेषताएँ भी कॉपी की जाती हैं।

दरअसल, जैसा कि कई ने पहले ही अनुमान लगा लिया है, हम पहिया को फिर से नहीं बनाएंगे, लेकिन rsync प्रोग्राम का उपयोग करें, जो इसके लिए अभिप्रेत है। यहां कार्य हमारी स्क्रिप्ट के साथ rsync को लपेटना है ताकि इसका उपयोग करना सुविधाजनक हो। भला, कौन ऐसा कुछ लिखना चाहता है ?:

 rsync -rlptgoDvEAH --delete --delete-अलावा -super --force
 --progress --log-file = / var / log / rs-total.txt --log-file-format =% o% i% i% b% b
 / data / src / proj / perl / my / web / company / roga-i-kopyta /
 / data / save / proj / perl / my / web / company / roga-i-kopyta /

जाहिर है, हमारी स्क्रिप्ट में कम से कम 2 पैरामीटर हैं - स्रोत और रिसीवर निर्देशिका। पिछले लेख में, इस स्थिति पर विचार नहीं किया गया था, अर्थात्, कैसे, कुंजी के साथ, एक निश्चित स्थिति के मापदंडों को भी संसाधित करने के लिए। और यह बहुत ही वांछनीय है कि चाबियाँ कहीं भी डाली जा सकती हैं, तय मापदंडों के साथ उनके चारों ओर बहती हैं। उदाहरण के लिए:

dir-sync -key1 src-sri -key2 dest-dir key3 

पहले से वर्णित पैरामीटर पार्सिंग एल्गोरिथ्म आपको एक अनियंत्रित क्रम में और दो रूपों में चाबियाँ संसाधित करने की अनुमति देता है। यह केवल निम्नलिखित परिवर्तन करने के लिए बना हुआ है:

 #     fixPrmCnt=0 pSrcDir= # - pDstDir= # - ... while [ 1 ] ; do if [ "$1" = "--yes" ] ; then pYes=1 ... else #     . #    ( )    . # ,    « » - #       (( fixPrmCnt++ )) #      #  ( )  —     #    if [ 1 -eq $fixPrmCnt ] ; then pSrcDir="$1" elif [ 2 -eq $fixPrmCnt ] ; then pDstDir="$1" #    ,   #   -  else errMess ":  " exit 1 fi fi shift done 

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

अब हम अपनी क्लोनिंग स्क्रिप्ट की कार्यक्षमता को परिभाषित करते हैं। वह चाहिए:

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

और यहाँ एक और आकर्षण है:

• यदि आप -i स्विच निर्दिष्ट करते हैं, तो स्क्रिप्ट इंटरएक्टिव हो जानी चाहिए।

इस स्क्रिप्ट के लिए, यह सुविधा संभवतः अनावश्यक है। मैं इसका वर्णन करता हूं कि क्या संभव है, और कभी-कभी सुविधाजनक है। वास्तव में, यदि स्क्रिप्ट के पास कई विकल्प हैं, जिनके बारे में भूलना महत्वपूर्ण नहीं है, तो ऐसे अवसर के लिए प्रदान करना बेहतर है, लेकिन निश्चित रूप से, हर कारण के लिए नहीं। सामान्य नियम यह है कि अन्तरक्रियाशीलता वैकल्पिक होनी चाहिए। हालांकि, ऐसी स्क्रिप्ट हैं जो विशेष रूप से इंटरैक्टिव होनी चाहिए - उदाहरण के लिए, अनुभवहीन उपयोगकर्ताओं के लिए विशिष्ट कार्य करने के लिए।

खैर, वास्तव में कार्यात्मक:

• मोड का चयन: सटीक कॉपी / अपडेट
• पृष्ठभूमि मोड चालू करें (nohup के माध्यम से)
• एक लॉग फ़ाइल नाम निर्दिष्ट करना
• परिणामी rsync आदेश को देखने की क्षमता (एक उदाहरण के रूप में, और नहीं)

पहली बार, कार्यक्षमता पर्याप्त है। यदि आवश्यक हो, तो हम भविष्य में इसे विकसित करेंगे। मैं rsync और nohup का वर्णन नहीं करूंगा - बस उनके आदमी को पढ़ें।

हम सभी कुंजियों का वर्णन करते हैं:

• -हाँ: पुष्टि अनुरोध को दबाएं
• -आई | -एक्टिव: इंटरएक्टिव मोड को इनेबल करें
• -शहर | --log-file =: लॉग फ़ाइल का नाम सेट करें
• -यू | - अपडेट: अपडेट मोड (डिफ़ॉल्ट एक सटीक प्रतिलिपि है)
• -एससी | -शो-कमांड: rsync अंतिम कमांड दिखाएं
• -n | -dry- रन: "निष्क्रिय मोड" - rsync शुरू होता है और कार्यों के बारे में सूचित करता है, लेकिन वास्तव में कुछ भी नहीं करता है
• -बग | - बैकग्राउंड: बैकग्राउंड में रन करें

इन कुंजियों के लिए संगत चर की आवश्यकता होती है। तो स्क्रिप्ट का हेडर कुछ इस तरह होगा:

 #   fixPrmCnt=0 #    pInter= #   pLogFile= #  - pUpdate= #   pShowCmd= #   rsync pDryRun= #   pBackgr= #    pSrcDir= #   pDstDir= #   RSCmd= #  rsync RSPrm= #   rsync 

हम pyes पैरामीटर घोषित नहीं करते हैं, क्योंकि यह हमारे पुस्तकालय में है। अब कार्यक्रम के मुख्य ब्लॉकों पर विचार करें।

यहाँ पैरामीटर हैंडलिंग क्या दिखता है:

 if [ -z "$1" ] ; then usage exit fi while [ 1 ] ; do if [ "$1" = "--yes" ] ; then pYes=1 elif [ "$1" = "-i" ] ; then pInter=1 elif [ "$1" = "--interactive" ] ; then pInter=1 elif procParmS "-lf" "$1" "$2" ; then pLogFile="$cRes" ; shift elif procParmL "--log-file" "$1" ; then pLogFile="$cRes" elif [ "$1" = "-u" ] ; then pUpdate=1 elif [ "$1" = "--update" ] ; then pUpdate=1 elif [ "$1" = "-sc" ] ; then pShowCmd=1 elif [ "$1" = "--show-command" ] ; then pShowCmd=1 elif [ "$1" = "-n" ] ; then pDryRun=1 elif [ "$1" = "--dry-run" ] ; then pDryRun=1 elif [ "$1" = "-bg" ] ; then pBackgr=1 elif [ "$1" = "--background" ] ; then pBackgr=1 elif [ -z "$1" ] ; then break #   else (( fixPrmCnt++ )) if [ 1 -eq $fixPrmCnt ] ; then pSrcDir="$1" elif [ 2 -eq $fixPrmCnt ] ; then pDstDir="$1" else errMess ":  " exit 1 fi fi shift done 

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

 checkParm "$pSrcDir" "  -" checkParm "$pDstDir" "  -" if [ "$pInter" = "1" ] && [ "$pYes" = "1" ] ; then errMess " : --yes  -i" exit 1 fi #   ,    pSrcDir="${pSrcDir%/}" pDstDir="${pDstDir%/}" checkDir "$pSrcDir" checkDir "$pDstDir" 

स्क्रिप्ट का गैर-संवादात्मक भाग बहुत सरल लगता है:

 #    if [ "$pInter" != "1" ] ; then #   if [ "$pYes" != "1" ] ; then echo " ${curScript##*/}  !" showInfo myAskYesNo "    !  ?" || exit fi createCmd 

फ़ंक्शन showInfo और createCmd पर बाद में चर्चा की जाएगी - यह, वास्तव में, मापदंडों के बारे में जानकारी प्रदर्शित करना और rsync कमांड उत्पन्न करना है।

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

  cat <<EOF  ${curScript##*/}  !        .   : ------------------------ c) clone ( ) u) update ( ) .)  EOF input1 " : " "cu." [ "$cRes" = "." ] && exit pBackgr= #    ,     input1 "       ? (y/n): " "yn." [ "$cRes" = "." ] && exit [ "$cRes" = "y" ] && pBackgr=1 #       ,      read -p "  - ( : $pLogFile): " a1 [ -n "$a1" ] && pLogFile="$a1" [ "$a1" = "." ] && exit pShowCmd= #    ,     input1 "    ? (y/n): " "yn." [ "$cRes" = "." ] && exit [ "$cRes" = "y" ] && pShowCmd=1 createCmd echo #     showInfo if [ "$pShowCmd" = "1" ] ; then echo " rsync:" echo " $RSCmd" "${RSPrm[@]}" fi myAskYesNo "!  ?" || exit 

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

ShowInfo और createCmd फ़ंक्शन भी हैं।

और अब हम इनपुट 1 फ़ंक्शन को थोड़ा संशोधित करते हैं (लाइब्रेरी में देखें) ताकि यह एक पैरामीटर को स्वीकार करे जो कहता है कि यदि आप एक बिंदु पर क्लिक करते हैं, तो आपको स्क्रिप्ट से बाहर निकलने की आवश्यकता है - "डॉट-एक्जिट"। हम प्रत्येक पैरामीटर के प्रसंस्करण के लिए एक पंक्ति को बाहर करते हैं! अब इसके लिए जिम्मेदार कोड का हिस्सा इस तरह दिखता है:

  input1 " : " "cu." "dot-exit" pBackgr= #    ,     input1 "       ? (y/n): " "yn." "dot-exit" [ "$cRes" = "y" ] && pBackgr=1 #       ,      read -p "  - ( : $pLogFile): " a1 [ -n "$a1" ] && pLogFile="$a1" pShowCmd= #    ,     input1 "    ? (y/n): " "yn." "dot-exit" [ "$cRes" = "y" ] && pShowCmd=1 

आप आगे जा सकते हैं और मापदंडों को दर्ज करने के लिए कई कार्य कर सकते हैं। लेकिन हम अगली बार इसे छोड़ देंगे।

अंत स्पष्ट है:

 if [ "$pBackgr" = "1" ] ; then nohup $RSCmd "${RSPrm[@]}" & else $RSCmd "${RSPrm[@]}" fi 

हम सरणी के उपयोग पर थोड़ा बाद में विचार करेंगे, लेकिन अब हम ध्यान देते हैं कि चूंकि rsync को बहुत ही अंत में लॉन्च किया गया है, इसलिए इसका निष्पादन हमारी स्क्रिप्ट के निष्पादन का परिणाम होगा। इस तरह, हम नियम को लागू करते हैं कि किसी भी स्क्रिप्ट का परिणाम वापस होना चाहिए।

अब हम उन कार्यों को देखते हैं जो सरल और सीधे भी हैं।

 showInfo() { local a1 if [ "$pUpdate" = "1" ] ; then a1="" else a1="" fi padMid 80 "" "$a1" ; echo $cRes padMid 80 "" "$pSrcDir" ; echo $cRes padMid 80 "" "$pDstDir" ; echo $cRes padMid 80 "-" "$pLogFile" ; echo $cRes transYesNoRu $pBackgr padMid 80 "  " "$cRes" ; echo $cRes transYesNoRu $pDryRun padMid 80 "   " "$cRes" ; echo $cRes } 

यहां हम पैरामीटर मानों को खूबसूरती और समान रूप से प्रदर्शित करने के लिए पैडमिड लाइब्रेरी फ़ंक्शन का उपयोग करते हैं (पैरामीटर "80" - लाइन की चौड़ाई)। 1 का transYesNoRu फ़ंक्शन बाकी "नहीं" का "हां" बनाता है।

निष्कर्ष लगभग इस प्रकार है:

 .....................................  .......................... /data/src/proj/fed16 ........................... /data/src/proj/sync -......................... /var/log/dir-sync.log   ...................................     ........................  

और अंत में, स्क्रिप्ट का दिल rsync कमांड की पीढ़ी है, जहां चाबियाँ निर्दिष्ट मापदंडों के अनुसार क्रमिक रूप से जोड़ी जाती हैं।

 createCmd() { RSCmd="$rsync" if [ "$pUpdate" = "1" ] ; then RSCmd="$RSCmd -urlptgoDvEAH" else RSCmd="$RSCmd -rlptgoDvEAH --delete" fi #    -    ,   if [ "$pBackgr" = "1" ] ; then RSCmd="$RSCmd -q" else RSCmd="$RSCmd --progress -v" fi if [ "$pDryRun" = "1" ] ; then RSCmd="$RSCmd -n" fi RSCmd="$RSCmd --super --force" #   -   n=-1 ((n++)) ; RSPrm[n]="--log-file=$pLogFile" ((n++)) ; RSPrm[n]="$pSrcDir/" ((n++)) ; RSPrm[n]="$pDstDir/" } 

यही है, createCmd RSCmd चर बनाता है, जो तब स्क्रिप्ट के अंत में चलाया जाता है।

विशेष रूप से नोट RSPrm सरणी का उपयोग है। तथ्य यह है कि यदि फ़ाइल नामों में रिक्त स्थान हैं (और हम एक अधिक या कम सार्वभौमिक स्क्रिप्ट लिख रहे हैं जो इसे ध्यान में रखना चाहिए), तो RSCmd की एक पंक्ति को इकट्ठा करना काम नहीं करेगा। अंत याद रखें: $ RSCmd "$ {RSPrm [@]}"? अगर सब कुछ केवल $ $ RSCmd में पैक किया गया था और अंत $ RSCmd की तरह लग रहा था, तो रिक्त स्थान के साथ रिक्त स्थान के साथ निर्देशिका या लॉग फ़ाइल का नाम टूट जाएगा। उदाहरण के लिए, यदि आप स्रोत निर्देशिका "मेरी डीर" को निर्दिष्ट करते हैं, तो "मेरे डीआईआर" को कॉपी करने के बजाय, जहां संकेत दिया गया है, वहां मेरी कॉपी को डीआईआर में कॉपी करने की कोशिश होगी, और फिर उस "कहीं" पर वापस आ जाएगी।

एक साथ एक स्ट्रिंग डाल करने का प्रयास

 RSCmd="$RSCmd \"$pSrcDir/\" \"$pDstDir/\" " 

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

एक सरणी का उपयोग इस समस्या को हल करता है। सरणी को एक नियमित चर (RSPrm =) के रूप में भी आरंभीकृत किया जाता है, अधिक सटीक रूप से, यह एक नियमित चर है जब तक कि इसे एक सरणी के रूप में उपयोग नहीं किया जाता है। और यह ठीक वैसा ही है जब हम निष्पादित करते हैं ((n ++)); RSPrm [n] = "- लॉग-फाइल = $ pLogFile"। बैश में सरणी सूचक शून्य से शुरू होते हैं। बहुमुखी प्रतिभा और पठनीयता के लिए, हम n = -1 को इनिशियलाइज़ करते हैं, ताकि बाद में हम इसे बढ़ाएँ और एक नया वैध इंडेक्स प्राप्त करें।

सरणी का उपयोग अंत में होता है:

 $RSCmd "${RSPrm[@]}" 

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

सामान्य तौर पर, इस तरह से सरणियों का उपयोग अत्यंत उपयोगी होता है जब पैरामीटर रिक्त स्थान वाले तार होते हैं। उदाहरण के लिए, एक ही rsync फ़ाइल फ़िल्टरिंग विकल्पों को स्वीकार कर सकता है, जैसे: '-f- * .tmp', जिसका अर्थ है कि * .tmp फ़ाइलों को सिंक्रनाइज़ेशन के दौरान अनदेखा किया जाता है। तो, '-f- * .tmp' एक एकल पैरामीटर है जिसमें एक स्थान होता है। यदि आप एक बार लाइनें एकत्र करते हैं, तो आप इन मापदंडों को उद्धरण चिह्नों या प्रकार के एपोस्ट्रोफिस में निर्दिष्ट कर सकते हैं:

 rsync ... '-f- *.tmp' '-f- *.log' ... 

लेकिन अगर आप पहले इस तरह के तार को इकट्ठा करने की कोशिश करते हैं, और फिर इसे निष्पादित करते हैं, तो एक गार्ड होगा! उदाहरण के लिए:

 param="-f- *.tmp" param="$param -f- *.log" 

इसी तरह काम नहीं करेगा और

 param="'-f- *.tmp'" param="$param '-f- *.log'" 

और ऐसे मामलों में, हम ऊपर वर्णित अनुसार सरणी का उपयोग करने के लिए मजबूर हैं।

सारांश

• हमने पार्सिंग एल्गोरिदम में निश्चित पैरामीटर प्रसंस्करण को जोड़ा।
• हमने देखा कि अन्तरक्रियाशीलता को सरल और समझने योग्य साधनों के साथ प्रदान किया जा सकता है।
• हमने देखा कि पुस्तकालय के कार्य स्पष्टता और लेखन में आसानी लाते हैं।
• हमने देखा कि कैसे ऐरे पैरामीटर बनाने में मदद कर सकते हैं
• हमें इसकी क्षमताओं के भीतर वास्तव में काम करने वाली स्क्रिप्ट मिली

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

मैं उन पाठकों का ध्यान आकर्षित करूंगा, जो rsync से परिचित नहीं हैं - निर्देशिका में से एक को रिमोट मशीन पर फॉर्म में सेट किया जा सकता है

 [user@][host:]dir-from-root 

वह है

 vova@mycomp:/save/work mycomp:/save/work 

एक स्क्रिप्ट कॉल हो सकता है, उदाहरण के लिए, इस तरह:

 dir-sync -u /work mycomp:/save/work 

अगर ऐसे पाठक हैं जो इस स्क्रिप्ट को विकसित करना जारी रखना चाहेंगे - टिप्पणियों में लिखें।

लाइब्रेरी की फाइलें और स्क्रिप्ट खुद यहां पाई जा सकती हैं ।