What does it mean that a Git push can not be fast foward merged?

Can someone please provide a simple example of what would cause a Git push to a central repo to fail because a fast forward could not occur? What would the local repo vs the central repo’s state need to look like in order for this to occur? Really having trouble visualizing this…

  • Migrate SVN to git with cleanup
  • Using git to merge two directories with common parent (but different SHA1)
  • Avoid merge commit in git
  • Why git rebase creates conflicts, but git rebase -i does not?
  • How to revert changes due to a merge with Eclipse and EGit
  • All changes overwritten in git
  • How can i merge a git commit from a different branch?
  • What to do with unused feature branches
  • 2 Solutions collect form web for “What does it mean that a Git push can not be fast foward merged?”

    I assume you’re seeing this problem:

     ! [rejected]        master -> master (non-fast-forward)
    error: failed to push some refs to '/Users/mayoff/t/test/central'
    To prevent you from losing history, non-fast-forward updates were rejected
    Merge the remote changes (e.g. 'git pull') before pushing again.  See the
    'Note about fast-forwards' section of 'git push --help' for details.
    

    Here’s how the “non-fast-forward updates were rejected” problem happens.

    Let’s say Alice and Bob are working on a project. They each have a repository, and there’s a central repository they both push to and pull from. Initially, the three repositories look like this:

    initial synchronized repos

    Now Alice and Bob both do some work. Each commits a different change to their local repository:

    private repos have new commits

    Next, Alice pushes her change to the central repo:

    central repo updated by Alice

    Next, Bob tries to push. The central repo’s master branch points at commit 3. Bob’s push tries to update it to point at commit 4. Since commit 4 doesn’t have commit 3 as an ancestor, a merge is required, but git push doesn’t do real merges. It only does “fast-forwards”, where the new master has the old master as an ancestor. So Bob gets the error because he’s trying to push something that requires a real merge, not a fast-forward.

    To push successfully, Bob has to first fetch the new commit from the central repo:

    Bob has fetched Alice's commit

    and he has to merge his changes (commit #4) with Alice’s changes (commit #3), creating a new commit that has both commits as ancestors:

    Bob has merged the commits

    The fetch and merge can be done in two commands (git fetch followed by git merge) or in one command (git pull).

    Now Bob can push successfully, because the central repo sees that the new master has the old master as an ancestor.

    Bob pushed the merge

    Notice that now Alice is missing Bob’s commits. If she makes more commits to her repo and tries to push before pulling from the central repo, she’ll get the non-fast-forward error, and she’ll have to fetch and merge to fix it, just like Bob did.

    Simply make make a commit on the central repo on the same branch without pulling to your local one. Then commit locally and try to push.

    Git Baby is a git and github fan, let's start git clone.