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.
Key Features
Included components
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).
Continuous Integration
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)
Upgrades
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.
Authentication
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-in-one Integration
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.
Deployment
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.
Lightweight deployment
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.
Externalize components
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
Going further
Trying it out
We currently run a version of Software Factory here (Use your github account to connect).
The code is also replicated to github (another cool feature of Software Factory !) here.
Learning about it
Documentation can be browsed here.
Contributing
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 !
