import os
import fnmatch
import shutil
from conanbase import ConanBase
from conan.tools.scm import Git, Version
from conan.tools.meson import Meson, MesonToolchain
from conan.tools.env import VirtualBuildEnv
from conan.tools.files import copy
required_conan_version = ">=2.13.0"
class AppConan(ConanBase):
language = "c++"
generators = "CMakeDeps", "VirtualBuildEnv", "PkgConfigDeps"
no_copy_source = True
options = {
"asan": [True, False],
"gcov": [True, False],
"test": [True, False],
"enable_luajit": [True, False],
"unidev": [True, False],
"chipv2_enable": [True, False],
"feature_ssu": [True, False],
"feature_rs485": [True, False],
"feature_mellanox": [True, False],
}
default_options = {
"asan": False,
"gcov": False,
"test": False,
"enable_luajit": False,
"unidev": False,
"chipv2_enable": False,
"feature_ssu": False,
"feature_rs485": False,
"feature_mellanox": True,
}
def requirements(self):
super().requirements()
if self.options.test:
self.requires("gtest/[>=1.14.0]@openubmc/stable")
def package_id(self):
base_package_id = getattr(
super(),
"package_id",
None,
)
if callable(base_package_id):
base_package_id()
self.info.requires[
"libsoc_adapter"
].patch_mode()
_source_excludes_extra = [
"build.sh",
"coverage_filtered.info", "coverage.info",
"build_clean_compare.*",
"build_optimized.log",
".cache",
".cache/*",
]
def source(self):
sources = self.conan_data["sources"][self.version]
if sources["url"] and sources["branch"]:
Git(self).fetch_commit(url=sources["url"], commit=sources["branch"].split("/")[-1])
return
excludes = list(self._source_excludes_extra)
base_excludes = getattr(self, "_DEFAULT_SOURCE_EXCLUDES", None)
if base_excludes:
for item in base_excludes:
if item not in excludes:
excludes.append(item)
else:
for item in ("builddir*", "build", ".build", "temp", "temp/*",
"*.log", "bingo-*.txt",
".libmcpp_prebuilt", ".ccache_wrapper", ".pkg-config",
".cache", ".cache/*",
".vscode", ".DS_Store", ".git", ".gitignore"):
if item not in excludes:
excludes.append(item)
copy(self, "*", src=sources["pwd"], dst=".", excludes=excludes)
def package_info(self):
if self.settings.arch == "armv8" or self.settings.arch == "x86_64":
self.cpp_info.libdirs = ["usr/lib64"]
self.env_info.LD_LIBRARY_PATH.append(os.path.join(self.package_folder, "usr/lib64"))
libdir = "usr/lib64"
else:
self.cpp_info.libdirs = ["usr/lib"]
self.env_info.LD_LIBRARY_PATH.append(os.path.join(self.package_folder, "usr/lib"))
libdir = "usr/lib"
self.env_info.PATH.append(os.path.join(self.package_folder, "opt/bmc/apps/libmcpp"))
self.cpp_info.includedirs = [
"internal", "internal/bus/bus_base",
"internal/bus/bus_i2c", "internal/bus/bus_hisport",
"internal/chip/chip_base", "internal/chip/chip_lm75",
"internal/chip/chip_pca9545", "internal/chip/chip_pca9555",
]
self.cpp_info.components["internal"].libs = ["Internal", "dev_smbus", "dev_protocol"]
self.cpp_info.components["internal"].libdirs = [libdir]
self.cpp_info.components["internal"].set_property("pkg_config_name", "Internal")
self.cpp_info.components["internal"].requires = ["libmcpp::libmcpp", "libsoc_adapter::libsoc_adapter"]
self.cpp_info.components["chip"].libs = ["Chip", "device_tree"]
self.cpp_info.components["chip"].libdirs = ["opt/bmc/drivers", libdir]
self.cpp_info.components["chip"].set_property("pkg_config_name", "Chip")
self.cpp_info.components["chip"].requires = ["internal"]
if self.options.test:
self.cpp_info.components["gtest"].requires = ["gtest::gtest"]
def layout(self):
super().layout()
self.cpp.package.libdirs = ["usr/lib64"]
def generate(self):
tc = MesonToolchain(self, "ninja")
ms = VirtualBuildEnv(self)
libsoc_adapter_dep = self.dependencies.get(
"libsoc_adapter"
)
libsoc_adapter_version = (
str(libsoc_adapter_dep.ref.version)
if libsoc_adapter_dep is not None
else "0.0.0"
)
jtag_sec_mode_bcal = (
libsoc_adapter_dep is not None
and Version(libsoc_adapter_version)
>= Version("1.130.60")
)
tc.project_options[
"jtag_sec_mode_bcal"
] = jtag_sec_mode_bcal
self.output.info(
"JTAG SecModeType BCAL adapter: "
f"{'enabled' if jtag_sec_mode_bcal else 'disabled'}, "
f"libsoc_adapter={libsoc_adapter_version}, "
"minimum=1.130.60"
)
if self.options.asan:
tc.extra_cxxflags.append("-fsanitize=address")
tc.extra_cxxflags.append("-fno-omit-frame-pointer")
tc.extra_ldflags.append("-fsanitize=address")
tc.project_options["strip_binaries"] = "false"
tc.extra_ldflags.append("-lstdc++fs")
tc.extra_cxxflags.append("-Wno-unused-variable")
tc.extra_cxxflags.append("-Wno-unused-parameter")
tc.extra_cxxflags.append("-Wno-sign-compare")
tc.extra_cxxflags.append("-fpermissive")
tc.extra_cxxflags.append("-Wno-pedantic")
tc.extra_cxxflags.append("-fno-strict-aliasing")
tc.extra_cxxflags.append("-Wno-deprecated-copy")
pkg_path = ms.vars().get("PKG_CONFIG_PATH")
if pkg_path:
tc.pkg_config_path += ":" + pkg_path
os.environ["PKG_CONFIG"] = "/usr/bin/pkg-config"
if self.settings.arch == "armv8" or self.settings.arch == "x86_64":
tc.project_options["libdir"] = 'usr/lib64'
else:
tc.project_options["libdir"] = 'usr/lib'
tc.project_options["enable_conan_compile"] = "true"
if self.options.test:
tc.project_options["tests"] = "true"
else:
tc.project_options["tests"] = "false"
tc.project_options["meson_build"] = "false"
if self.options.unidev:
tc.project_options["unidev"] = "true"
else:
tc.project_options["unidev"] = "false"
if self.options.chipv2_enable:
tc.project_options["chipv2_enable"] = "true"
else:
tc.project_options["chipv2_enable"] = "false"
if self.options.feature_ssu:
tc.project_options["feature_ssu"] = "true"
else:
tc.project_options["feature_ssu"] = "false"
if self.options.feature_rs485:
tc.project_options["feature_rs485"] = "true"
else:
tc.project_options["feature_rs485"] = "false"
if self.options.feature_mellanox:
tc.project_options["feature_mellanox"] = "true"
else:
tc.project_options["feature_mellanox"] = "false"
if os.environ.get("CONAN_UNITY", "1") == "1":
tc.project_options["unity"] = "on"
tc.project_options["unity_size"] = os.environ.get("CONAN_UNITY_SIZE", "2")
if self.options.asan:
tc.project_options["fast_debug_info"] = "false"
else:
tc.project_options["fast_debug_info"] = "true"
tc.project_options["use_mold"] = "true"
tc.project_options["inlines_hidden"] = "true"
tc.project_options["use_icf"] = "true"
if self.settings.arch in ["armv8"]:
pkg_config_path = ms.vars().get("PKG_CONFIG_PATH")
if pkg_config_path:
tc.properties["pkg_config_libdir"] = pkg_config_path.split(":")
if self.settings.build_type == "Debug":
tc.extra_cxxflags.append("-Os")
tc.extra_cflags.append("-Os")
if self.options.asan:
tc.extra_cxxflags.append("-fsanitize=address")
tc.extra_cxxflags.append("-fsanitize-recover=address")
tc.extra_cxxflags.append("-fno-omit-frame-pointer")
tc.extra_cxxflags.append("-fno-stack-protector")
tc.extra_cxxflags.append("-O1")
tc.extra_cflags.append("-O1")
tc.extra_ldflags.append("-fsanitize=address")
tc.generate()
self._apply_parallelism()
def _clamp_build_jobs(self, jobs):
"""并发数至少为 1,不设固定硬上限,由内存/CPU 预算决定。"""
return 1 if jobs < 1 else jobs
def _apply_parallelism(self, jobs=None):
"""把算出的并发写进 Conan conf 与 meson test 环境,堵住 -j nproc 漏口。"""
if jobs is None:
jobs = getattr(self, "_cached_build_jobs", None)
if jobs is None:
jobs = self._calculate_build_jobs()
self._cached_build_jobs = jobs
try:
self.conf.define("tools.build:jobs", jobs)
except Exception:
pass
os.environ["MESON_TESTTHREADS"] = str(jobs)
return jobs
def _cgroup_memory_limit_gb(self):
"""读取 cgroup 内存上限(GiB)。无限制或读失败返回 0。"""
for path in ("/sys/fs/cgroup/memory.max",
"/sys/fs/cgroup/memory/memory.limit_in_bytes"):
try:
raw = open(path).read().strip()
if not raw or raw == "max":
continue
nbytes = int(raw)
if nbytes <= 0:
continue
gb = nbytes // 1024 // 1024 // 1024
if 0 < gb < 1024:
return gb
except (EnvironmentError, ValueError):
continue
return 0
def _cgroup_cpu_quota(self):
"""读取 cgroup CFS CPU 配额(核数)。无限制或读失败返回 0。"""
try:
if os.path.exists("/sys/fs/cgroup/cgroup.controllers"):
with open("/sys/fs/cgroup/cpu.max") as f:
parts = f.read().strip().split()
if parts and parts[0] != "max":
quota = int(parts[0])
period = int(parts[1]) if len(parts) > 1 else 100_000
if quota > 0 and period > 0:
return (quota + period - 1) // period
else:
with open("/sys/fs/cgroup/cpu/cpu.cfs_quota_us") as f:
quota = int(f.read().strip())
with open("/sys/fs/cgroup/cpu/cpu.cfs_period_us") as f:
period = int(f.read().strip())
if quota > 0 and period > 0:
return (quota + period - 1) // period
except (EnvironmentError, TypeError, ValueError):
pass
return 0
def _calculate_build_jobs(self):
"""
计算 bingo build / meson compile / meson test 并发数。
场景策略:
- BUILD_JOBS:强制覆盖,至少为 1
- 一律走内存与 CPU 取 min。不再把 CI / BUILD_NUMBER 当成「铺满 nproc」:
产品 bingo 和 Jenkins 常带 BUILD_NUMBER,本容器会被误判成 -j64。
独享 CI 节点请显式 BUILD_JOBS=N,或把节点上错误的 cpu.max 配正确。
内存同时看 MemAvailable 和 cgroup memory.max。
CPU 认 cpuset;若有 cpu.max CFS 配额,按配额铺满(8 核 → -j8),不超额。
"""
import multiprocessing
env_jobs = os.environ.get("BUILD_JOBS")
if env_jobs:
try:
return self._clamp_build_jobs(int(env_jobs))
except ValueError:
pass
physical_cores = multiprocessing.cpu_count()
cpu_cores = physical_cores
try:
with open("/sys/fs/cgroup/cpuset.cpus.effective") as f:
cpuset_str = f.read().strip()
if cpuset_str:
cpuset_count = 0
for part in cpuset_str.split(","):
if "-" in part:
start, end = part.split("-", 1)
cpuset_count += int(end) - int(start) + 1
else:
cpuset_count += 1
if 0 < cpuset_count < cpu_cores:
cpu_cores = cpuset_count
except (EnvironmentError, TypeError, ValueError):
pass
available_mem_gb = 0
swap_total_gb = 0
try:
with open("/proc/meminfo") as f:
for line in f:
if line.startswith("MemAvailable:"):
available_mem_gb = int(line.split()[1]) // 1024 // 1024
elif line.startswith("SwapTotal:"):
swap_total_gb = int(line.split()[1]) // 1024 // 1024
except (EnvironmentError, ValueError):
pass
mem_budget_gb = os.environ.get("SMART_BUILD_MEM_BUDGET_GB")
if mem_budget_gb:
try:
mem_budget_gb = int(mem_budget_gb)
except ValueError:
mem_budget_gb = min(available_mem_gb, 40)
else:
mem_budget_gb = min(available_mem_gb, 40)
cgroup_mem_gb = self._cgroup_memory_limit_gb()
if 0 < cgroup_mem_gb < mem_budget_gb:
mem_budget_gb = cgroup_mem_gb
mem_per_job_mb = os.environ.get("SMART_BUILD_MEM_PER_JOB_MB", "1200")
try:
mem_per_job_mb = int(mem_per_job_mb)
except ValueError:
mem_per_job_mb = 1200
mem_based_jobs = (mem_budget_gb * 1024) // mem_per_job_mb
if swap_total_gb == 0:
mem_based_jobs = mem_based_jobs * 9 // 10
cpu_quota = self._cgroup_cpu_quota()
if cpu_quota > 0:
cpu_based_jobs = cpu_quota
if cpu_based_jobs > cpu_cores:
cpu_based_jobs = cpu_cores
else:
cpu_based_jobs = cpu_cores
jobs = mem_based_jobs if mem_based_jobs < cpu_based_jobs else cpu_based_jobs
jobs = self._clamp_build_jobs(jobs)
print(f"[INFO] build jobs={jobs} (mem_based={mem_based_jobs}, "
f"cpu_based={cpu_based_jobs}, cpu_quota={cpu_quota or 'unlimited'}, "
f"mem_budget_gb={mem_budget_gb})")
return jobs
def _calculate_test_jobs(self):
"""meson test 并发:SMART_BUILD_TEST_JOBS 可单独覆盖,否则与编译同一套算法。"""
env_jobs = os.environ.get("SMART_BUILD_TEST_JOBS")
if env_jobs:
try:
return self._apply_parallelism(self._clamp_build_jobs(int(env_jobs)))
except ValueError:
pass
return self._apply_parallelism()
def build(self):
meson = Meson(self)
buildfile = os.path.join(self.build_folder, "build.ninja")
if not os.path.exists(buildfile):
meson.configure()
jobs = self._apply_parallelism()
last_error = None
for i in range(10):
try:
self.run(f'meson compile -C "{self.build_folder}" -j{jobs}')
last_error = None
break
except Exception as e:
last_error = e
print(f"[WARNING] 编译失败: {e}")
continue
if last_error is not None:
raise last_error
def test(self):
import glob
import shlex
import subprocess
if self.options.asan:
source_folder = os.environ.get("PWD", "") or self.source_folder
asan_log_dir = os.path.join(source_folder, "temp", "asan")
os.environ["ASAN_OPTIONS"] = f"log_path={asan_log_dir}/asan.log:detect_leaks=1:halt_on_error=0"
lsan_suppressions_path = f"{asan_log_dir}/lsan_suppressions.txt"
if os.path.exists(lsan_suppressions_path):
os.environ["LSAN_OPTIONS"] = f"suppressions={lsan_suppressions_path}"
runtime_lib_dirs = [
os.path.join(self.build_folder, "usr/lib64"),
os.path.join(self.build_folder, "opt/bmc/drivers"),
os.path.join(self.build_folder, "gen"),
]
for pc_file in glob.glob(os.path.join(self.build_folder, "generators", "*.pc")):
prefix = ""
libdir = ""
with open(pc_file, encoding="utf-8") as file:
for line in file:
line = line.strip()
if line.startswith("prefix="):
prefix = line.split("=", 1)[1]
elif line.startswith("libdir="):
libdir = line.split("=", 1)[1]
if libdir:
libdir = libdir.replace("${prefix}", prefix)
if libdir not in runtime_lib_dirs:
runtime_lib_dirs.append(libdir)
old_ld_path = os.environ.get("LD_LIBRARY_PATH", "")
os.environ["LD_LIBRARY_PATH"] = ":".join(runtime_lib_dirs + ([old_ld_path] if old_ld_path else []))
runtime_ld_path = ":".join(runtime_lib_dirs)
install_cmd = [
"meson",
"install",
"-C",
self.build_folder,
"--no-rebuild",
"--destdir",
self.build_folder,
]
self.output.info(f"准备 Meson 测试运行时产物: {' '.join(install_cmd)}")
install_result = subprocess.run(install_cmd, capture_output=False, text=True)
if install_result.returncode != 0:
raise Exception("Meson 测试运行时产物准备失败")
inc_dir = os.path.join(self.build_folder, "include")
if os.path.isdir(inc_dir):
shutil.rmtree(inc_dir)
wrapper = os.path.join(self.build_folder, "meson_test_runtime_wrapper.sh")
with open(wrapper, "w", encoding="utf-8") as file:
file.write("#!/bin/sh\n")
file.write(f"export LD_LIBRARY_PATH={shlex.quote(runtime_ld_path)}:$LD_LIBRARY_PATH\n")
file.write('exec "$@"\n')
os.chmod(wrapper, 0o755)
cmd = [
"meson",
"test",
"-C",
self.build_folder,
"-v",
"--no-rebuild",
"--wrapper",
wrapper,
]
filter_arg = os.environ.get("MCLI_TEST_FILTER")
if filter_arg:
cmd.extend(["--suite", filter_arg])
test_args_str = os.environ.get("MCLI_TEST_ARGS")
extra_args = shlex.split(test_args_str) if test_args_str else []
has_num_proc = any(
arg == "--num-processes" or arg.startswith("--num-processes=")
or arg == "-j" or (arg.startswith("-j") and arg[2:].isdigit())
for arg in extra_args
)
if not has_num_proc:
test_jobs = self._calculate_test_jobs()
cmd.extend(["--num-processes", str(test_jobs)])
cmd.extend(extra_args)
self.output.info(f"运行 Meson 测试: {' '.join(cmd)}")
result = subprocess.run(cmd, capture_output=False, text=True)
if result.returncode != 0:
raise Exception("Meson 测试失败")
def package(self):
self._apply_parallelism()
self.run(f"meson install --no-rebuild -C {self.build_folder} --destdir {self.package_folder}")
copy(self, "permissions.ini", src=self.source_folder, dst=self.package_folder)
copy(self, "model.json", src=os.path.join(self.source_folder, "mds"),
dst=os.path.join(self.package_folder, "include/mds"))
copy(self, "service.json", src=os.path.join(self.source_folder, "mds"),
dst=os.path.join(self.package_folder, "include/mds"))
copy(self, "*", src=os.path.join(self.source_folder, "include"),
dst=os.path.join(self.package_folder, "include"))
if self.options.test and os.getenv('TRANSTOBIN') is None:
return
copy(self, "*.sr", src=os.path.join(self.source_folder, "./drivers"),
dst=os.path.join(self.package_folder, "include/drivers"))
copy(self, "customization.py", src=os.path.join(self.source_folder, "./include"),
dst=os.path.join(self.package_folder, "include"))
os.chdir(self.package_folder)
if self.settings.build_type == "Debug" and not self.options.asan:
self._strip_debug_files()
def _strip_debug_files(self):
"""对Debug模式编译生成的文件进行strip处理"""
import subprocess
import stat
if self.settings.arch == "armv8":
strip_tool = "aarch64-target-linux-gnu-strip"
elif self.settings.arch == "x86_64":
strip_tool = "strip"
else:
strip_tool = "strip"
lib_dirs = []
if self.settings.arch == "armv8" or self.settings.arch == "x86_64":
lib_dirs.append("usr/lib64")
else:
lib_dirs.append("usr/lib")
bin_dirs = ["opt/bmc/apps/component_drivers", "opt/bmc/drivers"]
all_dirs = lib_dirs + bin_dirs
for directory in all_dirs:
dir_path = os.path.join(self.package_folder, directory)
if not os.path.exists(dir_path):
continue
for root, dirs, files in os.walk(dir_path):
for file in files:
file_path = os.path.join(root, file)
try:
if os.path.isfile(file_path) and not os.path.islink(file_path):
result = subprocess.run(["file", file_path],
capture_output=True, text=True, timeout=10)
if result.returncode == 0:
file_type = result.stdout.lower()
if ("executable" in file_type or "current ar archive" in file_type or
"shared object" in file_type or
"dynamically linked" in file_type):
self.run(f"{strip_tool} -s {file_path}")
except Exception as e:
print(f"Warning: Error processing {file_path}: {e}")
continue