diff options
| -rw-r--r-- | bpkg/system-package-manager-fedora.cxx | 1072 | ||||
| -rw-r--r-- | bpkg/system-package-manager-fedora.hxx | 95 |
2 files changed, 1013 insertions, 154 deletions
diff --git a/bpkg/system-package-manager-fedora.cxx b/bpkg/system-package-manager-fedora.cxx index a22bfba..e3e7f19 100644 --- a/bpkg/system-package-manager-fedora.cxx +++ b/bpkg/system-package-manager-fedora.cxx @@ -19,7 +19,8 @@ namespace bpkg // extra_{doc,dbg} arguments. // package_status system_package_manager_fedora:: - parse_name_value (const string& nv, + parse_name_value (const package_name& pn, + const string& nv, bool extra_doc, bool extra_debuginfo, bool extra_debugsource) @@ -39,7 +40,8 @@ namespace bpkg return nn > sn && n.compare (nn - sn, sn, s) == 0; }; - auto parse_group = [&split, &suffix] (const string& g) + auto parse_group = [&split, &suffix] (const string& g, + const package_name* pn) { strings ns (split (g, ' ')); @@ -48,8 +50,10 @@ namespace bpkg package_status r; - // Handle the devel instead of main special case for libraries. + // Handle the "devel instead of main" special case for libraries. // + // Note: the lib prefix check is based on the bpkg package name. + // // Check that the following name does not end with -devel. This will be // the only way to disambiguate the case where the library name happens // to end with -devel (e.g., libops-devel libops-devel-devel). @@ -57,7 +61,9 @@ namespace bpkg { string& m (ns[0]); - if (suffix (m, "-devel") && + if (pn != nullptr && + pn->string ().compare (0, 3, "lib") == 0 && + suffix (m, "-devel") && !(ns.size () > 1 && suffix (ns[1], "-devel"))) { r = package_status ("", move (m)); @@ -100,10 +106,10 @@ namespace bpkg for (size_t i (0); i != gs.size (); ++i) { if (i == 0) // Main group. - r = parse_group (gs[i]); + r = parse_group (gs[i], &pn); else { - package_status g (parse_group (gs[i])); + package_status g (parse_group (gs[i], nullptr)); if (!g.main.empty ()) r.extras.push_back (move (g.main)); if (!g.devel.empty ()) r.extras.push_back (move (g.devel)); @@ -126,6 +132,41 @@ namespace bpkg return r; } + // Attempt to determine the main package name from its -devel package based + // on the extracted dependencies. Return empty string if unable to. + // + string system_package_manager_fedora:: + main_from_dev (const string& devel_name, + const string& devel_ver, + const vector<pair<string, string>>& depends) + { + // For the main package we look for a dependency with the name + // <devel-stem> and the devel_ver version. Failed that, try the + // <devel-stem>-libs name instead. + // + string devel_stem (devel_name, 0, devel_name.rfind ("-devel")); + + auto find = [&devel_ver, &depends] (const string& n) + { + auto i (find_if (depends.begin (), depends.end (), + [&n, &devel_ver] (const pair<string, string>& d) + { + return d.first == n && d.second == devel_ver; + })); + + return i != depends.end () ? i->first : empty_string; + }; + + // Note that for a mixed package we need to rather end up with the -libs + // subpackage rather that with the base package. Think of the following + // package: + // + // openssl openssl-libs openssl-devel + // + string r (find (devel_stem + "-libs")); + return !r.empty () ? r : find (devel_stem); + } + static process_path dnf_path; static process_path sudo_path; @@ -135,35 +176,35 @@ namespace bpkg // If the n argument is not 0, then only query the first n packages. // void system_package_manager_fedora:: - dnf_list (vector<package_policy>& pps, size_t n) + dnf_list (vector<package_info>& pis, size_t n) { if (n == 0) - n = pps.size (); + n = pis.size (); - assert (n != 0 && n <= pps.size ()); + assert (n != 0 && n <= pis.size ()); - // In particular, --quiet makes sure we don't get 'Last metadata - // expiration check: <timestamp>' printed to stderr. It does not appear to - // affect error diagnostics (try specifying an unknown package). + // The --quiet option makes sure we don't get 'Last metadata expiration + // check: <timestamp>' printed to stderr. It does not appear to affect + // error diagnostics (try specifying an unknown package). // cstrings args { "dnf", "list", "--all", - "--cacheonly" + "--cacheonly", "--quiet"}; for (size_t i (0); i != n; ++i) { - package_policy& pp (pps[i]); + package_info& pi (pis[i]); - string& n (pp.name); + string& n (pi.name); assert (!n.empty ()); - pp.installed_version.clear (); - pp.candidate_version.clear (); + pi.installed_version.clear (); + pi.candidate_version.clear (); - n += '.'; - n += host_.cpu; + pi.installed_arch.clear (); + pi.candidate_arch.clear (); args.push_back (n.c_str ()); } @@ -268,6 +309,10 @@ namespace bpkg print_process (dr, pe, args); }); + // If true, then we inside the 'Installed Packages' section. If + // false, then we inside the 'Available Packages' section. Initially + // nullopt. + // optional<bool> installed; for (string l; !eof (getline (is, l)); ) { @@ -315,27 +360,57 @@ namespace bpkg string v (l, b, e - b); // While we don't really care about the rest of the line, let's - // for good measure verify that it also contains a repository id. + // verify that it also contains a repository id, for good measure. // b = l.find_first_not_of (' ', e); if (b == string::npos) fail << "expected package repository in '" << l << "'"; + // Skip the special dnf package. + // if (p == "dnf.noarch") continue; - // Find the package. + // Separate the architecture from the package name. + // + e = p.rfind ('.'); + + if (e == string::npos || e == p.size () - 1) + fail << "can't deduce architecture for package '" << p + << "' in '" << l << "'"; + + string a (p, e + 1); + + // Skip the package of a different architecture. + // + if (a != host_.cpu && a != "noarch") + continue; + + p.resize (e); + + // Find the package info to update. // - auto i (find_if (pps.begin (), pps.end (), - [&p] (const package_policy& pp) - {return pp.name == p;})); + auto i (find_if (pis.begin (), pis.end (), + [&p] (const package_info& pi) + {return pi.name == p;})); - if (i == pps.end ()) + if (i == pis.end ()) fail << "unexpected package name '" << p << "' in '" << l << "'"; - (*installed ? i->installed_version : i->candidate_version) = - move (v); + string& ver (*installed + ? i->installed_version + : i->candidate_version); + + if (!ver.empty ()) + fail << "multiple " << (*installed ? "installed " : "available ") + << "versions of package '" << p << "'" << + info << "first: " << ver << + info << "second: " << v; + + ver = move (v); + + (*installed ? i->installed_arch : i->candidate_arch) = move (a); } } @@ -380,11 +455,19 @@ namespace bpkg // returned. // vector<pair<string, string>> system_package_manager_fedora:: - dnf_repoquery_requires (const string& name, const string& ver) + dnf_repoquery_requires (const string& name, + const string& ver, + const string& arch) { assert (!name.empty () && !ver.empty ()); - string spec (name + '-' + ver); + // Qualify the package with an architecture suffix. + // + // Note that by reason unknown, the below command may also print + // dependency packages of different architectures. It feels sensible to + // just skip them. + // + string spec (name + '-' + ver + '.' + arch); // In particular, --quiet makes sure we don't get 'Last metadata // expiration check: <timestamp>' printed to stderr. It does not appear to @@ -393,8 +476,7 @@ namespace bpkg const char* args[] = { "dnf", "repoquery", "--requires", "--resolve", - "--arch", host_.cpu.c_str (), - "--qf", "%{name} %{version}-%{release}", + "--qf", "%{name} %{arch} %{epoch}:%{version}-%{release}", "--cacheonly", "--quiet", spec.c_str (), @@ -473,35 +555,61 @@ namespace bpkg { ifdstream is (move (pr.in_ofd), fdstream_mode::skip, ifdstream::badbit); - // The output of `dnf repoquery --requires <pkg>-<ver>` will be the - // sequence of the dependency package lines in the `<name> <version>` - // form. Here is a representative example: + // The output of the command will be the sequence of the dependency + // package lines in the `<name> <arc> <version>` form. So for example + // for the libicu-devel-69.1-6.fc35.x86_64 package it is as follows: // - // bash 5.1.8-3.fc35 - // glibc 2.34-49.fc35 - // libicu 69.1-6.fc35 - // libicu-devel 69.1-6.fc35 - // pkgconf-pkg-config 1.8.0-1.fc35 + // bash i686 0:5.1.8-3.fc35 + // bash x86_64 0:5.1.8-3.fc35 + // glibc i686 0:2.34-49.fc35 + // glibc x86_64 0:2.34-49.fc35 + // libicu x86_64 0:69.1-6.fc35 + // libicu-devel i686 0:69.1-6.fc35 + // libicu-devel x86_64 0:69.1-6.fc35 + // pkgconf-pkg-config i686 0:1.8.0-1.fc35 + // pkgconf-pkg-config x86_64 0:1.8.0-1.fc35 // for (string l; !eof (getline (is, l)); ) { - size_t p (l.find (' ')); + size_t e (l.find (' ')); + + if (l.empty () || e == 0) + fail << "expected package name in '" << l << "'"; + + if (e == string::npos) + fail << "expected package architecture in '" << l << "'"; - if (p == string::npos) - fail << "expected package name and version instead of '" << l - << "'"; + string p (l, 0, e); - // Split the line into the package name and version. + size_t b (e + 1); + e = l.find (' ', b); + + if (e == string::npos) + fail << "expected package version in '" << l << "'"; + + string a (l, b, e - b); + if (a.empty ()) + fail << "expected package architecture in '" << l << "'"; + + string v (l, e + 1); + + // Strip the '0:' epoch to align with package versions retrieved by + // other functions (dnf_list(), etc). // - string v (l, p + 1); - l.resize (p); // Name. + e = v.find (':'); + if (e == string::npos || e == 0) + fail << "no epoch for package version in '" << l << "'"; + + if (e == 1 && v[0] == '0') + v.erase (0, 2); - // Skip the potential self-dependency line (see the above example). + // Skip the potential self-dependency line (see the above example) + // and dependencies of a different architecture. // - if (l == name && v == ver) + if (l == name || (a != host_.cpu && a != "noarch")) continue; - r.emplace_back (move (l), move (v)); + r.emplace_back (move (p), move (v)); } is.close (); @@ -539,13 +647,285 @@ namespace bpkg return r; } + // Prepare the common options for `dnf makecache` and `dnf install` + // commands. + // + pair<cstrings, const process_path&> system_package_manager_fedora:: + dnf_common (const char* command) + { + cstrings args; + + if (!sudo_.empty ()) + args.push_back (sudo_.c_str ()); + + args.push_back ("dnf"); + args.push_back (command); + + // Map our verbosity/progress to dnf --quiet and --verbose options. + // + // Note that all the diagnostics, including the progress indication but + // excluding error messages, is printed to stdout. By default the progress + // bar for network transfers is printed, unless stdout is not a terminal. + // The --quiet option disables printing the plan and all the progress + // output, but not the confirmation prompt nor error messages. + // + if (progress_ && *progress_) + { + // Print the progress bar by default, unless this is not a terminal. + } + else if (verb == 0) + { + args.push_back ("--quiet"); + } + else if (verb > 3) + { + args.push_back ("--verbose"); + } + else if (progress_ && !*progress_) + { + args.push_back ("--quiet"); + } + + if (yes_) + { + args.push_back ("--assumeyes"); + } + else if (!stderr_term) + { + // Suppress any prompts if stderr is not a terminal for good measure. + // + args.push_back ("--assumeno"); + } + + try + { + const process_path* pp (nullptr); + + if (!sudo_.empty ()) + { + if (sudo_path.empty () && !simulate_) + sudo_path = process::path_search (args[0]); + + pp = &sudo_path; + } + else + { + if (dnf_path.empty () && !simulate_) + dnf_path = process::path_search (args[0]); + + pp = &dnf_path; + } + + return pair<cstrings, const process_path&> (move (args), *pp); + } + catch (const process_error& e) + { + error << "unable to execute " << args[0] << ": " << e; + + if (e.child) + exit (1); + + throw failed (); + } + } + + // Execute `dnf makecache` to download and cache the repositories metadata. + // + void system_package_manager_fedora:: + dnf_makecache () + { + pair<cstrings, const process_path&> args_pp (dnf_common ("makecache")); + + cstrings& args (args_pp.first); + const process_path& pp (args_pp.second); + + args.push_back ("--refresh"); + args.push_back (nullptr); + + try + { + if (verb >= 2) + print_process (args); + else if (verb == 1) + text << "updating " << os_release_.name_id + << " repositories metadata..."; + + process pr; + if (!simulate_) + pr = process (pp, args, 0 /* stdin */, 2 /* stdout */); + else + { + print_process (args); + // @@ TODO + //pr = process (process_exit (simulate_->apt_get_update_fail_ ? 100 : 0)); + } + + if (!pr.wait ()) + { + diag_record dr (fail); + dr << "dnf makecache exited with non-zero code"; + + if (verb < 2) + { + dr << info << "command line: "; + print_process (dr, args); + } + } + + if (verb == 1) + text << "updated " << os_release_.name_id << " repositories metadata"; + } + catch (const process_error& e) + { + error << "unable to execute " << args[0] << ": " << e; + + if (e.child) + exit (1); + + throw failed (); + } + } + + // Execute `dnf install` to install the specified packages/versions (e.g., + // libfoo or libfoo-1.2.3) and the `dnf mark install` to mark the specified + // packages as installed by user. + // + void system_package_manager_fedora:: + dnf_install (const strings& pkgs) + { + assert (!pkgs.empty ()); + + // Install. + // + { + pair<cstrings, const process_path&> args_pp (dnf_common ("install")); + + cstrings& args (args_pp.first); + const process_path& pp (args_pp.second); + + // Note that we can't use --cacheonly here to prevent the metadata + // update, since the install command expects the package RPM files to + // also be cached then and fails if that's not the case. Thus we + // override the metadata_expire=never configuration option instead. + // + args.push_back ("--setopt=metadata_expire=never"); + + for (const string& p: pkgs) + args.push_back (p.c_str ()); + + args.push_back (nullptr); + + try + { + if (verb >= 2) + print_process (args); + else if (verb == 1) + text << "installing " << os_release_.name_id << " packages..."; + + process pr; + if (!simulate_) + pr = process (pp, args, 0 /* stdin */, 2 /* stdout */); + else + { + print_process (args); + // @@ TODO + //pr = process (process_exit (simulate_->apt_get_install_fail_ ? 100 : 0)); + } + + if (!pr.wait ()) + { + diag_record dr (fail); + dr << "dnf install exited with non-zero code"; + + if (verb < 2) + { + dr << info << "command line: "; + print_process (dr, args); + } + + dr << info << "consider resolving the issue manually and retrying " + << "the bpkg command"; + } + } + catch (const process_error& e) + { + error << "unable to execute " << args[0] << ": " << e; + + if (e.child) + exit (1); + + throw failed (); + } + } + + // Mark as installed. + // + { + pair<cstrings, const process_path&> args_pp (dnf_common ("mark")); + + cstrings& args (args_pp.first); + const process_path& pp (args_pp.second); + + args.push_back ("install"); + args.push_back ("--cacheonly"); + + for (const string& p: pkgs) + args.push_back (p.c_str ()); + + args.push_back (nullptr); + + try + { + if (verb >= 2) + print_process (args); + + process pr; + if (!simulate_) + pr = process (pp, args, 0 /* stdin */, 2 /* stdout */); + else + { + print_process (args); + // @@ TODO + //pr = process (process_exit (simulate_->apt_get_install_fail_ ? 100 : 0)); + } + + if (!pr.wait ()) + { + diag_record dr (fail); + dr << "dnf mark install exited with non-zero code"; + + if (verb < 2) + { + dr << info << "command line: "; + print_process (dr, args); + } + + dr << info << "consider resolving the issue manually and retrying " + << "the bpkg command"; + } + + if (verb == 1) + text << "installed " << os_release_.name_id << " packages"; + } + catch (const process_error& e) + { + error << "unable to execute " << args[0] << ": " << e; + + if (e.child) + exit (1); + + throw failed (); + } + } + } + optional<const system_package_status*> system_package_manager_fedora:: pkg_status (const package_name& pn, const available_packages* aps) { // For now we ignore -doc and -debug* package components (but we may want // to have options controlling this later). Note also that we assume // -common is pulled automatically by the base package so we ignore it as - // well. + // well (see equivalent logic in parse_name_value()). // bool need_doc (false); bool need_debuginfo (false); @@ -582,44 +962,35 @@ namespace bpkg if (ns.empty ()) { // Attempt to automatically translate our package name (see above for - // details). + // details). Failed that we should try to use the project name, if + // present, instead. // const string& n (pn.string ()); + assert (!aps->empty ()); + + const shared_ptr<available_package>& ap (aps->front ().first); + string p (ap->project && *ap->project != n + ? ap->project->string () + : empty_string); + // 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 should probably to also/instead consider the project name. We - // will need to add it to available_package type then and take it - // from the latest available package. - // - // const string* prj (aps != nullptr && aps->front ().project - // ? &aps->front ().project->string () - // : nullptr); - // if (n.compare (0, 3, "lib") == 0) { + if (!p.empty ()) + p += "-devel"; + // Keep the base package name empty as an indication that it is to // be discovered. // - candidates.push_back (package_status ("", n + "-devel")); - - // @@ Add the project-based candidate. - // - // if (prj != nullptr) - // candidates.push_back (package_status ("", *prj + "-devel")); + candidates.push_back (package_status ("", n + "-devel", move (p))); } else - { - candidates.push_back (package_status (n)); - - // @@ Add the project-based candidate. - // - // if (prj != nullptr) - // candidates.push_back (package_status ("", *prj)); - } + candidates.push_back (package_status (n, "", move (p))); } else { @@ -627,8 +998,11 @@ namespace bpkg // for (const string& n: ns) { - package_status s ( - parse_name_value (n, need_doc, need_debuginfo, need_debugsource)); + package_status s (parse_name_value (pn, + n, + need_doc, + need_debuginfo, + need_debugsource)); // Suppress duplicates for good measure based on the base package // name (and falling back to -devel if empty). @@ -636,108 +1010,417 @@ namespace bpkg auto i (find_if (candidates.begin (), candidates.end (), [&s] (const package_status& x) { - return s.main.empty () - ? s.devel == x.devel - : s.main == x.main; + // Note that it's possible for one mapping to be + // specified as -devel only while the other as + // main and -devel. + // + return s.main.empty () || x.main.empty () + ? s.devel == x.devel + : s.main == x.main; })); if (i == candidates.end ()) candidates.push_back (move (s)); else { - // @@ Should we verify the rest matches for good measure? + // Should we verify the rest matches for good measure? But what if + // we need to override, as in: + // + // fedora_35-name: libfoo libfoo-bar-dev + // fedora_34-name: libfoo libfoo-dev + // + // Note that for this to work we must get fedora_35 values before + // fedora_34, which is the semantics guaranteed by + // system_package_names(). } } } } - // Guess unknown main package given the devel package and its version. + // Guess unknown main package given the -devel package and its version. // - auto guess_main = [this, &pn] (package_status& s, const string& ver) + auto guess_main = [this, &pn] (package_status& s, + const string& ver, + const string& arch) { vector<pair<string, string>> depends ( - dnf_repoquery_requires (s.devel, ver)); -#if 0 - s.main = main_from_dev (s.dev, ver, depends); + dnf_repoquery_requires (s.devel, ver, arch)); + + s.main = main_from_dev (s.devel, ver, depends); if (s.main.empty ()) { - fail << "unable to guess main Debian package for " << s.dev << ' ' - << ver << - info << s.dev << " Depends value: " << depends << - info << "consider specifying explicit mapping in " << pn - << " package manifest"; + diag_record dr (fail); + dr << "unable to guess main " << os_release_.name_id + << " package for " << s.devel << ' ' << ver << + info << "depends on"; + + bool first (true); + for (const pair<string, string>& d: depends) + { + if (first) + first = false; + else + dr << ','; + + dr << d.first << ' ' << d.second; + } + + dr << info << "consider specifying explicit mapping in " << pn + << " package manifest"; } -#endif }; - // First look for an already fully installed package. + // Calculate the package status from individual package components. + // Return nullopt if there is a component without installed or candidate + // version (which means the package cannot be installed). // - optional<package_status> r; + // The main argument specifies the size of the main group. Only components + // from this group are considered for partially_installed determination. + // + // @@ TODO: we should probably prioritize partially installed with fully + // installed main group. Add almost_installed next to partially_installed? + // + using status_type = package_status::status_type; + + auto status = [] (const vector<package_info>& pis, size_t main) + -> optional<status_type> + { + bool i (false), u (false); + + for (size_t j (0); j != pis.size (); ++j) + { + const package_info& pi (pis[j]); + + if (pi.installed_version.empty ()) + { + if (pi.candidate_version.empty ()) + return nullopt; + + u = true; + } + else if (j < main) + i = true; + } + + return (!u ? package_status::installed : + !i ? package_status::not_installed : + package_status::partially_installed); + }; + // First look for an already fully installed package. + // + // But first, choose between the package name-based and project-based + // guessed system package name. + // for (package_status& ps: candidates) { - vector<package_policy>& pps (ps.package_policies); + vector<package_info>& pis (ps.package_infos); - if (!ps.main.empty ()) pps.emplace_back (ps.main); - if (!ps.devel.empty ()) pps.emplace_back (ps.devel); - if (!ps.doc.empty () && need_doc) pps.emplace_back (ps.doc); + if (!ps.main.empty ()) pis.emplace_back (ps.main); + if (!ps.devel.empty ()) pis.emplace_back (ps.devel); + if (!ps.fallback.empty ()) pis.emplace_back (ps.fallback); + if (!ps.doc.empty () && need_doc) pis.emplace_back (ps.doc); if (!ps.debuginfo.empty () && need_debuginfo) - pps.emplace_back (ps.debuginfo); + pis.emplace_back (ps.debuginfo); if (!ps.debugsource.empty () && need_debugsource) - pps.emplace_back (ps.debugsource); + pis.emplace_back (ps.debugsource); - if (!ps.common.empty () && false) pps.emplace_back (ps.common); - ps.package_policies_main = pps.size (); - for (const string& n: ps.extras) pps.emplace_back (n); + if (!ps.common.empty () && false) pis.emplace_back (ps.common); + ps.package_infos_main = pis.size (); + for (const string& n: ps.extras) pis.emplace_back (n); - dnf_list (pps); + dnf_list (pis); - // Handle the unknown main package. + // If the (project-based) fallback system package name is specified, + // then choose between the guessed and fallback names depending on which + // of them is known to the system package manager. + // + // Specifically, if the guessed system package exists we use that. + // Otherwise, if the fallback system package exists we use that and fail + // otherwise. // - if (ps.main.empty ()) + if (!ps.fallback.empty ()) { - const package_policy& devel (pps.front ()); + assert (pis.size () > 1); // devel, fallback,... or main, fallback,... - // Note that at this stage we can only use the installed devel package - // (since the candidate version may change after fetch). + // Either devel or main is guessed. // - if (devel.installed_version.empty ()) - continue; + bool guessed_devel (!ps.devel.empty ()); + assert (guessed_devel == ps.main.empty ()); + + string& guessed (guessed_devel ? ps.devel : ps.main); + + package_info& gi (pis[0]); // Guessed package info. + package_info& fi (pis[1]); // Fallback package info. + + if (gi.unknown ()) + { + if (fi.known ()) + { + guessed = move (ps.fallback); + gi = move (fi); + } + else + { + fail << "unable to guess " << (guessed_devel ? "devel" : "main") + << ' ' << os_release_.name_id << " package for " << pn << + info << "neither " << guessed << " nor " << ps.fallback + << ' ' << os_release_.name_id << " package exists" << + info << "consider specifying explicit mapping in " << pn + << " package manifest"; + + } + } - guess_main (ps, devel.installed_version); - pps.emplace (pps.begin (), ps.main); - ps.package_policies_main++; - dnf_list (pps, 1); + // Whether it was used or not, cleanup the fallback information. + // + ps.fallback.clear (); + pis.erase (pis.begin () + 1); + --ps.package_infos_main; } + } -#if 0 - optional<status_type> s (status (pps, ps.package_policies_main)); + optional<package_status> r; - if (!s) - continue; + { + diag_record dr; // Ambiguity diagnostics. - if (*s == package_status::installed) + for (package_status& ps: candidates) { - const package_policy& main (pps.front ()); + vector<package_info>& pis (ps.package_infos); + + // Handle the unknown main package. + // + if (ps.main.empty ()) + { + const package_info& devel (pis.front ()); + + // Note that at this stage we can only use the installed -devel + // package (since the candidate version may change after fetch). + // + if (devel.installed_version.empty ()) + continue; + + guess_main (ps, devel.installed_version, devel.installed_arch); + pis.emplace (pis.begin (), ps.main); + ps.package_infos_main++; + dnf_list (pis, 1); + } + + optional<status_type> s (status (pis, ps.package_infos_main)); + + if (!s || *s != package_status::installed) + continue; + + const package_info& main (pis.front ()); ps.status = *s; ps.system_name = main.name; ps.system_version = main.installed_version; - if (r) + if (!r) + { + r = move (ps); + continue; + } + + if (dr.empty ()) + { + dr << fail << "multiple installed " << os_release_.name_id + << " packages for " << pn << + info << "candidate: " << r->main << " " << r->system_version; + } + + dr << info << "candidate: " << ps.main << " " << ps.system_version; + } + + if (!dr.empty ()) + dr << info << "consider specifying the desired version manually"; + } + + // Next look for available versions if we are allowed to install. + // + if (!r && install_) + { + // If we weren't instructed to fetch or we already fetched, then we + // don't need to re-run dnf_list(). + // + bool requery; + if ((requery = fetch_ && !fetched_)) + { + dnf_makecache (); + fetched_ = true; + } + + { + diag_record dr; // Ambiguity diagnostics. + + for (package_status& ps: candidates) + { + vector<package_info>& pis (ps.package_infos); + + if (requery) + dnf_list (pis); + + // Handle the unknown main package. + // + if (ps.main.empty ()) + { + const package_info& devel (pis.front ()); + + // Note that this time we use the candidate version. + // + if (devel.candidate_version.empty ()) + continue; // Not installable. + + guess_main (ps, devel.candidate_version, devel.candidate_arch); + pis.emplace (pis.begin (), ps.main); + ps.package_infos_main++; + dnf_list (pis, 1); + } + + optional<status_type> s (status (pis, ps.package_infos_main)); + + if (!s) + { + ps.main.clear (); // Not installable. + continue; + } + + assert (*s != package_status::installed); // Sanity check. + + const package_info& main (pis.front ()); + + // Note that if we are installing something for this main package, + // then we always go for the candidate version even though it may + // have an installed version that may be good enough (especially if + // what we are installing are extras). The reason is that it may as + // well not be good enough (especially if we are installing the -dev + // package) and there is no straightforward way to change our mind. + // + ps.status = *s; + ps.system_name = main.name; + ps.system_version = main.candidate_version; + + // Prefer partially installed to not installed. This makes detecting + // ambiguity a bit trickier so we handle partially installed here + // and not installed in a separate loop below. + // + if (ps.status != package_status::partially_installed) + continue; + + if (!r) + { + r = move (ps); + continue; + } + + auto print_missing = [&dr] (const package_status& s) + { + for (const package_info& pi: s.package_infos) + if (pi.installed_version.empty ()) + dr << ' ' << pi.name; + }; + + if (dr.empty ()) + { + dr << fail << "multiple partially installed " + << os_release_.name_id << " packages for " << pn; + + dr << info << "candidate: " << r->main << " " << r->system_version + << ", missing components:"; + print_missing (*r); + } + + dr << info << "candidate: " << ps.main << " " << ps.system_version + << ", missing components:"; + print_missing (ps); + } + + if (!dr.empty ()) + dr << info << "consider fully installing the desired package " + << "manually and retrying the bpkg command"; + } + + if (!r) + { + diag_record dr; // Ambiguity diagnostics. + + for (package_status& ps: candidates) { - fail << "multiple installed " << os_release_.name_id + if (ps.main.empty ()) + continue; + + assert (ps.status == package_status::not_installed); // Sanity check. + + if (!r) + { + r = move (ps); + continue; + } + + if (dr.empty ()) + { + dr << fail << "multiple available " << os_release_.name_id << " packages for " << pn << - info << "first package: " << r->main << " " << r->system_version << - info << "second package: " << ps.main << " " << ps.system_version << - info << "consider specifying the desired version manually"; + info << "candidate: " << r->main << " " << r->system_version; + } + + dr << info << "candidate: " << ps.main << " " << ps.system_version; } - r = move (ps); + if (!dr.empty ()) + dr << info << "consider installing the desired package manually and " + << "retrying the bpkg command"; } -#endif + } + + if (r) + { + // Map the Fedora version to the bpkg version. But first strip the + // revision from Fedora version ([<epoch>:]<version>-<release>). + // + // Note that according to deb-version(5), <upstream> may contain `:`/`-` + // but in these cases <epoch>/<revision> must be specified explicitly, + // respectively. + // + string sv (r->system_version, 0, r->system_version.rfind ('-')); + + optional<version> v ( + downstream_package_version (sv, + *aps, + os_release_.name_id, + os_release_.version_id, + os_release_.like_ids)); + + if (!v) + { + // Fallback to using system version as downstream version. But first + // strip the epoch, if any. + // + size_t p (sv.find (':')); + if (p != string::npos) + sv.erase (0, p + 1); + + try + { + v = version (sv); + } + catch (const invalid_argument& e) + { + fail << "unable to map " << os_release_.name_id << " package " + << r->system_name << " version " << sv << " to bpkg package " + << pn << " version" << + info << os_release_.name_id << " version is not a valid bpkg " + << "version: " << e.what () << + info << "consider specifying explicit mapping in " << pn + << " package manifest"; + } + } + + r->version = move (*v); } // Cache. @@ -747,8 +1430,141 @@ namespace bpkg } void system_package_manager_fedora:: - pkg_install (const vector<package_name>& /*pns*/) + pkg_install (const vector<package_name>& pns) { - // @@ TODO + assert (!pns.empty ()); + + assert (install_ && !installed_); + installed_ = true; + + // Collect and merge all the Fedora packages/version for the specified + // bpkg packages. + // + struct package + { + string name; + string version; // Empty if unspecified. + }; + vector<package> pkgs; + + for (const package_name& pn: pns) + { + auto it (status_cache_.find (pn)); + assert (it != status_cache_.end () && it->second); + + const package_status& ps (*it->second); + + // @@ Amend. + // + // At first it may seem we don't need to do anything for already fully + // installed packages. But it's possible some of them were automatically + // installed, meaning that they can be automatically removed if they no + // longer have any dependents (see dnf(8) for details). Which in + // turn means that things may behave differently depending on whether + // we've installed a package ourselves or if it was already installed. + // So instead we are going to also pass the already fully installed + // packages which will make sure they are all set to manually installed. + // But we must be careful not to force their upgrade. To achieve this + // we will specify the installed version as the desired version. + // + // Note also that for partially/not installed we don't specify the + // version, expecting the candidate version to be installed. + // + bool fi (ps.status == package_status::installed); + + for (const package_info& pi: ps.package_infos) + { + string n (pi.name); + string v (fi ? pi.installed_version : string ()); + + auto i (find_if (pkgs.begin (), pkgs.end (), + [&n] (const package& p) + { + return p.name == n; + })); + + if (i != pkgs.end ()) + { + if (i->version.empty ()) + i->version = move (v); + else + // Feels like this cannot happen since we always use the installed + // version of the package. + // + assert (i->version == v); + } + else + pkgs.push_back (package {move (n), move (v)}); + } + } + + // Install. + // + { + // Convert to the `dnf install` <pkg>[-<ver>] form. + // + strings specs; + specs.reserve (pkgs.size ()); + for (const package& p: pkgs) + { + string s (p.name); + if (!p.version.empty ()) + { + s += '-'; + s += p.version; + } + specs.push_back (move (s)); + } + + dnf_install (specs); + } + + // Verify that versions we have promised in pkg_status() match what + // actually got installed. + // + { + vector<package_info> pis; + + // Here we just check the main package component of each package. + // + for (const package_name& pn: pns) + { + const package_status& ps (*status_cache_.find (pn)->second); + + if (find_if (pis.begin (), pis.end (), + [&ps] (const package_info& pi) + { + return pi.name == ps.system_name; + }) == pis.end ()) + { + pis.push_back (package_info (ps.system_name)); + } + } + + dnf_list (pis); + + for (const package_name& pn: pns) + { + const package_status& ps (*status_cache_.find (pn)->second); + + auto i (find_if (pis.begin (), pis.end (), + [&ps] (const package_info& pi) + { + return pi.name == ps.system_name; + })); + assert (i != pis.end ()); + + const package_info& pi (*i); + + if (pi.installed_version != ps.system_version) + { + fail << "unexpected " << os_release_.name_id << " package version " + << "for " << ps.system_name << + info << "expected: " << ps.system_version << + info << "installed: " << pi.installed_version << + info << "consider retrying the bpkg command"; + } + } + } } } diff --git a/bpkg/system-package-manager-fedora.hxx b/bpkg/system-package-manager-fedora.hxx index 129a9d2..8047836 100644 --- a/bpkg/system-package-manager-fedora.hxx +++ b/bpkg/system-package-manager-fedora.hxx @@ -14,6 +14,8 @@ namespace bpkg // The system package manager implementation for Fedora and alike (Red Hat // Enterprise Linux, CentOS, etc) using the DNF frontend. // + // NOTE: the below description is also reproduced in the bpkg manual. + // // For background, a library in Fedora is normally split up into several // packages: the shared library package (e.g., libfoo), the development // files package (e.g., libfoo-devel), the static library package (e.g., @@ -27,7 +29,7 @@ namespace bpkg // name has it (see some examples below). // // For mixed packages which include both applications and libraries, the - // shared library package normally have the -libs suffix (e.g., foo-libs). + // shared library package normally has the -libs suffix (e.g., foo-libs). // // A package name may also include an upstream version based suffix if // multiple versions of the package can be installed simultaneously (e.g., @@ -51,7 +53,7 @@ namespace bpkg // // icu libicu libicu-devel libicu-doc // - // openssl openssl-devel openssl-libs + // openssl openssl-libs openssl-devel // // curl libcurl libcurl-devel // @@ -73,7 +75,7 @@ namespace bpkg // For application packages there is normally no -devel packages but // -debug*, -doc, and -common are plausible. // - // The format of the fedora-name (or alike) manifest value value is a comma- + // The format of the fedora-name (or alike) manifest value is a comma- // separated list of one or more package groups: // // <package-group> [, <package-group>...] @@ -110,12 +112,12 @@ namespace bpkg // The Fedora package version has the [<epoch>:]<version>-<release> form // where the parts correspond to the Epoch (optional upstream versioning // scheme), Version (upstream version), and Release (Fedora's package - // revision) RPM tags (see the Fedora package Versioning Guidelines and RPM - // tags documentation for details). If no explicit mapping to bpkg version - // is specified with the fedora-to-downstream-version manifest values (or - // alike), then we fallback to using the <version> part as bpkg version. If - // explicit mapping is specified, then we match it against the - // [<epoch>:]<version> parts ignoring <release>. + // revision) RPM tags (see the Fedora Package Versioning Guidelines and RPM + // tags documentation for details). If no explicit mapping to the bpkg + // version is specified with the fedora-to-downstream-version (or alike) + // manifest values or none match, then we fallback to using the <version> + // part as the bpkg version. If explicit mapping is specified, then we match + // it against the [<epoch>:]<version> parts ignoring <release>. // struct system_package_status_fedora: system_package_status { @@ -127,28 +129,56 @@ namespace bpkg string common; strings extras; - string devel_fallback; // Fallback based on project name. + string fallback; // Fallback based on project name. - // @@ Rename. package_info? - // - // The `apt-cache policy` output. + // The `dnf list` output. // - struct package_policy + struct package_info { string name; string installed_version; // Empty if none. string candidate_version; // Empty if none and no installed_version. + // The installed/candidate package version architecture. Can be the host + // architecture or noarch. + // + // Note that in Fedora the same package version can be available for + // multiple architectures or be architecture-independent. For example: + // + // dbus-libs-1:1.12.22-1.fc35.i686 + // dbus-libs-1:1.12.22-1.fc35.x86_64 + // dbus-common-1:1.12.22-1.fc35.noarch + // code-insiders-1.75.0-1675123170.el7.armv7hl + // code-insiders-1.75.0-1675123170.el7.aarch64 + // code-insiders-1.75.0-1675123170.el7.x86_64 + // + // Thus, on package query you normally need to qualify the package with + // the architecture suffix or filter the query result, normally skipping + // packages which are specific for architecture other than the host + // architecture. + // + string installed_arch; + string candidate_arch; + explicit - package_policy (string n): name (move (n)) {} + package_info (string n): name (move (n)) {} + + bool + unknown () const + { + return installed_version.empty () && candidate_version.empty (); + } + + bool + known () const {return !unknown ();} }; - vector<package_policy> package_policies; - size_t package_policies_main = 0; // Size of the main group. + vector<package_info> package_infos; + size_t package_infos_main = 0; // Size of the main group. explicit - system_package_status_fedora (string m, string d = {}) - : main (move (m)), devel (move (d)) + system_package_status_fedora (string m, string d = {}, string f = {}) + : main (move (m)), devel (move (d)), fallback (move (f)) { assert (!main.empty () || !devel.empty ()); } @@ -166,9 +196,8 @@ namespace bpkg pkg_install (const vector<package_name>&) override; public: - // Note: expects os_release::name_id to be "fedora" or os_release::like_id - // to contain "fedora". - // + // Expects os_release::name_id to be "fedora" or os_release::like_ids to + // contain "fedora". using system_package_manager::system_package_manager; // Implementation details exposed for testing (see definitions for @@ -176,16 +205,30 @@ namespace bpkg // public: using package_status = system_package_status_fedora; - using package_policy = package_status::package_policy; + using package_info = package_status::package_info; void - dnf_list (vector<package_policy>&, size_t = 0); + dnf_list (vector<package_info>&, size_t = 0); vector<pair<string, string>> - dnf_repoquery_requires (const string&, const string&); + dnf_repoquery_requires (const string&, const string&, const string&); + + void + dnf_makecache (); + + void + dnf_install (const strings&); + + pair<cstrings, const process_path&> + dnf_common (const char*); static package_status - parse_name_value (const string&, bool, bool, bool); + parse_name_value (const package_name&, const string&, bool, bool, bool); + + static string + main_from_dev (const string&, + const string&, + const vector<pair<string, string>>&); // @@ TODO // |