Collection IDs

A collection ID is a globally unique identifier which, if set, is used to identify refs from a repository which are mirrored elsewhere, such as in mirror repositories or peer to peer networks.

This is separate from the collection-id configuration key for a remote, which is used to store the collection ID of the repository that remote points to.

The collection ID should only be set on an OstreeRepo if it is the canonical collection for some refs.

A collection ID must be a reverse DNS name, where the domain name is under the control of the curator of the collection, so they can demonstrate ownership of the collection. The later elements in the reverse DNS name can be used to disambiguate between multiple collections from the same curator. For example, org.exampleos.Main and org.exampleos.Apps. For the complete format of collection IDs, see ostree_validate_collection_id().

ostree_repo_mode_from_string ()

gboolean
ostree_repo_mode_from_string (const char *mode,
                              OstreeRepoMode *out_mode,
                              GError **error);

ostree_repo_open_at ()

OstreeRepo *
ostree_repo_open_at (int dfd,
                     const char *path,
                     GCancellable *cancellable,
                     GError **error);

This combines ostree_repo_new() (but using fd-relative access) with ostree_repo_open(). Use this when you know you should be operating on an already extant repository. If you want to create one, use ostree_repo_create_at().

Since: 2017.10

ostree_repo_new ()

OstreeRepo *
ostree_repo_new (GFile *path);

ostree_repo_new_for_sysroot_path ()

OstreeRepo *
ostree_repo_new_for_sysroot_path (GFile *repo_path,
                                  GFile *sysroot_path);

Creates a new OstreeRepo instance, taking the system root path explicitly instead of assuming "/".

ostree_repo_new_default ()

OstreeRepo *
ostree_repo_new_default (void);

If the current working directory appears to be an OSTree repository, create a new OstreeRepo object for accessing it. Otherwise use the path in the OSTREE_REPO environment variable (if defined) or else the default system repository located at /ostree/repo.

ostree_repo_open ()

gboolean
ostree_repo_open (OstreeRepo *self,
                  GCancellable *cancellable,
                  GError **error);

ostree_repo_set_disable_fsync ()

void
ostree_repo_set_disable_fsync (OstreeRepo *self,
                               gboolean disable_fsync);

Disable requests to fsync() to stable storage during commits. This option should only be used by build system tools which are creating disposable virtual machines, or have higher level mechanisms for ensuring data consistency.

ostree_repo_get_disable_fsync ()

gboolean
ostree_repo_get_disable_fsync (OstreeRepo *self);

For more information see ostree_repo_set_disable_fsync().

ostree_repo_is_system ()

gboolean
ostree_repo_is_system (OstreeRepo *repo);

ostree_repo_is_writable ()

gboolean
ostree_repo_is_writable (OstreeRepo *self,
                         GError **error);

Returns whether the repository is writable by the current user. If the repository is not writable, the error indicates why.

ostree_repo_create_at ()

OstreeRepo *
ostree_repo_create_at (int dfd,
                       const char *path,
                       OstreeRepoMode mode,
                       GVariant *options,
                       GCancellable *cancellable,
                       GError **error);

This is a file-descriptor relative version of ostree_repo_create(). Create the underlying structure on disk for the repository, and call ostree_repo_open_at() on the result, preparing it for use.

If a repository already exists at dfd + path (defined by an objects/ subdirectory existing), then this function will simply call ostree_repo_open_at(). In other words, this function cannot be used to change the mode or configuration (repo/config) of an existing repo.

The options dict may contain:

Since: 2017.10

ostree_repo_create ()

gboolean
ostree_repo_create (OstreeRepo *self,
                    OstreeRepoMode mode,
                    GCancellable *cancellable,
                    GError **error);

Create the underlying structure on disk for the repository, and call ostree_repo_open() on the result, preparing it for use.

Since version 2016.8, this function will succeed on an existing repository, and finish creating any necessary files in a partially created repository. However, this function cannot change the mode of an existing repository, and will silently ignore an attempt to do so.

Since 2017.9, "existing repository" is defined by the existence of an objects subdirectory.

This function predates ostree_repo_create_at(). It is an error to call this function on a repository initialized via ostree_repo_open_at().

ostree_repo_get_collection_id ()

const gchar *
ostree_repo_get_collection_id (OstreeRepo *self);

Get the collection ID of this repository. See collection IDs.

Since: 2018.6

ostree_repo_get_bootloader ()

const gchar *
ostree_repo_get_bootloader (OstreeRepo *self);

Get the bootloader configured. See the documentation for the "sysroot.bootloader" config key.

Since: 2019.2

ostree_repo_get_path ()

GFile *
ostree_repo_get_path (OstreeRepo *self);

Note that since the introduction of ostree_repo_open_at(), this function may return a process-specific path in /proc if the repository was created using that API. In general, you should avoid use of this API.

ostree_repo_get_mode ()

OstreeRepoMode
ostree_repo_get_mode (OstreeRepo *self);

ostree_repo_get_min_free_space_bytes ()

gboolean
ostree_repo_get_min_free_space_bytes (OstreeRepo *self,
                                      guint64 *out_reserved_bytes,
                                      GError **error);

