mirrors/poky
1
0
Fork 0
mirror of https://git.yoctoproject.org/poky synced 2026-01-29 21:08:42 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
62afa02d01794376efab75623f42e7e08af08526
poky/meta/classes-global/package.bbclass
Richard Purdie 62afa02d01 base/package: Move source revision information from PV to PKGV 
Source control information being present in PV used to be a hard requirement
for bitbake to operate correctly. Now that hashes are a required part of task
stamps, this requirement no longer exists.

This means we can defer the hash pieces to PKGV and simplify PV.

Use new bitbake fetcher API to inject the source revisions directly into the hash
allowing removal of some horrible code from base.bbclass and avoiding any hardcoding
about how SRCREV may or may not be used.

Use that API to object the string to append to PKGV and append that directly.

The user visible effect of this change is that PV will no longer have revision
information in it and this will now be appended to PV through PKGV when the
packages are written. Since PV is used in STAMP and WORKDIR, users will see
small directory naming and stamp naming changes.

This will mean that sstate reuse through hash equivalence where the source
revision changes but the output does not will become possible as the sstate
naming will become less specific and no longer contain the revision.

The SRCPV variable will no longer be needed in PV and is effectively now just
a null operation. Usage can be removed over time.

(From OE-Core rev: a8e7b0f932b9ea69b3a218fca18041676c65aba0)

Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
2023-08-24 16:50:24 +01:00

619 lines
23 KiB
Plaintext
Raw Blame History

