invirtibuilder

   1 #!/usr/bin/python
   2
   3 """Process the Invirt build queue.
   4
   5 The Invirtibuilder handles package builds and uploads. On demand, it
   6 attempts to build a particular package.
   7
   8 If the build succeeds, the new version of the package is uploaded to
   9 the apt repository, tagged in its git repository, and the Invirt
  10 superproject is updated to point at the new version.
  11
  12 If the build fails, the Invirtibuilder sends mail with the build log.
  13
  14 The build queue is tracked via files in /var/lib/invirt-dev/queue. In
  15 order to maintain ordering, all filenames in that directory are the
  16 timestamp of their creation time.
  17
  18 Each queue file contains a file of the form
  19
  20     pocket package hash principal
  21
  22 where pocket is one of the pockets globally configured in
  23 build.pockets. For instance, the pockets in XVM are "prod" and "dev".
  24
  25 principal is the Kerberos principal that requested the build.
  26 """
  27
  28
  29 from __future__ import with_statement
  30
  31 import contextlib
  32 import glob
  33 import os
  34 import re
  35 import shutil
  36 import subprocess
  37 import tempfile
  38 import traceback
  39
  40 import pyinotify
  41
  42 from debian_bundle import deb822
  43
  44 import invirt.builder as b
  45 import invirt.common as c
  46 from invirt import database
  47 from invirt.config import structs as config
  48
  49
  50 logfile = None
  51
  52 def logAndRun(cmd, *args, **kwargs):
  53     # Always grab stdout, even if the caller doesn't need it.
  54     # TODO: don't slurp it all into memory in that case.
  55     if 'stdout' in kwargs and kwargs['stdout'] is None:
  56         del kwargs['stdout']
  57     kwargs['stderr'] = logfile
  58     logfile.write('---> Ran %s\n' % (cmd, ))
  59     if 'stdin_str' in kwargs:
  60         logfile.write('STDIN:\n')
  61         logfile.write(kwargs['stdin_str'])
  62     logfile.write('STDERR:\n')
  63     output = c.captureOutput(cmd, *args, **kwargs)
  64     logfile.write('STDOUT:\n')
  65     logfile.write(output)
  66     return output
  67
  68 def getControl(package, ref):
  69     """Get the parsed debian/control file for a given package.
  70
  71     This returns a list of debian_bundle.deb822.Deb822 objects, one
  72     for each section of the debian/control file. Each Deb822 object
  73     acts roughly like a dict.
  74     """
  75     return deb822.Deb822.iter_paragraphs(
  76         b.getGitFile(package, ref, 'debian/control').split('\n'))
  77
  78
  79 def getBinaries(package, ref):
  80     """Get a list of binary packages in a package at a given ref."""
  81     return [p['Package'] for p in getControl(package, ref)
  82             if 'Package' in p]
  83
  84
  85 def getArches(package, ref):
  86     """Get the set of all architectures in any binary package."""
  87     arches = set()
  88     for section in getControl(package, ref):
  89         if 'Architecture' in section:
  90             arches.update(section['Architecture'].split())
  91     return arches
  92
  93
  94 def getDscName(package, ref):
  95     """Return the .dsc file that will be generated for this package."""
  96     v = b.getVersion(package, ref)
  97     if v.debian_version:
  98         v_str = '%s-%s' % (v.upstream_version,
  99                            v.debian_version)
 100     else:
 101         v_str = v.upstream_version
 102     return '%s_%s.dsc' % (
 103         package,
 104         v_str)
 105
 106
 107 def sanitizeVersion(version):
 108     """Sanitize a Debian package version for use as a git tag.
 109
 110     This function strips the epoch from the version number and
 111     replaces any tildes with underscores."""
 112     if version.debian_version:
 113         v = '%s-%s' % (version.upstream_version,
 114                        version.debian_version)
 115     else:
 116         v = version.upstream_version
 117     return v.replace('~', '_')
 118
 119
 120 def aptCopy(package, commit, dst_pocket, src_pocket):
 121     """Copy a package from one pocket to another."""
 122     binaries = getBinaries(package, commit)
 123     logAndRun(['reprepro-env', 'copy',
 124                b.pocketToApt(dst_pocket),
 125                b.pocketToApt(src_pocket),
 126                package] + binaries)
 127
 128
 129 def sbuild(package, ref, distro, arch, workdir, arch_all=False):
 130     """Build a package for a particular architecture and distro."""
 131     # We append a suffix like ~ubuntu8.04 to differentiate the same
 132     # version built for multiple distros
 133     nmutag = b.distroToSuffix(distro)
 134     env = os.environ.copy()
 135     env['NMUTAG'] = nmutag
 136     maintainer = "Invirt Autobuilder <%s>" % (config.contact,)
 137     # Run sbuild with a hack in place to append arbitrary versions
 138     args = ['perl', '-I/usr/share/invirt-dev', '-MSbuildHack',
 139             '/usr/bin/sbuild',
 140             '--binNMU=171717', '--make-binNMU=Build with sbuild',
 141             '-v', '-d', distro, '-m', maintainer,
 142             '--arch', arch]
 143     if arch_all:
 144         args.append('-A')
 145     args.append(getDscName(package, ref))
 146     logAndRun(args, cwd=workdir, env=env)
 147
 148
 149 def sbuildAll(package, ref, distro, workdir):
 150     """Build a package for all architectures it supports."""
 151     arches = getArches(package, ref)
 152     if 'all' in arches or 'any' in arches or 'amd64' in arches:
 153         sbuild(package, ref, distro, 'amd64', workdir, arch_all=True)
 154     if 'any' in arches or 'i386' in arches:
 155         sbuild(package, ref, distro, 'i386', workdir)
 156
 157
 158 def tagSubmodule(pocket, package, commit, principal, version, env):
 159     """Tag a new version of a submodule.
 160
 161     If this pocket does not allow_backtracking, then this will create
 162     a new tag of the version at ref.
 163
 164     This function doesn't need to care about lock
 165     contention. git-receive-pack updates one ref at a time, and only
 166     takes out a lock for that ref after it's passed the update
 167     hook. Because we reject pushes to tags in the update hook, no push
 168     can ever take out a lock on any tags.
 169
 170     I'm sure that long description gives you great confidence in the
 171     legitimacy of my reasoning.
 172     """
 173     if not config.build.pockets[pocket].get('allow_backtracking', False):
 174         branch = b.pocketToGit(pocket)
 175         tag_msg = ('Tag %s of %s\n\n'
 176                    'Requested by %s' % (version.full_version,
 177                                         package,
 178                                         principal))
 179
 180         logAndRun(
 181             ['git', 'tag', '-m', tag_msg, '--', sanitizeVersion(version),
 182              commit],
 183             env=env,
 184             cwd=b.getRepo(package))
 185
 186
 187 def updateSubmoduleBranch(pocket, package, commit):
 188     """Update the appropriately named branch in the submodule."""
 189     branch = b.pocketToGit(pocket)
 190     logAndRun(
 191         ['git', 'update-ref', 'refs/heads/%s' % branch, commit], cwd=b.getRepo(package))
 192
 193
 194 def uploadBuild(pocket, workdir):
 195     """Upload all build products in the work directory."""
 196     force = config.build.pockets[pocket].get('allow_backtracking', False)
 197     apt = b.pocketToApt(pocket)
 198     for changes in glob.glob(os.path.join(workdir, '*.changes')):
 199         upload = ['reprepro-env', '--ignore=wrongdistribution',
 200                   'include', apt, changes]
 201         try:
 202             logAndRun(upload)
 203         except subprocess.CalledProcessError, e:
 204             if not force:
 205                 raise
 206             changelog = deb822.Changes(open(changes).read())
 207             packages = set(changelog['Binary'].split())
 208             packages.add(changelog['Source'])
 209             for package in packages:
 210                 logAndRun(['reprepro-env', 'remove', apt, package])
 211             logAndRun(upload)
 212
 213
 214 def updateSuperproject(pocket, package, commit, principal, version, env):
 215     """Update the superproject.
 216
 217     This will create a new commit on the branch for the given pocket
 218     that sets the commit for the package submodule to commit.
 219
 220     Note that there's no locking issue here, because we disallow all
 221     pushes to the superproject.
 222     """
 223     superproject = os.path.join(b._REPO_DIR, 'invirt/packages.git')
 224     branch = b.pocketToGit(pocket)
 225     tree = logAndRun(['git', 'ls-tree', branch],
 226                      cwd=superproject).strip()
 227
 228     tree_items = dict((k, v) for (v, k) in (x.split("\t") for x in tree.split("\n")))
 229
 230     created = not (package in tree_items)
 231
 232     tree_items[package] = "160000 commit "+commit
 233
 234     # If "created" is true, we need to check if the package is
 235     # mentioned in .gitmodules, and add it if not.
 236     if created:
 237         gitmodules = logAndRun(['git', 'cat-file', 'blob', '%s:.gitmodules' % (branch)],
 238                                cwd=superproject)
 239         if ('[submodule "%s"]' % (package)) not in gitmodules.split("\n"):
 240             gitmodules += """[submodule "%s"]
 241 \tpath = %s
 242 \turl = ../packages/%s.git
 243 """ % (package, package, package)
 244             gitmodules_hash = logAndRun(['git', 'hash-object', '-w', '--stdin'],
 245                                         cwd=superproject,
 246                                         stdin_str=gitmodules).strip()
 247             tree_items[package] = "100644 blob "+gitmodules_hash
 248
 249     new_tree = "\n".join("%s\t%s" % (v, k) for (k, v) in tree_items.iteritems())
 250
 251     new_tree_id = logAndRun(['git', 'mktree', '--missing'],
 252                             cwd=superproject,
 253                             stdin_str=new_tree).strip()
 254
 255     if created:
 256         commit_msg = 'Add %s at version %s'
 257     else:
 258         commit_msg = 'Update %s to version %s'
 259     commit_msg = ((commit_msg + '\n\n'
 260                    'Requested by %s') % (package,
 261                                          version.full_version,
 262                                          principal))
 263     new_commit = logAndRun(
 264         ['git', 'commit-tree', new_tree_id, '-p', branch],
 265         cwd=superproject,
 266         env=env,
 267         stdin_str=commit_msg).strip()
 268
 269     logAndRun(
 270         ['git', 'update-ref', 'refs/heads/%s' % branch, new_commit],
 271         cwd=superproject)
 272
 273
 274 def makeReadable(workdir):
 275     os.chmod(workdir, 0755)
 276
 277 @contextlib.contextmanager
 278 def packageWorkdir(package, commit, build_id):
 279     """Checkout the package in a temporary working directory.
 280
 281     This context manager returns that working directory. The requested
 282     package is checked out into a subdirectory of the working
 283     directory with the same name as the package.
 284
 285     When the context wrapped with this context manager is exited, the
 286     working directory is automatically deleted.
 287     """
 288     workdir = tempfile.mkdtemp(prefix=("b%d-" % build_id))
 289     try:
 290         p_archive = subprocess.Popen(
 291             ['git', '--git-dir=%s' % (b.getRepo(package),),
 292              'archive',
 293              '--prefix=%s/' % package,
 294              commit,
 295              ],
 296             stdout=subprocess.PIPE,
 297             )
 298         p_tar = subprocess.Popen(
 299             ['tar', '-x'],
 300             stdin=p_archive.stdout,
 301             cwd=workdir,
 302             )
 303         p_archive.wait()
 304         p_tar.wait()
 305
 306         yield workdir
 307     finally:
 308         shutil.rmtree(workdir)
 309
 310 def build():
 311     """Deal with items in the build queue.
 312
 313     When triggered, iterate over build queue items one at a time,
 314     until there are no more pending build jobs.
 315     """
 316     global logfile
 317
 318     while True:
 319         stage = 'processing incoming job'
 320         queue = os.listdir(b._QUEUE_DIR)
 321         if not queue:
 322             break
 323
 324         build = min(queue)
 325         job = open(os.path.join(b._QUEUE_DIR, build)).read().strip()
 326         pocket, package, commit, principal = job.split()
 327
 328         database.session.begin()
 329         db = database.Build()
 330         db.package = package
 331         db.pocket = pocket
 332         db.commit = commit
 333         db.principal = principal
 334         database.session.add(db)
 335         database.session.commit()
 336
 337         database.session.begin()
 338
 339         logdir = os.path.join(b._LOG_DIR, str(db.build_id))
 340         if not os.path.exists(logdir):
 341             os.makedirs(logdir)
 342
 343         try:
 344             db.failed_stage = 'validating job'
 345             # Don't expand the commit in the DB until we're sure the user
 346             # isn't trying to be tricky.
 347             b.ensureValidPackage(package)
 348
 349             logfile = open(os.path.join(logdir, '%s.log' % db.package), 'w')
 350
 351             db.commit = commit = b.canonicalize_commit(package, commit)
 352             src = b.validateBuild(pocket, package, commit)
 353             version = b.getVersion(package, commit)
 354             db.version = str(version)
 355             b.runHook('pre-build', [str(db.build_id)])
 356
 357             env = dict(os.environ)
 358             env['GIT_COMMITTER_NAME'] = config.build.tagger.name
 359             env['GIT_COMMITTER_EMAIL'] = config.build.tagger.email
 360
 361             # If validateBuild returns something other than True, then
 362             # it means we should copy from that pocket to our pocket.
 363             #
 364             # (If the validation failed, validateBuild would have
 365             # raised an exception)
 366             if src != True:
 367                 # TODO: cut out this code duplication
 368                 db.failed_stage = 'tagging submodule before copying package'
 369                 tagSubmodule(pocket, package, commit, principal, version, env)
 370                 db.failed_stage = 'updating submodule branches before copying package'
 371                 updateSubmoduleBranch(pocket, package, commit)
 372                 db.failed_stage = 'updating superproject before copying package'
 373                 updateSuperproject(pocket, package, commit, principal, version, env)
 374                 db.failed_stage = 'copying package from another pocket'
 375                 aptCopy(package, commit, pocket, src)
 376
 377             # If we can't copy the package from somewhere, but
 378             # validateBuild didn't raise an exception, then we need to
 379             # do the build ourselves
 380             else:
 381                 db.failed_stage = 'checking out package source'
 382                 with packageWorkdir(package, commit, db.build_id) as workdir:
 383                     db.failed_stage = 'preparing source package'
 384                     packagedir = os.path.join(workdir, package)
 385
 386                     # We should be more clever about dealing with
 387                     # things like non-Debian-native packages than we
 388                     # are.
 389                     #
 390                     # If we were, we could use debuild and get nice
 391                     # environment scrubbing. Since we're not, debuild
 392                     # complains about not having an orig.tar.gz
 393                     logAndRun(['dpkg-buildpackage', '-us', '-uc', '-S'],
 394                               cwd=packagedir)
 395
 396                     db.failed_stage = 'building binary packages'
 397                     sbuildAll(package, commit, b.pocketToDistro(pocket), workdir)
 398                     db.failed_stage = 'tagging submodule'
 399                     tagSubmodule(pocket, package, commit, principal, version, env)
 400                     db.failed_stage = 'updating submodule branches'
 401                     updateSubmoduleBranch(pocket, package, commit)
 402                     db.failed_stage = 'updating superproject'
 403                     updateSuperproject(pocket, package, commit, principal, version, env)
 404                     db.failed_stage = 'relaxing permissions on workdir'
 405                     makeReadable(workdir)
 406                     db.failed_stage = 'uploading packages to apt repo'
 407                     uploadBuild(pocket, workdir)
 408
 409                     db.failed_stage = 'cleaning up'
 410         except:
 411             db.traceback = traceback.format_exc()
 412         else:
 413             db.succeeded = True
 414             db.failed_stage = None
 415         finally:
 416             if logfile is not None:
 417                 logfile.close()
 418
 419             database.session.add(db)
 420             database.session.commit()
 421
 422             # Finally, now that everything is done, remove the
 423             # build queue item
 424             os.unlink(os.path.join(b._QUEUE_DIR, build))
 425
 426             if db.succeeded:
 427                 b.runHook('post-build', [str(db.build_id)])
 428             else:
 429                 b.runHook('failed-build', [str(db.build_id)])
 430
 431 class Invirtibuilder(pyinotify.ProcessEvent):
 432     """Process inotify triggers to build new packages."""
 433     def process_default(self, event):
 434         """Handle an inotify event.
 435
 436         When an inotify event comes in, trigger the builder.
 437         """
 438         build()
 439
 440
 441 def main():
 442     """Initialize the inotifications and start the main loop."""
 443     database.connect()
 444
 445     watch_manager = pyinotify.WatchManager()
 446     invirtibuilder = Invirtibuilder()
 447     notifier = pyinotify.Notifier(watch_manager, invirtibuilder)
 448     watch_manager.add_watch(b._QUEUE_DIR,
 449                             pyinotify.EventsCodes.ALL_FLAGS['IN_CREATE'] |
 450                             pyinotify.EventsCodes.ALL_FLAGS['IN_MOVED_TO'])
 451
 452     # Before inotifying, run any pending builds; otherwise we won't
 453     # get notified for them.
 454     build()
 455
 456     while True:
 457         notifier.process_events()
 458         if notifier.check_events():
 459             notifier.read_events()
 460
 461
 462 if __name__ == '__main__':
 463     main()