Git push error '[දුරස්ථව ප්‍රතික්ෂේප කරන ලද] මාස්ටර් -> මාස්ටර් (ශාඛාව දැනට පරීක්ෂා කර ඇත)'

ඊයේ, මම මගේ යන්ත්‍රයකින් තවත් යන්ත්‍රයකට Git ගබඩාවක් ක්ලෝන කරන්නේ කෙසේද යන්න පිළිබඳ ප්‍රශ්නයක් පළ කළෙමි, වෙනත් යන්ත්‍රයකින් 'git clone' කරන්නේ කෙසේද? .

මගේ මූලාශ්‍රයෙන් (192.168.1.2) සිට මගේ ගමනාන්තය දක්වා (192.168.1.1) Git ගබඩාවක් සාර්ථකව ක්ලෝන කිරීමට මට දැන් හැකි වී තිබේ.

නමුත් මම a git commit -a -m "test"සහ a ගොනුවකට සංස්කරණයක් කළ විට, git pushමෙම දෝෂය මගේ ගමනාන්තයට (192.168.1.1) ලැබෙනු ඇත:

git push                                                
hap@192.168.1.2's password: 
Counting objects: 21, done.
Compressing objects: 100% (11/11), done.
Writing objects: 100% (11/11), 1010 bytes, done.
Total 11 (delta 9), reused 0 (delta 0)
error: refusing to update checked out branch: refs/heads/master
error: By default, updating the current branch in a non-bare repository
error: is denied, because it will make the index and work tree inconsistent
error: with what you pushed, and will require 'git reset --hard' to match
error: the work tree to HEAD.
error: 
error: You can set 'receive.denyCurrentBranch' configuration variable to
error: 'ignore' or 'warn' in the remote repository to allow pushing into
error: its current branch; however, this is not recommended unless you
error: arranged to update its work tree to match what you pushed in some
error: other way.
error: 
error: To squelch this message and still keep the default behaviour, set
error: 'receive.denyCurrentBranch' configuration variable to 'refuse'.
To git+ssh://hap@192.168.1.2/media/LINUXDATA/working
! [remote rejected] master -> master (branch is currently checked out)
error: failed to push some refs to 'git+ssh://hap@192.168.1.2/media/LINUXDATA/working'

මම Git හි වෙනස් සංස්කරණ දෙකක් භාවිතා කරමි (දුරස්ථයේ 1.7 සහ දේශීය යන්ත්‍රයේ 1.5). එය විය හැකි හේතුවක් ද?

ඔබට ඔබේ දුරස්ථ නිධිය හිස් ගබඩාවක් බවට පරිවර්තනය කළ හැකිය (හිස් ගබඩාවේ වැඩ කරන පිටපතක් නොමැත - ෆෝල්ඩරයේ ඇත්තේ සත්‍ය නිධිය දත්ත පමණි).

ඔබගේ දුරස්ථ ගබඩාවේ ෆෝල්ඩරයේ පහත විධානය ක්‍රියාත්මක කරන්න:

git config --bool core.bare true

ඉන්පසු .gitඑම ෆෝල්ඩරයේ හැර අනෙකුත් සියලුම ගොනු මකන්න . එවිට ඔබට git pushකිසිදු දෝෂයකින් තොරව දුරස්ථ ගබඩාවට ක්‍රියා කිරීමට හැකි වනු ඇත .

මම Git ඉගෙන ගැනීමට පටන් ගන්නා අතරතුර එකම දෝෂයක් ඇතිවිය . තවත් සමහර පිළිතුරු පැහැදිලිවම Git ට අළුත් කෙනෙකුට නොවේ!

(අදහස ලබා ගැනීම සඳහා මම තාක්ෂණික නොවන යෙදුම් භාවිතා කිරීමට යන්නෙමි.) කෙසේ වෙතත්, සිදුවන්නේ ඔබට ගබඩාවන් දෙකක් තිබීමයි, එකක් ඔබ මුලින්ම සාදන ලද මුල් පිටපත වන අතර අනෙක ඔබ විසින් සාදන ලද වැඩය.

දැන් ඔබ ඔබේ වැඩ ගබඩාවේ සිටින අතර "මාස්ටර්" ශාඛාව භාවිතා කරයි. නමුත් ඔබ ඔබේ මුල් ගබඩාවේ එකම "ප්‍රධාන" ශාඛාවට "ලොග් වී" ඇත. දැන් ඔබ මුල් පිටපතට "ලොග් වී" ඇති හෙයින්, ඔබ මුල් පිටපතෙහි වැඩ කරමින් සිටින නිසා දේවල් අවුල් විය හැකි යැයි Git බිය වේ. එබැවින් ඔබ මුල් ගබඩාවට ආපසු ගොස් "git checkout someotherbranch" එකක් කළ යුතු අතර දැන් ඔබට කිසිදු ගැටළුවක් නොමැතිව තල්ලු කළ හැකිය.

මම හිතනවා මේක උදව් වෙයි කියලා.

දෝෂ පණිවිඩය සිදුවී ඇති දේ විස්තර කරයි. Git හි වඩාත් නවීන අනුවාදයන් එම ශාඛාව පරීක්ෂා කර බැලුවහොත් තල්ලුවක් හරහා ශාඛාවක් යාවත්කාලීන කිරීම ප්‍රතික්ෂේප කරයි.

හිස් නොවන නිධි දෙකක් අතර වැඩ කිරීමට ඇති පහසුම ක්‍රමය වන්නේ

1. සෑම විටම නිධිය අදින්න (හෝ ලබා ගැනීම හා ඒකාබද්ධ කිරීම) යාවත්කාලීන කරන්න හෝ ඔබට අවශ්‍ය නම්,

2. වෙනම ශාඛාවකට (ආනයන ශාඛාවකට) තල්ලු කිරීමෙන් සහ එම ශාඛාව දුරස්ථ යන්ත්‍රයේ ප්‍රධාන ශාඛාවට ඒකාබද්ධ කිරීමෙන්.

මෙම සීමාවට හේතුව තල්ලු කිරීමේ මෙහෙයුම ක්‍රියාත්මක වන්නේ දුරස්ථ Git ගබඩාව මත පමණි, එයට දර්ශකයට හා වැඩ කරන ගසට ප්‍රවේශයක් නොමැත. එබැවින්, අවසර දී ඇත්නම්, පරීක්ෂා කරන ලද ශාඛාව මතට තල්ලු කිරීම දුරස්ථ ගබඩාවේ දර්ශකයට හා වැඩ කරන ගසට නොගැලපෙන ලෙස වෙනස් කරයි HEAD .

මෙය තල්ලු කරන ලද සියළු වෙනස්කම් අහෝසි කරන වෙනසක් අහම්බෙන් සිදු කිරීම ඉතා පහසු කරවන අතර සිදු කර නොමැති දේශීය වෙනස්කම් සහ නව HEAD, දර්ශකය සහ වැඩ කරන ගස අතර වෙනස හඳුනා ගැනීම ඉතා අපහසු කරයි. තල්ලු චලනය නිසා ඇතිවේ HEAD.

