419 lines
15 KiB
Python
419 lines
15 KiB
Python
import codecs
|
|
import re
|
|
from collections import OrderedDict
|
|
|
|
from .debian import Changelog, PackageArchitecture, PackageDescription, \
|
|
PackageRelation, Version
|
|
|
|
|
|
class PackagesList(OrderedDict):
|
|
def append(self, package):
|
|
self[package['Package']] = package
|
|
|
|
def extend(self, packages):
|
|
for package in packages:
|
|
self[package['Package']] = package
|
|
|
|
|
|
class Makefile(object):
|
|
def __init__(self):
|
|
self.rules = {}
|
|
self.add('.NOTPARALLEL')
|
|
|
|
def add(self, name, deps=None, cmds=None):
|
|
if name in self.rules:
|
|
self.rules[name].add(deps, cmds)
|
|
else:
|
|
self.rules[name] = self.Rule(name, deps, cmds)
|
|
if deps is not None:
|
|
for i in deps:
|
|
if i not in self.rules:
|
|
self.rules[i] = self.Rule(i)
|
|
|
|
def write(self, out):
|
|
for i in sorted(self.rules.keys()):
|
|
self.rules[i].write(out)
|
|
|
|
class Rule(object):
|
|
def __init__(self, name, deps=None, cmds=None):
|
|
self.name = name
|
|
self.deps, self.cmds = set(), []
|
|
self.add(deps, cmds)
|
|
|
|
def add(self, deps=None, cmds=None):
|
|
if deps is not None:
|
|
self.deps.update(deps)
|
|
if cmds is not None:
|
|
self.cmds.append(cmds)
|
|
|
|
def write(self, out):
|
|
deps_string = ''
|
|
if self.deps:
|
|
deps = list(self.deps)
|
|
deps.sort()
|
|
deps_string = ' ' + ' '.join(deps)
|
|
|
|
if self.cmds:
|
|
if deps_string:
|
|
out.write('%s::%s\n' % (self.name, deps_string))
|
|
for c in self.cmds:
|
|
out.write('%s::\n' % self.name)
|
|
for i in c:
|
|
out.write('\t%s\n' % i)
|
|
else:
|
|
out.write('%s:%s\n' % (self.name, deps_string))
|
|
|
|
|
|
class MakeFlags(dict):
|
|
def __str__(self):
|
|
return ' '.join("%s='%s'" % i for i in sorted(self.items()))
|
|
|
|
def copy(self):
|
|
return self.__class__(super(MakeFlags, self).copy())
|
|
|
|
|
|
def iter_featuresets(config):
|
|
for featureset in config['base', ]['featuresets']:
|
|
if config.merge('base', None, featureset).get('enabled', True):
|
|
yield featureset
|
|
|
|
|
|
def iter_arches(config):
|
|
return iter(config['base', ]['arches'])
|
|
|
|
|
|
def iter_arch_featuresets(config, arch):
|
|
for featureset in config['base', arch].get('featuresets', []):
|
|
if config.merge('base', arch, featureset).get('enabled', True):
|
|
yield featureset
|
|
|
|
|
|
def iter_flavours(config, arch, featureset):
|
|
return iter(config['base', arch, featureset]['flavours'])
|
|
|
|
|
|
class Gencontrol(object):
|
|
makefile_targets = ('binary-arch', 'build-arch', 'setup')
|
|
makefile_targets_indep = ('binary-indep', 'build-indep', 'setup')
|
|
|
|
def __init__(self, config, templates, version=Version):
|
|
self.config, self.templates = config, templates
|
|
self.changelog = Changelog(version=version)
|
|
self.vars = {}
|
|
|
|
def __call__(self):
|
|
packages = PackagesList()
|
|
makefile = Makefile()
|
|
|
|
self.do_source(packages)
|
|
self.do_main(packages, makefile)
|
|
self.do_extra(packages, makefile)
|
|
|
|
self.merge_build_depends(packages)
|
|
self.write(packages, makefile)
|
|
|
|
def do_source(self, packages):
|
|
source = self.templates["control.source"][0]
|
|
if not source.get('Source'):
|
|
source['Source'] = self.changelog[0].source
|
|
packages['source'] = self.process_package(source, self.vars)
|
|
|
|
def do_main(self, packages, makefile):
|
|
vars = self.vars.copy()
|
|
|
|
makeflags = MakeFlags()
|
|
extra = {}
|
|
|
|
self.do_main_setup(vars, makeflags, extra)
|
|
self.do_main_makefile(makefile, makeflags, extra)
|
|
self.do_main_packages(packages, vars, makeflags, extra)
|
|
self.do_main_recurse(packages, makefile, vars, makeflags, extra)
|
|
|
|
def do_main_setup(self, vars, makeflags, extra):
|
|
pass
|
|
|
|
def do_main_makefile(self, makefile, makeflags, extra):
|
|
makefile.add('build-indep',
|
|
cmds=["$(MAKE) -f debian/rules.real build-indep %s" %
|
|
makeflags])
|
|
makefile.add('binary-indep',
|
|
cmds=["$(MAKE) -f debian/rules.real binary-indep %s" %
|
|
makeflags])
|
|
|
|
def do_main_packages(self, packages, vars, makeflags, extra):
|
|
pass
|
|
|
|
def do_main_recurse(self, packages, makefile, vars, makeflags, extra):
|
|
for featureset in iter_featuresets(self.config):
|
|
self.do_indep_featureset(packages, makefile, featureset,
|
|
vars.copy(), makeflags.copy(), extra)
|
|
for arch in iter_arches(self.config):
|
|
self.do_arch(packages, makefile, arch, vars.copy(),
|
|
makeflags.copy(), extra)
|
|
|
|
def do_extra(self, packages, makefile):
|
|
templates_extra = self.templates.get("control.extra", None)
|
|
if templates_extra is None:
|
|
return
|
|
|
|
packages_extra = self.process_packages(templates_extra, self.vars)
|
|
packages.extend(packages_extra)
|
|
extra_arches = {}
|
|
for package in packages_extra:
|
|
arches = package['Architecture']
|
|
for arch in arches:
|
|
i = extra_arches.get(arch, [])
|
|
i.append(package)
|
|
extra_arches[arch] = i
|
|
for arch in sorted(extra_arches.keys()):
|
|
cmds = []
|
|
for i in extra_arches[arch]:
|
|
cmds.append("$(MAKE) -f debian/rules.real install-dummy "
|
|
"ARCH='%s' DH_OPTIONS='-p%s'" %
|
|
(arch, i['Package']))
|
|
makefile.add('binary-arch_%s' % arch,
|
|
['binary-arch_%s_extra' % arch])
|
|
makefile.add("binary-arch_%s_extra" % arch, cmds=cmds)
|
|
|
|
def do_indep_featureset(self, packages, makefile, featureset, vars,
|
|
makeflags, extra):
|
|
vars['localversion'] = ''
|
|
if featureset != 'none':
|
|
vars['localversion'] = '-' + featureset
|
|
|
|
self.do_indep_featureset_setup(vars, makeflags, featureset, extra)
|
|
self.do_indep_featureset_makefile(makefile, featureset, makeflags,
|
|
extra)
|
|
self.do_indep_featureset_packages(packages, makefile, featureset,
|
|
vars, makeflags, extra)
|
|
|
|
def do_indep_featureset_setup(self, vars, makeflags, featureset, extra):
|
|
pass
|
|
|
|
def do_indep_featureset_makefile(self, makefile, featureset, makeflags,
|
|
extra):
|
|
makeflags['FEATURESET'] = featureset
|
|
|
|
for i in self.makefile_targets_indep:
|
|
target1 = i
|
|
target2 = '_'.join((target1, featureset))
|
|
target3 = '_'.join((target2, 'real'))
|
|
makefile.add(target1, [target2])
|
|
makefile.add(target2, [target3])
|
|
|
|
def do_indep_featureset_packages(self, packages, makefile, featureset,
|
|
vars, makeflags, extra):
|
|
pass
|
|
|
|
def do_arch(self, packages, makefile, arch, vars, makeflags, extra):
|
|
vars['arch'] = arch
|
|
|
|
self.do_arch_setup(vars, makeflags, arch, extra)
|
|
self.do_arch_makefile(makefile, arch, makeflags, extra)
|
|
self.do_arch_packages(packages, makefile, arch, vars, makeflags, extra)
|
|
self.do_arch_recurse(packages, makefile, arch, vars, makeflags, extra)
|
|
|
|
def do_arch_setup(self, vars, makeflags, arch, extra):
|
|
pass
|
|
|
|
def do_arch_makefile(self, makefile, arch, makeflags, extra):
|
|
makeflags['ARCH'] = arch
|
|
|
|
for i in self.makefile_targets:
|
|
target1 = i
|
|
target2 = '_'.join((target1, arch))
|
|
target3 = '_'.join((target2, 'real'))
|
|
makefile.add(target1, [target2])
|
|
makefile.add(target2, [target3])
|
|
|
|
def do_arch_packages(self, packages, makefile, arch, vars, makeflags,
|
|
extra):
|
|
pass
|
|
|
|
def do_arch_recurse(self, packages, makefile, arch, vars, makeflags,
|
|
extra):
|
|
for featureset in iter_arch_featuresets(self.config, arch):
|
|
self.do_featureset(packages, makefile, arch, featureset,
|
|
vars.copy(), makeflags.copy(), extra)
|
|
|
|
def do_featureset(self, packages, makefile, arch, featureset, vars,
|
|
makeflags, extra):
|
|
vars['localversion'] = ''
|
|
if featureset != 'none':
|
|
vars['localversion'] = '-' + featureset
|
|
|
|
self.do_featureset_setup(vars, makeflags, arch, featureset, extra)
|
|
self.do_featureset_makefile(makefile, arch, featureset, makeflags,
|
|
extra)
|
|
self.do_featureset_packages(packages, makefile, arch, featureset, vars,
|
|
makeflags, extra)
|
|
self.do_featureset_recurse(packages, makefile, arch, featureset, vars,
|
|
makeflags, extra)
|
|
|
|
def do_featureset_setup(self, vars, makeflags, arch, featureset, extra):
|
|
pass
|
|
|
|
def do_featureset_makefile(self, makefile, arch, featureset, makeflags,
|
|
extra):
|
|
makeflags['FEATURESET'] = featureset
|
|
|
|
for i in self.makefile_targets:
|
|
target1 = '_'.join((i, arch))
|
|
target2 = '_'.join((target1, featureset))
|
|
target3 = '_'.join((target2, 'real'))
|
|
makefile.add(target1, [target2])
|
|
makefile.add(target2, [target3])
|
|
|
|
def do_featureset_packages(self, packages, makefile, arch, featureset,
|
|
vars, makeflags, extra):
|
|
pass
|
|
|
|
def do_featureset_recurse(self, packages, makefile, arch, featureset, vars,
|
|
makeflags, extra):
|
|
for flavour in iter_flavours(self.config, arch, featureset):
|
|
self.do_flavour(packages, makefile, arch, featureset, flavour,
|
|
vars.copy(), makeflags.copy(), extra)
|
|
|
|
def do_flavour(self, packages, makefile, arch, featureset, flavour, vars,
|
|
makeflags, extra):
|
|
vars['localversion'] += '-' + flavour
|
|
|
|
self.do_flavour_setup(vars, makeflags, arch, featureset, flavour,
|
|
extra)
|
|
self.do_flavour_makefile(makefile, arch, featureset, flavour,
|
|
makeflags, extra)
|
|
self.do_flavour_packages(packages, makefile, arch, featureset, flavour,
|
|
vars, makeflags, extra)
|
|
|
|
def do_flavour_setup(self, vars, makeflags, arch, featureset, flavour,
|
|
extra):
|
|
for i in (
|
|
('kernel-arch', 'KERNEL_ARCH'),
|
|
('localversion', 'LOCALVERSION'),
|
|
):
|
|
if i[0] in vars:
|
|
makeflags[i[1]] = vars[i[0]]
|
|
|
|
def do_flavour_makefile(self, makefile, arch, featureset, flavour,
|
|
makeflags, extra):
|
|
makeflags['FLAVOUR'] = flavour
|
|
|
|
for i in self.makefile_targets:
|
|
target1 = '_'.join((i, arch, featureset))
|
|
target2 = '_'.join((target1, flavour))
|
|
target3 = '_'.join((target2, 'real'))
|
|
makefile.add(target1, [target2])
|
|
makefile.add(target2, [target3])
|
|
|
|
def do_flavour_packages(self, packages, makefile, arch, featureset,
|
|
flavour, vars, makeflags, extra):
|
|
pass
|
|
|
|
def process_relation(self, dep, vars):
|
|
import copy
|
|
dep = copy.deepcopy(dep)
|
|
for groups in dep:
|
|
for item in groups:
|
|
item.name = self.substitute(item.name, vars)
|
|
if item.version:
|
|
item.version = self.substitute(item.version, vars)
|
|
return dep
|
|
|
|
def process_description(self, in_desc, vars):
|
|
desc = in_desc.__class__()
|
|
desc.short = self.substitute(in_desc.short, vars)
|
|
for i in in_desc.long:
|
|
desc.append(self.substitute(i, vars))
|
|
return desc
|
|
|
|
def process_package(self, in_entry, vars={}):
|
|
entry = in_entry.__class__()
|
|
for key, value in in_entry.items():
|
|
if isinstance(value, PackageRelation):
|
|
value = self.process_relation(value, vars)
|
|
elif isinstance(value, PackageDescription):
|
|
value = self.process_description(value, vars)
|
|
else:
|
|
value = self.substitute(value, vars)
|
|
entry[key] = value
|
|
return entry
|
|
|
|
def process_packages(self, entries, vars):
|
|
return [self.process_package(i, vars) for i in entries]
|
|
|
|
def substitute(self, s, vars):
|
|
if isinstance(s, (list, tuple)):
|
|
return [self.substitute(i, vars) for i in s]
|
|
|
|
def subst(match):
|
|
return vars[match.group(1)]
|
|
|
|
return re.sub(r'@([-_a-z0-9]+)@', subst, str(s))
|
|
|
|
def merge_build_depends(self, packages):
|
|
# Merge Build-Depends pseudo-fields from binary packages into the
|
|
# source package
|
|
source = packages["source"]
|
|
arch_all = PackageArchitecture("all")
|
|
for name, package in packages.items():
|
|
if name == "source":
|
|
continue
|
|
dep = package.get("Build-Depends")
|
|
if not dep:
|
|
continue
|
|
del package["Build-Depends"]
|
|
for group in dep:
|
|
for item in group:
|
|
if package["Architecture"] != arch_all and not item.arches:
|
|
item.arches = sorted(package["Architecture"])
|
|
if package.get("Build-Profiles") and not item.restrictions:
|
|
profiles = package["Build-Profiles"]
|
|
assert profiles[0] == "<" and profiles[-1] == ">"
|
|
item.restrictions = re.split(r"\s+", profiles[1:-1])
|
|
if package["Architecture"] == arch_all:
|
|
dep_type = "Build-Depends-Indep"
|
|
else:
|
|
dep_type = "Build-Depends-Arch"
|
|
if dep_type not in source:
|
|
source[dep_type] = PackageRelation()
|
|
source[dep_type].extend(dep)
|
|
|
|
def write(self, packages, makefile):
|
|
self.write_control(packages.values())
|
|
self.write_makefile(makefile)
|
|
|
|
def write_control(self, list, name='debian/control'):
|
|
self.write_rfc822(codecs.open(name, 'w', 'utf-8'), list)
|
|
|
|
def write_makefile(self, makefile, name='debian/rules.gen'):
|
|
f = open(name, 'w')
|
|
makefile.write(f)
|
|
f.close()
|
|
|
|
def write_rfc822(self, f, list):
|
|
for entry in list:
|
|
for key, value in entry.items():
|
|
f.write(u"%s: %s\n" % (key, value))
|
|
f.write('\n')
|
|
|
|
|
|
def merge_packages(packages, new, arch):
|
|
for new_package in new:
|
|
name = new_package['Package']
|
|
if name in packages:
|
|
package = packages.get(name)
|
|
package['Architecture'].add(arch)
|
|
|
|
for field in ('Depends', 'Provides', 'Suggests', 'Recommends',
|
|
'Conflicts'):
|
|
if field in new_package:
|
|
if field in package:
|
|
v = package[field]
|
|
v.extend(new_package[field])
|
|
else:
|
|
package[field] = new_package[field]
|
|
|
|
else:
|
|
new_package['Architecture'] = arch
|
|
packages.append(new_package)
|