kvm-master.cfg

# -*- python -*-
# ex: set syntax=python:

# ENVIRONMENT: kvm.git

###
# buildermaster config file from buildbot.b1-systems.de
# author: Daniel Gollub <gollub@b1-systems.de>
# author: Christian Berendt <berendt@b1-systems.de>
##
# documentation: see docs/config.xhtml

import sys
sys.path.append('/var/lib/buildbot/kvm')
from database_authority import *

c = BuildmasterConfig = {}

####### PROJECT IDENTITY
c['projectName'] = "kvm"
c['projectURL'] = "http://www.linux-kvm.org/"
c['buildbotURL'] = "http://buildbot.b1-systems.de/kvm/"


####### EMAIL STUFF
emailAddressFrom = "kvm@buildbot.b1-systems.de"
emailAddressesNotify = ["kvm@vger.kernel.org"]

####### BUILDSLAVES

from buildbot.buildslave import BuildSlave
c['slaves'] = database_authority

# max_builds = 2 # limits to two concurrent builds

c['slavePortnum'] = 9991

####### CHANGESOURCES

from buildbot.changes.pb import PBChangeSource
c['change_source'] = PBChangeSource()

####### SCHEDULERS

from buildbot.scheduler import Scheduler, Periodic, Nightly, AnyBranchScheduler


ARCHES = [ "x86_64", "i386", "s390", "ia64", "ppc44x", "ppc64" ];
masterBuilders = ARCHES; 
nigthlyBuilders = [ "next-x86_64", "next-i386", "next-s390", "next-ia64", "next-ppc44x", "next-ppc64" ];
allBuilders = masterBuilders + nigthlyBuilders;

c['schedulers'] = []
c['schedulers'].append(Nightly(name="nightly_master", branch="master",
                       builderNames=masterBuilders,
                       hour=5, minute=3))

c['schedulers'].append(Nightly(name="nightly_next", branch="next",
                       builderNames=nigthlyBuilders,
                       hour=6, minute=3))

c['schedulers'].append(
  AnyBranchScheduler(
    name="continous",
    branches=["master"],
    treeStableTimer=7200,
    builderNames=masterBuilders
  )
)


### try: Scheduler

from buildbot.scheduler import Try_Userpass
try_sched = Try_Userpass(
  "try_command",
  allBuilders,
  port=8033,
  userpass=database_authority_try
)

c['schedulers'].append(try_sched)


####### BUILDERS

# source: http://kogs-www.informatik.uni-hamburg.de/~meine/python_tricks
def flatten(x):
    """flatten(sequence) -> list

    Returns a single, flat list which contains all elements retrieved
    from the sequence and all recursively contained sub-sequences
    (iterables).

    Examples:
    >>> [1, 2, [3,4], (5,6)]
    [1, 2, [3, 4], (5, 6)]
    >>> flatten([[[1,2,3], (42,None)], [4,5], [6], 7, MyVector(8,9,10)])
    [1, 2, 3, 42, None, 4, 5, 6, 7, 8, 9, 10]"""

    result = []
    for el in x:
        #if isinstance(el, (list, tuple)):
        if hasattr(el, "__iter__") and not isinstance(el, basestring):
            result.extend(flatten(el))
        else:
            result.append(el)
    return result


	

from buildbot.process import factory
from buildbot.steps.source import Git
from buildbot.steps import shell
from buildbot.steps.shell import Configure, Compile

