mirror of
git://git.yoctoproject.org/poky.git
synced 2025-07-19 21:09:03 +02:00
07f76656d9
Use DevtoolError exception more widely for handling error cases. This exception is now caught in the main script and raising it can be used to exit with an error. This hopefully simplifies error handling. The change also makes exit codes more consistent, always returning '1' when an error occurs. (From OE-Core rev: 2e4f1dcade7ccb581c7a390c32163ea3deeac6d5) Signed-off-by: Markus Lehtonen <markus.lehtonen@linux.intel.com> Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
923 lines
39 KiB
Python
923 lines
39 KiB
Python
# Development tool - standard commands plugin
|
|
#
|
|
# Copyright (C) 2014-2015 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 tempfile
|
|
import logging
|
|
import argparse
|
|
import scriptutils
|
|
import errno
|
|
from devtool import exec_build_env_command, setup_tinfoil, DevtoolError
|
|
|
|
logger = logging.getLogger('devtool')
|
|
|
|
|
|
def plugin_init(pluginlist):
|
|
"""Plugin initialization"""
|
|
pass
|
|
|
|
|
|
def add(args, config, basepath, workspace):
|
|
"""Entry point for the devtool 'add' subcommand"""
|
|
import bb
|
|
import oe.recipeutils
|
|
|
|
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)
|
|
|
|
srctree = os.path.abspath(args.srctree)
|
|
if os.path.exists(srctree):
|
|
if args.fetch:
|
|
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.fetch:
|
|
raise DevtoolError("Specified source tree %s could not be found" %
|
|
srctree)
|
|
|
|
appendpath = os.path.join(config.workspace_path, 'appends')
|
|
if not os.path.exists(appendpath):
|
|
os.makedirs(appendpath)
|
|
|
|
recipedir = os.path.join(config.workspace_path, 'recipes', args.recipename)
|
|
bb.utils.mkdirhier(recipedir)
|
|
rfv = None
|
|
if args.version:
|
|
if '_' in args.version or ' ' in args.version:
|
|
raise DevtoolError('Invalid version string "%s"' % args.version)
|
|
rfv = args.version
|
|
if args.fetch:
|
|
if args.fetch.startswith('git://'):
|
|
rfv = 'git'
|
|
elif args.fetch.startswith('svn://'):
|
|
rfv = 'svn'
|
|
elif args.fetch.startswith('hg://'):
|
|
rfv = 'hg'
|
|
if rfv:
|
|
bp = "%s_%s" % (args.recipename, rfv)
|
|
else:
|
|
bp = args.recipename
|
|
recipefile = os.path.join(recipedir, "%s.bb" % bp)
|
|
if sys.stdout.isatty():
|
|
color = 'always'
|
|
else:
|
|
color = args.color
|
|
extracmdopts = ''
|
|
if args.fetch:
|
|
source = args.fetch
|
|
extracmdopts = '-x %s' % srctree
|
|
else:
|
|
source = srctree
|
|
if args.version:
|
|
extracmdopts += ' -V %s' % args.version
|
|
try:
|
|
stdout, _ = exec_build_env_command(config.init_path, basepath, 'recipetool --color=%s create -o %s "%s" %s' % (color, recipefile, source, extracmdopts))
|
|
logger.info('Recipe %s has been automatically created; further editing may be required to make it fully functional' % recipefile)
|
|
except bb.process.ExecutionError as e:
|
|
raise DevtoolError('Command \'%s\' failed:\n%s' % (e.command, e.stdout))
|
|
|
|
_add_md5(config, args.recipename, recipefile)
|
|
|
|
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()
|
|
|
|
appendfile = os.path.join(appendpath, '%s.bbappend' % bp)
|
|
with open(appendfile, 'w') as f:
|
|
f.write('inherit externalsrc\n')
|
|
f.write('EXTERNALSRC = "%s"\n' % srctree)
|
|
if args.same_dir:
|
|
f.write('EXTERNALSRC_BUILD = "%s"\n' % srctree)
|
|
if initial_rev:
|
|
f.write('\n# initial_rev: %s\n' % initial_rev)
|
|
|
|
_add_md5(config, args.recipename, appendfile)
|
|
|
|
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")
|
|
|
|
if pn in ['kernel-devsrc', 'package-index'] or pn.startswith('gcc-source'):
|
|
raise DevtoolError("The %s recipe is not supported by this tool" % pn)
|
|
|
|
if bb.data.inherits_class('image', d):
|
|
raise DevtoolError("The %s recipe is an image, and therefore is not "
|
|
"supported by this tool" % pn)
|
|
|
|
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)
|
|
|
|
if bb.data.inherits_class('packagegroup', d):
|
|
raise DevtoolError("The %s recipe is a packagegroup, and therefore is "
|
|
"not supported by this tool" % pn)
|
|
|
|
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)
|
|
|
|
if bb.data.inherits_class('externalsrc', d) and d.getVar('EXTERNALSRC', True):
|
|
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 _get_recipe_file(cooker, pn):
|
|
"""Find recipe file corresponding a package name"""
|
|
import oe.recipeutils
|
|
recipefile = oe.recipeutils.pn_to_recipe(cooker, pn)
|
|
if not recipefile:
|
|
skipreasons = oe.recipeutils.get_unavailable_reasons(cooker, pn)
|
|
if skipreasons:
|
|
logger.error('\n'.join(skipreasons))
|
|
else:
|
|
logger.error("Unable to find any recipe file matching %s" % pn)
|
|
return recipefile
|
|
|
|
def _parse_recipe(config, tinfoil, pn, appends):
|
|
"""Parse recipe of a package"""
|
|
import oe.recipeutils
|
|
recipefile = _get_recipe_file(tinfoil.cooker, pn)
|
|
if not recipefile:
|
|
# Error already logged
|
|
return None
|
|
if appends:
|
|
append_files = tinfoil.cooker.collection.get_file_appends(recipefile)
|
|
# Filter out appends from the workspace
|
|
append_files = [path for path in append_files if
|
|
not path.startswith(config.workspace_path)]
|
|
return oe.recipeutils.parse_recipe(recipefile, append_files,
|
|
tinfoil.config_data)
|
|
|
|
|
|
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 = setup_tinfoil()
|
|
|
|
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, rd)
|
|
if initial_rev:
|
|
return 0
|
|
else:
|
|
return 1
|
|
|
|
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')
|
|
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)
|
|
bb.build.exec_func(func, localdata)
|
|
self.executed.append(func)
|
|
|
|
|
|
def _extract_source(srctree, keep_temp, devbranch, 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 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)
|
|
|
|
# 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}/${BP}')
|
|
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 = BbTaskExecutor(crd)
|
|
|
|
logger.info('Fetching %s...' % pn)
|
|
task_executor.exec_func('do_fetch', False)
|
|
logger.info('Unpacking...')
|
|
task_executor.exec_func('do_unpack', False)
|
|
srcsubdir = crd.getVar('S', True)
|
|
if srcsubdir == workdir:
|
|
# Find non-patch sources that were "unpacked" to srctree directory
|
|
recipe_patches = [os.path.basename(patch) for patch in
|
|
oe.recipeutils.get_recipe_patches(crd)]
|
|
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:
|
|
tgt_dir = os.path.join(srcsubdir, os.path.dirname(path))
|
|
bb.utils.mkdirhier(tgt_dir)
|
|
shutil.move(os.path.join(workdir, path), tgt_dir)
|
|
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)
|
|
|
|
patchdir = os.path.join(srcsubdir, 'patches')
|
|
haspatches = False
|
|
if os.path.exists(patchdir):
|
|
if os.listdir(patchdir):
|
|
haspatches = True
|
|
else:
|
|
os.rmdir(patchdir)
|
|
|
|
if bb.data.inherits_class('kernel-yocto', d):
|
|
(stdout, _) = bb.process.run('git --git-dir="%s" rev-parse HEAD' % crd.expand('${WORKDIR}/git'), cwd=srcsubdir)
|
|
initial_rev = stdout.rstrip()
|
|
else:
|
|
if not os.listdir(srcsubdir):
|
|
raise DevtoolError("no source unpacked to S, perhaps the %s "
|
|
"recipe doesn't use any source?" % pn)
|
|
|
|
if not os.path.exists(os.path.join(srcsubdir, '.git')):
|
|
bb.process.run('git init', cwd=srcsubdir)
|
|
bb.process.run('git add .', cwd=srcsubdir)
|
|
bb.process.run('git commit -q -m "Initial commit from upstream at version %s"' % crd.getVar('PV', True), cwd=srcsubdir)
|
|
|
|
(stdout, _) = bb.process.run('git rev-parse HEAD', cwd=srcsubdir)
|
|
initial_rev = stdout.rstrip()
|
|
|
|
bb.process.run('git checkout -b %s' % devbranch, cwd=srcsubdir)
|
|
bb.process.run('git tag -f devtool-base', cwd=srcsubdir)
|
|
|
|
crd.setVar('PATCHTOOL', 'git')
|
|
|
|
logger.info('Patching...')
|
|
task_executor.exec_func('do_patch', False)
|
|
|
|
bb.process.run('git tag -f devtool-patched', cwd=srcsubdir)
|
|
|
|
if os.path.exists(patchdir):
|
|
shutil.rmtree(patchdir)
|
|
if haspatches:
|
|
bb.process.run('git checkout patches', cwd=srcsubdir)
|
|
|
|
shutil.move(srcsubdir, srctree)
|
|
logger.info('Source tree extracted to %s' % 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 recipe to the md5-file of the workspace"""
|
|
import bb.utils
|
|
md5 = bb.utils.md5_file(filename)
|
|
with open(os.path.join(config.workspace_path, '.devtool_md5'), 'a') as f:
|
|
f.write('%s|%s|%s\n' % (recipename, os.path.relpath(filename, config.workspace_path), md5))
|
|
|
|
def _check_preserve(config, recipename):
|
|
"""Check if a recipe 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')
|
|
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)
|
|
|
|
if not args.extract and not os.path.isdir(args.srctree):
|
|
raise DevtoolError("directory %s does not exist or not a directory "
|
|
"(specify -x to extract source from recipe)" %
|
|
args.srctree)
|
|
|
|
tinfoil = setup_tinfoil()
|
|
|
|
rd = _parse_recipe(config, tinfoil, args.recipename, True)
|
|
if not rd:
|
|
return 1
|
|
recipefile = rd.getVar('FILE', True)
|
|
|
|
_check_compatible_recipe(args.recipename, rd)
|
|
|
|
initial_rev = None
|
|
commits = []
|
|
srctree = os.path.abspath(args.srctree)
|
|
if args.extract:
|
|
initial_rev = _extract_source(args.srctree, False, args.branch, rd)
|
|
if not initial_rev:
|
|
return 1
|
|
# Get list of commits since this revision
|
|
(stdout, _) = bb.process.run('git rev-list --reverse %s..HEAD' % initial_rev, cwd=args.srctree)
|
|
commits = stdout.split()
|
|
else:
|
|
if os.path.exists(os.path.join(args.srctree, '.git')):
|
|
# Check if it's a tree previously extracted by us
|
|
try:
|
|
(stdout, _) = bb.process.run('git branch --contains devtool-base', cwd=args.srctree)
|
|
except bb.process.ExecutionError:
|
|
stdout = ''
|
|
for line in stdout.splitlines():
|
|
if line.startswith('*'):
|
|
(stdout, _) = bb.process.run('git rev-parse devtool-base', cwd=args.srctree)
|
|
initial_rev = stdout.rstrip()
|
|
if not initial_rev:
|
|
# Otherwise, just grab the head revision
|
|
(stdout, _) = bb.process.run('git rev-parse HEAD', cwd=args.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)
|
|
|
|
appendpath = os.path.join(config.workspace_path, 'appends')
|
|
if not os.path.exists(appendpath):
|
|
os.makedirs(appendpath)
|
|
|
|
appendname = os.path.splitext(os.path.basename(recipefile))[0]
|
|
if args.wildcard:
|
|
appendname = re.sub(r'_.*', '_%', appendname)
|
|
appendfile = os.path.join(appendpath, appendname + '.bbappend')
|
|
with open(appendfile, 'w') as f:
|
|
f.write('FILESEXTRAPATHS_prepend := "${THISDIR}/${PN}:"\n\n')
|
|
f.write('inherit 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' % (args.recipename, srctree))
|
|
|
|
b_is_s = True
|
|
if args.no_same_dir:
|
|
logger.info('using separate build directory since --no-same-dir specified')
|
|
b_is_s = False
|
|
elif args.same_dir:
|
|
logger.info('using source tree as build directory since --same-dir specified')
|
|
elif bb.data.inherits_class('autotools-brokensep', rd):
|
|
logger.info('using source tree as build directory since original recipe inherits autotools-brokensep')
|
|
elif rd.getVar('B', True) == s:
|
|
logger.info('using source tree as build directory since that is the default for this recipe')
|
|
else:
|
|
b_is_s = False
|
|
if b_is_s:
|
|
f.write('EXTERNALSRC_BUILD_pn-%s = "%s"\n' % (args.recipename, srctree))
|
|
|
|
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, args.recipename, appendfile)
|
|
|
|
logger.info('Recipe %s now set up to build from %s' % (args.recipename, srctree))
|
|
|
|
return 0
|
|
|
|
def _get_patchset_revs(args, srctree, recipe_path):
|
|
"""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
|
|
|
|
if args.initial_rev:
|
|
return args.initial_rev, args.initial_rev
|
|
|
|
# Parse initial rev from recipe
|
|
commits = []
|
|
initial_rev = None
|
|
with open(recipe_path, 'r') as f:
|
|
for line in f:
|
|
if line.startswith('# initial_rev:'):
|
|
initial_rev = line.split(':')[-1].strip()
|
|
elif line.startswith('# commit:'):
|
|
commits.append(line.split(':')[-1].strip())
|
|
|
|
update_rev = initial_rev
|
|
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 xrange(min(len(commits), len(newcommits))):
|
|
if newcommits[i] == commits[i]:
|
|
update_rev = commits[i]
|
|
|
|
return initial_rev, update_rev
|
|
|
|
def _remove_patch_entries(srcuri, patchlist):
|
|
"""Remove patch entries from SRC_URI"""
|
|
remaining = patchlist[:]
|
|
entries = []
|
|
for patch in patchlist:
|
|
patchfile = os.path.basename(patch)
|
|
for i in xrange(len(srcuri)):
|
|
if srcuri[i].startswith('file://') and os.path.basename(srcuri[i].split(';')[0]) == patchfile:
|
|
entries.append(srcuri[i])
|
|
remaining.remove(patch)
|
|
srcuri.pop(i)
|
|
break
|
|
return entries, remaining
|
|
|
|
def _remove_patch_files(args, patches, destpath):
|
|
"""Unlink existing patch files"""
|
|
for patchfile in patches:
|
|
if args.append:
|
|
if not destpath:
|
|
raise Exception('destpath should be set here')
|
|
patchfile = os.path.join(destpath, os.path.basename(patchfile))
|
|
|
|
if os.path.exists(patchfile):
|
|
logger.info('Removing patch %s' % patchfile)
|
|
# 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(patchfile)
|
|
# Remove directory if empty
|
|
try:
|
|
os.rmdir(os.path.dirname(patchfile))
|
|
except OSError as ose:
|
|
if ose.errno != errno.ENOTEMPTY:
|
|
raise
|
|
|
|
def _update_recipe_srcrev(args, srctree, rd, config_data):
|
|
"""Implement the 'srcrev' mode of update-recipe"""
|
|
import bb
|
|
import oe.recipeutils
|
|
from oe.patch import GitApplyTree
|
|
|
|
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
|
|
removepatches = []
|
|
patchfields = {}
|
|
patchfields['SRCREV'] = srcrev
|
|
orig_src_uri = rd.getVar('SRC_URI', False) or ''
|
|
if not args.no_remove:
|
|
# Find list of existing patches in recipe file
|
|
existing_patches = oe.recipeutils.get_recipe_patches(rd)
|
|
|
|
old_srcrev = (rd.getVar('SRCREV', False) or '')
|
|
tempdir = tempfile.mkdtemp(prefix='devtool')
|
|
try:
|
|
GitApplyTree.extractPatches(srctree, old_srcrev, tempdir)
|
|
newpatches = os.listdir(tempdir)
|
|
for patch in existing_patches:
|
|
patchfile = os.path.basename(patch)
|
|
if patchfile in newpatches:
|
|
removepatches.append(patch)
|
|
finally:
|
|
shutil.rmtree(tempdir)
|
|
|
|
if removepatches:
|
|
srcuri = orig_src_uri.split()
|
|
removedentries, _ = _remove_patch_entries(srcuri, removepatches)
|
|
if removedentries:
|
|
patchfields['SRC_URI'] = ' '.join(srcuri)
|
|
|
|
if args.append:
|
|
_, destpath = oe.recipeutils.bbappend_recipe(
|
|
rd, args.append, None, wildcardver=args.wildcard_version,
|
|
extralines=patchfields)
|
|
else:
|
|
oe.recipeutils.patch_recipe(config_data, recipefile, patchfields)
|
|
|
|
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_patch_files(args, removepatches, destpath)
|
|
|
|
def _update_recipe_patch(args, config, srctree, rd, config_data):
|
|
"""Implement the 'patch' mode of update-recipe"""
|
|
import bb
|
|
import oe.recipeutils
|
|
from oe.patch import GitApplyTree
|
|
|
|
recipefile = rd.getVar('FILE', True)
|
|
append = os.path.join(config.workspace_path, 'appends', '%s.bbappend' %
|
|
os.path.splitext(os.path.basename(recipefile))[0])
|
|
if not os.path.exists(append):
|
|
raise DevtoolError('unable to find workspace bbappend for recipe %s' %
|
|
args.recipename)
|
|
|
|
initial_rev, update_rev = _get_patchset_revs(args, srctree, append)
|
|
if not initial_rev:
|
|
raise DevtoolError('Unable to find initial revision - please specify '
|
|
'it with --initial-rev')
|
|
|
|
# Find list of existing patches in recipe file
|
|
existing_patches = oe.recipeutils.get_recipe_patches(rd)
|
|
|
|
removepatches = []
|
|
seqpatch_re = re.compile('^([0-9]{4}-)?(.+)')
|
|
if not args.no_remove:
|
|
# Get all patches from source tree and check if any should be removed
|
|
tempdir = tempfile.mkdtemp(prefix='devtool')
|
|
try:
|
|
GitApplyTree.extractPatches(srctree, initial_rev, tempdir)
|
|
# 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...
|
|
newpatches = [seqpatch_re.match(fname).group(2) for fname in
|
|
os.listdir(tempdir)]
|
|
for patch in existing_patches:
|
|
basename = seqpatch_re.match(
|
|
os.path.basename(patch)).group(2)
|
|
if basename not in newpatches:
|
|
removepatches.append(patch)
|
|
finally:
|
|
shutil.rmtree(tempdir)
|
|
|
|
# Get updated patches from source tree
|
|
tempdir = tempfile.mkdtemp(prefix='devtool')
|
|
try:
|
|
GitApplyTree.extractPatches(srctree, update_rev, tempdir)
|
|
|
|
# Match up and replace existing patches with corresponding new patches
|
|
updatepatches = False
|
|
updaterecipe = False
|
|
destpath = None
|
|
newpatches = os.listdir(tempdir)
|
|
if args.append:
|
|
patchfiles = {}
|
|
for patch in existing_patches:
|
|
patchfile = os.path.basename(patch)
|
|
if patchfile in newpatches:
|
|
patchfiles[os.path.join(tempdir, patchfile)] = patchfile
|
|
newpatches.remove(patchfile)
|
|
for patchfile in newpatches:
|
|
patchfiles[os.path.join(tempdir, patchfile)] = None
|
|
|
|
if patchfiles or removepatches:
|
|
removevalues = None
|
|
if removepatches:
|
|
srcuri = (rd.getVar('SRC_URI', False) or '').split()
|
|
removedentries, remaining = _remove_patch_entries(
|
|
srcuri, removepatches)
|
|
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, args.append, patchfiles,
|
|
removevalues=removevalues)
|
|
else:
|
|
logger.info('No patches needed updating')
|
|
else:
|
|
for patch in existing_patches:
|
|
patchfile = os.path.basename(patch)
|
|
if patchfile in newpatches:
|
|
logger.info('Updating patch %s' % patchfile)
|
|
shutil.move(os.path.join(tempdir, patchfile), patch)
|
|
newpatches.remove(patchfile)
|
|
updatepatches = True
|
|
srcuri = (rd.getVar('SRC_URI', False) or '').split()
|
|
if newpatches:
|
|
# Add any patches left over
|
|
patchdir = os.path.join(os.path.dirname(recipefile),
|
|
rd.getVar('BPN', True))
|
|
bb.utils.mkdirhier(patchdir)
|
|
for patchfile in newpatches:
|
|
logger.info('Adding new patch %s' % patchfile)
|
|
shutil.move(os.path.join(tempdir, patchfile),
|
|
os.path.join(patchdir, patchfile))
|
|
srcuri.append('file://%s' % patchfile)
|
|
updaterecipe = True
|
|
if removepatches:
|
|
removedentries, _ = _remove_patch_entries(srcuri, removepatches)
|
|
if removedentries:
|
|
updaterecipe = True
|
|
if updaterecipe:
|
|
logger.info('Updating recipe %s' % os.path.basename(recipefile))
|
|
oe.recipeutils.patch_recipe(config_data, recipefile,
|
|
{'SRC_URI': ' '.join(srcuri)})
|
|
elif not updatepatches:
|
|
# Neither patches nor recipe were updated
|
|
logger.info('No patches need updating')
|
|
finally:
|
|
shutil.rmtree(tempdir)
|
|
|
|
_remove_patch_files(args, removepatches, destpath)
|
|
|
|
def update_recipe(args, config, basepath, workspace):
|
|
"""Entry point for the devtool 'update-recipe' subcommand"""
|
|
if not args.recipename in workspace:
|
|
raise DevtoolError("no recipe named %s in your 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()
|
|
|
|
rd = _parse_recipe(config, tinfoil, args.recipename, True)
|
|
if not rd:
|
|
return 1
|
|
|
|
orig_src_uri = rd.getVar('SRC_URI', False) or ''
|
|
if args.mode == 'auto':
|
|
if 'git://' in orig_src_uri:
|
|
mode = 'srcrev'
|
|
else:
|
|
mode = 'patch'
|
|
else:
|
|
mode = args.mode
|
|
|
|
srctree = workspace[args.recipename]
|
|
|
|
if mode == 'srcrev':
|
|
_update_recipe_srcrev(args, srctree, rd, tinfoil.config_data)
|
|
elif mode == 'patch':
|
|
_update_recipe_patch(args, config, srctree, rd, tinfoil.config_data)
|
|
else:
|
|
raise DevtoolError('update_recipe: invalid mode %s' % mode)
|
|
|
|
return 0
|
|
|
|
|
|
def status(args, config, basepath, workspace):
|
|
"""Entry point for the devtool 'status' subcommand"""
|
|
if workspace:
|
|
for recipe, value in workspace.iteritems():
|
|
print("%s: %s" % (recipe, value))
|
|
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(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")
|
|
elif not args.recipename in workspace:
|
|
raise DevtoolError("no recipe named %s in your workspace" %
|
|
args.recipename)
|
|
elif not args.all:
|
|
raise DevtoolError("Recipe must be specified, or specify -a/--all to "
|
|
"reset all recipes")
|
|
if args.all:
|
|
recipes = workspace
|
|
else:
|
|
recipes = [args.recipename]
|
|
|
|
for pn in recipes:
|
|
if not args.no_clean:
|
|
logger.info('Cleaning sysroot for recipe %s...' % pn)
|
|
try:
|
|
exec_build_env_command(config.init_path, basepath, 'bitbake -c clean %s' % pn)
|
|
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))
|
|
|
|
_check_preserve(config, pn)
|
|
|
|
preservepath = os.path.join(config.workspace_path, 'attic', pn)
|
|
def preservedir(origdir):
|
|
if os.path.exists(origdir):
|
|
for fn in os.listdir(origdir):
|
|
logger.warn('Preserving %s in %s' % (fn, preservepath))
|
|
bb.utils.mkdirhier(preservepath)
|
|
shutil.move(os.path.join(origdir, fn), os.path.join(preservepath, fn))
|
|
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))
|
|
|
|
return 0
|
|
|
|
|
|
def build(args, config, basepath, workspace):
|
|
"""Entry point for the devtool 'build' subcommand"""
|
|
import bb
|
|
if not args.recipename in workspace:
|
|
raise DevtoolError("no recipe named %s in your workspace" %
|
|
args.recipename)
|
|
build_task = config.get('Build', 'build_task', 'populate_sysroot')
|
|
try:
|
|
exec_build_env_command(config.init_path, basepath, 'bitbake -c %s %s' % (build_task, args.recipename), watch=True)
|
|
except bb.process.ExecutionError as e:
|
|
# We've already seen the output since watch=True, so just ensure we return something to the user
|
|
return e.exitcode
|
|
|
|
return 0
|
|
|
|
|
|
def register_commands(subparsers, context):
|
|
"""Register devtool subcommands from this plugin"""
|
|
parser_add = subparsers.add_parser('add', help='Add a new recipe',
|
|
description='Adds a new recipe')
|
|
parser_add.add_argument('recipename', help='Name for new recipe to add')
|
|
parser_add.add_argument('srctree', help='Path to external source tree')
|
|
parser_add.add_argument('--same-dir', '-s', help='Build in same directory as source', action="store_true")
|
|
parser_add.add_argument('--fetch', '-f', help='Fetch the specified URI and extract it to create the source tree', metavar='URI')
|
|
parser_add.add_argument('--version', '-V', help='Version to use within recipe (PV)')
|
|
parser_add.set_defaults(func=add)
|
|
|
|
parser_modify = subparsers.add_parser('modify', help='Modify the source for an existing recipe',
|
|
description='Enables modifying the source for an existing recipe',
|
|
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
|
|
parser_modify.add_argument('recipename', help='Name for recipe to edit')
|
|
parser_modify.add_argument('srctree', help='Path to external source tree')
|
|
parser_modify.add_argument('--wildcard', '-w', action="store_true", help='Use wildcard for unversioned bbappend')
|
|
parser_modify.add_argument('--extract', '-x', action="store_true", help='Extract source as well')
|
|
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 (only when using -x)')
|
|
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',
|
|
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
|
|
parser_extract.add_argument('recipename', help='Name for 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')
|
|
parser_extract.add_argument('--keep-temp', action="store_true", help='Keep temporary directory (for debugging)')
|
|
parser_extract.set_defaults(func=extract)
|
|
|
|
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)')
|
|
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='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',
|
|
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
|
|
parser_status.set_defaults(func=status)
|
|
|
|
parser_build = subparsers.add_parser('build', help='Build a recipe',
|
|
description='Builds the specified recipe using bitbake',
|
|
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
|
|
parser_build.add_argument('recipename', help='Recipe to build')
|
|
parser_build.set_defaults(func=build)
|
|
|
|
parser_reset = subparsers.add_parser('reset', help='Remove a recipe from your workspace',
|
|
description='Removes the specified recipe from your workspace (resetting its state)',
|
|
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
|
|
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)
|