from __future__ import with_statement
import contextlib
+import glob
import os
import re
import shutil
import subprocess
+import tempfile
+import traceback
import pyinotify
+from debian_bundle import deb822
+
import invirt.builder as b
+import invirt.common as c
from invirt import database
+from invirt.config import structs as config
DISTRIBUTION = 'hardy'
acts roughly like a dict.
"""
return deb822.Deb822.iter_paragraphs(
- getGitFile(package, ref, 'debian/control').split('\n'))
+ b.getGitFile(package, ref, 'debian/control').split('\n'))
def getBinaries(package, ref):
def getDscName(package, ref):
"""Return the .dsc file that will be generated for this package."""
- v = getVersion(package, ref)
+ v = b.getVersion(package, ref)
if v.debian_version:
v_str = '%s-%s' % (v.upstream_version,
v.debian_version)
return v.replace('~', '.')
-def aptCopy(packages, dst_pocket, src_pocket):
+def aptCopy(package, commit, dst_pocket, src_pocket):
"""Copy a package from one pocket to another."""
binaries = getBinaries(package, commit)
- cpatureOutput(['reprepro-env', 'copy',
- b.pocketToApt(dst_pocket),
- b.pocketToApt(src_pocket),
- package] + binaries)
+ c.captureOutput(['reprepro-env', 'copy',
+ b.pocketToApt(dst_pocket),
+ b.pocketToApt(src_pocket),
+ package] + binaries)
def sbuild(package, ref, arch, workdir, arch_all=False):
"""Build a package for a particular architecture."""
- args = ['sbuild', '-d', DISTRIBUTION, '--arch', arch]
+ args = ['sbuild', '-v', '-d', DISTRIBUTION, '--arch', arch]
if arch_all:
args.append('-A')
args.append(getDscName(package, ref))
- c.captureOutput(args, cwd=workdir, stdout=None)
+ c.captureOutput(args, cwd=workdir)
def sbuildAll(package, ref, workdir):
sbuild(package, ref, 'i386', workdir)
-def tagSubmodule(pocket, package, ref, principal):
+def tagSubmodule(pocket, package, commit, principal, version, env):
"""Tag a new version of a submodule.
If this pocket does not allow_backtracking, then this will create
legitimacy of my reasoning.
"""
if not config.build.pockets[pocket].get('allow_backtracking', False):
- env = dict(os.environ)
branch = b.pocketToGit(pocket)
- version = b.getVersion(package, ref)
-
- env['GIT_COMMITTER_NAME'] = config.build.tagger.name
- env['GIT_COMMITTER_EMAIL'] = config.build.tagger.email
tag_msg = ('Tag %s of %s\n\n'
'Requested by %s' % (version.full_version,
package,
c.captureOutput(
['git', 'tag', '-m', tag_msg, commit],
- stdout=None,
- env=env)
+ env=env,
+ cwd=b.getRepo(package))
-def updateSubmoduleBranch(pocket, package, ref):
+def updateSubmoduleBranch(pocket, package, commit):
"""Update the appropriately named branch in the submodule."""
branch = b.pocketToGit(pocket)
c.captureOutput(
- ['git', 'update-ref', 'refs/heads/%s' % branch, ref])
+ ['git', 'update-ref', 'refs/heads/%s' % branch, commit], cwd=b.getRepo(package))
def uploadBuild(pocket, workdir):
apt = b.pocketToApt(pocket)
for changes in glob.glob(os.path.join(workdir, '*.changes')):
c.captureOutput(['reprepro-env',
- 'include',
'--ignore=wrongdistribution',
+ 'include',
apt,
changes])
-def updateSuperproject(pocket, package, commit, principal):
+def updateSuperproject(pocket, package, commit, principal, version, env):
"""Update the superproject.
This will create a new commit on the branch for the given pocket
superproject = os.path.join(b._REPO_DIR, 'invirt/packages.git')
branch = b.pocketToGit(pocket)
tree = c.captureOutput(['git', 'ls-tree', branch],
- cwd=superproject)
+ cwd=superproject).strip()
new_tree = re.compile(
r'^(160000 commit )[0-9a-f]*(\t%s)$' % package, re.M).sub(
- r'\1%s\2' % commit,
+ r'\g<1>%s\g<2>' % commit,
tree)
- new_tree_id = c.captureOutput(['git', 'mktree'],
- cwd=superproject,
- stdin_str=new_tree)
+ new_tree_id = c.captureOutput(['git', 'mktree', '--missing'],
+ cwd=superproject,
+ stdin_str=new_tree).strip()
commit_msg = ('Update %s to version %s\n\n'
'Requested by %s' % (package,
version.full_version,
principal))
new_commit = c.captureOutput(
- ['git', 'commit-tree', new_tree_hash, '-p', branch],
+ ['git', 'commit-tree', new_tree_id, '-p', branch],
cwd=superproject,
env=env,
- stdin_str=commit_msg)
+ stdin_str=commit_msg).strip()
c.captureOutput(
['git', 'update-ref', 'refs/heads/%s' % branch, new_commit],
cwd=superproject)
+def makeReadable(workdir):
+ os.chmod(workdir, 0755)
+
@contextlib.contextmanager
def packageWorkdir(package, commit):
"""Checkout the package in a temporary working directory.
p_archive = subprocess.Popen(
['git', 'archive',
'--remote=file://%s' % b.getRepo(package),
- '--prefix=%s' % package,
+ '--prefix=%s/' % package,
commit,
],
stdout=subprocess.PIPE,
finally:
shutil.rmtree(workdir)
-
-def reportBuild(build):
- """Run hooks to report the results of a build attempt."""
-
- c.captureOutput(['run-parts',
- '--arg=%s' % build.build_id,
- '--',
- b._HOOKS_DIR])
-
-
def build():
"""Deal with items in the build queue.
db.commit = commit
db.principal = principal
database.session.save_or_update(db)
- database.commit()
+ database.session.commit()
- database.begin()
+ database.session.begin()
try:
db.failed_stage = 'validating job'
- src = validateBuild(pocket, package, commit)
+ # Don't expand the commit in the DB until we're sure the user
+ # isn't trying to be tricky.
+ b.ensureValidPackage(package)
+ db.commit = commit = b.canonicalize_commit(package, commit)
+ src = b.validateBuild(pocket, package, commit)
db.version = str(b.getVersion(package, commit))
+ b.runHook('pre-build', [str(db.build_id), db.pocket, db.package,
+ db.commit, db.principal, db.version, str(db.inserted_at)])
# If validateBuild returns something other than True, then
# it means we should copy from that pocket to our pocket.
# raised an exception)
if src != True:
db.failed_stage = 'copying package from another pocket'
- aptCopy(packages, pocket, src)
+ aptCopy(package, commit, pocket, src)
# If we can't copy the package from somewhere, but
# validateBuild didn't raise an exception, then we need to
# do the build ourselves
db.failed_stage = 'building binary packages'
sbuildAll(package, commit, workdir)
finally:
- logdir = os.path.join(b._LOG_DIR, db.build_id)
+ logdir = os.path.join(b._LOG_DIR, str(db.build_id))
if not os.path.exists(logdir):
os.makedirs(logdir)
- for log in glob.glob(os.path.join(workdir, '*.build')):
- os.copy2(log, logdir)
+ for log in glob.glob(os.path.join(workdir, 'build-*.log')):
+ os.copy(log, logdir)
+
+ db.failed_stage = 'processing metadata'
+ env = dict(os.environ)
+ env['GIT_COMMITTER_NAME'] = config.build.tagger.name
+ env['GIT_COMMITTER_EMAIL'] = config.build.tagger.email
+ version = b.getVersion(package, commit)
+
db.failed_stage = 'tagging submodule'
- tagSubmodule(pocket, package, commit, principal)
+ tagSubmodule(pocket, package, principal, version, env)
db.failed_stage = 'updating submodule branches'
updateSubmoduleBranch(pocket, package, commit)
db.failed_stage = 'updating superproject'
- updateSuperproject(pocket, package, commit, principal)
+ updateSuperproject(pocket, package, commit, principal, version, env)
+ db.failed_stage = 'relaxing permissions on workdir'
+ makeReadable(workdir)
db.failed_stage = 'uploading packages to apt repo'
uploadBuild(pocket, workdir)
# build queue item
os.unlink(os.path.join(b._QUEUE_DIR, build))
- reportBuild(db)
-
+ if db.succeeded:
+ b.runHook('post-build', [str(db.build_id)])
+ else:
+ b.runHook('failed-build', [str(db.build_id)])
class Invirtibuilder(pyinotify.ProcessEvent):
"""Process inotify triggers to build new packages."""
projects / invirt/packages/invirt-dev.git / blobdiff