git - गिट पुश त्रुटि '[रिमोट अस्वीकार] मास्टर-> मास्टर(शाखा वर्तमान में चेक आउट है)'




git-push (19)

कल, मैंने अपनी मशीनों में से किसी एक से Git भंडार को क्लोन करने के तरीके पर एक प्रश्न पोस्ट किया, मैं किसी अन्य मशीन से 'क्लोन क्लोन' कैसे कर सकता हूं?

अब मैं अपने स्रोत (1 9 2.168.1.1) से अपने गंतव्य (1 9 2.168.1.1) से गिट भंडार सफलतापूर्वक क्लोन करने में सक्षम हूं।

लेकिन जब मैंने एक फ़ाइल में एक संपादन किया, एक git commit -a -m "test" और एक git push , मुझे यह त्रुटि मेरे गंतव्य पर मिलती है (1 9 2.168.1.1):

git push                                                
[email protected]'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://[email protected]/media/LINUXDATA/working
! [remote rejected] master -> master (branch is currently checked out)
error: failed to push some refs to 'git+ssh://[email protected]/media/LINUXDATA/working'

मैं गिट के दो अलग-अलग संस्करणों का उपयोग कर रहा हूं (रिमोट पर 1.7 और स्थानीय मशीन पर 1.5)। क्या यह एक संभावित कारण है?


सारांश

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

चूंकि नंगे भंडारों में कभी भी कोई शाखा चेक नहीं होती है, तो आप हमेशा एक नंगे भंडार की किसी भी शाखा को दबा सकते हैं।

आपकी जरूरतों के आधार पर कई समाधान हैं।

समाधान 1: एक दुर्लभ repostiory का उपयोग करें

जैसा कि सुझाव दिया गया है, अगर एक मशीन पर, आपको कार्यशील निर्देशिका की आवश्यकता नहीं है, तो आप एक नंगे भंडार में जा सकते हैं। भंडार के साथ गड़बड़ से बचने के लिए, आप इसे क्लोन कर सकते हैं:

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 रिमोट रेपो में हों तो आपको इसे मर्ज करने की आवश्यकता होगी:

machine1$ git merge master+machine2

समस्या की शव

जब एक शाखा की जांच की जाती है, तो मौजूदा शाखा के सिर के साथ एक नई प्रतिबद्धता उसके माता-पिता के रूप में जोड़ती है और शाखा के सिर को उस नई प्रतिबद्धता के रूप में ले जाती है।

इसलिए

A ← B
    ↑
[HEAD,branch1]

हो जाता है

A ← B ← C
        ↑
    [HEAD,branch1]

लेकिन अगर कोई उस शाखा में धक्का दे सकता है, तो उपयोगकर्ता खुद को उस गेट में ले जाएगा जो अलग-अलग सिर मोड को कॉल करता है:

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

अब उपयोगकर्ता शाखा 1 में नहीं है, बिना किसी अन्य शाखा की जांच करने के लिए स्पष्ट रूप से पूछा गया है। इससे भी बदतर, उपयोगकर्ता अब किसी भी शाखा के बाहर है , और कोई भी नई प्रतिबद्धता केवल लटक जाएगी :

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

Hypothetically, अगर इस बिंदु पर, उपयोगकर्ता एक और शाखा की जांच करता है, तो यह लटकती प्रतिबद्ध गिट के कचरा कलेक्टर के लिए उचित खेल बन जाता है।


आपके पास 3 विकल्प हैं

  1. खींचो और फिर धक्का:

    git pull; git push
    
  2. विभिन्न शाखाओं में पुश करें:

    git push origin master:foo
    

    और इसे दूरस्थ पर विलय करें (या तो git या pull-request )

    git merge foo
    
  3. इसे मजबूर करें (जब तक आप जानबूझकर रीबेज के माध्यम से काम नहीं करते हैं तब तक अनुशंसित नहीं किया जाता है):

    git push origin master -f
    

    अगर अभी भी इनकार कर दिया गया है, तो रिमोट रिपोजिटरी पर denyCurrentBranch अक्षम करें:

    git config receive.denyCurrentBranch ignore
    

आप गंतव्य सर्वर पर .git/config संपादित करके इस "सीमा" के आसपास हो सकते हैं। गिट रिपॉजिटरी को "चेक आउट" होने पर भी धक्का देने के लिए निम्नलिखित जोड़ें:

