cloudstack-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Rohit Yadav <>
Subject Re: Code quality, QA, etc
Date Sat, 08 Feb 2014 06:19:13 GMT
On Fri, Feb 7, 2014 at 2:16 PM, Hugo Trippaers <> wrote:
> Hey David,
> I would make a distinction between code issues and functional issues. Occasionally somebody
just plainly breaks the build, i'm guilty of that myself actually, and thats just plain stupid.
Luckily we have Jenkins to catch these errors quickly. I'm in a continuous struggle with Jenkins
to get the build time to less than 5 minutes. I feel that is an acceptable time to get feedback
on a commit, any longer and you have moved on to the next thing or gone home.

Why not do incremental builds, since last build on a git SHA to speed
up by cheating?

May I share a hack I use based on an old method once shared by Edison
to do a fast builds locally:

1. If you just clone cloudstack, build once this will probably take a
lot of time, also to get deps and whatnot

2. Start making changes and build only projects/modules that got
changed using: (you make create a shell function that wraps this in
your bashrc or zshrc etc)

mvn -pl `git status --porcelain |sed -n '/\/src/p'| awk '{print $2}'
|sed 's/\/src/$/'|cut -d $ -f 1|uniq |tr "\n" "," |sed
's/,$/,client/'` clean install

3. Commit often on your branch after build works and when you're
implemented your stuff do a squash merge on master (or target branch)
which results in a single (reviewable) commit. This probably will save
you from breaking builds.

> Also this kind of testing isn't really hard, run the build and unit tests. By introducing
something like gerrit we can actually make this happen before committing it to the repo. Push
a patch to gerrit, gerrit tells jenkins to test the patch, if +1 from jerkins commit, for
non committers the step would be to invite somebody for review as well. Second nice thing
about jenkins is the post-review test, if a contributor submits a patch its build by jenkins,
if a reviewes approves the patch, jerkins will again run a build to ensure that the patch
will still apply and doesn't break the build. Very handy if there is some time between patch
submission and patch review.


I think it's a culture issue, while we may think that introducing and
forcing everyone to go through code reviewing process will slow
everyone down IMHO over time this will inculcate the habit in everyone
to do code reviews for others (their patches/branches etc.) so others
would do for them. It can fail in case there are not enough reviewers
available for a code review or they lack interest/time (our state with

So, the trick could be to have, in addition of the reviewers, few
assigned maintainers who are responsible for churning out pending
reviews in parts of the codebase they understand very well and can
help with reviews process.

> Functional issues are much harder to track. For example yesterday i found several issues
in the contrail plugin that would not cause any pain in a contrail environment, but any other
environments creating a network would fail. These examples are too common and difficult to
catch with unit tests. It can be done, but requires some serious effort on the developers
side and we in general don't seem to be very active at writing unit tests. These kind of issues
can only be found by actually running CloudStack and executing a series of functional tests.
Ideally that is what we have the BVT suite for, but i think our current BVT setup is not documented
enough to give accurate feedback to a developer about which patch broke a certain piece of
functionality. In jenkins the path from code to BVT is not kept yet, so it is almost impossible
to see which commits were new in a particular run of the bvt suite.
> Personally i'm trying to get into the habit of running a series of tests on devcloud
before committing something. Doesn't prove a lot, but does guarantee that the bare basic developer
functionality is working before committing something. After a commit at least i'm sure that
anybody will be able to spinup devcloud and deploy an instance. I'm trying to get this automated
as well so we can use this as feedback on a patch. Beers for anyone who writes an easy to
use script that configures devcloud with a zone and tests if a user vm can be instantiated
on an isolated sourcenat network. If we could include such a script in the tree it might help
people with testing their patch before committing.

I once discussed an idea that we use something fast to do the testing,
so instead of vms or nested vms we can use a mocked hypervisor
(simulator) or LXC container on a VM locally. But again, in every case
they will be just passing very small set of test cases.


> I think we are seeing more and more reverts in the tree. Not necessarily a good thing,
but at least people know that there is that option if a commit really breaks a build. Also
please help each other out, everybody can make a mistake and commit it. If its a trivial mistake
it might not be much effort to track it down and fix it, which is way better than a revert
or a mail that something is broken.
> In short, we need to make testing more efficient and transparent to allow people to easily
incorporate it in their personal workflow.
> Cheers,
> Hugo
> On 7 feb. 2014, at 04:50, David Nalley <> wrote:
>> Hi folks,
>> We continue to break things large and small in the codebase, and after
>> a number of different conversations; I thought I'd bring that
>> discussion here.
>> First - coding quality is only one factor that the PMC considers when
>> making someone a committer.
>> Second - CloudStack is a huge codebase; has a ton of inter-related
>> pieces, and unintended consequences are easy.
>> We also have an pretty heady commit velocity - 20+ commits today alone.
>> Some communities have Review-then-commit - which would slow us down,
>> and presumably help us increase quality. However, I am not personally
>> convinced that it will do so measurably because even the most
>> experienced CloudStack developers occasionally break a build or worse.
>> We could have an automated pipeline that verifies a number of
>> different tests pass - before a patch/commit makes it into a mainline
>> branch. That is difficult with our current tooling; but perhaps
>> something worth considering.
>> At FOSDEM, Hugo and I were discussing his experiences with Gerrit and
>> OpenDaylight, and he thinks thats a viable option. I think it would
>> certainly be a step in the right direction.
>> Separately, Jake Farrell and I were discussing our git-related
>> proposal for ApacheCon, and broached the subject of Gerrit. Jake is
>> the current person bearing most of the load for git at the ASF, and
>> he's also run Gerrit in other contexts. He points out a number of
>> difficulties. (And I'd love for him to weigh in on this conversation,
>> hence the CC) He wants to expand RB significantly, including
>> pre-commit testing.
>> So - thoughts, comments, flames? How do we improve code quality, stop
>> needless breakage? Much of this is going to be cultural I think, and I
>> personally think we struggle with that. Many folks have voiced an
>> opinion about stopping continued commits when the build is broken; but
>> we haven't been able to do that.
>> --David

View raw message