සාරාංශය

ඔබට නිධියක පරීක්ෂා කළ එක් ශාඛාවකට තල්ලු කළ නොහැක, මන්ද එය එම ගබඩාවේ පරිශීලකයා සමඟ පටලවා ගෙන දත්ත හා ඉතිහාසය නැතිවීමෙන් බොහෝ දුරට අවසන් වනු ඇත . නමුත් ඔබට එකම ගබඩාවේ වෙනත් ඕනෑම ශාඛාවකට තල්ලු කළ හැකිය.

හිස් ගබඩාවල කිසි විටෙක කිසිදු ශාඛාවක් පරීක්ෂා කර නොමැති බැවින්, ඔබට සෑම විටම හිස් ගබඩාවක ඕනෑම ශාඛාවකට තල්ලු කළ හැකිය.

ඔබේ අවශ්‍යතා අනුව විවිධ විසඳුම් තිබේ.

විසඳුම 1: හිස් ගබඩාවක් භාවිතා කරන්න

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

machine1$ cd ..
machine1$ mv repo repo.old
machine1$ git clone --bare repo.old repo

දැන් ඔබට අවශ්‍ය සියල්ල පෙර මෙන් එකම ලිපිනයට තල්ලු කළ හැකිය.

විසඳුම 2: පරීක්ෂා නොකළ ශාඛාවකට තල්ලු කරන්න

නමුත් ඔබේ දුරස්ථයේ ඇති කේතය පරීක්ෂා කිරීමට ඔබට අවශ්‍ය නම්, ඔබට <remote>තල්ලු කිරීම සඳහා විශේෂ ශාඛාවක් භාවිතා කළ හැකිය. ඔබගේ දේශීය ගබඩාවේදී ඔබ දුරස්ථය අමතා originඔබ ශාඛා මාස්ටර් බව කියමු. එවිට ඔබට කළ හැකිය

machine2$ git push origin master:master+machine2

ඔබ originදුරස්ථ repo හි සිටින විට එය ඒකාබද්ධ කිරීමට අවශ්‍යය :

machine1$ git merge master+machine2

ගැටලුවේ මරණ පරීක්ෂණය

ශාඛාවක් පරික්ෂා කර බැලූ විට, කැපවීම වත්මන් ශාඛාවේ හිස සමඟ එහි මවුපියන් ලෙස නව බැඳීමක් එක් කරන අතර ශාඛාවේ හිස එම නව කැපවීම බවට පත් කරයි.

නිසා

A ← B
    ↑
[HEAD,branch1]

බවට පත්වේ

A ← B ← C
        ↑
    [HEAD,branch1]

නමුත් යමෙකුට එම ශාඛාව තුළට තල්ලු කළ හැකි නම්, පරිශීලකයාට git යනුවෙන් හැඳින්වෙන හෙඩ් ප්‍රකාරය ලැබෙනු ඇත :

A ← B ← X
    ↑   ↑
[HEAD] [branch1]

වෙනත් පරිශීලක ශාඛාවක් පරීක්ෂා කර බැලීමට පැහැදිලිවම ඉල්ලා නොසිට පරිශීලකයා දැන් ශාඛා 1 හි නොමැත. නරකම දෙය නම්, පරිශීලකයා දැන් ඕනෑම ශාඛාවකට පිටතින් සිටින අතර , ඕනෑම නව බැඳීමක් කරදරකාරී වනු ඇත :

      [HEAD]
        ↓
        C
      ↙
A ← B ← X
        ↑
       [branch1]

උපකල්පිත වශයෙන්, මෙම අවස්ථාවේදී, පරිශීලකයා වෙනත් ශාඛාවක් පරික්ෂා කරන්නේ නම්, මෙම අන්තරාදායක කැපවීම Git හි කසළ එකතු කරන්නාට සාධාරණ ක්‍රීඩාවක් බවට පත්වේ .

සංස්කරණය කිරීමෙන් ඔබට මෙම “සීමාව” ඉක්මවා යා හැකිය .git/configගමනාන්ත සේවාදායකයේ . Git ගබඩාවක් “පරීක්ෂා කර බැලුවද” එය තල්ලු කිරීමට ඉඩ දීම සඳහා පහත සඳහන් දෑ එක් කරන්න:

[receive]
denyCurrentBranch = warn

හෝ

[receive]
denyCurrentBranch = false

පළමුවැන්න තල්ලු කිරීමට ඉඩ දෙන අතර ශාඛාව අවුල් කිරීමට ඇති හැකියාව ගැන අනතුරු අඟවන අතර දෙවැන්න නිහ ly ව එයට ඉඩ දෙනු ඇත.

සංස්කරණය සඳහා අදහස් නොකරන සේවාදායකයකට කේතය "යෙදවීම" සඳහා මෙය භාවිතා කළ හැකිය. මෙය හොඳම ප්‍රවේශය නොව කේතය යෙදවීම සඳහා ඉක්මන් ක්‍රමයකි.

git config --local receive.denyCurrentBranch updateInstead

https://github.com/git/git/blob/v2.3.0/Documentation/config.txt#L2155

සේවාදායක ගබඩාවේ එය භාවිතා කරන්න, තවද අනවසරයෙන් නැවත ලිවීමක් සිදු නොවන්නේ නම් එය වැඩ කරන ගස යාවත්කාලීන කරයි.

අදහස් දැක්වීමේදී VonC විසින් සඳහන් කර ඇති පරිදි එය Git 2.3 හි එකතු කරන ලදී .

මම Git 2.3 සම්පාදනය කර එය උත්සාහ කර බැලුවෙමි. නියැදි භාවිතය:

git init server
cd server
touch a
git add .
git commit -m 0
git config --local receive.denyCurrentBranch updateInstead

cd ..
git clone server local
cd local
touch b
git add .
git commit -m 1
git push origin master:master

cd ../server
ls

ප්‍රතිදානය:

a
b

ඔව්, bතල්ලු වුණා!

දුරස්ථ කොටුවේ තවමත් භාවිතා කළ හැකි ගබඩාවක් තිබීමේ අදහසට මා කැමතිය, නමුත් ව්‍යාජ ශාඛාවක් වෙනුවට මම භාවිතා කිරීමට කැමතියි:

git checkout --detach

මෙය Git හි ඉතා නව අංගයක් ලෙස පෙනේ - මම git අනුවාදය 1.7.7.4 භාවිතා කරමි.

මටත් ඒ ප්‍රශ්නයම තිබුණා. මට, මම මගේ සේවාදායකයට කේතය ගෙනයාමට Git push භාවිතා කරමි. මම කිසි විටෙකත් සේවාදායක පැත්තේ කේතය වෙනස් නොකරමි, එබැවින් මෙය ආරක්ෂිතයි.