[receive]
denyCurrentBranch = warn

या

[receive]
denyCurrentBranch = false

पहली बार पुश को गड़बड़ाने की संभावना की चेतावनी के दौरान पुश की अनुमति देगा, जबकि दूसरा चुपचाप इसे अनुमति देगा।

इसका उपयोग किसी सर्वर पर "तैनाती" कोड के लिए किया जा सकता है जो संपादन के लिए नहीं है। यह सबसे अच्छा तरीका नहीं है, लेकिन कोड को तैनात करने के लिए एक त्वरित है।


आप बस अपने रिमोट रिपॉजिटरी को नंगे भंडार में परिवर्तित कर सकते हैं (नंगे भंडार में कोई कार्यशील प्रति नहीं है - फ़ोल्डर में केवल वास्तविक भंडार डेटा है)।

अपने रिमोट रिपोजिटरी फ़ोल्डर में निम्न आदेश निष्पादित करें:

git config --bool core.bare true

फिर उस फ़ोल्डर में .git को छोड़कर सभी फाइलों को हटा दें। और फिर आप बिना किसी त्रुटि के रिमोट रिपोजिटरी में git push करने में सक्षम होंगे।


एक लेख जो मैंने पाया है कि दूसरों के लिए उपयोगी हो सकता है वह गिट 5 मिनट में है

मेरे पास गिट संस्करण नियंत्रण के तहत एक Xcode प्रोजेक्ट था जिसे मैं एक डीसी में एक वर्चुअल डिस्ट्रिब्यूटेड ईथरनेट (वीडीई) तक धक्का देना चाहता था। Centos 5 चलाता है।

गिट के बारे में मैंने जो भी लेख पढ़ा है, उनमें से कोई भी नंगे भंडारों के बारे में बात करता है। यह सब तब तक आसान लग रहा था जब तक मैंने कोशिश नहीं की कि मैंने सोचा कि SVN पृष्ठभूमि से क्या आसान होना चाहिए।

दूरस्थ भंडार बनाने के लिए यहां दिए गए सुझावों ने नंगे काम किया। मेरी आवश्यकताओं के लिए भी बेहतर था Xcode प्रोजेक्ट को projectname.git पर क्लोन करना, दूरस्थ सर्वर पर कॉपी करना; फिर जादुई काम करता है। अगला कदम एक्सकोड के बारे में त्रुटियों के बिना धक्का देने के लिए मिल जाएगा, लेकिन अभी के लिए मैं टर्मिनल से यह ठीक कर रहा हूँ।

इसलिए:

cd /tmp (or another other directory on your system)<br/>
git clone --bare /xcode-project-directory projectname.git<br/>
scp -r projectname.git [email protected]:repos/<br/>

Xcode में किए जाने के बाद अपने एक्सकोड प्रोजेक्ट से परिवर्तनों को पुश करने के लिए:

cd /xcode-project-directory<br/>
git push [email protected]:repos/projectname.git<br/>

मुझे यकीन है कि ऊपर करने का एक आसान और अधिक परिष्कृत तरीका है, लेकिन कम से कम यह काम करता है। बस इतना सब कुछ स्पष्ट है, यहां कुछ स्पष्टीकरण दिए गए हैं: /xcode-project-directory है जो आपकी एक्सकोड प्रोजेक्ट में संग्रहीत है। यह शायद /Users/Your_Name/Documents/Project_Name । प्रोजेक्टनाम सचमुच प्रोजेक्ट का नाम है, लेकिन यह कुछ भी हो सकता है जिसे आप कॉल करना चाहते हैं। गिट परवाह नहीं है, आप करेंगे।

एसपीपी का उपयोग करने के लिए आपको दूरस्थ सर्वर पर उपयोगकर्ता खाता होना चाहिए जिसकी SSH पहुंच की अनुमति है। कोई भी अपना स्वयं का सर्वर चलाने वाला यह होगा। यदि आप साझा होस्टिंग या पसंद का उपयोग कर रहे हैं, तो आप भाग्य से बाहर हो सकते हैं।

