From: Michael Tremer Date: Sun, 29 Jun 2025 15:49:53 +0000 (+0000) Subject: transaction: --> self X-Git-Url: http://git.ipfire.org/gitweb/gitweb.cgi?a=commitdiff_plain;h=e04c7be3a11f958b46ff9a1078b7fa86e09a9ceb;p=people%2Fms%2Fpakfire.git transaction: --> self Signed-off-by: Michael Tremer --- diff --git a/src/pakfire/transaction.c b/src/pakfire/transaction.c index cfcf9018..25538339 100644 --- a/src/pakfire/transaction.c +++ b/src/pakfire/transaction.c @@ -95,17 +95,17 @@ enum pakfire_steps { }; static enum pakfire_steps pakfire_transaction_get_step_type( - pakfire_transaction* transaction, pakfire_package* pkg) { + pakfire_transaction* self, pakfire_package* pkg) { const Id id = pakfire_package_id(pkg); const int flags = SOLVER_TRANSACTION_CHANGE_IS_REINSTALL; - int type = transaction_type(transaction->transaction, id, + int type = transaction_type(self->transaction, id, SOLVER_TRANSACTION_SHOW_ACTIVE|flags); // If this step is being ignored in active mode, we try passive mode if (type == SOLVER_TRANSACTION_IGNORE) - type = transaction_type(transaction->transaction, id, flags); + type = transaction_type(self->transaction, id, flags); // Translate solver types into our own types switch (type) { @@ -134,35 +134,34 @@ static enum pakfire_steps pakfire_transaction_get_step_type( return PAKFIRE_STEP_DOWNGRADED; default: - ERROR(transaction->ctx, + ERROR(self->ctx, "Unhandled step type 0x%x. Ignoring.\n", (unsigned int)type); return PAKFIRE_STEP_UNKNOWN; } } -static void pakfire_transaction_free_archives_and_packages( - pakfire_transaction* transaction) { - if (transaction->archives) { - for (unsigned int i = 0; i < transaction->num; i++) - if (transaction->archives[i]) - pakfire_archive_unref(transaction->archives[i]); - free(transaction->archives); +static void pakfire_transaction_free_archives_and_packages(pakfire_transaction* self) { + if (self->archives) { + for (unsigned int i = 0; i < self->num; i++) + if (self->archives[i]) + pakfire_archive_unref(self->archives[i]); + free(self->archives); - transaction->archives = NULL; + self->archives = NULL; } - if (transaction->packages) { - for (unsigned int i = 0; i < transaction->num; i++) - if (transaction->packages[i]) - pakfire_package_unref(transaction->packages[i]); - free(transaction->packages); + if (self->packages) { + for (unsigned int i = 0; i < self->num; i++) + if (self->packages[i]) + pakfire_package_unref(self->packages[i]); + free(self->packages); - transaction->packages = NULL; + self->packages = NULL; } } -static int pakfire_transaction_import_transaction(pakfire_transaction* transaction) { +static int pakfire_transaction_import_transaction(pakfire_transaction* self) { pakfire_package* pkg = NULL; int new_pkgs; Queue pkgs; @@ -172,65 +171,65 @@ static int pakfire_transaction_import_transaction(pakfire_transaction* transacti queue_init(&pkgs); // Clone the transaction to keep a copy of it - transaction->transaction = solver_create_transaction(transaction->solver); - if (!transaction->transaction) { - ERROR(transaction->ctx, "Could not create transaction from solver: %m\n"); + self->transaction = solver_create_transaction(self->solver); + if (!self->transaction) { + ERROR(self->ctx, "Could not create transaction from solver: %m\n"); r = -errno; goto ERROR; } // Order the transaction - transaction_order(transaction->transaction, 0); + transaction_order(self->transaction, 0); // Log the transaction - transaction_print(transaction->transaction); + transaction_print(self->transaction); // Free any previous content - pakfire_transaction_free_archives_and_packages(transaction); + pakfire_transaction_free_archives_and_packages(self); // How many steps? - transaction->num = transaction->transaction->steps.count; + self->num = self->transaction->steps.count; // Allocate space for packages - transaction->packages = calloc(transaction->num, sizeof(*transaction->packages)); - if (!transaction->packages) { + self->packages = calloc(self->num, sizeof(*self->packages)); + if (!self->packages) { r = -errno; goto ERROR; } // Allocate space for archives - transaction->archives = calloc(transaction->num, sizeof(*transaction->archives)); - if (!transaction->archives) { + self->archives = calloc(self->num, sizeof(*self->archives)); + if (!self->archives) { r = -errno; goto ERROR; } // Create all packages - for (unsigned int i = 0; i < transaction->num; i++) { - r = pakfire_package_create_from_solvable(&transaction->packages[i], transaction->ctx, - transaction->root, NULL, transaction->transaction->steps.elements[i]); + for (unsigned int i = 0; i < self->num; i++) { + r = pakfire_package_create_from_solvable(&self->packages[i], self->ctx, + self->root, NULL, self->transaction->steps.elements[i]); if (r < 0) goto ERROR; } // Fetch a list of all packages that will be installed in the end - new_pkgs = transaction_installedresult(transaction->transaction, &pkgs); + new_pkgs = transaction_installedresult(self->transaction, &pkgs); // Store all newly installed and overall all installed packages for (int i = 0; i < pkgs.count; i++) { - r = pakfire_package_create_from_solvable(&pkg, transaction->ctx, - transaction->root, NULL, pkgs.elements[i]); + r = pakfire_package_create_from_solvable(&pkg, self->ctx, + self->root, NULL, pkgs.elements[i]); if (r < 0) goto ERROR; // Add the package to the total list of packages - r = pakfire_packagelist_add(transaction->installed_packages, pkg); + r = pakfire_packagelist_add(self->installed_packages, pkg); if (r < 0) goto ERROR; // If the package is being newly installed, we add it to that list, too if (i < new_pkgs) { - r = pakfire_packagelist_add(transaction->new_packages, pkg); + r = pakfire_packagelist_add(self->new_packages, pkg); if (r < 0) goto ERROR; } @@ -247,7 +246,7 @@ ERROR: return r; } -static int pakfire_transaction_import_userinstalled(pakfire_transaction* transaction) { +static int pakfire_transaction_import_userinstalled(pakfire_transaction* self) { Queue userinstalled; const char* package = NULL; int r = 0; @@ -255,34 +254,34 @@ static int pakfire_transaction_import_userinstalled(pakfire_transaction* transac queue_init(&userinstalled); // Cleanup previous content - if (transaction->userinstalled) { - pakfire_strings_free(transaction->userinstalled); - transaction->userinstalled = NULL; + if (self->userinstalled) { + pakfire_strings_free(self->userinstalled); + self->userinstalled = NULL; } // Fetch a list of all packages that are installed by the user - solver_get_userinstalled(transaction->solver, &userinstalled, GET_USERINSTALLED_NAMES); + solver_get_userinstalled(self->solver, &userinstalled, GET_USERINSTALLED_NAMES); // Skip everything if the queue is empty if (!userinstalled.count) goto OUT; - transaction->userinstalled = calloc(userinstalled.count + 1, sizeof(*transaction->userinstalled)); - if (!transaction->userinstalled) { - ERROR(transaction->ctx, "Could not allocate userinstalled: %m\n"); + self->userinstalled = calloc(userinstalled.count + 1, sizeof(*self->userinstalled)); + if (!self->userinstalled) { + ERROR(self->ctx, "Could not allocate userinstalled: %m\n"); r = -errno; goto ERROR; } - Pool* pool = pakfire_root_get_solv_pool(transaction->root); + Pool* pool = pakfire_root_get_solv_pool(self->root); // Store the names of all userinstalled packages for (int i = 0; i < userinstalled.count; i++) { package = pool_id2str(pool, userinstalled.elements[i]); - transaction->userinstalled[i] = strdup(package); + self->userinstalled[i] = strdup(package); - if (!transaction->userinstalled[i]) { + if (!self->userinstalled[i]) { r = -errno; goto ERROR; } @@ -292,9 +291,9 @@ static int pakfire_transaction_import_userinstalled(pakfire_transaction* transac r = 0; ERROR: - if (transaction->userinstalled) { - pakfire_strings_free(transaction->userinstalled); - transaction->userinstalled = NULL; + if (self->userinstalled) { + pakfire_strings_free(self->userinstalled); + self->userinstalled = NULL; } OUT: @@ -303,140 +302,138 @@ OUT: return r; } -static int pakfire_transaction_setup_solver(pakfire_transaction* transaction) { - Pool* pool = pakfire_root_get_solv_pool(transaction->root); +static int pakfire_transaction_setup_solver(pakfire_transaction* self) { + Pool* pool = pakfire_root_get_solv_pool(self->root); // Allocate a new solver - transaction->solver = solver_create(pool); - if (!transaction->solver) { - ERROR(transaction->ctx, "Could not allocate solver: %m\n"); + self->solver = solver_create(pool); + if (!self->solver) { + ERROR(self->ctx, "Could not allocate solver: %m\n"); return -errno; } // Obey policy when searching for the best solvable - solver_set_flag(transaction->solver, SOLVER_FLAG_BEST_OBEY_POLICY, 1); + solver_set_flag(self->solver, SOLVER_FLAG_BEST_OBEY_POLICY, 1); // Automatically update when installation is requested - solver_set_flag(transaction->solver, SOLVER_FLAG_INSTALL_ALSO_UPDATES, 1); + solver_set_flag(self->solver, SOLVER_FLAG_INSTALL_ALSO_UPDATES, 1); #ifdef SOLVER_FLAG_FOCUS_NEW // By default, only update as many packages as necessary - solver_set_flag(transaction->solver, SOLVER_FLAG_FOCUS_NEW, 1); + solver_set_flag(self->solver, SOLVER_FLAG_FOCUS_NEW, 1); #endif // In build mode, we want to install the best versions - if (pakfire_root_has_flag(transaction->root, PAKFIRE_ROOT_FLAGS_BUILD)) - solver_set_flag(transaction->solver, SOLVER_FLAG_FOCUS_BEST, 1); + if (pakfire_root_has_flag(self->root, PAKFIRE_ROOT_FLAGS_BUILD)) + solver_set_flag(self->solver, SOLVER_FLAG_FOCUS_BEST, 1); // Can the solver downgrade packages? - if (transaction->flags & PAKFIRE_TRANSACTION_ALLOW_DOWNGRADE) - solver_set_flag(transaction->solver, SOLVER_FLAG_ALLOW_DOWNGRADE, 1); + if (self->flags & PAKFIRE_TRANSACTION_ALLOW_DOWNGRADE) + solver_set_flag(self->solver, SOLVER_FLAG_ALLOW_DOWNGRADE, 1); // Can the solver uninstall packages? - if (transaction->flags & PAKFIRE_TRANSACTION_ALLOW_UNINSTALL) - solver_set_flag(transaction->solver, SOLVER_FLAG_ALLOW_UNINSTALL, 1); + if (self->flags & PAKFIRE_TRANSACTION_ALLOW_UNINSTALL) + solver_set_flag(self->solver, SOLVER_FLAG_ALLOW_UNINSTALL, 1); // Do not install any recommended packages - if (transaction->flags & PAKFIRE_TRANSACTION_WITHOUT_RECOMMENDED) - solver_set_flag(transaction->solver, SOLVER_FLAG_IGNORE_RECOMMENDED, 1); + if (self->flags & PAKFIRE_TRANSACTION_WITHOUT_RECOMMENDED) + solver_set_flag(self->solver, SOLVER_FLAG_IGNORE_RECOMMENDED, 1); return 0; } -static void pakfire_transaction_free(pakfire_transaction* transaction) { - pakfire_transaction_free_archives_and_packages(transaction); - - if (transaction->installed_packages) - pakfire_packagelist_unref(transaction->installed_packages); - if (transaction->new_packages) - pakfire_packagelist_unref(transaction->new_packages); - if (transaction->userinstalled) - pakfire_strings_free(transaction->userinstalled); - if (transaction->progress) - pakfire_progress_unref(transaction->progress); - if (transaction->transaction) - transaction_free(transaction->transaction); - if (transaction->solver) - solver_free(transaction->solver); - if (transaction->root) - pakfire_root_unref(transaction->root); - if (transaction->ctx) - pakfire_ctx_unref(transaction->ctx); - queue_free(&transaction->jobs); - free(transaction); +static void pakfire_transaction_free(pakfire_transaction* self) { + pakfire_transaction_free_archives_and_packages(self); + + if (self->installed_packages) + pakfire_packagelist_unref(self->installed_packages); + if (self->new_packages) + pakfire_packagelist_unref(self->new_packages); + if (self->userinstalled) + pakfire_strings_free(self->userinstalled); + if (self->progress) + pakfire_progress_unref(self->progress); + if (self->transaction) + transaction_free(self->transaction); + if (self->solver) + solver_free(self->solver); + if (self->root) + pakfire_root_unref(self->root); + if (self->ctx) + pakfire_ctx_unref(self->ctx); + queue_free(&self->jobs); + free(self); } int pakfire_transaction_create(pakfire_transaction** transaction, pakfire_ctx* ctx, pakfire_root* root, int flags) { + pakfire_transaction* self = NULL; int r; // Allocate the transaction - pakfire_transaction* t = calloc(1, sizeof(*t)); - if (!t) + self = calloc(1, sizeof(*self)); + if (!self) return -errno; // Store a reference to the context - t->ctx = pakfire_ctx_ref(ctx); + self->ctx = pakfire_ctx_ref(ctx); // Store reference to Pakfire - t->root = pakfire_root_ref(root); + self->root = pakfire_root_ref(root); // Initialize the reference counter - t->nrefs = 1; + self->nrefs = 1; // Store flags - t->flags = flags; + self->flags = flags; // Allocate a job queue - queue_init(&t->jobs); + queue_init(&self->jobs); // Create a progress indicator - r = pakfire_progress_create(&t->progress, t->ctx, PAKFIRE_PROGRESS_SHOW_PERCENTAGE, NULL); + r = pakfire_progress_create(&self->progress, self->ctx, + PAKFIRE_PROGRESS_SHOW_PERCENTAGE, NULL); if (r < 0) goto ERROR; // Setup the solver - r = pakfire_transaction_setup_solver(t); + r = pakfire_transaction_setup_solver(self); if (r) goto ERROR; // Setup package lists - r = pakfire_packagelist_create(&t->installed_packages, t->ctx); + r = pakfire_packagelist_create(&self->installed_packages, self->ctx); if (r < 0) goto ERROR; - r = pakfire_packagelist_create(&t->new_packages, t->ctx); + r = pakfire_packagelist_create(&self->new_packages, self->ctx); if (r < 0) goto ERROR; // Return the transaction - *transaction = t; + *transaction = self; return 0; ERROR: - pakfire_transaction_free(t); - + pakfire_transaction_free(self); return r; } -pakfire_transaction* pakfire_transaction_ref( - pakfire_transaction* transaction) { - transaction->nrefs++; +pakfire_transaction* pakfire_transaction_ref(pakfire_transaction* self) { + self->nrefs++; - return transaction; + return self; } -pakfire_transaction* pakfire_transaction_unref( - pakfire_transaction* transaction) { - if (--transaction->nrefs > 0) - return transaction; +pakfire_transaction* pakfire_transaction_unref(pakfire_transaction* self) { + if (--self->nrefs > 0) + return self; - pakfire_transaction_free(transaction); + pakfire_transaction_free(self); return NULL; } -pakfire_problem** pakfire_transaction_get_problems( - pakfire_transaction* transaction) { +pakfire_problem** pakfire_transaction_get_problems(pakfire_transaction* self) { pakfire_problem** problems = NULL; pakfire_problem* problem = NULL; unsigned int count = 0; @@ -444,7 +441,7 @@ pakfire_problem** pakfire_transaction_get_problems( int r; // Count problems - count = solver_problem_count(transaction->solver); + count = solver_problem_count(self->solver); // Return NULL if there are no problems if (!count) @@ -459,13 +456,12 @@ pakfire_problem** pakfire_transaction_get_problems( for (unsigned int i = 0; i < count; i++) { // Fetch the ID of the next problem - id = solver_next_problem(transaction->solver, id); + id = solver_next_problem(self->solver, id); if (!id) break; // Create a new problem - r = pakfire_problem_create(&problem, - transaction->ctx, transaction->root, transaction, id); + r = pakfire_problem_create(&problem, self->ctx, self->root, self, id); if (r) goto ERROR; @@ -476,7 +472,7 @@ pakfire_problem** pakfire_transaction_get_problems( return problems; ERROR: - ERROR(transaction->ctx, "Could not import problems: %s\n", strerror(r)); + ERROR(self->ctx, "Could not import problems: %s\n", strerror(r)); if (problems) { for (pakfire_problem** p = problems; *p; p++) @@ -488,7 +484,7 @@ ERROR: } static int pakfire_transaction_append_solutions( - pakfire_transaction* transaction, char** buffer, pakfire_solution** solutions) { + pakfire_transaction* self, char** buffer, pakfire_solution** solutions) { const char* s = NULL; int r; @@ -507,7 +503,7 @@ static int pakfire_transaction_append_solutions( } static int pakfire_transaction_append_problems( - pakfire_transaction* transaction, char** buffer, pakfire_problem** problems, int flags) { + pakfire_transaction* self, char** buffer, pakfire_problem** problems, int flags) { pakfire_solution** solutions = NULL; const char* s = NULL; int r; @@ -528,7 +524,7 @@ static int pakfire_transaction_append_problems( solutions = pakfire_problem_get_solutions(*problem); if (solutions) { - r = pakfire_transaction_append_solutions(transaction, buffer, solutions); + r = pakfire_transaction_append_solutions(self, buffer, solutions); // Cleanup for (pakfire_solution** solution = solutions; *solution; solution++) @@ -545,18 +541,18 @@ static int pakfire_transaction_append_problems( } static char* pakfire_transaction_get_problem_string( - pakfire_transaction* transaction, int flags) { + pakfire_transaction* self, int flags) { pakfire_problem** problems = NULL; char* buffer = NULL; int r; // Fetch any problems - problems = pakfire_transaction_get_problems(transaction); + problems = pakfire_transaction_get_problems(self); // Show problems if (problems) { // Append all problems - r = pakfire_transaction_append_problems(transaction, &buffer, problems, flags); + r = pakfire_transaction_append_problems(self, &buffer, problems, flags); if (r) { if (buffer) free(buffer); @@ -576,11 +572,11 @@ static char* pakfire_transaction_get_problem_string( return buffer; } -Solver* pakfire_transaction_get_solver(pakfire_transaction* transaction) { - return transaction->solver; +Solver* pakfire_transaction_get_solver(pakfire_transaction* self) { + return self->solver; } -int pakfire_transaction_solve(pakfire_transaction* transaction, +int pakfire_transaction_solve(pakfire_transaction* self, int flags, char** problems) { clock_t solving_start; clock_t solving_end; @@ -591,25 +587,25 @@ int pakfire_transaction_solve(pakfire_transaction* transaction, // XXX halt if the request has already been solved // Prepare pool - pakfire_root_pool_internalize(transaction->root); + pakfire_root_pool_internalize(self->root); - Pool* pool = pakfire_root_get_solv_pool(transaction->root); + Pool* pool = pakfire_root_get_solv_pool(self->root); - const char* selection = pool_selection2str(pool, &transaction->jobs, 0); + const char* selection = pool_selection2str(pool, &self->jobs, 0); if (selection) - DEBUG(transaction->ctx, "Solving: %s\n", selection); + DEBUG(self->ctx, "Solving: %s\n", selection); for (;;) { // Save time when we starting solving solving_start = clock(); // Solve the request and get the number of problems - r = solver_solve(transaction->solver, &transaction->jobs); + r = solver_solve(self->solver, &self->jobs); // Save time when we finished solving solving_end = clock(); - DEBUG(transaction->ctx, "Solved request in %.4fms\n", + DEBUG(self->ctx, "Solved request in %.4fms\n", (double)(solving_end - solving_start) * 1000 / CLOCKS_PER_SEC); switch (r) { @@ -619,18 +615,18 @@ int pakfire_transaction_solve(pakfire_transaction* transaction, solved = 1; // Import the transaction - r = pakfire_transaction_import_transaction(transaction); + r = pakfire_transaction_import_transaction(self); if (r) goto ERROR; // Import userinstalled packages - r = pakfire_transaction_import_userinstalled(transaction); + r = pakfire_transaction_import_userinstalled(self); if (r) goto ERROR; #ifdef ENABLE_DEBUG // Print all decisions - solver_printdecisions(transaction->solver); + solver_printdecisions(self->solver); #endif goto SOLVED; @@ -639,14 +635,14 @@ int pakfire_transaction_solve(pakfire_transaction* transaction, default: #ifdef ENABLE_DEBUG // Print all solutions - solver_printallsolutions(transaction->solver); + solver_printallsolutions(self->solver); #endif // Fetch the reason why we could not solve the request - p = pakfire_transaction_get_problem_string(transaction, flags); + p = pakfire_transaction_get_problem_string(self, flags); if (p) { - DEBUG(transaction->ctx, + DEBUG(self->ctx, "Could not solve request: %s\n%s\n", selection, p); // Return the problems @@ -655,7 +651,7 @@ int pakfire_transaction_solve(pakfire_transaction* transaction, } // Ask the user to pick a solution - r = pakfire_ctx_pick_solution(transaction->ctx, transaction->root, transaction); + r = pakfire_ctx_pick_solution(self->ctx, self->root, self); switch (r) { case 0: continue; @@ -685,7 +681,7 @@ static int pakfire_transaction_is_file(const char* what) { return pakfire_string_endswith(what, ".pfm"); } -static int __pakfire_transaction_add(pakfire_transaction* transaction, +static int __pakfire_transaction_add(pakfire_transaction* self, const enum pakfire_job_action action, const Id type, const Id id, int flags) { Id job = ID_NULL; @@ -737,7 +733,7 @@ static int __pakfire_transaction_add(pakfire_transaction* transaction, // Drop orphans? if (!(flags & PAKFIRE_JOB_KEEP_ORPHANED)) - queue_push2(&transaction->jobs, SOLVER_DROP_ORPHANED, 0); + queue_push2(&self->jobs, SOLVER_DROP_ORPHANED, 0); break; case PAKFIRE_JOB_LOCK: @@ -750,20 +746,20 @@ static int __pakfire_transaction_add(pakfire_transaction* transaction, } // Add it to the job queue - queue_push2(&transaction->jobs, job|type, id); + queue_push2(&self->jobs, job|type, id); return 0; } -static int pakfire_transaction_add_job(pakfire_transaction* transaction, +static int pakfire_transaction_add_job(pakfire_transaction* self, const enum pakfire_job_action action, const char* what, int extra_flags) { Queue jobs; int r; - Pool* pool = pakfire_root_get_solv_pool(transaction->root); + Pool* pool = pakfire_root_get_solv_pool(self->root); // Make the pool ready - pakfire_root_pool_internalize(transaction->root); + pakfire_root_pool_internalize(self->root); // Initialize jobs queue_init(&jobs); @@ -791,7 +787,7 @@ static int pakfire_transaction_add_job(pakfire_transaction* transaction, // Did we find anything? if (jobs.count == 0) { - Id id = pakfire_str2dep(transaction->root, what); + Id id = pakfire_str2dep(self->root, what); if (!id) { r = -errno; goto ERROR; @@ -800,11 +796,11 @@ static int pakfire_transaction_add_job(pakfire_transaction* transaction, queue_push2(&jobs, SOLVER_SOLVABLE_PROVIDES, id); } - DEBUG(transaction->ctx, "Found %d match(es) for '%s'\n", jobs.count / 2, what); + DEBUG(self->ctx, "Found %d match(es) for '%s'\n", jobs.count / 2, what); // Set action and global flags for (int i = 0; i < jobs.count; i += 2) { - r = __pakfire_transaction_add(transaction, action, + r = __pakfire_transaction_add(self, action, jobs.elements[i], jobs.elements[i+1], extra_flags); if (r) goto ERROR; @@ -819,7 +815,7 @@ ERROR: return r; } -int pakfire_transaction_request(pakfire_transaction* transaction, +int pakfire_transaction_request(pakfire_transaction* self, const enum pakfire_job_action action, const char* what, int flags) { pakfire_package* package = NULL; int r; @@ -831,25 +827,25 @@ int pakfire_transaction_request(pakfire_transaction* transaction, } if (!what) { - r = __pakfire_transaction_add(transaction, action, ID_NULL, ID_NULL, flags); + r = __pakfire_transaction_add(self, action, ID_NULL, ID_NULL, flags); if (r) goto ERROR; // Check if we got given a URL or some file } else if (pakfire_string_is_url(what) || pakfire_transaction_is_file(what)) { // Add them to the commandline repository - r = pakfire_root_commandline_add(transaction->root, what, &package); + r = pakfire_root_commandline_add(self->root, what, &package); if (r) goto ERROR; // Then add the package - r = pakfire_transaction_request_package(transaction, action, package, flags); + r = pakfire_transaction_request_package(self, action, package, flags); if (r) goto ERROR; // Otherwise try adding this as a job } else { - r = pakfire_transaction_add_job(transaction, action, what, flags); + r = pakfire_transaction_add_job(self, action, what, flags); if (r) goto ERROR; } @@ -861,16 +857,16 @@ ERROR: return r; } -int pakfire_transaction_request_package(pakfire_transaction* transaction, +int pakfire_transaction_request_package(pakfire_transaction* self, const enum pakfire_job_action action, pakfire_package* package, int flags) { // Get the solvable ID Id id = pakfire_package_id(package); // Add it to the job queue - return __pakfire_transaction_add(transaction, action, SOLVER_SOLVABLE, id, flags); + return __pakfire_transaction_add(self, action, SOLVER_SOLVABLE, id, flags); } -int pakfire_transaction_take_solution(pakfire_transaction* transaction, +int pakfire_transaction_take_solution(pakfire_transaction* self, pakfire_solution* solution) { pakfire_problem* problem = pakfire_solution_get_problem(solution); @@ -879,29 +875,29 @@ int pakfire_transaction_take_solution(pakfire_transaction* transaction, Id solution_id = pakfire_solution_get_id(solution); // Feed the solution into the solver - solver_take_solution(transaction->solver, problem_id, solution_id, &transaction->jobs); + solver_take_solution(self->solver, problem_id, solution_id, &self->jobs); pakfire_problem_unref(problem); return 0; } -size_t pakfire_transaction_count(pakfire_transaction* transaction) { - return transaction->num; +size_t pakfire_transaction_count(pakfire_transaction* self) { + return self->num; } -static ssize_t pakfire_transaction_installsizechange(pakfire_transaction* transaction) { - ssize_t sizechange = transaction_calc_installsizechange(transaction->transaction); +static ssize_t pakfire_transaction_installsizechange(pakfire_transaction* self) { + ssize_t sizechange = transaction_calc_installsizechange(self->transaction); // Convert from kbytes to bytes return sizechange * 1024; } -static ssize_t pakfire_transaction_downloadsize(pakfire_transaction* transaction) { +static ssize_t pakfire_transaction_downloadsize(pakfire_transaction* self) { ssize_t size = 0; - for (unsigned int i = 0; i < transaction->num; i++) + for (unsigned int i = 0; i < self->num; i++) size += pakfire_package_get_num( - transaction->packages[i], PAKFIRE_PKG_DOWNLOADSIZE, 0); + self->packages[i], PAKFIRE_PKG_DOWNLOADSIZE, 0); return size; } @@ -1004,7 +1000,7 @@ static int pakfire_transaction_add_usage_line(char** s, size_t width, return pakfire_transaction_append_line(s, "%s%-21s: %s\n", *s, headline, buffer); } -char* pakfire_transaction_dump(pakfire_transaction* transaction, size_t width) { +char* pakfire_transaction_dump(pakfire_transaction* self, size_t width) { char headline[1024]; char* s = NULL; int r; @@ -1015,7 +1011,7 @@ char* pakfire_transaction_dump(pakfire_transaction* transaction, size_t width) { queue_init(&classes); queue_init(&pkgs); - Pool* pool = transaction->transaction->pool; + Pool* pool = self->transaction->pool; const int mode = SOLVER_TRANSACTION_SHOW_OBSOLETES | SOLVER_TRANSACTION_OBSOLETE_IS_UPGRADE; @@ -1042,7 +1038,7 @@ char* pakfire_transaction_dump(pakfire_transaction* transaction, size_t width) { goto ERROR; // Get all classes - transaction_classify(transaction->transaction, mode, &classes); + transaction_classify(self->transaction, mode, &classes); /* The classes queue now contains a list of all classes as a tuple of: @@ -1153,7 +1149,7 @@ char* pakfire_transaction_dump(pakfire_transaction* transaction, size_t width) { goto ERROR; // Fetch packages in this class - transaction_classify_pkgs(transaction->transaction, mode, class, + transaction_classify_pkgs(self->transaction, mode, class, classes.elements[i+2], classes.elements[i+3], &pkgs); // List all packages @@ -1161,16 +1157,16 @@ char* pakfire_transaction_dump(pakfire_transaction* transaction, size_t width) { pakfire_package* old_pkg = NULL; pakfire_package* new_pkg = NULL; - r = pakfire_package_create_from_solvable(&old_pkg, transaction->ctx, - transaction->root, NULL, pkgs.elements[j]); + r = pakfire_package_create_from_solvable(&old_pkg, self->ctx, + self->root, NULL, pkgs.elements[j]); if (r) continue; switch (class) { case SOLVER_TRANSACTION_UPGRADED: case SOLVER_TRANSACTION_DOWNGRADED: - r = pakfire_package_create_from_solvable(&new_pkg, transaction->ctx, - transaction->root, NULL, transaction_obs_pkg(transaction->transaction, pkgs.elements[j])); + r = pakfire_package_create_from_solvable(&new_pkg, self->ctx, + self->root, NULL, transaction_obs_pkg(self->transaction, pkgs.elements[j])); if (r) continue; @@ -1207,7 +1203,7 @@ char* pakfire_transaction_dump(pakfire_transaction* transaction, size_t width) { goto ERROR; // How much do we need to download? - size_t downloadsize = pakfire_transaction_downloadsize(transaction); + size_t downloadsize = pakfire_transaction_downloadsize(self); if (downloadsize > 0) { r = pakfire_transaction_add_usage_line(&s, width, @@ -1217,7 +1213,7 @@ char* pakfire_transaction_dump(pakfire_transaction* transaction, size_t width) { } // How much more space do we need? - ssize_t sizechange = pakfire_transaction_installsizechange(transaction); + ssize_t sizechange = pakfire_transaction_installsizechange(self); // Show if we need more space if (sizechange > 0) { @@ -1233,7 +1229,7 @@ char* pakfire_transaction_dump(pakfire_transaction* transaction, size_t width) { } if (s) - DEBUG(transaction->ctx, "%s", s); + DEBUG(self->ctx, "%s", s); ERROR: queue_free(&classes); @@ -1242,8 +1238,7 @@ ERROR: return s; } -static int pakfire_transaction_check_fileconflicts( - pakfire_transaction* transaction) { +static int pakfire_transaction_check_fileconflicts(pakfire_transaction* self) { /* XXX TODO @@ -1253,18 +1248,18 @@ static int pakfire_transaction_check_fileconflicts( return 0; } -static int pakfire_transaction_check(pakfire_transaction* transaction) { +static int pakfire_transaction_check(pakfire_transaction* self) { int r; // Check for any file conflicts - r = pakfire_transaction_check_fileconflicts(transaction); + r = pakfire_transaction_check_fileconflicts(self); if (r) return r; return 0; } -static int pakfire_transaction_verify(pakfire_transaction* transaction, +static int pakfire_transaction_verify(pakfire_transaction* self, pakfire_package* pkg, pakfire_archive* archive) { enum pakfire_hash_type hash = PAKFIRE_HASH_UNDEFINED; const unsigned char* checksum = NULL; @@ -1275,20 +1270,20 @@ static int pakfire_transaction_verify(pakfire_transaction* transaction, // Nothing to do if this step does not have an archive if (!archive) { - DEBUG(transaction->ctx, "Package %s requires no archive\n", nevra); + DEBUG(self->ctx, "Package %s requires no archive\n", nevra); return 0; } // Fetch digest from package r = pakfire_package_get_checksum(pkg, &hash, &checksum, &checksum_length); if (r < 0) { - ERROR(transaction->ctx, "Could not fetch checksum for %s: %s\n", nevra, strerror(-r)); + ERROR(self->ctx, "Could not fetch checksum for %s: %s\n", nevra, strerror(-r)); return r; } // Fail if there is no checksum if (!checksum) { - ERROR(transaction->ctx, "Package %s has no checksum\n", nevra); + ERROR(self->ctx, "Package %s has no checksum\n", nevra); return -EINVAL; } @@ -1300,7 +1295,7 @@ static int pakfire_transaction_verify(pakfire_transaction* transaction, return 0; } -static int pakfire_transaction_run_script(pakfire_transaction* transaction, pakfire_db* db, +static int pakfire_transaction_run_script(pakfire_transaction* self, pakfire_db* db, pakfire_jail* jail, const char* type, pakfire_package* pkg, pakfire_archive* archive) { pakfire_scriptlet* scriptlet = NULL; int r = 0; @@ -1318,7 +1313,7 @@ static int pakfire_transaction_run_script(pakfire_transaction* transaction, pakf // Execute the scriptlet r = pakfire_scriptlet_execute(scriptlet, jail); if (r < 0) { - ERROR(transaction->ctx, "Failed to execute the scriptlet: %s\n", strerror(-r)); + ERROR(self->ctx, "Failed to execute the scriptlet: %s\n", strerror(-r)); goto ERROR; } @@ -1342,7 +1337,7 @@ static int pakfire_transaction_ldconfig(pakfire_transaction* self, pakfire_jail* return pakfire_jail_execute_command(jail, argv, NULL, PAKFIRE_JAIL_NOENT_OK); } -static int pakfire_transaction_extract(pakfire_transaction* transaction, +static int pakfire_transaction_extract(pakfire_transaction* self, pakfire_jail* jail, pakfire_package* pkg, pakfire_archive* archive) { pakfire_filelist* filelist = NULL; int r; @@ -1351,14 +1346,14 @@ static int pakfire_transaction_extract(pakfire_transaction* transaction, const char* nevra = pakfire_package_get_string(pkg, PAKFIRE_PKG_NEVRA); // Update status - r = pakfire_progress_push_status(transaction->progress, _("Installing %s..."), nevra); + r = pakfire_progress_push_status(self->progress, _("Installing %s..."), nevra); if (r < 0) return r; // Extract payload - r = pakfire_archive_extract(archive, NULL, 0, transaction->progress); + r = pakfire_archive_extract(archive, NULL, 0, self->progress); if (r) { - ERROR(transaction->ctx, "Could not extract package %s: %m\n", + ERROR(self->ctx, "Could not extract package %s: %m\n", nevra); goto ERROR; } @@ -1370,18 +1365,18 @@ static int pakfire_transaction_extract(pakfire_transaction* transaction, // Update the runtime linker cache if (pakfire_filelist_contains(filelist, "*/lib*.so.?")) - pakfire_transaction_ldconfig(transaction, jail); + pakfire_transaction_ldconfig(self, jail); if (filelist) pakfire_filelist_unref(filelist); ERROR: - pakfire_progress_pop_status(transaction->progress); + pakfire_progress_pop_status(self->progress); return 0; } -static int pakfire_transaction_erase(pakfire_transaction* transaction, +static int pakfire_transaction_erase(pakfire_transaction* self, pakfire_db* db, pakfire_jail* jail, pakfire_package* pkg) { pakfire_filelist* filelist = NULL; int r; @@ -1390,7 +1385,7 @@ static int pakfire_transaction_erase(pakfire_transaction* transaction, const char* nevra = pakfire_package_get_string(pkg, PAKFIRE_PKG_NEVRA); // Update status - r = pakfire_progress_push_status(transaction->progress, _("Removing %s..."), nevra); + r = pakfire_progress_push_status(self->progress, _("Removing %s..."), nevra); if (r < 0) return r; @@ -1405,10 +1400,10 @@ static int pakfire_transaction_erase(pakfire_transaction* transaction, goto ERROR; // Update the runtime linker cache after all files have been removed - r = pakfire_transaction_ldconfig(transaction, jail); + r = pakfire_transaction_ldconfig(self, jail); ERROR: - pakfire_progress_pop_status(transaction->progress); + pakfire_progress_pop_status(self->progress); if (filelist) pakfire_filelist_unref(filelist); @@ -1471,15 +1466,15 @@ static const char* pakfire_step_type_string(enum pakfire_steps type) { } static int pakfire_transaction_package_is_userinstalled( - pakfire_transaction* transaction, pakfire_package* pkg) { + pakfire_transaction* self, pakfire_package* pkg) { // No packages on the list - if (!transaction->userinstalled) + if (!self->userinstalled) return 0; const char* name = pakfire_package_get_string(pkg, PAKFIRE_PKG_NAME); // Check if the package is on the list - for (char** elem = transaction->userinstalled; *elem; elem++) { + for (char** elem = self->userinstalled; *elem; elem++) { if (strcmp(name, *elem) == 0) return 1; } @@ -1488,7 +1483,7 @@ static int pakfire_transaction_package_is_userinstalled( return 0; } -static int pakfire_transaction_apply_systemd_sysusers(pakfire_transaction* transaction, +static int pakfire_transaction_apply_systemd_sysusers(pakfire_transaction* self, pakfire_package* pkg, pakfire_archive* archive) { // Walk through the archive and find all sysuser files if (pakfire_package_matches_dep(pkg, PAKFIRE_PKG_REQUIRES, "pakfire(systemd-sysusers)")) @@ -1498,15 +1493,15 @@ static int pakfire_transaction_apply_systemd_sysusers(pakfire_transaction* trans } static int pakfire_transaction_apply_systemd_tmpfiles( - pakfire_transaction* transaction, pakfire_package* pkg) { + pakfire_transaction* self, pakfire_package* pkg) { // Apply any tmpfiles (ignore any errors) if (pakfire_package_matches_dep(pkg, PAKFIRE_PKG_REQUIRES, "pakfire(systemd-tmpfiles)")) - pakfire_jail_run_systemd_tmpfiles(transaction->ctx, transaction->root); + pakfire_jail_run_systemd_tmpfiles(self->ctx, self->root); return 0; } -static int pakfire_transaction_run_step(pakfire_transaction* transaction, pakfire_db* db, +static int pakfire_transaction_run_step(pakfire_transaction* self, pakfire_db* db, pakfire_jail* jail, const enum pakfire_actions action, pakfire_package* pkg, pakfire_archive* archive) { if (!pkg) { errno = EINVAL; @@ -1514,16 +1509,16 @@ static int pakfire_transaction_run_step(pakfire_transaction* transaction, pakfir } const char* nevra = pakfire_package_get_string(pkg, PAKFIRE_PKG_NEVRA); - const enum pakfire_steps type = pakfire_transaction_get_step_type(transaction, pkg); + const enum pakfire_steps type = pakfire_transaction_get_step_type(self, pkg); - DEBUG(transaction->ctx, "Running %s (%s) for %s\n", + DEBUG(self->ctx, "Running %s (%s) for %s\n", pakfire_action_type_string(action), pakfire_step_type_string(type), nevra); int r = 0; switch (action) { // Verify this step case PAKFIRE_ACTION_VERIFY: - r = pakfire_transaction_verify(transaction, pkg, archive); + r = pakfire_transaction_verify(self, pkg, archive); break; // Run the pre-transaction scripts @@ -1531,18 +1526,18 @@ static int pakfire_transaction_run_step(pakfire_transaction* transaction, pakfir switch (type) { case PAKFIRE_STEP_INSTALL: case PAKFIRE_STEP_REINSTALL: - r = pakfire_transaction_run_script(transaction, db, jail, + r = pakfire_transaction_run_script(self, db, jail, "pretransin", pkg, archive); break; case PAKFIRE_STEP_UPGRADE: case PAKFIRE_STEP_DOWNGRADE: - r = pakfire_transaction_run_script(transaction, db, jail, + r = pakfire_transaction_run_script(self, db, jail, "pretransup", pkg, archive); break; case PAKFIRE_STEP_ERASE: - r = pakfire_transaction_run_script(transaction, db, jail, + r = pakfire_transaction_run_script(self, db, jail, "pretransun", pkg, archive); break; @@ -1559,18 +1554,18 @@ static int pakfire_transaction_run_step(pakfire_transaction* transaction, pakfir switch (type) { case PAKFIRE_STEP_INSTALL: case PAKFIRE_STEP_REINSTALL: - r = pakfire_transaction_run_script(transaction, db, jail, + r = pakfire_transaction_run_script(self, db, jail, "posttransin", pkg, archive); break; case PAKFIRE_STEP_UPGRADE: case PAKFIRE_STEP_DOWNGRADE: - r = pakfire_transaction_run_script(transaction, db, jail, + r = pakfire_transaction_run_script(self, db, jail, "posttransup", pkg, archive); break; case PAKFIRE_STEP_ERASE: - r = pakfire_transaction_run_script(transaction, db, jail, + r = pakfire_transaction_run_script(self, db, jail, "posttransun", pkg, archive); break; @@ -1585,22 +1580,22 @@ static int pakfire_transaction_run_step(pakfire_transaction* transaction, pakfir // Execute the action of this script case PAKFIRE_ACTION_EXECUTE: // Increment progress - pakfire_progress_increment(transaction->progress, 1); + pakfire_progress_increment(self->progress, 1); switch (type) { case PAKFIRE_STEP_INSTALL: case PAKFIRE_STEP_REINSTALL: // Apply systemd sysusers - r = pakfire_transaction_apply_systemd_sysusers(transaction, pkg, archive); + r = pakfire_transaction_apply_systemd_sysusers(self, pkg, archive); if (r) break; - r = pakfire_transaction_run_script(transaction, db, jail, + r = pakfire_transaction_run_script(self, db, jail, "prein", pkg, archive); if (r) break; - r = pakfire_transaction_extract(transaction, jail, pkg, archive); + r = pakfire_transaction_extract(self, jail, pkg, archive); if (r) break; @@ -1612,56 +1607,56 @@ static int pakfire_transaction_run_step(pakfire_transaction* transaction, pakfir } r = pakfire_db_add_package(db, pkg, archive, - pakfire_transaction_package_is_userinstalled(transaction, pkg)); + pakfire_transaction_package_is_userinstalled(self, pkg)); if (r) break; // Apply systemd tmpfiles - r = pakfire_transaction_apply_systemd_tmpfiles(transaction, pkg); + r = pakfire_transaction_apply_systemd_tmpfiles(self, pkg); if (r) break; - r = pakfire_transaction_run_script(transaction, db, jail, + r = pakfire_transaction_run_script(self, db, jail, "postin", pkg, archive); break; case PAKFIRE_STEP_UPGRADE: case PAKFIRE_STEP_DOWNGRADE: // Apply systemd sysusers - r = pakfire_transaction_apply_systemd_sysusers(transaction, pkg, archive); + r = pakfire_transaction_apply_systemd_sysusers(self, pkg, archive); if (r) break; - r = pakfire_transaction_run_script(transaction, db, jail, + r = pakfire_transaction_run_script(self, db, jail, "preup", pkg, archive); if (r) break; - r = pakfire_transaction_extract(transaction, jail, pkg, archive); + r = pakfire_transaction_extract(self, jail, pkg, archive); if (r) break; r = pakfire_db_add_package(db, pkg, archive, - pakfire_transaction_package_is_userinstalled(transaction, pkg)); + pakfire_transaction_package_is_userinstalled(self, pkg)); if (r) break; // Apply systemd tmpfiles - r = pakfire_transaction_apply_systemd_tmpfiles(transaction, pkg); + r = pakfire_transaction_apply_systemd_tmpfiles(self, pkg); if (r) break; - r = pakfire_transaction_run_script(transaction, db, jail, + r = pakfire_transaction_run_script(self, db, jail, "postup", pkg, archive); break; case PAKFIRE_STEP_ERASE: - r = pakfire_transaction_run_script(transaction, db, jail, + r = pakfire_transaction_run_script(self, db, jail, "preun", pkg, archive); if (r) break; - r = pakfire_transaction_erase(transaction, db, jail, pkg); + r = pakfire_transaction_erase(self, db, jail, pkg); if (r) break; @@ -1669,14 +1664,14 @@ static int pakfire_transaction_run_step(pakfire_transaction* transaction, pakfir if (r) break; - r = pakfire_transaction_run_script(transaction, db, jail, + r = pakfire_transaction_run_script(self, db, jail, "postun", pkg, archive); break; // Erase the package data without running any scripts case PAKFIRE_STEP_UPGRADED: case PAKFIRE_STEP_DOWNGRADED: - r = pakfire_transaction_erase(transaction, db, jail, pkg); + r = pakfire_transaction_erase(self, db, jail, pkg); if (r) break; @@ -1697,32 +1692,32 @@ static int pakfire_transaction_run_step(pakfire_transaction* transaction, pakfir } if (r) - ERROR(transaction->ctx, "Step %s (%u) for %s has failed: %m\n", + ERROR(self->ctx, "Step %s (%u) for %s has failed: %m\n", pakfire_action_type_string(action), type, nevra); return r; } -static int pakfire_transaction_run_steps(pakfire_transaction* transaction, +static int pakfire_transaction_run_steps(pakfire_transaction* self, pakfire_db* db, pakfire_jail* jail, enum pakfire_actions action) { int r = 0; // Update status switch (action) { case PAKFIRE_ACTION_VERIFY: - r = pakfire_progress_push_status(transaction->progress, _("Verifying Packages...")); + r = pakfire_progress_push_status(self->progress, _("Verifying Packages...")); if (r < 0) return r; break; case PAKFIRE_ACTION_PRETRANS: - r = pakfire_progress_push_status(transaction->progress, _("Preparing Installation...")); + r = pakfire_progress_push_status(self->progress, _("Preparing Installation...")); if (r < 0) return r; break; case PAKFIRE_ACTION_POSTTRANS: - r = pakfire_progress_push_status(transaction->progress, _("Finishing Up...")); + r = pakfire_progress_push_status(self->progress, _("Finishing Up...")); if (r < 0) return r; break; @@ -1732,13 +1727,13 @@ static int pakfire_transaction_run_steps(pakfire_transaction* transaction, } // Walk through all steps - for (unsigned int i = 0; i < transaction->num; i++) { - r = pakfire_transaction_run_step(transaction, db, jail, action, - transaction->packages[i], transaction->archives[i]); + for (unsigned int i = 0; i < self->num; i++) { + r = pakfire_transaction_run_step(self, db, jail, action, + self->packages[i], self->archives[i]); // End loop if action was unsuccessful if (r) { - DEBUG(transaction->ctx, "Step %u failed: %m\n", i); + DEBUG(self->ctx, "Step %u failed: %m\n", i); break; } } @@ -1748,7 +1743,7 @@ static int pakfire_transaction_run_steps(pakfire_transaction* transaction, case PAKFIRE_ACTION_VERIFY: case PAKFIRE_ACTION_PRETRANS: case PAKFIRE_ACTION_POSTTRANS: - pakfire_progress_pop_status(transaction->progress); + pakfire_progress_pop_status(self->progress); break; default: @@ -1759,15 +1754,15 @@ static int pakfire_transaction_run_steps(pakfire_transaction* transaction, } static int pakfire_transaction_open_archives( - pakfire_transaction* transaction, size_t* total_size) { + pakfire_transaction* self, size_t* total_size) { pakfire_archive* archive = NULL; int r; - for (unsigned int i = 0; i < transaction->num; i++) { - pakfire_package* pkg = transaction->packages[i]; + for (unsigned int i = 0; i < self->num; i++) { + pakfire_package* pkg = self->packages[i]; // Fetch the type - enum pakfire_steps type = pakfire_transaction_get_step_type(transaction, pkg); + enum pakfire_steps type = pakfire_transaction_get_step_type(self, pkg); // Do we need the archive? switch (type) { @@ -1791,7 +1786,7 @@ static int pakfire_transaction_open_archives( return r; // Reference the archive - transaction->archives[i] = archive; + self->archives[i] = archive; // Count the total size if requested if (total_size) @@ -1865,76 +1860,76 @@ static int pakfire_usrmove(pakfire_ctx* ctx, pakfire_root* root) { return r; } -static int pakfire_transaction_perform(pakfire_transaction* transaction) { +static int pakfire_transaction_perform(pakfire_transaction* self) { pakfire_repo* repo = NULL; pakfire_jail* jail = NULL; pakfire_db* db; size_t total_size = 0; int r; - DEBUG(transaction->ctx, "Running Transaction %p\n", transaction); + DEBUG(self->ctx, "Running Transaction %p\n", self); // Create a new jail to execute any commands - r = pakfire_jail_create(&jail, transaction->ctx, transaction->root); + r = pakfire_jail_create(&jail, self->ctx, self->root); if (r < 0) goto ERROR; // Open all archives - r = pakfire_transaction_open_archives(transaction, &total_size); + r = pakfire_transaction_open_archives(self, &total_size); if (r < 0) goto ERROR; // Set the title - r = pakfire_progress_set_title(transaction->progress, "%s", _("Installing Packages...")); + r = pakfire_progress_set_title(self->progress, "%s", _("Installing Packages...")); if (r < 0) goto ERROR; // Start the progress... - r = pakfire_progress_start(transaction->progress, total_size); + r = pakfire_progress_start(self->progress, total_size); if (r < 0) goto ERROR; // Open the database - r = pakfire_db_open(&db, transaction->ctx, transaction->root, PAKFIRE_DB_READWRITE); - if (r) { - ERROR(transaction->ctx, "Could not open the database\n"); + r = pakfire_db_open(&db, self->ctx, self->root, PAKFIRE_DB_READWRITE); + if (r < 0) { + ERROR(self->ctx, "Could not open the database\n"); goto ERROR; } // Verify steps - r = pakfire_transaction_run_steps(transaction, db, jail, PAKFIRE_ACTION_VERIFY); - if (r) + r = pakfire_transaction_run_steps(self, db, jail, PAKFIRE_ACTION_VERIFY); + if (r < 0) goto ERROR; // Make sure /usr-move is working - r = pakfire_usrmove(transaction->ctx, transaction->root); - if (r) + r = pakfire_usrmove(self->ctx, self->root); + if (r < 0) goto ERROR; // Execute all pre transaction actions - r = pakfire_transaction_run_steps(transaction, db, jail, PAKFIRE_ACTION_PRETRANS); - if (r) + r = pakfire_transaction_run_steps(self, db, jail, PAKFIRE_ACTION_PRETRANS); + if (r < 0) goto ERROR; - r = pakfire_transaction_run_steps(transaction, db, jail, PAKFIRE_ACTION_EXECUTE); - if (r) + r = pakfire_transaction_run_steps(self, db, jail, PAKFIRE_ACTION_EXECUTE); + if (r < 0) goto ERROR; // Execute all post transaction actions - r = pakfire_transaction_run_steps(transaction, db, jail, PAKFIRE_ACTION_POSTTRANS); - if (r) + r = pakfire_transaction_run_steps(self, db, jail, PAKFIRE_ACTION_POSTTRANS); + if (r < 0) goto ERROR; // Finish progress - r = pakfire_progress_finish(transaction->progress); + r = pakfire_progress_finish(self->progress); if (r < 0) goto ERROR; - DEBUG(transaction->ctx, "The transaction has finished successfully\n"); + DEBUG(self->ctx, "The transaction has finished successfully\n"); // Reload database for next transaction - repo = pakfire_root_get_installed_repo(transaction->root); + repo = pakfire_root_get_installed_repo(self->root); if (!repo) goto ERROR; @@ -1951,7 +1946,7 @@ ERROR: return r; } -static int pakfire_transaction_download_package(pakfire_transaction* transaction, +static int pakfire_transaction_download_package(pakfire_transaction* self, pakfire_httpclient* httpclient, pakfire_package* pkg) { pakfire_repo* repo = NULL; pakfire_xfer* xfer = NULL; @@ -1984,10 +1979,10 @@ ERROR: } static int pakfire_transaction_package_needs_download( - pakfire_transaction* transaction, pakfire_package* pkg) { + pakfire_transaction* self, pakfire_package* pkg) { int r; - enum pakfire_steps type = pakfire_transaction_get_step_type(transaction, pkg); + enum pakfire_steps type = pakfire_transaction_get_step_type(self, pkg); switch (type) { case PAKFIRE_STEP_INSTALL: case PAKFIRE_STEP_REINSTALL: @@ -2023,30 +2018,30 @@ static int pakfire_transaction_package_needs_download( } } -int pakfire_transaction_download(pakfire_transaction* transaction) { +int pakfire_transaction_download(pakfire_transaction* self) { pakfire_httpclient* httpclient = NULL; int r; // Initialize the HTTP client - r = pakfire_httpclient_create(&httpclient, transaction->ctx, 0); + r = pakfire_httpclient_create(&httpclient, self->ctx, 0); if (r) { - ERROR(transaction->ctx, "Could not initialize HTTP client: %m\n"); + ERROR(self->ctx, "Could not initialize HTTP client: %m\n"); return 1; } // Add all packages that need to be downloaded - for (unsigned int i = 0; i < transaction->num; i++) { - pakfire_package* pkg = transaction->packages[i]; + for (unsigned int i = 0; i < self->num; i++) { + pakfire_package* pkg = self->packages[i]; - if (!pakfire_transaction_package_needs_download(transaction, pkg)) + if (!pakfire_transaction_package_needs_download(self, pkg)) continue; // Enqueue download - r = pakfire_transaction_download_package(transaction, httpclient, pkg); + r = pakfire_transaction_download_package(self, httpclient, pkg); if (r) { const char* nevra = pakfire_package_get_string(pkg, PAKFIRE_PKG_NEVRA); - ERROR(transaction->ctx, "Could not add download to queue: %s: %m\n", nevra); + ERROR(self->ctx, "Could not add download to queue: %s: %m\n", nevra); goto ERROR; } } @@ -2060,45 +2055,45 @@ ERROR: return r; } -int pakfire_transaction_run(pakfire_transaction* transaction) { +int pakfire_transaction_run(pakfire_transaction* self) { char* dump = NULL; int r; // Automatically solve if not done, yet - if (!transaction->transaction) { - r = pakfire_transaction_solve(transaction, 0, NULL); + if (!self->transaction) { + r = pakfire_transaction_solve(self, 0, NULL); if (r) goto ERROR; } // Skip running an empty transaction - if (!transaction->num) { - DEBUG(transaction->ctx, "Empty transaction. Skipping...\n"); + if (!self->num) { + DEBUG(self->ctx, "Empty transaction. Skipping...\n"); return 0; } // Show what would be done - dump = pakfire_transaction_dump(transaction, 80); + dump = pakfire_transaction_dump(self, 80); // Check if we should continue - r = pakfire_ctx_confirm(transaction->ctx, transaction->root, dump, _("Is this okay?")); + r = pakfire_ctx_confirm(self->ctx, self->root, dump, _("Is this okay?")); if (r) { - ERROR(transaction->ctx, "Transaction aborted upon user request\n"); + ERROR(self->ctx, "Transaction aborted upon user request\n"); goto ERROR; } // Perform a check if this can actually be run - r = pakfire_transaction_check(transaction); + r = pakfire_transaction_check(self); if (r) goto ERROR; // Download what we need - r = pakfire_transaction_download(transaction); + r = pakfire_transaction_download(self); if (r) goto ERROR; // Perform all steps - r = pakfire_transaction_perform(transaction); + r = pakfire_transaction_perform(self); if (r) goto ERROR; @@ -2110,25 +2105,25 @@ ERROR: return r; } -int pakfire_transaction_compose_repo(pakfire_transaction* transaction, +int pakfire_transaction_compose_repo(pakfire_transaction* self, pakfire_key* key, const char* path) { pakfire_archive* archive = NULL; int r; // Allocate an array for all files - const char* files[transaction->num + 1]; + const char* files[self->num + 1]; unsigned int num = 0; - DEBUG(transaction->ctx, "Writing transaction to %s...\n", path); + DEBUG(self->ctx, "Writing transaction to %s...\n", path); // Open all archives - r = pakfire_transaction_open_archives(transaction, NULL); + r = pakfire_transaction_open_archives(self, NULL); if (r) return r; // Walk through all steps - for (unsigned int i = 0; i < transaction->num; i++) { - archive = transaction->archives[i]; + for (unsigned int i = 0; i < self->num; i++) { + archive = self->archives[i]; // Skip steps that don't have an archive if (!archive) @@ -2142,5 +2137,5 @@ int pakfire_transaction_compose_repo(pakfire_transaction* transaction, files[num] = NULL; // Create the repository - return pakfire_repo_compose(transaction->ctx, transaction->root, path, key, files); + return pakfire_repo_compose(self->ctx, self->root, path, key, files); } diff --git a/src/pakfire/transaction.h b/src/pakfire/transaction.h index 21cc07d7..80fcc05a 100644 --- a/src/pakfire/transaction.h +++ b/src/pakfire/transaction.h @@ -63,30 +63,29 @@ enum pakfire_job_flags { int pakfire_transaction_create(pakfire_transaction** transaction, pakfire_ctx* ctx, pakfire_root* root, int flags); -pakfire_transaction* pakfire_transaction_ref(pakfire_transaction* transaction); -pakfire_transaction* pakfire_transaction_unref(pakfire_transaction* transaction); +pakfire_transaction* pakfire_transaction_ref(pakfire_transaction* self); +pakfire_transaction* pakfire_transaction_unref(pakfire_transaction* self); -int pakfire_transaction_solve(pakfire_transaction* transaction, int flags, char** problems); +int pakfire_transaction_solve(pakfire_transaction* self, int flags, char** problems); -int pakfire_transaction_request(pakfire_transaction* transaction, +int pakfire_transaction_request(pakfire_transaction* self, const enum pakfire_job_action action, const char* what, int flags); -int pakfire_transaction_request_package(pakfire_transaction* transaction, +int pakfire_transaction_request_package(pakfire_transaction* self, const enum pakfire_job_action action, pakfire_package* package, int flags); -pakfire_problem** pakfire_transaction_get_problems(pakfire_transaction* transaction); -int pakfire_transaction_take_solution( - pakfire_transaction* transaction, pakfire_solution* solution); +pakfire_problem** pakfire_transaction_get_problems(pakfire_transaction* self); +int pakfire_transaction_take_solution(pakfire_transaction* self, pakfire_solution* solution); -size_t pakfire_transaction_count(pakfire_transaction* transaction); -char* pakfire_transaction_dump(pakfire_transaction* transaction, size_t width); +size_t pakfire_transaction_count(pakfire_transaction* self); +char* pakfire_transaction_dump(pakfire_transaction* self, size_t width); -int pakfire_transaction_run(pakfire_transaction* transaction); +int pakfire_transaction_run(pakfire_transaction* self); -int pakfire_transaction_download(pakfire_transaction* transaction); +int pakfire_transaction_download(pakfire_transaction* self); -Solver* pakfire_transaction_get_solver(pakfire_transaction* transaction); +Solver* pakfire_transaction_get_solver(pakfire_transaction* self); -int pakfire_transaction_compose_repo(pakfire_transaction* transaction, - pakfire_key* key, const char* path); +int pakfire_transaction_compose_repo( + pakfire_transaction* self, pakfire_key* key, const char* path); #endif /* PAKFIRE_TRANSACTION_H */