| # Development tool - standard commands plugin |
| # |
| # Copyright (C) 2014-2016 Intel Corporation |
| # |
| # This program is free software; you can redistribute it and/or modify |
| # it under the terms of the GNU General Public License version 2 as |
| # published by the Free Software Foundation. |
| # |
| # This program is distributed in the hope that it will be useful, |
| # but WITHOUT ANY WARRANTY; without even the implied warranty of |
| # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| # GNU General Public License for more details. |
| # |
| # You should have received a copy of the GNU General Public License along |
| # with this program; if not, write to the Free Software Foundation, Inc., |
| # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. |
| """Devtool standard plugins""" |
| |
| import os |
| import sys |
| import re |
| import shutil |
| import subprocess |
| import tempfile |
| import logging |
| import argparse |
| import argparse_oe |
| import scriptutils |
| import errno |
| import glob |
| import filecmp |
| from collections import OrderedDict |
| from devtool import exec_build_env_command, setup_tinfoil, check_workspace_recipe, use_external_build, setup_git_repo, recipe_to_append, get_bbclassextend_targets, ensure_npm, DevtoolError |
| from devtool import parse_recipe |
| |
| logger = logging.getLogger('devtool') |
| |
| |
| def add(args, config, basepath, workspace): |
| """Entry point for the devtool 'add' subcommand""" |
| import bb |
| import oe.recipeutils |
| |
| if not args.recipename and not args.srctree and not args.fetch and not args.fetchuri: |
| raise argparse_oe.ArgumentUsageError('At least one of recipename, srctree, fetchuri or -f/--fetch must be specified', 'add') |
| |
| # These are positional arguments, but because we're nice, allow |
| # specifying e.g. source tree without name, or fetch URI without name or |
| # source tree (if we can detect that that is what the user meant) |
| if scriptutils.is_src_url(args.recipename): |
| if not args.fetchuri: |
| if args.fetch: |
| raise DevtoolError('URI specified as positional argument as well as -f/--fetch') |
| args.fetchuri = args.recipename |
| args.recipename = '' |
| elif scriptutils.is_src_url(args.srctree): |
| if not args.fetchuri: |
| if args.fetch: |
| raise DevtoolError('URI specified as positional argument as well as -f/--fetch') |
| args.fetchuri = args.srctree |
| args.srctree = '' |
| elif args.recipename and not args.srctree: |
| if os.sep in args.recipename: |
| args.srctree = args.recipename |
| args.recipename = None |
| elif os.path.isdir(args.recipename): |
| logger.warn('Ambiguous argument "%s" - assuming you mean it to be the recipe name' % args.recipename) |
| |
| if args.srctree and os.path.isfile(args.srctree): |
| args.fetchuri = 'file://' + os.path.abspath(args.srctree) |
| args.srctree = '' |
| |
| if args.fetch: |
| if args.fetchuri: |
| raise DevtoolError('URI specified as positional argument as well as -f/--fetch') |
| else: |
| logger.warn('-f/--fetch option is deprecated - you can now simply specify the URL to fetch as a positional argument instead') |
| args.fetchuri = args.fetch |
| |
| if args.recipename: |
| if args.recipename in workspace: |
| raise DevtoolError("recipe %s is already in your workspace" % |
| args.recipename) |
| reason = oe.recipeutils.validate_pn(args.recipename) |
| if reason: |
| raise DevtoolError(reason) |
| |
| if args.srctree: |
| srctree = os.path.abspath(args.srctree) |
| srctreeparent = None |
| tmpsrcdir = None |
| else: |
| srctree = None |
| srctreeparent = get_default_srctree(config) |
| bb.utils.mkdirhier(srctreeparent) |
| tmpsrcdir = tempfile.mkdtemp(prefix='devtoolsrc', dir=srctreeparent) |
| |
| if srctree and os.path.exists(srctree): |
| if args.fetchuri: |
| if not os.path.isdir(srctree): |
| raise DevtoolError("Cannot fetch into source tree path %s as " |
| "it exists and is not a directory" % |
| srctree) |
| elif os.listdir(srctree): |
| raise DevtoolError("Cannot fetch into source tree path %s as " |
| "it already exists and is non-empty" % |
| srctree) |
| elif not args.fetchuri: |
| if args.srctree: |
| raise DevtoolError("Specified source tree %s could not be found" % |
| args.srctree) |
| elif srctree: |
| raise DevtoolError("No source tree exists at default path %s - " |
| "either create and populate this directory, " |
| "or specify a path to a source tree, or a " |
| "URI to fetch source from" % srctree) |
| else: |
| raise DevtoolError("You must either specify a source tree " |
| "or a URI to fetch source from") |
| |
| if args.version: |
| if '_' in args.version or ' ' in args.version: |
| raise DevtoolError('Invalid version string "%s"' % args.version) |
| |
| if args.color == 'auto' and sys.stdout.isatty(): |
| color = 'always' |
| else: |
| color = args.color |
| extracmdopts = '' |
| if args.fetchuri: |
| if args.fetchuri.startswith('npm://'): |
| ensure_npm(config, basepath, args.fixed_setup) |
| |
| source = args.fetchuri |
| if srctree: |
| extracmdopts += ' -x %s' % srctree |
| else: |
| extracmdopts += ' -x %s' % tmpsrcdir |
| else: |
| source = srctree |
| if args.recipename: |
| extracmdopts += ' -N %s' % args.recipename |
| if args.version: |
| extracmdopts += ' -V %s' % args.version |
| if args.binary: |
| extracmdopts += ' -b' |
| if args.also_native: |
| extracmdopts += ' --also-native' |
| if args.src_subdir: |
| extracmdopts += ' --src-subdir "%s"' % args.src_subdir |
| if args.autorev: |
| extracmdopts += ' -a' |
| |
| tempdir = tempfile.mkdtemp(prefix='devtool') |
| try: |
| while True: |
| try: |
| stdout, _ = exec_build_env_command(config.init_path, basepath, 'recipetool --color=%s create -o %s "%s" %s' % (color, tempdir, source, extracmdopts)) |
| except bb.process.ExecutionError as e: |
| if e.exitcode == 14: |
| # FIXME this is a horrible hack that is unfortunately |
| # necessary due to the fact that we can't run bitbake from |
| # inside recipetool since recipetool keeps tinfoil active |
| # with references to it throughout the code, so we have |
| # to exit out and come back here to do it. |
| ensure_npm(config, basepath, args.fixed_setup) |
| continue |
| elif e.exitcode == 15: |
| raise DevtoolError('Could not auto-determine recipe name, please specify it on the command line') |
| else: |
| raise DevtoolError('Command \'%s\' failed:\n%s' % (e.command, e.stdout)) |
| break |
| |
| recipes = glob.glob(os.path.join(tempdir, '*.bb')) |
| if recipes: |
| recipename = os.path.splitext(os.path.basename(recipes[0]))[0].split('_')[0] |
| if recipename in workspace: |
| raise DevtoolError('A recipe with the same name as the one being created (%s) already exists in your workspace' % recipename) |
| recipedir = os.path.join(config.workspace_path, 'recipes', recipename) |
| bb.utils.mkdirhier(recipedir) |
| recipefile = os.path.join(recipedir, os.path.basename(recipes[0])) |
| appendfile = recipe_to_append(recipefile, config) |
| if os.path.exists(appendfile): |
| # This shouldn't be possible, but just in case |
| raise DevtoolError('A recipe with the same name as the one being created already exists in your workspace') |
| if os.path.exists(recipefile): |
| raise DevtoolError('A recipe file %s already exists in your workspace; this shouldn\'t be there - please delete it before continuing' % recipefile) |
| if tmpsrcdir: |
| srctree = os.path.join(srctreeparent, recipename) |
| if os.path.exists(tmpsrcdir): |
| if os.path.exists(srctree): |
| if os.path.isdir(srctree): |
| try: |
| os.rmdir(srctree) |
| except OSError as e: |
| if e.errno == errno.ENOTEMPTY: |
| raise DevtoolError('Source tree path %s already exists and is not empty' % srctree) |
| else: |
| raise |
| else: |
| raise DevtoolError('Source tree path %s already exists and is not a directory' % srctree) |
| logger.info('Using default source tree path %s' % srctree) |
| shutil.move(tmpsrcdir, srctree) |
| else: |
| raise DevtoolError('Couldn\'t find source tree created by recipetool') |
| bb.utils.mkdirhier(recipedir) |
| shutil.move(recipes[0], recipefile) |
| # Move any additional files created by recipetool |
| for fn in os.listdir(tempdir): |
| shutil.move(os.path.join(tempdir, fn), recipedir) |
| else: |
| raise DevtoolError('Command \'%s\' did not create any recipe file:\n%s' % (e.command, e.stdout)) |
| attic_recipe = os.path.join(config.workspace_path, 'attic', recipename, os.path.basename(recipefile)) |
| if os.path.exists(attic_recipe): |
| logger.warn('A modified recipe from a previous invocation exists in %s - you may wish to move this over the top of the new recipe if you had changes in it that you want to continue with' % attic_recipe) |
| finally: |
| if tmpsrcdir and os.path.exists(tmpsrcdir): |
| shutil.rmtree(tmpsrcdir) |
| shutil.rmtree(tempdir) |
| |
| for fn in os.listdir(recipedir): |
| _add_md5(config, recipename, os.path.join(recipedir, fn)) |
| |
| tinfoil = setup_tinfoil(config_only=True, basepath=basepath) |
| try: |
| rd = oe.recipeutils.parse_recipe(tinfoil.cooker, recipefile, None) |
| if not rd: |
| return 1 |
| |
| if args.fetchuri and not args.no_git: |
| setup_git_repo(srctree, args.version, 'devtool', d=tinfoil.config_data) |
| |
| initial_rev = None |
| if os.path.exists(os.path.join(srctree, '.git')): |
| (stdout, _) = bb.process.run('git rev-parse HEAD', cwd=srctree) |
| initial_rev = stdout.rstrip() |
| |
| if args.src_subdir: |
| srctree = os.path.join(srctree, args.src_subdir) |
| |
| bb.utils.mkdirhier(os.path.dirname(appendfile)) |
| with open(appendfile, 'w') as f: |
| f.write('inherit externalsrc\n') |
| f.write('EXTERNALSRC = "%s"\n' % srctree) |
| |
| b_is_s = use_external_build(args.same_dir, args.no_same_dir, rd) |
| if b_is_s: |
| f.write('EXTERNALSRC_BUILD = "%s"\n' % srctree) |
| if initial_rev: |
| f.write('\n# initial_rev: %s\n' % initial_rev) |
| |
| if args.binary: |
| f.write('do_install_append() {\n') |
| f.write(' rm -rf ${D}/.git\n') |
| f.write(' rm -f ${D}/singletask.lock\n') |
| f.write('}\n') |
| |
| if bb.data.inherits_class('npm', rd): |
| f.write('do_install_append() {\n') |
| f.write(' # Remove files added to source dir by devtool/externalsrc\n') |
| f.write(' rm -f ${NPM_INSTALLDIR}/singletask.lock\n') |
| f.write(' rm -rf ${NPM_INSTALLDIR}/.git\n') |
| f.write(' rm -rf ${NPM_INSTALLDIR}/oe-local-files\n') |
| f.write(' for symlink in ${EXTERNALSRC_SYMLINKS} ; do\n') |
| f.write(' rm -f ${NPM_INSTALLDIR}/${symlink%%:*}\n') |
| f.write(' done\n') |
| f.write('}\n') |
| |
| _add_md5(config, recipename, appendfile) |
| |
| logger.info('Recipe %s has been automatically created; further editing may be required to make it fully functional' % recipefile) |
| |
| finally: |
| tinfoil.shutdown() |
| |
| return 0 |
| |
| |
| def _check_compatible_recipe(pn, d): |
| """Check if the recipe is supported by devtool""" |
| if pn == 'perf': |
| raise DevtoolError("The perf recipe does not actually check out " |
| "source and thus cannot be supported by this tool", |
| 4) |
| |
| if pn in ['kernel-devsrc', 'package-index'] or pn.startswith('gcc-source'): |
| raise DevtoolError("The %s recipe is not supported by this tool" % pn, 4) |
| |
| if bb.data.inherits_class('image', d): |
| raise DevtoolError("The %s recipe is an image, and therefore is not " |
| "supported by this tool" % pn, 4) |
| |
| if bb.data.inherits_class('populate_sdk', d): |
| raise DevtoolError("The %s recipe is an SDK, and therefore is not " |
| "supported by this tool" % pn, 4) |
| |
| if bb.data.inherits_class('packagegroup', d): |
| raise DevtoolError("The %s recipe is a packagegroup, and therefore is " |
| "not supported by this tool" % pn, 4) |
| |
| if bb.data.inherits_class('meta', d): |
| raise DevtoolError("The %s recipe is a meta-recipe, and therefore is " |
| "not supported by this tool" % pn, 4) |
| |
| if bb.data.inherits_class('externalsrc', d) and d.getVar('EXTERNALSRC', True): |
| # Not an incompatibility error per se, so we don't pass the error code |
| raise DevtoolError("externalsrc is currently enabled for the %s " |
| "recipe. This prevents the normal do_patch task " |
| "from working. You will need to disable this " |
| "first." % pn) |
| |
| def _move_file(src, dst): |
| """Move a file. Creates all the directory components of destination path.""" |
| dst_d = os.path.dirname(dst) |
| if dst_d: |
| bb.utils.mkdirhier(dst_d) |
| shutil.move(src, dst) |
| |
| def _copy_file(src, dst): |
| """Copy a file. Creates all the directory components of destination path.""" |
| dst_d = os.path.dirname(dst) |
| if dst_d: |
| bb.utils.mkdirhier(dst_d) |
| shutil.copy(src, dst) |
| |
| def _git_ls_tree(repodir, treeish='HEAD', recursive=False): |
| """List contents of a git treeish""" |
| import bb |
| cmd = ['git', 'ls-tree', '-z', treeish] |
| if recursive: |
| cmd.append('-r') |
| out, _ = bb.process.run(cmd, cwd=repodir) |
| ret = {} |
| for line in out.split('\0'): |
| if line: |
| split = line.split(None, 4) |
| ret[split[3]] = split[0:3] |
| return ret |
| |
| def _git_exclude_path(srctree, path): |
| """Return pathspec (list of paths) that excludes certain path""" |
| # NOTE: "Filtering out" files/paths in this way is not entirely reliable - |
| # we don't catch files that are deleted, for example. A more reliable way |
| # to implement this would be to use "negative pathspecs" which were |
| # introduced in Git v1.9.0. Revisit this when/if the required Git version |
| # becomes greater than that. |
| path = os.path.normpath(path) |
| recurse = True if len(path.split(os.path.sep)) > 1 else False |
| git_files = list(_git_ls_tree(srctree, 'HEAD', recurse).keys()) |
| if path in git_files: |
| git_files.remove(path) |
| return git_files |
| else: |
| return ['.'] |
| |
| def _ls_tree(directory): |
| """Recursive listing of files in a directory""" |
| ret = [] |
| for root, dirs, files in os.walk(directory): |
| ret.extend([os.path.relpath(os.path.join(root, fname), directory) for |
| fname in files]) |
| return ret |
| |
| |
| def extract(args, config, basepath, workspace): |
| """Entry point for the devtool 'extract' subcommand""" |
| import bb |
| |
| tinfoil = _prep_extract_operation(config, basepath, args.recipename) |
| if not tinfoil: |
| # Error already shown |
| return 1 |
| try: |
| rd = parse_recipe(config, tinfoil, args.recipename, True) |
| if not rd: |
| return 1 |
| |
| srctree = os.path.abspath(args.srctree) |
| initial_rev = _extract_source(srctree, args.keep_temp, args.branch, False, rd) |
| logger.info('Source tree extracted to %s' % srctree) |
| |
| if initial_rev: |
| return 0 |
| else: |
| return 1 |
| finally: |
| tinfoil.shutdown() |
| |
| def sync(args, config, basepath, workspace): |
| """Entry point for the devtool 'sync' subcommand""" |
| import bb |
| |
| tinfoil = _prep_extract_operation(config, basepath, args.recipename) |
| if not tinfoil: |
| # Error already shown |
| return 1 |
| try: |
| rd = parse_recipe(config, tinfoil, args.recipename, True) |
| if not rd: |
| return 1 |
| |
| srctree = os.path.abspath(args.srctree) |
| initial_rev = _extract_source(srctree, args.keep_temp, args.branch, True, rd) |
| logger.info('Source tree %s synchronized' % srctree) |
| |
| if initial_rev: |
| return 0 |
| else: |
| return 1 |
| finally: |
| tinfoil.shutdown() |
| |
| class BbTaskExecutor(object): |
| """Class for executing bitbake tasks for a recipe |
| |
| FIXME: This is very awkward. Unfortunately it's not currently easy to |
| properly execute tasks outside of bitbake itself, until then this has to |
| suffice if we are to handle e.g. linux-yocto's extra tasks |
| """ |
| |
| def __init__(self, rdata): |
| self.rdata = rdata |
| self.executed = [] |
| |
| def exec_func(self, func, report): |
| """Run bitbake task function""" |
| if not func in self.executed: |
| deps = self.rdata.getVarFlag(func, 'deps', False) |
| if deps: |
| for taskdepfunc in deps: |
| self.exec_func(taskdepfunc, True) |
| if report: |
| logger.info('Executing %s...' % func) |
| fn = self.rdata.getVar('FILE', True) |
| localdata = bb.build._task_data(fn, func, self.rdata) |
| try: |
| bb.build.exec_func(func, localdata) |
| except bb.build.FuncFailed as e: |
| raise DevtoolError(str(e)) |
| self.executed.append(func) |
| |
| |
| class PatchTaskExecutor(BbTaskExecutor): |
| def __init__(self, rdata): |
| import oe.patch |
| self.check_git = False |
| self.useroptions = [] |
| oe.patch.GitApplyTree.gitCommandUserOptions(self.useroptions, d=rdata) |
| super(PatchTaskExecutor, self).__init__(rdata) |
| |
| def exec_func(self, func, report): |
| from oe.patch import GitApplyTree |
| srcsubdir = self.rdata.getVar('S', True) |
| haspatches = False |
| if func == 'do_patch': |
| patchdir = os.path.join(srcsubdir, 'patches') |
| if os.path.exists(patchdir): |
| if os.listdir(patchdir): |
| haspatches = True |
| else: |
| os.rmdir(patchdir) |
| |
| super(PatchTaskExecutor, self).exec_func(func, report) |
| if self.check_git and os.path.exists(srcsubdir): |
| if func == 'do_patch': |
| if os.path.exists(patchdir): |
| shutil.rmtree(patchdir) |
| if haspatches: |
| stdout, _ = bb.process.run('git status --porcelain patches', cwd=srcsubdir) |
| if stdout: |
| bb.process.run('git checkout patches', cwd=srcsubdir) |
| |
| stdout, _ = bb.process.run('git status --porcelain', cwd=srcsubdir) |
| if stdout: |
| bb.process.run('git add .; git %s commit -a -m "Committing changes from %s\n\n%s"' % (' '.join(self.useroptions), func, GitApplyTree.ignore_commit_prefix + ' - from %s' % func), cwd=srcsubdir) |
| |
| |
| def _prep_extract_operation(config, basepath, recipename, tinfoil=None): |
| """HACK: Ugly workaround for making sure that requirements are met when |
| trying to extract a package. Returns the tinfoil instance to be used.""" |
| if not tinfoil: |
| tinfoil = setup_tinfoil(basepath=basepath) |
| |
| rd = parse_recipe(config, tinfoil, recipename, True) |
| if not rd: |
| return None |
| |
| if bb.data.inherits_class('kernel-yocto', rd): |
| tinfoil.shutdown() |
| try: |
| stdout, _ = exec_build_env_command(config.init_path, basepath, |
| 'bitbake kern-tools-native') |
| tinfoil = setup_tinfoil(basepath=basepath) |
| except bb.process.ExecutionError as err: |
| raise DevtoolError("Failed to build kern-tools-native:\n%s" % |
| err.stdout) |
| return tinfoil |
| |
| |
| def _extract_source(srctree, keep_temp, devbranch, sync, d): |
| """Extract sources of a recipe""" |
| import bb.event |
| import oe.recipeutils |
| |
| def eventfilter(name, handler, event, d): |
| """Bitbake event filter for devtool extract operation""" |
| if name == 'base_eventhandler': |
| return True |
| else: |
| return False |
| |
| if hasattr(bb.event, 'set_eventfilter'): |
| bb.event.set_eventfilter(eventfilter) |
| |
| pn = d.getVar('PN', True) |
| |
| _check_compatible_recipe(pn, d) |
| |
| if sync: |
| if not os.path.exists(srctree): |
| raise DevtoolError("output path %s does not exist" % srctree) |
| else: |
| if os.path.exists(srctree): |
| if not os.path.isdir(srctree): |
| raise DevtoolError("output path %s exists and is not a directory" % |
| srctree) |
| elif os.listdir(srctree): |
| raise DevtoolError("output path %s already exists and is " |
| "non-empty" % srctree) |
| |
| if 'noexec' in (d.getVarFlags('do_unpack', False) or []): |
| raise DevtoolError("The %s recipe has do_unpack disabled, unable to " |
| "extract source" % pn, 4) |
| |
| if not sync: |
| # Prepare for shutil.move later on |
| bb.utils.mkdirhier(srctree) |
| os.rmdir(srctree) |
| |
| # We don't want notes to be printed, they are too verbose |
| origlevel = bb.logger.getEffectiveLevel() |
| if logger.getEffectiveLevel() > logging.DEBUG: |
| bb.logger.setLevel(logging.WARNING) |
| |
| initial_rev = None |
| tempdir = tempfile.mkdtemp(prefix='devtool') |
| try: |
| crd = d.createCopy() |
| # Make a subdir so we guard against WORKDIR==S |
| workdir = os.path.join(tempdir, 'workdir') |
| crd.setVar('WORKDIR', workdir) |
| crd.setVar('T', os.path.join(tempdir, 'temp')) |
| if not crd.getVar('S', True).startswith(workdir): |
| # Usually a shared workdir recipe (kernel, gcc) |
| # Try to set a reasonable default |
| if bb.data.inherits_class('kernel', d): |
| crd.setVar('S', '${WORKDIR}/source') |
| else: |
| crd.setVar('S', '${WORKDIR}/%s' % os.path.basename(d.getVar('S', True))) |
| if bb.data.inherits_class('kernel', d): |
| # We don't want to move the source to STAGING_KERNEL_DIR here |
| crd.setVar('STAGING_KERNEL_DIR', '${S}') |
| |
| task_executor = PatchTaskExecutor(crd) |
| |
| crd.setVar('EXTERNALSRC_forcevariable', '') |
| |
| logger.info('Fetching %s...' % pn) |
| task_executor.exec_func('do_fetch', False) |
| logger.info('Unpacking...') |
| task_executor.exec_func('do_unpack', False) |
| if bb.data.inherits_class('kernel-yocto', d): |
| # Extra step for kernel to populate the source directory |
| logger.info('Doing kernel checkout...') |
| task_executor.exec_func('do_kernel_checkout', False) |
| srcsubdir = crd.getVar('S', True) |
| |
| task_executor.check_git = True |
| |
| # Move local source files into separate subdir |
| recipe_patches = [os.path.basename(patch) for patch in |
| oe.recipeutils.get_recipe_patches(crd)] |
| local_files = oe.recipeutils.get_recipe_local_files(crd) |
| |
| # Ignore local files with subdir={BP} |
| srcabspath = os.path.abspath(srcsubdir) |
| local_files = [fname for fname in local_files if |
| os.path.exists(os.path.join(workdir, fname)) and |
| (srcabspath == workdir or not |
| os.path.join(workdir, fname).startswith(srcabspath + |
| os.sep))] |
| if local_files: |
| for fname in local_files: |
| _move_file(os.path.join(workdir, fname), |
| os.path.join(tempdir, 'oe-local-files', fname)) |
| with open(os.path.join(tempdir, 'oe-local-files', '.gitignore'), |
| 'w') as f: |
| f.write('# Ignore local files, by default. Remove this file ' |
| 'if you want to commit the directory to Git\n*\n') |
| |
| if srcsubdir == workdir: |
| # Find non-patch non-local sources that were "unpacked" to srctree |
| # directory |
| src_files = [fname for fname in _ls_tree(workdir) if |
| os.path.basename(fname) not in recipe_patches] |
| # Force separate S so that patch files can be left out from srctree |
| srcsubdir = tempfile.mkdtemp(dir=workdir) |
| crd.setVar('S', srcsubdir) |
| # Move source files to S |
| for path in src_files: |
| _move_file(os.path.join(workdir, path), |
| os.path.join(srcsubdir, path)) |
| elif os.path.dirname(srcsubdir) != workdir: |
| # Handle if S is set to a subdirectory of the source |
| srcsubdir = os.path.join(workdir, os.path.relpath(srcsubdir, workdir).split(os.sep)[0]) |
| |
| scriptutils.git_convert_standalone_clone(srcsubdir) |
| |
| # Make sure that srcsubdir exists |
| bb.utils.mkdirhier(srcsubdir) |
| if not os.path.exists(srcsubdir) or not os.listdir(srcsubdir): |
| logger.warning("no source unpacked to S, either the %s recipe " |
| "doesn't use any source or the correct source " |
| "directory could not be determined" % pn) |
| |
| setup_git_repo(srcsubdir, crd.getVar('PV', True), devbranch, d=d) |
| |
| (stdout, _) = bb.process.run('git rev-parse HEAD', cwd=srcsubdir) |
| initial_rev = stdout.rstrip() |
| |
| crd.setVar('PATCHTOOL', 'git') |
| |
| logger.info('Patching...') |
| task_executor.exec_func('do_patch', False) |
| |
| bb.process.run('git tag -f devtool-patched', cwd=srcsubdir) |
| |
| kconfig = None |
| if bb.data.inherits_class('kernel-yocto', d): |
| # Store generate and store kernel config |
| logger.info('Generating kernel config') |
| task_executor.exec_func('do_configure', False) |
| kconfig = os.path.join(crd.getVar('B', True), '.config') |
| |
| |
| tempdir_localdir = os.path.join(tempdir, 'oe-local-files') |
| srctree_localdir = os.path.join(srctree, 'oe-local-files') |
| |
| if sync: |
| bb.process.run('git fetch file://' + srcsubdir + ' ' + devbranch + ':' + devbranch, cwd=srctree) |
| |
| # Move oe-local-files directory to srctree |
| # As the oe-local-files is not part of the constructed git tree, |
| # remove them directly during the synchrounizating might surprise |
| # the users. Instead, we move it to oe-local-files.bak and remind |
| # user in the log message. |
| if os.path.exists(srctree_localdir + '.bak'): |
| shutil.rmtree(srctree_localdir, srctree_localdir + '.bak') |
| |
| if os.path.exists(srctree_localdir): |
| logger.info('Backing up current local file directory %s' % srctree_localdir) |
| shutil.move(srctree_localdir, srctree_localdir + '.bak') |
| |
| if os.path.exists(tempdir_localdir): |
| logger.info('Syncing local source files to srctree...') |
| shutil.copytree(tempdir_localdir, srctree_localdir) |
| else: |
| # Move oe-local-files directory to srctree |
| if os.path.exists(tempdir_localdir): |
| logger.info('Adding local source files to srctree...') |
| shutil.move(tempdir_localdir, srcsubdir) |
| |
| shutil.move(srcsubdir, srctree) |
| |
| if kconfig: |
| logger.info('Copying kernel config to srctree') |
| shutil.copy2(kconfig, srctree) |
| |
| finally: |
| bb.logger.setLevel(origlevel) |
| |
| if keep_temp: |
| logger.info('Preserving temporary directory %s' % tempdir) |
| else: |
| shutil.rmtree(tempdir) |
| return initial_rev |
| |
| def _add_md5(config, recipename, filename): |
| """Record checksum of a file (or recursively for a directory) to the md5-file of the workspace""" |
| import bb.utils |
| |
| def addfile(fn): |
| md5 = bb.utils.md5_file(fn) |
| with open(os.path.join(config.workspace_path, '.devtool_md5'), 'a') as f: |
| f.write('%s|%s|%s\n' % (recipename, os.path.relpath(fn, config.workspace_path), md5)) |
| |
| if os.path.isdir(filename): |
| for root, _, files in os.walk(filename): |
| for f in files: |
| addfile(os.path.join(root, f)) |
| else: |
| addfile(filename) |
| |
| def _check_preserve(config, recipename): |
| """Check if a file was manually changed and needs to be saved in 'attic' |
| directory""" |
| import bb.utils |
| origfile = os.path.join(config.workspace_path, '.devtool_md5') |
| newfile = os.path.join(config.workspace_path, '.devtool_md5_new') |
| preservepath = os.path.join(config.workspace_path, 'attic', recipename) |
| with open(origfile, 'r') as f: |
| with open(newfile, 'w') as tf: |
| for line in f.readlines(): |
| splitline = line.rstrip().split('|') |
| if splitline[0] == recipename: |
| removefile = os.path.join(config.workspace_path, splitline[1]) |
| try: |
| md5 = bb.utils.md5_file(removefile) |
| except IOError as err: |
| if err.errno == 2: |
| # File no longer exists, skip it |
| continue |
| else: |
| raise |
| if splitline[2] != md5: |
| bb.utils.mkdirhier(preservepath) |
| preservefile = os.path.basename(removefile) |
| logger.warn('File %s modified since it was written, preserving in %s' % (preservefile, preservepath)) |
| shutil.move(removefile, os.path.join(preservepath, preservefile)) |
| else: |
| os.remove(removefile) |
| else: |
| tf.write(line) |
| os.rename(newfile, origfile) |
| |
| def modify(args, config, basepath, workspace): |
| """Entry point for the devtool 'modify' subcommand""" |
| import bb |
| import oe.recipeutils |
| |
| if args.recipename in workspace: |
| raise DevtoolError("recipe %s is already in your workspace" % |
| args.recipename) |
| |
| tinfoil = setup_tinfoil(basepath=basepath) |
| try: |
| rd = parse_recipe(config, tinfoil, args.recipename, True) |
| if not rd: |
| return 1 |
| |
| pn = rd.getVar('PN', True) |
| if pn != args.recipename: |
| logger.info('Mapping %s to %s' % (args.recipename, pn)) |
| if pn in workspace: |
| raise DevtoolError("recipe %s is already in your workspace" % |
| pn) |
| |
| if args.srctree: |
| srctree = os.path.abspath(args.srctree) |
| else: |
| srctree = get_default_srctree(config, pn) |
| |
| if args.no_extract and not os.path.isdir(srctree): |
| raise DevtoolError("--no-extract specified and source path %s does " |
| "not exist or is not a directory" % |
| srctree) |
| if not args.no_extract: |
| tinfoil = _prep_extract_operation(config, basepath, pn, tinfoil) |
| if not tinfoil: |
| # Error already shown |
| return 1 |
| |
| recipefile = rd.getVar('FILE', True) |
| appendfile = recipe_to_append(recipefile, config, args.wildcard) |
| if os.path.exists(appendfile): |
| raise DevtoolError("Another variant of recipe %s is already in your " |
| "workspace (only one variant of a recipe can " |
| "currently be worked on at once)" |
| % pn) |
| |
| _check_compatible_recipe(pn, rd) |
| |
| initial_rev = None |
| commits = [] |
| if not args.no_extract: |
| initial_rev = _extract_source(srctree, False, args.branch, False, rd) |
| if not initial_rev: |
| return 1 |
| logger.info('Source tree extracted to %s' % srctree) |
| # Get list of commits since this revision |
| (stdout, _) = bb.process.run('git rev-list --reverse %s..HEAD' % initial_rev, cwd=srctree) |
| commits = stdout.split() |
| else: |
| if os.path.exists(os.path.join(srctree, '.git')): |
| # Check if it's a tree previously extracted by us |
| try: |
| (stdout, _) = bb.process.run('git branch --contains devtool-base', cwd=srctree) |
| except bb.process.ExecutionError: |
| stdout = '' |
| for line in stdout.splitlines(): |
| if line.startswith('*'): |
| (stdout, _) = bb.process.run('git rev-parse devtool-base', cwd=srctree) |
| initial_rev = stdout.rstrip() |
| if not initial_rev: |
| # Otherwise, just grab the head revision |
| (stdout, _) = bb.process.run('git rev-parse HEAD', cwd=srctree) |
| initial_rev = stdout.rstrip() |
| |
| # Check that recipe isn't using a shared workdir |
| s = os.path.abspath(rd.getVar('S', True)) |
| workdir = os.path.abspath(rd.getVar('WORKDIR', True)) |
| if s.startswith(workdir) and s != workdir and os.path.dirname(s) != workdir: |
| # Handle if S is set to a subdirectory of the source |
| srcsubdir = os.path.relpath(s, workdir).split(os.sep, 1)[1] |
| srctree = os.path.join(srctree, srcsubdir) |
| |
| bb.utils.mkdirhier(os.path.dirname(appendfile)) |
| with open(appendfile, 'w') as f: |
| f.write('FILESEXTRAPATHS_prepend := "${THISDIR}/${PN}:"\n') |
| # Local files can be modified/tracked in separate subdir under srctree |
| # Mostly useful for packages with S != WORKDIR |
| f.write('FILESPATH_prepend := "%s:"\n' % |
| os.path.join(srctree, 'oe-local-files')) |
| |
| f.write('\ninherit externalsrc\n') |
| f.write('# NOTE: We use pn- overrides here to avoid affecting multiple variants in the case where the recipe uses BBCLASSEXTEND\n') |
| f.write('EXTERNALSRC_pn-%s = "%s"\n' % (pn, srctree)) |
| |
| b_is_s = use_external_build(args.same_dir, args.no_same_dir, rd) |
| if b_is_s: |
| f.write('EXTERNALSRC_BUILD_pn-%s = "%s"\n' % (pn, srctree)) |
| |
| if bb.data.inherits_class('kernel', rd): |
| f.write('SRCTREECOVEREDTASKS = "do_validate_branches do_kernel_checkout ' |
| 'do_fetch do_unpack do_patch do_kernel_configme do_kernel_configcheck"\n') |
| f.write('\ndo_configure_append() {\n' |
| ' cp ${B}/.config ${S}/.config.baseline\n' |
| ' ln -sfT ${B}/.config ${S}/.config.new\n' |
| '}\n') |
| if initial_rev: |
| f.write('\n# initial_rev: %s\n' % initial_rev) |
| for commit in commits: |
| f.write('# commit: %s\n' % commit) |
| |
| _add_md5(config, pn, appendfile) |
| |
| logger.info('Recipe %s now set up to build from %s' % (pn, srctree)) |
| |
| finally: |
| tinfoil.shutdown() |
| |
| return 0 |
| |
| def _get_patchset_revs(srctree, recipe_path, initial_rev=None): |
| """Get initial and update rev of a recipe. These are the start point of the |
| whole patchset and start point for the patches to be re-generated/updated. |
| """ |
| import bb |
| |
| # Parse initial rev from recipe if not specified |
| commits = [] |
| with open(recipe_path, 'r') as f: |
| for line in f: |
| if line.startswith('# initial_rev:'): |
| if not initial_rev: |
| initial_rev = line.split(':')[-1].strip() |
| elif line.startswith('# commit:'): |
| commits.append(line.split(':')[-1].strip()) |
| |
| update_rev = initial_rev |
| changed_revs = None |
| if initial_rev: |
| # Find first actually changed revision |
| stdout, _ = bb.process.run('git rev-list --reverse %s..HEAD' % |
| initial_rev, cwd=srctree) |
| newcommits = stdout.split() |
| for i in range(min(len(commits), len(newcommits))): |
| if newcommits[i] == commits[i]: |
| update_rev = commits[i] |
| |
| try: |
| stdout, _ = bb.process.run('git cherry devtool-patched', |
| cwd=srctree) |
| except bb.process.ExecutionError as err: |
| stdout = None |
| |
| if stdout is not None: |
| changed_revs = [] |
| for line in stdout.splitlines(): |
| if line.startswith('+ '): |
| rev = line.split()[1] |
| if rev in newcommits: |
| changed_revs.append(rev) |
| |
| return initial_rev, update_rev, changed_revs |
| |
| def _remove_file_entries(srcuri, filelist): |
| """Remove file:// entries from SRC_URI""" |
| remaining = filelist[:] |
| entries = [] |
| for fname in filelist: |
| basename = os.path.basename(fname) |
| for i in range(len(srcuri)): |
| if (srcuri[i].startswith('file://') and |
| os.path.basename(srcuri[i].split(';')[0]) == basename): |
| entries.append(srcuri[i]) |
| remaining.remove(fname) |
| srcuri.pop(i) |
| break |
| return entries, remaining |
| |
| def _remove_source_files(append, files, destpath): |
| """Unlink existing patch files""" |
| for path in files: |
| if append: |
| if not destpath: |
| raise Exception('destpath should be set here') |
| path = os.path.join(destpath, os.path.basename(path)) |
| |
| if os.path.exists(path): |
| logger.info('Removing file %s' % path) |
| # FIXME "git rm" here would be nice if the file in question is |
| # tracked |
| # FIXME there's a chance that this file is referred to by |
| # another recipe, in which case deleting wouldn't be the |
| # right thing to do |
| os.remove(path) |
| # Remove directory if empty |
| try: |
| os.rmdir(os.path.dirname(path)) |
| except OSError as ose: |
| if ose.errno != errno.ENOTEMPTY: |
| raise |
| |
| |
| def _export_patches(srctree, rd, start_rev, destdir): |
| """Export patches from srctree to given location. |
| Returns three-tuple of dicts: |
| 1. updated - patches that already exist in SRCURI |
| 2. added - new patches that don't exist in SRCURI |
| 3 removed - patches that exist in SRCURI but not in exported patches |
| In each dict the key is the 'basepath' of the URI and value is the |
| absolute path to the existing file in recipe space (if any). |
| """ |
| import oe.recipeutils |
| from oe.patch import GitApplyTree |
| updated = OrderedDict() |
| added = OrderedDict() |
| seqpatch_re = re.compile('^([0-9]{4}-)?(.+)') |
| |
| existing_patches = dict((os.path.basename(path), path) for path in |
| oe.recipeutils.get_recipe_patches(rd)) |
| |
| # Generate patches from Git, exclude local files directory |
| patch_pathspec = _git_exclude_path(srctree, 'oe-local-files') |
| GitApplyTree.extractPatches(srctree, start_rev, destdir, patch_pathspec) |
| |
| new_patches = sorted(os.listdir(destdir)) |
| for new_patch in new_patches: |
| # Strip numbering from patch names. If it's a git sequence named patch, |
| # the numbers might not match up since we are starting from a different |
| # revision This does assume that people are using unique shortlog |
| # values, but they ought to be anyway... |
| new_basename = seqpatch_re.match(new_patch).group(2) |
| found = False |
| for old_patch in existing_patches: |
| old_basename = seqpatch_re.match(old_patch).group(2) |
| if new_basename == old_basename: |
| updated[new_patch] = existing_patches.pop(old_patch) |
| found = True |
| # Rename patch files |
| if new_patch != old_patch: |
| os.rename(os.path.join(destdir, new_patch), |
| os.path.join(destdir, old_patch)) |
| break |
| if not found: |
| added[new_patch] = None |
| return (updated, added, existing_patches) |
| |
| |
| def _create_kconfig_diff(srctree, rd, outfile): |
| """Create a kconfig fragment""" |
| # Only update config fragment if both config files exist |
| orig_config = os.path.join(srctree, '.config.baseline') |
| new_config = os.path.join(srctree, '.config.new') |
| if os.path.exists(orig_config) and os.path.exists(new_config): |
| cmd = ['diff', '--new-line-format=%L', '--old-line-format=', |
| '--unchanged-line-format=', orig_config, new_config] |
| pipe = subprocess.Popen(cmd, stdout=subprocess.PIPE, |
| stderr=subprocess.PIPE) |
| stdout, stderr = pipe.communicate() |
| if pipe.returncode == 1: |
| logger.info("Updating config fragment %s" % outfile) |
| with open(outfile, 'w') as fobj: |
| fobj.write(stdout) |
| elif pipe.returncode == 0: |
| logger.info("Would remove config fragment %s" % outfile) |
| if os.path.exists(outfile): |
| # Remove fragment file in case of empty diff |
| logger.info("Removing config fragment %s" % outfile) |
| os.unlink(outfile) |
| else: |
| raise bb.process.ExecutionError(cmd, pipe.returncode, stdout, stderr) |
| return True |
| return False |
| |
| |
| def _export_local_files(srctree, rd, destdir): |
| """Copy local files from srctree to given location. |
| Returns three-tuple of dicts: |
| 1. updated - files that already exist in SRCURI |
| 2. added - new files files that don't exist in SRCURI |
| 3 removed - files that exist in SRCURI but not in exported files |
| In each dict the key is the 'basepath' of the URI and value is the |
| absolute path to the existing file in recipe space (if any). |
| """ |
| import oe.recipeutils |
| |
| # Find out local files (SRC_URI files that exist in the "recipe space"). |
| # Local files that reside in srctree are not included in patch generation. |
| # Instead they are directly copied over the original source files (in |
| # recipe space). |
| existing_files = oe.recipeutils.get_recipe_local_files(rd) |
| new_set = None |
| updated = OrderedDict() |
| added = OrderedDict() |
| removed = OrderedDict() |
| local_files_dir = os.path.join(srctree, 'oe-local-files') |
| git_files = _git_ls_tree(srctree) |
| if 'oe-local-files' in git_files: |
| # If tracked by Git, take the files from srctree HEAD. First get |
| # the tree object of the directory |
| tmp_index = os.path.join(srctree, '.git', 'index.tmp.devtool') |
| tree = git_files['oe-local-files'][2] |
| bb.process.run(['git', 'checkout', tree, '--', '.'], cwd=srctree, |
| env=dict(os.environ, GIT_WORK_TREE=destdir, |
| GIT_INDEX_FILE=tmp_index)) |
| new_set = list(_git_ls_tree(srctree, tree, True).keys()) |
| elif os.path.isdir(local_files_dir): |
| # If not tracked by Git, just copy from working copy |
| new_set = _ls_tree(os.path.join(srctree, 'oe-local-files')) |
| bb.process.run(['cp', '-ax', |
| os.path.join(srctree, 'oe-local-files', '.'), destdir]) |
| else: |
| new_set = [] |
| |
| # Special handling for kernel config |
| if bb.data.inherits_class('kernel-yocto', rd): |
| fragment_fn = 'devtool-fragment.cfg' |
| fragment_path = os.path.join(destdir, fragment_fn) |
| if _create_kconfig_diff(srctree, rd, fragment_path): |
| if os.path.exists(fragment_path): |
| if fragment_fn not in new_set: |
| new_set.append(fragment_fn) |
| # Copy fragment to local-files |
| if os.path.isdir(local_files_dir): |
| shutil.copy2(fragment_path, local_files_dir) |
| else: |
| if fragment_fn in new_set: |
| new_set.remove(fragment_fn) |
| # Remove fragment from local-files |
| if os.path.exists(os.path.join(local_files_dir, fragment_fn)): |
| os.unlink(os.path.join(local_files_dir, fragment_fn)) |
| |
| if new_set is not None: |
| for fname in new_set: |
| if fname in existing_files: |
| origpath = existing_files.pop(fname) |
| workpath = os.path.join(local_files_dir, fname) |
| if not filecmp.cmp(origpath, workpath): |
| updated[fname] = origpath |
| elif fname != '.gitignore': |
| added[fname] = None |
| |
| workdir = rd.getVar('WORKDIR', True) |
| s = rd.getVar('S', True) |
| if not s.endswith(os.sep): |
| s += os.sep |
| |
| if workdir != s: |
| # Handle files where subdir= was specified |
| for fname in list(existing_files.keys()): |
| # FIXME handle both subdir starting with BP and not? |
| fworkpath = os.path.join(workdir, fname) |
| if fworkpath.startswith(s): |
| fpath = os.path.join(srctree, os.path.relpath(fworkpath, s)) |
| if os.path.exists(fpath): |
| origpath = existing_files.pop(fname) |
| if not filecmp.cmp(origpath, fpath): |
| updated[fpath] = origpath |
| |
| removed = existing_files |
| return (updated, added, removed) |
| |
| |
| def _determine_files_dir(rd): |
| """Determine the appropriate files directory for a recipe""" |
| recipedir = rd.getVar('FILE_DIRNAME', True) |
| for entry in rd.getVar('FILESPATH', True).split(':'): |
| relpth = os.path.relpath(entry, recipedir) |
| if not os.sep in relpth: |
| # One (or zero) levels below only, so we don't put anything in machine-specific directories |
| if os.path.isdir(entry): |
| return entry |
| return os.path.join(recipedir, rd.getVar('BPN', True)) |
| |
| |
| def _update_recipe_srcrev(srctree, rd, appendlayerdir, wildcard_version, no_remove): |
| """Implement the 'srcrev' mode of update-recipe""" |
| import bb |
| import oe.recipeutils |
| |
| recipefile = rd.getVar('FILE', True) |
| logger.info('Updating SRCREV in recipe %s' % os.path.basename(recipefile)) |
| |
| # Get HEAD revision |
| try: |
| stdout, _ = bb.process.run('git rev-parse HEAD', cwd=srctree) |
| except bb.process.ExecutionError as err: |
| raise DevtoolError('Failed to get HEAD revision in %s: %s' % |
| (srctree, err)) |
| srcrev = stdout.strip() |
| if len(srcrev) != 40: |
| raise DevtoolError('Invalid hash returned by git: %s' % stdout) |
| |
| destpath = None |
| remove_files = [] |
| patchfields = {} |
| patchfields['SRCREV'] = srcrev |
| orig_src_uri = rd.getVar('SRC_URI', False) or '' |
| srcuri = orig_src_uri.split() |
| tempdir = tempfile.mkdtemp(prefix='devtool') |
| update_srcuri = False |
| try: |
| local_files_dir = tempfile.mkdtemp(dir=tempdir) |
| upd_f, new_f, del_f = _export_local_files(srctree, rd, local_files_dir) |
| if not no_remove: |
| # Find list of existing patches in recipe file |
| patches_dir = tempfile.mkdtemp(dir=tempdir) |
| old_srcrev = (rd.getVar('SRCREV', False) or '') |
| upd_p, new_p, del_p = _export_patches(srctree, rd, old_srcrev, |
| patches_dir) |
| |
| # Remove deleted local files and "overlapping" patches |
| remove_files = list(del_f.values()) + list(upd_p.values()) |
| if remove_files: |
| removedentries = _remove_file_entries(srcuri, remove_files)[0] |
| update_srcuri = True |
| |
| if appendlayerdir: |
| files = dict((os.path.join(local_files_dir, key), val) for |
| key, val in list(upd_f.items()) + list(new_f.items())) |
| removevalues = {} |
| if update_srcuri: |
| removevalues = {'SRC_URI': removedentries} |
| patchfields['SRC_URI'] = '\\\n '.join(srcuri) |
| _, destpath = oe.recipeutils.bbappend_recipe( |
| rd, appendlayerdir, files, wildcardver=wildcard_version, |
| extralines=patchfields, removevalues=removevalues) |
| else: |
| files_dir = _determine_files_dir(rd) |
| for basepath, path in upd_f.items(): |
| logger.info('Updating file %s' % basepath) |
| if os.path.isabs(basepath): |
| # Original file (probably with subdir pointing inside source tree) |
| # so we do not want to move it, just copy |
| _copy_file(basepath, path) |
| else: |
| _move_file(os.path.join(local_files_dir, basepath), path) |
| update_srcuri= True |
| for basepath, path in new_f.items(): |
| logger.info('Adding new file %s' % basepath) |
| _move_file(os.path.join(local_files_dir, basepath), |
| os.path.join(files_dir, basepath)) |
| srcuri.append('file://%s' % basepath) |
| update_srcuri = True |
| if update_srcuri: |
| patchfields['SRC_URI'] = ' '.join(srcuri) |
| oe.recipeutils.patch_recipe(rd, recipefile, patchfields) |
| finally: |
| shutil.rmtree(tempdir) |
| if not 'git://' in orig_src_uri: |
| logger.info('You will need to update SRC_URI within the recipe to ' |
| 'point to a git repository where you have pushed your ' |
| 'changes') |
| |
| _remove_source_files(appendlayerdir, remove_files, destpath) |
| return True |
| |
| def _update_recipe_patch(recipename, workspace, srctree, rd, appendlayerdir, wildcard_version, no_remove, initial_rev): |
| """Implement the 'patch' mode of update-recipe""" |
| import bb |
| import oe.recipeutils |
| |
| recipefile = rd.getVar('FILE', True) |
| append = workspace[recipename]['bbappend'] |
| if not os.path.exists(append): |
| raise DevtoolError('unable to find workspace bbappend for recipe %s' % |
| recipename) |
| |
| initial_rev, update_rev, changed_revs = _get_patchset_revs(srctree, append, initial_rev) |
| if not initial_rev: |
| raise DevtoolError('Unable to find initial revision - please specify ' |
| 'it with --initial-rev') |
| |
| tempdir = tempfile.mkdtemp(prefix='devtool') |
| try: |
| local_files_dir = tempfile.mkdtemp(dir=tempdir) |
| upd_f, new_f, del_f = _export_local_files(srctree, rd, local_files_dir) |
| |
| remove_files = [] |
| if not no_remove: |
| # Get all patches from source tree and check if any should be removed |
| all_patches_dir = tempfile.mkdtemp(dir=tempdir) |
| upd_p, new_p, del_p = _export_patches(srctree, rd, initial_rev, |
| all_patches_dir) |
| # Remove deleted local files and patches |
| remove_files = list(del_f.values()) + list(del_p.values()) |
| |
| # Get updated patches from source tree |
| patches_dir = tempfile.mkdtemp(dir=tempdir) |
| upd_p, new_p, del_p = _export_patches(srctree, rd, update_rev, |
| patches_dir) |
| updatefiles = False |
| updaterecipe = False |
| destpath = None |
| srcuri = (rd.getVar('SRC_URI', False) or '').split() |
| if appendlayerdir: |
| files = dict((os.path.join(local_files_dir, key), val) for |
| key, val in list(upd_f.items()) + list(new_f.items())) |
| files.update(dict((os.path.join(patches_dir, key), val) for |
| key, val in list(upd_p.items()) + list(new_p.items()))) |
| if files or remove_files: |
| removevalues = None |
| if remove_files: |
| removedentries, remaining = _remove_file_entries( |
| srcuri, remove_files) |
| if removedentries or remaining: |
| remaining = ['file://' + os.path.basename(item) for |
| item in remaining] |
| removevalues = {'SRC_URI': removedentries + remaining} |
| _, destpath = oe.recipeutils.bbappend_recipe( |
| rd, appendlayerdir, files, |
| wildcardver=wildcard_version, |
| removevalues=removevalues) |
| else: |
| logger.info('No patches or local source files needed updating') |
| else: |
| # Update existing files |
| for basepath, path in upd_f.items(): |
| logger.info('Updating file %s' % basepath) |
| if os.path.isabs(basepath): |
| # Original file (probably with subdir pointing inside source tree) |
| # so we do not want to move it, just copy |
| _copy_file(basepath, path) |
| else: |
| _move_file(os.path.join(local_files_dir, basepath), path) |
| updatefiles = True |
| for basepath, path in upd_p.items(): |
| patchfn = os.path.join(patches_dir, basepath) |
| if changed_revs is not None: |
| # Avoid updating patches that have not actually changed |
| with open(patchfn, 'r') as f: |
| firstlineitems = f.readline().split() |
| if len(firstlineitems) > 1 and len(firstlineitems[1]) == 40: |
| if not firstlineitems[1] in changed_revs: |
| continue |
| logger.info('Updating patch %s' % basepath) |
| _move_file(patchfn, path) |
| updatefiles = True |
| # Add any new files |
| files_dir = _determine_files_dir(rd) |
| for basepath, path in new_f.items(): |
| logger.info('Adding new file %s' % basepath) |
| _move_file(os.path.join(local_files_dir, basepath), |
| os.path.join(files_dir, basepath)) |
| srcuri.append('file://%s' % basepath) |
| updaterecipe = True |
| for basepath, path in new_p.items(): |
| logger.info('Adding new patch %s' % basepath) |
| _move_file(os.path.join(patches_dir, basepath), |
| os.path.join(files_dir, basepath)) |
| srcuri.append('file://%s' % basepath) |
| updaterecipe = True |
| # Update recipe, if needed |
| if _remove_file_entries(srcuri, remove_files)[0]: |
| updaterecipe = True |
| if updaterecipe: |
| logger.info('Updating recipe %s' % os.path.basename(recipefile)) |
| oe.recipeutils.patch_recipe(rd, recipefile, |
| {'SRC_URI': ' '.join(srcuri)}) |
| elif not updatefiles: |
| # Neither patches nor recipe were updated |
| logger.info('No patches or files need updating') |
| return False |
| finally: |
| shutil.rmtree(tempdir) |
| |
| _remove_source_files(appendlayerdir, remove_files, destpath) |
| return True |
| |
| def _guess_recipe_update_mode(srctree, rdata): |
| """Guess the recipe update mode to use""" |
| src_uri = (rdata.getVar('SRC_URI', False) or '').split() |
| git_uris = [uri for uri in src_uri if uri.startswith('git://')] |
| if not git_uris: |
| return 'patch' |
| # Just use the first URI for now |
| uri = git_uris[0] |
| # Check remote branch |
| params = bb.fetch.decodeurl(uri)[5] |
| upstr_branch = params['branch'] if 'branch' in params else 'master' |
| # Check if current branch HEAD is found in upstream branch |
| stdout, _ = bb.process.run('git rev-parse HEAD', cwd=srctree) |
| head_rev = stdout.rstrip() |
| stdout, _ = bb.process.run('git branch -r --contains %s' % head_rev, |
| cwd=srctree) |
| remote_brs = [branch.strip() for branch in stdout.splitlines()] |
| if 'origin/' + upstr_branch in remote_brs: |
| return 'srcrev' |
| |
| return 'patch' |
| |
| def _update_recipe(recipename, workspace, rd, mode, appendlayerdir, wildcard_version, no_remove, initial_rev): |
| srctree = workspace[recipename]['srctree'] |
| if mode == 'auto': |
| mode = _guess_recipe_update_mode(srctree, rd) |
| |
| if mode == 'srcrev': |
| updated = _update_recipe_srcrev(srctree, rd, appendlayerdir, wildcard_version, no_remove) |
| elif mode == 'patch': |
| updated = _update_recipe_patch(recipename, workspace, srctree, rd, appendlayerdir, wildcard_version, no_remove, initial_rev) |
| else: |
| raise DevtoolError('update_recipe: invalid mode %s' % mode) |
| return updated |
| |
| def update_recipe(args, config, basepath, workspace): |
| """Entry point for the devtool 'update-recipe' subcommand""" |
| check_workspace_recipe(workspace, args.recipename) |
| |
| if args.append: |
| if not os.path.exists(args.append): |
| raise DevtoolError('bbappend destination layer directory "%s" ' |
| 'does not exist' % args.append) |
| if not os.path.exists(os.path.join(args.append, 'conf', 'layer.conf')): |
| raise DevtoolError('conf/layer.conf not found in bbappend ' |
| 'destination layer "%s"' % args.append) |
| |
| tinfoil = setup_tinfoil(basepath=basepath, tracking=True) |
| try: |
| |
| rd = parse_recipe(config, tinfoil, args.recipename, True) |
| if not rd: |
| return 1 |
| |
| updated = _update_recipe(args.recipename, workspace, rd, args.mode, args.append, args.wildcard_version, args.no_remove, args.initial_rev) |
| |
| if updated: |
| rf = rd.getVar('FILE', True) |
| if rf.startswith(config.workspace_path): |
| logger.warn('Recipe file %s has been updated but is inside the workspace - you will need to move it (and any associated files next to it) out to the desired layer before using "devtool reset" in order to keep any changes' % rf) |
| finally: |
| tinfoil.shutdown() |
| |
| return 0 |
| |
| |
| def status(args, config, basepath, workspace): |
| """Entry point for the devtool 'status' subcommand""" |
| if workspace: |
| for recipe, value in workspace.items(): |
| recipefile = value['recipefile'] |
| if recipefile: |
| recipestr = ' (%s)' % recipefile |
| else: |
| recipestr = '' |
| print("%s: %s%s" % (recipe, value['srctree'], recipestr)) |
| else: |
| logger.info('No recipes currently in your workspace - you can use "devtool modify" to work on an existing recipe or "devtool add" to add a new one') |
| return 0 |
| |
| |
| def _reset(recipes, no_clean, config, basepath, workspace): |
| """Reset one or more recipes""" |
| |
| if recipes and not no_clean: |
| if len(recipes) == 1: |
| logger.info('Cleaning sysroot for recipe %s...' % recipes[0]) |
| else: |
| logger.info('Cleaning sysroot for recipes %s...' % ', '.join(recipes)) |
| # If the recipe file itself was created in the workspace, and |
| # it uses BBCLASSEXTEND, then we need to also clean the other |
| # variants |
| targets = [] |
| for recipe in recipes: |
| targets.append(recipe) |
| recipefile = workspace[recipe]['recipefile'] |
| if recipefile and os.path.exists(recipefile): |
| targets.extend(get_bbclassextend_targets(recipefile, recipe)) |
| try: |
| exec_build_env_command(config.init_path, basepath, 'bitbake -c clean %s' % ' '.join(targets)) |
| except bb.process.ExecutionError as e: |
| raise DevtoolError('Command \'%s\' failed, output:\n%s\nIf you ' |
| 'wish, you may specify -n/--no-clean to ' |
| 'skip running this command when resetting' % |
| (e.command, e.stdout)) |
| |
| for pn in recipes: |
| _check_preserve(config, pn) |
| |
| preservepath = os.path.join(config.workspace_path, 'attic', pn, pn) |
| def preservedir(origdir): |
| if os.path.exists(origdir): |
| for root, dirs, files in os.walk(origdir): |
| for fn in files: |
| logger.warn('Preserving %s in %s' % (fn, preservepath)) |
| _move_file(os.path.join(origdir, fn), |
| os.path.join(preservepath, fn)) |
| for dn in dirs: |
| preservedir(os.path.join(root, dn)) |
| os.rmdir(origdir) |
| |
| preservedir(os.path.join(config.workspace_path, 'recipes', pn)) |
| # We don't automatically create this dir next to appends, but the user can |
| preservedir(os.path.join(config.workspace_path, 'appends', pn)) |
| |
| srctree = workspace[pn]['srctree'] |
| if os.path.isdir(srctree): |
| if os.listdir(srctree): |
| # We don't want to risk wiping out any work in progress |
| logger.info('Leaving source tree %s as-is; if you no ' |
| 'longer need it then please delete it manually' |
| % srctree) |
| else: |
| # This is unlikely, but if it's empty we can just remove it |
| os.rmdir(srctree) |
| |
| |
| def reset(args, config, basepath, workspace): |
| """Entry point for the devtool 'reset' subcommand""" |
| import bb |
| if args.recipename: |
| if args.all: |
| raise DevtoolError("Recipe cannot be specified if -a/--all is used") |
| else: |
| for recipe in args.recipename: |
| check_workspace_recipe(workspace, recipe, checksrc=False) |
| elif not args.all: |
| raise DevtoolError("Recipe must be specified, or specify -a/--all to " |
| "reset all recipes") |
| if args.all: |
| recipes = list(workspace.keys()) |
| else: |
| recipes = args.recipename |
| |
| _reset(recipes, args.no_clean, config, basepath, workspace) |
| |
| return 0 |
| |
| |
| def _get_layer(layername, d): |
| """Determine the base layer path for the specified layer name/path""" |
| layerdirs = d.getVar('BBLAYERS', True).split() |
| layers = {os.path.basename(p): p for p in layerdirs} |
| # Provide some shortcuts |
| if layername.lower() in ['oe-core', 'openembedded-core']: |
| layerdir = layers.get('meta', None) |
| else: |
| layerdir = layers.get(layername, None) |
| if layerdir: |
| layerdir = os.path.abspath(layerdir) |
| return layerdir or layername |
| |
| def finish(args, config, basepath, workspace): |
| """Entry point for the devtool 'finish' subcommand""" |
| import bb |
| import oe.recipeutils |
| |
| check_workspace_recipe(workspace, args.recipename) |
| |
| tinfoil = setup_tinfoil(basepath=basepath, tracking=True) |
| try: |
| rd = parse_recipe(config, tinfoil, args.recipename, True) |
| if not rd: |
| return 1 |
| |
| destlayerdir = _get_layer(args.destination, tinfoil.config_data) |
| origlayerdir = oe.recipeutils.find_layerdir(rd.getVar('FILE', True)) |
| |
| if not os.path.isdir(destlayerdir): |
| raise DevtoolError('Unable to find layer or directory matching "%s"' % args.destination) |
| |
| if os.path.abspath(destlayerdir) == config.workspace_path: |
| raise DevtoolError('"%s" specifies the workspace layer - that is not a valid destination' % args.destination) |
| |
| # If it's an upgrade, grab the original path |
| origpath = None |
| origfilelist = None |
| append = workspace[args.recipename]['bbappend'] |
| with open(append, 'r') as f: |
| for line in f: |
| if line.startswith('# original_path:'): |
| origpath = line.split(':')[1].strip() |
| elif line.startswith('# original_files:'): |
| origfilelist = line.split(':')[1].split() |
| |
| if origlayerdir == config.workspace_path: |
| # Recipe file itself is in workspace, update it there first |
| appendlayerdir = None |
| origrelpath = None |
| if origpath: |
| origlayerpath = oe.recipeutils.find_layerdir(origpath) |
| if origlayerpath: |
| origrelpath = os.path.relpath(origpath, origlayerpath) |
| destpath = oe.recipeutils.get_bbfile_path(rd, destlayerdir, origrelpath) |
| if not destpath: |
| raise DevtoolError("Unable to determine destination layer path - check that %s specifies an actual layer and %s/conf/layer.conf specifies BBFILES. You may also need to specify a more complete path." % (args.destination, destlayerdir)) |
| elif destlayerdir == origlayerdir: |
| # Same layer, update the original recipe |
| appendlayerdir = None |
| destpath = None |
| else: |
| # Create/update a bbappend in the specified layer |
| appendlayerdir = destlayerdir |
| destpath = None |
| |
| # Remove any old files in the case of an upgrade |
| if origpath and origfilelist and oe.recipeutils.find_layerdir(origpath) == oe.recipeutils.find_layerdir(destlayerdir): |
| for fn in origfilelist: |
| fnp = os.path.join(origpath, fn) |
| try: |
| os.remove(fnp) |
| except FileNotFoundError: |
| pass |
| |
| # Actually update the recipe / bbappend |
| _update_recipe(args.recipename, workspace, rd, args.mode, appendlayerdir, wildcard_version=True, no_remove=False, initial_rev=args.initial_rev) |
| |
| if origlayerdir == config.workspace_path and destpath: |
| # Recipe file itself is in the workspace - need to move it and any |
| # associated files to the specified layer |
| logger.info('Moving recipe file to %s' % destpath) |
| recipedir = os.path.dirname(rd.getVar('FILE', True)) |
| for root, _, files in os.walk(recipedir): |
| for fn in files: |
| srcpath = os.path.join(root, fn) |
| relpth = os.path.relpath(os.path.dirname(srcpath), recipedir) |
| destdir = os.path.abspath(os.path.join(destpath, relpth)) |
| bb.utils.mkdirhier(destdir) |
| shutil.move(srcpath, os.path.join(destdir, fn)) |
| |
| finally: |
| tinfoil.shutdown() |
| |
| # Everything else has succeeded, we can now reset |
| _reset([args.recipename], no_clean=False, config=config, basepath=basepath, workspace=workspace) |
| |
| return 0 |
| |
| |
| def get_default_srctree(config, recipename=''): |
| """Get the default srctree path""" |
| srctreeparent = config.get('General', 'default_source_parent_dir', config.workspace_path) |
| if recipename: |
| return os.path.join(srctreeparent, 'sources', recipename) |
| else: |
| return os.path.join(srctreeparent, 'sources') |
| |
| def register_commands(subparsers, context): |
| """Register devtool subcommands from this plugin""" |
| |
| defsrctree = get_default_srctree(context.config) |
| parser_add = subparsers.add_parser('add', help='Add a new recipe', |
| description='Adds a new recipe to the workspace to build a specified source tree. Can optionally fetch a remote URI and unpack it to create the source tree.', |
| group='starting', order=100) |
| parser_add.add_argument('recipename', nargs='?', help='Name for new recipe to add (just name - no version, path or extension). If not specified, will attempt to auto-detect it.') |
| parser_add.add_argument('srctree', nargs='?', help='Path to external source tree. If not specified, a subdirectory of %s will be used.' % defsrctree) |
| parser_add.add_argument('fetchuri', nargs='?', help='Fetch the specified URI and extract it to create the source tree') |
| group = parser_add.add_mutually_exclusive_group() |
| group.add_argument('--same-dir', '-s', help='Build in same directory as source', action="store_true") |
| group.add_argument('--no-same-dir', help='Force build in a separate build directory', action="store_true") |
| parser_add.add_argument('--fetch', '-f', help='Fetch the specified URI and extract it to create the source tree (deprecated - pass as positional argument instead)', metavar='URI') |
| parser_add.add_argument('--version', '-V', help='Version to use within recipe (PV)') |
| parser_add.add_argument('--no-git', '-g', help='If fetching source, do not set up source tree as a git repository', action="store_true") |
| parser_add.add_argument('--autorev', '-a', help='When fetching from a git repository, set SRCREV in the recipe to a floating revision instead of fixed', action="store_true") |
| parser_add.add_argument('--binary', '-b', help='Treat the source tree as something that should be installed verbatim (no compilation, same directory structure). Useful with binary packages e.g. RPMs.', action='store_true') |
| parser_add.add_argument('--also-native', help='Also add native variant (i.e. support building recipe for the build host as well as the target machine)', action='store_true') |
| parser_add.add_argument('--src-subdir', help='Specify subdirectory within source tree to use', metavar='SUBDIR') |
| parser_add.set_defaults(func=add, fixed_setup=context.fixed_setup) |
| |
| parser_modify = subparsers.add_parser('modify', help='Modify the source for an existing recipe', |
| description='Sets up the build environment to modify the source for an existing recipe. The default behaviour is to extract the source being fetched by the recipe into a git tree so you can work on it; alternatively if you already have your own pre-prepared source tree you can specify -n/--no-extract.', |
| group='starting', order=90) |
| parser_modify.add_argument('recipename', help='Name of existing recipe to edit (just name - no version, path or extension)') |
| parser_modify.add_argument('srctree', nargs='?', help='Path to external source tree. If not specified, a subdirectory of %s will be used.' % defsrctree) |
| parser_modify.add_argument('--wildcard', '-w', action="store_true", help='Use wildcard for unversioned bbappend') |
| group = parser_modify.add_mutually_exclusive_group() |
| group.add_argument('--extract', '-x', action="store_true", help='Extract source for recipe (default)') |
| group.add_argument('--no-extract', '-n', action="store_true", help='Do not extract source, expect it to exist') |
| group = parser_modify.add_mutually_exclusive_group() |
| group.add_argument('--same-dir', '-s', help='Build in same directory as source', action="store_true") |
| group.add_argument('--no-same-dir', help='Force build in a separate build directory', action="store_true") |
| parser_modify.add_argument('--branch', '-b', default="devtool", help='Name for development branch to checkout (when not using -n/--no-extract) (default "%(default)s")') |
| parser_modify.set_defaults(func=modify) |
| |
| parser_extract = subparsers.add_parser('extract', help='Extract the source for an existing recipe', |
| description='Extracts the source for an existing recipe', |
| group='advanced') |
| parser_extract.add_argument('recipename', help='Name of recipe to extract the source for') |
| parser_extract.add_argument('srctree', help='Path to where to extract the source tree') |
| parser_extract.add_argument('--branch', '-b', default="devtool", help='Name for development branch to checkout (default "%(default)s")') |
| parser_extract.add_argument('--keep-temp', action="store_true", help='Keep temporary directory (for debugging)') |
| parser_extract.set_defaults(func=extract, no_workspace=True) |
| |
| parser_sync = subparsers.add_parser('sync', help='Synchronize the source tree for an existing recipe', |
| description='Synchronize the previously extracted source tree for an existing recipe', |
| formatter_class=argparse.ArgumentDefaultsHelpFormatter, |
| group='advanced') |
| parser_sync.add_argument('recipename', help='Name of recipe to sync the source for') |
| parser_sync.add_argument('srctree', help='Path to the source tree') |
| parser_sync.add_argument('--branch', '-b', default="devtool", help='Name for development branch to checkout') |
| parser_sync.add_argument('--keep-temp', action="store_true", help='Keep temporary directory (for debugging)') |
| parser_sync.set_defaults(func=sync) |
| |
| parser_update_recipe = subparsers.add_parser('update-recipe', help='Apply changes from external source tree to recipe', |
| description='Applies changes from external source tree to a recipe (updating/adding/removing patches as necessary, or by updating SRCREV). Note that these changes need to have been committed to the git repository in order to be recognised.', |
| group='working', order=-90) |
| parser_update_recipe.add_argument('recipename', help='Name of recipe to update') |
| parser_update_recipe.add_argument('--mode', '-m', choices=['patch', 'srcrev', 'auto'], default='auto', help='Update mode (where %(metavar)s is %(choices)s; default is %(default)s)', metavar='MODE') |
| parser_update_recipe.add_argument('--initial-rev', help='Override starting revision for patches') |
| parser_update_recipe.add_argument('--append', '-a', help='Write changes to a bbappend in the specified layer instead of the recipe', metavar='LAYERDIR') |
| parser_update_recipe.add_argument('--wildcard-version', '-w', help='In conjunction with -a/--append, use a wildcard to make the bbappend apply to any recipe version', action='store_true') |
| parser_update_recipe.add_argument('--no-remove', '-n', action="store_true", help='Don\'t remove patches, only add or update') |
| parser_update_recipe.set_defaults(func=update_recipe) |
| |
| parser_status = subparsers.add_parser('status', help='Show workspace status', |
| description='Lists recipes currently in your workspace and the paths to their respective external source trees', |
| group='info', order=100) |
| parser_status.set_defaults(func=status) |
| |
| parser_reset = subparsers.add_parser('reset', help='Remove a recipe from your workspace', |
| description='Removes the specified recipe(s) from your workspace (resetting its state back to that defined by the metadata).', |
| group='working', order=-100) |
| parser_reset.add_argument('recipename', nargs='*', help='Recipe to reset') |
| parser_reset.add_argument('--all', '-a', action="store_true", help='Reset all recipes (clear workspace)') |
| parser_reset.add_argument('--no-clean', '-n', action="store_true", help='Don\'t clean the sysroot to remove recipe output') |
| parser_reset.set_defaults(func=reset) |
| |
| parser_finish = subparsers.add_parser('finish', help='Finish working on a recipe in your workspace', |
| description='Pushes any committed changes to the specified recipe to the specified layer and removes it from your workspace. Roughly equivalent to an update-recipe followed by reset, except the update-recipe step will do the "right thing" depending on the recipe and the destination layer specified.', |
| group='working', order=-100) |
| parser_finish.add_argument('recipename', help='Recipe to finish') |
| parser_finish.add_argument('destination', help='Layer/path to put recipe into. Can be the name of a layer configured in your bblayers.conf, the path to the base of a layer, or a partial path inside a layer. %(prog)s will attempt to complete the path based on the layer\'s structure.') |
| parser_finish.add_argument('--mode', '-m', choices=['patch', 'srcrev', 'auto'], default='auto', help='Update mode (where %(metavar)s is %(choices)s; default is %(default)s)', metavar='MODE') |
| parser_finish.add_argument('--initial-rev', help='Override starting revision for patches') |
| parser_finish.set_defaults(func=finish) |