[antlir2] package.rpm learns about provide and how to build empty RPMs

Summary:
Use Antlir2-native funcitonality for producing an RPM as a package, then installing that RPM via a feature into a layer.

This is (eventually) needed for producing kernel-devel RPMs, so add the ability to augment Provides in the RPM and produce truly empty RPM files.

Test Plan:
Tests updated (and they pass), diff used in a WIP diff (D46280710) and built RPM inspected as:

  [rmikey@devbig040.lla2 ~/fbsource/fbcode (antlir2-wip3)]$ rpm -qilp --provides ../buck-out/v2/gen/fbcode/b7b9cdc2a40f3aaa/os_foundation/images/impl/v2/centos9/__kernel-devel-1.0-fb0.noarch--package__/image.rpm
  Name        : kernel-devel
  Epoch       : 0
  Version     : 1.0
  Release     : fb0
  Architecture: noarch
  Install Date: (not installed)
  Group       : Unspecified
  Size        : 0
  License     : Facebook Internal
  Signature   : (none)
  Source RPM  : kernel-devel-1.0-fb0.src.rpm
  Build Date  : Mon 05 Jun 2023 08:48:52 PDT
  Build Host  : subvol-compile-55ed9e9d00bd22e6
  Relocations : (not relocatable)
  Summary     : kernel-devel
  Description :

  kernel-devel = 0:1.0-fb0
  kernel-devel = 1.0
  (contains no files)
  [rmikey@devbig040.lla2 ~/fbsource/fbcode (antlir2-wip3)]$

Reviewed By: sergeyfd

Differential Revision: D46448257

fbshipit-source-id: 22b3042e4d19e5f336972ca5e1973761d8a16f91

antlir/antlir2/antlir2_package/antlir2_package_lib/src/lib.rs

@@ -92,6 +92,8 @@ pub enum Spec {
         summary: String,
         requires: Vec<String>,
         recommends: Vec<String>,
+        provides: Vec<String>,
+        empty: bool,
     },
     #[serde(rename = "squashfs")]
     SquashFs {

antlir/antlir2/antlir2_package/antlir2_packager/src/main.rs

@@ -362,21 +362,32 @@ fn main() -> Result<()> {
             license,
             requires,
             recommends,
+            provides,
+            empty,
         } => {
             let layer_abspath = layer
                 .canonicalize()
                 .context("failed to build absolute path to layer")?;
 
             let requires = requires
                 .into_iter()
-                .map(|req| format!("Requires: {req}"))
+                .map(|r| format!("Requires: {r}"))
                 .join("\n");
 
             let recommends = recommends
                 .into_iter()
-                .map(|req| format!("Recommends: {req}"))
+                .map(|r| format!("Recommends: {r}"))
                 .join("\n");
 
+            let provides = provides
+                .into_iter()
+                .map(|p| format!("Provides: {p}"))
+                .join("\n");
+
+            let comment_install = match empty {
+                true => "#",
+                _ => "",
+            };
             let mut spec = format!(
                 r#"Name: {name}
 Epoch: {epoch}
@@ -389,30 +400,36 @@ License: {license}
 
 {requires}
 {recommends}
+{provides}
 
 %description
 
-%install
-cp -rp "{layer}"/* %{{buildroot}}/
+{comment_install}%install
+{comment_install}cp -rp "{layer}"/* %{{buildroot}}/
 
 %files
 "#,
+                comment_install = comment_install,
                 layer = layer_abspath.display(),
                 requires = requires,
+                recommends = recommends,
+                provides = provides,
             );
-            for entry in walkdir::WalkDir::new(&layer) {
-                let entry = entry.context("while walking layer")?;
-                let relpath = Path::new("/").join(
-                    entry
-                        .path()
-                        .strip_prefix(&layer)
-                        .expect("must be under layer"),
-                );
-                if relpath == Path::new("/") {
-                    continue;
+            if !empty {
+                for entry in walkdir::WalkDir::new(&layer) {
+                    let entry = entry.context("while walking layer")?;
+                    let relpath = Path::new("/").join(
+                        entry
+                            .path()
+                            .strip_prefix(&layer)
+                            .expect("must be under layer"),
+                    );
+                    if relpath == Path::new("/") {
+                        continue;
+                    }
+                    spec.push_str(relpath.to_str().expect("our paths are always valid utf8"));
+                    spec.push('\n');
                 }
-                spec.push_str(relpath.to_str().expect("our paths are always valid utf8"));
-                spec.push('\n');
             }
             let mut rpm_spec_file =
                 NamedTempFile::new().context("failed to create tempfile for rpm spec")?;

antlir/antlir2/bzl/package/defs.bzl

@@ -179,14 +179,18 @@ def _rpm(
         summary: [str.type, None] = None,
         requires: [str.type] = [],
         recommends: [str.type] = [],
+        provides: [str.type] = [],
+        empty: bool.type = False,
         **kwargs):
     check_kwargs(kwargs)
 
     opts = {
         "arch": arch,
+        "empty": empty,
         "epoch": epoch,
         "license": license,
         "name": rpm_name,
+        "provides": provides,
         "recommends": recommends,
         "release": release,
         "requires": requires,

antlir/antlir2/test_images/rpms/repo/BUCK

@@ -31,6 +31,17 @@ image.layer(
     parent_layer = ":foobar.layer",
 )
 
+image.layer(
+    name = "for-empty.layer",
+    features = [
+        feature.install(
+            src = "//antlir:empty",
+            dst = "/empty-file-will-not-exist-in-rpm",
+        ),
+    ],
+    flavor = "//antlir/antlir2/test_images:test-image-flavor",
+)
+
 _GEN_VERSIONS = [
     1,
     2,
@@ -43,11 +54,23 @@ all_rpms = [
         parent_layer = ":foo.layer",
         recommends = ["foo-recommends-me == " + str(version)],
         release = "1",
+        requires = ["foo-empty == " + str(version)],
         version = str(version),
     )
     for version in _GEN_VERSIONS
 ]
 
+all_rpms.extend([
+    test_rpm(
+        name = "foo-empty",
+        empty = True,
+        parent_layer = ":for-empty.layer",
+        release = "1",
+        version = str(version),
+    )
+    for version in _GEN_VERSIONS
+])
+
 all_rpms.extend([
     test_rpm(
         name = "foobar",

antlir/antlir2/test_images/rpms/repo/defs.bzl

@@ -19,7 +19,8 @@ def test_rpm(
         requires: [str.type] = [],
         recommends: [str.type] = [],
         features: [types.antlir_feature] = [],
-        parent_layer: [str.type, None] = None) -> str.type:
+        parent_layer: [str.type, None] = None,
+        empty: bool.type = False) -> str.type:
     target_name = name + "-" + version + "-" + release + "." + arch
     image.layer(
         name = target_name + "--layer",
@@ -38,6 +39,7 @@ def test_rpm(
         license = license,
         requires = requires,
         recommends = recommends,
+        empty = empty,
         visibility = [":" + target_name],
     )
     rpm(

antlir/antlir2/testing/tests/foo-rpms.txt

@@ -1,3 +1,4 @@
 foo                  0 bytes required by foobar
+foo-empty            0 bytes required by foo
 foobar               0 bytes required by foobarbaz
 foobarbaz            0 bytes