We are proud to announce the first stable release of Software Factory. We have been operating a deployment that is hosting some projects along SF itself for a long time already. And since the platform has been proven stable enough for us, and consistently upgraded without much outage, it’s a good opportunity to look back at what we built and where we are now.
The Software Factory stack includes the well known Jenkins (job automation) and Gerrit (code review) services as well as Zuul (gating system) and makes them all work together. In addition the stack is composed of Redmine (issue tracker), Lodgeit (pastebin clone) and Etherpad (collaborative text editor).
Software Factory enables continuous integration:
- New changes are proposed for review using Gerrit.
- Zuul triggers a collection of checks and reports the results on the review thread.
- Core developers can review and approve changes.
- Zuul triggers another round of gate checks to make sure the change is still correct before being merged.
The workflow is customizable, e.g.:
- Requirements for a change to be approved (number of core reviewers approvals, …)
- Check and Gate tests
- Post-merge jobs can be configured to be run after a change is merged (for example, upload the current build somewhere)
Software Factory has an upgrade validation mechanism integrated in its development. Each change is going through a series of upgrade tests to make sure the new release does not break a previous instance, and can be upgraded to. This is a result of the Continous Integration of SF developments that allow our team to be confident when doing an upgrade.
All services are unified under a single sign-on mechanism called cauth that you can plug to different authentication sources: login with github and and through an external LDAP are currently supported. Read more about cauth here: http://softwarefactory.enovance.com/docs/intro.html#single-sign-on
All the services are integrated together, using a common top menu and dashboard along a REST interface to do basic actions like create new projects and assign users to specifics group.
Each Software Factory services are isolated and can be deployed either using thin lxc containers, or on top of an Openstack-based infrastructure with a HEAT stack. A set of scripts and configuration files make any deployment very easy and customizable.
What’s next ?
Unified configuration with upstream puppet modules
While brewing our own manifests allowed us to quickly get something up and running on CentOS, we should have re-used upstream configuration modules. We are now looking at merging our work and use an unified set of puppet modules to configure Software Factory.
We have already experimented with extra thin container technologies like Docker and it proves to be a better solution to deploy such infrastructure:
- Faster to build
- Easier to deploy on platforms like openshift or using OpenStack container projects
While this is promising, configuration still remains a challenge at this point.
Some components could live out of the main project to be more easily re-usable:
- cauth is a cool Python SSO solution built on top of Apache
- our provisioning tools to import issues from one tracker to another
- functional tests
Trying it out
Learning about it
Documentation can be browsed here.
Log into http://softwarefactory.enovance.com with your github account, clone the project from gerrit, set up the review process with
git review -s
and start hacking !