Wie aktualisiere ich ein GitHub-Forked-Repository?

Ab Mai 2014 ist es möglich, einen Fork direkt von GitHub aus zu aktualisieren. Dies funktioniert noch ab September 2017, , ABER es wird zu einem Dirty Commit-Verlauf führen.

1. Öffne deine Gabel auf GitHub.
2. Klicke auf Pull Requests.
3. Klicke auf New Pull Request. Standardmäßig vergleicht GitHub das Original mit Ihrer Gabel und es sollte nichts zu vergleichen sein, wenn Sie keine Änderungen vorgenommen haben.
4. Klicken switching the base wenn Sie diesen Link sehen. Andernfalls stellen Sie das manuell ein base fork Lass dich auf deine Gabel fallen und die head fork zum Upstream. Jetzt vergleicht GitHub Ihre Gabel mit dem Original und Sie sollten alle aktuellen Änderungen sehen.
5. Create pull request und weisen Sie Ihrer Pull-Anfrage einen vorhersehbaren Namen zu (z. B. Update from original).
6. Scrollen Sie nach unten zu Merge pull request, aber noch nichts anklicken.

Jetzt haben Sie drei Möglichkeiten, aber jede führt zu einem nicht sauberen Festschreibungsverlauf.

1. Die Standardeinstellung erstellt ein unschönes Merge-Commit.
2. Wenn Sie auf die Dropdown-Liste klicken und "Squash and Merge" auswählen, werden alle dazwischen liegenden Commits zu einem zusammengefasst. Dies ist meistens etwas, was Sie nicht wollen.
3. Wenn du klickst Rebase and merge, alle Commits werden "mit dir" gemacht, die ursprünglichen PRs werden mit deiner PR verknüpft und GitHub wird This branch is X commits ahead, Y commits behind <original fork> anzeigen.

Also ja, Sie können Ihr Repo über die GitHub-Web-Benutzeroberfläche mit dem Upstream auf dem neuesten Stand halten, aber dadurch wird Ihr Commit-Verlauf beeinträchtigt. Halten Sie sich an die Befehlszeile stattdessen - es ist einfach.

Hier ist GitHubs offizielles Dokument zum Thema Synchronisieren einer Gabel :

Gabel synchronisieren

Die Einrichtung

Bevor Sie synchronisieren können, müssen Sie eine Fernbedienung hinzufügen, die auf das Upstream-Repository verweist. Sie haben dies möglicherweise getan, als Sie ursprünglich gegabelt haben.

Tipp: Durch das Synchronisieren Ihres Fork wird nur Ihre lokale Kopie des Repositorys aktualisiert. Ihr Repository auf GitHub wird nicht aktualisiert.

$ git remote -v
# List the current remotes
Origin  https://github.com/user/repo.git (fetch)
Origin  https://github.com/user/repo.git (Push)

$ git remote add upstream https://github.com/otheruser/repo.git
# Set a new remote

$ git remote -v
# Verify new remote
Origin    https://github.com/user/repo.git (fetch)
Origin    https://github.com/user/repo.git (Push)
upstream  https://github.com/otheruser/repo.git (fetch)
upstream  https://github.com/otheruser/repo.git (Push)

Synchronisierung

Es sind zwei Schritte erforderlich, um Ihr Repository mit dem Upstream zu synchronisieren: Zuerst müssen Sie von der Remote-Site abrufen und dann den gewünschten Zweig in Ihrem lokalen Zweig zusammenführen.

Holen

Beim Abrufen aus dem Remote-Repository werden die zugehörigen Zweige und die entsprechenden Commits eingebunden. Diese werden in Ihrem lokalen Repository unter speziellen Zweigen gespeichert.

$ git fetch upstream
# Grab the upstream remote's branches
remote: Counting objects: 75, done.
remote: Compressing objects: 100% (53/53), done.
remote: Total 62 (delta 27), reused 44 (delta 9)
Unpacking objects: 100% (62/62), done.
From https://github.com/otheruser/repo
 * [new branch]      master     -> upstream/master

