Rsync में कुल प्रगति दिखा रहा है: क्या यह संभव है?


229

मैंने पहले ही इस विकल्प को खोज लिया है, लेकिन केवल ऐसे समाधान खोजे हैं जिनमें कस्टम पैचिंग शामिल है । तथ्य यह है कि यह --help में नहीं दिखता है और कोई और जानकारी नहीं मिल सकती है, शायद यह इंगित करता है कि उत्तर 'नहीं' है, लेकिन मैं इस बात की पुष्टि करना चाहता हूं।

क्या rsync के साथ कुल फ़ाइल स्थानांतरण प्रगति दिखाना संभव है ?


22
चूंकि rsync 3.1.0 में अब एक मूल कुल फ़ाइल स्थानांतरण प्रगति शामिल है। जवाब देखें serverfault.com/a/441724/107793 जानकारी के लिए।
फ्लोरियन फेलदौस

14
कृपया स्वीकृत उत्तर बदलें। @ डेविड का जवाब पूरी तरह से बेकार है।
नवीन

जवाबों:


36

डानाकिम सही है। कुल प्रगति सूचक जोड़ने के लिए कोई तुच्छ तरीके नहीं हैं।

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

दूसरे शब्दों में, गणना करने का सबसे आसान तरीका यह है कि वास्तव में कितना काम करना है।


42
आपके पास अभी भी एक साधारण संकेतक हो सकता है जैसे (डेटा ट्रांसफर + डेटा स्किप्ड) / (स्रोत में कुल डेटा), या (# फ़ाइलें स्थानांतरित या छोड़ दी गई) / (# स्रोत में फ़ाइलें)। यह विशेष रूप से सटीक नहीं होगा, लेकिन यह एक विचार देगा। जब आप दिन के अंत में एक बड़ा स्थानान्तरण कर रहे हों, तो अच्छा होगा और आप सोच रहे होंगे कि क्या आस-पास रुकें और कंप्यूटर बंद करें, या इसे रात भर चलने दें ...
naught101

3
मैं नहीं मानता कि निष्कर्ष सही है। मुझे लगता है कि @ n-0101 प्रश्न के लिए अधिक उचित है, और मुझे लगता है कि इसका उपयोग न करने --size-onlyया इस तरह से जवाब देने की भविष्यवाणी करना गलत है।
इवान कैरोल

2
जिस समय मैंने उत्तर लिखा था, यह सटीक था - rsync के पास कुल प्रगति संकेतक के लिए एक तंत्र नहीं था। और हाँ, आप अपने खुद के लिख सकते हैं, लेकिन बहुत कम लोग करेंगे।
डेविड मैकिनटोश

6
नवागंतुकों के लिए टिप्पणी: अब यह संभव है: serverfault.com/a/441724/422003
23

दो पास का उपयोग करते हुए, पहले "--dry-run" (कुल अपेक्षित फ़ाइल गणना) और दूसरा एक फ़ाइल में लॉग किए गए विस्तृत आउटपुट के साथ (और लाइनों को पूर्ण या 'pv' के लिए एक पाइप का उपयोग करके), आसानी से पूरा होने का अनुमान लगाने की अनुमति देता है। नकारात्मक पक्ष नेस्टेड निर्देशिकाओं को दो बार स्कैन कर रहा है। जरूरत के आधार पर, यानी सुरक्षित ग्राहक डेटा माइग्रेशन सुनिश्चित करना, यह स्वीकार्य हो सकता है।
Ives

377

अब rsync (संस्करण 3.1.0 प्रोटोकॉल संस्करण 31, Ubuntu ट्रस्टी 14.04 के साथ परीक्षण) में ऐसा करने का एक आधिकारिक तरीका है।

#> ./rsync -a --info=progress2 /usr .
    305,002,533  80%   65.69MB/s    0:00:01  xfr#1653, ir-chk=1593/3594)

मैंने अपने /usrफ़ोल्डर के साथ कोशिश की, क्योंकि मैं पूरे फाइल सिस्टम /usrको स्थानांतरित करने के लिए यह सुविधा चाहता था, और एक अच्छा प्रतिनिधि नमूना प्रतीत हो रहा था।

यह --info=progress2एक अच्छा समग्र प्रतिशत देता है, भले ही यह एक आंशिक मूल्य हो। वास्तव में, मेरा /usrफ़ोल्डर 6 गिग्स से अधिक है:

#> du -sh /usr
6,6G    /usr/

और rsyncयह सब स्कैन करने के लिए बहुत समय लगा। तो लगभग हर समय मैंने जो प्रतिशत देखा है वह लगभग 90% पूरा हो गया था, लेकिन फिर भी यह देखने के लिए आराम है कि कुछ कॉपी किया जा रहा है :)

