diff options
| -rw-r--r-- | bpkg/diagnostics.hxx | 2 | ||||
| -rw-r--r-- | bpkg/system-package-manager-debian.cxx | 199 | ||||
| -rw-r--r-- | bpkg/system-package-manager.cxx | 19 |
3 files changed, 208 insertions, 12 deletions
diff --git a/bpkg/diagnostics.hxx b/bpkg/diagnostics.hxx index 9dcd9cb..79dc384 100644 --- a/bpkg/diagnostics.hxx +++ b/bpkg/diagnostics.hxx @@ -133,7 +133,7 @@ namespace bpkg thunk (const diag_frame& f, const butl::diag_record& r) { static_cast<const diag_frame_impl&> (f).func_ ( - static_cast<const diag_record&> (r)); + const_cast<diag_record&> (static_cast<const diag_record&> (r))); } const F func_; diff --git a/bpkg/system-package-manager-debian.cxx b/bpkg/system-package-manager-debian.cxx index cf15a46..f1e78a1 100644 --- a/bpkg/system-package-manager-debian.cxx +++ b/bpkg/system-package-manager-debian.cxx @@ -220,6 +220,191 @@ namespace bpkg return r; } + // Obtain the installed and candidate versions for the specified list + // of Debian packages by executing apt-cache policy. + // + struct package_policy + { + string name; + string installed_version; // Empty if none. + string candidate_version; // Empty if none. + }; + + static process_path apt_cache; + + static void + apt_cache_policy (vector<package_policy>& pps) + { + assert (!pps.empty ()); + + // In particular, --quite makes sure we don't get a noice (N) printed to + // stderr if the package is unknown. It does not appear to affect error + // diagnostics (try temporarily renaming /var/lib/dpkg/status). + // + cstrings args {"apt-cache", "policy", "--quiet"}; + + for (const package_policy& pp: pps) + { + assert (!pp.name.empty () && + pp.installed_version.empty () && + pp.candidate_version.empty ()); + + args.push_back (pp.name.c_str ()); + } + + args.push_back (nullptr); + + // Run with the C locale to make sure there is no localization. Note that + // this is not without potential drawbacks, see Debian bug #643787. But + // for now it seems to work and feels like the least of two potential + // evils. + // + const char* evars[] = {"LC_ALL=C", nullptr}; + + try + { + if (apt_cache.empty ()) + apt_cache = process::path_search (args[0]); + + process_env pe (apt_cache, evars); + + if (verb >= 3) + print_process (pe, args); + + // Redirect stdout to a pipe. For good measure also redirect stdin to + // /dev/null to make sure there are no prompts of any kind. + // + process pr (apt_cache, + args, + -2 /* stdin */, + -1 /* stdout */, + 2 /* stderr */, + nullptr /* cwd */, + evars); + try + { + ifdstream is (move (pr.in_ofd), fdstream_mode::skip, ifdstream::badbit); + + // The output of `apt-cache policy <pkg1> <pkg2> ...` are blocks of + // lines in the following form: + // + // <pkg1>: + // Installed: 1.2.3-1 + // Candidate: 1.3.0-2 + // Version table: + // <...> + // <pkg2>: + // Installed: (none) + // Candidate: 1.3.0+dfsg-2+b1 + // Version table: + // <...> + // + // Where <...> are further lines indented with at least one space. If + // a package is unknown, then the entire block (including the first + // <pkg>: line) is omitted. The blocks appear in the same order as + // packages on the command line and multiple entries for the same + // package result in multiple corresponding blocks. It looks like + // there should be not blank lines but who really knows. + // + { + auto df = make_diag_frame ( + [&pe, &args] (diag_record& dr) + { + dr << info << "while parsing output of "; + print_process (dr, pe, args); + }); + + auto i (pps.begin ()); + + string l; + for (getline (is, l); !eof (is); ) + { + // Parse the first line of the block. + // + if (l.empty () || l.front () == ' ' || l.back () != ':') + fail << "expected package name instead of '" << l << "'"; + + l.pop_back (); + + // Skip until this package. + // + for (; i != pps.end () && i->name != l; ++i) ; + + if (i == pps.end ()) + fail << "unexpected package name '" << l << "'"; + + auto parse_version = [&l] (const string& n) -> string + { + size_t s (n.size ()); + + if (l[0] == ' ' && + l[1] == ' ' && + l.compare (2, s, n) == 0 && + l[2 + s] == ':') + { + string v (l, 2 + s + 1); + trim (v); + + if (!v.empty ()) + return v == "(none)" ? string () : move (v); + } + + fail << "invalid " << n << " version line '" << l << "'" << endf; + }; + + // Get the installed version line. + // + if (eof (getline (is, l))) + fail << "expected Installed version line after package name"; + + i->installed_version = parse_version ("Installed"); + + // Get the candidate version line. + // + if (eof (getline (is, l))) + fail << "expected Candidate version line after Installed version"; + + i->installed_version = parse_version ("Candidate"); + + // Skip the rest of the indented lines (or blanks, just in case). + // + while (!eof (getline (is, l)) && (l.empty () || l.front () != ' ')) ; + } + } + + is.close (); + } + catch (const io_error& e) + { + if (pr.wait ()) + fail << "unable to read " << args[0] << " policy output: " << e; + + // Fall through. + } + + if (!pr.wait ()) + { + diag_record dr (fail); + dr << args[0] << " policy exited with non-zero code"; + + if (verb < 3) + { + dr << "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 (); + } + } + optional<const system_package_status*> system_package_manager_debian:: pkg_status (const package_name& pn, @@ -239,13 +424,13 @@ namespace bpkg return nullptr; } - vector<unique_ptr<package_status_debian>> rs; + vector<unique_ptr<package_status_debian>> rs; // Candidates. // Translate our package name to the Debian package names. // { auto df = make_diag_frame ( - [&pn] (const diag_record& dr) + [&pn] (diag_record& dr) { dr << info << "while mapping " << pn << " to Debian package name"; }); @@ -312,6 +497,16 @@ namespace bpkg // unique_ptr<package_status_debian> r; + for (unique_ptr<package_status_debian>& c: rs) + { + vector<package_policy> pps; + + // @@ TODO: rest of packages (and main can be empty). + // + pps.push_back (package_policy {c->main, "", ""}); + + apt_cache_policy (pps); + } // Next look for available versions if we are allowed to install. // diff --git a/bpkg/system-package-manager.cxx b/bpkg/system-package-manager.cxx index 5e933ae..0f7349a 100644 --- a/bpkg/system-package-manager.cxx +++ b/bpkg/system-package-manager.cxx @@ -81,8 +81,8 @@ namespace bpkg } // Return the version id parsed as a semantic version if it is not empty and - // the "0" semantic version otherwise. Issue diagnostics and fail on the - // parsing error. + // the "0" semantic version otherwise. Issue diagnostics and fail on parsing + // errors. // // Note: the name_id argument is only used for diagnostics. // @@ -104,8 +104,8 @@ namespace bpkg } // Parse the <distribution> component of the specified <distribution>-* - // value into the distribution name and version (returne as "0" if not - // present). Issue diagnostics and fail on the parsing error. + // value into the distribution name and version (return as "0" if not + // present). Issue diagnostics and fail on parsing errors. // // Note: the value_name, ap, and af arguments are only used for diagnostics. // @@ -118,8 +118,9 @@ namespace bpkg string dn (move (d)); // <name>[_<version>] size_t p (dn.rfind ('_')); // Version-separating underscore. - // If '_' separator is present, then make sure that the right-hand part - // looks like a version (is not empty and only contains digits and dots). + // If the '_' separator is present, then make sure that the right-hand + // part looks like a version (not empty and only contains digits and + // dots). // if (p != string::npos) { @@ -264,7 +265,7 @@ namespace bpkg // specified one. Otherwise (the version is less), continue iterating // while preferring downstream version candidates for greater distribution // versions. Note that here we are trying to use a version mapping for the - // distribution version most close (but never greater) to the specified + // distribution version closest (but never greater) to the specified // distribution version. So, for example, if both following values contain // a matching mapping, then for debian 11 we prefer the downstream version // produced by the debian_10-to-downstream-version value: @@ -273,8 +274,8 @@ namespace bpkg // debian_10-to-downstream-version // auto downstream_version = [&aps, &system_version] - (const string& n, const semantic_version& v) - -> optional<version> + (const string& n, + const semantic_version& v) -> optional<version> { optional<version> r; semantic_version rv; |