Top | ![]() |
![]() |
![]() |
![]() |
Content-addressed object storeContent-addressed object store — A git-like storage system for operating system binaries |
typedef | OstreeRepo |
enum | OstreeRepoMode |
enum | OstreeRepoRemoteChange |
struct | OstreeRepoTransactionStats |
enum | OstreeRepoCommitFilterResult |
typedef | OstreeRepoCommitModifier |
enum | OstreeRepoCommitModifierFlags |
enum | OstreeRepoCheckoutMode |
enum | OstreeRepoCheckoutOverwriteMode |
enum | OstreeRepoListObjectsFlags |
#define | OSTREE_REPO_LIST_OBJECTS_VARIANT_TYPE |
enum | OstreeStaticDeltaGenerateOpt |
enum | OstreeRepoPruneFlags |
enum | OstreeRepoPullFlags |
The OstreeRepo is like git, a content-addressed object store. Unlike git, it records uid, gid, and extended attributes.
There are three possible "modes" for an OstreeRepo;
OSTREE_REPO_MODE_BARE
is very simple - content files are
represented exactly as they are, and checkouts are just hardlinks.
OSTREE_REPO_MODE_BARE_USER
is similar, except the uid/gids are not
set on the files, and checkouts as hardlinks hardlinks work only for user checkouts.
A OSTREE_REPO_MODE_ARCHIVE_Z2
repository in contrast stores
content files zlib-compressed. It is suitable for non-root-owned
repositories that can be served via a static HTTP server.
Creating an OstreeRepo does not invoke any file I/O, and thus needs
to be initialized, either from an existing contents or with a new
repository. If you have an existing repo, use ostree_repo_open()
to load it from disk and check its validity. To initialize a new
repository in the given filepath, use ostree_repo_create()
instead.
To store content in the repo, first start a transaction with
ostree_repo_prepare_transaction()
. Then create a
OstreeMutableTree, and apply functions such as
ostree_repo_write_directory_to_mtree()
to traverse a physical
filesystem and write content, possibly multiple times.
Once the OstreeMutableTree is complete, write all of its metadata
with ostree_repo_write_mtree()
, and finally create a commit with
ostree_repo_write_commit()
.
gboolean ostree_repo_mode_from_string (const char *mode
,OstreeRepoMode *out_mode
,GError **error
);
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 "/".
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.
gboolean ostree_repo_open (OstreeRepo *self
,GCancellable *cancellable
,GError **error
);
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.
gboolean
ostree_repo_get_disable_fsync (OstreeRepo *self
);
For more information see ostree_repo_set_disable_fsync()
.
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.
gboolean ostree_repo_create (OstreeRepo *self
,OstreeRepoMode mode
,GCancellable *cancellable
,GError **error
);
Create the underlying structure on disk for the repository.
self |
An OstreeRepo |
|
mode |
The mode to store the repository in |
|
cancellable |
Cancellable |
|
error |
Error |
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).
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()
self |
Repo |
|
name |
Name of remote |
|
url |
URL for remote (if URL begins with metalink=, it will be used as such) |
|
options |
GVariant of type a{sv}. |
[allow-none] |
cancellable |
Cancellable |
|
error |
Error |
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.
gboolean ostree_repo_remote_change (OstreeRepo *self
,GFile *sysroot
,OstreeRepoRemoteChange changeop
,const char *name
,const char *url
,GVariant *options
,GCancellable *cancellable
,GError **error
);
A combined function handling the equivalent of
ostree_repo_remote_add()
, ostree_repo_remote_delete()
, with more
options.
self |
Repo |
|
sysroot |
System root. |
[allow-none] |
changeop |
Operation to perform |
|
name |
Name of remote |
|
url |
URL for remote (if URL begins with metalink=, it will be used as such) |
|
options |
GVariant of type a{sv}. |
[allow-none] |
cancellable |
Cancellable |
|
error |
Error |
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
.
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.
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.
self |
Repo |
|
name |
Name of remote |
|
out_gpg_verify |
Remote's GPG option. |
[out][allow-none] |
error |
Error |
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.
self |
Repo |
|
name |
Name of remote |
|
out_gpg_verify_summary |
Remote's GPG option. |
[out][allow-none] |
error |
Error |
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
.
self |
Self |
|
name |
name of a remote |
|
source_stream |
a GInputStream, or |
[allow-none] |
key_ids |
a |
[array zero-terminated=1][element-type utf8][allow-none] |
out_imported |
return location for the number of imported
keys, or |
[allow-none] |
cancellable |
a GCancellable |
|
error |
a GError |
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
.
Parse the summary data into a GVariant using g_variant_new_from_bytes()
with OSTREE_SUMMARY_GVARIANT_FORMAT as the format string.
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
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
.
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 an zero terminated array of strings.
If the option is not set, out_value
will be set to NULL
.
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.
self |
A OstreeRepo |
|
remote_name |
Name |
|
option_name |
Option |
|
default_value |
Value returned if |
[allow-none] |
out_value |
Return location for value. |
[out] |
error |
Error |
OstreeRepo *
ostree_repo_get_parent (OstreeRepo *self
);
Before this function can be used, ostree_repo_init()
must have been
called.
gboolean ostree_repo_write_config (OstreeRepo *self
,GKeyFile *new_config
,GError **error
);
Save new_config
in place of this repository's config file. Note
that new_config
should not be modified after - this function
simply adds a reference.
gboolean ostree_repo_scan_hardlinks (OstreeRepo *self
,GCancellable *cancellable
,GError **error
);
When ostree builds a mutable tree from directory like in
ostree_repo_write_directory_to_mtree()
, it has to scan all files that you
pass in and compute their checksums. If your commit contains hardlinks from
ostree's existing repo, ostree can build 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_write_directory_to_mtree()
or similar.
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 are not atomic, and aborting a transaction will not erase any data you write during the transaction.
self |
An OstreeRepo |
|
out_transaction_resume |
Whether this transaction
is resuming from a previous one. This is a legacy state, now OSTree
pulls use per-commit |
[allow-none][out] |
cancellable |
Cancellable |
|
error |
Error |
gboolean ostree_repo_commit_transaction (OstreeRepo *self
,OstreeRepoTransactionStats *out_stats
,GCancellable *cancellable
,GError **error
);
Complete the transaction. Any refs set with
ostree_repo_transaction_set_ref()
or
ostree_repo_transaction_set_refspec()
will be written out.
self |
An OstreeRepo |
|
out_stats |
A set of statistics of things that happened during this transaction. |
[allow-none][out] |
cancellable |
Cancellable |
|
error |
Error |
gboolean ostree_repo_abort_transaction (OstreeRepo *self
,GCancellable *cancellable
,GError **error
);
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.
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 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.
self |
An OstreeRepo |
|
remote |
A remote for the ref. |
[allow-none] |
ref |
The ref to write |
|
checksum |
The checksum to point it to |
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.
self |
An OstreeRepo |
|
remote |
A remote for the ref. |
[allow-none] |
ref |
The ref to write |
|
checksum |
The checksum to point it to, or |
[allow-none] |
cancellable |
GCancellable |
|
error |
GError |
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.
self |
An OstreeRepo |
|
dfd |
directory fd |
|
path |
subpath in |
|
cancellable |
a GCancellable |
|
error |
a GError |
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.
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.
self |
Repo |
|
objtype |
Object type |
|
checksum |
ASCII SHA256 checksum |
|
out_have_object |
|
[out] |
cancellable |
Cancellable |
|
error |
Error |
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 variant
. Return the checksum
as out_csum
.
If expected_checksum
is not NULL
, verify it against the
computed checksum.
self |
Repo |
|
objtype |
Object type |
|
expected_checksum |
If provided, validate content against this checksum. |
[allow-none] |
object |
Metadata |
|
out_csum |
Binary checksum. |
[out][array fixed-size=32][allow-none] |
cancellable |
Cancellable |
|
error |
Error |
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.
self |
Repo |
|
objtype |
Object type |
|
expected_checksum |
If provided, validate content against this checksum. |
[allow-none] |
object |
Metadata |
|
cancellable |
Cancellable |
|
callback |
Invoked when metadata is writed |
|
user_data |
Data for |
gboolean ostree_repo_write_metadata_finish (OstreeRepo *self
,GAsyncResult *result
,guchar **out_csum
,GError **error
);
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
.
self |
Repo |
|
expected_checksum |
If provided, validate content against this checksum. |
[allow-none] |
object_input |
Content object stream |
|
length |
Length of |
|
out_csum |
Binary checksum. |
[out][array fixed-size=32][allow-none] |
cancellable |
Cancellable |
|
error |
Error |
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.
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.
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.
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.
self |
Repo |
|
expected_checksum |
If provided, validate content against this checksum. |
[allow-none] |
object |
Input |
|
length |
Length of |
|
cancellable |
Cancellable |
|
callback |
Invoked when content is writed |
|
user_data |
User data for |
gboolean ostree_repo_write_content_finish (OstreeRepo *self
,GAsyncResult *result
,guchar **out_csum
,GError **error
);
Completes an invocation of ostree_repo_write_content_async()
.
self |
||
result |
a GAsyncResult |
|
out_csum |
A binary SHA256 checksum of the content object. |
[out][transfer full] |
error |
a GError |
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.
self |
Repo |
|
refspec |
A refspec |
|
allow_noent |
Do not throw an error if refspec does not exist |
|
out_rev |
A checksum,or |
[out][transfer full] |
error |
Error |
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.
self |
Repo |
|
refspec |
A refspec |
|
allow_noent |
Do not throw an error if refspec does not exist |
|
flags |
Options controlling behavior |
|
out_rev |
A checksum,or |
[out][transfer full] |
error |
Error |
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.
self |
Repo |
|
refspec_prefix |
Only list refs which match this prefix. |
[allow-none] |
out_all_refs |
Mapping from ref to checksum. |
[out][element-type utf8 utf8] |
cancellable |
Cancellable |
|
error |
Error |
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. Differently from
ostree_repo_list_refs()
, the prefix will not be removed from the ref
name.
self |
Repo |
|
refspec_prefix |
Only list refs which match this prefix. |
[allow-none] |
out_all_refs |
Mapping from ref to checksum. |
[out][element-type utf8 utf8] |
flags |
Options controlling listing behavior |
|
cancellable |
Cancellable |
|
error |
Error |
gboolean ostree_repo_remote_list_refs (OstreeRepo *self
,const char *remote_name
,GHashTable **out_all_refs
,GCancellable *cancellable
,GError **error
);
self |
Repo |
|
remote_name |
Name of the remote. |
|
out_all_refs |
Mapping from ref to checksum. |
[out][element-type utf8 utf8] |
cancellable |
Cancellable |
|
error |
Error |
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
.
self |
Repo |
|
objtype |
Expected object type |
|
sha256 |
Checksum string |
|
out_variant |
Metadata object. |
[out][transfer full] |
error |
Error |
gboolean ostree_repo_load_commit (OstreeRepo *self
,const char *checksum
,GVariant **out_commit
,OstreeRepoCommitState *out_state
,GError **error
);
A version of ostree_repo_load_variant()
specialized to commits,
capable of returning extended state information. Currently
the only extended state is OSTREE_REPO_COMMIT_STATE_PARTIAL
, which
means that only a sub-path of the commit is available.
self |
Repo |
|
checksum |
Commit checksum |
|
out_commit |
Commit. |
[out][allow-none] |
out_state |
Commit state. |
[out][allow-none] |
error |
Error |
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,
NULL
is returned.
self |
Repo |
|
objtype |
Object type |
|
sha256 |
ASCII checksum |
|
out_variant |
Metadata. |
[out][transfer full] |
error |
Error |
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.
self |
Repo |
|
checksum |
ASCII SHA256 checksum |
|
out_input |
File content. |
[out][allow-none] |
out_file_info |
File information. |
[out][allow-none] |
out_xattrs |
Extended attributes. |
[out][allow-none] |
cancellable |
Cancellable |
|
error |
Error |
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.
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.
self |
Repo |
|
objtype |
Object type |
|
sha256 |
Checksum |
|
out_size |
Size in bytes object occupies physically. |
[out] |
cancellable |
Cancellable |
|
error |
Error |
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.
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 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.
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
.
self |
An OstreeRepo |
|
opts |
Options structure, ensure this is zeroed, then set specific variables |
|
archive |
Really this is "struct archive*" |
|
mtree |
The OstreeMutableTree to write to |
|
modifier |
Optional commit modifier. |
[allow-none] |
cancellable |
Cancellable |
|
error |
Error |
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
.
self |
An OstreeRepo |
|
opts |
Options controlling conversion |
|
root |
An OstreeRepoFile for the base directory |
|
archive |
A |
|
cancellable |
Cancellable |
|
error |
Error |
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.
OstreeRepoCommitFilterResult (*OstreeRepoCommitFilter) (OstreeRepo *repo
,const char *path
,GFileInfo *file_info
,gpointer user_data
);
OstreeRepoCommitModifier * ostree_repo_commit_modifier_new (OstreeRepoCommitModifierFlags flags
,OstreeRepoCommitFilter commit_filter
,gpointer user_data
,GDestroyNotify destroy_notify
);
flags |
Control options for filter |
|
commit_filter |
Function that can inspect individual files. |
[allow-none] |
user_data |
User data. |
[allow-none] |
destroy_notify |
A GDestroyNotify |
GVariant * (*OstreeRepoCommitModifierXattrCallback) (OstreeRepo *repo
,const char *path
,GFileInfo *file_info
,gpointer user_data
);
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.
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.
void ostree_repo_commit_modifier_set_devino_cache (OstreeRepoCommitModifier *modifier
,OstreeRepoDevInoCache *cache
);
See the documentation for
. This function can
then be used for later calls to
ostree_repo_devino_cache_new()
to optimize commits.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.
OstreeRepoCommitModifier *
ostree_repo_commit_modifier_ref (OstreeRepoCommitModifier *modifier
);
void
ostree_repo_commit_modifier_unref (OstreeRepoCommitModifier *modifier
);
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 OstreeRepoCheckoutOptions
, then call
ostree_repo_commit_set_devino_cache()
.
OstreeRepoDevInoCache *
ostree_repo_devino_cache_ref (OstreeRepoDevInoCache *cache
);
void
ostree_repo_devino_cache_unref (OstreeRepoDevInoCache *cache
);
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
.
self |
Repo |
|
dir |
Path to a directory |
|
mtree |
Overlay directory contents into this tree |
|
modifier |
Optional modifier. |
[allow-none] |
cancellable |
Cancellable |
|
error |
Error |
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
.
self |
Repo |
|
dfd |
Directory file descriptor |
|
path |
Path |
|
mtree |
Overlay directory contents into this tree |
|
modifier |
Optional modifier. |
[allow-none] |
cancellable |
Cancellable |
|
error |
Error |
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
.
self |
An OstreeRepo |
|
archive |
A path to an archive file |
|
mtree |
The OstreeMutableTree to write to |
|
modifier |
Optional commit modifier. |
[allow-none] |
autocreate_parents |
Autocreate parent directories |
|
cancellable |
Cancellable |
|
error |
Error |
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.
self |
Repo |
|
mtree |
Mutable tree |
|
out_file |
An OstreeRepoFile representing |
[out] |
cancellable |
Cancellable |
|
error |
Error |
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
.
self |
Repo |
|
parent |
ASCII SHA256 checksum for parent, or |
[allow-none] |
subject |
Subject. |
[allow-none] |
body |
Body. |
[allow-none] |
metadata |
GVariant of type a{sv}, or |
[allow-none] |
root |
The tree to point the commit to |
|
out_commit |
Resulting ASCII SHA256 checksum for commit. |
[out] |
cancellable |
Cancellable |
|
error |
Error |
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
.
self |
Repo |
|
parent |
ASCII SHA256 checksum for parent, or |
[allow-none] |
subject |
Subject. |
[allow-none] |
body |
Body. |
[allow-none] |
metadata |
GVariant of type a{sv}, or |
[allow-none] |
root |
The tree to point the commit to |
|
time |
The time to use to stamp the commit |
|
out_commit |
Resulting ASCII SHA256 checksum for commit. |
[out] |
cancellable |
Cancellable |
|
error |
Error |
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
.
self |
Repo |
|
checksum |
ASCII SHA256 commit checksum |
|
out_metadata |
Metadata associated with commit in with format "a{sv}", or |
[out][transfer full] |
cancellable |
Cancellable |
|
error |
Error |
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.
self |
Repo |
|
checksum |
ASCII SHA256 commit checksum |
|
metadata |
Metadata to associate with commit in with format "a{sv}", or |
[allow-none] |
cancellable |
Cancellable |
|
error |
Error |
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.
gboolean ostree_repo_checkout_tree_at (OstreeRepo *self
,OstreeRepoCheckoutOptions *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 OstreeRepoCheckoutOptions
,
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.
self |
Repo |
|
options |
Options. |
[allow-none] |
destination_dfd |
Directory FD for destination |
|
destination_path |
Directory for destination |
|
commit |
Checksum for commit |
|
cancellable |
Cancellable |
|
error |
Error |
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.
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
.
self |
Repo |
|
ref |
Ref or ASCII checksum |
|
out_root |
An OstreeRepoFile corresponding to the root. |
[out] |
out_commit |
The resolved commit checksum. |
[out] |
cancellable |
Cancellable |
|
error |
Error |
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
.
self |
Repo |
|
flags |
Flags controlling enumeration |
|
out_objects |
Map of serialized object name to variant data. |
[out] |
cancellable |
Cancellable |
|
error |
Error |
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
.
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
.
self |
Repo |
|
out_deltas |
String name of deltas (checksum-checksum.delta). |
[out][element-type utf8][transfer container] |
cancellable |
Cancellable |
|
error |
Error |
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, and parts in the same directory. Default saves to repository.
self |
Repo |
|
opt |
High level optimization choice |
|
from |
ASCII SHA256 checksum of origin, or |
|
to |
ASCII SHA256 checksum of target |
|
metadata |
Optional metadata. |
[allow-none] |
params |
Parameters, see below. |
[allow-none] |
cancellable |
Cancellable |
|
error |
Error |
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.
GHashTable *
ostree_repo_traverse_new_reachable (void
);
This hash table is a set of GVariant which can be accessed via
ostree_object_name_deserialize()
.
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.
repo |
Repo |
|
commit_checksum |
ASCII SHA256 checksum |
|
maxdepth |
Traverse this many parent commits, -1 for unlimited |
|
out_reachable |
Set of reachable objects. |
[out][transfer container][element-type GVariant GVariant] |
cancellable |
Cancellable |
|
error |
Error |
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]
void
ostree_repo_commit_traverse_iter_cleanup
(void *p
);
void
ostree_repo_commit_traverse_iter_clear
(OstreeRepoCommitTraverseIter *iter
);
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()
.
iter |
An iter |
|
out_name |
Name of current dir. |
[out][transfer none] |
out_content_checksum |
Checksum of current content. |
[out][transfer none] |
out_meta_checksum |
Checksum of current metadata. |
[out][transfer none] |
void ostree_repo_commit_traverse_iter_get_file (OstreeRepoCommitTraverseIter *iter
,char **out_name
,char **out_checksum
);
Return information on the current file. This function may only be
called if OSTREE_REPO_COMMIT_ITER_RESULT_FILE
was returned from
ostree_repo_commit_traverse_iter_next()
.
iter |
An iter |
|
out_name |
Name of current file. |
[out][transfer none] |
out_checksum |
Checksum of current file. |
[out][transfer none] |
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.
iter |
An iter |
|
repo |
A repo |
|
commit |
Variant of type |
|
flags |
Flags |
|
error |
Error |
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.
iter |
An iter |
|
repo |
A repo |
|
dirtree |
Variant of type |
|
flags |
Flags |
|
error |
Error |
OstreeRepoCommitIterResult ostree_repo_commit_traverse_iter_next (OstreeRepoCommitTraverseIter *iter
,GCancellable *cancellable
,GError **error
);
Step the interator to the next item. Files will be returned first,
then subdirectories. Call this in a loop; upon encountering
OSTREE_REPO_COMMIT_ITER_RESULT_END
, there will be no more files or
directories. If OSTREE_REPO_COMMIT_ITER_RESULT_DIR
is returned,
then call ostree_repo_commit_traverse_iter_get_dir()
to retrieve
data for that directory. Similarly, if
OSTREE_REPO_COMMIT_ITER_RESULT_FILE
is returned, call
ostree_repo_commit_traverse_iter_get_file()
.
If OSTREE_REPO_COMMIT_ITER_RESULT_ERROR
is returned, it is a
program error to call any further API on iter
except for
ostree_repo_commit_traverse_iter_clear()
.
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.
self |
Repo |
|
flags |
Options controlling prune process |
|
depth |
Stop traversal after this many iterations (-1 for unlimited) |
|
out_objects_total |
Number of objects found. |
[out] |
out_objects_pruned |
Number of objects deleted. |
[out] |
out_pruned_object_size_total |
Storage size in bytes of objects deleted. |
[out] |
cancellable |
Cancellable |
|
error |
Error |
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.
self |
Repo |
|
commit |
ASCII SHA256 checksum for commit, or |
[allow-none] |
cancellable |
Cancellable |
|
error |
Error |
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.
self |
Repo |
|
remote_name |
Name of remote |
|
refs_to_fetch |
Optional list of refs; if |
[array zero-terminated=1][element-type utf8][allow-none] |
flags |
Options controlling fetch behavior |
|
progress |
Progress. |
[allow-none] |
cancellable |
Cancellable |
|
error |
Error |
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.
self |
Repo |
|
remote_name |
Name of remote |
|
dir_to_pull |
Subdirectory path |
|
refs_to_fetch |
Optional list of refs; if |
[array zero-terminated=1][element-type utf8][allow-none] |
flags |
Options controlling fetch behavior |
|
progress |
Progress. |
[allow-none] |
cancellable |
Cancellable |
|
error |
Error |
gboolean ostree_repo_pull_with_options (OstreeRepo *self
,const char *remote_name
,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
flags (i): An instance of OstreeRepoPullFlags
subdir (s): Pull just this subdirectory
override-remote-name (s): If local, add this remote to refspec
gpg-verify (b): GPG verify commits
gpg-verify-summary (b): GPG verify summary
depth (i): How far in the history to traverse; default is 0, -1 means infinite
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
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
self |
Repo |
|
remote_name |
Name of remote |
|
options |
A GVariant a{sv} with an extensible set of flags. |
|
progress |
Progress. |
[allow-none] |
cancellable |
Cancellable |
|
error |
Error |
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.
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.
self |
Self |
|
commit_checksum |
SHA256 of given commit to sign |
|
key_id |
Use this GPG key id |
|
homedir |
GPG home directory, or |
[allow-none] |
cancellable |
A GCancellable |
|
error |
a GError |
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.
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 static delta.
self |
Self |
|
key_id |
NULL-terminated array of GPG keys. |
|
homedir |
GPG home directory, or |
[allow-none] |
cancellable |
A GCancellable |
|
error |
a GError |
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.
self |
Repository |
|
remote_name |
Name of remote. |
[nullable] |
data |
Data as a GBytes |
|
signatures |
Signatures as a GBytes |
|
keyringdir |
Path to directory GPG keyrings; overrides built-in default if given. |
[nullable] |
extra_keyring |
Path to additional keyring file (not a directory). |
[nullable] |
cancellable |
Cancellable |
|
error |
Error |
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
.
self |
Repository |
|
commit_checksum |
ASCII SHA256 checksum |
|
keyringdir |
Path to directory GPG keyrings; overrides built-in default if given. |
[allow-none] |
extra_keyring |
Path to additional keyring file (not a directory). |
[allow-none] |
cancellable |
Cancellable |
|
error |
Error |
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.
self |
Repository |
|
commit_checksum |
ASCII SHA256 checksum |
|
keyringdir |
Path to directory GPG keyrings; overrides built-in default if given. |
[allow-none] |
extra_keyring |
Path to additional keyring file (not a directory). |
[allow-none] |
cancellable |
Cancellable |
|
error |
Error |
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.
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.
It is regenerated automatically after a commit if
core/commit-update-summary
is set.
self |
Repo |
|
additional_metadata |
A GVariant of type a{sv}, or |
[allow-none] |
cancellable |
Cancellable |
|
error |
Error |
See the documentation of OstreeRepo for more information about the possible modes.
struct OstreeRepoTransactionStats { guint metadata_objects_total; guint metadata_objects_written; guint content_objects_total; guint content_objects_written; guint64 content_bytes_written; guint64 padding1; guint64 padding2; guint64 padding3; guint64 padding4; };
A list of statistics for each transaction that may be interesting for reporting purposes.
The total number of metadata objects in the repository after this transaction has completed. |
||
The number of metadata objects that were written to the repository in this transaction. |
||
The total number of content objects in the repository after this transaction has completed. |
||
The number of content objects that were written to the repository in this transaction. |
||
The amount of data added to the repository, in bytes, counting only content objects. |
||
reserved |
||
reserved |
||
reserved |
||
reserved |
typedef struct OstreeRepoCommitModifier OstreeRepoCommitModifier;
A structure allowing control over commits.
#define OSTREE_REPO_LIST_OBJECTS_VARIANT_TYPE (G_VARIANT_TYPE ("(bas)")
b - TRUE
if object is available "loose"
as - List of pack file checksums in which this object appears