def setUp(self):
Database().clean()
RebuilddConfig().set('build', 'archs', 'i386 amd64')
self.backports = (('alsa-driver', 'lenny', BackportPolicy.Smart.Value),
('alsa-driver', 'lucid', BackportPolicy.Smart.Value),
('alsa-firmware', 'lenny', BackportPolicy.Smart.Value),
('alsa-firmware', 'lucid', BackportPolicy.Smart.Value))
for backport in self.backports:
Backporter().add(backport[0], backport[1])
Backporter().set(backport[0], backport[1], 'policy', backport[2])
def do_status(self, arg):
archs = Backporter().archs
cols = [
'Package', 'Dist', 'Origin', 'Bleeding', 'Official', 'Target',
'Archs', 'Progress', 'Policy'
]
cols += archs
rows = []
for b in Backporter().status():
rows.append((b.pkg, b.dist, b.origin, b.bleeding, b.official,
b.target, b.archs, str(b.progress),
BackportPolicy[b.policy]) + tuple(b.jobs[arch].status
for arch in archs))
self._print_listing(cols, rows)
def do_set(self, line):
(pkg, dist, rest) = self._parse_cmd(line)
if len(rest) != 2:
self._exit_with_error('Wrong syntax')
if rest[0] in ['policy']:
opt = rest[0]
val = getattr(getattr(BackportPolicy, rest[1]), 'Value')
Backporter().set(pkg, dist, opt, val)
return 1
if rest[0] in ['origin']:
opt = rest[0]
val = rest[1]
if val not in Backporter().bdists:
self._exit_with_error('%s is not a valid origin' % val)
Backporter().set(pkg, dist, opt, val)
return 1
self._exit_with_error('Unknown option')
def GET(self, dist, policy=None):
backports = Backporter().status(dist=dist)
# Render integer values properly
for b in backports:
b.policy = BackportPolicy[b.policy]
for arch in archs:
b.jobs[arch].status = status_to_html(
JobStatus.whatis(b.jobs[arch].status))
return bp_render.base(page=bp_render.backport(backports=backports, dist=dist, archs=archs, policy=policy), \
hostname=socket.gethostname(), dists=dists)
def do_source(self, line):
arg = self._tokenize(line)
if not len(arg) >= 3:
self._exit_with_error('Wrong syntax')
if not arg[0] == '-d':
self._exit_with_error('Wrong syntax')
if not arg[1] in self.dists:
self._exit_with_error('Unknown distribution "%s"' % arg[1])
if not len(arg[2].split('=')) == 2:
self._exit_with_error('Wrong package or version "%s"' % arg[2])
if len(arg) >= 4 and not arg[3] == '--':
self._exit_with_error('Wrong syntax')
dist = arg[1]
pkg = arg[2].split('=')[0]
ver = arg[2].split('=')[1]
if ver.endswith('~%s1' % dist):
ver = ver[:-len('~%s1' % dist)]
if len(arg) >= 5:
opts = " ".join(arg[4:])
else:
opts = None
return Backporter().source(dist, pkg, ver, opts)
def test_schedule(self):
Backporter().update()
Backporter().schedule()
status = {'alsa-driver':
{'lenny':
{'i386' :JobStatus.BUILD_FAILED,
'amd64':JobStatus.BUILD_OK},
'lucid':
{'i386' :JobStatus.BUILD_OK,
'amd64':JobStatus.BUILD_OK}},
'alsa-firmware':
{'lenny':
{'i386' :JobStatus.BUILD_OK,
'amd64':JobStatus.DEPWAIT},
'lucid':
{'i386' :JobStatus.BUILD_OK,
'amd64':JobStatus.DEPWAIT}},
}
# We must have one job for every dist/arch
self.assertEqual(len(Job.select()), 8)
# Check the first scheduling pass and set the status for the next one
for b in Backport().select():
# Target versions must be bleeding and progress zero
self.assertEqual(b.target, '%s~%s1' % (b.bleeding, b.dist))
self.assertEqual(b.progress,0)
p = Package(b.pkg, b.target)
# There must be one job for every arch in WAIT status
for arch in Backporter().archs:
jobs = Job.select(package_id=p.id, dist=b.dist, arch=arch)
self.assertEqual(len(jobs),1)
self.assertEqual(jobs[0].status, JobStatus.WAIT)
jobs[0].status = status[b.pkg][b.dist][arch]
jobs[0].update()
Backporter().schedule()
self.assertEqual(Backport('alsa-driver','lenny').progress,1)
self.assertEqual(Backport('alsa-driver','lenny').archs,['amd64'])
self.assertEqual(Backport('alsa-driver','lucid').progress,2)
self.assertEqual(Backport('alsa-firmware','lenny').progress,1)
self.assertEqual(Backport('alsa-firmware','lenny').archs,['i386'])
self.assertEqual(Backport('alsa-firmware','lucid').archs,['i386'])
# We should have two more jobs (for the DEPWAITs)
self.assertEqual(len(Job.select()), 8 + 2)
# Nothing happens
Backporter().schedule()
self.assertEqual(len(Job.select()), 8 + 2)
# Let's add a backport to solve the DEPWAIT
self.backports = (('freecycle', 'lenny', BackportPolicy.Smart.Value),
('freecycle', 'lucid', BackportPolicy.Smart.Value))
for backport in self.backports:
Backporter().add(backport[0], backport[1])
Backporter().set(backport[0], backport[1], 'policy', backport[2])
# New pass
Backporter().update()
Backporter().schedule()
# We should have 4 brand new jobs
self.assertEqual(len(Job.select()), 8 + 2 + 4)
# Let's say they are all succesful..
for dist in ['lenny', 'lucid']:
b = Backport('freecycle',dist)
p = Package(b.pkg, b.target)
for arch in Backporter().archs:
j = Job.select(package_id=p.id, dist=b.dist, arch=arch)[0]
j.status = JobStatus.BUILD_OK
j.update()
# This will re-trigger the DEPWAITs
Backporter().schedule()
# We should have again 2 jobs for the DEPWAITs
self.assertEqual(len(Job.select()), 8 + 2 + 4 + 2)
# Now let's force alsa-firmware/lenny/i386 re-schedule
Backporter().set('alsa-driver', 'lenny', 'policy', BackportPolicy.Always.Value)
Backporter().schedule()
self.assertEqual(len(Job.select()), 8 + 2 + 4 + 2 + 1)
def __init__(self):
Backporter()
Rebuildd()
import os
from rebuildd.JobStatus import JobStatus
from rebuildd.RebuilddConfig import RebuilddConfig
from rebuildd.Rebuildd import Rebuildd
from rebuildd.RebuilddHTTPServer import RequestPackage, RequestArch, RequestJob, RequestGraph
from backporter.Backporter import Backporter
from backporter.Models import BackportPolicy
from backporter.BackporterConfig import BackporterConfig
from backporter.Enum import Enum
render = web.template.render(RebuilddConfig().get('http', 'templates_dir'),
cache=False)
bp_render = web.template.render(BackporterConfig().get('http', 'templates'),
cache=False)
dists = Backporter().rdists
archs = Backporter().archs
Color = Enum('Bleeding', 'Official', 'Newer', 'Backport', 'OutOfDate')
class RequestIndex:
def GET(self):
return bp_render.base(page=render.index(), \
hostname=socket.gethostname(), \
dists=dists)
def version_to_html(text):
if text == None:
def do_add(self, line):
(pkg, dist, rest) = self._parse_cmd(line)
try:
Backporter().add(pkg, dist)
except IntegrityError, e:
self._exit_with_error('Field exists')
def do_schedule(self, line):
Backporter().schedule()
def do_update(self, line):
Backporter().update()
def do_remove(self, line):
(pkg, dist, rest) = self._parse_cmd(line)
try:
Backporter().remove(pkg, dist)
except BackporterError, e:
self._exit_with_error(e.message)
def do_list(self, arg):
fields = [
'Package', 'Dist', 'Origin', 'Bleeding', 'Official', 'Target',
'Archs', 'Progress', 'Policy'
]
self._print_listing(fields, Backporter().list())