Wir haben jetzt die Hauptniederlassung des Upstreams in einer lokalen Niederlassung, Upstream/Master, gespeichert

$ git branch -va
# List all local and remote-tracking branches
* master                  a422352 My local commit
  remotes/Origin/HEAD     -> Origin/master
  remotes/Origin/master   a422352 My local commit
  remotes/upstream/master 5fdff0f Some upstream commit

Zusammenführen

Nachdem wir das Upstream-Repository abgerufen haben, möchten wir seine Änderungen in unserer lokalen Niederlassung zusammenführen. Dadurch wird dieser Zweig mit dem Upstream synchronisiert, ohne dass unsere lokalen Änderungen verloren gehen.

$ git checkout master
# Check out our local master branch
Switched to branch 'master'

$ git merge upstream/master
# Merge upstream's master into our own
Updating a422352..5fdff0f
Fast-forward
 README                    |    9 -------
 README.md                 |    7 ++++++
 2 files changed, 7 insertions(+), 9 deletions(-)
 delete mode 100644 README
 create mode 100644 README.md

Wenn Ihre lokale Niederlassung keine eindeutigen Commits hatte, führt git stattdessen einen "Schnellvorlauf" durch:

$ git merge upstream/master
Updating 34e91da..16c56ad
Fast-forward
 README.md                 |    5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

Tipp: Wenn Sie Ihr Repository auf GitHub aktualisieren möchten, befolgen Sie die Anweisungen hier

Viele Antworten führen dazu, dass Sie Ihren Fork um einen Commit vor dem übergeordneten Repository verschieben. Diese Antwort fasst die gefundenen Schritte zusammen hier , mit denen Sie Ihren Fork auf das gleiche Commit wie den übergeordneten verschieben.

1. Wechseln Sie in Ihr lokales Repository.

   • Wechseln Sie zum Hauptzweig, wenn Sie nicht git checkout master sind.

2. Fügen Sie das übergeordnete Repository als Remote-Repository hinzu, git remote add upstream <repo-location>.

3. Ausgabe git fetch upstream

4. Ausgabe git rebase upstream/master

   • In dieser Phase überprüfen Sie, ob festgeschrieben wird, was zusammengeführt wird, indem Sie git status eingeben.

5. Ausgabe git Push Origin master

Weitere Informationen zu diesen Befehlen finden Sie unter Schritt .

Seit November 2013 ist eine inoffizielle Feature-Anfrage bei GitHub eingegangen, in der sie gebeten werden, eine sehr einfache und intuitive Methode hinzuzufügen, um eine lokale Abzweigung mit dem Upstream synchron zu halten:

https://github.com/isaacs/github/issues/121

Hinweis: Da die Funktionsanforderung inoffiziell ist, sollten Sie sich auch an [email protected] wenden, um Ihre Unterstützung für die Implementierung einer solchen Funktion hinzuzufügen. Die obige inoffizielle Merkmalsanfrage könnte als Beweis für das Ausmaß des Interesses an der Implementierung verwendet werden.

Vorwort: Ihre Abzweigung ist der "Ursprung" und das Repository, aus dem Sie abzweigen, ist der "Upstream".

Nehmen wir an, Sie haben bereits Ihre Gabel mit einem Befehl wie dem folgenden auf Ihren Computer geklont:

git clone [email protected]:your_name/project_name.git
cd project_name

Wenn dies angegeben ist, müssen Sie in dieser Reihenfolge fortfahren:

1. Fügen Sie den "Upstream" zu Ihrem geklonten Repository hinzu ("Origin"):

   git remote add upstream [email protected]:original_author/project_name.git
   

2. Holen Sie sich die Commits (und Zweige) aus dem "Upstream":

   git fetch upstream
   

