Managing releases effectively through Git

- By Mohd Farid

Agenda

● Git branching support

● Why branching strategy?

● Introducing git-flow

● Different branches for different purposes

● Different Workfows while using git-flow

Git branching support

● Git allows us to create multiple branches.

● Merge any branch into another.

● Pull changes from any branch to any branch.

Note: With great power comes great responsibilities

Why do I need a branching strategy?

Git branching strategy - Why it is important ?

Frequent overwriting of my commits by this guy.

Git branching strategy - Why it is important ?

Difficult to debug what went wrong from the clumsy tree structure.

Git branching strategy - Why it is important ?

Situation goes out of control: We call the experts … and they do things like..

git reset HEAD git reset HARD and .. evil

Our hearts start beating faster and faster… with eachcommand they type !!!

Git branching strategy - Why it is important ?

We always have a stable branch ready to be deployed to production.

But before we solve it, lets see, how things go wrong…

The good, The bad and the ugly

The Good - Single developer days

The Bad - Two developers on the project

The Ugly - Multiple developer days..

It definitely needs a genius (+ time) to decipher this tree.

What is the way out from this ….. life ?

Lets meet a branching strategy.. Git-flow

Git-flow is a way to manage our code such that:

● There are no code overrides by my colleague.

● If something goes wrong, I can easily figure out which commit failed by referring to a very simple tree.

Lets meet a branching strategy.. Git-flow

Ques: Do I need to learn new set of commands for this

Ans: NO, We just need to be follow a simple process and everything will fall in place.

Most frequently used commands

git pull origin development

git checkout -b branchName

git commit -am “Commit message”

git merge --no-ff feature-branch

git rebase

git branch -d

git push origin development

What is git-flow

What are these different kind of branches

● development branch

● feature branch

● release branch

● master branch

● hotfix branch

Branches

Merging a feature branch into development

1. git checkout development

2. git checkout -b JIRA-103

3. work on the feature.

4. commit your changes to the branch.

5. git checkout development

6. git pull origin development

7. if no new changes are received in the pull

8. git merge --no-ff JIRA-103

9. git push origin development

10. git branch -d JIRA-103

Merging a feature branch into development

1. ….

2. if some new changes are received in the pull

3. git checkout JIRA-103

4. git rebase development // Rebasing the current branch (JIRA-

103) with development

5. git checkout development

6. git merge --no-ff JIRA-103

7. git push origin development

8. git branch -d JIRA-103

Work flow 1: Working on a feature

1. git checkout development

2. git checkout -b JIRA-103

3. work on the feature.

4. commit your changes to the branch.

5. git checkout development

6. git pull origin development

7. if there are no new changes recieved in the pull

8. git merge --no-ff JIRA-103

9. git push origin development

Work flow 1: Working on a feature

1. ...

2. git checkout development

3. git pull origin development

4. if there are some new changes received in the pull

5. git checkout JIRA-103

6. git rebase development

7. git checkout development

8. git merge --no-ff JIRA-103

9. git push origin development

Workflow 2: Releasing to production

1. git checkout development

2. git checkout -b release-2.1

3. up the application version and commit this change.

4. git push origin release-2.1

5. test the release branch on staging environment

6. if there are any issues, fix them only on release branch

7. once satisfied, git checkout master

8. git merge --no-ff release-2.1

9. git tag v2.1

10. git push origin master

Workflow 2: Releasing to production

...

once satisfied with release-2.1

git checkout master

git merge --no-ff release-2.1

git tag v2.1

git push origin master

git push --tags

deploy the master branch to production.

Workflow 3: Addressing the Production issues: Hotfix branch

Once the master has been deployed to production and there is some issue on production.

1. git checkout master

2. git checkout -b hot-fix-2.1.1

3. increase the application version.

4. fix the issue and commit the changes.

Merge the hotfix branch on master & development *(if there is no active release branch. If there is one then merge it on master and the active release branch. )

Workflow 3: Addressing the Production issues: Hotfix branch

Merging the hotfix branch on master..

1. git checkout master

2. git pull origin master

3. if there are no new changes:

4. git merge --no-ff hotfix-2.1.1

5. git push origin master

6. git branch -d hotfix-2.1.1

if there are changes in master then rebase the hotfix and then merge

Workflow 3: Addressing the Production issues: Hotfix branch

Merging the hotfix branch on development..

1. git checkout development

2. git pull origin development

3. if there are no new changes:

4. git merge --no-ff hotfix-2.1.1

5. git push origin development

6. git branch -d hotfix-2.1.1

if there are changes in development then rebase the hotfix and then merge

Few rules that worked for us..

● Never pull on one branch from another. In order to get those changes,

we do a rebase.

● Delete the feature branches, release branches and hotfix branches

once they are merged into the desired branch/es

● Never commit again on a branch which has already been merged into

the destination branch.

● Use feature branch names like ticket numbers, they help in quickly

identifying the purpose of the branch.

Must read..

http://nvie.com/posts/a-successful-git-branching-model/

Questions