නිධිය තුළ, ඔබ ටයිප් කිරීමට තල්ලු කරයි:

git config receive.denyCurrentBranch ignore

මෙය වැඩ කරන පිටපතක් වන අතර නිධිය වෙනස් කිරීමට ඔබට ඉඩ සලසයි.

ඔබ Git push ධාවනය කිරීමෙන් පසු දුරස්ථ යන්ත්‍රය වෙත ගොස් මෙය ටයිප් කරන්න:

git checkout -f

මෙය ඔබ තල්ලු කළ වෙනස්කම් දුරස්ථ යන්ත්‍රයේ ක්‍රියාකාරී පිටපතෙහි පිළිබිඹු වේ.

කරුණාකර සටහන් කරන්න, ඔබ තල්ලු කරන වැඩ කරන පිටපතෙහි වෙනස්කම් සිදු කරන්නේ නම් මෙය සැමවිටම ආරක්ෂිත නොවේ.

ඔබට ඔබේ සේවාදායක ගබඩාව ප්‍රතිනිර්මාණය කර ඔබේ ප්‍රාදේශීය ශාඛා මාස්ටර් වෙතින් සේවාදායක මාස්ටර් වෙත තල්ලු කළ හැකිය.

ඔබගේ දුරස්ථ සේවාදායකයේ:

mkdir myrepo.git
cd myrepo.git
git init --bare

හරි, ඔබේ ප්‍රාදේශීය ශාඛාවෙන්:

git push origin master:master

මෙය සිදුවීමට ඔබ බොහෝ විට කළ දේ:

ඔබ කුඩා වැඩසටහනක් කිරීමට ගිය විට මේ ආකාරයේ දෙයක් සිදු වේ. ඔබ මේ වන විටත් ක්‍රියාත්මක වෙමින් තිබූ දෙයක් වෙනස් කිරීමට සූදානම්ව සිටී, එබැවින් ඔබ ඔබේ මට්ටම -3 අක්ෂර වින්‍යාසය සදාකාලිකවම අහෝසි කළ හැකිය:

machine1:~/proj1> git init

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

machine2:~> git clone ssh://machine1/~/proj1

එය ක්ලෝන වන අතර සෑම දෙයක්ම හොඳින් පෙනේ, එබැවින් ඔබ ඔබේ කේතය මැෂින් 2 වෙතින් වැඩ කරයි.

ඉන්පසුව ... ඔබ ඔබේ කොමිස් මැෂින් 2 වෙතින් තල්ලු කිරීමට උත්සාහ කරන අතර ඔබට මාතෘකාව තුළ අනතුරු ඇඟවීමේ පණිවිඩය ලැබේ.

මෙම පණිවිඩයට හේතුව වන්නේ ඔබ ඇදගත් git repo යන්ත්රය 1 හි ඇති ෆෝල්ඩරය සඳහා පමණක් භාවිතා කිරීමට අදහස් කිරීමයි. ඔබට එයින් ක්ලෝන කළ හැකිය , නමුත් තල්ලු කිරීම ගැටළු ඇති කළ හැකිය. විවිධ ස්ථාන දෙකක කේතය කළමනාකරණය කිරීමේ “නිසි” ක්‍රමය යෝජනා කර ඇති පරිදි “හිස්” රෙපෝවකි. යන්තම් රෙපෝවක් නිර්මාණය කර ඇත්තේ එහි කිසිදු වැඩක් සිදු කිරීම සඳහා නොවේ, එයින් අදහස් කරන්නේ බහු ප්‍රභවයන්ගෙන් ලැබෙන කොමිස් සම්බන්ධීකරණය කිරීමයි. ඔබට පසුව .git ෆෝල්ඩරය හැර අනෙකුත් සියලුම ගොනු / ෆෝල්ඩර මකා දැමීමට ඉහළම ශ්‍රේණිගත පිළිතුර යෝජනා කරන්නේ මේ නිසා යgit config --bool core.bare true .

ඉහළම ශ්‍රේණිගත පිළිතුර පැහැදිලි කිරීම: බොහෝ අදහස් දැක්වෙන්නේ "මම මැෂින් 1 වෙතින් .git නොවන ගොනු මකා නොදැමූ අතර මට තවමත් මැෂින් 2 වෙතින් කැපවීමට හැකි විය" වැනි ය. ඒක හරි. කෙසේ වෙතත්, එම අනෙකුත් ලිපිගොනු දැන් git repo වෙතින් සම්පූර්ණයෙන්ම "දික්කසාද" වී ඇත. එහි ගොස් උත්සාහ කරන්න git status, ඔබ "මාරාන්තික: මෙම ක්‍රියාව වැඩ කරන ගසක ක්‍රියාත්මක කළ යුතුය" වැනි දෙයක් දැකිය යුතුය. ඒ නිසා, ගොනු මකා දැමීම සඳහා යෝජනාව machine2 කැමැත්ත සිදු එසේ නොවේ වැඩ ; එය එසේ වන්නේ ඔබ ව්‍යාකූල නොවී ගිට් තවමත් එම ලිපිගොනු ලුහුබඳිමින් සිටින බව සිතමිනි. නමුත්, මැෂින් 1 හි ඇති ගොනු මත වැඩ කිරීමට ඔබට අවශ්‍ය නම්, ගොනු මකා දැමීම ගැටළුවක් වේ, එසේ නොවේ ද?

ඉතින්, ඔබ ඇත්තටම කළ යුත්තේ කුමක්ද?

මැෂින් 1 සහ මැෂින් 2 මත වැඩ කිරීමට ඔබ කොපමණ ප්‍රමාණයක් සැලසුම් කර ඇත්ද යන්න මත රඳා පවතී ...

ඔබ මැෂින් 1 සිට සංවර්ධනය කර ඔබගේ සියලු සංවර්ධනය මැෂින් 2 වෙත ගෙන ගොස් තිබේ නම් ... ඉහළම ශ්‍රේණිගත පිළිතුරෙන් යෝජනා කරන දේ කරන්න:git config --bool core.bare true ඉන්පසු, විකල්පයක් ලෙස, එම ෆෝල්ඩරයෙන් .git හැර අනෙකුත් සියලුම ගොනු / ෆෝල්ඩර මකා දමන්න. සොයා නොගත් අතර ව්‍යාකූලත්වයට හේතු විය හැක.

මැෂින් 2 හි ඔබගේ වැඩ කටයුතු එක් වරක් පමණක් වූවා නම්, ඔබට එහි සංවර්ධනය දිගටම කරගෙන යාමට අවශ්‍ය නොවේ නම් ... නම් එහෙනම් හිස් සෑදීමට කරදර නොවන්න; ftp / rsync / scp / etc. * 1 * යන්ත්‍රයේ ඇති ලිපිගොනු මුදුනේ * 2 * යන්ත්‍රයෙන්, * 1 * යන්ත්‍රයෙන් කැපවීම / තල්ලු කිරීම, ඉන්පසු යන්ත්‍රයෙන් ලිපිගොනු මකා දමන්න * 2 *. තවත් සමහරු ශාඛාවක් සෑදීමට යෝජනා කර ඇත, නමුත් මම සිතන්නේ ඔබ එක් වරකදී සිදු කළ යම් සංවර්ධනයක් වෙනත් යන්ත්‍රයකින් ඒකාබද්ධ කිරීමට අවශ්‍ය නම් එය ටිකක් අවුල් සහගත බවයි.

