255 lines
8.2 KiB
Python
255 lines
8.2 KiB
Python
#!/usr/bin/python3
|
|
#
|
|
# Copyright (C) 2022 The Android Open Source Project
|
|
#
|
|
# 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
|
|
#
|
|
# http://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.
|
|
|
|
import enum
|
|
import os
|
|
import platform
|
|
|
|
_API_SURFACES = "api_surfaces"
|
|
_INTERMEDIATES = "intermediates"
|
|
|
|
# Phony target to assemble al the api files in out/api_surfaces
|
|
ASSEMBLE_PHONY_TARGET = "multitree-sdk"
|
|
|
|
class Context(object):
|
|
"""Mockable container for global state."""
|
|
|
|
def __init__(self, out_root, errors):
|
|
self.out = OutDir(out_root)
|
|
self.errors = errors
|
|
self.tools = HostTools()
|
|
|
|
|
|
class ContextTest(Context):
|
|
"""Context for testing.
|
|
|
|
The real Context is manually constructed in orchestrator.py.
|
|
"""
|
|
|
|
def __init__(self, test_work_dir: str, test_name: str):
|
|
"""Initialize the object.
|
|
|
|
Args:
|
|
test_work_dir: The working directory to use for the test: typically
|
|
created with tempfile.mkdtemp().
|
|
test_name: A name unique to the test: typically self.id() in the test.
|
|
"""
|
|
super().__init__(os.path.join(test_work_dir, test_name), Errors(None))
|
|
|
|
|
|
@enum.unique
|
|
class OutDirBase(enum.Enum):
|
|
"""The basepath to use for output paths.
|
|
|
|
ORIGIN: Path is relative to ${OUT_DIR}. Use this when the path will be
|
|
consumed while not nsjailed. (default)
|
|
OUTER: Path is relative to the outer tree root. Use this when the path
|
|
will be consumed while nsjailed in the outer tree.
|
|
"""
|
|
DEFAULT = 0
|
|
ORIGIN = 1
|
|
OUTER = 2
|
|
|
|
|
|
class OutDir(object):
|
|
"""Encapsulates the logic about the out directory at the outer-tree level.
|
|
See also inner_tree.OutDirLayout for inner tree out dir contents."""
|
|
|
|
# For ease of use.
|
|
Base = OutDirBase
|
|
|
|
def __init__(self, out_origin, out_path="out"):
|
|
"""Initialize with the root of the OUT_DIR for the inner tree.
|
|
|
|
Args:
|
|
out_origin: The OUT_DIR path to use. Usually "out".
|
|
out_path: Where the outer tree out_dir will be mapped, relative to the
|
|
outer tree root. Usually "out".
|
|
"""
|
|
self._base = {}
|
|
self._base[self.Base.ORIGIN] = out_origin
|
|
self._base[self.Base.OUTER] = out_path
|
|
self._base[self.Base.DEFAULT] = self._base[self.Base.ORIGIN]
|
|
|
|
def _generate_path(self,
|
|
*args,
|
|
base: OutDirBase = OutDirBase.DEFAULT,
|
|
abspath=False):
|
|
"""Return the path to the file.
|
|
|
|
Args:
|
|
args: Path elements to use.
|
|
base: Which base path to use.
|
|
abspath: Whether to return the absolute path.
|
|
"""
|
|
ret = os.path.join(self._base[base], *args)
|
|
if abspath:
|
|
ret = os.path.abspath(ret)
|
|
return ret
|
|
|
|
def root(self, **kwargs):
|
|
"""The provided out_dir, mapped into "out/" for ninja."""
|
|
return self._generate_path(**kwargs)
|
|
|
|
def inner_tree_dir(self, tree_root, product, **kwargs):
|
|
"""True root directory for inner tree inside the out dir."""
|
|
product = product or "unbundled"
|
|
out_root = f'{tree_root}_{product}'
|
|
return self._generate_path("trees", out_root, **kwargs)
|
|
|
|
def api_ninja_file(self, **kwargs):
|
|
"""The ninja file that assembles API surfaces."""
|
|
return self._generate_path("api_surfaces.ninja", **kwargs)
|
|
|
|
def api_library_dir(self, surface, version, library, **kwargs):
|
|
"""Directory for all the contents of a library inside an API surface.
|
|
|
|
This includes the build files. Any intermediates should go in
|
|
api_library_work_dir.
|
|
"""
|
|
return self._generate_path(_API_SURFACES, surface, str(version),
|
|
library, **kwargs)
|
|
|
|
def api_library_work_dir(self, surface, version, library, **kwargs):
|
|
"""Intermediate scratch directory for library inside an API surface."""
|
|
return self._generate_path(self.api_surfaces_work_dir(),
|
|
surface,
|
|
str(version),
|
|
library,
|
|
**kwargs)
|
|
|
|
def api_surfaces_dir(self, **kwargs):
|
|
"""The published api_surfaces directory."""
|
|
return self._generate_path(_API_SURFACES, **kwargs)
|
|
|
|
def api_surfaces_work_dir(self, *args):
|
|
"""Intermediates / scratch directory for API surface assembly.
|
|
Useful for creating artifacts that are expected to be shared between multiple API libraries"""
|
|
return self._generate_path(_INTERMEDIATES, _API_SURFACES, *args)
|
|
|
|
def outer_ninja_file(self, **kwargs):
|
|
return self._generate_path("multitree.ninja", **kwargs)
|
|
|
|
def module_share_dir(self, module_type, module_name, **kwargs):
|
|
return self._generate_path("shared", module_type, module_name,
|
|
**kwargs)
|
|
|
|
def staging_dir(self, **kwargs):
|
|
return self._generate_path("staging", **kwargs)
|
|
|
|
def dist_dir(self, **kwargs):
|
|
"""The DIST_DIR provided or out/dist"""
|
|
# TODO: Look at DIST_DIR
|
|
return self._generate_path("dist", **kwargs)
|
|
|
|
def nsjail_config_file(self, **kwargs):
|
|
"""The nsjail config file used for the ninja run."""
|
|
return self._generate_path("nsjail.cfg", **kwargs)
|
|
|
|
|
|
class Errors(object):
|
|
"""Class for reporting and tracking errors."""
|
|
|
|
def __init__(self, stream):
|
|
"""Initialize Error reporter with a file-like object."""
|
|
self._stream = stream
|
|
self._all = []
|
|
|
|
def error(self, message, file=None, line=None, col=None):
|
|
"""Record the error message."""
|
|
s = ""
|
|
if file:
|
|
s += str(file)
|
|
s += ":"
|
|
if line:
|
|
s += str(line)
|
|
s += ":"
|
|
if col:
|
|
s += str(col)
|
|
s += ":"
|
|
if s:
|
|
s += " "
|
|
s += str(message)
|
|
if s[-1] != "\n":
|
|
s += "\n"
|
|
self._all.append(s)
|
|
if self._stream:
|
|
self._stream.write(s)
|
|
|
|
def had_error(self):
|
|
"""Return if there were any errors reported."""
|
|
return len(self._all)
|
|
|
|
def get_errors(self):
|
|
"""Get all errors that were reported."""
|
|
return self._all
|
|
|
|
# This clang_version was picked from Soong (build/soong/cc/config/global.go).
|
|
# However, C stubs are ABI-stable and should not be affected by divergence in toolchain
|
|
# versions of orchestrator and inner_build.
|
|
CLANG_VERSION = "clang-r475365b"
|
|
|
|
class HostTools(object):
|
|
def __init__(self):
|
|
if platform.system() == "Linux":
|
|
self._arch = "linux-x86"
|
|
else:
|
|
raise Exception(
|
|
f"Orchestrator: unknown system {platform.system()}")
|
|
|
|
# Some of these are called a lot, so pre-compute the strings to save
|
|
# memory.
|
|
self._prebuilts = os.path.join("orchestrator", "prebuilts",
|
|
"build-tools", self._arch, "bin")
|
|
self._acp = os.path.join(self._prebuilts, "acp")
|
|
self._ninja = os.path.join(self._prebuilts, "ninja")
|
|
self._nsjail = os.path.join(self._prebuilts, "nsjail")
|
|
clang_root = os.path.join(
|
|
"orchestrator",
|
|
"prebuilts",
|
|
"clang",
|
|
"host",
|
|
self._arch,
|
|
CLANG_VERSION,
|
|
"bin",
|
|
)
|
|
self._clang = os.path.join(clang_root, "clang")
|
|
self._clang_cxx = os.path.join(clang_root, "clang++")
|
|
|
|
|
|
# TODO: @property
|
|
def acp(self):
|
|
return self._acp
|
|
|
|
# TODO: @property
|
|
def ninja(self):
|
|
return self._ninja
|
|
|
|
def clang(self):
|
|
return self._clang
|
|
|
|
def clang_cxx(self):
|
|
return self._clang_cxx
|
|
|
|
@property
|
|
def nsjail(self):
|
|
return self._nsjail
|
|
|
|
|
|
def choose_out_dir():
|
|
"""Get the root of the out dir, either $OUT_DIR or a default."""
|
|
return os.environ.get("OUT_DIR") or "out"
|