Finding lost changes with git fsck
by Jakub Narębski, Rasmus Voss, Aske Olsson, Ferdinando Santacroce
Git: Mastering Version Control
- Git: Mastering Version Control
- Table of Contents
- Git: Mastering Version Control
- Git: Mastering Version Control
- Credits
- Preface
- I. Module 1
- 1. Getting Started with Git
- 2. Git Fundamentals – Working Locally
- 3. Git Fundamentals – Working Remotely
- 4. Git Fundamentals – Niche Concepts, Configurations, and Commands
- Dissecting the Git configuration
- Configuration architecture
- Configuration levels
- Listing configurations
- Editing configuration files manually
- Setting up other environment configurations
- Basic configurations
- 5. Obtaining the Most – Good Commits and Workflows
- The art of committing
- Adopting a workflow – a wise act
- Summary
- 6. Migrating to Git
- 7. Git Resources
- II. Module 2
- 1. Navigating Git
- 2. Configuration
- 3. Branching, Merging, and Options
- 4. Rebase Regularly and Interactively, and Other Use Cases
- 5. Storing Additional Information in Your Repository
- 6. Extracting Data from the Repository
- 7. Enhancing Your Daily Work with Git Hooks, Aliases, and Scripts
- Introduction
- Using a branch description in the commit message
- Creating a dynamic commit message template
- Using external information in the commit message
- Preventing the push of specific commits
- Configuring and using Git aliases
- Configuring and using Git scripts
- Setting up and using a commit template
- 8. Recovering from Mistakes
- Introduction
- Undo – remove a commit completely
- Undo – remove a commit and retain the changes to files
- Undo – remove a commit and retain the changes in the staging area
- Undo – working with a dirty area
- Redo – recreate the latest commit with new changes
- Revert – undo the changes introduced by a commit
- Reverting a merge
- Viewing past Git actions with git reflog
- Finding lost changes with git fsck
- 9. Repository Maintenance
- Introduction
- Pruning remote branches
- Running garbage collection manually
- Turning off automatic garbage collection
- Splitting a repository
- Rewriting history – changing a single file
- Back up your repositories as mirror repositories
- A quick submodule how-to
- Subtree merging
- Submodule versus subtree merging
- 10. Patching and Offline Sharing
- 11. Git Plumbing and Attributes
- Introduction
- Displaying the repository information
- Displaying the tree information
- Displaying the file information
- Writing a blob object to the database
- Writing a tree object to the database
- Writing a commit object to the database
- Keyword expansion with attribute filters
- Metadata diff of binary files
- Storing binaries elsewhere
- Checking the attributes of a file
- Attributes to export an archive
- 12. Tips and Tricks
- III. Module 3
- 1. Git Basics in Practice
- An introduction to version control and Git
- Git by example
- Repository setup
- Creating a Git repository
- Cloning the repository and creating the first commit
- Publishing changes
- Examining history and viewing changes
- Renaming and moving files
- Updating your repository (with merge)
- Creating a tag
- Resolving a merge conflict
- Adding files in bulk and removing files
- Undoing changes to a file
- Creating a new branch
- Merging a branch (no conflicts)
- Undoing an unpublished merge
- Summary
- 2. Exploring Project History
- 3. Developing with Git
- 4. Managing Your Worktree
- Ignoring files
- File attributes
- Fixing mistakes with the reset command
- Stashing away your changes
- Managing worktrees and the staging area
- Multiple working directories
- Summary
- 5. Collaborative Development with Git
- 6. Advanced Branching Techniques
- Types and purposes of branches
- Branching workflows and release engineering
- Interacting with branches in remote repositories
- Summary
- 7. Merging Changes Together
- 8. Keeping History Clean
- An introduction to Git internals
- Rewriting history
- Amending history without rewriting
- Summary
- 9. Managing Subprojects – Building a Living Framework
- Managing library and framework dependencies
- Managing large Git repositories
- Summary
- 10. Customizing and Extending Git
- 11. Git Administration
- 12. Git Best Practices
- 1. Git Basics in Practice
- A. Bibliography
- Index
- Configuration architecture
- Dissecting the Git configuration
Another tool exists in Git that can help you find and recover lost commits and even blobs (files), which is git fsck. The fsck command tests the object database and verifies the SHA-1 ID of the objects and the connections they make. The command can also be used to find objects that are not reachable from any named reference, as it tests all the objects found in the database, which are under the .git/objects folder.
Again, we'll use the hello world repository. If you make a fresh clone, make sure to run the scripts for this chapter (04_undo_dirty.sh), so there will be some objects for git fsck to consider. The scripts can be found on the book's homepage. If you just reset the master branch after performing the other recipes in the chapter, everything is ready.
We can create the fresh clone as follows:
$ git clone https://github.com/dvaske/hello_world_cookbook.git $ cd hello_world_cookbook
We can reset an existing clone as follows:
$ cd hello_world_cookbook $ git checkout master $ git reset --hard origin master HEAD is now at 3061dc6 Adds Java version of 'hello world'
- Let's look for the unreachable objects in the database:
$ git fsck --unreachable Checking object directories: 100% (256/256), done. unreachable commit 147240ad0297f85c9ca3ed513906d4b75209e83d unreachable blob b16cf63ab66605f9505c17c5affd88b34c9150ce unreachable commit 4c3b1e10d8876cd507bcf2072c85cc474f7fb93b
- We found two commits and one blob. Let's take a closer look at each of them; the blob first:
git show b16cf63ab66605f9505c17c5affd88b34c9150ce #include <stdio.h> void say_hello(void) { printf("hello, world "); } int main(void){ say_hello(); return 0; }
So the blob is the
hello_world.cfile from the example which stashing away your changes before resetting a commit. Here we stashed away the file, performed a reset, and resurrected the file from the stash, but we never actually performed a commit. Thestashcommand, however, did add the file to the database, so it could find it again, and the file will continue to be there until the garbage collection kicks in or forever if it is referenced by a commit in the general history. - Let's look closer at the two commits:
$ git show 147240ad0297f85c9ca3ed513906d4b75209e83d commit 147240ad0297f85c9ca3ed513906d4b75209e83d Merge: 3061dc6 4c3b1e1 Author: Aske Olsson <[email protected]> Date: Thu Mar 13 23:19:37 2014 +0100 WIP on master: 3061dc6 Adds Java version of 'hello world' diff --cc hello_world.c index 881ef55,881ef55..b16cf63 --- a/hello_world.c +++ b/hello_world.c @@@ -1,7 -1,7 +1,10 @@@ #include <stdio.h> --int main(void){ ++void say_hello(void) { printf("hello, world "); ++} ++int main(void){ ++ say_hello(); return 0; --} ++} $ git show 4c3b1e10d8876cd507bcf2072c85cc474f7fb93b commit 4c3b1e10d8876cd507bcf2072c85cc474f7fb93b Author: Aske Olsson <[email protected]> Date: Thu Mar 13 23:19:37 2014 +0100 index on master: 3061dc6 Adds Java version of 'hello world'
Both the commits are actually commits we made when we stashed away our changes in the previous example. The
stashcommand creates a commit object with the contents of the staging area, and a merge commit mergingHEADand the commit with the index with the content of the working directory (tracked files only). As we resurrected our stashed changes in the previous example, we no longer have any reference pointing at the preceding commits; therefore, they are found bygit fsck.
The git fsck command will test all the objects found under the .git/objects folder. When the --unreachable option is given, it will report the objects found that can't be reached from another reference; the reference can be a branch, a tag, a commit, a tree, the reflog, or stashed away changes.
- Refer to Chapter 12, Tips and Tricks, for more information on the
git stashcommand
-
No Comment