මැෂින් 1 සහ මැෂින් 2 යන දෙවර්ගයේම සංවර්ධනය දිගටම කරගෙන යාමට ඔබට අවශ්‍ය නම් ... එවිට ඔබ නිසි ලෙස දේවල් සකස් කළ යුතුය. ඔබට ඔබේ ගබඩාව හිස් තැනකට පරිවර්තනය කළ යුතුය, එවිට ඔබට වැඩ කිරීමට මැෂින් 1 හි ක්ලෝනයක් සෑදිය යුතුය . බොහෝ විට මෙය කිරීමට ඉක්මන්ම ක්‍රමය වන්නේ

machine1:~/proj1> git config --bool core.bare true
machine1:~/proj1> mv .git/ ../proj1.git
machine1:~/proj1> cd ..
machine1:~> rm -rf proj1
machine1:~> git clone proj1.git
machine1:~> cd proj1

ඉතා වැදගත්: ඔබ repo හි පිහිටීම proj1 සිට proj1.git වෙත ගෙන ගොස් ඇති නිසා, ඔබ මෙය machine2 හි .git / config ගොනුවේ යාවත්කාලීන කළ යුතුය . ඊට පසු, ඔබට යන්ත්‍ර 2 වෙතින් ඔබේ වෙනස්කම් සිදු කළ හැකිය. අවසාන වශයෙන්, මම මගේ හිස් ගස් මගේ වැඩ ගස් වලින් away ත්ව කේන්ද්‍රීය ස්ථානයක තබා ගැනීමට උත්සාහ කරමි (එනම් 'proj1.git' එකම මව් ෆෝල්ඩරයේ 'proj1' ලෙස නොතබන්න). ඒ හා සමාන දෙයක් කිරීමට මම ඔබට උපදෙස් දෙමි, නමුත් මට අවශ්‍ය වූයේ හැකි පියවර හැකි තරම් සරල ලෙස තබා ගැනීමටයි.

සැකසීමේ පියවර කිහිපයක් සමඟ ඔබට එක්-ලයිනර් වැනි පහසුවෙන් ඔබේ වෙබ් අඩවියේ වෙනස්කම් යෙදවිය හැකිය

git push production

එය කදිම හා සරල වන අතර ඔබට දුරස්ථ සේවාදායකයට ඇතුළු වී අදින්න හෝ කිසිවක් කිරීමට අවශ්‍ය නැත. ඔබ ඔබේ නිෂ්පාදන පිරික්සුම ක්‍රියාකාරී ශාඛාවක් ලෙස භාවිතා නොකරන්නේ නම් මෙය වඩාත් හොඳින් ක්‍රියාත්මක වන බව සලකන්න! (OP තරමක් වෙනස් සන්දර්භයක් තුළ ක්‍රියාත්මක වූ අතර, මම සිතන්නේ ob රොබට් ගුල්ඩ්ගේ විසඳුම එය හොඳින් ආමන්ත්‍රණය කළේය. දුරස්ථ සේවාදායකයකට යෙදවීම සඳහා මෙම විසඳුම වඩාත් යෝග්‍ය වේ.)

පළමුව ඔබ ඔබේ වෙබ් රූට් වලින් පිටත ඔබේ සේවාදායකයේ කොතැනක හෝ හිස් ගබඩාවක් සැකසිය යුතුය.

mkdir mywebsite.git
cd mywebsite.git
git init --bare

ඉන්පසු ගොනුව සාදන්න hooks/post-receive:

#!/bin/sh
GIT_WORK_TREE=/path/to/webroot/of/mywebsite git checkout -f

ගොනුව ක්‍රියාත්මක කළ හැකි කරන්න:

chmod +x hooks/post-receive

ඔබේ දේශීය යන්ත්‍රයේ,

git remote add production git@myserver.com:mywebsite.git
git push production +master:refs/heads/master

සියල්ල සූදානම්! දැන් අනාගතයේදී git push productionඔබේ වෙනස්කම් යෙදවීමට ඔබට භාවිතා කළ හැකිය !

මෙම විසඳුම සඳහා ණය http://sebduggan.com/blog/deploy-your-website-changes-using-git/ වෙත යයි . සිදුවන්නේ කුමක්ද යන්න පිළිබඳ වඩාත් සවිස්තරාත්මක පැහැදිලි කිරීමක් සඳහා එහි බලන්න.

ඔබ කළ යුත්තේ හිස් ගබඩාවකට පමණි. හිස් ගබඩාවක් යනු පරීක්ෂා නොකළ ශාඛා නොමැති ගබඩාවකි. ඔබ සීඩී යන්තම් නිධි ගබඩාවකට ගියහොත්, ඔබට පෙනෙන්නේ .git නාමාවලියක අන්තර්ගතය පමණි.

ඔබට විකල්ප 3 ක් ඇත

1. අදින්න සහ නැවත තල්ලු කරන්න:

   git pull; git push
   

2. විවිධ ශාඛාවලට තල්ලු කරන්න:

   git push origin master:foo
   

   එය දුරස්ථව ඒකාබද්ධ කරන්න ( ඉල්ලීම අනුවgit හෝ අදින්න )

   git merge foo
   

3. එයට බල කරන්න (ඔබ හිතාමතාම කොමිස් වෙනස් නොකළහොත් නිර්දේශ නොකරයි rebase):

   git push origin master -f
   

   තවමත් ප්රතික්ෂේප කළා නම්, ආබාධිත denyCurrentBranch මත දුරස්ථ දම්න්න:

   git config receive.denyCurrentBranch ignore
   

ඔබගේ .git/configගමනාන්ත ව්‍යාපෘතියේ පරීක්ෂා කරන්න :

$ cat .git/config 
[core]
    repositoryformatversion = 0
    filemode = true
    bare = false
    logallrefupdates = true
[receive]
    denyCurrentBranch = updateInstead

නම් core. bareබොරු, ඔබ සැබෑ ලෙස සකස් කර හැක:

$ git config core.bare true

ඉන්පසු ඔබේ දේශීය දුරස්ථව තල්ලු කිරීමේදී:

git push remote_repo   // suppose the destination repo is remote_repo

එය සාර්ථක වනු ඇත, දුරස්ථ_රෙපෝ තුළ ඔබට git අනුවාදය පරීක්ෂා කළ හැකිය.

$ git log -1
commit 0623b1b900ef7331b9184722a5381bbdd2d935ba
Author: aircraft < aircraft_xxx@126.com>
Date:   Thu May 17 21:54:37 2018 +0800