संदर्भ:


19
ध्यान दें कि यह 3.1.0 में उतरा है। यह भी ध्यान रखना महत्वपूर्ण है कि यह समय के परिप्रेक्ष्य में आवश्यक नहीं है। यह अनिवार्य रूप से डेटा की मात्रा दिखा रहा है जिसे दूरस्थ छोर पर मौजूद होने के लिए सत्यापित किया गया है। और दर वह दर है जिस पर दूरस्थ छोर पर डेटा को सही होने के लिए सीखा जा रहा है (चाहे वह पहले से ही इस तरह से था या नया डेटा स्थानांतरित किया गया था और इसे सही बनाया गया था)। इसलिए यद्यपि आपको बहुत उपयोगी समझने की आवश्यकता है।
केविन कॉक्स

15
होमब्रेक के साथ OSX पर इसका उपयोग करने के लिए, "ब्रू टैप होमब्रे / डुप्स; ब्रिउप इंस्टाल rsync"
मैट कैरियर

18
वर्थ नोटिंग जो --info=progress2साथ काम नहीं करता है-v
sanmai

42
--no-i-rस्विच को अस्वेल में जोड़ें , ताकि rsyncइंक्रीमेंट पर स्कैन न हो लेकिन पूरी तरह से कॉपी करने से पहले और जाने कि कितना काम बाकी है।
एलेक्स

16
ध्यान दें कि आप MB (GB) में कुल आकार देखने के लिए --human-readable(या -h) का उपयोग कर सकते हैं ।
नक्स

45

आप 'pv' ( apt-get install pvडेबियन और उबंटू के साथ) के साथ कर सकते हैं । मैं हस्तांतरित फ़ाइलों की संख्या की निगरानी करने की सलाह देता हूं, क्योंकि हस्तांतरित डेटा की मात्रा फ़ाइलों के आकार से संबंधित नहीं है, लेकिन स्रोत और गंतव्य के बीच डेल्टा पर। और फाइलों की गिनती एक बड़े डेल्टा के लिए समान प्रगति और दूसरे छोटे डेल्टा के साथ गिनती होगी। जिसका अर्थ है कि किसी भी मामले में ईटीए आकलन बहुत दूर हो सकता है। आकार-आधारित ईटीए केवल तभी काम करता है यदि आपका गंतव्य खाली है, इस मामले में == स्रोत का आकार।

सामान्य विचार rsync से फ़ाइल 'ट्रांसफर' की एक पंक्ति का उत्सर्जन करना है, और उन पंक्तियों को 'pv' के साथ गिनना है:

rsync -ai / स्रोत रिमोट: / भाग्य | pv -les [फाइलों की संख्या]> / dev / null

मैं (कई कारणों से) बैकअप पूरी फ़ाइल सिस्टम के लिए करते हैं, इस मामले में आप बहुत सस्ता उपयोग कर सकते हैं dfफ़ाइलों की संख्या प्राप्त करने के लिए (बजाय duया findजो rsync के बाद यह किया अपने स्रोत पदानुक्रम एक और समय तय करेंगे)। -X विकल्प यह सुनिश्चित करने के लिए प्रतीत होता है कि rsync एक ही स्रोत फाइल सिस्टम पर रहता है (और अन्य आंतरिक आरोह का अनुसरण नहीं करता है):

rsync -aix / स्रोत रिमोट: / भाग्य | pv -les $ (df -i / source | perl -ane 'प्रिंट $ F [2] अगर $ F [5] = ~ m: ^ /:')> / dev / null

यदि आप सामान्य तरीके से / स्रोत में फ़ाइलों को गिनना चाहते हैं, तो उपयोग करें find /source|wc -l(पुनः चेतावनी: I / O पर धीमा और भारी हो सकता है)।


