So based on my passion as open source developer in particular for the Apache Maven Project. I work JIRA based which helps us and myself to organize our work and of course follow the reported issues, feature request etc.
So usually I start my work based on a particular issue in JIRA and go via the following process:
- Create an issue for myself (if already existing move to step 2)
- Create a branch within the appropriate project based on the issue
- Assign the issue to myself
- Migrate the issue into the state of
- Do some work on the branch and commit
- Push the branch to remote and let Jenkins check the branch repeat with Step 5 until I finished my work.
- Rebase against master if needed
- Merge the created branch into master and delete the remote and local branch.
- Close the appropriate jira issue with a reference to the commit in comment.
Let us take a look at a real life example. The exemplary issue is MCLEAN-87 which has been worked on and commited with an appropriate commit message which should look like the following:
So the real life commit looks like this:
1 2 3 4 5
If you take a look at the list of process steps, it is a huge number of steps. Unfortunately many of the steps are manual steps which is time consuming and error-prone.
So about four or five months ago I started to automate/simplifying some steps of the above process.
Automation Step 1
In process step 6 while I was working on a branch
I have to push the current state of the branch over and over again
to remote and let Jenkins check if everything is going fine.
Furthermore it could be that I need to rebase this branch
against master which has to be followed by a
git push --force BRANCH
--force is very dangerous which means I have to use
git push --force-with-lease BRANCH instead. I already have a bash
completion for git running which safes a lot of typing but I would
like to make it more comfortable.
So I started to write a bash script which comprises of the following steps:
- Check if we are on a branch just to be sure.
- Get the branch name
git push origin --force-with-lease BRANCH
So this means in the end I simply call the script:
The first step of automation accomplished which means a little bit improvement but not enough.
Automation Step 2
So after a time working with that I thought about process step 8 wich is really much typing and error-prone. Let me summarize the steps:
- check if we are on a branch
- get the branch name
- checkout master
- merge the branch only if a fast forward is possible fail otherwise
- push changes to remote master
- delete the remote branch
- delete the local branch
The result was my gitmergeandclean.sh script which I use like the following:
The output looks like this:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
The second step of automation accomplished which means more improvement but not enough.
Automation Step 3
If I work on a branch I often do several commits on it until I think I am done. The result is a branch which contains 5, 6 or more commits which should be squashed into a single commit with a good commit message and a reference to the issue I am working on.
This can be done manually and interactive via the following steps:
- Count the number of commits you would like to squash
- git rebase -i HEAD~NUMBEROFCOMMIT
- Going through the editor and replace
- Safe and rewrite the commit message.
(I assume I have missed something). So this was really cumbersome. So I decided to find a scripted way to handle that. After some experiments I found a solution which results in my gitrebasebranch.sh script
and in the editor I only rework the commit message. That’s it. After this I can do:
The third step of automation accomplished which means more improvement but not enough.
The story will be continued in my next post.