Determine the number of bytes of free disk space that are reserved according to the repo config and return that number in out_reserved_bytes . See the documentation for the core.min-free-space-size and core.min-free-space-percent repo config options.

Since: 2018.9

ostree_repo_get_config ()

GKeyFile *
ostree_repo_get_config (OstreeRepo *self);

ostree_repo_get_dfd ()

int
ostree_repo_get_dfd (OstreeRepo *self);

In some cases it's useful for applications to access the repository directly; for example, writing content into repo/tmp ensures it's on the same filesystem. Another case is detecting the mtime on the repository (to see whether a ref was written).

Since: 2016.4

ostree_repo_get_default_repo_finders ()

const gchar *const *
ostree_repo_get_default_repo_finders (OstreeRepo *self);

Get the set of default repo finders configured. See the documentation for the "core.default-repo-finders" config key.

Since: 2018.9

ostree_repo_lock_pop ()

gboolean
ostree_repo_lock_pop (OstreeRepo *self,
                      OstreeRepoLockType lock_type,
                      GCancellable *cancellable,
                      GError **error);

Release a lock of type lock_type from the lock state. If the lock state becomes empty, the repository is unlocked. Otherwise, the lock state only changes when transitioning from an exclusive lock back to a shared lock. The requested lock_type must be the same type that was requested in the call to ostree_repo_lock_push(). It is a programmer error if these do not match and the program may abort if the lock would reach an invalid state.

ostree_repo_lock_pop() waits for the lock depending on the repository's lock-timeout-secs configuration. When lock-timeout-secs is -1, a blocking lock is attempted. Otherwise, the lock is removed non-blocking and ostree_repo_lock_pop() will sleep synchronously up to lock-timeout-secs seconds attempting to remove the lock. If the lock cannot be removed within the timeout, a G_IO_ERROR_WOULD_BLOCK error is returned.

If self is not writable by the user, then no unlocking is attempted and TRUE is returned.

Since: 2021.3

ostree_repo_lock_push ()

gboolean
ostree_repo_lock_push (OstreeRepo *self,
                       OstreeRepoLockType lock_type,
                       GCancellable *cancellable,
                       GError **error);

Takes a lock on the repository and adds it to the lock state. If lock_type is OSTREE_REPO_LOCK_SHARED, a shared lock is taken. If lock_type is OSTREE_REPO_LOCK_EXCLUSIVE, an exclusive lock is taken. The actual lock state is only changed when locking a previously unlocked repository or upgrading the lock from shared to exclusive. If the requested lock type is unchanged or would represent a downgrade (exclusive to shared), the lock state is not changed.

ostree_repo_lock_push() waits for the lock depending on the repository's lock-timeout-secs configuration. When lock-timeout-secs is -1, a blocking lock is attempted. Otherwise, the lock is taken non-blocking and ostree_repo_lock_push() will sleep synchronously up to lock-timeout-secs seconds attempting to acquire the lock. If the lock cannot be acquired within the timeout, a G_IO_ERROR_WOULD_BLOCK error is returned.

If self is not writable by the user, then no locking is attempted and TRUE is returned.

Since: 2021.3

ostree_repo_auto_lock_push ()

OstreeRepoAutoLock *
ostree_repo_auto_lock_push (OstreeRepo *self,
                            OstreeRepoLockType lock_type,
                            GCancellable *cancellable,
                            GError **error);

Like ostree_repo_lock_push(), but for usage with OstreeRepoAutoLock. The intended usage is to declare the OstreeRepoAutoLock with g_autoptr() so that ostree_repo_auto_lock_cleanup() is called when it goes out of scope. This will automatically release the lock if it was acquired successfully.

1
2
3
4

g_autoptr(OstreeRepoAutoLock) lock = NULL;
lock = ostree_repo_auto_lock_push (repo, lock_type, cancellable, error);
if (!lock)
  return FALSE;

[skip]

Since: 2021.3

ostree_repo_auto_lock_cleanup ()

void
ostree_repo_auto_lock_cleanup (OstreeRepoAutoLock *lock);

A cleanup handler for use with ostree_repo_auto_lock_push(). If lock is not NULL, ostree_repo_lock_pop() will be called on it. If ostree_repo_lock_pop() fails, a critical warning will be emitted.

[skip]

Since: 2021.3

ostree_repo_hash ()

guint
ostree_repo_hash (OstreeRepo *self);

Calculate a hash value for the given open repository, suitable for use when putting it into a hash table. It is an error to call this on an OstreeRepo which is not yet open, as a persistent hash value cannot be calculated until the repository is open and the inode of its root directory has been loaded.

This function does no I/O.

Since: 2017.12

ostree_repo_equal ()

gboolean
ostree_repo_equal (OstreeRepo *a,
                   OstreeRepo *b);

Check whether two opened repositories are the same on disk: if their root directories are the same inode. If a or b are not open yet (due to ostree_repo_open() not being called on them yet), FALSE will be returned.

Since: 2017.12

ostree_repo_copy_config ()

GKeyFile *
ostree_repo_copy_config (OstreeRepo *self);

