* Always run "dotnet pack", regardless of csharp toggle opt * Run "dotnet publish" if csharp toggled on
181 lines
6.2 KiB
Python
181 lines
6.2 KiB
Python
import argparse
|
|
import os
|
|
import shutil
|
|
import subprocess
|
|
import sys
|
|
|
|
from core.argparse_utils import add_toggle_opt
|
|
from core.dotnet_utils import DotnetCommand
|
|
from core.file_utils import SparkPaths
|
|
from core.iter_utils import at_bounded
|
|
|
|
|
|
def _get_arg_parser():
|
|
parser = argparse.ArgumentParser(
|
|
description="Pack the Spark Sdk (CSharp)"
|
|
)
|
|
parser.add_argument(
|
|
"--configuration",
|
|
metavar="debug|release",
|
|
help="The build configuration",
|
|
)
|
|
parser.add_argument(
|
|
"--cmake-jobs",
|
|
type=int,
|
|
help="The number of cmake parallel jobs",
|
|
)
|
|
parser.add_argument(
|
|
"--clean",
|
|
action="store_true",
|
|
help="Perform a clean build (remove artifacts from previous build)",
|
|
)
|
|
parser.add_argument(
|
|
"--spark-version",
|
|
help="The version identifier for the nuget packages (by default, uses git to generate semantic version number)"
|
|
)
|
|
parser.add_argument("--pack-out-dir", help="Output dir for .nupkg files")
|
|
parser.add_argument("--native-linux-lib", help="The Spark native linux library to pack (.so)")
|
|
parser.add_argument("--native-windows-lib", help="The Spark native linux library to pack (.dll)")
|
|
add_toggle_opt(parser, "cpp", help="Build c++ libs")
|
|
add_toggle_opt(parser, "cs", help="Build c# libs")
|
|
parser.add_argument(
|
|
"--verbosity",
|
|
metavar="{0-5}",
|
|
choices=range(0, 6),
|
|
type=int,
|
|
help="The output verbosity level",
|
|
)
|
|
parser.add_argument(
|
|
"--dry-run",
|
|
action="store_true",
|
|
help="Preview the build commands without running them",
|
|
)
|
|
parser.set_defaults(
|
|
configuration="release",
|
|
clean=False,
|
|
cpp=True,
|
|
cs=True,
|
|
verbosity=1,
|
|
spark_version=None,
|
|
)
|
|
return parser
|
|
|
|
|
|
def _dotnet_verbosity(level):
|
|
names = ["quiet", "minimal", "normal", "detailed", "diagnostic"]
|
|
return at_bounded(names, level)
|
|
|
|
|
|
def _cmake_verbosity(level):
|
|
# Skip 'WARNING' and 'NOTICE' levels, since the default CMake verbosity,
|
|
# 'STATUS', doesn't produce that much output. This also better normalizes
|
|
# numeric representation of verbosity w/ dotnet, which only has 5 levels.
|
|
names = [
|
|
"ERROR",
|
|
# 'WARNING',
|
|
# 'NOTICE',
|
|
"STATUS",
|
|
"VERBOSE",
|
|
"DEBUG",
|
|
"TRACE",
|
|
]
|
|
return at_bounded(names, level)
|
|
|
|
|
|
def _cmake_preset():
|
|
match sys.platform:
|
|
case "win32":
|
|
return "spark-windows"
|
|
case "linux":
|
|
return "spark-linux"
|
|
case _:
|
|
raise ValueError(f"Unsupported platform {sys.platform}")
|
|
|
|
|
|
def _main():
|
|
parser = _get_arg_parser()
|
|
args = parser.parse_args()
|
|
|
|
def run(cmd):
|
|
print(cmd)
|
|
if args.dry_run:
|
|
return
|
|
subprocess.run(cmd, shell=True).check_returncode()
|
|
|
|
def run_cp(src, dst):
|
|
print(f"[pseudo shell] cp {src} {dst}")
|
|
if args.dry_run:
|
|
return
|
|
os.makedirs(os.path.dirname(dst), exist_ok=True)
|
|
if os.path.exists(src) and os.path.isfile(src):
|
|
shutil.copyfile(src, dst)
|
|
else:
|
|
shutil.copytree(src, dst)
|
|
|
|
native_linux_lib = args.native_linux_lib
|
|
native_windows_lib = args.native_windows_lib
|
|
if native_linux_lib and not os.path.exists(native_linux_lib):
|
|
raise ValueError(f"Native linux lib not found '{native_linux_lib}'")
|
|
if native_windows_lib and not os.path.exists(native_windows_lib):
|
|
raise ValueError(f"Native windows lib not found '{native_windows_lib}'")
|
|
build_cpp = args.cpp
|
|
if build_cpp:
|
|
if sys.platform == "win32":
|
|
build_cpp = not native_windows_lib
|
|
elif sys.platform == "linux":
|
|
build_cpp = not native_linux_lib
|
|
cmake_preset = _cmake_preset()
|
|
cmake_config = args.configuration.title()
|
|
cmake_jobs = args.cmake_jobs
|
|
cmake_verbosity = _cmake_verbosity(args.verbosity)
|
|
dotnet_config = args.configuration.title()
|
|
dotnet_verbosity = _dotnet_verbosity(args.verbosity)
|
|
dotnet_publish_dir = f"build/{dotnet_config}/bin/net8.0/publish"
|
|
spark_version = args.spark_version
|
|
if not spark_version:
|
|
from core.git_utils import git_head_version
|
|
spark_version = git_head_version()
|
|
os.chdir(SparkPaths.root())
|
|
sln = "Bts.Spark.Sdk.sln"
|
|
if args.clean:
|
|
if build_cpp:
|
|
run(f"cmake --build build/{cmake_preset} --target clean")
|
|
if args.cs:
|
|
run(f"dotnet clean {sln} -c {dotnet_config} -v {dotnet_verbosity}")
|
|
if build_cpp:
|
|
run(f"cmake --preset {cmake_preset} -DCMAKE_MESSAGE_LOG_LEVEL={cmake_verbosity}")
|
|
cmake_build_cmd = f"cmake --build build/{cmake_preset} --config {cmake_config}"
|
|
if cmake_jobs:
|
|
cmake_build_cmd += f" -j {cmake_jobs}"
|
|
run(cmake_build_cmd)
|
|
if native_windows_lib:
|
|
run_cp(native_windows_lib, f"{dotnet_publish_dir}/runtimes/win-x64/native/{native_windows_lib}")
|
|
if native_linux_lib:
|
|
run_cp(native_linux_lib, f"{dotnet_publish_dir}/runtimes/linux-x64/native/{native_linux_lib}")
|
|
if args.cs:
|
|
run(f"dotnet publish {sln} -c {dotnet_config} -v {dotnet_verbosity} -f net8.0 --sc -p:SparkVersion={spark_version} -p:UseProjectRefs=true")
|
|
pack_out_dir = args.pack_out_dir or f'"build/{dotnet_config}/bin"'
|
|
pack_props = {
|
|
"SparkVersion": spark_version,
|
|
"UseProjectRefs": "false",
|
|
"RestoreSources": pack_out_dir,
|
|
}
|
|
pack_opts = { "-c": dotnet_config, "-v": dotnet_verbosity, "-o": pack_out_dir }
|
|
if native_windows_lib:
|
|
pack_props["SparkNativeWindowsLib"] = native_windows_lib
|
|
if native_linux_lib:
|
|
pack_props["SparkNativeLinuxLib"] = native_linux_lib
|
|
pack_cmd_base = DotnetCommand("pack").add_opts(pack_opts).add_props(pack_props)
|
|
run(pack_cmd_base.clone().add_positional("src/cs/Bts.Spark.Core").cmd)
|
|
run(pack_cmd_base.clone().add_positional("src/cs/Bts.Extensions.Hosting").cmd)
|
|
run(pack_cmd_base.clone().add_positional("src/cs/Bts.Spark.Api").cmd)
|
|
run(pack_cmd_base.clone().add_positional("src/cs/Bts.Spark.Sdk").cmd)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
try:
|
|
_main()
|
|
except Exception as e:
|
|
print(f"pack_sdk.py failed: {e}")
|
|
exit(1)
|