forked from openkylin/platform_build
Product configuration in Starlark support files.
Bug: 170637441 Test: rbcrun build/make/tests/run.rbc Change-Id: Ie8f0c3dea66a287f2b0a3b588c446bfbb2c9a978
This commit is contained in:
Sasha Smundak
parent
24159db21e
commit
5c8b09b2ef
|
|
@ -0,0 +1,21 @@
|
|||
|
||||
# Copyright 2021 Google LLC
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# https://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
|
||||
# This file has been manually converted from build_id.mk
|
||||
def init(g):
|
||||
|
||||
# BUILD_ID is usually used to specify the branch name (like "MAIN") or a branch name and a release candidate
|
||||
# (like "CRB01"). It must be a single word, and is capitalized by convention.
|
||||
g["BUILD_ID"]="AOSP.MASTER"
|
||||
|
|
@ -0,0 +1,199 @@
|
|||
|
||||
# Copyright 2021 Google LLC
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# https://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
|
||||
load(":build_id.rbc|init", _build_id_init="init")
|
||||
|
||||
def _all_versions():
|
||||
"""Returns all known versions."""
|
||||
versions = ["OPR1", "OPD1", "OPD2","OPM1", "OPM2", "PPR1", "PPD1", "PPD2", "PPM1", "PPM2", "QPR1" ]
|
||||
for v in ("Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"):
|
||||
for e in ("P1A", "P1B", "P2A", "P2B", "D1A", "D1B", "D2A", "D2B", "Q1A", "Q1B", "Q2A", "Q2B", "Q3A", "Q3B"):
|
||||
versions.append(v+e)
|
||||
return versions
|
||||
|
||||
def _allowed_versions(all_versions, min_version, max_version, default_version):
|
||||
"""Checks that version range and default versions is valid, returns all versions in range."""
|
||||
for v in (min_version, max_version, default_version):
|
||||
if v not in all_versions:
|
||||
fail("% is invalid" % v)
|
||||
|
||||
min_i = all_versions.index(min_version)
|
||||
max_i = all_versions.index(max_version)
|
||||
def_i = all_versions.index(default_version)
|
||||
if min_i > max_i:
|
||||
fail("%s should come before %s in the version list" % (min_version, max_version))
|
||||
if def_i < min_i or def_i > max_i:
|
||||
fail("%s should come between % and %s" % (default_version, min_version, max_version))
|
||||
return all_versions[min_i:max_i+1]
|
||||
|
||||
# This function is a manual conversion of the version_defaults.mk
|
||||
def _versions_default(g, all_versions):
|
||||
"""Handle various build version information.
|
||||
|
||||
Guarantees that the following are defined:
|
||||
PLATFORM_VERSION
|
||||
PLATFORM_SDK_VERSION
|
||||
PLATFORM_VERSION_CODENAME
|
||||
DEFAULT_APP_TARGET_SDK
|
||||
BUILD_ID
|
||||
BUILD_NUMBER
|
||||
PLATFORM_SECURITY_PATCH
|
||||
PLATFORM_VNDK_VERSION
|
||||
PLATFORM_SYSTEMSDK_VERSIONS
|
||||
"""
|
||||
|
||||
# If build_id.rbc exists, it may override some of the defaults.
|
||||
# Note that build.prop target also wants INTERNAL_BUILD_ID_MAKEFILE to be set if the file exists.
|
||||
if _build_id_init != None:
|
||||
_build_id_init(g)
|
||||
g["INTERNAL_BUILD_ID_MAKEFILE"] = "build/make/core/build_id"
|
||||
|
||||
allowed_versions = _allowed_versions(all_versions, v_min, v_max, v_default)
|
||||
g.setdefault("TARGET_PLATFORM_VERSION", v_default)
|
||||
if g["TARGET_PLATFORM_VERSION"] not in allowed_versions:
|
||||
fail("% is not valid, must be one of %s" % (g["TARGET_PLATFORM_VERSION"], allowed_versions))
|
||||
|
||||
g["DEFAULT_PLATFORM_VERSION"] = v_default
|
||||
g["PLATFORM_VERSION_LAST_STABLE"] = 11
|
||||
g.setdefault("PLATFORM_VERSION_CODENAME", g["TARGET_PLATFORM_VERSION"])
|
||||
# TODO(asmundak): set PLATFORM_VERSION_ALL_CODENAMES
|
||||
|
||||
g.setdefault("PLATFORM_VERSION",
|
||||
g["PLATFORM_VERSION_LAST_STABLE"] if g["PLATFORM_VERSION_CODENAME"] == "REL" else g["PLATFORM_VERSION_CODENAME"])
|
||||
g.setdefault("PLATFORM_SDK_VERSION", 30)
|
||||
if g["PLATFORM_VERSION_CODENAME"] == "REL":
|
||||
g["PLATFORM_PREVIEW_SDK_VERSION"] = 0
|
||||
else:
|
||||
g.setdefault("PLATFORM_PREVIEW_SDK_VERSION", 1)
|
||||
|
||||
g.setdefault("DEFAULT_APP_TARGET_SDK",
|
||||
g["PLATFORM_SDK_VERSION"] if g["PLATFORM_VERSION_CODENAME"] == "REL" else g["PLATFORM_VERSION_CODENAME"])
|
||||
g.setdefault("PLATFORM_VNDK_VERSION",
|
||||
g["PLATFORM_SDK_VERSION"] if g["PLATFORM_VERSION_CODENAME"] == "REL" else g["PLATFORM_VERSION_CODENAME"])
|
||||
g.setdefault("PLATFORM_SYSTEMSDK_MIN_VERSION", 28)
|
||||
versions = [str(i) for i in range(g["PLATFORM_SYSTEMSDK_MIN_VERSION"], g["PLATFORM_SDK_VERSION"] + 1)]
|
||||
versions.append(g["PLATFORM_VERSION_CODENAME"])
|
||||
g["PLATFORM_SYSTEMSDK_VERSIONS"] = sorted(versions)
|
||||
|
||||
# Used to indicate the security patch that has been applied to the device.
|
||||
# It must signify that the build includes all security patches issued up through the designated Android Public Security Bulletin.
|
||||
# It must be of the form "YYYY-MM-DD" on production devices.
|
||||
# It must match one of the Android Security Patch Level strings of the Public Security Bulletins.
|
||||
# If there is no $PLATFORM_SECURITY_PATCH set, keep it empty.
|
||||
g.setdefault("PLATFORM_SECURITY_PATCH", "2021-03-05")
|
||||
dt = 'TZ="GMT" %s' % g["PLATFORM_SECURITY_PATCH"]
|
||||
g.setdefault("PLATFORM_SECURITY_PATCH_TIMESTAMP", rblf_shell("date -d '%s' +%%s" % dt))
|
||||
|
||||
# Used to indicate the base os applied to the device. Can be an arbitrary string, but must be a single word.
|
||||
# If there is no $PLATFORM_BASE_OS set, keep it empty.
|
||||
g.setdefault("PLATFORM_BASE_OS", "")
|
||||
|
||||
# Used to signify special builds. E.g., branches and/or releases, like "M5-RC7". Can be an arbitrary string, but
|
||||
# must be a single word and a valid file name. If there is no BUILD_ID set, make it obvious.
|
||||
g.setdefault("BUILD_ID", "UNKNOWN")
|
||||
|
||||
# BUILD_NUMBER should be set to the source control value that represents the current state of the source code.
|
||||
# E.g., a perforce changelist number or a git hash. Can be an arbitrary string (to allow for source control that
|
||||
# uses something other than numbers), but must be a single word and a valid file name.
|
||||
#
|
||||
# If no BUILD_NUMBER is set, create a useful "I am an engineering build from this date/time" value. Make it start
|
||||
# with a non-digit so that anyone trying to parse it as an integer will probably get "0".
|
||||
g.setdefault("BUILD_NUMBER", "eng.%s.%s" % (g["USER"], "TIMESTAMP"))
|
||||
|
||||
# Used to set minimum supported target sdk version. Apps targeting SDK version lower than the set value will result
|
||||
# in a warning being shown when any activity from the app is started.
|
||||
g.setdefault("PLATFORM_MIN_SUPPORTED_TARGET_SDK_VERSION", 23)
|
||||
|
||||
def init(g):
|
||||
all_versions = _all_versions()
|
||||
_versions_default(g, all_versions)
|
||||
for v in all_versions:
|
||||
g["IS_AT_LEAST" + v] = True
|
||||
if v == g["TARGET_PLATFORM_VERSION"]:
|
||||
break
|
||||
|
||||
# ---------------------------------------------------------------
|
||||
# If you update the build system such that the environment setup or buildspec.mk need to be updated,
|
||||
# increment this number, and people who haven't re-run those will have to do so before they can build.
|
||||
# Make sure to also update the corresponding value in buildspec.mk.default and envsetup.sh.
|
||||
g["CORRECT_BUILD_ENV_SEQUENCE_NUMBER"] = 13
|
||||
|
||||
g.setdefault("TARGET_PRODUCT", "aosp_arm")
|
||||
g.setdefault("TARGET_BUILD_VARIANT", "eng")
|
||||
|
||||
g.setdefault("TARGET_BUILD_APPS", [])
|
||||
g["TARGET_BUILD_UNBUNDLED"] = (g["TARGET_BUILD_APPS"] != []) or (getattr(g, "TARGET_BUILD_UNBUNDLED_IMAGE", "") != "")
|
||||
|
||||
# ---------------------------------------------------------------
|
||||
# Set up configuration for host machine. We don't do cross-compiles except for arm, so the HOST
|
||||
# is whatever we are running on.
|
||||
host = rblf_shell("uname -sm")
|
||||
if host.find("Linux") >= 0:
|
||||
g["HOST_OS"] = "linux"
|
||||
elif host.find("Darwin") >= 0:
|
||||
g["HOST_OS"] = "darwin"
|
||||
else:
|
||||
fail("Cannot run on %s OS" % host)
|
||||
|
||||
# TODO(asmundak): set g.HOST_OS_EXTRA
|
||||
|
||||
g["BUILD_OS"] = g["HOST_OS"]
|
||||
|
||||
# TODO(asmundak): check cross-OS build
|
||||
|
||||
if host.find("x86_64") >= 0:
|
||||
g["HOST_ARCH"] = "x86_64"
|
||||
g["HOST_2ND_ARCH"] = "x86"
|
||||
g["HOST_IS_64_BIT"] = True
|
||||
elif host.find("i686") >= 0 or host.find("x86") >= 0:
|
||||
fail("Building on a 32-bit x86 host is not supported: %s" % host)
|
||||
elif g["HOST_OS"] == "darwin":
|
||||
g["HOST_2ND_ARCH"] = ""
|
||||
|
||||
g["HOST_2ND_ARCH_VAR_PREFIX"] = "2ND_"
|
||||
g["HOST_2ND_ARCH_MODULE_SUFFIX"] = "_32"
|
||||
g["HOST_CROSS_2ND_ARCH_VAR_PREFIX"] = "2ND_"
|
||||
g["HOST_CROSS_2ND_ARCH_MODULE_SUFFIX"] = "_64"
|
||||
g["TARGET_2ND_ARCH_VAR_PREFIX"] = "2ND_"
|
||||
|
||||
# TODO(asmundak): combo-related stuff
|
||||
|
||||
# on windows, the tools have .exe at the end, and we depend on the
|
||||
# host config stuff being done first
|
||||
g["BUILD_ARCH"] = g["HOST_ARCH"]
|
||||
g["BUILD_2ND_ARCH"] = g["HOST_2ND_ARCH"]
|
||||
|
||||
# the host build defaults to release, and it must be release or debug
|
||||
g.setdefault("HOST_BUILD_TYPE", "release")
|
||||
if g["HOST_BUILD_TYPE"] != "release" and g["HOST_BUILD_TYPE"] != "debug":
|
||||
fail("HOST_BUILD_TYPE must be either release or debug, not '%s'" % g["HOST_BUILD_TYPE"])
|
||||
|
||||
# TODO(asmundak): a lot more, but not needed for the product configuration
|
||||
|
||||
g["ART_APEX_JARS"] = [
|
||||
"com.android.art:core-oj",
|
||||
"com.android.art:core-libart",
|
||||
"com.android.art:okhttp",
|
||||
"com.android.art:bouncycastle",
|
||||
"com.android.art:apache-xml"
|
||||
]
|
||||
|
||||
if g.get("TARGET_BUILD_TYPE", "") != "debug":
|
||||
g["TARGET_BUILD_TYPE"] = "release"
|
||||
|
||||
|
||||
v_default = "SP1A"
|
||||
v_min = "SP1A"
|
||||
v_max = "SP1A"
|
||||
|
|
@ -0,0 +1,483 @@
|
|||
|
||||
# Copyright 2021 Google LLC
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# https://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
|
||||
load("//build/make/core:envsetup.rbc", _envsetup_init="init")
|
||||
"""Runtime functions."""
|
||||
|
||||
def _global_init():
|
||||
"""Returns dict created from the runtime environment."""
|
||||
globals = dict()
|
||||
|
||||
# Environment variables
|
||||
for k in dir(rblf_env):
|
||||
globals[k] = getattr(rblf_env, k)
|
||||
|
||||
# Variables set as var=value command line arguments
|
||||
for k in dir(rblf_cli):
|
||||
globals[k] = getattr(rblf_cli, k)
|
||||
|
||||
globals.setdefault("PRODUCT_SOONG_NAMESPACES", [])
|
||||
_envsetup_init(globals)
|
||||
|
||||
# Variables that should be defined.
|
||||
mandatory_vars = [
|
||||
"PLATFORM_VERSION_CODENAME", "PLATFORM_VERSION",
|
||||
"PRODUCT_SOONG_NAMESPACES",
|
||||
# TODO(asmundak): do we need TARGET_ARCH? AOSP does not reference it
|
||||
"TARGET_BUILD_TYPE", "TARGET_BUILD_VARIANT", "TARGET_PRODUCT",
|
||||
]
|
||||
for bv in mandatory_vars:
|
||||
if not bv in globals:
|
||||
fail(bv, " is not defined")
|
||||
|
||||
return globals
|
||||
|
||||
_globals_base = _global_init()
|
||||
|
||||
def __print_attr(attr, value):
|
||||
if not value:
|
||||
return
|
||||
if type(value) == "list":
|
||||
if _options.rearrange:
|
||||
value = __printvars_rearrange_list(value)
|
||||
if _options.format == "pretty":
|
||||
print(attr, "=", repr(value))
|
||||
elif _options.format == "make":
|
||||
print(attr, ":=", " ".join(value))
|
||||
else:
|
||||
if _options.format == "pretty":
|
||||
print(attr, "=", repr(value))
|
||||
elif _options.format == "make":
|
||||
print(attr, ":=", value)
|
||||
else:
|
||||
fail("bad output format", _options.format)
|
||||
|
||||
|
||||
def _printvars(globals, cfg):
|
||||
"""Prints known configuration variables."""
|
||||
for attr, val in sorted(cfg.items()):
|
||||
__print_attr(attr, val)
|
||||
if _options.print_globals:
|
||||
for attr, val in sorted(globals.items()):
|
||||
print()
|
||||
if attr not in _globals_base:
|
||||
__print_attr(attr, val)
|
||||
|
||||
|
||||
def __printvars_rearrange_list(l):
|
||||
"""Rearrange value list: return only distinct elements, maybe sorted."""
|
||||
seen = { item: 0 for item in l}
|
||||
return sorted(seen.keys()) if _options.rearrange == "sort" else seen.keys()
|
||||
|
||||
def _product_configuration(top_pcm_name, top_pcm):
|
||||
"""Creates configuration."""
|
||||
|
||||
# Product configuration is created by traversing product's inheritance
|
||||
# tree. It is traversed twice.
|
||||
# First, beginning with top-level module we execute a module and find
|
||||
# its ancestors, repeating this recursively. At the end of this phase
|
||||
# we get the full inheritance tree.
|
||||
# Second, we traverse the tree in the postfix order (i.e., visiting a
|
||||
# node after its ancestors) to calculate the product configuration.
|
||||
#
|
||||
# PCM means "Product Configuration Module", i.e., a Starlark file
|
||||
# whose body consists of a single init function.
|
||||
|
||||
globals = dict(**_globals_base)
|
||||
|
||||
config_postfix = [] # Configs in postfix order
|
||||
# Each PCM is represented by a quadruple of function, config, children names
|
||||
# and readyness (that is, the configurations from inherited PCMs have been
|
||||
# substituted).
|
||||
configs = { top_pcm_name: (top_pcm, None, [], False)} # All known PCMs
|
||||
|
||||
stash = [] # Configs to push once their descendants are done
|
||||
|
||||
# Stack maintaining PCMs to be processed. An item in the stack
|
||||
# is a pair of PCMs name and its height in the product inheritance tree.
|
||||
pcm_stack = []
|
||||
pcm_stack.append((top_pcm_name, 0))
|
||||
pcm_count = 0
|
||||
# Run it until pcm_stack is exhausted, but no more than N times
|
||||
for n in range(1000):
|
||||
if not pcm_stack:
|
||||
break
|
||||
(name, height) = pcm_stack.pop()
|
||||
pcm, cfg, c, _ = configs[name]
|
||||
# each PCM is executed once
|
||||
if cfg != None:
|
||||
continue
|
||||
# Push ancestors until we reach this node's height
|
||||
config_postfix.extend([stash.pop() for i in range(len(stash) - height)])
|
||||
|
||||
# Run this one, obtaining its configuration and child PCMs.
|
||||
if _options.trace_modules:
|
||||
print("%s:" % n[0])
|
||||
|
||||
# The handle passed to the PCM consists of config and inheritance state.dict of inherited modules
|
||||
# and a list containing the current default value of a list variable.
|
||||
handle = __h_new()
|
||||
pcm(globals, handle)
|
||||
children = __h_inherited_modules(handle)
|
||||
if _options.trace_modules:
|
||||
print(" ", " ".join(children.keys()))
|
||||
configs[name] = (pcm, __h_cfg(handle), children.keys(), False)
|
||||
pcm_count = pcm_count+1
|
||||
|
||||
if len(children) == 0:
|
||||
# Leaf PCM goes straight to the config_postfix
|
||||
config_postfix.append(name)
|
||||
continue
|
||||
|
||||
# Stash this PCM, process children in the sorted order
|
||||
stash.append(name)
|
||||
for child_name in sorted(children, reverse=True):
|
||||
if child_name not in configs:
|
||||
configs[child_name] = (children[child_name], None, [], False)
|
||||
pcm_stack.append((child_name, len(stash)))
|
||||
|
||||
# Flush the stash
|
||||
config_postfix.extend([stash.pop() for i in range(len(stash))])
|
||||
if len(config_postfix) != pcm_count:
|
||||
fail("Ran %d modules but postfix tree has only %d entries" % (pcm_count, len(config_postfix)))
|
||||
|
||||
|
||||
if _options.trace_modules:
|
||||
print("\n---Postfix---")
|
||||
for x in config_postfix:
|
||||
print(" ", x)
|
||||
|
||||
# Traverse the tree from the bottom, evaluating inherited values
|
||||
for pcm_name in config_postfix:
|
||||
pcm, cfg, children_names, ready = configs[pcm_name]
|
||||
# Should run
|
||||
if cfg == None:
|
||||
fail("%s: has not been run" % pcm_name)
|
||||
# Ready once
|
||||
if ready:
|
||||
continue
|
||||
# Children should be ready
|
||||
for child_name in children_names:
|
||||
if not configs[child_name][3]:
|
||||
fail("%s: child is not ready" % child_name)
|
||||
|
||||
# if _options.trace_modules:
|
||||
# print(">%s: %s" % (pcm_name, cfg))
|
||||
|
||||
_substitute_inherited(configs, pcm_name, cfg)
|
||||
_percolate_inherited(configs, pcm_name, cfg, children_names)
|
||||
configs[pcm_name] = pcm, cfg, children_names, True
|
||||
# if _options.trace_modules:
|
||||
# print("<%s: %s" % (pcm_name, cfg))
|
||||
|
||||
return globals, configs[top_pcm_name][1]
|
||||
|
||||
|
||||
def _substitute_inherited(configs, pcm_name, cfg):
|
||||
"""Substitutes inherited values in all the configuration settings."""
|
||||
for attr, val in cfg.items():
|
||||
trace_it = attr in _options.trace_variables
|
||||
if trace_it:
|
||||
old_val = val
|
||||
|
||||
# TODO(asmundak): should we handle single vars?
|
||||
if type(val) != "list":
|
||||
continue
|
||||
|
||||
if trace_it:
|
||||
new_val = _value_expand(configs, attr, val)
|
||||
if new_val != old_val:
|
||||
print("%s(i): %s=%s (was %s)" % (pcm_name, attr, new_val, old_val))
|
||||
cfg[attr] = new_val
|
||||
continue
|
||||
|
||||
cfg[attr] = _value_expand(configs, attr, val)
|
||||
|
||||
|
||||
|
||||
def _value_expand(configs, attr, values_list):
|
||||
"""Expands references to inherited values in a given list."""
|
||||
result = []
|
||||
expanded={}
|
||||
for item in values_list:
|
||||
# Inherited values are 1-tuples
|
||||
if type(item) != "tuple":
|
||||
result.append(item)
|
||||
continue
|
||||
child_name = item[0]
|
||||
if child_name in expanded:
|
||||
continue
|
||||
expanded[child_name] = True
|
||||
child = configs[child_name]
|
||||
if not child[3]:
|
||||
fail("%s should be ready" % child_name)
|
||||
__move_items(result, child[1], attr)
|
||||
|
||||
return result
|
||||
|
||||
|
||||
def _percolate_inherited(configs, cfg_name, cfg, children_names):
|
||||
"""Percolates the settings that are present only in children."""
|
||||
percolated_attrs = {}
|
||||
for child_name in children_names:
|
||||
child_cfg = configs[child_name][1]
|
||||
for attr, value in child_cfg.items():
|
||||
if type(value) != "list":
|
||||
if attr in percolated_attrs or not attr in cfg:
|
||||
cfg[attr] = value
|
||||
percolated_attrs[attr] = True
|
||||
continue
|
||||
if attr in percolated_attrs:
|
||||
# We already are percolating this one, just add this list
|
||||
__move_items(cfg[attr], child_cfg, attr)
|
||||
elif not attr in cfg:
|
||||
percolated_attrs[attr] = True
|
||||
cfg[attr] = []
|
||||
__move_items(cfg[attr], child_cfg, attr)
|
||||
|
||||
for attr in _options.trace_variables:
|
||||
if attr in percolated_attrs:
|
||||
print("%s: %s^=%s" % (cfg_name, attr, cfg[attr]))
|
||||
|
||||
|
||||
def __move_items(to_list, from_cfg, attr):
|
||||
l = from_cfg.get(attr, [])
|
||||
if l:
|
||||
to_list.extend(l)
|
||||
from_cfg[attr] = []
|
||||
|
||||
|
||||
def _indirect(pcm_name):
|
||||
"""Returns configuration item for the inherited module."""
|
||||
return (pcm_name,)
|
||||
|
||||
|
||||
def _addprefix(prefix, string_or_list):
|
||||
"""Adds prefix and returns a list.
|
||||
|
||||
If string_or_list is a list, prepends prefix to each element.
|
||||
Otherwise, string_or_list is considered to be a string which
|
||||
is split into words and then prefix is prepended to each one.
|
||||
|
||||
Args:
|
||||
prefix
|
||||
string_or_list
|
||||
|
||||
"""
|
||||
return [ prefix + x for x in __words(string_or_list)]
|
||||
|
||||
|
||||
def _addsuffix(suffix, string_or_list):
|
||||
"""Adds suffix and returns a list.
|
||||
|
||||
If string_or_list is a list, appends suffix to each element.
|
||||
Otherwise, string_or_list is considered to be a string which
|
||||
is split into words and then suffix is appended to each one.
|
||||
|
||||
Args:
|
||||
suffix
|
||||
string_or_list
|
||||
"""
|
||||
return [ x + suffix for x in __words(string_or_list)]
|
||||
|
||||
|
||||
def __words(string_or_list):
|
||||
if type(string_or_list) == "list":
|
||||
return string_or_list
|
||||
return string_or_list.split()
|
||||
|
||||
|
||||
def __h_new():
|
||||
"""Constructs a handle which is passed to PCM."""
|
||||
return (dict(), dict(), list())
|
||||
|
||||
def __h_inherited_modules(handle):
|
||||
return handle[1]
|
||||
|
||||
|
||||
def __h_cfg(handle):
|
||||
return handle[0]
|
||||
|
||||
|
||||
def _setdefault(handle, attr):
|
||||
"""Sets given attribute's value if it has not been set."""
|
||||
cfg = handle[0]
|
||||
if cfg.get(attr) == None:
|
||||
cfg[attr] = list(handle[2])
|
||||
return cfg[attr]
|
||||
|
||||
def _inherit(handle, pcm_name, pcm):
|
||||
"""Records inheritance."""
|
||||
cfg, inherited, default_lv = handle
|
||||
inherited[pcm_name]=pcm
|
||||
default_lv.append(_indirect(pcm_name))
|
||||
# Add inherited module reference to all configuration values
|
||||
for attr, val in cfg.items():
|
||||
if type(val) == "list":
|
||||
val.append(_indirect(pcm_name))
|
||||
|
||||
|
||||
def _copy_if_exists(path_pair):
|
||||
"""If from file exists, returns [from:to] pair."""
|
||||
l = path_pair.split(":", 2)
|
||||
# Check that l[0] exists
|
||||
return [":".join(l)] if rblf_file_exists(l[0]) else []
|
||||
|
||||
def _enforce_product_packages_exist(pkg_string_or_list):
|
||||
"""Makes including non-existent modules in PRODUCT_PACKAGES an error."""
|
||||
#TODO(asmundak)
|
||||
pass
|
||||
|
||||
|
||||
def _file_wildcard_exists(file_pattern):
|
||||
"""Return True if there are files matching given bash pattern."""
|
||||
return len(rblf_wildcard(file_pattern)) > 0
|
||||
|
||||
|
||||
def _find_and_copy(pattern, from_dir, to_dir):
|
||||
"""Return a copy list for the files matching the pattern."""
|
||||
return ["%s/%s:%s/%s" % (from_dir, f, to_dir, f) for f in rblf_wildcard(pattern, from_dir)]
|
||||
|
||||
|
||||
def _filter_out(pattern, text):
|
||||
"""Return all the words from `text' that do not match any word in `pattern'.
|
||||
|
||||
Args:
|
||||
pattern: string or list of words. '%' stands for wildcard (in regex terms, '.*')
|
||||
text: string or list of words
|
||||
Return:
|
||||
list of words
|
||||
"""
|
||||
rex = __mk2regex(__words(pattern))
|
||||
res = []
|
||||
for w in __words(text):
|
||||
if not _regex_match(rex, w):
|
||||
res.append(w)
|
||||
return res
|
||||
|
||||
|
||||
def _filter(pattern, text):
|
||||
"""Return all the words in `text` that match `pattern`.
|
||||
|
||||
Args:
|
||||
pattern: strings of words or a list. A word can contain '%',
|
||||
which stands for any sequence of characters.
|
||||
text: string or list of words.
|
||||
"""
|
||||
rex = __mk2regex(__words(pattern))
|
||||
res = []
|
||||
for w in __words(text):
|
||||
if _regex_match(rex, w):
|
||||
res.append(w)
|
||||
return res
|
||||
|
||||
|
||||
def __mk2regex(words):
|
||||
"""Returns regular expression equivalent to Make pattern."""
|
||||
|
||||
# TODO(asmundak): this will mishandle '\%'
|
||||
return "^(" + "|".join([w.replace("%", ".*", 1) for w in words]) + ")"
|
||||
|
||||
|
||||
def _regex_match(regex, w):
|
||||
return rblf_regex(regex, w)
|
||||
|
||||
|
||||
def _require_artifacts_in_path(paths, allowed_paths):
|
||||
"""TODO."""
|
||||
#print("require_artifacts_in_path(", __words(paths), ",", __words(allowed_paths), ")")
|
||||
pass
|
||||
|
||||
|
||||
def _require_artifacts_in_path_relaxed(paths, allowed_paths):
|
||||
"""TODO."""
|
||||
pass
|
||||
|
||||
|
||||
def _expand_wildcard(pattern):
|
||||
"""Expands shell wildcard pattern."""
|
||||
return rblf_wildcard(pattern)
|
||||
|
||||
|
||||
def _mkerror(file, message=""):
|
||||
"""Prints error and stops."""
|
||||
fail("%s: %s. Stop" % (file, message))
|
||||
|
||||
|
||||
def _mkwarning(file, message=""):
|
||||
"""Prints warning."""
|
||||
print("%s: warning: %s" % (file, message))
|
||||
|
||||
|
||||
def _mkinfo(file, message=""):
|
||||
"""Prints info."""
|
||||
print(message)
|
||||
|
||||
|
||||
def __get_options():
|
||||
"""Returns struct containing runtime global settings."""
|
||||
settings = dict(
|
||||
format = "pretty",
|
||||
print_globals = False,
|
||||
rearrange = "",
|
||||
trace_modules = False,
|
||||
trace_variables = [],
|
||||
)
|
||||
for x in getattr(rblf_cli, "RBC_OUT", "").split(","):
|
||||
if x == "sort" or x == "unique":
|
||||
if settings["rearrange"]:
|
||||
fail("RBC_OUT: either sort or unique is allowed (and sort implies unique)")
|
||||
settings["rearrange"] = x
|
||||
elif x == "pretty" or x == "make":
|
||||
settings["format"] = x
|
||||
elif x == "global":
|
||||
settings["print_globals"] = True
|
||||
elif x != "":
|
||||
fail("RBC_OUT: got %s, should be one of: [pretty|make] [sort|unique]" % x)
|
||||
for x in getattr(rblf_cli, "RBC_DEBUG", "").split(","):
|
||||
if x == "!trace":
|
||||
settings["trace_modules"] = True
|
||||
elif x != "":
|
||||
settings["trace_variables"].append(x)
|
||||
return struct(**settings)
|
||||
|
||||
# Settings used during debugging.
|
||||
_options = __get_options()
|
||||
rblf = struct(addprefix=_addprefix,
|
||||
addsuffix=_addsuffix,
|
||||
copy_if_exists=_copy_if_exists,
|
||||
cfg=__h_cfg,
|
||||
enforce_product_packages_exist=_enforce_product_packages_exist,
|
||||
expand_wildcard=_expand_wildcard,
|
||||
file_exists=rblf_file_exists,
|
||||
file_wildcard_exists=_file_wildcard_exists,
|
||||
filter=_filter,
|
||||
filter_out=_filter_out,
|
||||
find_and_copy=_find_and_copy,
|
||||
global_init=_global_init,
|
||||
inherit=_inherit,
|
||||
indirect=_indirect,
|
||||
mkinfo=_mkinfo,
|
||||
mkerror=_mkerror,
|
||||
mkwarning=_mkwarning,
|
||||
printvars=_printvars,
|
||||
product_configuration=_product_configuration,
|
||||
require_artifacts_in_path=_require_artifacts_in_path,
|
||||
require_artifacts_in_path_relaxed=_require_artifacts_in_path_relaxed,
|
||||
setdefault=_setdefault,
|
||||
shell=rblf_shell,
|
||||
warning=_mkwarning,
|
||||
)
|
||||
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
|
||||
# Copyright 2021 Google LLC
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# https://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
|
||||
# Top-level test configuration.
|
||||
# Converted from the following makefile
|
||||
### PRODUCT_PACKAGES += dev
|
||||
### PRODUCT_HOST_PACKAGES += host
|
||||
### $(call inherit-product, $(LOCAL_PATH)/part1.mk)
|
||||
### PRODUCT_COPY_FILES += device_from:device_to
|
||||
### include $(LOCAL_PATH)/include1.mk
|
||||
### PRODUCT_PACKAGES += dev_after
|
||||
### PRODUCT_COPY_FILES += $(call find-copy-subdir-files,audio_platform_info*.xml,device/google/redfin/audio,$(TARGET_COPY_OUT_VENDOR)/etc) xyz
|
||||
|
||||
load("//build/make/core:product_config.rbc", "rblf")
|
||||
load(":part1.rbc", _part1_init = "init")
|
||||
load(":include1.rbc", _include1_init = "init")
|
||||
|
||||
def init(g, handle):
|
||||
cfg = rblf.cfg(handle)
|
||||
rblf.setdefault(handle, "PRODUCT_PACKAGES")
|
||||
cfg["PRODUCT_PACKAGES"] += ["dev"]
|
||||
rblf.setdefault(handle, "PRODUCT_HOST_PACKAGES")
|
||||
cfg["PRODUCT_HOST_PACKAGES"] += ["host"]
|
||||
rblf.inherit(handle, "test/part1", _part1_init)
|
||||
rblf.setdefault(handle, "PRODUCT_COPY_FILES")
|
||||
cfg["PRODUCT_COPY_FILES"] += ["device_from:device_to"]
|
||||
_include1_init(g, handle)
|
||||
cfg["PRODUCT_PACKAGES"] += ["dev_after"]
|
||||
cfg["PRODUCT_COPY_FILES"] += (rblf.find_and_copy("audio_platform_info*.xml", "device/google/redfin/audio", "||VENDOR-PATH-PH||/etc") +
|
||||
["xyz"])
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
|
||||
# Copyright 2021 Google LLC
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# https://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
|
||||
# Included file (not inherited)
|
||||
# Converted from makefile
|
||||
### PRODUCT_PACKAGES += inc
|
||||
|
||||
load("//build/make/core:product_config.rbc", "rblf")
|
||||
|
||||
def init(g, handle):
|
||||
cfg = rblf.cfg(handle)
|
||||
rblf.setdefault(handle, "PRODUCT_PACKAGES")
|
||||
cfg["PRODUCT_PACKAGES"] += ["inc"]
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
|
||||
# Copyright 2021 Google LLC
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# https://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
|
||||
# Part configuration
|
||||
# Converted from
|
||||
### PRODUCT_COPY_FILES += part_from:part_to
|
||||
### PRODUCT_PRODUCT_PROPERTIES += part_properties
|
||||
|
||||
load("//build/make/core:product_config.rbc", "rblf")
|
||||
|
||||
def init(g, handle):
|
||||
cfg = rblf.cfg(handle)
|
||||
rblf.setdefault(handle, "PRODUCT_COPY_FILES")
|
||||
cfg["PRODUCT_COPY_FILES"] += ["part_from:part_to"]
|
||||
rblf.setdefault(handle, "PRODUCT_PRODUCT_PROPERTIES")
|
||||
cfg["PRODUCT_PRODUCT_PROPERTIES"] += ["part_properties"]
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
|
||||
# Copyright 2021 Google LLC
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# https://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
|
||||
|
||||
# Run test configuration and verify its result.
|
||||
# The main configuration file is device.rbc.
|
||||
# It inherits part1.rbc and also includes include1.rbc
|
||||
# TODO(asmundak): more tests are needed to verify that:
|
||||
# * multi-level inheritance works as expected
|
||||
# * all runtime functions (wildcard, regex, etc.) work
|
||||
|
||||
load("//build/make/core:product_config.rbc", "rblf")
|
||||
load(":device.rbc", "init")
|
||||
|
||||
def assert_eq(expected, actual):
|
||||
if expected != actual:
|
||||
fail("Expected %s, got %s" % (expected, actual))
|
||||
|
||||
|
||||
globals, config = rblf.product_configuration("test/device", init)
|
||||
assert_eq(
|
||||
{
|
||||
"PRODUCT_COPY_FILES": [
|
||||
"part_from:part_to",
|
||||
"device_from:device_to",
|
||||
"device/google/redfin/audio/audio_platform_info_noextcodec_snd.xml:||VENDOR-PATH-PH||/etc/audio_platform_info_noextcodec_snd.xml",
|
||||
"xyz"
|
||||
],
|
||||
"PRODUCT_HOST_PACKAGES": ["host"],
|
||||
"PRODUCT_PACKAGES": [
|
||||
"dev",
|
||||
"inc",
|
||||
"dev_after"
|
||||
],
|
||||
"PRODUCT_PRODUCT_PROPERTIES": ["part_properties"]
|
||||
},
|
||||
{ k:v for k, v in sorted(config.items()) }
|
||||
)
|
||||
Loading…
Reference in New Issue