#
# Copyright OpenEmbedded Contributors
#
# SPDX-License-Identifier: MIT
#
#
# Packaging process
#
# Executive summary: This class iterates over the functions listed in PACKAGEFUNCS
# Taking D and splitting it up into the packages listed in PACKAGES, placing the
# resulting output in PKGDEST.
#
# There are the following default steps but PACKAGEFUNCS can be extended:
#
# a) package_convert_pr_autoinc - convert AUTOINC in PKGV to ${PRSERV_PV_AUTOINC}
#
# b) perform_packagecopy - Copy D into PKGD
#
# c) package_do_split_locales - Split out the locale files, updates FILES and PACKAGES
#
# d) split_and_strip_files - split the files into runtime and debug and strip them.
# Debug files include debug info split, and associated sources that end up in -dbg packages
#
# e) fixup_perms - Fix up permissions in the package before we split it.
#
# f) populate_packages - Split the files in PKGD into separate packages in PKGDEST/<pkgname>
# Also triggers the binary stripping code to put files in -dbg packages.
#
# g) package_do_filedeps - Collect perfile run-time dependency metadata
# The data is stores in FILER{PROVIDES,DEPENDS}_file_pkg variables with
# a list of affected files in FILER{PROVIDES,DEPENDS}FLIST_pkg
#
# h) package_do_shlibs - Look at the shared libraries generated and autotmatically add any
# dependencies found. Also stores the package name so anyone else using this library
# knows which package to depend on.
#
# i) package_do_pkgconfig - Keep track of which packages need and provide which .pc files
#
# j) read_shlibdeps - Reads the stored shlibs information into the metadata
#
# k) package_depchains - Adds automatic dependencies to -dbg and -dev packages
#
# l) emit_pkgdata - saves the packaging data into PKGDATA_DIR for use in later
# packaging steps
inherit packagedata
inherit chrpath
inherit package_pkgdata
inherit insane
PKGD = "${WORKDIR}/package"
PKGDEST = "${WORKDIR}/packages-split"
LOCALE_SECTION ?= ''
ALL_MULTILIB_PACKAGE_ARCHS = "${@all_multilib_tune_values(d, 'PACKAGE_ARCHS')}"
# rpm is used for the per-file dependency identification
# dwarfsrcfiles is used to determine the list of debug source files
PACKAGE_DEPENDS += "rpm-native dwarfsrcfiles-native"
# If your postinstall can execute at rootfs creation time rather than on
# target but depends on a native/cross tool in order to execute, you need to
# list that tool in PACKAGE_WRITE_DEPS. Target package dependencies belong
# in the package dependencies as normal, this is just for native/cross support
# tools at rootfs build time.
PACKAGE_WRITE_DEPS ??= ""
def legitimize_package_name(s):
return oe.package.legitimize_package_name(s)
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, allow_links=False, summary=None):
"""
Used in .bb files to split up dynamically generated subpackages of a
given package, usually plugins or modules.
Arguments:
root -- the path in which to search
file_regex -- regular expression to match searched files. Use
parentheses () to mark the part of this expression
that should be used to derive the module name (to be
substituted where %s is used in other function
arguments as noted below)
output_pattern -- pattern to use for the package names. Must include %s.
description -- description to set for each package. Must include %s.
postinst -- postinstall script to use for all packages (as a
string)
recursive -- True to perform a recursive search - default False
hook -- a hook function to be called for every match. The
function will be called with the following arguments
(in the order listed):
f: full path to the file/directory match
pkg: the package name
file_regex: as above
output_pattern: as above
modulename: the module name derived using file_regex
extra_depends -- extra runtime dependencies (RDEPENDS) to be set for
all packages. The default value of None causes a
dependency on the main package (${PN}) - if you do
not want this, pass '' for this parameter.
aux_files_pattern -- extra item(s) to be added to FILES for each
package. Can be a single string item or a list of
strings for multiple items. Must include %s.
postrm -- postrm script to use for all packages (as a string)
allow_dirs -- True allow directories to be matched - default False
prepend -- if True, prepend created packages to PACKAGES instead
of the default False which appends them
match_path -- match file_regex on the whole relative path to the
root rather than just the file name
aux_files_pattern_verbatim -- extra item(s) to be added to FILES for
each package, using the actual derived module name
rather than converting it to something legal for a
package name. Can be a single string item or a list
of strings for multiple items. Must include %s.
allow_links -- True to allow symlinks to be matched - default False
summary -- Summary to set for each package. Must include %s;
defaults to description if not set.
"""
dvar = d.getVar('PKGD')
root = d.expand(root)
output_pattern = d.expand(output_pattern)
extra_depends = d.expand(extra_depends)
# If the root directory doesn't exist, don't error out later but silently do
# no splitting.
if not os.path.exists(dvar + root):
return []
ml = d.getVar("MLPREFIX")
if ml:
if not output_pattern.startswith(ml):
output_pattern = ml + output_pattern
newdeps = []
for dep in (extra_depends or "").split():
if dep.startswith(ml):
newdeps.append(dep)
else:
newdeps.append(ml + dep)
if newdeps:
extra_depends = " ".join(newdeps)
packages = d.getVar('PACKAGES').split()
split_packages = set()
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 = d.getVar("PN")
if not summary:
summary = description
for o in sorted(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_links and stat.S_ISLNK(mode)) or (allow_dirs and stat.S_ISDIR(mode))):
continue
on = oe.package.legitimize_package_name(m.group(1))
pkg = output_pattern % on
split_packages.add(pkg)
if not pkg in packages:
if prepend:
packages = [pkg] + packages
else:
packages.append(pkg)
oldfiles = d.getVar('FILES:' + pkg)
newfile = os.path.join(root, o)
# These names will be passed through glob() so if the filename actually
# contains * or ? (rare, but possible) we need to handle that specially
newfile = newfile.replace('*', '[*]')
newfile = newfile.replace('?', '[?]')
if not oldfiles:
the_files = [newfile]
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))
d.setVar('FILES:' + pkg, " ".join(the_files))
else:
d.setVar('FILES:' + pkg, oldfiles + " " + newfile)
if extra_depends != '':
d.appendVar('RDEPENDS:' + pkg, ' ' + extra_depends)
if not d.getVar('DESCRIPTION:' + pkg):
d.setVar('DESCRIPTION:' + pkg, description % on)
if not d.getVar('SUMMARY:' + pkg):
d.setVar('SUMMARY:' + pkg, summary % on)
if postinst:
d.setVar('pkg_postinst:' + pkg, postinst)
if postrm:
d.setVar('pkg_postrm:' + pkg, postrm)
if callable(hook):
hook(f, pkg, file_regex, output_pattern, m.group(1))
d.setVar('PACKAGES', ' '.join(packages))
return list(split_packages)
PACKAGE_DEPENDS += "file-native"
python () {
if d.getVar('PACKAGES') != '':
deps = ""
for dep in (d.getVar('PACKAGE_DEPENDS') or "").split():
deps += " %s:do_populate_sysroot" % dep
if d.getVar('PACKAGE_MINIDEBUGINFO') == '1':
deps += ' xz-native:do_populate_sysroot'
d.appendVarFlag('do_package', 'depends', deps)
# shlibs requires any DEPENDS to have already packaged for the *.list files
d.appendVarFlag('do_package', 'deptask', " do_packagedata")
}
PRSERV_ACTIVE = "${@bool(d.getVar("PRSERV_HOST"))}"
PRSERV_ACTIVE[vardepvalue] = "${PRSERV_ACTIVE}"
package_get_auto_pr[vardepsexclude] = "BB_TASKDEPDATA"
package_get_auto_pr[vardeps] += "PRSERV_ACTIVE"
python package_get_auto_pr() {
import oe.prservice
def get_do_package_hash(pn):
if d.getVar("BB_RUNTASK") != "do_package":
taskdepdata = d.getVar("BB_TASKDEPDATA", False)
for dep in taskdepdata:
if taskdepdata[dep][1] == "do_package" and taskdepdata[dep][0] == pn:
return taskdepdata[dep][6]
return None
# Support per recipe PRSERV_HOST
pn = d.getVar('PN')
host = d.getVar("PRSERV_HOST_" + pn)
if not (host is None):
d.setVar("PRSERV_HOST", host)
pkgv = d.getVar("PKGV")
# PR Server not active, handle AUTOINC
if not d.getVar('PRSERV_HOST'):
d.setVar("PRSERV_PV_AUTOINC", "0")
return
auto_pr = None
pv = d.getVar("PV")
version = d.getVar("PRAUTOINX")
pkgarch = d.getVar("PACKAGE_ARCH")
checksum = get_do_package_hash(pn)
# If do_package isn't in the dependencies, we can't get the checksum...
if not checksum:
bb.warn('Task %s requested do_package unihash, but it was not available.' % d.getVar('BB_RUNTASK'))
#taskdepdata = d.getVar("BB_TASKDEPDATA", False)
#for dep in taskdepdata:
# bb.warn('%s:%s = %s' % (taskdepdata[dep][0], taskdepdata[dep][1], taskdepdata[dep][6]))
return
if d.getVar('PRSERV_LOCKDOWN'):
auto_pr = d.getVar('PRAUTO_' + version + '_' + pkgarch) or d.getVar('PRAUTO_' + version) or None
if auto_pr is None:
bb.fatal("Can NOT get PRAUTO from lockdown exported file")
d.setVar('PRAUTO',str(auto_pr))
return
try:
conn = oe.prservice.prserv_make_conn(d)
if conn is not None:
if "AUTOINC" in pkgv:
srcpv = bb.fetch2.get_srcrev(d)
base_ver = "AUTOINC-%s" % version[:version.find(srcpv)]
value = conn.getPR(base_ver, pkgarch, srcpv)
d.setVar("PRSERV_PV_AUTOINC", str(value))
auto_pr = conn.getPR(version, pkgarch, checksum)
conn.close()
except Exception as e:
bb.fatal("Can NOT get PRAUTO, exception %s" % str(e))
if auto_pr is None:
bb.fatal("Can NOT get PRAUTO from remote PR service")
d.setVar('PRAUTO',str(auto_pr))
}
#
# Package functions suitable for inclusion in PACKAGEFUNCS
#
python package_setup_pkgv() {
pkgv = d.getVar("PKGV")
# Expand SRCPV into PKGV if not present
srcpv = bb.fetch.get_pkgv_string(d)
if srcpv and "+" in pkgv:
d.appendVar("PKGV", srcpv)
pkgv = d.getVar("PKGV")
# Adjust pkgv as necessary...
if 'AUTOINC' in pkgv:
d.setVar("PKGV", pkgv.replace("AUTOINC", "${PRSERV_PV_AUTOINC}"))
}
python package_convert_pr_autoinc() {
# Change PRSERV_PV_AUTOINC and EXTENDPRAUTO usage to special values
d.setVar('PRSERV_PV_AUTOINC', '@PRSERV_PV_AUTOINC@')
d.setVar('EXTENDPRAUTO', '@EXTENDPRAUTO@')
}
LOCALEBASEPN ??= "${PN}"
python package_do_split_locales() {
oe.package.split_locales(d)
}
python perform_packagecopy () {
import subprocess
import shutil
dest = d.getVar('D')
dvar = d.getVar('PKGD')
# Start by package population by taking a copy of the installed
# files to operate on
# Preserve sparse files and hard links
cmd = 'tar --exclude=./sysroot-only -cf - -C %s -p -S . | tar -xf - -C %s' % (dest, dvar)
subprocess.check_output(cmd, shell=True, stderr=subprocess.STDOUT)
# replace RPATHs for the nativesdk binaries, to make them relocatable
if bb.data.inherits_class('nativesdk', d) or bb.data.inherits_class('cross-canadian', d):
rpath_replace (dvar, d)
}
perform_packagecopy[cleandirs] = "${PKGD}"
perform_packagecopy[dirs] = "${PKGD}"
python populate_packages () {
oe.package.populate_packages(d)
}
populate_packages[dirs] = "${D}"
python package_fixsymlinks () {
oe.package.process_fixsymlinks(pkgfiles, d)
}
python package_package_name_hook() {
"""
A package_name_hook function can be used to rewrite the package names by
changing PKG. For an example, see debian.bbclass.
"""
pass
}
EXPORT_FUNCTIONS package_name_hook
PKGDESTWORK = "${WORKDIR}/pkgdata"
PKGDATA_VARS = "PN PE PV PR PKGE PKGV PKGR LICENSE DESCRIPTION SUMMARY RDEPENDS RPROVIDES RRECOMMENDS RSUGGESTS RREPLACES RCONFLICTS SECTION PKG ALLOW_EMPTY FILES CONFFILES FILES_INFO PACKAGE_ADD_METADATA pkg_postinst pkg_postrm pkg_preinst pkg_prerm"
python emit_pkgdata() {
import oe.packagedata
oe.packagedata.emit_pkgdata(pkgfiles, d)
}
emit_pkgdata[dirs] = "${PKGDESTWORK}/runtime ${PKGDESTWORK}/runtime-reverse ${PKGDESTWORK}/runtime-rprovides ${PKGDESTWORK}/extended"
ldconfig_postinst_fragment() {
if [ x"$D" = "x" ]; then
if [ -x /sbin/ldconfig ]; then /sbin/ldconfig ; fi
fi
}
RPMDEPS = "${STAGING_LIBDIR_NATIVE}/rpm/rpmdeps --alldeps --define '__font_provides %{nil}'"
python package_do_filedeps() {
oe.package.process_filedeps(pkgfiles, d)
}
SHLIBSDIRS = "${WORKDIR_PKGDATA}/${MLPREFIX}shlibs2"
SHLIBSWORKDIR = "${PKGDESTWORK}/${MLPREFIX}shlibs2"
python package_do_shlibs() {
oe.package.process_shlibs(pkgfiles, d)
}
python package_do_pkgconfig () {
oe.package.process_pkgconfig(pkgfiles, d)
}
python read_shlibdeps () {
pkglibdeps = oe.package.read_libdep_files(d)
packages = d.getVar('PACKAGES').split()
for pkg in packages:
rdepends = bb.utils.explode_dep_versions2(d.getVar('RDEPENDS:' + pkg) or "")
for dep in sorted(pkglibdeps[pkg]):
# Add the dep if it's not already there, or if no comparison is set
if dep not in rdepends:
rdepends[dep] = []
for v in pkglibdeps[pkg][dep]:
if v not in rdepends[dep]:
rdepends[dep].append(v)
d.setVar('RDEPENDS:' + pkg, bb.utils.join_deps(rdepends, commasep=False))
}
python package_depchains() {
oe.package.process_depchains(pkgfiles, d)
}
# Since bitbake can't determine which variables are accessed during package
# iteration, we need to list them here:
PACKAGEVARS = "FILES RDEPENDS RRECOMMENDS SUMMARY DESCRIPTION RSUGGESTS RPROVIDES RCONFLICTS PKG ALLOW_EMPTY pkg_postinst pkg_postrm pkg_postinst_ontarget INITSCRIPT_NAME INITSCRIPT_PARAMS DEBIAN_NOAUTONAME ALTERNATIVE PKGE PKGV PKGR USERADD_PARAM GROUPADD_PARAM CONFFILES SYSTEMD_SERVICE LICENSE SECTION pkg_preinst pkg_prerm RREPLACES GROUPMEMS_PARAM SYSTEMD_AUTO_ENABLE SKIP_FILEDEPS PRIVATE_LIBS PACKAGE_ADD_METADATA"
def gen_packagevar(d, pkgvars="PACKAGEVARS"):
ret = []
pkgs = (d.getVar("PACKAGES") or "").split()
vars = (d.getVar(pkgvars) or "").split()
for v in vars:
ret.append(v)
for p in pkgs:
for v in vars:
ret.append(v + ":" + p)
# Ensure that changes to INCOMPATIBLE_LICENSE re-run do_package for
# affected recipes.
ret.append('_exclude_incompatible-%s' % p)
return " ".join(ret)
# Functions for setting up PKGD
PACKAGE_PREPROCESS_FUNCS ?= ""
# Functions which split PKGD up into separate packages
PACKAGESPLITFUNCS ?= " \
package_do_split_locales \
populate_packages"
# Functions which process metadata based on split packages
PACKAGEFUNCS += " \
package_fixsymlinks \
package_name_hook \
package_do_filedeps \
package_do_shlibs \
package_do_pkgconfig \
read_shlibdeps \
package_depchains \
emit_pkgdata"
python do_package () {
# Change the following version to cause sstate to invalidate the package
# cache. This is useful if an item this class depends on changes in a
# way that the output of this class changes. rpmdeps is a good example
# as any change to rpmdeps requires this to be rerun.
# PACKAGE_BBCLASS_VERSION = "5"
# Init cachedpath
global cpath
cpath = oe.cachedpath.CachedPath()
###########################################################################
# Sanity test the setup
###########################################################################
packages = (d.getVar('PACKAGES') or "").split()
if len(packages) < 1:
bb.debug(1, "No packages to build, skipping do_package")
return
workdir = d.getVar('WORKDIR')
outdir = d.getVar('DEPLOY_DIR')
dest = d.getVar('D')
dvar = d.getVar('PKGD')
pn = d.getVar('PN')
if not workdir or not outdir or not dest or not dvar or not pn:
msg = "WORKDIR, DEPLOY_DIR, D, PN and PKGD all must be defined, unable to package"
oe.qa.handle_error("var-undefined", msg, d)
return
bb.build.exec_func("package_setup_pkgv", d)
bb.build.exec_func("package_convert_pr_autoinc", d)
# Check for conflict between renamed packages and existing ones
# for each package in PACKAGES, check if it will be renamed to an existing one
for p in packages:
localdata = bb.data.createCopy(d)
localdata.setVar('OVERRIDES', p)
rename = localdata.getVar('PKG')
if (rename != None) and rename in packages:
bb.fatal('package "%s" is renamed to "%s" using PKG:%s, but package name already exists'%(p,rename,p))
###########################################################################
# Optimisations
###########################################################################
# Continually expanding complex expressions is inefficient, particularly
# when we write to the datastore and invalidate the expansion cache. This
# code pre-expands some frequently used variables
def expandVar(x, d):
d.setVar(x, d.getVar(x))
for x in 'PN', 'PV', 'BPN', 'TARGET_SYS', 'EXTENDPRAUTO':
expandVar(x, d)
###########################################################################
# Setup PKGD (from D)
###########################################################################
bb.build.exec_func("package_prepare_pkgdata", d)
bb.build.exec_func("perform_packagecopy", d)
for f in (d.getVar('PACKAGE_PREPROCESS_FUNCS') or '').split():
bb.build.exec_func(f, d)
oe.package.process_split_and_strip_files(d)
oe.package.fixup_perms(d)
###########################################################################
# Split up PKGD into PKGDEST
###########################################################################
cpath = oe.cachedpath.CachedPath()
for f in (d.getVar('PACKAGESPLITFUNCS') or '').split():
bb.build.exec_func(f, d)
###########################################################################
# Process PKGDEST
###########################################################################
# Build global list of files in each split package
global pkgfiles
pkgfiles = {}
packages = d.getVar('PACKAGES').split()
pkgdest = d.getVar('PKGDEST')
for pkg in packages:
pkgfiles[pkg] = []
for walkroot, dirs, files in cpath.walk(pkgdest + "/" + pkg):
for file in files:
pkgfiles[pkg].append(walkroot + os.sep + file)
for f in (d.getVar('PACKAGEFUNCS') or '').split():
bb.build.exec_func(f, d)
oe.qa.exit_if_errors(d)
}
do_package[dirs] = "${SHLIBSWORKDIR} ${D}"
do_package[vardeps] += "${PACKAGE_PREPROCESS_FUNCS} ${PACKAGESPLITFUNCS} ${PACKAGEFUNCS} ${@gen_packagevar(d)}"
addtask package after do_install
SSTATETASKS += "do_package"
do_package[cleandirs] = "${PKGDEST} ${PKGDESTWORK}"
do_package[sstate-plaindirs] = "${PKGD} ${PKGDEST} ${PKGDESTWORK}"
do_package_setscene[dirs] = "${STAGING_DIR}"
python do_package_setscene () {
sstate_setscene(d)
}
addtask do_package_setscene
# Copy from PKGDESTWORK to tempdirectory as tempdirectory can be cleaned at both
# do_package_setscene and do_packagedata_setscene leading to races
python do_packagedata () {
bb.build.exec_func("package_setup_pkgv", d)
bb.build.exec_func("package_get_auto_pr", d)
src = d.expand("${PKGDESTWORK}")
dest = d.expand("${WORKDIR}/pkgdata-pdata-input")
oe.path.copyhardlinktree(src, dest)
bb.build.exec_func("packagedata_translate_pr_autoinc", d)
}
do_packagedata[cleandirs] += "${WORKDIR}/pkgdata-pdata-input"
# Translate the EXTENDPRAUTO and AUTOINC to the final values
packagedata_translate_pr_autoinc() {
find ${WORKDIR}/pkgdata-pdata-input -type f | xargs --no-run-if-empty \
sed -e 's,@PRSERV_PV_AUTOINC@,${PRSERV_PV_AUTOINC},g' \
-e 's,@EXTENDPRAUTO@,${EXTENDPRAUTO},g' -i
}
addtask packagedata before do_build after do_package
SSTATETASKS += "do_packagedata"
do_packagedata[sstate-inputdirs] = "${WORKDIR}/pkgdata-pdata-input"
do_packagedata[sstate-outputdirs] = "${PKGDATA_DIR}"
do_packagedata[stamp-extra-info] = "${MACHINE_ARCH}"
python do_packagedata_setscene () {
sstate_setscene(d)
}
addtask do_packagedata_setscene
Reference in New Issue View Git Blame Copy Permalink