def main():
args = BuildArgs()
console.configure(level=args.logging_level)
manifest = InputManifest.from_file(args.manifest)
if args.ref_manifest:
manifest = manifest.stable()
if os.path.exists(args.ref_manifest):
if manifest == InputManifest.from_path(args.ref_manifest):
logging.info(f"No changes since {args.ref_manifest}")
else:
logging.info(f"Updating {args.ref_manifest}")
manifest.to_file(args.ref_manifest)
else:
logging.info(f"Creating {args.ref_manifest}")
manifest.to_file(args.ref_manifest)
exit(0)
output_dir = BuildOutputDir(manifest.build.filename).dir
with TemporaryDirectory(keep=args.keep, chdir=True) as work_dir:
logging.info(f"Building in {work_dir.name}")
target = BuildTarget(
name=manifest.build.name,
version=manifest.build.version,
patches=manifest.build.patches,
snapshot=args.snapshot if args.snapshot is not None else manifest.build.snapshot,
output_dir=output_dir,
platform=args.platform or manifest.build.platform,
architecture=args.architecture or manifest.build.architecture,
)
build_recorder = BuildRecorder(target)
logging.info(f"Building {manifest.build.name} ({target.architecture}) into {target.output_dir}")
for component in manifest.components.select(focus=args.component, platform=target.platform):
logging.info(f"Building {component.name}")
builder = Builders.builder_from(component, target)
try:
builder.checkout(work_dir.name)
builder.build(build_recorder)
builder.export_artifacts(build_recorder)
except:
logging.error(f"Error building {component.name}, retry with: {args.component_command(component.name)}")
raise
build_recorder.write_manifest()
logging.info("Done.")
def test_components(self) -> None:
self.assertEqual(BuildArgs().components, ["foo", "bar"])
def test_component(self) -> None:
self.assertEqual(BuildArgs().components, ["xyz"])
def test_component_default(self) -> None:
self.assertIsNone(BuildArgs().components)
def test_verbose_true(self) -> None:
self.assertTrue(BuildArgs().logging_level, logging.DEBUG)
def test_script_path(self) -> None:
self.assertEqual(BuildArgs().script_path, self.BUILD_SH)
def test_distribution_default(self) -> None:
self.assertEqual(BuildArgs().distribution, "tar")
def test_architecture_default(self) -> None:
self.assertIsNone(BuildArgs().architecture)
def test_keep_true(self) -> None:
self.assertTrue(BuildArgs().keep)
def test_keep_default(self) -> None:
self.assertFalse(BuildArgs().keep)
def test_manifest(self) -> None:
self.assertEqual(BuildArgs().manifest.name,
TestBuildArgs.OPENSEARCH_MANIFEST)
def test_manifest_no_lock(self) -> None:
self.assertIsNone(BuildArgs().ref_manifest)
def test_manifest_lock(self) -> None:
self.assertEqual(BuildArgs().ref_manifest,
TestBuildArgs.OPENSEARCH_MANIFEST + ".lock")
def test_component_command_with_snapshot(self) -> None:
self.assertEqual(
BuildArgs().component_command("component"),
f"{self.BUILD_SH} {self.OPENSEARCH_MANIFEST} --component component --snapshot",
)
def test_platform_default(self) -> None:
self.assertIsNone(BuildArgs().platform)
def test_platform(self) -> None:
self.assertEqual(BuildArgs().platform, "linux")
def test_snapshot_default(self) -> None:
self.assertFalse(BuildArgs().snapshot)
def test_architecture(self) -> None:
self.assertEqual(BuildArgs().architecture, "arm64")
def test_snapshot_true(self) -> None:
self.assertTrue(BuildArgs().snapshot)
def test_distribution(self) -> None:
self.assertEqual(BuildArgs().distribution, "rpm")
def test_verbose_default(self) -> None:
self.assertEqual(BuildArgs().logging_level, logging.INFO)
