නවතම සම්භවය සඳහා Git උප මොඩියුලය යාවත්කාලීන කරන්න

මට Git උප මොඩියුලයක් සහිත ව්‍යාපෘතියක් තිබේ. එය ssh: // ... URL එකකින් වන අතර එය බැඳී ඇත. බැඳීම B එම URL වෙත තල්ලු කර ඇති අතර මට අවශ්‍ය වන්නේ උප මොඩියුලය බැඳීම නැවත ලබාගෙන එය වෙනස් කිරීමයි.

දැන්, මගේ අවබෝධය නම් මෙය කළ git submodule updateයුතු නමුත් එය එසේ නොවේ. එය කිසිවක් නොකරයි (ප්‍රතිදානය නැත, සාර්ථක පිටවීමේ කේතය). මෙන්න උදාහරණයක්:

$ mkdir foo
$ cd foo
$ git init .
Initialized empty Git repository in /.../foo/.git/
$ git submodule add ssh://user@host/git/mod mod
Cloning into mod...
user@host's password: hunter2
remote: Counting objects: 131, done.
remote: Compressing objects: 100% (115/115), done.
remote: Total 131 (delta 54), reused 0 (delta 0)
Receiving objects: 100% (131/131), 16.16 KiB, done.
Resolving deltas: 100% (54/54), done.
$ git commit -m "Hello world."
[master (root-commit) 565b235] Hello world.
 2 files changed, 4 insertions(+), 0 deletions(-)
 create mode 100644 .gitmodules
 create mode 160000 mod