remotehost.com आपके रिमोट होस्ट का नाम है। आप आसानी से अपने आईपी पते का उपयोग कर सकते हैं। बस स्पष्टता के लिए मैं एसएसएच कुंजी के साथ रिमोट होस्ट पर Gitosis का उपयोग कर रहा हूं, इसलिए जब मैं धक्का देता हूं तो मुझे पासवर्ड के लिए संकेत नहीं दिया जाता है। आलेख होस्टिंग गिट रेपॉजिटरीज़, आसान (और सुरक्षित) तरीका आपको बताता है कि यह सब कैसे सेट करें।


ऐसा करने का सबसे अच्छा तरीका है:

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

यह भंडार क्लोन करेगा, लेकिन यह किसी भी कामकाजी प्रतिलिपि नहीं बनायेगा .../remote । यदि आप रिमोट को देखते हैं, तो आपको currentrepo.git नामक एक निर्देशिका दिखाई देगी, जो शायद आप चाहते हैं।

फिर अपने स्थानीय गिट भंडार से:

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

परिवर्तन करने के बाद, आप यह कर सकते हैं:

git push remoterepo master

गिट के पुराने संस्करण गैर-नंगे भंडार की वर्तमान में चेक की गई शाखा को धक्का देते हैं।

यह पता चला कि यह अनुमति देने के लिए एक बहुत ही भ्रमित चीज थी। इसलिए उन्होंने आपके द्वारा देखे गए चेतावनी संदेश को जोड़ा, जो भी बहुत भ्रमित है।

यदि पहला भंडार सिर्फ सर्वर के रूप में कार्य कर रहा है तो इसे एक नंगे भंडार में परिवर्तित करें क्योंकि अन्य उत्तरों की सिफारिश है और इसके साथ किया जाना चाहिए।

यदि आपको दो रिपो के बीच एक साझा शाखा की आवश्यकता है जो दोनों उपयोग में हैं तो आप इसे निम्न सेटअप के साथ प्राप्त कर सकते हैं

Repo1 - सर्वर के रूप में कार्य करेगा और विकास के लिए भी इस्तेमाल किया जाएगा

Repo2 - केवल विकास के लिए होगा

निम्नानुसार सेटअप Repo1

काम साझा करने के लिए एक शाखा बनाएँ।

git branch shared_branch

सुरक्षित होने के लिए, आपको $ (REPO) .git / hooks / update भी बनाना चाहिए जो साझा_ब्रैंच के अलावा किसी अन्य चीज़ में किसी भी बदलाव को अस्वीकार करता है, क्योंकि आप नहीं चाहते हैं कि लोग आपकी निजी शाखाओं के साथ मिल जाए।

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 push लिए git config --global push.default upstream को git config --global push.default upstream करने की आवश्यकता हो सकती है)

अब आप के साथ repo2 बना सकते हैं

git clone path/to/repo1 repo2 
git checkout shared_branch 

इस बिंदु पर आपके पास स्थानीय शाखाओं पर काम करने के लिए repo1 और repo2 सेटअप दोनों हैं जो shared_branch में shared_branch से धक्का और खींचते हैं, उस त्रुटि संदेश के बारे में चिंता करने की आवश्यकता के बिना या कार्य निर्देशिका को repo1 में सिंक से बाहर करने की आवश्यकता के बिना। जो भी सामान्य वर्कफ़्लो आप उपयोग करते हैं, उसे काम करना चाहिए।


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

उदाहरण के लिए, रिमोट सर्वर पर:

git branch dev
git checkout dev

स्थानीय सेटअप पर:

git push 

रिमोट सर्वर पर:

git merge dev

मुझे अपने एंड्रॉइड फोन और लैपटॉप पर रिपॉजिटरीज सिंक्रनाइज़ करने के लिए गिट का उपयोग करने में भी यही समस्या थी। मेरे लिए समाधान पुश की बजाय पुल करना था, क्योंकि @ चार्ल्सबैली ने सुझाव दिया था।

एंड्रॉइड रिपोजिटरी पर git push origin master मेरे लिए एक ही त्रुटि संदेशों के साथ विफल रहता है कि @ hap497 को एक रिपॉजिटरी + वर्किंग-कॉपी के एक गैर-चेकआउट चेकआउट के लिए धक्का दिया गया है।

