From b2f192faabe412adce79534e22efe9fb69ee40e2 Mon Sep 17 00:00:00 2001 From: Richard Purdie Date: Fri, 21 Jul 2006 10:10:31 +0000 Subject: Rename /openembedded/ -> /meta/ git-svn-id: https://svn.o-hand.com/repos/poky/trunk@530 311d38ba-8fff-0310-9ca6-ca027cbcb966 --- meta/classes/package.bbclass | 729 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 729 insertions(+) create mode 100644 meta/classes/package.bbclass (limited to 'meta/classes/package.bbclass') diff --git a/meta/classes/package.bbclass b/meta/classes/package.bbclass new file mode 100644 index 0000000000..9edcc1e5ed --- /dev/null +++ b/meta/classes/package.bbclass @@ -0,0 +1,729 @@ +def legitimize_package_name(s): + return s.lower().replace('_', '-').replace('@', '+').replace(',', '+').replace('/', '-') + +STAGING_PKGMAPS_DIR ?= "${STAGING_DIR}/pkgmaps" + +def add_package_mapping (pkg, new_name, d): + import bb, os + + def encode(str): + import codecs + c = codecs.getencoder("string_escape") + return c(str)[0] + + pmap_dir = bb.data.getVar('STAGING_PKGMAPS_DIR', d, 1) + + bb.mkdirhier(pmap_dir) + + data_file = os.path.join(pmap_dir, pkg) + + f = open(data_file, 'w') + f.write("%s\n" % encode(new_name)) + f.close() + +def get_package_mapping (pkg, d): + import bb, os + + def decode(str): + import codecs + c = codecs.getdecoder("string_escape") + return c(str)[0] + + data_file = bb.data.expand("${STAGING_PKGMAPS_DIR}/%s" % pkg, d) + + if os.access(data_file, os.R_OK): + f = file(data_file, 'r') + lines = f.readlines() + f.close() + for l in lines: + return decode(l).strip() + return pkg + +def runtime_mapping_rename (varname, d): + import bb, os + + #bb.note("%s before: %s" % (varname, bb.data.getVar(varname, d, 1))) + + new_depends = [] + for depend in explode_deps(bb.data.getVar(varname, d, 1) or ""): + # Have to be careful with any version component of the depend + split_depend = depend.split(' (') + new_depend = get_package_mapping(split_depend[0].strip(), d) + if len(split_depend) > 1: + new_depends.append("%s (%s" % (new_depend, split_depend[1])) + else: + new_depends.append(new_depend) + + bb.data.setVar(varname, " ".join(new_depends) or None, d) + + #bb.note("%s after: %s" % (varname, bb.data.getVar(varname, d, 1))) + +python package_mapping_rename_hook () { + runtime_mapping_rename("RDEPENDS", d) + runtime_mapping_rename("RRECOMMENDS", d) + runtime_mapping_rename("RSUGGESTS", d) + runtime_mapping_rename("RPROVIDES", d) + runtime_mapping_rename("RREPLACES", d) + runtime_mapping_rename("RCONFLICTS", d) +} + + +def do_split_packages(d, root, file_regex, output_pattern, description, postinst=None, recursive=False, hook=None, extra_depends=None, aux_files_pattern=None, postrm=None, allow_dirs=False, prepend=False, match_path=False, aux_files_pattern_verbatim=None): + import os, os.path, bb + + dvar = bb.data.getVar('D', d, 1) + if not dvar: + bb.error("D not defined") + return + + packages = bb.data.getVar('PACKAGES', d, 1).split() + if not packages: + # nothing to do + return + + if postinst: + postinst = '#!/bin/sh\n' + postinst + '\n' + if postrm: + postrm = '#!/bin/sh\n' + postrm + '\n' + if not recursive: + objs = os.listdir(dvar + root) + else: + objs = [] + for walkroot, dirs, files in os.walk(dvar + root): + for file in files: + relpath = os.path.join(walkroot, file).replace(dvar + root + '/', '', 1) + if relpath: + objs.append(relpath) + + if extra_depends == None: + extra_depends = bb.data.getVar('PKG_' + packages[0], d, 1) or packages[0] + + for o in objs: + import re, stat + if match_path: + m = re.match(file_regex, o) + else: + m = re.match(file_regex, os.path.basename(o)) + + if not m: + continue + f = os.path.join(dvar + root, o) + mode = os.lstat(f).st_mode + if not (stat.S_ISREG(mode) or (allow_dirs and stat.S_ISDIR(mode))): + continue + on = legitimize_package_name(m.group(1)) + pkg = output_pattern % on + if not pkg in packages: + if prepend: + packages = [pkg] + packages + else: + packages.append(pkg) + the_files = [os.path.join(root, o)] + if aux_files_pattern: + if type(aux_files_pattern) is list: + for fp in aux_files_pattern: + the_files.append(fp % on) + else: + the_files.append(aux_files_pattern % on) + if aux_files_pattern_verbatim: + if type(aux_files_pattern_verbatim) is list: + for fp in aux_files_pattern_verbatim: + the_files.append(fp % m.group(1)) + else: + the_files.append(aux_files_pattern_verbatim % m.group(1)) + bb.data.setVar('FILES_' + pkg, " ".join(the_files), d) + if extra_depends != '': + the_depends = bb.data.getVar('RDEPENDS_' + pkg, d, 1) + if the_depends: + the_depends = '%s %s' % (the_depends, extra_depends) + else: + the_depends = extra_depends + bb.data.setVar('RDEPENDS_' + pkg, the_depends, d) + bb.data.setVar('DESCRIPTION_' + pkg, description % on, d) + if postinst: + bb.data.setVar('pkg_postinst_' + pkg, postinst, d) + if postrm: + bb.data.setVar('pkg_postrm_' + pkg, postrm, d) + else: + oldfiles = bb.data.getVar('FILES_' + pkg, d, 1) + if not oldfiles: + bb.fatal("Package '%s' exists but has no files" % pkg) + bb.data.setVar('FILES_' + pkg, oldfiles + " " + os.path.join(root, o), d) + if callable(hook): + hook(f, pkg, file_regex, output_pattern, m.group(1)) + + bb.data.setVar('PACKAGES', ' '.join(packages), d) + +# Function to strip a single file, called from RUNSTRIP below +# A working 'file' (one which works on the target architecture) +# is necessary for this stuff to work. +#PACKAGE_DEPENDS ?= "file-native" +#DEPENDS_prepend =+ "${PACKAGE_DEPENDS} " +#FIXME: this should be "" when any errors are gone! +IGNORE_STRIP_ERRORS ?= "1" + +runstrip() { + local ro st + st=0 + if { file "$1" || { + oewarn "file $1: failed (forced strip)" >&2 + echo 'not stripped' + } + } | grep -q 'not stripped' + then + oenote "${STRIP} $1" + ro= + test -w "$1" || { + ro=1 + chmod +w "$1" + } + '${STRIP}' "$1" + st=$? + test -n "$ro" && chmod -w "$1" + if test $st -ne 0 + then + oewarn "runstrip: ${STRIP} $1: strip failed" >&2 + if [ x${IGNORE_STRIP_ERRORS} == x1 ] + then + #FIXME: remove this, it's for error detection + if file "$1" 2>/dev/null >&2 + then + (oefatal "${STRIP} $1: command failed" >/dev/tty) + else + (oefatal "file $1: command failed" >/dev/tty) + fi + st=0 + fi + fi + else + oenote "runstrip: skip $1" + fi + return $st +} + +python populate_packages () { + import glob, stat, errno, re + + workdir = bb.data.getVar('WORKDIR', d, 1) + if not workdir: + bb.error("WORKDIR not defined, unable to package") + return + + import os # path manipulations + outdir = bb.data.getVar('DEPLOY_DIR', d, 1) + if not outdir: + bb.error("DEPLOY_DIR not defined, unable to package") + return + bb.mkdirhier(outdir) + + dvar = bb.data.getVar('D', d, 1) + if not dvar: + bb.error("D not defined, unable to package") + return + bb.mkdirhier(dvar) + + packages = bb.data.getVar('PACKAGES', d, 1) + if not packages: + bb.debug(1, "PACKAGES not defined, nothing to package") + return + + pn = bb.data.getVar('PN', d, 1) + if not pn: + bb.error("PN not defined") + return + + os.chdir(dvar) + + def isexec(path): + try: + s = os.stat(path) + except (os.error, AttributeError): + return 0 + return (s[stat.ST_MODE] & stat.S_IEXEC) + + # Sanity check PACKAGES for duplicates - should be moved to + # sanity.bbclass once we have he infrastucture + pkgs = [] + for pkg in packages.split(): + if pkg in pkgs: + bb.error("%s is listed in PACKAGES mutliple times. Undefined behaviour will result." % pkg) + pkgs += pkg + + for pkg in packages.split(): + localdata = bb.data.createCopy(d) + root = os.path.join(workdir, "install", pkg) + + os.system('rm -rf %s' % root) + + bb.data.setVar('ROOT', '', localdata) + bb.data.setVar('ROOT_%s' % pkg, root, localdata) + pkgname = bb.data.getVar('PKG_%s' % pkg, localdata, 1) + if not pkgname: + pkgname = pkg + bb.data.setVar('PKG', pkgname, localdata) + + overrides = bb.data.getVar('OVERRIDES', localdata, 1) + if not overrides: + raise bb.build.FuncFailed('OVERRIDES not defined') + bb.data.setVar('OVERRIDES', overrides+':'+pkg, localdata) + + bb.data.update_data(localdata) + + root = bb.data.getVar('ROOT', localdata, 1) + bb.mkdirhier(root) + filesvar = bb.data.getVar('FILES', localdata, 1) or "" + files = filesvar.split() + stripfunc = "" + for file in files: + if os.path.isabs(file): + file = '.' + file + if not os.path.islink(file): + if os.path.isdir(file): + newfiles = [ os.path.join(file,x) for x in os.listdir(file) ] + if newfiles: + files += newfiles + continue + globbed = glob.glob(file) + if globbed: + if [ file ] != globbed: + files += globbed + continue + if (not os.path.islink(file)) and (not os.path.exists(file)): + continue + fpath = os.path.join(root,file) + dpath = os.path.dirname(fpath) + bb.mkdirhier(dpath) + if (bb.data.getVar('INHIBIT_PACKAGE_STRIP', d, 1) != '1') and not os.path.islink(file) and isexec(file): + stripfunc += "\trunstrip %s || st=1\n" % fpath + ret = bb.movefile(file,fpath) + if ret is None or ret == 0: + raise bb.build.FuncFailed("File population failed") + if not stripfunc == "": + from bb import build + # strip + bb.data.setVar('RUNSTRIP', '\tlocal st\n\tst=0\n%s\treturn $st' % stripfunc, localdata) + bb.data.setVarFlag('RUNSTRIP', 'func', 1, localdata) + bb.build.exec_func('RUNSTRIP', localdata) + del localdata + os.chdir(workdir) + + unshipped = [] + for root, dirs, files in os.walk(dvar): + for f in files: + path = os.path.join(root[len(dvar):], f) + unshipped.append(path) + + if unshipped != []: + bb.note("the following files were installed but not shipped in any package:") + for f in unshipped: + bb.note(" " + f) + + bb.build.exec_func("package_name_hook", d) + + for pkg in packages.split(): + pkgname = bb.data.getVar('PKG_%s' % pkg, d, 1) + if pkgname is None: + bb.data.setVar('PKG_%s' % pkg, pkg, d) + else: + add_package_mapping(pkg, pkgname, d) + + dangling_links = {} + pkg_files = {} + for pkg in packages.split(): + dangling_links[pkg] = [] + pkg_files[pkg] = [] + inst_root = os.path.join(workdir, "install", pkg) + for root, dirs, files in os.walk(inst_root): + for f in files: + path = os.path.join(root, f) + rpath = path[len(inst_root):] + pkg_files[pkg].append(rpath) + try: + s = os.stat(path) + except OSError, (err, strerror): + if err != errno.ENOENT: + raise + target = os.readlink(path) + if target[0] != '/': + target = os.path.join(root[len(inst_root):], target) + dangling_links[pkg].append(os.path.normpath(target)) + + for pkg in packages.split(): + rdepends = explode_deps(bb.data.getVar('RDEPENDS_' + pkg, d, 1) or bb.data.getVar('RDEPENDS', d, 1) or "") + for l in dangling_links[pkg]: + found = False + bb.debug(1, "%s contains dangling link %s" % (pkg, l)) + for p in packages.split(): + for f in pkg_files[p]: + if f == l: + found = True + bb.debug(1, "target found in %s" % p) + if p == pkg: + break + dp = bb.data.getVar('PKG_' + p, d, 1) or p + if not dp in rdepends: + rdepends.append(dp) + break + if found == False: + bb.note("%s contains dangling symlink to %s" % (pkg, l)) + bb.data.setVar('RDEPENDS_' + pkg, " " + " ".join(rdepends), d) + + def write_if_exists(f, pkg, var): + def encode(str): + import codecs + c = codecs.getencoder("string_escape") + return c(str)[0] + + val = bb.data.getVar('%s_%s' % (var, pkg), d, 1) + if val: + f.write('%s_%s: %s\n' % (var, pkg, encode(val))) + + data_file = os.path.join(workdir, "install", pn + ".package") + f = open(data_file, 'w') + f.write("PACKAGES: %s\n" % packages) + for pkg in packages.split(): + write_if_exists(f, pkg, 'DESCRIPTION') + write_if_exists(f, pkg, 'RDEPENDS') + write_if_exists(f, pkg, 'RPROVIDES') + write_if_exists(f, pkg, 'PKG') + write_if_exists(f, pkg, 'ALLOW_EMPTY') + write_if_exists(f, pkg, 'FILES') + write_if_exists(f, pkg, 'pkg_postinst') + write_if_exists(f, pkg, 'pkg_postrm') + write_if_exists(f, pkg, 'pkg_preinst') + write_if_exists(f, pkg, 'pkg_prerm') + f.close() + bb.build.exec_func("read_subpackage_metadata", d) +} + +ldconfig_postinst_fragment() { +if [ x"$D" = "x" ]; then + ldconfig +fi +} + +python package_do_shlibs() { + import os, re, os.path + + exclude_shlibs = bb.data.getVar('EXCLUDE_FROM_SHLIBS', d, 0) + if exclude_shlibs: + bb.note("not generating shlibs") + return + + lib_re = re.compile("^lib.*\.so") + libdir_re = re.compile(".*/lib$") + + packages = bb.data.getVar('PACKAGES', d, 1) + if not packages: + bb.debug(1, "no packages to build; not calculating shlibs") + return + + workdir = bb.data.getVar('WORKDIR', d, 1) + if not workdir: + bb.error("WORKDIR not defined") + return + + staging = bb.data.getVar('STAGING_DIR', d, 1) + if not staging: + bb.error("STAGING_DIR not defined") + return + + ver = bb.data.getVar('PV', d, 1) + if not ver: + bb.error("PV not defined") + return + + target_sys = bb.data.getVar('TARGET_SYS', d, 1) + if not target_sys: + bb.error("TARGET_SYS not defined") + return + + shlibs_dir = os.path.join(staging, target_sys, "shlibs") + old_shlibs_dir = os.path.join(staging, "shlibs") + bb.mkdirhier(shlibs_dir) + + needed = {} + for pkg in packages.split(): + needs_ldconfig = False + bb.debug(2, "calculating shlib provides for %s" % pkg) + + pkgname = bb.data.getVar('PKG_%s' % pkg, d, 1) + if not pkgname: + pkgname = pkg + + needed[pkg] = [] + sonames = list() + top = os.path.join(workdir, "install", pkg) + for root, dirs, files in os.walk(top): + for file in files: + soname = None + path = os.path.join(root, file) + if os.access(path, os.X_OK) or lib_re.match(file): + cmd = (bb.data.getVar('BUILD_PREFIX', d, 1) or "") + "objdump -p " + path + " 2>/dev/null" + fd = os.popen(cmd) + lines = fd.readlines() + fd.close() + for l in lines: + m = re.match("\s+NEEDED\s+([^\s]*)", l) + if m: + needed[pkg].append(m.group(1)) + m = re.match("\s+SONAME\s+([^\s]*)", l) + if m and not m.group(1) in sonames: + sonames.append(m.group(1)) + if m and libdir_re.match(root): + needs_ldconfig = True + shlibs_file = os.path.join(shlibs_dir, pkgname + ".list") + if os.path.exists(shlibs_file): + os.remove(shlibs_file) + shver_file = os.path.join(shlibs_dir, pkgname + ".ver") + if os.path.exists(shver_file): + os.remove(shver_file) + if len(sonames): + fd = open(shlibs_file, 'w') + for s in sonames: + fd.write(s + '\n') + fd.close() + fd = open(shver_file, 'w') + fd.write(ver + '\n') + fd.close() + if needs_ldconfig: + bb.debug(1, 'adding ldconfig call to postinst for %s' % pkg) + postinst = bb.data.getVar('pkg_postinst_%s' % pkg, d, 1) or bb.data.getVar('pkg_postinst', d, 1) + if not postinst: + postinst = '#!/bin/sh\n' + postinst += bb.data.getVar('ldconfig_postinst_fragment', d, 1) + bb.data.setVar('pkg_postinst_%s' % pkg, postinst, d) + + shlib_provider = {} + list_re = re.compile('^(.*)\.list$') + for dir in [old_shlibs_dir, shlibs_dir]: + if not os.path.exists(dir): + continue + for file in os.listdir(dir): + m = list_re.match(file) + if m: + dep_pkg = m.group(1) + fd = open(os.path.join(dir, file)) + lines = fd.readlines() + fd.close() + ver_file = os.path.join(dir, dep_pkg + '.ver') + lib_ver = None + if os.path.exists(ver_file): + fd = open(ver_file) + lib_ver = fd.readline().rstrip() + fd.close() + for l in lines: + shlib_provider[l.rstrip()] = (dep_pkg, lib_ver) + + + for pkg in packages.split(): + bb.debug(2, "calculating shlib requirements for %s" % pkg) + + p_pkg = bb.data.getVar("PKG_%s" % pkg, d, 1) or pkg + + deps = list() + for n in needed[pkg]: + if n in shlib_provider.keys(): + (dep_pkg, ver_needed) = shlib_provider[n] + + if dep_pkg == p_pkg: + continue + + if ver_needed: + dep = "%s (>= %s)" % (dep_pkg, ver_needed) + else: + dep = dep_pkg + if not dep in deps: + deps.append(dep) + else: + bb.note("Couldn't find shared library provider for %s" % n) + + + deps_file = os.path.join(workdir, "install", pkg + ".shlibdeps") + if os.path.exists(deps_file): + os.remove(deps_file) + if len(deps): + fd = open(deps_file, 'w') + for dep in deps: + fd.write(dep + '\n') + fd.close() +} + +python package_do_pkgconfig () { + import re, os + + packages = bb.data.getVar('PACKAGES', d, 1) + if not packages: + bb.debug(1, "no packages to build; not calculating pkgconfig dependencies") + return + + workdir = bb.data.getVar('WORKDIR', d, 1) + if not workdir: + bb.error("WORKDIR not defined") + return + + staging = bb.data.getVar('STAGING_DIR', d, 1) + if not staging: + bb.error("STAGING_DIR not defined") + return + + target_sys = bb.data.getVar('TARGET_SYS', d, 1) + if not target_sys: + bb.error("TARGET_SYS not defined") + return + + shlibs_dir = os.path.join(staging, target_sys, "shlibs") + old_shlibs_dir = os.path.join(staging, "shlibs") + bb.mkdirhier(shlibs_dir) + + pc_re = re.compile('(.*)\.pc$') + var_re = re.compile('(.*)=(.*)') + field_re = re.compile('(.*): (.*)') + + pkgconfig_provided = {} + pkgconfig_needed = {} + for pkg in packages.split(): + pkgconfig_provided[pkg] = [] + pkgconfig_needed[pkg] = [] + top = os.path.join(workdir, "install", pkg) + for root, dirs, files in os.walk(top): + for file in files: + m = pc_re.match(file) + if m: + pd = bb.data.init() + name = m.group(1) + pkgconfig_provided[pkg].append(name) + path = os.path.join(root, file) + if not os.access(path, os.R_OK): + continue + f = open(path, 'r') + lines = f.readlines() + f.close() + for l in lines: + m = var_re.match(l) + if m: + name = m.group(1) + val = m.group(2) + bb.data.setVar(name, bb.data.expand(val, pd), pd) + continue + m = field_re.match(l) + if m: + hdr = m.group(1) + exp = bb.data.expand(m.group(2), pd) + if hdr == 'Requires': + pkgconfig_needed[pkg] += exp.replace(',', ' ').split() + + for pkg in packages.split(): + ppkg = bb.data.getVar("PKG_" + pkg, d, 1) or pkg + pkgs_file = os.path.join(shlibs_dir, ppkg + ".pclist") + if os.path.exists(pkgs_file): + os.remove(pkgs_file) + if pkgconfig_provided[pkg] != []: + f = open(pkgs_file, 'w') + for p in pkgconfig_provided[pkg]: + f.write('%s\n' % p) + f.close() + + for dir in [old_shlibs_dir, shlibs_dir]: + if not os.path.exists(dir): + continue + for file in os.listdir(dir): + m = re.match('^(.*)\.pclist$', file) + if m: + pkg = m.group(1) + fd = open(os.path.join(dir, file)) + lines = fd.readlines() + fd.close() + pkgconfig_provided[pkg] = [] + for l in lines: + pkgconfig_provided[pkg].append(l.rstrip()) + + for pkg in packages.split(): + deps = [] + for n in pkgconfig_needed[pkg]: + found = False + for k in pkgconfig_provided.keys(): + if n in pkgconfig_provided[k]: + if k != pkg and not (k in deps): + deps.append(k) + found = True + if found == False: + bb.note("couldn't find pkgconfig module '%s' in any package" % n) + deps_file = os.path.join(workdir, "install", pkg + ".pcdeps") + if os.path.exists(deps_file): + os.remove(deps_file) + if len(deps): + fd = open(deps_file, 'w') + for dep in deps: + fd.write(dep + '\n') + fd.close() +} + +python package_do_split_locales() { + import os + + if (bb.data.getVar('PACKAGE_NO_LOCALE', d, 1) == '1'): + bb.debug(1, "package requested not splitting locales") + return + + packages = (bb.data.getVar('PACKAGES', d, 1) or "").split() + if not packages: + bb.debug(1, "no packages to build; not splitting locales") + return + + datadir = bb.data.getVar('datadir', d, 1) + if not datadir: + bb.note("datadir not defined") + return + + dvar = bb.data.getVar('D', d, 1) + if not dvar: + bb.error("D not defined") + return + + pn = bb.data.getVar('PN', d, 1) + if not pn: + bb.error("PN not defined") + return + + if pn + '-locale' in packages: + packages.remove(pn + '-locale') + + localedir = os.path.join(dvar + datadir, 'locale') + + if not os.path.isdir(localedir): + bb.debug(1, "No locale files in this package") + return + + locales = os.listdir(localedir) + + mainpkg = packages[0] + + for l in locales: + ln = legitimize_package_name(l) + pkg = pn + '-locale-' + ln + packages.append(pkg) + bb.data.setVar('FILES_' + pkg, os.path.join(datadir, 'locale', l), d) + bb.data.setVar('RDEPENDS_' + pkg, '${PKG_%s} virtual-locale-%s' % (mainpkg, ln), d) + bb.data.setVar('RPROVIDES_' + pkg, '%s-locale %s-translation' % (pn, ln), d) + bb.data.setVar('DESCRIPTION_' + pkg, '%s translation for %s' % (l, pn), d) + + bb.data.setVar('PACKAGES', ' '.join(packages), d) + + rdep = (bb.data.getVar('RDEPENDS_%s' % mainpkg, d, 1) or bb.data.getVar('RDEPENDS', d, 1) or "").split() + rdep.append('%s-locale*' % pn) + bb.data.setVar('RDEPENDS_%s' % mainpkg, ' '.join(rdep), d) +} + +PACKAGEFUNCS = "do_install package_do_split_locales \ + populate_packages package_do_shlibs \ + package_do_pkgconfig read_shlibdeps" +python package_do_package () { + for f in (bb.data.getVar('PACKAGEFUNCS', d, 1) or '').split(): + bb.build.exec_func(f, d) +} + +do_package[dirs] = "${D}" +populate_packages[dirs] = "${D}" +EXPORT_FUNCTIONS do_package do_shlibs do_split_locales mapping_rename_hook +addtask package before do_build after do_populate_staging -- cgit v1.2.3-54-g00ecf