Git weigert om niet-gerelateerde geschiedenissen samen te voegen bij rebase

Tijdens git rebase origin/development wordt de volgende foutmelding getoond van Git:

fatal: refusing to merge unrelated histories
Error redoing merge 1234deadbeef1234deadbeef

Mijn Git-versie is 2.9.0. In de vorige versie werkte het prima.

Hoe kan ik doorgaan met deze rebase en niet-gerelateerde geschiedenissen toestaan ​​met de geforceerde vlag die in de nieuwe release is geïntroduceerd?


Antwoord 1, autoriteit 100%

Het standaardgedrag is veranderd sinds Git 2.9:

“git merge” gebruikt om het samenvoegen van twee branches die geen gemeenschappelijk hebben toe te staan
base standaard, wat leidde tot een geheel nieuwe geschiedenis van een bestaande
project gemaakt en vervolgens getrokken door een nietsvermoedende onderhouder,
waardoor een onnodige parallelle geschiedenis werd samengevoegd tot de
bestaand project. Het commando is geleerd dit niet toe te staan ​​door
standaard
, met een ontsnappingsluik --allow-unrelated-histories optie
te gebruiken in een zeldzame gebeurtenis die de geschiedenis van twee projecten samenvoegt
die hun leven zelfstandig begonnen.

Bekijk de Git-release changelog voor meer informatie.

Je kunt --allow-unrelated-histories gebruiken om de samenvoeging te forceren.


Antwoord 2, autoriteit 48%

In mijn geval was de fout gewoon fatal: refusing to merge unrelated histories bij elke poging, vooral het eerste pull-verzoek na het op afstand toevoegen van een Git-repository.

Het gebruik van de vlag --allow-unrelated-histories werkte op deze manier met een pull-verzoek:

git pull origin branchname --allow-unrelated-histories

Antwoord 3, autoriteit 21%

Probeer het volgende commando:

git pull origin master  --allow-unrelated-histories

Dit zou je probleem moeten oplossen.


Antwoord 4, autoriteit 10%

Ik kreeg deze foutmelding toen ik eerst een lokale repository instelde. Toen ging ik naar GitHub en maakte een nieuwe repository. Toen rende ik

git remote add origin <repository url>

Toen ik probeerde te duwen of te trekken, kreeg ik elke keer dezelfde fatal: unrelated_histories-fout.

Dit is hoe ik het heb opgelost:

git pull origin master --allow-unrelated-histories
git merge origin origin/master
... add and commit here...
git push origin master

Antwoord 5, autoriteit 5%

Voer hiervoor het commando in:

git pull origin branchname --allow-unrelated-histories

Bijvoorbeeld

git pull origin master  --allow-unrelated-histories

Referentie:

GitHub niet-gerelateerd geschiedenisprobleem


Antwoord 6, autoriteit 5%

git pull origin <branch> --allow-unrelated-histories

Je wordt doorgestuurd naar een Vim-bewerkingsvenster:

  • Voeg commit-bericht in
  • Druk vervolgens op Esc (om de modus “Invoegen” te verlaten),
    dan : (dubbele punt), dan x (kleine “x”)
    en druk tenslotte op Enter om Vim te verlaten
  • git push --set-upstream origin <branch>

Antwoord 7, autoriteit 4%

Ik heb deze opdracht uitgevoerd en het probleem is opgelost.

git pull origin branchname --allow-unrelated-histories

Bekijk deze pagina voor meer informatie.


Antwoord 8, autoriteit 3%

Ik had hetzelfde probleem. Probeer dit:

git pull origin master --allow-unrelated-histories 
git push origin master

Antwoord 9, autoriteit 2%

1. Los het probleem op

Krijg deze Fout wanneer een git pull origin master wordt uitgevoerd?:

fatal: refusing to merge unrelated histories

Voer een van de onderstaande commando’s uit (vroeger was het master, nu de belangrijkste) volgens het scenario

 git pull origin master --allow-unrelated-histories
 git pull origin main --allow-unrelated-histories

2. Betekenis

  • De fout:

