static PyObject* pyalpm_trans_commit(PyObject *self, PyObject *args) {
alpm_handle_t *handle = ALPM_HANDLE(self);
alpm_list_t *data = NULL;
int ret;
enum _alpm_errno_t err;
PyObject *err_info = NULL;
ret = alpm_trans_commit(handle, &data);
if (ret == 0) Py_RETURN_NONE;
if (ret != -1) {
PyErr_Format(PyExc_RuntimeError,
"unexpected return value %d from alpm_trans_commit()", ret);
return NULL;
}
err = alpm_errno(handle);
switch(err) {
case ALPM_ERR_FILE_CONFLICTS:
/* return the list of file conflicts in the exception */
err_info = alpmlist_to_pylist(data, pyobject_from_pmfileconflict);
break;
case ALPM_ERR_PKG_INVALID:
case ALPM_ERR_PKG_INVALID_CHECKSUM:
case ALPM_ERR_PKG_INVALID_SIG:
case ALPM_ERR_DLT_INVALID:
err_info = alpmlist_to_pylist(data, pyobject_from_string);
break;
default:
break;
}
if (err_info)
RET_ERR_DATA("transaction failed", err, err_info, NULL);
else
RET_ERR("transaction failed", err, NULL);
}
static gboolean pacman_transaction_real_commit (PacmanTransaction *transaction, GError **error) {
g_return_val_if_fail (transaction != NULL, FALSE);
if (alpm_trans_commit (NULL) < 0) {
g_set_error (error, PACMAN_ERROR, pm_errno, _("Could not commit transaction: %s"), alpm_strerrorlast ());
return FALSE;
}
return TRUE;
}
gboolean
pk_backend_transaction_commit (PkBackend *self, GError **error)
{
alpm_list_t *data = NULL;
gchar *prefix;
g_return_val_if_fail (self != NULL, FALSE);
g_return_val_if_fail (alpm != NULL, FALSE);
if (pk_backend_cancelled (self)) {
return TRUE;
}
pk_backend_job_set_allow_cancel (self, FALSE);
pk_backend_job_set_status (self, PK_STATUS_ENUM_RUNNING);
if (alpm_trans_commit (alpm, &data) >= 0) {
return TRUE;
}
switch (alpm_errno (alpm)) {
case ALPM_ERR_FILE_CONFLICTS:
prefix = alpm_fileconflict_build_list (data);
alpm_list_free_inner (data, alpm_fileconflict_free);
alpm_list_free (data);
break;
case ALPM_ERR_PKG_INVALID:
case ALPM_ERR_DLT_INVALID:
prefix = alpm_string_build_list (data);
alpm_list_free (data);
break;
default:
prefix = NULL;
if (data != NULL) {
g_warning ("unhandled error %d",
alpm_errno (alpm));
}
break;
}
if (prefix != NULL) {
alpm_errno_t errno = alpm_errno (alpm);
g_set_error (error, ALPM_ERROR, errno, "%s: %s", prefix,
alpm_strerror (errno));
g_free (prefix);
} else {
alpm_errno_t errno = alpm_errno (alpm);
g_set_error_literal (error, ALPM_ERROR, errno,
alpm_strerror (errno));
}
return FALSE;
}
/* int alpm_trans_commit(alpm_list_t **data); */
int lalpm_trans_commit(lua_State *L)
{
luaL_checktype(L, 1, LUA_TTABLE);
alpm_list_t *list = lstring_table_to_alpm_list(L, 1);
const int result = alpm_trans_commit(&list);
lua_pushnumber(L, result);
if (result == -1) {
switch(pm_errno) {
case PM_ERR_FILE_CONFLICTS:
alpm_list_to_any_table(L, list, PMFILECONFLICT_T);
break;
case PM_ERR_PKG_INVALID:
case PM_ERR_DLT_INVALID:
alpm_list_to_any_table(L, list, STRING);
break;
default:
break;
}
return 2;
}
return 1;
}
/**
* @brief Upgrade a specified list of packages.
*
* @param targets a list of packages (as strings) to upgrade
*
* @return 0 on success, 1 on failure
*/
int pacman_upgrade(alpm_list_t *targets)
{
alpm_list_t *i, *data = NULL;
pgp_verify_t check_sig = alpm_option_get_default_sigverify(config->handle);
int retval = 0;
if(targets == NULL) {
pm_printf(PM_LOG_ERROR, _("no targets specified (use -h for help)\n"));
return 1;
}
/* Check for URL targets and process them
*/
for(i = targets; i; i = alpm_list_next(i)) {
if(strstr(i->data, "://")) {
char *str = alpm_fetch_pkgurl(config->handle, i->data);
if(str == NULL) {
pm_fprintf(stderr, PM_LOG_ERROR, "'%s': %s\n",
(char *)i->data, alpm_strerror(alpm_errno(config->handle)));
return 1;
} else {
free(i->data);
i->data = str;
}
}
}
/* Step 1: create a new transaction */
if(trans_init(config->flags) == -1) {
return 1;
}
/* add targets to the created transaction */
for(i = targets; i; i = alpm_list_next(i)) {
char *targ = alpm_list_getdata(i);
pmpkg_t *pkg;
if(alpm_pkg_load(config->handle, targ, 1, check_sig, &pkg) != 0) {
pm_fprintf(stderr, PM_LOG_ERROR, "'%s': %s\n",
targ, alpm_strerror(alpm_errno(config->handle)));
trans_release();
return 1;
}
if(alpm_add_pkg(config->handle, pkg) == -1) {
pm_fprintf(stderr, PM_LOG_ERROR, "'%s': %s\n",
targ, alpm_strerror(alpm_errno(config->handle)));
alpm_pkg_free(pkg);
trans_release();
return 1;
}
}
/* Step 2: "compute" the transaction based on targets and flags */
/* TODO: No, compute nothing. This is stupid. */
if(alpm_trans_prepare(config->handle, &data) == -1) {
enum _pmerrno_t err = alpm_errno(config->handle);
pm_fprintf(stderr, PM_LOG_ERROR, _("failed to prepare transaction (%s)\n"),
alpm_strerror(err));
switch(err) {
case PM_ERR_PKG_INVALID_ARCH:
for(i = data; i; i = alpm_list_next(i)) {
char *pkg = alpm_list_getdata(i);
printf(_(":: package %s does not have a valid architecture\n"), pkg);
}
break;
case PM_ERR_UNSATISFIED_DEPS:
for(i = data; i; i = alpm_list_next(i)) {
pmdepmissing_t *miss = alpm_list_getdata(i);
char *depstring = alpm_dep_compute_string(miss->depend);
/* TODO indicate if the error was a virtual package or not:
* :: %s: requires %s, provided by %s
*/
printf(_(":: %s: requires %s\n"), miss->target, depstring);
free(depstring);
}
break;
case PM_ERR_CONFLICTING_DEPS:
for(i = data; i; i = alpm_list_next(i)) {
pmconflict_t *conflict = alpm_list_getdata(i);
if(strcmp(conflict->package1, conflict->reason) == 0 ||
strcmp(conflict->package2, conflict->reason) == 0) {
printf(_(":: %s and %s are in conflict\n"),
conflict->package1, conflict->package2);
} else {
printf(_(":: %s and %s are in conflict (%s)\n"),
conflict->package1, conflict->package2, conflict->reason);
}
}
break;
default:
break;
}
trans_release();
FREELIST(data);
return 1;
}
/* Step 3: perform the installation */
alpm_list_t *packages = alpm_trans_get_add(config->handle);
if(config->print) {
print_packages(packages);
trans_release();
return 0;
}
/* print targets and ask user confirmation */
if(packages == NULL) { /* we are done */
printf(_(" there is nothing to do\n"));
trans_release();
return retval;
}
display_targets(alpm_trans_get_remove(config->handle), 0);
display_targets(alpm_trans_get_add(config->handle), 1);
printf("\n");
int confirm = yesno(_("Proceed with installation?"));
if(!confirm) {
trans_release();
return retval;
}
if(alpm_trans_commit(config->handle, &data) == -1) {
enum _pmerrno_t err = alpm_errno(config->handle);
pm_fprintf(stderr, PM_LOG_ERROR, _("failed to commit transaction (%s)\n"),
alpm_strerror(err));
switch(err) {
case PM_ERR_FILE_CONFLICTS:
for(i = data; i; i = alpm_list_next(i)) {
pmfileconflict_t *conflict = alpm_list_getdata(i);
switch(conflict->type) {
case PM_FILECONFLICT_TARGET:
printf(_("%s exists in both '%s' and '%s'\n"),
conflict->file, conflict->target, conflict->ctarget);
break;
case PM_FILECONFLICT_FILESYSTEM:
printf(_("%s: %s exists in filesystem\n"),
conflict->target, conflict->file);
break;
}
}
break;
case PM_ERR_PKG_INVALID:
case PM_ERR_DLT_INVALID:
for(i = data; i; i = alpm_list_next(i)) {
char *filename = alpm_list_getdata(i);
printf(_("%s is invalid or corrupted\n"), filename);
}
break;
default:
break;
}
FREELIST(data);
trans_release();
return 1;
}
if(trans_release() == -1) {
retval = 1;
}
return retval;
}
static int sync_prepare_execute(void)
{
alpm_list_t *i, *packages, *data = NULL;
int retval = 0;
/* Step 2: "compute" the transaction based on targets and flags */
if(alpm_trans_prepare(handle, &data) == -1) {
alpm_errno_t err = alpm_errno(handle);
printf("failed to prepare transaction (%s)\n", alpm_strerror(err));
switch(err) {
case ALPM_ERR_PKG_INVALID_ARCH:
for(i = data; i; i = alpm_list_next(i)) {
const char *pkg = i->data;
printf("package %s does not have a valid architecture\n", pkg);
}
break;
case ALPM_ERR_UNSATISFIED_DEPS:
for(i = data; i; i = alpm_list_next(i)) {
alpm_depmissing_t *miss = i->data;
char *depstring = alpm_dep_compute_string(miss->depend);
printf("%s: requires %s\n", miss->target, depstring);
free(depstring);
}
break;
case ALPM_ERR_CONFLICTING_DEPS:
for(i = data; i; i = alpm_list_next(i)) {
alpm_conflict_t *conflict = i->data;
/* only print reason if it contains new information */
if(conflict->reason->mod == ALPM_DEP_MOD_ANY) {
printf("%s and %s are in conflict\n",
conflict->package1, conflict->package2);
} else {
char *reason = alpm_dep_compute_string(conflict->reason);
printf("%s and %s are in conflict (%s)\n",
conflict->package1, conflict->package2, reason);
free(reason);
}
}
break;
default:
break;
}
retval = 1;
goto cleanup;
}
packages = alpm_trans_get_add(handle);
if(packages == NULL) {
/* nothing to do: just exit without complaining */
printf(" there is nothing to do\n");
goto cleanup;
}
printf("\n");
if(alpm_trans_commit(handle, &data) == -1) {
alpm_errno_t err = alpm_errno(handle);
printf("failed to commit transaction (%s)\n",
alpm_strerror(err));
switch(err) {
case ALPM_ERR_FILE_CONFLICTS:
printf("unable to %s directory-file conflicts\n", "--force");
for(i = data; i; i = alpm_list_next(i)) {
alpm_fileconflict_t *conflict = i->data;
switch(conflict->type) {
case ALPM_FILECONFLICT_TARGET:
printf("%s exists in both '%s' and '%s'\n",
conflict->file, conflict->target, conflict->ctarget);
break;
case ALPM_FILECONFLICT_FILESYSTEM:
printf("%s: %s exists in filesystem\n",
conflict->target, conflict->file);
break;
}
}
break;
case ALPM_ERR_PKG_INVALID:
case ALPM_ERR_PKG_INVALID_CHECKSUM:
case ALPM_ERR_PKG_INVALID_SIG:
case ALPM_ERR_DLT_INVALID:
for(i = data; i; i = alpm_list_next(i)) {
const char *filename = i->data;
printf("%s is invalid or corrupted\n", filename);
}
break;
default:
break;
}
/* TODO: stderr? */
printf("Errors occurred, no packages were upgraded.\n");
retval = 1;
goto cleanup;
}
/* Step 4: release transaction resources */
cleanup:
if(data) {
FREELIST(data);
}
if(trans_release(handle) == -1) {
retval = 1;
}
return retval;
}
/**
* @brief Remove a specified list of packages.
*
* @param targets a list of packages (as strings) to remove from the system
*
* @return 0 on success, 1 on failure
*/
int pacman_remove(alpm_list_t *targets)
{
int retval = 0;
alpm_list_t *i, *data = NULL;
if(targets == NULL) {
pm_printf(PM_LOG_ERROR, _("no targets specified (use -h for help)\n"));
return(1);
}
/* Step 0: create a new transaction */
if(trans_init(PM_TRANS_TYPE_REMOVE, config->flags) == -1) {
return(1);
}
/* Step 1: add targets to the created transaction */
for(i = targets; i; i = alpm_list_next(i)) {
char *targ = alpm_list_getdata(i);
if(alpm_trans_addtarget(targ) == -1) {
if(pm_errno == PM_ERR_PKG_NOT_FOUND) {
printf(_("%s not found, searching for group...\n"), targ);
pmgrp_t *grp = alpm_db_readgrp(db_local, targ);
if(grp == NULL) {
pm_fprintf(stderr, PM_LOG_ERROR, _("'%s': not found in local db\n"), targ);
retval = 1;
goto cleanup;
} else {
alpm_list_t *p, *pkgnames = NULL;
/* convert packages to package names */
for(p = alpm_grp_get_pkgs(grp); p; p = alpm_list_next(p)) {
pmpkg_t *pkg = alpm_list_getdata(p);
pkgnames = alpm_list_add(pkgnames, (void *)alpm_pkg_get_name(pkg));
}
printf(_(":: group %s:\n"), targ);
list_display(" ", pkgnames);
int all = yesno(1, _(" Remove whole content?"));
for(p = pkgnames; p; p = alpm_list_next(p)) {
char *pkgn = alpm_list_getdata(p);
if(all || yesno(1, _(":: Remove %s from group %s?"), pkgn, targ)) {
if(alpm_trans_addtarget(pkgn) == -1) {
pm_fprintf(stderr, PM_LOG_ERROR, "'%s': %s\n", targ,
alpm_strerrorlast());
retval = 1;
alpm_list_free(pkgnames);
goto cleanup;
}
}
}
alpm_list_free(pkgnames);
}
} else {
pm_fprintf(stderr, PM_LOG_ERROR, "'%s': %s\n", targ, alpm_strerrorlast());
retval = 1;
goto cleanup;
}
}
}
/* Step 2: prepare the transaction based on its type, targets and flags */
if(alpm_trans_prepare(&data) == -1) {
pm_fprintf(stderr, PM_LOG_ERROR, _("failed to prepare transaction (%s)\n"),
alpm_strerrorlast());
switch(pm_errno) {
case PM_ERR_UNSATISFIED_DEPS:
for(i = data; i; i = alpm_list_next(i)) {
pmdepmissing_t *miss = alpm_list_getdata(i);
pmdepend_t *dep = alpm_miss_get_dep(miss);
char *depstring = alpm_dep_get_string(dep);
printf(_(":: %s: requires %s\n"), alpm_miss_get_target(miss),
depstring);
free(depstring);
}
FREELIST(data);
break;
default:
break;
}
retval = 1;
goto cleanup;
}
/* Warn user in case of dangerous operation */
if(config->flags & PM_TRANS_FLAG_RECURSE ||
config->flags & PM_TRANS_FLAG_CASCADE) {
/* list transaction targets */
alpm_list_t *pkglist = alpm_trans_get_pkgs();
display_targets(pkglist, 0);
printf("\n");
/* get confirmation */
if(yesno(1, _("Do you want to remove these packages?")) == 0) {
retval = 1;
goto cleanup;
}
}
/* Step 3: actually perform the removal */
if(alpm_trans_commit(NULL) == -1) {
pm_fprintf(stderr, PM_LOG_ERROR, _("failed to commit transaction (%s)\n"),
alpm_strerrorlast());
retval = 1;
}
/* Step 4: release transaction resources */
cleanup:
if(trans_release() == -1) {
retval = 1;
}
return(retval);
}
/**
* @brief Remove a specified list of packages.
*
* @param targets a list of packages (as strings) to remove from the system
*
* @return 0 on success, 1 on failure
*/
int pacman_remove(alpm_list_t *targets)
{
int retval = 0;
alpm_list_t *i, *data = NULL;
if(targets == NULL) {
pm_printf(ALPM_LOG_ERROR, _("no targets specified (use -h for help)\n"));
return 1;
}
/* Step 0: create a new transaction */
if(trans_init(config->flags, 0) == -1) {
return 1;
}
/* Step 1: add targets to the created transaction */
for(i = targets; i; i = alpm_list_next(i)) {
char *target = i->data;
if(strncmp(target, "local/", 6) == 0) {
target += 6;
}
if(remove_target(target) == -1) {
retval = 1;
}
}
if(retval == 1) {
goto cleanup;
}
/* Step 2: prepare the transaction based on its type, targets and flags */
if(alpm_trans_prepare(config->handle, &data) == -1) {
alpm_errno_t err = alpm_errno(config->handle);
pm_printf(ALPM_LOG_ERROR, _("failed to prepare transaction (%s)\n"),
alpm_strerror(err));
switch(err) {
case ALPM_ERR_UNSATISFIED_DEPS:
for(i = data; i; i = alpm_list_next(i)) {
alpm_depmissing_t *miss = i->data;
char *depstring = alpm_dep_compute_string(miss->depend);
colon_printf(_("%s: requires %s\n"), miss->target, depstring);
free(depstring);
alpm_depmissing_free(miss);
}
break;
default:
break;
}
alpm_list_free(data);
retval = 1;
goto cleanup;
}
/* Search for holdpkg in target list */
int holdpkg = 0;
for(i = alpm_trans_get_remove(config->handle); i; i = alpm_list_next(i)) {
alpm_pkg_t *pkg = i->data;
if(alpm_list_find(config->holdpkg, alpm_pkg_get_name(pkg), fnmatch_cmp)) {
pm_printf(ALPM_LOG_WARNING, _("%s is designated as a HoldPkg.\n"),
alpm_pkg_get_name(pkg));
holdpkg = 1;
}
}
if(holdpkg && (noyes(_("HoldPkg was found in target list. Do you want to continue?")) == 0)) {
retval = 1;
goto cleanup;
}
/* Step 3: actually perform the removal */
alpm_list_t *pkglist = alpm_trans_get_remove(config->handle);
if(pkglist == NULL) {
printf(_(" there is nothing to do\n"));
goto cleanup; /* we are done */
}
if(config->print) {
print_packages(pkglist);
goto cleanup;
}
/* print targets and ask user confirmation */
display_targets();
printf("\n");
if(yesno(_("Do you want to remove these packages?")) == 0) {
retval = 1;
goto cleanup;
}
if(alpm_trans_commit(config->handle, &data) == -1) {
pm_printf(ALPM_LOG_ERROR, _("failed to commit transaction (%s)\n"),
alpm_strerror(alpm_errno(config->handle)));
retval = 1;
}
FREELIST(data);
/* Step 4: release transaction resources */
cleanup:
if(trans_release() == -1) {
retval = 1;
}
return retval;
}
