| # Development tool - sdk-update command plugin |
| # |
| # Copyright (C) 2015-2016 Intel Corporation |
| # |
| # SPDX-License-Identifier: GPL-2.0-only |
| # |
| |
| import os |
| import subprocess |
| import logging |
| import glob |
| import shutil |
| import errno |
| import sys |
| import tempfile |
| import re |
| from devtool import exec_build_env_command, setup_tinfoil, parse_recipe, DevtoolError |
| |
| logger = logging.getLogger('devtool') |
| |
| def parse_locked_sigs(sigfile_path): |
| """Return <pn:task>:<hash> dictionary""" |
| sig_dict = {} |
| with open(sigfile_path) as f: |
| lines = f.readlines() |
| for line in lines: |
| if ':' in line: |
| taskkey, _, hashval = line.rpartition(':') |
| sig_dict[taskkey.strip()] = hashval.split()[0] |
| return sig_dict |
| |
| def generate_update_dict(sigfile_new, sigfile_old): |
| """Return a dict containing <pn:task>:<hash> which indicates what need to be updated""" |
| update_dict = {} |
| sigdict_new = parse_locked_sigs(sigfile_new) |
| sigdict_old = parse_locked_sigs(sigfile_old) |
| for k in sigdict_new: |
| if k not in sigdict_old: |
| update_dict[k] = sigdict_new[k] |
| continue |
| if sigdict_new[k] != sigdict_old[k]: |
| update_dict[k] = sigdict_new[k] |
| continue |
| return update_dict |
| |
| def get_sstate_objects(update_dict, sstate_dir): |
| """Return a list containing sstate objects which are to be installed""" |
| sstate_objects = [] |
| for k in update_dict: |
| files = set() |
| hashval = update_dict[k] |
| p = sstate_dir + '/' + hashval[:2] + '/*' + hashval + '*.tgz' |
| files |= set(glob.glob(p)) |
| p = sstate_dir + '/*/' + hashval[:2] + '/*' + hashval + '*.tgz' |
| files |= set(glob.glob(p)) |
| files = list(files) |
| if len(files) == 1: |
| sstate_objects.extend(files) |
| elif len(files) > 1: |
| logger.error("More than one matching sstate object found for %s" % hashval) |
| |
| return sstate_objects |
| |
| def mkdir(d): |
| try: |
| os.makedirs(d) |
| except OSError as e: |
| if e.errno != errno.EEXIST: |
| raise e |
| |
| def install_sstate_objects(sstate_objects, src_sdk, dest_sdk): |
| """Install sstate objects into destination SDK""" |
| sstate_dir = os.path.join(dest_sdk, 'sstate-cache') |
| if not os.path.exists(sstate_dir): |
| logger.error("Missing sstate-cache directory in %s, it might not be an extensible SDK." % dest_sdk) |
| raise |
| for sb in sstate_objects: |
| dst = sb.replace(src_sdk, dest_sdk) |
| destdir = os.path.dirname(dst) |
| mkdir(destdir) |
| logger.debug("Copying %s to %s" % (sb, dst)) |
| shutil.copy(sb, dst) |
| |
| def check_manifest(fn, basepath): |
| import bb.utils |
| changedfiles = [] |
| with open(fn, 'r') as f: |
| for line in f: |
| splitline = line.split() |
| if len(splitline) > 1: |
| chksum = splitline[0] |
| fpath = splitline[1] |
| curr_chksum = bb.utils.sha256_file(os.path.join(basepath, fpath)) |
| if chksum != curr_chksum: |
| logger.debug('File %s changed: old csum = %s, new = %s' % (os.path.join(basepath, fpath), curr_chksum, chksum)) |
| changedfiles.append(fpath) |
| return changedfiles |
| |
| def sdk_update(args, config, basepath, workspace): |
| """Entry point for devtool sdk-update command""" |
| updateserver = args.updateserver |
| if not updateserver: |
| updateserver = config.get('SDK', 'updateserver', '') |
| logger.debug("updateserver: %s" % updateserver) |
| |
| # Make sure we are using sdk-update from within SDK |
| logger.debug("basepath = %s" % basepath) |
| old_locked_sig_file_path = os.path.join(basepath, 'conf/locked-sigs.inc') |
| if not os.path.exists(old_locked_sig_file_path): |
| logger.error("Not using devtool's sdk-update command from within an extensible SDK. Please specify correct basepath via --basepath option") |
| return -1 |
| else: |
| logger.debug("Found conf/locked-sigs.inc in %s" % basepath) |
| |
| if not '://' in updateserver: |
| logger.error("Update server must be a URL") |
| return -1 |
| |
| layers_dir = os.path.join(basepath, 'layers') |
| conf_dir = os.path.join(basepath, 'conf') |
| |
| # Grab variable values |
| tinfoil = setup_tinfoil(config_only=True, basepath=basepath) |
| try: |
| stamps_dir = tinfoil.config_data.getVar('STAMPS_DIR') |
| sstate_mirrors = tinfoil.config_data.getVar('SSTATE_MIRRORS') |
| site_conf_version = tinfoil.config_data.getVar('SITE_CONF_VERSION') |
| finally: |
| tinfoil.shutdown() |
| |
| tmpsdk_dir = tempfile.mkdtemp() |
| try: |
| os.makedirs(os.path.join(tmpsdk_dir, 'conf')) |
| new_locked_sig_file_path = os.path.join(tmpsdk_dir, 'conf', 'locked-sigs.inc') |
| # Fetch manifest from server |
| tmpmanifest = os.path.join(tmpsdk_dir, 'conf', 'sdk-conf-manifest') |
| ret = subprocess.call("wget -q -O %s %s/conf/sdk-conf-manifest" % (tmpmanifest, updateserver), shell=True) |
| if ret != 0: |
| logger.error("Cannot dowload files from %s" % updateserver) |
| return ret |
| changedfiles = check_manifest(tmpmanifest, basepath) |
| if not changedfiles: |
| logger.info("Already up-to-date") |
| return 0 |
| # Update metadata |
| logger.debug("Updating metadata via git ...") |
| #Check for the status before doing a fetch and reset |
| if os.path.exists(os.path.join(basepath, 'layers/.git')): |
| out = subprocess.check_output("git status --porcelain", shell=True, cwd=layers_dir) |
| if not out: |
| ret = subprocess.call("git fetch --all; git reset --hard @{u}", shell=True, cwd=layers_dir) |
| else: |
| logger.error("Failed to update metadata as there have been changes made to it. Aborting."); |
| logger.error("Changed files:\n%s" % out); |
| return -1 |
| else: |
| ret = -1 |
| if ret != 0: |
| ret = subprocess.call("git clone %s/layers/.git" % updateserver, shell=True, cwd=tmpsdk_dir) |
| if ret != 0: |
| logger.error("Updating metadata via git failed") |
| return ret |
| logger.debug("Updating conf files ...") |
| for changedfile in changedfiles: |
| ret = subprocess.call("wget -q -O %s %s/%s" % (changedfile, updateserver, changedfile), shell=True, cwd=tmpsdk_dir) |
| if ret != 0: |
| logger.error("Updating %s failed" % changedfile) |
| return ret |
| |
| # Check if UNINATIVE_CHECKSUM changed |
| uninative = False |
| if 'conf/local.conf' in changedfiles: |
| def read_uninative_checksums(fn): |
| chksumitems = [] |
| with open(fn, 'r') as f: |
| for line in f: |
| if line.startswith('UNINATIVE_CHECKSUM'): |
| splitline = re.split(r'[\[\]"\']', line) |
| if len(splitline) > 3: |
| chksumitems.append((splitline[1], splitline[3])) |
| return chksumitems |
| |
| oldsums = read_uninative_checksums(os.path.join(basepath, 'conf/local.conf')) |
| newsums = read_uninative_checksums(os.path.join(tmpsdk_dir, 'conf/local.conf')) |
| if oldsums != newsums: |
| uninative = True |
| for buildarch, chksum in newsums: |
| uninative_file = os.path.join('downloads', 'uninative', chksum, '%s-nativesdk-libc.tar.bz2' % buildarch) |
| mkdir(os.path.join(tmpsdk_dir, os.path.dirname(uninative_file))) |
| ret = subprocess.call("wget -q -O %s %s/%s" % (uninative_file, updateserver, uninative_file), shell=True, cwd=tmpsdk_dir) |
| |
| # Ok, all is well at this point - move everything over |
| tmplayers_dir = os.path.join(tmpsdk_dir, 'layers') |
| if os.path.exists(tmplayers_dir): |
| shutil.rmtree(layers_dir) |
| shutil.move(tmplayers_dir, layers_dir) |
| for changedfile in changedfiles: |
| destfile = os.path.join(basepath, changedfile) |
| os.remove(destfile) |
| shutil.move(os.path.join(tmpsdk_dir, changedfile), destfile) |
| os.remove(os.path.join(conf_dir, 'sdk-conf-manifest')) |
| shutil.move(tmpmanifest, conf_dir) |
| if uninative: |
| shutil.rmtree(os.path.join(basepath, 'downloads', 'uninative')) |
| shutil.move(os.path.join(tmpsdk_dir, 'downloads', 'uninative'), os.path.join(basepath, 'downloads')) |
| |
| if not sstate_mirrors: |
| with open(os.path.join(conf_dir, 'site.conf'), 'a') as f: |
| f.write('SCONF_VERSION = "%s"\n' % site_conf_version) |
| f.write('SSTATE_MIRRORS:append = " file://.* %s/sstate-cache/PATH \\n "\n' % updateserver) |
| finally: |
| shutil.rmtree(tmpsdk_dir) |
| |
| if not args.skip_prepare: |
| # Find all potentially updateable tasks |
| sdk_update_targets = [] |
| tasks = ['do_populate_sysroot', 'do_packagedata'] |
| for root, _, files in os.walk(stamps_dir): |
| for fn in files: |
| if not '.sigdata.' in fn: |
| for task in tasks: |
| if '.%s.' % task in fn or '.%s_setscene.' % task in fn: |
| sdk_update_targets.append('%s:%s' % (os.path.basename(root), task)) |
| # Run bitbake command for the whole SDK |
| logger.info("Preparing build system... (This may take some time.)") |
| try: |
| exec_build_env_command(config.init_path, basepath, 'bitbake --setscene-only %s' % ' '.join(sdk_update_targets), stderr=subprocess.STDOUT) |
| output, _ = exec_build_env_command(config.init_path, basepath, 'bitbake -n %s' % ' '.join(sdk_update_targets), stderr=subprocess.STDOUT) |
| runlines = [] |
| for line in output.splitlines(): |
| if 'Running task ' in line: |
| runlines.append(line) |
| if runlines: |
| logger.error('Unexecuted tasks found in preparation log:\n %s' % '\n '.join(runlines)) |
| return -1 |
| except bb.process.ExecutionError as e: |
| logger.error('Preparation failed:\n%s' % e.stdout) |
| return -1 |
| return 0 |
| |
| def sdk_install(args, config, basepath, workspace): |
| """Entry point for the devtool sdk-install command""" |
| |
| import oe.recipeutils |
| import bb.process |
| |
| for recipe in args.recipename: |
| if recipe in workspace: |
| raise DevtoolError('recipe %s is a recipe in your workspace' % recipe) |
| |
| tasks = ['do_populate_sysroot', 'do_packagedata'] |
| stampprefixes = {} |
| def checkstamp(recipe): |
| stampprefix = stampprefixes[recipe] |
| stamps = glob.glob(stampprefix + '*') |
| for stamp in stamps: |
| if '.sigdata.' not in stamp and stamp.startswith((stampprefix + '.', stampprefix + '_setscene.')): |
| return True |
| else: |
| return False |
| |
| install_recipes = [] |
| tinfoil = setup_tinfoil(config_only=False, basepath=basepath) |
| try: |
| for recipe in args.recipename: |
| rd = parse_recipe(config, tinfoil, recipe, True) |
| if not rd: |
| return 1 |
| stampprefixes[recipe] = '%s.%s' % (rd.getVar('STAMP'), tasks[0]) |
| if checkstamp(recipe): |
| logger.info('%s is already installed' % recipe) |
| else: |
| install_recipes.append(recipe) |
| finally: |
| tinfoil.shutdown() |
| |
| if install_recipes: |
| logger.info('Installing %s...' % ', '.join(install_recipes)) |
| install_tasks = [] |
| for recipe in install_recipes: |
| for task in tasks: |
| if recipe.endswith('-native') and 'package' in task: |
| continue |
| install_tasks.append('%s:%s' % (recipe, task)) |
| options = '' |
| if not args.allow_build: |
| options += ' --setscene-only' |
| try: |
| exec_build_env_command(config.init_path, basepath, 'bitbake %s %s' % (options, ' '.join(install_tasks)), watch=True) |
| except bb.process.ExecutionError as e: |
| raise DevtoolError('Failed to install %s:\n%s' % (recipe, str(e))) |
| failed = False |
| for recipe in install_recipes: |
| if checkstamp(recipe): |
| logger.info('Successfully installed %s' % recipe) |
| else: |
| raise DevtoolError('Failed to install %s - unavailable' % recipe) |
| failed = True |
| if failed: |
| return 2 |
| |
| try: |
| exec_build_env_command(config.init_path, basepath, 'bitbake build-sysroots', watch=True) |
| except bb.process.ExecutionError as e: |
| raise DevtoolError('Failed to bitbake build-sysroots:\n%s' % (str(e))) |
| |
| |
| def register_commands(subparsers, context): |
| """Register devtool subcommands from the sdk plugin""" |
| if context.fixed_setup: |
| parser_sdk = subparsers.add_parser('sdk-update', |
| help='Update SDK components', |
| description='Updates installed SDK components from a remote server', |
| group='sdk') |
| updateserver = context.config.get('SDK', 'updateserver', '') |
| if updateserver: |
| parser_sdk.add_argument('updateserver', help='The update server to fetch latest SDK components from (default %s)' % updateserver, nargs='?') |
| else: |
| parser_sdk.add_argument('updateserver', help='The update server to fetch latest SDK components from') |
| parser_sdk.add_argument('--skip-prepare', action="store_true", help='Skip re-preparing the build system after updating (for debugging only)') |
| parser_sdk.set_defaults(func=sdk_update) |
| |
| parser_sdk_install = subparsers.add_parser('sdk-install', |
| help='Install additional SDK components', |
| description='Installs additional recipe development files into the SDK. (You can use "devtool search" to find available recipes.)', |
| group='sdk') |
| parser_sdk_install.add_argument('recipename', help='Name of the recipe to install the development artifacts for', nargs='+') |
| parser_sdk_install.add_argument('-s', '--allow-build', help='Allow building requested item(s) from source', action='store_true') |
| parser_sdk_install.set_defaults(func=sdk_install) |