7

I've set up our continuous integration system, and it has been working for about a year now. We have finally reached a point where we want to do releases using the same. Before our CI system, the process(es) that was used was:

(Develop) -> Ready for release -> Create a branch -> (Build -> Fix bugs as QA finds them) Loop -> Final build -> Tag

(Develop) -> Ready for release -> (build -> fix bugs) Loop -> Tag



Our CI setup:
1 server for development (DEV)
1 server for qa/release (QA)

The second one has integrated into CI perfectly. I create a branch when the software is ready for release, and the branch never changes thereafter, which means the build is reproduceable without having to change the CI job. Any future development takes place on HEAD, and even maintainence releases get a completely new branch and a completely new job, which remains on the CI system forever, and then some.

The first method is harder to adapt. If the branch changes, the build is not reproduceable unless I use the tag to build [jobs on the CI server uses the branch for QA/RELEASE, and HEAD for development builds].

However, if I use the tag to build, I have to create a new CI job to build from the tag (lose changelog on server), or change the existing job (lose original job configuration).

I know this sounds complicated, and if required, I will rewrite/edit to explain the situation better. However, my question:

[If at all] what process does your company use to release software using continuous integration systems. Is it even done using the CI system, or manually?

Sagar
  • 173

3 Answers3

2

We branch on release. I think that's inevitable if you release patches, because patching means going back and updating the release. We also tend to keep coding during the RTM process, which means the shipped release is out of date before it leaves the building. Some of our users skip versions, so right now we have two active versions in the field plus the new version we're working on now. So we have 1.0, 1.1, 2.0, 2.1, 2.2 and soon 3.0 in use (and we get support calls for all of them). Testing the patch/version matrix keeps QA quite busy.

Our process is more like this:

(develop) -> branch to QA -> RTM -> ship -> patch branch ...
          -> keep developing in trunk -> merge patches ...

I'll be interested to see what other options appear.

1

We use the following: (Develop on mainline) -> phase 1 testing -> phase 2 testing -> (Branch from mainline) -> phase 3 testing -> RTM -> Patch on branch

Each build is tagged after the fact. The gold build have a more traditional tag. Development starts working on the next release on the mainline during phase 3 testing.

Arcege
  • 271
1

We build from the tag. The build job is parameterized (the parameter is the name of the tag) so it only needed to be created once.

Jeff Knecht
  • 271