debian/bin/gencontrol.py

   1 #!/usr/bin/env python
   2
   3 import os, sys
   4 sys.path.append("debian/lib/python")
   5
   6 from debian_linux.config import ConfigCoreHierarchy
   7 from debian_linux.debian import *
   8 from debian_linux.gencontrol import Gencontrol as Base
   9 from debian_linux.utils import Templates
  10
  11 class Gencontrol(Base):
  12     def __init__(self, config_dirs = ["debian/config"], template_dirs = ["debian/templates"]):
  13         super(Gencontrol, self).__init__(ConfigCoreHierarchy(config_dirs), Templates(template_dirs), VersionLinux)
  14         self.process_changelog()
  15         self.config_dirs = config_dirs
  16
  17     def _setup_makeflags(self, names, makeflags, data):
  18         for src, dst, optional in names:
  19             if src in data or not optional:
  20                 makeflags[dst] = data[src]
  21
  22     def do_main_setup(self, vars, makeflags, extra):
  23         super(Gencontrol, self).do_main_setup(vars, makeflags, extra)
  24         makeflags.update({
  25             'MAJOR': self.version.linux_major,
  26             'VERSION': self.version.linux_version,
  27             'UPSTREAMVERSION': self.version.linux_upstream,
  28             'ABINAME': self.abiname,
  29             'SOURCEVERSION': self.version.complete,
  30         })
  31
  32     def do_main_packages(self, packages, vars, makeflags, extra):
  33         packages.extend(self.process_packages(self.templates["control.main"], self.vars))
  34
  35     arch_makeflags = (
  36         ('kernel-arch', 'KERNEL_ARCH', False),
  37     )
  38
  39     def do_arch_setup(self, vars, makeflags, arch, extra):
  40         config_base = self.config.merge('base', arch)
  41         self._setup_makeflags(self.arch_makeflags, makeflags, config_base)
  42
  43     def do_arch_packages(self, packages, makefile, arch, vars, makeflags, extra):
  44         headers_arch = self.templates["control.headers.arch"]
  45         packages_headers_arch = self.process_packages(headers_arch, vars)
  46
  47         libc_dev = self.templates["control.libc-dev"]
  48         packages_headers_arch[0:0] = self.process_packages(libc_dev, {})
  49
  50         packages_headers_arch[-1]['Depends'].extend(PackageRelation())
  51         extra['headers_arch_depends'] = packages_headers_arch[-1]['Depends']
  52
  53         self.merge_packages(packages, packages_headers_arch, arch)
  54
  55         cmds_binary_arch = ["$(MAKE) -f debian/rules.real binary-arch-arch %s" % makeflags]
  56         cmds_source = ["$(MAKE) -f debian/rules.real source-arch %s" % makeflags]
  57         makefile.add('binary-arch_%s_real' % arch, cmds = cmds_binary_arch)
  58         makefile.add('source_%s_real' % arch, cmds = cmds_source)
  59
  60     def do_featureset_setup(self, vars, makeflags, arch, featureset, extra):
  61         config_base = self.config.merge('base', arch, featureset)
  62         makeflags['LOCALVERSION_HEADERS'] = vars['localversion_headers'] = vars['localversion']
  63
  64     def do_featureset_packages(self, packages, makefile, arch, featureset, vars, makeflags, extra):
  65         headers_featureset = self.templates["control.headers.featureset"]
  66         package_headers = self.process_package(headers_featureset[0], vars)
  67
  68         self.merge_packages(packages, (package_headers,), arch)
  69
  70         cmds_binary_arch = ["$(MAKE) -f debian/rules.real binary-arch-featureset %s" % makeflags]
  71         cmds_source = ["$(MAKE) -f debian/rules.real source-featureset %s" % makeflags]
  72         makefile.add('binary-arch_%s_%s_real' % (arch, featureset), cmds = cmds_binary_arch)
  73         makefile.add('source_%s_%s_real' % (arch, featureset), cmds = cmds_source)
  74
  75     flavour_makeflags_base = (
  76         ('compiler', 'COMPILER', False),
  77         ('kernel-arch', 'KERNEL_ARCH', False),
  78         ('cflags', 'CFLAGS_KERNEL', True),
  79         ('override-host-type', 'OVERRIDE_HOST_TYPE', True),
  80     )
  81
  82     flavour_makeflags_image = (
  83         ('type', 'TYPE', False),
  84         ('initramfs', 'INITRAMFS', True),
  85     )
  86
  87     flavour_makeflags_other = (
  88         ('localversion', 'LOCALVERSION', False),
  89         ('localversion-image', 'LOCALVERSION_IMAGE', True),
  90     )
  91
  92     def do_flavour_setup(self, vars, makeflags, arch, featureset, flavour, extra):
  93         config_base = self.config.merge('base', arch, featureset, flavour)
  94         config_description = self.config.merge('description', arch, featureset, flavour)
  95         config_image = self.config.merge('image', arch, featureset, flavour)
  96
  97         vars['class'] = config_description['hardware']
  98         vars['longclass'] = config_description.get('hardware-long') or vars['class']
  99
 100         vars['localversion-image'] = vars['localversion']
 101         override_localversion = config_image.get('override-localversion', None)
 102         if override_localversion is not None:
 103             vars['localversion-image'] = vars['localversion_headers'] + '-' + override_localversion
 104
 105         self._setup_makeflags(self.flavour_makeflags_base, makeflags, config_base)
 106         self._setup_makeflags(self.flavour_makeflags_image, makeflags, config_image)
 107         self._setup_makeflags(self.flavour_makeflags_other, makeflags, vars)
 108
 109     def do_flavour_packages(self, packages, makefile, arch, featureset, flavour, vars, makeflags, extra):
 110         headers = self.templates["control.headers"]
 111
 112         config_entry_base = self.config.merge('base', arch, featureset, flavour)
 113         config_entry_description = self.config.merge('description', arch, featureset, flavour)
 114         config_entry_image = self.config.merge('image', arch, featureset, flavour)
 115         config_entry_image_dbg = self.config.merge('image-dbg', arch, featureset, flavour)
 116         config_entry_relations = self.config.merge('relations', arch, featureset, flavour)
 117
 118         compiler = config_entry_base.get('compiler', 'gcc')
 119         relations_compiler = PackageRelation(config_entry_relations[compiler])
 120         relations_compiler_build_dep = PackageRelation(config_entry_relations[compiler])
 121         for group in relations_compiler_build_dep:
 122             for item in group:
 123                 item.arches = [arch]
 124         packages['source']['Build-Depends'].extend(relations_compiler_build_dep)
 125
 126         image_fields = {'Description': PackageDescription()}
 127         for field in 'Depends', 'Provides', 'Suggests', 'Recommends', 'Conflicts':
 128             image_fields[field] = PackageRelation(config_entry_image.get(field.lower(), None), override_arches=(arch,))
 129
 130         if config_entry_image.get('initramfs', True):
 131             generators = config_entry_image['initramfs-generators']
 132             config_entry_commands_initramfs = self.config.merge('commands-image-initramfs-generators', arch, featureset, flavour)
 133             commands = [config_entry_commands_initramfs[i] for i in generators if config_entry_commands_initramfs.has_key(i)]
 134             makeflags['INITRD_CMD'] = ' '.join(commands)
 135             l_depends = PackageRelationGroup()
 136             for i in generators:
 137                 i = config_entry_relations.get(i, i)
 138                 l_depends.append(i)
 139                 a = PackageRelationEntry(i)
 140                 if a.operator is not None:
 141                     a.operator = -a.operator
 142                     image_fields['Conflicts'].append(PackageRelationGroup([a]))
 143             image_fields['Depends'].append(l_depends)
 144
 145         desc_parts = self.config.get_merge('description', arch, featureset, flavour, 'parts')
 146         if desc_parts:
 147             # XXX: Workaround, we need to support multiple entries of the same name
 148             parts = list(set(desc_parts))
 149             parts.sort()
 150             desc = image_fields['Description']
 151             for part in parts:
 152                 desc.append(config_entry_description['part-long-' + part])
 153                 desc.append_short(config_entry_description.get('part-short-' + part, ''))
 154
 155         packages_dummy = []
 156         packages_own = []
 157
 158         if config_entry_image['type'] == 'plain-s390-tape':
 159             image = self.templates["control.image.type-standalone"]
 160             build_modules = False
 161         elif config_entry_image['type'] == 'plain-xen':
 162             raise RuntimeError
 163             image = self.templates["control.image.type-modulesextra"]
 164             build_modules = True
 165             config_entry_xen = self.config.merge('xen', arch, featureset, flavour)
 166             if config_entry_xen.get('dom0-support', True):
 167                 p = self.process_packages(self.templates['control.xen-linux-system'], vars)
 168                 l = PackageRelationGroup()
 169                 xen_versions = []
 170                 for xen_flavour in config_entry_xen['flavours']:
 171                     for version in config_entry_xen['versions']:
 172                         l.append("xen-hypervisor-%s-%s" % (version, xen_flavour))
 173                         xen_versions.append('%s-%s' % (version, xen_flavour))
 174                 makeflags['XEN_VERSIONS'] = ' '.join(xen_versions)
 175                 p[0]['Depends'].append(l)
 176                 packages_dummy.extend(p)
 177         else:
 178             build_modules = True
 179             image = self.templates["control.image.type-%s" % config_entry_image['type']]
 180             #image = self.templates["control.image.type-modulesinline"]
 181
 182         config_entry_xen = self.config.merge('xen', arch, featureset, flavour)
 183         if config_entry_xen.get('dom0-support', False):
 184             p = self.process_packages(self.templates['control.xen-linux-system'], vars)
 185             l = PackageRelationGroup()
 186             for xen_flavour in config_entry_xen['flavours']:
 187                 l.append("xen-hypervisor-%s" % xen_flavour)
 188             p[0]['Depends'].append(l)
 189             packages_dummy.extend(p)
 190
 191         vars.setdefault('desc', None)
 192
 193         packages_own.append(self.process_real_image(image[0], image_fields, vars))
 194         packages_own.extend(self.process_packages(image[1:], vars))
 195
 196         if build_modules:
 197             makeflags['MODULES'] = True
 198             package_headers = self.process_package(headers[0], vars)
 199             package_headers['Depends'].extend(relations_compiler)
 200             packages_own.append(package_headers)
 201             extra['headers_arch_depends'].append('%s (= ${binary:Version})' % packages_own[-1]['Package'])
 202
 203         build_debug = config_entry_image_dbg.get('enabled')
 204         if build_debug:
 205             makeflags['DEBUG'] = True
 206             packages_own.extend(self.process_packages(self.templates['control.image-dbg'], vars))
 207
 208         self.merge_packages(packages, packages_own + packages_dummy, arch)
 209
 210         if config_entry_image['type'] == 'plain-xen':
 211             for i in ('postinst', 'postrm', 'prerm'):
 212                 j = self.substitute(self.templates["image.xen.%s" % i], vars)
 213                 file("debian/%s.%s" % (packages_own[0]['Package'], i), 'w').write(j)
 214
 215         def get_config(*entry_name):
 216             entry_real = ('image',) + entry_name
 217             entry = self.config.get(entry_real, None)
 218             if entry is None:
 219                 return None
 220             return entry.get('configs', None)
 221
 222         def check_config_default(fail, f):
 223             for d in self.config_dirs[::-1]:
 224                 f1 = d + '/' + f
 225                 if os.path.exists(f1):
 226                     return [f1]
 227             if fail:
 228                 raise RuntimeError("%s unavailable" % f)
 229             return []
 230
 231         def check_config_files(files):
 232             ret = []
 233             for f in files:
 234                 for d in self.config_dirs[::-1]:
 235                     f1 = d + '/' + f
 236                     if os.path.exists(f1):
 237                         ret.append(f1)
 238                         break
 239                 else:
 240                     raise RuntimeError("%s unavailable" % f)
 241             return ret
 242
 243         def check_config(default, fail, *entry_name):
 244             configs = get_config(*entry_name)
 245             if configs is None:
 246                 return check_config_default(fail, default)
 247             return check_config_files(configs)
 248
 249         kconfig = check_config('config', True)
 250         kconfig.extend(check_config("%s/config" % arch, True, arch))
 251         kconfig.extend(check_config("%s/config.%s" % (arch, flavour), False, arch, None, flavour))
 252         kconfig.extend(check_config("featureset-%s/config" % featureset, False, None, featureset))
 253         kconfig.extend(check_config("%s/%s/config" % (arch, featureset), False, arch, featureset))
 254         kconfig.extend(check_config("%s/%s/config.%s" % (arch, featureset, flavour), False, arch, featureset, flavour))
 255         makeflags['KCONFIG'] = ' '.join(kconfig)
 256         if build_debug:
 257             makeflags['KCONFIG_OPTIONS'] = '-o DEBUG_INFO=y'
 258
 259         cmds_binary_arch = ["$(MAKE) -f debian/rules.real binary-arch-flavour %s" % makeflags]
 260         if packages_dummy:
 261             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))
 262         cmds_build = ["$(MAKE) -f debian/rules.real build %s" % makeflags]
 263         cmds_setup = ["$(MAKE) -f debian/rules.real setup-flavour %s" % makeflags]
 264         makefile.add('binary-arch_%s_%s_%s_real' % (arch, featureset, flavour), cmds = cmds_binary_arch)
 265         makefile.add('build_%s_%s_%s_real' % (arch, featureset, flavour), cmds = cmds_build)
 266         makefile.add('setup_%s_%s_%s_real' % (arch, featureset, flavour), cmds = cmds_setup)
 267
 268     def do_extra(self, packages, makefile):
 269         apply = self.templates['patch.apply']
 270
 271         vars = {
 272             'revisions': 'orig base ' + ' '.join([i.revision for i in self.versions[::-1]]),
 273             'upstream': self.version.upstream,
 274             'linux_upstream': self.version.linux_upstream,
 275             'abiname': self.abiname,
 276         }
 277
 278         apply = self.substitute(apply, vars)
 279
 280         file('debian/bin/patch.apply', 'w').write(apply)
 281
 282     def merge_packages(self, packages, new, arch):
 283         for new_package in new:
 284             name = new_package['Package']
 285             if name in packages:
 286                 package = packages.get(name)
 287                 package['Architecture'].append(arch)
 288
 289                 for field in 'Depends', 'Provides', 'Suggests', 'Recommends', 'Conflicts':
 290                     if field in new_package:
 291                         if field in package:
 292                             v = package[field]
 293                             v.extend(new_package[field])
 294                         else:
 295                             package[field] = new_package[field]
 296
 297             else:
 298                 new_package['Architecture'] = [arch]
 299                 packages.append(new_package)
 300
 301     def process_changelog(self):
 302         act_upstream = self.changelog[0].version.linux_upstream
 303         versions = []
 304         for i in self.changelog:
 305             if i.version.linux_upstream != act_upstream:
 306                 break
 307             versions.append(i.version)
 308         self.versions = versions
 309         version = self.version = self.changelog[0].version
 310         if self.version.linux_modifier is not None:
 311             self.abiname = ''
 312         else:
 313             self.abiname = '-%s' % self.config['abi',]['abiname']
 314         self.vars = {
 315             'upstreamversion': self.version.linux_upstream,
 316             'version': self.version.linux_version,
 317             'source_upstream': self.version.upstream,
 318             'major': self.version.linux_major,
 319             'abiname': self.abiname,
 320         }
 321         self.config['version',] = {'source': self.version.complete, 'abiname': self.abiname}
 322
 323         distribution = self.changelog[0].distribution
 324
 325 # Skip version/distribution checks for SLP
 326         distribution = 'SLP'
 327
 328         if distribution in ('unstable', ):
 329             if (version.linux_revision_experimental or
 330                     version.linux_revision_other):
 331                 raise RuntimeError("Can't upload to %s with a version of %s" %
 332                         (distribution, version))
 333         if distribution in ('experimental', ):
 334             if not version.linux_revision_experimental:
 335                 raise RuntimeError("Can't upload to %s with a version of %s" %
 336                         (distribution, version))
 337
 338     def process_real_image(self, entry, fields, vars):
 339         entry = self.process_package(entry, vars)
 340         for key, value in fields.iteritems():
 341             if key in entry:
 342                 real = entry[key]
 343                 real.extend(value)
 344             elif value:
 345                 entry[key] = value
 346         return entry
 347
 348     def write(self, packages, makefile):
 349         self.write_config()
 350         super(Gencontrol, self).write(packages, makefile)
 351
 352     def write_config(self):
 353         f = file("debian/config.defines.dump", 'w')
 354         self.config.dump(f)
 355         f.close()
 356
 357 if __name__ == '__main__':
 358     Gencontrol()()