Rsync හි සම්පූර්ණ ප්‍රගතිය පෙන්වයි: එය කළ හැකිද?


261

මම දැනටමත් මෙම විකල්පය සෙව්වෙමි, නමුත් සොයාගෙන ඇත්තේ අභිරුචි පැච් කිරීම සම්බන්ධ විසඳුම් පමණි . එය --help හි නොපෙන්වන අතර තවත් තොරතුරු සොයාගත නොහැකි වීම බොහෝ විට ඇඟවෙන්නේ පිළිතුරු 'නැත' යන්නයි, නමුත් මෙය සනාථ කරනු දැකීමට මා කැමතිය.

Rsync සමඟ සම්පූර්ණ ගොනු හුවමාරු ප්‍රගතිය පෙන්විය හැකිද?


22
Rsync 3.1.0 සිට දැන් මූලික ගොනු හුවමාරු ප්‍රගතියක් ඇතුළත් වේ. වැඩි විස්තර සඳහා serverfault.com/a/441724/107793 බලන්න.
ෆ්ලෝරියන් ෆෙල්ඩවුස්

16
කරුණාකර පිළිගත් පිළිතුර වෙනස් කරන්න. @ ඩේවිඩ්ගේ පිළිතුර සම්පූර්ණයෙන්ම නිෂ් .ලයි.
නවීන්

Answers:


418

Rsync හි මෙය කිරීමට දැන් නිල ක්‍රමයක් ඇත (3.1.0 ප්‍රොටොකෝලය අනුවාදය 31, උබුන්ටු ට්‍රස්ටි සමඟ පරීක්ෂා කර ඇත 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% ක් පමණ සම්පූර්ණ වී ඇත, නමුත් ඒ කෙසේ වෙතත් යමක් පිටපත් වන බව දැකීම සැනසිල්ලකි :)

යොමුව:


21
මෙය 3.1.0 ට ගොඩ බැස ඇති බව සලකන්න. කාල දෘෂ්ටිකෝණයෙන් මෙය අනිවාර්යයෙන්ම නිවැරදි නොවන බව සැලකිල්ලට ගැනීම වැදගත්ය. එය අත්‍යවශ්‍යයෙන්ම දුරස්ථ කෙළවරේ පවතින බව තහවුරු කර ඇති දත්ත ප්‍රමාණය පෙන්වයි. අනුපාතය යනු දුරස්ථ කෙළවරේ දත්ත නිවැරදි යැයි ඉගෙන ගන්නා අනුපාතයයි (එය දැනටමත් ඒ ආකාරයෙන් හෝ නව දත්ත මාරු කර එය නිවැරදි කර තිබේද යන්න). එබැවින් ඉතා ප්‍රයෝජනවත් වුවද ඔබ අවවාද තේරුම් ගත යුතුය.
කෙවින් කොක්ස්

16
හෝම්බ rew සමඟ OSX හි මෙය භාවිතා කිරීම සඳහා, "බීර ටැප් හෝම්බ rew / ඩියුප්; බීර ස්ථාපනය rsync"
මැට් කැරියර්

19
--info=progress2එය සමඟ වැඩ නොකරන බව සඳහන් කිරීම වටී-v
සන්මායි

48
--no-i-rස්විචය අස්වෙල් එක් කරන්න , එමඟින් rsyncපිටපත් කිරීමට පෙර වර්ධක ලෙස නොව සම්පූර්ණයෙන් පරිලෝකනය නොකරන අතර දැන ගැනීම + කොපමණ වැඩ ප්‍රමාණයක් ඉතිරිව ඇත්දැයි පෙන්වයි.
ඇලෙක්ස්

19
MB / GB හි සම්පූර්ණ ප්‍රමාණය බැලීමට ඔබට --human-readable(හෝ -h) භාවිතා කළ හැකි බව සලකන්න .
Nux

48

