+
Functions
+
+
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().
+
+
+
Returns
+
An accessor object for an OSTree repository located at dfd
++ path
+.
+
[transfer full]
+
+
Since: 2017.10
+
+
+
+
ostree_repo_new ()
+
OstreeRepo *
+ostree_repo_new (GFile *path);
+
+
+
Returns
+
An accessor object for an OSTree repository located at path
+.
+
[transfer full]
+
+
+
+
+
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 "/".
+
+
+
Returns
+
An accessor object for the OSTree repository located at repo_path
+.
+
[transfer full]
+
+
+
+
+
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.
+
+
Returns
+
An accessor object for an OSTree repository located at /ostree/repo.
+
[transfer full]
+
+
+
+
+
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().
+
+
+
Returns
+
Whether or not fsync() is enabled for this repo.
+
+
+
+
+
ostree_repo_is_system ()
+
gboolean
+ostree_repo_is_system (OstreeRepo *repo);
+
+
+
Returns
+
TRUE if this repository is the root-owned system global repository
+
+
+
+
+
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.
+
+
+
Returns
+
TRUE if this repository is writable
+
+
+
+
+
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.
+
+
+
Returns
+
collection ID for the repository.
+
[nullable]
+
+
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.
+
+
+
Returns
+
bootloader configuration for the sysroot.
+
[transfer none]
+
+
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_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.
+
+
+
Returns
+
TRUE on success, FALSE otherwise.
+
+
Since: 2018.9
+
+
+
+
ostree_repo_get_config ()
+
GKeyFile *
+ostree_repo_get_config (OstreeRepo *self);
+
+
Returns
+
The repository configuration; do not modify.
+
[transfer none]
+
+
+
+
+
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).
+
+
+
Returns
+
File descriptor for repository root - owned by self
+
+
+
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.
+
+
+
Returns
+
NULL-terminated array of strings.
+
[array zero-terminated=1][element-type utf8]
+
+
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.
+
+
+
Returns
+
TRUE on success, otherwise FALSE with error
+set
+
+
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.
+
+
+
Returns
+
TRUE on success, otherwise FALSE with error
+set
+
+
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.
+
+
+
Returns
+
TRUE if a
+and b
+are the same repository on disk, FALSE otherwise
+
+
Since: 2017.12
+
+
+
+
ostree_repo_copy_config ()
+
GKeyFile *
+ostree_repo_copy_config (OstreeRepo *self);
+
+
Returns
+
A newly-allocated copy of the repository config.
+
[transfer full]
+
+
+
+
+
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:
+
+s: g_key_file_set_string()
b: g_key_file_set_boolean()
as: g_key_file_set_string_list()
+
+
+
+
+
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_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.
+
+
+
Returns
+
a NULL-terminated
+array of remote names.
+
[array length=out_n_remotes][transfer full]
+
+
+
+
+
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.
+
+
+
Returns
+
TRUE on success, FALSE on failure
+
+
+
+
+
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.
+
+
+
Returns
+
TRUE on success, FALSE on failure
+
+
+
+
+
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.
+
+
+
Returns
+
TRUE on success, FALSE on failure
+
+
+
+
+
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.
+
+
+
Returns
+
TRUE if the GPG keys could be enumerated, FALSE otherwise
+
+
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
+.
+
+
+
Returns
+
TRUE on success, FALSE on failure
+
+
+
+
+
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.
+
+
+
Returns
+
TRUE on success, FALSE on failure
+
+
+
+
+
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:
+
+override-url (s): Fetch summary from this URL if remote specifies no metalink in options
http-headers (a(ss)): Additional headers to add to all HTTP requests
append-user-agent (s): Additional string to append to the user agent
n-network-retries (u): Number of times to retry each download on receiving
+a transient network error, such as a socket timeout; default is 5, 0
+means return errors without retrying
+
+
+
Returns
+
TRUE on success, FALSE on failure
+
+
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.
+
+
+
Returns
+
TRUE on success, otherwise FALSE with error
+set
+
+
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.
+
+
+
Returns
+
TRUE on success, otherwise FALSE with error
+set
+
+
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.
+
+
+
Returns
+
TRUE on success, otherwise FALSE with error
+set
+
+
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()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_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().
+
+
+
Returns
+
TRUE on success, FALSE otherwise
+
+
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.
+
+
+
Returns
+
TRUE on success, FALSE otherwise
+
+
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.
+
+
+
Returns
+
FALSE if an unexpected error occurred, TRUE 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()expected_checksum
+ is provided,
+this function will not check for the presence of the object beforehand.
+
+
+
Returns
+
Checksum (as a hex string) of the committed file.
+
[transfer full]
+
+
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()expected_checksum
+ is provided,
+this function will not check for the presence of the object beforehand.
+
+
+
Returns
+
Checksum (as a hex string) of the committed file.
+
[transfer full]
+
+
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.
+
+
+
Returns
+
TRUE on success, FALSE otherwise
+
+
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.
+
+
+
Returns
+
TRUE on success, FALSE on failure
+
+
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_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
+
+
+
+
+
+
+
+
OstreeRepoCommitModifierXattrCallback ()
+
GVariant *
+(*OstreeRepoCommitModifierXattrCallback)
+ (OstreeRepo *repo,
+ const char *path,
+ GFileInfo *file_info,
+ gpointer user_data);
+
+
+
+
ostree_repo_commit_modifier_set_xattr_callback ()
+
void
+ostree_repo_commit_modifier_set_xattr_callback
+ (OstreeRepoCommitModifier *modifier,
+ OstreeRepoCommitModifierXattrCallback callback,
+ GDestroyNotify destroy,
+ gpointer user_data);
+
If set, this function should return extended attributes to use for
+the given path. This is useful for things like ACLs and SELinux,
+where a build system can label the files as it's committing to the
+repository.
+
+
+
+
+
ostree_repo_commit_modifier_set_sepolicy ()
+
void
+ostree_repo_commit_modifier_set_sepolicy
+ (OstreeRepoCommitModifier *modifier,
+ OstreeSePolicy *sepolicy);
+
If policy
+ is non-NULL, use it to look up labels to use for
+"security.selinux" extended attributes.
+
Note that any policy specified this way operates in addition to any
+extended attributes provided via
+ostree_repo_commit_modifier_set_xattr_callback(). However if both
+specify a value for "security.selinux", then the one from the
+policy wins.
+
+
+
+
+
ostree_repo_commit_modifier_set_sepolicy_from_commit ()
+
gboolean
+ostree_repo_commit_modifier_set_sepolicy_from_commit
+ (OstreeRepoCommitModifier *modifier,
+ OstreeRepo *repo,
+ const char *rev,
+ GCancellable *cancellable,
+ GError **error);
+
In many cases, one wants to create a "derived" commit from base commit.
+SELinux policy labels are part of that base commit. This API allows
+one to easily set up SELinux labeling from a base commit.
+
+
Since: 2020.4
+
+
+
+
ostree_repo_commit_modifier_set_devino_cache ()
+
void
+ostree_repo_commit_modifier_set_devino_cache
+ (OstreeRepoCommitModifier *modifier,
+ OstreeRepoDevInoCache *cache);
+
See the documentation for
+ostree_repo_devino_cache_new()ostree_repo_write_directory_to_mtree()
+
Note if your process has multiple writers, you should use separate
+OSTreeRepo instances if you want to also use this API.
+
This function will add a reference to cache
+ without copying - you
+should avoid further mutation of the cache.
+
+
Since: 2017.13
+
+
+
+
+
+
+
+
ostree_repo_devino_cache_new ()
+
OstreeRepoDevInoCache *
+ostree_repo_devino_cache_new (void);
+
OSTree has support for pairing ostree_repo_checkout_tree_at() using
+hardlinks in combination with a later
+ostree_repo_write_directory_to_mtree() using a (normally modified)
+directory. In order for OSTree to optimally detect just the new
+files, use this function and fill in the devino_to_csum_cache
+member of OstreeRepoCheckoutAtOptions, then call
+ostree_repo_commit_set_devino_cache().
+
+
+
+
+
ostree_repo_devino_cache_ref ()
+
OstreeRepoDevInoCache *
+ostree_repo_devino_cache_ref (OstreeRepoDevInoCache *cache);
+
+
+
+
ostree_repo_devino_cache_unref ()
+
void
+ostree_repo_devino_cache_unref (OstreeRepoDevInoCache *cache);
+
+
+
+
ostree_repo_devino_cache_get_type ()
+
GType
+ostree_repo_devino_cache_get_type (void);
+
+
+
+
ostree_repo_write_directory_to_mtree ()
+
gboolean
+ostree_repo_write_directory_to_mtree (OstreeRepo *self,
+ GFile *dir,
+ OstreeMutableTree *mtree,
+ OstreeRepoCommitModifier *modifier,
+ GCancellable *cancellable,
+ GError **error);
+
Store objects for dir
+ and all children into the repository self
+,
+overlaying the resulting filesystem hierarchy into mtree
+.
+
+
+
+
+
ostree_repo_write_dfd_to_mtree ()
+
gboolean
+ostree_repo_write_dfd_to_mtree (OstreeRepo *self,
+ int dfd,
+ const char *path,
+ OstreeMutableTree *mtree,
+ OstreeRepoCommitModifier *modifier,
+ GCancellable *cancellable,
+ GError **error);
+
Store as objects all contents of the directory referred to by dfd
+
+and path
+ all children into the repository self
+, overlaying the
+resulting filesystem hierarchy into mtree
+.
+
+
+
+
+
ostree_repo_write_archive_to_mtree ()
+
gboolean
+ostree_repo_write_archive_to_mtree (OstreeRepo *self,
+ GFile *archive,
+ OstreeMutableTree *mtree,
+ OstreeRepoCommitModifier *modifier,
+ gboolean autocreate_parents,
+ GCancellable *cancellable,
+ GError **error);
+
Import an archive file archive
+ into the repository, and write its
+file structure to mtree
+.
+
+
+
+
+
ostree_repo_write_archive_to_mtree_from_fd ()
+
gboolean
+ostree_repo_write_archive_to_mtree_from_fd
+ (OstreeRepo *self,
+ int fd,
+ OstreeMutableTree *mtree,
+ OstreeRepoCommitModifier *modifier,
+ gboolean autocreate_parents,
+ GCancellable *cancellable,
+ GError **error);
+
Read an archive from fd
+ and import it into the repository, writing
+its file structure to mtree
+.
+
+
+
+
+
ostree_repo_write_mtree ()
+
gboolean
+ostree_repo_write_mtree (OstreeRepo *self,
+ OstreeMutableTree *mtree,
+ GFile **out_file,
+ GCancellable *cancellable,
+ GError **error);
+
Write all metadata objects for mtree
+ to repo; the resulting
+out_file
+ points to the OSTREE_OBJECT_TYPE_DIR_TREE object that
+the mtree
+ represented.
+
+
+
+
+
ostree_repo_write_commit ()
+
gboolean
+ostree_repo_write_commit (OstreeRepo *self,
+ const char *parent,
+ const char *subject,
+ const char *body,
+ GVariant *metadata,
+ OstreeRepoFile *root,
+ char **out_commit,
+ GCancellable *cancellable,
+ GError **error);
+
Write a commit metadata object, referencing root_contents_checksum
+
+and root_metadata_checksum
+.
+This uses the current time as the commit timestamp, but it can be
+overridden with an explicit timestamp via the
+standard
+SOURCE_DATE_EPOCH environment flag.
+
+
+
+
+
ostree_repo_write_commit_with_time ()
+
gboolean
+ostree_repo_write_commit_with_time (OstreeRepo *self,
+ const char *parent,
+ const char *subject,
+ const char *body,
+ GVariant *metadata,
+ OstreeRepoFile *root,
+ guint64 time,
+ char **out_commit,
+ GCancellable *cancellable,
+ GError **error);
+
Write a commit metadata object, referencing root_contents_checksum
+
+and root_metadata_checksum
+.
+
+
+
+
+
ostree_repo_read_commit_detached_metadata ()
+
gboolean
+ostree_repo_read_commit_detached_metadata
+ (OstreeRepo *self,
+ const char *checksum,
+ GVariant **out_metadata,
+ GCancellable *cancellable,
+ GError **error);
+
OSTree commits can have arbitrary metadata associated; this
+function retrieves them. If none exists, out_metadata
+ will be set
+to NULL.
+
+
+
+
+
ostree_repo_write_commit_detached_metadata ()
+
gboolean
+ostree_repo_write_commit_detached_metadata
+ (OstreeRepo *self,
+ const char *checksum,
+ GVariant *metadata,
+ GCancellable *cancellable,
+ GError **error);
+
Replace any existing metadata associated with commit referred to by
+checksum
+ with metadata
+. If metadata
+ is NULL, then existing
+data will be deleted.
+
+
+
+
+
ostree_repo_commit_add_composefs_metadata ()
+
gboolean
+ostree_repo_commit_add_composefs_metadata
+ (OstreeRepo *self,
+ guint format_version,
+ GVariantDict *dict,
+ OstreeRepoFile *repo_root,
+ GCancellable *cancellable,
+ GError **error);
+
Compute the composefs digest for a filesystem tree
+and insert it into metadata for a commit object. The composefs
+digest covers the entire filesystem tree and can be verified by
+the composefs mount tooling.
+
+
+
+
+
ostree_repo_checkout_at_options_set_devino ()
+
void
+ostree_repo_checkout_at_options_set_devino
+ (OstreeRepoCheckoutAtOptions *opts,
+ OstreeRepoDevInoCache *cache);
+
This function simply assigns cache
+ to the devino_to_csum_cache member of
+opts
+; it's only useful for introspection.
+
Note that cache does *not* have its refcount incremented - the lifetime of
+cache
+ must be equal to or greater than that of opts
+.
+
+
Since: 2017.13
+
+
+
+
ostree_repo_checkout_tree ()
+
gboolean
+ostree_repo_checkout_tree (OstreeRepo *self,
+ OstreeRepoCheckoutMode mode,
+ OstreeRepoCheckoutOverwriteMode overwrite_mode,
+ GFile *destination,
+ OstreeRepoFile *source,
+ GFileInfo *source_info,
+ GCancellable *cancellable,
+ GError **error);
+
Check out source
+ into destination
+, which must live on the
+physical filesystem. source
+ may be any subdirectory of a given
+commit. The mode
+ and overwrite_mode
+ allow control over how the
+files are checked out.
+
+
+
+
+
ostree_repo_checkout_tree_at ()
+
gboolean
+ostree_repo_checkout_tree_at (OstreeRepo *self,
+ OstreeRepoCheckoutOptions *options,
+ int destination_dfd,
+ const char *destination_path,
+ const char *commit,
+ GCancellable *cancellable,
+ GError **error);
+
ostree_repo_checkout_tree_at is deprecated and should not be used in newly-written code.
+
Similar to ostree_repo_checkout_tree(), but uses directory-relative
+paths for the destination, uses a new OstreeRepoCheckoutAtOptions,
+and takes a commit checksum and optional subpath pair, rather than
+requiring use of GFile APIs for the caller.
+
Note in addition that unlike ostree_repo_checkout_tree(), the
+default is not to use the repository-internal uncompressed objects
+cache.
+
This function is deprecated. Use ostree_repo_checkout_at() instead.
+
[skip]
+
+
+
+
+
ostree_repo_checkout_at ()
+
gboolean
+ostree_repo_checkout_at (OstreeRepo *self,
+ OstreeRepoCheckoutAtOptions *options,
+ int destination_dfd,
+ const char *destination_path,
+ const char *commit,
+ GCancellable *cancellable,
+ GError **error);
+
Similar to ostree_repo_checkout_tree(), but uses directory-relative
+paths for the destination, uses a new OstreeRepoCheckoutAtOptions,
+and takes a commit checksum and optional subpath pair, rather than
+requiring use of GFile APIs for the caller.
+
It also replaces ostree_repo_checkout_at() which was not safe to
+use with GObject introspection.
+
Note in addition that unlike ostree_repo_checkout_tree(), the
+default is not to use the repository-internal uncompressed objects
+cache.
+
+
Since: 2016.8
+
+
+
+
ostree_repo_checkout_gc ()
+
gboolean
+ostree_repo_checkout_gc (OstreeRepo *self,
+ GCancellable *cancellable,
+ GError **error);
+
Call this after finishing a succession of checkout operations; it
+will delete any currently-unused uncompressed objects from the
+cache.
+
+
+
+
+
ostree_repo_read_commit ()
+
gboolean
+ostree_repo_read_commit (OstreeRepo *self,
+ const char *ref,
+ GFile **out_root,
+ char **out_commit,
+ GCancellable *cancellable,
+ GError **error);
+
Load the content for rev
+ into out_root
+.
+
+
+
+
+
ostree_repo_list_objects ()
+
gboolean
+ostree_repo_list_objects (OstreeRepo *self,
+ OstreeRepoListObjectsFlags flags,
+ GHashTable **out_objects,
+ GCancellable *cancellable,
+ GError **error);
+
This function synchronously enumerates all objects in the
+repository, returning data in out_objects
+. out_objects
+
+maps from keys returned by ostree_object_name_serialize()
+to GVariant values of type OSTREE_REPO_LIST_OBJECTS_VARIANT_TYPE.
+
+
+
Returns
+
TRUE on success, FALSE on error, and error
+will be set
+
+
+
+
+
ostree_repo_list_commit_objects_starting_with ()
+
gboolean
+ostree_repo_list_commit_objects_starting_with
+ (OstreeRepo *self,
+ const char *start,
+ GHashTable **out_commits,
+ GCancellable *cancellable,
+ GError **error);
+
This function synchronously enumerates all commit objects starting
+with start
+, returning data in out_commits
+.
+
To list all commit objects, provide the empty string "" for start
+.
+
+
+
Returns
+
TRUE on success, FALSE on error, and error
+will be set
+
+
+
+
+
ostree_repo_list_static_delta_names ()
+
gboolean
+ostree_repo_list_static_delta_names (OstreeRepo *self,
+ GPtrArray **out_deltas,
+ GCancellable *cancellable,
+ GError **error);
+
This function synchronously enumerates all static deltas in the
+repository, returning its result in out_deltas
+.
+
+
+
+
+
ostree_repo_list_static_delta_indexes ()
+
gboolean
+ostree_repo_list_static_delta_indexes (OstreeRepo *self,
+ GPtrArray **out_indexes,
+ GCancellable *cancellable,
+ GError **error);
+
This function synchronously enumerates all static delta indexes in the
+repository, returning its result in out_indexes
+.
+
+
Since: 2020.8
+
+
+
+
ostree_repo_static_delta_reindex ()
+
gboolean
+ostree_repo_static_delta_reindex (OstreeRepo *repo,
+ OstreeStaticDeltaIndexFlags flags,
+ const char *opt_to_commit,
+ GCancellable *cancellable,
+ GError **error);
+
The delta index for a particular commit lists all the existing deltas that can be used
+when downloading that commit. This operation regenerates these indexes, either for
+a particular commit (if opt_to_commit
+ is non-NULL), or for all commits that
+are reachable by an existing delta (if opt_to_commit
+ is NULL).
+
This is normally called automatically when the summary is updated in
+ostree_repo_regenerate_summary().
+
Locking: shared
+
+
Since: 2020.8
+
+
+
+
ostree_repo_static_delta_generate ()
+
gboolean
+ostree_repo_static_delta_generate (OstreeRepo *self,
+ OstreeStaticDeltaGenerateOpt opt,
+ const char *from,
+ const char *to,
+ GVariant *metadata,
+ GVariant *params,
+ GCancellable *cancellable,
+ GError **error);
+
Generate a lookaside "static delta" from from
+ (NULL means
+from-empty) which can generate the objects in to
+. This delta is
+an optimization over fetching individual objects, and can be
+conveniently stored and applied offline.
+
The params
+ argument should be an a{sv}. The following attributes
+are known:
+
+min-fallback-size: u: Minimum uncompressed size in megabytes to use fallback, 0 to disable
+fallbacks
max-chunk-size: u: Maximum size in megabytes of a delta part
max-bsdiff-size: u: Maximum size in megabytes to consider bsdiff compression
+for input files
compression: y: Compression type: 0=none, x=lzma, g=gzip
bsdiff-enabled: b: Enable bsdiff compression. Default TRUE.
inline-parts: b: Put part data in header, to get a single file delta. Default FALSE.
verbose: b: Print diagnostic messages. Default FALSE.
endianness: b: Deltas use host byte order by default; this option allows choosing
+(G_BIG_ENDIAN or G_LITTLE_ENDIAN)
filename: ^ay: Save delta superblock to this filename (bytestring), and parts in the same
+directory. Default saves to repository.
sign-name: ^ay: Signature type to use (bytestring).
sign-key-ids: ^as: NULL-terminated array of keys used to sign delta superblock.
+
+
+
+
+
ostree_repo_static_delta_execute_offline_with_signature ()
+
gboolean
+ostree_repo_static_delta_execute_offline_with_signature
+ (OstreeRepo *self,
+ GFile *dir_or_file,
+ OstreeSign *sign,
+ gboolean skip_validation,
+ GCancellable *cancellable,
+ GError **error);
+
Given a directory representing an already-downloaded static delta
+on disk, apply it, generating a new commit.
+If sign is passed, the static delta signature is verified.
+If sign-verify-deltas configuration option is set and static delta is signed,
+signature verification will be mandatory before apply the static delta.
+The directory must be named with the form "FROM-TO", where both are
+checksums, and it must contain a file named "superblock", along with at least
+one part.
+
+
Since: 2020.7
+
+
+
+
ostree_repo_static_delta_execute_offline ()
+
gboolean
+ostree_repo_static_delta_execute_offline
+ (OstreeRepo *self,
+ GFile *dir_or_file,
+ gboolean skip_validation,
+ GCancellable *cancellable,
+ GError **error);
+
Given a directory representing an already-downloaded static delta
+on disk, apply it, generating a new commit. The directory must be
+named with the form "FROM-TO", where both are checksums, and it
+must contain a file named "superblock", along with at least one part.
+
+
+
+
+
ostree_repo_static_delta_verify_signature ()
+
gboolean
+ostree_repo_static_delta_verify_signature
+ (OstreeRepo *self,
+ const char *delta_id,
+ OstreeSign *sign,
+ char **out_success_message,
+ GError **error);
+
Verify static delta file signature.
+
+
+
Returns
+
TRUE if the signature of static delta file is valid using the
+signature engine provided, FALSE otherwise.
+
+
Since: 2020.7
+
+
+
+
ostree_repo_traverse_new_reachable ()
+
GHashTable *
+ostree_repo_traverse_new_reachable (void);
+
This hash table is a set of GVariant which can be accessed via
+ostree_object_name_deserialize().
+
+
+
+
+
ostree_repo_traverse_new_parents ()
+
GHashTable *
+ostree_repo_traverse_new_parents (void);
+
This hash table is a mapping from GVariant which can be accessed
+via ostree_object_name_deserialize() to a GVariant containing either
+a similar GVariant or and array of them, listing the parents of the key.
+
+
Since: 2018.5
+
+
+
+
ostree_repo_traverse_parents_get_commits ()
+
char **
+ostree_repo_traverse_parents_get_commits
+ (GHashTable *parents,
+ GVariant *object);
+
Gets all the commits that a certain object belongs to, as recorded
+by a parents table gotten from ostree_repo_traverse_commit_union_with_parents.
+
+
Returns
+
An array of checksums for
+the commits the key belongs to.
+
[transfer full][array zero-terminated=1]
+
+
Since: 2018.5
+
+
+
+
ostree_repo_traverse_commit ()
+
gboolean
+ostree_repo_traverse_commit (OstreeRepo *repo,
+ const char *commit_checksum,
+ int maxdepth,
+ GHashTable **out_reachable,
+ GCancellable *cancellable,
+ GError **error);
+
Create a new set out_reachable
+ containing all objects reachable
+from commit_checksum
+, traversing maxdepth
+ parent commits.
+
+
+
+
+
ostree_repo_traverse_commit_union ()
+
gboolean
+ostree_repo_traverse_commit_union (OstreeRepo *repo,
+ const char *commit_checksum,
+ int maxdepth,
+ GHashTable *inout_reachable,
+ GCancellable *cancellable,
+ GError **error);
+
Update the set inout_reachable
+ containing all objects reachable
+from commit_checksum
+, traversing maxdepth
+ parent commits.
+
[skip]
+
+
+
+
+
ostree_repo_traverse_commit_union_with_parents ()
+
gboolean
+ostree_repo_traverse_commit_union_with_parents
+ (OstreeRepo *repo,
+ const char *commit_checksum,
+ int maxdepth,
+ GHashTable *inout_reachable,
+ GHashTable *inout_parents,
+ GCancellable *cancellable,
+ GError **error);
+
Update the set inout_reachable
+ containing all objects reachable
+from commit_checksum
+, traversing maxdepth
+ parent commits.
+
Additionally this constructs a mapping from each object to the parents
+of the object, which can be used to track which commits an object
+belongs to.
+
[skip]
+
+
Since: 2018.5
+
+
+
+
ostree_repo_traverse_commit_with_flags ()
+
gboolean
+ostree_repo_traverse_commit_with_flags
+ (OstreeRepo *repo,
+ OstreeRepoCommitTraverseFlags flags,
+ const char *commit_checksum,
+ int maxdepth,
+ GHashTable *inout_reachable,
+ GHashTable *inout_parents,
+ GCancellable *cancellable,
+ GError **error);
+
Update the set inout_reachable
+ containing all objects reachable
+from commit_checksum
+, traversing maxdepth
+ parent commits.
+
Additionally this constructs a mapping from each object to the parents
+of the object, which can be used to track which commits an object
+belongs to.
+
[skip]
+
+
Since: 2018.5
+
+
+
+
ostree_repo_commit_traverse_iter_cleanup ()
+
void
+ostree_repo_commit_traverse_iter_cleanup
+ (void *p);
+
+
+
+
ostree_repo_commit_traverse_iter_clear ()
+
void
+ostree_repo_commit_traverse_iter_clear
+ (OstreeRepoCommitTraverseIter *iter);
+
+
+
+
ostree_repo_commit_traverse_iter_get_dir ()
+
void
+ostree_repo_commit_traverse_iter_get_dir
+ (OstreeRepoCommitTraverseIter *iter,
+ char **out_name,
+ char **out_content_checksum,
+ char **out_meta_checksum);
+
Return information on the current directory. This function may
+only be called if OSTREE_REPO_COMMIT_ITER_RESULT_DIR was returned
+from ostree_repo_commit_traverse_iter_next().
+
+
+
+
+
+
+
ostree_repo_commit_traverse_iter_init_commit ()
+
gboolean
+ostree_repo_commit_traverse_iter_init_commit
+ (OstreeRepoCommitTraverseIter *iter,
+ OstreeRepo *repo,
+ GVariant *commit,
+ OstreeRepoCommitTraverseFlags flags,
+ GError **error);
+
Initialize (in place) an iterator over the root of a commit object.
+
+
+
+
+
ostree_repo_commit_traverse_iter_init_dirtree ()
+
gboolean
+ostree_repo_commit_traverse_iter_init_dirtree
+ (OstreeRepoCommitTraverseIter *iter,
+ OstreeRepo *repo,
+ GVariant *dirtree,
+ OstreeRepoCommitTraverseFlags flags,
+ GError **error);
+
Initialize (in place) an iterator over a directory tree.
+
+
+
+
+
+
+
ostree_repo_prune ()
+
gboolean
+ostree_repo_prune (OstreeRepo *self,
+ OstreeRepoPruneFlags flags,
+ gint depth,
+ gint *out_objects_total,
+ gint *out_objects_pruned,
+ guint64 *out_pruned_object_size_total,
+ GCancellable *cancellable,
+ GError **error);
+
Delete content from the repository. By default, this function will
+only delete "orphaned" objects not referred to by any commit. This
+can happen during a local commit operation, when we have written
+content objects but not saved the commit referencing them.
+
However, if OSTREE_REPO_PRUNE_FLAGS_REFS_ONLY is provided, instead
+of traversing all commits, only refs will be used. Particularly
+when combined with depth
+, this is a convenient way to delete
+history from the repository.
+
Use the OSTREE_REPO_PRUNE_FLAGS_NO_PRUNE to just determine
+statistics on objects that would be deleted, without actually
+deleting them.
+
Locking: exclusive
+
+
+
+
+
ostree_repo_prune_static_deltas ()
+
gboolean
+ostree_repo_prune_static_deltas (OstreeRepo *self,
+ const char *commit,
+ GCancellable *cancellable,
+ GError **error);
+
Prune static deltas, if COMMIT is specified then delete static delta files only
+targeting that commit; otherwise any static delta of non existing commits are
+deleted.
+
Locking: exclusive
+
+
+
+
+
ostree_repo_traverse_reachable_refs ()
+
gboolean
+ostree_repo_traverse_reachable_refs (OstreeRepo *self,
+ guint depth,
+ GHashTable *reachable,
+ GCancellable *cancellable,
+ GError **error);
+
Add all commit objects directly reachable via a ref to reachable
+.
+
Locking: shared
+
+
Since: 2018.6
+
+
+
+
ostree_repo_prune_from_reachable ()
+
gboolean
+ostree_repo_prune_from_reachable (OstreeRepo *self,
+ OstreeRepoPruneOptions *options,
+ gint *out_objects_total,
+ gint *out_objects_pruned,
+ guint64 *out_pruned_object_size_total,
+ GCancellable *cancellable,
+ GError **error);
+
Delete content from the repository. This function is the "backend"
+half of the higher level ostree_repo_prune(). To use this function,
+you determine the root set yourself, and this function finds all other
+unreferenced objects and deletes them.
+
Use this API when you want to perform more selective pruning - for example,
+retain all commits from a production branch, but just GC some history from
+your dev branch.
+
The OSTREE_REPO_PRUNE_FLAGS_NO_PRUNE flag may be specified to just determine
+statistics on objects that would be deleted, without actually deleting them.
+
Locking: exclusive
+
+
Since: 2017.1
+
+
+
+
ostree_repo_pull ()
+
gboolean
+ostree_repo_pull (OstreeRepo *self,
+ const char *remote_name,
+ char **refs_to_fetch,
+ OstreeRepoPullFlags flags,
+ OstreeAsyncProgress *progress,
+ GCancellable *cancellable,
+ GError **error);
+
Connect to the remote repository, fetching the specified set of
+refs refs_to_fetch
+. For each ref that is changed, download the
+commit, all metadata, and all content objects, storing them safely
+on disk in self
+.
+
If flags
+ contains OSTREE_REPO_PULL_FLAGS_MIRROR, and
+the refs_to_fetch
+ is NULL, and the remote repository contains a
+summary file, then all refs will be fetched.
+
If flags
+ contains OSTREE_REPO_PULL_FLAGS_COMMIT_ONLY, then only the
+metadata for the commits in refs_to_fetch
+ is pulled.
+
Warning: This API will iterate the thread default main context,
+which is a bug, but kept for compatibility reasons. If you want to
+avoid this, use g_main_context_push_thread_default() to push a new
+one around this call.
+
+
+
+
+
ostree_repo_pull_one_dir ()
+
gboolean
+ostree_repo_pull_one_dir (OstreeRepo *self,
+ const char *remote_name,
+ const char *dir_to_pull,
+ char **refs_to_fetch,
+ OstreeRepoPullFlags flags,
+ OstreeAsyncProgress *progress,
+ GCancellable *cancellable,
+ GError **error);
+
This is similar to ostree_repo_pull(), but only fetches a single
+subpath.
+
+
+
+
+
ostree_repo_pull_with_options ()
+
gboolean
+ostree_repo_pull_with_options (OstreeRepo *self,
+ const char *remote_name_or_baseurl,
+ GVariant *options,
+ OstreeAsyncProgress *progress,
+ GCancellable *cancellable,
+ GError **error);
+
Like ostree_repo_pull(), but supports an extensible set of flags.
+The following are currently defined:
+
+refs (as): Array of string refs
collection-refs (a(sss)): Array of (collection ID, ref name, checksum) tuples to pull;
+mutually exclusive with refs and override-commit-ids. Checksums may be the empty
+string to pull the latest commit for that ref
flags (i): An instance of OstreeRepoPullFlags
subdir (s): Pull just this subdirectory
subdirs (as): Pull just these subdirectories
override-remote-name (s): If local, add this remote to refspec
gpg-verify (b): GPG verify commits
gpg-verify-summary (b): GPG verify summary
disable-sign-verify (b): Disable signapi verification of commits
disable-sign-verify-summary (b): Disable signapi verification of the summary
depth (i): How far in the history to traverse; default is 0, -1 means infinite
per-object-fsync (b): Perform disk writes more slowly, avoiding a single large I/O sync
disable-static-deltas (b): Do not use static deltas
require-static-deltas (b): Require static deltas
override-commit-ids (as): Array of specific commit IDs to fetch for refs
timestamp-check (b): Verify commit timestamps are newer than current (when pulling via
+ref); Since: 2017.11
timestamp-check-from-rev (s): Verify that all fetched commit timestamps are newer than
+timestamp of given rev; Since: 2020.4
max-metadata-size (t): Restrict metadata objects to a maximum number of bytes; 0 to
+disable. Since: 2018.9
dry-run (b): Only print information on what will be downloaded (requires static deltas)
override-url (s): Fetch objects from this URL if remote specifies no metalink in options
inherit-transaction (b): Don't initiate, finish or abort a transaction, useful to do
+multiple pulls in one transaction.
http-headers (a(ss)): Additional headers to add to all HTTP requests
update-frequency (u): Frequency to call the async progress callback in milliseconds, if
+any; only values higher than 0 are valid
localcache-repos (as): File paths for local repos to use as caches when doing remote
+fetches
append-user-agent (s): Additional string to append to the user agent
n-network-retries (u): Number of times to retry each download on receiving
+a transient network error, such as a socket timeout; default is 5, 0
+means return errors without retrying. Since: 2018.6
low-speed-limit-bytes (u): The average transfer speed per second of a transfer
+ during the time set via "low-speed-time-seconds" for libcurl to abort.
low-speed-time-seconds (u): The time in number seconds that the transfer
+ speed should be below the "low-speed-limit-bytes" setting for libcurl to abort.
retry-all-network-errors (b): Retry when network issues happen, instead of
+ failing automatically. Currently only affects libcurl. (Default set to true)
max-outstanding-fetcher-requests (u): The max amount of concurrent connections allowed.
ref-keyring-map (a(sss)): Array of (collection ID, ref name, keyring
+remote name) tuples specifying which remote's keyring should be used when
+doing GPG verification of each collection-ref. This is useful to prevent a
+remote from serving malicious updates to refs which did not originate from
+it. This can be a subset or superset of the refs being pulled; any ref
+not being pulled will be ignored and any ref without a keyring remote
+will be verified with the keyring of the remote being pulled from.
+
+
Since: 2020.9
+
+
+
+
ostree_repo_pull_default_console_progress_changed ()
+
void
+ostree_repo_pull_default_console_progress_changed
+ (OstreeAsyncProgress *progress,
+ gpointer user_data);
+
Convenient "changed" callback for use with
+ostree_async_progress_new_and_connect() when pulling from a remote
+repository.
+
Depending on the state of the OstreeAsyncProgress, either displays a
+custom status message, or else outstanding fetch progress in bytes/sec,
+or else outstanding content or metadata writes to the repository in
+number of objects.
+
Compatibility note: this function previously assumed that user_data
+
+was a pointer to a GSConsole instance. This is no longer the case,
+and user_data
+ is ignored.
+
+
+
+
+
ostree_repo_sign_commit ()
+
gboolean
+ostree_repo_sign_commit (OstreeRepo *self,
+ const gchar *commit_checksum,
+ const gchar *key_id,
+ const gchar *homedir,
+ GCancellable *cancellable,
+ GError **error);
+
Add a GPG signature to a commit.
+
+
+
+
+
ostree_repo_append_gpg_signature ()
+
gboolean
+ostree_repo_append_gpg_signature (OstreeRepo *self,
+ const gchar *commit_checksum,
+ GBytes *signature_bytes,
+ GCancellable *cancellable,
+ GError **error);
+
Append a GPG signature to a commit.
+
+
+
+
+
ostree_repo_add_gpg_signature_summary ()
+
gboolean
+ostree_repo_add_gpg_signature_summary (OstreeRepo *self,
+ const gchar **key_id,
+ const gchar *homedir,
+ GCancellable *cancellable,
+ GError **error);
+
Add a GPG signature to a summary file.
+
+
+
+
+
ostree_repo_gpg_sign_data ()
+
gboolean
+ostree_repo_gpg_sign_data (OstreeRepo *self,
+ GBytes *data,
+ GBytes *old_signatures,
+ const gchar **key_id,
+ const gchar *homedir,
+ GBytes **out_signatures,
+ GCancellable *cancellable,
+ GError **error);
+
Sign the given data
+ with the specified keys in key_id
+. Similar to
+ostree_repo_add_gpg_signature_summary() but can be used on any
+data.
+
You can use ostree_repo_gpg_verify_data() to verify the signatures.
+
+
+
Returns
+
TRUE if data
+has been signed successfully,
+FALSE in case of error (error
+will contain the reason).
+
+
Since: 2020.8
+
+
+
+
ostree_repo_gpg_verify_data ()
+
OstreeGpgVerifyResult *
+ostree_repo_gpg_verify_data (OstreeRepo *self,
+ const gchar *remote_name,
+ GBytes *data,
+ GBytes *signatures,
+ GFile *keyringdir,
+ GFile *extra_keyring,
+ GCancellable *cancellable,
+ GError **error);
+
Verify signatures
+ for data
+ using GPG keys in the keyring for
+remote_name
+, and return an OstreeGpgVerifyResult.
+
The remote_name
+ parameter can be NULL. In that case it will do
+the verifications using GPG keys in the keyrings of all remotes.
+
+
+
Since: 2016.6
+
+
+
+
ostree_repo_signature_verify_commit_data ()
+
gboolean
+ostree_repo_signature_verify_commit_data
+ (OstreeRepo *self,
+ const char *remote_name,
+ GBytes *commit_data,
+ GBytes *commit_metadata,
+ OstreeRepoVerifyFlags flags,
+ char **out_results,
+ GError **error);
+
Validate the commit data using the commit metadata which must
+contain at least one valid signature. If GPG and signapi are
+both enabled, then both must find at least one valid signature.
+
+
+
+
+
ostree_repo_verify_commit ()
+
gboolean
+ostree_repo_verify_commit (OstreeRepo *self,
+ const gchar *commit_checksum,
+ GFile *keyringdir,
+ GFile *extra_keyring,
+ GCancellable *cancellable,
+ GError **error);
+
Check for a valid GPG signature on commit named by the ASCII
+checksum commit_checksum
+.
+
+
+
Returns
+
TRUE if there was a GPG signature from a trusted keyring, otherwise FALSE
+
+
+
+
+
ostree_repo_verify_commit_ext ()
+
OstreeGpgVerifyResult *
+ostree_repo_verify_commit_ext (OstreeRepo *self,
+ const gchar *commit_checksum,
+ GFile *keyringdir,
+ GFile *extra_keyring,
+ GCancellable *cancellable,
+ GError **error);
+
Read GPG signature(s) on the commit named by the ASCII checksum
+commit_checksum
+ and return detailed results.
+
+
+
+
+
+
ostree_repo_verify_commit_for_remote ()
+
OstreeGpgVerifyResult *
+ostree_repo_verify_commit_for_remote (OstreeRepo *self,
+ const gchar *commit_checksum,
+ const gchar *remote_name,
+ GCancellable *cancellable,
+ GError **error);
+
Read GPG signature(s) on the commit named by the ASCII checksum
+commit_checksum
+ and return detailed results, based on the keyring
+configured for remote
+.
+
+
+
Since: 2016.14
+
+
+
+
ostree_repo_verify_summary ()
+
OstreeGpgVerifyResult *
+ostree_repo_verify_summary (OstreeRepo *self,
+ const char *remote_name,
+ GBytes *summary,
+ GBytes *signatures,
+ GCancellable *cancellable,
+ GError **error);
+
Verify signatures
+ for summary
+ data using GPG keys in the keyring for
+remote_name
+, and return an OstreeGpgVerifyResult.
+
+
+
+
+
+
ostree_repo_regenerate_metadata ()
+
gboolean
+ostree_repo_regenerate_metadata (OstreeRepo *self,
+ GVariant *additional_metadata,
+ GVariant *options,
+ GCancellable *cancellable,
+ GError **error);
+
Regenerate the OSTree repository metadata used by clients to describe
+available branches and other metadata.
+
The repository metadata currently consists of the summary file. See
+ostree_repo_regenerate_summary() and OSTREE_SUMMARY_GVARIANT_FORMAT for
+additional details on its contents.
+
Additionally, if the core/collection-id key is set in the configuration, a
+OSTREE_REPO_METADATA_REF commit will be created.
+
The following options
+ are currently defined:
+
+gpg-key-ids (as): Array of GPG key IDs to sign the metadata with.
gpg-homedir (s): GPG home directory.
sign-keys (av): Array of keys to sign the metadata with. The key
+type is specific to the sign engine used.
sign-type (s): Sign engine type to use. If not specified,
+OSTREE_SIGN_NAME_ED25519 is used.
+
Locking: shared
+
+
Since: 2023.1
+
+
+
+
ostree_repo_regenerate_summary ()
+
gboolean
+ostree_repo_regenerate_summary (OstreeRepo *self,
+ GVariant *additional_metadata,
+ GCancellable *cancellable,
+ GError **error);
+
An OSTree repository can contain a high level "summary" file that
+describes the available branches and other metadata.
+
If the timetable for making commits and updating the summary file is fairly
+regular, setting the ostree.summary.expires key in additional_metadata
+
+will aid clients in working out when to check for updates.
+
It is regenerated automatically after any ref is
+added, removed, or updated if core/auto-update-summary is set.
+
If the core/collection-id key is set in the configuration, it will be
+included as OSTREE_SUMMARY_COLLECTION_ID in the summary file. Refs that
+have associated collection IDs will be included in the generated summary
+file, listed under the OSTREE_SUMMARY_COLLECTION_MAP key. Collection IDs
+and refs in OSTREE_SUMMARY_COLLECTION_MAP are guaranteed to be in
+lexicographic order.
+
Locking: shared (Prior to 2021.7, this was exclusive)
+
+
+