දැන් ඔබට ඔබේ "වැඩපොළ" තුළ git භාවිතා කළ නොහැක:

$ git status
fatal: This operation must be run in a work tree

ඔබ bare.bareනැවත අසත්‍යයට යා යුතුය .

$ git config core.bare false

ඇත්ත වශයෙන්ම, දුරස්ථය පරීක්ෂා නොකළ ශාඛාවකට සැකසීම ප්‍රමාණවත් වේ. ඔබේ දුරස්ථය වෙනත් ශාඛාවකින් පරීක්ෂා කිරීමෙන් පසුව, ඔබට තල්ලු කළ හැකිය.

මගේ ඇන්ඩ්‍රොයිඩ් දුරකථනයේ සහ ලැප්ටොප් පරිගණකයේ ගබඩාවන් සමමුහුර්ත කිරීමට Git භාවිතා කිරීම මට සමාන ගැටලුවක් විය. මට විසඳුම වූයේ har චාර්ල්ස් බේලි යෝජනා කළ පරිදි තල්ලුවක් වෙනුවට අදින්න.

git push origin master ඇන්ඩ්‍රොයිඩ් නිධිය තුළ @ hap497 වෙත ලැබුණු දෝෂ සහිත පණිවිඩ මට අසමත් වන්නේ නිධිය + වැඩ කරන පිටපතක් නොසැලකිලිමත් ලෙස පිරික්සීමට තල්ලු වීම නිසාය.

git pull droid masterලැප්ටොප් ගබඩාවේ සහ වැඩ කරන පිටපත් මට වැඩ කරයි. ඇත්ත වශයෙන්ම, ඔබ මීට පෙර වැනි දෙයක් ධාවනය කර තිබිය යුතුය git remote add droid /media/KINGSTON4GB/notes_repo/.

Git හි පැරණි අනුවාදයන් දැනට පරික්‍ෂා කර ඇති හිස් ගබඩාවකට තල්ලු කිරීමට ඉඩ ලබා දේ.

මෙය ඉඩ දීම අතිශය ව්‍යාකූල දෙයක් බව පෙනේ. එබැවින් ඔවුන් ඔබ දකින අනතුරු ඇඟවීමේ පණිවිඩය එක් කළ අතර එය ද ව්‍යාකූල ය.

පළමු නිධිය සේවාදායකයක් ලෙස ක්‍රියා කරන්නේ නම් අනෙක් පිළිතුරු නිර්දේශ කරන පරිදි එය හිස් ගබඩාවක් බවට පරිවර්තනය කර එය සමඟ කරන්න.

කෙසේ වෙතත් ඔබට භාවිතයේ ඇති නිධි දෙකක් අතර හවුල් ශාඛාවක් තිබිය යුතු නම් පහත සඳහන් සැකසුම සමඟ ඔබට එය සාක්ෂාත් කරගත හැකිය

Repo1 - සේවාදායකය ලෙස ක්‍රියා කරන අතර සංවර්ධනය සඳහා ද භාවිතා වේ

Repo2 - සංවර්ධනය සඳහා පමණි

Repo1 පහත පරිදි සකසන්න

වැඩ බෙදා ගැනීමට ශාඛාවක් සාදන්න.

git branch shared_branch

ආරක්ෂිත වීමට, ඔබ shared (REPO) .git / කොකු / යාවත්කාලීනයක් නිර්මාණය කළ යුතු අතර එය හවුල්_ ශාඛාව හැර වෙනත් ඕනෑම දෙයක වෙනස්කම් ප්‍රතික්ෂේප කරයි, මන්ද ඔබේ පුද්ගලික ශාඛා සමඟ මිනිසුන් සම්බන්ධ වීම ඔබට අවශ්‍ය නැති බැවිනි.

repo1/.git/hooks  (GIT_DIR!)$ cat update
#!/bin/sh
refname="$1"
oldrev="$2"
newrev="$3"

if [ "${refname}" != "refs/heads/shared_branch" ]
then
   echo "You can only push changes to shared_branch, you cannot push to ${refname}"
   exit 1
fi

දැන් repo1 හි දේශීය ශාඛාවක් සාදන්න, එහිදී ඔබ ඔබේ සැබෑ වැඩ කටයුතු කරනු ඇත.

git checkout -b my_work --track shared_branch
Branch my_work set up to track local branch shared_branch.
Switched to a new branch 'my_work'

( git config --global push.default upstreamඅනුපිළිවෙලට අවශ්‍ය විය හැකgit push වැඩ )

දැන් ඔබට repo2 සමඟ නිර්මාණය කළ හැකිය

git clone path/to/repo1 repo2 
git checkout shared_branch 

මෙම අවස්ථාවෙහිදී shared_branch, එම දෝෂ පණිවිඩය ගැන කරදර වීමට අවශ්‍ය නොවී හෝ වැඩ කරන නාමාවලිය repo1 හි සමමුහුර්තතාවයෙන් ඉවත් නොවී, repo1 තුළට තල්ලු කර අදින දේශීය ශාඛා මත වැඩ කිරීමට ඔබට repo1 සහ repo2 සැකසුම් දෙකම ඇත. ඔබ භාවිතා කරන සාමාන්‍ය කාර්ය ප්‍රවාහය කුමක් වුවත් වැඩ කළ යුතුය.

හරි, ඔබට සාමාන්‍ය දුරස්ථ ගබඩාවක් අවශ්‍ය නම් අමතර ශාඛාවක් සාදා එය පරීක්ෂා කරන්න. එය එක් ශාඛාවකට තල්ලු කර (පරීක්ෂා කර නොමැති) සහ දේශීයව තල්ලු කිරීමෙන් පසුව දැනට ක්‍රියාත්මක වන ශාඛාවක් සමඟ එය ඒකාබද්ධ කරන්න.

උදාහරණයක් ලෙස, දුරස්ථ සේවාදායකයක:

git branch dev
git checkout dev

දේශීය සැකසුම මත:

git push 

දුරස්ථ සේවාදායකයේ:

git merge dev

bareසේවාදායක දේවල් ක්‍රියාත්මක වන ආකාරය බැලීමට ඔබට කළ හැකි එක් පරීක්ෂණය මෙන්න :

ඔබට වැඩපොළක් සහ සජීවී වෙබ් අඩවියක් ඇති සේවාදායකයක් ඇතැයි සිතන්න, ඔබට මෙම වෙබ් අඩවිය වරින් වර යාවත්කාලීන කිරීමට අවශ්‍යය (සංවර්ධකයින් දෙදෙනෙකු ඔවුන්ගේ වැඩ කටයුතු යන්තම් අතරමැදියා හරහා යවන තත්වයකට ද මෙය අදාළ වේ).

ආරම්භ කිරීම

ඔබේ දේශීය පරිගණකයේ සහ ඒ cdතුළට යම් නාමාවලියක් සාදන්න , ඉන්පසු මෙම විධානයන් ක්‍රියාත්මක කරන්න:

