flatpak_transaction_new_for_installation ()

FlatpakTransaction *
flatpak_transaction_new_for_installation
                               (FlatpakInstallation *installation,
                                GCancellable *cancellable,
                                GError **error);

Creates a new FlatpakTransaction 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().

flatpak_transaction_add_install ()

gboolean
flatpak_transaction_add_install (FlatpakTransaction *self,
                                 const char *remote,
                                 const char *ref,
                                 const char **subpaths,
                                 GError **error);

Adds installing the given ref to this transaction.

The remote can either be a configured remote of the installation, or a file:// uri pointing at a local repository to install from, in which case an origin remote is created.

flatpak_transaction_add_install_bundle ()

gboolean
flatpak_transaction_add_install_bundle
                               (FlatpakTransaction *self,
                                GFile *file,
                                GBytes *gpg_data,
                                GError **error);

Adds installing the given bundle to this transaction.

flatpak_transaction_add_install_flatpakref ()

gboolean
flatpak_transaction_add_install_flatpakref
                               (FlatpakTransaction *self,
                                GBytes *flatpakref_data,
                                GError **error);

Adds installing the given flatpakref to this transaction.

flatpak_transaction_add_rebase ()

gboolean
flatpak_transaction_add_rebase (FlatpakTransaction *self,
                                const char *remote,
                                const char *ref,
                                const char **subpaths,
                                const char **previous_ids,
                                GError **error);

Adds updating the previous_ids of the given ref to this transaction, via either installing the ref if it was not already present or updating it. This will treat ref as the result of following an eol-rebase, and data migration from the refs in previous_ids will be set up.

See flatpak_transaction_add_install() for a description of remote .

Since: 1.3.3.

flatpak_transaction_add_update ()

gboolean
flatpak_transaction_add_update (FlatpakTransaction *self,
                                const char *ref,
                                const char **subpaths,
                                const char *commit,
                                GError **error);

Adds updating the given ref to this transaction.

flatpak_transaction_add_uninstall ()

gboolean
flatpak_transaction_add_uninstall (FlatpakTransaction *self,
                                   const char *ref,
                                   GError **error);

Adds uninstalling the given ref to this transaction. If the transaction is set to not deploy updates, the request is ignored.

flatpak_transaction_add_default_dependency_sources ()

void
flatpak_transaction_add_default_dependency_sources
                               (FlatpakTransaction *self);

Similar to flatpak_transaction_add_dependency_source(), but adds all the default installations, which means all the defined system-wide (but not per-user) installations.

flatpak_transaction_add_dependency_source ()

void
flatpak_transaction_add_dependency_source
                               (FlatpakTransaction *self,
                                FlatpakInstallation *installation);

Adds an extra installation as a source for application dependencies. This means that applications can be installed in this transaction relying on runtimes from this additional installation (whereas it would normally install required runtimes that are not installed in the installation the transaction works on).

Also see flatpak_transaction_add_default_dependency_sources().

flatpak_transaction_run ()

gboolean
flatpak_transaction_run (FlatpakTransaction *transaction,
                         GCancellable *cancellable,
                         GError **error);

Executes the transaction.

During the course of the execution, various signals will get emitted. The FlatpakTransaction::choose-remote-for-ref and “add-new-remote” signals may get emitted while resolving operations. “ready” is emitted when the transaction has been fully resolved, and “new-operation” and “operation-done” are emitted while the operations are carried out. If an error occurs at any point during the execution, “operation-error” is emitted.

Note that this call blocks until the transaction is done.

flatpak_transaction_get_current_operation ()

FlatpakTransactionOperation *
flatpak_transaction_get_current_operation
                               (FlatpakTransaction *self);

Gets the current operation.

flatpak_transaction_get_installation ()

FlatpakInstallation *
flatpak_transaction_get_installation (FlatpakTransaction *self);

Gets the installation this transaction was created for.

flatpak_transaction_get_operations ()

GList *
flatpak_transaction_get_operations (FlatpakTransaction *self);

Gets the list of operations. Skipped operations are not included. The order of the list is the order in which the operations are executed.

