1 files changed, 64 insertions, 46 deletions

diff --git a/scripts/devtool b/scripts/devtool
index 8a4f41bc37..39cebec0d8 100755
--- a/scripts/devtool
+++ b/scripts/devtool
@@ -7,19 +7,17 @@
 # SPDX-License-Identifier: GPL-2.0-only
 #
 
+import dataclasses
 import sys
 import os
 import argparse
 import glob
 import re
 import configparser
-import subprocess
 import logging
 
-basepath = ''
-workspace = {}
-config = None
-context = None
+# This can be removed once our minimum is Python 3.9: https://docs.python.org/3/whatsnew/3.9.html#type-hinting-generics-in-standard-collections
+from typing import List
 
 
 scripts_path = os.path.dirname(os.path.realpath(__file__))
@@ -30,16 +28,16 @@ import scriptutils
 import argparse_oe
 logger = scriptutils.logger_create('devtool')
 
-plugins = []
 
-
-class ConfigHandler(object):
+class ConfigHandler:
+    basepath = None
     config_file = ''
     config_obj = None
     init_path = ''
     workspace_path = ''
 
-    def __init__(self, filename):
+    def __init__(self, basepath, filename):
+        self.basepath = basepath
         self.config_file = filename
         self.config_obj = configparser.ConfigParser()
 
@@ -47,7 +45,7 @@ class ConfigHandler(object):
         try:
             ret = self.config_obj.get(section, option)
         except (configparser.NoOptionError, configparser.NoSectionError):
-            if default != None:
+            if default is not None:
                 ret = default
             else:
                 raise
@@ -59,14 +57,14 @@ class ConfigHandler(object):
 
             if self.config_obj.has_option('General', 'init_path'):
                 pth = self.get('General', 'init_path')
-                self.init_path = os.path.join(basepath, pth)
+                self.init_path = os.path.join(self.basepath, pth)
                 if not os.path.exists(self.init_path):
                     logger.error('init_path %s specified in config file cannot be found' % pth)
                     return False
         else:
             self.config_obj.add_section('General')
 
-        self.workspace_path = self.get('General', 'workspace_path', os.path.join(basepath, 'workspace'))
+        self.workspace_path = self.get('General', 'workspace_path', os.path.join(self.basepath, 'workspace'))
         return True
 
 
@@ -81,29 +79,32 @@ class ConfigHandler(object):
             self.config_obj.add_section(section)
         self.config_obj.set(section, option, value)
 
+
+@dataclasses.dataclass
 class Context:
-    def __init__(self, **kwargs):
-        self.__dict__.update(kwargs)
+    fixed_setup: bool
+    config: ConfigHandler
+    pluginpaths: List[str]
 
 
-def read_workspace():
-    global workspace
+def read_workspace(basepath, context):
     workspace = {}
-    if not os.path.exists(os.path.join(config.workspace_path, 'conf', 'layer.conf')):
+    if not os.path.exists(os.path.join(context.config.workspace_path, 'conf', 'layer.conf')):
         if context.fixed_setup:
             logger.error("workspace layer not set up")
             sys.exit(1)
         else:
-            logger.info('Creating workspace layer in %s' % config.workspace_path)
-            _create_workspace(config.workspace_path, config, basepath)
+            logger.info('Creating workspace layer in %s' % context.config.workspace_path)
+            _create_workspace(context.config.workspace_path, basepath)
     if not context.fixed_setup:
-        _enable_workspace_layer(config.workspace_path, config, basepath)
+        _enable_workspace_layer(context.config.workspace_path, context.config, basepath)
 
-    logger.debug('Reading workspace in %s' % config.workspace_path)
-    externalsrc_re = re.compile(r'^EXTERNALSRC(_pn-([^ =]+))? *= *"([^"]*)"$')
-    for fn in glob.glob(os.path.join(config.workspace_path, 'appends', '*.bbappend')):
+    logger.debug('Reading workspace in %s' % context.config.workspace_path)
+    externalsrc_re = re.compile(r'^EXTERNALSRC(:pn-([^ =]+))? *= *"([^"]*)"$')
+    for fn in glob.glob(os.path.join(context.config.workspace_path, 'appends', '*.bbappend')):
         with open(fn, 'r') as f:
             pnvalues = {}
