2

My question concerns Github :

  • I have an official repo containing data, that I will call the upstream repo
  • I have a fork of that official repo, made by a second github user (a second user of mine)

I want to be able to keep the fork and the upstream identical, meaning "with the same commits history".

If a commit is made on the upstream repo, I have a message in the fork saying that the fork is now 1 commit behind the upstream.

I create a PR from the upstream into the fork, and merge it. I have tried the different merge strategies, but let say I merge it using the "rebase" technique.

At this point, what I expected to have is a fork up-to-date with the upstream. It is the case, if you look at the repo content, but in term of commit history, the fork is now 1 commit behind, and 1 ahead the upstream. In fact we are talking about the same commit, but its sha changed during the merge process. So Github consider those are 2 different commits.

This wouldn't bother me, except that now, I can't repeat the process. If a new commit is made to the upstream, I create again a PR towards the fork, but this PR now has merging conflicts that cannot be solved automatically !

How can I keep my fork up-to-date with the upstream (without deleting it every time) ?

Edit : I should have been more precise, I am hoping to find a workflow with the Github API only, and without any local git repo / git CLI involved.

Istopopoki
  • 1,584
  • 1
  • 13
  • 20
  • https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/syncing-a-fork – jonrsharpe Mar 17 '21 at 11:47
  • Thanks, but i read "Syncing your fork only updates your local copy of the repository. To update your fork on GitHub, you must push your changes." And my problems arrive when I push. – Istopopoki Mar 17 '21 at 11:53
  • 1
    You cannot do this with GitHub directly; you must use a Git repository on your own machine. See [my answer here](https://stackoverflow.com/a/66642567/1256452) to a related question. – torek Mar 17 '21 at 16:32
  • Very interesting answer @torek. As I am doing everything through Github API, it means I am stuck as there is no way to either bring the upstream commit in my fork without creating extra commits, or to allow extra commits and automatically solve conflicts afterwards. Do you confirm ? – Istopopoki Mar 18 '21 at 08:07
  • Also an interesting question/answer : https://stackoverflow.com/questions/60597400/how-to-do-a-fast-forward-merge-on-github – Istopopoki Mar 18 '21 at 08:33
  • Yes, unless GitHub add some kind of fast-forward-merge option, you're stuck. You also have an issue once you get one merge commit in your own repository, since now there's no way to rejoin the fast-forward-ing. – torek Mar 18 '21 at 14:53

1 Answers1

1

This is a common problem andere there are some ways to prevent recreating the fork when using git locally.

Most important is you never change your the content of the main branch (e.g. master, main or maybe dev - I assume main here), as you like to keep them fully identical to the original source. So every feature needs in a feature branch.

So the flow will work:

  1. Create a new branch on your fork (maybe first locally), add some changes/commits
  2. Create a PR to the original github repo.
  3. After merge of the PR, update your main branch to have it identical to main branch of the original source. See steps below.

Update your main branch to have it identical to main branch

For this you need first also a connection from your local clone to the original source.

Initial setup

When cloning your fork locally you have the, fork as origin remote:

git remote -v

Will return something like

origin  https://github.com/YourUserName/Repo.git (fetch)
origin  https://github.com/YourUserName/Repo.git (push)

You need first also the remote of the original source, commonly called upstream. This need to be done only once for each clone.

git remote add upstream https://github.com/Original/Repo.git

Now git remote -v will return:

origin    https://github.com/YourUserName/Repo.git (fetch)
origin    https://github.com/YourUserName/Repo.git (push)
upstream  https://github.com/Original/Repo.git (fetch)
upstream  https://github.com/Original/Repo.git (push)

Update your main branch

Now after the main branch from the original repo has been updated, you need to do:

git checkout main 
git fetch upstream
git merge upstream/main --ff-only
git push

This will do:

  • move to main branch
  • fetch the source of the upstream remote
  • merge with the main of the upstream and with fast forward only option. This ensures there are no other
  • push it to your fork (origin)

When there are changes in your main, the merge will fail because of the fast forward option. To fix this, I think this answer is better for that

Julian
  • 33,915
  • 22
  • 119
  • 174
  • Thank you for your answer ! I was hoping to do everything through the Github API and I didn't want to use a local git. But @torek comment seems to indicate that it is not possible... – Istopopoki Mar 18 '21 at 08:11
  • OK, maybe we should remove the tag `git` then :) – Julian Mar 18 '21 at 10:03