# initialization
git init --bare server/.git
git clone server content
git clone server local

1. පළමුව ඔබ හිස් serverඩිරෙක්ටරියක් සාදන්න (අවසානයේ .git බලන්න). මෙම නාමාවලිය ඔබගේ නිධි ලිපිගොනු සඳහා පමණක් බහාලුමක් ලෙස සේවය කරයි.
2. ඉන්පසු ඔබගේ සේවාදායක ගබඩාව අලුතින් සාදන ලද contentනාමාවලියකට ක්ලෝන කරන්න . මෙය ඔබගේ සජීවී / නිෂ්පාදන නාමාවලිය වන අතර එය ඔබේ සේවාදායක මෘදුකාංග මඟින් සපයනු ඇත.
3. පළමු ඩිරෙක්ටරි දෙක ඔබේ සේවාදායකයේ වාසය කරයි, තෙවනුව ඔබේ සේවා ස්ථානයේ දේශීය නාමාවලියකි.

කාර්ය ප්‍රවාහය

දැන් මෙහි මූලික කාර්ය ප්‍රවාහය:

1. localනාමාවලිය ඇතුළත් කරන්න , ලිපිගොනු කිහිපයක් සාදා ඒවා සිදු කරන්න. අවසාන වශයෙන් ඒවා සේවාදායකයට තල්ලු කරන්න:

   # create crazy stuff
   git commit -av
   git push origin master
   

2. දැන් contentනාමාවලිය ඇතුළත් කර සේවාදායකයේ අන්තර්ගතය යාවත්කාලීන කරන්න:

   git pull
   

3. 1-2 නැවත කරන්න. මෙන්න contentසේවාදායකයා වෙතට තල්ලු කළ හැකි තවත් සංවර්ධකයෙකු විය හැකි අතර, localඔබ ඔහුගෙන් ඉවත් විය හැකිය.

දුරස්ථ උඩු මහලේ ශාඛාව වෙත තල්ලු කිරීම සඳහා මෙය භාවිතා කිරීම මට මෙම ගැටළුව විසඳීය:

git push <remote> master:origin/master

දුරස්ථයට උඩුගං බලාගාරයට ප්‍රවේශයක් නොතිබූ බැවින් එම දුරස්ථයට නවතම වෙනස්කම් ලබා ගැනීමට මෙය හොඳ ක්‍රමයකි

git --initදැනට පවතින හිස් ගබඩාවක නැවත ධාවනය කිරීමට මට සිදු වූ අතර, මෙය හිස් ගබඩාව .gitතුළ නාමාවලියක් නිර්මාණය කර ඇත - git statusඑහි ටයිප් කිරීමෙන් පසුව මට වැටහුණි . මම එය මකා දැමූ අතර සියල්ල නැවත හොඳින් විය :)

(මේ සියලු පිළිතුරු විශිෂ්ටයි, නමුත් මගේ නඩුවේ එය සම්පූර්ණයෙන්ම වෙනස් දෙයක් (මට පෙනෙන පරිදි), විස්තර කර ඇති පරිදි.)

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

විස්තර කරන ලද දෝෂය හමු වූ විට මට සූර්යග්‍රහණ + ඊජිට් වෙබ් ව්‍යාපෘති සැකසුමක් තිබුණි. මට උදව් වූයේ හුදෙක් GitHub යෙදුම භාවිතා කිරීමයි, එය ගැටලුව ඉන්ද්‍රජාලිකව විසඳන බවක් පෙනෙන්නට තිබුණි. EGit සෑම විටම තල්ලුව ප්‍රතික්ෂේප කරන අතර, GitHub ඩෙස්ක්ටොප් යෙදුම එහි උරහිස් ඉරා දමා මගේ වෙනස්කම් තල්ලු කරයි. සමහර විට එය බහු පිවිසුම් තත්වය වඩාත් මනරම් ලෙස හසුරුවයි.

අනෙක් අයට ප්‍රයෝජනවත් විය හැකි ලිපියක් මිනිත්තු 5 කින් Git වේ .

මට ඩීසී එකක ඇති අථත්‍ය බෙදාහැරුණු ඊතර්නෙට් (වීඩීඊ) දක්වා තල්ලු කිරීමට අවශ්‍ය වූ Git අනුවාද පාලනය යටතේ මට Xcode ව්‍යාපෘතියක් තිබුණි . VDE සෙන්ටෝස් 5 ධාවනය කරයි.

Git ගැන මා කියවූ කිසිදු ලිපියක් හිස් ගබඩාවන් ගැන කතා කළේ නැත. SVN පසුබිමකින් පැමිණීම පහසු යැයි මා සිතූ දේ උත්සාහ කරන තෙක් ඒ සියල්ල ඉතා සරල ය .

දුරස්ථ ගබඩාව හිස් කිරීම සඳහා මෙහි යෝජනා ක්‍රියාත්මක විය. මගේ අවශ්‍යතාවයන් සඳහා ඊටත් වඩා හොඳ වූයේ Xcode ව්‍යාපෘතිය ක්ලෝන කිරීම projectname.git, එය දුරස්ථ සේවාදායකයට පිටපත් කිරීම ය; එවිට ඉන්ද්‍රජාලිකව වැඩ කරයි. මීලඟ පියවර වනුයේ කොමිස් පිළිබඳ දෝෂ නොමැතිව Xcode තල්ලු කිරීමයි, නමුත් දැනට මම එය ටර්මිනල් වෙතින් කිරීම හරි.

නිසා:

cd /tmp (or another other directory on your system)<br/>
git clone --bare /xcode-project-directory projectname.git<br/>
scp -r projectname.git sshusername@remotehost.com:repos/<br/>

ඔබ Xcode හි කැපවීමෙන් පසු ඔබගේ Xcode ව්‍යාපෘතියෙන් වෙනස්කම් තල්ලු කිරීමට:

cd /xcode-project-directory<br/>
git push sshusername@remotehost.com:repos/projectname.git<br/>

ඉහත සඳහන් කිරීමේ වඩාත් සුමට නවීන ක්‍රමයක් ඇති බව මට විශ්වාසයි, නමුත් අවම වශයෙන් මෙය ක්‍රියාත්මක වේ. සෑම දෙයක්ම පැහැදිලිය, මෙන්න පැහැදිලි කිරීම් කිහිපයක්: /xcode-project-directoryඔබේ xcode ව්‍යාපෘතිය ගබඩා කර ඇති නාමාවලියද? එය බොහෝ විට විය හැකිය/Users/Your_Name/Documents/Project_Name . projectname යනු වචනයේ පරිසමාප්ත අර්ථයෙන්ම ව්‍යාපෘතියේ නමයි, නමුත් එය ඔබ එය හැඳින්වීමට කැමති ඕනෑම දෙයක් විය හැකිය. Git ගණන් ගන්නේ නැහැ, ඔබ එසේ කරයි.

