Rebasing remote branches in Git

I am using an intermediate Git repository to mirror a remote SVN repository, from which people can clone and work on. The intermediate repository has it’s master branch rebased nightly from the upstream SVN, and we are working on feature branches. For example:

remote:
  master

local:
  master
  feature

I can successfully push my feature branch back to the remote, and end up with what I expect:

  • What will happen if I delete a branch on my git repo and someone try to push a commit to it?
  • How to set tracking on an existing repo to a remote repo with ngit (or jgit)?
  • Git - getting a list of branches that were merged into another branch
  • Does git change submodule reference when switching branch
  • pull-only repo's 'git status' saying the branch is ahead of origin/master. Why?
  • Show the original branch for a commit
  • remote:
      master
      feature
    
    local:
      master
      feature
    

    I then re-setup the branch to track the remote:

    remote:
      master
      feature
    
    local:
      master
      feature -> origin/feature
    

    And all is well. What I would like to do from here is to rebase the feature branch to the master branch on the remote, but I would like to do this from my local machine. I’d like to be able to do:

    git checkout master
    git pull
    git checkout feature
    git rebase master
    git push origin feature
    

    To keep the remote feature branch up-to-date with the remote master. However, this method causes Git to complain:

    To <remote>
     ! [rejected]        feature -> feature (non-fast-forward)
    error: failed to push some refs to '<remote>'
    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.
    

    git pull does the trick but causes a merge commit that I’d like to avoid. I’m concerned that the message states feature -> feature rather than feature -> origin/feature but this may just be a presentation thing.

    Am I missing something, or going about this in completely the wrong way? It’s not critical to avoid doing the rebase on the remote server, but it makes fixing any merge conflicts from the rebase much harder.

  • get size of commit from github api
  • can't find api token in Github
  • running git on a linux server vs github
  • Most Flexible Open Office Word Document Format (Not MS Word) For Git Versioning and Collaboration
  • Is git dot notation in its commands a part of something more generic?
  • git rm --cached everything that is listed in .gitignore
  • 4 Solutions collect form web for “Rebasing remote branches in Git”

    It comes down to whether the feature is used by one person or if others are working off of it.

    You can force the push after the rebase if it’s just you:

    git push origin feature -f
    

    However, if others are working on it, you should merge and not rebase off of master.

    git merge master
    git push origin feature
    

    This will ensure that you have a common history with the people you are collaborating with.

    On a different level, you should not be doing back-merges. What you are doing is polluting your feature branch’s history with other commits that don’t belong to the feature, making subsequent work with that branch more difficult – rebasing or not.

    This is my article on the subject called branch per feature.

    Hope this helps.

    Nice that you brought this subject up.

    This is an important thing/concept in git that a lof of git users would benefit from knowing. git rebase is a very powerful tool and enables you to squash commits together, remove commits etc. But as with any powerful tool, you basically need to know what you’re doing or some shit’s gonna hit the fan 🙂

    When you are working locally and messing around with your local branches, you can do whatever you like as long as you haven’t pushed the changes to the central repository. This means you can rewrite your own history, but not others history. By only messing around with your local stuff, nothing will have any impact on other repositories.

    This is why it’s important to remember that once you have pushed commits, you should not rebase them later on. The reason why this is important, is that other people might pull in your commits and base their work on your contributions to the code base, and if you later on decide to move that content from one place to another (rebase it) and push those changes, then other people will get problems and have to rebase their code. Now imagine you have 1000 developers 🙂 It just causes a lot of unnecessary rework.

    Because you rebased feature on top of the new master, your local feature is not a fast-forward of origin/feature anymore. So, I think, it’s perfectly fine in this case to override the fast-forward check by doing git push origin +feature. You can also specify this in your config

    git config remote.origin.push +refs/heads/feature:refs/heads/feature
    

    If other people work on top of origin/feature, they will be disturbed by this forced update. You can avoid that by merging in the new master into feature instead of rebasing. The result will indeed be a fast-forward.

    You can disable the check (if you’re really sure you know what you’re doing) by using the --force option to git push.

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