poky/scripts/oe-pkgdata-util

#!/usr/bin/env python

OpenEmbedded pkgdata utility

Written by: Paul Eggleton paul.eggleton@linux.intel.com

Copyright 2012-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.

import sys import os import os.path import fnmatch import re import argparse import logging from collections import defaultdict

scripts_path = os.path.dirname(os.path.realpath(file)) lib_path = scripts_path + '/lib' sys.path = sys.path + [lib_path] import scriptutils logger = scriptutils.logger_create('pkgdatautil')

def tinfoil_init(): import bb.tinfoil import logging tinfoil = bb.tinfoil.Tinfoil() tinfoil.prepare(True)

tinfoil.logger.setLevel(logging.WARNING)
return tinfoil

def glob(args): # Handle both multiple arguments and multiple values within an arg (old syntax) globs = [] for globitem in args.glob: globs.extend(globitem.split())

if not os.path.exists(args.pkglistfile):
    logger.error('Unable to find package list file %s' % args.pkglistfile)
    sys.exit(1)

skipregex = re.compile("-locale-|^locale-base-|-dev$|-doc$|-dbg$|-staticdev$|^kernel-module-")

mappedpkgs = set()
with open(args.pkglistfile, 'r') as f:
    for line in f:
        fields = line.rstrip().split()
        if not fields:
            continue
        pkg = fields[0]
        # We don't care about other args (used to need the package architecture but the
        # new pkgdata structure avoids the need for that)

        # Skip packages for which there is no point applying globs
        if skipregex.search(pkg):
            logger.debug("%s -> !!" % pkg)
            continue

        # Skip packages that already match the globs, so if e.g. a dev package
        # is already installed and thus in the list, we don't process it any further
        # Most of these will be caught by skipregex already, but just in case...
        already = False
        for g in globs:
            if fnmatch.fnmatchcase(pkg, g):
                already = True
                break
        if already:
            logger.debug("%s -> !" % pkg)
            continue

        # Define some functions
        def revpkgdata(pkgn):
            return os.path.join(args.pkgdata_dir, "runtime-reverse", pkgn)
        def fwdpkgdata(pkgn):
            return os.path.join(args.pkgdata_dir, "runtime", pkgn)
        def readpn(pkgdata_file):
            pn = ""
            with open(pkgdata_file, 'r') as f:
                for line in f:
                    if line.startswith("PN:"):
                        pn = line.split(': ')[1].rstrip()
            return pn
        def readrenamed(pkgdata_file):
            renamed = ""
            pn = os.path.basename(pkgdata_file)
            with open(pkgdata_file, 'r') as f:
                for line in f:
                    if line.startswith("PKG_%s:" % pn):
                        renamed = line.split(': ')[1].rstrip()
            return renamed

        # Main processing loop
        for g in globs:
            mappedpkg = ""
            # First just try substitution (i.e. packagename -> packagename-dev)
            newpkg = g.replace("*", pkg)
            revlink = revpkgdata(newpkg)
            if os.path.exists(revlink):
                mappedpkg = os.path.basename(os.readlink(revlink))
                fwdfile = fwdpkgdata(mappedpkg)
                if os.path.exists(fwdfile):
                    mappedpkg = readrenamed(fwdfile)
                if not os.path.exists(fwdfile + ".packaged"):
                    mappedpkg = ""
            else:
                revlink = revpkgdata(pkg)
                if os.path.exists(revlink):
                    # Check if we can map after undoing the package renaming (by resolving the symlink)
                    origpkg = os.path.basename(os.readlink(revlink))
                    newpkg = g.replace("*", origpkg)
                    fwdfile = fwdpkgdata(newpkg)
                    if os.path.exists(fwdfile):
                        mappedpkg = readrenamed(fwdfile)
                    else:
                        # That didn't work, so now get the PN, substitute that, then map in the other direction
                        pn = readpn(revlink)
                        newpkg = g.replace("*", pn)
                        fwdfile = fwdpkgdata(newpkg)
                        if os.path.exists(fwdfile):
                            mappedpkg = readrenamed(fwdfile)
                    if not os.path.exists(fwdfile + ".packaged"):
                        mappedpkg = ""
                else:
                    # Package doesn't even exist...
                    logger.debug("%s is not a valid package!" % (pkg))
                    break

            if mappedpkg:
                logger.debug("%s (%s) -> %s" % (pkg, g, mappedpkg))
                mappedpkgs.add(mappedpkg)
            else:
                logger.debug("%s (%s) -> ?" % (pkg, g))