De fatale: weigeren om niet-gerelateerde geschiedenissen samen te voegen Git-fout treedt op wanneer twee niet-gerelateerde projecten worden samengevoegd (d.w.z. projecten die niet op de hoogte zijn van elkaars bestaan ​​en niet-overeenkomende commit-geschiedenissen hebben).

Standaard weigert het git merge commando om geschiedenissen samen te voegen die geen gemeenschappelijke voorouder delen. Deze optie kan worden gebruikt om deze veiligheid op te heffen bij het samenvoegen van de geschiedenis van twee projecten die onafhankelijk van elkaar zijn begonnen. Omdat dat een zeer zeldzame gelegenheid is, bestaat er geen configuratievariabele om dit standaard in te schakelen en zal deze niet worden toegevoegd.

voer hier de afbeeldingsbeschrijving in


Referenties


Meer over StackOverflow


Antwoord 10, autoriteit 2%

Voor Android Studio en IntelliJ:

Eerst bega alles en los eventuele conflicten op.

Open vervolgens de terminal van onderen van IDE en voer in:

git pull origin master  --allow-unrelated-histories

Je kunt nu pushen.


Antwoord 11, autoriteit 2%

Probeer git pull --rebase development


Antwoord 12

WAARSCHUWING DIT ZAL POTENTIEEL DE REMOTE REPOSITORY OVERSCHRIJVEN

Dit werkte voor mij:

git push origin master --force

Antwoord 13

Aangezien alle andere antwoorden de vraag niet echt beantwoorden, is hier een oplossing die is geïnspireerd op dit antwoord op een verwante vraag.

Dus je krijgt je foutmelding bij het doen van git rebase:

$ git rebase origin/development
fatal: refusing to merge unrelated histories
Error redoing merge 1234deadbeef1234deadbeef

Deze fout annuleert de rebase niet echt, maar je zit er nu middenin:

$ git status
interactive rebase in progress; onto 4321beefdead
Last command done (1 command done):
   pick 1234deadbeef1234deadbeef test merge commit

Dus je kunt het samenvoegen nu met de hand doen. Ontdek de parent commits van de originele merge commit:

$ git log -1 1234deadbeef1234deadbeef
commit 1234deadbeef1234deadbeef
Merge: 111111111 222222222
Author: Hans Dampf
Date:   Wed Jun 6 18:04:35 2018 +0200
    test merge commit

Ontdek welke van de twee samenvoeg-ouders degene is die is samengevoegd met de huidige (waarschijnlijk de tweede, verifieer met git log 222222222), en voer de samenvoeging met de hand uit, kopieer het commit bericht van de originele merge commit:

$ git merge --allow-unrelated 222222222 --no-commit
Automatic merge went well; stopped before committing as requested
$ git commit -C 1234deadbeef1234deadbeef
[detached HEAD 909af09ec] test merge commit
 Date: Wed Jun 6 18:04:35 2018 +0200
$ git rebase --continue
Successfully rebased and updated refs/heads/test-branch.

Antwoord 14

Ik had hetzelfde probleem. Het probleem is dat er iets op afstand was dat dit verhinderde.

Ik heb eerst een lokale repository gemaakt. Ik heb een LICENSE en README.md-bestand toegevoegd aan mijn lokale en vastgelegde.

Toen wilde ik een externe repository, dus maakte ik er een op GitHub. Hier heb ik een fout gemaakt door “Initialiseer deze repository met een README” aan te vinken, waardoor ook een README.md in remote werd aangemaakt.

Dus toen ik rende

git push --set-upstream origin master

Ik heb:

error: failed to push some refs to 'https://github.com/lokeshub/myTODs.git'
hint: Updates were rejected because the tip of your current branch is behind
hint: its remote counterpart. Integrate the remote changes
(e.g. hint: 'git pull ...') before pushing again.
hint: See the 'Note about fast-forwards' in 'git push --help' for details.

Om dit te overwinnen heb ik het gedaan

git pull origin master

Wat resulteerde in de onderstaande fout:

From https://github.com/lokeshub/myTODs
branch            master     -> FETCH_HEAD
fatal: refusing to merge unrelated histories**

