Git Merge Rebase and Cherry Pick - deep dive

Hello guys 🙂 this post I would like to share with you about the "git merge" experiments.

We have multiple code lines in the project, once the developer completes his task branch is ready to move to the next branch for testing. 

Git Merge and git rebase

There are multiple ways to combine the code lines. If the HEAD pointed to the tip of the branch then the best way to merge from the other branches into the current branch. 

• FF fast forward merge 
• 3 Way merge

You will be on the target-branch (most of the time it will be main/master or release or production) and then you will run the following command with a source-branch.

git merge [branch-name]

The following example for the Git Merge 'ort' Strategy, let's begin

clear
mkdir merge_test; cd merge_test; git init 
# on main branch two commits
touch test1 ; git add . ; git commit -m "test1"
touch test2 ; git add . ; git commit -m "test2"
# branch out feature and do 2 commits 
git checkout -b feature
touch test3 ; git add . ; git commit -m "test3"
touch test4 ; git add . ; git commit -m "test4"
# switch back to main branch 2 commits
git switch main
touch test5 ; git add . ; git commit -m "test5"
touch test6 ; git add . ; git commit -m "test6"
graph
#confirm which branch 
git branch

# merge the feature branch to main 
git merge feature

 After merge

Git Merge 'ort" Strategy

The git merge execution example is given below:

# clone a project repo from GitHub/BitBucket
# Create branch a-branch do a commit
git checkout -b a-branch 
touch a ; git add ; git commit -m"a changes"
git status -s
# Get the main branch on top it create b-branch 
git switch main 
git checkout -b b-branch
# b changes commit
touch b ; git add ; git commit -m"b changes"
git status -b # assuming that you are on the b-branch
# get all the changes in a-branch get into the b-branch 
# HEAD pointing to b-branch 
git merge a-branch 
git log --oneline --graph -all

You can also clearly mention on the that what is source and target branch as shown below:

git merge [source branch] [target branch]

Merging a branch newbranch into a target branch as master.

git branch
git merge newbranch master
git log --oneline --graph -all

There is one more thing here "git rebase". Let's deep dive into rebase experiment now.

As per my understanding rebase will be used when we have few changes on a feature branch from there you worked on some more changes in a latest branch and those changes you wish to include into the master then rebase is best choice and when you merge the third level branch to master it will only considers the latest branch commits and it does not consider it's parent commits during master branch merge which is actual fast forward. Here is my understanding 

Before git rebase

Now let's do the rebase from the feature2 branch to master branch as shown below

Example of feature2 branch rebase to master from feature1 branch

The rebase and fast-forward merge execution sample is given below:

Example of rebase here rebased to from feature2 to master, that means excluding feature1

After the rebase of a branch it will be fast-forward merge only.

Git fast-forward merge automatically after rebase

Fast-forward merge experiment

We can use the --ff and --ff-only options when doing the merging a branch. here is the each one option meaning from the git help

--ff

           When the merge resolves as a fast-forward, only update the branch pointer, without creating a

           merge commit. This is the default behavior.

       --ff-only

           Refuse to merge and exit with a non-zero status unless the current HEAD is already up-to-date or

           the merge can be resolved as a fast-forward.

git merge fast forward

 master) B
c313a34 A

scmuser@localhost ~/merging (master)
$ git checkout -b "feature"
Switched to a new branch 'feature'

scmuser@localhost ~/merging (feature)
$ touch C; git add .; git commit -m"C"
[feature 76e64d8] C
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 C

scmuser@localhost ~/merging (feature)
$ touch D; git add .; git commit -m"D"
[feature 2c421a7] D
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 D

scmuser@localhost ~/merging (feature)
$ git log --oneline --graph --all
* 2c421a7 (HEAD -> feature) D
* 76e64d8 C
* 2548379 (master) B
* c313a34 A

scmuser@localhost ~/merging (feature)
$ git switch master
Switched to branch 'master'

scmuser@localhost ~/merging (master)
$ git status -b -s
## master

scmuser@localhost ~/merging (master)
$ git merge feature
Updating 2548379..2c421a7
Fast-forward
 C | 0
 D | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 C
 create mode 100644 D

scmuser@localhost ~/merging (master)
$ git branch -d feature
Deleted branch feature (was 2c421a7).

scmuser@localhost ~/merging (master)
$ git log --oneline --graph --all
* 2c421a7 (HEAD -> master) D
* 76e64d8 C
* 2548379 B
* c313a34 A

scmuser@localhost ~/merging (master)
$ ls
A  B  C  D 

What is Merge Conflicts?

If two collaborators use the same file for editing on the code lines. When it's pushed to the remote repository there is a chance to conflict.

  mkdir mergeconflict; cd mergeconflict
git init
vi hello.py 
# Entered line as -  print("Hello World!")

git add .; git commit -m"Initial commit"

# takeout a new branch from master
git checkout -b vastav

# Edit the file replaced with  - print("Hello Vastav!")
vi hello.py 
git add .; git commit -m"vastav commit"

#switch back to master branch
git switch master 

# modify the same line with - print("Hello Dihitha")
git add .; git commit -m"Dihitha commit"

# Double check you are on master branch and ready for merge vastav branch
git merge vastav

