aboutsummaryrefslogtreecommitdiff
path: root/bpkg/system-package-manager-fedora.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'bpkg/system-package-manager-fedora.cxx')
-rw-r--r--bpkg/system-package-manager-fedora.cxx2355
1 files changed, 2342 insertions, 13 deletions
diff --git a/bpkg/system-package-manager-fedora.cxx b/bpkg/system-package-manager-fedora.cxx
index 8ea1866..6ace1d2 100644
--- a/bpkg/system-package-manager-fedora.cxx
+++ b/bpkg/system-package-manager-fedora.cxx
@@ -3,8 +3,12 @@
#include <bpkg/system-package-manager-fedora.hxx>
+#include <locale>
+
#include <bpkg/diagnostics.hxx>
+#include <bpkg/pkg-bindist-options.hxx>
+
using namespace butl;
namespace bpkg
@@ -158,7 +162,7 @@ namespace bpkg
// just <devel-stem>.
//
// Note that the order is important since for a mixed package we need to
- // end up with the -libs subpackage rather than with the base package as,
+ // end up with the -libs sub-package rather than with the base package as,
// for example, in the following case:
//
// sqlite-devel 3.36.0-3.fc35 ->
@@ -1141,7 +1145,8 @@ namespace bpkg
// Without explicit type, the best we can do in trying to detect whether
// this is a library is to check for the lib prefix. Libraries without
// the lib prefix and non-libraries with the lib prefix (both of which
- // we do not recomment) will have to provide a manual mapping.
+ // we do not recomment) will have to provide a manual mapping (or
+ // explicit type).
//
// Note that using the first (latest) available package as a source of
// type information seems like a reasonable choice.
@@ -1643,7 +1648,9 @@ namespace bpkg
if (p != string::npos)
sv.erase (0, p + 1);
- // @@ Do the same for Debian?
+ // Consider the first '~' character as a pre-release separator. Note
+ // that if there are more of them, then we will fail since '~' is an
+ // invalid character for bpkg version.
//
p = sv.find ('~');
if (p != string::npos)
@@ -1829,20 +1836,2342 @@ namespace bpkg
}
}
+ // Map non-system bpkg package to system package name(s) and version.
+ //
+ // This is used both to map the package being generated and its
+ // dependencies. What should we do with extras returned in package_status?
+ // We can't really generate any of them (which files would we place in
+ // them?) nor can we list them as dependencies (we don't know their system
+ // versions). So it feels like the only sensible choice is to ignore extras.
+ //
+ // In a sense, we have a parallel arrangement going on here: binary packages
+ // that we generate don't have extras (i.e., they include everything
+ // necessary in the "standard" packages from the main group) and when we
+ // punch a system dependency based on a non-system bpkg package, we assume
+ // it was generated by us and thus doesn't have any extras. Or, to put it
+ // another way, if you want the system dependency to refer to a "native"
+ // system package with extras you need to configure it as a system bpkg
+ // package.
+ //
+ // In fact, this extends to package names. For example, unless custom
+ // mapping is specified, we will generate libsqlite3 and libsqlite3-devel
+ // while native names are sqlite-libs and sqlite-devel. While this duality
+ // is not ideal, presumably we will normally only be producing our binary
+ // packages if there are no suitable native packages. And for a few
+ // exceptions (e.g., our package is "better" in some way, such as configured
+ // differently or fixes a critical bug), we will just have to provide
+ // appropriate manual mapping that makes sure the names match (the extras is
+ // still a potential problem though -- we will only have them as
+ // dependencies if we build against a native system package; maybe we can
+ // add them manually with an option).
+ //
+ package_status system_package_manager_fedora::
+ map_package (const package_name& pn,
+ const version& pv,
+ const available_packages& aps) const
+ {
+ // We should only have one available package corresponding to this package
+ // name/version.
+ //
+ assert (aps.size () == 1);
+
+ const shared_ptr<available_package>& ap (aps.front ().first);
+ const lazy_shared_ptr<repository_fragment>& rf (aps.front ().second);
+
+ // Without explicit type, the best we can do in trying to detect whether
+ // this is a library is to check for the lib prefix. Libraries without the
+ // lib prefix and non-libraries with the lib prefix (both of which we do
+ // not recomment) will have to provide a manual mapping (or explicit
+ // type).
+ //
+ const string& pt (ap->effective_type ());
+
+ strings ns (system_package_names (aps,
+ os_release.name_id,
+ os_release.version_id,
+ os_release.like_ids,
+ false /* native */));
+ package_status r;
+ if (ns.empty ())
+ {
+ // Automatically translate our package name similar to the consumption
+ // case above. Except here we don't attempt to deduce main from -devel
+ // or fallback to the project name, naturally.
+ //
+ const string& n (pn.string ());
+
+ if (pt == "lib")
+ r = package_status (n, n + "-devel");
+ else
+ r = package_status (n);
+ }
+ else
+ {
+ // Even though we only pass one available package, we may still end up
+ // with multiple mappings. In this case we take the first, per the
+ // documentation.
+ //
+ r = parse_name_value (pt,
+ ns.front (),
+ false /* need_doc */,
+ false /* need_debuginfo */,
+ false /* need_debugsource */);
+
+ // If this is -devel without main, then derive main by stripping the
+ // -devel suffix. This feels tighter than just using the bpkg package
+ // name.
+ //
+ if (r.main.empty ())
+ {
+ assert (!r.devel.empty ());
+ r.main.assign (r.devel, 0, r.devel.size () - 6);
+ }
+ }
+
+ // Map the version.
+ //
+ // To recap, a Fedora package version has the following form:
+ //
+ // [<epoch>:]<version>-<release>
+ //
+ // Where <release> has the following form:
+ //
+ // <release-number>[.<distribution-tag>]
+ //
+ // For details on the ordering semantics, see the Fedora Versioning
+ // Guidelines. While overall unsurprising, the only notable exceptions are
+ // `~`, which sorts before anything else and is commonly used for upstream
+ // pre-releases, and '^', which sorts after anything else and is
+ // supposedly used for upstream post-release snapshots. For example,
+ // 0.1.0~alpha.1-1.fc35 sorts earlier than 0.1.0-1.fc35.
+ //
+ // Ok, so how do we map our version to that? To recap, the bpkg version
+ // has the following form:
+ //
+ // [+<epoch>-]<upstream>[-<prerel>][+<revision>]
+ //
+ // Let's start with the case where neither distribution nor upstream
+ // version is specified and we need to derive everything from the bpkg
+ // version.
+ //
+ // <epoch>
+ //
+ // On one hand, if we keep the epoch, it won't necessarily match
+ // Fedora's native package epoch. But on the other it will allow our
+ // binary packages from different epochs to co-exist. Seeing that this
+ // can be easily overridden with a custom distribution version, let's
+ // keep it.
+ //
+ // Note that while the Fedora start/default epoch is 0, ours is 1 (we
+ // use the 0 epoch for stub packages). So we will need to shift this
+ // value range.
+ //
+ //
+ // <upstream>[-<prerel>]
+ //
+ // Our upstream version maps naturally to Fedora's <version>. That is,
+ // our upstream version format/semantics is a subset of Fedora's
+ // <version>.
+ //
+ // If this is a pre-release, then we could fail (that is, don't allow
+ // pre-releases) but then we won't be able to test on pre-release
+ // packages, for example, to make sure the name mapping is correct.
+ // Plus sometimes it's useful to publish pre-releases. We could ignore
+ // it, but then such packages will be indistinguishable from each other
+ // and the final release, which is not ideal. On the other hand, Fedora
+ // has the mechanism (`~`) which is essentially meant for this, so let's
+ // use it. We will use <prerel> as is since its format is the same as
+ // <upstream> and thus should map naturally.
+ //
+ //
+ // <revision>
+ //
+ // Similar to epoch, our revision won't necessarily match Fedora's
+ // native package release number. But on the other hand it will allow us
+ // to establish a correspondence between source and binary packages.
+ // Plus, upgrades between binary package releases will be handled
+ // naturally. Also note that the revision is mandatory in Fedora.
+ // Seeing that we allow overriding the releases with a custom
+ // distribution version (see below), let's use it.
+ //
+ // Note that the Fedora start release number is 1 and our revision is
+ // 0. So we will need to shift this value range.
+ //
+ // Another related question is whether we should do anything about the
+ // distribution tag (.fc35, .el8, etc). Given that the use of hardcoded
+ // distribution tags in RPM spec files is strongly discouraged we will
+ // just rely on the standard approach to include the appropriate tag
+ // (while allowing the user to redefine it with an option). Note that
+ // the distribution tag is normally specified for the Release and
+ // Requires directives using the %{?dist} macro expansion and can be
+ // left unspecified for the Requires directive. For example:
+ //
+ // Name: curl
+ // Version: 7.87.0
+ // Release: 1%{?dist}
+ // Requires: libcurl%{?_isa} >= %{version}-%{release}
+ // %global libpsl_version 1.2.3
+ // Requires: libpsl%{?_isa} >= %{libpsl_version}
+ //
+ // The next case to consider is when we have the upstream version
+ // (upstream-version manifest value). After some rumination it feels
+ // correct to use it in place of the <epoch>-<upstream> components in the
+ // above mapping (upstream version itself cannot have epoch). In other
+ // words, we will add the pre-release and revision components from the
+ // bpkg version. If this is not the desired semantics, then it can always
+ // be overrided with the distribution version.
+ //
+ // Finally, we have the distribution version. The <epoch> and <version>
+ // components are straightforward: they should be specified by the
+ // distribution version as required. This leaves pre-release and
+ // release. It feels like in most cases we would want these copied over
+ // from the bpkg version automatically -- it's too tedious and error-
+ // prone to maintain them manually. However, we want the user to have the
+ // full override ability. So instead, if empty release is specified, as in
+ // 1.2.3-, then we automatically add bpkg revision. Similarly, if empty
+ // pre-release is specified, as in 1.2.3~, then we add bpkg pre-release.
+ // To add both automatically, we would specify 1.2.3~- (other combinations
+ // are 1.2.3~b.1- and 1.2.3~-1). If specified, the release must not
+ // contain the distribution tag, since it is deduced automatically using
+ // the %{?dist} macro expansion if required. Also, since the release
+ // component is mandatory in Fedora, if it is omitted together with the
+ // separating dash we will add the release 1 automatically.
+ //
+ // Note also that per the RPM spec file format documentation neither
+ // version nor release components may contain `:` or `-`. Note that the
+ // bpkg upstream version may not contain either.
+ //
+ string& sv (r.system_version);
+
+ if (optional<string> ov = system_package_version (ap,
+ rf,
+ os_release.name_id,
+ os_release.version_id,
+ os_release.like_ids))
+ {
+ string& dv (*ov);
+ size_t n (dv.size ());
+
+ // Find the package release and upstream pre-release positions, if any.
+ //
+ size_t rp (dv.rfind ('-'));
+ size_t pp (dv.rfind ('~', rp));
+
+ // Copy over the [<epoch>:]<version> part.
+ //
+ sv.assign (dv, 0, pp < rp ? pp : rp);
+
+ // Add pre-release copying over the bpkg version value if empty.
+ //
+ if (pp != string::npos)
+ {
+ if (size_t pn = (rp != string::npos ? rp : n) - (pp + 1))
+ {
+ sv.append (dv, pp, pn + 1);
+ }
+ else
+ {
+ if (pv.release)
+ {
+ assert (!pv.release->empty ()); // Cannot be earliest special.
+ sv += '~';
+ sv += *pv.release;
+ }
+ }
+ }
+
+ // Add release copying over the bpkg version revision if empty.
+ //
+ if (rp != string::npos)
+ {
+ if (size_t rn = n - (rp + 1))
+ {
+ sv.append (dv, rp, rn + 1);
+ }
+ else
+ {
+ sv += '-';
+ sv += to_string (pv.revision ? *pv.revision + 1 : 1);
+ }
+ }
+ else
+ sv += "-1"; // Default to 1 since the release is mandatory.
+ }
+ else
+ {
+ if (ap->upstream_version)
+ {
+ const string& uv (*ap->upstream_version);
+
+ // Make sure the upstream version doesn't contain ':' and '-'
+ // characters since they are not allowed in the <version> component
+ // (see the RPM spec file format documentation for details).
+ //
+ // Note that this verification is not exhaustive and here we only make
+ // sure that these characters are only used to separate the version
+ // components.
+ //
+ size_t p (uv.find (":-"));
+ if (p != string::npos)
+ fail << "'" << uv[p] << "' character in upstream-version manifest "
+ << "value " << uv << " of package " << pn << ' '
+ << ap->version <<
+ info << "consider specifying explicit " << os_release.name_id
+ << " version mapping in " << pn << " package manifest";
+
+ sv += uv;
+ }
+ else
+ {
+ // Add epoch unless maps to 0.
+ //
+ assert (pv.epoch != 0); // Cannot be a stub.
+ if (pv.epoch != 1)
+ {
+ sv = to_string (pv.epoch - 1);
+ sv += ':';
+ }
+
+ sv += pv.upstream;
+ }
+
+ // Add pre-release.
+ //
+ if (pv.release)
+ {
+ assert (!pv.release->empty ()); // Cannot be earliest special.
+ sv += '~';
+ sv += *pv.release;
+ }
+
+ // Add revision.
+ //
+ sv += '-';
+ sv += to_string (pv.revision ? *pv.revision + 1 : 1);
+ }
+
+ return r;
+ }
+
+ // Evaluate the specified expressions expanding the contained macros by
+ // executing `rpm --eval <expr1> --eval <expr2>...` and return the list of
+ // the resulting lines read from the process stdout. Note that an expression
+ // may potentially end up with multiple lines which the caller is expected
+ // to deal with (ensure fixed number of lines, eval only one expression,
+ // etc).
+ //
+ strings system_package_manager_fedora::
+ rpm_eval (const cstrings& opts, const cstrings& expressions)
+ {
+ strings r;
+
+ if (expressions.empty ())
+ return r;
+
+ cstrings args;
+ args.reserve (2 + opts.size () + expressions.size () * 2);
+
+ args.push_back ("rpm");
+
+ for (const char* o: opts)
+ args.push_back (o);
+
+ for (const char* e: expressions)
+ {
+ args.push_back ("--eval");
+ args.push_back (e);
+ }
+
+ args.push_back (nullptr);
+
+ try
+ {
+ process_path pp (process::path_search (args[0]));
+ process_env pe (pp);
+
+ if (verb >= 3)
+ print_process (pe, args);
+
+ process pr (pp, args, -2 /* stdin */, -1 /* stdout */, 2);
+
+ try
+ {
+ ifdstream is (move (pr.in_ofd), fdstream_mode::skip, ifdstream::badbit);
+
+ // The number of lines is normally equal to or greater than the number
+ // of expressions.
+ //
+ r.reserve (expressions.size ());
+
+ for (string l; !eof (getline (is, l)); )
+ r.push_back (move (l));
+
+ is.close ();
+ }
+ catch (const io_error& e)
+ {
+ if (pr.wait ())
+ fail << "unable to read " << args[0] << " --eval output: " << e;
+
+ // Fall through.
+ }
+
+ if (!pr.wait ())
+ {
+ diag_record dr (fail);
+ dr << args[0] << " exited with non-zero code";
+
+ if (verb < 3)
+ {
+ dr << info << "command line: ";
+ print_process (dr, pe, args);
+ }
+ }
+ }
+ catch (const process_error& e)
+ {
+ error << "unable to execute " << args[0] << ": " << e;
+
+ if (e.child)
+ exit (1);
+
+ throw failed ();
+ }
+
+ return r;
+ }
+
+ // Some background on creating Fedora packages (for a bit more detailed
+ // overview see the RPM Packaging Guide).
+ //
+ // An RPM package consists of the cpio archive, which contains the package
+ // files plus the RPM header file with metadata about the package. The RPM
+ // package manager uses this metadata to determine dependencies, where to
+ // install files, and other information. There are two types of RPM
+ // packages: source RPM and binary RPM. A source RPM contains source code,
+ // optionally patches to apply, and the spec file, which describes how to
+ // build the source code into a binary RPM. A binary RPM contains the
+ // binaries built from the sources package. While it's possible to create
+ // the package completely manually without using any of the Fedora tools, we
+ // are not going to go this route (see reasons mentioned in the Debian
+ // implementation for the list of issues with this approach).
+ //
+ // Based on this our plan is to produce an RPM spec file and then invoke
+ // rpmbuild to produce the binary package from that. While this approach is
+ // normally used to build things from source, it feels like we should be
+ // able to pretend that we are. Specifially, we can implement the %install
+ // section of the spec file to invoke the build system and install all the
+ // packages directly from their bpkg locations.
+ //
+ // Note that the -debuginfo sub-packages are generated by default and all we
+ // need to do from our side is to compile with debug information (-g),
+ // failed which we get a warning from rpmbuild. We will also disable
+ // generating the -debugsource sub-packages since that would require to set
+ // up the source files infrastructure in the ~/rpmbuild/BUILD/ directory,
+ // which feels too hairy for now.
+ //
+ // Note: this setup requires rpmdevtools (rpmdev-setuptree) and its
+ // dependency rpm-build and rpm packages.
+ //
paths system_package_manager_fedora::
- generate (const packages&,
- const packages&,
- const strings&,
- const dir_path&,
- const package_manifest&,
- const string&,
- const small_vector<language, 1>&,
- optional<recursive_mode>)
+ generate (const packages& pkgs,
+ const packages& deps,
+ const strings& vars,
+ const dir_path& cfg_dir,
+ const package_manifest& pm,
+ const string& pt,
+ const small_vector<language, 1>& langs,
+ optional<recursive_mode> recur)
{
- // @@ TODO: make sure --output-root is not specified or matched the
- // rpm standard directory.
+ tracer trace ("system_package_manager_fedora::generate");
+
+ assert (!langs.empty ()); // Should be effective.
+
+ const shared_ptr<selected_package>& sp (pkgs.front ().selected);
+ const package_name& pn (sp->name);
+ const version& pv (sp->version);
+
+ const available_packages& aps (pkgs.front ().available);
+
+ bool lib (pt == "lib");
+ bool priv (ops_->private_ ()); // Private installation.
+
+ // For now we only know how to handle libraries with C-common interface
+ // languages. But we allow other implementation languages.
+ //
+ if (lib)
+ {
+ for (const language& l: langs)
+ if (!l.impl && l.name != "c" && l.name != "c++" && l.name != "cc")
+ fail << l.name << " libraries are not yet supported";
+ }
+
+ // Return true if this package uses the specified language, only as
+ // interface language if intf_only is true.
+ //
+ auto lang = [&langs] (const char* n, bool intf_only = false) -> bool
+ {
+ return find_if (langs.begin (), langs.end (),
+ [n, intf_only] (const language& l)
+ {
+ return (!intf_only || !l.impl) && l.name == n;
+ }) != langs.end ();
+ };
+
+ // As a first step, figure out the system names and version of the package
+ // we are generating and all the dependencies, diagnosing anything fishy.
+ //
+ // Note that there should be no duplicate dependencies and we can sidestep
+ // the status cache.
+ //
+ package_status st (map_package (pn, pv, aps));
+
+ vector<package_status> sdeps;
+ sdeps.reserve (deps.size ());
+ for (const package& p: deps)
+ {
+ const shared_ptr<selected_package>& sp (p.selected);
+ const available_packages& aps (p.available);
+
+ package_status s;
+ if (sp->substate == package_substate::system)
+ {
+ optional<package_status> os (status (sp->name, aps));
+
+ if (!os || os->status != package_status::installed)
+ fail << os_release.name_id << " package for " << sp->name
+ << " system package is no longer installed";
+
+ // For good measure verify the mapped back version still matches
+ // configured. Note that besides the normal case (queried by the
+ // system package manager), it could have also been specified by the
+ // user as an actual version or a wildcard. Ignoring this check for a
+ // wildcard feels consistent with the overall semantics.
+ //
+ if (sp->version != wildcard_version && sp->version != os->version)
+ {
+ fail << "current " << os_release.name_id << " package version for "
+ << sp->name << " system package does not match configured" <<
+ info << "configured version: " << sp->version <<
+ info << "current version: " << os->version << " ("
+ << os->system_version << ')';
+ }
+
+ s = move (*os);
+
+ // Note that the system version retrieved with status() likely
+ // contains the distribution tag in its release component. We,
+ // however, don't want it to ever be mentioned in the spec file and so
+ // just strip it right away. This will also make it consistent with
+ // the non-system dependencies.
+ //
+ string& v (s.system_version);
+ size_t p (v.find_last_of ("-."));
+ assert (p != string::npos); // The release is mandatory.
+ if (v[p] == '.')
+ v.resize (p);
+ }
+ else
+ s = map_package (sp->name, sp->version, aps);
+
+ sdeps.push_back (move (s));
+ }
+
+ if (verb >= 3)
+ {
+ auto print_status = [] (diag_record& dr, const package_status& s)
+ {
+ dr << s.main
+ << (s.devel.empty () ? "" : " ") << s.devel
+ << (s.static_.empty () ? "" : " ") << s.static_
+ << (s.doc.empty () ? "" : " ") << s.doc
+ << (s.debuginfo.empty () ? "" : " ") << s.debuginfo
+ << (s.debugsource.empty () ? "" : " ") << s.debugsource
+ << (s.common.empty () ? "" : " ") << s.common
+ << ' ' << s.system_version;
+ };
+
+ {
+ diag_record dr (trace);
+ dr << "package: ";
+ print_status (dr, st);
+ }
+
+ for (const package_status& st: sdeps)
+ {
+ diag_record dr (trace);
+ dr << "dependency: ";
+ print_status (dr, st);
+ }
+ }
+
+ // We only allow the standard -debug* sub-package names.
+ //
+ if (!st.debuginfo.empty () && st.debuginfo != st.main + "-debuginfo")
+ fail << "generation of -debuginfo packages with custom names not "
+ << "supported" <<
+ info << "use " << st.main + "-debuginfo name instead";
+
+ if (!st.debugsource.empty () && st.debuginfo != st.main + "-debugsource")
+ fail << "generation of -debugsource packages with custom names not "
+ << "supported" <<
+ info << "use " << st.main + "-debugsource name instead";
+
+ // Prepare the common extra options that need to be passed to both
+ // rpmbuild and rpm.
+ //
+ strings common_opts {"--target", arch};
+
+ // Add the dist macro (un)definition if --fedora-dist-tag is specified.
+ //
+ if (ops_->fedora_dist_tag_specified ())
+ {
+ string dist (ops_->fedora_dist_tag ());
+
+ if (!dist.empty ())
+ {
+ // Insert the leading dot into the distribution tag if missing.
+ //
+ if (dist.front () != '.')
+ dist.insert (dist.begin (), '.');
+
+ common_opts.push_back ("--define=dist " + dist);
+ }
+ else
+ common_opts.push_back ("--define=dist %{nil}");
+ }
+
+ // Evaluate the specified expressions expanding the contained macros. Make
+ // sure these macros are expanded to the same values as if used in the
+ // being generated spec file.
+ //
+ // Note that %{_docdir} and %{_licensedir} macros are set internally by
+ // rpmbuild (may depend on DocDir spec file directive, etc which we will
+ // not use) and thus cannot be queried with `rpm --eval` out of the
+ // box. To allow using these macros in the expressions, we provide their
+ // definitions to their default values on the command line.
+ //
+ auto eval = [&common_opts, this] (const cstrings& expressions)
+ {
+ cstrings opts;
+ opts.reserve (common_opts.size () +
+ 2 +
+ ops_->fedora_query_option ().size ());
+
+ // Pass the rpmbuild/rpm common options.
+ //
+ for (const string& o: common_opts)
+ opts.push_back (o.c_str ());
+
+ // Pass the %{_docdir} and %{_licensedir} macro definitions.
+ //
+ opts.push_back ("--define=_docdir %{_defaultdocdir}");
+ opts.push_back ("--define=_licensedir %{_defaultlicensedir}");
+
+ // Pass any additional options specified by the user.
+ //
+ for (const string& o: ops_->fedora_query_option ())
+ opts.push_back (o.c_str ());
+
+ return rpm_eval (opts, expressions);
+ };
+
+ // We override every config.install.* variable in order not to pick
+ // anything configured. Note that we add some more in the spec file below.
+ //
+ // We make use of the <project> substitution since in the recursive mode
+ // we may be installing multiple projects. Note that the <private>
+ // directory component is automatically removed if this functionality is
+ // not enabled. One side-effect of using <project> is that we will be
+ // using the bpkg package name instead of the Fedora package name. But
+ // perhaps that's correct: while in Fedora the source package name (which
+ // is the same as the main binary package name) does not necessarily
+ // correspond to the "logical" package name, we still want to use the
+ // logical name (consider libsqlite3 which is mapped to sqlite-libs and
+ // sqlite-devel; we don't want <project> to be sqlite-libs). To keep
+ // things consistent we use the bpkg package name for <private> as well.
+ //
+ // Let's only use those directory macros which we can query with `rpm
+ // --eval` (see eval() lambda for details). Note that this means our
+ // installed_entries paths (see below) may not correspond exactly to where
+ // things will actually be installed during rpmbuild. But that shouldn't
+ // be an issue since we make sure to never use these paths directly in the
+ // spec file (always using macros instead).
+ //
+ // NOTE: make sure to update the expressions evaluation and the %files
+ // sections below if changing anything here.
+ //
+ strings config {
+ "config.install.root=%{_prefix}/",
+ "config.install.data_root=%{_exec_prefix}/",
+ "config.install.exec_root=%{_exec_prefix}/",
+
+ "config.install.bin=%{_bindir}/",
+ "config.install.sbin=%{_sbindir}/",
+
+ // On Fedora shared libraries should be executable.
+ //
+ "config.install.lib=%{_libdir}/<private>/",
+ "config.install.lib.mode=755",
+ "config.install.libexec=%{_libexecdir}/<private>/<project>/",
+ "config.install.pkgconfig=lib/pkgconfig/",
+
+ "config.install.etc=%{_sysconfdir}/",
+ "config.install.include=%{_includedir}/<private>/",
+ "config.install.include_arch=include/",
+ "config.install.share=%{_datadir}/",
+ "config.install.data=share/<private>/<project>/",
+
+ "config.install.doc=%{_docdir}/<private>/<project>/",
+ "config.install.legal=%{_licensedir}/<private>/<project>/",
+ "config.install.man=%{_mandir}/",
+ "config.install.man1=man/man1/",
+ "config.install.man2=man/man2/",
+ "config.install.man3=man/man3/",
+ "config.install.man4=man/man4/",
+ "config.install.man5=man/man5/",
+ "config.install.man6=man/man6/",
+ "config.install.man7=man/man7/",
+ "config.install.man8=man/man8/"};
+
+ config.push_back ("config.install.private=" +
+ (priv ? pn.string () : "[null]"));
+
+ // Add user-specified configuration variables last to allow them to
+ // override anything.
+ //
+ for (const string& v: vars)
+ config.push_back (v);
+
+ // Note that we need to expand macros in the configuration variables
+ // before passing them to the below installed_entries() call.
+ //
+ // Also note that we expand the variables passed on the command line as
+ // well. While this can be useful, it can also be surprising. However, it
+ // is always possible to escape the '%' character which introduces the
+ // macro expansion, which in most cases won't be necessary since an
+ // undefined macro expansion is preserved literally.
+ //
+ // While at it, also obtain some other information that we will need down
+ // the road.
+ //
+ strings expansions;
+
+ // These are used for sorting out the installed files into the %files
+ // sections of the sub-packages.
+ //
+ dir_path bindir;
+ dir_path sbindir;
+ dir_path libexecdir;
+ dir_path confdir;
+ dir_path incdir;
+ dir_path libdir;
+ dir_path pkgdir; // Not queried, set as libdir/pkgconfig/.
+ dir_path sharedir;
+ dir_path docdir;
+ dir_path mandir;
+ dir_path licensedir;
+
+ // Note that the ~/rpmbuild/{BUILD,BUILDROOT,RPMS,SOURCES,SPECS,SRPMS}
+ // directory paths used by rpmbuild are actually defined as the
+ // %{_topdir}, %{_builddir}, %{_buildrootdir}, %{_rpmdir}, %{_sourcedir},
+ // %{_specdir}, and %{_srcrpmdir} RPM macros. These macros can potentially
+ // be redefined in RPM configuration files, in particular, in
+ // ~/.rpmmacros.
+ //
+ dir_path topdir; // ~/rpmbuild/
+ dir_path specdir; // ~/rpmbuild/SPECS/
+
+ // RPM file absolute path template.
+ //
+ // Note that %{_rpmfilename} normally expands as the following template:
+ //
+ // %{ARCH}/%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}.rpm
+ //
+ string rpmfile;
+ {
+ cstrings expressions;
+ expressions.reserve (config.size () + 13);
+
+ for (const string& c: config)
+ expressions.push_back (c.c_str ());
+
+ expressions.push_back ("%{?_bindir}");
+ expressions.push_back ("%{?_sbindir}");
+ expressions.push_back ("%{?_libexecdir}");
+ expressions.push_back ("%{?_sysconfdir}");
+ expressions.push_back ("%{?_includedir}");
+ expressions.push_back ("%{?_libdir}");
+ expressions.push_back ("%{?_datadir}");
+ expressions.push_back ("%{?_docdir}");
+ expressions.push_back ("%{?_mandir}");
+ expressions.push_back ("%{?_licensedir}");
+
+ expressions.push_back ("%{?_topdir}");
+ expressions.push_back ("%{?_specdir}");
+
+ expressions.push_back ("%{_rpmdir}/%{_rpmfilename}");
+
+ // Note that if the architecture passed with the --target option is
+ // invalid, then rpmbuild will fail with some ugly diagnostics since
+ // %{_arch} macro stays unexpanded in some commands executed by
+ // rpmbuild. Thus, let's verify that the architecture is recognized by
+ // rpmbuild and fail early if that's not the case.
+ //
+ expressions.push_back ("%{?_arch}");
+
+ expansions = eval (expressions);
+
+ // Shouldn't happen unless some paths contain newlines, which we don't
+ // care about.
+ //
+ if (expansions.size () != expressions.size ())
+ fail << "number of RPM directory path expansions differs from number "
+ << "of path expressions";
+
+ // Pop the string/directory expansions.
+ //
+ auto pop_string = [&expansions, &expressions] ()
+ {
+ assert (!expansions.empty ());
+
+ string r (move (expansions.back ()));
+
+ if (r.empty ())
+ fail << "macro '" << expressions.back () << "' expands into empty "
+ << "string";
+
+ expansions.pop_back ();
+ expressions.pop_back ();
+ return r;
+ };
+
+ auto pop_dir = [&expansions, &expressions] ()
+ {
+ assert (!expansions.empty ());
+
+ try
+ {
+ dir_path r (move (expansions.back ()));
+
+ if (r.empty ())
+ fail << "macro '" << expressions.back () << "' expands into empty "
+ << "path";
+
+ expansions.pop_back ();
+ expressions.pop_back ();
+ return r;
+ }
+ catch (const invalid_path& e)
+ {
+ fail << "macro '" << expressions.back () << "' expands into invalid "
+ << "path '" << e.path << "'" << endf;
+ }
+ };
+
+ // The source of a potentially invalid architecture is likely to be the
+ // --architecture option specified by the user. But can probably also be
+ // some mis-configuration.
+ //
+ if (expansions.back ().empty ()) // %{?_arch}
+ fail << "unknown target architecture '" << arch << "'";
+
+ pop_string (); // We only need %{?_arch} expansion for the verification.
+
+ rpmfile = pop_string ();
+ specdir = pop_dir ();
+ topdir = pop_dir ();
+
+ // Let's tighten things up and only look for the installed files in
+ // <private>/ (if specified) to make sure there is nothing stray.
+ //
+ dir_path pd (priv ? pn.string () : "");
+
+ licensedir = pop_dir () / pd;
+ mandir = pop_dir ();
+ docdir = pop_dir () / pd;
+ sharedir = pop_dir () / pd;
+ libdir = pop_dir () / pd;
+ pkgdir = libdir / dir_path ("pkgconfig");
+ incdir = pop_dir () / pd;
+ confdir = pop_dir ();
+ libexecdir = pop_dir () / pd;
+ sbindir = pop_dir ();
+ bindir = pop_dir ();
+
+ // Only configuration variables expansions must remain.
+ //
+ assert (expansions.size () == config.size ());
+ }
+
+ // Note that the conventional place for all the inputs and outputs of the
+ // rpmbuild operations is the directory tree rooted at ~/rpmbuild/. We
+ // won't fight with rpmbuild and will use this tree as the user would
+ // do while creating the binary package manually.
+ //
+ // Specifially, we will create the RPM spec file in ~/rpmbuild/SPECS/,
+ // install the package(s) under the ~/rpmbuild/BUILDROOT/<package-dir>/
+ // chroot, and expect the generated RPM files under ~/rpmbuild/RPMS/.
+ //
+ // That, in particular, means that we have no use for the --output-root
+ // directory. We will also make sure that we don't overwrite an existing
+ // RPM spec file unless --wipe-output is specified.
+ //
+ if (ops_->output_root_specified () && ops_->output_root () != topdir)
+ fail << "--output-root|-o must be " << topdir << " if specified";
+
+ // Note that in Fedora the Name spec file directive names the source
+ // package as well as the main binary package and the spec file should
+ // match this name.
+ //
+ // @@ TODO (maybe/later): it's unclear whether it's possible to rename
+ // the main binary package. Maybe makes sense to investigate if/when
+ // we decide to generate source packages.
+ //
+ path spec (specdir / (st.main + ".spec"));
+
+ if (exists (spec) && !ops_->wipe_output ())
+ fail << "RPM spec file " << spec << " already exists" <<
+ info << "use --wipe-output to remove but be careful";
+
+ // Note that we can use weak install scope for the auto recursive mode
+ // since we know dependencies cannot be spread over multiple linked
+ // configurations.
+ //
+ string scope (!recur || *recur == recursive_mode::full
+ ? "project"
+ : "weak");
+
+ // Get the map of files that will end up in the binary packages.
+ //
+ installed_entry_map ies (
+ installed_entries (*ops_, pkgs, expansions, scope));
+
+ if (ies.empty ())
+ fail << "specified package(s) do not install any files";
+
+ if (verb >= 4)
+ {
+ for (const auto& p: ies)
+ {
+ diag_record dr (trace);
+ dr << "installed entry: " << p.first;
+
+ if (p.second.target != nullptr)
+ dr << " -> " << p.second.target->first; // Symlink.
+ else
+ dr << " " << p.second.mode;
+ }
+ }
+
+ // Prepare the data for the RPM spec file.
+ //
+ // Url directive.
+ //
+ string url (pm.package_url ? pm.package_url->string () :
+ pm.url ? pm.url->string () :
+ string ());
+
+ // Packager directive.
+ //
+ string packager;
+ if (ops_->fedora_packager_specified ())
+ {
+ packager = ops_->fedora_packager ();
+ }
+ else
+ {
+ const email* e (pm.package_email ? &*pm.package_email :
+ pm.email ? &*pm.email :
+ nullptr);
+
+ if (e == nullptr)
+ fail << "unable to determine packager from manifest" <<
+ info << "specify explicitly with --fedora-packager";
+
+ // In certain places (e.g., %changelog), Fedora expect this to be in the
+ // `John Doe <john@example.org>` form while we often specify just the
+ // email address (e.g., to the mailing list). Try to detect such a case
+ // and complete it to the desired format.
+ //
+ if (e->find (' ') == string::npos && e->find ('@') != string::npos)
+ {
+ // Try to use comment as name, if any.
+ //
+ if (!e->comment.empty ())
+ {
+ packager = e->comment;
+
+ // Strip the potential trailing dot.
+ //
+ if (packager.back () == '.')
+ packager.pop_back ();
+ }
+ else
+ packager = pn.string () + " package maintainer";
+
+ packager += " <" + *e + '>';
+ }
+ else
+ packager = *e;
+ }
+
+ // Version, Release, and Epoch directives.
+ //
+ struct system_version
+ {
+ string epoch;
+ string version;
+ string release;
+ };
+
+ auto parse_system_version = [] (const string& v)
+ {
+ system_version r;
+
+ size_t e (v.find (':'));
+ if (e != string::npos)
+ r.epoch = string (v, 0, e);
+
+ size_t b (e != string::npos ? e + 1 : 0);
+ e = v.find ('-', b);
+ assert (e != string::npos); // Release is required.
+
+ r.version = string (v, b, e - b);
+
+ b = e + 1;
+ r.release = string (v, b);
+ return r;
+ };
+
+ system_version sys_version (parse_system_version (st.system_version));
+
+ // License directive.
+ //
+ // The directive value is a SPDX license expression. Note that the OR/AND
+ // operators must be specified in upper case and the AND operator has a
+ // higher precedence than OR.
+ //
+ string license;
+ for (const licenses& ls: pm.license_alternatives)
+ {
+ if (!license.empty ())
+ license += " OR ";
+
+ for (auto b (ls.begin ()), i (b); i != ls.end (); ++i)
+ {
+ if (i != b)
+ license += " AND ";
+
+ license += *i;
+ }
+ }
+
+ // Create the ~/rpmbuild directory tree if it doesn't exist yet.
+ //
+ if (!exists (topdir))
+ {
+ cstrings args {"rpmdev-setuptree", nullptr};
+
+ try
+ {
+ process_path pp (process::path_search (args[0]));
+ process_env pe (pp);
+
+ if (verb >= 3)
+ print_process (pe, args);
+
+ process pr (pp, args);
+
+ if (!pr.wait ())
+ {
+ diag_record dr (fail);
+ dr << args[0] << " exited with non-zero code";
+
+ if (verb < 3)
+ {
+ dr << info << "command line: ";
+ print_process (dr, pe, args);
+ }
+ }
+ }
+ catch (const process_error& e)
+ {
+ error << "unable to execute " << args[0] << ": " << e;
+
+ if (e.child)
+ exit (1);
+
+ throw failed ();
+ }
+
+ // For good measure verify that ~/rpmbuild directory now exists.
+ //
+ if (!exists (topdir))
+ fail << "unable to create RPM build directory " << topdir;
+ }
+
+ // We cannot easily detect architecture-independent packages (think
+ // libbutl.bash) and providing an option feels like the best we can do.
+ // Note that the noarch value means architecture-independent and any other
+ // value means architecture-dependent.
+ //
+ const string& build_arch (ops_->fedora_build_arch_specified ()
+ ? ops_->fedora_build_arch ()
+ : empty_string);
+
+ // The RPM spec file.
+ //
+ // Note that we try to do a reasonably thorough job (e.g., using macros
+ // rather than hardcoding values, trying to comply with Fedora guidelines
+ // and recommendations, etc) with the view that this can be used as a
+ // starting point for manual packaging.
+ //
+ try
+ {
+ ofdstream os (spec);
+
+ // Note that Fedora Packaging Guidelines recommend to declare the
+ // package dependencies in the architecture-specific fashion using the
+ // %{?_isa} macro in the corresponding Requires directive (e.g.,
+ // `Requires: foo%{?_isa}` which would expand to something like
+ // `Requires: foo(x86-64)`). We, however, cannot easily detect if the
+ // distribution packages which correspond to the bpkg package
+ // dependencies are architecture-specific or not. Thus, we will generate
+ // the architecture-independent Requires directives for them which
+ // postpones the architecture resolution until the package installation
+ // time by dnf. We could potentially still try to guess if the
+ // dependency package is architecture-specific or not based on its
+ // languages, but let's keep it simple for now seeing that it's not a
+ // deal breaker.
+ //
+ // Also note that we will generate the architecture-specific
+ // dependencies on our own sub-packages, unless the --fedora-build-arch
+ // option has been specified, and for the C/C++ language related
+ // dependencies (glibc, etc). In other words, we will not try to craft
+ // the architecture specifier ourselves when we cannot use %{?_isa}.
+ //
+ string isa (build_arch.empty () ? "%{?_isa}" : "");
+
+ // Add the Requires directive(s), optionally separating them from the
+ // previous directives with an empty line.
+ //
+ auto add_requires = [&os] (bool& first, const string& v)
+ {
+ if (first)
+ {
+ os << '\n';
+ first = false;
+ }
+
+ os << "Requires: " << v << '\n';
+ };
+
+ auto add_requires_list = [&add_requires] (bool& first, const strings& vs)
+ {
+ for (const string& v: vs)
+ add_requires (first, v);
+ };
+
+ // Add the Requires directives for language dependencies of a
+ // sub-package. Deduce the language dependency packages (such as glibc,
+ // libstdc++, etc), unless they are specified explicitly via the
+ // --fedora-*-langreq options. If single option with an empty value is
+ // specified, then no language dependencies are added. The valid
+ // sub-package suffixes are '' (main package), '-devel', and '-static'.
+ //
+ auto add_lang_requires = [&lang, &add_requires, &add_requires_list]
+ (bool& first,
+ const string& suffix,
+ const strings& options,
+ bool intf_only = false)
+ {
+ if (!options.empty ())
+ {
+ if (options.size () != 1 || !options[0].empty ())
+ add_requires_list (first, options);
+ }
+ else
+ {
+ // Add dependency on libstdc++<suffix> and glibc<suffix> packages.
+ //
+ // It doesn't seems that the -static sub-package needs to define any
+ // default C/C++ language dependencies. That is a choice of the
+ // dependent packages which may want to link the standard libraries
+ // either statically or dynamically, so let's leave if for them to
+ // arrange.
+ //
+ if (suffix != "-static")
+ {
+ // If this is an undetermined C-common library, we assume it may
+ // be C++ (better to over- than under-specify).
+ //
+ bool cc (lang ("cc", intf_only));
+ if (cc || lang ("c++", intf_only))
+ add_requires (first, string ("libstdc++") + suffix + "%{?_isa}");
+
+ if (cc || lang ("c", intf_only))
+ add_requires (first, string ("glibc") + suffix + "%{?_isa}");
+ }
+ }
+ };
+
+ // We need to add the mandatory Summary and %description directives both
+ // for the main package and for the sub-packages. In the Summary
+ // directives we will use the `summary` package manifest value. In the
+ // %description directives we will just describe the sub-package content
+ // since using the `description` package manifest value is not going to
+ // be easy: it can be arbitrarily long and may not even be plain text
+ // (it's commonly the contents of the README.md file).
+ //
+ // We will disable automatic dependency discovery for all sub-packages
+ // using the `AutoReqProv: no` directive.
+ //
+
+ // The main package.
+ //
+ {
+ os << "Name: " << st.main << '\n'
+ << "Version: " << sys_version.version << '\n'
+ << "Release: " << sys_version.release << "%{?dist}" << '\n';
+
+ if (!sys_version.epoch.empty ())
+ os << "Epoch: " << sys_version.epoch << '\n';
+
+ os << "License: " << license << '\n'
+ << "Summary: " << pm.summary << '\n'
+ << "Url: " << url << '\n';
+
+ if (!packager.empty ())
+ os << "Packager: " << packager << '\n';
+
+ if (!build_arch.empty ())
+ os << "BuildArch: " << build_arch << '\n';
+
+#if 0
+ os << "#Source: https://pkg.cppget.org/1/???/"
+ << pm.effective_project () << '/' << sp->name << '-'
+ << sp->version << ".tar.gz" << '\n';
+#endif
+
+ // Idiomatic epoch-version-release value.
+ //
+ os << '\n'
+ << "%global evr %{?epoch:%{epoch}:}%{version}-%{release}" << '\n';
+
+ os << '\n'
+ << "# " << st.main << '\n'
+ << "#" << '\n'
+ << "AutoReqProv: no" << '\n';
+
+ // Requires directives.
+ //
+ {
+ bool first (true);
+ if (!st.common.empty ())
+ add_requires (first, st.common + " = %{evr}");
+
+ for (const package_status& s: sdeps)
+ add_requires (first, s.main + " >= " + s.system_version);
+
+ add_lang_requires (first,
+ "" /* suffix */,
+ ops_->fedora_main_langreq ());
+
+ if (ops_->fedora_main_extrareq_specified ())
+ add_requires_list (first, ops_->fedora_main_extrareq ());
+ }
+
+ os << '\n'
+ << "%description" << '\n'
+ << "This package contains the runtime files." << '\n';
+ }
+
+ // The -devel sub-package.
+ //
+ if (!st.devel.empty ())
+ {
+ os << '\n'
+ << "# " << st.devel << '\n'
+ << "#" << '\n'
+ << "%package -n " << st.devel << '\n'
+ << "Summary: " << pm.summary << '\n';
+
+ // Feels like the architecture should be the same as for the main
+ // package.
+ //
+ if (!build_arch.empty ())
+ os << "BuildArch: " << build_arch << '\n';
+
+ os << '\n'
+ << "AutoReqProv: no" << '\n';
+
+ // Requires directives.
+ //
+ {
+ bool first (true);
+
+ // Dependency on the main package.
+ //
+ add_requires (first, "%{name}" + isa + " = %{evr}");
+
+ for (const package_status& s: sdeps)
+ {
+ // Doesn't look like we can distinguish between interface and
+ // implementation dependencies here. So better to over- than
+ // under-specify.
+ //
+ // Note that if the -devel sub-package doesn't exist for a
+ // dependency, then its potential content may be part of the main
+ // package. If that's the case we, strictly speaking, should add
+ // the dependency on the main package. Let's, however, skip that
+ // since we already have this dependency implicitly via our own
+ // main package, which the -devel sub-package depends on.
+ //
+ if (!s.devel.empty ())
+ add_requires (first, s.devel + " >= " + s.system_version);
+ }
+
+ add_lang_requires (first,
+ "-devel",
+ ops_->fedora_devel_langreq (),
+ true /* intf_only */);
+
+ if (ops_->fedora_devel_extrareq_specified ())
+ add_requires_list (first, ops_->fedora_devel_extrareq ());
+ }
+
+ // If the -static sub-package is not being generated but there are
+ // some static libraries installed, then they will be added to the
+ // -devel sub-package. If that's the case, we add the
+ // `Provides: %{name}-static` directive for the -devel sub-package, as
+ // recommended.
+ //
+ // Should we do the same for the main package, where the static
+ // libraries go if the -devel sub-package is not being generated
+ // either? While it feels sensible, we've never seen such a practice
+ // or recommendation. So let's not do it for now.
+ //
+ if (st.static_.empty ())
+ {
+ for (auto p (ies.find_sub (libdir)); p.first != p.second; ++p.first)
+ {
+ const path& f (p.first->first);
+ path l (f.leaf (libdir));
+ const string& n (l.string ());
+
+ if (l.simple () &&
+ n.size () > 3 && n.compare (0, 3, "lib") == 0 &&
+ l.extension () == "a")
+ {
+ os << '\n'
+ << "Provides: %{name}-static" << isa << " = %{evr}" << '\n';
+
+ break;
+ }
+ }
+ }
+
+ os << '\n'
+ << "%description -n " << st.devel << '\n'
+ << "This package contains the development files." << '\n';
+ }
+
+ // The -static sub-package.
+ //
+ if (!st.static_.empty ())
+ {
+ os << '\n'
+ << "# " << st.static_ << '\n'
+ << "#" << '\n'
+ << "%package -n " << st.static_ << '\n'
+ << "Summary: " << pm.summary << '\n';
+
+ // Feels like the architecture should be the same as for the -devel
+ // sub-package.
+ //
+ if (!build_arch.empty ())
+ os << "BuildArch: " << build_arch << '\n';
+
+ os << '\n'
+ << "AutoReqProv: no" << '\n';
+
+ // Requires directives.
+ //
+ {
+ bool first (true);
+
+ // The static libraries without headers doesn't seem to be of any
+ // use. Thus, add dependency on the -devel or main sub-package, if
+ // not being generated.
+ //
+ add_requires (
+ first,
+ (!st.devel.empty () ? st.devel : "%{name}") + isa + " = %{evr}");
+
+ // Add dependency on sub-packages that may contain static libraries.
+ // Note that in the -devel case we can potentially over-specify the
+ // dependency which is better than to under-specify.
+ //
+ for (const package_status& s: sdeps)
+ {
+ // Note that if the -static sub-package doesn't exist for a
+ // dependency, then its potential content may be part of the
+ // -devel sub-package, if exists, or the main package otherwise.
+ // If that's the case we, strictly speaking, should add the
+ // dependency on the -devel sub-package, if exists, or the main
+ // package otherwise. Let's, however, also consider the implicit
+ // dependencies via our own -devel and main (sub-)packages, which
+ // we depend on, and simplify things similar to what we do for the
+ // -devel sub-package above.
+ //
+ // Also note that we only refer to the dependency's -devel
+ // sub-package if we don't have our own -devel sub-package
+ // (unlikely, but possible), which would provide us with such an
+ // implicit dependency.
+ //
+ const string& p (!s.static_.empty () ? s.static_ :
+ st.devel.empty () ? s.devel :
+ empty_string);
+
+ if (!p.empty ())
+ add_requires (first, p + " >= " + st.system_version);
+ }
+
+ add_lang_requires (first, "-static", ops_->fedora_stat_langreq ());
+
+ if (ops_->fedora_stat_extrareq_specified ())
+ add_requires_list (first, ops_->fedora_stat_extrareq ());
+ }
+
+ os << '\n'
+ << "%description -n " << st.static_ << '\n'
+ << "This package contains the static libraries." << '\n';
+ }
+
+ // The -doc sub-package.
+ //
+ if (!st.doc.empty ())
+ {
+ os << '\n'
+ << "# " << st.doc << '\n'
+ << "#" << '\n'
+ << "%package -n " << st.doc << '\n'
+ << "Summary: " << pm.summary << '\n'
+ << "BuildArch: noarch" << '\n'
+ << '\n'
+ << "AutoReqProv: no" << '\n'
+ << '\n'
+ << "%description -n " << st.doc << '\n'
+ << "This package contains the documentation." << '\n';
+ }
+
+ // The -common sub-package.
+ //
+ if (!st.common.empty ())
+ {
+ // Generally, this sub-package is not necessarily architecture-
+ // independent (for example, it could contain something shared between
+ // multiple binary packages produced from the same source package
+ // rather than something shared between all the architectures of a
+ // binary package). But seeing that we always generate one binary
+ // package, for us it only makes sense as architecture-independent.
+ //
+ // It's also not clear what dependencies we can deduce for this
+ // sub-package. Assuming that it depends on all the dependency -common
+ // sub-packages is probably unreasonable.
+ //
+ os << '\n'
+ << "# " << st.common << '\n'
+ << "#" << '\n'
+ << "%package -n " << st.common << '\n'
+ << "Summary: " << pm.summary << '\n'
+ << "BuildArch: noarch" << '\n'
+ << '\n'
+ << "AutoReqProv: no" << '\n'
+ << '\n'
+ << "%description -n " << st.common << '\n'
+ << "This package contains the architecture-independent files." << '\n';
+ }
+
+ // Build setup.
+ //
+ {
+ bool lang_c (lang ("c"));
+ bool lang_cxx (lang ("c++"));
+ bool lang_cc (lang ("cc"));
+
+ os << '\n'
+ << "# Build setup." << '\n'
+ << "#" << '\n';
+
+ // The -debuginfo and -debugsource sub-packages.
+ //
+ // Note that the -debuginfo and -debugsource sub-packages are defined
+ // in the spec file by expanding the %{debug_package} macro (search
+ // the macro definition in `rpm --showrc` stdout for details). This
+ // expansion happens as part of the %install section processing but
+ // only if the %{buildsubdir} macro is defined. This macro refers to
+ // the package source subdirectory in the ~/rpmbuild/BUILD directory
+ // and is normally set by the %setup macro expansion in the %prep
+ // section which, in particular, extracts source files from an
+ // archive, defines the %{buildsubdir} macro, and make this directory
+ // current. Since we don't have an archive to extract, we will use the
+ // %setup macro disabling sources extraction (-T) and creating an
+ // empty source directory instead (-c). This directory is also used by
+ // rpmbuild for saving debuginfo-related intermediate files
+ // (debugfiles.list, etc). See "Fedora Debuginfo packages" and "Using
+ // RPM build flags" documentation for better understanding what's
+ // going on under the hood. There is also the "[Rpm-ecosystem] Trying
+ // to understand %buildsubdir and debuginfo generation" mailing list
+ // thread which provides some additional clarifications.
+ //
+ // Also note that we disable generating the -debugsource sub-packages
+ // (see the generate() description above for the reasoning).
+ //
+ os << "%undefine _debugsource_packages" << '\n';
+
+ // Append the -ffile-prefix-map option (if specified) which is used to
+ // strip source file path prefix in debug information (besides other
+ // places). By default it is not used, presumably since we disable
+ // generating the -debugsource sub-packages. We change it to point to
+ // the bpkg configuration directory. Note that this won't work for
+ // external packages with source out of configuration (e.g., managed
+ // by bdep).
+ //
+ // @@ Supposedly this code won't be necessary when we add support for
+ // -debugsource sub-packages.
+ //
+ // Note that adding this option may also result in notification
+ // messages for probably all the source files as following:
+ //
+ // cpio: libfoo-1.2.3/foo.cxx: Cannot stat: No such file or directory
+ //
+ // This bloats the rpmbuild output but doesn't seem to break
+ // anything.
+ //
+ if (ops_->fedora_buildflags () != "ignore")
+ {
+ if (lang_c || lang_cc)
+ os << "%global build_cflags %{?build_cflags} -ffile-prefix-map="
+ << cfg_dir.string () << "=." << '\n';
+
+ if (lang_cxx || lang_cc)
+ os << "%global build_cxxflags %{?build_cxxflags} -ffile-prefix-map="
+ << cfg_dir.string () << "=." << '\n';
+ }
+
+ // Common arguments for build2 commands.
+ //
+ // Let's use absolute path to the build system driver in case we are
+ // invoked with altered environment or some such.
+ //
+ // Note: should be consistent with the invocation in installed_entries()
+ // above.
+ //
+ cstrings verb_args; string verb_arg;
+ map_verb_b (*ops_, verb_b::normal, verb_args, verb_arg);
+
+ os << '\n'
+ << "%global build2 " << search_b (*ops_).effect_string ();
+ for (const char* o: verb_args) os << ' ' << o;
+ for (const string& o: ops_->build_option ()) os << ' ' << o;
+
+ // Map the %{_smp_build_ncpus} macro value to the build2 --jobs or
+ // --serial-stop options.
+ //
+ os << '\n'
+ << '\n'
+ << "%if %{defined _smp_build_ncpus}" << '\n'
+ << " %if %{_smp_build_ncpus} == 1" << '\n'
+ << " %global build2 %{build2} --serial-stop" << '\n'
+ << " %else" << '\n'
+ << " %global build2 %{build2} --jobs=%{_smp_build_ncpus}" << '\n'
+ << " %endif" << '\n'
+ << "%endif" << '\n';
+
+ // Configuration variables.
+ //
+ // Note: we need to quote values that contain `<>`, `[]`, since they
+ // will be passed through shell. For simplicity, let's just quote
+ // everything.
+ //
+ os << '\n'
+ << "%global config_vars";
+
+ auto add_macro_line = [&os] (const auto& v)
+ {
+ os << " \\\\\\\n " << v;
+ };
+
+ add_macro_line ("config.install.chroot='%{buildroot}/'");
+ add_macro_line ("config.install.sudo='[null]'");
+
+ // If this is a C-based language, add rpath for private installation.
+ //
+ if (priv && (lang_c || lang_cxx || lang_cc))
+ add_macro_line ("config.bin.rpath='%{_libdir}/" + pn.string () + "/'");
+
+ // Add build flags.
+ //
+ if (ops_->fedora_buildflags () != "ignore")
+ {
+ const string& m (ops_->fedora_buildflags ());
+
+ string o (m == "assign" ? "=" :
+ m == "append" ? "+=" :
+ m == "prepend" ? "=+" : "");
+
+ if (o.empty ())
+ fail << "unknown --fedora-buildflags option value '" << m << "'";
+
+ // Note that config.cc.* doesn't play well with the append/prepend
+ // modes because the orders are:
+ //
+ // x.poptions cc.poptions
+ // cc.coptions x.coptions
+ // cc.loptions x.loptions
+ //
+ // Oh, well, hopefully it will be close enough for most cases.
+ //
+ // Note also that there are compiler mode options that are not
+ // overridden. Also the preprocessor options are normally contained
+ // in the %{build_cflags} and %{build_cxxflags} macro definitions
+ // and have no separate macros associated at this level (see "Using
+ // RPM build flags" documentation for details). For example:
+ //
+ // $ rpm --eval "%{build_cflags}"
+ // -O2 -flto=auto -ffat-lto-objects -fexceptions -g
+ // -grecord-gcc-switches -pipe -Wall -Werror=format-security
+ // -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS
+ // -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1
+ // -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1
+ // -m64 -mtune=generic -fasynchronous-unwind-tables
+ // -fstack-clash-protection -fcf-protection
+ //
+ // Note the -Wp options above. Thus, we reset config.{c,cxx}.poptions
+ // to [null] in the assign mode and, for simplicity, leave them as
+ // configured otherwise. We could potentially fix that either by
+ // extracting the -Wp,... options from %{build_cflags} and
+ // %{build_cxxflags} macro values or using more lower level macros
+ // instead (%{_preprocessor_defines}, %{_hardened_cflags}, etc),
+ // which all feels quite hairy and brittle.
+ //
+ if (o == "=" && (lang_c || lang_cxx || lang_cc))
+ {
+ add_macro_line ("config.cc.poptions='[null]'");
+ add_macro_line ("config.cc.coptions='[null]'");
+ add_macro_line ("config.cc.loptions='[null]'");
+ }
+
+ if (lang_c || lang_cc)
+ {
+ if (o == "=")
+ add_macro_line ("config.c.poptions='[null]'");
+
+ add_macro_line ("config.c.coptions" + o + "'%{?build_cflags}'");
+ add_macro_line ("config.c.loptions" + o + "'%{?build_ldflags}'");
+ }
+
+ if (lang_cxx || lang_cc)
+ {
+ if (o == "=")
+ add_macro_line ("config.cxx.poptions='[null]'");
+
+ add_macro_line ("config.cxx.coptions" + o + "'%{?build_cxxflags}'");
+ add_macro_line ("config.cxx.loptions" + o + "'%{?build_ldflags}'");
+ }
+ }
+
+ // Keep last to allow user-specified configuration variables to
+ // override anything.
+ //
+ for (const string& c: config)
+ {
+ // Quote the value unless already quoted (see above). Presense of
+ // potentially-quoted user variables complicates things a bit (can
+ // be partially quoted, double-quoted, etc).
+ //
+ size_t p (c.find_first_of ("=+ \t")); // End of name.
+ if (p != string::npos)
+ {
+ p = c.find_first_not_of ("=+ \t", p); // Beginning of value.
+ if (p != string::npos)
+ {
+ if (c.find_first_of ("'\"", p) == string::npos) // Not quoted.
+ {
+ add_macro_line (string (c, 0, p) + '\'' + string (c, p) + '\'');
+ continue;
+ }
+ }
+ }
+
+ add_macro_line (c);
+ }
+
+ os << '\n'; // Close the macro definition.
+
+ // List of packages we need to install.
+ //
+ os << '\n'
+ << "%global packages";
+
+ for (const package& p: pkgs)
+ add_macro_line (p.out_root.representation ());
+
+ os << '\n'; // Close the macro definition.
+ }
+
+ // Build sections.
+ //
+ {
+ os << '\n'
+ << "# Build sections." << '\n'
+ << "#" << '\n'
+ << "%prep" << '\n'
+ << "%setup -T -c" << '\n'
+ << '\n'
+ << "%build" << '\n'
+ << "%{build2} %{config_vars} update-for-install: %{packages}" << '\n'
+ << '\n'
+ << "%install" << '\n'
+ << "%{build2} %{config_vars} '!config.install.scope=" << scope
+ << "' install: %{packages}" << '\n';
+ }
+
+ // Files sections.
+ //
+ // Generate the %files section for each sub-package in order to sort out
+ // which files belong where.
+ //
+ // For the details on the %files section directives see "Directives For
+ // the %files list" documentation. But the summary is:
+ //
+ // - Supports only simple wildcards (?, *, [...]; no recursive/**).
+ // - Includes directories recursively, unless the path is prefixed
+ // with the %dir directive, in which case only includes this
+ // directory entry, which will be created on install and removed on
+ // uninstall, if empty.
+ // - An entry that doesn't match anything is an error (say,
+ // /usr/sbin/*).
+ //
+ // Keep in mind that wherever there is <project> in the config.install.*
+ // variable, we can end up with multiple different directories (bundled
+ // packages).
+ //
+ {
+ string main;
+ string devel;
+ string static_;
+ string doc;
+ string common;
+
+ // Note that declaring package ownership for standard directories is
+ // considered in Fedora a bad idea and is reported as an error by some
+ // RPM package checking tools (rpmlint, etc). Thus, we generate, for
+ // example, libexecdir/* entry rather than libexecdir/. However, if
+ // the private directory is specified we generate libexecdir/<private>/
+ // to own the directory.
+ //
+ // NOTE: use consistently with the above install directory expressions
+ // (%{?_includedir}, etc) evaluation.
+ //
+ string pd (priv ? pn.string () + '/' : "");
+
+ // The main package contains everything that doesn't go to another
+ // packages.
+ //
+ if (ies.contains_sub (bindir)) main += "%{_bindir}/*\n";
+ if (ies.contains_sub (sbindir)) main += "%{_sbindir}/*\n";
+
+ if (ies.contains_sub (libexecdir))
+ main += "%{_libexecdir}/" + (priv ? pd : "*") + '\n';
+
+ // This could potentially go to -common but it could also be target-
+ // specific, who knows. So let's keep it in main for now.
+ //
+ // Let's also specify that the confdir/ sub-entries are non-replacable
+ // configuration files. This, in particular, means that if edited they
+ // will not be replaced/removed on the package upgrade or
+ // uninstallation (see RPM Packaging Guide for more details on the
+ // %config(noreplace) directive). Also note that the binary package
+ // configuration files can later be queried by the user via the `rpm
+ // --query --configfiles` command.
+ //
+ if (ies.contains_sub (confdir))
+ main += "%config(noreplace) %{_sysconfdir}/*\n";
+
+ if (ies.contains_sub (incdir))
+ (!st.devel.empty () ? devel : main) +=
+ "%{_includedir}/" + (priv ? pd : "*") + '\n';
+
+ if (st.devel.empty () && st.static_.empty ())
+ {
+ if (ies.contains_sub (libdir))
+ main += "%{_libdir}/" + (priv ? pd : "*") + '\n';
+ }
+ else
+ {
+ // Ok, time for things to get hairy: we need to split the contents
+ // of lib/ into the main, -devel, and/or -static sub-packages. The
+ // -devel sub-package, if present, should contain three things:
+ //
+ // 1. Static libraries (.a), if no -static sub-package is present.
+ // 2. Non-versioned shared library symlinks (.so).
+ // 3. Contents of the pkgconfig/ subdirectory, except for *.static.pc
+ // files if -static sub-package is present.
+ //
+ // The -static sub-package, if present, should contain two things:
+ //
+ // 1. Static libraries (.a).
+ // 2. *.static.pc files in pkgconfig/ subdirectory.
+ //
+ // Everything else should go into the main package.
+ //
+ // The shared libraries are tricky. Here we can have three plausible
+ // arrangements:
+ //
+ // A. Portably-versioned library:
+ //
+ // libfoo-1.2.so
+ // libfoo.so -> libfoo-1.2.so
+ //
+ // B. Natively-versioned library:
+ //
+ // libfoo.so.1.2.3
+ // libfoo.so.1.2 -> libfoo.so.1.2.3
+ // libfoo.so.1 -> libfoo.so.1.2
+ // libfoo.so -> libfoo.so.1
+ //
+ // C. Non-versioned library:
+ //
+ // libfoo.so
+ //
+ // Note that in the (C) case the library should go into the main
+ // package. Based on this, the criteria appears to be
+ // straightforward: the extension is .so and it's a symlink. For
+ // good measure we also check that there is the `lib` prefix
+ // (plugins, etc).
+ //
+ // Also note that if <private>/ is specified, then to establish
+ // ownership of the libdir/<private>/ directory we also need to add
+ // it non-recursively to one of the potentially 3 sub-packages,
+ // which all can contain some of its sub-entries. Not doing this
+ // will result in an empty libdir/<private>/ subdirectory after the
+ // binary package uninstallation. Naturally, the owner should be the
+ // right-most sub-package on the following diagram which contains
+ // any of the libdir/<private>/ sub-entries:
+ //
+ // -static -> -devel -> main
+ //
+ // The same reasoning applies to libdir/<private>/pkgconfig/.
+ //
+ string* owners[] = {&static_, &devel, &main};
+
+ // Indexes (in owners) of sub-packages which should own
+ // libdir/<private>/ and libdir/<private>/pkgconfig/. If nullopt,
+ // then no additional directory ownership entry needs to be added
+ // (installation is not private, recursive directory entry is
+ // already added, etc).
+ //
+ optional<size_t> private_owner;
+ optional<size_t> pkgconfig_owner;
+
+ for (auto p (ies.find_sub (libdir)); p.first != p.second; )
+ {
+ const path& f (p.first->first);
+ const installed_entry& ie ((p.first++)->second);
+
+ path l (f.leaf (libdir));
+ const string& n (l.string ());
+ string* fs (&main); // Go to the main package as a last resort.
+
+ auto update_ownership = [&owners, &fs] (optional<size_t>& pi)
+ {
+ size_t i (0);
+ for (; owners[i] != fs; ++i) ;
+
+ if (!pi || *pi < i)
+ pi = i;
+ };
+
+ if (l.simple ())
+ {
+ if (n.size () > 3 && n.compare (0, 3, "lib") == 0)
+ {
+ string e (l.extension ());
+
+ if (e == "a")
+ {
+ fs = !st.static_.empty () ? &static_ : &devel;
+ }
+ else if (e == "so" && ie.target != nullptr &&
+ !st.devel.empty ())
+ {
+ fs = &devel;
+ }
+ }
+
+ *fs += "%{_libdir}/" + pd + n + '\n';
+ }
+ else
+ {
+ // Let's keep things tidy and, when possible, use a
+ // sub-directory rather than listing all its sub-entries
+ // verbatim.
+ //
+ dir_path sd (*l.begin ());
+ dir_path d (libdir / sd);
+
+ if (d == pkgdir)
+ {
+ // If the -static sub-package is not being generated, then the
+ // whole directory goes into the -devel sub-package.
+ // Otherwise, *.static.pc files go into the -static
+ // sub-package and the rest into the -devel sub-package,
+ // unless it is not being generated in which case it goes into
+ // the main package.
+ //
+ if (!st.static_.empty ())
+ {
+ if (n.size () > 10 &&
+ n.compare (n.size () - 10, 10, ".static.pc") == 0)
+ fs = &static_;
+ else if (!st.devel.empty ())
+ fs = &devel;
+
+ *fs += "%{_libdir}/" + pd + n;
+
+ // Update the index of a sub-package which should own
+ // libdir/<private>/pkgconfig/.
+ //
+ if (priv)
+ update_ownership (pkgconfig_owner);
+ }
+ else
+ {
+ fs = &devel;
+ *fs += "%{_libdir}/" + pd + sd.string () + '/';
+ }
+ }
+ else
+ *fs += "%{_libdir}/" + pd + sd.string () + '/';
+
+ // In the case of the directory (has the trailing slash) skip
+ // all the other entries in this subdirectory (in the prefix map
+ // they will all be in a contiguous range).
+ //
+ if (fs->back () == '/')
+ {
+ while (p.first != p.second && p.first->first.sub (d))
+ ++p.first;
+ }
+
+ *fs += '\n';
+ }
+
+ // Update the index of a sub-package which should own
+ // libdir/<private>/.
+ //
+ if (priv)
+ update_ownership (private_owner);
+ }
+
+ // Add the directory ownership entries.
+ //
+ if (private_owner)
+ *owners[*private_owner] += "%dir %{_libdir}/" + pd + '\n';
+
+ if (pkgconfig_owner)
+ *owners[*pkgconfig_owner] += "%dir %{_libdir}/" + pd + "pkgconfig/" + '\n';
+ }
+
+ // We cannot just do usr/share/* since it will clash with doc/, man/,
+ // and licenses/ below. So we have to list all the top-level entries
+ // in usr/share/ that are not doc/, man/, or licenses/.
+ //
+ {
+ // Note that if <private>/ is specified, then we also need to
+ // establish ownership of the sharedir/<private>/ directory (similar
+ // to what we do for libdir/<private>/ above).
+ //
+ string* private_owner (nullptr);
+
+ string& fs (!st.common.empty () ? common : main);
+
+ for (auto p (ies.find_sub (sharedir)); p.first != p.second; )
+ {
+ const path& f ((p.first++)->first);
+
+ if (f.sub (docdir) || f.sub (mandir) || f.sub (licensedir))
+ continue;
+
+ path l (f.leaf (sharedir));
+
+ if (l.simple ())
+ {
+ fs += "%{_datadir}/" + pd + l.string () + '\n';
+ }
+ else
+ {
+ // Let's keep things tidy and use a sub-directory rather than
+ // listing all its sub-entries verbatim.
+ //
+ dir_path sd (*l.begin ());
+
+ fs += "%{_datadir}/" + pd + sd.string () + '\n';
+
+ // Skip all the other entries in this subdirectory (in the prefix
+ // map they will all be in a contiguous range).
+ //
+ dir_path d (sharedir / sd);
+ while (p.first != p.second && p.first->first.sub (d))
+ ++p.first;
+ }
+
+ // Indicate that we need to establish ownership of
+ // sharedir/<private>/.
+ //
+ if (priv)
+ private_owner = &fs;
+ }
+
+ // Add the directory ownership entry.
+ //
+ if (private_owner != nullptr)
+ *private_owner += "%dir %{_datadir}/" + pd + '\n';
+ }
+
+ // Should we put the documentation into -common if there is no -doc?
+ // While there doesn't seem to be anything explicit in the policy,
+ // there are packages that do it this way (e.g., mariadb-common). And
+ // the same logic seems to apply to -devel (e.g., zlib-devel).
+ //
+ {
+ string& fs (!st.doc.empty () ? doc :
+ !st.common.empty () ? common :
+ !st.devel.empty () ? devel :
+ main);
+
+ // Let's specify that the docdir/ sub-entries are documentation
+ // files. Note that the binary package documentation files can later
+ // be queried by the user via the `rpm --query --docfiles` command.
+ //
+ if (ies.contains_sub (docdir))
+ fs += "%doc %{_docdir}/" + (priv ? pd : "*") + '\n';
+
+ // Since the man file may not appear directly in the man/
+ // subdirectory we use the man/*/* wildcard rather than man/* not to
+ // declare ownership for standard directories.
+ //
+ // As a side note, rpmbuild compresses the man files in the
+ // installation directory, which needs to be taken into account if
+ // writing more specific wildcards (e.g., %{_mandir}/man1/foo.1*).
+ //
+ if (ies.contains_sub (mandir))
+ fs += "%{_mandir}/*/*\n";
+ }
+
+ // Let's specify that the licensedir/ sub-entries are license files.
+ // Note that the binary package license files can later be queried by
+ // the user via the `rpm --query --licensefiles` command.
+ //
+ if (ies.contains_sub (licensedir))
+ main += "%license %{_licensedir}/" + (priv ? pd : "*") + '\n';
+
+ // Finally, write the %files sections.
+ //
+ if (!main.empty ())
+ {
+ os << '\n'
+ << "# " << st.main << " files." << '\n'
+ << "#" << '\n'
+ << "%files" << '\n'
+ << main;
+ }
+
+ if (!devel.empty ())
+ {
+ os << '\n'
+ << "# " << st.devel << " files." << '\n'
+ << "#" << '\n'
+ << "%files -n " << st.devel << '\n'
+ << devel;
+ }
+
+ if (!static_.empty ())
+ {
+ os << '\n'
+ << "# " << st.static_ << " files." << '\n'
+ << "#" << '\n'
+ << "%files -n " << st.static_ << '\n'
+ << static_;
+ }
+
+ if (!doc.empty ())
+ {
+ os << '\n'
+ << "# " << st.doc << " files." << '\n'
+ << "#" << '\n'
+ << "%files -n " << st.doc << '\n'
+ << doc;
+ }
+
+ if (!common.empty ())
+ {
+ os << '\n'
+ << "# " << st.common << " files." << '\n'
+ << "#" << '\n'
+ << "%files -n " << st.common << '\n'
+ << common;
+ }
+ }
+
+ // Changelog section.
+ //
+ // The section entry has the following format:
+ //
+ // * <day-of-week> <month> <day> <year> <name> <surname> <email> - <version>-<release>
+ // - <change1-description>
+ // - <change2-description>
+ // ...
+ //
+ // For example:
+ //
+ // * Wed Feb 22 2023 John Doe <john@example.com> - 2.3.4-1
+ // - New bpkg package release 2.3.4.
+ //
+ // We will use the Packager value for the `<name> <surname> <email>`
+ // fields. Strictly speaking it may not exactly match the fields set but
+ // it doesn't seem to break anything if that's the case. For good
+ // measure, me will also use the English locale for the date.
+ //
+ // Note that the <release> field doesn't contain the distribution tag.
+ //
+ {
+ os << '\n'
+ << "%changelog" << '\n'
+ << "* ";
+
+ // Given that we don't include the timezone there is no much sense to
+ // print the current time as local.
+ //
+ std::locale l (os.imbue (std::locale ("C")));
+ to_stream (os,
+ system_clock::now (),
+ "%a %b %d %Y",
+ false /* special */,
+ false /* local */);
+ os.imbue (l);
+
+ os << ' ' << packager << " - ";
+
+ if (!sys_version.epoch.empty ())
+ os << sys_version.epoch << ':';
+
+ os << sys_version.version << '-' << sys_version.release << '\n'
+ << "- New bpkg package release " << pv.string () << '.' << '\n';
+ }
+
+ os.close ();
+ }
+ catch (const io_error& e)
+ {
+ fail << "unable to write to " << spec << ": " << e;
+ }
+
+ // Run rpmbuild.
+ //
+ // Note that rpmbuild causes recompilation periodically by setting the
+ // SOURCE_DATE_EPOCH environment variable (which we track for changes
+ // since it affects GCC). Its value depends on the timestamp of the latest
+ // change log entry and thus has a day resolution. Note that since we
+ // don't have this SOURCE_DATE_EPOCH during dry-run caused by
+ // installed_entries(), there would be a recompilation even if the value
+ // weren't changing.
+ //
+ cstrings args {"rpmbuild", "-bb"}; // Only build binary packages.
+
+ // Map our verbosity to rpmbuild --quiet and -vv options (-v is the
+ // default). Note that there doesn't seem to be any way to control its
+ // progress.
+ //
+ // Also note that even in the quiet mode rpmbuild may still print some
+ // progress lines.
+ //
+ if (verb == 0)
+ args.push_back ("--quiet");
+ else if (verb >= 4) // Note that -vv feels too verbose for level 3.
+ args.push_back ("-vv");
+
+ // If requested, keep the installation directory, etc.
+ //
+ if (ops_->keep_output ())
+ args.push_back ("--noclean");
+
+ // Pass our --jobs value, if any.
+ //
+ string jobs_arg;
+ if (size_t n = ops_->jobs_specified () ? ops_->jobs () : 0)
+ {
+ jobs_arg = "--define=_smp_build_ncpus " + to_string (n);
+ args.push_back (jobs_arg.c_str ());
+ }
+
+ // Pass the rpmbuild/rpm common options.
+ //
+ for (const string& o: common_opts)
+ args.push_back (o.c_str ());
+
+ // Pass any additional options specified by the user.
+ //
+ for (const string& o: ops_->fedora_build_option ())
+ args.push_back (o.c_str ());
+
+ args.push_back (spec.string ().c_str ());
+ args.push_back (nullptr);
+
+ if (ops_->fedora_prepare_only ())
+ {
+ if (verb >= 1)
+ {
+ diag_record dr (text);
+
+ dr << "prepared " << spec <<
+ text << "command line: ";
+
+ print_process (dr, args);
+ }
+
+ return paths {};
+ }
+
+ try
+ {
+ process_path pp (process::path_search (args[0]));
+ process_env pe (pp);
+
+ // There is going to be quite a bit of diagnostics so print the command
+ // line unless quiet.
+ //
+ if (verb >= 1)
+ print_process (pe, args);
+
+ // Redirect stdout to stderr since some of rpmbuild diagnostics goes
+ // there. For good measure also redirect stdin to /dev/null to make sure
+ // there are no prompts of any kind.
+ //
+ process pr (pp, args, -2 /* stdin */, 2 /* stdout */, 2 /* stderr */);
+
+ if (!pr.wait ())
+ {
+ // Let's repeat the command line even if it was printed at the
+ // beginning to save the user a rummage through the logs.
+ //
+ diag_record dr (fail);
+ dr << args[0] << " exited with non-zero code" <<
+ info << "command line: "; print_process (dr, pe, args);
+ }
+ }
+ catch (const process_error& e)
+ {
+ error << "unable to execute " << args[0] << ": " << e;
+
+ if (e.child)
+ exit (1);
+
+ throw failed ();
+ }
+
+ // While it's tempting to always keep the spec file let's remove it,
+ // unless requested not to, since it contains absolute paths to
+ // configuration.
+ //
+ if (!ops_->keep_output ())
+ rm (spec);
+
+ // Collect and return the binary sub-package paths.
+ //
+ // Here we will use `rpm --eval` to resolve the RPM sub-package paths.
+ //
paths r;
+ {
+ string expressions;
+
+ auto add_macro = [&expressions] (const string& name, const string& value)
+ {
+ expressions += "%global " + name + ' ' + value + '\n';
+ };
+
+ add_macro ("VERSION", sys_version.version);
+ add_macro ("RELEASE", sys_version.release + "%{?dist}");
+
+ const string& package_arch (!build_arch.empty () ? build_arch : arch);
+
+ size_t np (0);
+ auto add_package = [&expressions, &rpmfile, &np, &add_macro]
+ (const string& name, const string& arch) -> size_t
+ {
+ add_macro ("NAME", name);
+ add_macro ("ARCH", arch);
+ expressions += rpmfile + '\n';
+ return np++;
+ };
+
+ add_package (st.main, package_arch);
+
+ if (!st.devel.empty ())
+ add_package (st.devel, package_arch);
+
+ if (!st.static_.empty ())
+ add_package (st.static_, package_arch);
+
+ if (!st.doc.empty ())
+ add_package (st.doc, "noarch");
+
+ if (!st.common.empty ())
+ add_package (st.common, "noarch");
+
+ size_t di (add_package (st.main + "-debuginfo", arch));
+
+ // Strip the trailing newline since rpm adds one.
+ //
+ expressions.pop_back ();
+
+ strings expansions (eval (cstrings ({expressions.c_str ()})));
+
+ if (expansions.size () != np)
+ fail << "number of RPM file path expansions differs from number "
+ << "of path expressions";
+
+ r.reserve (np);
+
+ for (size_t i (0); i != expansions.size(); ++i)
+ {
+ try
+ {
+ path p (move (expansions[i]));
+
+ if (p.empty ())
+ throw invalid_path ("");
+
+ // Note that the -debuginfo sub-package may potentially not be
+ // generated (no installed binaries to extract the debug info from,
+ // etc).
+ //
+ if (exists (p))
+ r.push_back (move (p));
+ else if (i != di) // Not a -debuginfo sub-package?
+ fail << "expected output file " << p << " does not exist";
+ }
+ catch (const invalid_path& e)
+ {
+ fail << "invalid path '" << e.path << "' in RPM file path expansions";
+ }
+ }
+ }
+
return r;
}
}