324 lines
15 KiB
Python
Executable File
324 lines
15 KiB
Python
Executable File
#!/usr/bin/env python
|
|
|
|
import os, sys
|
|
sys.path.append("debian/lib/python")
|
|
|
|
from debian_linux.config import ConfigCoreHierarchy
|
|
from debian_linux.debian import *
|
|
from debian_linux.gencontrol import Gencontrol as Base
|
|
from debian_linux.utils import Templates
|
|
|
|
class Gencontrol(Base):
|
|
def __init__(self, config_dirs = ["debian/config"], template_dirs = ["debian/templates"]):
|
|
super(Gencontrol, self).__init__(ConfigCoreHierarchy(config_dirs), Templates(template_dirs), VersionLinux)
|
|
self.process_changelog()
|
|
self.config_dirs = config_dirs
|
|
|
|
def do_main_setup(self, vars, makeflags, extra):
|
|
super(Gencontrol, self).do_main_setup(vars, makeflags, extra)
|
|
makeflags.update({
|
|
'MAJOR': self.version.linux_major,
|
|
'VERSION': self.version.linux_version,
|
|
'UPSTREAMVERSION': self.version.linux_upstream,
|
|
'ABINAME': self.abiname,
|
|
'SOURCEVERSION': self.version.complete,
|
|
})
|
|
|
|
def do_main_packages(self, packages, vars, makeflags, extra):
|
|
packages.extend(self.process_packages(self.templates["control.main"], self.vars))
|
|
packages.append(self.process_real_tree(self.templates["control.tree"][0], self.vars))
|
|
packages.extend(self.process_packages(self.templates["control.support"], self.vars))
|
|
|
|
def do_arch_setup(self, vars, makeflags, arch, extra):
|
|
config_base = self.config.merge('base', arch)
|
|
config_libc_dev = self.config.merge('libc-dev', arch)
|
|
makeflags['LIBC_DEV_ARCH'] = config_libc_dev.get('arch', config_base.get('kernel-arch'))
|
|
|
|
def do_arch_packages(self, packages, makefile, arch, vars, makeflags, extra):
|
|
headers_arch = self.templates["control.headers.arch"]
|
|
packages_headers_arch = self.process_packages(headers_arch, vars)
|
|
|
|
libc_dev = self.templates["control.libc-dev"]
|
|
packages_headers_arch[0:0] = self.process_packages(libc_dev, {})
|
|
|
|
extra['headers_arch_depends'] = packages_headers_arch[-1]['Depends'] = PackageRelation()
|
|
|
|
for package in packages_headers_arch:
|
|
name = package['Package']
|
|
if packages.has_key(name):
|
|
package = packages.get(name)
|
|
package['Architecture'].append(arch)
|
|
else:
|
|
package['Architecture'] = [arch]
|
|
packages.append(package)
|
|
|
|
cmds_binary_arch = ["$(MAKE) -f debian/rules.real binary-arch-arch %s" % makeflags]
|
|
cmds_source = ["$(MAKE) -f debian/rules.real source-arch %s" % makeflags]
|
|
makefile.add('binary-arch_%s_real' % arch, cmds = cmds_binary_arch)
|
|
makefile.add('source_%s_real' % arch, cmds = cmds_source)
|
|
|
|
def do_featureset_setup(self, vars, makeflags, arch, featureset, extra):
|
|
config_base = self.config.merge('base', arch, featureset)
|
|
makeflags['KERNEL_HEADER_DIRS'] = config_base.get('kernel-header-dirs', config_base.get('kernel-arch'))
|
|
makeflags['LOCALVERSION_HEADERS'] = vars['localversion_headers'] = vars['localversion']
|
|
|
|
def do_featureset_packages(self, packages, makefile, arch, featureset, vars, makeflags, extra):
|
|
headers_featureset = self.templates["control.headers.featureset"]
|
|
package_headers = self.process_package(headers_featureset[0], vars)
|
|
|
|
name = package_headers['Package']
|
|
if packages.has_key(name):
|
|
package_headers = packages.get(name)
|
|
package_headers['Architecture'].append(arch)
|
|
else:
|
|
package_headers['Architecture'] = [arch]
|
|
packages.append(package_headers)
|
|
|
|
cmds_binary_arch = ["$(MAKE) -f debian/rules.real binary-arch-featureset %s" % makeflags]
|
|
cmds_source = ["$(MAKE) -f debian/rules.real source-featureset %s" % makeflags]
|
|
makefile.add('binary-arch_%s_%s_real' % (arch, featureset), cmds = cmds_binary_arch)
|
|
makefile.add('source_%s_%s_real' % (arch, featureset), cmds = cmds_source)
|
|
|
|
def do_flavour_setup(self, vars, makeflags, arch, featureset, flavour, extra):
|
|
config_base = self.config.merge('base', arch, featureset, flavour)
|
|
config_image = self.config.merge('image', arch, featureset, flavour)
|
|
|
|
vars['localversion-image'] = vars['localversion']
|
|
override_localversion = config_image.get('override-localversion', None)
|
|
if override_localversion is not None:
|
|
vars['localversion-image'] = vars['localversion_headers'] + '-' + override_localversion
|
|
|
|
data = vars.copy()
|
|
data.update(config_base)
|
|
data.update(config_image)
|
|
|
|
for i in (
|
|
('compiler', 'COMPILER'),
|
|
('kernel-arch', 'KERNEL_ARCH'),
|
|
('localversion', 'LOCALVERSION'),
|
|
('type', 'TYPE'),
|
|
):
|
|
makeflags[i[1]] = data[i[0]]
|
|
for i in (
|
|
('cflags', 'CFLAGS'),
|
|
('initramfs', 'INITRAMFS'),
|
|
('kpkg-arch', 'KPKG_ARCH'),
|
|
('kpkg-subarch', 'KPKG_SUBARCH'),
|
|
('localversion-image', 'LOCALVERSION_IMAGE'),
|
|
('override-host-type', 'OVERRIDE_HOST_TYPE'),
|
|
):
|
|
if data.has_key(i[0]):
|
|
makeflags[i[1]] = data[i[0]]
|
|
|
|
def do_flavour_packages(self, packages, makefile, arch, featureset, flavour, vars, makeflags, extra):
|
|
headers = self.templates["control.headers"]
|
|
|
|
config_entry_base = self.config.merge('base', arch, featureset, flavour)
|
|
config_entry_image = self.config.merge('image', arch, featureset, flavour)
|
|
config_entry_relations = self.config.merge('relations', arch, featureset, flavour)
|
|
|
|
compiler = config_entry_base.get('compiler', 'gcc')
|
|
relations_compiler = PackageRelation(config_entry_relations[compiler])
|
|
relations_compiler_build_dep = PackageRelation(config_entry_relations[compiler])
|
|
for group in relations_compiler_build_dep:
|
|
for item in group:
|
|
item.arches = [arch]
|
|
packages['source']['Build-Depends'].extend(relations_compiler_build_dep)
|
|
|
|
image_fields = {'Description': PackageDescription()}
|
|
for field in 'Depends', 'Provides', 'Suggests', 'Recommends', 'Conflicts':
|
|
image_fields[field] = PackageRelation(config_entry_image.get(field.lower(), None))
|
|
|
|
if config_entry_image.get('initramfs', True):
|
|
generators = config_entry_image['initramfs-generators']
|
|
config_entry_commands_initramfs = self.config.merge('commands-image-initramfs-generators', arch, featureset, flavour)
|
|
commands = [config_entry_commands_initramfs[i] for i in generators if config_entry_commands_initramfs.has_key(i)]
|
|
makeflags['INITRD_CMD'] = ' '.join(commands)
|
|
l_depends = PackageRelationGroup()
|
|
for i in generators:
|
|
i = config_entry_relations.get(i, i)
|
|
l_depends.append(i)
|
|
a = PackageRelationEntry(i)
|
|
if a.operator is not None:
|
|
a.operator = -a.operator
|
|
image_fields['Conflicts'].append(PackageRelationGroup([a]))
|
|
image_fields['Depends'].append(l_depends)
|
|
|
|
if 'desc-parts' in config_entry_image:
|
|
desc = image_fields['Description']
|
|
parts = config_entry_image['desc-parts']
|
|
for part in parts:
|
|
desc.append(config_entry_image['desc-long-part-' + part])
|
|
desc.append_short(config_entry_image.get('desc-short-part-' + part, ''))
|
|
|
|
packages_dummy = []
|
|
packages_own = []
|
|
|
|
if config_entry_image['type'] == 'plain-s390-tape':
|
|
image = self.templates["control.image.type-standalone"]
|
|
build_modules = False
|
|
elif config_entry_image['type'] == 'plain-xen':
|
|
image = self.templates["control.image.type-modulesextra"]
|
|
build_modules = True
|
|
config_entry_xen = self.config.merge('xen', arch, featureset, flavour)
|
|
if config_entry_xen.get('dom0-support', True):
|
|
p = self.process_packages(self.templates['control.xen-linux-system'], vars)
|
|
l = PackageRelationGroup()
|
|
for version in config_entry_xen['versions']:
|
|
l.append("xen-hypervisor-%s-%s" % (version, config_entry_xen['flavour']))
|
|
makeflags['XEN_VERSIONS'] = ' '.join(['%s-%s' % (i, config_entry_xen['flavour']) for i in config_entry_xen['versions']])
|
|
p[0]['Depends'].append(l)
|
|
packages_dummy.extend(p)
|
|
else:
|
|
build_modules = True
|
|
image = self.templates["control.image.type-%s" % config_entry_image['type']]
|
|
#image = self.templates["control.image.type-modulesinline"]
|
|
|
|
vars.setdefault('desc', None)
|
|
|
|
packages_own.append(self.process_real_image(image[0], image_fields, vars))
|
|
packages_own.extend(self.process_packages(image[1:], vars))
|
|
|
|
if build_modules:
|
|
makeflags['MODULES'] = True
|
|
package_headers = self.process_package(headers[0], vars)
|
|
package_headers['Depends'].extend(relations_compiler)
|
|
packages_own.append(package_headers)
|
|
extra['headers_arch_depends'].append('%s (= ${binary:Version})' % packages_own[-1]['Package'])
|
|
|
|
for package in packages_own + packages_dummy:
|
|
name = package['Package']
|
|
if packages.has_key(name):
|
|
package = packages.get(name)
|
|
package['Architecture'].append(arch)
|
|
else:
|
|
package['Architecture'] = [arch]
|
|
packages.append(package)
|
|
|
|
if config_entry_image['type'] == 'plain-xen':
|
|
for i in ('postinst', 'postrm', 'prerm'):
|
|
j = self.substitute(self.templates["image.xen.%s" % i], vars)
|
|
file("debian/%s.%s" % (packages_own[0]['Package'], i), 'w').write(j)
|
|
|
|
def get_config(*entry_name):
|
|
entry_real = ('image',) + entry_name
|
|
entry = self.config.get(entry_real, None)
|
|
if entry is None:
|
|
return None
|
|
return entry.get('configs', None)
|
|
|
|
def check_config_default(fail, f):
|
|
for d in self.config_dirs[::-1]:
|
|
f1 = d + '/' + f
|
|
if os.path.exists(f1):
|
|
return [f1]
|
|
if fail:
|
|
raise RuntimeError("%s unavailable" % f)
|
|
return []
|
|
|
|
def check_config_files(files):
|
|
ret = []
|
|
for f in files:
|
|
for d in self.config_dirs[::-1]:
|
|
f1 = d + '/' + f
|
|
if os.path.exists(f1):
|
|
ret.append(f1)
|
|
break
|
|
else:
|
|
raise RuntimeError("%s unavailable" % f)
|
|
return ret
|
|
|
|
def check_config(default, fail, *entry_name):
|
|
configs = get_config(*entry_name)
|
|
if configs is None:
|
|
return check_config_default(fail, default)
|
|
return check_config_files(configs)
|
|
|
|
kconfig = check_config('config', True)
|
|
kconfig.extend(check_config("%s/config" % arch, True, arch))
|
|
kconfig.extend(check_config("%s/config.%s" % (arch, flavour), False, arch, None, flavour))
|
|
kconfig.extend(check_config("featureset-%s/config" % featureset, False, None, featureset))
|
|
kconfig.extend(check_config("%s/%s/config" % (arch, featureset), False, arch, featureset))
|
|
kconfig.extend(check_config("%s/%s/config.%s" % (arch, featureset, flavour), False, arch, featureset, flavour))
|
|
makeflags['KCONFIG'] = ' '.join(kconfig)
|
|
|
|
cmds_binary_arch = ["$(MAKE) -f debian/rules.real binary-arch-flavour %s" % makeflags]
|
|
if packages_dummy:
|
|
cmds_binary_arch.append("$(MAKE) -f debian/rules.real install-dummy DH_OPTIONS='%s' %s" % (' '.join(["-p%s" % i['Package'] for i in packages_dummy]), makeflags))
|
|
cmds_build = ["$(MAKE) -f debian/rules.real build %s" % makeflags]
|
|
cmds_setup = ["$(MAKE) -f debian/rules.real setup-flavour %s" % makeflags]
|
|
makefile.add('binary-arch_%s_%s_%s_real' % (arch, featureset, flavour), cmds = cmds_binary_arch)
|
|
makefile.add('build_%s_%s_%s_real' % (arch, featureset, flavour), cmds = cmds_build)
|
|
makefile.add('setup_%s_%s_%s_real' % (arch, featureset, flavour), cmds = cmds_setup)
|
|
|
|
def do_extra(self, packages, makefile):
|
|
apply = self.templates['patch.apply']
|
|
|
|
vars = {
|
|
'revisions': 'orig ' + ' '.join([i.revision for i in self.versions[::-1]]),
|
|
'upstream': self.version.upstream,
|
|
'linux_upstream': self.version.linux_upstream,
|
|
'abiname': self.abiname,
|
|
}
|
|
|
|
apply = self.substitute(apply, vars)
|
|
|
|
file('debian/bin/patch.apply', 'w').write(apply)
|
|
|
|
def process_changelog(self):
|
|
act_upstream = self.changelog[0].version.linux_upstream
|
|
versions = []
|
|
for i in self.changelog:
|
|
if i.version.linux_upstream != act_upstream:
|
|
break
|
|
versions.append(i.version)
|
|
self.versions = versions
|
|
self.version = self.changelog[0].version
|
|
if self.version.linux_modifier is not None:
|
|
self.abiname = ''
|
|
else:
|
|
self.abiname = '-%s' % self.config['abi',]['abiname']
|
|
self.vars = {
|
|
'upstreamversion': self.version.linux_upstream,
|
|
'version': self.version.linux_version,
|
|
'source_upstream': self.version.upstream,
|
|
'major': self.version.linux_major,
|
|
'abiname': self.abiname,
|
|
}
|
|
self.config['version',] = {'source': self.version.complete, 'abiname': self.abiname}
|
|
|
|
def process_real_image(self, entry, fields, vars):
|
|
entry = self.process_package(entry, vars)
|
|
for key, value in fields.iteritems():
|
|
if key in entry:
|
|
real = entry[key]
|
|
real.extend(value)
|
|
elif value:
|
|
entry[key] = value
|
|
return entry
|
|
|
|
def process_real_tree(self, entry, vars):
|
|
entry = self.process_package(entry, vars)
|
|
version = self.changelog[0].version
|
|
|
|
value = entry.setdefault('Depends', PackageRelation())
|
|
value.append("linux-patch-debian-%s (= %s)" % (version.linux_version, version.complete))
|
|
value.append(PackageRelationGroup(["linux-source-%s (= %s)" % (v.linux_version, v.complete) for v in self.versions]))
|
|
|
|
value = entry.setdefault('Provides', PackageRelation())
|
|
value.extend(["linux-tree-%s" % v.complete.replace('~', '-') for v in self.versions])
|
|
|
|
return entry
|
|
|
|
def write(self, packages, makefile):
|
|
self.write_config()
|
|
super(Gencontrol, self).write(packages, makefile)
|
|
|
|
def write_config(self):
|
|
f = file("debian/config.defines.dump", 'w')
|
|
self.config.dump(f)
|
|
f.close()
|
|
|
|
if __name__ == '__main__':
|
|
Gencontrol()()
|