Ik heb het geprobeerd:

git pull origin master  --allow-unrelated-histories

Resultaat:

From https://github.com/lokeshub/myTODs
 * branch            master     -> FETCH_HEAD
Auto-merging README.md
CONFLICT (add/add): Merge conflict in README.md
Automatic merge failed;
fix conflicts and then commit the result.

Oplossing:

Ik heb de externe repository verwijderd en een nieuwe gemaakt (ik denk dat alleen het verwijderen van het bestand README had kunnen werken) en daarna werkte het onderstaande:

git remote rm origin
git remote add origin https://github.com/lokeshub/myTODOs.git
git push --set-upstream origin master

Antwoord 15

Trek eerst de externe wijzigingen naar uw lokaal met behulp van de volgende opdracht:

git pull origin branchname --allow-unrelated-histories

** branchnaam is master in mijn geval.

Als het pull-commando is voltooid, treedt er een conflict op. Je moet de conflicten oplossen. Ik gebruik Android Studio om conflicten op te lossen.
voer hier de afbeeldingsbeschrijving in

Als de conflicten zijn opgelost, is het samenvoegen klaar!

Je kunt nu veilig duwen.


Antwoord 16

Dit gebeurt meestal wanneer u de eerste keer commit aan een externe repository.
Omdat de fout duidelijk zegt “weigeren om niet-gerelateerde geschiedenissen samen te voegen”, moeten we de vlag –allow-unrelated-histories gebruiken.

git pull origin master  --allow-unrelated-histories

Nu zouden er enkele conflicten zijn die we handmatig moeten oplossen. Voer daarna gewoon de code in en druk erop.


Antwoord 17

Ik probeerde git pull --allow-unrelated-histories werkte niet, maar wat dit probleem voor mij oplost was:

  1. Ik heb alle bestanden op mijn bureaubladrepository naar een andere map gekopieerd en vervolgens de map verwijderd.

  2. Dan kloon ik de repo opnieuw omdat het een nieuw project is.

  3. Toen ik mijn bestanden opnieuw kopieerde en pushte, werkte het als een tierelier.


Antwoord 18

Toen ik een git pull deed, kreeg ik dit bericht fatal: refusing to merge unrelated histories
voor een repo-module waar ik de lokale kopie al een tijdje niet had bijgewerkt.

Ik heb deze opdracht alleen uitgevoerd om lokaal van oorsprong te vernieuwen. Ik wilde alleen het laatste nieuws op afstand en had geen lokale wijzigingen nodig.

git reset --hard origin/master

Dit heeft het in mijn geval opgelost.


Antwoord 19

Ik worstelde hier ook mee, maar ik heb een oplossing gevonden.

Als je de bovenstaande fout tegenkomt, kies dan gewoon de merge-commit en ga verder met de rebase:

git cherry-pick -m 1 1234deadbeef1234deadbeef
git rebase --continue

Antwoord 20

Voor Googlers:

Als je een nieuwe repo op GitHub hebt gemaakt en deze per ongeluk hebt geïnitialiseerd met README– of .gitignore-bestanden.

Als je merkt dat je niet in staat bent om samen te voegen of opnieuw te baseren omdat de map .git beschadigd is geraakt.

Dan:

  • Maak een nieuwe map
  • git clone
  • Plak al je bestanden in deze map

Nu hebben de lokale en externe instellingen "gerelateerde geschiedenissen" en zal gelukkig samenvoegen of rebasen.


Antwoord 21

De fout wordt opgelost door de schakelaar allow-unrelated-histories om te zetten. Voeg na een git pull of git merge commando de volgende tag toe:

git pull origin master  --allow-unrelated-histories

Daarna krijg je misschien conflicten. Dus loste het conflict op en pleeg het. Het is werk voor mij.


Antwoord 22

Voor mijn geval wilde ik een niet-gerelateerde geschiedenistak samenvoegen met mijn huidige:

git merge <-unrelated-history-branch-name> --allow-unrelated-histories

Antwoord 23

