OSTree API references |
|---|
for OSTree 2021.6
for OSTree 2022.3
| +Top + | + |
+ |
+ |
+ |
+
char * +ostree_content_writer_finish (+OstreeContentWriter *self, +GCancellable *cancellable, +GError **error);
Complete the object write and return the checksum.
+ + +| +Top + | + |
+ |
+ |
+ |
+
void
+ostree_kernel_args_free (OstreeKernelArgs *kargs);
+Frees the kargs structure
+ +Since: 2019.3
+OstreeKernelArgs *
+ostree_kernel_args_new (void);
+Initializes a new OstreeKernelArgs structure and returns it
+[skip]
+ +Since: 2019.3
+void
+ostree_kernel_args_cleanup (void *loc);
+Frees the OstreeKernelArgs structure pointed by *loc
+ +Since: 2019.3
+void +ostree_kernel_args_replace_take (+OstreeKernelArgs *kargs, +char *arg);
Finds and replaces the old key if arg
+ is already in the hash table,
+otherwise adds arg
+ as new key and split_keyeq (arg) as value.
+Note that when replacing old key, the old values are freed.
kargs |
+a OstreeKernelArgs instance |
++ |
arg |
+key or key/value pair for replacement. |
+[transfer full] | +
Since: 2019.3
+void +ostree_kernel_args_replace (+OstreeKernelArgs *kargs, +const char *arg);
Finds and replaces the old key if arg
+ is already in the hash table,
+otherwise adds arg
+ as new key and split_keyeq (arg) as value.
+Note that when replacing old key value pair, the old values are freed.
kargs |
+a OstreeKernelArgs instance |
++ |
arg |
+key or key/value pair for replacement |
++ |
Since: 2019.3
+void +ostree_kernel_args_replace_argv (+OstreeKernelArgs *kargs, +char **argv);
Finds and replaces each non-null arguments of argv
+ in the hash table,
+otherwise adds individual arg as new key and split_keyeq (arg) as value.
+Note that when replacing old key value pair, the old values are freed.
kargs |
+a OstreeKernelArgs instance |
++ |
argv |
+an array of key or key/value pairs |
++ |
Since: 2019.3
+void +ostree_kernel_args_append (+OstreeKernelArgs *kargs, +const char *arg);
Appends arg
+ which is in the form of key=value pair to the hash table kargs->table
+(appends to the value list if key is already in the hash table)
+and appends key to kargs->order if it is not in the hash table already.
kargs |
+a OstreeKernelArgs instance |
++ |
arg |
+key or key/value pair to be added |
++ |
Since: 2019.3
+void +ostree_kernel_args_append_argv (+OstreeKernelArgs *kargs, +char **argv);
Appends each value in argv
+ to the corresponding value array and
+appends key to kargs->order if it is not in the hash table already.
kargs |
+a OstreeKernelArgs instance |
++ |
argv |
+an array of key=value argument pairs |
++ |
Since: 2019.3
+void +ostree_kernel_args_append_argv_filtered + (+OstreeKernelArgs *kargs, +char **argv, +char **prefixes);
Appends each argument that does not have one of the prefixes
+ as prefix to the kargs
+
kargs |
+a OstreeKernelArgs instance |
++ |
argv |
+an array of key=value argument pairs |
++ |
prefixes |
+an array of prefix strings |
++ |
Since: 2019.3
+gboolean +ostree_kernel_args_new_replace (+OstreeKernelArgs *kargs, +const char *arg, +GError **error);
This function implements the basic logic behind key/value pair +replacement. Do note that the arg need to be properly formatted
+When replacing key with exact one value, the arg can be in +the form: +key, key=new_val, or key=old_val=new_val +The first one swaps the old_val with the key to an empty value +The second and third replace the old_val into the new_val
+When replacing key with multiple values, the arg can only be +in the form of: +key=old_val=new_val. Unless there is a special case where +there is an empty value associated with the key, then +key=new_val will work because old_val is empty. The empty +val will be swapped with the new_val in that case
+kargs |
+OstreeKernelArgs instance |
++ |
arg |
+a string argument |
++ |
error |
+error instance |
++ |
TRUE on success, FALSE on failure (and in some other instances such as:
key not found in kargs
+
old value not found when arg
+is in the form of key=old_val=new_val
multiple old values found when arg
+is in the form of key=old_val)
Since: 2019.3
+gboolean +ostree_kernel_args_delete (+OstreeKernelArgs *kargs, +const char *arg, +GError **error);
There are few scenarios being handled for deletion:
+1: for input arg with a single key(i.e without = for split), + the key/value pair will be deleted if there is only + one value that is associated with the key
+2: for input arg wth key/value pair, the specific key + value pair will be deleted from the pointer array + if those exist.
+3: If the found key has only one value + associated with it, the key entry in the table will also + be removed, and the key will be removed from order table
+kargs |
+a OstreeKernelArgs instance |
++ |
arg |
+key or key/value pair for deletion |
++ |
error |
+an GError instance |
++ |
Since: 2019.3
+gboolean +ostree_kernel_args_delete_key_entry (+OstreeKernelArgs *kargs, +const char *key, +GError **error);
This function removes the key entry from the hashtable +as well from the order pointer array inside kargs
+Note: since both table and order inside kernel args +are with free function, no extra free functions are +being called as they are done automatically by GLib
+kargs |
+an OstreeKernelArgs instance |
++ |
key |
+the key to remove |
++ |
error |
+an GError instance |
++ |
Since: 2019.3
+gboolean +ostree_kernel_args_append_proc_cmdline + (+OstreeKernelArgs *kargs, +GCancellable *cancellable, +GError **error);
Appends the command line arguments in the file "/proc/cmdline"
+that does not have "BOOT_IMAGE=" and "initrd=" as prefixes to the kargs
+
kargs |
+a OstreeKernelArgs instance |
++ |
cancellable |
+optional GCancellable object, NULL to ignore |
++ |
error |
+an GError instance |
++ |
Since: 2019.3
+void +ostree_kernel_args_parse_append (+OstreeKernelArgs *kargs, +const char *options);
Parses options
+ by separating it by whitespaces and appends each argument to kargs
+
kargs |
+a OstreeKernelArgs instance |
++ |
options |
+a string representing command line arguments |
++ |
Since: 2019.3
+const char * +ostree_kernel_args_get_last_value (+OstreeKernelArgs *kargs, +const char *key);
Finds and returns the last element of value array
+corresponding to the key
+ in kargs
+ hash table. Note that the application
+will be terminated if the key
+ is found but the value array is empty
kargs |
+a OstreeKernelArgs instance |
++ |
key |
+a key to look for in |
++ |
NULL if key
+is not found in the kargs
+hash table,
+otherwise returns last element of value array corresponding to key
+
Since: 2019.3
+OstreeKernelArgs *
+ostree_kernel_args_from_string (const char *options);
+Initializes a new OstreeKernelArgs then parses and appends options
+
+to the empty OstreeKernelArgs
[skip]
+ + +Since: 2019.3
+char **
+ostree_kernel_args_to_strv (OstreeKernelArgs *kargs);
+Extracts all key value pairs in kargs
+ and appends to a temporary
+array in forms of "key=value" or "key" if value is NULL, and returns
+the temporary array with the GPtrArray wrapper freed
Since: 2019.3
+char *
+ostree_kernel_args_to_string (OstreeKernelArgs *kargs);
+Extracts all key value pairs in kargs
+ and appends to a temporary
+GString in forms of "key=value" or "key" if value is NULL separated
+by a single whitespace, and returns the temporary string with the
+GString wrapper freed
Note: the application will be terminated if one of the values array
+in kargs
+ is NULL
a string of "key=value" pairs or "key" if value is NULL, +separated by single whitespaces.
+ +Since: 2019.3
+| +Top + | + |
+ |
+ |
+ |
+
| +OstreeCollectionRef * + | ++ostree_collection_ref_new () + | +
| +OstreeCollectionRef * + | ++ostree_collection_ref_dup () + | +
| +void + | ++ostree_collection_ref_free () + | +
| +guint + | ++ostree_collection_ref_hash () + | +
| +gboolean + | ++ostree_collection_ref_equal () + | +
| +OstreeCollectionRef ** + | ++ostree_collection_ref_dupv () + | +
| +void + | ++ostree_collection_ref_freev () + | +
OstreeCollectionRef * +ostree_collection_ref_new (+const gchar *collection_id, +const gchar *ref_name);
Create a new OstreeCollectionRef containing (collection_id
+, ref_name
+). If
+collection_id
+ is NULL, this is equivalent to a plain ref name string (not a
+refspec; no remote name is included), which can be used for non-P2P
+operations.
collection_id |
+a collection ID, or |
+[nullable] | +
ref_name |
+a ref name |
++ |
Since: 2018.6
+OstreeCollectionRef *
+ostree_collection_ref_dup (const OstreeCollectionRef *ref);
+Create a copy of the given ref
+.
Since: 2018.6
+void
+ostree_collection_ref_free (OstreeCollectionRef *ref);
+Free the given ref
+.
Since: 2018.6
+guint
+ostree_collection_ref_hash (gconstpointer ref);
+Hash the given ref
+. This function is suitable for use with GHashTable.
+ref
+ must be non-NULL.
Since: 2018.6
+gboolean +ostree_collection_ref_equal (+gconstpointer ref1, +gconstpointer ref2);
Compare ref1
+ and ref2
+ and return TRUE if they have the same collection ID and
+ref name, and FALSE otherwise. Both ref1
+ and ref2
+ must be non-NULL.
ref1 |
+an OstreeCollectionRef. |
+[not nullable] | +
ref2 |
+another OstreeCollectionRef. |
+[not nullable] | +
Since: 2018.6
+OstreeCollectionRef **
+ostree_collection_ref_dupv (const OstreeCollectionRef * const *refs);
+Copy an array of OstreeCollectionRefs, including deep copies of all its
+elements. refs
+ must be NULL-terminated; it may be empty, but must not be
+NULL.
refs |
+
|
+[array zero-terminated=1] | +
Since: 2018.6
+void
+ostree_collection_ref_freev (OstreeCollectionRef **refs);
+Free the given array of refs
+, including freeing all its elements. refs
+
+must be NULL-terminated; it may be empty, but must not be NULL.
refs |
+an array of OstreeCollectionRefs. |
+[transfer full][array zero-terminated=1] | +
Since: 2018.6
+| +Top + | + |
+ |
+ |
+ |
+
| +OstreeRemote * + | ++ostree_remote_ref () + | +
| +void + | ++ostree_remote_unref () + | +
| const gchar * + | ++ostree_remote_get_name () + | +
| +gchar * + | ++ostree_remote_get_url () + | +
OstreeRemote *
+ostree_remote_ref (OstreeRemote *remote);
+Increase the reference count on the given remote
+.
Since: 2018.6
+void
+ostree_remote_unref (OstreeRemote *remote);
+Decrease the reference count on the given remote
+ and free it if the
+reference count reaches 0.
Since: 2018.6
+const gchar *
+ostree_remote_get_name (OstreeRemote *remote);
+Get the human-readable name of the remote. This is what the user configured, +if the remote was explicitly configured; and will otherwise be a stable, +arbitrary, string.
+ + +Since: 2018.6
+gchar *
+ostree_remote_get_url (OstreeRemote *remote);
+Get the URL from the remote.
+ + +Since: 2018.6
+struct OstreeRemote {
+ int ref_count; /* atomic */
+ char *name; /* (not nullable) */
+ char *refspec_name; /* (nullable) */
+ char *group; /* group name in options (not nullable) */
+ char *keyring; /* keyring name ($refspec_name.trustedkeys.gpg) (not nullable) */
+ GFile *file; /* NULL if remote defined in repo/config */
+ GKeyFile *options;
+};
+
+This represents the configuration for a single remote repository. Currently, +remotes can only be passed around as (reference counted) opaque handles. In +future, more API may be added to create and interrogate them.
+Since: 2018.6
+
| +Top + | + |
+ |
+ |
+ |
+
| +void + | ++ostree_repo_finder_resolve_async () + | +
| +GPtrArray * + | ++ostree_repo_finder_resolve_finish () + | +
| +void + | ++ostree_repo_finder_resolve_all_async () + | +
| +GPtrArray * + | ++ostree_repo_finder_resolve_all_finish () + | +
| +OstreeRepoFinderResult * + | ++ostree_repo_finder_result_new () + | +
| +OstreeRepoFinderResult * + | ++ostree_repo_finder_result_dup () + | +
| +void + | ++ostree_repo_finder_result_free () + | +
| +gint + | ++ostree_repo_finder_result_compare () + | +
| +void + | ++ostree_repo_finder_result_freev () + | +
void +ostree_repo_finder_resolve_async (+OstreeRepoFinder *self, +const OstreeCollectionRef * const *refs, +OstreeRepo *parent_repo, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Find reachable remote URIs which claim to provide any of the given refs
+. The
+specific method for finding the remotes depends on the OstreeRepoFinder
+implementation.
Any remote which is found and which claims to support any of the given refs
+
+will be returned in the results. It is possible that a remote claims to
+support a given ref, but turns out not to — it is not possible to verify this
+until ostree_repo_pull_from_remotes_async() is called.
The returned results will be sorted with the most useful first — this is
+typically the remote which claims to provide the most refs
+, at the lowest
+latency.
Each result contains a mapping of refs
+ to the checksums of the commits
+which the result provides. If the result provides the latest commit for a ref
+across all of the results, the checksum will be set. Otherwise, if the
+result provides an outdated commit, or doesn’t provide a given ref at all,
+the checksum will not be set. Results which provide none of the requested
+refs
+ may be listed with an empty refs map.
Pass the results to ostree_repo_pull_from_remotes_async() to pull the given
+refs
+ from those remotes.
self |
++ | + |
refs |
+non-empty array of collection–ref pairs to find remotes for. |
+[array zero-terminated=1] | +
parent_repo |
+the local repository which the refs are being resolved for, +which provides configuration information and GPG keys. |
+[transfer none] | +
cancellable |
+a GCancellable, or |
+[nullable] | +
callback |
+asynchronous completion callback |
++ |
user_data |
+data to pass to |
++ |
Since: 2018.6
+GPtrArray * +ostree_repo_finder_resolve_finish (+OstreeRepoFinder *self, +GAsyncResult *result, +GError **error);
Get the results from a ostree_repo_finder_resolve_async() operation.
self |
++ | + |
result |
+GAsyncResult from the callback |
++ |
error |
+return location for a GError |
++ |
Since: 2018.6
+void +ostree_repo_finder_resolve_all_async (+OstreeRepoFinder * const *finders, +const OstreeCollectionRef * const *refs, +OstreeRepo *parent_repo, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
A version of ostree_repo_finder_resolve_async() which queries one or more
+finders
+ in parallel and combines the results.
finders |
+non-empty array of OstreeRepoFinders. |
+[array zero-terminated=1] | +
refs |
+non-empty array of collection–ref pairs to find remotes for. |
+[array zero-terminated=1] | +
parent_repo |
+the local repository which the refs are being resolved for, +which provides configuration information and GPG keys. |
+[transfer none] | +
cancellable |
+a GCancellable, or |
+[nullable] | +
callback |
+asynchronous completion callback |
++ |
user_data |
+data to pass to |
++ |
Since: 2018.6
+GPtrArray * +ostree_repo_finder_resolve_all_finish (+GAsyncResult *result, +GError **error);
Get the results from a ostree_repo_finder_resolve_all_async() operation.
result |
+GAsyncResult from the callback |
++ |
error |
+return location for a GError |
++ |
Since: 2018.6
+OstreeRepoFinderResult * +ostree_repo_finder_result_new (+OstreeRemote *remote, +OstreeRepoFinder *finder, +gint priority, +GHashTable *ref_to_checksum, +GHashTable *ref_to_timestamp, +guint64 summary_last_modified);
Create a new OstreeRepoFinderResult instance. The semantics for the arguments +are as described in the OstreeRepoFinderResult documentation.
+remote |
+an OstreeRemote containing the transport details +for the result. |
+[transfer none] | +
finder |
+the OstreeRepoFinder instance which produced the +result. |
+[transfer none] | +
priority |
+static priority of the result, where higher numbers indicate lower +priority |
++ |
ref_to_checksum |
+map of collection–ref pairs to checksums provided by this result. |
+[element-type OstreeCollectionRef utf8][transfer none] | +
ref_to_timestamp |
+(element-type OstreeCollectionRef guint64) (nullable) +(transfer none): map of collection–ref pairs to timestamps provided by this +result |
++ |
summary_last_modified |
+Unix timestamp (seconds since the epoch, UTC) when
+the summary file for the result was last modified, or |
++ |
Since: 2018.6
+OstreeRepoFinderResult *
+ostree_repo_finder_result_dup (OstreeRepoFinderResult *result);
+Copy an OstreeRepoFinderResult.
+ + +Since: 2018.6
+void
+ostree_repo_finder_result_free (OstreeRepoFinderResult *result);
+Free the given result
+.
Since: 2018.6
+gint +ostree_repo_finder_result_compare (+const OstreeRepoFinderResult *a, +const OstreeRepoFinderResult *b);
Compare two OstreeRepoFinderResult instances to work out which one is better +to pull from, and hence needs to be ordered before the other.
+a |
+an OstreeRepoFinderResult |
++ |
b |
+an OstreeRepoFinderResult |
++ |
<0 if a
+is ordered before b
+, 0 if they are ordered equally,
+>0 if b
+is ordered before a
+
Since: 2018.6
+void
+ostree_repo_finder_result_freev (OstreeRepoFinderResult **results);
+Free the given results
+ array, freeing each element and the container.
results |
+an OstreeRepoFinderResult. |
+[array zero-terminated=1][transfer full] | +
Since: 2018.6
+| +Top + | + |
+ |
+ |
+ |
+
| +void + | ++ostree_repo_find_remotes_async () + | +
| +OstreeRepoFinderResult ** + | ++ostree_repo_find_remotes_finish () + | +
| +void + | ++ostree_repo_pull_from_remotes_async () + | +
| +gboolean + | ++ostree_repo_pull_from_remotes_finish () + | +
| +OstreeRemote * + | ++ostree_repo_resolve_keyring_for_collection () + | +
| #define | +OSTREE_REPO_METADATA_REF | +
| #define | +OSTREE_META_KEY_DEPLOY_COLLECTION_ID | +
void +ostree_repo_find_remotes_async (+OstreeRepo *self, +const OstreeCollectionRef * const *refs, +GVariant *options, +OstreeRepoFinder **finders, +OstreeAsyncProgress *progress, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Find reachable remote URIs which claim to provide any of the given named
+refs
+. This will search for configured remotes (OstreeRepoFinderConfig),
+mounted volumes (OstreeRepoFinderMount) and (if enabled at compile time)
+local network peers (OstreeRepoFinderAvahi). In order to use a custom
+configuration of OstreeRepoFinder instances, call
+ostree_repo_finder_resolve_all_async() on them individually.
Any remote which is found and which claims to support any of the given refs
+
+will be returned in the results. It is possible that a remote claims to
+support a given ref, but turns out not to — it is not possible to verify this
+until ostree_repo_pull_from_remotes_async() is called.
The returned results will be sorted with the most useful first — this is
+typically the remote which claims to provide the most of refs
+, at the lowest
+latency.
Each result contains a list of the subset of refs
+ it claims to provide. It
+is possible for a non-empty list of results to be returned, but for some of
+refs
+ to not be listed in any of the results. Callers must check for this.
Pass the results to ostree_repo_pull_from_remotes_async() to pull the given refs
+
+from those remotes.
The following options
+ are currently defined:
override-commit-ids (as): Array of specific commit IDs to fetch. The nth
+commit ID applies to the nth ref, so this must be the same length as refs
+, if
+provided.
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
finders
+ must be a non-empty NULL-terminated array of the OstreeRepoFinder
+instances to use, or NULL to use the system default set of finders, which
+will typically be all available finders using their default options (but
+this is not guaranteed).
GPG verification of commits will be used unconditionally.
+This will use the thread-default GMainContext, but will not iterate it.
+self |
+an OstreeRepo |
++ |
refs |
+non-empty array of collection–ref pairs to find remotes for. |
+[array zero-terminated=1] | +
options |
+a GVariant |
+[nullable] | +
finders |
+non-empty array of
+OstreeRepoFinder instances to use, or |
+[array zero-terminated=1][transfer none] | +
progress |
+an OstreeAsyncProgress to update with the operation’s
+progress, or |
+[nullable] | +
cancellable |
+a GCancellable, or |
+[nullable] | +
callback |
+asynchronous completion callback |
++ |
user_data |
+data to pass to |
++ |
Since: 2018.6
+OstreeRepoFinderResult ** +ostree_repo_find_remotes_finish (+OstreeRepo *self, +GAsyncResult *result, +GError **error);
Finish an asynchronous pull operation started with
+ostree_repo_find_remotes_async().
self |
+an OstreeRepo |
++ |
result |
+the asynchronous result |
++ |
error |
+return location for a GError, or |
++ |
a potentially empty array
+of OstreeRepoFinderResults, followed by a NULL terminator element; or
+NULL on error.
[transfer full][array zero-terminated=1]
+Since: 2018.6
+void +ostree_repo_pull_from_remotes_async (+OstreeRepo *self, +const OstreeRepoFinderResult * const *results, +GVariant *options, +OstreeAsyncProgress *progress, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Pull refs from multiple remotes which have been found using
+ostree_repo_find_remotes_async().
results
+ are expected to be in priority order, with the best remotes to pull
+from listed first. ostree_repo_pull_from_remotes_async() will generally pull
+from the remotes in order, but may parallelise its downloads.
If an error is encountered when pulling from a given remote, that remote will
+be ignored and another will be tried instead. If any refs have not been
+downloaded successfully after all remotes have been tried, G_IO_ERROR_FAILED
+will be returned. The results of any successful downloads will remain cached
+in the local repository.
If cancellable
+ is cancelled, G_IO_ERROR_CANCELLED will be returned
+immediately. The results of any successfully completed downloads at that
+point will remain cached in the local repository.
GPG verification of commits will be used unconditionally.
+The following options
+ are currently defined:
flags (i): OstreeRepoPullFlags to apply to the pull operation
inherit-transaction (b): TRUE to inherit an ongoing transaction on
+the OstreeRepo, rather than encapsulating the pull in a new one
depth (i): How far in the history to traverse; default is 0, -1 means infinite
disable-static-deltas (b): Do not use static deltas
http-headers (a(ss)): Additional headers to add to all HTTP requests
subdirs (as): Pull just these subdirectories
update-frequency (u): Frequency to call the async progress callback in
+milliseconds, if any; only values higher than 0 are valid
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
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.
self |
+an OstreeRepo |
++ |
results |
+
|
+[array zero-terminated=1] | +
options |
+A GVariant |
+[nullable] | +
progress |
+an OstreeAsyncProgress to update with the operation’s
+progress, or |
+[nullable] | +
cancellable |
+a GCancellable, or |
+[nullable] | +
callback |
+asynchronous completion callback |
++ |
user_data |
+data to pass to |
++ |
Since: 2018.6
+gboolean +ostree_repo_pull_from_remotes_finish (+OstreeRepo *self, +GAsyncResult *result, +GError **error);
Finish an asynchronous pull operation started with
+ostree_repo_pull_from_remotes_async().
self |
+an OstreeRepo |
++ |
result |
+the asynchronous result |
++ |
error |
+return location for a GError, or |
++ |
Since: 2018.6
+OstreeRemote * +ostree_repo_resolve_keyring_for_collection + (+OstreeRepo *self, +const gchar *collection_id, +GCancellable *cancellable, +GError **error);
Find the GPG keyring for the given collection_id
+, using the local
+configuration from the given OstreeRepo. This will search the configured
+remotes for ones whose collection-id key matches collection_id
+, and will
+return the first matching remote.
If multiple remotes match and have different keyrings, a debug message will +be emitted, and the first result will be returned. It is expected that the +keyrings should match.
+If no match can be found, a G_IO_ERROR_NOT_FOUND error will be returned.
self |
+an OstreeRepo |
++ |
collection_id |
+the collection ID to look up a keyring for |
++ |
cancellable |
+a GCancellable, or |
+[nullable] | +
error |
+return location for a GError, or |
++ |
Since: 2018.6
+#define OSTREE_REPO_METADATA_REF "ostree-metadata" ++
The name of a ref which is used to store metadata for the entire repository,
+such as its expected update time (ostree.summary.expires), name, or new
+GPG keys. Metadata is stored on contentless commits in the ref, and hence is
+signed with the commits.
This supersedes the additional metadata dictionary in the summary file
+(see ostree_repo_regenerate_summary()), as the use of a ref means that the
+metadata for multiple upstream repositories can be included in a single mirror
+repository, disambiguating the refs using collection IDs. In order to support
+peer to peer redistribution of repository metadata, repositories must set a
+collection ID (ostree_repo_set_collection_id()).
Users of OSTree may place arbitrary metadata in commits on this ref, but the
+keys must be namespaced by product or developer. For example,
+exampleos.end-of-life. The ostree. prefix is reserved.
Since: 2018.6
+#define OSTREE_META_KEY_DEPLOY_COLLECTION_ID "ostree.deploy-collection-id" ++
GVariant type s. This key can be used in the repo metadata which is stored
+in OSTREE_REPO_METADATA_REF as well as in the summary. The semantics of this
+are that the remote repository wants clients to update their remote config
+to add this collection ID (clients can't do P2P operations involving a
+remote without a collection ID configured on it, even if one is configured
+on the server side). Clients must never change or remove a collection ID
+already set in their remote config.
Currently, OSTree does not implement changing a remote config based on this +key, but it may do so in a later release, and until then clients such as +Flatpak may implement it.
+This is a replacement for the similar metadata key implemented by flatpak,
+xa.collection-id, which is now deprecated as clients which supported it had
+bugs with their P2P implementations.
Since: 2018.9
+| +Top + | + |
+ |
+ |
+ |
+
| #define | +OSTREE_YEAR_VERSION | +
| #define | +OSTREE_RELEASE_VERSION | +
| #define | +OSTREE_VERSION | +
| #define | +OSTREE_VERSION_S | +
| #define | +OSTREE_VERSION_HEX | +
#define OSTREE_CHECK_VERSION(year,release)+
Compile-time version checking. Evaluates to TRUE if the version
+of ostree is equal or greater than the required one.
year |
+required year version |
++ |
release |
+required release version |
++ |
Since: 2017.4
+#define OSTREE_YEAR_VERSION (2022) ++
ostree year version component (e.g. 2017 if OSTREE_VERSION is 2017.2)
Since: 2017.4
+#define OSTREE_RELEASE_VERSION (3) ++
ostree release version component (e.g. 2 if OSTREE_VERSION is 2017.2)
Since: 2017.4
+#define OSTREE_VERSION_S "2022.3" ++
ostree version, encoded as a string, useful for printing and +concatenation.
+Since: 2017.4
+