diff options
Diffstat (limited to 'meta/classes/base.bbclass')
| -rw-r--r-- | meta/classes/base.bbclass | 666 |
1 files changed, 388 insertions, 278 deletions
diff --git a/meta/classes/base.bbclass b/meta/classes/base.bbclass index 801896a5b9..d95afb7b9b 100644 --- a/meta/classes/base.bbclass +++ b/meta/classes/base.bbclass @@ -10,13 +10,13 @@ inherit utility-tasks inherit metadata_scm inherit logging -OE_IMPORTS += "os sys time oe.path oe.utils oe.data oe.packagegroup oe.sstatesig oe.lsb" +OE_IMPORTS += "os sys time oe.path oe.utils oe.types oe.package oe.packagegroup oe.sstatesig oe.lsb oe.cachedpath oe.license" OE_IMPORTS[type] = "list" def oe_import(d): import sys - bbpath = d.getVar("BBPATH", True).split(":") + bbpath = d.getVar("BBPATH").split(":") sys.path[0:0] = [os.path.join(dir, "lib") for dir in bbpath] def inject(name, value): @@ -31,16 +31,13 @@ def oe_import(d): imported = __import__(toimport) inject(toimport.split(".", 1)[0], imported) -python oe_import_eh () { - if isinstance(e, bb.event.ConfigParsed): - oe_import(e.data) - e.data.setVar("NATIVELSBSTRING", lsb_distro_identifier(e.data)) -} + return "" -addhandler oe_import_eh +# We need the oe module name space early (before INHERITs get added) +OE_IMPORTED := "${@oe_import(d)}" def lsb_distro_identifier(d): - adjust = d.getVar('LSB_DISTRO_ADJUST', True) + adjust = d.getVar('LSB_DISTRO_ADJUST') adjust_func = None if adjust: try: @@ -50,13 +47,16 @@ def lsb_distro_identifier(d): return oe.lsb.distro_identifier(adjust_func) die() { - bbfatal "$*" + bbfatal_log "$*" } -oe_runmake() { - if [ x"$MAKE" = x ]; then MAKE=make; fi +oe_runmake_call() { bbnote ${MAKE} ${EXTRA_OEMAKE} "$@" - ${MAKE} ${EXTRA_OEMAKE} "$@" || die "oe_runmake failed" + ${MAKE} ${EXTRA_OEMAKE} "$@" +} + +oe_runmake() { + oe_runmake_call "$@" || die "oe_runmake failed" } @@ -71,8 +71,8 @@ def base_dep_prepend(d): # INHIBIT_DEFAULT_DEPS doesn't apply to the patch command. Whether or not # we need that built is the responsibility of the patch function / class, not # the application. - if not d.getVar('INHIBIT_DEFAULT_DEPS'): - if (d.getVar('HOST_SYS', True) != d.getVar('BUILD_SYS', True)): + if not d.getVar('INHIBIT_DEFAULT_DEPS', False): + if (d.getVar('HOST_SYS') != d.getVar('BUILD_SYS')): deps += " virtual/${TARGET_PREFIX}gcc virtual/${TARGET_PREFIX}compilerlibs virtual/libc " return deps @@ -80,157 +80,111 @@ BASEDEPENDS = "${@base_dep_prepend(d)}" DEPENDS_prepend="${BASEDEPENDS} " -FILESPATH = "${@base_set_filespath([ "${FILE_DIRNAME}/${PF}", "${FILE_DIRNAME}/${P}", "${FILE_DIRNAME}/${PN}", "${FILE_DIRNAME}/${BP}", "${FILE_DIRNAME}/${BPN}", "${FILE_DIRNAME}/files", "${FILE_DIRNAME}" ], d)}" +FILESPATH = "${@base_set_filespath(["${FILE_DIRNAME}/${BP}", "${FILE_DIRNAME}/${BPN}", "${FILE_DIRNAME}/files"], d)}" # THISDIR only works properly with imediate expansion as it has to run # in the context of the location its used (:=) -THISDIR = "${@os.path.dirname(d.getVar('FILE', True))}" +THISDIR = "${@os.path.dirname(d.getVar('FILE'))}" def extra_path_elements(d): path = "" - elements = (d.getVar('EXTRANATIVEPATH', True) or "").split() + elements = (d.getVar('EXTRANATIVEPATH') or "").split() for e in elements: path = path + "${STAGING_BINDIR_NATIVE}/" + e + ":" return path PATH_prepend = "${@extra_path_elements(d)}" +def get_lic_checksum_file_list(d): + filelist = [] + lic_files = d.getVar("LIC_FILES_CHKSUM") or '' + tmpdir = d.getVar("TMPDIR") + s = d.getVar("S") + b = d.getVar("B") + workdir = d.getVar("WORKDIR") + + urls = lic_files.split() + for url in urls: + # We only care about items that are absolute paths since + # any others should be covered by SRC_URI. + try: + path = bb.fetch.decodeurl(url)[2] + if not path: + raise bb.fetch.MalformedUrl(url) + + if path[0] == '/': + if path.startswith((tmpdir, s, b, workdir)): + continue + filelist.append(path + ":" + str(os.path.exists(path))) + except bb.fetch.MalformedUrl: + bb.fatal(d.getVar('PN') + ": LIC_FILES_CHKSUM contains an invalid URL: " + url) + return " ".join(filelist) + +def setup_hosttools_dir(dest, toolsvar, d, fatal=True): + tools = d.getVar(toolsvar).split() + origbbenv = d.getVar("BB_ORIGENV", False) + path = origbbenv.getVar("PATH") + bb.utils.mkdirhier(dest) + notfound = [] + for tool in tools: + desttool = os.path.join(dest, tool) + if not os.path.exists(desttool): + srctool = bb.utils.which(path, tool, executable=True) + if "ccache" in srctool: + srctool = bb.utils.which(path, tool, executable=True, direction=1) + if srctool: + os.symlink(srctool, desttool) + else: + notfound.append(tool) + if notfound and fatal: + bb.fatal("The following required tools (as specified by HOSTTOOLS) appear to be unavailable in PATH, please install them in order to proceed:\n %s" % " ".join(notfound)) + addtask fetch do_fetch[dirs] = "${DL_DIR}" do_fetch[file-checksums] = "${@bb.fetch.get_checksum_file_list(d)}" +do_fetch[file-checksums] += " ${@get_lic_checksum_file_list(d)}" +do_fetch[vardeps] += "SRCREV" python base_do_fetch() { - src_uri = (d.getVar('SRC_URI', True) or "").split() + src_uri = (d.getVar('SRC_URI') or "").split() if len(src_uri) == 0: return - localdata = bb.data.createCopy(d) - bb.data.update_data(localdata) - try: - fetcher = bb.fetch2.Fetch(src_uri, localdata) + fetcher = bb.fetch2.Fetch(src_uri, d) fetcher.download() - except bb.fetch2.BBFetchException, e: - raise bb.build.FuncFailed(e) + except bb.fetch2.BBFetchException as e: + bb.fatal(str(e)) } addtask unpack after do_fetch do_unpack[dirs] = "${WORKDIR}" -do_unpack[cleandirs] = "${S}/patches" + +python () { + if d.getVar('S') != d.getVar('WORKDIR'): + d.setVarFlag('do_unpack', 'cleandirs', '${S}') + else: + d.setVarFlag('do_unpack', 'cleandirs', os.path.join('${S}', 'patches')) +} python base_do_unpack() { - src_uri = (d.getVar('SRC_URI', True) or "").split() + src_uri = (d.getVar('SRC_URI') or "").split() if len(src_uri) == 0: return - localdata = bb.data.createCopy(d) - bb.data.update_data(localdata) - - rootdir = localdata.getVar('WORKDIR', True) - try: - fetcher = bb.fetch2.Fetch(src_uri, localdata) - fetcher.unpack(rootdir) - except bb.fetch2.BBFetchException, e: - raise bb.build.FuncFailed(e) + fetcher = bb.fetch2.Fetch(src_uri, d) + fetcher.unpack(d.getVar('WORKDIR')) + except bb.fetch2.BBFetchException as e: + bb.fatal(str(e)) } -GIT_CONFIG_PATH = "${STAGING_DIR_NATIVE}/etc" -GIT_CONFIG = "${GIT_CONFIG_PATH}/gitconfig" - -def generate_git_config(e): - if e.data.getVar('GIT_CORE_CONFIG', True): - gitconfig_path = e.data.getVar('GIT_CONFIG', True) - proxy_command = " gitProxy = %s\n" % e.data.getVar('OE_GIT_PROXY_COMMAND', True) - - bb.mkdirhier(e.data.expand("${GIT_CONFIG_PATH}")) - if (os.path.exists(gitconfig_path)): - os.remove(gitconfig_path) - - f = open(gitconfig_path, 'w') - f.write("[core]\n") - ignore_hosts = e.data.getVar('GIT_PROXY_IGNORE', True).split() - for ignore_host in ignore_hosts: - f.write(" gitProxy = none for %s\n" % ignore_host) - f.write(proxy_command) - f.close - def pkgarch_mapping(d): # Compatibility mappings of TUNE_PKGARCH (opt in) - if d.getVar("PKGARCHCOMPAT_ARMV7A", True): - if d.getVar("TUNE_PKGARCH", True) == "armv7a-vfp-neon": + if d.getVar("PKGARCHCOMPAT_ARMV7A"): + if d.getVar("TUNE_PKGARCH") == "armv7a-vfp-neon": d.setVar("TUNE_PKGARCH", "armv7a") -def preferred_ml_updates(d): - # If any PREFERRED_PROVIDER or PREFERRED_VERSIONS are set, - # we need to mirror these variables in the multilib case; - # likewise the PNBLACKLIST flags. - multilibs = d.getVar('MULTILIBS', True) or "" - if not multilibs: - return - - prefixes = [] - for ext in multilibs.split(): - eext = ext.split(':') - if len(eext) > 1 and eext[0] == 'multilib': - prefixes.append(eext[1]) - - versions = [] - providers = [] - blacklists = d.getVarFlags('PNBLACKLIST') or {} - for v in d.keys(): - if v.startswith("PREFERRED_VERSION_"): - versions.append(v) - if v.startswith("PREFERRED_PROVIDER_"): - providers.append(v) - - for pkg, reason in blacklists.items(): - for p in prefixes: - newpkg = p + "-" + pkg - if not d.getVarFlag('PNBLACKLIST', newpkg, True): - d.setVarFlag('PNBLACKLIST', newpkg, reason) - - for v in versions: - val = d.getVar(v, False) - pkg = v.replace("PREFERRED_VERSION_", "") - if pkg.endswith("-native") or pkg.startswith("nativesdk-"): - continue - for p in prefixes: - newname = "PREFERRED_VERSION_" + p + "-" + pkg - if not d.getVar(newname, False): - d.setVar(newname, val) - - for prov in providers: - val = d.getVar(prov, False) - pkg = prov.replace("PREFERRED_PROVIDER_", "") - if pkg.endswith("-native") or pkg.startswith("nativesdk-"): - continue - virt = "" - if pkg.startswith("virtual/"): - pkg = pkg.replace("virtual/", "") - virt = "virtual/" - for p in prefixes: - newname = "PREFERRED_PROVIDER_" + virt + p + "-" + pkg - if pkg != "kernel": - val = p + "-" + val - if not d.getVar(newname, False): - d.setVar(newname, val) - - - mp = (d.getVar("MULTI_PROVIDER_WHITELIST", True) or "").split() - extramp = [] - for p in mp: - if p.endswith("-native") or p.startswith("nativesdk-"): - continue - virt = "" - if p.startswith("virtual/"): - p = p.replace("virtual/", "") - virt = "virtual/" - for pref in prefixes: - extramp.append(virt + pref + "-" + p) - d.setVar("MULTI_PROVIDER_WHITELIST", " ".join(mp + extramp)) - - def get_layers_branch_rev(d): - layers = (d.getVar("BBLAYERS", True) or "").split() + layers = (d.getVar("BBLAYERS") or "").split() layers_branch_rev = ["%-17s = \"%s:%s\"" % (os.path.basename(i), \ base_get_metadata_git_branch(i, None).strip(), \ base_get_metadata_git_revision(i, None)) \ @@ -257,7 +211,7 @@ BUILDCFG_FUNCS[type] = "list" def buildcfg_vars(d): statusvars = oe.data.typed_value('BUILDCFG_VARS', d) for var in statusvars: - value = d.getVar(var, True) + value = d.getVar(var) if value is not None: yield '%-17s = "%s"' % (var, value) @@ -265,7 +219,7 @@ def buildcfg_neededvars(d): needed_vars = oe.data.typed_value("BUILDCFG_NEEDEDVARS", d) pesteruser = [] for v in needed_vars: - val = d.getVar(v, True) + val = d.getVar(v) if not val or val == 'INVALID': pesteruser.append(v) @@ -273,37 +227,103 @@ def buildcfg_neededvars(d): bb.fatal('The following variable(s) were not set: %s\nPlease set them directly, or choose a MACHINE or DISTRO that sets them.' % ', '.join(pesteruser)) addhandler base_eventhandler +base_eventhandler[eventmask] = "bb.event.ConfigParsed bb.event.BuildStarted bb.event.RecipePreFinalise bb.runqueue.sceneQueueComplete bb.event.RecipeParsed" python base_eventhandler() { + import bb.runqueue + if isinstance(e, bb.event.ConfigParsed): + if not e.data.getVar("NATIVELSBSTRING", False): + e.data.setVar("NATIVELSBSTRING", lsb_distro_identifier(e.data)) e.data.setVar('BB_VERSION', bb.__version__) - generate_git_config(e) pkgarch_mapping(e.data) - preferred_ml_updates(e.data) + oe.utils.features_backfill("DISTRO_FEATURES", e.data) + oe.utils.features_backfill("MACHINE_FEATURES", e.data) + # Works with the line in layer.conf which changes PATH to point here + setup_hosttools_dir(d.getVar('HOSTTOOLS_DIR'), 'HOSTTOOLS', d) + setup_hosttools_dir(d.getVar('HOSTTOOLS_DIR'), 'HOSTTOOLS_NONFATAL', d, fatal=False) if isinstance(e, bb.event.BuildStarted): + localdata = bb.data.createCopy(e.data) statuslines = [] - for func in oe.data.typed_value('BUILDCFG_FUNCS', e.data): + for func in oe.data.typed_value('BUILDCFG_FUNCS', localdata): g = globals() if func not in g: bb.warn("Build configuration function '%s' does not exist" % func) else: - flines = g[func](e.data) + flines = g[func](localdata) if flines: statuslines.extend(flines) - statusheader = e.data.getVar('BUILDCFG_HEADER', True) - bb.plain('\n%s\n%s\n' % (statusheader, '\n'.join(statuslines))) + statusheader = e.data.getVar('BUILDCFG_HEADER') + if statusheader: + bb.plain('\n%s\n%s\n' % (statusheader, '\n'.join(statuslines))) + + # This code is to silence warnings where the SDK variables overwrite the + # target ones and we'd see dulpicate key names overwriting each other + # for various PREFERRED_PROVIDERS + if isinstance(e, bb.event.RecipePreFinalise): + if e.data.getVar("TARGET_PREFIX") == e.data.getVar("SDK_PREFIX"): + e.data.delVar("PREFERRED_PROVIDER_virtual/${TARGET_PREFIX}binutils") + e.data.delVar("PREFERRED_PROVIDER_virtual/${TARGET_PREFIX}gcc-initial") + e.data.delVar("PREFERRED_PROVIDER_virtual/${TARGET_PREFIX}gcc") + e.data.delVar("PREFERRED_PROVIDER_virtual/${TARGET_PREFIX}g++") + e.data.delVar("PREFERRED_PROVIDER_virtual/${TARGET_PREFIX}compilerlibs") + + if isinstance(e, bb.runqueue.sceneQueueComplete): + completions = e.data.expand("${STAGING_DIR}/sstatecompletions") + if os.path.exists(completions): + cmds = set() + with open(completions, "r") as f: + cmds = set(f) + e.data.setVar("completion_function", "\n".join(cmds)) + e.data.setVarFlag("completion_function", "func", "1") + bb.debug(1, "Executing SceneQueue Completion commands: %s" % "\n".join(cmds)) + bb.build.exec_func("completion_function", e.data) + os.remove(completions) + + if isinstance(e, bb.event.RecipeParsed): + # + # If we have multiple providers of virtual/X and a PREFERRED_PROVIDER_virtual/X is set + # skip parsing for all the other providers which will mean they get uninstalled from the + # sysroot since they're now "unreachable". This makes switching virtual/kernel work in + # particular. + # + pn = d.getVar('PN') + source_mirror_fetch = d.getVar('SOURCE_MIRROR_FETCH', False) + if not source_mirror_fetch: + provs = (d.getVar("PROVIDES") or "").split() + multiwhitelist = (d.getVar("MULTI_PROVIDER_WHITELIST") or "").split() + for p in provs: + if p.startswith("virtual/") and p not in multiwhitelist: + profprov = d.getVar("PREFERRED_PROVIDER_" + p) + if profprov and pn != profprov: + raise bb.parse.SkipPackage("PREFERRED_PROVIDER_%s set to %s, not %s" % (p, profprov, pn)) } +CONFIGURESTAMPFILE = "${WORKDIR}/configure.sstate" +CLEANBROKEN = "0" + addtask configure after do_patch -do_configure[dirs] = "${S} ${B}" -do_configure[deptask] = "do_populate_sysroot" +do_configure[dirs] = "${B}" +do_prepare_recipe_sysroot[deptask] = "do_populate_sysroot" base_do_configure() { - : + if [ -n "${CONFIGURESTAMPFILE}" -a -e "${CONFIGURESTAMPFILE}" ]; then + if [ "`cat ${CONFIGURESTAMPFILE}`" != "${BB_TASKHASH}" ]; then + cd ${B} + if [ "${CLEANBROKEN}" != "1" -a \( -e Makefile -o -e makefile -o -e GNUmakefile \) ]; then + oe_runmake clean + fi + find ${B} -ignore_readdir_race -name \*.la -delete + fi + fi + if [ -n "${CONFIGURESTAMPFILE}" ]; then + mkdir -p `dirname ${CONFIGURESTAMPFILE}` + echo ${BB_TASKHASH} > ${CONFIGURESTAMPFILE} + fi } addtask compile after do_configure -do_compile[dirs] = "${S} ${B}" +do_compile[dirs] = "${B}" base_do_compile() { if [ -e Makefile -o -e makefile -o -e GNUmakefile ]; then oe_runmake || die "make failed" @@ -313,7 +333,7 @@ base_do_compile() { } addtask install after do_compile -do_install[dirs] = "${D} ${S} ${B}" +do_install[dirs] = "${B}" # Remove and re-create ${D} so that is it guaranteed to be empty do_install[cleandirs] = "${D}" @@ -326,38 +346,71 @@ base_do_package() { } addtask build after do_populate_sysroot -do_build = "" -do_build[func] = "1" do_build[noexec] = "1" do_build[recrdeptask] += "do_deploy" do_build () { : } +def set_packagetriplet(d): + archs = [] + tos = [] + tvs = [] + + archs.append(d.getVar("PACKAGE_ARCHS").split()) + tos.append(d.getVar("TARGET_OS")) + tvs.append(d.getVar("TARGET_VENDOR")) + + def settriplet(d, varname, archs, tos, tvs): + triplets = [] + for i in range(len(archs)): + for arch in archs[i]: + triplets.append(arch + tvs[i] + "-" + tos[i]) + triplets.reverse() + d.setVar(varname, " ".join(triplets)) + + settriplet(d, "PKGTRIPLETS", archs, tos, tvs) + + variants = d.getVar("MULTILIB_VARIANTS") or "" + for item in variants.split(): + localdata = bb.data.createCopy(d) + overrides = localdata.getVar("OVERRIDES", False) + ":virtclass-multilib-" + item + localdata.setVar("OVERRIDES", overrides) + + archs.append(localdata.getVar("PACKAGE_ARCHS").split()) + tos.append(localdata.getVar("TARGET_OS")) + tvs.append(localdata.getVar("TARGET_VENDOR")) + + settriplet(d, "PKGMLTRIPLETS", archs, tos, tvs) + python () { - import exceptions, string, re + import string, re # Handle PACKAGECONFIG # # These take the form: # - # PACKAGECONFIG ?? = "<default options>" + # PACKAGECONFIG ??= "<default options>" # PACKAGECONFIG[foo] = "--enable-foo,--disable-foo,foo_depends,foo_runtime_depends" pkgconfigflags = d.getVarFlags("PACKAGECONFIG") or {} if pkgconfigflags: - pkgconfig = (d.getVar('PACKAGECONFIG', True) or "").split() - pn = d.getVar("PN", True) - mlprefix = d.getVar("MLPREFIX", True) + pkgconfig = (d.getVar('PACKAGECONFIG') or "").split() + pn = d.getVar("PN") + + mlprefix = d.getVar("MLPREFIX") def expandFilter(appends, extension, prefix): appends = bb.utils.explode_deps(d.expand(" ".join(appends))) newappends = [] for a in appends: - if a.endswith("-native") or a.endswith("-cross"): + if a.endswith("-native") or ("-cross-" in a): newappends.append(a) elif a.startswith("virtual/"): subs = a.split("/", 1)[1] - newappends.append("virtual/" + prefix + subs + extension) + if subs.startswith(prefix): + newappends.append(a + extension) + else: + newappends.append("virtual/" + prefix + subs + extension) else: if a.startswith(prefix): newappends.append(a + extension) @@ -369,11 +422,11 @@ python () { if not appends: return if varname.find("DEPENDS") != -1: - if pn.startswith("nativesdk-"): + if bb.data.inherits_class('nativesdk', d) or bb.data.inherits_class('cross-canadian', d) : appends = expandFilter(appends, "", "nativesdk-") - if pn.endswith("-native"): + elif bb.data.inherits_class('native', d): appends = expandFilter(appends, "-native", "") - if mlprefix: + elif mlprefix: appends = expandFilter(appends, "", mlprefix) varname = d.expand(varname) d.appendVar(varname, " " + " ".join(appends)) @@ -381,13 +434,12 @@ python () { extradeps = [] extrardeps = [] extraconf = [] - for flag, flagval in pkgconfigflags.items(): - if flag == "defaultval": - continue + for flag, flagval in sorted(pkgconfigflags.items()): items = flagval.split(",") num = len(items) if num > 4: - bb.error("Only enable,disable,depend,rdepend can be specified!") + bb.error("%s: PACKAGECONFIG[%s] Only enable,disable,depend,rdepend can be specified!" + % (d.getVar('PN'), flag)) if flag in pkgconfig: if num >= 3 and items[2]: @@ -400,130 +452,190 @@ python () { extraconf.append(items[1]) appendVar('DEPENDS', extradeps) appendVar('RDEPENDS_${PN}', extrardeps) - appendVar('EXTRA_OECONF', extraconf) - - # If PRINC is set, try and increase the PR value by the amount specified - princ = d.getVar('PRINC', True) - if princ and princ != "0": - pr = d.getVar('PR', True) - pr_prefix = re.search("\D+",pr) - prval = re.search("\d+",pr) - if pr_prefix is None or prval is None: - bb.error("Unable to analyse format of PR variable: %s" % pr) - nval = int(prval.group(0)) + int(princ) - pr = pr_prefix.group(0) + str(nval) + pr[prval.end():] - d.setVar('PR', pr) - - pn = d.getVar('PN', True) - license = d.getVar('LICENSE', True) + appendVar('PACKAGECONFIG_CONFARGS', extraconf) + + pn = d.getVar('PN') + license = d.getVar('LICENSE') if license == "INVALID": bb.fatal('This recipe does not have the LICENSE field set (%s)' % pn) - unmatched_license_flag = check_license_flags(d) - if unmatched_license_flag: - bb.debug(1, "Skipping %s because it has a restricted license not" - " whitelisted in LICENSE_FLAGS_WHITELIST" % pn) - raise bb.parse.SkipPackage("because it has a restricted license not" - " whitelisted in LICENSE_FLAGS_WHITELIST") + if bb.data.inherits_class('license', d): + check_license_format(d) + unmatched_license_flag = check_license_flags(d) + if unmatched_license_flag: + bb.debug(1, "Skipping %s because it has a restricted license not" + " whitelisted in LICENSE_FLAGS_WHITELIST" % pn) + raise bb.parse.SkipPackage("because it has a restricted license not" + " whitelisted in LICENSE_FLAGS_WHITELIST") # If we're building a target package we need to use fakeroot (pseudo) # in order to capture permissions, owners, groups and special files if not bb.data.inherits_class('native', d) and not bb.data.inherits_class('cross', d): - d.setVarFlag('do_configure', 'umask', 022) - d.setVarFlag('do_compile', 'umask', 022) + d.setVarFlag('do_unpack', 'umask', '022') + d.setVarFlag('do_configure', 'umask', '022') + d.setVarFlag('do_compile', 'umask', '022') d.appendVarFlag('do_install', 'depends', ' virtual/fakeroot-native:do_populate_sysroot') - d.setVarFlag('do_install', 'fakeroot', 1) - d.setVarFlag('do_install', 'umask', 022) + d.setVarFlag('do_install', 'fakeroot', '1') + d.setVarFlag('do_install', 'umask', '022') d.appendVarFlag('do_package', 'depends', ' virtual/fakeroot-native:do_populate_sysroot') - d.setVarFlag('do_package', 'fakeroot', 1) - d.setVarFlag('do_package', 'umask', 022) - d.setVarFlag('do_package_setscene', 'fakeroot', 1) - source_mirror_fetch = d.getVar('SOURCE_MIRROR_FETCH', 0) + d.setVarFlag('do_package', 'fakeroot', '1') + d.setVarFlag('do_package', 'umask', '022') + d.setVarFlag('do_package_setscene', 'fakeroot', '1') + d.appendVarFlag('do_package_setscene', 'depends', ' virtual/fakeroot-native:do_populate_sysroot') + d.setVarFlag('do_devshell', 'fakeroot', '1') + d.appendVarFlag('do_devshell', 'depends', ' virtual/fakeroot-native:do_populate_sysroot') + + need_machine = d.getVar('COMPATIBLE_MACHINE') + if need_machine: + import re + compat_machines = (d.getVar('MACHINEOVERRIDES') or "").split(":") + for m in compat_machines: + if re.match(need_machine, m): + break + else: + raise bb.parse.SkipPackage("incompatible with machine %s (not in COMPATIBLE_MACHINE)" % d.getVar('MACHINE')) + + source_mirror_fetch = d.getVar('SOURCE_MIRROR_FETCH', False) if not source_mirror_fetch: - need_host = d.getVar('COMPATIBLE_HOST', True) + need_host = d.getVar('COMPATIBLE_HOST') if need_host: import re - this_host = d.getVar('HOST_SYS', True) + this_host = d.getVar('HOST_SYS') if not re.match(need_host, this_host): raise bb.parse.SkipPackage("incompatible with host %s (not in COMPATIBLE_HOST)" % this_host) - need_machine = d.getVar('COMPATIBLE_MACHINE', True) - if need_machine: - import re - this_machine = d.getVar('MACHINE', True) - if this_machine and not re.match(need_machine, this_machine): - this_soc_family = d.getVar('SOC_FAMILY', True) - if (this_soc_family and not re.match(need_machine, this_soc_family)) or not this_soc_family: - raise bb.parse.SkipPackage("incompatible with machine %s (not in COMPATIBLE_MACHINE)" % this_machine) - - - dont_want_license = d.getVar('INCOMPATIBLE_LICENSE', True) - - if dont_want_license and not pn.endswith("-native") and not pn.endswith("-cross") and not pn.endswith("-cross-initial") and not pn.endswith("-cross-intermediate") and not pn.endswith("-crosssdk-intermediate") and not pn.endswith("-crosssdk") and not pn.endswith("-crosssdk-initial") and not pn.endswith("-cross-canadian-%s" % d.getVar('TRANSLATED_TARGET_ARCH', True)) and not pn.startswith("nativesdk-"): - # Internally, we'll use the license mapping. This way INCOMPATIBLE_LICENSE = "GPLv2" and - # INCOMPATIBLE_LICENSE = "GPLv2.0" will pick up all variations of GPL-2.0 - spdx_license = return_spdx(d, dont_want_license) - hosttools_whitelist = (d.getVar('HOSTTOOLS_WHITELIST_%s' % dont_want_license, True) or d.getVar('HOSTTOOLS_WHITELIST_%s' % spdx_license, True) or "").split() - lgplv2_whitelist = (d.getVar('LGPLv2_WHITELIST_%s' % dont_want_license, True) or d.getVar('HOSTTOOLS_WHITELIST_%s' % spdx_license, True) or "").split() - dont_want_whitelist = (d.getVar('WHITELIST_%s' % dont_want_license, True) or d.getVar('HOSTTOOLS_WHITELIST_%s' % spdx_license, True) or "").split() - if pn not in hosttools_whitelist and pn not in lgplv2_whitelist and pn not in dont_want_whitelist: - this_license = d.getVar('LICENSE', True) - # At this point we know the recipe contains an INCOMPATIBLE_LICENSE, however it may contain packages that do not. - packages = d.getVar('PACKAGES', True).split() - dont_skip_recipe = False - skipped_packages = {} - unskipped_packages = [] - for pkg in packages: - if incompatible_license(d, dont_want_license, pkg): - skipped_packages[pkg] = this_license - dont_skip_recipe = True + bad_licenses = (d.getVar('INCOMPATIBLE_LICENSE') or "").split() + + check_license = False if pn.startswith("nativesdk-") else True + for t in ["-native", "-cross-${TARGET_ARCH}", "-cross-initial-${TARGET_ARCH}", + "-crosssdk-${SDK_SYS}", "-crosssdk-initial-${SDK_SYS}", + "-cross-canadian-${TRANSLATED_TARGET_ARCH}"]: + if pn.endswith(d.expand(t)): + check_license = False + if pn.startswith("gcc-source-"): + check_license = False + + if check_license and bad_licenses: + bad_licenses = expand_wildcard_licenses(d, bad_licenses) + + whitelist = [] + incompatwl = [] + for lic in bad_licenses: + spdx_license = return_spdx(d, lic) + for w in ["LGPLv2_WHITELIST_", "WHITELIST_"]: + whitelist.extend((d.getVar(w + lic) or "").split()) + if spdx_license: + whitelist.extend((d.getVar(w + spdx_license) or "").split()) + ''' + We need to track what we are whitelisting and why. If pn is + incompatible we need to be able to note that the image that + is created may infact contain incompatible licenses despite + INCOMPATIBLE_LICENSE being set. + ''' + incompatwl.extend((d.getVar(w + lic) or "").split()) + if spdx_license: + incompatwl.extend((d.getVar(w + spdx_license) or "").split()) + + if not pn in whitelist: + pkgs = d.getVar('PACKAGES').split() + skipped_pkgs = [] + unskipped_pkgs = [] + for pkg in pkgs: + if incompatible_license(d, bad_licenses, pkg): + skipped_pkgs.append(pkg) else: - unskipped_packages.append(pkg) - if not unskipped_packages: - # if we hit here and have excluded all packages, then we can just exclude the recipe - dont_skip_recipe = False - elif skipped_packages and unskipped_packages: - for pkg, license in skipped_packages.iteritems(): - bb.note("SKIPPING the package " + pkg + " at do_rootfs because it's " + this_license) - d.setVar('LICENSE_EXCLUSION-' + pkg, 1) - for index, pkg in enumerate(unskipped_packages): - bb.note("INCLUDING the package " + pkg) - - if dont_skip_recipe is False and incompatible_license(d, dont_want_license): - bb.note("SKIPPING recipe %s because it's %s" % (pn, this_license)) - raise bb.parse.SkipPackage("incompatible with license %s" % this_license) - - - - srcuri = d.getVar('SRC_URI', True) - # Svn packages should DEPEND on subversion-native - if "svn://" in srcuri: - d.appendVarFlag('do_fetch', 'depends', ' subversion-native:do_populate_sysroot') - - # Git packages should DEPEND on git-native - if "git://" in srcuri: - d.appendVarFlag('do_fetch', 'depends', ' git-native:do_populate_sysroot') - - # Mercurial packages should DEPEND on mercurial-native - elif "hg://" in srcuri: - d.appendVarFlag('do_fetch', 'depends', ' mercurial-native:do_populate_sysroot') - - # OSC packages should DEPEND on osc-native - elif "osc://" in srcuri: - d.appendVarFlag('do_fetch', 'depends', ' osc-native:do_populate_sysroot') - - # *.xz should depends on xz-native for unpacking - # Not endswith because of "*.patch.xz;patch=1". Need bb.decodeurl in future - if '.xz' in srcuri: - d.appendVarFlag('do_unpack', 'depends', ' xz-native:do_populate_sysroot') - - # unzip-native should already be staged before unpacking ZIP recipes - if ".zip" in srcuri: - d.appendVarFlag('do_unpack', 'depends', ' unzip-native:do_populate_sysroot') + unskipped_pkgs.append(pkg) + all_skipped = skipped_pkgs and not unskipped_pkgs + if unskipped_pkgs: + for pkg in skipped_pkgs: + bb.debug(1, "SKIPPING the package " + pkg + " at do_rootfs because it's " + license) + mlprefix = d.getVar('MLPREFIX') + d.setVar('LICENSE_EXCLUSION-' + mlprefix + pkg, 1) + for pkg in unskipped_pkgs: + bb.debug(1, "INCLUDING the package " + pkg) + elif all_skipped or incompatible_license(d, bad_licenses): + bb.debug(1, "SKIPPING recipe %s because it's %s" % (pn, license)) + raise bb.parse.SkipPackage("it has an incompatible license: %s" % license) + elif pn in whitelist: + if pn in incompatwl: + bb.note("INCLUDING " + pn + " as buildable despite INCOMPATIBLE_LICENSE because it has been whitelisted") + + # Try to verify per-package (LICENSE_<pkg>) values. LICENSE should be a + # superset of all per-package licenses. We do not do advanced (pattern) + # matching of license expressions - just check that all license strings + # in LICENSE_<pkg> are found in LICENSE. + license_set = oe.license.list_licenses(license) + for pkg in d.getVar('PACKAGES').split(): + pkg_license = d.getVar('LICENSE_' + pkg) + if pkg_license: + unlisted = oe.license.list_licenses(pkg_license) - license_set + if unlisted: + bb.warn("LICENSE_%s includes licenses (%s) that are not " + "listed in LICENSE" % (pkg, ' '.join(unlisted))) + + needsrcrev = False + srcuri = d.getVar('SRC_URI') + for uri in srcuri.split(): + (scheme, _ , path) = bb.fetch.decodeurl(uri)[:3] + + # HTTP/FTP use the wget fetcher + if scheme in ("http", "https", "ftp"): + d.appendVarFlag('do_fetch', 'depends', ' wget-native:do_populate_sysroot') + + # Svn packages should DEPEND on subversion-native + if scheme == "svn": + needsrcrev = True + d.appendVarFlag('do_fetch', 'depends', ' subversion-native:do_populate_sysroot') + + # Git packages should DEPEND on git-native + elif scheme in ("git", "gitsm"): + needsrcrev = True + d.appendVarFlag('do_fetch', 'depends', ' git-native:do_populate_sysroot') + + # Mercurial packages should DEPEND on mercurial-native + elif scheme == "hg": + needsrcrev = True + d.appendVarFlag('do_fetch', 'depends', ' mercurial-native:do_populate_sysroot') + + # Perforce packages support SRCREV = "${AUTOREV}" + elif scheme == "p4": + needsrcrev = True + + # OSC packages should DEPEND on osc-native + elif scheme == "osc": + d.appendVarFlag('do_fetch', 'depends', ' osc-native:do_populate_sysroot') + + elif scheme == "npm": + d.appendVarFlag('do_fetch', 'depends', ' nodejs-native:do_populate_sysroot') + + # *.lz4 should DEPEND on lz4-native for unpacking + if path.endswith('.lz4'): + d.appendVarFlag('do_unpack', 'depends', ' lz4-native:do_populate_sysroot') + + # *.lz should DEPEND on lzip-native for unpacking + elif path.endswith('.lz'): + d.appendVarFlag('do_unpack', 'depends', ' lzip-native:do_populate_sysroot') + + # *.xz should DEPEND on xz-native for unpacking + elif path.endswith('.xz'): + d.appendVarFlag('do_unpack', 'depends', ' xz-native:do_populate_sysroot') + + # .zip should DEPEND on unzip-native for unpacking + elif path.endswith('.zip'): + d.appendVarFlag('do_unpack', 'depends', ' unzip-native:do_populate_sysroot') + + # file is needed by rpm2cpio.sh + elif path.endswith('.src.rpm'): + d.appendVarFlag('do_unpack', 'depends', ' file-native:do_populate_sysroot') + + if needsrcrev: + d.setVar("SRCPV", "${@bb.fetch2.get_srcrev(d)}") + + set_packagetriplet(d) # 'multimachine' handling - mach_arch = d.getVar('MACHINE_ARCH', True) - pkg_arch = d.getVar('PACKAGE_ARCH', True) + mach_arch = d.getVar('MACHINE_ARCH') + pkg_arch = d.getVar('PACKAGE_ARCH') if (pkg_arch == mach_arch): # Already machine specific - nothing further to do @@ -533,11 +645,11 @@ python () { # We always try to scan SRC_URI for urls with machine overrides # unless the package sets SRC_URI_OVERRIDES_PACKAGE_ARCH=0 # - override = d.getVar('SRC_URI_OVERRIDES_PACKAGE_ARCH', True) + override = d.getVar('SRC_URI_OVERRIDES_PACKAGE_ARCH') if override != '0': paths = [] - fpaths = (d.getVar('FILESPATH', True) or '').split(':') - machine = d.getVar('MACHINE', True) + fpaths = (d.getVar('FILESPATH') or '').split(':') + machine = d.getVar('MACHINE') for p in fpaths: if os.path.basename(p) == machine and os.path.isdir(p): paths.append(p) @@ -554,37 +666,35 @@ python () { d.setVar('PACKAGE_ARCH', "${MACHINE_ARCH}") return - packages = d.getVar('PACKAGES', True).split() + packages = d.getVar('PACKAGES').split() for pkg in packages: - pkgarch = d.getVar("PACKAGE_ARCH_%s" % pkg, True) + pkgarch = d.getVar("PACKAGE_ARCH_%s" % pkg) # We could look for != PACKAGE_ARCH here but how to choose # if multiple differences are present? # Look through PACKAGE_ARCHS for the priority order? if pkgarch and pkgarch == mach_arch: d.setVar('PACKAGE_ARCH', "${MACHINE_ARCH}") - bb.warn("Recipe %s is marked as only being architecture specific but seems to have machine specific packages?! The recipe may as well mark itself as machine specific directly." % d.getVar("PN", True)) + bb.warn("Recipe %s is marked as only being architecture specific but seems to have machine specific packages?! The recipe may as well mark itself as machine specific directly." % d.getVar("PN")) } addtask cleansstate after do_clean python do_cleansstate() { sstate_clean_cachefiles(d) } - addtask cleanall after do_cleansstate +do_cleansstate[nostamp] = "1" + python do_cleanall() { - src_uri = (d.getVar('SRC_URI', True) or "").split() + src_uri = (d.getVar('SRC_URI') or "").split() if len(src_uri) == 0: return - localdata = bb.data.createCopy(d) - bb.data.update_data(localdata) - try: - fetcher = bb.fetch2.Fetch(src_uri, localdata) + fetcher = bb.fetch2.Fetch(src_uri, d) fetcher.clean() - except bb.fetch2.BBFetchException, e: - raise bb.build.FuncFailed(e) + except bb.fetch2.BBFetchException as e: + bb.fatal(str(e)) } do_cleanall[nostamp] = "1" |