1
जैसा कि zerodeuz निर्दिष्ट किया गया है, "df" का उपयोग केवल तब करें जब आप पूरे विभाजन को rsyncing कर रहे हों, क्योंकि df -i /sourceसभी विभाजन जिसमें से / स्रोत रहते हैं , इनोड्स (फ़ाइलों) की संख्या प्राप्त होती है। अन्यथा "$ ()" अभिव्यक्ति के अंदर एक निर्देशिका के अंदर फाइलों को गिनने के लिए 'खोज' का उपयोग करें ।
लेप

1
के लिए एक वैकल्पिक duया findमान लीजिए कि आप एक अधूरी प्रति परिष्करण या हटाए साथ एक में जगह अद्यतन कर रहे हैं - - उपयोग करने के लिए है rsync -ai --dry-runएक ही फाइल सूची मुख्य चलाने के लिए गुजर रहा हो जाएगा प्राप्त करने के लिएpv
Izkata

32

निम्नलिखित rsync संस्करण 3.0.0 और इसके बाद के संस्करण पर लागू होता है। नीचे दिए गए विकल्प 1 मार्च, 2008 को जारी किए गए थे।

--Info = प्रगति 2 के साथ-साथ आप वृद्धिशील पुनरावृत्ति को अक्षम करने के लिए भी -no -inc-recursive विकल्प (या इसके छोटे - कोई- अन्य उपनाम) का उपयोग नहीं कर सकते हैं।

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

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

