4 files changed, 233 insertions, 150 deletions

diff --git a/bitbake/bin/bitbake-setup b/bitbake/bin/bitbake-setup
index a0426005ff..29fdf11892 100755
--- a/bitbake/bin/bitbake-setup
+++ b/bitbake/bin/bitbake-setup
@@ -18,6 +18,7 @@ import configparser
 import datetime
 import glob
 import subprocess
+import copy
 
 default_registry = os.path.normpath(os.path.dirname(__file__) + "/../default-registry")
 
@@ -57,9 +58,15 @@ def get_config_name(config):
     else:
         raise Exception("Config file {} does not end with {}, please rename the file.".format(config, suffix))
 
-def write_config(config, config_dir):
+def write_upstream_config(config_dir, config_data):
     with open(os.path.join(config_dir, "config-upstream.json"),'w') as s:
-        json.dump(config, s, sort_keys=True, indent=4)
+        json.dump(config_data, s, sort_keys=True, indent=4)
+
+def write_sources_fixed_revisions(config_dir, config_data):
+    sources = {}
+    sources['sources'] = config_data
+    with open(os.path.join(config_dir, "sources-fixed-revisions.json"),'w') as s:
+        json.dump(sources, s, sort_keys=True, indent=4)
 
 def commit_config(config_dir):
     bb.process.run("git -C {} add .".format(config_dir))
@@ -76,6 +83,7 @@ def _write_layer_list(dest, repodirs):
         json.dump({"version":"1.0","layers":layers}, f, sort_keys=True, indent=4)
 
 def checkout_layers(layers, layerdir, d):
+    layers_fixed_revisions = copy.deepcopy(layers)
     repodirs = []
     oesetupbuild = None
     print("Fetching layer/tool repositories into {}".format(layerdir))
@@ -90,14 +98,18 @@ def checkout_layers(layers, layerdir, d):
         remotes = r_remote['remotes']
 
         for remote in remotes:
-            type,host,path,user,pswd,params = bb.fetch.decodeurl(remotes[remote]["uri"])
+            prot,host,path,user,pswd,params = bb.fetch.decodeurl(remotes[remote]["uri"])
             fetchuri = bb.fetch.encodeurl(('git',host,path,user,pswd,params))
             print("    {}".format(r_name))
             if branch:
-                fetcher = bb.fetch.Fetch(["{};protocol={};rev={};branch={};destsuffix={}".format(fetchuri,type,rev,branch,repodir)], d)
+                src_uri = f"{fetchuri};protocol={prot};rev={rev};branch={branch};destsuffix={repodir}"
             else:
-                fetcher = bb.fetch.Fetch(["{};protocol={};rev={};nobranch=1;destsuffix={}".format(fetchuri,type,rev,repodir)], d)
+                src_uri = f"{fetchuri};protocol={prot};rev={rev};nobranch=1;destsuffix={repodir}"
+            fetcher = bb.fetch.Fetch([src_uri], d)
             do_fetch(fetcher, layerdir)
+            urldata = fetcher.ud[src_uri]
+            revision = urldata.revision
+            layers_fixed_revisions[r_name]['git-remote']['rev'] = revision
 
         if os.path.exists(os.path.join(layerdir, repodir, 'scripts/oe-setup-build')):
             oesetupbuild = os.path.join(layerdir, repodir, 'scripts/oe-setup-build')
@@ -114,22 +126,27 @@ def checkout_layers(layers, layerdir, d):
                 os.remove(symlink)
             os.symlink(os.path.relpath(t,layerdir),symlink)
 
-def setup_bitbake_build(bitbake_config, layerdir, builddir, thisdir):
-    def _setup_build_conf(layers, build_conf_dir):
+    return layers_fixed_revisions
+
+def setup_bitbake_build(bitbake_config, layerdir, setupdir, thisdir):
+    def _setup_build_conf(layers, relative_layers, build_conf_dir):
         os.makedirs(build_conf_dir)
         layers_s = []
+
         for l in layers:
-            if l.startswith("{THISDIR}/"):
-                if thisdir:
-                    l = l.format(THISDIR=thisdir)
-                else:
-                    raise Exception("Configuration is using {THISDIR} to specify " \
-                    "a layer path relative to itself. This can be done only " \
-                    "when the configuration is specified by its path on local " \
-                    "disk, not when it's in a registry or is fetched over http.")
-            if not os.path.isabs(l):
-                l = os.path.join(layerdir, l)
+            l = os.path.join(layerdir, l)
             layers_s.append("  {} \\".format(l))