Scp භාවිතා කිරීමට ඔබට දුරස්ථ සේවාදායකයේ SSH ප්‍රවේශයට අවසර ඇති පරිශීලක ගිණුමක් තිබිය යුතුය . තමන්ගේම සේවාදායකයක් ධාවනය කරන ඕනෑම කෙනෙකුට මෙය ලැබේ. ඔබ හවුල් සත්කාරක හෝ වෙනත් දේ භාවිතා කරන්නේ නම්, ඔබ වාසනාවන්ත නොවනු ඇත.

remotehost.comයනු ඔබගේ දුරස්ථ ධාරකයේ නමයි. ඔබට පහසුවෙන් එහි IP ලිපිනය භාවිතා කළ හැකිය. වැඩිදුර පැහැදිලි කිරීම සඳහා මම දුරස්ථ ධාරකයේ SSH යතුරු සමඟ ගිටෝසිස් භාවිතා කරමි , එබැවින් මම තල්ලු කරන විට මුරපද ඉල්ලා නොසිටිමි. ලිපිය Git ආයතනමය, ඊසි (සහ ආරක්ෂා කර) මාර්ගය Hosting සියල්ල සකස් කරන්නේ කෙසේද යන්න ඔබට කියනවා.

මෙය කළ හැකි හොඳම ක්‍රමය නම්:

mkdir ..../remote
cd ..../remote
git clone --bare .../currentrepo/

මෙය නිධිය ක්ලෝන කරනු ඇත, නමුත් එය වැඩ කරන පිටපත් කිසිවක් නොකරයි .../remote. ඔබ දුරස්ථය දෙස බැලුවහොත්, ඔබ විසින් නිර්මාණය කරන ලද එක් නාමාවලියක් දකිනු ඇත currentrepo.git, එය ඔබට අවශ්‍ය දේ විය හැකිය.

ඉන්පසු ඔබේ දේශීය Git ගබඩාවෙන්:

git remote add remoterepo ..../remote/currentrepo.git

ඔබ වෙනස්කම් කළ පසු, ඔබට:

git push remoterepo master

මම මේ ගැටලුවට ගොදුරු වූයේ හෙරොකු හි යෙදවීමේ උපකරණ ගබඩාවක් සමඟ ය .

හෙරොකුගේ පැත්තෙන් හිස් නොවන ගබඩාවක් තිබෙන්නේ ඇයිදැයි මම නොදනිමි, නමුත් වැඩ කිරීමේ ප්‍රති as ලයක් ලෙස දුරස්ථ ගබඩාව නැවත සැකසීමට සහ නැවත පූරණය කිරීමට මට හැකි විය.

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

නැවත සැකසීමට:

0. ඔබ දැනටමත් නොමැති නම් හෙරොකු මෙවලම් පටි (විධාන රේඛා සේවාදායකයා අඩංගු) ස්ථාපනය කරන්න .

1. ඔබ දැනටමත් නොමැති නම් හෙරොකු-රෙපෝ ප්ලගිනය ස්ථාපනය කරන්න .

   heroku plugins:install https://github.com/heroku/heroku-repo.git
   

2. යළි පිහිටුවීම කරන්න, එය නිධිය මකා දමා නව හිස් එකක් නිර්මාණය කරයි

   heroku repo:reset
   

3. ඔබ සාමාන්‍යයෙන් මෙන් ඔබේ හෙරොකු දුරස්ථයට තල්ලු කරන්න; එය සියල්ල නැවත පූරණය කරනු ඇත.

ඔබ හිස් (හිස්) ගබඩාවක් නිර්මාණය කළ පසු දුරස්ථ සේවාදායකයේ වින්‍යාස ගොනුව වෙනස් කිරීමට ඔබට අවශ්‍ය වනු ඇත

root@development:/home/git/repository/my-project# cat config 

එහිදී ඔබට පෙනෙනු ඇත

[core]
repositoryformatversion = 0
filemode = true
bare = false
logallrefupdates = true

ඔබ මෙය සත්‍යය අසත්‍යයක් බවට පත් කර මම logallrefupdates = true (එහි භාවිතය ගැන විශ්වාස නැත!) ඉවත් කළෙමි.

වෙත

[core]
repositoryformatversion = 0
filemode = true
bare = true

ඔබට පහත දෑ පරීක්ෂා කළ හැකිය

$ git remote show origin
* remote origin
Fetch URL: my-portal@development:/home/XYZ/repository/XYZ
Push  URL: my-portal@development:/home/XYZ/repository/XYZ
HEAD branch: (unknown)

මෙම හෙඩ් ශාඛාව: ඔබට තල්ලු කිරීමට නොහැකි නම් (නොදන්නා) පෙන්වනු ඇත. එබැවින් හෙඩ් ශාඛාව නොදන්නේ නම්, ඔබ සත්‍ය ලෙස වෙනස් කළ යුතු අතර සාර්ථකව තල්ලු කිරීමෙන් පසු ඔබට නැවත භාවිතා කළ හැකිය

git remote show origin

එවිට ඔබට පෙනෙනු ඇත

 HEAD branch: master

මට වැඩ කිරීමේ විසඳුම නම්:

ඉවත් කරන්න:

git checkout -b some_tmp_name

දේශීය:

git push

ඉවත් කරන්න:

git checkout master
git branch -d some_tmp_name

නමුත් මෙය සැබෑ විසඳුම නොවේ.

යමෙකුට එය ප්‍රයෝජනවත් යැයි හැඟේ නම්. මට නම් එය git සේවාදායක අවසර නිකුතුවකි. මම හිඟමනේ සිට ව්‍යාපෘතිය පරීක්ෂා කර සරල ගොනුවක් තල්ලු කළ අතර පසුව "තල්ලු කිරීම ප්‍රතික්ෂේප කරන ලදි: ආරම්භයට තල්ලු කිරීම / ස්වාමියා ප්‍රතික්ෂේප කරන ලදි"

Git සමඟ, නිත්‍ය (හිස් නොවන) නිධි දෙකකට කෙලින්ම කෙලින්ම ඉදිරියට තල්ලු කළ නොහැක. අතරමැදි හිස් ගබඩාවක් තිබිය යුතුය. පෙනෙන විදිහට, එය විවාහක යුවළක් ළමයෙකු හා සමාන වන අතර යුවළ දික්කසාද වේ. දෙමව්පියන් එකිනෙකා සමඟ කතා නොකරනු ඇත, නමුත් ඔවුන් දරුවා හරහා සන්නිවේදනය කරනු ඇත.

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

ඉතින්, මෙන්න උදාහරණයක්:

පරිගණකයේ, ~ / වැඩපොළ තුළ

git init
echo "line 1" > afile.txt
git add .
git commit -m ‘initial import’
git clone --bare . ../remote-repository.git
git remote add origin ../remote-repository.git
git push --set-upstream origin master

ලැප්ටොප් පරිගණකයේ, work / වැඩපොළ තුළ (git init ආදිය නොකරන්න)