लैपटॉप भंडार और कामकाजी प्रतिलिपि पर git pull droid master मेरे लिए काम करता है। बेशक, आपको पहले कुछ git remote add droid /media/KINGSTON4GB/notes_repo/ जैसे कुछ चलाने की ज़रूरत है।


मुझे अभी भी रिमोट बॉक्स पर उपयोग करने योग्य भंडार रखने का विचार पसंद है, लेकिन एक डमी शाखा के बजाय, मुझे इसका उपयोग करना पसंद है:

git checkout --detach

यह Git की एक बहुत ही नई विशेषता प्रतीत होता है - मैं गिट संस्करण 1.7.7.4 का उपयोग कर रहा हूं।


मुझे यकीन है कि इस सवाल को देखने वाले ज्यादातर लोग पहले दो बड़े उत्तरों पर रुकेंगे, लेकिन मैं अभी भी अपना समाधान देना चाहता हूं।

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


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

भंडार में, आप टाइप करने के लिए दबाव डाल रहे हैं:

git config receive.denyCurrentBranch ignore

यह आपको एक कार्यशील प्रतिलिपि के दौरान भंडार बदलने की अनुमति देगा।

गिट पुश चलाने के बाद, रिमोट मशीन पर जाएं और इसे टाइप करें:

git checkout -f

यह आपके द्वारा किए गए परिवर्तनों को दूरस्थ मशीन की कार्यशील प्रति में प्रतिबिंबित करेगा।

कृपया ध्यान दें, अगर आप उस कार्यशील प्रतिलिपि में बदलाव करते हैं जो आप दबा रहे हैं तो यह हमेशा सुरक्षित नहीं होता है।


वास्तव में, रिमोट को गैर-चेक आउट शाखा में सेट करना पर्याप्त है। एक अलग शाखा में अपने रिमोट की जांच करने के बाद, आप धक्का दे सकते हैं।


Git सीखना शुरू करने के दौरान मुझे वही त्रुटि मिली। कुछ अन्य उत्तरों स्पष्ट रूप से गिट के लिए नए व्यक्ति के लिए नहीं हैं!

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

अभी आप अपने काम भंडार में हैं और "मास्टर" शाखा का उपयोग कर रहे हैं। लेकिन आप "मूल" शाखा में अपने मूल भंडार में "लॉग इन" भी होते हैं। अब जब आप मूल में "लॉग इन" हैं, तो गिट डरता है कि आप गड़बड़ कर सकते हैं क्योंकि आप मूल पर काम कर रहे हैं और चीजों को खराब कर सकते हैं। तो आपको मूल भंडार में वापस लौटना होगा और "गिट चेकआउट कुछथ्रैब्रंच" करना होगा, और अब आप कोई समस्या नहीं उठा सकते हैं।

आशा है कि ये आपकी मदद करेगा।


आपने शायद इसका कारण क्या किया:

इस तरह की चीज होती है जब आप एक छोटे से कार्यक्रम को बाहर करने के लिए जाते हैं। आप कुछ ऐसा बदल रहे हैं जो पहले से ही काम कर रहा था, इसलिए आपने निरंतर अस्थिरता के अपने स्तर -3 वर्तनी डाली:

machine1:~/proj1> git init

और आप जोड़ना / शुरू करना शुरू करते हैं। लेकिन फिर , परियोजना अधिक शामिल हो रही है और आप इसे किसी अन्य कंप्यूटर (जैसे आपके होम पीसी या लैपटॉप) से काम करना चाहते हैं, तो आप कुछ ऐसा करते हैं

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

और यह क्लोन और सबकुछ अच्छा दिखता है, और इसलिए आप मशीन 2 से अपने कोड पर काम करते हैं।

फिर ... आप मशीन 2 से अपने काम को धक्का देने की कोशिश करते हैं, और आपको शीर्षक में चेतावनी संदेश मिलता है।

