phase1/master.cfg

   1 # -*- python -*-
   2 # ex: set syntax=python:
   3
   4 import os
   5 import re
   6 import subprocess
   7 import ConfigParser
   8
   9 from buildbot import locks
  10
  11 # This is a sample buildmaster config file. It must be installed as
  12 # 'master.cfg' in your buildmaster's base directory.
  13
  14 ini = ConfigParser.ConfigParser()
  15 ini.read("./config.ini")
  16
  17 # This is the dictionary that the buildmaster pays attention to. We also use
  18 # a shorter alias to save typing.
  19 c = BuildmasterConfig = {}
  20
  21 ####### BUILDSLAVES
  22
  23 # The 'slaves' list defines the set of recognized buildslaves. Each element is
  24 # a BuildSlave object, specifying a unique slave name and password.  The same
  25 # slave name and password must be configured on the slave.
  26 from buildbot.buildslave import BuildSlave
  27
  28 slave_port = 9989
  29
  30 if ini.has_option("general", "port"):
  31         slave_port = ini.getint("general", "port")
  32
  33 c['slaves'] = []
  34 max_builds = dict()
  35
  36 for section in ini.sections():
  37         if section.startswith("slave "):
  38                 if ini.has_option(section, "name") and ini.has_option(section, "password"):
  39                         name = ini.get(section, "name")
  40                         password = ini.get(section, "password")
  41                         max_builds[name] = 1
  42                         if ini.has_option(section, "builds"):
  43                                 max_builds[name] = ini.getint(section, "builds")
  44                         c['slaves'].append(BuildSlave(name, password, max_builds = max_builds[name]))
  45
  46 # 'slavePortnum' defines the TCP port to listen on for connections from slaves.
  47 # This must match the value configured into the buildslaves (with their
  48 # --master option)
  49 c['slavePortnum'] = slave_port
  50
  51 # coalesce builds
  52 c['mergeRequests'] = True
  53
  54 ####### CHANGESOURCES
  55
  56 home_dir = os.path.abspath(ini.get("general", "homedir"))
  57 tree_expire = 0
  58 other_builds = 0
  59
  60 if ini.has_option("general", "expire"):
  61         tree_expire = ini.getint("general", "expire")
  62
  63 if ini.has_option("general", "other_builds"):
  64         other_builds = ini.getint("general", "other_builds")
  65
  66 repo_url = ini.get("repo", "url")
  67 repo_branch = "master"
  68
  69 if ini.has_option("repo", "branch"):
  70         repo_branch = ini.get("repo", "branch")
  71
  72 rsync_bin_url = ini.get("rsync", "binary_url")
  73 rsync_bin_key = ini.get("rsync", "binary_password")
  74
  75 rsync_src_url = None
  76 rsync_src_key = None
  77
  78 if ini.has_option("rsync", "source_url"):
  79         rsync_src_url = ini.get("rsync", "source_url")
  80         rsync_src_key = ini.get("rsync", "source_password")
  81
  82 gpg_home = "~/.gnupg"
  83 gpg_keyid = None
  84 gpg_comment = "Unattended build signature"
  85 gpg_passfile = "/dev/null"
  86
  87 if ini.has_option("gpg", "home"):
  88         gpg_home = ini.get("gpg", "home")
  89
  90 if ini.has_option("gpg", "keyid"):
  91         gpg_keyid = ini.get("gpg", "keyid")
  92
  93 if ini.has_option("gpg", "comment"):
  94         gpg_comment = ini.get("gpg", "comment")
  95
  96 if ini.has_option("gpg", "passfile"):
  97         gpg_passfile = ini.get("gpg", "passfile")
  98
  99
 100 # find targets
 101 targets = [ ]
 102
 103 if not os.path.isdir(home_dir+'/source.git'):
 104         subprocess.call(["git", "clone", "--depth=1", "--branch="+repo_branch, repo_url, home_dir+'/source.git'])
 105 else:
 106         subprocess.call(["git", "pull"], cwd = home_dir+'/source.git')
 107
 108 findtargets = subprocess.Popen([home_dir+'/dumpinfo.pl', 'targets'],
 109         stdout = subprocess.PIPE, cwd = home_dir+'/source.git')
 110
 111 while True:
 112         line = findtargets.stdout.readline()
 113         if not line:
 114                 break
 115         ta = line.strip().split(' ')
 116         targets.append(ta[0])
 117
 118
 119 # the 'change_source' setting tells the buildmaster how it should find out
 120 # about source code changes.  Here we point to the buildbot clone of pyflakes.
 121
 122 from buildbot.changes.gitpoller import GitPoller
 123 c['change_source'] = []
 124 c['change_source'].append(GitPoller(
 125         repo_url,
 126         workdir=home_dir+'/work.git', branch=repo_branch,
 127         pollinterval=300))
 128
 129 ####### SCHEDULERS
 130
 131 # Configure the Schedulers, which decide how to react to incoming changes.  In this
 132 # case, just kick off a 'basebuild' build
 133
 134 from buildbot.schedulers.basic import SingleBranchScheduler
 135 from buildbot.schedulers.forcesched import ForceScheduler
 136 from buildbot.changes import filter
 137 c['schedulers'] = []
 138 c['schedulers'].append(SingleBranchScheduler(
 139         name="all",
 140         change_filter=filter.ChangeFilter(branch=repo_branch),
 141         treeStableTimer=60,
 142         builderNames=targets))
 143
 144 c['schedulers'].append(ForceScheduler(
 145         name="force",
 146         builderNames=targets))
 147
 148 ####### BUILDERS
 149
 150 # The 'builders' list defines the Builders, which tell Buildbot how to perform a build:
 151 # what steps, and which slaves can execute them.  Note that any particular build will
 152 # only take place on one slave.
 153
 154 from buildbot.process.factory import BuildFactory
 155 from buildbot.steps.source.git import Git
 156 from buildbot.steps.shell import ShellCommand
 157 from buildbot.steps.shell import SetProperty
 158 from buildbot.steps.transfer import FileUpload
 159 from buildbot.steps.transfer import FileDownload
 160 from buildbot.steps.master import MasterShellCommand
 161 from buildbot.process.properties import WithProperties
 162
 163
 164 CleanTargetMap = [
 165         [ "tools",      "tools/clean"                   ],
 166         [ "chain",      "toolchain/clean"               ],
 167         [ "linux",      "target/linux/clean"    ],
 168         [ "dir",        "dirclean"                              ],
 169         [ "dist",       "distclean"                             ]
 170 ]
 171
 172 def IsCleanRequested(pattern):
 173         def CheckCleanProperty(step):
 174                 val = step.getProperty("clean")
 175                 if val and re.match(pattern, val):
 176                         return True
 177                 else:
 178                         return False
 179
 180         return CheckCleanProperty
 181
 182 def IsTaggingRequested(step):
 183         val = step.getProperty("tag")
 184         if val and re.match("^[0-9]+\.[0-9]+\.[0-9]+$", val):
 185                 return True
 186         else:
 187                 return False
 188
 189 def IsNoTaggingRequested(step):
 190         return not IsTaggingRequested(step)
 191
 192 def IsNoMasterBuild(step):
 193         return repo_branch != "master"
 194
 195 def GetBaseVersion(props):
 196         if re.match("^[^-]+-[0-9]+\.[0-9]+$", repo_branch):
 197                 return repo_branch.split('-')[1]
 198         else:
 199                 return "master"
 200
 201 def GetVersionPrefix(props):
 202         basever = GetBaseVersion(props)
 203         if props.hasProperty("tag") and re.match("^[0-9]+\.[0-9]+\.[0-9]+$", props["tag"]):
 204                 return "%s/" % props["tag"]
 205         elif basever != "master":
 206                 return "%s-SNAPSHOT/" % basever
 207         else:
 208                 return ""
 209
 210 def GetNumJobs(props):
 211         if props.hasProperty("slavename") and props.hasProperty("nproc"):
 212                 return ((int(props["nproc"]) / (max_builds[props["slavename"]] + other_builds)) + 1)
 213         else:
 214                 return 1
 215
 216
 217 c['builders'] = []
 218
 219 dlLock = locks.SlaveLock("slave_dl")
 220 tagLock = locks.MasterLock("make_tag")
 221
 222 checkBuiltin = re.sub('[\t\n ]+', ' ', """
 223         checkBuiltin() {
 224                 local symbol op path file;
 225                 for file in $CHANGED_FILES; do
 226                         case "$file" in
 227                                 package/*/*) : ;;
 228                                 *) return 0 ;;
 229                         esac;
 230                 done;
 231                 while read symbol op path; do
 232                         case "$symbol" in package-*)
 233                                 symbol="${symbol##*(}";
 234                                 symbol="${symbol%)}";
 235                                 for file in $CHANGED_FILES; do
 236                                         case "$file" in "package/$path/"*)
 237                                                 grep -qsx "$symbol=y" .config && return 0
 238                                         ;; esac;
 239                                 done;
 240                         esac;
 241                 done < tmp/.packagedeps;
 242                 return 1;
 243         }
 244 """).strip()
 245
 246
 247 class IfBuiltinShellCommand(ShellCommand):
 248         def _quote(self, str):
 249                 if re.search("[^a-zA-Z0-9/_.-]", str):
 250                         return "'%s'" %(re.sub("'", "'\"'\"'", str))
 251                 return str
 252
 253         def setCommand(self, command):
 254                 if not isinstance(command, (str, unicode)):
 255                         command = ' '.join(map(self._quote, command))
 256                 self.command = [
 257                         '/bin/sh', '-c',
 258                         '%s; if checkBuiltin; then %s; else exit 0; fi' %(checkBuiltin, command)
 259                 ]
 260
 261         def setupEnvironment(self, cmd):
 262                 slaveEnv = self.slaveEnvironment
 263                 if slaveEnv is None:
 264                         slaveEnv = { }
 265                 changedFiles = { }
 266                 for request in self.build.requests:
 267                         for source in request.sources:
 268                                 for change in source.changes:
 269                                         for file in change.files:
 270                                                 changedFiles[file] = True
 271                 fullSlaveEnv = slaveEnv.copy()
 272                 fullSlaveEnv['CHANGED_FILES'] = ' '.join(changedFiles.keys())
 273                 cmd.args['env'] = fullSlaveEnv
 274
 275 slaveNames = [ ]
 276
 277 for slave in c['slaves']:
 278         slaveNames.append(slave.slavename)
 279
 280 for target in targets:
 281         ts = target.split('/')
 282
 283         factory = BuildFactory()
 284
 285         # find number of cores
 286         factory.addStep(SetProperty(
 287                 name = "nproc",
 288                 property = "nproc",
 289                 description = "Finding number of CPUs",
 290                 command = ["nproc"]))
 291
 292         # expire tree if needed
 293         if tree_expire > 0:
 294                 factory.addStep(FileDownload(
 295                         mastersrc = "expire.sh",
 296                         slavedest = "../expire.sh",
 297                         mode = 0755))
 298
 299                 factory.addStep(ShellCommand(
 300                         name = "expire",
 301                         description = "Checking for build tree expiry",
 302                         command = ["./expire.sh", str(tree_expire)],
 303                         workdir = ".",
 304                         haltOnFailure = True,
 305                         timeout = 2400))
 306
 307         # user-requested clean targets
 308         for tuple in CleanTargetMap:
 309                 factory.addStep(ShellCommand(
 310                         name = tuple[1],
 311                         description = 'User-requested "make %s"' % tuple[1],
 312                         command = ["make", tuple[1], "V=s"],
 313                         doStepIf = IsCleanRequested(tuple[0])
 314                 ))
 315
 316         factory.addStep(MasterShellCommand(
 317                 name = "maketag",
 318                 description = "Tagging Git repository",
 319                 command = [home_dir+'/maketag.sh', '-i', '-k', str(gpg_keyid or ''),
 320                            '-p', str(gpg_passfile or ''), '-v', WithProperties("%(tag:-)s")],
 321                 path = home_dir+'/source.git',
 322                 env = {'GNUPGHOME': gpg_home},
 323                 haltOnFailure = True,
 324                 doStepIf = IsTaggingRequested,
 325                 locks = [tagLock.access('exclusive')]
 326         ))
 327
 328         # switch to branch
 329         factory.addStep(ShellCommand(
 330                 name = "switchbranch",
 331                 description = "Checking out Git branch",
 332                 command = "if [ -d .git ]; then git checkout '%s'; else exit 0; fi" % repo_branch,
 333                 haltOnFailure = True,
 334                 doStepIf = IsNoTaggingRequested
 335         ))
 336
 337         # check out the source
 338         factory.addStep(Git(
 339                 repourl = repo_url,
 340                 branch = repo_branch,
 341                 mode = 'incremental',
 342                 method = 'clean'))
 343
 344         # update remote refs
 345         factory.addStep(ShellCommand(
 346                 name = "fetchrefs",
 347                 description = "Fetching Git remote refs",
 348                 command = ["git", "fetch", "origin", "+refs/heads/%s:refs/remotes/origin/%s" %(repo_branch, repo_branch)],
 349                 haltOnFailure = True
 350         ))
 351
 352         # fetch tags
 353         factory.addStep(ShellCommand(
 354                 name = "fetchtag",
 355                 description = "Fetching Git tags",
 356                 command = ["git", "fetch", "--tags", "--", repo_url],
 357                 haltOnFailure = True,
 358                 doStepIf = IsTaggingRequested
 359         ))
 360
 361         # switch to tag
 362         factory.addStep(ShellCommand(
 363                 name = "switchtag",
 364                 description = "Checking out Git tag",
 365                 command = ["git", "checkout", WithProperties("tags/v%(tag:-)s")],
 366                 haltOnFailure = True,
 367                 doStepIf = IsTaggingRequested
 368         ))
 369
 370         factory.addStep(ShellCommand(
 371                 name = "rmtmp",
 372                 description = "Remove tmp folder",
 373                 command=["rm", "-rf", "tmp/"]))
 374
 375         # feed
 376 #       factory.addStep(ShellCommand(
 377 #               name = "feedsconf",
 378 #               description = "Copy the feeds.conf",
 379 #               command='''cp ~/feeds.conf ./feeds.conf''' ))
 380
 381         # feed
 382         factory.addStep(ShellCommand(
 383                 name = "rmfeedlinks",
 384                 description = "Remove feed symlinks",
 385                 command=["rm", "-rf", "package/feeds/"]))
 386
 387         # feed
 388         factory.addStep(ShellCommand(
 389                 name = "updatefeeds",
 390                 description = "Updating feeds",
 391                 command=["./scripts/feeds", "update"]))
 392
 393         # feed
 394         factory.addStep(ShellCommand(
 395                 name = "installfeeds",
 396                 description = "Installing feeds",
 397                 command=["./scripts/feeds", "install", "-a"]))
 398
 399         # seed config
 400         factory.addStep(FileDownload(
 401                 mastersrc = "config.seed",
 402                 slavedest = ".config",
 403                 mode = 0644
 404         ))
 405
 406         # configure
 407         factory.addStep(ShellCommand(
 408                 name = "newconfig",
 409                 description = "Seeding .config",
 410                 command = "printf 'CONFIG_TARGET_%s=y\\nCONFIG_TARGET_%s_%s=y\\n' >> .config" %(ts[0], ts[0], ts[1])
 411         ))
 412
 413         factory.addStep(ShellCommand(
 414                 name = "delbin",
 415                 description = "Removing output directory",
 416                 command = ["rm", "-rf", "bin/"]
 417         ))
 418
 419         factory.addStep(ShellCommand(
 420                 name = "defconfig",
 421                 description = "Populating .config",
 422                 command = ["make", "defconfig"]
 423         ))
 424
 425         # check arch
 426         factory.addStep(ShellCommand(
 427                 name = "checkarch",
 428                 description = "Checking architecture",
 429                 command = ["grep", "-sq", "CONFIG_TARGET_%s=y" %(ts[0]), ".config"],
 430                 logEnviron = False,
 431                 want_stdout = False,
 432                 want_stderr = False,
 433                 haltOnFailure = True
 434         ))
 435
 436         # find libc suffix
 437         factory.addStep(SetProperty(
 438                 name = "libc",
 439                 property = "libc",
 440                 description = "Finding libc suffix",
 441                 command = ["sed", "-ne", '/^CONFIG_LIBC=/ { s!^CONFIG_LIBC="\\(.*\\)"!\\1!; s!^musl$!!; s!.\\+!-&!p }', ".config"]))
 442
 443         # install build key
 444         factory.addStep(FileDownload(mastersrc=home_dir+'/key-build', slavedest="key-build", mode=0600))
 445         factory.addStep(FileDownload(mastersrc=home_dir+'/key-build.pub', slavedest="key-build.pub", mode=0600))
 446
 447         # prepare dl
 448         factory.addStep(ShellCommand(
 449                 name = "dldir",
 450                 description = "Preparing dl/",
 451                 command = "mkdir -p $HOME/dl && rm -rf ./dl && ln -sf $HOME/dl ./dl",
 452                 logEnviron = False,
 453                 want_stdout = False
 454         ))
 455
 456         # prepare tar
 457         factory.addStep(ShellCommand(
 458                 name = "dltar",
 459                 description = "Building GNU tar",
 460                 command = ["make", WithProperties("-j%(jobs)d", jobs=GetNumJobs), "tools/tar/install", "V=s"],
 461                 haltOnFailure = True
 462         ))
 463
 464         # populate dl
 465         factory.addStep(ShellCommand(
 466                 name = "dlrun",
 467                 description = "Populating dl/",
 468                 command = ["make", WithProperties("-j%(jobs)d", jobs=GetNumJobs), "download", "V=s"],
 469                 logEnviron = False,
 470                 locks = [dlLock.access('exclusive')]
 471         ))
 472
 473         factory.addStep(ShellCommand(
 474                 name = "cleanbase",
 475                 description = "Cleaning base-files",
 476                 command=["make", "package/base-files/clean", "V=s"]
 477         ))
 478
 479         # build
 480         factory.addStep(ShellCommand(
 481                 name = "tools",
 482                 description = "Building tools",
 483                 command = ["make", WithProperties("-j%(jobs)d", jobs=GetNumJobs), "tools/install", "V=s"],
 484                 haltOnFailure = True
 485         ))
 486
 487         factory.addStep(ShellCommand(
 488                 name = "toolchain",
 489                 description = "Building toolchain",
 490                 command=["make", WithProperties("-j%(jobs)d", jobs=GetNumJobs), "toolchain/install", "V=s"],
 491                 haltOnFailure = True
 492         ))
 493
 494         factory.addStep(ShellCommand(
 495                 name = "kmods",
 496                 description = "Building kmods",
 497                 command=["make", WithProperties("-j%(jobs)d", jobs=GetNumJobs), "target/compile", "V=s", "IGNORE_ERRORS=n m", "BUILD_LOG=1"],
 498                 #env={'BUILD_LOG_DIR': 'bin/%s' %(ts[0])},
 499                 haltOnFailure = True
 500         ))
 501
 502         factory.addStep(ShellCommand(
 503                 name = "pkgbuild",
 504                 description = "Building packages",
 505                 command=["make", WithProperties("-j%(jobs)d", jobs=GetNumJobs), "package/compile", "V=s", "IGNORE_ERRORS=n m", "BUILD_LOG=1"],
 506                 #env={'BUILD_LOG_DIR': 'bin/%s' %(ts[0])},
 507                 haltOnFailure = True
 508         ))
 509
 510         # factory.addStep(IfBuiltinShellCommand(
 511         factory.addStep(ShellCommand(
 512                 name = "pkginstall",
 513                 description = "Installing packages",
 514                 command=["make", WithProperties("-j%(jobs)d", jobs=GetNumJobs), "package/install", "V=s"],
 515                 haltOnFailure = True
 516         ))
 517
 518         factory.addStep(ShellCommand(
 519                 name = "pkgindex",
 520                 description = "Indexing packages",
 521                 command=["make", WithProperties("-j%(jobs)d", jobs=GetNumJobs), "package/index", "V=s"],
 522                 haltOnFailure = True
 523         ))
 524
 525         #factory.addStep(IfBuiltinShellCommand(
 526         factory.addStep(ShellCommand(
 527                 name = "images",
 528                 description = "Building images",
 529                 command=["make", WithProperties("-j%(jobs)d", jobs=GetNumJobs), "target/install", "V=s"],
 530                 haltOnFailure = True
 531         ))
 532
 533         factory.addStep(ShellCommand(
 534                 name = "diffconfig",
 535                 description = "Generating config.seed",
 536                 command=["make", "-j1", "diffconfig", "V=s"],
 537                 haltOnFailure = True
 538         ))
 539
 540         factory.addStep(ShellCommand(
 541                 name = "checksums",
 542                 description = "Calculating checksums",
 543                 command=["make", "-j1", "checksum", "V=s"],
 544                 haltOnFailure = True
 545         ))
 546
 547         # sign
 548         if gpg_keyid is not None:
 549                 factory.addStep(MasterShellCommand(
 550                         name = "signprepare",
 551                         description = "Preparing temporary signing directory",
 552                         command = ["mkdir", "-p", "%s/signing" %(home_dir)],
 553                         haltOnFailure = True
 554                 ))
 555
 556                 factory.addStep(ShellCommand(
 557                         name = "signpack",
 558                         description = "Packing files to sign",
 559                         command = WithProperties("find bin/targets/%s/%s%%(libc)s/ -mindepth 1 -maxdepth 2 -type f -name sha256sums -print0 -or -name Packages -print0 | xargs -0 tar -czf sign.tar.gz" %(ts[0], ts[1])),
 560                         haltOnFailure = True
 561                 ))
 562
 563                 factory.addStep(FileUpload(
 564                         slavesrc = "sign.tar.gz",
 565                         masterdest = "%s/signing/%s.%s.tar.gz" %(home_dir, ts[0], ts[1]),
 566                         haltOnFailure = True
 567                 ))
 568
 569                 factory.addStep(MasterShellCommand(
 570                         name = "signfiles",
 571                         description = "Signing files",
 572                         command = ["%s/signall.sh" %(home_dir), "%s/signing/%s.%s.tar.gz" %(home_dir, ts[0], ts[1]), gpg_keyid, gpg_comment],
 573                         env = {'GNUPGHOME': gpg_home, 'PASSFILE': gpg_passfile},
 574                         haltOnFailure = True
 575                 ))
 576
 577                 factory.addStep(FileDownload(
 578                         mastersrc = "%s/signing/%s.%s.tar.gz" %(home_dir, ts[0], ts[1]),
 579                         slavedest = "sign.tar.gz",
 580                         haltOnFailure = True
 581                 ))
 582
 583                 factory.addStep(ShellCommand(
 584                         name = "signunpack",
 585                         description = "Unpacking signed files",
 586                         command = ["tar", "-xzf", "sign.tar.gz"],
 587                         haltOnFailure = True
 588                 ))
 589
 590         # upload
 591         factory.addStep(ShellCommand(
 592                 name = "dirprepare",
 593                 description = "Preparing upload directory structure",
 594                 command = ["mkdir", "-p", WithProperties("tmp/upload/%%(prefix)stargets/%s/%s" %(ts[0], ts[1]), prefix=GetVersionPrefix)],
 595                 haltOnFailure = True
 596         ))
 597
 598         factory.addStep(ShellCommand(
 599                 name = "linkprepare",
 600                 description = "Preparing repository symlink",
 601                 command = ["ln", "-s", "-f", WithProperties("../packages-%(basever)s", basever=GetBaseVersion), WithProperties("tmp/upload/%(prefix)spackages", prefix=GetVersionPrefix)],
 602                 doStepIf = IsNoMasterBuild,
 603                 haltOnFailure = True
 604         ))
 605
 606         factory.addStep(ShellCommand(
 607                 name = "dirupload",
 608                 description = "Uploading directory structure",
 609                 command = ["rsync", "-avz", "tmp/upload/", "%s/" %(rsync_bin_url)],
 610                 env={'RSYNC_PASSWORD': rsync_bin_key},
 611                 haltOnFailure = True,
 612                 logEnviron = False
 613         ))
 614
 615         factory.addStep(ShellCommand(
 616                 name = "targetupload",
 617                 description = "Uploading target files",
 618                 command=["rsync", "--delete", "--checksum", "--delay-updates", "--partial-dir=.~tmp~%s~%s" %(ts[0], ts[1]),
 619                          "-avz", WithProperties("bin/targets/%s/%s%%(libc)s/" %(ts[0], ts[1])),
 620                          WithProperties("%s/%%(prefix)stargets/%s/%s/" %(rsync_bin_url, ts[0], ts[1]), prefix=GetVersionPrefix)],
 621                 env={'RSYNC_PASSWORD': rsync_bin_key},
 622                 haltOnFailure = True,
 623                 logEnviron = False
 624         ))
 625
 626         if rsync_src_url is not None:
 627                 factory.addStep(ShellCommand(
 628                         name = "sourceupload",
 629                         description = "Uploading source archives",
 630                         command=["rsync", "--checksum", "--delay-updates", "--partial-dir=.~tmp~%s~%s" %(ts[0], ts[1]), "-avz", "dl/", "%s/" %(rsync_src_url)],
 631                         env={'RSYNC_PASSWORD': rsync_src_key},
 632                         haltOnFailure = True,
 633                         logEnviron = False
 634                 ))
 635
 636         if False:
 637                 factory.addStep(ShellCommand(
 638                         name = "packageupload",
 639                         description = "Uploading package files",
 640                         command=["rsync", "--delete", "--delay-updates", "--partial-dir=.~tmp~%s~%s" %(ts[0], ts[1]), "-avz", "bin/packages/", "%s/packages/" %(rsync_bin_url)],
 641                         env={'RSYNC_PASSWORD': rsync_bin_key},
 642                         haltOnFailure = False,
 643                         logEnviron = False
 644                 ))
 645
 646         # logs
 647         if False:
 648                 factory.addStep(ShellCommand(
 649                         name = "upload",
 650                         description = "Uploading logs",
 651                         command=["rsync", "--delete", "--delay-updates", "--partial-dir=.~tmp~%s~%s" %(ts[0], ts[1]), "-avz", "logs/", "%s/logs/%s/%s/" %(rsync_bin_url, ts[0], ts[1])],
 652                         env={'RSYNC_PASSWORD': rsync_bin_key},
 653                         haltOnFailure = False,
 654                         alwaysRun = True,
 655                         logEnviron = False
 656                 ))
 657
 658         from buildbot.config import BuilderConfig
 659
 660         c['builders'].append(BuilderConfig(name=target, slavenames=slaveNames, factory=factory))
 661
 662
 663 ####### STATUS TARGETS
 664
 665 # 'status' is a list of Status Targets. The results of each build will be
 666 # pushed to these targets. buildbot/status/*.py has a variety to choose from,
 667 # including web pages, email senders, and IRC bots.
 668
 669 c['status'] = []
 670
 671 from buildbot.status import html
 672 from buildbot.status.web import authz, auth
 673
 674 if ini.has_option("status", "bind"):
 675         if ini.has_option("status", "user") and ini.has_option("status", "password"):
 676                 authz_cfg=authz.Authz(
 677                         # change any of these to True to enable; see the manual for more
 678                         # options
 679                         auth=auth.BasicAuth([(ini.get("status", "user"), ini.get("status", "password"))]),
 680                         gracefulShutdown = 'auth',
 681                         forceBuild = 'auth', # use this to test your slave once it is set up
 682                         forceAllBuilds = 'auth',
 683                         pingBuilder = False,
 684                         stopBuild = 'auth',
 685                         stopAllBuilds = 'auth',
 686                         cancelPendingBuild = 'auth',
 687                 )
 688                 c['status'].append(html.WebStatus(http_port=ini.get("status", "bind"), authz=authz_cfg))
 689         else:
 690                 c['status'].append(html.WebStatus(http_port=ini.get("status", "bind")))
 691
 692
 693 from buildbot.status import words
 694
 695 if ini.has_option("irc", "host") and ini.has_option("irc", "nickname") and ini.has_option("irc", "channel"):
 696         irc_host = ini.get("irc", "host")
 697         irc_port = 6667
 698         irc_chan = ini.get("irc", "channel")
 699         irc_nick = ini.get("irc", "nickname")
 700         irc_pass = None
 701
 702         if ini.has_option("irc", "port"):
 703                 irc_port = ini.getint("irc", "port")
 704
 705         if ini.has_option("irc", "password"):
 706                 irc_pass = ini.get("irc", "password")
 707
 708         irc = words.IRC(irc_host, irc_nick, port = irc_port, password = irc_pass,
 709                         channels = [{ "channel": irc_chan }],
 710                         notify_events = {
 711                           'exception': 1,
 712                           'successToFailure': 1,
 713                           'failureToSuccess': 1
 714                         }
 715         )
 716
 717         c['status'].append(irc)
 718
 719
 720 ####### PROJECT IDENTITY
 721
 722 # the 'title' string will appear at the top of this buildbot
 723 # installation's html.WebStatus home page (linked to the
 724 # 'titleURL') and is embedded in the title of the waterfall HTML page.
 725
 726 c['title'] = ini.get("general", "title")
 727 c['titleURL'] = ini.get("general", "title_url")
 728
 729 # the 'buildbotURL' string should point to the location where the buildbot's
 730 # internal web server (usually the html.WebStatus page) is visible. This
 731 # typically uses the port number set in the Waterfall 'status' entry, but
 732 # with an externally-visible host name which the buildbot cannot figure out
 733 # without some help.
 734
 735 c['buildbotURL'] = ini.get("general", "buildbot_url")
 736
 737 ####### DB URL
 738
 739 c['db'] = {
 740         # This specifies what database buildbot uses to store its state.  You can leave
 741         # this at its default for all but the largest installations.
 742         'db_url' : "sqlite:///state.sqlite",
 743 }