PTU5KAS/kas/plugins/menu.py
Jan Kiszka 5fb9067894 Fall back to .config.yaml if no configuration file given
Make the configuration file on the command line optional and fall back
to trying to open the generated .config.yaml instead. This allows the
sequence

kas menu -> save & exit
kas build
kas shell
kas ...

and also makes rebuilding the self-configured image simpler.

Signed-off-by: Jan Kiszka <jan.kiszka@siemens.com>
2021-10-09 15:00:05 +02:00

494 lines
17 KiB
Python

# kas - setup tool for bitbake based projects
#
# Copyright (c) Siemens AG, 2021
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
#
# Parts of this were based on kconfiglib, examples/menuconfig_example.py
#
# Copyright (c) 2011-2019, Ulf Magnusson <ulfalizer@gmail.com>
#
# Permission to use, copy, modify, and/or distribute this software for any
# purpose with or without fee is hereby granted, provided that the above
# copyright notice and this permission notice appear in all copies.
#
"""
This plugin implements the ``kas menu`` command.
When this command is executed, kas will open a configuration menu as
described by a Kconfig file. It processes any pre-existing configuration
file with saved settings, stores the final selections and invokes the build
plugin if requested by the user.
To make use of this plugin, a ``Kconfig`` file has to be provided. The
menu can define these types of configuration variables that the plugin
will translate into a kas configuration:
- kas configuration files that will be included when building the
generated configuration. Those are picked up from kconfig string
variables that have the name prefix ``KAS_INCLUDE_``.
- bitbake targets that shall be built via the generated configuration.
Those are picked up from kconfig string variables that have the name
prefix ``KAS_TARGET_``.
- The ``build_system`` that will used. The static kconfig string variable
``KAS_BUILD_SYSTEM`` defines this value which must be ``openembedded``,
``oe`` or ``isar`` is set.
- bitbake configuration variables that will be added to the
``local_conf_header`` section of the generated configuration. All other
active kconfig string, integer or hex variables are treated as such.
See https://www.kernel.org/doc/html/latest/kbuild/kconfig-language.html
for a complete documentation of the Kconfig language.
The menu plugin writes the selected configuration to a ``.config.yaml``
file in the kas work directory and also reads previous selection from such
a file if it exists. The ``.config.yaml`` both contains the selected
configuration in the ``menu_configuration`` key and also the effective
settings that can be used to invoke ``kas build`` or other kas commands.
"""
import logging
import os
import pprint
import sys
import yaml
from kconfiglib import Kconfig, Symbol, Choice, expr_value, TYPE_TO_STR, \
MENU, COMMENT, STRING, BOOL, INT, HEX, UNKNOWN
from kas import __version__, __file_version__
from kas.context import create_global_context
from kas.config import CONFIG_YAML_FILE
from kas.includehandler import load_config as load_config_yaml
from kas.plugins.build import Build
try:
from snack import SnackScreen, EntryWindow, ButtonChoiceWindow, \
ButtonBar, Listbox, GridFormHelp
newt_available = True
except ImportError:
newt_available = False # will be reported in run()
__license__ = 'MIT'
__copyright__ = \
'Copyright (c) 2011-2019, Ulf Magnusson <ulfalizer@gmail.com>\n' \
'Copyright (c) Siemens AG, 2021'
def check_sym_is_string(sym):
if sym.type != STRING:
logging.error('Variable %s must be of string type', sym.name)
sys.exit(1)
def str_representer(dumper, data):
style = '|' if len(data.splitlines()) > 1 else None
return dumper.represent_scalar('tag:yaml.org,2002:str', data, style=style)
class Args:
pass
class Menu:
"""
This class implements the menu plugin for kas.
"""
name = 'menu'
helpmsg = (
'Provides a configuration menu and triggers the build of the choices.'
)
@classmethod
def setup_parser(cls, parser):
parser.add_argument('kconfig',
help='Kconfig file',
nargs='?', default='Kconfig')
def load_config(self, filename):
try:
self.orig_config = load_config_yaml(filename)
except FileNotFoundError:
self.orig_config = {}
return
menu_configuration = self.orig_config.get('menu_configuration', {})
for symname in menu_configuration:
sym = self.kconf.syms.get(symname)
if not sym:
logging.warning(
'Ignoring unknown configuration variable %s in %s',
symname, filename)
continue
symvalue = menu_configuration[symname]
if sym.type == BOOL:
sym.set_value('y' if symvalue else 'n')
elif sym.type == INT:
sym.set_value(str(symvalue))
elif sym.type == HEX:
sym.set_value(str(hex(symvalue)))
else: # string
sym.set_value(symvalue)
def save_config(self, filename):
kas_includes = []
kas_targets = []
kas_build_system = None
kas_vars = {}
menu_configuration = {}
for symname in self.kconf.syms:
if symname == 'MODULES':
continue
sym = self.kconf.syms[symname]
symvalue = sym.str_value
if expr_value(sym.direct_dep) < 2:
continue
if sym.visibility == 2:
if sym.type == BOOL:
menu_configuration[symname] = symvalue == 'y'
elif sym.type == STRING:
menu_configuration[symname] = symvalue
elif sym.type == INT:
menu_configuration[symname] = int(symvalue)
elif sym.type == HEX:
menu_configuration[symname] = int(symvalue, 16)
else:
logging.error(
'Configuration variable %s uses unsupported type',
symname)
sys.exit(1)
if symname.startswith('KAS_INCLUDE_'):
check_sym_is_string(sym)
if symvalue != '':
kas_includes.append(symvalue)
elif symname.startswith('KAS_TARGET_'):
check_sym_is_string(sym)
if symvalue != '':
kas_targets.append(symvalue)
elif symname == 'KAS_BUILD_SYSTEM':
check_sym_is_string(sym)
if symvalue != '':
kas_build_system = symvalue
elif sym.type in (STRING, INT, HEX):
kas_vars[symname] = symvalue
config = {
'header': {
'version': __file_version__,
'includes': kas_includes
},
'menu_configuration': menu_configuration
}
if kas_build_system:
config['build_system'] = kas_build_system
if len(kas_targets) > 0:
config['target'] = kas_targets
if len(kas_vars) > 0:
config['local_conf_header'] = {
'__menu_config_vars': '\n'.join([
'{} = "{}"'.format(key, value)
for key, value in kas_vars.items()
])
}
logging.debug('Menu configuration:\n%s', pprint.pformat(config))
if config != self.orig_config:
logging.info('Saving configuration as %s', filename)
# format multi-line strings more nicely
yaml.add_representer(str, str_representer)
try:
os.rename(filename, filename + '.old')
except FileNotFoundError:
pass
with open(filename, 'w') as config_file:
config_file.write(
'#\n'
'# Automatically generated by kas {}\n'
'#\n'.format(__version__))
yaml.dump(config, config_file)
def dump_kconf_warnings(self):
if len(self.kconf.warnings) > 0:
logging.warning("\n".join(self.kconf.warnings))
self.kconf.warnings = []
def run(self, args):
if not newt_available:
logging.error(
'Menu plugin requires \'python3-newt\' distribution package.')
sys.exit(1)
ctx = create_global_context(args)
self.kconf = Kconfig(args.kconfig, warn_to_stderr=False)
config_filename = os.path.join(ctx.kas_work_dir, CONFIG_YAML_FILE)
self.load_config(config_filename)
self.dump_kconf_warnings()
menu = Menuconfig(self.kconf)
action = menu.show()
if action == 'exit':
return
self.save_config(config_filename)
self.dump_kconf_warnings()
if action == 'build':
logging.debug('Starting build')
build_args = Args()
build_args.config = None
build_args.target = None
build_args.task = None
build_args.extra_bitbake_args = []
build_args.skip = None
Build().run(build_args)
class Menuconfig():
def __init__(self, kconf):
self.kconf = kconf
self.screen = None
@staticmethod
def value_str(sym):
"""
Returns the value part ("[*]", "(foo)" etc.) of a menu entry.
"""
if sym.type in (STRING, INT, HEX):
return "({})".format(sym.str_value)
# BOOL (TRISTATE not supported)
# The choice mode is an upper bound on the visibility of choice
# symbols, so we can check the choice symbols' own visibility to see
# if the choice is in y mode
if sym.choice and sym.visibility == 2:
return "(*)" if sym.choice.selection is sym else "( )"
tri_val_str = (" ", None, "*")[sym.tri_value]
if len(sym.assignable) == 1:
# Pinned to a single value
return "-{}-".format(tri_val_str)
if sym.type == BOOL:
return "[{}]".format(tri_val_str)
raise RuntimeError()
@staticmethod
def node_str(node, indent):
"""
Returns the complete menu entry text for a menu node, or "" for
invisible menu nodes. Invisible menu nodes are those that lack a prompt
or that do not have a satisfied prompt condition.
Example return value: "[*] Bool symbol (BOOL)"
The symbol name is printed in parentheses to the right of the prompt.
This is so that symbols can easily be referred to in the configuration
interface.
"""
if not node.prompt:
return ""
# Even for menu nodes for symbols and choices, it's wrong to check
# Symbol.visibility / Choice.visibility here. The reason is that a
# symbol (and a choice, in theory) can be defined in multiple
# locations, giving it multiple menu nodes, which do not necessarily
# all have the same prompt visibility. Symbol.visibility /
# Choice.visibility is calculated as the OR of the visibility of all
# the prompts.
prompt, prompt_cond = node.prompt
if not expr_value(prompt_cond):
return ""
if node.item == MENU:
return " " + indent * " " + prompt + " --->"
if type(node.item) == Choice:
return " " + indent * " " + prompt
if node.item == COMMENT:
return " " + indent * " " + "*** {} ***".format(prompt)
# Symbol
sym = node.item
if sym.type == UNKNOWN:
return ""
# {:3} sets the field width to three. Gives nice alignment for empty
# string values.
res = "{:3} {}{}".format(Menuconfig.value_str(sym), indent * " ",
prompt)
# Append a sub-menu arrow if menuconfig and enabled
if node.is_menuconfig:
res += " ---" + (">" if sym.tri_value > 0 else "-")
return res
@staticmethod
def menu_node_strings(node, indent):
items = []
while node:
string = Menuconfig.node_str(node, indent)
if string:
items.append((string, node))
if (node.list and node.item != MENU
and (type(node.item) == Choice or not node.is_menuconfig)):
items.extend(Menuconfig.menu_node_strings(node.list,
indent + 2))
node = node.next
return items
def show_menu(self, title, top_node):
selection = 0
while True:
items = Menuconfig.menu_node_strings(top_node, 0)
height = len(items)
scroll = 0
if height > self.screen.height - 13:
height = self.screen.height - 13
scroll = 1
buttons = [
('Save & Build', 'build', 'B'),
('Save & Exit', 'save', 'S'),
(' Help ', 'help', 'h'),
(' Exit ', 'exit', 'ESC')
]
buttonbar = ButtonBar(self.screen, buttons)
listbox = Listbox(height, scroll=scroll, returnExit=1)
count = 0
for string, _ in items:
listbox.append(string, count)
if (selection == count):
listbox.setCurrent(count)
count = count + 1
grid = GridFormHelp(self.screen, title, None, 1, 2)
grid.add(listbox, 0, 0, padding=(0, 0, 0, 1))
grid.add(buttonbar, 0, 1, growx=1)
grid.addHotKey(' ')
rc = grid.runOnce()
action = buttonbar.buttonPressed(rc)
if action and action != 'help':
return action
if count == 0:
continue
selection = listbox.current()
_, selected_node = items[selection]
sym = selected_node.item
if action == 'help':
prompt, _ = selected_node.prompt
if hasattr(selected_node, 'help') and selected_node.help:
help = selected_node.help
else:
help = 'No help available.'
ButtonChoiceWindow(
screen=self.screen,
title="Help on '{}'".format(prompt),
text=help,
width=60,
buttons=[' Ok '])
continue
show_submenu = False
if type(sym) == Symbol:
if rc == ' ':
if sym.type == BOOL:
sym.set_value('n' if sym.tri_value > 0 else 'y')
else:
if selected_node.is_menuconfig:
show_submenu = True
elif sym.type in (STRING, INT, HEX):
action, values = EntryWindow(
screen=self.screen,
title=sym.name,
text='Enter a %s value:' % TYPE_TO_STR[sym.type],
prompts=[('', sym.str_value)],
buttons=[(' Ok ', 'Ok'), ('Cancel', '', 'ESC')])
if action == 'Ok':
self.kconf.warnings = []
val = values[0]
if sym.type == HEX and not val.startswith('0x'):
val = '0x' + val
sym.set_value(val)
# only fetching triggers range check - how ugly...
sym.str_value
if len(self.kconf.warnings) > 0:
ButtonChoiceWindow(
screen=self.screen,
title="Invalid entry",
text="\n".join(self.kconf.warnings),
width=60,
buttons=[' Ok '])
self.kconf.warnings = []
elif selected_node.is_menuconfig and type(sym) != Choice:
show_submenu = True
if show_submenu:
submenu_title, _ = selected_node.prompt
action = self.show_menu(submenu_title,
selected_node.list)
if action != 'exit':
return action
def show(self):
self.screen = SnackScreen()
action = self.show_menu(self.kconf.mainmenu_text,
self.kconf.top_node.list)
self.screen.finish()
return action
__KAS_PLUGINS__ = [Menu]