From 8365a8f55e05628109db9cf6c3321932aa0b0f16 Mon Sep 17 00:00:00 2001 From: Karen Arutyunov Date: Tue, 19 Dec 2023 21:32:52 +0300 Subject: Try to automatically resolve unsatisfied dependency constraints by specifying dependent version --- bpkg/database.hxx | 2 +- bpkg/package.cxx | 3 + bpkg/pkg-build-collect.cxx | 2 +- bpkg/pkg-build-collect.hxx | 27 +- bpkg/pkg-build.cxx | 1343 ++++++++++-- tests/common/satisfy/libbaz-1.2.0.tar.gz | Bin 400 -> 383 bytes tests/common/satisfy/libfoo-3.0.0.tar.gz | Bin 360 -> 416 bytes tests/common/satisfy/t4k/libbar-1.0.0.tar.gz | Bin 0 -> 364 bytes tests/common/satisfy/t4k/libbaz-1.0.0.tar.gz | Bin 0 -> 355 bytes tests/common/satisfy/t4k/libfax-1.0.0.tar.gz | Bin 0 -> 365 bytes tests/common/satisfy/t4k/libfax-2.0.0.tar.gz | Bin 0 -> 364 bytes tests/common/satisfy/t4k/libfaz-1.0.0.tar.gz | Bin 0 -> 360 bytes tests/common/satisfy/t4k/libfaz-2.0.0.tar.gz | Bin 0 -> 360 bytes tests/common/satisfy/t4k/libfex-1.0.0.tar.gz | Bin 0 -> 362 bytes tests/common/satisfy/t4k/libfex-2.0.0.tar.gz | Bin 0 -> 360 bytes tests/common/satisfy/t4k/libfix-1.0.0.tar.gz | Bin 0 -> 360 bytes tests/common/satisfy/t4k/libfix-2.0.0.tar.gz | Bin 0 -> 361 bytes tests/common/satisfy/t4k/libfoo-1.0.0.tar.gz | Bin 0 -> 359 bytes tests/common/satisfy/t4k/libfoo-2.0.0.tar.gz | Bin 0 -> 360 bytes tests/common/satisfy/t4k/libfox-1.0.0.tar.gz | Bin 0 -> 361 bytes tests/common/satisfy/t4k/libfox-1.2.0.tar.gz | Bin 0 -> 376 bytes tests/common/satisfy/t4k/libfox-2.0.0.tar.gz | Bin 0 -> 362 bytes tests/common/satisfy/t4k/libfux-1.0.0.tar.gz | Bin 0 -> 371 bytes tests/common/satisfy/t4k/libfux-2.0.0.tar.gz | Bin 0 -> 371 bytes tests/common/satisfy/t4k/libfuz-1.0.0.tar.gz | Bin 0 -> 349 bytes tests/common/satisfy/t4k/libfuz-2.0.0.tar.gz | Bin 0 -> 348 bytes tests/common/satisfy/t4k/repositories.manifest | 1 + tests/pkg-build.testscript | 2775 +++++++++++++++++++++--- tests/pkg-build/t4k | 1 + 29 files changed, 3685 insertions(+), 469 deletions(-) create mode 100644 tests/common/satisfy/t4k/libbar-1.0.0.tar.gz create mode 100644 tests/common/satisfy/t4k/libbaz-1.0.0.tar.gz create mode 100644 tests/common/satisfy/t4k/libfax-1.0.0.tar.gz create mode 100644 tests/common/satisfy/t4k/libfax-2.0.0.tar.gz create mode 100644 tests/common/satisfy/t4k/libfaz-1.0.0.tar.gz create mode 100644 tests/common/satisfy/t4k/libfaz-2.0.0.tar.gz create mode 100644 tests/common/satisfy/t4k/libfex-1.0.0.tar.gz create mode 100644 tests/common/satisfy/t4k/libfex-2.0.0.tar.gz create mode 100644 tests/common/satisfy/t4k/libfix-1.0.0.tar.gz create mode 100644 tests/common/satisfy/t4k/libfix-2.0.0.tar.gz create mode 100644 tests/common/satisfy/t4k/libfoo-1.0.0.tar.gz create mode 100644 tests/common/satisfy/t4k/libfoo-2.0.0.tar.gz create mode 100644 tests/common/satisfy/t4k/libfox-1.0.0.tar.gz create mode 100644 tests/common/satisfy/t4k/libfox-1.2.0.tar.gz create mode 100644 tests/common/satisfy/t4k/libfox-2.0.0.tar.gz create mode 100644 tests/common/satisfy/t4k/libfux-1.0.0.tar.gz create mode 100644 tests/common/satisfy/t4k/libfux-2.0.0.tar.gz create mode 100644 tests/common/satisfy/t4k/libfuz-1.0.0.tar.gz create mode 100644 tests/common/satisfy/t4k/libfuz-2.0.0.tar.gz create mode 100644 tests/common/satisfy/t4k/repositories.manifest create mode 120000 tests/pkg-build/t4k diff --git a/bpkg/database.hxx b/bpkg/database.hxx index a9e1da5..035ff60 100644 --- a/bpkg/database.hxx +++ b/bpkg/database.hxx @@ -538,7 +538,7 @@ namespace bpkg inline ostream& operator<< (ostream& os, const database& db) { - const string& s (const_cast (db).string); + const string& s (db.string); if (!s.empty ()) os << ' ' << s; diff --git a/bpkg/package.cxx b/bpkg/package.cxx index 4beba8e..05dbc0d 100644 --- a/bpkg/package.cxx +++ b/bpkg/package.cxx @@ -97,6 +97,9 @@ namespace bpkg bool package_version_key:: operator< (const package_version_key& v) const { + // NOTE: remember to update cmdline_adjustments::tried_earlier() if + // changing anything here. + // if (int r = name.compare (v.name)) return r < 0; diff --git a/bpkg/pkg-build-collect.cxx b/bpkg/pkg-build-collect.cxx index 6f5f864..352fa52 100644 --- a/bpkg/pkg-build-collect.cxx +++ b/bpkg/pkg-build-collect.cxx @@ -5023,7 +5023,7 @@ namespace bpkg l5 ([&]{trace << "re-evaluation of dependent " << pkg.available_name_version_db () << " deviated for depends clause " << di + 1 - << ": now can't select alternative, previously " + << ": now cannot select alternative, previously " << oi << " was selected";}); throw reevaluation_deviated (); diff --git a/bpkg/pkg-build-collect.hxx b/bpkg/pkg-build-collect.hxx index 6cb155d..f84c86f 100644 --- a/bpkg/pkg-build-collect.hxx +++ b/bpkg/pkg-build-collect.hxx @@ -807,8 +807,28 @@ namespace bpkg // and existing dependents. If the search succeeds, we update an existing // package spec or add the new one to the command line and recollect from // the very beginning. Note that we always add a new spec with the - // hold_version flag set to false. If the search fails, we report the first - // encountered unsatisfied (and ignored) dependency constraint and fail. + // hold_version flag set to false. If the search fails, then, similarily, we + // try to find the replacement for some of the dependency's dependents, + // recursively. Note that we track the package build replacements and never + // repeat a replacement for the same command line state (which we adjust for + // each replacement). If no replacement is deduced, then we roll back the + // latest command line adjustment and recollect from the very beginning. If + // there are no adjustments left to try, then we give up the resolution + // search and report the first encountered unsatisfied (and ignored) + // dependency constraint and fail. + // + // Note that while we are trying to pick a dependent replacement for the + // subsequent re-collection, we cannot easily detect if the replacement is + // satisfied with the currently collected dependencies since that would + // effectively require to collect the replacement (select dependency + // alternatives, potentially re-negotiate dependency configurations, + // etc). Thus, we only verify that the replacement version satisfies its + // currently collected dependents. To reduce the number of potential + // dependent replacements to consider, we apply the heuristics and only + // consider those dependents which have or may have some satisfaction + // problems (not satisfied with a collected dependency, apply a dependency + // constraint which is incompatible with other dependents, etc; see + // try_replace_dependent() for details). // struct unsatisfied_constraint { @@ -828,8 +848,7 @@ namespace bpkg version_constraint constraint; // Only specified when the failure is postponed during the collection of - // the explicitly specified packages and their dependencies. Only used to - // properly reproduce the postponed failure diagnostics. + // the explicitly specified packages and their dependencies. // vector unsatisfied_constraints; vector dependency_chain; diff --git a/bpkg/pkg-build.cxx b/bpkg/pkg-build.cxx index 755d9d9..89239cc 100644 --- a/bpkg/pkg-build.cxx +++ b/bpkg/pkg-build.cxx @@ -1459,21 +1459,592 @@ namespace bpkg return r && r->available == nullptr ? nullopt : r; } - // Try to replace a collected package which is unsatisfactory for some of - // its new and/or existing dependents with a satisfactory available version. + // Stack of the command line adjustments as per unsatisfied_dependents + // description. + // + struct cmdline_adjustment + { + enum class adjustment_type: uint8_t + { + hold_existing, // Adjust constraint in existing build-to-hold spec. + dep_existing, // Adjust constraint in existing dependency spec. + hold_new, // Add new build-to-hold spec. + dep_new // Add new dependency spec. + }; + + adjustment_type type; + reference_wrapper db; + package_name name; + bpkg::version version; // Replacement. + + // Meaningful only for the *_new types. + // + optional upgrade; + bool deorphan = false; + + // For the newly created or popped from the stack object the following + // three members contain the package version replacement information. + // Otherwise (pushed to the stack), they contain the original command line + // spec information. + // + shared_ptr available; // NULL for dep_* types. + lazy_shared_ptr repository_fragment; // As above. + optional constraint; + + // Create object of the hold_existing type. + // + cmdline_adjustment (database& d, + const package_name& n, + shared_ptr&& a, + lazy_shared_ptr&& f) + : type (adjustment_type::hold_existing), + db (d), + name (n), + version (a->version), + available (move (a)), + repository_fragment (move (f)), + constraint (version_constraint (version)) {} + + // Create object of the dep_existing type. + // + cmdline_adjustment (database& d, + const package_name& n, + const bpkg::version& v) + : type (adjustment_type::dep_existing), + db (d), + name (n), + version (v), + constraint (version_constraint (version)) {} + + // Create object of the hold_new type. + // + cmdline_adjustment (database& d, + const package_name& n, + shared_ptr&& a, + lazy_shared_ptr&& f, + optional u, + bool o) + : type (adjustment_type::hold_new), + db (d), + name (n), + version (a->version), + upgrade (u), + deorphan (o), + available (move (a)), + repository_fragment (move (f)), + constraint (version_constraint (version)) {} + + // Create object of the dep_new type. + // + cmdline_adjustment (database& d, + const package_name& n, + const bpkg::version& v, + optional u, + bool o) + : type (adjustment_type::dep_new), + db (d), + name (n), + version (v), + upgrade (u), + deorphan (o), + constraint (version_constraint (version)) {} + }; + + class cmdline_adjustments + { + public: + cmdline_adjustments (vector& hps, dependency_packages& dps) + : hold_pkgs_ (hps), + dep_pkgs_ (dps) {} + + // Apply the specified adjustment to the command line, push the adjustment + // to the stack, and record the resulting command line state as the SHA256 + // checksum. + // + void + push (cmdline_adjustment&& a) + { + using type = cmdline_adjustment::adjustment_type; + + // We always set the `== ` constraint in the resulting spec. + // + assert (a.constraint); + + database& db (a.db); + const package_name& nm (a.name); + package_version_key cmd_line (db.main_database (), "command line"); + + switch (a.type) + { + case type::hold_existing: + { + auto i (find_hold_pkg (a)); + assert (i != hold_pkgs_.end ()); // As per adjustment type. + + build_package& bp (*i); + swap (bp.available, a.available); + swap (bp.repository_fragment, a.repository_fragment); + + if (!bp.constraints.empty ()) + { + swap (bp.constraints[0].value, *a.constraint); + } + else + { + bp.constraints.emplace_back (move (*a.constraint), + cmd_line.db, + cmd_line.name.string ()); + a.constraint = nullopt; + } + + break; + } + case type::dep_existing: + { + auto i (find_dep_pkg (a)); + assert (i != dep_pkgs_.end ()); // As per adjustment type. + swap (i->constraint, a.constraint); + break; + } + case type::hold_new: + { + // As per adjustment type. + // + assert (find_hold_pkg (a) == hold_pkgs_.end ()); + + // Start the database transaction to perform the + // database::find call, unless we are already in + // the transaction. + // + transaction t (db, !transaction::has_current ()); + + build_package bp { + build_package::build, + db, + db.find (nm), + move (a.available), + move (a.repository_fragment), + nullopt, // Dependencies. + nullopt, // Dependencies alternatives. + nullopt, // Package skeleton. + nullopt, // Postponed dependency alternatives. + false, // Recursive collection. + true, // Hold package. + false, // Hold version. + {}, // Constraints. + false, // System. + false, // Keep output directory. + false, // Disfigure (from-scratch reconf). + false, // Configure-only. + nullopt, // Checkout root. + false, // Checkout purge. + strings (), // Configuration variables. + a.upgrade, + a.deorphan, + {cmd_line}, // Required by (command line). + false, // Required by dependents. + (a.deorphan + ? build_package::build_replace + : uint16_t (0))}; + + t.commit (); + + bp.constraints.emplace_back (move (*a.constraint), + cmd_line.db, + cmd_line.name.string ()); + + a.constraint = nullopt; + + hold_pkgs_.push_back (move (bp)); + break; + } + case type::dep_new: + { + // As per adjustment type. + // + assert (find_dep_pkg (a) == dep_pkgs_.end ()); + + // Start the database transaction to perform the + // database::find call, unless we are already in + // the transaction. + // + transaction t (db, !transaction::has_current ()); + + dep_pkgs_.push_back ( + dependency_package {&db, + nm, + move (*a.constraint), + false /* hold_version */, + db.find (nm), + false /* system */, + false /* existing */, + a.upgrade, + a.deorphan, + false /* keep_out */, + false /* disfigure */, + nullopt /* checkout_root */, + false /* checkout_purge */, + strings () /* config_vars */, + nullptr /* system_status */}); + + t.commit (); + + a.constraint = nullopt; + break; + } + } + + packages_.insert (package_version_key (db, nm, a.version)); + adjustments_.push_back (move (a)); + former_states_.insert (state ()); + } + + // Roll back the latest (default) or first command line adjustment, pop it + // from the stack, and return the popped adjustment. Assume that the stack + // is not empty. + // + // Note that the returned object can be pushed to the stack again. + // + cmdline_adjustment + pop (bool first = false) + { + using type = cmdline_adjustment::adjustment_type; + + assert (!empty ()); + + // Pop the adjustment. + // + cmdline_adjustment a (move (!first + ? adjustments_.back () + : adjustments_.front ())); + if (!first) + adjustments_.pop_back (); + else + adjustments_.erase (adjustments_.begin ()); + + packages_.erase (package_version_key (a.db, a.name, a.version)); + + // Roll back the adjustment. + // + switch (a.type) + { + case type::hold_existing: + { + auto i (find_hold_pkg (a)); + assert (i != hold_pkgs_.end ()); + + build_package& bp (*i); + swap (bp.available, a.available); + swap (bp.repository_fragment, a.repository_fragment); + + // Must contain the replacement version. + // + assert (!bp.constraints.empty ()); + + version_constraint& c (bp.constraints[0].value); + + if (a.constraint) // Original spec contains a version constraint? + { + swap (c, *a.constraint); + } + else + { + a.constraint = move (c); + bp.constraints.clear (); + } + + break; + } + case type::dep_existing: + { + auto i (find_dep_pkg (a)); + assert (i != dep_pkgs_.end ()); + swap (i->constraint, a.constraint); + break; + } + case type::hold_new: + { + auto i (find_hold_pkg (a)); + assert (i != hold_pkgs_.end ()); + + build_package& bp (*i); + a.available = move (bp.available); + a.repository_fragment = move (bp.repository_fragment); + + // Must contain the replacement version. + // + assert (!bp.constraints.empty ()); + + a.constraint = move (bp.constraints[0].value); + + hold_pkgs_.erase (i); + break; + } + case type::dep_new: + { + auto i (find_dep_pkg (a)); + assert (i != dep_pkgs_.end ()); + + a.constraint = move (i->constraint); + + dep_pkgs_.erase (i); + break; + } + } + + return a; + } + + // Return the specified adjustment's string representation in the + // following form: + // + // hold_existing: '[ ][ ]' -> ' ' + // dep_existing: '?[ ][ ]' -> '? ' + // hold_new: ' [ ]' + // dep_new: '? [ ]' + // + // Note: the adjustment is assumed to be newly created or be popped from + // the stack. + // + string + to_string (const cmdline_adjustment& a) const + { + using type = cmdline_adjustment::adjustment_type; + + assert (a.constraint); // Since not pushed. + + const string& s (a.db.get ().string); + + switch (a.type) + { + case type::hold_existing: + { + string r ("'" + a.name.string ()); + + auto i (find_hold_pkg (a)); + assert (i != hold_pkgs_.end ()); + + const build_package& bp (*i); + if (!bp.constraints.empty ()) + r += ' ' + bp.constraints[0].value.string (); + + if (!s.empty ()) + r += ' ' + s; + + r += "' -> '" + a.name.string () + ' ' + a.constraint->string () + + "'"; + + return r; + } + case type::dep_existing: + { + string r ("'?" + a.name.string ()); + + auto i (find_dep_pkg (a)); + assert (i != dep_pkgs_.end ()); + + if (i->constraint) + r += ' ' + i->constraint->string (); + + if (!s.empty ()) + r += ' ' + s; + + r += "' -> '?" + a.name.string () + ' ' + a.constraint->string () + + "'"; + + return r; + } + case type::hold_new: + { + assert (find_hold_pkg (a) == hold_pkgs_.end ()); + + string r ("'" + a.name.string () + ' ' + a.constraint->string ()); + + if (!s.empty ()) + r += ' ' + s; + + r += "'"; + return r; + } + case type::dep_new: + { + assert (find_dep_pkg (a) == dep_pkgs_.end ()); + + string r ("'?" + a.name.string () + ' ' + a.constraint->string ()); + + if (!s.empty ()) + r += ' ' + s; + + r += "'"; + return r; + } + } + + assert (false); // Can't be here. + return ""; + } + + // Return true, if there are no adjustments in the stack. + // + bool + empty () const + { + return adjustments_.empty (); + } + + // Return true, if push() has been called at least once. + // + bool + tried () const + { + return !former_states_.empty (); + } + + // Return the number of adjustments in the stack. + // + size_t + size () const + { + return adjustments_.size (); + } + + // Return true if replacing a package build with the specified version + // will result in a command line which has already been (unsuccessfully) + // tried as a starting point for the package builds re-collection. + // + bool + tried_earlier (database& db, const package_name& n, const version& v) const + { + if (former_states_.empty ()) + return false; + + // Similar to the state() function, calculate the checksum over the + // packages set, but also consider the specified package version as if + // it were present in the set. + // + // Note that the specified package version may not be in the set, since + // we shouldn't be trying to replace with the package version which is + // already in the command line. + // + sha256 cs; + + auto lt = [&db, &n, &v] (const package_version_key& pvk) + { + if (int r = n.compare (pvk.name)) + return r < 0; + + if (int r = v.compare (*pvk.version)) + return r < 0; + + return db < pvk.db; + }; + + bool appended (false); + for (const package_version_key& p: packages_) + { + assert (p.version); // Only the real packages can be here. + + if (!appended && lt (p)) + { + cs.append (db.config.string ()); + cs.append (n.string ()); + cs.append (v.string ()); + + appended = true; + } + + cs.append (p.db.get ().config.string ()); + cs.append (p.name.string ()); + cs.append (p.version->string ()); + } + + if (!appended) + { + cs.append (db.config.string ()); + cs.append (n.string ()); + cs.append (v.string ()); + } + + return former_states_.find (cs.string ()) != former_states_.end (); + } + + private: + // Return the SHA256 checksum of the current command line state. + // + string + state () const + { + // NOTE: remember to update tried_earlier() if changing anything here. + // + sha256 cs; + for (const package_version_key& p: packages_) + { + assert (p.version); // Only the real packages can be here. + + cs.append (p.db.get ().config.string ()); + cs.append (p.name.string ()); + cs.append (p.version->string ()); + } + + return cs.string (); + } + + // Find the command line package spec an adjustment applies to. + // + vector::iterator + find_hold_pkg (const cmdline_adjustment& a) const + { + return find_if (hold_pkgs_.begin (), hold_pkgs_.end (), + [&a] (const build_package& p) + { + return p.name () == a.name && p.db == a.db; + }); + } + + dependency_packages::iterator + find_dep_pkg (const cmdline_adjustment& a) const + { + return find_if (dep_pkgs_.begin (), dep_pkgs_.end (), + [&a] (const dependency_package& p) + { + return p.name == a.name && + p.db != nullptr && + *p.db == a.db; + }); + } + + private: + vector& hold_pkgs_; + dependency_packages& dep_pkgs_; + + vector adjustments_; // Adjustments stack. + set packages_; // Replacements. + set former_states_; // Command line seen states. + }; + + // Try to replace a collected package with a different available version, + // satisfactory for all its new and/or existing dependents. Return the + // command line adjustment if such a replacement is deduced and nullopt + // otherwise. In the latter case, also return the list of the being built + // dependents which are unsatisfied by some of the dependency available + // versions (unsatisfied_dpts argument). // // Specifically, try to find the best available package version considering // all the imposed constraints as per unsatisfied_dependents description. If - // succeed, update/add the respective entry to hold_pkgs or dep_pkgs and - // return true. + // succeed, return the command line adjustment reflecting the replacement. // // Notes: // + // - Doesn't perform the actual adjustment of the command line. + // // - Expected to be called after the execution plan is fully refined. That, // in particular, means that all the existing dependents are also // collected and thus the constraints they impose are already in their // dependencies' constraints lists. // + // - The specified package version may or may not be satisfactory for its + // new and existing dependents. + // // - The replacement is denied in the following cases: // // - If it turns out that the package have been specified on the command @@ -1497,51 +2068,57 @@ namespace bpkg // requested to be upgraded, patched, and/or deorphaned, then we // shouldn't be silently up/down-grading it. // - bool + optional try_replace_dependency (const common_options& o, const build_package& p, const build_packages& pkgs, - vector& hold_pkgs, - dependency_packages& dep_pkgs) + const vector& hold_pkgs, + const dependency_packages& dep_pkgs, + const cmdline_adjustments& cmdline_adjs, + vector& unsatisfied_dpts, + const char* what) { tracer trace ("try_replace_dependency"); + assert (p.available != nullptr); // By definition. + // Bail out for the system package build. // if (p.system) { - l4 ([&]{trace << "replacement of unsatisfactory package version " + l5 ([&]{trace << "replacement of " << what << " version " << p.available_name_version_db () << " is denied " << "since it is being configured as system";}); - return false; + return nullopt; } // Bail out for an existing package archive/directory. // database& db (p.db); const package_name& nm (p.name ()); + const version& ver (p.available->version); if (find_existing (db, nm, nullopt /* version_constraint */).first != nullptr) { - l4 ([&]{trace << "replacement of unsatisfactory package version " + l5 ([&]{trace << "replacement of " << what << " version " << p.available_name_version_db () << " is denied since " << "it is being built as existing archive/directory";}); - return false; + return nullopt; } // Find the package command line entry and stash the reference to its // version constraint, if any. Bail out if the constraint is specified as // an exact package version. // - build_package* hold_pkg (nullptr); - dependency_package* dep_pkg (nullptr); - version_constraint* constraint (nullptr); + const build_package* hold_pkg (nullptr); + const dependency_package* dep_pkg (nullptr); + const version_constraint* constraint (nullptr); - for (build_package& hp: hold_pkgs) + for (const build_package& hp: hold_pkgs) { if (hp.name () == nm && hp.db == db) { @@ -1553,16 +2130,16 @@ namespace bpkg // assert (hp.constraints.size () == 1); - version_constraint& c (hp.constraints[0].value); + const version_constraint& c (hp.constraints[0].value); if (c.min_version == c.max_version) { - l4 ([&]{trace << "replacement of unsatisfactory package version " + l5 ([&]{trace << "replacement of " << what << " version " << p.available_name_version_db () << " is denied " << "since it is specified on command line as '" << nm << ' ' << c << "'";}); - return false; + return nullopt; } else constraint = &c; @@ -1574,7 +2151,7 @@ namespace bpkg if (hold_pkg == nullptr) { - for (dependency_package& dp: dep_pkgs) + for (const dependency_package& dp: dep_pkgs) { if (dp.name == nm && dp.db != nullptr && *dp.db == db) { @@ -1582,16 +2159,16 @@ namespace bpkg if (dp.constraint) { - version_constraint& c (*dp.constraint); + const version_constraint& c (*dp.constraint); if (c.min_version == c.max_version) { - l4 ([&]{trace << "replacement of unsatisfactory package version " + l5 ([&]{trace << "replacement of " << what << " version " << p.available_name_version_db () << " is denied " << "since it is specified on command line as '?" << nm << ' ' << c << "'";}); - return false; + return nullopt; } else constraint = &c; @@ -1612,18 +2189,17 @@ namespace bpkg hold_pkg == nullptr && dep_pkg == nullptr && !p.upgrade && !p.deorphan) { - l4 ([&]{trace << "replacement of unsatisfactory package version " + l5 ([&]{trace << "replacement of " << what << " version " << p.available_name_version_db () << " is denied since " - << "it is not specified on command line nor is being " - << "upgraded or deorphaned";}); + << "it is already built to hold version and it is not " + << "specified on command line nor is being upgraded or " + << "deorphaned";}); - return false; + return nullopt; } transaction t (db); - assert (!p.constraints.empty ()); // Must contain unsatisfied constraints. - // Collect the repository fragments to search the available packages in. // config_repo_fragments rfs; @@ -1691,7 +2267,7 @@ namespace bpkg { for (database& ddb: db.dependent_configs ()) { - for (auto& pd: query_dependents (ddb, nm, db)) + for (const auto& pd: query_dependents (ddb, nm, db)) { const build_package* d (pkgs.entered_build (ddb, pd.name)); @@ -1736,7 +2312,7 @@ namespace bpkg using available = pair, lazy_shared_ptr>; - available r; + available ra; // Version to deorphan. // @@ -1768,17 +2344,33 @@ namespace bpkg available deorphan_later_minor; available deorphan_latest_available; - // Return true if a version satisfy all the dependency constraints. + // Return true if a version satisfies all the dependency constraints. + // Otherwise, save all the being built unsatisfied dependents into the + // resulting list, suppressing duplicates. // - auto satisfactory = [&p] (const version& v) + auto satisfactory = [&p, &unsatisfied_dpts] (const version& v) { + bool r (true); + for (const auto& c: p.constraints) { if (!satisfies (v, c.value)) - return false; + { + r = false; + + if (c.dependent.version && !c.selected_dependent) + { + package_key pk (c.dependent.db, c.dependent.name); + + if (find (unsatisfied_dpts.begin (), + unsatisfied_dpts.end (), + pk) == unsatisfied_dpts.end ()) + unsatisfied_dpts.push_back (move (pk)); + } + } } - return true; + return r; }; for (available& af: afs) @@ -1790,31 +2382,64 @@ namespace bpkg const version& av (ap->version); + // Skip if the available package version doesn't satisfy all the + // constraints (note: must be checked first since has a byproduct). + // + if (!satisfactory (av)) + continue; + + // Don't offer to replace to the same version. + // + if (av == ver) + continue; + + // Don't repeatedly offer the same adjustments for the same command + // line. + // + if (cmdline_adjs.tried_earlier (db, nm, av)) + { + l5 ([&]{trace << "replacement " << package_version_key (db, nm, av) + << " tried earlier for same command line, skipping";}); + + continue; + } + // If we aim to upgrade to the latest version and it tends to be less // then the selected one, then what we currently have is the best that // we can get. Thus, we use the selected version as a replacement, // unless it doesn't satisfy all the constraints or we are deorphaning. // - if (constraint == nullptr && sp != nullptr && av < sp->version) + if (constraint == nullptr && sp != nullptr) { - if (!sp->system () && !p.deorphan && satisfactory (sp->version)) + const version& sv (sp->version); + if (av < sv && !sp->system () && !p.deorphan) { - r = make_available_fragment (o, db, sp); - break; + // Only consider the selected package if its version is satisfactory + // for its new dependents (note: must be checked first since has a + // byproduct), differs from the version being replaced, and was + // never used for the same command line (see above for details). + // + if (satisfactory (sv) && sv != ver) + { + if (!cmdline_adjs.tried_earlier (db, nm, sv)) + { + ra = make_available_fragment (o, db, sp); + break; + } + else + l5 ([&]{trace << "selected package replacement " + << package_version_key (db, nm, sp->version) + << " tried earlier for same command line, " + << "skipping";}); + } } } - // Skip if the available package version doesn't satisfy all the - // constraints. - // - if (!satisfactory (av)) - continue; - if (orphan_best_match) { if (av == *dov) { - r = move (af); + ra = move (af); break; } @@ -1854,104 +2479,82 @@ namespace bpkg } else { - r = move (af); + ra = move (af); break; } } - shared_ptr& rap (r.first); + shared_ptr& rap (ra.first); if (rap == nullptr && orphan_best_match) { if (deorphan_latest_iteration.first != nullptr) - r = move (deorphan_latest_iteration); + ra = move (deorphan_latest_iteration); else if (deorphan_later_revision.first != nullptr) - r = move (deorphan_later_revision); + ra = move (deorphan_later_revision); else if (deorphan_later_patch.first != nullptr) - r = move (deorphan_later_patch); + ra = move (deorphan_later_patch); else if (deorphan_later_minor.first != nullptr) - r = move (deorphan_later_minor); + ra = move (deorphan_later_minor); else if (deorphan_latest_available.first != nullptr) - r = move (deorphan_latest_available); + ra = move (deorphan_latest_available); } t.commit (); - if (rap == nullptr) - return false; - - // Now, as the replacement is found, punch the respective spec to the - // command line. + // Bail out if no appropriate replacement is found and return the + // command line adjustment object otherwise. // - lazy_shared_ptr& raf (r.second); + if (rap == nullptr) + return nullopt; - // Should we use a different special name for the package specs we - // amend/add? Probably that would only make sense if some diagnostics - // becomes confusing. Let's wait and see and hopefully that won't be - // necessary. - // - package_version_key cmd_line (db.main_database (), "command line"); + optional r; - // If the package is present on the command line, then update its - // constraint, if present, and add the constraint otherwise. Otherwise, - // add the new package spec. - // - version_constraint vc (rap->version); + lazy_shared_ptr& raf (ra.second); - if (hold_pkg != nullptr || dep_pkg != nullptr) + if (hold_pkg != nullptr || dep_pkg != nullptr) // Specified on command line? { if (hold_pkg != nullptr) { + r = cmdline_adjustment (hold_pkg->db, + hold_pkg->name (), + move (rap), + move (raf)); + if (constraint != nullptr) { - l4 ([&]{trace << "replace unsatisfactory package version " - << p.available_name_version_db () << " with " - << rap->version << " by overwriting constraint '" - << nm << ' ' << *constraint << "' by '" << nm << ' ' - << vc << "' on command line";}); + l5 ([&]{trace << "replace " << what << " version " + << p.available_name_version () << " with " + << r->version << " by overwriting constraint " + << cmdline_adjs.to_string (*r) << " on command line";}); } else { - l4 ([&]{trace << "replace unsatisfactory package version " - << p.available_name_version_db () << " with " - << rap->version << " by overwriting spec '" << nm - << "' by '" << nm << ' ' << vc << "' on command line";}); - - hold_pkg->constraints.emplace_back (move (vc), - cmd_line.db, - cmd_line.name.string ()); + l5 ([&]{trace << "replace " << what << " version " + << p.available_name_version () << " with " + << r->version << " by adding constraint " + << cmdline_adjs.to_string (*r) << " on command line";}); } - - hold_pkg->available = move (rap); - hold_pkg->repository_fragment = move (raf); } else // dep_pkg != nullptr { + r = cmdline_adjustment (*dep_pkg->db, dep_pkg->name, rap->version); + if (constraint != nullptr) { - l4 ([&]{trace << "replace unsatisfactory package version " - << p.available_name_version_db () << " with " - << rap->version << " by overwriting constraint '?" - << nm << ' ' << *constraint << "' by '?" << nm << ' ' - << vc << "' on command line";}); + l5 ([&]{trace << "replace " << what << " version " + << p.available_name_version () << " with " + << r->version << " by overwriting constraint " + << cmdline_adjs.to_string (*r) << " on command line";}); } else { - // It feels like this case may never happen, since for a dependency - // specified without version constraint on the command line the - // dependency evaluation machinery will pick the best available - // version in pretty much the same way as we do in this - // function. This is in contrast to a dependency specified with a - // version constraint which will not be upgraded if the configured - // dependency satisfies this constraint (see evaluate_dependency() - // for details). Let's, however, handle this case, for good measure. - // - dep_pkg->constraint = move (vc); + l5 ([&]{trace << "replace " << what << " version " + << p.available_name_version () << " with " + << r->version << " by adding constraint " + << cmdline_adjs.to_string (*r) << " on command line";}); } } - - if (constraint != nullptr) - *constraint = move (vc); } else // The package is not specified on the command line. { @@ -1993,73 +2596,258 @@ namespace bpkg // if (sp != nullptr && sp->hold_package) { - l4 ([&]{trace << "replace unsatisfactory package version " - << p.available_name_version_db () << " with " - << rap->version << " by adding package spec '" << nm - << ' ' << vc << "' to command line";}); + r = cmdline_adjustment (db, + nm, + move (rap), + move (raf), + p.upgrade, + p.deorphan); + + l5 ([&]{trace << "replace " << what << " version " + << p.available_name_version () << " with " << r->version + << " by adding package spec " + << cmdline_adjs.to_string (*r) + << " to command line";}); + } + else + { + r = cmdline_adjustment (db, nm, rap->version, p.upgrade, p.deorphan); - build_package hp { - build_package::build, - db, - sp, - move (rap), - move (raf), - nullopt, // Dependencies. - nullopt, // Dependencies alternatives. - nullopt, // Package skeleton. - nullopt, // Postponed dependency alternatives. - false, // Recursive collection. - true, // Hold package. - false, // Hold version. - {}, // Constraints. - false, // System. - false, // Keep output directory. - false, // Disfigure (from-scratch reconf). - false, // Configure-only. - nullopt, // Checkout root. - false, // Checkout purge. - strings (), // Configuration variables. - p.upgrade, - p.deorphan, - {cmd_line}, // Required by (command line). - false, // Required by dependents. - (p.deorphan - ? build_package::build_replace - : uint16_t (0))}; + l5 ([&]{trace << "replace " << what << " version " + << p.available_name_version () << " with " << r->version + << " by adding package spec " + << cmdline_adjs.to_string (*r) + << " to command line";}); + } + } + + return r; + } + + // Try to replace some of the being built, potentially indirect, dependents + // of the specified dependency with a different available version, + // satisfactory for all its new and existing dependents (if any). Return the + // command line adjustment if such a replacement is deduced and nullopt + // otherwise. It is assumed that the dependency replacement has been + // (unsuccessfully) tried by using the try_replace_dependency() call and its + // resulting list of the dependents, unsatisfied by some of the dependency + // available versions, is also passed to the function call as the + // unsatisfied_dpts argument. + // + // Specifically, try to replace the dependents in the following order by + // calling try_replace_dependency() for them: + // + // - Immediate dependents unsatisfied with the specified dependency. For the + // sake of tracing and documentation, we (naturally) call them unsatisfied + // dependents. + // + // - Immediate dependents satisfied with the dependency but applying the + // version constraint which has prevented us from picking a version which + // would be satisfactory to the unsatisfied dependents. Note that this + // information is only available for the being built unsatisfied + // dependents (added by collect_build() rather than collect_dependents()). + // We call them conflicting dependents. + // + // - Immediate dependents which apply constraint to this dependency, + // incompatible with constraints of some other dependents (both new and + // existing). We call them unsatisfiable dependents. + // + // - Immediate dependents from unsatisfied_dpts argument. We call them + // constraining dependents. + // + // - Dependents of all the above types of dependents, discovered by + // recursively calling try_replace_dependent() for them. + // + optional + try_replace_dependent (const common_options& o, + const build_package& p, // Dependency. + const vector* ucs, + const build_packages& pkgs, + const cmdline_adjustments& cmdline_adjs, + const vector& unsatisfied_dpts, + vector& hold_pkgs, + dependency_packages& dep_pkgs, + set& visited_dpts) + { + tracer trace ("try_replace_dependent"); + + // Bail out if the dependent has already been visited and add it to the + // visited set otherwise. + // + if (!visited_dpts.insert (&p).second) + return nullopt; + + using constraint_type = build_package::constraint_type; + + const shared_ptr& ap (p.available); + assert (ap != nullptr); // By definition. + + const version& av (ap->version); + + // List of the dependents which we have (unsuccessfully) tried to replace + // together with the lists of the constraining dependents. + // + vector>> dpts; - hp.constraints.emplace_back (move (vc), - cmd_line.db, - cmd_line.name.string ()); + // Try to replace a dependent, unless we have already tried to replace it. + // + auto try_replace = [&o, + &p, + &pkgs, + &cmdline_adjs, + &hold_pkgs, + &dep_pkgs, + &visited_dpts, + &dpts, + &trace] (package_key dk, const char* what) + -> optional + { + if (find_if (dpts.begin (), dpts.end (), + [&dk] (const auto& v) {return v.first == dk;}) == + dpts.end ()) + { + const build_package* d (pkgs.entered_build (dk)); + + // Always come from the dependency's constraints member. + // + assert (d != nullptr); + + // Skip the visited dependents since, by definition, we have already + // tried to replace them. + // + if (find (visited_dpts.begin (), visited_dpts.end (), d) == + visited_dpts.end ()) + { + l5 ([&]{trace << "try to replace " << what << ' ' + << d->available_name_version_db () << " of dependency " + << p.available_name_version_db () << " with some " + << "other version";}); + + vector uds; + + if (optional a = try_replace_dependency ( + o, + *d, + pkgs, + hold_pkgs, + dep_pkgs, + cmdline_adjs, + uds, + what)) + { + return a; + } - hold_pkgs.push_back (move (hp)); + dpts.emplace_back (move (dk), move (uds)); + } } - else + + return nullopt; + }; + + // Try to replace unsatisfied dependents. + // + for (const constraint_type& c: p.constraints) + { + const package_version_key& dvk (c.dependent); + + if (dvk.version && !c.selected_dependent && !satisfies (av, c.value)) { - l4 ([&]{trace << "replace unsatisfactory package version " - << p.available_name_version_db () << " with " - << rap->version << " by adding package spec '?" << nm - << ' ' << vc << "' to command line";}); - - dep_pkgs.push_back ( - dependency_package {&db, - nm, - move (vc), - false /* hold_version */, - sp, - false /* system */, - false /* existing */, - p.upgrade, - p.deorphan, - false /* keep_out */, - false /* disfigure */, - nullopt /* checkout_root */, - false /* checkout_purge */, - strings () /* config_vars */, - nullptr /* system_status */}); + if (optional a = try_replace ( + package_key (dvk.db, dvk.name), "unsatisfied dependent")) + { + return a; + } } } - return true; + // Try to replace conflicting dependents. + // + if (ucs != nullptr) + { + for (const unsatisfied_constraint& uc: *ucs) + { + const package_version_key& dvk (uc.constraint.dependent); + + if (dvk.version) + { + if (optional a = try_replace ( + package_key (dvk.db, dvk.name), "conflicting dependent")) + { + return a; + } + } + } + } + + // Try to replace unsatisfiable dependents. + // + for (const constraint_type& c1: p.constraints) + { + const package_version_key& dvk (c1.dependent); + + if (dvk.version && !c1.selected_dependent) + { + const version_constraint& v1 (c1.value); + + bool unsatisfiable (false); + for (const constraint_type& c2: p.constraints) + { + const version_constraint& v2 (c2.value); + + if (!satisfies (v1, v2) && !satisfies (v2, v1)) + { + unsatisfiable = true; + break; + } + } + + if (unsatisfiable) + { + if (optional a = try_replace ( + package_key (dvk.db, dvk.name), "unsatisfiable dependent")) + { + return a; + } + } + } + } + + // Try to replace constraining dependents. + // + for (const auto& dk: unsatisfied_dpts) + { + if (optional a = try_replace ( + dk, "constraining dependent")) + { + return a; + } + } + + // Try to replace dependents of the above dependents, recursively. + // + for (const auto& dep: dpts) + { + const build_package* d (pkgs.entered_build (dep.first)); + + assert (d != nullptr); + + if (optional a = try_replace_dependent ( + o, + *d, + nullptr /* unsatisfied_constraints */, + pkgs, + cmdline_adjs, + dep.second, + hold_pkgs, + dep_pkgs, + visited_dpts)) + { + return a; + } + } + + return nullopt; } // Return false if the plan execution was noop. If unsatisfied dependents @@ -3419,6 +4207,32 @@ namespace bpkg dependency_packages dep_pkgs; recursive_packages rec_pkgs; + // Note that the command line adjustments which resolve the unsatisfied + // dependent issue (see unsatisfied_dependents for details) may + // potentially be sub-optimal, since we do not perform the full + // backtracking by trying all the possible adjustments and picking the + // most optimal combination. Instead, we keep collecting adjustments until + // either the package builds collection succeeds or there are no more + // adjustment combinations to try (and we don't try all of them). As a + // result we, for example, may end up with some redundant constraints on + // the command line just because the respective dependents have been + // evaluated first. Generally, dropping all the redundant adjustments can + // potentially be quite time-consuming, since we would need to try + // dropping all their possible combinations. We, however, will implement + // the refinement for only the common case (adjustments are independent), + // trying to drop just one adjustment per the refinement cycle iteration + // and wait and see how it goes. + // + cmdline_adjustments cmdline_adjs (hold_pkgs, dep_pkgs); + + // If both are present, then we are in the command line adjustments + // refinement cycle, where cmdline_refine_adjustment is the adjustment + // being currently dropped and cmdline_refine_index is its index on the + // stack (as it appears at the beginning of the cycle). + // + optional cmdline_refine_adjustment; + optional cmdline_refine_index; + { // Check if the package is a duplicate. Return true if it is but // harmless. @@ -6002,37 +6816,16 @@ namespace bpkg t.commit (); } - // Issue diagnostics and fail if the execution plan is finalized and - // any existing dependents are not satisfied with their dependencies. - // - // But first, try to resolve the first encountered unsatisfied - // constraint by replacing the collected unsatisfactory dependency - // with some other available package version which, while not being - // the best possible choice, is satisfactory for all the new and - // existing dependents. If succeed, punch the replacement version into - // the command line and recollect from the very beginning. Note that - // at the moment there is no backtracking and so the once selected - // package version may not be reconsidered. - // - // @@ What if a new dependent appears after the recollection for which - // the new dependency is also unsatisfactory and which we could - // solve by picking yet another different version? We could - // probably support this by marking this entry as amenable to - // change. But we will also need to keep track of what we have - // tried before in order not to yo-yo. - // - if (!refine && !unsatisfied_depts.empty ()) + if (!refine) { - const unsatisfied_dependent& dpt (unsatisfied_depts.front ()); - - assert (!dpt.ignored_constraints.empty ()); - - const ignored_constraint& ic (dpt.ignored_constraints.front ()); - - const build_package* p (pkgs.entered_build (ic.dependency)); - assert (p != nullptr); // The dependency must be collected. - - if (try_replace_dependency (o, *p, pkgs, hold_pkgs, dep_pkgs)) + // Cleanup the package build collecting state, preparing for the + // re-collection from the very beginning. + // + auto prepare_recollect = [&refine, + &scratch_exe, + &deps, + &existing_deps, + &deorphaned_deps] () { refine = true; scratch_exe = true; @@ -6040,11 +6833,171 @@ namespace bpkg deps.clear (); existing_deps.clear (); deorphaned_deps.clear (); + }; - continue; + // Issue diagnostics and fail if any existing dependents are not + // satisfied with their dependencies. + // + // But first, try to resolve the first encountered unsatisfied + // constraint by replacing the collected unsatisfactory dependency + // or some of its dependents with some other available package + // version. This version, while not being the best possible choice, + // must be satisfactory for all its new and existing dependents. If + // succeed, punch the replacement version into the command line and + // recollect from the very beginning (see unsatisfied_dependents for + // details). + // + if (!unsatisfied_depts.empty ()) + { + if (!cmdline_refine_index) // Not command line adjustments refinement? + { + const unsatisfied_dependent& dpt (unsatisfied_depts.front ()); + + assert (!dpt.ignored_constraints.empty ()); + + const ignored_constraint& ic (dpt.ignored_constraints.front ()); + + const build_package* p (pkgs.entered_build (ic.dependency)); + assert (p != nullptr); // The dependency must be collected. + + l5 ([&]{trace << "try to replace unsatisfactory dependency " + << p->available_name_version_db () << " with some " + << "other version";}); + + optional a; + vector unsatisfied_dpts; + set visited_dpts; + + if ((a = try_replace_dependency (o, + *p, + pkgs, + hold_pkgs, + dep_pkgs, + cmdline_adjs, + unsatisfied_dpts, + "unsatisfactory dependency")) || + (a = try_replace_dependent (o, + *p, + &ic.unsatisfied_constraints, + pkgs, + cmdline_adjs, + unsatisfied_dpts, + hold_pkgs, + dep_pkgs, + visited_dpts)) || + !cmdline_adjs.empty ()) + { + if (a) + { + cmdline_adjs.push (move (*a)); + } + else + { + cmdline_adjustment a (cmdline_adjs.pop ()); + + l5 ([&]{trace << "cannot replace any package, rolling back " + << "latest command line adjustment (" + << cmdline_adjs.to_string (a) << ')';}); + } + + prepare_recollect (); + } + else + unsatisfied_depts.diag (pkgs); // Issue the diagnostics and fail. + } + else // We are in the command line adjustments refinement cycle. + { + // Since we have failed to collect, then the currently dropped + // command line adjustment is essential. Thus, push it back to + // the stack, drop the next one, and retry. If this is the last + // adjustment in the stack, then we assume that no further + // refinement is possible and we just recollect, assuming that + // this recollection will be successful. + // + assert (cmdline_refine_adjustment); // Wouldn't be here otherwise. + + l5 ([&]{trace << "attempt to refine command line adjustments by " + << "rolling back adjustment " + << cmdline_adjs.to_string ( + *cmdline_refine_adjustment) + << " failed, pushing it back";}); + + cmdline_adjs.push (move (*cmdline_refine_adjustment)); + + // Index of the being previously dropped adjustment must be + // valid. + // + assert (*cmdline_refine_index != cmdline_adjs.size ()); + + if (++(*cmdline_refine_index) != cmdline_adjs.size ()) + { + cmdline_refine_adjustment = cmdline_adjs.pop (true /* front */); + + l5 ([&]{trace << "continue with command line adjustments " + << "refinement cycle by rolling back adjustment " + << cmdline_adjs.to_string ( + *cmdline_refine_adjustment);}); + } + else + { + cmdline_refine_adjustment = nullopt; + + l5 ([&]{trace << "cannot further refine command line " + << "adjustments, performing final collection";}); + } + + prepare_recollect (); + } } + // + // If the collection was successful, then see if we still need to + // perform the command line adjustments refinement. + // + else if (cmdline_adjs.tried () && + (!cmdline_refine_index || + *cmdline_refine_index != cmdline_adjs.size ())) + { + // If some command line adjustment is currently being dropped, + // that means that this adjustment is redundant. + // + bool initial (!cmdline_refine_index); + + if (!initial) + { + assert (cmdline_refine_adjustment); + + l5 ([&]{trace << "command line adjustment " + << cmdline_adjs.to_string ( + *cmdline_refine_adjustment) + << " is redundant, dropping it";}); + + cmdline_refine_adjustment = nullopt; + cmdline_refine_index = nullopt; + } + + // We cannot remove all the adjustments during the refinement. + // Otherwise, we shouldn't be failing in the first place. + // + assert (!cmdline_adjs.empty ()); + + // If there is just a single adjustment left, then there is + // nothing to refine anymore. + // + if (cmdline_adjs.size () != 1) + { + cmdline_refine_adjustment = cmdline_adjs.pop (true /* front */); + cmdline_refine_index = 0; - unsatisfied_depts.diag (pkgs); + l5 ([&]{trace << (initial ? "start" : "re-start") << " command " + << "line adjustments refinement cycle by rolling " + << "back first adjustment (" + << cmdline_adjs.to_string ( + *cmdline_refine_adjustment) + << ')';}); + + prepare_recollect (); + } + } } } } diff --git a/tests/common/satisfy/libbaz-1.2.0.tar.gz b/tests/common/satisfy/libbaz-1.2.0.tar.gz index 86b6e25..ad05b7e 100644 Binary files a/tests/common/satisfy/libbaz-1.2.0.tar.gz and b/tests/common/satisfy/libbaz-1.2.0.tar.gz differ diff --git a/tests/common/satisfy/libfoo-3.0.0.tar.gz b/tests/common/satisfy/libfoo-3.0.0.tar.gz index 55dc602..3ef4fdf 100644 Binary files a/tests/common/satisfy/libfoo-3.0.0.tar.gz and b/tests/common/satisfy/libfoo-3.0.0.tar.gz differ diff --git a/tests/common/satisfy/t4k/libbar-1.0.0.tar.gz b/tests/common/satisfy/t4k/libbar-1.0.0.tar.gz new file mode 100644 index 0000000..4fbd21e Binary files /dev/null and b/tests/common/satisfy/t4k/libbar-1.0.0.tar.gz differ diff --git a/tests/common/satisfy/t4k/libbaz-1.0.0.tar.gz b/tests/common/satisfy/t4k/libbaz-1.0.0.tar.gz new file mode 100644 index 0000000..dc17b9f Binary files /dev/null and b/tests/common/satisfy/t4k/libbaz-1.0.0.tar.gz differ diff --git a/tests/common/satisfy/t4k/libfax-1.0.0.tar.gz b/tests/common/satisfy/t4k/libfax-1.0.0.tar.gz new file mode 100644 index 0000000..8145884 Binary files /dev/null and b/tests/common/satisfy/t4k/libfax-1.0.0.tar.gz differ diff --git a/tests/common/satisfy/t4k/libfax-2.0.0.tar.gz b/tests/common/satisfy/t4k/libfax-2.0.0.tar.gz new file mode 100644 index 0000000..7ab921f Binary files /dev/null and b/tests/common/satisfy/t4k/libfax-2.0.0.tar.gz differ diff --git a/tests/common/satisfy/t4k/libfaz-1.0.0.tar.gz b/tests/common/satisfy/t4k/libfaz-1.0.0.tar.gz new file mode 100644 index 0000000..3ab004a Binary files /dev/null and b/tests/common/satisfy/t4k/libfaz-1.0.0.tar.gz differ diff --git a/tests/common/satisfy/t4k/libfaz-2.0.0.tar.gz b/tests/common/satisfy/t4k/libfaz-2.0.0.tar.gz new file mode 100644 index 0000000..1c3d003 Binary files /dev/null and b/tests/common/satisfy/t4k/libfaz-2.0.0.tar.gz differ diff --git a/tests/common/satisfy/t4k/libfex-1.0.0.tar.gz b/tests/common/satisfy/t4k/libfex-1.0.0.tar.gz new file mode 100644 index 0000000..f008cc0 Binary files /dev/null and b/tests/common/satisfy/t4k/libfex-1.0.0.tar.gz differ diff --git a/tests/common/satisfy/t4k/libfex-2.0.0.tar.gz b/tests/common/satisfy/t4k/libfex-2.0.0.tar.gz new file mode 100644 index 0000000..9cefe9f Binary files /dev/null and b/tests/common/satisfy/t4k/libfex-2.0.0.tar.gz differ diff --git a/tests/common/satisfy/t4k/libfix-1.0.0.tar.gz b/tests/common/satisfy/t4k/libfix-1.0.0.tar.gz new file mode 100644 index 0000000..fe1a6e9 Binary files /dev/null and b/tests/common/satisfy/t4k/libfix-1.0.0.tar.gz differ diff --git a/tests/common/satisfy/t4k/libfix-2.0.0.tar.gz b/tests/common/satisfy/t4k/libfix-2.0.0.tar.gz new file mode 100644 index 0000000..7b09f8b Binary files /dev/null and b/tests/common/satisfy/t4k/libfix-2.0.0.tar.gz differ diff --git a/tests/common/satisfy/t4k/libfoo-1.0.0.tar.gz b/tests/common/satisfy/t4k/libfoo-1.0.0.tar.gz new file mode 100644 index 0000000..38bb25b Binary files /dev/null and b/tests/common/satisfy/t4k/libfoo-1.0.0.tar.gz differ diff --git a/tests/common/satisfy/t4k/libfoo-2.0.0.tar.gz b/tests/common/satisfy/t4k/libfoo-2.0.0.tar.gz new file mode 100644 index 0000000..b868a61 Binary files /dev/null and b/tests/common/satisfy/t4k/libfoo-2.0.0.tar.gz differ diff --git a/tests/common/satisfy/t4k/libfox-1.0.0.tar.gz b/tests/common/satisfy/t4k/libfox-1.0.0.tar.gz new file mode 100644 index 0000000..0a1e328 Binary files /dev/null and b/tests/common/satisfy/t4k/libfox-1.0.0.tar.gz differ diff --git a/tests/common/satisfy/t4k/libfox-1.2.0.tar.gz b/tests/common/satisfy/t4k/libfox-1.2.0.tar.gz new file mode 100644 index 0000000..34efae0 Binary files /dev/null and b/tests/common/satisfy/t4k/libfox-1.2.0.tar.gz differ diff --git a/tests/common/satisfy/t4k/libfox-2.0.0.tar.gz b/tests/common/satisfy/t4k/libfox-2.0.0.tar.gz new file mode 100644 index 0000000..ce73b71 Binary files /dev/null and b/tests/common/satisfy/t4k/libfox-2.0.0.tar.gz differ diff --git a/tests/common/satisfy/t4k/libfux-1.0.0.tar.gz b/tests/common/satisfy/t4k/libfux-1.0.0.tar.gz new file mode 100644 index 0000000..983cda7 Binary files /dev/null and b/tests/common/satisfy/t4k/libfux-1.0.0.tar.gz differ diff --git a/tests/common/satisfy/t4k/libfux-2.0.0.tar.gz b/tests/common/satisfy/t4k/libfux-2.0.0.tar.gz new file mode 100644 index 0000000..0f63133 Binary files /dev/null and b/tests/common/satisfy/t4k/libfux-2.0.0.tar.gz differ diff --git a/tests/common/satisfy/t4k/libfuz-1.0.0.tar.gz b/tests/common/satisfy/t4k/libfuz-1.0.0.tar.gz new file mode 100644 index 0000000..42b2c0e Binary files /dev/null and b/tests/common/satisfy/t4k/libfuz-1.0.0.tar.gz differ diff --git a/tests/common/satisfy/t4k/libfuz-2.0.0.tar.gz b/tests/common/satisfy/t4k/libfuz-2.0.0.tar.gz new file mode 100644 index 0000000..c31d82a Binary files /dev/null and b/tests/common/satisfy/t4k/libfuz-2.0.0.tar.gz differ diff --git a/tests/common/satisfy/t4k/repositories.manifest b/tests/common/satisfy/t4k/repositories.manifest new file mode 100644 index 0000000..5b70556 --- /dev/null +++ b/tests/common/satisfy/t4k/repositories.manifest @@ -0,0 +1 @@ +: 1 diff --git a/tests/pkg-build.testscript b/tests/pkg-build.testscript index b982734..443ce5f 100644 --- a/tests/pkg-build.testscript +++ b/tests/pkg-build.testscript @@ -138,6 +138,28 @@ # | |-- libbaz-2.1.0.tar.gz # | `-- repositories.manifest # | +# |-- t4k +# | |-- libbar-1.0.0.tar.gz -> libfoo == 1.0.0 +# | |-- libbaz-1.0.0.tar.gz -> libfox +# | |-- libfoo-1.0.0.tar.gz -> libfix == 1.0.0 +# | |-- libfoo-2.0.0.tar.gz -> libfix == 2.0.0 +# | |-- libfox-1.0.0.tar.gz -> libfux == 1.0.0 +# | |-- libfox-1.2.0.tar.gz -> libfux == 1.0.0, libfex >= 2.0.0 +# | |-- libfox-2.0.0.tar.gz -> libfux == 2.0.0 +# | |-- libfix-1.0.0.tar.gz -> libfax == 1.0.0 +# | |-- libfix-2.0.0.tar.gz -> libfax == 2.0.0 +# | |-- libfux-1.0.0.tar.gz -> libfaz == 1.0.0, libfex == 1.0.0 +# | |-- libfux-2.0.0.tar.gz -> libfaz == 2.0.0, libfex == 2.0.0 +# | |-- libfex-1.0.0.tar.gz -> libfaz == 1.0.0 +# | |-- libfex-2.0.0.tar.gz -> libfaz == 2.0.0 +# | |-- libfax-1.0.0.tar.gz -> libfuz == 1.0.0 +# | |-- libfax-2.0.0.tar.gz -> libfuz == 2.0.0 +# | |-- libfaz-1.0.0.tar.gz -> libfuz == 1.0.0 +# | |-- libfaz-2.0.0.tar.gz -> libfuz == 2.0.0 +# | |-- libfuz-1.0.0.tar.gz +# | |-- libfuz-2.0.0.tar.gz +# | `-- repositories.manifest +# | # |-- t5 # | |-- libbar-1.2.0.tar.gz # | |-- libbox-1.2.0.tar.gz @@ -521,6 +543,7 @@ posix = ($cxx.target.class != 'windows') cp -r $src/t4f $out/t4f && $rep_create $out/t4f &$out/t4f/packages.manifest cp -r $src/t4i $out/t4i && $rep_create $out/t4i &$out/t4i/packages.manifest cp -r $src/t4j $out/t4j && $rep_create $out/t4j &$out/t4j/packages.manifest + cp -r $src/t4k $out/t4k && $rep_create $out/t4k &$out/t4k/packages.manifest cp -r $src/t5 $out/t5 && $rep_create $out/t5 &$out/t5/packages.manifest cp -r $src/t6 $out/t6 && $rep_create $out/t6 &$out/t6/packages.manifest cp -r $src/t7a $out/t7a && $rep_create $out/t7a &$out/t7a/packages.manifest @@ -2203,22 +2226,65 @@ test.arguments += --sys-no-query # Picks up the latest libbaz (2.0.0) as a prerequisite for foo, which # leads to the conflict between libbaz/2.0.0 and libbox/1.0.0 about # prerequisite libbar because of the incompatible version constraints. + # This get automatically resolved by the unsatisfied constraints + # resolution machinery. # - $* foo 2>>EOE != 0; - error: unable to satisfy constraints on package libbar - info: libbaz/2.0.0 depends on (libbar ^2.0.0) - info: libbox/1.0.0 depends on (libbar ^1.0.0) - info: available libbar/2.0.0 - info: available libbar/1.0.0 - info: while satisfying libbox/1.0.0 - info: while satisfying foo/1.0.0 - info: explicitly specify libbar version to manually satisfy both constraints + $* foo --plan '' --verbose 5 2>>~%EOE%; + %.* + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add foo/1.0.0 + trace: collect_build_prerequisites: begin foo/1.0.0 + trace: collect_build: add libbaz/2.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbaz/2.0.0 of dependent foo/1.0.0 + trace: collect_build_prerequisites: begin libbaz/2.0.0 + trace: collect_build: add libbar/2.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/2.0.0 of dependent libbaz/2.0.0 + trace: collect_build_prerequisites: begin libbar/2.0.0 + trace: collect_build_prerequisites: end libbar/2.0.0 + trace: collect_build_prerequisites: end libbaz/2.0.0 + trace: collect_build: add libbox/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbox/1.0.0 of dependent foo/1.0.0 + trace: collect_build_prerequisites: begin libbox/1.0.0 + trace: collect_build: postpone failure for dependent libbox unsatisfied with dependency libbar/2.0.0 (^1.0.0) + trace: collect_build: pick libbar/2.0.0 over libbar/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/2.0.0 of dependent libbox/1.0.0 + trace: collect_build_prerequisites: end libbox/1.0.0 + trace: collect_build_prerequisites: end foo/1.0.0 + trace: execute_plan: simulate: yes + %.* + trace: pkg_build: try to replace unsatisfactory dependency libbar/2.0.0 with some other version + trace: try_replace_dependent: try to replace unsatisfied dependent libbox/1.0.0 of dependency libbar/2.0.0 with some other version + trace: try_replace_dependent: try to replace conflicting dependent libbaz/2.0.0 of dependency libbar/2.0.0 with some other version + trace: try_replace_dependency: replace conflicting dependent version libbaz/2.0.0 with 1.0.0 by adding package spec '?libbaz == 1.0.0' to command line + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add foo/1.0.0 + trace: collect_build_prerequisites: begin foo/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbaz/1.0.0 of dependent foo/1.0.0 + trace: collect_build_prerequisites: begin libbaz/1.0.0 + trace: collect_build: add libbar/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/1.0.0 of dependent libbaz/1.0.0 + trace: collect_build_prerequisites: begin libbar/1.0.0 + trace: collect_build_prerequisites: end libbar/1.0.0 + trace: collect_build_prerequisites: end libbaz/1.0.0 + trace: collect_build: add libbox/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbox/1.0.0 of dependent foo/1.0.0 + trace: collect_build_prerequisites: begin libbox/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/1.0.0 of dependent libbox/1.0.0 + trace: collect_build_prerequisites: end libbox/1.0.0 + trace: collect_build_prerequisites: end foo/1.0.0 + trace: execute_plan: simulate: yes + %.* + new libbar/1.0.0 (required by libbaz, libbox) + new libbaz/1.0.0 (required by foo) + new libbox/1.0.0 (required by foo) + new foo/1.0.0 + trace: execute_plan: simulate: no + %.* EOE - $* foo ?libbaz/1.0.0 2>!; $pkg_status -r >>EOO; !foo configured 1.0.0 - libbaz configured !1.0.0 available 2.0.0 + libbaz configured 1.0.0 available 2.0.0 libbar configured 1.0.0 available 2.0.0 libbox configured 1.0.0 libbar configured 1.0.0 available 2.0.0 @@ -2271,20 +2337,49 @@ test.arguments += --sys-no-query libbar configured 1.0.0 available 2.0.0 EOO - # Unable to satisfy the dependent libbox with an upgraded (due to - # libbaz 2.0.0) prerequisite libbar/2.0.0. + # Initially unable to satisfy the dependent libbox with an upgraded + # (due to libbaz 2.0.0) prerequisite libbar/2.0.0. But this get + # automatically resolved by the unsatisfied constraints resolution + # machinery. # - $* ?libbaz 2>>EOE != 0; - error: unable to upgrade package libbar/1.0.0 to 2.0.0 - info: because configured package libbox/1.0.0 depends on (libbar ^1.0.0) - info: package libbar/2.0.0 required by - libbaz/2.0.0 (libbar ^2.0.0) - info: re-run with -v for additional dependency information - info: consider re-trying with --upgrade|-u potentially combined with --recursive|-r - info: or explicitly request up/downgrade of package libbox - info: or explicitly specify package libbar version to manually satisfy these constraints + $* ?libbaz --plan '' --verbose 5 2>>~%EOE%; + %.* + trace: pkg_build: refine package collection/plan execution from scratch + trace: execute_plan: simulate: yes + trace: evaluate_dependency: libbaz/1.0.0: update to libbaz/2.0.0 + trace: pkg_build: refine package collection/plan execution + trace: collect_build_prerequisites: pre-reeval foo/1.0.0 + trace: collect_build_prerequisites: pre-reevaluated foo/1.0.0: end reached + trace: collect_build_prerequisites: begin libbaz/2.0.0 + trace: collect_build: add libbar/2.0.0 + info: package libbaz dependency on (libbar ^2.0.0) is forcing upgrade of libbar/1.0.0 to 2.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/2.0.0 of dependent libbaz/2.0.0 + trace: collect_build_prerequisites: skip being built existing dependent libbaz of dependency libbar + trace: collect_build_prerequisites: skip unsatisfied existing dependent libbox of dependency libbar/2.0.0 due to constraint (libbar ^1.0.0) + trace: collect_build_prerequisites: begin libbar/2.0.0 + trace: collect_build_prerequisites: end libbar/2.0.0 + trace: collect_build_prerequisites: end libbaz/2.0.0 + trace: collect_dependents: postpone failure for existing dependent libbox unsatisfied with dependency libbar/2.0.0 (^1.0.0) + trace: execute_plan: simulate: yes + %.* + trace: pkg_build: try to replace unsatisfactory dependency libbar/2.0.0 with some other version + trace: try_replace_dependent: try to replace unsatisfiable dependent libbaz/2.0.0 of dependency libbar/2.0.0 with some other version + trace: try_replace_dependency: replace unsatisfiable dependent version libbaz/2.0.0 with 1.0.0 by adding constraint '?libbaz' -> '?libbaz == 1.0.0' on command line + trace: pkg_build: refine package collection/plan execution from scratch + trace: execute_plan: simulate: yes + %.* + trace: execute_plan: simulate: no + %.* EOE + $pkg_status -r >>EOO; + !foo configured 1.0.0 + libbaz configured 1.0.0 available 2.0.0 + libbar configured 1.0.0 available 2.0.0 + libbox configured 1.0.0 + libbar configured 1.0.0 available 2.0.0 + EOO + $pkg_drop foo } } @@ -2298,24 +2393,109 @@ test.arguments += --sys-no-query $clone_root_cfg; $rep_add ../../1/t9-3 && $rep_fetch; - # Similar to the repository state 2, picks up the latest libbaz (2.0.0) - # as a prerequisite for foo, which leads to the conflict. + # Similar to the repository state 2, picks up the latest libbaz + # (2.0.0) as a prerequisite for foo, which leads to the conflict, + # which is resolved automatically. # - $* foo 2>>EOE != 0; - error: unable to satisfy constraints on package libbar - info: libbaz/2.0.0 depends on (libbar ^2.0.0) - info: libbox/1.1.0 depends on (libbar ^1.0.0) - info: available libbar/2.0.0 - info: available libbar/1.0.0 - info: while satisfying libbox/1.1.0 - info: while satisfying foo/1.0.0 - info: explicitly specify libbar version to manually satisfy both constraints + $* foo --plan '' --verbose 5 2>>~%EOE%; + %.* + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add foo/1.0.0 + trace: collect_build_prerequisites: begin foo/1.0.0 + trace: collect_build: add libbaz/2.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbaz/2.0.0 of dependent foo/1.0.0 + trace: collect_build_prerequisites: begin libbaz/2.0.0 + trace: collect_build: add libbar/2.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/2.0.0 of dependent libbaz/2.0.0 + trace: collect_build_prerequisites: begin libbar/2.0.0 + trace: collect_build_prerequisites: end libbar/2.0.0 + trace: collect_build_prerequisites: end libbaz/2.0.0 + trace: collect_build: add libbox/1.1.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbox/1.1.0 of dependent foo/1.0.0 + trace: collect_build_prerequisites: begin libbox/1.1.0 + trace: collect_build: postpone failure for dependent libbox unsatisfied with dependency libbar/2.0.0 (^1.0.0) + trace: collect_build: pick libbar/2.0.0 over libbar/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/2.0.0 of dependent libbox/1.1.0 + trace: collect_build_prerequisites: end libbox/1.1.0 + trace: collect_build_prerequisites: end foo/1.0.0 + trace: execute_plan: simulate: yes + %.* + trace: pkg_build: try to replace unsatisfactory dependency libbar/2.0.0 with some other version + trace: try_replace_dependent: try to replace unsatisfied dependent libbox/1.1.0 of dependency libbar/2.0.0 with some other version + trace: try_replace_dependency: replace unsatisfied dependent version libbox/1.1.0 with 1.0.0 by adding package spec '?libbox == 1.0.0' to command line + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add foo/1.0.0 + trace: collect_build_prerequisites: begin foo/1.0.0 + trace: collect_build: add libbaz/2.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbaz/2.0.0 of dependent foo/1.0.0 + trace: collect_build_prerequisites: begin libbaz/2.0.0 + trace: collect_build: add libbar/2.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/2.0.0 of dependent libbaz/2.0.0 + trace: collect_build_prerequisites: begin libbar/2.0.0 + trace: collect_build_prerequisites: end libbar/2.0.0 + trace: collect_build_prerequisites: end libbaz/2.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbox/1.0.0 of dependent foo/1.0.0 + trace: collect_build_prerequisites: begin libbox/1.0.0 + trace: collect_build: postpone failure for dependent libbox unsatisfied with dependency libbar/2.0.0 (^1.0.0) + trace: collect_build: pick libbar/2.0.0 over libbar/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/2.0.0 of dependent libbox/1.0.0 + trace: collect_build_prerequisites: end libbox/1.0.0 + trace: collect_build_prerequisites: end foo/1.0.0 + trace: execute_plan: simulate: yes + %.* + trace: pkg_build: try to replace unsatisfactory dependency libbar/2.0.0 with some other version + trace: try_replace_dependent: try to replace unsatisfied dependent libbox/1.0.0 of dependency libbar/2.0.0 with some other version + trace: try_replace_dependency: replacement of unsatisfied dependent version libbox/1.0.0 is denied since it is specified on command line as '?libbox == 1.0.0' + trace: try_replace_dependent: try to replace conflicting dependent libbaz/2.0.0 of dependency libbar/2.0.0 with some other version + trace: try_replace_dependency: replace conflicting dependent version libbaz/2.0.0 with 1.0.0 by adding package spec '?libbaz == 1.0.0' to command line + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add foo/1.0.0 + trace: collect_build_prerequisites: begin foo/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbaz/1.0.0 of dependent foo/1.0.0 + trace: collect_build_prerequisites: begin libbaz/1.0.0 + trace: collect_build: add libbar/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/1.0.0 of dependent libbaz/1.0.0 + trace: collect_build_prerequisites: begin libbar/1.0.0 + trace: collect_build_prerequisites: end libbar/1.0.0 + trace: collect_build_prerequisites: end libbaz/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbox/1.0.0 of dependent foo/1.0.0 + trace: collect_build_prerequisites: begin libbox/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/1.0.0 of dependent libbox/1.0.0 + trace: collect_build_prerequisites: end libbox/1.0.0 + trace: collect_build_prerequisites: end foo/1.0.0 + trace: execute_plan: simulate: yes + %.* + trace: pkg_build: start command line adjustments refinement cycle by rolling back first adjustment ('?libbox == 1.0.0') + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add foo/1.0.0 + trace: collect_build_prerequisites: begin foo/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbaz/1.0.0 of dependent foo/1.0.0 + trace: collect_build_prerequisites: begin libbaz/1.0.0 + trace: collect_build: add libbar/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/1.0.0 of dependent libbaz/1.0.0 + trace: collect_build_prerequisites: begin libbar/1.0.0 + trace: collect_build_prerequisites: end libbar/1.0.0 + trace: collect_build_prerequisites: end libbaz/1.0.0 + trace: collect_build: add libbox/1.1.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbox/1.1.0 of dependent foo/1.0.0 + trace: collect_build_prerequisites: begin libbox/1.1.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/1.0.0 of dependent libbox/1.1.0 + trace: collect_build_prerequisites: end libbox/1.1.0 + trace: collect_build_prerequisites: end foo/1.0.0 + trace: execute_plan: simulate: yes + %.* + trace: pkg_build: command line adjustment '?libbox == 1.0.0' is redundant, dropping it + new libbar/1.0.0 (required by libbaz, libbox) + new libbaz/1.0.0 (required by foo) + new libbox/1.1.0 (required by foo) + new foo/1.0.0 + trace: execute_plan: simulate: no + %.* EOE - $* foo ?libbaz/1.0.0 2>!; $pkg_status -r >>EOO; !foo configured 1.0.0 - libbaz configured !1.0.0 available 2.0.0 + libbaz configured 1.0.0 available 2.0.0 libbar configured 1.0.0 available 2.0.0 libbox configured 1.1.0 libbar configured 1.0.0 available 2.0.0 @@ -2368,34 +2548,146 @@ test.arguments += --sys-no-query libbar configured 1.0.0 available 2.0.0 EOO - # Unable to satisfy the dependent libbox with an upgraded (due to - # libbaz 2.0.0) prerequisite libbar/2.0.0. + test.arguments += --plan '' --verbose 5; + + # Initially, unable to satisfy the dependent libbox with an upgraded + # (due to libbaz 2.0.0) prerequisite libbar/2.0.0. But this get + # automatically resolved by the unsatisfied constraints resolution + # machinery. # - $* foo ?libbaz 2>>EOE != 0; - error: unable to upgrade package libbar/1.0.0 to 2.0.0 - info: because configured package libbox/1.0.0 depends on (libbar ^1.0.0) - info: package libbar/2.0.0 required by - libbaz/2.0.0 (libbar ^2.0.0) - info: re-run with -v for additional dependency information - info: consider re-trying with --upgrade|-u potentially combined with --recursive|-r - info: or explicitly request up/downgrade of package libbox - info: or explicitly specify package libbar version to manually satisfy these constraints + $* foo ?libbaz 2>>~%EOE%; + %.* + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add foo/1.0.0 + trace: collect_build_prerequisites: skip configured foo/1.0.0 + trace: execute_plan: simulate: yes + trace: evaluate_dependency: libbaz/1.0.0: update to libbaz/2.0.0 + trace: pkg_build: refine package collection/plan execution + trace: collect_build_prerequisites: pre-reeval foo/1.0.0 + trace: collect_build_prerequisites: pre-reevaluated foo/1.0.0: end reached + trace: collect_build_prerequisites: begin libbaz/2.0.0 + trace: collect_build: add libbar/2.0.0 + info: package libbaz dependency on (libbar ^2.0.0) is forcing upgrade of libbar/1.0.0 to 2.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/2.0.0 of dependent libbaz/2.0.0 + trace: collect_build_prerequisites: skip being built existing dependent libbaz of dependency libbar + trace: collect_build_prerequisites: skip unsatisfied existing dependent libbox of dependency libbar/2.0.0 due to constraint (libbar ^1.0.0) + trace: collect_build_prerequisites: begin libbar/2.0.0 + trace: collect_build_prerequisites: end libbar/2.0.0 + trace: collect_build_prerequisites: end libbaz/2.0.0 + trace: collect_dependents: postpone failure for existing dependent libbox unsatisfied with dependency libbar/2.0.0 (^1.0.0) + trace: execute_plan: simulate: yes + %.* + trace: pkg_build: try to replace unsatisfactory dependency libbar/2.0.0 with some other version + trace: try_replace_dependent: try to replace unsatisfiable dependent libbaz/2.0.0 of dependency libbar/2.0.0 with some other version + trace: try_replace_dependency: replace unsatisfiable dependent version libbaz/2.0.0 with 1.0.0 by adding constraint '?libbaz' -> '?libbaz == 1.0.0' on command line + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add foo/1.0.0 + trace: collect_build_prerequisites: skip configured foo/1.0.0 + trace: execute_plan: simulate: yes + %.* + update foo/1.0.0 + trace: execute_plan: simulate: no + %.* EOE - # libbar/2.0.0 is still unsatisfactory as a prerequisite for libbox, - # even after libbox upgrade is requested on the command line. + $pkg_status -r >>EOO; + !foo configured 1.0.0 + libbaz configured 1.0.0 available 2.0.0 + libbar configured 1.0.0 available 2.0.0 + libbox configured 1.0.0 available 1.1.0 + libbar configured 1.0.0 available 2.0.0 + EOO + + # libbar/2.0.0 is still unsatisfactory, initially, as a prerequisite + # for libbox, even after libbox upgrade is requested on the command + # line. This get automatically resolved by the unsatisfied constraints + # resolution machinery. # - $* foo ?libbaz ?libbox 2>>EOE != 0; - error: unable to satisfy constraints on package libbar - info: libbaz/2.0.0 depends on (libbar ^2.0.0) - info: libbox/1.1.0 depends on (libbar ^1.0.0) - info: available libbar/2.0.0 - info: available libbar/1.0.0 - info: while satisfying libbox/1.1.0 - info: explicitly specify libbar version to manually satisfy both constraints + $* foo ?libbaz ?libbox 2>>~%EOE%; + %.* + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add foo/1.0.0 + trace: collect_build_prerequisites: skip configured foo/1.0.0 + trace: execute_plan: simulate: yes + trace: evaluate_dependency: libbaz/1.0.0: update to libbaz/2.0.0 + trace: evaluate_dependency: libbox/1.0.0: update to libbox/1.1.0 + trace: pkg_build: refine package collection/plan execution + trace: collect_build_prerequisites: pre-reeval foo/1.0.0 + trace: collect_build_prerequisites: pre-reevaluated foo/1.0.0: end reached + trace: collect_build_prerequisites: begin libbaz/2.0.0 + trace: collect_build: add libbar/2.0.0 + info: package libbaz dependency on (libbar ^2.0.0) is forcing upgrade of libbar/1.0.0 to 2.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/2.0.0 of dependent libbaz/2.0.0 + trace: collect_build_prerequisites: skip being built existing dependent libbaz of dependency libbar + trace: collect_build_prerequisites: skip unsatisfied existing dependent libbox of dependency libbar/2.0.0 due to constraint (libbar ^1.0.0) + trace: collect_build_prerequisites: begin libbar/2.0.0 + trace: collect_build_prerequisites: end libbar/2.0.0 + trace: collect_build_prerequisites: end libbaz/2.0.0 + trace: collect_build_prerequisites: pre-reeval foo/1.0.0 + trace: collect_build_prerequisites: pre-reevaluated foo/1.0.0: end reached + trace: collect_build_prerequisites: begin libbox/1.1.0 + trace: collect_build: postpone failure for dependent libbox unsatisfied with dependency libbar/2.0.0 (^1.0.0) + trace: collect_build: pick libbar/2.0.0 over libbar/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/2.0.0 of dependent libbox/1.1.0 + trace: collect_build_prerequisites: end libbox/1.1.0 + trace: execute_plan: simulate: yes + %.* + trace: pkg_build: try to replace unsatisfactory dependency libbar/2.0.0 with some other version + trace: try_replace_dependent: try to replace unsatisfied dependent libbox/1.1.0 of dependency libbar/2.0.0 with some other version + trace: try_replace_dependency: replace unsatisfied dependent version libbox/1.1.0 with 1.0.0 by adding constraint '?libbox' -> '?libbox == 1.0.0' on command line + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add foo/1.0.0 + trace: collect_build_prerequisites: skip configured foo/1.0.0 + trace: execute_plan: simulate: yes + trace: evaluate_dependency: libbaz/1.0.0: update to libbaz/2.0.0 + %.* + trace: pkg_build: refine package collection/plan execution + trace: collect_build_prerequisites: pre-reeval foo/1.0.0 + trace: collect_build_prerequisites: pre-reevaluated foo/1.0.0: end reached + trace: collect_build_prerequisites: begin libbaz/2.0.0 + trace: collect_build: add libbar/2.0.0 + info: package libbaz dependency on (libbar ^2.0.0) is forcing upgrade of libbar/1.0.0 to 2.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/2.0.0 of dependent libbaz/2.0.0 + trace: collect_build_prerequisites: skip being built existing dependent libbaz of dependency libbar + trace: collect_build_prerequisites: skip unsatisfied existing dependent libbox of dependency libbar/2.0.0 due to constraint (libbar ^1.0.0) + trace: collect_build_prerequisites: begin libbar/2.0.0 + trace: collect_build_prerequisites: end libbar/2.0.0 + trace: collect_build_prerequisites: end libbaz/2.0.0 + trace: collect_dependents: postpone failure for existing dependent libbox unsatisfied with dependency libbar/2.0.0 (^1.0.0) + trace: execute_plan: simulate: yes + %.* + trace: pkg_build: try to replace unsatisfactory dependency libbar/2.0.0 with some other version + trace: try_replace_dependent: try to replace unsatisfiable dependent libbaz/2.0.0 of dependency libbar/2.0.0 with some other version + trace: try_replace_dependency: replace unsatisfiable dependent version libbaz/2.0.0 with 1.0.0 by adding constraint '?libbaz' -> '?libbaz == 1.0.0' on command line + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add foo/1.0.0 + trace: collect_build_prerequisites: skip configured foo/1.0.0 + trace: execute_plan: simulate: yes + %.* + trace: pkg_build: start command line adjustments refinement cycle by rolling back first adjustment ('?libbox' -> '?libbox == 1.0.0') + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add foo/1.0.0 + trace: collect_build_prerequisites: skip configured foo/1.0.0 + trace: execute_plan: simulate: yes + trace: evaluate_dependency: libbaz/1.0.0: unchanged + trace: evaluate_dependency: libbox/1.0.0: update to libbox/1.1.0 + trace: pkg_build: refine package collection/plan execution + trace: collect_build_prerequisites: pre-reeval foo/1.0.0 + trace: collect_build_prerequisites: pre-reevaluated foo/1.0.0: end reached + trace: collect_build_prerequisites: begin libbox/1.1.0 + trace: collect_build: add libbar/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/1.0.0 of dependent libbox/1.1.0 + trace: collect_build_prerequisites: skip configured libbar/1.0.0 + trace: collect_build_prerequisites: end libbox/1.1.0 + trace: execute_plan: simulate: yes + %.* + trace: pkg_build: command line adjustment '?libbox' -> '?libbox == 1.0.0' is redundant, dropping it + upgrade libbox/1.1.0 + reconfigure/update foo/1.0.0 + trace: execute_plan: simulate: no + %.* EOE - $* ?libbox 2>!; $pkg_status -r >>EOO; !foo configured 1.0.0 libbaz configured 1.0.0 available 2.0.0 @@ -2946,7 +3238,8 @@ test.arguments += --sys-no-query trace: collect_build_prerequisites: end libbiz/0.0.2 trace: execute_plan: simulate: yes %.* - trace: try_replace_dependency: replace unsatisfactory package version libbaz/0.1.0 with 0.0.3 by adding package spec '?libbaz == 0.0.3' to command line + trace: pkg_build: try to replace unsatisfactory dependency libbaz/0.1.0 with some other version + trace: try_replace_dependency: replace unsatisfactory dependency version libbaz/0.1.0 with 0.0.3 by adding package spec '?libbaz == 0.0.3' to command line trace: pkg_build: refine package collection/plan execution from scratch trace: collect_build: add libfix/0.0.3 trace: collect_build: add libbiz/0.0.2 @@ -3015,40 +3308,71 @@ test.arguments += --sys-no-query : Test resolving a conflict when libbox and libfox have selected such : versions of their dependency libfoo, that do not satisfy each other : constraints. Note that these constraints are incompatible, so we - : resolve the conflict explicitly specifying ?libfox/0.0.1 on the - : command line, to replace one of the conflicting dependents. + : automatically resolve the conflict by implicitly specifying + : ?libfox/0.0.1 on the command line, to replace one of the conflicting + : dependents. : { $clone_root_cfg; $rep_fetch $rep/t0d; - $* libbiz 2>>EOE != 0; - error: unable to satisfy constraints on package libfoo - info: libbox/0.0.2 depends on (libfoo == 1.0.0) - info: libfox/0.0.2 depends on (libfoo == 0.0.1) - info: available libfoo/1.0.0 - info: available libfoo/0.0.1 - info: while satisfying libbox/0.0.2 - info: while satisfying libbiz/0.0.1 - info: explicitly specify libfoo version to manually satisfy both constraints - EOE - - $* libbiz ?libfox/0.0.1 2>>EOE; - fetched libfox/0.0.1 - unpacked libfox/0.0.1 - fetched libfoo/1.0.0 - unpacked libfoo/1.0.0 - fetched libbox/0.0.2 - unpacked libbox/0.0.2 - fetched libbiz/0.0.1 - unpacked libbiz/0.0.1 - configured libfox/0.0.1 - configured libfoo/1.0.0 - configured libbox/0.0.2 - configured libbiz/0.0.1 + $* libbiz --plan "" --verbose 5 2>>~%EOE%; + %.* + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add libbiz/0.0.1 + trace: collect_build_prerequisites: begin libbiz/0.0.1 + trace: collect_build: add libfox/0.0.2 + trace: collect_build_prerequisites: no cfg-clause for dependency libfox/0.0.2 of dependent libbiz/0.0.1 + trace: collect_build_prerequisites: begin libfox/0.0.2 + trace: collect_build: add libfoo/0.0.1 + trace: collect_build_prerequisites: no cfg-clause for dependency libfoo/0.0.1 of dependent libfox/0.0.2 + trace: collect_build_prerequisites: begin libfoo/0.0.1 + trace: collect_build: add libfix/0.0.1 + trace: collect_build_prerequisites: no cfg-clause for dependency libfix/0.0.1 of dependent libfoo/0.0.1 + trace: collect_build_prerequisites: begin libfix/0.0.1 + trace: collect_build_prerequisites: end libfix/0.0.1 + trace: collect_build_prerequisites: end libfoo/0.0.1 + trace: collect_build_prerequisites: end libfox/0.0.2 + trace: collect_build: add libbox/0.0.2 + trace: collect_build_prerequisites: no cfg-clause for dependency libbox/0.0.2 of dependent libbiz/0.0.1 + trace: collect_build_prerequisites: begin libbox/0.0.2 + trace: collect_build: postpone failure for dependent libbox unsatisfied with dependency libfoo/0.0.1 (== 1.0.0) + trace: collect_build: pick libfoo/0.0.1 over libfoo/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfoo/0.0.1 of dependent libbox/0.0.2 + trace: collect_build_prerequisites: end libbox/0.0.2 + trace: collect_build_prerequisites: end libbiz/0.0.1 + trace: execute_plan: simulate: yes + %.* + trace: pkg_build: try to replace unsatisfactory dependency libfoo/0.0.1 with some other version + trace: try_replace_dependent: try to replace unsatisfied dependent libbox/0.0.2 of dependency libfoo/0.0.1 with some other version + trace: try_replace_dependent: try to replace conflicting dependent libfox/0.0.2 of dependency libfoo/0.0.1 with some other version + trace: try_replace_dependency: replace conflicting dependent version libfox/0.0.2 with 0.0.1 by adding package spec '?libfox == 0.0.1' to command line + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add libbiz/0.0.1 + trace: collect_build_prerequisites: begin libbiz/0.0.1 + trace: collect_build_prerequisites: no cfg-clause for dependency libfox/0.0.1 of dependent libbiz/0.0.1 + trace: collect_build_prerequisites: begin libfox/0.0.1 + trace: collect_build_prerequisites: end libfox/0.0.1 + trace: collect_build: add libbox/0.0.2 + trace: collect_build_prerequisites: no cfg-clause for dependency libbox/0.0.2 of dependent libbiz/0.0.1 + trace: collect_build_prerequisites: begin libbox/0.0.2 + trace: collect_build: add libfoo/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfoo/1.0.0 of dependent libbox/0.0.2 + trace: collect_build_prerequisites: begin libfoo/1.0.0 + trace: collect_build_prerequisites: end libfoo/1.0.0 + trace: collect_build_prerequisites: end libbox/0.0.2 + trace: collect_build_prerequisites: end libbiz/0.0.1 + trace: execute_plan: simulate: yes + %.* + new libfox/0.0.1 (required by libbiz) + new libfoo/1.0.0 (required by libbox) + new libbox/0.0.2 (required by libbiz) + new libbiz/0.0.1 + trace: execute_plan: simulate: no + %.* EOE - $pkg_status libfox >'libfox configured !0.0.1 available 0.0.2'; + $pkg_status libfox >'libfox configured 0.0.1 available 0.0.2'; $pkg_drop libbiz } @@ -4070,7 +4394,7 @@ test.arguments += --sys-no-query { $clone_cfg; - $* libbaz libfoo libfox --verbose 5 2>>~%EOE% != 0 + $* libbaz libfoo libfox --plan "" --verbose 5 2>>~%EOE%; %.* trace: pkg_build: refine package collection/plan execution from scratch trace: collect_build: add libbaz/2.1.0 @@ -4135,16 +4459,68 @@ test.arguments += --sys-no-query trace: collect_build_prerequisites: end libfox/3.0.0 trace: execute_plan: simulate: yes %.* - error: unable to satisfy constraints on package libbar - info: libbaz/1.2.0 depends on (libbar == 1.2.0) - libfox/3.0.0 requires (libbaz == 1.2.0) - info: libfox/3.0.0 depends on (libbar == 0.1.0) - info: available libbar/1.2.0 - info: available libbar/0.1.0 - info: while satisfying libfox/3.0.0 - info: explicitly specify libbar version to manually satisfy both constraints + trace: pkg_build: try to replace unsatisfactory dependency libbar/1.2.0 with some other version + trace: try_replace_dependent: try to replace unsatisfied dependent libfox/3.0.0 of dependency libbar/1.2.0 with some other version + trace: try_replace_dependency: replace unsatisfied dependent version libfox/3.0.0 with 2.1.0 by adding constraint 'libfox' -> 'libfox == 2.1.0' on command line + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add libbaz/2.1.0 + trace: collect_build: add libfoo/3.0.0 + trace: collect_build: add libfox/2.1.0 + trace: collect_build_prerequisites: begin libbaz/2.1.0 + trace: collect_build_prerequisites: end libbaz/2.1.0 + trace: collect_build_prerequisites: begin libfoo/3.0.0 + trace: collect_build: add libbar/1.2.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/1.2.0 of dependent libfoo/3.0.0 + trace: collect_build_prerequisites: begin libbar/1.2.0 + trace: collect_build_prerequisites: end libbar/1.2.0 + trace: collect_build_prerequisites: end libfoo/3.0.0 + trace: collect_build_prerequisites: begin libfox/2.1.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/1.2.0 of dependent libfox/2.1.0 + trace: collect_build: pick libbaz/1.2.0 over libbaz/2.1.0 + trace: collect_build: libbaz/2.1.0 package version needs to be replaced with libbaz/1.2.0 + trace: pkg_build: collection failed due to package version replacement, retry from scratch + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: apply version replacement for libbaz/2.1.0 + trace: collect_build: replacement: libbaz/1.2.0 + trace: collect_build: add libbaz/1.2.0 + trace: collect_build: add libfoo/3.0.0 + trace: collect_build: add libfox/2.1.0 + trace: collect_build_prerequisites: begin libbaz/1.2.0 + trace: collect_build: add libbar/1.2.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/1.2.0 of dependent libbaz/1.2.0 + trace: collect_build_prerequisites: begin libbar/1.2.0 + trace: collect_build_prerequisites: end libbar/1.2.0 + trace: collect_build_prerequisites: end libbaz/1.2.0 + trace: collect_build_prerequisites: begin libfoo/3.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/1.2.0 of dependent libfoo/3.0.0 + trace: collect_build_prerequisites: end libfoo/3.0.0 + trace: collect_build_prerequisites: begin libfox/2.1.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/1.2.0 of dependent libfox/2.1.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbaz/1.2.0 of dependent libfox/2.1.0 + trace: collect_build_prerequisites: end libfox/2.1.0 + trace: execute_plan: simulate: yes + %.* + new libbar/1.2.0 (required by libbaz, libfoo, libfox) + new libbaz/1.2.0 + new libfoo/3.0.0 + new libfox/2.1.0 + trace: execute_plan: simulate: no %.* EOE + + $pkg_status -ar >>EOO; + libbar configured 1.2.0 + !libbaz configured 1.2.0 available 2.1.0 + libbar configured 1.2.0 + !libfoo configured 3.0.0 + libbar configured 1.2.0 + !libfox configured 2.1.0 available 3.0.0 + libbar configured 1.2.0 + !libbaz configured 1.2.0 available 2.1.0 + libbar configured 1.2.0 + EOO + + $pkg_drop libbaz libfoo libfox } : collect-drop @@ -4239,14 +4615,15 @@ test.arguments += --sys-no-query : basics : - : This test demonstrates a case when the dependency resolution machinery - : fails to resolve unsatisfied dependency constraints by replacing an - : unsatisfied dependent version with a satisfied one. + : This test demonstrates a case when the dependency resolution + : machinery resolves unsatisfied dependency constraints by adding the + : package spec to the command line for an unsatisfied dependent + : version. : { $clone_cfg; - $* libfoo libfix 2>>~%EOE% != 0; + $* libfoo libfix 2>>~%EOE%; %.* trace: pkg_build: refine package collection/plan execution from scratch trace: collect_build: add libfoo/2.0.0 @@ -4268,44 +4645,43 @@ test.arguments += --sys-no-query trace: collect_build_prerequisites: end libfix/1.0.0 trace: execute_plan: simulate: yes %.* - error: unable to satisfy constraints on package libbar - info: libfox/2.0.0 depends on (libbar >= 2.0.0) - info: libfoo/2.0.0 depends on (libbar == 1.2.0) - info: available libbar/2.1.0 - info: available libbar/1.2.0 - info: while satisfying libfox/2.0.0 - info: while satisfying libfix/1.0.0 - info: explicitly specify libbar version to manually satisfy both constraints + trace: pkg_build: try to replace unsatisfactory dependency libbar/1.2.0 with some other version + trace: try_replace_dependent: try to replace unsatisfied dependent libfox/2.0.0 of dependency libbar/1.2.0 with some other version + trace: try_replace_dependency: replace unsatisfied dependent version libfox/2.0.0 with 1.1.0 by adding package spec '?libfox == 1.1.0' to command line + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add libfoo/2.0.0 + trace: collect_build: add libfix/1.0.0 + trace: collect_build_prerequisites: begin libfoo/2.0.0 + trace: collect_build: add libbar/1.2.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/1.2.0 of dependent libfoo/2.0.0 + trace: collect_build_prerequisites: begin libbar/1.2.0 + trace: collect_build_prerequisites: end libbar/1.2.0 + trace: collect_build_prerequisites: end libfoo/2.0.0 + trace: collect_build_prerequisites: begin libfix/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfox/1.1.0 of dependent libfix/1.0.0 + trace: collect_build_prerequisites: begin libfox/1.1.0 + trace: collect_build: pick libbar/1.2.0 over libbar/2.1.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/1.2.0 of dependent libfox/1.1.0 + trace: collect_build_prerequisites: end libfox/1.1.0 + trace: collect_build_prerequisites: end libfix/1.0.0 + trace: execute_plan: simulate: yes %.* - EOE - - $* libfoo libfix ?libfox/1.1.0 --verbose 1 2>>EOE; new libbar/1.2.0 (required by libfoo, libfox) new libfoo/2.0.0 new libfox/1.1.0 (required by libfix) new libfix/1.0.0 - fetched libbar/1.2.0 - unpacked libbar/1.2.0 - fetched libfoo/2.0.0 - unpacked libfoo/2.0.0 - fetched libfox/1.1.0 - unpacked libfox/1.1.0 - fetched libfix/1.0.0 - unpacked libfix/1.0.0 - configured libbar/1.2.0 - configured libfoo/2.0.0 - configured libfox/1.1.0 - configured libfix/1.0.0 + trace: execute_plan: simulate: no + %.* EOE $pkg_status -ar >>EOO; libbar configured 1.2.0 available 2.1.0 !libfoo configured 2.0.0 libbar configured 1.2.0 available 2.1.0 - libfox configured !1.1.0 available 2.0.0 + libfox configured 1.1.0 available 2.0.0 libbar configured 1.2.0 available 2.1.0 !libfix configured 1.0.0 - libfox configured !1.1.0 available 2.0.0 + libfox configured 1.1.0 available 2.0.0 libbar configured 1.2.0 available 2.1.0 EOO @@ -4315,12 +4691,13 @@ test.arguments += --sys-no-query : reorder : : Similar to the above, but the unsatisfied dependent which needs to be - : replaced differs from the one added to the unsatisfied dependents list. + : replaced differs from the one added to the unsatisfied dependents + : list. : { $clone_cfg; - $* libfix libfoo 2>>~%EOE% != 0; + $* libfix libfoo 2>>~%EOE%; %.* trace: pkg_build: refine package collection/plan execution from scratch trace: collect_build: add libfix/1.0.0 @@ -4350,41 +4727,67 @@ test.arguments += --sys-no-query trace: collect_build_prerequisites: end libfoo/2.0.0 trace: execute_plan: simulate: yes %.* - error: unable to satisfy constraints on package libbar - info: libfox/2.0.0 depends on (libbar >= 2.0.0) - info: libfoo/2.0.0 depends on (libbar == 1.2.0) - info: available libbar/2.1.0 - info: available libbar/1.2.0 - info: while satisfying libfoo/2.0.0 - info: explicitly specify libbar version to manually satisfy both constraints - %.* - EOE - - $* libfix libfoo ?libfox/1.1.0 --verbose 1 2>>EOE; - new libbar/1.2.0 (required by libfoo, libfox) - new libfox/1.1.0 (required by libfix) - new libfix/1.0.0 - new libfoo/2.0.0 - fetched libbar/1.2.0 - unpacked libbar/1.2.0 - fetched libfox/1.1.0 - unpacked libfox/1.1.0 - fetched libfix/1.0.0 - unpacked libfix/1.0.0 - fetched libfoo/2.0.0 - unpacked libfoo/2.0.0 - configured libbar/1.2.0 - configured libfox/1.1.0 - configured libfix/1.0.0 - configured libfoo/2.0.0 - EOE - - $pkg_status -ar >>EOO; - libbar configured 1.2.0 available 2.1.0 - libfox configured !1.1.0 available 2.0.0 - libbar configured 1.2.0 available 2.1.0 - !libfix configured 1.0.0 - libfox configured !1.1.0 available 2.0.0 + trace: pkg_build: try to replace unsatisfactory dependency libbar/2.1.0 with some other version + trace: try_replace_dependent: try to replace unsatisfied dependent libfoo/2.0.0 of dependency libbar/2.1.0 with some other version + trace: try_replace_dependent: try to replace conflicting dependent libfox/2.0.0 of dependency libbar/2.1.0 with some other version + trace: try_replace_dependency: replace conflicting dependent version libfox/2.0.0 with 1.1.0 by adding package spec '?libfox == 1.1.0' to command line + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add libfix/1.0.0 + trace: collect_build: add libfoo/2.0.0 + trace: collect_build_prerequisites: begin libfix/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfox/1.1.0 of dependent libfix/1.0.0 + trace: collect_build_prerequisites: begin libfox/1.1.0 + trace: collect_build: add libbar/2.1.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/2.1.0 of dependent libfox/1.1.0 + trace: collect_build_prerequisites: begin libbar/2.1.0 + trace: collect_build: add libbox/2.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbox/2.0.0 of dependent libbar/2.1.0 + trace: collect_build_prerequisites: begin libbox/2.0.0 + trace: collect_build: add libbax/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbax/1.0.0 of dependent libbox/2.0.0 + trace: collect_build_prerequisites: begin libbax/1.0.0 + trace: collect_build_prerequisites: end libbax/1.0.0 + trace: collect_build_prerequisites: end libbox/2.0.0 + trace: collect_build_prerequisites: end libbar/2.1.0 + trace: collect_build_prerequisites: end libfox/1.1.0 + trace: collect_build_prerequisites: end libfix/1.0.0 + trace: collect_build_prerequisites: begin libfoo/2.0.0 + trace: collect_build: pick libbar/1.2.0 over libbar/2.1.0 + trace: collect_build: libbar/2.1.0 package version needs to be replaced with libbar/1.2.0 + trace: pkg_build: collection failed due to package version replacement, retry from scratch + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add libfix/1.0.0 + trace: collect_build: add libfoo/2.0.0 + trace: collect_build_prerequisites: begin libfix/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfox/1.1.0 of dependent libfix/1.0.0 + trace: collect_build_prerequisites: begin libfox/1.1.0 + trace: collect_build: apply version replacement for libbar/2.1.0 + trace: collect_build: replacement: libbar/1.2.0 + trace: collect_build: add libbar/1.2.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/1.2.0 of dependent libfox/1.1.0 + trace: collect_build_prerequisites: begin libbar/1.2.0 + trace: collect_build_prerequisites: end libbar/1.2.0 + trace: collect_build_prerequisites: end libfox/1.1.0 + trace: collect_build_prerequisites: end libfix/1.0.0 + trace: collect_build_prerequisites: begin libfoo/2.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/1.2.0 of dependent libfoo/2.0.0 + trace: collect_build_prerequisites: end libfoo/2.0.0 + trace: execute_plan: simulate: yes + %.* + new libbar/1.2.0 (required by libfoo, libfox) + new libfox/1.1.0 (required by libfix) + new libfix/1.0.0 + new libfoo/2.0.0 + trace: execute_plan: simulate: no + %.* + EOE + + $pkg_status -ar >>EOO; + libbar configured 1.2.0 available 2.1.0 + libfox configured 1.1.0 available 2.0.0 + libbar configured 1.2.0 available 2.1.0 + !libfix configured 1.0.0 + libfox configured 1.1.0 available 2.0.0 libbar configured 1.2.0 available 2.1.0 !libfoo configured 2.0.0 libbar configured 1.2.0 available 2.1.0 @@ -4395,13 +4798,13 @@ test.arguments += --sys-no-query : to-hold : - : Similar to the replace-dependent test, but the unsatisfied dependent - : is being built to hold rather than as a dependency. + : Similar to the basics test, but the unsatisfied dependent is being + : built to hold rather than as a dependency. : { $clone_cfg; - $* libfoo libfox 2>>~%EOE% != 0; + $* libfoo libfox 2>>~%EOE%; %.* trace: pkg_build: refine package collection/plan execution from scratch trace: collect_build: add libfoo/2.0.0 @@ -4419,36 +4822,35 @@ test.arguments += --sys-no-query trace: collect_build_prerequisites: end libfox/2.0.0 trace: execute_plan: simulate: yes %.* - error: unable to satisfy constraints on package libbar - info: libfox/2.0.0 depends on (libbar >= 2.0.0) - info: libfoo/2.0.0 depends on (libbar == 1.2.0) - info: available libbar/2.1.0 - info: available libbar/1.2.0 - info: while satisfying libfox/2.0.0 - info: explicitly specify libbar version to manually satisfy both constraints + trace: try_replace_dependent: try to replace unsatisfied dependent libfox/2.0.0 of dependency libbar/1.2.0 with some other version + trace: try_replace_dependency: replace unsatisfied dependent version libfox/2.0.0 with 1.1.0 by adding constraint 'libfox' -> 'libfox == 1.1.0' on command line + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add libfoo/2.0.0 + trace: collect_build: add libfox/1.1.0 + trace: collect_build_prerequisites: begin libfoo/2.0.0 + trace: collect_build: add libbar/1.2.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/1.2.0 of dependent libfoo/2.0.0 + trace: collect_build_prerequisites: begin libbar/1.2.0 + trace: collect_build_prerequisites: end libbar/1.2.0 + trace: collect_build_prerequisites: end libfoo/2.0.0 + trace: collect_build_prerequisites: begin libfox/1.1.0 + trace: collect_build: pick libbar/1.2.0 over libbar/2.1.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/1.2.0 of dependent libfox/1.1.0 + trace: collect_build_prerequisites: end libfox/1.1.0 + trace: execute_plan: simulate: yes %.* - EOE - - $* libfoo libfox/1.1.0 --verbose 1 2>>EOE; new libbar/1.2.0 (required by libfoo, libfox) new libfoo/2.0.0 new libfox/1.1.0 - fetched libbar/1.2.0 - unpacked libbar/1.2.0 - fetched libfoo/2.0.0 - unpacked libfoo/2.0.0 - fetched libfox/1.1.0 - unpacked libfox/1.1.0 - configured libbar/1.2.0 - configured libfoo/2.0.0 - configured libfox/1.1.0 + trace: execute_plan: simulate: no + %.* EOE $pkg_status -ar >>EOO; libbar configured 1.2.0 available 2.1.0 !libfoo configured 2.0.0 libbar configured 1.2.0 available 2.1.0 - !libfox configured !1.1.0 available 2.0.0 + !libfox configured 1.1.0 available 2.0.0 libbar configured 1.2.0 available 2.1.0 EOO @@ -4458,12 +4860,13 @@ test.arguments += --sys-no-query : to-hold-reorder : : Similar to the above, but the unsatisfied dependent which needs to be - : replaced differs from the one added to the unsatisfied dependents list. + : replaced differs from the one added to the unsatisfied dependents + : list. : { $clone_cfg; - $* libfox libfoo 2>>~%EOE% != 0; + $* libfox libfoo 2>>~%EOE%; %.* trace: pkg_build: refine package collection/plan execution from scratch trace: collect_build: add libfox/2.0.0 @@ -4489,34 +4892,57 @@ test.arguments += --sys-no-query trace: collect_build_prerequisites: end libfoo/2.0.0 trace: execute_plan: simulate: yes %.* - error: unable to satisfy constraints on package libbar - info: libfox/2.0.0 depends on (libbar >= 2.0.0) - info: libfoo/2.0.0 depends on (libbar == 1.2.0) - info: available libbar/2.1.0 - info: available libbar/1.2.0 - info: while satisfying libfoo/2.0.0 - info: explicitly specify libbar version to manually satisfy both constraints + trace: pkg_build: try to replace unsatisfactory dependency libbar/2.1.0 with some other version + trace: try_replace_dependent: try to replace unsatisfied dependent libfoo/2.0.0 of dependency libbar/2.1.0 with some other version + trace: try_replace_dependent: try to replace conflicting dependent libfox/2.0.0 of dependency libbar/2.1.0 with some other version + trace: try_replace_dependency: replace conflicting dependent version libfox/2.0.0 with 1.1.0 by adding constraint 'libfox' -> 'libfox == 1.1.0' on command line + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add libfox/1.1.0 + trace: collect_build: add libfoo/2.0.0 + trace: collect_build_prerequisites: begin libfox/1.1.0 + trace: collect_build: add libbar/2.1.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/2.1.0 of dependent libfox/1.1.0 + trace: collect_build_prerequisites: begin libbar/2.1.0 + trace: collect_build: add libbox/2.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbox/2.0.0 of dependent libbar/2.1.0 + trace: collect_build_prerequisites: begin libbox/2.0.0 + trace: collect_build: add libbax/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbax/1.0.0 of dependent libbox/2.0.0 + trace: collect_build_prerequisites: begin libbax/1.0.0 + trace: collect_build_prerequisites: end libbax/1.0.0 + trace: collect_build_prerequisites: end libbox/2.0.0 + trace: collect_build_prerequisites: end libbar/2.1.0 + trace: collect_build_prerequisites: end libfox/1.1.0 + trace: collect_build_prerequisites: begin libfoo/2.0.0 + trace: collect_build: pick libbar/1.2.0 over libbar/2.1.0 + trace: collect_build: libbar/2.1.0 package version needs to be replaced with libbar/1.2.0 + trace: pkg_build: collection failed due to package version replacement, retry from scratch + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add libfox/1.1.0 + trace: collect_build: add libfoo/2.0.0 + trace: collect_build_prerequisites: begin libfox/1.1.0 + trace: collect_build: apply version replacement for libbar/2.1.0 + trace: collect_build: replacement: libbar/1.2.0 + trace: collect_build: add libbar/1.2.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/1.2.0 of dependent libfox/1.1.0 + trace: collect_build_prerequisites: begin libbar/1.2.0 + trace: collect_build_prerequisites: end libbar/1.2.0 + trace: collect_build_prerequisites: end libfox/1.1.0 + trace: collect_build_prerequisites: begin libfoo/2.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libbar/1.2.0 of dependent libfoo/2.0.0 + trace: collect_build_prerequisites: end libfoo/2.0.0 + trace: execute_plan: simulate: yes %.* - EOE - - $* libfox/1.1.0 libfoo --verbose 1 2>>EOE; new libbar/1.2.0 (required by libfoo, libfox) new libfox/1.1.0 new libfoo/2.0.0 - fetched libbar/1.2.0 - unpacked libbar/1.2.0 - fetched libfox/1.1.0 - unpacked libfox/1.1.0 - fetched libfoo/2.0.0 - unpacked libfoo/2.0.0 - configured libbar/1.2.0 - configured libfox/1.1.0 - configured libfoo/2.0.0 + trace: execute_plan: simulate: no + %.* EOE $pkg_status -ar >>EOO; libbar configured 1.2.0 available 2.1.0 - !libfox configured !1.1.0 available 2.0.0 + !libfox configured 1.1.0 available 2.0.0 libbar configured 1.2.0 available 2.1.0 !libfoo configured 2.0.0 libbar configured 1.2.0 available 2.1.0 @@ -4527,12 +4953,14 @@ test.arguments += --sys-no-query : unsatisfied-dependent : - : This test demonstrates a case when the dependency resolution machinery - : fails to complete successfully as noop. + : This test demonstrates a case when the dependency resolution + : machinery resolves unsatisfied dependency constraints by + : enforcing noop. : - : Note that there is no version constraints are specified on the command - : line, the request is to upgrade all packages to the latest possible - : versions, and thus noop in this case would be an appropriate outcome. + : Note that there is no version constraints are specified on the + : command line, the request is to upgrade all packages to the latest + : possible versions, and thus noop in this case is an appropriate + : outcome. : { $clone_cfg; @@ -4550,7 +4978,7 @@ test.arguments += --sys-no-query libbax configured 1.0.0 available 2.0.0 EOO - $* --upgrade --recursive 2>>~%EOE% != 0; + $* --upgrade --recursive 2>>~%EOE%; %.* trace: pkg_build: refine package collection/plan execution from scratch trace: collect_build: add libbox/2.0.0 @@ -4577,18 +5005,280 @@ test.arguments += --sys-no-query trace: collect_dependents: postpone failure for existing dependent libbox unsatisfied with dependency libbax/2.0.0 (== 1.0.0) trace: execute_plan: simulate: yes %.* - error: unable to upgrade package libbax/1.0.0 to 2.0.0 - info: because configured package libbox/2.0.0 depends on (libbax == 1.0.0) - info: package libbax/2.0.0 required by - libbix/2.0.0 (libbax == 2.0.0) - info: consider re-trying with --upgrade|-u potentially combined with --recursive|-r - info: or explicitly request up/downgrade of package libbox - info: or explicitly specify package libbax version to manually satisfy these constraints + trace: pkg_build: try to replace unsatisfactory dependency libbax/2.0.0 with some other version + trace: try_replace_dependent: try to replace unsatisfiable dependent libbix/2.0.0 of dependency libbax/2.0.0 with some other version + trace: try_replace_dependency: replace unsatisfiable dependent version libbix/2.0.0 with 1.0.0 by adding package spec '?libbix == 1.0.0' to command line + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add libbox/2.0.0 + trace: collect_build: add libbux/1.0.0 + trace: collect_build_prerequisites: skip configured libbox/2.0.0 + trace: collect_build_prerequisites: skip configured libbux/1.0.0 + trace: execute_plan: simulate: yes + %.* + trace: execute_plan: simulate: no %.* EOE + $pkg_status -ar >>EOO; + libbax configured 1.0.0 available 2.0.0 + !libbox configured 2.0.0 + libbax configured 1.0.0 available 2.0.0 + libbix configured !1.0.0 available 2.0.0 + libbax configured 1.0.0 available 2.0.0 + !libbux configured 1.0.0 + libbix configured !1.0.0 available 2.0.0 + libbax configured 1.0.0 available 2.0.0 + EOO + $pkg_drop libbox libbux } + + : indirect + : + : Test replacement of indirect dependents of an unsatisfactory + : dependency. + : + { + $clone_root_cfg; + $rep_add $rep/t4k && $rep_fetch; + + $* libbaz libbar 2>>~%EOE%; + %.* + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add libbaz/1.0.0 + trace: collect_build: add libbar/1.0.0 + trace: collect_build_prerequisites: begin libbaz/1.0.0 + trace: collect_build: add libfox/2.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfox/2.0.0 of dependent libbaz/1.0.0 + trace: collect_build_prerequisites: begin libfox/2.0.0 + trace: collect_build: add libfux/2.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfux/2.0.0 of dependent libfox/2.0.0 + trace: collect_build_prerequisites: begin libfux/2.0.0 + trace: collect_build: add libfaz/2.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfaz/2.0.0 of dependent libfux/2.0.0 + trace: collect_build_prerequisites: begin libfaz/2.0.0 + trace: collect_build: add libfuz/2.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfuz/2.0.0 of dependent libfaz/2.0.0 + trace: collect_build_prerequisites: begin libfuz/2.0.0 + trace: collect_build_prerequisites: end libfuz/2.0.0 + trace: collect_build_prerequisites: end libfaz/2.0.0 + trace: collect_build: add libfex/2.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfex/2.0.0 of dependent libfux/2.0.0 + trace: collect_build_prerequisites: begin libfex/2.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfaz/2.0.0 of dependent libfex/2.0.0 + trace: collect_build_prerequisites: end libfex/2.0.0 + trace: collect_build_prerequisites: end libfux/2.0.0 + trace: collect_build_prerequisites: end libfox/2.0.0 + trace: collect_build_prerequisites: end libbaz/1.0.0 + trace: collect_build_prerequisites: begin libbar/1.0.0 + trace: collect_build: add libfoo/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfoo/1.0.0 of dependent libbar/1.0.0 + trace: collect_build_prerequisites: begin libfoo/1.0.0 + trace: collect_build: add libfix/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfix/1.0.0 of dependent libfoo/1.0.0 + trace: collect_build_prerequisites: begin libfix/1.0.0 + trace: collect_build: add libfax/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfax/1.0.0 of dependent libfix/1.0.0 + trace: collect_build_prerequisites: begin libfax/1.0.0 + trace: collect_build: postpone failure for dependent libfax unsatisfied with dependency libfuz/2.0.0 (== 1.0.0) + trace: collect_build: pick libfuz/2.0.0 over libfuz/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfuz/2.0.0 of dependent libfax/1.0.0 + trace: collect_build_prerequisites: end libfax/1.0.0 + trace: collect_build_prerequisites: end libfix/1.0.0 + trace: collect_build_prerequisites: end libfoo/1.0.0 + trace: collect_build_prerequisites: end libbar/1.0.0 + trace: execute_plan: simulate: yes + %.* + trace: pkg_build: try to replace unsatisfactory dependency libfuz/2.0.0 with some other version + trace: try_replace_dependent: try to replace unsatisfied dependent libfax/1.0.0 of dependency libfuz/2.0.0 with some other version + trace: try_replace_dependent: try to replace conflicting dependent libfaz/2.0.0 of dependency libfuz/2.0.0 with some other version + trace: try_replace_dependent: try to replace constraining dependent libfix/1.0.0 of dependency libfax/1.0.0 with some other version + trace: try_replace_dependent: try to replace constraining dependent libfoo/1.0.0 of dependency libfix/1.0.0 with some other version + trace: try_replace_dependent: try to replace constraining dependent libbar/1.0.0 of dependency libfoo/1.0.0 with some other version + trace: try_replace_dependent: try to replace constraining dependent libfux/2.0.0 of dependency libfaz/2.0.0 with some other version + trace: try_replace_dependent: try to replace constraining dependent libfex/2.0.0 of dependency libfaz/2.0.0 with some other version + trace: try_replace_dependent: try to replace constraining dependent libfox/2.0.0 of dependency libfux/2.0.0 with some other version + trace: try_replace_dependency: replace constraining dependent version libfox/2.0.0 with 1.2.0 by adding package spec '?libfox == 1.2.0' to command line + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add libbaz/1.0.0 + trace: collect_build: add libbar/1.0.0 + trace: collect_build_prerequisites: begin libbaz/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfox/1.2.0 of dependent libbaz/1.0.0 + trace: collect_build_prerequisites: begin libfox/1.2.0 + trace: collect_build: add libfux/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfux/1.0.0 of dependent libfox/1.2.0 + trace: collect_build_prerequisites: begin libfux/1.0.0 + trace: collect_build: add libfaz/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfaz/1.0.0 of dependent libfux/1.0.0 + trace: collect_build_prerequisites: begin libfaz/1.0.0 + trace: collect_build: add libfuz/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfuz/1.0.0 of dependent libfaz/1.0.0 + trace: collect_build_prerequisites: begin libfuz/1.0.0 + trace: collect_build_prerequisites: end libfuz/1.0.0 + trace: collect_build_prerequisites: end libfaz/1.0.0 + trace: collect_build: add libfex/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfex/1.0.0 of dependent libfux/1.0.0 + trace: collect_build_prerequisites: begin libfex/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfaz/1.0.0 of dependent libfex/1.0.0 + trace: collect_build_prerequisites: end libfex/1.0.0 + trace: collect_build_prerequisites: end libfux/1.0.0 + trace: collect_build: postpone failure for dependent libfox unsatisfied with dependency libfex/1.0.0 (>= 2.0.0) + trace: collect_build: pick libfex/1.0.0 over libfex/2.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfex/1.0.0 of dependent libfox/1.2.0 + trace: collect_build_prerequisites: end libfox/1.2.0 + trace: collect_build_prerequisites: end libbaz/1.0.0 + trace: collect_build_prerequisites: begin libbar/1.0.0 + trace: collect_build: add libfoo/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfoo/1.0.0 of dependent libbar/1.0.0 + trace: collect_build_prerequisites: begin libfoo/1.0.0 + trace: collect_build: add libfix/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfix/1.0.0 of dependent libfoo/1.0.0 + trace: collect_build_prerequisites: begin libfix/1.0.0 + trace: collect_build: add libfax/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfax/1.0.0 of dependent libfix/1.0.0 + trace: collect_build_prerequisites: begin libfax/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfuz/1.0.0 of dependent libfax/1.0.0 + trace: collect_build_prerequisites: end libfax/1.0.0 + trace: collect_build_prerequisites: end libfix/1.0.0 + trace: collect_build_prerequisites: end libfoo/1.0.0 + trace: collect_build_prerequisites: end libbar/1.0.0 + trace: execute_plan: simulate: yes + %.* + trace: pkg_build: try to replace unsatisfactory dependency libfex/1.0.0 with some other version + trace: try_replace_dependent: try to replace unsatisfied dependent libfox/1.2.0 of dependency libfex/1.0.0 with some other version + trace: try_replace_dependency: replacement of unsatisfied dependent version libfox/1.2.0 is denied since it is specified on command line as '?libfox == 1.2.0' + trace: try_replace_dependent: try to replace conflicting dependent libfux/1.0.0 of dependency libfex/1.0.0 with some other version + trace: pkg_build: cannot replace any package, rolling back latest command line adjustment ('?libfox == 1.2.0') + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add libbaz/1.0.0 + trace: collect_build: add libbar/1.0.0 + trace: collect_build_prerequisites: begin libbaz/1.0.0 + trace: collect_build: add libfox/2.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfox/2.0.0 of dependent libbaz/1.0.0 + trace: collect_build_prerequisites: begin libfox/2.0.0 + trace: collect_build: add libfux/2.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfux/2.0.0 of dependent libfox/2.0.0 + trace: collect_build_prerequisites: begin libfux/2.0.0 + trace: collect_build: add libfaz/2.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfaz/2.0.0 of dependent libfux/2.0.0 + trace: collect_build_prerequisites: begin libfaz/2.0.0 + trace: collect_build: add libfuz/2.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfuz/2.0.0 of dependent libfaz/2.0.0 + trace: collect_build_prerequisites: begin libfuz/2.0.0 + trace: collect_build_prerequisites: end libfuz/2.0.0 + trace: collect_build_prerequisites: end libfaz/2.0.0 + trace: collect_build: add libfex/2.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfex/2.0.0 of dependent libfux/2.0.0 + trace: collect_build_prerequisites: begin libfex/2.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfaz/2.0.0 of dependent libfex/2.0.0 + trace: collect_build_prerequisites: end libfex/2.0.0 + trace: collect_build_prerequisites: end libfux/2.0.0 + trace: collect_build_prerequisites: end libfox/2.0.0 + trace: collect_build_prerequisites: end libbaz/1.0.0 + trace: collect_build_prerequisites: begin libbar/1.0.0 + trace: collect_build: add libfoo/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfoo/1.0.0 of dependent libbar/1.0.0 + trace: collect_build_prerequisites: begin libfoo/1.0.0 + trace: collect_build: add libfix/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfix/1.0.0 of dependent libfoo/1.0.0 + trace: collect_build_prerequisites: begin libfix/1.0.0 + trace: collect_build: add libfax/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfax/1.0.0 of dependent libfix/1.0.0 + trace: collect_build_prerequisites: begin libfax/1.0.0 + trace: collect_build: postpone failure for dependent libfax unsatisfied with dependency libfuz/2.0.0 (== 1.0.0) + trace: collect_build: pick libfuz/2.0.0 over libfuz/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfuz/2.0.0 of dependent libfax/1.0.0 + trace: collect_build_prerequisites: end libfax/1.0.0 + trace: collect_build_prerequisites: end libfix/1.0.0 + trace: collect_build_prerequisites: end libfoo/1.0.0 + trace: collect_build_prerequisites: end libbar/1.0.0 + trace: execute_plan: simulate: yes + %.* + trace: pkg_build: try to replace unsatisfactory dependency libfuz/2.0.0 with some other version + trace: try_replace_dependent: try to replace unsatisfied dependent libfax/1.0.0 of dependency libfuz/2.0.0 with some other version + trace: try_replace_dependent: try to replace conflicting dependent libfaz/2.0.0 of dependency libfuz/2.0.0 with some other version + trace: try_replace_dependent: try to replace constraining dependent libfix/1.0.0 of dependency libfax/1.0.0 with some other version + trace: try_replace_dependent: try to replace constraining dependent libfoo/1.0.0 of dependency libfix/1.0.0 with some other version + trace: try_replace_dependent: try to replace constraining dependent libbar/1.0.0 of dependency libfoo/1.0.0 with some other version + trace: try_replace_dependent: try to replace constraining dependent libfux/2.0.0 of dependency libfaz/2.0.0 with some other version + trace: try_replace_dependent: try to replace constraining dependent libfex/2.0.0 of dependency libfaz/2.0.0 with some other version + trace: try_replace_dependent: try to replace constraining dependent libfox/2.0.0 of dependency libfux/2.0.0 with some other version + trace: try_replace_dependency: replacement libfox/1.2.0 tried earlier for same command line, skipping + trace: try_replace_dependency: replace constraining dependent version libfox/2.0.0 with 1.0.0 by adding package spec '?libfox == 1.0.0' to command line + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add libbaz/1.0.0 + trace: collect_build: add libbar/1.0.0 + trace: collect_build_prerequisites: begin libbaz/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfox/1.0.0 of dependent libbaz/1.0.0 + trace: collect_build_prerequisites: begin libfox/1.0.0 + trace: collect_build: add libfux/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfux/1.0.0 of dependent libfox/1.0.0 + trace: collect_build_prerequisites: begin libfux/1.0.0 + trace: collect_build: add libfaz/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfaz/1.0.0 of dependent libfux/1.0.0 + trace: collect_build_prerequisites: begin libfaz/1.0.0 + trace: collect_build: add libfuz/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfuz/1.0.0 of dependent libfaz/1.0.0 + trace: collect_build_prerequisites: begin libfuz/1.0.0 + trace: collect_build_prerequisites: end libfuz/1.0.0 + trace: collect_build_prerequisites: end libfaz/1.0.0 + trace: collect_build: add libfex/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfex/1.0.0 of dependent libfux/1.0.0 + trace: collect_build_prerequisites: begin libfex/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfaz/1.0.0 of dependent libfex/1.0.0 + trace: collect_build_prerequisites: end libfex/1.0.0 + trace: collect_build_prerequisites: end libfux/1.0.0 + trace: collect_build_prerequisites: end libfox/1.0.0 + trace: collect_build_prerequisites: end libbaz/1.0.0 + trace: collect_build_prerequisites: begin libbar/1.0.0 + trace: collect_build: add libfoo/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfoo/1.0.0 of dependent libbar/1.0.0 + trace: collect_build_prerequisites: begin libfoo/1.0.0 + trace: collect_build: add libfix/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfix/1.0.0 of dependent libfoo/1.0.0 + trace: collect_build_prerequisites: begin libfix/1.0.0 + trace: collect_build: add libfax/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfax/1.0.0 of dependent libfix/1.0.0 + trace: collect_build_prerequisites: begin libfax/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency libfuz/1.0.0 of dependent libfax/1.0.0 + trace: collect_build_prerequisites: end libfax/1.0.0 + trace: collect_build_prerequisites: end libfix/1.0.0 + trace: collect_build_prerequisites: end libfoo/1.0.0 + trace: collect_build_prerequisites: end libbar/1.0.0 + trace: execute_plan: simulate: yes + %.* + new libfuz/1.0.0 (required by libfax, libfaz) + new libfaz/1.0.0 (required by libfex, libfux) + new libfex/1.0.0 (required by libfux) + new libfux/1.0.0 (required by libfox) + new libfox/1.0.0 (required by libbaz) + new libbaz/1.0.0 + new libfax/1.0.0 (required by libfix) + new libfix/1.0.0 (required by libfoo) + new libfoo/1.0.0 (required by libbar) + new libbar/1.0.0 + trace: execute_plan: simulate: no + %.* + EOE + + $pkg_status -r libbaz libbar >>EOO; + !libbaz configured 1.0.0 + libfox configured 1.0.0 available 2.0.0 1.2.0 + libfux configured 1.0.0 available 2.0.0 + libfaz configured 1.0.0 available 2.0.0 + libfuz configured 1.0.0 available 2.0.0 + libfex configured 1.0.0 available 2.0.0 + libfaz configured 1.0.0 available 2.0.0 + libfuz configured 1.0.0 available 2.0.0 + !libbar configured 1.0.0 + libfoo configured 1.0.0 available 2.0.0 + libfix configured 1.0.0 available 2.0.0 + libfax configured 1.0.0 available 2.0.0 + libfuz configured 1.0.0 available 2.0.0 + EOO + + $pkg_drop libbaz libbar + } } : replace-dependency @@ -4599,9 +5289,10 @@ test.arguments += --sys-no-query : basics : - : This test demonstrates a case when the dependency resolution machinery - : resolves unsatisfied dependency constraints by adding the package spec - : to the command line for an unsatisfactory dependency version. + : This test demonstrates a case when the dependency resolution + : machinery resolves unsatisfied dependency constraints by adding the + : package spec to the command line for an unsatisfactory dependency + : version. : { $clone_cfg; @@ -4632,7 +5323,8 @@ test.arguments += --sys-no-query trace: collect_build_prerequisites: end libbaz/2.0.0 trace: execute_plan: simulate: yes %.* - trace: try_replace_dependency: replace unsatisfactory package version libbar/2.1.0 with 1.2.0 by adding package spec '?libbar == 1.2.0' to command line + trace: pkg_build: try to replace unsatisfactory dependency libbar/2.1.0 with some other version + trace: try_replace_dependency: replace unsatisfactory dependency version libbar/2.1.0 with 1.2.0 by adding package spec '?libbar == 1.2.0' to command line trace: pkg_build: refine package collection/plan execution from scratch trace: collect_build: add libfox/1.1.0 trace: collect_build: add libbaz/2.0.0 @@ -4688,7 +5380,8 @@ test.arguments += --sys-no-query trace: collect_build_prerequisites: end libfox/1.1.0 trace: execute_plan: simulate: yes %.* - trace: try_replace_dependency: replace unsatisfactory package version libbar/0.1.0 with 1.2.0 by adding package spec '?libbar == 1.2.0' to command line + trace: pkg_build: try to replace unsatisfactory dependency libbar/0.1.0 with some other version + trace: try_replace_dependency: replace unsatisfactory dependency version libbar/0.1.0 with 1.2.0 by adding package spec '?libbar == 1.2.0' to command line trace: pkg_build: refine package collection/plan execution from scratch trace: collect_build: add libbaz/2.0.0 trace: collect_build: add libfox/1.1.0 @@ -4824,7 +5517,8 @@ test.arguments += --sys-no-query trace: collect_build_prerequisites: end libfox/1.1.0 trace: execute_plan: simulate: yes %.* - trace: try_replace_dependency: replace unsatisfactory package version libbar/0.1.0 with 1.2.0 by overwriting constraint '?libbar < 3.0.0' by '?libbar == 1.2.0' on command line + trace: pkg_build: try to replace unsatisfactory dependency libbar/0.1.0 with some other version + trace: try_replace_dependency: replace unsatisfactory dependency version libbar/0.1.0 with 1.2.0 by overwriting constraint '?libbar < 3.0.0' -> '?libbar == 1.2.0' on command line trace: pkg_build: refine package collection/plan execution from scratch trace: collect_build: add libbaz/2.0.0 trace: collect_build: add libfox/1.1.0 @@ -4901,7 +5595,8 @@ test.arguments += --sys-no-query trace: collect_build_prerequisites: end libbar/0.1.0 trace: execute_plan: simulate: yes %.* - trace: try_replace_dependency: replace unsatisfactory package version libbar/0.1.0 with 1.2.0 by overwriting spec 'libbar' by 'libbar == 1.2.0' on command line + trace: pkg_build: try to replace unsatisfactory dependency libbar/0.1.0 with some other version + trace: try_replace_dependency: replace unsatisfactory dependency version libbar/0.1.0 with 1.2.0 by adding constraint 'libbar' -> 'libbar == 1.2.0' on command line trace: pkg_build: refine package collection/plan execution from scratch trace: collect_build: add libbaz/2.0.0 trace: collect_build: add libfox/1.1.0 @@ -4975,7 +5670,8 @@ test.arguments += --sys-no-query trace: collect_build_prerequisites: end libbar/0.1.0 trace: execute_plan: simulate: yes %.* - trace: try_replace_dependency: replace unsatisfactory package version libbar/0.1.0 with 1.2.0 by overwriting constraint 'libbar < 3.0.0' by 'libbar == 1.2.0' on command line + trace: pkg_build: try to replace unsatisfactory dependency libbar/0.1.0 with some other version + trace: try_replace_dependency: replace unsatisfactory dependency version libbar/0.1.0 with 1.2.0 by overwriting constraint 'libbar < 3.0.0' -> 'libbar == 1.2.0' on command line trace: pkg_build: refine package collection/plan execution from scratch trace: collect_build: add libbaz/2.0.0 trace: collect_build: add libfox/1.1.0 @@ -5036,8 +5732,9 @@ test.arguments += --sys-no-query trace: collect_build_prerequisites: end libbaz/2.0.0 trace: execute_plan: simulate: yes %.* + trace: pkg_build: try to replace unsatisfactory dependency libbar/2.1.0 with some other version warning: package libbaz/2.0.0 dependency on (libbar < 2.1.0) is forcing downgrade of libbar/2.1.0 to 1.2.0 - trace: try_replace_dependency: replace unsatisfactory package version libbar/2.1.0 with 1.2.0 by adding package spec 'libbar == 1.2.0' to command line + trace: try_replace_dependency: replace unsatisfactory dependency version libbar/2.1.0 with 1.2.0 by adding package spec 'libbar == 1.2.0' to command line trace: pkg_build: refine package collection/plan execution from scratch trace: collect_build: add libfox/1.1.0 trace: collect_build: add libbaz/2.0.0 @@ -5122,7 +5819,8 @@ test.arguments += --sys-no-query trace: collect_dependents: postpone failure for existing dependent libfoo unsatisfied with dependency libbar/2.1.0 (== 1.2.0) trace: execute_plan: simulate: yes %.* - trace: try_replace_dependency: replace unsatisfactory package version libbar/2.1.0 with 1.2.0 by overwriting spec 'libbar' by 'libbar == 1.2.0' on command line + trace: pkg_build: try to replace unsatisfactory dependency libbar/2.1.0 with some other version + trace: try_replace_dependency: replace unsatisfactory dependency version libbar/2.1.0 with 1.2.0 by adding constraint 'libbar' -> 'libbar == 1.2.0' on command line trace: pkg_build: refine package collection/plan execution from scratch trace: collect_build: add libbar/1.2.0 trace: collect_build_prerequisites: skip configured libbar/1.2.0 @@ -11586,44 +12284,660 @@ test.arguments += --sys-no-query %.* trace: execute_plan: while configuring dependent tez in simulation mode unconstrain (toz == 0.1.0) %.* - error: unable to satisfy constraints on package toz - info: tvz/1.0.0 depends on (toz == 0.2.0) - info: tez/1.0.0 depends on (toz == 0.1.0) - info: available toz/0.2.0 - info: available toz/0.1.0 - info: while satisfying tez/1.0.0 - info: explicitly specify toz version to manually satisfy both constraints - %.* - EOE - - $pkg_drop tvz - } - - : restore-unsatisfied-depts - : - { - $clone_cfg; - - # Dependencies: - # - # tez: depends: libbox(c) - # depends: toz == 0.1.0 (c) - # depends: libbar(c) - # - # toz/0.1.0: - # - # toz/0.2.0: depends: libfoo(c) - # depends: libbar(c) - # - # tvz: depends: toz == 0.2.0 (c) - # depends: bax - # depends: libfoo(c) - # - # bax: depends: libfoo(c) - # depends: {libbox libbar} (c) - # - $* tez 2>!; - + trace: pkg_build: try to replace unsatisfactory dependency toz/0.2.0 with some other version + trace: try_replace_dependent: try to replace unsatisfied dependent tez/1.0.0 of dependency toz/0.2.0 with some other version + trace: try_replace_dependency: replace unsatisfied dependent version tez/1.0.0 with 0.1.0 by adding constraint 'tez' -> 'tez == 0.1.0' on command line + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add tvz/1.0.0 + trace: collect_build: add tez/0.1.0 + trace: collect_build_prerequisites: begin tvz/1.0.0 + trace: collect_build: add toz/0.2.0 + trace: collect_build_prerequisites: cfg-postpone dependency toz/0.2.0 of dependent tvz/1.0.0 + trace: postponed_configurations::add: create {tvz | toz->{tvz/1,1}} + trace: collect_build_prerequisites: postpone tvz/1.0.0 + trace: collect_build_prerequisites: begin tez/0.1.0 + trace: collect_build: add libbox/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent tez/0.1.0 + trace: postponed_configurations::add: create {tez | libbox->{tez/1,1}} + trace: collect_build_prerequisites: postpone tez/0.1.0 + trace: collect_build_postponed (0): begin + trace: collect_build_postponed (1): begin {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (1): skip being built existing dependent tvz of dependency toz + trace: collect_build_postponed (1): cfg-negotiate begin {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: begin toz/0.2.0 + trace: collect_build: add libfoo/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent toz/0.2.0 + trace: postponed_configurations::add: create {toz | libfoo->{toz/1,1}} + trace: collect_build_prerequisites: postpone toz/0.2.0 + trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tvz/1.0.0 + trace: collect_build_prerequisites: resume tvz/1.0.0 + trace: collect_build_prerequisites: end tvz/1.0.0 + trace: collect_build_postponed (1): cfg-negotiate end {tvz | toz->{tvz/1,1}}! + trace: collect_build_postponed (2): begin {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (2): cfg-negotiate begin {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: begin libbox/1.0.0 + trace: collect_build_prerequisites: end libbox/1.0.0 + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tez/0.1.0 + trace: collect_build_prerequisites: resume tez/0.1.0 + trace: collect_build: postpone failure for dependent tez unsatisfied with dependency toz/0.2.0 (== 0.1.0) + trace: collect_build: pick toz/0.2.0 over toz/0.1.0 + trace: collect_build_prerequisites: cfg-postpone dependency toz/0.2.0 of dependent tez/0.1.0 + trace: postponed_configurations::add: add {tez 2,1: toz} to {tvz | toz->{tvz/1,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tez/0.1.0 is negotiated + trace: collect_build_prerequisites: dependency toz/0.2.0 of dependent tez/0.1.0 is already (being) recursively collected, skipping + trace: collect_build_prerequisites: end tez/0.1.0 + trace: collect_build_postponed (2): cfg-negotiate end {tez | libbox->{tez/1,1}}! + trace: collect_build_postponed (3): begin {toz | libfoo->{toz/1,1}} + trace: collect_build_postponed (3): skip being built existing dependent toz of dependency libfoo + trace: collect_build_postponed (3): cfg-negotiate begin {toz | libfoo->{toz/1,1}} + trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: skip configured libfoo/1.0.0 + trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent toz/0.2.0 + trace: collect_build_prerequisites: resume toz/0.2.0 + trace: collect_build: add libbar/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent toz/0.2.0 + trace: postponed_configurations::add: create {toz | libbar->{toz/2,1}} + trace: collect_build_prerequisites: postpone toz/0.2.0 + trace: collect_build_postponed (3): cfg-negotiate end {toz | libfoo->{toz/1,1}}! + trace: collect_build_postponed (4): begin {toz | libbar->{toz/2,1}} + trace: collect_build_postponed (4): skip being built existing dependent toz of dependency libbar + trace: collect_build_postponed (4): cfg-negotiate begin {toz | libbar->{toz/2,1}} + trace: collect_build_postponed (4): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: skip configured libbar/1.0.0 + trace: collect_build_postponed (4): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (4): select cfg-negotiated dependency alternative for dependent toz/0.2.0 + trace: collect_build_prerequisites: resume toz/0.2.0 + trace: collect_build_prerequisites: end toz/0.2.0 + trace: collect_build_postponed (4): cfg-negotiate end {toz | libbar->{toz/2,1}}! + trace: collect_build_postponed (4): end {toz | libbar->{toz/2,1}} + trace: collect_build_postponed (3): end {toz | libfoo->{toz/1,1}} + trace: collect_build_postponed (2): end {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (1): end {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (0): end + trace: execute_plan: simulate: yes + %.* + trace: execute_plan: while configuring dependent tez in simulation mode unconstrain (toz == 0.1.0) + %.* + trace: pkg_build: try to replace unsatisfactory dependency toz/0.2.0 with some other version + trace: try_replace_dependent: try to replace unsatisfied dependent tez/0.1.0 of dependency toz/0.2.0 with some other version + trace: try_replace_dependency: replacement of unsatisfied dependent version tez/0.1.0 is denied since it is specified on command line as 'tez == 0.1.0' + trace: try_replace_dependent: try to replace conflicting dependent tvz/1.0.0 of dependency toz/0.2.0 with some other version + trace: try_replace_dependency: replace conflicting dependent version tvz/1.0.0 with 0.1.0 by adding constraint 'tvz' -> 'tvz == 0.1.0' on command line + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add tvz/0.1.0 + trace: collect_build: add tez/0.1.0 + trace: collect_build_prerequisites: begin tvz/0.1.0 + trace: collect_build: add toz/0.2.0 + trace: collect_build_prerequisites: cfg-postpone dependency toz/0.2.0 of dependent tvz/0.1.0 + trace: postponed_configurations::add: create {tvz | toz->{tvz/1,1}} + trace: collect_build_prerequisites: postpone tvz/0.1.0 + trace: collect_build_prerequisites: begin tez/0.1.0 + trace: collect_build: add libbox/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent tez/0.1.0 + trace: postponed_configurations::add: create {tez | libbox->{tez/1,1}} + trace: collect_build_prerequisites: postpone tez/0.1.0 + trace: collect_build_postponed (0): begin + trace: collect_build_postponed (1): begin {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (1): skip being built existing dependent tvz of dependency toz + trace: collect_build_postponed (1): cfg-negotiate begin {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: begin toz/0.2.0 + trace: collect_build: add libfoo/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent toz/0.2.0 + trace: postponed_configurations::add: create {toz | libfoo->{toz/1,1}} + trace: collect_build_prerequisites: postpone toz/0.2.0 + trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tvz/0.1.0 + trace: collect_build_prerequisites: resume tvz/0.1.0 + trace: collect_build: add bax/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency bax/1.0.0 of dependent tvz/0.1.0 + trace: collect_build_prerequisites: begin bax/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent bax/1.0.0 + trace: postponed_configurations::add: add {bax 1,1: libfoo} to {toz | libfoo->{toz/1,1}} + trace: collect_build_prerequisites: postpone bax/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent tvz/0.1.0 + trace: postponed_configurations::add: add {tvz 3,1: libfoo} to {bax toz | libfoo->{bax/1,1 toz/1,1}} + trace: collect_build_prerequisites: postpone tvz/0.1.0 + trace: collect_build_postponed (1): cfg-negotiate end {tvz | toz->{tvz/1,1}}! + trace: collect_build_postponed (2): begin {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (2): cfg-negotiate begin {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: begin libbox/1.0.0 + trace: collect_build_prerequisites: end libbox/1.0.0 + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tez/0.1.0 + trace: collect_build_prerequisites: resume tez/0.1.0 + trace: collect_build: postpone failure for dependent tez unsatisfied with dependency toz/0.2.0 (== 0.1.0) + trace: collect_build: pick toz/0.2.0 over toz/0.1.0 + trace: collect_build_prerequisites: cfg-postpone dependency toz/0.2.0 of dependent tez/0.1.0 + trace: postponed_configurations::add: add {tez 2,1: toz} to {tvz | toz->{tvz/1,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tez/0.1.0 is negotiated + trace: collect_build_prerequisites: dependency toz/0.2.0 of dependent tez/0.1.0 is already (being) recursively collected, skipping + trace: collect_build_prerequisites: end tez/0.1.0 + trace: collect_build_postponed (2): cfg-negotiate end {tez | libbox->{tez/1,1}}! + trace: collect_build_postponed (3): begin {bax toz tvz | libfoo->{bax/1,1 toz/1,1 tvz/3,1}} + trace: collect_build_postponed (3): skip being built existing dependent toz of dependency libfoo + trace: collect_build_postponed (3): cfg-negotiate begin {bax toz tvz | libfoo->{bax/1,1 toz/1,1 tvz/3,1}} + trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: skip configured libfoo/1.0.0 + trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent bax/1.0.0 + trace: collect_build_prerequisites: resume bax/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent bax/1.0.0 + trace: collect_build: add libbar/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bax/1.0.0 + trace: postponed_configurations::add: add {bax 2,1: libbox libbar} to {tez | libbox->{tez/1,1}}! + trace: collect_build_prerequisites: skip being built existing dependent toz of dependency libbar + trace: collect_build_prerequisites: cfg-postponing dependent bax/1.0.0 involves (being) negotiated configurations and results in {bax tez | libbox->{bax/2,1 tez/1,1} libbar->{bax/2,1}}!, throwing retry_configuration + trace: collect_build_postponed (1): cfg-negotiation of {tez | libbox->{tez/1,1}} failed due to dependent bax, refining configuration + trace: collect_build_postponed (2): begin {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (2): cfg-negotiate begin {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: begin libbox/1.0.0 + trace: collect_build_prerequisites: end libbox/1.0.0 + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tez/0.1.0 + trace: collect_build_prerequisites: resume tez/0.1.0 + trace: collect_build: postpone failure for dependent tez unsatisfied with dependency toz/0.2.0 (== 0.1.0) + trace: collect_build: pick toz/0.2.0 over toz/0.1.0 + trace: collect_build_prerequisites: cfg-postpone dependency toz/0.2.0 of dependent tez/0.1.0 + trace: postponed_configurations::add: add {tez 2,1: toz} to {tvz | toz->{tvz/1,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tez/0.1.0 is negotiated + trace: collect_build_prerequisites: dependency toz/0.2.0 of dependent tez/0.1.0 is already (being) recursively collected, skipping + trace: collect_build_prerequisites: end tez/0.1.0 + trace: collect_build_postponed (2): cfg-negotiate end {tez | libbox->{tez/1,1}}! + trace: collect_build_postponed (3): begin {bax toz tvz | libfoo->{bax/1,1 toz/1,1 tvz/3,1}} + trace: collect_build_postponed (3): skip being built existing dependent toz of dependency libfoo + trace: collect_build_postponed (3): cfg-negotiate begin {bax toz tvz | libfoo->{bax/1,1 toz/1,1 tvz/3,1}} + trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: skip configured libfoo/1.0.0 + trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent bax/1.0.0 + trace: collect_build_prerequisites: resume bax/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent bax/1.0.0 + trace: collect_build: add libbar/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bax/1.0.0 + trace: postponed_configurations::add: add {bax 2,1: libbox libbar} to {tez | libbox->{tez/1,1}}! + trace: collect_build_prerequisites: skip being built existing dependent toz of dependency libbar + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent bax/1.0.0 is negotiated + trace: collect_build_prerequisites: dependency libbox/1.0.0 of dependent bax/1.0.0 is already (being) recursively collected, skipping + trace: collect_build_prerequisites: collecting cfg-postponed dependency libbar/1.0.0 of dependent bax/1.0.0 + trace: collect_build_prerequisites: skip configured libbar/1.0.0 + trace: collect_build_prerequisites: end bax/1.0.0 + trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent toz/0.2.0 + trace: collect_build_prerequisites: resume toz/0.2.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent toz/0.2.0 + trace: postponed_configurations::add: add {toz 2,1: libbar} to {bax tez | libbox->{bax/2,1 tez/1,1} libbar->{bax/2,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent toz/0.2.0 is negotiated + trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent toz/0.2.0 is already (being) recursively collected, skipping + trace: collect_build_prerequisites: end toz/0.2.0 + trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent tvz/0.1.0 + trace: collect_build_prerequisites: resume tvz/0.1.0 + trace: collect_build_prerequisites: end tvz/0.1.0 + trace: collect_build_postponed (3): cfg-negotiate end {bax toz tvz | libfoo->{bax/1,1 toz/1,1 tvz/3,1}}! + trace: collect_build_postponed (3): end {bax toz tvz | libfoo->{bax/1,1 toz/1,1 tvz/3,1}} + trace: collect_build_postponed (2): end {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (1): end {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (0): end + trace: execute_plan: simulate: yes + %.* + trace: execute_plan: while configuring dependent tez in simulation mode unconstrain (toz == 0.1.0) + %.* + trace: pkg_build: try to replace unsatisfactory dependency toz/0.2.0 with some other version + trace: try_replace_dependent: try to replace unsatisfied dependent tez/0.1.0 of dependency toz/0.2.0 with some other version + trace: try_replace_dependency: replacement of unsatisfied dependent version tez/0.1.0 is denied since it is specified on command line as 'tez == 0.1.0' + trace: try_replace_dependent: try to replace conflicting dependent tvz/0.1.0 of dependency toz/0.2.0 with some other version + trace: try_replace_dependency: replacement of conflicting dependent version tvz/0.1.0 is denied since it is specified on command line as 'tvz == 0.1.0' + trace: pkg_build: cannot replace any package, rolling back latest command line adjustment ('tvz' -> 'tvz == 0.1.0') + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add tvz/1.0.0 + trace: collect_build: add tez/0.1.0 + trace: collect_build_prerequisites: begin tvz/1.0.0 + trace: collect_build: add toz/0.2.0 + trace: collect_build_prerequisites: cfg-postpone dependency toz/0.2.0 of dependent tvz/1.0.0 + trace: postponed_configurations::add: create {tvz | toz->{tvz/1,1}} + trace: collect_build_prerequisites: postpone tvz/1.0.0 + trace: collect_build_prerequisites: begin tez/0.1.0 + trace: collect_build: add libbox/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent tez/0.1.0 + trace: postponed_configurations::add: create {tez | libbox->{tez/1,1}} + trace: collect_build_prerequisites: postpone tez/0.1.0 + trace: collect_build_postponed (0): begin + trace: collect_build_postponed (1): begin {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (1): skip being built existing dependent tvz of dependency toz + trace: collect_build_postponed (1): cfg-negotiate begin {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: begin toz/0.2.0 + trace: collect_build: add libfoo/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent toz/0.2.0 + trace: postponed_configurations::add: create {toz | libfoo->{toz/1,1}} + trace: collect_build_prerequisites: postpone toz/0.2.0 + trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tvz/1.0.0 + trace: collect_build_prerequisites: resume tvz/1.0.0 + trace: collect_build_prerequisites: end tvz/1.0.0 + trace: collect_build_postponed (1): cfg-negotiate end {tvz | toz->{tvz/1,1}}! + trace: collect_build_postponed (2): begin {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (2): cfg-negotiate begin {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: begin libbox/1.0.0 + trace: collect_build_prerequisites: end libbox/1.0.0 + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tez/0.1.0 + trace: collect_build_prerequisites: resume tez/0.1.0 + trace: collect_build: postpone failure for dependent tez unsatisfied with dependency toz/0.2.0 (== 0.1.0) + trace: collect_build: pick toz/0.2.0 over toz/0.1.0 + trace: collect_build_prerequisites: cfg-postpone dependency toz/0.2.0 of dependent tez/0.1.0 + trace: postponed_configurations::add: add {tez 2,1: toz} to {tvz | toz->{tvz/1,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tez/0.1.0 is negotiated + trace: collect_build_prerequisites: dependency toz/0.2.0 of dependent tez/0.1.0 is already (being) recursively collected, skipping + trace: collect_build_prerequisites: end tez/0.1.0 + trace: collect_build_postponed (2): cfg-negotiate end {tez | libbox->{tez/1,1}}! + trace: collect_build_postponed (3): begin {toz | libfoo->{toz/1,1}} + trace: collect_build_postponed (3): skip being built existing dependent toz of dependency libfoo + trace: collect_build_postponed (3): cfg-negotiate begin {toz | libfoo->{toz/1,1}} + trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: skip configured libfoo/1.0.0 + trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent toz/0.2.0 + trace: collect_build_prerequisites: resume toz/0.2.0 + trace: collect_build: add libbar/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent toz/0.2.0 + trace: postponed_configurations::add: create {toz | libbar->{toz/2,1}} + trace: collect_build_prerequisites: postpone toz/0.2.0 + trace: collect_build_postponed (3): cfg-negotiate end {toz | libfoo->{toz/1,1}}! + trace: collect_build_postponed (4): begin {toz | libbar->{toz/2,1}} + trace: collect_build_postponed (4): skip being built existing dependent toz of dependency libbar + trace: collect_build_postponed (4): cfg-negotiate begin {toz | libbar->{toz/2,1}} + trace: collect_build_postponed (4): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: skip configured libbar/1.0.0 + trace: collect_build_postponed (4): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (4): select cfg-negotiated dependency alternative for dependent toz/0.2.0 + trace: collect_build_prerequisites: resume toz/0.2.0 + trace: collect_build_prerequisites: end toz/0.2.0 + trace: collect_build_postponed (4): cfg-negotiate end {toz | libbar->{toz/2,1}}! + trace: collect_build_postponed (4): end {toz | libbar->{toz/2,1}} + trace: collect_build_postponed (3): end {toz | libfoo->{toz/1,1}} + trace: collect_build_postponed (2): end {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (1): end {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (0): end + trace: execute_plan: simulate: yes + %.* + trace: execute_plan: while configuring dependent tez in simulation mode unconstrain (toz == 0.1.0) + %.* + trace: pkg_build: try to replace unsatisfactory dependency toz/0.2.0 with some other version + trace: try_replace_dependent: try to replace unsatisfied dependent tez/0.1.0 of dependency toz/0.2.0 with some other version + trace: try_replace_dependency: replacement of unsatisfied dependent version tez/0.1.0 is denied since it is specified on command line as 'tez == 0.1.0' + trace: try_replace_dependent: try to replace conflicting dependent tvz/1.0.0 of dependency toz/0.2.0 with some other version + trace: try_replace_dependency: replacement tvz/0.1.0 tried earlier for same command line, skipping + trace: pkg_build: cannot replace any package, rolling back latest command line adjustment ('tez' -> 'tez == 0.1.0') + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add tvz/1.0.0 + trace: collect_build: add tez/1.0.0 + trace: collect_build_prerequisites: begin tvz/1.0.0 + trace: collect_build: add toz/0.2.0 + trace: collect_build_prerequisites: cfg-postpone dependency toz/0.2.0 of dependent tvz/1.0.0 + trace: postponed_configurations::add: create {tvz | toz->{tvz/1,1}} + trace: collect_build_prerequisites: postpone tvz/1.0.0 + trace: collect_build_prerequisites: begin tez/1.0.0 + trace: collect_build: add libbox/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent tez/1.0.0 + trace: postponed_configurations::add: create {tez | libbox->{tez/1,1}} + trace: collect_build_prerequisites: postpone tez/1.0.0 + trace: collect_build_postponed (0): begin + trace: collect_build_postponed (1): begin {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (1): skip being built existing dependent tvz of dependency toz + trace: collect_build_postponed (1): cfg-negotiate begin {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: begin toz/0.2.0 + trace: collect_build: add libfoo/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent toz/0.2.0 + trace: postponed_configurations::add: create {toz | libfoo->{toz/1,1}} + trace: collect_build_prerequisites: postpone toz/0.2.0 + trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tvz/1.0.0 + trace: collect_build_prerequisites: resume tvz/1.0.0 + trace: collect_build_prerequisites: end tvz/1.0.0 + trace: collect_build_postponed (1): cfg-negotiate end {tvz | toz->{tvz/1,1}}! + trace: collect_build_postponed (2): begin {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (2): cfg-negotiate begin {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: begin libbox/1.0.0 + trace: collect_build_prerequisites: end libbox/1.0.0 + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tez/1.0.0 + trace: collect_build_prerequisites: resume tez/1.0.0 + trace: collect_build: postpone failure for dependent tez unsatisfied with dependency toz/0.2.0 (== 0.1.0) + trace: collect_build: pick toz/0.2.0 over toz/0.1.0 + trace: collect_build_prerequisites: cfg-postpone dependency toz/0.2.0 of dependent tez/1.0.0 + trace: postponed_configurations::add: add {tez 2,1: toz} to {tvz | toz->{tvz/1,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tez/1.0.0 is negotiated + trace: collect_build_prerequisites: dependency toz/0.2.0 of dependent tez/1.0.0 is already (being) recursively collected, skipping + trace: collect_build: add libbar/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tez/1.0.0 + trace: postponed_configurations::add: create {tez | libbar->{tez/3,1}} + trace: collect_build_prerequisites: postpone tez/1.0.0 + trace: collect_build_postponed (2): cfg-negotiate end {tez | libbox->{tez/1,1}}! + trace: collect_build_postponed (3): begin {toz | libfoo->{toz/1,1}} + trace: collect_build_postponed (3): skip being built existing dependent toz of dependency libfoo + trace: collect_build_postponed (3): cfg-negotiate begin {toz | libfoo->{toz/1,1}} + trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: skip configured libfoo/1.0.0 + trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent toz/0.2.0 + trace: collect_build_prerequisites: resume toz/0.2.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent toz/0.2.0 + trace: postponed_configurations::add: add {toz 2,1: libbar} to {tez | libbar->{tez/3,1}} + trace: collect_build_prerequisites: postpone toz/0.2.0 + trace: collect_build_postponed (3): cfg-negotiate end {toz | libfoo->{toz/1,1}}! + trace: collect_build_postponed (4): begin {tez toz | libbar->{tez/3,1 toz/2,1}} + trace: collect_build_postponed (4): skip being built existing dependent toz of dependency libbar + trace: collect_build_postponed (4): cfg-negotiate begin {tez toz | libbar->{tez/3,1 toz/2,1}} + trace: collect_build_postponed (4): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: skip configured libbar/1.0.0 + trace: collect_build_postponed (4): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (4): select cfg-negotiated dependency alternative for dependent tez/1.0.0 + trace: collect_build_prerequisites: resume tez/1.0.0 + trace: collect_build_prerequisites: end tez/1.0.0 + trace: collect_build_postponed (4): select cfg-negotiated dependency alternative for dependent toz/0.2.0 + trace: collect_build_prerequisites: resume toz/0.2.0 + trace: collect_build_prerequisites: end toz/0.2.0 + trace: collect_build_postponed (4): cfg-negotiate end {tez toz | libbar->{tez/3,1 toz/2,1}}! + trace: collect_build_postponed (4): end {tez toz | libbar->{tez/3,1 toz/2,1}} + trace: collect_build_postponed (3): end {toz | libfoo->{toz/1,1}} + trace: collect_build_postponed (2): end {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (1): end {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (0): end + trace: execute_plan: simulate: yes + %.* + trace: execute_plan: while configuring dependent tez in simulation mode unconstrain (toz == 0.1.0) + %.* + trace: pkg_build: try to replace unsatisfactory dependency toz/0.2.0 with some other version + trace: try_replace_dependent: try to replace unsatisfied dependent tez/1.0.0 of dependency toz/0.2.0 with some other version + trace: try_replace_dependency: replacement tez/0.1.0 tried earlier for same command line, skipping + trace: try_replace_dependent: try to replace conflicting dependent tvz/1.0.0 of dependency toz/0.2.0 with some other version + trace: try_replace_dependency: replace conflicting dependent version tvz/1.0.0 with 0.1.0 by adding constraint 'tvz' -> 'tvz == 0.1.0' on command line + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add tvz/0.1.0 + trace: collect_build: add tez/1.0.0 + trace: collect_build_prerequisites: begin tvz/0.1.0 + trace: collect_build: add toz/0.2.0 + trace: collect_build_prerequisites: cfg-postpone dependency toz/0.2.0 of dependent tvz/0.1.0 + trace: postponed_configurations::add: create {tvz | toz->{tvz/1,1}} + trace: collect_build_prerequisites: postpone tvz/0.1.0 + trace: collect_build_prerequisites: begin tez/1.0.0 + trace: collect_build: add libbox/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent tez/1.0.0 + trace: postponed_configurations::add: create {tez | libbox->{tez/1,1}} + trace: collect_build_prerequisites: postpone tez/1.0.0 + trace: collect_build_postponed (0): begin + trace: collect_build_postponed (1): begin {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (1): skip being built existing dependent tvz of dependency toz + trace: collect_build_postponed (1): cfg-negotiate begin {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: begin toz/0.2.0 + trace: collect_build: add libfoo/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent toz/0.2.0 + trace: postponed_configurations::add: create {toz | libfoo->{toz/1,1}} + trace: collect_build_prerequisites: postpone toz/0.2.0 + trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tvz/0.1.0 + trace: collect_build_prerequisites: resume tvz/0.1.0 + trace: collect_build: add bax/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency bax/1.0.0 of dependent tvz/0.1.0 + trace: collect_build_prerequisites: begin bax/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent bax/1.0.0 + trace: postponed_configurations::add: add {bax 1,1: libfoo} to {toz | libfoo->{toz/1,1}} + trace: collect_build_prerequisites: postpone bax/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent tvz/0.1.0 + trace: postponed_configurations::add: add {tvz 3,1: libfoo} to {bax toz | libfoo->{bax/1,1 toz/1,1}} + trace: collect_build_prerequisites: postpone tvz/0.1.0 + trace: collect_build_postponed (1): cfg-negotiate end {tvz | toz->{tvz/1,1}}! + trace: collect_build_postponed (2): begin {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (2): cfg-negotiate begin {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: begin libbox/1.0.0 + trace: collect_build_prerequisites: end libbox/1.0.0 + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tez/1.0.0 + trace: collect_build_prerequisites: resume tez/1.0.0 + trace: collect_build: postpone failure for dependent tez unsatisfied with dependency toz/0.2.0 (== 0.1.0) + trace: collect_build: pick toz/0.2.0 over toz/0.1.0 + trace: collect_build_prerequisites: cfg-postpone dependency toz/0.2.0 of dependent tez/1.0.0 + trace: postponed_configurations::add: add {tez 2,1: toz} to {tvz | toz->{tvz/1,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tez/1.0.0 is negotiated + trace: collect_build_prerequisites: dependency toz/0.2.0 of dependent tez/1.0.0 is already (being) recursively collected, skipping + trace: collect_build: add libbar/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tez/1.0.0 + trace: postponed_configurations::add: create {tez | libbar->{tez/3,1}} + trace: collect_build_prerequisites: postpone tez/1.0.0 + trace: collect_build_postponed (2): cfg-negotiate end {tez | libbox->{tez/1,1}}! + trace: collect_build_postponed (3): begin {bax toz tvz | libfoo->{bax/1,1 toz/1,1 tvz/3,1}} + trace: collect_build_postponed (3): skip being built existing dependent toz of dependency libfoo + trace: collect_build_postponed (3): cfg-negotiate begin {bax toz tvz | libfoo->{bax/1,1 toz/1,1 tvz/3,1}} + trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: skip configured libfoo/1.0.0 + trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent bax/1.0.0 + trace: collect_build_prerequisites: resume bax/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent bax/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bax/1.0.0 + trace: postponed_configurations::add: add {bax 2,1: libbox libbar} to {tez | libbox->{tez/1,1}}! + trace: postponed_configurations::add: merge {tez | libbar->{tez/3,1}} into {bax tez | libbox->{bax/2,1 tez/1,1} libbar->{bax/2,1}}! + trace: collect_build_prerequisites: cfg-postponing dependent bax/1.0.0 merges non-negotiated and/or being negotiated configurations in and results in {bax tez | libbox->{bax/2,1 tez/1,1} libbar->{bax/2,1 tez/3,1}}!, throwing merge_configuration + trace: collect_build_postponed (1): cfg-negotiation of {tez | libbox->{tez/1,1}} failed due to non-negotiated clusters, force-merging based on shadow cluster {bax tez | libbox->{bax/2,1 tez/1,1} libbar->{bax/2,1 tez/3,1}}! + trace: collect_build_postponed (2): begin {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (2): cfg-negotiate begin {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: begin libbox/1.0.0 + trace: collect_build_prerequisites: end libbox/1.0.0 + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tez/1.0.0 + trace: collect_build_prerequisites: resume tez/1.0.0 + trace: collect_build: postpone failure for dependent tez unsatisfied with dependency toz/0.2.0 (== 0.1.0) + trace: collect_build: pick toz/0.2.0 over toz/0.1.0 + trace: collect_build_prerequisites: cfg-postpone dependency toz/0.2.0 of dependent tez/1.0.0 + trace: postponed_configurations::add: add {tez 2,1: toz} to {tvz | toz->{tvz/1,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tez/1.0.0 is negotiated + trace: collect_build_prerequisites: dependency toz/0.2.0 of dependent tez/1.0.0 is already (being) recursively collected, skipping + trace: collect_build: add libbar/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tez/1.0.0 + trace: postponed_configurations::add: add {tez 3,1: libbar} to {tez | libbox->{tez/1,1}}? (shadow cluster-based) + trace: collect_build_prerequisites: skip being built existing dependent toz of dependency libbar + trace: collect_build_prerequisites: cfg-postponing dependent tez/1.0.0 involves (being) negotiated configurations and results in {tez | libbox->{tez/1,1} libbar->{tez/3,1}}?, throwing retry_configuration + trace: collect_build_postponed (1): cfg-negotiation of {tez | libbox->{tez/1,1}} failed due to dependent tez, refining configuration + trace: collect_build_postponed (2): begin {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (2): cfg-negotiate begin {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: begin libbox/1.0.0 + trace: collect_build_prerequisites: end libbox/1.0.0 + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tez/1.0.0 + trace: collect_build_prerequisites: resume tez/1.0.0 + trace: collect_build: postpone failure for dependent tez unsatisfied with dependency toz/0.2.0 (== 0.1.0) + trace: collect_build: pick toz/0.2.0 over toz/0.1.0 + trace: collect_build_prerequisites: cfg-postpone dependency toz/0.2.0 of dependent tez/1.0.0 + trace: postponed_configurations::add: add {tez 2,1: toz} to {tvz | toz->{tvz/1,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tez/1.0.0 is negotiated + trace: collect_build_prerequisites: dependency toz/0.2.0 of dependent tez/1.0.0 is already (being) recursively collected, skipping + trace: collect_build: add libbar/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tez/1.0.0 + trace: postponed_configurations::add: add {tez 3,1: libbar} to {tez | libbox->{tez/1,1}}? (shadow cluster-based) + trace: collect_build_prerequisites: skip being built existing dependent toz of dependency libbar + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tez/1.0.0 is shadow-negotiated + trace: collect_build_prerequisites: collecting cfg-postponed dependency libbar/1.0.0 of dependent tez/1.0.0 + trace: collect_build_prerequisites: skip configured libbar/1.0.0 + trace: collect_build_prerequisites: end tez/1.0.0 + trace: collect_build_postponed (2): cfg-negotiate end {tez | libbox->{tez/1,1} libbar->{tez/3,1}}! + trace: collect_build_postponed (3): begin {bax toz tvz | libfoo->{bax/1,1 toz/1,1 tvz/3,1}} + trace: collect_build_postponed (3): skip being built existing dependent toz of dependency libfoo + trace: collect_build_postponed (3): cfg-negotiate begin {bax toz tvz | libfoo->{bax/1,1 toz/1,1 tvz/3,1}} + trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: skip configured libfoo/1.0.0 + trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent bax/1.0.0 + trace: collect_build_prerequisites: resume bax/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent bax/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bax/1.0.0 + trace: postponed_configurations::add: add {bax 2,1: libbox libbar} to {tez | libbox->{tez/1,1} libbar->{tez/3,1}}! (shadow cluster-based) + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent bax/1.0.0 is shadow-negotiated + trace: collect_build_prerequisites: dependency libbox/1.0.0 of dependent bax/1.0.0 is already (being) recursively collected, skipping + trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent bax/1.0.0 is already (being) recursively collected, skipping + trace: collect_build_prerequisites: end bax/1.0.0 + trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent toz/0.2.0 + trace: collect_build_prerequisites: resume toz/0.2.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent toz/0.2.0 + trace: postponed_configurations::add: add {toz 2,1: libbar} to {bax tez | libbox->{bax/2,1 tez/1,1} libbar->{bax/2,1 tez/3,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent toz/0.2.0 is negotiated + trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent toz/0.2.0 is already (being) recursively collected, skipping + trace: collect_build_prerequisites: end toz/0.2.0 + trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent tvz/0.1.0 + trace: collect_build_prerequisites: resume tvz/0.1.0 + trace: collect_build_prerequisites: end tvz/0.1.0 + trace: collect_build_postponed (3): cfg-negotiate end {bax toz tvz | libfoo->{bax/1,1 toz/1,1 tvz/3,1}}! + trace: collect_build_postponed (3): end {bax toz tvz | libfoo->{bax/1,1 toz/1,1 tvz/3,1}} + trace: collect_build_postponed (2): end {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (1): end {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (0): end + trace: execute_plan: simulate: yes + %.* + trace: execute_plan: while configuring dependent tez in simulation mode unconstrain (toz == 0.1.0) + %.* + trace: pkg_build: try to replace unsatisfactory dependency toz/0.2.0 with some other version + trace: try_replace_dependent: try to replace unsatisfied dependent tez/1.0.0 of dependency toz/0.2.0 with some other version + trace: try_replace_dependency: replacement tez/0.1.0 tried earlier for same command line, skipping + trace: try_replace_dependent: try to replace conflicting dependent tvz/0.1.0 of dependency toz/0.2.0 with some other version + trace: try_replace_dependency: replacement of conflicting dependent version tvz/0.1.0 is denied since it is specified on command line as 'tvz == 0.1.0' + trace: pkg_build: cannot replace any package, rolling back latest command line adjustment ('tvz' -> 'tvz == 0.1.0') + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add tvz/1.0.0 + trace: collect_build: add tez/1.0.0 + trace: collect_build_prerequisites: begin tvz/1.0.0 + trace: collect_build: add toz/0.2.0 + trace: collect_build_prerequisites: cfg-postpone dependency toz/0.2.0 of dependent tvz/1.0.0 + trace: postponed_configurations::add: create {tvz | toz->{tvz/1,1}} + trace: collect_build_prerequisites: postpone tvz/1.0.0 + trace: collect_build_prerequisites: begin tez/1.0.0 + trace: collect_build: add libbox/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent tez/1.0.0 + trace: postponed_configurations::add: create {tez | libbox->{tez/1,1}} + trace: collect_build_prerequisites: postpone tez/1.0.0 + trace: collect_build_postponed (0): begin + trace: collect_build_postponed (1): begin {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (1): skip being built existing dependent tvz of dependency toz + trace: collect_build_postponed (1): cfg-negotiate begin {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: begin toz/0.2.0 + trace: collect_build: add libfoo/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent toz/0.2.0 + trace: postponed_configurations::add: create {toz | libfoo->{toz/1,1}} + trace: collect_build_prerequisites: postpone toz/0.2.0 + trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tvz/1.0.0 + trace: collect_build_prerequisites: resume tvz/1.0.0 + trace: collect_build_prerequisites: end tvz/1.0.0 + trace: collect_build_postponed (1): cfg-negotiate end {tvz | toz->{tvz/1,1}}! + trace: collect_build_postponed (2): begin {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (2): cfg-negotiate begin {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: begin libbox/1.0.0 + trace: collect_build_prerequisites: end libbox/1.0.0 + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tez/1.0.0 + trace: collect_build_prerequisites: resume tez/1.0.0 + trace: collect_build: postpone failure for dependent tez unsatisfied with dependency toz/0.2.0 (== 0.1.0) + trace: collect_build: pick toz/0.2.0 over toz/0.1.0 + trace: collect_build_prerequisites: cfg-postpone dependency toz/0.2.0 of dependent tez/1.0.0 + trace: postponed_configurations::add: add {tez 2,1: toz} to {tvz | toz->{tvz/1,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tez/1.0.0 is negotiated + trace: collect_build_prerequisites: dependency toz/0.2.0 of dependent tez/1.0.0 is already (being) recursively collected, skipping + trace: collect_build: add libbar/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tez/1.0.0 + trace: postponed_configurations::add: create {tez | libbar->{tez/3,1}} + trace: collect_build_prerequisites: postpone tez/1.0.0 + trace: collect_build_postponed (2): cfg-negotiate end {tez | libbox->{tez/1,1}}! + trace: collect_build_postponed (3): begin {toz | libfoo->{toz/1,1}} + trace: collect_build_postponed (3): skip being built existing dependent toz of dependency libfoo + trace: collect_build_postponed (3): cfg-negotiate begin {toz | libfoo->{toz/1,1}} + trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: skip configured libfoo/1.0.0 + trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent toz/0.2.0 + trace: collect_build_prerequisites: resume toz/0.2.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent toz/0.2.0 + trace: postponed_configurations::add: add {toz 2,1: libbar} to {tez | libbar->{tez/3,1}} + trace: collect_build_prerequisites: postpone toz/0.2.0 + trace: collect_build_postponed (3): cfg-negotiate end {toz | libfoo->{toz/1,1}}! + trace: collect_build_postponed (4): begin {tez toz | libbar->{tez/3,1 toz/2,1}} + trace: collect_build_postponed (4): skip being built existing dependent toz of dependency libbar + trace: collect_build_postponed (4): cfg-negotiate begin {tez toz | libbar->{tez/3,1 toz/2,1}} + trace: collect_build_postponed (4): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: skip configured libbar/1.0.0 + trace: collect_build_postponed (4): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (4): select cfg-negotiated dependency alternative for dependent tez/1.0.0 + trace: collect_build_prerequisites: resume tez/1.0.0 + trace: collect_build_prerequisites: end tez/1.0.0 + trace: collect_build_postponed (4): select cfg-negotiated dependency alternative for dependent toz/0.2.0 + trace: collect_build_prerequisites: resume toz/0.2.0 + trace: collect_build_prerequisites: end toz/0.2.0 + trace: collect_build_postponed (4): cfg-negotiate end {tez toz | libbar->{tez/3,1 toz/2,1}}! + trace: collect_build_postponed (4): end {tez toz | libbar->{tez/3,1 toz/2,1}} + trace: collect_build_postponed (3): end {toz | libfoo->{toz/1,1}} + trace: collect_build_postponed (2): end {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (1): end {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (0): end + trace: execute_plan: simulate: yes + %.* + trace: execute_plan: while configuring dependent tez in simulation mode unconstrain (toz == 0.1.0) + %.* + trace: pkg_build: try to replace unsatisfactory dependency toz/0.2.0 with some other version + trace: try_replace_dependent: try to replace unsatisfied dependent tez/1.0.0 of dependency toz/0.2.0 with some other version + trace: try_replace_dependency: replacement tez/0.1.0 tried earlier for same command line, skipping + trace: try_replace_dependent: try to replace conflicting dependent tvz/1.0.0 of dependency toz/0.2.0 with some other version + trace: try_replace_dependency: replacement tvz/0.1.0 tried earlier for same command line, skipping + error: unable to satisfy constraints on package toz + info: tvz/1.0.0 depends on (toz == 0.2.0) + info: tez/1.0.0 depends on (toz == 0.1.0) + info: available toz/0.2.0 + info: available toz/0.1.0 + info: while satisfying tez/1.0.0 + info: explicitly specify toz version to manually satisfy both constraints + %.* + EOE + + $pkg_drop tvz + } + + : restore-unsatisfied-depts + : + { + $clone_cfg; + + # Dependencies: + # + # tez: depends: libbox(c) + # depends: toz == 0.1.0 (c) + # depends: libbar(c) + # + # toz/0.1.0: + # + # toz/0.2.0: depends: libfoo(c) + # depends: libbar(c) + # + # tvz: depends: toz == 0.2.0 (c) + # depends: bax + # depends: libfoo(c) + # + # bax: depends: libfoo(c) + # depends: {libbox libbar} (c) + # + $* tez 2>!; + $pkg_status -r >>EOO; !tez configured 1.0.0 libbar configured 1.0.0 @@ -11780,6 +13094,288 @@ test.arguments += --sys-no-query %.* trace: execute_plan: while configuring dependent tez in simulation mode unconstrain (toz == 0.1.0) %.* + trace: pkg_build: try to replace unsatisfactory dependency toz/0.2.0 with some other version + trace: try_replace_dependent: try to replace unsatisfied dependent tez/1.0.0 of dependency toz/0.2.0 with some other version + trace: try_replace_dependency: replace unsatisfied dependent version tez/1.0.0 with 0.1.0 by adding constraint 'tez' -> 'tez == 0.1.0' on command line + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add tvz/0.1.0 + trace: collect_build: add tez/0.1.0 + trace: collect_build_prerequisites: begin tvz/0.1.0 + trace: collect_build: add toz/0.2.0 + info: package tvz dependency on (toz == 0.2.0) is forcing upgrade of toz/0.1.0 to 0.2.0 + trace: collect_build_prerequisites: cfg-postpone dependency toz/0.2.0 of dependent tvz/0.1.0 + trace: postponed_configurations::add: create {tvz | toz->{tvz/1,1}} + trace: collect_build_prerequisites: postpone tvz/0.1.0 + trace: collect_build_prerequisites: begin tez/0.1.0 + trace: collect_build: add libbox/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent tez/0.1.0 + trace: postponed_configurations::add: create {tez | libbox->{tez/1,1}} + trace: collect_build_prerequisites: postpone tez/0.1.0 + trace: collect_build_postponed (0): begin + trace: collect_build_postponed (1): begin {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (1): skip being built existing dependent tez of dependency toz + trace: collect_build_postponed (1): cfg-negotiate begin {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: begin toz/0.2.0 + trace: collect_build: add libfoo/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent toz/0.2.0 + trace: postponed_configurations::add: create {toz | libfoo->{toz/1,1}} + trace: collect_build_prerequisites: postpone toz/0.2.0 + trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tvz/0.1.0 + trace: collect_build_prerequisites: resume tvz/0.1.0 + trace: collect_build: add bax/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency bax/1.0.0 of dependent tvz/0.1.0 + trace: collect_build_prerequisites: begin bax/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent bax/1.0.0 + trace: postponed_configurations::add: add {bax 1,1: libfoo} to {toz | libfoo->{toz/1,1}} + trace: collect_build_prerequisites: postpone bax/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent tvz/0.1.0 + trace: postponed_configurations::add: add {tvz 3,1: libfoo} to {bax toz | libfoo->{bax/1,1 toz/1,1}} + trace: collect_build_prerequisites: postpone tvz/0.1.0 + trace: collect_build_postponed (1): cfg-negotiate end {tvz | toz->{tvz/1,1}}! + trace: collect_build_postponed (2): begin {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (2): skip being built existing dependent tez of dependency libbox + trace: collect_build_postponed (2): cfg-negotiate begin {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: skip configured libbox/1.0.0 + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tez/0.1.0 + trace: collect_build_prerequisites: resume tez/0.1.0 + trace: collect_build: postpone failure for dependent tez unsatisfied with dependency toz/0.2.0 (== 0.1.0) + trace: collect_build: pick toz/0.2.0 over toz/0.1.0 + trace: collect_build_prerequisites: cfg-postpone dependency toz/0.2.0 of dependent tez/0.1.0 + trace: postponed_configurations::add: add {tez 2,1: toz} to {tvz | toz->{tvz/1,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tez/0.1.0 is negotiated + trace: collect_build_prerequisites: dependency toz/0.2.0 of dependent tez/0.1.0 is already (being) recursively collected, skipping + trace: collect_build_prerequisites: end tez/0.1.0 + trace: collect_build_postponed (2): cfg-negotiate end {tez | libbox->{tez/1,1}}! + trace: collect_build_postponed (3): begin {bax toz tvz | libfoo->{bax/1,1 toz/1,1 tvz/3,1}} + trace: collect_build_postponed (3): cfg-negotiate begin {bax toz tvz | libfoo->{bax/1,1 toz/1,1 tvz/3,1}} + trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: begin libfoo/1.0.0 + trace: collect_build_prerequisites: end libfoo/1.0.0 + trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent bax/1.0.0 + trace: collect_build_prerequisites: resume bax/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent bax/1.0.0 + trace: collect_build: add libbar/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bax/1.0.0 + trace: postponed_configurations::add: add {bax 2,1: libbox libbar} to {tez | libbox->{tez/1,1}}! + trace: collect_build_prerequisites: skip being built existing dependent tez of dependency libbar + trace: collect_build_prerequisites: cfg-postponing dependent bax/1.0.0 involves (being) negotiated configurations and results in {bax tez | libbox->{bax/2,1 tez/1,1} libbar->{bax/2,1}}!, throwing retry_configuration + trace: collect_build_postponed (1): cfg-negotiation of {tez | libbox->{tez/1,1}} failed due to dependent bax, refining configuration + trace: collect_build_postponed (2): begin {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (2): skip being built existing dependent tez of dependency libbox + trace: collect_build_postponed (2): cfg-negotiate begin {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: skip configured libbox/1.0.0 + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tez/0.1.0 + trace: collect_build_prerequisites: resume tez/0.1.0 + trace: collect_build: postpone failure for dependent tez unsatisfied with dependency toz/0.2.0 (== 0.1.0) + trace: collect_build: pick toz/0.2.0 over toz/0.1.0 + trace: collect_build_prerequisites: cfg-postpone dependency toz/0.2.0 of dependent tez/0.1.0 + trace: postponed_configurations::add: add {tez 2,1: toz} to {tvz | toz->{tvz/1,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tez/0.1.0 is negotiated + trace: collect_build_prerequisites: dependency toz/0.2.0 of dependent tez/0.1.0 is already (being) recursively collected, skipping + trace: collect_build_prerequisites: end tez/0.1.0 + trace: collect_build_postponed (2): cfg-negotiate end {tez | libbox->{tez/1,1}}! + trace: collect_build_postponed (3): begin {bax toz tvz | libfoo->{bax/1,1 toz/1,1 tvz/3,1}} + trace: collect_build_postponed (3): cfg-negotiate begin {bax toz tvz | libfoo->{bax/1,1 toz/1,1 tvz/3,1}} + trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: begin libfoo/1.0.0 + trace: collect_build_prerequisites: end libfoo/1.0.0 + trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent bax/1.0.0 + trace: collect_build_prerequisites: resume bax/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent bax/1.0.0 + trace: collect_build: add libbar/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bax/1.0.0 + trace: postponed_configurations::add: add {bax 2,1: libbox libbar} to {tez | libbox->{tez/1,1}}! + trace: collect_build_prerequisites: skip being built existing dependent tez of dependency libbar + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent bax/1.0.0 is negotiated + trace: collect_build_prerequisites: dependency libbox/1.0.0 of dependent bax/1.0.0 is already (being) recursively collected, skipping + trace: collect_build_prerequisites: collecting cfg-postponed dependency libbar/1.0.0 of dependent bax/1.0.0 + trace: collect_build_prerequisites: skip configured libbar/1.0.0 + trace: collect_build_prerequisites: end bax/1.0.0 + trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent toz/0.2.0 + trace: collect_build_prerequisites: resume toz/0.2.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent toz/0.2.0 + trace: postponed_configurations::add: add {toz 2,1: libbar} to {bax tez | libbox->{bax/2,1 tez/1,1} libbar->{bax/2,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent toz/0.2.0 is negotiated + trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent toz/0.2.0 is already (being) recursively collected, skipping + trace: collect_build_prerequisites: end toz/0.2.0 + trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent tvz/0.1.0 + trace: collect_build_prerequisites: resume tvz/0.1.0 + trace: collect_build_prerequisites: end tvz/0.1.0 + trace: collect_build_postponed (3): cfg-negotiate end {bax toz tvz | libfoo->{bax/1,1 toz/1,1 tvz/3,1}}! + trace: collect_build_postponed (3): end {bax toz tvz | libfoo->{bax/1,1 toz/1,1 tvz/3,1}} + trace: collect_build_postponed (2): end {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (1): end {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (0): end + trace: execute_plan: simulate: yes + %.* + trace: execute_plan: while configuring dependent tez in simulation mode unconstrain (toz == 0.1.0) + %.* + trace: pkg_build: try to replace unsatisfactory dependency toz/0.2.0 with some other version + trace: try_replace_dependent: try to replace unsatisfied dependent tez/0.1.0 of dependency toz/0.2.0 with some other version + trace: try_replace_dependency: replacement of unsatisfied dependent version tez/0.1.0 is denied since it is specified on command line as 'tez == 0.1.0' + trace: try_replace_dependent: try to replace conflicting dependent tvz/0.1.0 of dependency toz/0.2.0 with some other version + trace: try_replace_dependency: replacement of conflicting dependent version tvz/0.1.0 is denied since it is specified on command line as 'tvz == 0.1.0' + trace: pkg_build: cannot replace any package, rolling back latest command line adjustment ('tez' -> 'tez == 0.1.0') + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add tvz/0.1.0 + trace: collect_build: add tez/1.0.0 + trace: collect_build_prerequisites: begin tvz/0.1.0 + trace: collect_build: add toz/0.2.0 + info: package tvz dependency on (toz == 0.2.0) is forcing upgrade of toz/0.1.0 to 0.2.0 + trace: collect_build_prerequisites: cfg-postpone dependency toz/0.2.0 of dependent tvz/0.1.0 + trace: postponed_configurations::add: create {tvz | toz->{tvz/1,1}} + trace: collect_build_prerequisites: postpone tvz/0.1.0 + trace: collect_build_prerequisites: begin tez/1.0.0 + trace: collect_build: add libbox/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent tez/1.0.0 + trace: postponed_configurations::add: create {tez | libbox->{tez/1,1}} + trace: collect_build_prerequisites: postpone tez/1.0.0 + trace: collect_build_postponed (0): begin + trace: collect_build_postponed (1): begin {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (1): skip being built existing dependent tez of dependency toz + trace: collect_build_postponed (1): cfg-negotiate begin {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: begin toz/0.2.0 + trace: collect_build: add libfoo/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent toz/0.2.0 + trace: postponed_configurations::add: create {toz | libfoo->{toz/1,1}} + trace: collect_build_prerequisites: postpone toz/0.2.0 + trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tvz/0.1.0 + trace: collect_build_prerequisites: resume tvz/0.1.0 + trace: collect_build: add bax/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency bax/1.0.0 of dependent tvz/0.1.0 + trace: collect_build_prerequisites: begin bax/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent bax/1.0.0 + trace: postponed_configurations::add: add {bax 1,1: libfoo} to {toz | libfoo->{toz/1,1}} + trace: collect_build_prerequisites: postpone bax/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent tvz/0.1.0 + trace: postponed_configurations::add: add {tvz 3,1: libfoo} to {bax toz | libfoo->{bax/1,1 toz/1,1}} + trace: collect_build_prerequisites: postpone tvz/0.1.0 + trace: collect_build_postponed (1): cfg-negotiate end {tvz | toz->{tvz/1,1}}! + trace: collect_build_postponed (2): begin {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (2): skip being built existing dependent tez of dependency libbox + trace: collect_build_postponed (2): cfg-negotiate begin {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: skip configured libbox/1.0.0 + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tez/1.0.0 + trace: collect_build_prerequisites: resume tez/1.0.0 + trace: collect_build: postpone failure for dependent tez unsatisfied with dependency toz/0.2.0 (== 0.1.0) + trace: collect_build: pick toz/0.2.0 over toz/0.1.0 + trace: collect_build_prerequisites: cfg-postpone dependency toz/0.2.0 of dependent tez/1.0.0 + trace: postponed_configurations::add: add {tez 2,1: toz} to {tvz | toz->{tvz/1,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tez/1.0.0 is negotiated + trace: collect_build_prerequisites: dependency toz/0.2.0 of dependent tez/1.0.0 is already (being) recursively collected, skipping + trace: collect_build: add libbar/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tez/1.0.0 + trace: postponed_configurations::add: create {tez | libbar->{tez/3,1}} + trace: collect_build_prerequisites: postpone tez/1.0.0 + trace: collect_build_postponed (2): cfg-negotiate end {tez | libbox->{tez/1,1}}! + trace: collect_build_postponed (3): begin {bax toz tvz | libfoo->{bax/1,1 toz/1,1 tvz/3,1}} + trace: collect_build_postponed (3): cfg-negotiate begin {bax toz tvz | libfoo->{bax/1,1 toz/1,1 tvz/3,1}} + trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: begin libfoo/1.0.0 + trace: collect_build_prerequisites: end libfoo/1.0.0 + trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent bax/1.0.0 + trace: collect_build_prerequisites: resume bax/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent bax/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bax/1.0.0 + trace: postponed_configurations::add: add {bax 2,1: libbox libbar} to {tez | libbox->{tez/1,1}}! + trace: postponed_configurations::add: merge {tez | libbar->{tez/3,1}} into {bax tez | libbox->{bax/2,1 tez/1,1} libbar->{bax/2,1}}! + trace: collect_build_prerequisites: cfg-postponing dependent bax/1.0.0 merges non-negotiated and/or being negotiated configurations in and results in {bax tez | libbox->{bax/2,1 tez/1,1} libbar->{bax/2,1 tez/3,1}}!, throwing merge_configuration + trace: collect_build_postponed (1): cfg-negotiation of {tez | libbox->{tez/1,1}} failed due to non-negotiated clusters, force-merging based on shadow cluster {bax tez | libbox->{bax/2,1 tez/1,1} libbar->{bax/2,1 tez/3,1}}! + trace: collect_build_postponed (2): begin {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (2): skip being built existing dependent tez of dependency libbox + trace: collect_build_postponed (2): cfg-negotiate begin {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: skip configured libbox/1.0.0 + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tez/1.0.0 + trace: collect_build_prerequisites: resume tez/1.0.0 + trace: collect_build: postpone failure for dependent tez unsatisfied with dependency toz/0.2.0 (== 0.1.0) + trace: collect_build: pick toz/0.2.0 over toz/0.1.0 + trace: collect_build_prerequisites: cfg-postpone dependency toz/0.2.0 of dependent tez/1.0.0 + trace: postponed_configurations::add: add {tez 2,1: toz} to {tvz | toz->{tvz/1,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tez/1.0.0 is negotiated + trace: collect_build_prerequisites: dependency toz/0.2.0 of dependent tez/1.0.0 is already (being) recursively collected, skipping + trace: collect_build: add libbar/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tez/1.0.0 + trace: postponed_configurations::add: add {tez 3,1: libbar} to {tez | libbox->{tez/1,1}}? (shadow cluster-based) + trace: collect_build_prerequisites: skip being built existing dependent tez of dependency libbar + trace: collect_build_prerequisites: cfg-postponing dependent tez/1.0.0 involves (being) negotiated configurations and results in {tez | libbox->{tez/1,1} libbar->{tez/3,1}}?, throwing retry_configuration + trace: collect_build_postponed (1): cfg-negotiation of {tez | libbox->{tez/1,1}} failed due to dependent tez, refining configuration + trace: collect_build_postponed (2): begin {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (2): skip being built existing dependent tez of dependency libbox + trace: collect_build_postponed (2): cfg-negotiate begin {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: skip configured libbox/1.0.0 + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tez/1.0.0 + trace: collect_build_prerequisites: resume tez/1.0.0 + trace: collect_build: postpone failure for dependent tez unsatisfied with dependency toz/0.2.0 (== 0.1.0) + trace: collect_build: pick toz/0.2.0 over toz/0.1.0 + trace: collect_build_prerequisites: cfg-postpone dependency toz/0.2.0 of dependent tez/1.0.0 + trace: postponed_configurations::add: add {tez 2,1: toz} to {tvz | toz->{tvz/1,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tez/1.0.0 is negotiated + trace: collect_build_prerequisites: dependency toz/0.2.0 of dependent tez/1.0.0 is already (being) recursively collected, skipping + trace: collect_build: add libbar/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tez/1.0.0 + trace: postponed_configurations::add: add {tez 3,1: libbar} to {tez | libbox->{tez/1,1}}? (shadow cluster-based) + trace: collect_build_prerequisites: skip being built existing dependent tez of dependency libbar + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tez/1.0.0 is shadow-negotiated + trace: collect_build_prerequisites: collecting cfg-postponed dependency libbar/1.0.0 of dependent tez/1.0.0 + trace: collect_build_prerequisites: skip configured libbar/1.0.0 + trace: collect_build_prerequisites: end tez/1.0.0 + trace: collect_build_postponed (2): cfg-negotiate end {tez | libbox->{tez/1,1} libbar->{tez/3,1}}! + trace: collect_build_postponed (3): begin {bax toz tvz | libfoo->{bax/1,1 toz/1,1 tvz/3,1}} + trace: collect_build_postponed (3): cfg-negotiate begin {bax toz tvz | libfoo->{bax/1,1 toz/1,1 tvz/3,1}} + trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: begin libfoo/1.0.0 + trace: collect_build_prerequisites: end libfoo/1.0.0 + trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent bax/1.0.0 + trace: collect_build_prerequisites: resume bax/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent bax/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bax/1.0.0 + trace: postponed_configurations::add: add {bax 2,1: libbox libbar} to {tez | libbox->{tez/1,1} libbar->{tez/3,1}}! (shadow cluster-based) + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent bax/1.0.0 is shadow-negotiated + trace: collect_build_prerequisites: dependency libbox/1.0.0 of dependent bax/1.0.0 is already (being) recursively collected, skipping + trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent bax/1.0.0 is already (being) recursively collected, skipping + trace: collect_build_prerequisites: end bax/1.0.0 + trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent toz/0.2.0 + trace: collect_build_prerequisites: resume toz/0.2.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent toz/0.2.0 + trace: postponed_configurations::add: add {toz 2,1: libbar} to {bax tez | libbox->{bax/2,1 tez/1,1} libbar->{bax/2,1 tez/3,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent toz/0.2.0 is negotiated + trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent toz/0.2.0 is already (being) recursively collected, skipping + trace: collect_build_prerequisites: end toz/0.2.0 + trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent tvz/0.1.0 + trace: collect_build_prerequisites: resume tvz/0.1.0 + trace: collect_build_prerequisites: end tvz/0.1.0 + trace: collect_build_postponed (3): cfg-negotiate end {bax toz tvz | libfoo->{bax/1,1 toz/1,1 tvz/3,1}}! + trace: collect_build_postponed (3): end {bax toz tvz | libfoo->{bax/1,1 toz/1,1 tvz/3,1}} + trace: collect_build_postponed (2): end {tez | libbox->{tez/1,1}} + trace: collect_build_postponed (1): end {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (0): end + trace: execute_plan: simulate: yes + %.* + trace: execute_plan: while configuring dependent tez in simulation mode unconstrain (toz == 0.1.0) + %.* + trace: pkg_build: try to replace unsatisfactory dependency toz/0.2.0 with some other version + trace: try_replace_dependent: try to replace unsatisfied dependent tez/1.0.0 of dependency toz/0.2.0 with some other version + trace: try_replace_dependency: replacement tez/0.1.0 tried earlier for same command line, skipping + trace: try_replace_dependent: try to replace conflicting dependent tvz/0.1.0 of dependency toz/0.2.0 with some other version + trace: try_replace_dependency: replacement of conflicting dependent version tvz/0.1.0 is denied since it is specified on command line as 'tvz == 0.1.0' error: unable to satisfy constraints on package toz info: tvz/0.1.0 depends on (toz == 0.2.0) command line requires (tvz == 0.1.0) @@ -18962,9 +20558,651 @@ test.arguments += --sys-no-query EOO # While at it make sure that we won't be able to build tvz since it - # requires toz of the 0.2.0 version, which can't be satisfied. + # requires toz of the 0.2.0 version, which initially can't be + # satisfied. But this get automatically resolved by the unsatisfied + # constraints resolution machinery. # - $* tvz --verbose 1 2>>EOE != 0; + $* tvz 2>&1 != 0 | $filter 2>>~%EOE%; + %.* + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add tvz/1.0.0 + trace: collect_build_prerequisites: begin tvz/1.0.0 + trace: collect_build: add toz/0.2.0 + info: package tvz dependency on (toz == 0.2.0) is forcing upgrade of toz/0.1.0 to 0.2.0 + trace: collect_build_prerequisites: cfg-postpone dependency toz/0.2.0 of dependent tvz/1.0.0 + trace: postponed_configurations::add: create {tvz | toz->{tvz/1,1}} + trace: collect_build_prerequisites: postpone tvz/1.0.0 + trace: collect_build_postponed (0): begin + trace: collect_build_postponed (1): begin {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (1): skip unsatisfied existing dependent tez of dependency toz/0.2.0 due to constraint (toz == 0.1.0) + trace: collect_build_postponed (1): cfg-negotiate begin {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: begin toz/0.2.0 + trace: collect_build: add libfoo/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent toz/0.2.0 + trace: postponed_configurations::add: create {toz | libfoo->{toz/1,1}} + trace: collect_build_prerequisites: postpone toz/0.2.0 + trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tvz/1.0.0 + trace: collect_build_prerequisites: resume tvz/1.0.0 + trace: collect_build_prerequisites: end tvz/1.0.0 + trace: collect_build_postponed (1): cfg-negotiate end {tvz | toz->{tvz/1,1}}! + trace: collect_build_postponed (2): begin {toz | libfoo->{toz/1,1}} + trace: collect_build_prerequisites: pre-reeval tex/1.0.0 + trace: collect_build_prerequisites: pre-reevaluated tex/1.0.0: 1,1 + trace: collect_build_prerequisites: pre-reeval bax/1.0.0 + trace: collect_build_prerequisites: pre-reevaluated bax/1.0.0: 1,1 + trace: collect_build: add libbar/1.0.0 + trace: collect_build_postponed (2): re-evaluate existing dependents for {toz | libfoo->{toz/1,1}} + trace: collect_build: add bax/1.0.0 + trace: collect_build_prerequisites: reeval bax/1.0.0 + trace: postponed_configurations::add: add {bax^ 1,1: libfoo} to {toz | libfoo->{toz/1,1}} + trace: collect_build_prerequisites: re-evaluating dependent bax/1.0.0 results in {bax^ toz | libfoo->{bax/1,1 toz/1,1}} + trace: collect_build_prerequisites: re-evaluated bax/1.0.0 + trace: collect_build: add tex/1.0.0 + trace: collect_build_prerequisites: reeval tex/1.0.0 + trace: postponed_configurations::add: create {tex^ | libbar->{tex/1,1}} + trace: collect_build_prerequisites: re-evaluating dependent tex/1.0.0 results in {tex^ | libbar->{tex/1,1}} + trace: collect_build_prerequisites: re-evaluated tex/1.0.0 + trace: collect_build_postponed (2): cfg-negotiate begin {bax^ toz | libfoo->{bax/1,1 toz/1,1}} + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: skip configured libfoo/1.0.0 + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent bax/1.0.0 + trace: collect_build_prerequisites: resume bax/1.0.0 + trace: collect_build: add libbox/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent bax/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bax/1.0.0 + trace: postponed_configurations::add: add {bax 2,1: libbox libbar} to {tex^ | libbar->{tex/1,1}} + trace: collect_build_prerequisites: postpone bax/1.0.0 + trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent toz/0.2.0 + trace: collect_build_prerequisites: resume toz/0.2.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent toz/0.2.0 + trace: postponed_configurations::add: add {toz 2,1: libbar} to {bax tex^ | libbar->{bax/2,1 tex/1,1} libbox->{bax/2,1}} + trace: collect_build_prerequisites: postpone toz/0.2.0 + trace: collect_build_postponed (2): cfg-negotiate end {bax^ toz | libfoo->{bax/1,1 toz/1,1}}! + trace: collect_build_postponed (3): begin {bax tex^ toz | libbar->{bax/2,1 tex/1,1 toz/2,1} libbox->{bax/2,1}} + trace: collect_build_postponed (3): skip being built existing dependent tex of dependency libbar + trace: collect_build_postponed (3): skip being built existing dependent bax of dependency libbar + trace: collect_build_prerequisites: pre-reeval tiz/1.0.0 + trace: collect_build_prerequisites: pre-reevaluated tiz/1.0.0: 1,1 + trace: collect_build_prerequisites: pre-reeval tez/1.0.0 + trace: collect_build_prerequisites: re-evaluation of dependent tez/1.0.0 deviated for depends clause 2: now cannot select alternative, previously 1 was selected + trace: collect_build_postponed (3): schedule re-collection of deviated existing dependent tez/1.0.0 + trace: collect_build: add tez/1.0.0 + trace: collect_build_postponed (3): skip being built existing dependent bax of dependency libbox + trace: collect_build_postponed (3): skip being built existing dependent tez of dependency libbox + trace: collect_build_postponed (3): re-evaluate existing dependents for {bax tex^ toz | libbar->{bax/2,1 tex/1,1 toz/2,1} libbox->{bax/2,1}} + trace: collect_build: add tiz/1.0.0 + trace: collect_build_prerequisites: reeval tiz/1.0.0 + trace: collect_build_prerequisites: cannot re-evaluate existing dependent tiz/1.0.0 due to dependency tex/1.0.0 (collected prematurely), throwing postpone_dependency + trace: pkg_build: collection failed due to prematurely collected dependency (tex), retry from scratch + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add tvz/1.0.0 + trace: collect_build_prerequisites: begin tvz/1.0.0 + trace: collect_build: add toz/0.2.0 + info: package tvz dependency on (toz == 0.2.0) is forcing upgrade of toz/0.1.0 to 0.2.0 + trace: collect_build_prerequisites: cfg-postpone dependency toz/0.2.0 of dependent tvz/1.0.0 + trace: postponed_configurations::add: create {tvz | toz->{tvz/1,1}} + trace: collect_build_prerequisites: postpone tvz/1.0.0 + trace: collect_build_postponed (0): begin + trace: collect_build_postponed (1): begin {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (1): skip unsatisfied existing dependent tez of dependency toz/0.2.0 due to constraint (toz == 0.1.0) + trace: collect_build_postponed (1): cfg-negotiate begin {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: begin toz/0.2.0 + trace: collect_build: add libfoo/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent toz/0.2.0 + trace: postponed_configurations::add: create {toz | libfoo->{toz/1,1}} + trace: collect_build_prerequisites: postpone toz/0.2.0 + trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tvz/1.0.0 + trace: collect_build_prerequisites: resume tvz/1.0.0 + trace: collect_build_prerequisites: end tvz/1.0.0 + trace: collect_build_postponed (1): cfg-negotiate end {tvz | toz->{tvz/1,1}}! + trace: collect_build_postponed (2): begin {toz | libfoo->{toz/1,1}} + trace: collect_build_prerequisites: pre-reeval tex/1.0.0 + trace: collect_build_prerequisites: pre-reevaluated tex/1.0.0: 1,1 + trace: collect_build_prerequisites: pre-reeval bax/1.0.0 + trace: collect_build_prerequisites: pre-reevaluated bax/1.0.0: 1,1 + trace: collect_build_postponed (2): skip dep-postponed existing dependent tex of dependency libfoo + trace: collect_build: add tex/1.0.0 + trace: collect_build_postponed (2): re-evaluate existing dependents for {toz | libfoo->{toz/1,1}} + trace: collect_build: add bax/1.0.0 + trace: collect_build_prerequisites: reeval bax/1.0.0 + trace: postponed_configurations::add: add {bax^ 1,1: libfoo} to {toz | libfoo->{toz/1,1}} + trace: collect_build_prerequisites: re-evaluating dependent bax/1.0.0 results in {bax^ toz | libfoo->{bax/1,1 toz/1,1}} + trace: collect_build_prerequisites: re-evaluated bax/1.0.0 + trace: collect_build_postponed (2): cfg-negotiate begin {bax^ toz | libfoo->{bax/1,1 toz/1,1}} + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: skip configured libfoo/1.0.0 + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent bax/1.0.0 + trace: collect_build_prerequisites: resume bax/1.0.0 + trace: collect_build: add libbox/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent bax/1.0.0 + trace: collect_build: add libbar/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bax/1.0.0 + trace: postponed_configurations::add: create {bax | libbox->{bax/2,1} libbar->{bax/2,1}} + trace: collect_build_prerequisites: postpone bax/1.0.0 + trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent toz/0.2.0 + trace: collect_build_prerequisites: resume toz/0.2.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent toz/0.2.0 + trace: postponed_configurations::add: add {toz 2,1: libbar} to {bax | libbox->{bax/2,1} libbar->{bax/2,1}} + trace: collect_build_prerequisites: postpone toz/0.2.0 + trace: collect_build_postponed (2): cfg-negotiate end {bax^ toz | libfoo->{bax/1,1 toz/1,1}}! + trace: collect_build_postponed (3): begin {bax toz | libbox->{bax/2,1} libbar->{bax/2,1 toz/2,1}} + trace: collect_build_postponed (3): skip being built existing dependent bax of dependency libbox + trace: collect_build_prerequisites: pre-reeval tez/1.0.0 + trace: collect_build_prerequisites: re-evaluation of dependent tez/1.0.0 deviated for depends clause 2: now cannot select alternative, previously 1 was selected + trace: collect_build_postponed (3): schedule re-collection of deviated existing dependent tez/1.0.0 + trace: collect_build: add tez/1.0.0 + trace: collect_build_prerequisites: pre-reeval tex/1.0.0 + trace: collect_build_prerequisites: pre-reevaluated tex/1.0.0: 1,1 + trace: collect_build_postponed (3): skip being built existing dependent bax of dependency libbar + trace: collect_build_prerequisites: pre-reeval tiz/1.0.0 + trace: collect_build_prerequisites: pre-reevaluated tiz/1.0.0: 1,1 + trace: collect_build_postponed (3): skip being built existing dependent tez of dependency libbar + trace: collect_build_postponed (3): skip dep-postponed existing dependent tex of dependency libbar + trace: collect_build_postponed (3): re-evaluate existing dependents for {bax toz | libbox->{bax/2,1} libbar->{bax/2,1 toz/2,1}} + trace: collect_build: add tiz/1.0.0 + trace: collect_build_prerequisites: reeval tiz/1.0.0 + trace: postponed_configurations::add: create {tiz^ | tex->{tiz/1,1}} + trace: collect_build_prerequisites: re-evaluating dependent tiz/1.0.0 results in {tiz^ | tex->{tiz/1,1}} + trace: collect_build_prerequisites: re-evaluated tiz/1.0.0 + trace: collect_build_postponed (3): cfg-negotiate begin {bax toz | libbox->{bax/2,1} libbar->{bax/2,1 toz/2,1}} + trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: skip configured libbox/1.0.0 + trace: collect_build_prerequisites: skip configured libbar/1.0.0 + trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent bax/1.0.0 + trace: collect_build_prerequisites: resume bax/1.0.0 + trace: collect_build_prerequisites: end bax/1.0.0 + trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent toz/0.2.0 + trace: collect_build_prerequisites: resume toz/0.2.0 + trace: collect_build_prerequisites: end toz/0.2.0 + trace: collect_build_postponed (3): cfg-negotiate end {bax toz | libbox->{bax/2,1} libbar->{bax/2,1 toz/2,1}}! + trace: collect_build_prerequisites: begin tez/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent tez/1.0.0 + trace: postponed_configurations::add: add {tez 1,1: libbox} to {bax toz | libbox->{bax/2,1} libbar->{bax/2,1 toz/2,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tez/1.0.0 is negotiated + trace: collect_build_prerequisites: dependency libbox/1.0.0 of dependent tez/1.0.0 is already (being) recursively collected, skipping + trace: collect_build: postpone failure for dependent tez unsatisfied with dependency toz/0.2.0 (== 0.1.0) + trace: collect_build: pick toz/0.2.0 over toz/0.1.0 + trace: collect_build_prerequisites: cfg-postpone dependency toz/0.2.0 of dependent tez/1.0.0 + trace: postponed_configurations::add: add {tez 2,1: toz} to {tvz | toz->{tvz/1,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tez/1.0.0 is negotiated + trace: collect_build_prerequisites: dependency toz/0.2.0 of dependent tez/1.0.0 is already (being) recursively collected, skipping + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tez/1.0.0 + trace: postponed_configurations::add: add {tez 3,1: libbar} to {bax tez toz | libbox->{bax/2,1 tez/1,1} libbar->{bax/2,1 toz/2,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tez/1.0.0 is negotiated + trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent tez/1.0.0 is already (being) recursively collected, skipping + trace: collect_build_prerequisites: end tez/1.0.0 + trace: collect_build_postponed (4): begin {tiz^ | tex->{tiz/1,1}} + trace: collect_build_postponed (4): skip being built existing dependent tiz of dependency tex + trace: collect_build_postponed (4): cfg-negotiate begin {tiz^ | tex->{tiz/1,1}} + trace: collect_build_postponed (4): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: begin tex/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tex/1.0.0 + trace: postponed_configurations::add: add {tex 1,1: libbar} to {bax tez toz | libbox->{bax/2,1 tez/1,1} libbar->{bax/2,1 tez/3,1 toz/2,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tex/1.0.0 is negotiated + trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent tex/1.0.0 is already (being) recursively collected, skipping + trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent tex/1.0.0 + trace: postponed_configurations::add: add {tex 2,1: libfoo} to {bax^ toz | libfoo->{bax/1,1 toz/1,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tex/1.0.0 is negotiated + trace: collect_build_prerequisites: dependency libfoo/1.0.0 of dependent tex/1.0.0 is already (being) recursively collected, skipping + trace: collect_build_prerequisites: end tex/1.0.0 + trace: collect_build_postponed (4): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (4): select cfg-negotiated dependency alternative for dependent tiz/1.0.0 + trace: collect_build_prerequisites: resume tiz/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tiz/1.0.0 + trace: postponed_configurations::add: add {tiz 2,1: libbar} to {bax tex tez toz | libbox->{bax/2,1 tez/1,1} libbar->{bax/2,1 tex/1,1 tez/3,1 toz/2,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tiz/1.0.0 is negotiated + trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent tiz/1.0.0 is already (being) recursively collected, skipping + trace: collect_build_prerequisites: end tiz/1.0.0 + trace: collect_build_postponed (4): cfg-negotiate end {tiz^ | tex->{tiz/1,1}}! + trace: collect_build_postponed (4): end {tiz^ | tex->{tiz/1,1}} + trace: collect_build_postponed (3): end {bax toz | libbox->{bax/2,1} libbar->{bax/2,1 toz/2,1}} + trace: collect_build_postponed (2): end {toz | libfoo->{toz/1,1}} + trace: collect_build_postponed (1): end {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (0): end + trace: execute_plan: simulate: yes + %.* + trace: pkg_build: try to replace unsatisfactory dependency toz/0.2.0 with some other version + trace: try_replace_dependent: try to replace unsatisfied dependent tez/1.0.0 of dependency toz/0.2.0 with some other version + trace: try_replace_dependent: try to replace conflicting dependent tvz/1.0.0 of dependency toz/0.2.0 with some other version + trace: try_replace_dependency: replace conflicting dependent version tvz/1.0.0 with 0.1.0 by adding constraint 'tvz' -> 'tvz == 0.1.0' on command line + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add tvz/0.1.0 + trace: collect_build_prerequisites: begin tvz/0.1.0 + trace: collect_build: add toz/0.2.0 + info: package tvz dependency on (toz == 0.2.0) is forcing upgrade of toz/0.1.0 to 0.2.0 + trace: collect_build_prerequisites: cfg-postpone dependency toz/0.2.0 of dependent tvz/0.1.0 + trace: postponed_configurations::add: create {tvz | toz->{tvz/1,1}} + trace: collect_build_prerequisites: postpone tvz/0.1.0 + trace: collect_build_postponed (0): begin + trace: collect_build_postponed (1): begin {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (1): skip unsatisfied existing dependent tez of dependency toz/0.2.0 due to constraint (toz == 0.1.0) + trace: collect_build_postponed (1): cfg-negotiate begin {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: begin toz/0.2.0 + trace: collect_build: add libfoo/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent toz/0.2.0 + trace: postponed_configurations::add: create {toz | libfoo->{toz/1,1}} + trace: collect_build_prerequisites: postpone toz/0.2.0 + trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tvz/0.1.0 + trace: collect_build_prerequisites: resume tvz/0.1.0 + trace: collect_build: add bax/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency bax/1.0.0 of dependent tvz/0.1.0 + trace: collect_build_prerequisites: skip configured bax/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent tvz/0.1.0 + trace: postponed_configurations::add: add {tvz 3,1: libfoo} to {toz | libfoo->{toz/1,1}} + trace: collect_build_prerequisites: postpone tvz/0.1.0 + trace: collect_build_postponed (1): cfg-negotiate end {tvz | toz->{tvz/1,1}}! + trace: collect_build_postponed (2): begin {toz tvz | libfoo->{toz/1,1 tvz/3,1}} + trace: collect_build_prerequisites: pre-reeval tex/1.0.0 + trace: collect_build_prerequisites: pre-reevaluated tex/1.0.0: 1,1 + trace: collect_build_prerequisites: pre-reeval bax/1.0.0 + trace: collect_build_prerequisites: pre-reevaluated bax/1.0.0: 1,1 + trace: collect_build: add libbar/1.0.0 + trace: collect_build_postponed (2): re-evaluate existing dependents for {toz tvz | libfoo->{toz/1,1 tvz/3,1}} + trace: collect_build_prerequisites: reeval bax/1.0.0 + trace: postponed_configurations::add: add {bax^ 1,1: libfoo} to {toz tvz | libfoo->{toz/1,1 tvz/3,1}} + trace: collect_build_prerequisites: re-evaluating dependent bax/1.0.0 results in {bax^ toz tvz | libfoo->{bax/1,1 toz/1,1 tvz/3,1}} + trace: collect_build_prerequisites: re-evaluated bax/1.0.0 + trace: collect_build: add tex/1.0.0 + trace: collect_build_prerequisites: reeval tex/1.0.0 + trace: postponed_configurations::add: create {tex^ | libbar->{tex/1,1}} + trace: collect_build_prerequisites: re-evaluating dependent tex/1.0.0 results in {tex^ | libbar->{tex/1,1}} + trace: collect_build_prerequisites: re-evaluated tex/1.0.0 + trace: collect_build_postponed (2): cfg-negotiate begin {bax^ toz tvz | libfoo->{bax/1,1 toz/1,1 tvz/3,1}} + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: skip configured libfoo/1.0.0 + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent bax/1.0.0 + trace: collect_build_prerequisites: resume bax/1.0.0 + trace: collect_build: add libbox/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent bax/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bax/1.0.0 + trace: postponed_configurations::add: add {bax 2,1: libbox libbar} to {tex^ | libbar->{tex/1,1}} + trace: collect_build_prerequisites: postpone bax/1.0.0 + trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent toz/0.2.0 + trace: collect_build_prerequisites: resume toz/0.2.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent toz/0.2.0 + trace: postponed_configurations::add: add {toz 2,1: libbar} to {bax tex^ | libbar->{bax/2,1 tex/1,1} libbox->{bax/2,1}} + trace: collect_build_prerequisites: postpone toz/0.2.0 + trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tvz/0.1.0 + trace: collect_build_prerequisites: resume tvz/0.1.0 + trace: collect_build_prerequisites: end tvz/0.1.0 + trace: collect_build_postponed (2): cfg-negotiate end {bax^ toz tvz | libfoo->{bax/1,1 toz/1,1 tvz/3,1}}! + trace: collect_build_postponed (3): begin {bax tex^ toz | libbar->{bax/2,1 tex/1,1 toz/2,1} libbox->{bax/2,1}} + trace: collect_build_postponed (3): skip being built existing dependent tex of dependency libbar + trace: collect_build_postponed (3): skip being built existing dependent bax of dependency libbar + trace: collect_build_prerequisites: pre-reeval tiz/1.0.0 + trace: collect_build_prerequisites: pre-reevaluated tiz/1.0.0: 1,1 + trace: collect_build_prerequisites: pre-reeval tez/1.0.0 + trace: collect_build_prerequisites: re-evaluation of dependent tez/1.0.0 deviated for depends clause 2: now cannot select alternative, previously 1 was selected + trace: collect_build_postponed (3): schedule re-collection of deviated existing dependent tez/1.0.0 + trace: collect_build: add tez/1.0.0 + trace: collect_build_postponed (3): skip being built existing dependent bax of dependency libbox + trace: collect_build_postponed (3): skip being built existing dependent tez of dependency libbox + trace: collect_build_postponed (3): re-evaluate existing dependents for {bax tex^ toz | libbar->{bax/2,1 tex/1,1 toz/2,1} libbox->{bax/2,1}} + trace: collect_build: add tiz/1.0.0 + trace: collect_build_prerequisites: reeval tiz/1.0.0 + trace: collect_build_prerequisites: cannot re-evaluate existing dependent tiz/1.0.0 due to dependency tex/1.0.0 (collected prematurely), throwing postpone_dependency + trace: pkg_build: collection failed due to prematurely collected dependency (tex), retry from scratch + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add tvz/0.1.0 + trace: collect_build_prerequisites: begin tvz/0.1.0 + trace: collect_build: add toz/0.2.0 + info: package tvz dependency on (toz == 0.2.0) is forcing upgrade of toz/0.1.0 to 0.2.0 + trace: collect_build_prerequisites: cfg-postpone dependency toz/0.2.0 of dependent tvz/0.1.0 + trace: postponed_configurations::add: create {tvz | toz->{tvz/1,1}} + trace: collect_build_prerequisites: postpone tvz/0.1.0 + trace: collect_build_postponed (0): begin + trace: collect_build_postponed (1): begin {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (1): skip unsatisfied existing dependent tez of dependency toz/0.2.0 due to constraint (toz == 0.1.0) + trace: collect_build_postponed (1): cfg-negotiate begin {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: begin toz/0.2.0 + trace: collect_build: add libfoo/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent toz/0.2.0 + trace: postponed_configurations::add: create {toz | libfoo->{toz/1,1}} + trace: collect_build_prerequisites: postpone toz/0.2.0 + trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tvz/0.1.0 + trace: collect_build_prerequisites: resume tvz/0.1.0 + trace: collect_build: add bax/1.0.0 + trace: collect_build_prerequisites: no cfg-clause for dependency bax/1.0.0 of dependent tvz/0.1.0 + trace: collect_build_prerequisites: skip configured bax/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent tvz/0.1.0 + trace: postponed_configurations::add: add {tvz 3,1: libfoo} to {toz | libfoo->{toz/1,1}} + trace: collect_build_prerequisites: postpone tvz/0.1.0 + trace: collect_build_postponed (1): cfg-negotiate end {tvz | toz->{tvz/1,1}}! + trace: collect_build_postponed (2): begin {toz tvz | libfoo->{toz/1,1 tvz/3,1}} + trace: collect_build_prerequisites: pre-reeval tex/1.0.0 + trace: collect_build_prerequisites: pre-reevaluated tex/1.0.0: 1,1 + trace: collect_build_prerequisites: pre-reeval bax/1.0.0 + trace: collect_build_prerequisites: pre-reevaluated bax/1.0.0: 1,1 + trace: collect_build_postponed (2): skip dep-postponed existing dependent tex of dependency libfoo + trace: collect_build: add tex/1.0.0 + trace: collect_build_postponed (2): re-evaluate existing dependents for {toz tvz | libfoo->{toz/1,1 tvz/3,1}} + trace: collect_build_prerequisites: reeval bax/1.0.0 + trace: postponed_configurations::add: add {bax^ 1,1: libfoo} to {toz tvz | libfoo->{toz/1,1 tvz/3,1}} + trace: collect_build_prerequisites: re-evaluating dependent bax/1.0.0 results in {bax^ toz tvz | libfoo->{bax/1,1 toz/1,1 tvz/3,1}} + trace: collect_build_prerequisites: re-evaluated bax/1.0.0 + trace: collect_build_postponed (2): cfg-negotiate begin {bax^ toz tvz | libfoo->{bax/1,1 toz/1,1 tvz/3,1}} + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: skip configured libfoo/1.0.0 + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent bax/1.0.0 + trace: collect_build_prerequisites: resume bax/1.0.0 + trace: collect_build: add libbox/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent bax/1.0.0 + trace: collect_build: add libbar/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bax/1.0.0 + trace: postponed_configurations::add: create {bax | libbox->{bax/2,1} libbar->{bax/2,1}} + trace: collect_build_prerequisites: postpone bax/1.0.0 + trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent toz/0.2.0 + trace: collect_build_prerequisites: resume toz/0.2.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent toz/0.2.0 + trace: postponed_configurations::add: add {toz 2,1: libbar} to {bax | libbox->{bax/2,1} libbar->{bax/2,1}} + trace: collect_build_prerequisites: postpone toz/0.2.0 + trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tvz/0.1.0 + trace: collect_build_prerequisites: resume tvz/0.1.0 + trace: collect_build_prerequisites: end tvz/0.1.0 + trace: collect_build_postponed (2): cfg-negotiate end {bax^ toz tvz | libfoo->{bax/1,1 toz/1,1 tvz/3,1}}! + trace: collect_build_postponed (3): begin {bax toz | libbox->{bax/2,1} libbar->{bax/2,1 toz/2,1}} + trace: collect_build_postponed (3): skip being built existing dependent bax of dependency libbox + trace: collect_build_prerequisites: pre-reeval tez/1.0.0 + trace: collect_build_prerequisites: re-evaluation of dependent tez/1.0.0 deviated for depends clause 2: now cannot select alternative, previously 1 was selected + trace: collect_build_postponed (3): schedule re-collection of deviated existing dependent tez/1.0.0 + trace: collect_build: add tez/1.0.0 + trace: collect_build_prerequisites: pre-reeval tex/1.0.0 + trace: collect_build_prerequisites: pre-reevaluated tex/1.0.0: 1,1 + trace: collect_build_postponed (3): skip being built existing dependent bax of dependency libbar + trace: collect_build_prerequisites: pre-reeval tiz/1.0.0 + trace: collect_build_prerequisites: pre-reevaluated tiz/1.0.0: 1,1 + trace: collect_build_postponed (3): skip being built existing dependent tez of dependency libbar + trace: collect_build_postponed (3): skip dep-postponed existing dependent tex of dependency libbar + trace: collect_build_postponed (3): re-evaluate existing dependents for {bax toz | libbox->{bax/2,1} libbar->{bax/2,1 toz/2,1}} + trace: collect_build: add tiz/1.0.0 + trace: collect_build_prerequisites: reeval tiz/1.0.0 + trace: postponed_configurations::add: create {tiz^ | tex->{tiz/1,1}} + trace: collect_build_prerequisites: re-evaluating dependent tiz/1.0.0 results in {tiz^ | tex->{tiz/1,1}} + trace: collect_build_prerequisites: re-evaluated tiz/1.0.0 + trace: collect_build_postponed (3): cfg-negotiate begin {bax toz | libbox->{bax/2,1} libbar->{bax/2,1 toz/2,1}} + trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: skip configured libbox/1.0.0 + trace: collect_build_prerequisites: skip configured libbar/1.0.0 + trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent bax/1.0.0 + trace: collect_build_prerequisites: resume bax/1.0.0 + trace: collect_build_prerequisites: end bax/1.0.0 + trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent toz/0.2.0 + trace: collect_build_prerequisites: resume toz/0.2.0 + trace: collect_build_prerequisites: end toz/0.2.0 + trace: collect_build_postponed (3): cfg-negotiate end {bax toz | libbox->{bax/2,1} libbar->{bax/2,1 toz/2,1}}! + trace: collect_build_prerequisites: begin tez/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent tez/1.0.0 + trace: postponed_configurations::add: add {tez 1,1: libbox} to {bax toz | libbox->{bax/2,1} libbar->{bax/2,1 toz/2,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tez/1.0.0 is negotiated + trace: collect_build_prerequisites: dependency libbox/1.0.0 of dependent tez/1.0.0 is already (being) recursively collected, skipping + trace: collect_build: postpone failure for dependent tez unsatisfied with dependency toz/0.2.0 (== 0.1.0) + trace: collect_build: pick toz/0.2.0 over toz/0.1.0 + trace: collect_build_prerequisites: cfg-postpone dependency toz/0.2.0 of dependent tez/1.0.0 + trace: postponed_configurations::add: add {tez 2,1: toz} to {tvz | toz->{tvz/1,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tez/1.0.0 is negotiated + trace: collect_build_prerequisites: dependency toz/0.2.0 of dependent tez/1.0.0 is already (being) recursively collected, skipping + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tez/1.0.0 + trace: postponed_configurations::add: add {tez 3,1: libbar} to {bax tez toz | libbox->{bax/2,1 tez/1,1} libbar->{bax/2,1 toz/2,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tez/1.0.0 is negotiated + trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent tez/1.0.0 is already (being) recursively collected, skipping + trace: collect_build_prerequisites: end tez/1.0.0 + trace: collect_build_postponed (4): begin {tiz^ | tex->{tiz/1,1}} + trace: collect_build_postponed (4): skip being built existing dependent tiz of dependency tex + trace: collect_build_postponed (4): cfg-negotiate begin {tiz^ | tex->{tiz/1,1}} + trace: collect_build_postponed (4): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: begin tex/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tex/1.0.0 + trace: postponed_configurations::add: add {tex 1,1: libbar} to {bax tez toz | libbox->{bax/2,1 tez/1,1} libbar->{bax/2,1 tez/3,1 toz/2,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tex/1.0.0 is negotiated + trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent tex/1.0.0 is already (being) recursively collected, skipping + trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent tex/1.0.0 + trace: postponed_configurations::add: add {tex 2,1: libfoo} to {bax^ toz tvz | libfoo->{bax/1,1 toz/1,1 tvz/3,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tex/1.0.0 is negotiated + trace: collect_build_prerequisites: dependency libfoo/1.0.0 of dependent tex/1.0.0 is already (being) recursively collected, skipping + trace: collect_build_prerequisites: end tex/1.0.0 + trace: collect_build_postponed (4): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (4): select cfg-negotiated dependency alternative for dependent tiz/1.0.0 + trace: collect_build_prerequisites: resume tiz/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tiz/1.0.0 + trace: postponed_configurations::add: add {tiz 2,1: libbar} to {bax tex tez toz | libbox->{bax/2,1 tez/1,1} libbar->{bax/2,1 tex/1,1 tez/3,1 toz/2,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tiz/1.0.0 is negotiated + trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent tiz/1.0.0 is already (being) recursively collected, skipping + trace: collect_build_prerequisites: end tiz/1.0.0 + trace: collect_build_postponed (4): cfg-negotiate end {tiz^ | tex->{tiz/1,1}}! + trace: collect_build_postponed (4): end {tiz^ | tex->{tiz/1,1}} + trace: collect_build_postponed (3): end {bax toz | libbox->{bax/2,1} libbar->{bax/2,1 toz/2,1}} + trace: collect_build_postponed (2): end {toz tvz | libfoo->{toz/1,1 tvz/3,1}} + trace: collect_build_postponed (1): end {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (0): end + trace: execute_plan: simulate: yes + %.* + trace: pkg_build: try to replace unsatisfactory dependency toz/0.2.0 with some other version + trace: try_replace_dependent: try to replace unsatisfied dependent tez/1.0.0 of dependency toz/0.2.0 with some other version + trace: try_replace_dependent: try to replace conflicting dependent tvz/0.1.0 of dependency toz/0.2.0 with some other version + trace: try_replace_dependency: replacement of conflicting dependent version tvz/0.1.0 is denied since it is specified on command line as 'tvz == 0.1.0' + trace: pkg_build: cannot replace any package, rolling back latest command line adjustment ('tvz' -> 'tvz == 0.1.0') + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add tvz/1.0.0 + trace: collect_build_prerequisites: begin tvz/1.0.0 + trace: collect_build: add toz/0.2.0 + info: package tvz dependency on (toz == 0.2.0) is forcing upgrade of toz/0.1.0 to 0.2.0 + trace: collect_build_prerequisites: cfg-postpone dependency toz/0.2.0 of dependent tvz/1.0.0 + trace: postponed_configurations::add: create {tvz | toz->{tvz/1,1}} + trace: collect_build_prerequisites: postpone tvz/1.0.0 + trace: collect_build_postponed (0): begin + trace: collect_build_postponed (1): begin {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (1): skip unsatisfied existing dependent tez of dependency toz/0.2.0 due to constraint (toz == 0.1.0) + trace: collect_build_postponed (1): cfg-negotiate begin {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: begin toz/0.2.0 + trace: collect_build: add libfoo/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent toz/0.2.0 + trace: postponed_configurations::add: create {toz | libfoo->{toz/1,1}} + trace: collect_build_prerequisites: postpone toz/0.2.0 + trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tvz/1.0.0 + trace: collect_build_prerequisites: resume tvz/1.0.0 + trace: collect_build_prerequisites: end tvz/1.0.0 + trace: collect_build_postponed (1): cfg-negotiate end {tvz | toz->{tvz/1,1}}! + trace: collect_build_postponed (2): begin {toz | libfoo->{toz/1,1}} + trace: collect_build_prerequisites: pre-reeval tex/1.0.0 + trace: collect_build_prerequisites: pre-reevaluated tex/1.0.0: 1,1 + trace: collect_build_prerequisites: pre-reeval bax/1.0.0 + trace: collect_build_prerequisites: pre-reevaluated bax/1.0.0: 1,1 + trace: collect_build: add libbar/1.0.0 + trace: collect_build_postponed (2): re-evaluate existing dependents for {toz | libfoo->{toz/1,1}} + trace: collect_build: add bax/1.0.0 + trace: collect_build_prerequisites: reeval bax/1.0.0 + trace: postponed_configurations::add: add {bax^ 1,1: libfoo} to {toz | libfoo->{toz/1,1}} + trace: collect_build_prerequisites: re-evaluating dependent bax/1.0.0 results in {bax^ toz | libfoo->{bax/1,1 toz/1,1}} + trace: collect_build_prerequisites: re-evaluated bax/1.0.0 + trace: collect_build: add tex/1.0.0 + trace: collect_build_prerequisites: reeval tex/1.0.0 + trace: postponed_configurations::add: create {tex^ | libbar->{tex/1,1}} + trace: collect_build_prerequisites: re-evaluating dependent tex/1.0.0 results in {tex^ | libbar->{tex/1,1}} + trace: collect_build_prerequisites: re-evaluated tex/1.0.0 + trace: collect_build_postponed (2): cfg-negotiate begin {bax^ toz | libfoo->{bax/1,1 toz/1,1}} + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: skip configured libfoo/1.0.0 + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent bax/1.0.0 + trace: collect_build_prerequisites: resume bax/1.0.0 + trace: collect_build: add libbox/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent bax/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bax/1.0.0 + trace: postponed_configurations::add: add {bax 2,1: libbox libbar} to {tex^ | libbar->{tex/1,1}} + trace: collect_build_prerequisites: postpone bax/1.0.0 + trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent toz/0.2.0 + trace: collect_build_prerequisites: resume toz/0.2.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent toz/0.2.0 + trace: postponed_configurations::add: add {toz 2,1: libbar} to {bax tex^ | libbar->{bax/2,1 tex/1,1} libbox->{bax/2,1}} + trace: collect_build_prerequisites: postpone toz/0.2.0 + trace: collect_build_postponed (2): cfg-negotiate end {bax^ toz | libfoo->{bax/1,1 toz/1,1}}! + trace: collect_build_postponed (3): begin {bax tex^ toz | libbar->{bax/2,1 tex/1,1 toz/2,1} libbox->{bax/2,1}} + trace: collect_build_postponed (3): skip being built existing dependent tex of dependency libbar + trace: collect_build_postponed (3): skip being built existing dependent bax of dependency libbar + trace: collect_build_prerequisites: pre-reeval tiz/1.0.0 + trace: collect_build_prerequisites: pre-reevaluated tiz/1.0.0: 1,1 + trace: collect_build_prerequisites: pre-reeval tez/1.0.0 + trace: collect_build_prerequisites: re-evaluation of dependent tez/1.0.0 deviated for depends clause 2: now cannot select alternative, previously 1 was selected + trace: collect_build_postponed (3): schedule re-collection of deviated existing dependent tez/1.0.0 + trace: collect_build: add tez/1.0.0 + trace: collect_build_postponed (3): skip being built existing dependent bax of dependency libbox + trace: collect_build_postponed (3): skip being built existing dependent tez of dependency libbox + trace: collect_build_postponed (3): re-evaluate existing dependents for {bax tex^ toz | libbar->{bax/2,1 tex/1,1 toz/2,1} libbox->{bax/2,1}} + trace: collect_build: add tiz/1.0.0 + trace: collect_build_prerequisites: reeval tiz/1.0.0 + trace: collect_build_prerequisites: cannot re-evaluate existing dependent tiz/1.0.0 due to dependency tex/1.0.0 (collected prematurely), throwing postpone_dependency + trace: pkg_build: collection failed due to prematurely collected dependency (tex), retry from scratch + trace: pkg_build: refine package collection/plan execution from scratch + trace: collect_build: add tvz/1.0.0 + trace: collect_build_prerequisites: begin tvz/1.0.0 + trace: collect_build: add toz/0.2.0 + info: package tvz dependency on (toz == 0.2.0) is forcing upgrade of toz/0.1.0 to 0.2.0 + trace: collect_build_prerequisites: cfg-postpone dependency toz/0.2.0 of dependent tvz/1.0.0 + trace: postponed_configurations::add: create {tvz | toz->{tvz/1,1}} + trace: collect_build_prerequisites: postpone tvz/1.0.0 + trace: collect_build_postponed (0): begin + trace: collect_build_postponed (1): begin {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (1): skip unsatisfied existing dependent tez of dependency toz/0.2.0 due to constraint (toz == 0.1.0) + trace: collect_build_postponed (1): cfg-negotiate begin {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: begin toz/0.2.0 + trace: collect_build: add libfoo/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent toz/0.2.0 + trace: postponed_configurations::add: create {toz | libfoo->{toz/1,1}} + trace: collect_build_prerequisites: postpone toz/0.2.0 + trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tvz/1.0.0 + trace: collect_build_prerequisites: resume tvz/1.0.0 + trace: collect_build_prerequisites: end tvz/1.0.0 + trace: collect_build_postponed (1): cfg-negotiate end {tvz | toz->{tvz/1,1}}! + trace: collect_build_postponed (2): begin {toz | libfoo->{toz/1,1}} + trace: collect_build_prerequisites: pre-reeval tex/1.0.0 + trace: collect_build_prerequisites: pre-reevaluated tex/1.0.0: 1,1 + trace: collect_build_prerequisites: pre-reeval bax/1.0.0 + trace: collect_build_prerequisites: pre-reevaluated bax/1.0.0: 1,1 + trace: collect_build_postponed (2): skip dep-postponed existing dependent tex of dependency libfoo + trace: collect_build: add tex/1.0.0 + trace: collect_build_postponed (2): re-evaluate existing dependents for {toz | libfoo->{toz/1,1}} + trace: collect_build: add bax/1.0.0 + trace: collect_build_prerequisites: reeval bax/1.0.0 + trace: postponed_configurations::add: add {bax^ 1,1: libfoo} to {toz | libfoo->{toz/1,1}} + trace: collect_build_prerequisites: re-evaluating dependent bax/1.0.0 results in {bax^ toz | libfoo->{bax/1,1 toz/1,1}} + trace: collect_build_prerequisites: re-evaluated bax/1.0.0 + trace: collect_build_postponed (2): cfg-negotiate begin {bax^ toz | libfoo->{bax/1,1 toz/1,1}} + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: skip configured libfoo/1.0.0 + trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent bax/1.0.0 + trace: collect_build_prerequisites: resume bax/1.0.0 + trace: collect_build: add libbox/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent bax/1.0.0 + trace: collect_build: add libbar/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bax/1.0.0 + trace: postponed_configurations::add: create {bax | libbox->{bax/2,1} libbar->{bax/2,1}} + trace: collect_build_prerequisites: postpone bax/1.0.0 + trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent toz/0.2.0 + trace: collect_build_prerequisites: resume toz/0.2.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent toz/0.2.0 + trace: postponed_configurations::add: add {toz 2,1: libbar} to {bax | libbox->{bax/2,1} libbar->{bax/2,1}} + trace: collect_build_prerequisites: postpone toz/0.2.0 + trace: collect_build_postponed (2): cfg-negotiate end {bax^ toz | libfoo->{bax/1,1 toz/1,1}}! + trace: collect_build_postponed (3): begin {bax toz | libbox->{bax/2,1} libbar->{bax/2,1 toz/2,1}} + trace: collect_build_postponed (3): skip being built existing dependent bax of dependency libbox + trace: collect_build_prerequisites: pre-reeval tez/1.0.0 + trace: collect_build_prerequisites: re-evaluation of dependent tez/1.0.0 deviated for depends clause 2: now cannot select alternative, previously 1 was selected + trace: collect_build_postponed (3): schedule re-collection of deviated existing dependent tez/1.0.0 + trace: collect_build: add tez/1.0.0 + trace: collect_build_prerequisites: pre-reeval tex/1.0.0 + trace: collect_build_prerequisites: pre-reevaluated tex/1.0.0: 1,1 + trace: collect_build_postponed (3): skip being built existing dependent bax of dependency libbar + trace: collect_build_prerequisites: pre-reeval tiz/1.0.0 + trace: collect_build_prerequisites: pre-reevaluated tiz/1.0.0: 1,1 + trace: collect_build_postponed (3): skip being built existing dependent tez of dependency libbar + trace: collect_build_postponed (3): skip dep-postponed existing dependent tex of dependency libbar + trace: collect_build_postponed (3): re-evaluate existing dependents for {bax toz | libbox->{bax/2,1} libbar->{bax/2,1 toz/2,1}} + trace: collect_build: add tiz/1.0.0 + trace: collect_build_prerequisites: reeval tiz/1.0.0 + trace: postponed_configurations::add: create {tiz^ | tex->{tiz/1,1}} + trace: collect_build_prerequisites: re-evaluating dependent tiz/1.0.0 results in {tiz^ | tex->{tiz/1,1}} + trace: collect_build_prerequisites: re-evaluated tiz/1.0.0 + trace: collect_build_postponed (3): cfg-negotiate begin {bax toz | libbox->{bax/2,1} libbar->{bax/2,1 toz/2,1}} + trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: skip configured libbox/1.0.0 + trace: collect_build_prerequisites: skip configured libbar/1.0.0 + trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent bax/1.0.0 + trace: collect_build_prerequisites: resume bax/1.0.0 + trace: collect_build_prerequisites: end bax/1.0.0 + trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent toz/0.2.0 + trace: collect_build_prerequisites: resume toz/0.2.0 + trace: collect_build_prerequisites: end toz/0.2.0 + trace: collect_build_postponed (3): cfg-negotiate end {bax toz | libbox->{bax/2,1} libbar->{bax/2,1 toz/2,1}}! + trace: collect_build_prerequisites: begin tez/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent tez/1.0.0 + trace: postponed_configurations::add: add {tez 1,1: libbox} to {bax toz | libbox->{bax/2,1} libbar->{bax/2,1 toz/2,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tez/1.0.0 is negotiated + trace: collect_build_prerequisites: dependency libbox/1.0.0 of dependent tez/1.0.0 is already (being) recursively collected, skipping + trace: collect_build: postpone failure for dependent tez unsatisfied with dependency toz/0.2.0 (== 0.1.0) + trace: collect_build: pick toz/0.2.0 over toz/0.1.0 + trace: collect_build_prerequisites: cfg-postpone dependency toz/0.2.0 of dependent tez/1.0.0 + trace: postponed_configurations::add: add {tez 2,1: toz} to {tvz | toz->{tvz/1,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tez/1.0.0 is negotiated + trace: collect_build_prerequisites: dependency toz/0.2.0 of dependent tez/1.0.0 is already (being) recursively collected, skipping + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tez/1.0.0 + trace: postponed_configurations::add: add {tez 3,1: libbar} to {bax tez toz | libbox->{bax/2,1 tez/1,1} libbar->{bax/2,1 toz/2,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tez/1.0.0 is negotiated + trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent tez/1.0.0 is already (being) recursively collected, skipping + trace: collect_build_prerequisites: end tez/1.0.0 + trace: collect_build_postponed (4): begin {tiz^ | tex->{tiz/1,1}} + trace: collect_build_postponed (4): skip being built existing dependent tiz of dependency tex + trace: collect_build_postponed (4): cfg-negotiate begin {tiz^ | tex->{tiz/1,1}} + trace: collect_build_postponed (4): recursively collect cfg-negotiated dependencies + trace: collect_build_prerequisites: begin tex/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tex/1.0.0 + trace: postponed_configurations::add: add {tex 1,1: libbar} to {bax tez toz | libbox->{bax/2,1 tez/1,1} libbar->{bax/2,1 tez/3,1 toz/2,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tex/1.0.0 is negotiated + trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent tex/1.0.0 is already (being) recursively collected, skipping + trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent tex/1.0.0 + trace: postponed_configurations::add: add {tex 2,1: libfoo} to {bax^ toz | libfoo->{bax/1,1 toz/1,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tex/1.0.0 is negotiated + trace: collect_build_prerequisites: dependency libfoo/1.0.0 of dependent tex/1.0.0 is already (being) recursively collected, skipping + trace: collect_build_prerequisites: end tex/1.0.0 + trace: collect_build_postponed (4): recursively collect cfg-negotiated dependents + trace: collect_build_postponed (4): select cfg-negotiated dependency alternative for dependent tiz/1.0.0 + trace: collect_build_prerequisites: resume tiz/1.0.0 + trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tiz/1.0.0 + trace: postponed_configurations::add: add {tiz 2,1: libbar} to {bax tex tez toz | libbox->{bax/2,1 tez/1,1} libbar->{bax/2,1 tex/1,1 tez/3,1 toz/2,1}}! + trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tiz/1.0.0 is negotiated + trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent tiz/1.0.0 is already (being) recursively collected, skipping + trace: collect_build_prerequisites: end tiz/1.0.0 + trace: collect_build_postponed (4): cfg-negotiate end {tiz^ | tex->{tiz/1,1}}! + trace: collect_build_postponed (4): end {tiz^ | tex->{tiz/1,1}} + trace: collect_build_postponed (3): end {bax toz | libbox->{bax/2,1} libbar->{bax/2,1 toz/2,1}} + trace: collect_build_postponed (2): end {toz | libfoo->{toz/1,1}} + trace: collect_build_postponed (1): end {tvz | toz->{tvz/1,1}} + trace: collect_build_postponed (0): end + trace: execute_plan: simulate: yes + %.* + trace: pkg_build: try to replace unsatisfactory dependency toz/0.2.0 with some other version + trace: try_replace_dependent: try to replace unsatisfied dependent tez/1.0.0 of dependency toz/0.2.0 with some other version + trace: try_replace_dependent: try to replace conflicting dependent tvz/1.0.0 of dependency toz/0.2.0 with some other version + trace: try_replace_dependency: replacement tvz/0.1.0 tried earlier for same command line, skipping error: unable to satisfy constraints on package toz info: tvz/1.0.0 depends on (toz == 0.2.0) info: tez/1.0.0 depends on (toz == 0.1.0) @@ -18972,6 +21210,7 @@ test.arguments += --sys-no-query info: available toz/0.1.0 info: while satisfying tez/1.0.0 info: explicitly specify toz version to manually satisfy both constraints + %.* EOE $pkg_drop bax tiz tez diff --git a/tests/pkg-build/t4k b/tests/pkg-build/t4k new file mode 120000 index 0000000..a4fa90c --- /dev/null +++ b/tests/pkg-build/t4k @@ -0,0 +1 @@ +../common/satisfy/t4k \ No newline at end of file -- cgit v1.1