flatpak_transaction_is_empty ()

gboolean
flatpak_transaction_is_empty (FlatpakTransaction *self);

Returns whether the transaction contains any non-skipped operations.

flatpak_transaction_set_disable_dependencies ()

void
flatpak_transaction_set_disable_dependencies
                               (FlatpakTransaction *self,
                                gboolean disable_dependencies);

Sets whether the transaction should ignore runtime dependencies when resolving operations for applications.

flatpak_transaction_set_disable_prune ()

void
flatpak_transaction_set_disable_prune (FlatpakTransaction *self,
                                       gboolean disable_prune);

Sets whether the transaction should avoid pruning the local OSTree repository after updating.

flatpak_transaction_set_disable_related ()

void
flatpak_transaction_set_disable_related
                               (FlatpakTransaction *self,
                                gboolean disable_related);

Sets whether the transaction should avoid adding related refs when resolving operations. Related refs are extensions that are suggested by apps, such as locales.

flatpak_transaction_set_disable_static_deltas ()

void
flatpak_transaction_set_disable_static_deltas
                               (FlatpakTransaction *self,
                                gboolean disable_static_deltas);

Sets whether the transaction should avoid using static deltas when pulling.

flatpak_transaction_set_no_deploy ()

void
flatpak_transaction_set_no_deploy (FlatpakTransaction *self,
                                   gboolean no_deploy);

Sets whether the transaction should download updates, but not deploy them.

flatpak_transaction_get_no_deploy ()

gboolean
flatpak_transaction_get_no_deploy (FlatpakTransaction *self);

Gets whether the transaction is only downloading updates, and not deploying them.

Since: 1.5.1

flatpak_transaction_set_no_pull ()

void
flatpak_transaction_set_no_pull (FlatpakTransaction *self,
                                 gboolean no_pull);

Sets whether the transaction should operate only on locally available data.

flatpak_transaction_get_no_pull ()

gboolean
flatpak_transaction_get_no_pull (FlatpakTransaction *self);

Gets whether the transaction should operate only on locally available data.

Since: 1.5.1

flatpak_transaction_set_reinstall ()

void
flatpak_transaction_set_reinstall (FlatpakTransaction *self,
                                   gboolean reinstall);

Sets whether the transaction should uninstall first if a ref is already installed.

flatpak_transaction_set_force_uninstall ()

void
flatpak_transaction_set_force_uninstall
                               (FlatpakTransaction *self,
                                gboolean force_uninstall);

Sets whether the transaction should uninstall files even if they're used by a running application.

flatpak_transaction_set_default_arch ()

void
flatpak_transaction_set_default_arch (FlatpakTransaction *self,
                                      const char *arch);

Sets the architecture to default to where it is unspecified.

flatpak_transaction_set_parent_window ()

void
flatpak_transaction_set_parent_window (FlatpakTransaction *self,
                                       const char *parent_window);

Sets the parent window (if any) to use for any UI show by this transaction. This is used by authenticators if they need to interact with the user during authentication.

The format of this string depends on the display system in use, and is the same as used by xdg-desktop-portal.

On X11 it should be of the form x11:$xid where $xid is the hex version of the xwindows id.

On wayland is should be wayland:$handle where handle is gotten by using the export call of the xdg-foreign-unstable wayland extension.

Since: 1.5.1

flatpak_transaction_get_parent_window ()

const char *
flatpak_transaction_get_parent_window (FlatpakTransaction *self);

Gets the parent window set for this transaction, or NULL if unset. See flatpak_transaction_get_parent_window().

Since: 1.5.1

flatpak_transaction_abort_webflow ()

void
flatpak_transaction_abort_webflow (FlatpakTransaction *self,
                                   guint id);

Cancel an ongoing webflow authentication request. This can be call in the time between “webflow-start” returned TRUE, and “webflow-done” is emitted. It will cancel the ongoing authentication operation.

This is useful for example if you're showing an authenticaion window with a browser, but the user closed it before it was finished.

Since: 1.5.1

FlatpakTransaction

typedef struct _FlatpakTransaction FlatpakTransaction;