+
+        for l in relative_layers:
+            if thisdir:
+                l = os.path.join(thisdir, l)
+            else:
+                raise Exception("Configuration is using bb-layers-relative to specify " \
+                "a layer path relative to itself. This can be done only " \
+                "when the configuration is specified by its path on local " \
+                "disk, not when it's in a registry or is fetched over http.")
+            layers_s.append("  {} \\".format(l))
+
         layers_s = "\n".join(layers_s)
         bblayers_conf = """BBLAYERS ?= " \\
 {}
@@ -188,7 +205,7 @@ def setup_bitbake_build(bitbake_config, layerdir, builddir, thisdir):
             f.write('\n')
             f.write(content)
 
-    bitbake_builddir = os.path.join(builddir, "build")
+    bitbake_builddir = os.path.join(setupdir, "build")
     print("Setting up bitbake configuration in\n    {}\n".format(bitbake_builddir))
 
     template = bitbake_config.get("oe-template")
@@ -206,7 +223,8 @@ def setup_bitbake_build(bitbake_config, layerdir, builddir, thisdir):
         os.rename(bitbake_confdir, backup_bitbake_confdir)
 
     if layers:
-        _setup_build_conf(layers, bitbake_confdir)
+        relative_layers = bitbake_config.get("bb-layers-relative") or []
+        _setup_build_conf(layers, relative_layers, bitbake_confdir)
 
     if template:
         bb.process.run("{} setup -c {} -b {} --no-shell".format(oesetupbuild, template, bitbake_builddir))
@@ -220,7 +238,7 @@ def setup_bitbake_build(bitbake_config, layerdir, builddir, thisdir):
     _prepend_passthrough_to_init_build_env(bitbake_builddir)
 
     siteconf_symlink = os.path.join(bitbake_confdir, "site.conf")
-    siteconf = os.path.normpath(os.path.join(builddir, '..', "site.conf"))
+    siteconf = os.path.normpath(os.path.join(setupdir, '..', "site.conf"))
     if os.path.lexists(siteconf_symlink):
         os.remove(symlink)
     os.symlink(os.path.relpath(siteconf, bitbake_confdir) ,siteconf_symlink)
@@ -267,16 +285,17 @@ def get_registry_config(registry_path, id):
                 return os.path.join(root, f)
     raise Exception("Unable to find {} in available configurations; use 'list' sub-command to see what is available".format(id))
 
-def update_build(config, confdir, builddir, layerdir, d):
-    layer_config = config["data"]["sources"]
+def update_build(config, confdir, setupdir, layerdir, d):
+    layer_config = copy.deepcopy(config["data"]["sources"])
     layer_overrides = config["source-overrides"]["sources"]
     for k,v in layer_overrides.items():
         if k in layer_config:
             layer_config[k]["git-remote"] = v["git-remote"]
-    checkout_layers(layer_config, layerdir, d)
+    sources_fixed_revisions = checkout_layers(layer_config, layerdir, d)
     bitbake_config = config["bitbake-config"]
     thisdir = os.path.dirname(config["path"]) if config["type"] == 'local' else None
-    setup_bitbake_build(bitbake_config, layerdir, builddir, thisdir)
+    setup_bitbake_build(bitbake_config, layerdir, setupdir, thisdir)
+    write_sources_fixed_revisions(confdir, sources_fixed_revisions)
 
 def int_input(allowed_values):
     n = None
@@ -441,22 +460,22 @@ def init_config(top_dir, settings, args, d):
     upstream_config = obtain_config(top_dir, settings, args, source_overrides, d)
     print("\nRun 'bitbake-setup init --non-interactive {}' to select this configuration non-interactively.\n".format(" ".join(upstream_config['non-interactive-cmdline-options'])))
 
-    builddir = os.path.join(os.path.abspath(top_dir), args.build_dir_name or "{}-{}".format(upstream_config['name']," ".join(upstream_config['non-interactive-cmdline-options'][1:]).replace(" ","-").replace("/","_")))
-    if os.path.exists(os.path.join(builddir, "layers")):
-        print(f"Build already initialized in:\n    {builddir}\nUse 'bitbake-setup status' to check if it needs to be updated, or 'bitbake-setup update' to perform the update.\nIf you would like to start over and re-initialize a build in this directory, remove it, and run 'bitbake-setup init' again.")
+    setupdir = os.path.join(os.path.abspath(top_dir), args.setup_dir_name or "{}-{}".format(upstream_config['name']," ".join(upstream_config['non-interactive-cmdline-options'][1:]).replace(" ","-").replace("/","_")))
+    if os.path.exists(os.path.join(setupdir, "layers")):
+        print(f"Setup already initialized in:\n    {setupdir}\nUse 'bitbake-setup status' to check if it needs to be updated, or 'bitbake-setup update' to perform the update.\nIf you would like to start over and re-initialize in this directory, remove it, and run 'bitbake-setup init' again.")
         return
 
-    print("Initializing a build in\n    {}".format(builddir))
+    print("Initializing a setup directory in\n    {}".format(setupdir))
     if not args.non_interactive:
         y_or_n = input('Continue? (y/N): ')
         if y_or_n != 'y':
             exit()
         print()
 
-    os.makedirs(builddir, exist_ok=True)
+    os.makedirs(setupdir, exist_ok=True)
 
-    confdir = os.path.join(builddir, "config")
-    layerdir = os.path.join(builddir, "layers")
+    confdir = os.path.join(setupdir, "config")
+    layerdir = os.path.join(setupdir, "layers")
 
     os.makedirs(confdir)
     os.makedirs(layerdir)
@@ -469,9 +488,9 @@ def init_config(top_dir, settings, args, d):
 
     bb.event.register("bb.build.TaskProgress", handle_task_progress, data=d)
 
-    write_config(upstream_config, confdir)
+    write_upstream_config(confdir, upstream_config)
+    update_build(upstream_config, confdir, setupdir, layerdir, d)
     commit_config(confdir)
-    update_build(upstream_config, confdir, builddir, layerdir, d)
 
     bb.event.remove("bb.build.TaskProgress", None)
 
@@ -513,10 +532,10 @@ def are_layers_changed(layers, layerdir, d):
     return changed
 
 def build_status(top_dir, settings, args, d, update=False):
-    builddir = args.build_dir
+    setupdir = args.setup_dir
 
-    confdir = os.path.join(builddir, "config")
-    layerdir = os.path.join(builddir, "layers")
+    confdir = os.path.join(setupdir, "config")
+    layerdir = os.path.join(setupdir, "layers")
 
     current_upstream_config = json.load(open(os.path.join(confdir, "config-upstream.json")))
 
@@ -526,24 +545,24 @@ def build_status(top_dir, settings, args, d, update=False):
     source_overrides = current_upstream_config["source-overrides"]
     new_upstream_config = obtain_config(top_dir, settings, args, source_overrides, d)
 
-    write_config(new_upstream_config, confdir)
+    write_upstream_config(confdir, new_upstream_config)
     config_diff = bb.process.run('git -C {} diff'.format(confdir))[0]
 
     if config_diff:
-        print('\nConfiguration in {} has changed:\n{}'.format(builddir, config_diff))
+        print('\nConfiguration in {} has changed:\n{}'.format(setupdir, config_diff))
         if update:
             commit_config(confdir)
-            update_build(new_upstream_config, confdir, builddir, layerdir, d)
+            update_build(new_upstream_config, confdir, setupdir, layerdir, d)
         else:
             bb.process.run('git -C {} restore config-upstream.json'.format(confdir))
         return
 
     if are_layers_changed(current_upstream_config["data"]["sources"], layerdir, d):
         if update:
-            update_build(current_upstream_config, confdir, builddir, layerdir, d)
+            update_build(current_upstream_config, confdir, setupdir, layerdir, d)
         return
 
-    print("\nConfiguration in {} has not changed.".format(builddir))
+    print("\nConfiguration in {} has not changed.".format(setupdir))
 
 def build_update(top_dir, settings, args, d):
     build_status(top_dir, settings, args, d, update=True)
@@ -616,7 +635,7 @@ def list_configs(top_dir, settings, args, d):
         print("Available configurations written into {}".format(args.write_json))
 
 def install_buildtools(top_dir, settings, args, d):
-    buildtools_install_dir = os.path.join(args.build_dir, 'buildtools')
+    buildtools_install_dir = os.path.join(args.setup_dir, 'buildtools')
     if os.path.exists(buildtools_install_dir):
         if not args.force:
             print("Buildtools are already installed in {}.".format(buildtools_install_dir))
@@ -629,14 +648,11 @@ def install_buildtools(top_dir, settings, args, d):
             return
         shutil.rmtree(buildtools_install_dir)
 
-    install_buildtools = os.path.join(args.build_dir, 'layers/oe-scripts/install-buildtools')
-    buildtools_download_dir = os.path.join(args.build_dir, 'buildtools-downloads/{}'.format(time.strftime("%Y%m%d%H%M%S")))
+    install_buildtools = os.path.join(args.setup_dir, 'layers/oe-scripts/install-buildtools')
+    buildtools_download_dir = os.path.join(args.setup_dir, 'buildtools-downloads/{}'.format(time.strftime("%Y%m%d%H%M%S")))
     print("Buildtools archive is downloaded into {} and its content installed into {}".format(buildtools_download_dir, buildtools_install_dir))
     subprocess.check_call("{} -d {} --downloads-directory {}".format(install_buildtools, buildtools_install_dir, buildtools_download_dir), shell=True)
 
-def default_settings_path(top_dir):
-    return os.path.join(top_dir, 'settings.conf')
-
 def create_siteconf(top_dir, non_interactive=True):
     siteconfpath = os.path.join(top_dir, 'site.conf')
     print('A common site.conf file will be created, please edit or replace before running builds\n    {}\n'.format(siteconfpath))
@@ -653,6 +669,9 @@ def create_siteconf(top_dir, non_interactive=True):
     with open(siteconfpath, 'w') as siteconffile:
         siteconffile.write('# This file is intended for build host-specific bitbake settings\n')
 
+def topdir_settings_path(top_dir):
+    return os.path.join(top_dir, 'settings.conf')
+
 def global_settings_path(args):
     return os.path.abspath(args.global_settings) if args.global_settings else os.path.join(os.path.expanduser('~'), '.config', 'bitbake-setup', 'settings.conf')
 
@@ -667,7 +686,7 @@ def change_setting(top_dir, args):
     if vars(args)['global']:
         settings_path = global_settings_path(args)
     else:
-        settings_path = default_settings_path(top_dir)
+        settings_path = topdir_settings_path(top_dir)
     settings = load_settings(settings_path)
 
     if args.subcommand == 'set':
@@ -696,50 +715,54 @@ def settings_func(top_dir, all_settings, args):
     elif args.subcommand == 'set' or args.subcommand == 'unset':
         change_setting(top_dir, args)
 
-def get_build_dir_via_bbpath():
+def get_setup_dir_via_bbpath():
     bbpath = os.environ.get('BBPATH')
     if bbpath:
         bitbake_dir = os.path.normpath(bbpath.split(':')[0])
         if os.path.exists(os.path.join(bitbake_dir,'init-build-env')):
-            build_dir = os.path.dirname(bitbake_dir)
-            return build_dir
+            setup_dir = os.path.dirname(bitbake_dir)
+            return setup_dir
     return None
 
 def get_top_dir(args, settings):
-    build_dir_via_bbpath = get_build_dir_via_bbpath()
-    if build_dir_via_bbpath:
-        top_dir = os.path.dirname(build_dir_via_bbpath)
-        if os.path.exists(default_settings_path(top_dir)):
+    setup_dir_via_bbpath = get_setup_dir_via_bbpath()
+    if setup_dir_via_bbpath:
+        top_dir = os.path.dirname(setup_dir_via_bbpath)
+        if os.path.exists(topdir_settings_path(top_dir)):
             return top_dir
 
-    if hasattr(args, 'build_dir'):
-        top_dir = os.path.dirname(os.path.normpath(args.build_dir))
+    if hasattr(args, 'setup_dir'):
+        top_dir = os.path.dirname(os.path.normpath(args.setup_dir))
         return top_dir
 
     top_dir_prefix = settings['default']['top-dir-prefix']
     top_dir_name = settings['default']['top-dir-name']
     return os.path.join(top_dir_prefix, top_dir_name)
 
-def merge_settings(builtin_settings, global_settings, local_settings, cmdline_settings):
+def merge_settings(builtin_settings, global_settings, topdir_settings, cmdline_settings):
     all_settings = builtin_settings
 
-    for s in (global_settings, local_settings):
+    for s in (global_settings, topdir_settings):
         for section, section_settings in s.items():
             for setting, value in section_settings.items():
+                if section not in all_settings.keys():
+                    all_settings[section] = {}
                 all_settings[section][setting] = value
 
     for (section, setting, value) in cmdline_settings:
+        if section not in all_settings.keys():
+            all_settings[section] = {}
         all_settings[section][setting] = value
 
     return all_settings
 
 def main():
-    def add_build_dir_arg(parser):
-        build_dir = get_build_dir_via_bbpath()
-        if build_dir:
-            parser.add_argument('--build-dir', default=build_dir, help="Path to the build, default is %(default)s via BBPATH")
+    def add_setup_dir_arg(parser):
+        setup_dir = get_setup_dir_via_bbpath()
+        if setup_dir:
+            parser.add_argument('--setup-dir', default=setup_dir, help="Path to the setup, default is %(default)s via BBPATH")
         else:
-            parser.add_argument('--build-dir', required=True, help="Path to the build")
+            parser.add_argument('--setup-dir', required=True, help="Path to the setup")
 
     parser = argparse.ArgumentParser(
         description="BitBake setup utility. Run with 'init' argument to get started.",
@@ -761,24 +784,24 @@ def main():
     parser_list.add_argument('--write-json', action='store', help='Write available configurations into a json file so they can be programmatically processed.')
     parser_list.set_defaults(func=list_configs)
 
-    parser_init = subparsers.add_parser('init', help='Select a configuration and initialize a build from it')
+    parser_init = subparsers.add_parser('init', help='Select a configuration and initialize a setup from it')
     parser_init.add_argument('config', nargs='*', help="path/URL/id to a configuration file (use 'list' command to get available ids), followed by configuration options. Bitbake-setup will ask to choose from available choices if command line doesn't completely specify them.")
     parser_init.add_argument('--non-interactive', action='store_true', help='Do not ask to interactively choose from available options; if bitbake-setup cannot make a decision it will stop with a failure.')
     parser_init.add_argument('--source-overrides', action='store', help='Override sources information (repositories/revisions) with values from a local json file.')
-    parser_init.add_argument('--build-dir-name', action='store', help='A custom build directory name under the top directory.')
+    parser_init.add_argument('--setup-dir-name', action='store', help='A custom setup directory name under the top directory.')
     parser_init.add_argument('--skip-selection', action='append', help='Do not select and set an option/fragment from available choices; the resulting bitbake configuration may be incomplete.')
     parser_init.set_defaults(func=init_config)
 
-    parser_status = subparsers.add_parser('status', help='Check if the build needs to be synchronized with configuration')
-    add_build_dir_arg(parser_status)
+    parser_status = subparsers.add_parser('status', help='Check if the setup needs to be synchronized with configuration')
+    add_setup_dir_arg(parser_status)
     parser_status.set_defaults(func=build_status)
 
-    parser_update = subparsers.add_parser('update', help='Update a build to be in sync with configuration')
-    add_build_dir_arg(parser_update)
+    parser_update = subparsers.add_parser('update', help='Update a setup to be in sync with configuration')
+    add_setup_dir_arg(parser_update)
     parser_update.set_defaults(func=build_update)
 
     parser_install_buildtools = subparsers.add_parser('install-buildtools', help='Install buildtools which can help fulfil missing or incorrect dependencies on the host machine')
-    add_build_dir_arg(parser_install_buildtools)
+    add_setup_dir_arg(parser_install_buildtools)
     parser_install_buildtools.add_argument('--force', action='store_true', help='Force a reinstall of buildtools over the previous installation.')
     parser_install_buildtools.set_defaults(func=install_buildtools)
 
@@ -786,7 +809,7 @@ def main():
     parser_settings_arg_global.add_argument('--global', action='store_true', help="Modify the setting in a global settings file, rather than one specific to a top directory")
 
     parser_settings = subparsers.add_parser('settings',
-                                            help='List current settings, or set or unset a setting in a settings file (e.g. the default prefix and name of the top directory, the location of build configuration registry, downloads directory and other settings specific to a top directory)')
+                                            help='List current settings, or set or unset a setting in a settings file (e.g. the default prefix and name of the top directory, the location of configuration registry, downloads directory and other settings specific to a top directory)')
     parser_settings.set_defaults(func=settings_func)
 
     subparser_settings = parser_settings.add_subparsers(dest="subcommand", required=True, help="The action to perform on the settings file")
@@ -820,9 +843,9 @@ def main():
                          level=logger.getEffectiveLevel())
 
     if 'func' in args:
-        if hasattr(args, 'build_dir'):
-            if not os.path.exists(os.path.join(args.build_dir,'build', 'init-build-env')):
-                print("Not a valid build directory: build/init-build-env does not exist in {}".format(args.build_dir))
+        if hasattr(args, 'setup_dir'):
+            if not os.path.exists(os.path.join(args.setup_dir,'build', 'init-build-env')):
+                print("Not a valid setup directory: build/init-build-env does not exist in {}".format(args.setup_dir))
                 return
 
         if not hasattr(args, 'non_interactive'):
@@ -841,7 +864,7 @@ def main():
         # This cannot be set with the rest of the builtin settings as top_dir needs to be determined first
         builtin_settings['default']['dl-dir'] = os.path.join(top_dir, '.bitbake-setup-downloads')
 
-        topdir_settings = load_settings(default_settings_path(top_dir))
+        topdir_settings = load_settings(topdir_settings_path(top_dir))
         all_settings = merge_settings(builtin_settings, global_settings, topdir_settings, args.cmdline_settings)
 
         if args.func == settings_func:
diff --git a/bitbake/bin/toaster b/bitbake/bin/toaster
index f002c8c159..d20cbe90ba 100755
--- a/bitbake/bin/toaster
+++ b/bitbake/bin/toaster
@@ -164,14 +164,20 @@ fi
 # in the local layers that currently make using an arbitrary
 # toasterconf.json difficult.
 
-. $OE_ROOT/.templateconf
-if [ -n "$TEMPLATECONF" ]; then
-    if [ ! -d "$TEMPLATECONF" ]; then
-        # Allow TEMPLATECONF=meta-xyz/conf as a shortcut
-        if [ -d "$OE_ROOT/$TEMPLATECONF" ]; then
-            TEMPLATECONF="$OE_ROOT/$TEMPLATECONF"
+# BBSETUP no longer supports .templateconf
+if [ -f $OE_ROOT/.templateconf ] ; then 
+    . $OE_ROOT/.templateconf
+    if [ -n "$TEMPLATECONF" ]; then
+        if [ ! -d "$TEMPLATECONF" ]; then
+            # Allow TEMPLATECONF=meta-xyz/conf as a shortcut
+            if [ -d "$OE_ROOT/$TEMPLATECONF" ]; then
+                TEMPLATECONF="$OE_ROOT/$TEMPLATECONF"
+            fi
         fi
     fi
+else
+    # Force poky
+    TEMPLATECONF="layers/meta-yocto/meta-poky/conf/templates/default"
 fi
 
 unset OE_ROOT
@@ -255,7 +261,8 @@ fi
 # 2) the build dir (in build)
 # 3) the sqlite db if that is being used.
 # 4) pid's we need to clean up on exit/shutdown
-export TOASTER_DIR=$TOASTERDIR
+# By default we move this all into the Toaster's parent build directory
+export TOASTER_DIR=$BUILDDIR
 export BB_ENV_PASSTHROUGH_ADDITIONS="$BB_ENV_PASSTHROUGH_ADDITIONS TOASTER_DIR"
 
 # Determine the action. If specified by arguments, fine, if not, toggle it
diff --git a/bitbake/lib/bb/tests/setup.py b/bitbake/lib/bb/tests/setup.py
index e320cdf56f..ba2a90009d 100644
--- a/bitbake/lib/bb/tests/setup.py
+++ b/bitbake/lib/bb/tests/setup.py
@@ -109,19 +109,19 @@ print("BBPATH is {{}}".format(os.environ["BBPATH"]))
         "configurations": [
             {
                 "name": "gadget",
-                "description": "Gadget build configuration",
+                "description": "Gadget configuration",
                 "oe-template": "test-configuration-gadget",
                 "oe-fragments": ["test-fragment-1"]
             },
             {
                 "name": "gizmo",
-                "description": "Gizmo build configuration",
+                "description": "Gizmo configuration",
                 "oe-template": "test-configuration-gizmo",
                 "oe-fragments": ["test-fragment-2"]
             },
             {
                 "name": "gizmo-env-passthrough",
-                "description": "Gizmo build configuration with environment-passthrough",
+                "description": "Gizmo configuration with environment-passthrough",
                 "bb-layers": ["layerC","layerD/meta-layer"],
                 "oe-fragments": ["test-fragment-1"],
                 "bb-env-passthrough-additions": [
@@ -132,25 +132,26 @@ print("BBPATH is {{}}".format(os.environ["BBPATH"]))
             },
             {
                 "name": "gizmo-no-fragment",
-                "description": "Gizmo no-fragment template-only build configuration",
+                "description": "Gizmo no-fragment template-only configuration",
                 "oe-template": "test-configuration-gizmo"
             },
             {
                 "name": "gadget-notemplate",
-                "description": "Gadget notemplate build configuration",
+                "description": "Gadget notemplate configuration",
                 "bb-layers": ["layerA","layerB/meta-layer"],
                 "oe-fragments": ["test-fragment-1"]
             },
             {
                 "name": "gizmo-notemplate",
-                "description": "Gizmo notemplate build configuration",
+                "description": "Gizmo notemplate configuration",
                 "bb-layers": ["layerC","layerD/meta-layer"],
                 "oe-fragments": ["test-fragment-2"]
             },
             {
-                "name": "gizmo-notemplate-with-thisdir",
-                "description": "Gizmo notemplate build configuration using THISDIR",
-                "bb-layers": ["layerC","layerD/meta-layer","{THISDIR}/layerE/meta-layer"],
+                "name": "gizmo-notemplate-with-relative-layers",
+                "description": "Gizmo notemplate configuration using relative layers",
+                "bb-layers": ["layerC","layerD/meta-layer"],
+                "bb-layers-relative": ["layerE/meta-layer"],
                 "oe-fragments": ["test-fragment-2"]
             }
         ]
@@ -177,14 +178,22 @@ print("BBPATH is {{}}".format(os.environ["BBPATH"]))
         self.git('add {}'.format(name), cwd=self.testrepopath)
         self.git('commit -m "Adding {}"'.format(name), cwd=self.testrepopath)
 
-    def check_builddir_files(self, buildpath, test_file_content, json_config):
-        with open(os.path.join(buildpath, 'layers', 'test-repo', 'test-file')) as f:
+    def check_setupdir_files(self, setuppath, test_file_content):
+        with open(os.path.join(setuppath, 'config', "config-upstream.json")) as f:
+            config_upstream = json.load(f)
+        with open(os.path.join(setuppath, 'layers', 'test-repo', 'test-file')) as f:
             self.assertEqual(f.read(), test_file_content)
-        bitbake_config = json_config["bitbake-config"]
-        bb_build_path = os.path.join(buildpath, 'build')
+        bitbake_config = config_upstream["bitbake-config"]
+        bb_build_path = os.path.join(setuppath, 'build')
         bb_conf_path = os.path.join(bb_build_path, 'conf')
         self.assertTrue(os.path.exists(os.path.join(bb_build_path, 'init-build-env')))
 
+        with open(os.path.join(setuppath, 'config', "sources-fixed-revisions.json")) as f:
+            sources_fixed_revisions = json.load(f)
+        self.assertTrue('test-repo' in sources_fixed_revisions['sources'].keys())
+        revision = self.git('rev-parse HEAD', cwd=self.testrepopath).strip()
+        self.assertEqual(revision, sources_fixed_revisions['sources']['test-repo']['git-remote']['rev'])
+
         if "oe-template" in bitbake_config:
             with open(os.path.join(bb_conf_path, 'conf-summary.txt')) as f:
                 self.assertEqual(f.read(), bitbake_config["oe-template"])
@@ -196,14 +205,13 @@ print("BBPATH is {{}}".format(os.environ["BBPATH"]))
             with open(os.path.join(bb_conf_path, 'bblayers.conf')) as f:
                 bblayers = f.read()
                 for l in bitbake_config["bb-layers"]:
-                    if l.startswith('{THISDIR}/'):
-                        thisdir_layer = os.path.join(
-                            os.path.dirname(json_config["path"]),
-                            l.removeprefix("{THISDIR}/"),
+                    self.assertIn(os.path.join(setuppath, "layers", l), bblayers)
+                for l in bitbake_config.get("bb-layers-relative") or []:
+                    relative_layer = os.path.join(
+                            os.path.dirname(config_upstream["path"]),
+                            l,
                         )
-                        self.assertIn(thisdir_layer, bblayers)
-                    else:
-                        self.assertIn(os.path.join(buildpath, "layers", l), bblayers)
+                    self.assertIn(relative_layer, bblayers)
 
         if 'oe-fragment' in bitbake_config.keys():
             for f in bitbake_config["oe-fragments"]:
@@ -290,25 +298,23 @@ print("BBPATH is {{}}".format(os.environ["BBPATH"]))
                                                                   'gizmo-env-passthrough',
                                                                   'gizmo-no-fragment',
                                                                   'gadget-notemplate','gizmo-notemplate',
-                                                                  'gizmo-notemplate-with-thisdir')}
+                                                                  'gizmo-notemplate-with-relative-layers')}
                                }
         for cf, v in test_configurations.items():
             for c in v['buildconfigs']:
                 out = self.runbbsetup("init --non-interactive {} {}".format(v['cmdline'], c))
-                buildpath = os.path.join(self.tempdir, 'bitbake-builds', '{}-{}'.format(cf, c))
-                with open(os.path.join(buildpath, 'config', "config-upstream.json")) as f:
-                    config_upstream = json.load(f)
-                self.check_builddir_files(buildpath, test_file_content, config_upstream)
-                os.environ['BBPATH'] = os.path.join(buildpath, 'build')
+                setuppath = os.path.join(self.tempdir, 'bitbake-builds', '{}-{}'.format(cf, c))
+                self.check_setupdir_files(setuppath, test_file_content)
+                os.environ['BBPATH'] = os.path.join(setuppath, 'build')
                 out = self.runbbsetup("status")
-                self.assertIn("Configuration in {} has not changed".format(buildpath), out[0])
+                self.assertIn("Configuration in {} has not changed".format(setuppath), out[0])
                 out = self.runbbsetup("update")
-                self.assertIn("Configuration in {} has not changed".format(buildpath), out[0])
+                self.assertIn("Configuration in {} has not changed".format(setuppath), out[0])
 
         # install buildtools
         out = self.runbbsetup("install-buildtools")
         self.assertIn("Buildtools installed into", out[0])
-        self.assertTrue(os.path.exists(os.path.join(buildpath, 'buildtools')))
+        self.assertTrue(os.path.exists(os.path.join(setuppath, 'buildtools')))
 
         # change a file in the test layer repo, make a new commit and
         # test that status/update correctly report the change and update the config
@@ -319,17 +325,15 @@ print("BBPATH is {{}}".format(os.environ["BBPATH"]))
                   'gizmo-env-passthrough',
                   'gizmo-no-fragment',
                   'gadget-notemplate', 'gizmo-notemplate'):
-            buildpath = os.path.join(self.tempdir, 'bitbake-builds', 'test-config-1-{}'.format(c))
-            os.environ['BBPATH'] = os.path.join(buildpath, 'build')
+            setuppath = os.path.join(self.tempdir, 'bitbake-builds', 'test-config-1-{}'.format(c))
+            os.environ['BBPATH'] = os.path.join(setuppath, 'build')
             out = self.runbbsetup("status")
-            self.assertIn("Layer repository file://{} checked out into {}/layers/test-repo updated revision master from".format(self.testrepopath, buildpath), out[0])
+            self.assertIn("Layer repository file://{} checked out into {}/layers/test-repo updated revision master from".format(self.testrepopath, setuppath), out[0])
             out = self.runbbsetup("update")
             if c in ('gadget', 'gizmo'):
-                self.assertIn("Existing bitbake configuration directory renamed to {}/build/conf-backup.".format(buildpath), out[0])
+                self.assertIn("Existing bitbake configuration directory renamed to {}/build/conf-backup.".format(setuppath), out[0])
                 self.assertIn('-{}+{}'.format(prev_test_file_content, test_file_content), out[0])
-            with open(os.path.join(buildpath, 'config', "config-upstream.json")) as f:
-                config_upstream = json.load(f)
-            self.check_builddir_files(buildpath, test_file_content, config_upstream)
+            self.check_setupdir_files(setuppath, test_file_content)
 
         # make a new branch in the test layer repo, change a file on that branch,
         # make a new commit, update the top level json config to refer to that branch,
@@ -344,15 +348,13 @@ print("BBPATH is {{}}".format(os.environ["BBPATH"]))
                   'gizmo-env-passthrough',
                   'gizmo-no-fragment',
                   'gadget-notemplate', 'gizmo-notemplate'):
-            buildpath = os.path.join(self.tempdir, 'bitbake-builds', 'test-config-1-{}'.format(c))
-            os.environ['BBPATH'] = os.path.join(buildpath, 'build')
+            setuppath = os.path.join(self.tempdir, 'bitbake-builds', 'test-config-1-{}'.format(c))
+            os.environ['BBPATH'] = os.path.join(setuppath, 'build')
             out = self.runbbsetup("status")
-            self.assertIn("Configuration in {} has changed:".format(buildpath), out[0])
+            self.assertIn("Configuration in {} has changed:".format(setuppath), out[0])
             self.assertIn('-                    "rev": "master"\n+                    "rev": "another-branch"', out[0])
             out = self.runbbsetup("update")
             if c in ('gadget', 'gizmo'):
-                self.assertIn("Existing bitbake configuration directory renamed to {}/build/conf-backup.".format(buildpath), out[0])
+                self.assertIn("Existing bitbake configuration directory renamed to {}/build/conf-backup.".format(setuppath), out[0])
                 self.assertIn('-{}+{}'.format(prev_test_file_content, test_file_content), out[0])
-            with open(os.path.join(buildpath, 'config', "config-upstream.json")) as f:
-                config_upstream = json.load(f)
-            self.check_builddir_files(buildpath, test_file_content, config_upstream)
+            self.check_setupdir_files(setuppath, test_file_content)
diff --git a/bitbake/lib/toaster/bldcontrol/localhostbecontroller.py b/bitbake/lib/toaster/bldcontrol/localhostbecontroller.py
index 577e765f11..37b0a75199 100644
--- a/bitbake/lib/toaster/bldcontrol/localhostbecontroller.py
+++ b/bitbake/lib/toaster/bldcontrol/localhostbecontroller.py
@@ -6,6 +6,11 @@
 # SPDX-License-Identifier: GPL-2.0-only
 #
 
+# DEBUGGING NOTE: if you need to add debug statements into the files within a
+# Toaster-imported layer, you must disable the "git fetch ..." command after
+# the initial clone else any changes will be automatically replaced with the
+# original code
+
 import os
 import re
 import shutil
@@ -183,6 +188,8 @@ class LocalhostBEController(BuildEnvironmentController):
             if commit != "HEAD":
                 logger.debug("localhostbecontroller: checking out commit %s to %s " % (commit, localdirname))
                 ref = commit if re.match('^[a-fA-F0-9]+$', commit) else 'origin/%s' % commit
+                # DEBUGGING NOTE: this is the 'git fetch" to disable after the initial clone to
+                # prevent inserted debugging commands from being lost
                 self._shellcmd('git fetch && git reset --hard "%s"' % ref, localdirname,env=git_env)
 
             # take the localdirname as poky dir if we can find the oe-init-build-env
@@ -319,7 +326,28 @@ class LocalhostBEController(BuildEnvironmentController):
         layers = self.setLayers(bitbake, layers, targets)
         is_merged_attr = bitbake.req.project.merged_attr
 
+        # Is this build for a Bitbake Setup installation?
+        isBBSetup = False
+        release_description = bitbake.req.project.release.description
+        if 'master' in release_description:
+            # This release going forward is Bitbake Setup
+            isBBSetup = True
+        else:
+            try:
+                # Yocto Project 5.3 "Whinlatter"
+                params = release_description.split(' ')
+                # Work past YP "10.1"
+                release_params = params[2].split('.')
+                if int(release_params[0]) > 5:
+                    isBBSetup = True
+                if (release_params[0] == '5') and (int(release_params[1]) >= 3):
+                    isBBSetup = True
+            except:
+                # If release schema not recognized, then this release is in the future
+                isBBSetup = True
+
         git_env = os.environ.copy()
+        toaster_run_dir = git_env['BUILDDIR']
         # (note: add custom environment settings here)
         try:
             # insure that the project init/build uses the selected bitbake, and not Toaster's
@@ -335,28 +363,44 @@ class LocalhostBEController(BuildEnvironmentController):
         else:
             builddir = '%s-toaster-%d' % (self.be.builddir, bitbake.req.project.id)
         oe_init = os.path.join(self.pokydirname, 'oe-init-build-env')
-        # init build environment
+        setup_init = os.path.join(builddir, 'init-build-env')
+        # init build environment and build directory structure
         try:
             custom_script = ToasterSetting.objects.get(name="CUSTOM_BUILD_INIT_SCRIPT").value
             custom_script = custom_script.replace("%BUILDDIR%" ,builddir)
             self._shellcmd("bash -c 'source %s'" % (custom_script),env=git_env)
         except ToasterSetting.DoesNotExist:
-            self._shellcmd("bash -c 'source %s %s'" % (oe_init, builddir),
-                       self.be.sourcedir,env=git_env)
+            # Normal setup
+            if isBBSetup:
+                # Create an 'init-build-env' for the build directory that points to respective cloned bitbake
+                os.makedirs(builddir, exist_ok = True)
+                build_init_script = os.path.join(builddir,'init-build-env')
+                os.system(f"cp {os.path.join(toaster_run_dir,'init-build-env')} {build_init_script}")
+                os.system(f"sed -i -e 's|^cd .*$|cd {self.pokydirname}|g' {build_init_script}")
+                os.system(f"sed -i -e 's|^set .*$|set {builddir}|g' {build_init_script}")
+                # Execute the init
+                self._shellcmd(f"bash -c 'source {build_init_script}'", env=git_env)
+            else:
+                self._shellcmd("bash -c 'source %s %s'" % (oe_init, builddir),
+                           self.be.sourcedir,env=git_env)
 
         # update bblayers.conf
         if not is_merged_attr:
             bblconfpath = os.path.join(builddir, "conf/toaster-bblayers.conf")
             with open(bblconfpath, 'w') as bblayers:
                 bblayers.write('# line added by toaster build control\n'
-                               'BBLAYERS = "%s"' % ' '.join(layers))
+                               'BBLAYERS = "%s"\n' % ' '.join(layers))
 
             # write configuration file
             confpath = os.path.join(builddir, 'conf/toaster.conf')
             with open(confpath, 'w') as conf:
+                if isBBSetup:
+                    # Force TOPDIR
+                    conf.write(f'# Force TOPDIR\n')
+                    conf.write(f'TOPDIR = "{builddir}"\n\n')
                 for var in variables:
-                    conf.write('%s="%s"\n' % (var.name, var.value))
-                conf.write('INHERIT+="toaster buildhistory"')
+                    conf.write('%s = "%s"\n' % (var.name, var.value))
+                conf.write('INHERIT += "toaster buildhistory"\n')
         else:
             # Append the Toaster-specific values directly to the bblayers.conf
             bblconfpath = os.path.join(builddir, "conf/bblayers.conf")
@@ -443,15 +487,25 @@ class LocalhostBEController(BuildEnvironmentController):
             else:
                 logger.error("Looks like Bitbake is not available, please fix your environment")
 
+        # NOTE: BB SETUP requires a 'bblayers.conf' even though Toaster immediately overrides it with 'toaster-bblayers.conf'
+        bblayers = os.path.join(builddir,"conf/bblayers.conf")
         toasterlayers = os.path.join(builddir,"conf/toaster-bblayers.conf")
-        if not is_merged_attr:
-            self._shellcmd('%s bash -c \"source %s %s; BITBAKE_UI="knotty" %s --read %s --read %s '
-                           '--server-only -B 0.0.0.0:0\"' % (env_clean, oe_init,
-                           builddir, bitbake, confpath, toasterlayers), self.be.sourcedir)
+        if isBBSetup:
+            # Use 'init-build-env' model
+            if not is_merged_attr:
+                self._shellcmd(f'{env_clean} bash -c \"source {setup_init}; BITBAKE_UI="knotty" {bitbake} --read {confpath} --read {bblayers} --read {toasterlayers} '
+                               '--server-only -B 0.0.0.0:0\"', self.be.sourcedir)
+            else:
+                self._shellcmd(f'{env_clean} bash -c \"source {setup_init}; BITBAKE_UI="knotty" {bitbake} '
+                           '--server-only -B 0.0.0.0:0\"', self.be.sourcedir)
         else:
-            self._shellcmd('%s bash -c \"source %s %s; BITBAKE_UI="knotty" %s '
-                           '--server-only -B 0.0.0.0:0\"' % (env_clean, oe_init,
-                           builddir, bitbake), self.be.sourcedir)
+            # Use 'oe-init-build-env' model
+            if not is_merged_attr:
+                self._shellcmd(f'{env_clean} bash -c \"source {oe_init} {builddir}; BITBAKE_UI="knotty" {bitbake} --read {confpath} --read {bblayers} --read {toasterlayers} '
+                               '--server-only -B 0.0.0.0:0\"', self.be.sourcedir)
+            else:
+                self._shellcmd(f'{env_clean} bash -c \"source {oe_init} {builddir}; BITBAKE_UI="knotty" {bitbake} '
+                           '--server-only -B 0.0.0.0:0\"', self.be.sourcedir)
 
         # read port number from bitbake.lock
         self.be.bbport = -1
@@ -497,20 +551,17 @@ class LocalhostBEController(BuildEnvironmentController):
         log = os.path.join(builddir, 'toaster_ui.log')
         local_bitbake = os.path.join(os.path.dirname(os.getenv('BBBASEDIR')),
                                      'bitbake')
+
         if not is_merged_attr:
-            self._shellcmd(['%s bash -c \"(TOASTER_BRBE="%s" BBSERVER="0.0.0.0:%s" '
-                        '%s %s -u toasterui  --read %s --read %s --token="" >>%s 2>&1;'
-                        'BITBAKE_UI="knotty" BBSERVER=0.0.0.0:%s %s -m)&\"' \
-                        % (env_clean, brbe, self.be.bbport, local_bitbake, bbtargets, confpath, toasterlayers, log,
-                        self.be.bbport, bitbake,)],
+            self._shellcmd([f'{env_clean} bash -c \"(TOASTER_BRBE="{brbe}" BBSERVER="0.0.0.0:{self.be.bbport}" '
+                        f'{bitbake} {bbtargets} -u toasterui  --read {confpath} --read {bblayers} --read {toasterlayers} --token="" >>{log} 2>&1;'
+                        f'BITBAKE_UI="knotty" BBSERVER=0.0.0.0:{self.be.bbport} {bitbake} -m)&\"'],
                         builddir, nowait=True)
         else:
-            self._shellcmd(['%s bash -c \"(TOASTER_BRBE="%s" BBSERVER="0.0.0.0:%s" '
-                        '%s %s -u toasterui  --token="" >>%s 2>&1;'
-                        'BITBAKE_UI="knotty" BBSERVER=0.0.0.0:%s %s -m)&\"' \
-                        % (env_clean, brbe, self.be.bbport, local_bitbake, bbtargets, log,
-                        self.be.bbport, bitbake,)],
+            self._shellcmd([f'{env_clean} bash -c \"(TOASTER_BRBE="{brbe}" BBSERVER="0.0.0.0:{self.be.bbport}" '
+                        f'{local_bitbake} {bbtargets} -u toasterui  --token="" >>{log} 2>&1;'
+                        f'BITBAKE_UI="knotty" BBSERVER=0.0.0.0:{self.be.bbport} {bitbake} -m)&\"'],
                         builddir, nowait=True)
 
         logger.debug('localhostbecontroller: Build launched, exiting. '
-                     'Follow build logs at %s' % log)
+                     f'Follow build logs at {log}')