Git How to Push Again After a Fail

{{text-cta}}

It is well known that using Git's push --forcefulness command is strongly discouraged and considered subversive. However, to me, it seemed very strange to put all my trust in Git with my projects and at the aforementioned time completely avert using i of its popular commands. This led me to research why is this control considered to be then harmful? Why does it even be in the start place? and what happens nether the hood?

In this tutorial, I will share my discoveries so you too can empathise the usage and impact of this command on your project, learn new, safer alternatives, and master the skills of restoring a broken co-operative. Yous will exist surprised how the 'force' is really with you lot 🙌🏻

The push command

To sympathize how git works under the hood we need to have a step back and examine how Git stores its data. For Git everything is about commits, a commit is an object that includes several keys such as a unique id, a pointer to the snapshot of the staged content and pointers to the commits that came direct before that commit. A co-operative for that affair is nothing but a pointer to a unmarried commit.

What git push does is basically -

1. Copies all the commits that be in the local branch
2. Integrates the histories past forwarding the remote branch to reference the new commit, too called Fast forward ref.

Fast forrad ref

Fast forwards is simply forwarding the electric current commit ref of the branch. When our changes are pushed Git automatically searches for a linear path from the electric current ref to the target commit ref.

If there is an antecedent commit that exists in the remote and non in local(i.due east someone updated the remote and nosotros are not up to engagement) Git won't be able to discover a linear path between the commits and git push will neglect.

git push

When to use the --force

Altering commit history and rewriting commits that have already been pushed tin can exist washed using git rebase, git squash and git commit --amend, but exist warned my friends that these mighty commands don't but alter the commits — they replace all the commits, creating new ones entirely. Therefore a elementary git push will fail and we volition have to featherbed the "fast frontwards" rule.

Enter --forcefulness.

This option overrides the "fast forward" restriction and matches our local co-operative to the remote branch. The force flag allows the states to lodge Git "practise it anyway". Whenever nosotros change our history or whenever we desire to push changes that are in consists with the remote branch we should utilize button --strength.

git commit better

Simple scenario

Permit's say Lilly and Bob are developers working on the same characteristic co-operative, Lilly completed her tasks and pushed her changes. After a while, Bob also finished his piece of work merely before pushing his changes he had noticed some changes had been added. In club to keep the tree clean, he performed a rebase and push --strength the rebased branch. Unfortunately, not being updated to the remote branch Bob accidentally erased all the records of Lilly'southward changes 😰.

git push force

I of the common mistakes using this command is when Bob forgets to update (git pull) his local tracked branch, in this instance, using the strength might cause Bob a lot of trouble. you must wonder why? Well… force pushes the changes with no regard to the land of the tracked branch, therefore commits might get lost in the process. Shame on you Bob!

Alternative: push — force-with-lease

The --forcefulness pick has a not and then famous relative called -- force-with-lease, which enables us to push --force our changes with a guarantee that we won't overwrite somebody else'south changes. On default, --force-with-lease volition pass up to update co-operative unless the remote-tracking branch and the remote branch points to the same commit ref. Pretty great right? Information technology becomes even better(!!) you can specify -- force-with-lease exactly which commit, branch or ref to compare to. -- forcefulness-with-lease gives you the flexibility to override new commits on your remote co-operative whilst protecting your old commit history. It's the aforementioned force just with a life vest.

{{text-cta}}

Guide: How to bargain with destructive --forcefulness

You are without a doubt a responsible developer but I bet it happened to you at least in one case, that you or one of your teammates accidentally ran git push --force into an important branch that should never be messed with and Oops! In the blink of an eye, everybody's latest piece of work is now lost.

‍

No need to panic! If you are very lucky someone else who is working on the same lawmaking pulled a recent version of the branch but before y'all broke it. If and so, all yous have to practise is to inquire him/her to --force push their recent changes!

But fifty-fifty if you are not that lucky you are however lucky enough to find this tutorial. 👍🏻

i. You were the terminal person to push before the fault? 😱

☝🏻 First DO Not close your last.

🥺 Second, become to your teammates and confess your sins.