# At this point, ssh://user@host/git/mod changes; submodule needs to change too.
$ git submodule init
Submodule 'mod' (ssh://user@host/git/mod) registered for path 'mod'
$ git submodule update
$ git submodule sync
Synchronizing submodule url for 'mod'
$ git submodule update
$ man git-submodule 
$ git submodule update --rebase
$ git submodule update
$ echo $?
0
$ git status
# On branch master
nothing to commit (working directory clean)
$ git submodule update mod
$ ...

මම ද උත්සාහ කලා git fetch modවූ හඩකින් නැහැ පෙනේ වන, (එය මුරපදය සඳහා ලෙසටත් නැහැ නිසා, නමුත් සමහර බෑ!), නමුත් git logසහ git showනව අනාචාරයේ පැවැත්ම ප්රතික්ෂේප. මෙතෙක් මම rmමොඩියුලය සකස් කර එය නැවත එකතු කර ඇත්තෙමි , නමුත් මෙය ප්‍රතිපත්තිමය වශයෙන් වැරදි සහ ප්‍රායෝගිකව වෙහෙසකාරී ය.

මෙම git submodule updateවිධානය ඇත්තටම Git පවසනවා ඔබ superproject වන දර්ශකය තුළ මේ වන විටත් නිරූපනය කැපවෙන්නේ පිටතට එක් එක් පරීක්ෂා කිරීමට ඔබගේ submodules අවශ්ය බව. ඔබේ උප මොඩියුලයන් දුරස්ථයෙන් ලබා ගත හැකි නවතම බැඳීම් වලට යාවත්කාලීන කිරීමට ඔබට අවශ්‍ය නම් , ඔබට මෙය කෙලින්ම උප මොඩියුලවල කළ යුතුය.

එබැවින් සාරාංශයක් ලෙස:

# Get the submodule initially
git submodule add ssh://bla submodule_dir
git submodule init

# Time passes, submodule upstream is updated
# and you now want to update

# Change to the submodule directory
cd submodule_dir

# Checkout desired branch
git checkout master

# Update
git pull

# Get back to your project root
cd ..

# Now the submodules are in the state you want, so
git commit -am "Pulled down update to submodule_dir"

නැතහොත්, ඔබ කාර්යබහුල පුද්ගලයෙක් නම්:

git submodule foreach git pull origin master

Git 1.8.2 හි නව විකල්පයක් ඇත, --remoteඑය හරියටම මෙම හැසිරීම සක්‍රීය කරයි. ධාවනය

git submodule update --remote --merge

එක් එක් උප මොඩියුලයේ උඩුමහලේ සිට නවතම වෙනස්කම් ලබා ගැනීම, ඒවා ඒකාබද්ධ කිරීම සහ උප මොඩියුලයේ නවතම සංශෝධනය පරීක්ෂා කිරීම. ලෙස ලේඛගතකිරීම තබන එය:

--දුරස්ථ

මෙම විකල්පය වලංගු වන්නේ යාවත්කාලීන විධානය සඳහා පමණි. උප මොඩියුලය යාවත්කාලීන කිරීම සඳහා සුපර් ප්‍රොජෙක්ට් හි පටිගත කරන ලද SHA-1 භාවිතා කරනවා වෙනුවට, උප මොඩියුලයේ දුරස්ථ ලුහුබැඳීමේ ශාඛාවේ තත්වය භාවිතා කරන්න.

මෙය git pullඑක් එක් උප මොඩියුලය තුළ ධාවනය කිරීමට සමාන වන අතර එය සාමාන්‍යයෙන් ඔබට අවශ්‍ය දේම වේ.

ඔබේ ව්‍යාපෘති මව් නාමාවලිය තුළ, ධාවනය කරන්න:

git submodule update --init

නැතහොත් ඔබට පුනරාවර්තන උප මොඩියුලයන් තිබේ නම්:

git submodule update --init --recursive

සමහර විට මෙය තවමත් ක්‍රියාත්මක නොවේ, මන්ද උප මොඩියුලය යාවත්කාලීන වන විට කෙසේ හෝ ඔබට දේශීය උප මොඩියුල නාමාවලියෙහි දේශීය වෙනස්කම් තිබේ.

බොහෝ විට දේශීය වෙනස ඔබට කිරීමට අවශ්‍ය එකක් නොවිය හැකිය. ඔබගේ උප මොඩියුලයේ ලිපිගොනු මකාදැමීම නිසා එය සිදුවිය හැකිය. එසේ නම්, ඔබේ දේශීය උප මොඩියුල නාමාවලියෙහි සහ ඔබේ ව්‍යාපෘති මව් නාමාවලියෙහි නැවත සැකසීමක් කරන්න, නැවත ධාවනය කරන්න:

git submodule update --init --recursive

ඔබේ ප්‍රධාන ව්‍යාපෘතිය මඟින් උප මොඩියුලය තිබිය යුතු විශේෂිත බැඳීමක් පෙන්නුම් කරයි. git submodule updateආරම්භ කර ඇති සෑම උප මොඩියුලයකම එම බැඳීම පරීක්ෂා කිරීමට උත්සාහ කරයි. උප මොඩියුලය සැබවින්ම ස්වාධීන ගබඩාවකි - උප මොඩියුලයේ නව බැඳීමක් ඇති කර එය ප්‍රමාණවත් නොවේ. ප්‍රධාන ව්‍යාපෘතියේ උප මොඩියුලයේ නව අනුවාදයද ඔබ පැහැදිලිව එකතු කළ යුතුය.

එබැවින්, ඔබේ නඩුවේදී, ඔබ උප මොඩියුලයේ නිවැරදි කැපවීම සොයාගත යුතුය - එය උපකල්පනය කරන්නේ master:

cd mod
git checkout master
git pull origin master

දැන් ප්‍රධාන ව්‍යාපෘතියට ආපසු ගොස් උප මොඩියුලය වේදිකා ගත කර එය සිදු කරන්න:

cd ..
git add mod
git commit -m "Updating the submodule 'mod' to the latest version"

දැන් ප්‍රධාන ව්‍යාපෘතියේ ඔබගේ නව අනුවාදය තල්ලු කරන්න:

git push origin master

මෙතැන් සිට, වෙනත් අයෙකු ඔවුන්ගේ ප්‍රධාන ව්‍යාපෘතිය යාවත්කාලීන කරන්නේ නම්, git submodule updateඔවුන් සඳහා උප මොඩියුලය යාවත්කාලීන කරනු ඇත, එය ආරම්භ කර ඇතැයි උපකල්පනය කරයි.

මෙම සාකච්ඡාවේදී වෙනස් අවස්ථා දෙකක් එකට මිශ්‍ර වී ඇති බව පෙනේ:

සිදුවීම 1

මගේ මව් ගබඩාවේ උපපොළවල් සඳහා උපමා මොඩියුල භාවිතා කරමින්, මව් ගබඩාව යොමු කරන සෑම උප මොඩියුලයකම ඇති බැඳීම පරීක්ෂා කර බැලීමට මට අවශ්‍යය, සමහර විට මුලින් සියලු උප මොඩියුල හරහා නැවත පැමිණ ඒවා දුරස්ථව යාවත්කාලීන කිරීම / ඇද ගැනීම.

මෙය පෙන්වා දී ඇති පරිදි සිදු කරනු ලැබේ

git submodule foreach git pull origin BRANCH
git submodule update

සිදුවීම 2, මම හිතන්නේ OP අරමුණු කරන්නේ එයයි

නව දේවල් එක් හෝ වැඩි උප මොඩියුලයක සිදුවී ඇති අතර, මට අවශ්‍ය වන්නේ 1) මෙම වෙනස්කම් අදින්න සහ 2) මෙම / මෙම උප මොඩියුලවල HEAD (නවතම) කැපවීම වෙත යොමු කිරීම සඳහා මව් ගබඩාව යාවත්කාලීන කරන්න.