इस संदेश का कारण यह है कि जिस गिट रेपो को आपने खींचा था, वह सिर्फ मशीन 1 पर उस फ़ोल्डर के लिए इस्तेमाल किया जाना था। आप इसे ठीक से क्लोन कर सकते हैं, लेकिन धक्का देने से समस्याएं पैदा हो सकती हैं। दो अलग-अलग स्थानों में कोड का प्रबंधन करने का "उचित" तरीका एक "बेयर" रेपो के साथ है, जैसा सुझाव दिया गया है। एक नंगे रेपो को इसमें कोई काम करने के लिए डिज़ाइन नहीं किया गया है, यह कई स्रोतों से काम करने के लिए है। यही कारण है कि शीर्ष रेटेड उत्तर आपको git config --bool core.bare true बाद git config --bool core.bare true फ़ोल्डर के अलावा सभी फ़ाइलों / फ़ोल्डर्स को हटाने का सुझाव देता git config --bool core.bare true

शीर्ष रेटेड उत्तर को स्पष्ट करना: उस उत्तर में कई टिप्पणियां कुछ कहती हैं जैसे "मैंने मशीन 1 से गैर-.git फ़ाइलों को नहीं हटाया और मैं अभी भी मशीन 2 से प्रतिबद्ध था"। ये सही है। हालांकि, उन अन्य फाइलें अब गिट रेपो से "तलाकशुदा" हैं। वहां git status आज़माएं और आपको कुछ "घातक" देखना चाहिए: यह ऑपरेशन एक कार्य पेड़ में चलाना चाहिए "। इसलिए, फ़ाइलों को हटाने का सुझाव ऐसा नहीं है कि मशीन 2 से प्रतिबद्धता काम करेगी; ऐसा इसलिए है कि आप उलझन में नहीं आते हैं और सोचते हैं कि गिट अभी भी उन फ़ाइलों को ट्रैक कर रहा है। लेकिन, फ़ाइलों को हटाने में समस्या है यदि आप अभी भी मशीन 1 पर फ़ाइलों पर काम करना चाहते हैं, है ना?

तो, आपको वास्तव में क्या करना चाहिए?

इस पर निर्भर करता है कि आप अभी भी मशीन 1 और मशीन 2 पर काम करने की योजना बना रहे हैं ...

यदि आप मशीन 1 से विकसित कर रहे हैं और अपने सभी विकास को मशीन 2 पर ले जा चुके हैं ... बस शीर्ष-रेटेड उत्तर से पता चलता है: git config --bool core.bare true और फिर, वैकल्पिक रूप से, सभी फ़ाइलों / फ़ोल्डरों को हटाएं उस फ़ोल्डर से .git से, क्योंकि वे अनचाहे हैं और भ्रम पैदा करने की संभावना है।

यदि मशीन 2 पर आपका काम सिर्फ एक बार की बात थी, और आपको वहां विकास जारी रखने की आवश्यकता नहीं है ... तो नंगे रेपो बनाने से परेशान न हों; बस ftp / rsync / scp / आदि। मशीन * 2 * पर फ़ाइलों के शीर्ष पर मशीन * 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

बहुत महत्वपूर्ण: क्योंकि आपने प्रोजे 1 से proj1.git में रेपो का स्थान स्थानांतरित कर दिया है, आपको इसे मशीन 2 पर .git / config फ़ाइल में अपडेट करने की आवश्यकता है । उसके बाद, आप मशीन 2 से अपने बदलाव कर सकते हैं। आखिरकार, मैं अपने काम के पेड़ों से दूर अपने नंगे रेपो को केंद्रीय स्थान पर रखने की कोशिश करता हूं (यानी 'proj1.git' को उसी मूल फ़ोल्डर में 'proj1' के रूप में न रखें)। मैं आपको वही करने की सलाह देता हूं, लेकिन मैं जितना संभव हो उतना सरल कदम रखना चाहता था।


For me working solution is:

ON REMOTE:

git checkout -b some_tmp_name

ON LOCAL:

git push

ON REMOTE:

git checkout master
git branch -d some_tmp_name

But this is not the real solution it's just workaround.


With Git, two regular (non-bare) repositories can't push/pull files back and forth directly. There must be an intermediary bare repository. Apparently, it's sort of like a married couple who have a kid, and the couple is getting divorced. The parents won't talk to each other, but they will communicate through the kid.

So, you have one repository, you clone this repository to a bare repository, and then you clone that to a third. The first and the third can exchange information via the second repository, the bare one. I guess this makes sense, as you wouldn't want someone able to check stuff into your repository without your consent, as that could cause merge conflicts & the like.

So, here's an example:

On PC, in ~/workspace

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