ostree_repo_remote_add ()

gboolean
ostree_repo_remote_add (OstreeRepo *self,
                        const char *name,
                        const char *url,
                        GVariant *options,
                        GCancellable *cancellable,
                        GError **error);

Create a new remote named name pointing to url . If options is provided, then it will be mapped to GKeyFile entries, where the GVariant dictionary key is an option string, and the value is mapped as follows:

ostree_repo_remote_delete ()

gboolean
ostree_repo_remote_delete (OstreeRepo *self,
                           const char *name,
                           GCancellable *cancellable,
                           GError **error);

Delete the remote named name . It is an error if the provided remote does not exist.

ostree_repo_remote_change ()

gboolean
ostree_repo_remote_change (OstreeRepo *self,
                           GFile *sysroot,
                           OstreeRepoRemoteChange changeop,
                           const char *name,
                           const char *url,
                           GVariant *options,
                           GCancellable *cancellable,
                           GError **error);

A combined function handling the equivalent of ostree_repo_remote_add(), ostree_repo_remote_delete(), with more options.

ostree_repo_remote_list ()

char **
ostree_repo_remote_list (OstreeRepo *self,
                         guint *out_n_remotes);

List available remote names in an OstreeRepo. Remote names are sorted alphabetically. If no remotes are available the function returns NULL.

ostree_repo_remote_list_collection_refs ()

gboolean
ostree_repo_remote_list_collection_refs
                               (OstreeRepo *self,
                                const char *remote_name,
                                GHashTable **out_all_refs,
                                GCancellable *cancellable,
                                GError **error);

List refs advertised by remote_name , including refs which are part of collections. If the repository at remote_name has a collection ID set, its refs will be returned with that collection ID; otherwise, they will be returned with a NULL collection ID in each OstreeCollectionRef key in out_all_refs . Any refs for other collections stored in the repository will also be returned. No filtering is performed.

Since: 2018.6

ostree_repo_remote_get_url ()

gboolean
ostree_repo_remote_get_url (OstreeRepo *self,
                            const char *name,
                            char **out_url,
                            GError **error);

Return the URL of the remote named name through out_url . It is an error if the provided remote does not exist.

ostree_repo_remote_get_gpg_verify ()

gboolean
ostree_repo_remote_get_gpg_verify (OstreeRepo *self,
                                   const char *name,
                                   gboolean *out_gpg_verify,
                                   GError **error);

Return whether GPG verification is enabled for the remote named name through out_gpg_verify . It is an error if the provided remote does not exist.

ostree_repo_remote_get_gpg_verify_summary ()

gboolean
ostree_repo_remote_get_gpg_verify_summary
                               (OstreeRepo *self,
                                const char *name,
                                gboolean *out_gpg_verify_summary,
                                GError **error);

Return whether GPG verification of the summary is enabled for the remote named name through out_gpg_verify_summary . It is an error if the provided remote does not exist.

ostree_repo_remote_get_gpg_keys ()

gboolean
ostree_repo_remote_get_gpg_keys (OstreeRepo *self,
                                 const char *name,
                                 const char *const *key_ids,
                                 GPtrArray **out_keys,
                                 GCancellable *cancellable,
                                 GError **error);

Enumerate the trusted GPG keys for the remote name . If name is NULL, the global GPG keys will be returned. The keys will be returned in the out_keys GPtrArray. Each element in the array is a GVariant of format OSTREE_GPG_KEY_GVARIANT_FORMAT. The key_ids array can be used to limit which keys are included. If key_ids is NULL, then all keys are included.

Since: 2021.4

ostree_repo_remote_gpg_import ()

gboolean
ostree_repo_remote_gpg_import (OstreeRepo *self,
                               const char *name,
                               GInputStream *source_stream,
                               const char *const *key_ids,
                               guint *out_imported,
                               GCancellable *cancellable,
                               GError **error);

Imports one or more GPG keys from the open source_stream , or from the user's personal keyring if source_stream is NULL. The key_ids array can optionally restrict which keys are imported. If key_ids is NULL, then all keys are imported.

The imported keys will be used to conduct GPG verification when pulling from the remote named name .

ostree_repo_remote_fetch_summary ()

gboolean
ostree_repo_remote_fetch_summary (OstreeRepo *self,
                                  const char *name,
                                  GBytes **out_summary,
                                  GBytes **out_signatures,
                                  GCancellable *cancellable,
                                  GError **error);

Tries to fetch the summary file and any GPG signatures on the summary file over HTTP, and returns the binary data in out_summary and out_signatures respectively.

If no summary file exists on the remote server, out_summary is set to NULL . Likewise if the summary file is not signed, out_signatures is set to NULL . In either case the function still returns TRUE.

This method does not verify the signature of the downloaded summary file. Use ostree_repo_verify_summary() for that.

Parse the summary data into a GVariant using g_variant_new_from_bytes() with OSTREE_SUMMARY_GVARIANT_FORMAT as the format string.

ostree_repo_remote_fetch_summary_with_options ()

