};
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) {
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;
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;
}
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;
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;
}
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:
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;
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)
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;
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++)
}
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;
}
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;
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++)
}
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);
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;
// 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) {
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;
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
}
// 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;
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;
// 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:
}
// 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);
// 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;
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;
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;
}
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;
}
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);
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;
}
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;
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;
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:
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
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;
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,
}
// 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) {
}
if (s)
- DEBUG(transaction->ctx, "%s", s);
+ DEBUG(self->ctx, "%s", s);
ERROR:
queue_free(&classes);
return s;
}
-static int pakfire_transaction_check_fileconflicts(
- pakfire_transaction* transaction) {
+static int pakfire_transaction_check_fileconflicts(pakfire_transaction* self) {
/*
XXX TODO
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;
// 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;
}
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;
// 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;
}
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;
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;
}
// 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;
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;
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);
}
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;
}
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)"))
}
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;
}
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
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;
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;
// 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;
}
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;
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;
}
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;
}
// 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;
}
}
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:
}
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) {
return r;
// Reference the archive
- transaction->archives[i] = archive;
+ self->archives[i] = archive;
// Count the total size if requested
if (total_size)
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;
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;
}
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:
}
}
-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;
}
}
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;
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)
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);
}
projects / pakfire.git / commitdiff