logger.debug("------")

print("\n".join(mappedpkgs))

def read_value(args): # Handle both multiple arguments and multiple values within an arg (old syntax) packages = [] for pkgitem in args.pkg: packages.extend(pkgitem.split())

def readvar(pkgdata_file, valuename):
    val = ""
    with open(pkgdata_file, 'r') as f:
        for line in f:
            if line.startswith(valuename + ":"):
                val = line.split(': ')[1].rstrip()
    return val

logger.debug("read-value('%s', '%s' '%s'" % (args.pkgdata_dir, args.valuename, packages))
for package in packages:
    pkg_split = package.split('_')
    pkg_name = pkg_split[0]
    logger.debug("package: '%s'" % pkg_name)
    revlink = os.path.join(args.pkgdata_dir, "runtime-reverse", pkg_name)
    logger.debug(revlink)
    if os.path.exists(revlink):
        mappedpkg = os.path.basename(os.readlink(revlink))
        qvar = args.valuename
        if qvar == "PKGSIZE":
            # append packagename
            qvar = "%s_%s" % (args.valuename, mappedpkg)
            # PKGSIZE is now in bytes, but we we want it in KB
            pkgsize = (int(readvar(revlink, qvar)) + 1024 // 2) // 1024
            print("%d" % pkgsize)
        else:
            print(readvar(revlink, qvar))

def lookup_pkg(args): # Handle both multiple arguments and multiple values within an arg (old syntax) pkgs = [] for pkgitem in args.recipepkg: pkgs.extend(pkgitem.split())

mappings = defaultdict(list)
for pkg in pkgs:
    pkgfile = os.path.join(args.pkgdata_dir, 'runtime', pkg)
    if os.path.exists(pkgfile):
        with open(pkgfile, 'r') as f:
            for line in f:
                fields = line.rstrip().split(': ')
                if fields[0] == 'PKG_%s' % pkg:
                    mappings[pkg].append(fields[1])
                    break
if len(mappings) < len(pkgs):
    missing = list(set(pkgs) - set(mappings.keys()))
    logger.error("The following packages could not be found: %s" % ', '.join(missing))
    sys.exit(1)

items = []
for pkg in pkgs:
    items.extend(mappings.get(pkg, []))
print('\n'.join(items))

def lookup_recipe(args): # Handle both multiple arguments and multiple values within an arg (old syntax) pkgs = [] for pkgitem in args.pkg: pkgs.extend(pkgitem.split())

mappings = defaultdict(list)
for pkg in pkgs:
    pkgfile = os.path.join(args.pkgdata_dir, 'runtime-reverse', pkg)
    if os.path.exists(pkgfile):
        with open(pkgfile, 'r') as f:
            for line in f:
                fields = line.rstrip().split(': ')
                if fields[0] == 'PN':
                    mappings[pkg].append(fields[1])
                    break
if len(mappings) < len(pkgs):
    missing = list(set(pkgs) - set(mappings.keys()))
    logger.error("The following packages could not be found: %s" % ', '.join(missing))
    sys.exit(1)

items = []
for pkg in pkgs:
    items.extend(mappings.get(pkg, []))
print('\n'.join(items))

def find_path(args): import json

found = False
for root, dirs, files in os.walk(os.path.join(args.pkgdata_dir, 'runtime')):
    for fn in files:
        with open(os.path.join(root,fn)) as f:
            for line in f:
                if line.startswith('FILES_INFO:'):
                    val = line.split(':', 1)[1].strip()
                    dictval = json.loads(val)
                    for fullpth in dictval.keys():
                        if fnmatch.fnmatchcase(fullpth, args.targetpath):
                            found = True
                            print("%s: %s" % (fn, fullpth))
                    break
if not found:
    logger.error("Unable to find any package producing path %s" % args.targetpath)
    sys.exit(1)

def main(): parser = argparse.ArgumentParser(description="OpenEmbedded pkgdata tool - queries the pkgdata files written out during do_package", epilog="Use %(prog)s --help to get help on a specific command") parser.add_argument('-d', '--debug', help='Enable debug output', action='store_true') parser.add_argument('-p', '--pkgdata-dir', help='Path to pkgdata directory (determined automatically if not specified)') subparsers = parser.add_subparsers(title='subcommands', metavar='')

parser_lookup_pkg = subparsers.add_parser('lookup-pkg',
                                      help='Translate recipe-space package names to runtime package names',
                                      description='Looks up the specified recipe-space package name(s) to see what the final runtime package name is (e.g. glibc becomes libc6)')
parser_lookup_pkg.add_argument('recipepkg', nargs='+', help='Recipe-space package name to look up')
parser_lookup_pkg.set_defaults(func=lookup_pkg)

parser_lookup_recipe = subparsers.add_parser('lookup-recipe',
                                      help='Find recipe producing one or more packages',
                                      description='Looks up the specified runtime package(s) to see which recipe they were produced by')
parser_lookup_recipe.add_argument('pkg', nargs='+', help='Runtime package name to look up')
parser_lookup_recipe.set_defaults(func=lookup_recipe)

parser_find_path = subparsers.add_parser('find-path',
                                      help='Find package providing a target path',
                                      description='Finds the recipe-space package providing the specified target path')
parser_find_path.add_argument('targetpath', help='Path to find (wildcards * ? allowed, use quotes to avoid shell expansion)')
parser_find_path.set_defaults(func=find_path)

parser_read_value = subparsers.add_parser('read-value',
                                      help='Read any pkgdata value for one or more packages',
                                      description='Reads the named value from the pkgdata files for the specified packages')
parser_read_value.add_argument('valuename', help='Name of the value to look up')
parser_read_value.add_argument('pkg', nargs='+', help='Runtime package name to look up')
parser_read_value.set_defaults(func=read_value)

parser_glob = subparsers.add_parser('glob',
                                      help='Expand package name glob expression',
                                      description='Expands one or more glob expressions over the packages listed in pkglistfile')
parser_glob.add_argument('pkglistfile', help='File listing packages (one package name per line)')
parser_glob.add_argument('glob', nargs="+", help='Glob expression for package names, e.g. *-dev')
parser_glob.set_defaults(func=glob)


args = parser.parse_args()

if args.debug:
    logger.setLevel(logging.DEBUG)

if not args.pkgdata_dir:
    import scriptpath
    bitbakepath = scriptpath.add_bitbake_lib_path()
    if not bitbakepath:
        logger.error("Unable to find bitbake by searching parent directory of this script or PATH")
        sys.exit(1)
    logger.debug('Found bitbake path: %s' % bitbakepath)
    tinfoil = tinfoil_init()
    args.pkgdata_dir = tinfoil.config_data.getVar('PKGDATA_DIR', True)
    logger.debug('Value of PKGDATA_DIR is "%s"' % args.pkgdata_dir)
    if not args.pkgdata_dir:
        logger.error('Unable to determine pkgdata directory from PKGDATA_DIR')
        sys.exit(1)

if not os.path.exists(args.pkgdata_dir):
    logger.error('Unable to find pkgdata directory %s' % pkgdata_dir)
    sys.exit(1)

ret = args.func(args)

return ret

if name == "main": main()