def kernelArchFactory(arch):

        f = factory.BuildFactory();


        kernelModules = [];
        kernelOptionsYes = [];
        kernelOptionsNo = [];

	CONFIG = [ "defconfig"];
	ARCH_TOOLCHAIN = ARCH = arch;

        ENV = {'LANG': 'C'};
        
        if arch == 'x86_64' or arch == 'i386':
                kernelModules = [ "KVM", "KVM_AMD", "KVM_INTEL" ];
        elif arch == 's390':
                kernelModules = [ "KVM" ];
                # revert when upgrading to gcc 4.6 or later
                kernelOptionsYes = [ "MARCH_Z10" ];
                kernelOptionsNo = [ "MARCH_Z196" ];
        elif arch == 'ia64':
                kernelModules = [ "KVM", "KVM_INTEL" ];
        elif arch == 'ppc44x':
                kernelModules = [ "VIRTIO_PCI", "VIRTIO_BALOON", "VIRTIO_BLK",
                                "VIRTIO_NET", "VIRTIO_CONSOLE" ];

                kernelOptionsYes = [ "VIRTUALIZATION", "KVM", "KVM_440" ];
                kernelOptionsNo = [ "KVM_E500", "KVM_EXIT_TIMING" ];


		ARCH_TOOLCHAIN = ARCH = "powerpc";
		CONFIG = [ "ppc44x_defconfig" ];
        elif arch == 'ppc64':
                kernelModules = [ "VIRTIO_BALOON", "VIRTIO_BLK",
                                "VIRTIO_NET", "VIRTIO_CONSOLE",
                                "KVM_BOOK3S_64" ];

                kernelOptionsYes = [ "VIRTUALIZATION", "KVM" ];
                kernelOptionsNo = [ "KVM_EXIT_TIMING" ];

		ARCH = "powerpc";
		ARCH_TOOLCHAIN = "powerpc64";
		CONFIG = [ "ppc64_defconfig" ];
        
        options = flatten(map(lambda x: ["--enable", x], kernelOptionsYes) 
                        + map(lambda x: ["--disable", x], kernelOptionsNo)
                        + map(lambda x: ["--module", x], kernelModules))


        MAKE = [ "make", "ARCH=" + ARCH, "CROSS_COMPILE=/opt/gcc-4.5.0-nolibc/"
		+ ARCH_TOOLCHAIN + "-linux/bin/" + ARCH_TOOLCHAIN + "-linux-"];


        """ git checkout """
        f.addStep(Git(repourl="git://git.kernel.org/pub/scm/virt/kvm/kvm.git"))


	""" make scripts
	f.addStep(Configure(command=MAKE + ["scripts"], env=ENV))
	"""

        """ do ARCH default configuration """
        f.addStep(Configure(command=MAKE + CONFIG, env=ENV))

        """ Configure Kernel (.config) """
        f.addStep(Configure(command=["./scripts/config"] + options, env=ENV))

        """ make oldconfig """
        f.addStep(Configure(command=MAKE + ["oldnoconfig"], env=ENV))


        """ make( V=1 ) """
        f.addStep(Compile(command=MAKE, env=ENV))

        return f;


botsAll = ["b1_kvm_1"]

from buildbot.locks import SlaveLock
slow_lock = SlaveLock("cpu")



c['builders'] = []



for arch in ARCHES:
	builder = {'name': arch,
			'slavenames': botsAll,
			'builddir': arch,
			'locks': [slow_lock],
			'factory': kernelArchFactory(arch)
			}

	c['builders'].append(builder);

for arch in ARCHES:
	next_arch = "next-%s" % arch;
        builder = {'name': next_arch,
                        'slavenames': botsAll,
                        'builddir': next_arch,
                        'locks': [slow_lock],
                        'factory': kernelArchFactory(arch)
                        }

        c['builders'].append(builder);




####### STATUS TARGETS

c['status'] = []

from buildbot.status import html
c['status'].append(html.WebStatus("tcp:3020:interface=127.0.0.1"))
#c['status'].append(html.Waterfall("tcp:3021:interface=127.0.0.1"))

from buildbot.status import mail
c['status'].append(mail.MailNotifier(fromaddr=emailAddressFrom,
					mode='problem',
                                      extraRecipients=emailAddressesNotify,
                                      sendToInterestedUsers=False))

####### DEBUGGING OPTIONS

#c['debugPassword'] = "debugpassword"