51

Yesterday, I pushed to my fork of ConnectBot on GitHub. I pushed once, realized that I hadn't made the change the way I wanted, redid the commit and pushed again.

Now, GitHub has both commits:

My master branch is only tracking the second commit, but the first commit is still available and is still in my activity feed. How can I remove it to make sure no one accidentally pulls that commit instead of the corrected version?

Improve this question
5
  • 34
    After 8 years the commits are both still there - accepted answer is obviously wrong.. Commented Nov 6, 2018 at 14:37
  • The good news after all these years is that GitHub now have a virtual assistant that will create a ticket automatically for you. Very smooth process. Commented Mar 22, 2023 at 8:53
  • @ospider from where could we create a ticket automatically? Commented May 21, 2023 at 17:41
  • 1
    @alper GitHub support. Commented May 22, 2023 at 7:06
  • 14 years and 10 months. Still here! Commented Oct 17 at 21:26

4 Answers 4

Reset to default
17

Delete the repo or contact GitHub

Deleting the repo and recreating it without the bad commit seems to work if you can afford losing all issues. The data also disappears from the commit API (although push events are still visible). See also: https://stackoverflow.com/a/32840254/895245

If you can't afford to lose issue data, GitHub support can manually delete dangling commits. For example, when I uploaded all GitHub commit emails to a repo they asked me to take it down, so I did, and they did a gc. Pull requests that contain the data have to be deleted however: that repo data remained accessible up to one year after initial takedown due to this.

Their current help page says:

you can permanently remove all of your repository's cached views and pull requests on GitHub by contacting GitHub Support.

Maybe making the repo private will also keep the issues around and get rid of the commit, I'm not sure. You lose stars/forks for sure though. Not sure if after restore the commits will be gone or not. But at least you might be able to keep a private backup of issues.

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

Note, you will also permanently lose all stars and forks if you make your repo private!
16

If you really need it to be removed immediately, you would probably have to contact GitHub Support.

Pulling should generate a pack that contains only objects that are referenced so no one should get that commit as a result of a clone or a pull. For example,

$ git clone git://github.com/nylen/connectbot.git
Cloning into connectbot...
remote: Counting objects: 6261, done.
remote: Compressing objects: 100% (1900/1900), done.
remote: Total 6261 (delta 3739), reused 5980 (delta 3520)
Receiving objects: 100% (6261/6261), 3.04 MiB | 3.40 MiB/s, done.
Resolving deltas: 100% (3739/3739), done.
$ git cat-file -t 1cd775d
fatal: Not a valid object name 1cd775d
Improve this answer

11 Comments

After four years, both OP's commits are still available on Github.
What's the basis for you saying that github will periodically garbage collect commits that aren't referenced? I've heard this said before but can't find anything more credible than answers like this.
You need to contact GitHub support (as indicated here) to remove cached commits which are no longer referenced.
In my case, I contacted github and they replied back that said they "cleared the cache on our end and run garbage collection" and I was able to confirm that the commits were no longer accessible.
11 years now and OP's dangling commit is still available on Github ( 1cd775d )
|
0

How can I remove it to make sure no one accidentally pulls that commit instead of the corrected version?

There's no need to do this, anybody using the master branch on your repo will get the correct commit (i.e., whatever you happen to have master branch pointing to at the time).

The reason that the other commit hasn't been garbage-collected is because there's still a reference to it somewhere.

In local repos this is usually the reflog, and the commit will be GC'd once it gets old enough that the reflog entry that indicates that HEAD and/or master pointed to that commit sometime in the past ages out and is GC'd, or is explicitly deleted.

GitHub is a bit more complex because there are plenty of things outside of a particular repo that can reference commits in a repo. This includes PRs, issues, and apparently even references in other repos, as the current message at the top of https://github.com/nylen/connectbot/commit/1cd775d indicates:

This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

I tried to track down where this reference might be by checking issues and PRs in the upstream repo and another fork repo mentioned in a PR for the "good" commit above. I didn't manage to track it down, but the upstream repo currently has 624 active forks, each with its own set of commits, PRs and issues (and whatever else GitHub has that references commits), so the reference is no doubt in there somewhere.

But again, there's no need to worry about this. Anybody looking at your master branch will always get the "correct" commit as of the time they last fetched your repo on the tracking branch, and they'll have to resolve things in the usual way if they happen to have a local branch that they made reference the older version of that commit. (In situations like this one, usually a simple git rebase will "replace" the old commit with the new one on the local branch.)

Improve this answer

Comments

0

I was looking for solution to this question and playing with some my private repo. Then I experienced interesting behavior.

I have mirror cloned repo (clone --mirror) and inside of it run commands mentioned in answers in this question. There were no orphaned commits at all. Then I pushed that mirror repo (push --mirror) to GitHub (to new blank repo to not mess with the original one) and indeed there were no these commits.

I did that with OP's repo for demo.

Original repo:
https://github.com/nylen/connectbot/commit/1cd775d

My repo:
https://github.com/jurakovic/connectbot_demo/commit/1cd775d

Executed commands:

git clone --mirror https://github.com/nylen/connectbot.git
cd connectbot.git
git push --mirror https://github.com/jurakovic/connectbot_demo.git

I still don't know what would happen if you would push --mirror to the existing repo with issues and pull requests. I will try that some time later with some demo repo and see.

Improve this answer

1 Comment

If you have a new question, please ask it by clicking the Ask Question button. Include a link to this question if it helps provide context. - From Review

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.