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…

  • What are the differences between `--squash` and `--no-ff --no-commit`?
  • How can I prevent non-fastforward pushes to selected branch(es) in git?
  • Git pull only certain number of commits
  • What is the difference between `git merge` and `git merge --no-ff`?
  • Aptana: Git merge without fast forward
  • Git: Allow amending commits without erasing the history
  • Updating project version number on git push
  • How to create a Package with Python-for-Android in windows?
  • Sync between laptop and PC for eclipse projects
  • Remove files from Git commit
  • What is the correct way to convert SVN remote branches and tags into local Git branches/tags during SVN to Git migration
  • Use git svn to roll back some changes on the svn server?
  • 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.