gboolean
ostree_repo_remote_fetch_summary_with_options
                               (OstreeRepo *self,
                                const char *name,
                                GVariant *options,
                                GBytes **out_summary,
                                GBytes **out_signatures,
                                GCancellable *cancellable,
                                GError **error);

Like ostree_repo_remote_fetch_summary(), but supports an extensible set of flags. The following are currently defined:

Since: 2016.6

ostree_repo_reload_config ()

gboolean
ostree_repo_reload_config (OstreeRepo *self,
                           GCancellable *cancellable,
                           GError **error);

By default, an OstreeRepo will cache the remote configuration and its own repo/config data. This API can be used to reload it.

Since: 2017.2

ostree_repo_get_remote_boolean_option ()

gboolean
ostree_repo_get_remote_boolean_option (OstreeRepo *self,
                                       const char *remote_name,
                                       const char *option_name,
                                       gboolean default_value,
                                       gboolean *out_value,
                                       GError **error);

OSTree remotes are represented by keyfile groups, formatted like: [remote "remotename"]. This function returns a value named option_name underneath that group, and returns it as a boolean. If the option is not set, out_value will be set to default_value . If an error is returned, out_value will be set to FALSE.

Since: 2016.5

ostree_repo_get_remote_list_option ()

gboolean
ostree_repo_get_remote_list_option (OstreeRepo *self,
                                    const char *remote_name,
                                    const char *option_name,
                                    char ***out_value,
                                    GError **error);

OSTree remotes are represented by keyfile groups, formatted like: [remote "remotename"]. This function returns a value named option_name underneath that group, and returns it as a zero terminated array of strings. If the option is not set, or if an error is returned, out_value will be set to NULL.

Since: 2016.5

ostree_repo_get_remote_option ()

gboolean
ostree_repo_get_remote_option (OstreeRepo *self,
                               const char *remote_name,
                               const char *option_name,
                               const char *default_value,
                               char **out_value,
                               GError **error);

OSTree remotes are represented by keyfile groups, formatted like: [remote "remotename"]. This function returns a value named option_name underneath that group, or default_value if the remote exists but not the option name. If an error is returned, out_value will be set to NULL.

Since: 2016.5

ostree_repo_get_parent ()

OstreeRepo *
ostree_repo_get_parent (OstreeRepo *self);

Before this function can be used, ostree_repo_init() must have been called.

ostree_repo_write_config ()

gboolean
ostree_repo_write_config (OstreeRepo *self,
                          GKeyFile *new_config,
                          GError **error);

Save new_config in place of this repository's config file.

ostree_repo_scan_hardlinks ()

gboolean
ostree_repo_scan_hardlinks (OstreeRepo *self,
                            GCancellable *cancellable,
                            GError **error);

This function is deprecated in favor of using ostree_repo_devino_cache_new(), which allows a precise mapping to be built up between hardlink checkout files and their checksums between ostree_repo_checkout_at() and ostree_repo_write_directory_to_mtree().

When invoking ostree_repo_write_directory_to_mtree(), it has to compute the checksum of all files. If your commit contains hardlinks from a checkout, this functions builds a mapping of device numbers and inodes to their checksum.

There is an upfront cost to creating this mapping, as this will scan the entire objects directory. If your commit is composed of mostly hardlinks to existing ostree objects, then this will speed up considerably, so call it before you call ostree_repo_write_directory_to_mtree() or similar. However, ostree_repo_devino_cache_new() is better as it avoids scanning all objects.

Multithreading: This function is *not* MT safe.

ostree_repo_prepare_transaction ()

gboolean
ostree_repo_prepare_transaction (OstreeRepo *self,
                                 gboolean *out_transaction_resume,
                                 GCancellable *cancellable,
                                 GError **error);

Starts or resumes a transaction. In order to write to a repo, you need to start a transaction. You can complete the transaction with ostree_repo_commit_transaction(), or abort the transaction with ostree_repo_abort_transaction().

Currently, transactions may result in partial commits or data in the target repository if interrupted during ostree_repo_commit_transaction(), and further writing refs is also not currently atomic.

There can be at most one transaction active on a repo at a time per instance of OstreeRepo; however, it is safe to have multiple threads writing objects on a single OstreeRepo instance as long as their lifetime is bounded by the transaction.

Locking: Acquires a shared lock; release via commit or abort Multithreading: This function is *not* MT safe; only one transaction can be active at a time.

ostree_repo_commit_transaction ()

gboolean
ostree_repo_commit_transaction (OstreeRepo *self,
                                OstreeRepoTransactionStats *out_stats,
                                GCancellable *cancellable,
                                GError **error);

Complete the transaction. Any refs set with ostree_repo_transaction_set_ref() or ostree_repo_transaction_set_refspec() will be written out.

Note that if multiple threads are performing writes, all such threads must have terminated before this function is invoked.

Locking: Releases shared lock acquired by ostree_repo_prepare_transaction() Multithreading: This function is *not* MT safe; only one transaction can be active at a time.

ostree_repo_abort_transaction ()

gboolean
ostree_repo_abort_transaction (OstreeRepo *self,
                               GCancellable *cancellable,
                               GError **error);

