267 lines
9.3 KiB
Python
Executable file
267 lines
9.3 KiB
Python
Executable file
#!/usr/bin/env python
|
|
#
|
|
# Long-running server process uses stdin & stdout to communicate JSON
|
|
# with a caller
|
|
#
|
|
from __future__ import print_function
|
|
import argparse
|
|
import json
|
|
import os
|
|
import sys
|
|
import confgen
|
|
from confgen import FatalError, __version__
|
|
|
|
try:
|
|
from . import kconfiglib
|
|
except Exception:
|
|
sys.path.insert(0, os.path.dirname(os.path.realpath(__file__)))
|
|
import kconfiglib
|
|
|
|
# Min/Max supported protocol versions
|
|
MIN_PROTOCOL_VERSION = 1
|
|
MAX_PROTOCOL_VERSION = 2
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(description='confserver.py v%s - Config Generation Tool' % __version__, prog=os.path.basename(sys.argv[0]))
|
|
|
|
parser.add_argument('--config',
|
|
help='Project configuration settings',
|
|
required=True)
|
|
|
|
parser.add_argument('--kconfig',
|
|
help='KConfig file with config item definitions',
|
|
required=True)
|
|
|
|
parser.add_argument('--env', action='append', default=[],
|
|
help='Environment to set when evaluating the config file', metavar='NAME=VAL')
|
|
|
|
parser.add_argument('--version', help='Set protocol version to use on initial status',
|
|
type=int, default=MAX_PROTOCOL_VERSION)
|
|
|
|
args = parser.parse_args()
|
|
|
|
if args.version < MIN_PROTOCOL_VERSION:
|
|
print("Version %d is older than minimum supported protocol version %d. Client is much older than ESP-IDF version?" %
|
|
(args.version, MIN_PROTOCOL_VERSION))
|
|
|
|
if args.version > MAX_PROTOCOL_VERSION:
|
|
print("Version %d is newer than maximum supported protocol version %d. Client is newer than ESP-IDF version?" %
|
|
(args.version, MAX_PROTOCOL_VERSION))
|
|
|
|
try:
|
|
args.env = [(name,value) for (name,value) in (e.split("=",1) for e in args.env)]
|
|
except ValueError:
|
|
print("--env arguments must each contain =. To unset an environment variable, use 'ENV='")
|
|
sys.exit(1)
|
|
|
|
for name, value in args.env:
|
|
os.environ[name] = value
|
|
|
|
run_server(args.kconfig, args.config)
|
|
|
|
|
|
def run_server(kconfig, sdkconfig, default_version=MAX_PROTOCOL_VERSION):
|
|
config = kconfiglib.Kconfig(kconfig)
|
|
config.load_config(sdkconfig)
|
|
|
|
print("Server running, waiting for requests on stdin...", file=sys.stderr)
|
|
|
|
config_dict = confgen.get_json_values(config)
|
|
ranges_dict = get_ranges(config)
|
|
visible_dict = get_visible(config)
|
|
|
|
if default_version == 1:
|
|
# V1: no 'visibility' key, send value None for any invisible item
|
|
values_dict = dict((k, v if visible_dict[k] else False) for (k,v) in config_dict.items())
|
|
json.dump({"version": 1, "values": values_dict, "ranges": ranges_dict}, sys.stdout)
|
|
else:
|
|
# V2 onwards: separate visibility from version
|
|
json.dump({"version": default_version, "values": config_dict, "ranges": ranges_dict, "visible": visible_dict}, sys.stdout)
|
|
print("\n")
|
|
|
|
while True:
|
|
line = sys.stdin.readline()
|
|
if not line:
|
|
break
|
|
try:
|
|
req = json.loads(line)
|
|
except ValueError as e: # json module throws JSONDecodeError (sublcass of ValueError) on Py3 but ValueError on Py2
|
|
response = {"version": default_version, "error": ["JSON formatting error: %s" % e]}
|
|
json.dump(response, sys.stdout)
|
|
print("\n")
|
|
continue
|
|
before = confgen.get_json_values(config)
|
|
before_ranges = get_ranges(config)
|
|
before_visible = get_visible(config)
|
|
|
|
if "load" in req: # load a new sdkconfig
|
|
|
|
if req.get("version", default_version) == 1:
|
|
# for V1 protocol, send all items when loading new sdkconfig.
|
|
# (V2+ will only send changes, same as when setting an item)
|
|
before = {}
|
|
before_ranges = {}
|
|
before_visible = {}
|
|
|
|
# if no new filename is supplied, use existing sdkconfig path, otherwise update the path
|
|
if req["load"] is None:
|
|
req["load"] = sdkconfig
|
|
else:
|
|
sdkconfig = req["load"]
|
|
|
|
if "save" in req:
|
|
if req["save"] is None:
|
|
req["save"] = sdkconfig
|
|
else:
|
|
sdkconfig = req["save"]
|
|
|
|
error = handle_request(config, req)
|
|
|
|
after = confgen.get_json_values(config)
|
|
after_ranges = get_ranges(config)
|
|
after_visible = get_visible(config)
|
|
|
|
values_diff = diff(before, after)
|
|
ranges_diff = diff(before_ranges, after_ranges)
|
|
visible_diff = diff(before_visible, after_visible)
|
|
if req["version"] == 1:
|
|
# V1 response, invisible items have value None
|
|
for k in (k for (k,v) in visible_diff.items() if not v):
|
|
values_diff[k] = None
|
|
response = {"version": 1, "values": values_diff, "ranges": ranges_diff}
|
|
else:
|
|
# V2+ response, separate visibility values
|
|
response = {"version": req["version"], "values": values_diff, "ranges": ranges_diff, "visible": visible_diff}
|
|
if error:
|
|
for e in error:
|
|
print("Error: %s" % e, file=sys.stderr)
|
|
response["error"] = error
|
|
json.dump(response, sys.stdout)
|
|
print("\n")
|
|
|
|
|
|
def handle_request(config, req):
|
|
if "version" not in req:
|
|
return ["All requests must have a 'version'"]
|
|
|
|
if req["version"] < MIN_PROTOCOL_VERSION or req["version"] > MAX_PROTOCOL_VERSION:
|
|
return ["Unsupported request version %d. Server supports versions %d-%d" % (
|
|
req["version"],
|
|
MIN_PROTOCOL_VERSION,
|
|
MAX_PROTOCOL_VERSION)]
|
|
|
|
error = []
|
|
|
|
if "load" in req:
|
|
print("Loading config from %s..." % req["load"], file=sys.stderr)
|
|
try:
|
|
config.load_config(req["load"])
|
|
except Exception as e:
|
|
error += ["Failed to load from %s: %s" % (req["load"], e)]
|
|
|
|
if "set" in req:
|
|
handle_set(config, error, req["set"])
|
|
|
|
if "save" in req:
|
|
try:
|
|
print("Saving config to %s..." % req["save"], file=sys.stderr)
|
|
confgen.write_config(config, req["save"])
|
|
except Exception as e:
|
|
error += ["Failed to save to %s: %s" % (req["save"], e)]
|
|
|
|
return error
|
|
|
|
|
|
def handle_set(config, error, to_set):
|
|
missing = [k for k in to_set if k not in config.syms]
|
|
if missing:
|
|
error.append("The following config symbol(s) were not found: %s" % (", ".join(missing)))
|
|
# replace name keys with the full config symbol for each key:
|
|
to_set = dict((config.syms[k],v) for (k,v) in to_set.items() if k not in missing)
|
|
|
|
# Work through the list of values to set, noting that
|
|
# some may not be immediately applicable (maybe they depend
|
|
# on another value which is being set). Therefore, defer
|
|
# knowing if any value is unsettable until then end
|
|
|
|
while len(to_set):
|
|
set_pass = [(k,v) for (k,v) in to_set.items() if k.visibility]
|
|
if not set_pass:
|
|
break # no visible keys left
|
|
for (sym,val) in set_pass:
|
|
if sym.type in (kconfiglib.BOOL, kconfiglib.TRISTATE):
|
|
if val is True:
|
|
sym.set_value(2)
|
|
elif val is False:
|
|
sym.set_value(0)
|
|
else:
|
|
error.append("Boolean symbol %s only accepts true/false values" % sym.name)
|
|
else:
|
|
sym.set_value(str(val))
|
|
print("Set %s" % sym.name)
|
|
del to_set[sym]
|
|
|
|
if len(to_set):
|
|
error.append("The following config symbol(s) were not visible so were not updated: %s" % (", ".join(s.name for s in to_set)))
|
|
|
|
|
|
def diff(before, after):
|
|
"""
|
|
Return a dictionary with the difference between 'before' and 'after',
|
|
for items which are present in 'after' dictionary
|
|
"""
|
|
diff = dict((k,v) for (k,v) in after.items() if before.get(k, None) != v)
|
|
return diff
|
|
|
|
|
|
def get_ranges(config):
|
|
ranges_dict = {}
|
|
|
|
def handle_node(node):
|
|
sym = node.item
|
|
if not isinstance(sym, kconfiglib.Symbol):
|
|
return
|
|
active_range = sym.active_range
|
|
if active_range[0] is not None:
|
|
ranges_dict[sym.name] = active_range
|
|
|
|
config.walk_menu(handle_node)
|
|
return ranges_dict
|
|
|
|
|
|
def get_visible(config):
|
|
"""
|
|
Return a dict mapping node IDs (config names or menu node IDs) to True/False for their visibility
|
|
"""
|
|
result = {}
|
|
menus = []
|
|
|
|
# when walking the menu the first time, only
|
|
# record whether the config symbols are visible
|
|
# and make a list of menu nodes (that are not symbols)
|
|
def handle_node(node):
|
|
sym = node.item
|
|
try:
|
|
visible = (sym.visibility != 0)
|
|
result[node] = visible
|
|
except AttributeError:
|
|
menus.append(node)
|
|
config.walk_menu(handle_node)
|
|
|
|
# now, figure out visibility for each menu. A menu is visible if any of its children are visible
|
|
for m in reversed(menus): # reverse to start at leaf nodes
|
|
result[m] = any(v for (n,v) in result.items() if n.parent == m)
|
|
|
|
# return a dict mapping the node ID to its visibility.
|
|
result = dict((confgen.get_menu_node_id(n),v) for (n,v) in result.items())
|
|
|
|
return result
|
|
|
|
|
|
if __name__ == '__main__':
|
|
try:
|
|
main()
|
|
except FatalError as e:
|
|
print("A fatal error occurred: %s" % e, file=sys.stderr)
|
|
sys.exit(2)
|