निम्नलिखित rsync मैनुअल (स्रोत - http://rsync.samba.org/ftp/rsync/rsync.html ) से है:

-आर, - व्यापक

यह निर्देशिकाओं को पुनरावर्ती रूप से कॉपी करने के लिए rsync को बताता है। यह भी देखें - dirs (-d)। Rsync 3.0.0 के साथ शुरुआत करते हुए, पुनरावर्ती एल्गोरिथ्म का उपयोग अब एक वृद्धिशील स्कैन है जो पहले की तुलना में बहुत कम मेमोरी का उपयोग करता है और पहले कुछ निर्देशिकाओं के स्कैनिंग के बाद स्थानांतरण शुरू होता है। यह वृद्धिशील स्कैन केवल हमारे पुनरावृत्ति एल्गोरिथ्म को प्रभावित करता है, और गैर-पुनरावर्ती हस्तांतरण को नहीं बदलता है। यह केवल तभी संभव है जब हस्तांतरण के दोनों छोर कम से कम संस्करण 3.0.0 हैं।

पूर्ण फ़ाइल सूची जानने के लिए कुछ विकल्पों में rsync की आवश्यकता होती है, इसलिए ये विकल्प वृद्धिशील पुनरावर्तन मोड को अक्षम करते हैं। इनमें शामिल हैं: --delete-before, --delete-after, -prune-blank-dirs और --delay-updates। इसके कारण, जब आप निर्दिष्ट करते हैं, तो डिफ़ॉल्ट डिलीट मोड --delete अब है -delete-दौरान जब कनेक्शन के दोनों छोर कम से कम 3.0.0 हैं (उपयोग --del या --delete- के दौरान इस बेहतर डिलीटेशन मोड का अनुरोध करने के लिए स्पष्ट रूप से)। यह भी देखें कि - डिलीट-डिले का विकल्प जो कि उपयोग करने से बेहतर विकल्प है - वेडली-आफ्टर।

वृद्धिशील पुनरावृत्ति को -no-inc-recursive विकल्प या इसके छोटे - कोई- अन्य उपनाम का उपयोग करके अक्षम किया जा सकता है ।

विशिष्ट संस्करण अंतर के लिए https://rsync.samba.org भी देखें (स्क्रॉल करें और रिलीज़ समाचार लिंक देखें)।


3
इसके लिए धन्यवाद, अन्य उत्तरों का परिणाम एक% आयु है जो ऊपर और नीचे जाता रहता है!
आर्टफुलब्रोट

28

लंबे तबादलों के लिए, मैं du -sदोनों तरफ से खुश हूं । यहां तक ​​कि watch -n1 du -s, अगर मैं वास्तव में चिंतित महसूस करता हूं।

watchdu -sसमय-समय पर (यहां हर 1 सेकंड) एक कमांड निष्पादित करता है और आउटपुट फुलस्क्रीन दिखाता है।


4
watchकमांड के उदाहरण के लिए धन्यवाद !
कैम

2
// , चालाक! Linfo.org के अनुसार: "डु (यानी, डिस्क उपयोग) कमांड ट्री के आकार को उनकी सभी सामग्री और व्यक्तिगत फ़ाइलों के आकार को शामिल करता है। यह स्पेस हॉग्स, निर्देशिका और फ़ाइलों को ट्रैक करने के लिए उपयोगी बनाता है। हार्ड डिस्क ड्राइव (HDD) या अन्य स्टोरेज मीडिया पर बड़ी या अत्यधिक मात्रा में जगह की खपत करता है। "
नाथन बासानीस

10
मैं नहीं जानता कि आप किस प्रकार के लंबे स्थानान्तरण करते हैं, जहाँ डु व्यवहार्य है। डु नरक के रूप में धीमी है जब परिणाम टीबी और एम फाइलों में होगा।
कोई भी

2
मेरे "लंबे स्थानान्तरण" के लिए एक डु ऑपरेशन को पूरा होने में लगभग एक घंटा लगता है, जिसके दौरान rsync बहुत धीमी गति से चल रहा है, क्योंकि वे डिस्क तक पहुंच से लड़ रहे हैं।
अभि बेकर्ट

12

मूल रूप से नहीं। आप केवल -प्रोग्रेस फ़्लैग के साथ प्रति-फ़ाइल प्रगति दिखा सकते हैं, लेकिन वह इसके बारे में है।

मुझे लगता है कि आप इसके चारों ओर एक आवरण लिख सकते हैं या आपके द्वारा पहले से ढूंढे गए किसी भी पैच का उपयोग कर सकते हैं लेकिन आपको खुद से पूछना चाहिए कि क्या यह वास्तव में लायक है, क्या आपको वास्तव में rsync के लिए कुल प्रगति की आवश्यकता है?


यहाँ एक आवरण लिपि है, जो कुल प्रगति और फ़ाइल प्रगति को एक अच्छी प्रगति पट्टी के रूप में दिखाती है
j13r

1
आप --progressकाम करने के तरीके को बदल सकते हैं --info=progress2, यह आपको वैश्विक प्रगति दिखाएगा। उपयोगी होने के लिए आपको वृद्धिशील पुनरावर्ती एल्गोरिथ्म को अक्षम करना होगा, इसलिए--info=progress2 --no-inc-recursive
Mat

@ j13r आप इस जिस्ट को एक उत्तर के रूप में भी साझा कर सकते हैं! इसका बढ़िया विकल्प!
स्काईविंदर

8

मैंने zerodeux से उत्तर का उपयोग किया और अपनी छोटी सी बाश स्क्रिप्ट लिखी:

#!/bin/bash

RSYNC="ionice -c3 rsync"
# don't use --progress
RSYNC_ARGS="-vrltD --delete --stats --human-readable"
SOURCES="/dir1 /dir2 /file3"
TARGET="storage::storage"

echo "Executing dry-run to see how many files must be transferred..."
TODO=$(${RSYNC} --dry-run ${RSYNC_ARGS} ${SOURCES} ${TARGET}|grep "^Number of files transferred"|awk '{print $5}')

${RSYNC} ${RSYNC_ARGS} ${SOURCES} ${TARGET} | pv -l -e -p -s "$TODO"

7

मैंने यह भी खोजा कि rsync के साथ कुल प्रगति को कैसे दिखाया जाए और मुझे इस पोस्ट से एक उपयोगी उत्तर मिला है: https://stackoverflow.com/questions/7157973/monitoring-rsync-progress

मूल रूप से, आप rsync 3.1.0 के देव संस्करण में --info = प्रगति 2 का उपयोग कर सकते हैं । यहाँ डॉक्टर ने कहा है:

एक --info = प्रगति 2 विकल्प भी है जो व्यक्तिगत फ़ाइलों के बजाय पूरे स्थानांतरण के आधार पर आंकड़ों को आउटपुट करता है। फ़ाइल नाम आउटपुट के बिना इस ध्वज का उपयोग करें (उदाहरण से बचें -v या निर्दिष्ट करें --info = name0 यदि आप यह देखना चाहते हैं कि स्क्रीन को बहुत सारे नामों के साथ स्क्रॉल किए बिना स्थानांतरण कैसे हो रहा है। - (आपको निर्दिष्ट करने की आवश्यकता नहीं है - प्रगति विकल्प का उपयोग करने के लिए --info = प्रगति 2।)


1
--info=name0सोना है gold
ipatch

6

मैंने zerodeux से उत्तर का उपयोग किया और अपनी छोटी BASH स्क्रिप्ट लिखी:

#!/bin/bash

RSYNC="ionice -c3 rsync"
# don't use --progress
RSYNC_ARGS="-vrltD --delete --stats --human-readable"
SOURCES="/dir1 /dir2 /file3"
TARGET="storage::storage"

#echo "Executing dry-run to see how many files must be transferred..."
TODO=$(find ${SOURCES} | wc -l)

${RSYNC} ${RSYNC_ARGS} ${SOURCES} ${TARGET} | pv -l -e -p -s "$TODO"

मैंने TODO को ड्राई-रन में बदल दिया

TODO=$(find ${SOURCES} | wc -l)

यह फाइलों की संख्या बहुत तेजी से पाता है!


rsync --dry-run की तुलना में बहुत बेहतर काम करता है !
होपसेकर

4
findकेवल तभी काम करता है जब आप rsyncस्थानीय स्तर पर काम कर रहे हों । rsync --dry-runदूरस्थ स्रोतों के साथ भी काम करता है ...
voretaq7

6

यदि आपके पास नवीनतम rsync नहीं है (उदाहरण के लिए, OS X में 2.6.9 है) और उपयोग नहीं कर सकता है --info=progress2, तो प्रगति पर पाठ स्क्रॉल करने के पृष्ठों से खुद को बचाने के लिए यहां एक और विकल्प है:

rsync -aPh <source> <destination> | xargs -L1 printf "\33[2K\rTransferring: %s"

यह एक लाइन पर प्रिंट हो जाएगा, नवीनतम फ़ाइल का नाम हस्तांतरित किया जा रहा है:

Transferring: the-latest.file


4

उपयोग

lsof -ad3-999 -c rsync

यह देखने के लिए कि वर्तमान में कौन सी फाइलें rsync खुली हैं (स्थानीय रूप से छिपी हुई फ़ाइल में rsync प्रतियां दिखाई देंगी)


मैं इसे पोस्ट करना चाहता था for i in $(pgrep 'rsync'); do ls -l /proc/$i/fd; doneलेकिन आपका समाधान सरल है।
एलेक्सी गेबी

4

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

'टू-चेक' स्टेट दिखाता है कि कुल कितनी फाइलें बची हैं। यह एक नए गंतव्य के लिए rsync'ing जब आप सभी फ़ाइलों को पूरी तरह से कॉपी किया जाएगा पता है कि सबसे अधिक उपयोग की है।

आदमी पृष्ठ से:

When [each] file transfer  finishes,  rsync  replaces  the
progress line with a summary line that looks like this:

    1238099 100%  146.38kB/s    0:00:08  (xfer#5, to-check=169/396)

In this example, the file was  1238099  bytes  long  in
total,  the average rate of transfer for the whole file
was 146.38 kilobytes per second over the 8 seconds that
it took to complete, it was the 5th transfer of a regu-
lar file during the current rsync  session,  and  there
are 169 more files for the receiver to check (to see if
they are up-to-date or not) remaining out  of  the  396
total files in the file-list.

3

यहां ध्यान दें कि यहां तक ​​कि --info = प्रगति 2 पूरी तरह से विश्वसनीय नहीं है क्योंकि यह प्रतिशत उस समय के बारे में है, जब प्रगति प्रदर्शित हो रही है उस समय के बारे में rsync 'जानता' फाइलों पर आधारित है। यह जरूरी नहीं कि फ़ाइलों की कुल संख्या है जो सिंकडाउन होने की आवश्यकता है (उदाहरण के लिए, यदि यह एक बड़ी संख्या में बड़ी फ़ाइलों को एक गहरी नेस्टेड निर्देशिका में पता चलता है)। यह सुनिश्चित करने का एक तरीका है कि --info = प्रगति 2 प्रगति में 'वापस कूदो' नहीं है संकेत को सिंक शुरू करने से पहले सभी निर्देशिकाओं को स्कैन करने के लिए rsync को मजबूर करना होगा (इसके बजाय एक आकस्मिक पुनरावर्ती स्कैन करने के अपने डिफ़ॉल्ट व्यवहार के लिए, -no-inc-recursive विकल्प भी प्रदान करके। ध्यान दें कि यह विकल्प rsync मेमोरी उपयोग और रन-टाइम को भी बढ़ाएगा।


वृद्धिशील पुनरावृत्ति को --no-inc-recursiveविकल्प या उसके छोटे --no-i-rउपनाम का उपयोग करके अक्षम किया जा सकता है । (अन्य उत्तर देखें)
koppor

2

मैं एक स्क्रिप्ट का उपयोग करता हूं जो rsync प्रक्रिया (या उस मामले के लिए कोई अन्य प्रक्रिया) के लिए / proc // io से जानकारी निकालता है और स्थानांतरित होने वाली कुल राशि को जानना प्रगति की गणना करता है।

#!/bin/bash

usage()
{
   echo "usage: $0 PID BASEMSIZE [DELAY[s|m|h]]"
}

if [ $# -lt 2 ]; then
   usage
   exit 1
elif [ $# -eq 3 ]; then
   DELAY=$3
else
   DELAY=5s
fi

PID=$1
PBASE=`echo "scale=2; $2/1024"|bc`

R_PID=$PID
W_PID=$PID

R_SPEED_MAX=0
W_SPEED_MAX=0
R_SPEED_CUM=0
W_SPEED_CUM=0
R_SPEED_AVG=0
W_SPEED_AVG=0

ETA=0
ETA_H=0
ETA_M=0
ETA_S=0

while [ ! -r /proc/$PID/io ];
do
   clear
   echo "Waiting for process with PID=$PID to appear!"
   sleep 1
done

B_READ_PREV=`cat /proc/$R_PID/io|awk '$1 ~ /^read_bytes/ {print $2}'`
B_WRITE_PREV=`cat /proc/$W_PID/io|awk '$1 ~ /^write_bytes/ {print $2}'`
T1=`date +%s.%N`

count=0
while true
do
   [ ! -r /proc/$PID/io ] && break
   clear
   B_READ=`cat /proc/$R_PID/io|awk '$1 ~ /^read_bytes/ {print $2}'`
   B_WRITE=`cat /proc/$W_PID/io|awk '$1 ~ /^write_bytes/ {print $2}'`
   BL_READ=`echo "scale=2; ($B_READ-$B_READ_PREV)/1048576"|bc`
   BL_WRITE=`echo "scale=2; ($B_WRITE-$B_WRITE_PREV)/1048576"|bc`
   GB_DONE=`echo "scale=2; $B_WRITE/1073741824"|bc`
   PDONE=`echo "scale=2; $GB_DONE*100/$PBASE"|bc`
   T2=`date +%s.%N`
   TLOOP=`echo "scale=2; ($T2-$T1)/1"|bc`
   R_SPEED=`echo "scale=2; $BL_READ/$TLOOP"|bc`
   W_SPEED=`echo "scale=2; $BL_WRITE/$TLOOP"|bc`

   if [ $count -ge 1 ]; then
      R_SPEED_CUM=`echo "scale=2; $R_SPEED_CUM+$R_SPEED"|bc`
      R_SPEED_AVG=`echo "scale=2; $R_SPEED_CUM/$count"|bc`
      W_SPEED_CUM=`echo "scale=2; $W_SPEED_CUM+$W_SPEED"|bc`
      W_SPEED_AVG=`echo "scale=2; $W_SPEED_CUM/$count"|bc`
      [ `echo "scale=2; $W_SPEED > $W_SPEED_MAX"|bc` -eq 1 ] && W_SPEED_MAX=$W_SPEED
      [ `echo "scale=2; $R_SPEED > $R_SPEED_MAX"|bc` -eq 1 ] && R_SPEED_MAX=$R_SPEED
   fi

   if [ `echo "scale=2; $W_SPEED_AVG > 0"|bc` -eq 1 ]; then
      ETA=`echo "scale=2; (($PBASE-$GB_DONE)*1024)/$W_SPEED_AVG"|bc`
      ETA_H=`echo "scale=0; $ETA/3600"|bc`
      ETA_M=`echo "scale=0; ($ETA%3600)/60"|bc`
      ETA_S=`echo "scale=0; ($ETA%3600)%60"|bc`
   fi

   echo "Monitoring PID: $PID"
   echo
   echo "Read:       $BL_READ MiB in $TLOOP s"
   echo "Write:      $BL_WRITE MiB in $TLOOP s"
   echo
   echo "Read Rate:  $R_SPEED MiB/s ( Avg: $R_SPEED_AVG, Max: $R_SPEED_MAX )"
   echo "Write Rate: $W_SPEED MiB/s ( Avg: $W_SPEED_AVG, Max: $W_SPEED_MAX )"
   echo
   echo "Done: $GB_DONE GiB / $PBASE GiB ($PDONE %)"
   [ `echo "scale=2; $ETA > 0"|bc` -eq 1 ] && printf "ETA: %02d:%02d:%05.2f (%.2fs)\n" $ETA_H $ETA_M $ETA_S $ETA
   echo "Elapsed: `ps -p $PID -o etime=`"

   T1=`date +%s.%N`
   sleep $DELAY
   B_READ_PREV=$B_READ
   B_WRITE_PREV=$B_WRITE
   ((count++))
done
echo "----- Finished -------------------------------------------------------------------"

2

यदि आपका संस्करण विकल्प को rsyncस्वीकार नहीं करता --info=progress2है, तो आप उपयोग कर सकते हैं tqdm:

स्थापित करने के लिए:

pip install tqdm

काम में लाना:

$ rsync -av / source / dest | tqdm --unit_scale | wc -l
10.0Mit [00:02, 3.58Mit / s]

1

शायद आप pvrsync के साथ संयोजन कर सकते हैं । विशेष रूप से पैरामीटर --sizeसहायक द्वारा हो सकता है। डॉक्स पर एक नज़र ले रहा है, की तरह कुछ pv --size $(du -sb . | awk '{print $1}') | rsync -av . host:/your/pathकाम करना चाहिए।

यहां आपको डॉक्स और सॉफ्टवेयर मिलेंगे।

अपने दम पर यह कोशिश नहीं की है।


1

यहां थोड़ी देर हो सकती है लेकिन भविष्य में उत्तर देने वाले लाभान्वित हो सकते हैं।

यह मुझे बहुत परेशान कर रहा था इसलिए मैंने सोचा कि मैं नीचे जाऊंगा और अपनी पहली स्क्रिप्ट लिखूंगा। पैकेज ज़ेनिटी को स्थापित किया जाना चाहिए (sudo apt-get install zenity), लेकिन मुझे यकीन है कि यह पहले से ही होगा। इसके अलावा, मैं wmctrl (विंडो मैनेजर कंट्रोल) का उपयोग प्रगति संवाद के शीर्षक को बदलने के लिए करता हूं जब यह किया जाता है, तो यह आसानी से इंस्टॉल करने योग्य होता है लेकिन यदि आप नहीं करते हैं तो इससे कोई फर्क नहीं पड़ेगा। मुझे यह देखना अच्छा लगता है कि यह मेरे पैनल में कब किया गया है।

स्क्रिप्ट मूल रूप से एक स्रोत और गंतव्य निर्देशिका के लिए पूछती है, दो का उपयोग करके आकार में स्रोत पर गंतव्य के प्रतिशत की गणना करता है और एक प्रगति बार प्रदर्शित करता है।

नोट: यह केवल पूर्ण निर्देशिका / फ़ाइल सिंकिंग के लिए काम करता है (मैं आमतौर पर इसका उपयोग apt कैश का बैकअप बनाने के लिए करता हूं), इसलिए no --exclude = / file / in / Source-directory विकल्प। गंतव्य निर्देशिका में फ़ाइलें / निर्देशिकाएँ निर्देशिका स्रोत में नहीं हैं, तो भी काम नहीं करेगा। मुझे यकीन नहीं है कि अगर यह दूरस्थ स्रोतों / गंतव्यों के लिए काम करता है तो कभी भी मुझे इसकी आवश्यकता नहीं है या संसाधनों का परीक्षण करने की आवश्यकता नहीं है।

पुनश्च। यह स्क्रिप्ट बहुत बुरी तरह से लिखी जा सकती है या बहुत अक्षम है, (स्क्रिप्ट-कुंवारी यहाँ), लेकिन कम से कम यह इसका उद्देश्य है और निश्चित रूप से आपकी आवश्यकताओं के अनुरूप इसे संपादित करने और इसे बेहतर बनाने के लिए आपका स्वागत है। पीएसएस। इसके अलावा, rsync को मारने के लिए रद्द बटन प्राप्त नहीं कर सका इसलिए मैंने इसे हटा दिया।

    #!/bin/bash
set -e;

WELC="Running RsyncP as $USER";

function echo_progress()
{
    while (($TRANSFER_SIZE > 1000));    
    do  
        DEST_SIZE=$(du -s $DEST_FOLDER | cut -d / -f 1); 
        ((TRANSFER_SIZE=$SOURCE_SIZE-DEST_SIZE)); 
        PROGRESS_PERC=$((DEST_SIZE*100/SOURCE_SIZE));
        echo $PROGRESS_PERC;
        sleep 0.1s;
    done;
    echo 100;
    zenity --info --width=250 --title=RsyncP --text="File syncing complete!";
}

function get_input()
{
    dirs=$(zenity --forms --width=500 --title="RsyncP" --text="Enter source And destination directories" --add-entry="Source: " --add-entry="Destination: " --separator=" ");

    SOURCE_FOLDER=$(echo $dirs | cut -d' ' -f 1);
    DEST_FOLDER=$(echo $dirs | cut -d' ' -f 2);

    OPTIONS=-$(zenity --list --title="RsyncP Options" --text="Select rsync options" --separator='' --height=470 --width=470 --checklist --column "activate" --column "Option" --column "Description" FALSE v "Verbose (Terminal only)" FALSE q "Quiet, supress non-error messages (Terminal only)" FALSE P "Progress (Terminal only)" FALSE a "Archive (lrpog)" TRUE r "Recurse into directories" FALSE p "Preserve permissions" FALSE o "Preserve owner" FALSE g "Preserve group" FALSE l "Copy symlinks as symlinks");

    zenity --question --no-wrap --title="RsyncP" --width=500 --text="rsync  $OPTIONS $SOURCE_FOLDER $DEST_FOLDER\nDo you want to continue?";

    SOURCE_SIZE=$(du -s $SOURCE_FOLDER | cut -d / -f 1); 
    DEST_SIZE=$(du -s $DEST_FOLDER | cut -d / -f 1); 
    PROGRESS_PERC=$((DEST_SIZE*100/SOURCE_SIZE)); 
    TRANSFER_SIZE=1001;
}

if [ "$(id -u)" != "0" ]; then
    zenity --question --title=RsyncP --text="$WELC, Continue?";
    get_input;
    rsync  $OPTIONS $SOURCE_FOLDER $DEST_FOLDER & 
    echo_progress | zenity --progress --title=RsyncP --no-cancel --auto-close --text="Copying from \n$SOURCE_FOLDER to \n$DEST_FOLDER" ;

else            
    zenity --question --title=RsyncP --text="$WELC, Continue?";
    get_input; 
    sudo rsync  $OPTIONS $SOURCE_FOLDER $DEST_FOLDER & 
    echo_progress | zenity --progress --title=RsyncP --no-cancel --auto-close --text="Copying from \n$SOURCE_FOLDER to \n$DEST_FOLDER" ;
fi

YAD पर एक नज़र डालें। यह ज़ेनिटी का एक कांटा (फिर से लिखना?) है और ज़ेनिटी की तरह है ... लेकिन स्टेरॉयड पर। मेरी स्क्रिप्ट्स ज़ेनिटी के लिए सब कुछ वापस करने के लिए इसका उपयोग करती हैं क्योंकि मेरे पास केवल ज़ेनिटी के साथ एक मशीन है। कमांड विकल्प इसके लिए पर्याप्त हैं, लेकिन आपने ज़ेनिटी के साथ बहुत सारी बारीकियों को ढीला कर दिया है।
DocSalvager
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.