Abort the active transaction; any staged objects and ref changes will be discarded. You *must* invoke this if you have chosen not to invoke ostree_repo_commit_transaction(). Calling this function when not in a transaction will do nothing and return successfully.

ostree_repo_transaction_set_refspec ()

void
ostree_repo_transaction_set_refspec (OstreeRepo *self,
                                     const char *refspec,
                                     const char *checksum);

Like ostree_repo_transaction_set_ref(), but takes concatenated refspec format as input instead of separate remote and name arguments.

Multithreading: Since v2017.15 this function is MT safe.

ostree_repo_transaction_set_collection_ref ()

void
ostree_repo_transaction_set_collection_ref
                               (OstreeRepo *self,
                                const OstreeCollectionRef *ref,
                                const char *checksum);

If checksum is not NULL, then record it as the target of local ref named ref .

Otherwise, if checksum is NULL, then record that the ref should be deleted.

The change will not be written out immediately, but when the transaction is completed with ostree_repo_commit_transaction(). If the transaction is instead aborted with ostree_repo_abort_transaction(), no changes will be made to the repository.

Multithreading: Since v2017.15 this function is MT safe.

Since: 2018.6

ostree_repo_transaction_set_ref ()

void
ostree_repo_transaction_set_ref (OstreeRepo *self,
                                 const char *remote,
                                 const char *ref,
                                 const char *checksum);

If checksum is not NULL, then record it as the target of ref named ref ; if remote is provided, the ref will appear to originate from that remote.

Otherwise, if checksum is NULL, then record that the ref should be deleted.

The change will be written when the transaction is completed with ostree_repo_commit_transaction(); that function takes care of writing all of the objects (such as the commit referred to by checksum ) before updating the refs. If the transaction is instead aborted with ostree_repo_abort_transaction(), no changes to the ref will be made to the repository.

Note however that currently writing *multiple* refs is not truly atomic; if the process or system is terminated during ostree_repo_commit_transaction(), it is possible that just some of the refs will have been updated. Your application should take care to handle this case.

Multithreading: Since v2017.15 this function is MT safe.

ostree_repo_set_ref_immediate ()

gboolean
ostree_repo_set_ref_immediate (OstreeRepo *self,
                               const char *remote,
                               const char *ref,
                               const char *checksum,
                               GCancellable *cancellable,
                               GError **error);

This is like ostree_repo_transaction_set_ref(), except it may be invoked outside of a transaction. This is presently safe for the case where we're creating or overwriting an existing ref.

Multithreading: This function is MT safe.

ostree_repo_set_alias_ref_immediate ()

gboolean
ostree_repo_set_alias_ref_immediate (OstreeRepo *self,
                                     const char *remote,
                                     const char *ref,
                                     const char *target,
                                     GCancellable *cancellable,
                                     GError **error);

Like ostree_repo_set_ref_immediate(), but creates an alias.

Since: 2017.10

ostree_repo_set_cache_dir ()

gboolean
ostree_repo_set_cache_dir (OstreeRepo *self,
                           int dfd,
                           const char *path,
                           GCancellable *cancellable,
                           GError **error);

Set a custom location for the cache directory used for e.g. per-remote summary caches. Setting this manually is useful when doing operations on a system repo as a user because you don't have write permissions in the repo, where the cache is normally stored.

Since: 2016.5

ostree_repo_set_collection_id ()

gboolean
ostree_repo_set_collection_id (OstreeRepo *self,
                               const gchar *collection_id,
                               GError **error);

Set or clear the collection ID of this repository. See collection IDs. The update will be made in memory, but must be written out to the repository configuration on disk using ostree_repo_write_config().

Since: 2018.6

ostree_repo_set_collection_ref_immediate ()

gboolean
ostree_repo_set_collection_ref_immediate
                               (OstreeRepo *self,
                                const OstreeCollectionRef *ref,
                                const char *checksum,
                                GCancellable *cancellable,
                                GError **error);

This is like ostree_repo_transaction_set_collection_ref(), except it may be invoked outside of a transaction. This is presently safe for the case where we're creating or overwriting an existing ref.

Since: 2018.6

ostree_repo_sign_delta ()

gboolean
ostree_repo_sign_delta (OstreeRepo *self,
                        const gchar *from_commit,
                        const gchar *to_commit,
                        const gchar *key_id,
                        const gchar *homedir,
                        GCancellable *cancellable,
                        GError **error);

This function is deprecated, sign the summary file instead. Add a GPG signature to a static delta.

ostree_repo_has_object ()

gboolean
ostree_repo_has_object (OstreeRepo *self,
                        OstreeObjectType objtype,
                        const char *checksum,
                        gboolean *out_have_object,
                        GCancellable *cancellable,
                        GError **error);

Set out_have_object to TRUE if self contains the given object; FALSE otherwise.

ostree_repo_mark_commit_partial ()

gboolean
ostree_repo_mark_commit_partial (OstreeRepo *self,
                                 const char *checksum,
                                 gboolean is_partial,
                                 GError **error);

Commits in the "partial" state do not have all their child objects written. This occurs in various situations, such as during a pull, but also if a "subpath" pull is used, as well as "commit only" pulls.