3. Wechseln Sie zum "Master" -Zweig Ihrer Gabel ("Origin"):

   git checkout master
   

4. Verstecken Sie die Änderungen Ihres "Master" -Zweigs:

   git stash
   

5. Führen Sie die Änderungen aus dem "Master" -Zweig des "Upstream" in den "Master" -Zweig Ihres "Origin" ein:

   git merge upstream/master
   

6. Lösen Sie Zusammenführungskonflikte, falls vorhanden, und übernehmen Sie die Zusammenführung

   git commit -am "Merged from upstream"
   

7. Schieben Sie die Änderungen an Ihre Gabel

   git Push
   

8. Erhalten Sie Ihre verwahrten Änderungen zurück (falls vorhanden)

   git stash pop
   

9. Sie sind fertig! Herzliche Glückwünsche!

GitHub enthält auch Anweisungen zu diesem Thema: Synchronisieren einer Gabel

Wenn Sie, wie ich, niemals etwas direkt an den Meister übergeben, was Sie wirklich tun sollten, können Sie Folgendes tun.

Erstellen Sie aus dem lokalen Klon Ihrer Abzweigung Ihre Upstream-Fernbedienung. Das müssen Sie nur einmal machen:

git remote add upstream https://github.com/whoever/whatever.git

Wann immer Sie sich mit dem Upstream-Repository-Master-Zweig in Verbindung setzen möchten, müssen Sie Folgendes tun:

git checkout master
git pull upstream master

Angenommen, Sie haben noch nie etwas für den Meister getan, sollten Sie dies bereits tun. Jetzt können Sie Ihren lokalen Master an Ihre Origin-Remote-GitHub-Gabel senden. Sie können Ihren Entwicklungszweig auch auf Ihrem jetzt aktuellen lokalen Master aufbauen.

Nach dem anfänglichen Upstream-Setup und der Master-Prüfung müssen Sie nur noch den folgenden Befehl ausführen, um Ihren Master mit dem Upstream zu synchronisieren: git pull upstream master.

Zum Zeitpunkt der Beantwortung dieser Frage hat GitHub diese Funktion in der Weboberfläche nicht ( oder soll ich nicht länger sagen? ). Sie können jedoch [email protected] bitten, Ihre Stimme dafür hinzuzufügen.

In der Zwischenzeit hat der GitHub-Benutzer bardiharborow ein Tool erstellt, um genau dies zu tun: https://upriver.github.io/ =

Quelle ist hier: https://github.com/upriver/upriver.github.io

Wenn Sie GitHub für Windows verwenden, haben sie jetzt eine Ein-Klick-Funktion zum Aktualisieren von Gabeln:

1. Wählen Sie das Repository in der Benutzeroberfläche aus.
2. Klicken Sie oben auf die Schaltfläche "Update from user/branch".

Tatsächlich ist es möglich, aus einem Commit des Upstreams im Browser einen Zweig in Ihrem Fork zu erstellen:

• Öffne https://github.com/<repo>/commits/<hash>, wobei repo deine Gabel ist und hash ist ein voller Hash von Commit, den Sie im Upstream-Webinterface finden. Zum Beispiel kann ich https://github.com/max630/linux/commits/0aa0313f9d576affd7747cc3f179feb097d2899 öffnen, was zum Zeitpunkt des Schreibens auf linuxmaster verweist.
• Klicken Sie auf die Schaltfläche "Baum: ....".
• Geben Sie den Namen des neuen Zweigs ein und drücken Sie Enter

Sie können diese Verzweigung dann auf Ihren lokalen Klon übertragen und müssen nicht alle Daten an GitHub zurückschreiben, wenn Sie die Änderungen zusätzlich zu diesem Commit übertragen. Oder verwenden Sie das Webinterface, um etwas in diesem Zweig zu ändern.