# Observe there is merge conflict
  

Git merge conflict

You can open the file in vi or vs code at your convenience. The conflict is represented by ">>>" and "===" symbols. If two teammates discuss the conflicts and then decide what code lines should be preserved and what lines can be removed.

Git merge conflict and its resolution

Once you save the conflict file, it will be committed to the local repo.

Cherry-pick Merge

How does cherry-pick works? 

We want to pick up a specific commit from a different branch and apply to the current branch. Git provided a subcommand 'cherry-pick'

 
Syntax:

git cherry-pick commit-id

When can I use the Cherry-pick?

• To make it correct when a commit is made in a different branch accidentally.
• Preferable way is traditional merges only
• To apply the changes in an existing commit urgently 
• Duplicate commits
• Bug fixing in production

 

Cherry-pick example branches

Example of git cherry-pick

mkdir check-pick; cd cherry-pick; git init .
alias graph="git log --oneline --graph --all" #if it is added to .bashrc you can skip this
touch A; git add .; git commit -m "A"
touch B; git add .; git commit -m "B"
# branch out feature
git checkout -b feature'
touch C; git add . ; git commit -m "C"
touch D; git add .; git commit -m "D"
touch F; git add .; git commit -m "F"
# check git work-tree
graph
git checkout master
touch E; git add .; git commit -m "E"
graph
git cherry-pick 6353156 [select D commit-code]
graph

Execution output as follows:

git cherry-pick example

Here we conclude now with branches and their corresponding merging is easy. we know how to merge the code from another branch. Also know how to be specific.

Have fun with Git/SCM tools!!

Please write your comment while working with this merge and rebase post along with cherry-pick concept and their corresponding execution examples.

GIT Commands reference for DevOps Engineer

Dear DevOps Engineer!! this post is full of experimenting with git commands running most of them on the 'Git Bash' window in my laptop. I've collected three things about each git command.

• git command syntax
• What this git command will do - short descriptions
• An example command that I've executed
• Screenshot of that command execution

How do I Start a Fresh repository in Git CLI(local repo)?

You need to create a folder where you would like to start your coding project. The code can be web-site related where you can have multiple directories involved such as HTML files into a folder, all images to be used in the website in a folder, CSS files into a folder, etc. First, make the folder structure for you project then at the root of the project need to initialize the project.  To create empty repo or re-initializing a repo

Syntax :

git init

Note: It is always better to have a fresh directory created and then run the above command to initialize a local Git repository.

git init example

Getting a remote repository to your git client - Local system/Laptop

You can have the remote repository either public or private teams on the following SCM clouds:

1. GitHub 
2. GitLab
3. BitBucket

git clone Syntax:

git clone ssh://git@github.com/[username]/[repository-name].git

Create a local copy of a remote repository of GitHub or Gitlab. Make sure that you're doing first time in that folder, it should not have the same repo that means if your re-run the same command it cannot work.

Please make sure you have the correct access rights and the remote repository exists

Example of using gitlab URL:

 git clone https://github.com/BhavaniShekhar/vtdevops2021feb.git

Vybhava : git clone 

Syntax:

git commit -m "[commit message]"

commit changes
Example:

git commit -m "some message"

git commit command

Syntax:

git checkout -b [branch name origin/[branch name]

Clone a remote branch and switch to it
Example:

git checkout -b feature2

Differences between git checkout & switch command

Syntax:

git checkout [branch name]

Switch to a branch
Example:

git checkout

git checkout command

Syntax :

git checkout -

Switch to the branch last checked out
Example :

git checkout -

git last checkout command

Syntax:

git checkout -- [file-name.txt]

Discard changes to a file on which you are worked recently.
Example:

Syntax:

git push origin [branch name]

push to a branch to your remote repository
 Example:

git push origin slave

git push command

Syntax:

git push -u origin [branch name]

push changes to remote repository (and remember the branch)
Example:

git push -u origin feature1

git push origin command

Syntax:

git push

push changes to remote repository (remembered branch)
Example:

git push

git push command 

Syntax:

git push origin --delete [branch name]

delete a remote branch
 Example:

git push origin --delete feature3

git remote branch delete oush command

git pull command

Syntax:

git pull origin [branch name]

update local repository to the newest commit
Example:

git pull

git pull command

pull changes from remote repository Example:

git pull origin newbranch2

git remote

Syntax:

git remote add origin ssh://git@github.com/[username]/[repository-name].git
    or
 git remote set-url origin ssh://git@github.com/[username]/[repository-name].git

add a remote repository Example 1:

git remote add origin git@gitlab.com:gitops4/docker-exercises.git

set a repository's origin branch to ssh Example 2:

git remote set-url origin git@gitlab.com:gitops4/docker-exercises.git

git log

The syntax for the git log command is:

git log [--summary] [--oneline]

view changes
Example:

git log

git log command

view changes made to files or directory in (detailed)
Example:

    git log --summary

git log summary command

view changes(briefly)
Example:

    git log --oneline

git log oneline command

Syntax:

git diff [source branch] [target branch]

preview changes before merging 

References: 

 Git log command examples https://www.thegeekstuff.com/2014/04/git-log/