This function is used by ostree_repo_pull_with_options(); you should use this if you are implementing a different type of transport.

Since: 2017.15

ostree_repo_mark_commit_partial_reason ()

gboolean
ostree_repo_mark_commit_partial_reason
                               (OstreeRepo *self,
                                const char *checksum,
                                gboolean is_partial,
                                OstreeRepoCommitState in_state,
                                GError **error);

Allows the setting of a reason code for a partial commit. Presently it only supports setting reason bitmask to OSTREE_REPO_COMMIT_STATE_FSCK_PARTIAL, or OSTREE_REPO_COMMIT_STATE_NORMAL. This will allow successive ostree fsck operations to exit properly with an error code if the repository has been truncated as a result of fsck trying to repair it.

Since: 2019.4

ostree_repo_write_metadata ()

gboolean
ostree_repo_write_metadata (OstreeRepo *self,
                            OstreeObjectType objtype,
                            const char *expected_checksum,
                            GVariant *object,
                            guchar **out_csum,
                            GCancellable *cancellable,
                            GError **error);

Store the metadata object object . Return the checksum as out_csum .

If expected_checksum is not NULL, verify it against the computed checksum.

ostree_repo_write_metadata_async ()

void
ostree_repo_write_metadata_async (OstreeRepo *self,
                                  OstreeObjectType objtype,
                                  const char *expected_checksum,
                                  GVariant *object,
                                  GCancellable *cancellable,
                                  GAsyncReadyCallback callback,
                                  gpointer user_data);

Asynchronously store the metadata object variant . If provided, the checksum expected_checksum will be verified.

ostree_repo_write_metadata_finish ()

gboolean
ostree_repo_write_metadata_finish (OstreeRepo *self,
                                   GAsyncResult *result,
                                   guchar **out_csum,
                                   GError **error);

Complete a call to ostree_repo_write_metadata_async().

ostree_repo_write_content ()

gboolean
ostree_repo_write_content (OstreeRepo *self,
                           const char *expected_checksum,
                           GInputStream *object_input,
                           guint64 length,
                           guchar **out_csum,
                           GCancellable *cancellable,
                           GError **error);

Store the content object streamed as object_input , with total length length . The actual checksum will be returned as out_csum .

ostree_repo_write_regfile ()

OstreeContentWriter *
ostree_repo_write_regfile (OstreeRepo *self,
                           const char *expected_checksum,
                           guint32 uid,
                           guint32 gid,
                           guint32 mode,
                           guint64 content_len,
                           GVariant *xattrs,
                           GError **error);

Create an OstreeContentWriter that allows streaming output into the repository.

Since: 2021.2

ostree_repo_write_regfile_inline ()

char *
ostree_repo_write_regfile_inline (OstreeRepo *self,
                                  const char *expected_checksum,
                                  guint32 uid,
                                  guint32 gid,
                                  guint32 mode,
                                  GVariant *xattrs,
                                  const guint8 *buf,
                                  gsize len,
                                  GCancellable *cancellable,
                                  GError **error);

Synchronously create a file object from the provided content. This API is intended for small files where it is reasonable to buffer the entire content in memory.

Unlike ostree_repo_write_content(), if expected_checksum is provided, this function will not check for the presence of the object beforehand.

Since: 2021.2

ostree_repo_write_symlink ()

char *
ostree_repo_write_symlink (OstreeRepo *self,
                           const char *expected_checksum,
                           guint32 uid,
                           guint32 gid,
                           GVariant *xattrs,
                           const char *symlink_target,
                           GCancellable *cancellable,
                           GError **error);

Synchronously create a symlink object.

Unlike ostree_repo_write_content(), if expected_checksum is provided, this function will not check for the presence of the object beforehand.

Since: 2021.2

ostree_repo_write_metadata_trusted ()

gboolean
ostree_repo_write_metadata_trusted (OstreeRepo *self,
                                    OstreeObjectType objtype,
                                    const char *checksum,
                                    GVariant *variant,
                                    GCancellable *cancellable,
                                    GError **error);

Store the metadata object variant ; the provided checksum is trusted.

ostree_repo_write_metadata_stream_trusted ()

gboolean
ostree_repo_write_metadata_stream_trusted
                               (OstreeRepo *self,
                                OstreeObjectType objtype,
                                const char *checksum,
                                GInputStream *object_input,
                                guint64 length,
                                GCancellable *cancellable,
                                GError **error);

Store the metadata object variant ; the provided checksum is trusted.

ostree_repo_write_content_trusted ()

gboolean
ostree_repo_write_content_trusted (OstreeRepo *self,
                                   const char *checksum,
                                   GInputStream *object_input,
                                   guint64 length,
                                   GCancellable *cancellable,
                                   GError **error);

Store the content object streamed as object_input , with total length length . The given checksum will be treated as trusted.

This function should be used when importing file objects from local disk, for example.

ostree_repo_write_content_async ()

void
ostree_repo_write_content_async (OstreeRepo *self,
                                 const char *expected_checksum,
                                 GInputStream *object,
                                 guint64 length,
                                 GCancellable *cancellable,
                                 GAsyncReadyCallback callback,
                                 gpointer user_data);