git clone //LJZ-DELLPC/remote-repository.git/ .

// ඉන්පසු විවිධ කැපවීම් කර ඒවා තල්ලු කරන්න:

echo "line 2" > afile.txt
git add afile.txt
git commit -m 'added line 2'
git push    

PC / වැඩපොළ තුළ PC වෙත ආපසු යන්න

git pull

// ඉන්පසු විවිධ කැපවීම් කර ඒවා තල්ලු කරන්න:

git push

ලැප්ටොප් ගිට් අදින්න

සහ ඉදිරියට ..

විධාන කවුළුවෙන් කෙළින්ම පිටපත් කරන ලද එක් යන්ත්‍රයක නිරපේක්ෂ සංයුක්ත උදාහරණයක් මෙන්න, එවිට කිසිදු පියවරක් ඉතිරි නොවූ බවත්, එය සැබවින්ම ක්‍රියාත්මක වූ බවත් අපි දැන ගනිමු:

lylez@LJZ-DELLPC ~
$ cd gitdir
/home/lylez/gitdir

lylez@LJZ-DELLPC ~/gitdir
$ ls

lylez@LJZ-DELLPC ~/gitdir
$ mkdir repo1

lylez@LJZ-DELLPC ~/gitdir
$ cd repo1
/home/lylez/gitdir/repo1

lylez@LJZ-DELLPC ~/gitdir/repo1
$ git init
Initialized empty Git repository in /home/lylez/gitdir/repo1/.git/

lylez@LJZ-DELLPC ~/gitdir/repo1
$ echo "line 1" > afile.txt

lylez@LJZ-DELLPC ~/gitdir/repo1
$ git add afile.txt

lylez@LJZ-DELLPC ~/gitdir/repo1
$ git commit -m 'initial import'
[master (root-commit) f407e12] initial import
 1 file changed, 1 insertion(+)
 create mode 100644 afile.txt

lylez@LJZ-DELLPC ~/gitdir/repo1
$ git clone --bar . ../repo1-bare-clone
Cloning into bare repository '../repo1-bare-clone'...
done.

lylez@LJZ-DELLPC ~/gitdir/repo1
$ git remote add origin ../repo1-bare-clone

lylez@LJZ-DELLPC ~/gitdir/repo1
$ git push --set-upstream origin master
Branch master set up to track remote branch master from origin.
Everything up-to-date

lylez@LJZ-DELLPC ~/gitdir/repo1
$ cd ..

lylez@LJZ-DELLPC ~/gitdir
$ ls
repo1  repo1-bare-clone

lylez@LJZ-DELLPC ~/gitdir
$ mkdir repo1-remote

lylez@LJZ-DELLPC ~/gitdir
$ cd repo1-remote
/home/lylez/gitdir/repo1-remote

lylez@LJZ-DELLPC ~/gitdir/repo1-remote
$ git clone ../repo1-bare-clone .
Cloning into '.'...
done.

lylez@LJZ-DELLPC ~/gitdir/repo1-remote
$ ls
afile.txt

lylez@LJZ-DELLPC ~/gitdir/repo1-remote
$ cat afile.txt
line 1

lylez@LJZ-DELLPC ~/gitdir/repo1-remote
$ echo "line 2" >> afile.txt

lylez@LJZ-DELLPC ~/gitdir/repo1-remote
$ git add afile.txt

lylez@LJZ-DELLPC ~/gitdir/repo1-remote
$ git commit -m 'added line 2'
[master 5ad31e0] added line 2
 1 file changed, 1 insertion(+)

lylez@LJZ-DELLPC ~/gitdir/repo1-remote
$ git push
Counting objects: 3, done.
Writing objects: 100% (3/3), 260 bytes | 0 bytes/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To /home/lylez/gitdir/repo1-remote/../repo1-bare-clone
   f407e12..5ad31e0  master -> master

lylez@LJZ-DELLPC ~/gitdir/repo1-remote
$ cd ../repo1

lylez@LJZ-DELLPC ~/gitdir/repo1
$ ls
afile.txt

lylez@LJZ-DELLPC ~/gitdir/repo1
$ cat afile.txt
line 1

lylez@LJZ-DELLPC ~/gitdir/repo1
$ git pull
remote: Counting objects: 3, done.
remote: Total 3 (delta 0), reused 0 (delta 0)
Unpacking objects: 100% (3/3), done.
From ../repo1-bare-clone
   f407e12..5ad31e0  master     -> origin/master
Updating f407e12..5ad31e0
Fast-forward
 afile.txt | 1 +
 1 file changed, 1 insertion(+)

lylez@LJZ-DELLPC ~/gitdir/repo1
$ cat afile.txt
line 1
line 2

lylez@LJZ-DELLPC ~/gitdir/repo1
$ echo "line 3" >> afile.txt

lylez@LJZ-DELLPC ~/gitdir/repo1
$ git add afile.txt

lylez@LJZ-DELLPC ~/gitdir/repo1
$ git commit -m 'added line 3'
[master 3fa569e] added line 3
 1 file changed, 1 insertion(+)

lylez@LJZ-DELLPC ~/gitdir/repo1
$ git push
Counting objects: 3, done.
Writing objects: 100% (3/3), 265 bytes | 0 bytes/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To ../repo1-bare-clone
   5ad31e0..3fa569e  master -> master

lylez@LJZ-DELLPC ~/gitdir/repo1
$ cd ../repo1-remote/

lylez@LJZ-DELLPC ~/gitdir/repo1-remote
$ ls
afile.txt

lylez@LJZ-DELLPC ~/gitdir/repo1-remote
$ cat afile.txt
line 1
line 2

lylez@LJZ-DELLPC ~/gitdir/repo1-remote
$ git pull
remote: Counting objects: 3, done.
remote: Total 3 (delta 0), reused 0 (delta 0)
Unpacking objects: 100% (3/3), done.
From /home/lylez/gitdir/repo1-remote/../repo1-bare-clone
   5ad31e0..3fa569e  master     -> origin/master
Updating 5ad31e0..3fa569e
Fast-forward
 afile.txt | 1 +
 1 file changed, 1 insertion(+)

lylez@LJZ-DELLPC ~/gitdir/repo1-remote
$ cat afile.txt
line 1
line 2
line 3

lylez@LJZ-DELLPC ~/gitdir/repo1-remote
$ git --version
git version 2.1.1

lylez@LJZ-DELLPC ~/gitdir/repo1-remote

මගේ විසඳුම (භාවිතයේ ඇත)

1. දුරස්ථ සේවාදායකයේ "මාස්ටර්" පරීක්ෂා කරන්න
2. "Dev" ශාඛාවේ දේශීයව වැඩ කරන්න
3. දුරස්ථ dev වෙත වෙනස්කම් තල්ලු කරන්න
4. දුරස්ථව dev මාස්ටර් සමඟ ඒකාබද්ධ කරන්න

බිංගෝ