END_TEST
START_TEST(test_goal_installonly_limit_with_modules)
{
// most complex installonly test case, includes the k-m packages
const char *installonly[] = {"k", "k-m", NULL};
HySack sack = test_globals.sack;
hy_sack_set_installonly(sack, installonly);
hy_sack_set_installonly_limit(sack, 3);
sack->running_kernel_fn = mock_running_kernel;
HyGoal goal = hy_goal_create(sack);
hy_goal_upgrade_all(goal);
fail_if(hy_goal_run_flags(goal, 0));
assert_iueo(goal, 2, 0, 5, 0);
HyPackageList erasures = hy_goal_list_erasures(goal);
assert_nevra_eq(hy_packagelist_get(erasures, 0), "k-1-0.x86_64");
assert_nevra_eq(hy_packagelist_get(erasures, 1), "k-m-1-0.x86_64");
assert_nevra_eq(hy_packagelist_get(erasures, 2), "k-freak-1-0-1-0.x86_64");
assert_nevra_eq(hy_packagelist_get(erasures, 3), "k-2-0.x86_64");
assert_nevra_eq(hy_packagelist_get(erasures, 4), "k-m-2-0.x86_64");
hy_packagelist_free(erasures);
hy_goal_free(goal);
}
END_TEST
START_TEST(test_goal_unneeded)
{
HySack sack = test_globals.sack;
HyGoal goal = hy_goal_create(sack);
userinstalled(sack, goal, "baby");
userinstalled(sack, goal, "dog");
userinstalled(sack, goal, "fool");
userinstalled(sack, goal, "gun");
userinstalled(sack, goal, "jay");
userinstalled(sack, goal, "penny");
userinstalled(sack, goal, "pilchard");
hy_goal_run(goal);
HyPackageList plist = hy_goal_list_unneeded(goal);
ck_assert_int_eq(hy_packagelist_count(plist), 4);
HyPackage pkg = hy_packagelist_get(plist, 0);
assert_nevra_eq(pkg, "flying-2-9.noarch");
pkg = hy_packagelist_get(plist, 1);
assert_nevra_eq(pkg, "penny-lib-4-1.x86_64");
hy_packagelist_free(plist);
hy_goal_free(goal);
}
END_TEST
START_TEST(test_goal_downgrade)
{
HySack sack = test_globals.sack;
HyPackage to_be_pkg = get_available_pkg(sack, "baby");
HyGoal goal = hy_goal_create(sack);
hy_goal_downgrade_to(goal, to_be_pkg);
fail_if(hy_goal_run(goal));
assert_iueo(goal, 0, 0, 0, 0);
HyPackageList plist = hy_goal_list_downgrades(goal);
fail_unless(hy_packagelist_count(plist) == 1);
HyPackage pkg = hy_packagelist_get(plist, 0);
ck_assert_str_eq(hy_package_get_evr(pkg),
"6:4.9-3");
HyPackageList obsoleted = hy_goal_list_obsoleted_by_package(goal, pkg);
fail_unless(hy_packagelist_count(obsoleted) == 1);
HyPackage old_pkg = hy_packagelist_get(obsoleted, 0);
ck_assert_str_eq(hy_package_get_evr(old_pkg),
"6:5.0-11");
hy_packagelist_free(obsoleted);
hy_packagelist_free(plist);
hy_goal_free(goal);
hy_package_free(to_be_pkg);
}
static void update(HySack sack, HyPackage pkg)
{
HyGoal goal = hy_goal_create(sack);
if (hy_goal_upgrade_to_flags(goal, pkg, HY_CHECK_INSTALLED)) {
printf("no package of that name installed, trying install\n");
hy_goal_install(goal, pkg);
}
if (hy_goal_run(goal)) {
dump_goal_errors(goal);
// handle errors
goto finish;
}
// handle upgrades
HyPackageList plist = hy_goal_list_upgrades(goal);
printf("upgrade count: %d\n", hy_packagelist_count(plist));
for (int i = 0; i < hy_packagelist_count(plist); ++i) {
HyPackage pkg = hy_packagelist_get(plist, i);
char *nvra = hy_package_get_nevra(pkg);
char *location = hy_package_get_location(pkg);
HyPackageList obsoleted = hy_goal_list_obsoleted_by_package(goal, pkg);
HyPackage installed = hy_packagelist_get(obsoleted, 0);
char *nvra_installed = hy_package_get_nevra(installed);
printf("upgrading: %s using %s\n", nvra, location);
printf("\tfrom: %s\n", nvra_installed);
printf("\tsize: %lld kB\n", hy_package_get_size(pkg) / 1024);
hy_free(nvra_installed);
hy_packagelist_free(obsoleted);
hy_free(location);
hy_free(nvra);
}
hy_packagelist_free(plist);
// handle installs
plist = hy_goal_list_installs(goal);
printf("install count: %d\n", hy_packagelist_count(plist));
for (int i = 0; i < hy_packagelist_count(plist); ++i) {
HyPackage pkg = hy_packagelist_get(plist, i);
char *nvra = hy_package_get_nevra(pkg);
char *location = hy_package_get_location(pkg);
printf("installing: %s using %s\n", nvra, location);
printf("\tsize: %lld kB\n", hy_package_get_size(pkg) / 1024);
hy_free(location);
hy_free(nvra);
}
hy_packagelist_free(plist);
finish:
hy_goal_free(goal);
}
END_TEST
START_TEST(test_goal_selector_upgrade)
{
HySelector sltr = hy_selector_create(test_globals.sack);
HyGoal goal = hy_goal_create(test_globals.sack);
fail_if(hy_selector_set(sltr, HY_PKG_NAME, HY_EQ, "dog"));
fail_if(hy_selector_set(sltr, HY_PKG_EVR, HY_EQ, "1-2"));
fail_if(hy_goal_upgrade_to_selector(goal, sltr));
fail_if(hy_goal_run(goal));
HyPackageList plist = hy_goal_list_upgrades(goal);
fail_unless(hy_packagelist_count(plist) == 1);
assert_nevra_eq(hy_packagelist_get(plist, 0), "dog-1-2.x86_64");
hy_packagelist_free(plist);
hy_goal_free(goal);
hy_selector_free(sltr);
sltr = hy_selector_create(test_globals.sack);
goal = hy_goal_create(test_globals.sack);
fail_if(hy_selector_set(sltr, HY_PKG_NAME, HY_EQ, "pilchard"));
fail_if(hy_goal_upgrade_to_selector(goal, sltr));
fail_if(hy_goal_run(goal));
assert_iueo(goal, 0, 2, 0, 0);
hy_goal_free(goal);
hy_selector_free(sltr);
}
END_TEST
START_TEST(test_goal_distupgrade_all_keep_arch)
{
HyGoal goal = hy_goal_create(test_globals.sack);
fail_if(hy_goal_distupgrade_all(goal));
fail_if(hy_goal_run(goal));
assert_iueo(goal, 0, 5, 0, 1);
HyPackageList plist = hy_goal_list_upgrades(goal);
// gun pkg is not upgraded to latest version of different arch
assert_nevra_eq(hy_packagelist_get(plist, 0), "dog-1-2.x86_64");
assert_nevra_eq(hy_packagelist_get(plist, 1), "pilchard-1.2.4-1.i686");
assert_nevra_eq(hy_packagelist_get(plist, 2), "pilchard-1.2.4-1.x86_64");
assert_nevra_eq(hy_packagelist_get(plist, 3), "flying-3.1-0.x86_64");
assert_nevra_eq(hy_packagelist_get(plist, 4), "fool-1-5.noarch");
hy_packagelist_free(plist);
plist = hy_goal_list_obsoleted(goal);
fail_unless(hy_packagelist_count(plist) == 1);
assert_nevra_eq(hy_packagelist_get(plist, 0), "penny-4-1.noarch");
hy_packagelist_free(plist);
plist = hy_goal_list_downgrades(goal);
fail_unless(hy_packagelist_count(plist) == 1);
assert_nevra_eq(hy_packagelist_get(plist, 0), "baby-6:4.9-3.x86_64");
hy_packagelist_free(plist);
hy_goal_free(goal);
}
END_TEST
START_TEST(test_goal_distupgrade_all)
{
HyGoal goal = hy_goal_create(test_globals.sack);
fail_if(hy_goal_distupgrade_all(goal));
fail_if(hy_goal_run(goal));
assert_iueo(goal, 0, 1, 0, 0);
HyPackageList plist = hy_goal_list_upgrades(goal);
assert_nevra_eq(hy_packagelist_get(plist, 0), "flying-3-0.noarch");
hy_packagelist_free(plist);
plist = hy_goal_list_downgrades(goal);
fail_unless(hy_packagelist_count(plist) == 1);
assert_nevra_eq(hy_packagelist_get(plist, 0), "baby-6:4.9-3.x86_64");
hy_packagelist_free(plist);
hy_goal_free(goal);
}
static void execute_print(HySack sack, HyQuery q, int show_obsoletes)
{
HyPackageList plist;
plist = hy_query_run(q);
const int count = hy_packagelist_count(plist);
for (int i = 0; i < count; ++i) {
HyPackage pkg = hy_packagelist_get(plist, i);
char *nvra = hy_package_get_nevra(pkg);
const char *reponame = hy_package_get_reponame(pkg);
printf("found package: %s [%s]\n", nvra, reponame);
if (strcmp(reponame, HY_SYSTEM_REPO_NAME) == 0) {
int type;
const unsigned char * hdrid = hy_package_get_hdr_chksum(pkg, &type);
char *str = hy_chksum_str(hdrid, type);
printf("\tsha1 header id: %s\n", str);
hy_free(str);
}
if (show_obsoletes) {
HyReldepList obsoletes = hy_package_get_obsoletes(pkg);
HyQuery qobs = hy_query_create(sack);
hy_query_filter(qobs, HY_PKG_REPONAME, HY_NEQ, HY_SYSTEM_REPO_NAME);
hy_query_filter_reldep_in(qobs, HY_PKG_PROVIDES, obsoletes);
HyPackageList olist = hy_query_run(qobs);
const int ocount = hy_packagelist_count(olist);
for (int j = 0; j < ocount; ++j) {
HyPackage opkg = hy_packagelist_get(olist, j);
char *onvra = hy_package_get_nevra(opkg);
printf("obsoleting: %s\n", onvra);
hy_free(onvra);
}
hy_packagelist_free(olist);
hy_query_free(qobs);
hy_reldeplist_free(obsoletes);
}
hy_free(nvra);
}
hy_packagelist_free(plist);
}
END_TEST
START_TEST(test_filter_latest2)
{
HyQuery q = hy_query_create(test_globals.sack);
hy_query_filter(q, HY_PKG_NAME, HY_EQ, "flying");
hy_query_filter_latest_per_arch(q, 1);
HyPackageList plist = hy_query_run(q);
fail_unless(hy_packagelist_count(plist) == 2);
HyPackage pkg = hy_packagelist_get(plist, 0);
fail_if(strcmp(hy_package_get_name(pkg), "flying"));
fail_if(strcmp(hy_package_get_evr(pkg), "3.1-0"));
pkg = hy_packagelist_get(plist, 1);
fail_if(strcmp(hy_package_get_name(pkg), "flying"));
fail_if(strcmp(hy_package_get_evr(pkg), "3.2-0"));
hy_query_free(q);
hy_packagelist_free(plist);
}
END_TEST
START_TEST(test_query_provides_in)
{
HyPackage pkg;
HyPackageList plist;
char* pkg_names[] = { "P", "fool <= 2.0", "fool-lib > 3-3", NULL };
HyQuery q = hy_query_create(test_globals.sack);
hy_query_filter_provides_in(q, pkg_names);
plist = hy_query_run(q);
pkg = hy_packagelist_get(plist, 0);
ck_assert_str_eq(hy_package_get_name(pkg), "fool");
ck_assert_str_eq(hy_package_get_evr(pkg), "1-3");
pkg = hy_packagelist_get(plist, 1);
ck_assert_str_eq(hy_package_get_name(pkg), "penny");
pkg = hy_packagelist_get(plist, 2);
ck_assert_str_eq(hy_package_get_name(pkg), "fool");
ck_assert_str_eq(hy_package_get_evr(pkg), "1-5");
fail_unless(size_and_free(q) == 3);
hy_packagelist_free(plist);
}
static void
erase(HySack sack, const char *name)
{
HyQuery q = hy_query_create(sack);
hy_query_filter(q, HY_PKG_NAME, HY_EQ, name);
hy_query_filter(q, HY_PKG_REPONAME, HY_EQ, HY_SYSTEM_REPO_NAME);
HyPackageList plist = hy_query_run(q);
if (hy_packagelist_count(plist) < 1) {
printf("No installed package to erase found.\n");
goto finish;
}
if (hy_packagelist_count(plist) > 1)
printf("(more than one updatables found, selecting the first one)\n");
HyGoal goal = hy_goal_create(sack);
hy_goal_erase(goal, hy_packagelist_get(plist, 0));
if (hy_goal_run(goal)) {
dump_goal_errors(goal);
hy_goal_free(goal);
goto finish;
}
hy_packagelist_free(plist);
plist = hy_goal_list_erasures(goal);
printf("erasure count: %d\n", hy_packagelist_count(plist));
for (int i = 0; i < hy_packagelist_count(plist); ++i) {
HyPackage pkg = hy_packagelist_get(plist, i);
char *nvra = hy_package_get_nevra(pkg);
printf("erasing %s\n", nvra);
hy_free(nvra);
}
hy_goal_free(goal);
finish:
hy_packagelist_free(plist);
hy_query_free(q);
}
END_TEST
START_TEST(test_query_supplements)
{
HyPackageList plist;
HyPackage pkg;
HyQuery q = hy_query_create(test_globals.sack);
hy_query_filter(q, HY_PKG_SUPPLEMENTS, HY_EQ, "flying");
plist = hy_query_run(q);
pkg = hy_packagelist_get(plist, 0);
ck_assert_str_eq(hy_package_get_name(pkg), "baby");
hy_query_free(q);
hy_packagelist_free(plist);
}
END_TEST
START_TEST(test_goal_installonly_limit)
{
const char *installonly[] = {"k", NULL};
HySack sack = test_globals.sack;
hy_sack_set_installonly(sack, installonly);
hy_sack_set_installonly_limit(sack, 3);
sack->running_kernel_fn = mock_running_kernel_no;
HyGoal goal = hy_goal_create(sack);
hy_goal_upgrade_all(goal);
fail_if(hy_goal_run_flags(goal, 0));
assert_iueo(goal, 1, 1, 3, 0); // k-m is just upgraded
HyPackageList erasures = hy_goal_list_erasures(goal);
assert_nevra_eq(hy_packagelist_get(erasures, 0), "k-1-0.x86_64");
assert_nevra_eq(hy_packagelist_get(erasures, 1), "k-freak-1-0-1-0.x86_64");
assert_nevra_eq(hy_packagelist_get(erasures, 2), "k-1-1.x86_64");
hy_packagelist_free(erasures);
hy_goal_free(goal);
}
END_TEST
START_TEST(test_query_enhances)
{
HyPackageList plist;
HyPackage pkg;
HyQuery q = hy_query_create(test_globals.sack);
hy_query_filter(q, HY_PKG_ENHANCES, HY_EQ, "flying");
plist = hy_query_run(q);
pkg = hy_packagelist_get(plist, 0);
ck_assert_str_eq(hy_package_get_name(pkg), "walrus");
hy_query_free(q);
hy_packagelist_free(plist);
}
END_TEST
START_TEST(test_downgrade)
{
HyQuery q = hy_query_create(test_globals.sack);
hy_query_filter(q, HY_PKG_NAME, HY_EQ, "jay");
hy_query_filter_downgrades(q, 1);
HyPackageList plist = hy_query_run(q);
fail_unless(hy_packagelist_count(plist) == 1);
HyPackage pkg = hy_packagelist_get(plist, 0);
ck_assert_str_eq(hy_package_get_evr(pkg), "4.9-0");
hy_query_free(q);
hy_packagelist_free(plist);
}
END_TEST
START_TEST(test_query_nevra_glob)
{
HySack sack = test_globals.sack;
HyQuery q;
HyPackageList plist;
q = hy_query_create(sack);
hy_query_filter(q, HY_PKG_NEVRA, HY_GLOB, "p*4-1*");
plist = hy_query_run(q);
ck_assert_int_eq(hy_packagelist_count(plist), 2);
HyPackage pkg1 = hy_packagelist_get(plist, 0);
HyPackage pkg2 = hy_packagelist_get(plist, 1);
char *nevra1 = hy_package_get_nevra(pkg1);
char *nevra2 = hy_package_get_nevra(pkg2);
ck_assert_str_eq(nevra1, "penny-4-1.noarch");
ck_assert_str_eq(nevra2, "penny-lib-4-1.x86_64");
solv_free(nevra1);
solv_free(nevra2);
hy_packagelist_free(plist);
hy_query_free(q);
}
END_TEST
START_TEST(test_goal_install_selector_file)
{
HySack sack = test_globals.sack;
HySelector sltr = hy_selector_create(sack);
HyGoal goal = hy_goal_create(sack);
fail_if(hy_selector_set(sltr, HY_PKG_FILE, HY_EQ|HY_GLOB, "/*/answers"));
fail_if(hy_goal_erase_selector(goal, sltr));
fail_if(hy_goal_run(goal));
assert_iueo(goal, 0, 0, 1, 0);
HyPackageList plist = hy_goal_list_erasures(goal);
HyPackage pkg = hy_packagelist_get(plist, 0);
ck_assert_str_eq("fool", hy_package_get_name(pkg));
hy_selector_free(sltr);
hy_packagelist_free(plist);
hy_goal_free(goal);
}
END_TEST
START_TEST(test_goal_distupgrade_selector_upgrade)
{
HyGoal goal = hy_goal_create(test_globals.sack);
HySelector sltr = hy_selector_create(test_globals.sack);
hy_selector_set(sltr, HY_PKG_NAME, HY_EQ, "flying");
fail_if(hy_goal_distupgrade_selector(goal, sltr));
fail_if(hy_goal_run(goal));
assert_iueo(goal, 0, 1, 0, 0);
HyPackageList plist = hy_goal_list_upgrades(goal);
assert_nevra_eq(hy_packagelist_get(plist, 0), "flying-3-0.noarch");
hy_packagelist_free(plist);
hy_goal_free(goal);
hy_selector_free(sltr);
}
END_TEST
START_TEST(test_goal_distupgrade_selector_downgrade)
{
HyGoal goal = hy_goal_create(test_globals.sack);
HySelector sltr = hy_selector_create(test_globals.sack);
hy_selector_set(sltr, HY_PKG_NAME, HY_EQ, "baby");
fail_if(hy_goal_distupgrade_selector(goal, sltr));
fail_if(hy_goal_run(goal));
assert_iueo(goal, 0, 0, 0, 0);
HyPackageList plist = hy_goal_list_downgrades(goal);
fail_unless(hy_packagelist_count(plist) == 1);
assert_nevra_eq(hy_packagelist_get(plist, 0), "baby-6:4.9-3.x86_64");
hy_packagelist_free(plist);
hy_goal_free(goal);
hy_selector_free(sltr);
}
END_TEST
static void
assert_list_names(HyPackageList plist, ...)
{
va_list names;
char *name;
int count = hy_packagelist_count(plist), i = 0;
va_start(names, plist);
while ((name = va_arg(names, char *)) != NULL) {
if (i >= count)
fail("assert_list_names(): list too short");
HyPackage pkg = hy_packagelist_get(plist, i++);
ck_assert_str_eq(hy_package_get_name(pkg), name);
}
fail_unless(i == count, "assert_list_names(): too many items in the list");
va_end(names);
}
END_TEST
START_TEST(test_filter_files)
{
HyQuery q = hy_query_create(test_globals.sack);
hy_query_filter(q, HY_PKG_FILE, HY_EQ, "/etc/takeyouaway");
HyPackageList plist = hy_query_run(q);
fail_unless(hy_packagelist_count(plist) == 1);
HyPackage pkg = hy_packagelist_get(plist, 0);
fail_if(strcmp(hy_package_get_name(pkg), "tour"));
hy_packagelist_free(plist);
hy_query_free(q);
q = hy_query_create(test_globals.sack);
hy_query_filter(q, HY_PKG_FILE, HY_GLOB, "/usr/*");
plist = hy_query_run(q);
fail_unless(hy_packagelist_count(plist) == 2);
hy_packagelist_free(plist);
hy_query_free(q);
}
static void update_remote(HySack sack, const char *name)
{
HyQuery q = hy_query_create(sack);
HyPackageList plist;
hy_query_filter(q, HY_PKG_NAME, HY_EQ, name);
hy_query_filter(q, HY_PKG_REPONAME, HY_NEQ, HY_SYSTEM_REPO_NAME);
hy_query_filter_latest_per_arch(q, 1);
plist = hy_query_run(q);
if (hy_packagelist_count(plist) == 0) {
printf("no updatables found\n");
goto finish;
}
if (hy_packagelist_count(plist) > 1)
printf("(more than one updatables found, selecting the first one)\n");
update(sack, hy_packagelist_get(plist, 0));
finish:
hy_packagelist_free(plist);
hy_query_free(q);
}
END_TEST
START_TEST(test_goal_get_reason_selector)
{
HySelector sltr = hy_selector_create(test_globals.sack);
HyGoal goal = hy_goal_create(test_globals.sack);
fail_if(hy_selector_set(sltr, HY_PKG_NAME, HY_EQ, "walrus"));
fail_if(hy_goal_install_selector(goal, sltr));
hy_selector_free(sltr);
fail_if(hy_goal_run(goal));
HyPackageList plist = hy_goal_list_installs(goal);
fail_unless(hy_packagelist_count(plist) == 2);
HyPackage pkg = hy_packagelist_get(plist, 0);
fail_unless(hy_goal_get_reason(goal, pkg) == HY_REASON_USER);
hy_packagelist_free(plist);
hy_goal_free(goal);
}
static GPtrArray *
query_all_packages_in_sack (RpmOstreeRefSack *rsack)
{
_cleanup_hyquery_ HyQuery hquery = NULL;
_cleanup_hypackagelist_ HyPackageList pkglist = NULL;
GPtrArray *result;
int i, c;
hquery = hy_query_create (rsack->sack);
hy_query_filter (hquery, HY_PKG_REPONAME, HY_EQ, HY_SYSTEM_REPO_NAME);
pkglist = hy_query_run (hquery);
result = g_ptr_array_new_with_free_func (g_object_unref);
c = hy_packagelist_count (pkglist);
for (i = 0; i < c; i++)
{
HyPackage pkg = hy_packagelist_get (pkglist, i);
g_ptr_array_add (result, _rpm_ostree_package_new (rsack, pkg));
}
return g_steal_pointer (&result);
}
END_TEST
START_TEST(test_goal_distupgrade_all_excludes)
{
HyQuery q = hy_query_create_flags(test_globals.sack, HY_IGNORE_EXCLUDES);
hy_query_filter_provides(q, HY_GT|HY_EQ, "flying", "0");
HyPackageSet pset = hy_query_run_set(q);
hy_sack_add_excludes(test_globals.sack, pset);
hy_packageset_free(pset);
hy_query_free(q);
HyGoal goal = hy_goal_create(test_globals.sack);
fail_if(hy_goal_distupgrade_all(goal));
fail_if(hy_goal_run(goal));
assert_iueo(goal, 0, 0, 0, 0);
HyPackageList plist = hy_goal_list_downgrades(goal);
fail_unless(hy_packagelist_count(plist) == 1);
assert_nevra_eq(hy_packagelist_get(plist, 0), "baby-6:4.9-3.x86_64");
hy_packagelist_free(plist);
hy_goal_free(goal);
}
uint32_t
TDNFTransAddErasePkgs(
PTDNFRPMTS pTS,
PTDNF pTdnf
)
{
uint32_t dwError = 0;
int i = 0;
HyPackage hPkg = NULL;
HyPackageList hPkgList = NULL;
hPkgList = hy_goal_list_erasures(pTdnf->hGoal);
if(!hPkgList)
{
dwError = ERROR_TDNF_NO_DATA;
BAIL_ON_TDNF_ERROR(dwError);
}
for(i = 0; (hPkg = hy_packagelist_get(hPkgList, i)) != NULL; ++i)
{
dwError = TDNFTransAddErasePkg(pTS, hPkg);
BAIL_ON_TDNF_ERROR(dwError);
}
cleanup:
if(hPkgList)
{
hy_packagelist_free(hPkgList);
}
return dwError;
error:
if(dwError == ERROR_TDNF_NO_DATA)
{
dwError = 0;
}
goto cleanup;
}
END_TEST
START_TEST(test_goal_install_selector)
{
HySelector sltr;
HyGoal goal = hy_goal_create(test_globals.sack);
// test arch forcing
sltr = hy_selector_create(test_globals.sack);
hy_selector_set(sltr, HY_PKG_NAME, HY_EQ, "semolina");
hy_selector_set(sltr, HY_PKG_ARCH, HY_EQ, "i686");
fail_if(hy_goal_install_selector(goal, sltr));
hy_selector_free(sltr);
fail_if(hy_goal_run(goal));
assert_iueo(goal, 1, 0, 0, 0);
HyPackageList plist = hy_goal_list_installs(goal);
char *nvra = hy_package_get_nevra(hy_packagelist_get(plist, 0));
ck_assert_str_eq(nvra, "semolina-2-0.i686");
hy_free(nvra);
hy_packagelist_free(plist);
hy_goal_free(goal);
}
/**
* rpm_ostree_db_diff:
* @repo: An OSTree repository
* @orig_ref: Original ref (branch or commit)
* @new_ref: New ref (branch or commit)
* @out_removed: (out) (transfer container) (element-type RpmOstreePackage): Return location for removed packages
* @out_added: (out) (transfer container) (element-type RpmOstreePackage): Return location for added packages
* @out_modified_old: (out) (transfer container) (element-type RpmOstreePackage): Return location for modified old packages
* @out_modified_new: (out) (transfer container) (element-type RpmOstreePackage): Return location for modified new packages
*
* Compute the RPM package delta between two commits. Currently you
* must use %NULL for the @query parameter; in a future version this
* function may allow looking at a subset of the packages.
*
* The @out_modified_old and @out_modified_new arrays will always be
* the same length, and indicies will refer to the same base package
* name. It is possible in RPM databases to have multiple packages
* installed with the same name; in this case, the behavior will
* depend on whether the package set is transitioning from 1 -> N or N
* -> 1. In the former case, an arbitrary single instance of one of
* the new packages will be in @out_modified_new. If the latter, then
* multiple entries with the same name will be returned in
* the array @out_modified_old, with each having a reference to the
* single corresponding new package.
*/
gboolean
rpm_ostree_db_diff (OstreeRepo *repo,
const char *orig_ref,
const char *new_ref,
GPtrArray **out_removed,
GPtrArray **out_added,
GPtrArray **out_modified_old,
GPtrArray **out_modified_new,
GCancellable *cancellable,
GError **error)
{
gboolean ret = FALSE;
g_autoptr(RpmOstreeRefSack) orig_sack = NULL;
g_autoptr(RpmOstreeRefSack) new_sack = NULL;
_cleanup_hypackagelist_ HyPackageList orig_pkglist = NULL;
_cleanup_hypackagelist_ HyPackageList new_pkglist = NULL;
g_autoptr(GPtrArray) ret_removed = g_ptr_array_new_with_free_func (g_object_unref);
g_autoptr(GPtrArray) ret_added = g_ptr_array_new_with_free_func (g_object_unref);
g_autoptr(GPtrArray) ret_modified_old = g_ptr_array_new_with_free_func (g_object_unref);
g_autoptr(GPtrArray) ret_modified_new = g_ptr_array_new_with_free_func (g_object_unref);
guint i;
HyPackage pkg;
g_return_val_if_fail (out_removed != NULL && out_added != NULL &&
out_modified_old != NULL && out_modified_new != NULL, FALSE);
orig_sack = _rpm_ostree_get_refsack_for_commit (repo, orig_ref, cancellable, error);
if (!orig_sack)
goto out;
{ _cleanup_hyquery_ HyQuery query = hy_query_create (orig_sack->sack);
hy_query_filter (query, HY_PKG_REPONAME, HY_EQ, HY_SYSTEM_REPO_NAME);
orig_pkglist = hy_query_run (query);
}
new_sack = _rpm_ostree_get_refsack_for_commit (repo, new_ref, cancellable, error);
if (!new_sack)
goto out;
{ _cleanup_hyquery_ HyQuery query = hy_query_create (new_sack->sack);
hy_query_filter (query, HY_PKG_REPONAME, HY_EQ, HY_SYSTEM_REPO_NAME);
new_pkglist = hy_query_run (query);
}
FOR_PACKAGELIST(pkg, new_pkglist, i)
{
_cleanup_hyquery_ HyQuery query = NULL;
_cleanup_hypackagelist_ HyPackageList pkglist = NULL;
guint count;
HyPackage oldpkg;
query = hy_query_create (orig_sack->sack);
hy_query_filter (query, HY_PKG_NAME, HY_EQ, hy_package_get_name (pkg));
hy_query_filter (query, HY_PKG_EVR, HY_NEQ, hy_package_get_evr (pkg));
hy_query_filter (query, HY_PKG_REPONAME, HY_EQ, HY_SYSTEM_REPO_NAME);
pkglist = hy_query_run (query);
count = hy_packagelist_count (pkglist);
if (count > 0)
{
/* See comment above about transitions from N -> 1 */
oldpkg = hy_packagelist_get (pkglist, 0);
g_ptr_array_add (ret_modified_old, _rpm_ostree_package_new (orig_sack, oldpkg));
g_ptr_array_add (ret_modified_new, _rpm_ostree_package_new (new_sack, pkg));
}
}
uint32_t
TDNFGoal(
PTDNF pTdnf,
HyPackageList hPkgList,
HySelector hSelector,
TDNF_ALTERTYPE nResolveFor,
PTDNF_SOLVED_PKG_INFO pInfo
)
{
uint32_t dwError = 0;
HyGoal hGoal = NULL;
HyPackage hPkg = NULL;
PTDNF_PKG_INFO pPkgsToInstall = NULL;
PTDNF_PKG_INFO pPkgsToUpgrade = NULL;
PTDNF_PKG_INFO pPkgsToDowngrade = NULL;
PTDNF_PKG_INFO pPkgsToRemove = NULL;
PTDNF_PKG_INFO pPkgsUnNeeded = NULL;
PTDNF_PKG_INFO pPkgsToReinstall = NULL;
int nFlags = 0;
int nRequirePkgList =
(nResolveFor != ALTER_UPGRADEALL &&
nResolveFor != ALTER_DISTRO_SYNC);
if(!pTdnf || !pInfo )
{
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
if(nResolveFor == ALTER_UPGRADE && !hSelector)
{
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
if(nRequirePkgList)
{
if(!hPkgList)
{
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
hPkg = hy_packagelist_get(hPkgList, 0);
if(!hPkg)
{
dwError = ERROR_TDNF_PACKAGELIST_EMPTY;
BAIL_ON_TDNF_ERROR(dwError);
}
}
hGoal = hy_goal_create(pTdnf->hSack);
if(!hGoal)
{
dwError = ERROR_TDNF_GOAL_CREATE;
BAIL_ON_TDNF_ERROR(dwError);
}
switch(nResolveFor)
{
case ALTER_DOWNGRADE:
dwError = hy_goal_downgrade_to(hGoal, hPkg);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
break;
case ALTER_ERASE:
dwError = hy_goal_erase(hGoal, hPkg);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
break;
case ALTER_REINSTALL:
dwError = hy_goal_install(hGoal, hPkg);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
break;
case ALTER_INSTALL:
dwError = TDNFPackageGetLatest(hPkgList, &hPkg);
BAIL_ON_TDNF_ERROR(dwError);
dwError = hy_goal_install(hGoal, hPkg);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
break;
case ALTER_UPGRADE:
dwError = hy_goal_upgrade_to_selector(hGoal, hSelector);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
break;
case ALTER_UPGRADEALL:
dwError = hy_goal_upgrade_all(hGoal);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
break;
case ALTER_DISTRO_SYNC:
dwError = hy_goal_distupgrade_all(hGoal);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
break;
case ALTER_AUTOERASE:
dwError = TDNFGoalSetUserInstalled(hGoal, hPkgList);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
break;
default:
dwError = ERROR_TDNF_INVALID_RESOLVE_ARG;
BAIL_ON_TDNF_ERROR(dwError);
}
if(pTdnf->pArgs->nBest)
{
nFlags = nFlags | HY_FORCE_BEST;
}
if(pTdnf->pArgs->nAllowErasing ||
nResolveFor == ALTER_ERASE ||
nResolveFor == ALTER_AUTOERASE)
{
nFlags = nFlags | HY_ALLOW_UNINSTALL;
}
dwError = hy_goal_run_flags(hGoal, nFlags);
if(pTdnf->pArgs->nDebugSolver)
{
hy_goal_write_debugdata(hGoal, "debugdata");
}
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
dwError = TDNFGoalGetResultsIgnoreNoData(
hy_goal_list_installs(hGoal),
&pPkgsToInstall);
BAIL_ON_TDNF_ERROR(dwError);
dwError = TDNFGoalGetResultsIgnoreNoData(
hy_goal_list_upgrades(hGoal),
&pPkgsToUpgrade);
BAIL_ON_TDNF_ERROR(dwError);
dwError = TDNFGoalGetResultsIgnoreNoData(
hy_goal_list_downgrades(hGoal),
&pPkgsToDowngrade);
BAIL_ON_TDNF_ERROR(dwError);
dwError = TDNFGoalGetResultsIgnoreNoData(
hy_goal_list_erasures(hGoal),
&pPkgsToRemove);
BAIL_ON_TDNF_ERROR(dwError);
if(nResolveFor == ALTER_AUTOERASE)
{
dwError = TDNFGoalGetResultsIgnoreNoData(
hy_goal_list_unneeded(hGoal),
&pPkgsUnNeeded);
BAIL_ON_TDNF_ERROR(dwError);
}
dwError = TDNFGoalGetResultsIgnoreNoData(
hy_goal_list_reinstalls(hGoal),
&pPkgsToReinstall);
BAIL_ON_TDNF_ERROR(dwError);
pInfo->pPkgsToInstall = pPkgsToInstall;
pInfo->pPkgsToUpgrade = pPkgsToUpgrade;
pInfo->pPkgsToDowngrade = pPkgsToDowngrade;
pInfo->pPkgsToRemove = pPkgsToRemove;
pInfo->pPkgsUnNeeded = pPkgsUnNeeded;
pInfo->pPkgsToReinstall = pPkgsToReinstall;
pTdnf->hGoal = hGoal;
cleanup:
return dwError;
error:
if(hGoal)
{
TDNFGoalReportProblems(hGoal);
hy_goal_free(hGoal);
}
if(pPkgsToInstall)
{
TDNFFreePackageInfo(pPkgsToInstall);
}
if(pPkgsToUpgrade)
{
TDNFFreePackageInfo(pPkgsToUpgrade);
}
if(pPkgsToDowngrade)
{
TDNFFreePackageInfo(pPkgsToDowngrade);
}
if(pPkgsToRemove)
{
TDNFFreePackageInfo(pPkgsToRemove);
}
if(pPkgsUnNeeded)
{
TDNFFreePackageInfo(pPkgsUnNeeded);
}
if(pPkgsToReinstall)
{
TDNFFreePackageInfo(pPkgsToReinstall);
}
goto cleanup;
}
static gboolean
handle_remove_files_from_package (GFile *yumroot,
RpmOstreeRefSack *refsack,
JsonArray *removespec,
GCancellable *cancellable,
GError **error)
{
gboolean ret = FALSE;
const char *pkg = json_array_get_string_element (removespec, 0);
guint i, j, npackages;
guint len = json_array_get_length (removespec);
HyPackage hypkg;
_cleanup_hyquery_ HyQuery query = NULL;
_cleanup_hypackagelist_ HyPackageList pkglist = NULL;
query = hy_query_create (refsack->sack);
hy_query_filter (query, HY_PKG_NAME, HY_EQ, pkg);
pkglist = hy_query_run (query);
npackages = hy_packagelist_count (pkglist);
if (npackages == 0)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Unable to find package '%s' specified in remove-files-from", pkg);
goto out;
}
for (j = 0; j < npackages; j++)
{
_cleanup_hystringarray_ HyStringArray pkg_files = NULL;
hypkg = hy_packagelist_get (pkglist, 0);
pkg_files = hy_package_get_files (hypkg);
for (i = 1; i < len; i++)
{
const char *remove_regex_pattern = json_array_get_string_element (removespec, i);
GRegex *regex;
char **strviter;
regex = g_regex_new (remove_regex_pattern, G_REGEX_JAVASCRIPT_COMPAT, 0, error);
if (!regex)
goto out;
for (strviter = pkg_files; strviter && strviter[0]; strviter++)
{
const char *file = *strviter;
if (g_regex_match (regex, file, 0, NULL))
{
gs_unref_object GFile *child = NULL;
if (file[0] == '/')
file++;
child = g_file_resolve_relative_path (yumroot, file);
g_print ("Deleting: %s\n", file);
if (!gs_shutil_rm_rf (child, cancellable, error))
goto out;
}
}
}
}
ret = TRUE;
out:
return ret;
}