Asynchronously store the content object object . If provided, the checksum expected_checksum will be verified.

ostree_repo_write_content_finish ()

gboolean
ostree_repo_write_content_finish (OstreeRepo *self,
                                  GAsyncResult *result,
                                  guchar **out_csum,
                                  GError **error);

Completes an invocation of ostree_repo_write_content_async().

ostree_repo_resolve_rev ()

gboolean
ostree_repo_resolve_rev (OstreeRepo *self,
                         const char *refspec,
                         gboolean allow_noent,
                         char **out_rev,
                         GError **error);

Look up the given refspec, returning the checksum it references in the parameter out_rev . Will fall back on remote directory if cannot find the given refspec in local.

ostree_repo_resolve_rev_ext ()

gboolean
ostree_repo_resolve_rev_ext (OstreeRepo *self,
                             const char *refspec,
                             gboolean allow_noent,
                             OstreeRepoResolveRevExtFlags flags,
                             char **out_rev,
                             GError **error);

Look up the given refspec, returning the checksum it references in the parameter out_rev . Differently from ostree_repo_resolve_rev(), this will not fall back to searching through remote repos if a local ref is specified but not found.

The flag OSTREE_REPO_RESOLVE_REV_EXT_LOCAL_ONLY is implied so using it has no effect.

Since: 2016.7

ostree_repo_list_refs ()

gboolean
ostree_repo_list_refs (OstreeRepo *self,
                       const char *refspec_prefix,
                       GHashTable **out_all_refs,
                       GCancellable *cancellable,
                       GError **error);

If refspec_prefix is NULL, list all local and remote refspecs, with their current values in out_all_refs . Otherwise, only list refspecs which have refspec_prefix as a prefix.

out_all_refs will be returned as a mapping from refspecs (including the remote name) to checksums. If refspec_prefix is non-NULL, it will be removed as a prefix from the hash table keys.

ostree_repo_list_refs_ext ()

gboolean
ostree_repo_list_refs_ext (OstreeRepo *self,
                           const char *refspec_prefix,
                           GHashTable **out_all_refs,
                           OstreeRepoListRefsExtFlags flags,
                           GCancellable *cancellable,
                           GError **error);

If refspec_prefix is NULL, list all local and remote refspecs, with their current values in out_all_refs . Otherwise, only list refspecs which have refspec_prefix as a prefix.

out_all_refs will be returned as a mapping from refspecs (including the remote name) to checksums. Differently from ostree_repo_list_refs(), the refspec_prefix will not be removed from the refspecs in the hash table.

Since: 2016.4

ostree_repo_list_collection_refs ()

gboolean
ostree_repo_list_collection_refs (OstreeRepo *self,
                                  const char *match_collection_id,
                                  GHashTable **out_all_refs,
                                  OstreeRepoListRefsExtFlags flags,
                                  GCancellable *cancellable,
                                  GError **error);

List all local, mirrored, and remote refs, mapping them to the commit checksums they currently point to in out_all_refs . If match_collection_id is specified, the results will be limited to those with an equal collection ID.

OstreeCollectionRefs are guaranteed to be returned with their collection ID set to a non-NULL value; so no refs from refs/heads will be listed if no collection ID is configured for the repository (ostree_repo_get_collection_id()).

If you want to exclude refs from refs/remotes, use OSTREE_REPO_LIST_REFS_EXT_EXCLUDE_REMOTES in flags . Similarly use OSTREE_REPO_LIST_REFS_EXT_EXCLUDE_MIRRORS to exclude refs from refs/mirrors.

Since: 2018.6

ostree_repo_remote_list_refs ()

gboolean
ostree_repo_remote_list_refs (OstreeRepo *self,
                              const char *remote_name,
                              GHashTable **out_all_refs,
                              GCancellable *cancellable,
                              GError **error);

ostree_repo_resolve_collection_ref ()

gboolean
ostree_repo_resolve_collection_ref (OstreeRepo *self,
                                    const OstreeCollectionRef *ref,
                                    gboolean allow_noent,
                                    OstreeRepoResolveRevExtFlags flags,
                                    char **out_rev,
                                    GCancellable *cancellable,
                                    GError **error);

Look up the checksum for the given collection–ref, returning it in out_rev . This will search through the mirrors and remote refs.

If allow_noent is TRUE and the given ref cannot be found, TRUE will be returned and out_rev will be set to NULL. If allow_noent is FALSE and the given ref cannot be found, a G_IO_ERROR_NOT_FOUND error will be returned.

If you want to check only local refs, not remote or mirrored ones, use the flag OSTREE_REPO_RESOLVE_REV_EXT_LOCAL_ONLY. This is analogous to using ostree_repo_resolve_rev_ext() but for collection-refs.

Since: 2018.6

ostree_repo_load_variant ()

gboolean
ostree_repo_load_variant (OstreeRepo *self,
                          OstreeObjectType objtype,
                          const char *sha256,
                          GVariant **out_variant,
                          GError **error);

Load the metadata object sha256 of type objtype , storing the result in out_variant .