මෙය සිදු කරනු ලබන්නේ

git submodule foreach git pull origin BRANCH
git add module_1_name
git add module_2_name
......
git add module_n_name
git push origin BRANCH

ඉතා ප්‍රායෝගික නොවේ, මන්දයත් ඔබට සියලු උප මොඩියුලයන් වෙත n මාර්ග තද කළ යුතු බැවින් උදා. මව් ගබඩාවේ බැඳීම් දර්ශක යාවත්කාලීන කිරීම සඳහා පිටපතක්.

එක් එක් උප මොඩියුලය හරහා ස්වයංක්‍රීයව නැවත යෙදීම සිසිල් git addවන අතර, උප-මොඩියුලයේ (ය) ප්‍රධානියා වෙත යොමු කිරීම සඳහා මව් නිධිය දර්ශකය (භාවිතා කරමින් ) යාවත්කාලීන කරයි .

මේ සඳහා, මම මෙම කුඩා බාෂ් පිටපත සෑදුවෙමි:

git-update-submodules.sh

#!/bin/bash

APP_PATH=$1
shift

if [ -z $APP_PATH ]; then
  echo "Missing 1st argument: should be path to folder of a git repo";
  exit 1;
fi

BRANCH=$1
shift

if [ -z $BRANCH ]; then
  echo "Missing 2nd argument (branch name)";
  exit 1;
fi

echo "Working in: $APP_PATH"
cd $APP_PATH

git checkout $BRANCH && git pull --ff origin $BRANCH

git submodule sync
git submodule init
git submodule update
git submodule foreach "(git checkout $BRANCH && git pull --ff origin $BRANCH && git push origin $BRANCH) || true"

for i in $(git submodule foreach --quiet 'echo $path')
do
  echo "Adding $i to root repo"
  git add "$i"
done

git commit -m "Updated $BRANCH branch of deployment repo to point to latest head of submodules"
git push origin $BRANCH

එය ක්‍රියාත්මක කිරීමට, ක්‍රියාත්මක කරන්න

git-update-submodules.sh /path/to/base/repo BRANCH_NAME

විස්තාරණය

පළමුවෙන්ම, මම සිතන්නේ සියලුම ගබඩාවල $ BRANCH (දෙවන තර්කය) යන ශාඛාව පවතින බවයි. මෙය වඩාත් සංකීර්ණ කිරීමට නිදහස් වන්න.