ඔබට 'පීවී' ( apt-get install pvඩෙබියන් සහ උබුන්ටු සමඟ) කළ හැකිය. මාරු කරන ලද දත්ත ප්‍රමාණය ලිපිගොනු ප්‍රමාණයට සහසම්බන්ධ නොවන නමුත් ප්‍රභවය සහ ගමනාන්තය අතර ඇති ඩෙල්ටාව මත මාරු කර ඇති ගොනු ගණන නිරීක්ෂණය කිරීමට මම නිර්දේශ කරමි. ලිපිගොනු ගණනය කිරීම එක් විශාල ඩෙල්ටාවකට සමාන ප්‍රගතියක් සහ කුඩා ඩෙල්ටාවක් ඇති තවත් එකක් ගණනය කරනු ඇත. එයින් අදහස් වන්නේ ඕනෑම අවස්ථාවක ETA තක්සේරුව දුර බැහැර විය හැකි බවයි. ප්‍රමාණය මත පදනම් වූ ETA ක්‍රියාත්මක වන්නේ ඔබගේ ගමනාන්තය හිස් නම් පමණි, මේ අවස්ථාවේ දී ඩෙල්ටා == ප්‍රභවයේ ප්‍රමාණය.

සාමාන්‍ය අදහස නම් rsync වෙතින් 'මාරු කරන ලද' ගොනුවකට එක් පේළියක් විමෝචනය කිරීම සහ එම පේළි 'pv' සමඟ ගණන් කිරීම:

rsync -ai / source remote: / dest | pv -les [ගොනු ගණන]> / dev / null

මම, උපස්ථ මුළු ගොනු පද්ධති (හේතු කිහිපයක් සඳහා) නැඹුරු මෙම නඩුවේ ඔබ වඩා බෙහෙවින් ලාභදායී භාවිතා කළ හැකි dfගොනු සංඛ්යාව (වඩා ලබා ගැනීමට duහෝ findrsync ඒක කළා පසු wich ඔබගේ මූලාශ්රය ධුරාවලියේ තවත් කාලය හරහා ගමන් කරනු ඇත). -X විකල්පය rsync එකම ප්‍රභව ගොනු පද්ධතියේ රැඳී සිටින බවට වග බලා ගැනීමට පෙනේ (සහ වෙනත් අභ්‍යන්තර සවි කිරීම් අනුගමනය නොකරයි):

rsync -aix / source remote: / dest | pv -les $ (df -i / source | perl -ane 'print $ F [2] if $ F [5] = ~ m: ^ /:')> / dev / null

ඔබට සාමාන්‍යයෙන් / ප්‍රභවයෙන් ලිපිගොනු ගණන් කිරීමට අවශ්‍ය නම්, භාවිතා කරන්න find /source|wc -l(නැවත අනතුරු ඇඟවීම: I / O මත මන්දගාමී හා බර විය හැක).


1
Zerodeuz නිශ්චිතව දක්වා ඇති පරිදි, "df" භාවිතා කරන්න ඔබ මුළු කොටසම සමමුහුර්ත කරන විට පමණක්, df -i /source/ ප්‍රභවය වාසය කරන සියලුම කොටස් වලින් ඉනෝඩ (ගොනු) ලබා ගන්නා පරිදි. එසේ නොමැතිනම් "$ ()" ප්‍රකාශනය තුළ ඇති නාමාවලියක් තුළ ඇති ගොනු ගණන් කිරීමට 'find' භාවිතා කරන්න .
lepe

1
විකල්පයක් duහෝ find- අපි කියමු ඔබ අසම්පූර්ණ පිටපතක් අවසන් කරන බව හෝ rsync -ai --dry-runpv
මකාදැමීම්

45

පහත දැක්වෙන්නේ rsync අනුවාදය 3.0.0 සහ ඊට ඉහළ ය. පහත විස්තර කර ඇති විකල්පයන් 2008 මාර්තු 1 වන දින එම නිකුතුවේදී හඳුන්වා දෙන ලදී.

සමග --info = progress2 ඔබ ද භාවිතා කළ හැකිය --no-inc-ආවර්තනික විකල්පය (හෝ එහි කෙටි --no-IR ආබාධිත වර්ධනාත්මක සහානුයාත කිරීමට හෙවත්).

මාරුවීම සිදුවන විට වැඩි ලිපිගොනු වැඩි වැඩියෙන් සොයා ගැනීමට වඩා මෙය මුලදී සම්පූර්ණ ගොනු ලැයිස්තුවම ගොඩනගනු ඇත. ආරම්භ කිරීමට පෙර එය සියළුම ලිපිගොනු දැන ගනු ඇති බැවින්, එය සමස්ත ප්‍රගතිය පිළිබඳ වඩා හොඳ වාර්තාවක් ලබා දෙනු ඇත. මෙය ගොනු ගණනට අදාළ වේ - එය ගොනු ප්‍රමාණයන් මත පදනම්ව කිසිදු ප්‍රගතියක් වාර්තා නොකරයි.