Wie es funktioniert (es ist eine Vermutung, ich weiß nicht, wie genau GitHub es tut): Forks teilen den Objektspeicher und verwenden Namespaces , um die Referenzen der Benutzer zu trennen. So können Sie über Ihre Gabel auf alle Commits zugreifen, auch wenn sie zum Zeitpunkt des Gabelns noch nicht vorhanden waren.

Befolgen Sie die folgenden Schritte. Ich habe es versucht und es hat mir geholfen.

Kasse zu Ihrer Filiale

Syntax: git branch yourDevelopmentBranch
Beispiel: Git Checkout Master

Quell-Repository-Zweig ziehen, um den neuesten Code zu erhalten

Syntax: git pull https://github.com/tastejs/awesome-app-ideas master
Beispiel: Git Pull https://github.com/ORIGINAL_OWNER/ORIGINAL_REPO.git BRANCH_NAME

Als Ergänzung zu dieser Antwort suchte ich nach einer Möglichkeit, alle entfernten Zweige meines geklonten Repos ( Origin ) von Upstream zu aktualisieren. ) Äste auf einmal. So habe ich es gemacht.

Dies setzt voraus, dass Sie bereits einen Upstream Remote-Verweis auf das Quell-Repository konfiguriert haben (von dem Ursprung abgeleitet wurde) und diesen mit synchronisiert haben git fetch upstream.

Dann renne:

for branch in $(git ls-remote --heads upstream|sed 's#^.*refs/heads/##'); do git Push Origin refs/remotes/upstream/$branch:refs/heads/$branch; done

Der erste Teil dieses Befehls listet alle Köpfe im Upstream Remote-Repository auf und entfernt das SHA-1, gefolgt vom Zweignamen-Präfix refs/heads/.

Dann wird für jeden dieser Zweige die lokale Kopie des Upstream- Remote-Tracking-Zweigs (refs/remotes/upstream/<branch> auf lokaler Seite) direkt zum Remote-Zweig auf Ursprung (refs/heads/<branch> auf der Remote-Seite).

Jeder dieser Verzweigungssynchronisationsbefehle kann aus einem von zwei Gründen fehlschlagen: Entweder wurde die Upstream-Verzweigung umgeschrieben, oder Sie haben Commits für diese Verzweigung an Ihren Fork gesendet. In dem ersten Fall, in dem Sie dem Zweig auf Ihrer Gabel nichts zugewiesen haben, ist es sicher, gewaltsam zu drücken (Fügen Sie den Schalter - f hinzu, d. H. git Push -f im obigen Befehl). In dem anderen Fall ist dies normal, da Ihr Fork Branch auseinander gegangen ist und Sie nicht damit rechnen können, dass der Sync-Befehl funktioniert, bis Ihre Commits wieder mit upstream zusammengeführt wurden.

Ich aktualisiere meine gespaltenen Repos mit dieser einen Zeile:

git pull https://github.com/forkuser/forkedrepo.git branch

Verwenden Sie diese Option, wenn Sie Ihrem Projekt keinen weiteren Remote-Endpunkt hinzufügen möchten, wie andere hier veröffentlichte Lösungen.

Android Studio hat nun gelernt, mit GitHub-Fork-Repositorys zu arbeiten (Sie müssen nicht einmal "Upstream" -Remote-Repository per Konsolenbefehl hinzufügen).

Menü öffnen VCS → Git

Und achten Sie auf die beiden letzten Popup-Menüpunkte:

• Meine GitHub-Gabel neu starten

• Pull-Anfrage erstellen

Versuch sie. Ich verwende den ersten, um mein lokales Repository zu synchronisieren. Auf jeden Fall können Sie in Android Studio auf die Zweige aus dem übergeordneten Remote-Repository ("Upstream") zugreifen, nachdem Sie auf "Meine GitHub-Verzweigung neu starten" geklickt haben, und Sie können problemlos mit ihnen arbeiten.

(Ich benutze Android Studio 3.0 mit "Git Integration" und "GitHub" Plugins.)