Het meest gestemde antwoord lost deze vraag niet op, wat in de context van rebasen is.

De enige manier om de twee gedivergeerde branches te synchroniseren, is door ze weer samen te voegen, wat resulteert in een extra merge-commit en twee sets commits die dezelfde wijzigingen bevatten (de originele en die van je gerebaseerde branch). Onnodig te zeggen dat dit een zeer verwarrende situatie is.

Dus, voordat je git rebase uitvoert, vraag jezelf altijd af, Kijkt er iemand anders naar deze branch? Als het antwoord ja is, haal je handen van het toetsenbord en begin na te denken over een niet -destructieve manier om je wijzigingen aan te brengen (bijv. het git revert commando). Anders kun je de geschiedenis zo vaak herschrijven als je wilt.

Referentie: https:/ /www.atlassian.com/git/tutorials/merging-vs-rebasing#the-golden-rule-of-rebasing


Antwoord 24

Ik gebruik de rebase al jaren en ik ben nog nooit zo’n probleem tegengekomen. Je eerste probleem is echter dat je het rechtstreeks probeert te doen op de remote branch development vanuit de remote repository, genaamd origin. Dat is letterlijk verkeerd omdat rebase een gevaarlijk commando is, dat de git-geschiedenis herstructureert. Dat gezegd hebbende, moet u eerst uw lokale repository proberen en deze alleen pushen, als het voor u werkt zoals verwacht.

Mijn gebruikelijke rebase-workflow ziet er dus als volgt uit (maar houd er rekening mee dat u rebase niet moet gebruiken op branches, aangezien u niet de enige commissie bent. Gebruik voor dergelijke branches gewoon merge en los conflicten op, indien van toepassing ):

  1. zorg ervoor dat je een schone werkboom hebt (geen wijzigingen ongedaan gemaakt)
  2. checkout naar de branch waarnaar je wilt rebasen (bijvoorbeeld, laten we zeggen dat het master is; als een éénregelig commando): git checkout master && git pull origin master && git checkout development
  3. Doe de daadwerkelijke rebase: git rebase master
  4. Als het klaar is en alles werkt zoals verwacht, duw je het naar je afstandsbediening. Om dit te doen, moet je het forceren, omdat de externe host de geschiedenis al in een andere volgorde heeft, de externe zou antwoorden met niets om te pushen. Dus we moeten zeggen “mijn lokale versie van de geschiedenis is correct, overschrijf alles op die remote branch met mijn lokale versie van de geschiedenis”: git push -f origin development

Zoals ik al zei, houd er rekening mee dat rebase de git-geschiedenis manipuleert, dat is meestal een slechte zaak. Het is echter mogelijk om dat te doen op branches, waar niemand anders zich aan verbindt. Om de branch pull-able te houden voor de andere ontwikkelaars, gebruik je een andere merge strategie zoals merge zelf, squash of cherrypick. Dus, met andere woorden: Rebase zou niet uw hulpmiddel moeten zijn voor gedistribueerde ontwikkeling. Het werkt prima voor jou als je de enige bent die aan deze repository werkt.

We gebruiken de feature branch-strategie. Hierin gebruik ik meestal rebase om de “updates” van de andere ontwikkelaars te krijgen, die in de tussentijd op de master-branch zijn gebeurd. Door dit te doen, verkleint het de grootte van commits die zichtbaar zijn in een pull-verzoek. Daarom wordt het voor de coderecensent gemakkelijker om mijn wijzigingen in deze functietak te zien.


Antwoord 25

Omdat je niet kunt duwen of trekken-en-duwen of samenvoegen-trekken-en-duwen: –

  1. Je kunt een nieuwe branch maken in de GitHub-repository.
  2. En dan: –
  3. git add .
  4. git commit -m 'commitName'
  5. En verwijs naar die branch in je huidige directory in Terminal.
  6. git branch -m master branchName
  7. git push -f origin branchName
  8. Je code wordt naar een nieuwe branch gepusht.
  9. En dan kun je deze 2 takken samenvoegen.

Dit werkte voor mij.

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Other episodes