aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--bpkg/system-package-manager-debian.cxx529
1 files changed, 488 insertions, 41 deletions
diff --git a/bpkg/system-package-manager-debian.cxx b/bpkg/system-package-manager-debian.cxx
index f1e78a1..d294416 100644
--- a/bpkg/system-package-manager-debian.cxx
+++ b/bpkg/system-package-manager-debian.cxx
@@ -41,7 +41,7 @@ namespace bpkg
// libssl3 libssl-dev libssl-doc
//
// libcurl4 libcurl4-doc libcurl4-openssl-dev
- // libcurl3-gnutls libcurl4-gnutls-dev
+ // libcurl3-gnutls libcurl4-gnutls-dev (yes, 3 and 4)
//
// Based on that, it seems our best bet when trying to automatically map our
// library package name to Debian package names is to go for the -dev
@@ -56,6 +56,17 @@ namespace bpkg
// For executable packages there is normally no -dev packages but -dbg,
// -doc, and -common are plausible.
//
+ struct package_policy // apt-cache policy output
+ {
+ reference_wrapper<const string> name;
+
+ string installed_version; // Empty if none.
+ string candidate_version; // Empty if none.
+
+ explicit
+ package_policy (const string& n): name (n) {}
+ };
+
class system_package_status_debian: public system_package_status
{
public:
@@ -66,6 +77,8 @@ namespace bpkg
string common;
strings extras;
+ vector<package_policy> package_policies;
+
explicit
system_package_status_debian (string m, string d = {})
: main (move (m)), dev (move (d))
@@ -117,11 +130,15 @@ namespace bpkg
// well, you are out of luck, I guess).
//
// Note also that for now we treat all the packages from the non-main groups
- // as extras. But in the future we may decide to sort them out like the main
- // group.
+ // as extras (but in the future we may decide to sort them out like the main
+ // group). For now we omit the -common package (assuming it's pulled by the
+ // main package) as well as -doc and -dbg unless requested (the
+ // extra_{doc,dbg} arguments).
//
static unique_ptr<package_status_debian>
- parse_debian_name (const string& nv)
+ parse_debian_name (const string& nv,
+ bool extra_doc,
+ bool extra_dbg)
{
auto split = [] (const string& s, char d) -> strings
{
@@ -203,14 +220,12 @@ namespace bpkg
{
unique_ptr<package_status_debian> g (parse_group (gs[i]));
- // @@ Shouldn't we filter some based on what we are installing?
-
- if (!g->main.empty ()) r->extras.push_back (move (g->main));
- if (!g->dev.empty ()) r->extras.push_back (move (g->dev));
- if (!g->doc.empty ()) r->extras.push_back (move (g->doc));
- if (!g->dbg.empty ()) r->extras.push_back (move (g->dbg));
- if (!g->common.empty ()) r->extras.push_back (move (g->common));
- if (!g->extras.empty ()) r->extras.insert (
+ if (!g->main.empty ()) r->extras.push_back (move (g->main));
+ if (!g->dev.empty ()) r->extras.push_back (move (g->dev));
+ if (!g->doc.empty () && extra_doc) r->extras.push_back (move (g->doc));
+ if (!g->dbg.empty () && extra_dbg) r->extras.push_back (move (g->dbg));
+ if (!g->common.empty () && false) r->extras.push_back (move (g->common));
+ if (!g->extras.empty ()) r->extras.insert (
r->extras.end (),
make_move_iterator (g->extras.begin ()),
make_move_iterator (g->extras.end ()));
@@ -220,22 +235,20 @@ namespace bpkg
return r;
}
+ static process_path apt_cache;
+
// 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;
-
+ // If the n argument is not 0, then only query the first n packages.
+ //
static void
- apt_cache_policy (vector<package_policy>& pps)
+ apt_cache_policy (vector<package_policy>& pps, size_t n = 0)
{
- assert (!pps.empty ());
+ if (n == 0)
+ n = pps.size ();
+
+ assert (n != 0 && n <= pps.size ());
// 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
@@ -243,13 +256,17 @@ namespace bpkg
//
cstrings args {"apt-cache", "policy", "--quiet"};
- for (const package_policy& pp: pps)
+ for (size_t i (0); i != n; ++i)
{
- assert (!pp.name.empty () &&
- pp.installed_version.empty () &&
- pp.candidate_version.empty ());
+ package_policy& pp (pps[i]);
+
+ const string& n (pp.name);
+ assert (!n.empty ());
+
+ pp.installed_version.clear ();
+ pp.candidate_version.clear ();
- args.push_back (pp.name.c_str ());
+ args.push_back (n.c_str ());
}
args.push_back (nullptr);
@@ -314,7 +331,7 @@ namespace bpkg
print_process (dr, pe, args);
});
- auto i (pps.begin ());
+ size_t i (0);
string l;
for (getline (is, l); !eof (is); )
@@ -328,11 +345,13 @@ namespace bpkg
// Skip until this package.
//
- for (; i != pps.end () && i->name != l; ++i) ;
+ for (; i != n && pps[i].name.get () != l; ++i) ;
- if (i == pps.end ())
+ if (i == n)
fail << "unexpected package name '" << l << "'";
+ package_policy& pp (pps[i]);
+
auto parse_version = [&l] (const string& n) -> string
{
size_t s (n.size ());
@@ -357,14 +376,14 @@ namespace bpkg
if (eof (getline (is, l)))
fail << "expected Installed version line after package name";
- i->installed_version = parse_version ("Installed");
+ pp.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");
+ pp.candidate_version = parse_version ("Candidate");
// Skip the rest of the indented lines (or blanks, just in case).
//
@@ -405,6 +424,246 @@ namespace bpkg
}
}
+ // Return the Depends value, if any, for the specified package and version.
+ // Fail if either package or version is unknown.
+ //
+ static string
+ apt_cache_show (const string& name, const string& ver)
+ {
+ assert (!name.empty () && !ver.empty ());
+
+ string spec (name + '=' + ver);
+
+ // In particular, --quite makes sure we don't get noices (N) printed to
+ // stderr. It does not appear to affect error diagnostics (try showing
+ // information for an unknown package).
+ //
+ const char* args[] = {
+ "apt-cache", "show", "--quiet", spec.c_str (), nullptr};
+
+ // Note that for this command there seems to be no need to run with the C
+ // locale since the output is presumably not localizable. But let's do it
+ // for good measure and also seeing that we try to backfit some
+ // diagnostics into apt-cache (see no_version below).
+ //
+ const char* evars[] = {"LC_ALL=C", nullptr};
+
+ string r;
+ 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);
+
+ bool no_version (false);
+ try
+ {
+ ifdstream is (move (pr.in_ofd), fdstream_mode::skip, ifdstream::badbit);
+
+ // The output of `apt-cache show <pkg>=<ver>` appears to be a single
+ // Debian control file in the RFC 822 encoding followed by a blank
+ // line. See deb822(5) for details. Here is a representative example:
+ //
+ // Package: libcurl4
+ // Version: 7.85.0-1
+ // Depends: libbrotli1 (>= 0.6.0), libc6 (>= 2.34), ...
+ // Description-en: easy-to-use client-side URL transfer library
+ // libcurl is an easy-to-use client-side URL transfer library.
+ //
+ // Note that if the package is unknown, then we get an error but if
+ // the version is unknown, we get no output (and a note if running
+ // without --quiet).
+ //
+ string l;
+ if (eof (getline (is, l)))
+ {
+ // The unknown version case. Issue diagnostics consistent with the
+ // unknown package case, at least for the English locale.
+ //
+ text << "E: No package version found";
+ no_version = true;
+ }
+ else
+ {
+ auto df = make_diag_frame (
+ [&pe, &args] (diag_record& dr)
+ {
+ dr << info << "while parsing output of ";
+ print_process (dr, pe, args);
+ });
+
+ do
+ {
+ // This line should be the start of a field unless it's a
+ // comment. According to deb822(5), there can be no leading
+ // whitespaces before `#`.
+ //
+ if (l[0] == '#')
+ {
+ getline (is, l);
+ continue;
+ }
+
+ size_t p (l.find (':'));
+
+ if (p == string::npos)
+ fail << "expected field name instead of '" << l << "'";
+
+ // Extract the field name. Note that field names are case-
+ // insensitive.
+ //
+ string n (l, 0, p);
+ trim (n);
+
+ // Extract the field value.
+ //
+ string v (l, p + 1);
+ trim (v);
+
+ // If we have more lines see if the following line is part of this
+ // value.
+ //
+ while (!eof (getline (is, l)) && (l[0] == ' ' || l[0] == '\t'))
+ {
+ // This can either be a "folded" or a "multiline" field and
+ // which one it is depends on the field semantics. Here we only
+ // care about Depends and so treat them all as folded (it's
+ // unclear whether Depends must be a simple field).
+ //
+ trim (l);
+ v += ' ';
+ v += l;
+ }
+
+ // See if this is a field of interest.
+ //
+ if (icasecmp (n, "Package") == 0)
+ {
+ assert (v == name); // Sanity check.
+ }
+ else if (icasecmp (n, "Version") == 0)
+ {
+ assert (v == ver); // Sanity check.
+ }
+ else if (icasecmp (n, "Depends") == 0)
+ {
+ r = move (v);
+
+ // Let's not waste time reading any further.
+ //
+ break;
+ }
+ }
+ while (!eof (is));
+ }
+
+ is.close ();
+ }
+ catch (const io_error& e)
+ {
+ if (pr.wait ())
+ fail << "unable to read " << args[0] << " policy output: " << e;
+
+ // Fall through.
+ }
+
+ if (!pr.wait () || no_version)
+ {
+ 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 ();
+ }
+
+ return r;
+ }
+
+ // Attempt to determine the main package name from its -dev package. Return
+ // empty string if unable. Save the extracted Depends value to the depends
+ // argument for diagnostics.
+ //
+ static string
+ main_from_dev (const string& dev_name,
+ const string& dev_ver,
+ string& depends)
+ {
+ depends = apt_cache_show (dev_name, dev_ver);
+
+ // The format of the Depends value is a comma-seperated list of dependency
+ // expressions. For example:
+ //
+ // Depends: libssl3 (= 3.0.7-1), libc6 (>= 2.34), libfoo | libbar
+ //
+ // For the main package we look for a dependency in the form:
+ //
+ // <dev-stem>* (= <dev-ver>)
+ //
+ // Usually it is the first one.
+ //
+ string dev_stem (dev_name, 0, dev_name.rfind ("-dev"));
+
+ string r;
+ for (size_t b (0), e (0); next_word (depends, b, e, ','); )
+ {
+ string d (depends, b, e - b);
+ trim (d);
+
+ size_t p (d.find (' '));
+ if (p != string::npos)
+ {
+ if (d.compare (0, dev_stem.size (), dev_stem) == 0) // <dev-stem>*
+ {
+ size_t q (d.find ('(', p + 1));
+ if (q != string::npos && d.back () == ')') // (...)
+ {
+ if (d[q + 1] == '=' && d[q + 2] == ' ') // Equal.
+ {
+ string v (d, q + 3, d.size () - q - 3 - 1);
+ trim (v);
+
+ if (v == dev_ver)
+ {
+ r.assign (d, 0, p);
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return r;
+ }
+
optional<const system_package_status*>
system_package_manager_debian::
pkg_status (const package_name& pn,
@@ -412,6 +671,13 @@ namespace bpkg
bool install,
bool fetch)
{
+ // For now we ignore -doc and -dbg package components (but we may want to
+ // have options controlling this later). Note also that we assume -common
+ // is pulled automatically by the main package so we ignore it as well.
+ //
+ bool need_doc (false);
+ bool need_dbg (false);
+
// First check the cache.
//
{
@@ -471,7 +737,8 @@ namespace bpkg
//
for (const string& n: ns)
{
- unique_ptr<package_status_debian> s (parse_debian_name (n));
+ unique_ptr<package_status_debian> s (
+ parse_debian_name (n, need_doc, need_dbg));
// Suppress duplicates for good measure based on the main package
// name (and falling back to -dev if empty).
@@ -493,31 +760,211 @@ namespace bpkg
}
}
- // First look for an already installed package.
+ // Guess unknown main package given the dev package and its version.
+ //
+ auto guess_main = [&pn] (package_status_debian& s, const string& ver)
+ {
+ string depends;
+ s.main = main_from_dev (s.dev, 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";
+ }
+ };
+
+ // 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).
+ //
+ // @@ Maybe we shouldn't be considering extras for partially_installed
+ // determination?
+ //
+ using status_type = package_status::status_type;
+
+ auto status = [] (const vector<package_policy>& pps) -> optional<status_type>
+ {
+ bool i (false), u (false);
+
+ for (const package_policy& pp: pps)
+ {
+ if (pp.installed_version.empty () && pp.candidate_version.empty ())
+ return nullopt;
+
+ (pp.installed_version.empty () ? u : i) = true;
+ }
+
+ return (!u ? package_status::installed :
+ !i ? package_status::not_installed :
+ package_status::partially_installed);
+ };
+
+ // First look for an already fully installed package.
//
unique_ptr<package_status_debian> r;
- for (unique_ptr<package_status_debian>& c: rs)
+ for (unique_ptr<package_status_debian>& ps: rs)
{
- vector<package_policy> pps;
+ vector<package_policy>& pps (ps->package_policies);
- // @@ TODO: rest of packages (and main can be empty).
- //
- pps.push_back (package_policy {c->main, "", ""});
+ if (!ps->main.empty ()) pps.emplace_back (ps->main);
+ if (!ps->dev.empty ()) pps.emplace_back (ps->dev);
+ if (!ps->doc.empty () && need_doc) pps.emplace_back (ps->doc);
+ if (!ps->dbg.empty () && need_dbg) pps.emplace_back (ps->dbg);
+ if (!ps->common.empty () && false) pps.emplace_back (ps->common);
+ for (const string& n: ps->extras) pps.emplace_back (n);
apt_cache_policy (pps);
+
+ // Handle the unknown main package.
+ //
+ if (ps->main.empty ())
+ {
+ const package_policy& dev (pps.front ());
+
+ // Note that at this stage we can only use the installed dev package
+ // (since the candidate version may change after fetch).
+ //
+ if (dev.installed_version.empty ())
+ continue;
+
+ guess_main (*ps, dev.installed_version);
+ pps.emplace (pps.begin (), ps->main);
+ apt_cache_policy (pps, 1);
+ }
+
+ optional<status_type> s (status (pps));
+
+ if (!s)
+ continue;
+
+ if (*s == package_status::installed)
+ {
+ const package_policy& main (pps.front ());
+
+ ps->status = *s;
+ ps->system_name = main.name;
+ ps->system_version = main.installed_version;
+
+ if (r != nullptr)
+ {
+ fail << "multiple installed Debian 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";
+ }
+
+ r = move (ps);
+ }
}
// Next look for available versions if we are allowed to install.
//
if (r == nullptr && install)
{
- if (fetch && !fetched_)
+ // If we weren't instructed to fetch or we already feteched, then we
+ // don't need to re-run apt_cache_policy().
+ //
+ bool requery;
+ if ((requery = fetch && !fetched_))
{
// @@ TODO: apt-get update
fetched_ = true;
}
+
+ for (unique_ptr<package_status_debian>& ps: rs)
+ {
+ vector<package_policy>& pps (ps->package_policies);
+
+ if (requery)
+ apt_cache_policy (pps);
+
+ // Handle the unknown main package.
+ //
+ if (ps->main.empty ())
+ {
+ const package_policy& dev (pps.front ());
+
+ // Note that this time we use the candidate version.
+ //
+ if (dev.candidate_version.empty ())
+ {
+ ps = nullptr; // Not installable.
+ continue;
+ }
+
+ guess_main (*ps, dev.candidate_version);
+ pps.emplace (pps.begin (), ps->main);
+ apt_cache_policy (pps, 1);
+
+ // @@ What if the main version doesn't match dev? Or it must? Or we
+ // use the candidate_version for main? Fuzzy.
+ }
+
+ optional<status_type> s (status (pps));
+
+ if (!s)
+ {
+ ps = nullptr; // Not installable.
+ continue;
+ }
+
+ assert (*s != package_status::installed); // Sanity check.
+
+ const package_policy& main (pps.front ());
+
+ 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)
+ {
+ if (r != nullptr)
+ {
+ fail << "multiple partially installed Debian 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";
+ }
+
+ r = move (ps);
+ }
+ }
+
+ if (r == nullptr)
+ {
+ for (unique_ptr<package_status_debian>& ps: rs)
+ {
+ if (ps == nullptr)
+ continue;
+
+ assert (ps->status != package_status::not_installed); // Sanity check.
+
+ if (r != nullptr)
+ {
+ fail << "multiple available Debian packages for " << pn <<
+ info << "first package: " << r->main << " " << r->system_version <<
+ info << "second package: " << ps->main << " " << ps->system_version <<
+ info << "consider installing the desired package manually";
+ }
+
+ r = move (ps);
+ }
+ }
+ }
+
+ if (r != nullptr)
+ {
+ // @@ TODO: map system version to bpkg version.
}
// Cache.