ostree_repo_load_commit ()

gboolean
ostree_repo_load_commit (OstreeRepo *self,
                         const char *checksum,
                         GVariant **out_commit,
                         OstreeRepoCommitState *out_state,
                         GError **error);

A version of ostree_repo_load_variant() specialized to commits, capable of returning extended state information. Currently the only extended state is OSTREE_REPO_COMMIT_STATE_PARTIAL, which means that only a sub-path of the commit is available.

ostree_repo_load_variant_if_exists ()

gboolean
ostree_repo_load_variant_if_exists (OstreeRepo *self,
                                    OstreeObjectType objtype,
                                    const char *sha256,
                                    GVariant **out_variant,
                                    GError **error);

Attempt to load the metadata object sha256 of type objtype if it exists, storing the result in out_variant . If it doesn't exist, out_variant will be set to NULL and the function will still return TRUE.

ostree_repo_load_file ()

gboolean
ostree_repo_load_file (OstreeRepo *self,
                       const char *checksum,
                       GInputStream **out_input,
                       GFileInfo **out_file_info,
                       GVariant **out_xattrs,
                       GCancellable *cancellable,
                       GError **error);

Load content object, decomposing it into three parts: the actual content (for regular files), the metadata, and extended attributes.

ostree_repo_load_object_stream ()

gboolean
ostree_repo_load_object_stream (OstreeRepo *self,
                                OstreeObjectType objtype,
                                const char *checksum,
                                GInputStream **out_input,
                                guint64 *out_size,
                                GCancellable *cancellable,
                                GError **error);

Load object as a stream; useful when copying objects between repositories.

ostree_repo_query_object_storage_size ()

gboolean
ostree_repo_query_object_storage_size (OstreeRepo *self,
                                       OstreeObjectType objtype,
                                       const char *sha256,
                                       guint64 *out_size,
                                       GCancellable *cancellable,
                                       GError **error);

Return the size in bytes of object with checksum sha256 , after any compression has been applied.

ostree_repo_import_object_from ()

gboolean
ostree_repo_import_object_from (OstreeRepo *self,
                                OstreeRepo *source,
                                OstreeObjectType objtype,
                                const char *checksum,
                                GCancellable *cancellable,
                                GError **error);

Copy object named by objtype and checksum into self from the source repository source . If both repositories are of the same type and on the same filesystem, this will simply be a fast Unix hard link operation.

Otherwise, a copy will be performed.

ostree_repo_import_object_from_with_trust ()

gboolean
ostree_repo_import_object_from_with_trust
                               (OstreeRepo *self,
                                OstreeRepo *source,
                                OstreeObjectType objtype,
                                const char *checksum,
                                gboolean trusted,
                                GCancellable *cancellable,
                                GError **error);

Copy object named by objtype and checksum into self from the source repository source . If trusted is TRUE and both repositories are of the same type and on the same filesystem, this will simply be a fast Unix hard link operation.

Otherwise, a copy will be performed.

Since: 2016.5

ostree_repo_import_archive_to_mtree ()

gboolean
ostree_repo_import_archive_to_mtree (OstreeRepo *self,
                                     OstreeRepoImportArchiveOptions *opts,
                                     void *archive,
                                     OstreeMutableTree *mtree,
                                     OstreeRepoCommitModifier *modifier,
                                     GCancellable *cancellable,
                                     GError **error);

Import an archive file archive into the repository, and write its file structure to mtree .

[skip]

ostree_repo_export_tree_to_archive ()

gboolean
ostree_repo_export_tree_to_archive (OstreeRepo *self,
                                    OstreeRepoExportArchiveOptions *opts,
                                    OstreeRepoFile *root,
                                    void *archive,
                                    GCancellable *cancellable,
                                    GError **error);

Import an archive file archive into the repository, and write its file structure to mtree .

[skip]

ostree_repo_delete_object ()

gboolean
ostree_repo_delete_object (OstreeRepo *self,
                           OstreeObjectType objtype,
                           const char *sha256,
                           GCancellable *cancellable,
                           GError **error);

Remove the object of type objtype with checksum sha256 from the repository. An error of type G_IO_ERROR_NOT_FOUND is thrown if the object does not exist.

ostree_repo_fsck_object ()

gboolean
ostree_repo_fsck_object (OstreeRepo *self,
                         OstreeObjectType objtype,
                         const char *sha256,
                         GCancellable *cancellable,
                         GError **error);

Verify consistency of the object; this performs checks only relevant to the immediate object itself, such as checksumming. This API call will not itself traverse metadata objects for example.

Since: 2017.15

OstreeRepoCommitFilter ()

OstreeRepoCommitFilterResult
(*OstreeRepoCommitFilter) (OstreeRepo *repo,
                           const char *path,
                           GFileInfo *file_info,
                           gpointer user_data);

ostree_repo_commit_modifier_new ()

OstreeRepoCommitModifier *
ostree_repo_commit_modifier_new (OstreeRepoCommitModifierFlags flags,
                                 OstreeRepoCommitFilter commit_filter,
                                 gpointer user_data,
                                 GDestroyNotify destroy_notify);