def test_delete_local_one():
# Test LOCAL-only delete of one option doesn't affect the other.
config.update_config('pytest', 'key1', 'foo', configfile=LOCAL)
config.update_config('pytest', 'key2', 'bar', configfile=LOCAL)
config.delete_config('pytest', 'key1', configfile=LOCAL)
assert 'pytest' in cfg(f=LOCAL)
assert cfg(f=LOCAL)['pytest']['key2'] == 'bar'
def do_run(self, args, user_args):
config_settings = configparser.ConfigParser()
configfile = args.configfile or ConfigFile.ALL
name_list = args.name.split(".", 1)
if len(name_list) != 2:
log.die(
'missing key, please invoke as: west config '
'<section>.<key>',
exit_code=3)
section = name_list[0]
key = name_list[1]
if args.value is None:
configuration.read_config(configfile, config_settings)
value = config_settings.get(section, key, fallback=None)
if value is not None:
log.inf(value)
else:
if configfile == ConfigFile.ALL:
# No file given, thus writing defaults to LOCAL
configfile = ConfigFile.LOCAL
configuration.update_config(section, key, args.value, configfile)
def test_local_creation_with_topdir():
# Like test_local_creation, with a specified topdir.
system = pathlib.Path(config._location(SYSTEM))
glbl = pathlib.Path(config._location(GLOBAL))
local = pathlib.Path(config._location(LOCAL))
topdir = pathlib.Path(os.getcwd()) / 'test-topdir'
topdir_west = topdir / '.west'
assert not topdir_west.exists()
topdir_west.mkdir(parents=True)
topdir_config = topdir_west / 'config'
assert not system.exists()
assert not glbl.exists()
assert not local.exists()
assert not topdir_config.exists()
config.update_config('pytest',
'key',
'val',
configfile=LOCAL,
topdir=str(topdir))
assert not system.exists()
assert not glbl.exists()
assert not local.exists()
assert topdir_config.exists()
assert cfg(f=ALL, topdir=str(topdir))['pytest']['key'] == 'val'
assert 'pytest' not in cfg(f=SYSTEM)
assert 'pytest' not in cfg(f=GLOBAL)
assert cfg(f=LOCAL, topdir=str(topdir))['pytest']['key'] == 'val'
def write(self, args):
section, key = self._sk(args)
what = args.configfile or LOCAL
try:
update_config(section, key, args.value, configfile=what)
except PermissionError as pe:
self._perm_error(pe, what, section, key)
def local(self, args):
if args.manifest_rev is not None:
log.die('--mr cannot be used with -l')
manifest_dir = util.canon_path(args.directory or os.getcwd())
manifest_file = join(manifest_dir, 'west.yml')
topdir = dirname(manifest_dir)
rel_manifest = basename(manifest_dir)
west_dir = os.path.join(topdir, WEST_DIR)
log.banner('Initializing from existing manifest repository',
rel_manifest)
if not exists(manifest_file):
log.die('No "west.yml" found in {}'.format(manifest_dir))
self.create(west_dir)
os.chdir(topdir)
# This validates the manifest. Note we cannot use
# self.manifest from west init, as we are in the middle of
# creating the installation right now.
projects = self.projects(manifest_file)
log.small_banner(
'Creating {} and local configuration'.format(west_dir))
update_config('manifest', 'path', rel_manifest)
self.topdir = topdir
return projects, manifest_dir
def bootstrap(self, args):
manifest_url = args.manifest_url or MANIFEST_URL_DEFAULT
manifest_rev = args.manifest_rev or MANIFEST_REV_DEFAULT
topdir = util.canon_path(args.directory or os.getcwd())
west_dir = join(topdir, WEST_DIR)
try:
already = util.west_topdir(topdir, fall_back=False)
self.die_already(already)
except util.WestNotFound:
pass
log.banner('Initializing in', topdir)
if not isdir(topdir):
self.create(topdir, exist_ok=False)
# Clone the manifest repository into a temporary directory.
tempdir = join(west_dir, 'manifest-tmp')
if exists(tempdir):
log.dbg('removing existing temporary manifest directory', tempdir)
shutil.rmtree(tempdir)
try:
self.clone_manifest(manifest_url, manifest_rev, tempdir)
except subprocess.CalledProcessError:
shutil.rmtree(tempdir, ignore_errors=True)
raise
# Verify the manifest file exists.
temp_manifest = join(tempdir, 'west.yml')
if not exists(temp_manifest):
log.die(f'can\'t init: no "west.yml" found in {tempdir}\n'
f' Hint: check --manifest-url={manifest_url} and '
'--manifest-rev={manifest_rev}\n'
f' You may need to remove {west_dir} before retrying.')
# Parse the manifest to get the manifest path, if it declares one.
# Otherwise, use the URL. Ignore imports -- all we really
# want to know is if there's a "self: path:" or not.
projects = Manifest.from_file(temp_manifest,
import_flags=ImportFlag.IGNORE,
topdir=topdir).projects
manifest_project = projects[MANIFEST_PROJECT_INDEX]
if manifest_project.path:
manifest_path = manifest_project.path
else:
manifest_path = posixpath.basename(urlparse(manifest_url).path)
manifest_abspath = join(topdir, manifest_path)
log.dbg('moving', tempdir, 'to', manifest_abspath,
level=log.VERBOSE_EXTREME)
try:
shutil.move(tempdir, manifest_abspath)
except shutil.Error as e:
log.die(e)
log.small_banner('setting manifest.path to', manifest_path)
update_config('manifest', 'path', manifest_path, topdir=topdir)
return topdir
def test_delete_basic():
# Basic deletion test: write local, verify global and system deletions
# don't work, then delete local does work.
config.update_config('pytest', 'key', 'val', configfile=LOCAL)
assert cfg(f=ALL)['pytest']['key'] == 'val'
with pytest.raises(KeyError):
config.delete_config('pytest', 'key', configfile=SYSTEM)
with pytest.raises(KeyError):
config.delete_config('pytest', 'key', configfile=GLOBAL)
config.delete_config('pytest', 'key', configfile=LOCAL)
assert 'pytest' not in cfg(f=ALL)
def test_config_system():
# Basic test of system-level configuration.
config.update_config('pytest', 'key', 'val', configfile=SYSTEM)
assert cfg(f=ALL)['pytest']['key'] == 'val'
assert cfg(f=SYSTEM)['pytest']['key'] == 'val'
assert 'pytest' not in cfg(f=GLOBAL)
assert 'pytest' not in cfg(f=LOCAL)
config.update_config('pytest', 'key', 'val2', configfile=SYSTEM)
assert cfg(f=SYSTEM)['pytest']['key'] == 'val2'
def test_local_creation():
# Like test_system_creation, for local config options.
assert not os.path.isfile(config._location(SYSTEM))
assert not os.path.isfile(config._location(GLOBAL))
assert not os.path.isfile(config._location(LOCAL))
config.update_config('pytest', 'key', 'val', configfile=LOCAL)
assert not os.path.isfile(config._location(SYSTEM))
assert not os.path.isfile(config._location(GLOBAL))
assert os.path.isfile(config._location(LOCAL))
assert cfg(f=ALL)['pytest']['key'] == 'val'
assert 'pytest' not in cfg(f=SYSTEM)
assert 'pytest' not in cfg(f=GLOBAL)
assert cfg(f=LOCAL)['pytest']['key'] == 'val'
def test_system_creation():
# Test that the system file -- and just that file -- is created on
# demand.
assert not os.path.isfile(config._location(SYSTEM))
assert not os.path.isfile(config._location(GLOBAL))
assert not os.path.isfile(config._location(LOCAL))
config.update_config('pytest', 'key', 'val', configfile=SYSTEM)
assert os.path.isfile(config._location(SYSTEM))
assert not os.path.isfile(config._location(GLOBAL))
assert not os.path.isfile(config._location(LOCAL))
assert cfg(f=ALL)['pytest']['key'] == 'val'
assert cfg(f=SYSTEM)['pytest']['key'] == 'val'
assert 'pytest' not in cfg(f=GLOBAL)
assert 'pytest' not in cfg(f=LOCAL)
def bootstrap(self, args):
manifest_url = args.manifest_url or MANIFEST_URL_DEFAULT
manifest_rev = args.manifest_rev or MANIFEST_REV_DEFAULT
topdir = canonical(args.directory or os.getcwd())
west_dir = join(topdir, WEST_DIR)
_banner('Initializing in ' + topdir)
if not isdir(topdir):
self.create(topdir, exist_ok=False)
os.chdir(topdir)
# Clone the manifest repository into a temporary directory. It's
# important that west_dir exists and we're under topdir, or we
# won't be able to call self.projects() without error later.
tempdir = join(west_dir, 'manifest-tmp')
if exists(tempdir):
log.dbg('removing existing temporary manifest directory', tempdir)
shutil.rmtree(tempdir)
try:
self.clone_manifest(manifest_url, manifest_rev, tempdir)
temp_manifest_file = join(tempdir, 'west.yml')
if not exists(temp_manifest_file):
log.die('No "west.yml" in manifest repository ({})'.
format(tempdir))
projects = self.projects(temp_manifest_file)
manifest_project = projects[MANIFEST_PROJECT_INDEX]
if manifest_project.path:
manifest_path = manifest_project.path
manifest_abspath = join(topdir, manifest_path)
else:
url_path = urlparse(manifest_url).path
manifest_path = posixpath.basename(url_path)
manifest_abspath = join(topdir, manifest_path)
shutil.move(tempdir, manifest_abspath)
update_config('manifest', 'path', manifest_path)
finally:
shutil.rmtree(tempdir, ignore_errors=True)
self.topdir = topdir
return projects, manifest_project.abspath
def _update_west(rebase, keep_descendants):
_banner('self-updating west:')
with _error_context(_FAILED_UPDATE_MSG):
project = _west_project()
old_sha = _sha(project, 'HEAD')
_update(project, rebase, keep_descendants)
if config.get('zephyr', 'base', fallback=None) is None:
for proj in _all_projects():
if proj.path == 'zephyr':
update_config('zephyr', 'base', proj.path)
break
if old_sha != _sha(project, 'HEAD'):
_msg(project.format('{name}: updated to {revision} (from {url}).'))
# Signal self-update, which will cause a restart. This is a bit
# nicer than doing the restart here, as callers will have a
# chance to flush file buffers, etc.
raise WestUpdated()
def local(self, args):
if args.manifest_rev is not None:
log.die('--mr cannot be used with -l')
manifest_dir = util.canon_path(args.directory or os.getcwd())
manifest_file = join(manifest_dir, 'west.yml')
topdir = dirname(manifest_dir)
rel_manifest = basename(manifest_dir)
west_dir = os.path.join(topdir, WEST_DIR)
if not exists(manifest_file):
log.die(f'can\'t init: no "west.yml" found in {manifest_dir}')
log.banner('Initializing from existing manifest repository',
rel_manifest)
log.small_banner(f'Creating {west_dir} and local configuration file')
self.create(west_dir)
os.chdir(topdir)
update_config('manifest', 'path', rel_manifest)
return topdir
def do_run(self, args, user_args):
# manifest.path is not supposed to be set during init, thus clear it
# for the session and update it to correct location when complete.
if config.get('manifest', 'path', fallback=None) is not None:
config.remove_option('manifest', 'path')
manifest_file = os.path.join(args.local or args.cache, 'west.yml')
projects = Manifest.from_file(manifest_file).projects
manifest_project = projects[MANIFEST_PROJECT_INDEX]
if args.local is not None:
rel_manifest = os.path.relpath(args.local, util.west_topdir())
update_config('manifest', 'path', rel_manifest)
else:
if manifest_project.path == '':
url_path = urlparse(args.manifest_url).path
manifest_project.path = posixpath.basename(url_path)
manifest_project.abspath = os.path.realpath(
os.path.join(util.west_topdir(), manifest_project.path))
manifest_project.name = manifest_project.path
shutil.move(args.cache, manifest_project.abspath)
update_config('manifest', 'path', manifest_project.path)
for project in projects:
if project.path == 'zephyr':
update_config('zephyr', 'base', project.path)
def test_env_overrides():
# Test that the WEST_CONFIG_SYSTEM etc. overrides work as
# expected.
#
# We are *not* using tstloc() and want to call cmd(), but
# we don't want to set the global or local environment variables
# in os.environ, or we'd have to be careful to clean them up,
# since they would affect other test cases. Use a copy instead.
# (Our autouse fixture cleans up the system variable.)
# Our test fixture already set up a system variable; test it.
assert not os.path.isfile(os.environ['WEST_CONFIG_SYSTEM'])
cmd('config --system pytest.foo bar')
assert os.path.isfile(os.environ['WEST_CONFIG_SYSTEM'])
assert cfg(f=SYSTEM)['pytest']['foo'] == 'bar'
# Copy the environment to make sure global and local settings
# take effect there, and only there.
env = os.environ.copy()
env['WEST_CONFIG_GLOBAL'] = os.path.abspath('config.global')
env['WEST_CONFIG_LOCAL'] = os.path.abspath('config.local')
config.update_config('pytest',
'foo',
'global-not-in-env',
configfile=GLOBAL)
assert not os.path.isfile(env['WEST_CONFIG_GLOBAL'])
assert cfg(f=ALL)['pytest']['foo'] == 'global-not-in-env'
cmd('config --global pytest.foo global-in-env', env=env)
assert os.path.isfile(env['WEST_CONFIG_GLOBAL'])
assert cmd('config pytest.foo', env=env).rstrip() == 'global-in-env'
config.update_config('pytest', 'foo', 'local-not-in-env', configfile=LOCAL)
assert not os.path.isfile(env['WEST_CONFIG_LOCAL'])
assert cfg(f=ALL)['pytest']['foo'] == 'local-not-in-env'
cmd('config --local pytest.foo local-in-env', env=env)
assert os.path.isfile(env['WEST_CONFIG_LOCAL'])
assert cmd('config pytest.foo', env=env).rstrip() == 'local-in-env'
def local(self, args):
if args.manifest_rev is not None:
log.die('--mr cannot be used with -l')
manifest_dir = canonical(args.directory or os.getcwd())
manifest_file = join(manifest_dir, 'west.yml')
topdir = dirname(manifest_dir)
rel_manifest = basename(manifest_dir)
west_dir = os.path.join(topdir, WEST_DIR)
_banner('Initializing from existing manifest repository ' +
rel_manifest)
if not exists(manifest_file):
log.die('No "west.yml" found in {}'.format(manifest_dir))
self.create(west_dir)
os.chdir(topdir)
projects = self.projects(manifest_file) # This validates the manifest.
_msg('Creating {} and local configuration'.format(west_dir))
update_config('manifest', 'path', rel_manifest)
self.topdir = topdir
return projects, manifest_dir
def test_delete_all():
# Deleting ConfigFile.ALL should delete from everywhere.
config.update_config('pytest', 'key', 'system', configfile=SYSTEM)
config.update_config('pytest', 'key', 'global', configfile=GLOBAL)
config.update_config('pytest', 'key', 'local', configfile=LOCAL)
assert cfg(f=SYSTEM)['pytest']['key'] == 'system'
assert cfg(f=GLOBAL)['pytest']['key'] == 'global'
assert cfg(f=LOCAL)['pytest']['key'] == 'local'
config.delete_config('pytest', 'key', configfile=ALL)
assert 'pytest' not in cfg(f=ALL)
def test_delete_local_with_topdir():
# Test LOCAL-only delete with specified topdir.
config.update_config('pytest', 'key', 'system', configfile=SYSTEM)
config.update_config('pytest', 'key', 'global', configfile=GLOBAL)
config.update_config('pytest', 'key', 'local', configfile=LOCAL)
assert cfg(f=SYSTEM)['pytest']['key'] == 'system'
assert cfg(f=GLOBAL)['pytest']['key'] == 'global'
assert cfg(f=LOCAL)['pytest']['key'] == 'local'
config.delete_config('pytest', 'key', configfile=LOCAL)
assert cfg(f=SYSTEM)['pytest']['key'] == 'system'
assert cfg(f=GLOBAL)['pytest']['key'] == 'global'
assert 'pytest' not in cfg(f=LOCAL)
def test_delete_global():
# Test GLOBAL-only delete.
config.update_config('pytest', 'key', 'system', configfile=SYSTEM)
config.update_config('pytest', 'key', 'global', configfile=GLOBAL)
config.update_config('pytest', 'key', 'local', configfile=LOCAL)
assert cfg(f=SYSTEM)['pytest']['key'] == 'system'
assert cfg(f=GLOBAL)['pytest']['key'] == 'global'
assert cfg(f=LOCAL)['pytest']['key'] == 'local'
config.delete_config('pytest', 'key', configfile=GLOBAL)
assert cfg(f=SYSTEM)['pytest']['key'] == 'system'
assert 'pytest' not in cfg(f=GLOBAL)
assert cfg(f=LOCAL)['pytest']['key'] == 'local'
def test_delete_list():
# Test delete of a list of places.
config.update_config('pytest', 'key', 'system', configfile=SYSTEM)
config.update_config('pytest', 'key', 'global', configfile=GLOBAL)
config.update_config('pytest', 'key', 'local', configfile=LOCAL)
assert cfg(f=SYSTEM)['pytest']['key'] == 'system'
assert cfg(f=GLOBAL)['pytest']['key'] == 'global'
assert cfg(f=LOCAL)['pytest']['key'] == 'local'
config.delete_config('pytest', 'key', configfile=[GLOBAL, LOCAL])
assert cfg(f=SYSTEM)['pytest']['key'] == 'system'
assert 'pytest' not in cfg(f=GLOBAL)
assert 'pytest' not in cfg(f=LOCAL)
def test_delete_none():
# Deleting None should delete from lowest-precedence global or
# local file only.
config.update_config('pytest', 'key', 'system', configfile=SYSTEM)
config.update_config('pytest', 'key', 'global', configfile=GLOBAL)
config.update_config('pytest', 'key', 'local', configfile=LOCAL)
assert cfg(f=SYSTEM)['pytest']['key'] == 'system'
assert cfg(f=GLOBAL)['pytest']['key'] == 'global'
assert cfg(f=LOCAL)['pytest']['key'] == 'local'
config.delete_config('pytest', 'key', configfile=None)
assert cfg(f=ALL)['pytest']['key'] == 'global'
config.delete_config('pytest', 'key', configfile=None)
assert cfg(f=ALL)['pytest']['key'] == 'system'
with pytest.raises(KeyError):
config.delete_config('pytest', 'key', configfile=None)
def test_config_system_precedence():
# Test precedence rules, including system level.
config.update_config('pytest', 'key', 'sys', configfile=SYSTEM)
assert cfg(f=SYSTEM)['pytest']['key'] == 'sys'
assert cfg(f=ALL)['pytest']['key'] == 'sys'
config.update_config('pytest', 'key', 'glb', configfile=GLOBAL)
assert cfg(f=SYSTEM)['pytest']['key'] == 'sys'
assert cfg(f=GLOBAL)['pytest']['key'] == 'glb'
assert cfg(f=ALL)['pytest']['key'] == 'glb'
config.update_config('pytest', 'key', 'lcl', configfile=LOCAL)
assert cfg(f=SYSTEM)['pytest']['key'] == 'sys'
assert cfg(f=GLOBAL)['pytest']['key'] == 'glb'
assert cfg(f=LOCAL)['pytest']['key'] == 'lcl'
assert cfg(f=ALL)['pytest']['key'] == 'lcl'
def set_zephyr_base(args, manifest, topdir):
'''Ensure ZEPHYR_BASE is set
Order of precedence:
1) Value given as command line argument
2) Value from environment setting: ZEPHYR_BASE
3) Value of zephyr.base setting in west config file
4) Project in the manifest with name, or path, "zephyr" (will
be persisted as zephyr.base in the local config if found)
Order of precedence between 2) and 3) can be changed with the setting
zephyr.base-prefer.
zephyr.base-prefer takes the values 'env' and 'configfile'
If 2) and 3) have different values and zephyr.base-prefer is unset,
a warning is printed.'''
if args.zephyr_base:
# The command line --zephyr-base takes precedence over
# everything else.
zb = os.path.abspath(args.zephyr_base)
zb_origin = 'command line'
else:
# If the user doesn't specify it concretely, then use ZEPHYR_BASE
# from the environment or zephyr.base from west.configuration.
#
# (We will configure zephyr.base to the project that has path
# 'zephyr' as a last resort here.)
#
# At some point, we need a more flexible way to set environment
# variables based on manifest contents, but this is good enough
# to get started with and to ask for wider testing.
zb_env = os.environ.get('ZEPHYR_BASE')
zb_prefer = config.config.get('zephyr', 'base-prefer', fallback=None)
rel_zb_config = config.config.get('zephyr', 'base', fallback=None)
if rel_zb_config is None:
projects = None
try:
projects = manifest.get_projects(['zephyr'])
except ValueError:
pass
if projects:
zephyr = projects[0]
config.update_config('zephyr', 'base', zephyr.path)
rel_zb_config = zephyr.path
if rel_zb_config is not None:
zb_config = Path(topdir) / rel_zb_config
else:
zb_config = None
if zb_prefer == 'env' and zb_env is not None:
zb = zb_env
zb_origin = 'env'
elif zb_prefer == 'configfile' and zb_config is not None:
zb = str(zb_config)
zb_origin = 'configfile'
elif zb_env is not None:
zb = zb_env
zb_origin = 'env'
try:
different = (zb_config and not zb_config.samefile(zb_env))
except FileNotFoundError:
different = (zb_config
and (PurePath(zb_config)) != PurePath(zb_env))
if different:
# The environment ZEPHYR_BASE takes precedence over the config
# setting, but is different than the zephyr.base config value.
#
# Therefore, issue a warning as the user might have
# run zephyr-env.sh/cmd in some other zephyr
# workspace and forgotten about it.
log.wrn(f'ZEPHYR_BASE={zb_env} '
f'in the calling environment will be used,\n'
f'but the zephyr.base config option in {topdir} '
f'is "{rel_zb_config}"\n'
f'which implies a different ZEPHYR_BASE={zb_config}\n'
f'To disable this warning in the future, execute '
f"'west config --global zephyr.base-prefer env'")
elif zb_config:
zb = str(zb_config)
zb_origin = 'configfile'
else:
zb = None
zb_origin = None
# No --zephyr-base, no ZEPHYR_BASE, and no zephyr.base.
log.wrn("can't find the zephyr repository\n"
' - no --zephyr-base given\n'
' - ZEPHYR_BASE is unset\n'
' - west config contains no zephyr.base setting\n'
' - no manifest project has name or path "zephyr"\n'
'\n'
" If this isn't a Zephyr workspace, you can "
" silence this warning with something like this:\n"
' west config zephyr.base not-using-zephyr')
if zb is not None:
os.environ['ZEPHYR_BASE'] = zb
log.dbg(f'ZEPHYR_BASE={zb} (origin: {zb_origin})')
def fixup_zephyr_base(self, projects):
for project in projects:
if project.path == 'zephyr':
update_config('zephyr', 'base', project.path)