පළමු කොටස් දෙකෙහි තර්ක තිබේදැයි පරීක්ෂා කිරීමකි. ඉන්පසු මම මව් ගබඩාවේ නවතම දෑ අදින්නෙමි (මම අදින්නට යන සෑම අවස්ථාවකදීම --ff (වේගයෙන් ඉදිරියට යැවීම) භාවිතා කිරීමට කැමැත්තෙමි.

git checkout $BRANCH && git pull --ff origin $BRANCH

නව උප මොඩියුල එකතු කර හෝ තවමත් ආරම්භ කර නොමැති නම් සමහර උප මොඩියුල ආරම්භ කිරීම අවශ්‍ය විය හැකිය:

git submodule sync
git submodule init
git submodule update

ඉන්පසු මම සියලු උප මොඩියුල යාවත්කාලීන කරමි / අදින්නෙමි:

git submodule foreach "(git checkout $BRANCH && git pull --ff origin $BRANCH && git push origin $BRANCH) || true"

කරුණු කිහිපයක් සැලකිල්ලට ගන්න: පළමුවෙන්ම, මම සමහර Git විධාන දම්වැලෙන් බැඳ තබමි &&- එනම් පෙර විධානය දෝෂයකින් තොරව ක්‍රියාත්මක විය යුතුය.

සාර්ථක ලෙස අදින්නට පසු (දුරස්ථව නව දේවල් හමු වූවා නම්), ඒකාබද්ධ කිරීමක් කළ හැකි බව සේවාදායකයා මත ඉතිරි නොකිරීමට මම තල්ලුවක් දෙමි. නැවතත්, එය සිදුවන්නේ ඇත්ත වශයෙන්ම අළුත් දේවල් ගෙන එන්නේ නම් පමණි .

අවසාන වශයෙන්, අවසාන || trueපිටපත දෝෂ මත අඛණ්ඩව සිදුවන බව සහතික කරයි. මෙම කාර්යය සිදු කිරීම සඳහා, පුනරාවර්තනයේ ඇති සෑම දෙයක්ම ද්විත්ව උපුටා දැක්වීම් වලින් ඔතා තිබිය යුතු අතර Git විධානයන් වරහන් වලින් ඔතා තිබිය යුතුය (ක්‍රියාකරු ප්‍රමුඛතාවය).

මගේ ප්‍රියතම කොටස:

for i in $(git submodule foreach --quiet 'echo $path')
do
  echo "Adding $i to root repo"
  git add "$i"
done

අවංකව සියලු submodules - සමග --quiet, ප්රතිදානය 'MODULE_PATH ඇතුළත්' ඉවත් කරන. භාවිතා කිරීම 'echo $path'(තනි උපුටා දැක්වීම්වල තිබිය යුතුය), උප මොඩියුලයට යන මාර්ගය ප්‍රතිදානය සඳහා ලියා ඇත.

සාපේක්ෂ උප මොඩියුල මාර්ග මෙම ලැයිස්තුව අරාවෙහි ග්‍රහණය කර ඇත ( $(...)) - අවසානයේ මෙය නැවත කියවා git add $iමව් ගබඩාව යාවත්කාලීන කිරීමට කරන්න.

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

මට ජෙන්කින්ස් හි තිර පිටපතක් තිබේ රැකියාවක අතර එය පසුව නියමිත ස්වයංක්‍රීය යෙදවීමකට සම්බන්ධ වේ.

මෙය යමෙකුට ප්‍රයෝජනවත් වනු ඇතැයි මම බලාපොරොත්තු වෙමි.

උප මොඩියුල ලබා ගැනීම සඳහා සරල හා සරල ය:

git submodule update --init --recursive

දැන් ඒවා නවතම ප්‍රධාන ශාඛාවට යාවත්කාලීන කිරීම දිගටම කරගෙන යන්න (උදාහරණයක් ලෙස):

git submodule foreach git pull origin master

සටහන, උප මොඩියුල යාවත්කාලීන කිරීමේ නවීන ක්‍රමය වනුයේ:

git submodule update --recursive --remote --merge --force

පැරණි ස්වරූපය වූයේ:

git submodule foreach --quiet git pull --quiet origin

හැර ... මෙම දෙවන ස්වරූපය සැබවින්ම "නිහ" "නොවේ.

Nguyễn Thái Ngọc Duy ( ) විසින් කරන ලද a282f5a (12 අප්‍රේල් 2019) බලන්න . ^{(විසින් අලුතින් ඒකාබද්ධ ජූනි සී Hamano - - දී f1c9f6c සිදු , 25 අප්රේල් 2019)}pclouds
gitster

submodule foreach: <command> --quietගරු නොකිරීමට " " නිවැරදි කරන්න

රොබින් ඒ බව වාර්තා කළේය

git submodule foreach --quiet git pull --quiet origin

තවදුරටත් නිහ quiet නැත. Fc1b924
ට පෙර එය නිහ be විය යුතුය ( submodule: port submodulesubcommand ' foreach' shell සිට C, 2018-05-10, Git v2.19.0-rc0) parseoptඅහම්බෙන් විකල්පයන් ආහාරයට ගත නොහැකි නිසා .

" git pull" හැසිරෙන්නේ හරියට--quiet ලබා නොදුන් .

මෙය සිදු නිසා parseoptතුළ submodule--helperදෙකම විග්රහ කළ කිරීමට උත්සාහ කරනු ඇත --quiet, නෑ ඔවුන් foreach ගේ විකල්ප නම් ලෙස විකල්ප git-pullගේ.
විග්‍රහ කරන ලද විකල්පයන් විධාන රේඛාවෙන් ඉවත් කරනු ලැබේ. ඉතින් අපි පසුව අදින විට, අපි මෙය ක්‍රියාත්මක කරමු

git pull origin

උප මොඩියුල සහායකයා අමතන විට, " --" ඉදිරිපිට " " එකතු කිරීම සැබවින්ම අයත් නොවන විග්‍රහ කිරීමේ විකල්පයන් සඳහා git pullනතර parseoptවේ submodule--helper foreach.

PARSE_OPT_KEEP_UNKNOWNආරක්ෂිත පියවරක් ලෙස ඉවත් කරනු ලැබේ. parseoptනොදන්නා විකල්පයන් කිසි විටෙකත් නොදැකිය යුතුය. මම ඔවුන් දෙස බලන අතරතුර යුවළක් භාවිතා කරන නූල් යාවත්කාලීන කිරීම් ද ඇත.

එය තිබියදී, මම " --" පසු කරන වෙනත් උපසම්පදාවලට " $@" එකතු කරමි submodule--helper. " $@" මෙම නඩු මාර්ග හා වීමට ඉඩ අඩු --something-like-this.
නමුත් කාරණය තවමත් පවතී, git-submoduleවිකල්ප මොනවාද, මාර්ග මොනවාද යන්න විග්‍රහ කොට වර්ගීකරණය කර ඇත.
submodule--helperසම්මත කළ මාර්ගයන් එකක් ලෙස පෙනුනත් git-submoduleවිකල්පයන් ලෙස කිසි විටෙකත් නොසැලකිය යුතුය .

Git 2.23 (Q3 2019) තවත් ගැටළුවක් නිරාකරණය කරයි: git submodule foreach" --recursive" විකල්පය භාවිතයේ තිබියදී, සෑම උප මොඩියුලයකම නිවැරදිව ක්‍රියාත්මක කිරීම සඳහා විධානය වෙත ලබා දුන් විධාන රේඛා විකල්පයන් ආරක්ෂා කර නැත .

මොරියන් සොනෙට් ( momoson) විසින් කරන ලද 30db18b (24 ජුනි 2019) බලන්න .
^{(විසින් අලුතින් ඒකාබද්ධ ජූනි සී Hamano - gitster- දී 968eecb සිදු 09 ජූලි 2019,)}

submodule foreach: විකල්ප පුනරාවර්තනය නිවැරදි කරන්න

ඇමතුම්:

git submodule foreach --recursive <subcommand> --<option>

විකල්පය --<option>නොදන්නා බව සඳහන් දෝෂයකට මග පාදයි submodule--helper.
එය ඇත්ත වශයෙන්ම <option>වලංගු විකල්පයක් නොවන විට පමණි git submodule foreach.

මෙයට හේතුව, ඉහත ඇමතුම අභ්‍යන්තරව උප මොඩියුලය සඳහා වූ ඇමතුමකට පරිවර්තනය කිරීමයි - සහායක:

git submodule--helper foreach --recursive \
    -- <subcommand> --<option>

මෙම ඇමතුම ආරම්භ වන්නේ පළමු මට්ටමේ උප මොඩියුලය තුළ ඇති උපසම්පදාව එහි විකල්පය සමඟ ක්‍රියාත්මක කිරීමෙන් වන අතර submodule foreachඇමතුමේ ඊළඟ නැවත නැවත ඇමතීමෙන්

git --super-prefix <submodulepath> submodule--helper \
   foreach --recursive <subcommand> --<option>

පළමු මට්ටමේ උප මොඩියුලය තුළ. උප කමාන්ඩ් ඉදිරිපිට ඇති ද්විත්ව ඉරක් නැති බව සලකන්න.

මෙම ගැටළුව පැන නැගීමට පටන් ගන්නේ මෑතකදී පමණි, a282f5a හි PARSE_OPT_KEEP_UNKNOWNතර්ක විග්‍රහ කිරීම සඳහා වූ ධජය git submodule foreachඉවත් කරන ලදි .
එබැවින්, නොදන්නා විකල්පය ගැන දැන් පැමිණිලි කරනු ලැබේ, තර්කය විග්‍රහ කිරීම ද්විත්ව ඉරකින් නිසි ලෙස අවසන් නොවන බැවින්.

පුනරාවර්තනයේදී උප කමාන්ඩ් ඉදිරිපිට ද්විත්ව ඉරක් එක් කිරීමෙන් මෙම බැඳීම ගැටළුව විසඳයි.

git pull --recurse-submodules

මෙය සියලු නවතම කොමිස් අදින්නේය.

මගේ නඩුවේදී, මට අවශ්ය විය git නවතම දේ යාවත්කාලීන කිරීමට සහ ඒ සමඟම නැතිවූ ලිපිගොනු නැවත ජනනය කිරීමට ය.

පහත දැක්වෙන්නේ නැතිවූ ලිපිගොනු ප්‍රතිෂ් ored ාපනය කිරීමයි (ස්තූතියි --forceමෙහි සඳහන් කර ඇති බවක් නොපෙනේ), නමුත් එය නව කොමිස් කිසිවක් ඇද ගත්තේ නැත:

git submodule update --init --recursive --force

මෙය සිදු කළේ:

git submodule update --recursive --remote --merge --force

ඔබ සත්කාරක ශාඛාව නොදන්නේ නම්, මෙය සාදන්න:

git submodule foreach git pull origin $(git rev-parse --abbrev-ref HEAD)

එය ප්‍රධාන Git ගබඩාවේ ශාඛාවක් ලබා ගන්නා අතර පසුව සෑම උප මොඩියුලයක් සඳහාම එකම ශාඛාවක් ඇද ගනු ඇත.

Ason ජේසන් එක්තරා ආකාරයකින් නිවැරදි නමුත් සම්පූර්ණයෙන්ම නොවේ.

යාවත්කාලීන කිරීම

ලියාපදිංචි උප මොඩියුල යාවත්කාලීන කරන්න, එනම් අතුරුදහන් වූ උප මොඩියුල ක්ලෝන සහ අඩංගු ගබඩාවේ දර්ශකයේ දක්වා ඇති බැඳීම පරීක්ෂා කරන්න. මේ submodules --rebase හෝ --merge නියම කර හෝ යතුර submodule. $ Name.update rebase හෝ ඒකාබද්ධ කිරීම හෝ සිදු කිරීමට නියමිතය මිස හිස වෙන් කළ යුතුයි.

එබැවින්, git submodule updateපිටවීම සිදු කරයි, නමුත් එය අඩංගු වන්නේ නිධියෙහි දර්ශකයේ ඇති බැඳීමයි. උඩුමහලේ නව කැපවීම ගැන එය තවමත් නොදනී. එබැවින් ඔබේ උප මොඩියුලය වෙත ගොස්, ඔබට අවශ්‍ය කැපවීම ලබාගෙන යාවත්කාලීන කරන ලද උප මොඩියුලයේ තත්වය ප්‍රධාන ගබඩාවේ සිදු කර ඉන්පසු කරන්න git submodule update.

සෑම දෙයක්ම නවතම මාස්ටර් වෙත යාවත්කාලීන කිරීමට නියමයි එක්-ලයිනර් මෙන්න:

git submodule foreach 'git fetch origin --tags; git checkout master; git pull' && git pull && git submodule update --init --recursive

මාර්ක් ජැකිත්ට ස්තූතියි

ඔබ masterඑක් එක් උප මොඩියුලය සඳහා පිටවීමේ ශාඛාවක් සොයන්නේ නම් - ඒ සඳහා ඔබට පහත විධානය භාවිතා කළ හැකිය:

git submodule foreach git checkout master