මෙයට වෙළඳාමක් සිදු වේ. සම්පූර්ණ ගොනු ලැයිස්තුව වේලාවට පෙර ගොඩ නැගීම වඩා මතකය අධික වන අතර සත්‍ය හුවමාරුව ආරම්භ කිරීම සැලකිය යුතු ලෙස ප්‍රමාද කළ හැකිය. ඔබ අපේක්ෂා කරන පරිදි, වැඩි ලිපිගොනු ඇති තරමට, ප්‍රමාදය වැඩි වන අතර වැඩි මතකයක් අවශ්‍ය වේ.

පහත සඳහන් වන rsync අත්පොත (මූලාශ්රය - වෙතින් වන http://rsync.samba.org/ftp/rsync/rsync.html ):

-r, --recursive

මෙය නැවත නැවත නාමාවලි පිටපත් කිරීමට rsync ට කියයි. --Dirs (-d) ද බලන්න. Rsync 3.0.0 සිට ඇරඹෙන පුනරාවර්තන ඇල්ගොරිතම දැන් වර්ධක ස්කෑන් එකක් වන අතර එය පෙරට වඩා අඩු මතකයක් භාවිතා කරන අතර පළමු නාමාවලි කිහිපය පරිලෝකනය කිරීමෙන් පසුව මාරුවීම ආරම්භ කරයි. මෙම වර්ධක ස්කෑන් අපගේ පුනරාවර්තන ඇල්ගොරිතමයට පමණක් බලපාන අතර පුනරාවර්තන නොවන මාරුවක් වෙනස් නොකරයි. එය කළ හැකි වන්නේ මාරුවේ කෙළවර දෙකම අවම වශයෙන් 3.0.0 අනුවාදය වන විට පමණි.

සමහර විකල්පයන් සඳහා සම්පූර්ණ ගොනු ලැයිස්තුව දැන ගැනීමට rsync අවශ්‍ය වේ, එබැවින් මෙම විකල්පයන් වර්ධක පුනරාවර්තන මාදිලිය අක්‍රීය කරයි. ඒවාට ඇතුළත් වන්නේ: --delete-before, --delete-after, --prune-හිස්-ඩර්ස්, සහ --delay-update. මේ හේතුව නිසා, ඔබ --delete දැන් සඳහන් කර ඇති විට සුපුරුදු මකාදැමීමේ මාදිලිය --delete-during අතර සම්බන්ධතාවයේ කෙළවර දෙකම අවම වශයෙන් 3.0.0 ක් වන විට (මෙම වැඩිදියුණු කළ මකාදැමීමේ ක්‍රමය ඉල්ලා සිටීමට --del හෝ --delete-during භාවිතා කරන්න. පැහැදිලිවම). --Delete-after භාවිතා කිරීමට වඩා හොඳ තේරීමක් වන --delete-delay විකල්පයද බලන්න.

--No-inc-recursive විකල්පය හෝ එහි කෙටි --no-ir අන්වර්ථය භාවිතා කරමින් වර්ධක පුනරාවර්තනය අක්‍රිය කළ හැකිය .

විශේෂිත අනුවාද වෙනස්කම් සඳහා https://rsync.samba.org ද බලන්න (පහළට අනුචලනය කර නිකුතු ප්‍රවෘත්ති සබැඳි බලන්න).


3
මේ සඳහා ස්තූතියි, අනෙක් පිළිතුරු වල ප්‍රති result ලය වන්නේ වයස අවුරුදු% ක් ඉහළට හා පහළට යන බවය!
artfulrobot

38

දානකිම් නිවැරදි ය. සම්පූර්ණ ප්‍රගති දර්ශකයක් එක් කිරීමට සුළු ක්‍රම නොමැත.

මෙයට හේතුව rsync සමමුහුර්ත කිරීම සඳහා ලිපිගොනු ලැයිස්තුවක් දෙස බලන විට, කුමන ගොනු වෙනස් කළ යුතුද යන්න කල්තියා නොදැන සිටීමයි. ඔබ ඩෙල්ටා මාරුවීම් කරන්නේ නම්, කළ යුතු කාර්යයන් පිළිබඳ සම්පූර්ණ චිත්‍රයක් ලබා දීම සඳහා ඩෙල්ටාව කලින් ගණනය කළ යුතුය.

වෙනත් වචන වලින් කිවහොත්, කළ යුතු වැඩ ප්‍රමාණය ගණනය කිරීමට ඇති පහසුම ක්‍රමය නම් එය සැබවින්ම කිරීමයි.


42
(දත්ත මාරු කළ + දත්ත මඟ හැරුනු) / (ප්‍රභවයේ ඇති මුළු දත්ත), හෝ (# ගොනු මාරු කිරීම හෝ මඟ හැරීම) / (ප්‍රභවයේ ඇති # ගොනු) වැනි සරල දර්ශකයක් ඔබට තවමත් තිබිය හැකිය. එය විශේෂයෙන් නිවැරදි නොවනු ඇත, නමුත් එය අදහසක් ලබා දෙනු ඇත. ඔබ දවස අවසානයේදී විශාල මාරුවක් සිදු කරන විට හොඳයි, ඔබ කල්පනා කරන්නේ පරිගණකය ක්‍රියා
විරහිත

3
නිගමනය නිවැරදි යැයි මම විශ්වාස නොකරමි. මම සිතන්නේ @ naught101 ප්‍රශ්නයට වඩා සාධාරණ වන අතර, මම හිතන්නේ පිළිතුරක් භාවිතා නොකිරීම --size-onlyහෝ ඒ හා සමාන තවත් පිළිතුරක් නැත .
ඉවාන් කැරොල්

2
මා පිළිතුර ලියන අවස්ථාවේ එය නිවැරදි ය - සම්පූර්ණ ප්‍රගති දර්ශකයක් සඳහා යාන්ත්‍රණයක් rsync සතුව නොතිබුණි. ඔව්, ඔබට ඔබේම දෑ ලිවිය හැකිය, නමුත් ඉතා සුළු පිරිසක් එසේ කරනු ඇත.
ඩේවිඩ් මැකින්ටොෂ්

6
නවකයින් සඳහා අදහස් දක්වන්න: දැන් එය කළ හැකි ය: serverfault.com/a/441724/422003
පැනවීම

මුරපද දෙකක් භාවිතා කිරීම, පළමුව "--dry-run" (සම්පූර්ණ අපේක්ෂිත ගොනු ගණන) සහ දෙවනුව සවිස්තරාත්මක ප්‍රතිදානය ගොනුවකට ලොග් වී ඇත (සහ රේඛා සම්පූර්ණ කිරීම හෝ 'පීවී' සඳහා පයිප්පයක් භාවිතා කිරීම), පහසුවෙන් නිම කිරීම තක්සේරු කිරීමට ඉඩ දෙයි. අවාසිය නම් විශාල කැදැලි නාමාවලි දෙවරක් පරිලෝකනය කිරීමයි. අවශ්‍යතාවය මත පදනම්ව, එනම් ආරක්ෂිත පාරිභෝගික දත්ත සංක්‍රමණය සහතික කිරීම, මෙය පිළිගත හැකිය.
ives

29

දිගු මාරුවීම් සඳහා, du -sදෙපස ධාවනය කිරීම ගැන මම සතුටු වෙමි . පවා watch -n1 du -s, මම ඇත්තටම තනිවීම නම්.

watchdu -sවරින් වර ( මෙහි) විධානයක් ක්‍රියාත්මක කරයි (සෑම තත්පර 1 කට වරක්) සහ ප්‍රතිදානය පූර්ණ තිරය පෙන්වයි.


4
watchවිධානයේ උදාහරණයට ස්තූතියි !
කැම්

2
//, දක්ෂයි! Linfo.org ට අනුව: "ඩු (එනම් තැටි භාවිතය) විධානය මඟින් ඒවායේ සියලුම අන්තර්ගතයන් ඇතුළත් ඩිරෙක්ටරි ගස්වල ප්‍රමාණයන් සහ තනි ලිපිගොනු වල ප්‍රමාණයන් වාර්තා කරයි. මෙය අභ්‍යවකාශ හොග්, එනම් ඩිරෙක්ටරි සහ ලිපිගොනු සොයා ගැනීමට ප්‍රයෝජනවත් වේ. දෘ hard තැටි (HDD) හෝ වෙනත් ගබඩා මාධ්‍යයක විශාල හෝ අධික ඉඩ ප්‍රමාණයක් පරිභෝජනය කරන.
නේතන් බසානිස්

10
ඩු ශක්‍ය වන ඔබ කුමන ආකාරයේ දිගු මාරුවීම් කරනවාදැයි මම නොදනිමි. ප්‍රති T ලය TB සහ M ලිපිගොනු වල ඇති විට du නිරය මෙන් මන්දගාමී වේ.
කිසිවෙකු

2
මගේ "දිගු මාරුවීම්" සඳහා ඩු මෙහෙයුමක් සම්පූර්ණ කිරීමට පැයක් පමණ ගත වේ, එම කාලය තුළ rsync ඉතා මන්දගාමීව ක්‍රියාත්මක වේ, මන්ද ඔවුන් තැටියට ප්‍රවේශ වීම සම්බන්ධයෙන් සටන් වදින බැවිනි.
අභි බෙකර්ට්

13

මූලික වශයෙන් නැත. ඔබට එක් ගොනුවකට ප්‍රගතිය පෙන්විය හැක්කේ --progress ධජය සමඟ පමණි, නමුත් එය ඒ ගැන ය.

මම හිතන්නේ ඔබට එය වටා එතීමක් ලිවීමට හෝ ඔබ දැනටමත් සොයාගෙන ඇති ඕනෑම පැච් එකක් භාවිතා කළ හැකි නමුත් එය ඇත්තෙන්ම වටිනවාදැයි ඔබගෙන්ම විමසා බැලිය යුතුය, ඇත්ත වශයෙන්ම ඔබට rsync සඳහා සම්පූර්ණ ප්‍රගතියක් අවශ්‍යද?


සම්පූර්ණ ප්‍රගතිය සහ ලිපිගොනු ප්‍රගතිය කදිම ප්‍රගති තීරුවක් ලෙස පෙන්වන එතීමේ පිටපතක් මෙන්න
j13r

1
ඔබට --progressභාවිතයෙන් වැඩ කරන ආකාරය වෙනස් කළ හැකිය --info=progress2, එය ඔබට ගෝලීය ප්‍රගතිය පෙන්වයි. එය ප්‍රයෝජනවත් වීම සඳහා වර්ධක පුනරාවර්තන ඇල්ගොරිතම අක්‍රිය කිරීමට ඔබට අවශ්‍ය වනු ඇත, එබැවින්--info=progress2 --no-inc-recursive
mat

13 j13r ඔබට මෙම සාරාංශය පිළිතුරක් ලෙස බෙදා ගත හැකිය! එහි විශිෂ්ට විකල්පය!
skywinder

8

මම ශුන්‍ය ඩියුක්ස් වෙතින් පිළිතුර භාවිතා කර මගේම කුඩා බාෂ් පිටපතක් ලිවීය:

#!/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 සමඟ සම්පූර්ණ ප්‍රගතිය පෙන්වන්නේ කෙසේදැයි මම සෙවූ අතර මෙම ලිපියෙන් ප්‍රයෝජනවත් පිළිතුරක් මට හමු විය: /programming/7157973/monitoring-rsync-progress

මූලික වශයෙන්, ඔබට rsync 3.1.0 හි dev අනුවාදයේ --info = progress2 භාවිතා කළ හැකිය . ලේඛනය පවසා ඇති දේ මෙන්න :

තනි ගොනු වලට වඩා සමස්ත හුවමාරුව මත පදනම්ව සංඛ්‍යාලේඛන ප්‍රතිදානය කරන --info = progress2 විකල්පයක් ද ඇත. ලිපිගොනු නාමයක් ප්‍රතිදානය නොකර මෙම ධජය භාවිතා කරන්න (උදා: -v මඟහරින්න හෝ --info = name0 සඳහන් කරන්න, ඔබට නම් විශාල ප්‍රමාණයක් සහිත තිරය අනුචලනය නොකර මාරුවීම සිදුවන ආකාරය බැලීමට අවශ්‍ය නම් (ඔබට නියම කිරීමට අවශ්‍ය නැත - භාවිතා කිරීම සඳහා ප්‍රගති විකල්පය --info = progress2.)


1
--info=name0රත්තරන් 🌈👑
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 ක වඩා!
hopeeekr

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නමුත් ඔබේ විසඳුම සරල ය.
Aalex Gabi

4

මම මෙය අදහස් දැක්වීමක් කළ නමුත් ප්‍රමාණවත් කීර්තියක් නැත. තෝරාගත් පිළිතුරට naught101 ගේ අදහස් දැක්වීමට ප්‍රතිචාර වශයෙන්, --progress විකල්පය මඟින් මාරු කළ යුතු මුළු මුදලින් කොපමණ ගොනු ප්‍රමාණයක් මාරු කර ඇත්දැයි පෙන්වයි. මෙම ලිපිය දෙස බලා ප්‍රතිදානය වඩාත් ප්‍රවේශමෙන් බලන තුරු මම මෙය තේරුම් නොගත්තෙමි.

'පරීක්ෂා කිරීමට' ප්‍ර stat ප්තියෙන් දැක්වෙන්නේ මුළු ලිපිගොනු ගණන කොපමණ ප්‍රමාණයක් ඉතිරිව තිබේද යන්නයි. නව ගමනාන්තයකට rsync කරන විට මෙය බොහෝ ප්‍රයෝජනවත් වේ, එවිට සියලු ලිපිගොනු සම්පූර්ණයෙන්ම පිටපත් වන බව ඔබ දනී.

මෑන් පිටුවෙන්:

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 = progress2 පවා සම්පුර්ණයෙන්ම විශ්වාසදායක නොවන බව සලකන්න. ප්‍රගතිය පෙන්වන අවස්ථාවේ දී rsync 'දන්නා' ගොනු ගණන මත පදනම් වේ. මෙය සමමුහුර්ත කිරීමට අවශ්‍ය මුළු ගොනු ගණන නොවේ (නිදසුනක් ලෙස, එය ගැඹුරින් කැදැලි නාමාවලියක විශාල ගොනු විශාල ප්‍රමාණයක් සොයා ගන්නේ නම්). ප්‍රගති දර්ශකයේ --info = progress2 'පසුපසට නොයන' බව සහතික කළ හැකි එක් ක්‍රමයක් වනුයේ සමමුහුර්තකරණය ආරම්භ කිරීමට පෙර සියලු ඩිරෙක්ටරි පුනරාවර්තව පරිලෝකනය කිරීමට rsync ට බල කිරීමයි (වැඩිවන පුනරාවර්තන ස්කෑන් කිරීමේ පෙරනිමි හැසිරීම වෙනුවට), --no-inc-recursive විකල්පය ද ලබා දීමෙන්. කෙසේ වෙතත් මෙම විකල්පය rsync මතක භාවිතය සහ ධාවන කාලය වැඩි කරන බව සලකන්න.


--no-inc-recursiveවිකල්පය හෝ එහි කෙටි --no-i-rඅන්වර්ථය භාවිතා කරමින් වැඩිවන පුනරාවර්තනය අක්‍රිය කළ හැකිය . (වෙනත් පිළිතුර බලන්න)
කොප්පෝර්

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 හැඹිලියේ උපස්ථ සෑදීම සඳහාය), එබැවින් --exclude = / file / in / Source-directory විකල්පයක් නොමැත. ප්‍රභව නාමාවලියෙහි නොමැති ගමනාන්ත නාමාවලියෙහි ගොනු / නාමාවලි තිබේ නම් එය ක්‍රියා නොකරනු ඇත. දුරස්ථ ප්‍රභවයන් / ගමනාන්තයන් සඳහා එය ක්‍රියාත්මක වේදැයි මට විශ්වාස නැත, මන්ද එය කිසි විටෙකත් මට අවශ්‍ය නොවීය.

පීඑස්. මෙම ස්ක්‍රිප්ට් එක ඉතා නරක ලෙස ලියා හෝ ඉතා අකාර්යක්ෂම විය හැකිය, (මෙහි ස්ක්‍රිප්ට්-කන්‍යා), නමුත් අවම වශයෙන් එය එහි අරමුණ ඉටු කරයි. ඇත්ත වශයෙන්ම ඔබේ අවශ්‍යතාවන්ට සරිලන පරිදි එය සංස්කරණය කර වැඩිදියුණු කිරීමට ඔබව සාදරයෙන් පිළිගනිමු. පීඑස්එස්. එසේම, rsync kill ාතනය කිරීමට අවලංගු කිරීමේ බොත්තම ලබා ගත නොහැකි වූ නිසා මම එය ඉවත් කළෙමි.

    #!/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 දෙස බලන්න. එය Zenity හි දෙබලක (නැවත ලිවීම?) එය Zenity හා සමානයි ... නමුත් ස්ටෙරොයිඩ් මත. මගේ ස්ක්‍රිප්ට් එය Zenity වෙත ආපසු යාමේ සෑම දෙයක් සඳහාම භාවිතා කරයි. විධාන විකල්පයන් ඒ සඳහා ප්‍රමාණවත් තරම් සමාන නමුත් ඔබ Zenity සමඟ ඇති සුන්දරත්වය නැති කර ගනී.
DocSalvager
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.