On laptop, in ~/workspace (do not do git init, etc.)

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

// Then make various commits, and push them:

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

Then back on PC, in ~/workspace

git pull

// Then make various commits, and push them:

git push

On laptop git pull

and so forth..

Here's an absolute concrete example all on one machine, copied straight from the command window, so that we'll know that no steps were left out, that it really did work, etc:

[email protected] ~
$ cd gitdir
/home/lylez/gitdir

[email protected] ~/gitdir
$ ls

[email protected] ~/gitdir
$ mkdir repo1

[email protected] ~/gitdir
$ cd repo1
/home/lylez/gitdir/repo1

[email protected] ~/gitdir/repo1
$ git init
Initialized empty Git repository in /home/lylez/gitdir/repo1/.git/

[email protected] ~/gitdir/repo1
$ echo "line 1" > afile.txt

[email protected] ~/gitdir/repo1
$ git add afile.txt

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

[email protected] ~/gitdir/repo1
$ git clone --bar . ../repo1-bare-clone
Cloning into bare repository '../repo1-bare-clone'...
done.

[email protected] ~/gitdir/repo1
$ git remote add origin ../repo1-bare-clone

[email protected] ~/gitdir/repo1
$ git push --set-upstream origin master
Branch master set up to track remote branch master from origin.
Everything up-to-date

[email protected] ~/gitdir/repo1
$ cd ..

[email protected] ~/gitdir
$ ls
repo1  repo1-bare-clone

[email protected] ~/gitdir
$ mkdir repo1-remote

[email protected] ~/gitdir
$ cd repo1-remote
/home/lylez/gitdir/repo1-remote

[email protected] ~/gitdir/repo1-remote
$ git clone ../repo1-bare-clone .
Cloning into '.'...
done.

[email protected] ~/gitdir/repo1-remote
$ ls
afile.txt

[email protected] ~/gitdir/repo1-remote
$ cat afile.txt
line 1

[email protected] ~/gitdir/repo1-remote
$ echo "line 2" >> afile.txt

[email protected] ~/gitdir/repo1-remote
$ git add afile.txt

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

[email protected] ~/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

[email protected] ~/gitdir/repo1-remote
$ cd ../repo1

[email protected] ~/gitdir/repo1
$ ls
afile.txt

[email protected] ~/gitdir/repo1
$ cat afile.txt
line 1

[email protected] ~/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(+)

[email protected] ~/gitdir/repo1
$ cat afile.txt
line 1
line 2

[email protected] ~/gitdir/repo1
$ echo "line 3" >> afile.txt

[email protected] ~/gitdir/repo1
$ git add afile.txt

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

[email protected] ~/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

[email protected] ~/gitdir/repo1
$ cd ../repo1-remote/

[email protected] ~/gitdir/repo1-remote
$ ls
afile.txt

[email protected] ~/gitdir/repo1-remote
$ cat afile.txt
line 1
line 2

[email protected] ~/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(+)

[email protected] ~/gitdir/repo1-remote
$ cat afile.txt
line 1
line 2
line 3

[email protected] ~/gitdir/repo1-remote
$ git --version
git version 2.1.1

[email protected] ~/gitdir/repo1-remote

You will need to change the config file on the remote server once you have created empty(bare) repository, say

[email protected]:/home/git/repository/my-project# cat config 

there you will see

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

You will make this bare to false to true and I removed logallrefupdates = true (not sure of its use!)

सेवा मेरे

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

You may test following

$ git remote show origin
* remote origin
Fetch URL: [email protected]:/home/XYZ/repository/XYZ
Push  URL: [email protected]:/home/XYZ/repository/XYZ
HEAD branch: (unknown)

This HEAD branch: (unknown) will be shown if you are unable to PUSH. So if the HEAD branch is unknow, you should change bare to true and after push successful you can reuse the

git remote show origin

and you will see

 HEAD branch: master

बस अगर किसी को यह उपयोगी लगता है। मेरे लिए यह एक गिट सर्वर अनुमतियाँ मुद्दा था। मैंने भिखारी से परियोजना की जांच की और एक साधारण फाइल दबा दी और फिर मुझे "पुश खारिज कर दिया गया: मूल / मास्टर को पुश अस्वीकार कर दिया गया"





git-push