shinys000114/linux
1
0
Fork 0
mirror of https://github.com/hardkernel/linux.git synced 2026-06-11 13:27:06 +09:00
Code Issues Packages Projects Releases Wiki Activity

Update Python debian_linux module from linux and use it in gencontrol.py

Browse Source 
svn path=/dists/trunk/linux-tools/; revision=19890
This commit is contained in:
Ben Hutchings
2013-03-02 16:31:41 +00:00
parent 2725cdf944
commit 8c00a1b1a9
6 changed files with 503 additions and 457 deletions
Download Patch File Download Diff File Expand all files Collapse all files

196
debian/lib/python/debian_linux/gencontrol.py vendored
View File

@@ -1,8 +1,10 @@
from config import *
from debian import *
from utils import *
import codecs
from collections import OrderedDict
class PackagesList(SortedDict):
from .debian import *
class PackagesList(OrderedDict):
def append(self, package):
self[package['Package']] = package
@@ -10,16 +12,21 @@ class PackagesList(SortedDict):
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):
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):
r = self.rules.keys()
@@ -28,12 +35,12 @@ class Makefile(object):
self.rules[i].write(out)
class Rule(object):
def __init__(self, name, deps = None, cmds = None):
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):
def add(self, deps=None, cmds=None):
if deps is not None:
self.deps.update(deps)
if cmds is not None:
@@ -56,22 +63,25 @@ class Makefile(object):
else:
out.write('%s:%s\n' % (self.name, deps_string))
class MakeFlags(dict):
def __repr__(self):
repr = super(flags, self).__repr__()
return "%s(%s)" % (self.__class__.__name__, repr)
def __str__(self):
return ' '.join(["%s='%s'" % i for i in self.iteritems()])
return ' '.join(["%s='%s'" % i for i in sorted(self.iteritems())])
def copy(self):
return self.__class__(super(MakeFlags, self).copy())
class Gencontrol(object):
makefile_targets = ('binary-arch', 'build', 'setup', 'source')
def __init__(self, config, templates):
class Gencontrol(object):
makefile_targets = ('binary-arch', 'build-arch', 'setup')
def __init__(self, config, templates, version=Version):
self.config, self.templates = config, templates
self.changelog = Changelog(version=version)
def __call__(self):
packages = PackagesList()
@@ -81,45 +91,42 @@ class Gencontrol(object):
self.do_main(packages, makefile)
self.do_extra(packages, makefile)
self.write_control(packages.itervalues())
self.write_makefile(makefile)
self.write(packages, makefile)
def do_source(self, packages):
source = self.templates["control.source"]
packages['source'] = self.process_package(source[0], self.vars)
source = self.templates["control.source"][0]
source['Source'] = self.changelog[0].source
packages['source'] = self.process_package(source)
def do_main(self, packages, makefile):
config_entry = self.config['base',]
config_entry = self.config['base', ]
vars = self.vars.copy()
vars.update(config_entry)
makeflags = MakeFlags()
extra = {}
self.do_main_setup(vars, makeflags, extra)
self.do_main_packages(packages, extra)
self.do_main_makefile(makefile, makeflags, extra)
for arch in iter(self.config['base',]['arches']):
self.do_arch(packages, makefile, arch, vars.copy(), makeflags.copy(), 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):
makeflags.update({
'VERSION': self.version.linux_version,
'UPSTREAMVERSION': self.version.linux_upstream,
'ABINAME': self.abiname,
})
def do_main_makefile(self, makefile, makeflags, extra):
makefile.add('binary-indep', cmds = ["$(MAKE) -f debian/rules.real binary-indep %s" % makeflags])
def do_main_packages(self, packages, 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 arch in iter(self.config['base', ]['arches']):
self.do_arch(packages, makefile, arch, vars.copy(), makeflags.copy(), extra)
def do_extra(self, packages, makefile):
try:
templates_extra = self.templates["control.extra"]
except IOError:
templates_extra = self.templates.get("control.extra", None)
if templates_extra is None:
return
packages.extend(self.process_packages(templates_extra, {}))
@@ -136,19 +143,15 @@ class Gencontrol(object):
cmds = []
for i in extra_arches[arch]:
tmp = []
if i.has_key('X-Version-Overwrite-Epoch'):
if 'X-Version-Overwrite-Epoch' in i:
tmp.append("-v1:%s" % self.version['source'])
cmds.append("$(MAKE) -f debian/rules.real install-dummy DH_OPTIONS='-p%s' GENCONTROL_ARGS='%s'" % (i['Package'], ' '.join(tmp)))
makefile.add('binary-arch_%s' % arch ['binary-arch_%s_extra' % arch])
makefile.add("binary-arch_%s_extra" % arch, cmds = cmds)
makefile.add('binary-arch_%s' % arch['binary-arch_%s_extra' % arch])
makefile.add("binary-arch_%s_extra" % arch, cmds=cmds)
def do_arch(self, packages, makefile, arch, vars, makeflags, extra):
config_base = self.config['base', arch]
vars.update(config_base)
vars['arch'] = arch
makeflags['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)
@@ -158,29 +161,27 @@ class Gencontrol(object):
pass
def do_arch_makefile(self, makefile, arch, makeflags, extra):
makeflags['ARCH'] = arch
for i in self.makefile_targets:
target1 = i
target2 = "%s_%s" % (i, arch)
target2 = '_'.join((target1, arch))
target3 = '_'.join((target2, 'real'))
makefile.add(target1, [target2])
makefile.add(target2, ['%s_real' % target2])
makefile.add('%s_real' % 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 self.config['base', arch]['featuresets']:
for featureset in self.config['base', arch].get('featuresets', ()):
self.do_featureset(packages, makefile, arch, featureset, vars.copy(), makeflags.copy(), extra)
def do_featureset(self, packages, makefile, arch, featureset, vars, makeflags, extra):
config_base = self.config.merge('base', arch, featureset)
vars.update(config_base)
if not config_base.get('enabled', True):
return
makeflags['FEATURESET'] = featureset
vars['localversion'] = ''
if featureset != 'none':
vars['localversion'] = '-' + featureset
@@ -194,12 +195,14 @@ class Gencontrol(object):
pass
def do_featureset_makefile(self, makefile, arch, featureset, makeflags, extra):
makeflags['FEATURESET'] = featureset
for i in self.makefile_targets:
target1 = "%s_%s" % (i, arch)
target2 = "%s_%s_%s" % (i, arch, featureset)
target1 = '_'.join((i, arch))
target2 = '_'.join((target1, featureset))
target3 = '_'.join((target2, 'real'))
makefile.add(target1, [target2])
makefile.add(target2, ['%s_real' % target2])
makefile.add('%s_real' % target2)
makefile.add(target2, [target3])
def do_featureset_packages(self, packages, makefile, arch, featureset, vars, makeflags, extra):
pass
@@ -210,12 +213,7 @@ class Gencontrol(object):
def do_flavour(self, packages, makefile, arch, featureset, flavour, vars, makeflags, extra):
config_base = self.config.merge('base', arch, featureset, flavour)
vars.update(config_base)
if not vars.has_key('longclass'):
vars['longclass'] = vars['class']
makeflags['FLAVOUR'] = flavour
vars['localversion'] += '-' + flavour
self.do_flavour_setup(vars, makeflags, arch, featureset, flavour, extra)
@@ -227,74 +225,74 @@ class Gencontrol(object):
('kernel-arch', 'KERNEL_ARCH'),
('localversion', 'LOCALVERSION'),
):
if vars.has_key(i[0]):
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 = "%s_%s_%s" % (i, arch, featureset)
target2 = "%s_%s_%s_%s" % (i, arch, featureset, flavour)
target1 = '_'.join((i, arch, featureset))
target2 = '_'.join((target1, flavour))
target3 = '_'.join((target2, 'real'))
makefile.add(target1, [target2])
makefile.add(target2, ['%s_real' % target2])
makefile.add('%s_real' % target2)
makefile.add(target2, [target3])
def do_flavour_packages(self, packages, makefile, arch, featureset, flavour, vars, makeflags, extra):
pass
def process_relation(self, key, e, in_e, vars):
def process_relation(self, dep, vars):
import copy
dep = copy.deepcopy(in_e[key])
dep = copy.deepcopy(dep)
for groups in dep:
for item in groups:
item.name = self.substitute(item.name, vars)
e[key] = dep
if item.version:
item.version = self.substitute(item.version, vars)
return dep
def process_description(self, e, in_e, vars):
in_desc = in_e['Description']
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))
e['Description'] = desc
return desc
def process_package(self, in_entry, vars):
e = Package()
def process_package(self, in_entry, vars={}):
entry = in_entry.__class__()
for key, value in in_entry.iteritems():
if isinstance(value, PackageRelation):
self.process_relation(key, e, in_entry, vars)
elif key == 'Description':
self.process_description(e, in_entry, vars)
elif key[:2] == 'X-':
pass
value = self.process_relation(value, vars)
elif isinstance(value, PackageDescription):
value = self.process_description(value, vars)
else:
e[key] = self.substitute(value, vars)
return e
value = self.substitute(value, vars)
entry[key] = value
return entry
def process_packages(self, in_entries, vars):
entries = []
for i in in_entries:
entries.append(self.process_package(i, vars))
return entries
def process_version_linux(self, version, abiname):
return {
'upstreamversion': version.linux_upstream,
'version': version.linux_version,
'source_upstream': version.upstream,
'abiname': abiname,
}
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)):
for i in xrange(len(s)):
s[i] = self.substitute(s[i], vars)
return s
return [self.substitute(i, vars) for i in s]
def subst(match):
return vars[match.group(1)]
return re.sub(r'@([-_a-z]+)@', subst, s)
return re.sub(r'@([-_a-z]+)@', subst, unicode(s))
def write(self, packages, makefile):
self.write_control(packages.itervalues())
self.write_makefile(makefile)
def write_config(self):
f = file("debian/config.dump", 'w')
self.config.write(f)
f.close()
def write_control(self, list):
self.write_rfc822(file("debian/control", 'w'), list)
self.write_rfc822(codecs.open("debian/control", 'w', 'utf-8'), list)
def write_makefile(self, makefile):
f = file("debian/rules.gen", 'w')
@@ -304,7 +302,5 @@ class Gencontrol(object):
def write_rfc822(self, f, list):
for entry in list:
for key, value in entry.iteritems():
f.write("%s: %s\n" % (key, value))
f.write('\n')
f.write(u"%s: %s\n" % (key, value))
f.write(u'\n')