/** Initializes a transaction * @param self a Handle object * ... * @return a Transaction object with the same underlying object */ PyObject* pyalpm_trans_init(PyObject *self, PyObject *args, PyObject *kwargs) { alpm_handle_t *handle = ALPM_HANDLE(self); PyObject *result; const char* keywords[] = { INDEX_FLAGS(flagnames), NULL }; char flags[18] = "\0\0\0\0\0" /* 5 */ "\0\0\0\0\0" /* 10 */ "\0\0\0\0\0" /* 15 */ "\0\0\0"; /* check all arguments */ if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|bbbbbbbbbbbbbbbbOOO", (char**)keywords, INDEX_FLAGS(&flags))) { return NULL; } /* run alpm_trans_init() */ { alpm_transflag_t flag_int = 0; int i, ret; for (i = 0; i < 18; i++) { if (flags[i]) flag_int |= 1U << i; } ret = alpm_trans_init(handle, flag_int); if (ret == -1) { RET_ERR("transaction could not be initialized", alpm_errno(handle), NULL); } } result = pyalpm_transaction_from_pmhandle(handle); return result; }
int lalpm_trans_init ( lua_State *L ) { pmtransflag_t flags; int result; lua_getfield( L, -1, "flags" ); if ( ! lua_istable( L, -1 )) { lua_pushstring( L, "No 'flags' field was provided to trans_init!" ); lua_error( L ); } flags = lualpm_totransflags( L ); lua_pop( L, 1 ); /* Pop the flags table off the stack. */ /* Registering a nil value with these is alright. In fact it is better than running old callbacks. */ lua_getfield( L, -1, "eventscb" ); cb_register( L, &transcb_key_event ); lua_getfield( L, -1, "convcb" ); cb_register( L, &transcb_key_conv ); lua_getfield( L, -1, "progresscb" ); cb_register( L, &transcb_key_progress ); result = alpm_trans_init( flags, transcb_cfunc_event, transcb_cfunc_conv, transcb_cfunc_progress ); lua_pushnumber(L, result); return 1; }
gboolean pk_backend_transaction_initialize (PkBackend *self, alpm_transflag_t flags, GError **error) { g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (alpm != NULL, FALSE); g_return_val_if_fail (cancellable != NULL, FALSE); if (alpm_trans_init (alpm, flags) < 0) { alpm_errno_t errno = alpm_errno (alpm); g_set_error_literal (error, ALPM_ERROR, errno, alpm_strerror (errno)); return FALSE; } alpm_option_set_eventcb (alpm, pk_backend_transaction_event_cb); alpm_option_set_questioncb (alpm, pk_backend_transaction_conv_cb); alpm_option_set_progresscb (alpm, pk_backend_transaction_progress_cb); alpm_option_set_dlcb (alpm, pk_backend_transaction_dlcb); alpm_option_set_totaldlcb (alpm, pk_backend_transaction_totaldlcb); g_cancellable_connect (cancellable, G_CALLBACK (transaction_cancelled_cb), self, NULL); return TRUE; }
int trans_init(alpm_transflag_t flags, int check_valid) { int ret; check_syncdbs(0, check_valid); ret = alpm_trans_init(config->handle, flags); if(ret == -1) { trans_init_error(); return -1; } return 0; }
/* * Return: 0 for success. */ int ipacman_sync_packages(alpm_list_t *targets) { int ret = 0; alpm_list_t *i; alpm_list_t *sync_dbs = alpm_get_syncdbs(handle); if(sync_dbs == NULL) { printf("no usable package repositories configured.\n"); return 1; } /* ensure all known dbs are valid */ for(i = sync_dbs; i; i = alpm_list_next(i)) { alpm_db_t *db = i->data; if(alpm_db_get_valid(db)) { printf("database '%s' is not valid (%s)\n", alpm_db_get_name(db), alpm_strerror(alpm_errno(handle))); ret = 1; } } if (ret) return ret; /* Step 1: create a new transaction... */ ret = alpm_trans_init(handle, ALPM_TRANS_FLAG_FORCE); if(ret == -1) { trans_init_error(handle); return 1; } /* process targets */ for(i = targets; i; i = alpm_list_next(i)) { const char *targ = i->data; if(process_target(targ, ret) == 1) { ret = 1; } } if(ret) { if(alpm_trans_release(handle) == -1) { printf("failed to release transaction (%s)\n", alpm_strerror(alpm_errno(handle))); } return ret; } return sync_prepare_execute(); }
gboolean pacman_transaction_start (guint32 flags, GError **error) { g_return_val_if_fail (pacman_manager != NULL, FALSE); if (pacman_manager_get_transaction (pacman_manager) != NULL) { PacmanError code = PACMAN_ERROR_TRANSACTION_ALREADY_INITIALIZED; g_set_error (error, PACMAN_ERROR, code, _("Could not initialize transaction: %s"), alpm_strerror (code)); return FALSE; } if (alpm_trans_init (flags, pacman_transaction_event_cb, pacman_transaction_question_cb, pacman_transaction_progress_cb) < 0) { if (pm_errno == PACMAN_ERROR_ALREADY_RUNNING) { g_message (_("If you are certain no other package manager is running, you can remove %s\n"), alpm_option_get_lockfile ()); } g_set_error (error, PACMAN_ERROR, pm_errno, _("Could not initialize transaction: %s"), alpm_strerrorlast ()); return FALSE; } alpm_option_set_dlcb (pacman_transaction_download_cb); alpm_option_set_totaldlcb (pacman_transaction_total_download_cb); return TRUE; }
/** * call-seq: * transaction( [ flags ] ){|transaction|...} → an_object * * Puts libalpm into transaction mode, i.e. allows you to add * and remove packaages by means of a transaction. The block * gets called with an instance of the (otherwise uninstanciatable, * this is a libalpm restriction) Transaction class, which you can * freely modify for your operations. When you added all packages * you want to add/remove to/from the system, call Transaction#prepare * in order to have libalpm resolve dependencies and other stuff. * You can then call Transaction#commit to execute your transaction. * * === Parameters * [flags ({})] * A hash with the following keys: * [:nodeps] * Ignore dependency checks. * [:force] * Ignore file conflicts and overwrite files. * [:nosave] * Delete files even if they are tagged as backup. * [:nodepversion] * Ignore version numbers when checking dependencies. * [:cascade] * Remove also any packages depending on a package being removed. * [:recurse] * Remove packages and their unneeded deps (not explicitely installed). * [:dbonly] * Modify database but do not commit changes to the filesystem. * [:alldeps] * Use ALPM_REASON_DEPEND when installing packages. * [:downloadonly] * Only download packages and do not actually install. * [:noscriptlet] * Do not execute install scriptlets after installing. * [:noconflicts] * Ignore dependency conflicts. * [:needed] * Do not install a package if it is already installed and up to date. * [:allexplicit] * Use ALPM_PKG_REASON_EXPLICIT when installing packages. * [:unneeded] * Do not remove a package if it is needed by another one. * [:recurseall] * Remove also explicitely installed unneeded deps (use with :recurse). * [:nolock] * Do not lock the database during the operation. * * === Return value * The result of the block’s last expression. * * === Remarks * Do not store the Transaction instance somewhere; this will give * you grief, because it is a transient object always referring to * the currently active transaction or bomb if there is none. */ static VALUE transaction(int argc, VALUE argv[], VALUE self) { VALUE transaction; VALUE result; alpm_handle_t* p_alpm = NULL; alpm_transflag_t flags = 0; Data_Get_Struct(self, alpm_handle_t, p_alpm); if (argc == 1) { if (TYPE(argv[0]) != T_HASH) rb_raise(rb_eTypeError, "Argument is not a hash."); if (rb_hash_aref(flags, STR2SYM("nodeps"))) flags |= ALPM_TRANS_FLAG_NODEPS; if (rb_hash_aref(flags, STR2SYM("force"))) flags |= ALPM_TRANS_FLAG_FORCE; if (rb_hash_aref(flags, STR2SYM("nosave"))) flags |= ALPM_TRANS_FLAG_NOSAVE; if (rb_hash_aref(flags, STR2SYM("nodepversion"))) flags |= ALPM_TRANS_FLAG_NODEPVERSION; if (rb_hash_aref(flags, STR2SYM("cascade"))) flags |= ALPM_TRANS_FLAG_CASCADE; if (rb_hash_aref(flags, STR2SYM("recurse"))) flags |= ALPM_TRANS_FLAG_RECURSE; if (rb_hash_aref(flags, STR2SYM("dbonly"))) flags |= ALPM_TRANS_FLAG_DBONLY; if (rb_hash_aref(flags, STR2SYM("alldeps"))) flags |= ALPM_TRANS_FLAG_ALLDEPS; if (rb_hash_aref(flags, STR2SYM("downloadonly"))) flags |= ALPM_TRANS_FLAG_DOWNLOADONLY; if (rb_hash_aref(flags, STR2SYM("noscriptlet"))) flags |= ALPM_TRANS_FLAG_NOSCRIPTLET; if (rb_hash_aref(flags, STR2SYM("noconflicts"))) flags |= ALPM_TRANS_FLAG_NOCONFLICTS; if (rb_hash_aref(flags, STR2SYM("needed"))) flags |= ALPM_TRANS_FLAG_NEEDED; if (rb_hash_aref(flags, STR2SYM("allexplicit"))) flags |= ALPM_TRANS_FLAG_ALLEXPLICIT; if (rb_hash_aref(flags, STR2SYM("unneeded"))) flags |= ALPM_TRANS_FLAG_UNNEEDED; if (rb_hash_aref(flags, STR2SYM("recurseall"))) flags |= ALPM_TRANS_FLAG_RECURSEALL; if (rb_hash_aref(flags, STR2SYM("nolock"))) flags |= ALPM_TRANS_FLAG_NOLOCK; } else { rb_raise(rb_eArgError, "Wrong number of arguments, expected 0..1, got %d.", argc); return Qnil; } /* Create the transaction */ if (alpm_trans_init(p_alpm, flags) < 0) return raise_last_alpm_error(p_alpm); /* Create an instance of Transaction. Note that alpm forces * you to only have *one* single Transaction instance, hence * there is no other way to instanciate this class apart from * this method. The user now modify and exute this sole * transaction. */ transaction = rb_obj_alloc(rb_cAlpm_Transaction); rb_iv_set(transaction, "@alpm", self); result = rb_yield(transaction); /* When we get here we assume the user is done with * his stuff. Clean up. */ if (alpm_trans_release(p_alpm) < 0) return raise_last_alpm_error(p_alpm); /* Return the last value from the block */ return result; }