🗣 Finally, make sure no one messes with the repo for the side by side couple of minutes because you accept some work to do.

Go dorsum to your station. In the output of the git push --force command in your terminal look for the line that resembles this one:

The first grouping of symbols(which look like a commit SHA prefix) is the fundamental to fixing this.

d02c26f is your last good commit to the branch before y'all inflicted damages. Your simply pick is to fight burn with fire and push button --strength this commit back to the co-operative on top of the bad one:

Congratulations! You saved the day! 🥳

2. I accidentally --force pushed to my repo, and I want to become back to the previous version. What practice I do? 😩

Imagine working on a feature branch, you lot pulled some changes, created a few commits and completed your part of the feature and pushed your changes upwardly to the main repository. Then you squashed the commits into one, using git rebase --i and pushed again using push --force. But something bad happened and y'all want to restore your branch to the way it was before the rebase -i. Now, the bang-up thing about Git is that it is very all-time to never lose information, so the version of the repository before the rebase is still available.

In this instance, we'll use the git reflog command which outputs a detailed history of the repository. For every "update" we do in our local repository, Git creates a reference log entry. git reflog control outputs these ref-logs which are stored in our local git repository. git reflog outputs all the actions that have changed the tips of branches and other references in the local repository, including switching branches and rebases(the tip of the branch called Caput, and it'due south a symbolic reference to the currently active branch. information technology's only a symbolic reference since a branch is a pointer to a commit).

Here is a unproblematic reflog that shows the scenario I described to a higher place:

git reflog

The notation HEAD@{number} is the position of Head at "number" of changes agone. And then Caput@{0} is Head where Caput is at present and HEAD@{4} is HEAD iv steps ago. We can see from the reflog higher up that HEAD@{4} is where we need to go to restore the branch to where it was before the rebase and 0c2d866ab is the commit ID for that commit. Then to restore test-branch to the country we want, we'll reset the branch

and force push once more to restore the repository on to where it was before.

📝 General recovery

Anytime y'all want to restore your branch to the previous version after y'all push --forced follow this general recovery solution template:

1. Become the previous commit via terminal, refLog…
2. Create a co-operative or reset to the previous commit
3. Push --forcefulness

☝🏻notice: If you created a new branch don't forget reset the co-operative so it will be synced with the remote by running the following command:

iii. Restore button --force deleted co-operative

Permit'southward say…

😎 Y'all own a repository.

🤓 You had a programmer that wrote a project for you.

😡 For some reason, the developer got aroused.

😈 The developer decided to delete all the branches, and push --force a commit with the message "Ha Ha The project was hither".

🏃‍♂️ The developer escaped from the land, with no way to contact or detect him.

😭 Leaving yous without any code and yous have never cloned the repo before.

First thing first — you need to discover a previous commit. Sadly, in this case, using git log won't aid because the only commit the branch points to is "Ha Ha The project was hither" without any related commits. In this case, you have to find deleted commits that aren't directly linked to by whatsoever kid commit, branch, tag or other references. Fortunately, these orphan commits are stored in the git's database and they tin can be found using the powerful git fsck command

These commits are also called Dangling commits, and according to the docs, unproblematic git GC would remove dangling commits if they are 2 weeks old. Now, having our dangling commits all we have left to practice is to notice the i previous commit before the damages were done and to follow the General Recovery steps we learned before. 🤟🏻

🛡 Alternative: Protected branches

As the former maxim goes:

"The deviation between a smart person and a clever person is that a smart person knows how to get out of trouble that a clever person wouldn't accept gotten into in the first identify."

if you wish to completely avert push --force, GitHub and GitLab offering a very cool feature called Protected Branches, which allows you to mark any branch equally protected so no one will be able to push — force it (you lot can also set admin preferences for that affair similar admin permissions).

🌸 Summary

Hopefully, you lot at present empathise when yous need to add together the --force option and what are the risks of using information technology. Remember, the --forcefulness is there for you, it's only a bypass and like every bypass, you should utilise information technology with intendance.

May the --force be with you lot 🙏🏻.

fortiergisabloo.blogspot.com

Source: https://www.datree.io/resources/git-push-force

Share this post