Wenn Sie Ihr Forked-Repository geklont haben, wechseln Sie zum Verzeichnispfad, in dem sich Ihr Klon befindet, und zu den wenigen Zeilen in Ihrem Git Bash-Terminal.

$ cd project-name

$ git remote add upstream https://github.com/user-name/project-name.git
 # Adding the upstream -> the main repo with which you wanna sync

$ git remote -v # you will see the upstream here 

$ git checkout master # see if you are already on master branch

$ git fetch upstream

Und schon kann es losgehen. Alle aktualisierten Änderungen im Haupt-Repository werden in Ihr Fork-Repository übertragen.

Der Befehl "fetch" ist unabdingbar, um in einem Projekt auf dem neuesten Stand zu bleiben: Nur wenn Sie einen "git fetch" ausführen, werden Sie über die Änderungen informiert, die Ihre Kollegen auf den Remote-Server übertragen haben.

Sie können immer noch hier für weitere Fragen besuchen

Das hängt von der Größe Ihres Repository ab und davon, wie Sie es gegabelt haben.

Wenn es sich um ein ziemlich großes Repository handelt, möchten Sie es möglicherweise auf besondere Weise verwalten (z. B. Ablageprotokoll). Grundsätzlich können Sie Unterschiede zwischen der aktuellen und der vorgelagerten Version feststellen, diese festschreiben und dann zum Master zurückkehren.

Versuchen Sie zu lesen dieses . Es wird beschrieben, wie Sie mit großen Git-Repositorys umgehen und diese mit den neuesten Änderungen aktualisieren.

Wenn Sie Ihren Upstream einstellen. Überprüfen Sie mit git remote -v, dann wird dies ausreichen.

git fetch upstream
git checkout master
git merge --no-edit upstream/master
git Push

Es gibt zwei wichtige Dinge, um ein Forked-Repository immer für immer auf dem neuesten Stand zu halten.

1. Erstellen Sie die Zweige vom Gabelmaster und nehmen Sie dort Änderungen vor .

Wenn Ihre Pull-Anfrage akzeptiert wird, können Sie den Zweig sicher löschen, da der von Ihnen eingegebene Code dann in Ihrem Master Ihres Forked-Repositorys gespeichert wird, wenn Sie es mit dem Upstream aktualisieren. Auf diese Weise ist Ihr Master immer in einem sauberen Zustand, um einen neuen Zweig für eine weitere Änderung zu erstellen.

2. Erstellen Sie einen geplanten Job , damit der Gabelmaster automatisch aktualisiert .

Dies kann mit cron erfolgen. Hier ist ein Beispielcode für Linux.

$ crontab -e

fügen Sie diesen Code in den crontab file ein, um den Job stündlich auszuführen.

0 * * * * sh ~/cron.sh

dann erstelle das cron.sh Skript und eine Git Interaktion mit ssh-agent = und/oder erwarten wie unten

#!/bin/sh
WORKDIR=/path/to/your/dir   
REPOSITORY=<name of your repo>
MASTER="[email protected]:<username>/$REPOSITORY.git"   
[email protected]:<upstream>/<name of the repo>.git  

cd $WORKDIR && rm -rf $REPOSITORY
eval `ssh-agent` && expect ~/.ssh/agent && ssh-add -l
git clone $MASTER && cd $REPOSITORY && git checkout master
git remote add upstream $UPSTREAM && git fetch --Prune upstream
if [ `git rev-list HEAD...upstream/master --count` -eq 0 ]
then
    echo "all the same, do nothing"
else
    echo "update exist, do rebase!"
    git reset --hard upstream/master
    git Push Origin master --force
fi
cd $WORKDIR && rm -rf $REPOSITORY
eval `ssh-agent -k`

Überprüfen Sie Ihr Forked-Repository. Von Zeit zu Zeit wird immer diese Benachrichtigung angezeigt:

Dieser Zweig ist gerade mit <upstream>: master .