enum FlatpakTransactionOperationType

The type of a FlatpakTransactionOperation.

enum FlatpakTransactionErrorDetails

The details for “operation-error”.

enum FlatpakTransactionRemoteReason

The reason for “add-new-remote”.

enum FlatpakTransactionResult

The details for “operation-done”.

The “installation” property

  “installation”             FlatpakInstallation *

The installation that the transaction operates on.

Owner: FlatpakTransaction

Flags: Read / Write / Construct Only

The “no-interaction” property

  “no-interaction”           gboolean

TRUE if the transaction is not interactive, FALSE otherwise.

See flatpak_transaction_set_no_interaction().

Owner: FlatpakTransaction

Flags: Read / Write

Default value: FALSE

Since: 1.13.0

The “add-new-remote” signal

gboolean
user_function (FlatpakTransaction *object,
               int                 reason,
               char               *from_id,
               char               *suggested_remote_name,
               char               *url,
               gpointer            user_data)

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 .

Flags: Run Last

The “basic-auth-start” signal

gboolean
user_function (FlatpakTransaction *object,
               char               *remote,
               char               *realm,
               GVariant           *options,
               int                 id,
               gpointer            user_data)

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 flatpak_transaction_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).

Flags: Run Last

Since: 1.5.2

The “choose-remote-for-ref” signal

int
user_function (FlatpakTransaction *object,
               char               *for_ref,
               char               *runtime_ref,
               GStrv               remotes,
               gpointer            user_data)

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

Flags: Run Last

The “end-of-lifed” signal

void
user_function (FlatpakTransaction *object,
               char               *ref,
               char               *reason,
               char               *rebase,
               gpointer            user_data)

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.

Flags: Run Last

The “end-of-lifed-with-rebase” signal

gboolean
user_function (FlatpakTransaction *object,
               char               *remote,
               char               *ref,
               char               *reason,
               char               *rebased_to_ref,
               GStrv               previous_ids,
               gpointer            user_data)

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 flatpak_transaction_add_uninstall() on ref , flatpak_transaction_add_rebase() on rebased_to_ref , and return TRUE. Otherwise FALSE may be returned.

Flags: Run Last

Since: 1.3.2

The “install-authenticator” signal

void
user_function (FlatpakTransaction *object,
               char               *remote,
               char               *authenticator_ref,
               gpointer            user_data)

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.

Flags: Run Last

Since: 1.8.0

The “new-operation” signal

void
user_function (FlatpakTransaction          *object,
               FlatpakTransactionOperation *operation,
               FlatpakTransactionProgress  *progress,
               gpointer                     user_data)

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

Flags: Run Last

The “operation-done” signal

void
user_function (FlatpakTransaction          *object,
               FlatpakTransactionOperation *operation,
               char                        *commit,
               int                          result,
               gpointer                     user_data)

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

Flags: Run Last

The “operation-error” signal

gboolean
user_function (FlatpakTransaction          *object,
               FlatpakTransactionOperation *operation,
               GError                      *error,
               int                          details,
               gpointer                     user_data)

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

Flags: Run Last

The “ready” signal

gboolean
user_function (FlatpakTransaction *object,
               gpointer            user_data)

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 flatpak_transaction_get_operations() will return all the operations that will be executed as part of the transaction.

Flags: Run Last

The “ready-pre-auth” signal

gboolean
user_function (FlatpakTransaction *object,
               gpointer            user_data)

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 flatpak_transaction_get_operations() will return all the operations that will be executed as part of the transaction. You can call flatpak_transaction_operation_get_requires_authentication() to see which will require authentication.

Flags: Run Last

Since: 1.9.1

The “webflow-done” signal

void
user_function (FlatpakTransaction *object,
               GVariant           *options,
               int                 id,
               gpointer            user_data)

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.

Flags: Run Last

Since: 1.5.1

The “webflow-start” signal

gboolean
user_function (FlatpakTransaction *object,
               char               *remote,
               char               *url,
               GVariant           *options,
               int                 id,
               gpointer            user_data)

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 flatpak_transaction_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.

Flags: Run Last

Since: 1.5.1