Struct libflatpak::Transaction

pub struct Transaction { /* private fields */ }

Properties

installation

The installation that the transaction operates on.

Readable | Writeable | Construct Only

no-interaction

true if the transaction is not interactive, false otherwise.

See TransactionExt::set_no_interaction().

Readable | Writeable

Signals

add-new-remote

The ::add-new-remote signal gets emitted if, as part of the transaction, it is required or recommended that a new remote is added, for the reason described in reason.

basic-auth-start

The ::basic-auth-start signal gets emitted when a basic user/password authentication is needed during the operation. If the caller handles this it should ask the user for the user and password and return true. Once the information is gathered call TransactionExt::complete_basic_auth() with it.

If the client does not support basic auth then return false from this signal (or don’t implement it). This will abort the authentication and likely result in the transaction failing (unless the authentication was somehow optional).

choose-remote-for-ref

The ::choose-remote-for-ref signal gets emitted when a remote needs to be selected during the execution of the transaction.

end-of-lifed

The ::end-of-lifed signal gets emitted when a ref is found to be marked as end-of-life during the execution of the transaction.

end-of-lifed-with-rebase

The ::end-of-lifed-with-rebase signal gets emitted when a ref is found to be marked as end-of-life before the transaction begins. Unlike end-of-lifed, this signal allows for the transaction to be modified in order to e.g. install the rebased ref.

If the caller wants to install the rebased ref, they should call [TransactionExt::add_rebase_and_uninstall()][crate::prelude::TransactionExt::add_rebase_and_uninstall()] on rebased_to_ref and ref_, and return true. Otherwise false may be returned.

install-authenticator

The ::install-authenticator signal gets emitted if, as part of resolving the transaction, we need to use an authenticator, but the authentication is not installed, but is available to be installed from the ref.

The application can handle this signal, and if so create another transaction to install the authenticator.

The default handler does nothing, and if the authenticator is not installed when the signal handler fails the transaction will error out.

new-operation

The ::new-operation signal gets emitted during the execution of the transaction when a new operation is beginning.

operation-done

The ::operation-done signal gets emitted during the execution of the transaction when an operation is finished.

operation-error

The ::operation-error signal gets emitted when an error occurs during the execution of the transaction.

ready

The ::ready signal is emitted when all the refs involved in the operation have been resolved to commits, and the required authentication for all ops is gotten. At this point TransactionExt::operations() will return all the operations that will be executed as part of the transaction.

ready-pre-auth

The ::ready-pre-auth signal is emitted when all the refs involved in the transaction have been resolved to commits, but we might not necessarily have asked for authentication for all their required operations. This is very similar to the ::ready signal, and you can choose which one (or both) to use depending on how you want to handle authentication in your user interface.

At this point TransactionExt::operations() will return all the operations that will be executed as part of the transaction. You can call TransactionOperation::requires_authentication() to see which will require authentication.

webflow-done

The ::webflow-done signal gets emitted when the authentication finished the webflow, independent of the reason and results. If you for were showing a web-browser window it can now be closed.

webflow-start

The ::webflow-start signal gets emitted when some kind of user authentication is needed during the operation. If the caller handles this it should show the url in a webbrowser and return true. This will eventually cause the webbrowser to finish the authentication operation and operation will continue, as signaled by the webflow-done being emitted.

If the client does not support webflow then return false from this signal (or don’t implement it). This will abort the authentication and likely result in the transaction failing (unless the authentication was somehow optional).

During the time between webflow-start and webflow-done the client can call TransactionExt::abort_webflow() to manually abort the authentication. This is useful if the user aborted the authentication operation some way, like e.g. closing the browser window.

Implements

TransactionExt, gio::prelude::InitableExt, TransactionExtManual

Implementations

impl Transaction

pub const NONE: Option<&'static Transaction> = None

pub fn for_installation( installation: &impl IsA<Installation>, cancellable: Option<&impl IsA<Cancellable>> ) -> Result<Transaction, Error>

Creates a new Transaction object that can be used to do installation and updates of multiple refs, as well as their dependencies, in a single operation. Set the options you want on the transaction and add the refs you want to install/update, then start the transaction with flatpak_transaction_run ().

installation

a Installation

cancellable

a gio::Cancellable

Returns

a Transaction, or None on failure.

pub fn builder() -> TransactionBuilder

Creates a new builder-pattern struct instance to construct Transaction objects.

This method returns an instance of TransactionBuilder which can be used to create Transaction objects.

Trait Implementations

impl Clone for Transaction

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Transaction

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl HasParamSpec for Transaction

type ParamSpec = ParamSpecObject

type SetValue = Transaction

Preferred value to be used as setter for the associated ParamSpec.

type BuilderFn = fn(_: &str) -> ParamSpecObjectBuilder<'_, Transaction>

fn param_spec_builder() -> Self::BuilderFn

impl Hash for Transaction

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Transaction

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl ParentClassIs for Transaction

type Parent = Object

impl<OT: ObjectType> PartialEq<OT> for Transaction

fn eq(&self, other: &OT) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<OT: ObjectType> PartialOrd<OT> for Transaction

fn partial_cmp(&self, other: &OT) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl StaticType for Transaction

fn static_type() -> Type

Returns the type identifier of Self.

impl Eq for Transaction

impl IsA<Initable> for Transaction