+            pn = None
             for line in f:
                 res = externalsrc_re.match(line.rstrip())
                 if res:
@@ -111,7 +112,7 @@ def read_workspace():
                     pn = res.group(2) or recipepn
                     # Find the recipe file within the workspace, if any
                     bbfile = os.path.basename(fn).replace('.bbappend', '.bb').replace('%', '*')
-                    recipefile = glob.glob(os.path.join(config.workspace_path,
+                    recipefile = glob.glob(os.path.join(context.config.workspace_path,
                                                         'recipes',
                                                         recipepn,
                                                         bbfile))
@@ -123,27 +124,42 @@ def read_workspace():
                 elif line.startswith('# srctreebase: '):
                     pnvalues['srctreebase'] = line.split(':', 1)[1].strip()
             if pnvalues:
+                if not pn:
+                    raise DevtoolError("Found *.bbappend in %s, but could not determine EXTERNALSRC:pn-*. "
+                            "Maybe still using old syntax?" % context.config.workspace_path)
                 if not pnvalues.get('srctreebase', None):
                     pnvalues['srctreebase'] = pnvalues['srctree']
                 logger.debug('Found recipe %s' % pnvalues)
                 workspace[pn] = pnvalues
 
-def create_workspace(args, config, basepath, workspace):
+    return workspace
+
+def create_workspace(args, config, basepath, _workspace):
     if args.layerpath:
         workspacedir = os.path.abspath(args.layerpath)
     else:
         workspacedir = os.path.abspath(os.path.join(basepath, 'workspace'))
-    _create_workspace(workspacedir, config, basepath)
+    layerseries = None
+    if args.layerseries:
+        layerseries = args.layerseries
+    _create_workspace(workspacedir, basepath, layerseries)
     if not args.create_only:
         _enable_workspace_layer(workspacedir, config, basepath)
 
-def _create_workspace(workspacedir, config, basepath):
-    import bb
+def _create_workspace(workspacedir, basepath, layerseries=None):
+    import bb.utils
 
     confdir = os.path.join(workspacedir, 'conf')
     if os.path.exists(os.path.join(confdir, 'layer.conf')):
         logger.info('Specified workspace already set up, leaving as-is')
     else:
+        if not layerseries:
+            tinfoil = setup_tinfoil(config_only=True, basepath=basepath)
+            try:
+                layerseries = tinfoil.config_data.getVar('LAYERSERIES_CORENAMES')
+            finally:
+                tinfoil.shutdown()
+
         # Add a config file
         bb.utils.mkdirhier(confdir)
         with open(os.path.join(confdir, 'layer.conf'), 'w') as f:
@@ -155,7 +171,7 @@ def _create_workspace(workspacedir, config, basepath):
             f.write('BBFILE_PATTERN_workspacelayer = "^$' + '{LAYERDIR}/"\n')
             f.write('BBFILE_PATTERN_IGNORE_EMPTY_workspacelayer = "1"\n')
             f.write('BBFILE_PRIORITY_workspacelayer = "99"\n')
-            f.write('LAYERSERIES_COMPAT_workspacelayer = "${LAYERSERIES_COMPAT_core}"\n')
+            f.write('LAYERSERIES_COMPAT_workspacelayer = "%s"\n' % layerseries)
         # Add a README file
         with open(os.path.join(workspacedir, 'README'), 'w') as f:
             f.write('This layer was created by the OpenEmbedded devtool utility in order to\n')
@@ -176,7 +192,7 @@ def _create_workspace(workspacedir, config, basepath):
 
 def _enable_workspace_layer(workspacedir, config, basepath):
     """Ensure the workspace layer is in bblayers.conf"""
-    import bb
+    import bb.utils
     bblayers_conf = os.path.join(basepath, 'conf', 'bblayers.conf')
     if not os.path.exists(bblayers_conf):
         logger.error('Unable to find bblayers.conf')
@@ -195,15 +211,9 @@ def _enable_workspace_layer(workspacedir, config, basepath):
 
 
 def main():
-    global basepath
-    global config
-    global context
-
     if sys.getfilesystemencoding() != "utf-8":
         sys.exit("Please use a locale setting which supports utf-8.\nPython can't change the filesystem locale after loading so we need a utf-8 when python starts or things won't work.")
 
-    context = Context(fixed_setup=False)
-
     # Default basepath
     basepath = os.path.dirname(os.path.abspath(__file__))
 
@@ -228,21 +238,23 @@ def main():
     elif global_args.quiet:
         logger.setLevel(logging.ERROR)
 
+    is_fixed_setup = False
+
     if global_args.basepath:
         # Override
         basepath = global_args.basepath
         if os.path.exists(os.path.join(basepath, '.devtoolbase')):
-            context.fixed_setup = True
+            is_fixed_setup = True
     else:
         pth = basepath
         while pth != '' and pth != os.sep:
             if os.path.exists(os.path.join(pth, '.devtoolbase')):
-                context.fixed_setup = True
+                is_fixed_setup = True
                 basepath = pth
                 break
             pth = os.path.dirname(pth)
 
-        if not context.fixed_setup:
+        if not is_fixed_setup:
             basepath = os.environ.get('BUILDDIR')
             if not basepath:
                 logger.error("This script can only be run after initialising the build environment (e.g. by using oe-init-build-env)")
@@ -250,10 +262,9 @@ def main():
 
     logger.debug('Using basepath %s' % basepath)
 
-    config = ConfigHandler(os.path.join(basepath, 'conf', 'devtool.conf'))
+    config = ConfigHandler(basepath, os.path.join(basepath, 'conf', 'devtool.conf'))
     if not config.read():
         return -1
-    context.config = config
 
     bitbake_subdir = config.get('General', 'bitbake_subdir', '')
     if bitbake_subdir:
@@ -275,6 +286,7 @@ def main():
     scriptutils.logger_setup_color(logger, global_args.color)
 
     if global_args.bbpath is None:
+        import bb
         try:
             tinfoil = setup_tinfoil(config_only=True, basepath=basepath)
             try:
@@ -285,8 +297,12 @@ def main():
             return 2
 
     # Search BBPATH first to allow layers to override plugins in scripts_path
-    for path in global_args.bbpath.split(':') + [scripts_path]:
-        pluginpath = os.path.join(path, 'lib', 'devtool')
+    pluginpaths = [os.path.join(path, 'lib', 'devtool') for path in global_args.bbpath.split(':') + [scripts_path]]
+
+    context = Context(fixed_setup=is_fixed_setup, config=config, pluginpaths=pluginpaths)
+
+    plugins = []
+    for pluginpath in pluginpaths:
         scriptutils.load_plugins(logger, plugins, pluginpath)
 
     subparsers = parser.add_subparsers(dest="subparser_name", title='subcommands', metavar='<subcommand>')
@@ -305,6 +321,7 @@ def main():
                                                         description='Sets up a new workspace. NOTE: other devtool subcommands will create a workspace automatically as needed, so you only need to use %(prog)s if you want to specify where the workspace should be located.',
                                                         group='advanced')
         parser_create_workspace.add_argument('layerpath', nargs='?', help='Path in which the workspace layer should be created')
+        parser_create_workspace.add_argument('--layerseries', help='Layer series the workspace should be set to be compatible with')
         parser_create_workspace.add_argument('--create-only', action="store_true", help='Only create the workspace layer, do not alter configuration')
         parser_create_workspace.set_defaults(func=create_workspace, no_workspace=True)
 
@@ -314,10 +331,10 @@ def main():
 
     args = parser.parse_args(unparsed_args, namespace=global_args)
 
-    if not getattr(args, 'no_workspace', False):
-        read_workspace()
-
     try:
+        workspace = {}
+        if not getattr(args, 'no_workspace', False):
+            workspace = read_workspace(basepath, context)
         ret = args.func(args, config, basepath, workspace)
     except DevtoolError as err:
         if str(err):
@@ -325,6 +342,7 @@ def main():
         ret = err.exitcode
     except argparse_oe.ArgumentUsageError as ae:
         parser.error_subcommand(ae.message, ae.subcommand)
+        ret = 2
 
     return ret