Content-addressed object store

Content-addressed object store — A git-like storage system for operating system binaries

Synopsis

typedef             OstreeRepo;
enum                OstreeRepoMode;
gboolean            ostree_repo_mode_from_string        (const char *mode,
                                                         OstreeRepoMode *out_mode,
                                                         GError **error);
OstreeRepo *        ostree_repo_new                     (GFile *path);
OstreeRepo *        ostree_repo_new_for_sysroot_path    (GFile *repo_path,
                                                         GFile *sysroot_path);
OstreeRepo *        ostree_repo_new_default             (void);
gboolean            ostree_repo_open                    (OstreeRepo *self,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                ostree_repo_set_disable_fsync       (OstreeRepo *self,
                                                         gboolean disable_fsync);
gboolean            ostree_repo_get_disable_fsync       (OstreeRepo *self);
gboolean            ostree_repo_is_system               (OstreeRepo *repo);
gboolean            ostree_repo_is_writable             (OstreeRepo *self,
                                                         GError **error);
gboolean            ostree_repo_create                  (OstreeRepo *self,
                                                         OstreeRepoMode mode,
                                                         GCancellable *cancellable,
                                                         GError **error);
GFile *             ostree_repo_get_path                (OstreeRepo *self);
OstreeRepoMode      ostree_repo_get_mode                (OstreeRepo *self);
GKeyFile *          ostree_repo_get_config              (OstreeRepo *self);
int                 ostree_repo_get_dfd                 (OstreeRepo *self);
GKeyFile *          ostree_repo_copy_config             (OstreeRepo *self);
gboolean            ostree_repo_remote_add              (OstreeRepo *self,
                                                         const char *name,
                                                         const char *url,
                                                         GVariant *options,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_remote_delete           (OstreeRepo *self,
                                                         const char *name,
                                                         GCancellable *cancellable,
                                                         GError **error);
enum                OstreeRepoRemoteChange;
gboolean            ostree_repo_remote_change           (OstreeRepo *self,
                                                         GFile *sysroot,
                                                         OstreeRepoRemoteChange changeop,
                                                         const char *name,
                                                         const char *url,
                                                         GVariant *options,
                                                         GCancellable *cancellable,
                                                         GError **error);
char **             ostree_repo_remote_list             (OstreeRepo *self,
                                                         guint *out_n_remotes);
gboolean            ostree_repo_remote_get_url          (OstreeRepo *self,
                                                         const char *name,
                                                         char **out_url,
                                                         GError **error);
gboolean            ostree_repo_remote_get_gpg_verify   (OstreeRepo *self,
                                                         const char *name,
                                                         gboolean *out_gpg_verify,
                                                         GError **error);
gboolean            ostree_repo_remote_get_gpg_verify_summary
                                                        (OstreeRepo *self,
                                                         const char *name,
                                                         gboolean *out_gpg_verify_summary,
                                                         GError **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);
gboolean            ostree_repo_remote_fetch_summary    (OstreeRepo *self,
                                                         const char *name,
                                                         GBytes **out_summary,
                                                         GBytes **out_signatures,
                                                         GCancellable *cancellable,
                                                         GError **error);
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);
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);
gboolean            ostree_repo_get_remote_list_option  (OstreeRepo *self,
                                                         const char *remote_name,
                                                         const char *option_name,
                                                         char ***out_value,
                                                         GError **error);
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);
OstreeRepo *        ostree_repo_get_parent              (OstreeRepo *self);
gboolean            ostree_repo_write_config            (OstreeRepo *self,
                                                         GKeyFile *new_config,
                                                         GError **error);
struct              OstreeRepoTransactionStats;
gboolean            ostree_repo_scan_hardlinks          (OstreeRepo *self,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_prepare_transaction     (OstreeRepo *self,
                                                         gboolean *out_transaction_resume,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_commit_transaction      (OstreeRepo *self,
                                                         OstreeRepoTransactionStats *out_stats,
                                                         GCancellable *cancellable,
                                                         GError **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);
void                ostree_repo_transaction_set_ref     (OstreeRepo *self,
                                                         const char *remote,
                                                         const char *ref,
                                                         const char *checksum);
gboolean            ostree_repo_set_ref_immediate       (OstreeRepo *self,
                                                         const char *remote,
                                                         const char *ref,
                                                         const char *checksum,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_set_cache_dir           (OstreeRepo *self,
                                                         int dfd,
                                                         const char *path,
                                                         GCancellable *cancellable,
                                                         GError **error);
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);
gboolean            ostree_repo_has_object              (OstreeRepo *self,
                                                         OstreeObjectType objtype,
                                                         const char *checksum,
                                                         gboolean *out_have_object,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_write_metadata          (OstreeRepo *self,
                                                         OstreeObjectType objtype,
                                                         const char *expected_checksum,
                                                         GVariant *object,
                                                         guchar **out_csum,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                ostree_repo_write_metadata_async    (OstreeRepo *self,
                                                         OstreeObjectType objtype,
                                                         const char *expected_checksum,
                                                         GVariant *object,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
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);
gboolean            ostree_repo_write_metadata_trusted  (OstreeRepo *self,
                                                         OstreeObjectType objtype,
                                                         const char *checksum,
                                                         GVariant *variant,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_write_metadata_stream_trusted
                                                        (OstreeRepo *self,
                                                         OstreeObjectType objtype,
                                                         const char *checksum,
                                                         GInputStream *object_input,
                                                         guint64 length,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_write_content_trusted   (OstreeRepo *self,
                                                         const char *checksum,
                                                         GInputStream *object_input,
                                                         guint64 length,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                ostree_repo_write_content_async     (OstreeRepo *self,
                                                         const char *expected_checksum,
                                                         GInputStream *object,
                                                         guint64 length,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            ostree_repo_write_content_finish    (OstreeRepo *self,
                                                         GAsyncResult *result,
                                                         guchar **out_csum,
                                                         GError **error);
gboolean            ostree_repo_resolve_rev             (OstreeRepo *self,
                                                         const char *refspec,
                                                         gboolean allow_noent,
                                                         char **out_rev,
                                                         GError **error);
gboolean            ostree_repo_resolve_rev_ext         (OstreeRepo *self,
                                                         const char *refspec,
                                                         gboolean allow_noent,
                                                         OstreeRepoResolveRevExtFlags flags,
                                                         char **out_rev,
                                                         GError **error);
gboolean            ostree_repo_list_refs               (OstreeRepo *self,
                                                         const char *refspec_prefix,
                                                         GHashTable **out_all_refs,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_list_refs_ext           (OstreeRepo *self,
                                                         const char *refspec_prefix,
                                                         GHashTable **out_all_refs,
                                                         OstreeRepoListRefsExtFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_remote_list_refs        (OstreeRepo *self,
                                                         const char *remote_name,
                                                         GHashTable **out_all_refs,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_load_variant            (OstreeRepo *self,
                                                         OstreeObjectType objtype,
                                                         const char *sha256,
                                                         GVariant **out_variant,
                                                         GError **error);
gboolean            ostree_repo_load_commit             (OstreeRepo *self,
                                                         const char *checksum,
                                                         GVariant **out_commit,
                                                         OstreeRepoCommitState *out_state,
                                                         GError **error);
gboolean            ostree_repo_load_variant_if_exists  (OstreeRepo *self,
                                                         OstreeObjectType objtype,
                                                         const char *sha256,
                                                         GVariant **out_variant,
                                                         GError **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);
gboolean            ostree_repo_load_object_stream      (OstreeRepo *self,
                                                         OstreeObjectType objtype,
                                                         const char *checksum,
                                                         GInputStream **out_input,
                                                         guint64 *out_size,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_query_object_storage_size
                                                        (OstreeRepo *self,
                                                         OstreeObjectType objtype,
                                                         const char *sha256,
                                                         guint64 *out_size,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_import_object_from      (OstreeRepo *self,
                                                         OstreeRepo *source,
                                                         OstreeObjectType objtype,
                                                         const char *checksum,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_import_object_from_with_trust
                                                        (OstreeRepo *self,
                                                         OstreeRepo *source,
                                                         OstreeObjectType objtype,
                                                         const char *checksum,
                                                         gboolean trusted,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_import_archive_to_mtree (OstreeRepo *self,
                                                         OstreeRepoImportArchiveOptions *opts,
                                                         void *archive,
                                                         OstreeMutableTree *mtree,
                                                         OstreeRepoCommitModifier *modifier,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_export_tree_to_archive  (OstreeRepo *self,
                                                         OstreeRepoExportArchiveOptions *opts,
                                                         OstreeRepoFile *root,
                                                         void *archive,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_delete_object           (OstreeRepo *self,
                                                         OstreeObjectType objtype,
                                                         const char *sha256,
                                                         GCancellable *cancellable,
                                                         GError **error);
enum                OstreeRepoCommitFilterResult;
OstreeRepoCommitFilterResult (*OstreeRepoCommitFilter)  (OstreeRepo *repo,
                                                         const char *path,
                                                         GFileInfo *file_info,
                                                         gpointer user_data);
typedef             OstreeRepoCommitModifier;
enum                OstreeRepoCommitModifierFlags;
OstreeRepoCommitModifier * ostree_repo_commit_modifier_new
                                                        (OstreeRepoCommitModifierFlags flags,
                                                         OstreeRepoCommitFilter commit_filter,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy_notify);
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);
void                ostree_repo_commit_modifier_set_sepolicy
                                                        (OstreeRepoCommitModifier *modifier,
                                                         OstreeSePolicy *sepolicy);
void                ostree_repo_commit_modifier_set_devino_cache
                                                        (OstreeRepoCommitModifier *modifier,
                                                         OstreeRepoDevInoCache *cache);
OstreeRepoCommitModifier * ostree_repo_commit_modifier_ref
                                                        (OstreeRepoCommitModifier *modifier);
void                ostree_repo_commit_modifier_unref   (OstreeRepoCommitModifier *modifier);
OstreeRepoDevInoCache * ostree_repo_devino_cache_new    (void);
OstreeRepoDevInoCache * ostree_repo_devino_cache_ref    (OstreeRepoDevInoCache *cache);
void                ostree_repo_devino_cache_unref      (OstreeRepoDevInoCache *cache);
GType               ostree_repo_devino_cache_get_type   (void);
gboolean            ostree_repo_write_directory_to_mtree
                                                        (OstreeRepo *self,
                                                         GFile *dir,
                                                         OstreeMutableTree *mtree,
                                                         OstreeRepoCommitModifier *modifier,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_write_dfd_to_mtree      (OstreeRepo *self,
                                                         int dfd,
                                                         const char *path,
                                                         OstreeMutableTree *mtree,
                                                         OstreeRepoCommitModifier *modifier,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_write_archive_to_mtree  (OstreeRepo *self,
                                                         GFile *archive,
                                                         OstreeMutableTree *mtree,
                                                         OstreeRepoCommitModifier *modifier,
                                                         gboolean autocreate_parents,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_write_mtree             (OstreeRepo *self,
                                                         OstreeMutableTree *mtree,
                                                         GFile **out_file,
                                                         GCancellable *cancellable,
                                                         GError **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);
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);
gboolean            ostree_repo_read_commit_detached_metadata
                                                        (OstreeRepo *self,
                                                         const char *checksum,
                                                         GVariant **out_metadata,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_write_commit_detached_metadata
                                                        (OstreeRepo *self,
                                                         const char *checksum,
                                                         GVariant *metadata,
                                                         GCancellable *cancellable,
                                                         GError **error);
enum                OstreeRepoCheckoutMode;
enum                OstreeRepoCheckoutOverwriteMode;
gboolean            ostree_repo_checkout_tree           (OstreeRepo *self,
                                                         OstreeRepoCheckoutMode mode,
                                                         OstreeRepoCheckoutOverwriteMode overwrite_mode,
                                                         GFile *destination,
                                                         OstreeRepoFile *source,
                                                         GFileInfo *source_info,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_checkout_tree_at        (OstreeRepo *self,
                                                         OstreeRepoCheckoutOptions *options,
                                                         int destination_dfd,
                                                         const char *destination_path,
                                                         const char *commit,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_checkout_at             (OstreeRepo *self,
                                                         OstreeRepoCheckoutAtOptions *options,
                                                         int destination_dfd,
                                                         const char *destination_path,
                                                         const char *commit,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_checkout_gc             (OstreeRepo *self,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_read_commit             (OstreeRepo *self,
                                                         const char *ref,
                                                         GFile **out_root,
                                                         char **out_commit,
                                                         GCancellable *cancellable,
                                                         GError **error);
enum                OstreeRepoListObjectsFlags;
#define             OSTREE_REPO_LIST_OBJECTS_VARIANT_TYPE
gboolean            ostree_repo_list_objects            (OstreeRepo *self,
                                                         OstreeRepoListObjectsFlags flags,
                                                         GHashTable **out_objects,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_list_commit_objects_starting_with
                                                        (OstreeRepo *self,
                                                         const char *start,
                                                         GHashTable **out_commits,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_list_static_delta_names (OstreeRepo *self,
                                                         GPtrArray **out_deltas,
                                                         GCancellable *cancellable,
                                                         GError **error);
enum                OstreeStaticDeltaGenerateOpt;
gboolean            ostree_repo_static_delta_generate   (OstreeRepo *self,
                                                         OstreeStaticDeltaGenerateOpt opt,
                                                         const char *from,
                                                         const char *to,
                                                         GVariant *metadata,
                                                         GVariant *params,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_static_delta_execute_offline
                                                        (OstreeRepo *self,
                                                         GFile *dir_or_file,
                                                         gboolean skip_validation,
                                                         GCancellable *cancellable,
                                                         GError **error);
GHashTable *        ostree_repo_traverse_new_reachable  (void);
gboolean            ostree_repo_traverse_commit         (OstreeRepo *repo,
                                                         const char *commit_checksum,
                                                         int maxdepth,
                                                         GHashTable **out_reachable,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_traverse_commit_union   (OstreeRepo *repo,
                                                         const char *commit_checksum,
                                                         int maxdepth,
                                                         GHashTable *inout_reachable,
                                                         GCancellable *cancellable,
                                                         GError **error);
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);
void                ostree_repo_commit_traverse_iter_get_file
                                                        (OstreeRepoCommitTraverseIter *iter,
                                                         char **out_name,
                                                         char **out_checksum);
gboolean            ostree_repo_commit_traverse_iter_init_commit
                                                        (OstreeRepoCommitTraverseIter *iter,
                                                         OstreeRepo *repo,
                                                         GVariant *commit,
                                                         OstreeRepoCommitTraverseFlags flags,
                                                         GError **error);
gboolean            ostree_repo_commit_traverse_iter_init_dirtree
                                                        (OstreeRepoCommitTraverseIter *iter,
                                                         OstreeRepo *repo,
                                                         GVariant *dirtree,
                                                         OstreeRepoCommitTraverseFlags flags,
                                                         GError **error);
OstreeRepoCommitIterResult ostree_repo_commit_traverse_iter_next
                                                        (OstreeRepoCommitTraverseIter *iter,
                                                         GCancellable *cancellable,
                                                         GError **error);
enum                OstreeRepoPruneFlags;
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);
gboolean            ostree_repo_prune_static_deltas     (OstreeRepo *self,
                                                         const char *commit,
                                                         GCancellable *cancellable,
                                                         GError **error);
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);
enum                OstreeRepoPullFlags;
gboolean            ostree_repo_pull                    (OstreeRepo *self,
                                                         const char *remote_name,
                                                         char **refs_to_fetch,
                                                         OstreeRepoPullFlags flags,
                                                         OstreeAsyncProgress *progress,
                                                         GCancellable *cancellable,
                                                         GError **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);
gboolean            ostree_repo_pull_with_options       (OstreeRepo *self,
                                                         const char *remote_name_or_baseurl,
                                                         GVariant *options,
                                                         OstreeAsyncProgress *progress,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                ostree_repo_pull_default_console_progress_changed
                                                        (OstreeAsyncProgress *progress,
                                                         gpointer user_data);
gboolean            ostree_repo_sign_commit             (OstreeRepo *self,
                                                         const gchar *commit_checksum,
                                                         const gchar *key_id,
                                                         const gchar *homedir,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_append_gpg_signature    (OstreeRepo *self,
                                                         const gchar *commit_checksum,
                                                         GBytes *signature_bytes,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_add_gpg_signature_summary
                                                        (OstreeRepo *self,
                                                         const gchar **key_id,
                                                         const gchar *homedir,
                                                         GCancellable *cancellable,
                                                         GError **error);
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);
gboolean            ostree_repo_verify_commit           (OstreeRepo *self,
                                                         const gchar *commit_checksum,
                                                         GFile *keyringdir,
                                                         GFile *extra_keyring,
                                                         GCancellable *cancellable,
                                                         GError **error);
OstreeGpgVerifyResult * ostree_repo_verify_commit_ext   (OstreeRepo *self,
                                                         const gchar *commit_checksum,
                                                         GFile *keyringdir,
                                                         GFile *extra_keyring,
                                                         GCancellable *cancellable,
                                                         GError **error);
OstreeGpgVerifyResult * ostree_repo_verify_commit_for_remote
                                                        (OstreeRepo *self,
                                                         const gchar *commit_checksum,
                                                         const gchar *remote_name,
                                                         GCancellable *cancellable,
                                                         GError **error);
OstreeGpgVerifyResult * ostree_repo_verify_summary      (OstreeRepo *self,
                                                         const char *remote_name,
                                                         GBytes *summary,
                                                         GBytes *signatures,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_regenerate_summary      (OstreeRepo *self,
                                                         GVariant *additional_metadata,
                                                         GCancellable *cancellable,
                                                         GError **error);

Description

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

Details

OstreeRepo

typedef struct OstreeRepo OstreeRepo;

Private instance structure.


enum OstreeRepoMode

typedef enum {
  OSTREE_REPO_MODE_BARE,
  OSTREE_REPO_MODE_ARCHIVE_Z2,
  OSTREE_REPO_MODE_BARE_USER
} OstreeRepoMode;

See the documentation of OstreeRepo for more information about the possible modes.

OSTREE_REPO_MODE_BARE

Files are stored as themselves; checkouts are hardlinks; can only be written as root

OSTREE_REPO_MODE_ARCHIVE_Z2

Files are compressed, should be owned by non-root. Can be served via HTTP

OSTREE_REPO_MODE_BARE_USER

Files are stored as themselves, except ownership; can be written by user. Hardlinks work only in user checkouts.

ostree_repo_mode_from_string ()

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

ostree_repo_new ()

OstreeRepo *        ostree_repo_new                     (GFile *path);

path :

Path to a repository

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 "/".

repo_path :

Path to a repository

sysroot_path :

Path to the system root

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.

self :

An OstreeRepo

disable_fsync :

If TRUE, do not fsync

ostree_repo_get_disable_fsync ()

gboolean            ostree_repo_get_disable_fsync       (OstreeRepo *self);

For more information see ostree_repo_set_disable_fsync().

self :

An OstreeRepo

Returns :

Whether or not fsync() is enabled for this repo.

ostree_repo_is_system ()

gboolean            ostree_repo_is_system               (OstreeRepo *repo);

repo :

Repository

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.

self :

Repo

error :

a GError

Returns :

TRUE if this repository is writable

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.

self :

An OstreeRepo

mode :

The mode to store the repository in

cancellable :

Cancellable

error :

Error

ostree_repo_get_path ()

GFile *             ostree_repo_get_path                (OstreeRepo *self);

Returns :

Path to repo. [transfer none]

ostree_repo_get_mode ()

OstreeRepoMode      ostree_repo_get_mode                (OstreeRepo *self);

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

self :

Repo

Returns :

File descriptor for repository root - owned by self

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()

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

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.

self :

Repo

name :

Name of remote

cancellable :

Cancellable

error :

Error

enum OstreeRepoRemoteChange

typedef enum {
  OSTREE_REPO_REMOTE_CHANGE_ADD,
  OSTREE_REPO_REMOTE_CHANGE_ADD_IF_NOT_EXISTS,
  OSTREE_REPO_REMOTE_CHANGE_DELETE,
  OSTREE_REPO_REMOTE_CHANGE_DELETE_IF_EXISTS
} OstreeRepoRemoteChange;

OSTREE_REPO_REMOTE_CHANGE_ADD

OSTREE_REPO_REMOTE_CHANGE_ADD_IF_NOT_EXISTS

OSTREE_REPO_REMOTE_CHANGE_DELETE

OSTREE_REPO_REMOTE_CHANGE_DELETE_IF_EXISTS


ostree_repo_remote_change ()

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

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

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

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.

self :

Repo

out_n_remotes :

Number of remotes available. [out][allow-none]

Returns :

a NULL-terminated array of remote names. [array length=out_n_remotes][transfer full]

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.

self :

Repo

name :

Name of remote

out_url :

Remote's URL. [out][allow-none]

error :

Error

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.

self :

Repo

name :

Name of remote

out_gpg_verify :

Remote's GPG option. [out][allow-none]

error :

Error

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.

self :

Repo

name :

Name of remote

out_gpg_verify_summary :

Remote's GPG option. [out][allow-none]

error :

Error

Returns :

TRUE on success, FALSE on failure

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.

self :

Self

name :

name of a remote

source_stream :

a GInputStream, or NULL. [allow-none]

key_ids :

a NULL-terminated array of GPG key IDs, or NULL. [array zero-terminated=1][element-type utf8][allow-none]

out_imported :

return location for the number of imported keys, or NULL. [allow-none]

cancellable :

a GCancellable

error :

a GError

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.

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

self :

Self

name :

name of a remote

out_summary :

return location for raw summary data, or NULL. [out][optional]

out_signatures :

return location for raw summary signature data, or NULL. [out][optional]

cancellable :

a GCancellable

error :

a GError

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

self :

Self

name :

name of a remote

options :

A GVariant a{sv} with an extensible set of flags. [nullable]

out_summary :

return location for raw summary data, or NULL. [out][optional]

out_signatures :

return location for raw summary signature data, or NULL. [out][optional]

cancellable :

a GCancellable

error :

a GError

Returns :

TRUE on success, FALSE on failure

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.

self :

A OstreeRepo

remote_name :

Name

option_name :

Option

default_value :

Value returned if option_name is not present

out_value :

(out) : location to store the result.

error :

Error

Returns :

TRUE on success, otherwise FALSE with error set

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 an zero terminated array of strings. If the option is not set, out_value will be set to NULL.

self :

A OstreeRepo

remote_name :

Name

option_name :

Option

out_value :

location to store the list of strings. The list should be freed with g_strfreev(). [out][array zero-terminated=1]

error :

Error

Returns :

TRUE on success, otherwise FALSE with error set

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.

self :

A OstreeRepo

remote_name :

Name

option_name :

Option

default_value :

Value returned if option_name is not present. [allow-none]

out_value :

Return location for value. [out]

error :

Error

Returns :

TRUE on success, otherwise FALSE with error set

ostree_repo_get_parent ()

OstreeRepo *        ostree_repo_get_parent              (OstreeRepo *self);

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

self :

Repo

Returns :

Parent repository, or NULL if none. [transfer none]

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. Note that new_config should not be modified after - this function simply adds a reference.

self :

Repo

new_config :

Overwrite the config file with this data. Do not change later!

error :

a GError

struct OstreeRepoTransactionStats

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.

guint metadata_objects_total;

The total number of metadata objects in the repository after this transaction has completed.

guint metadata_objects_written;

The number of metadata objects that were written to the repository in this transaction.

guint content_objects_total;

The total number of content objects in the repository after this transaction has completed.

guint content_objects_written;

The number of content objects that were written to the repository in this transaction.

guint64 content_bytes_written;

The amount of data added to the repository, in bytes, counting only content objects.

guint64 padding1;

reserved

guint64 padding2;

reserved

guint64 padding3;

reserved

guint64 padding4;

reserved

ostree_repo_scan_hardlinks ()

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.

self :

An OstreeRepo

cancellable :

Cancellable

error :

Error

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 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 `state/.commitpartial` files. [allow-none][out]

cancellable :

Cancellable

error :

Error

ostree_repo_commit_transaction ()

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

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

self :

An OstreeRepo

out_stats :

A set of statistics of things that happened during this transaction. [allow-none][out]

cancellable :

Cancellable

error :

Error

ostree_repo_abort_transaction ()

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

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.

self :

An OstreeRepo

refspec :

The refspec to write

checksum :

The checksum to point it to

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

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.

self :

An OstreeRepo

remote :

A remote for the ref. [allow-none]

ref :

The ref to write

checksum :

The checksum to point it to, or NULL to unset. [allow-none]

cancellable :

GCancellable

error :

GError

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.

self :

An OstreeRepo

dfd :

directory fd

path :

subpath in dfd

cancellable :

a GCancellable

error :

a GError

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.

self :

Repo

objtype :

Object type

checksum :

ASCII SHA256 checksum

out_have_object :

TRUE if repository contains object. [out]

cancellable :

Cancellable

error :

Error

Returns :

FALSE if an unexpected error occurred, TRUE otherwise

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

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.

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 callback

ostree_repo_write_metadata_finish ()

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

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.

self :

Repo

expected_checksum :

If provided, validate content against this checksum. [allow-none]

object_input :

Content object stream

length :

Length of object_input

out_csum :

Binary checksum. [out][array fixed-size=32][allow-none]

cancellable :

Cancellable

error :

Error

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.

self :

Repo

objtype :

Object type

checksum :

Store object with this ASCII SHA256 checksum

variant :

Metadata object

cancellable :

Cancellable

error :

Error

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.

self :

Repo

objtype :

Object type

checksum :

Store object with this ASCII SHA256 checksum

object_input :

Metadata object stream

length :

Length, may be 0 for unknown

cancellable :

Cancellable

error :

Error

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.

self :

Repo

checksum :

Store content using this ASCII SHA256 checksum

object_input :

Content stream

length :

Length of object_input

cancellable :

Cancellable

error :

Data for callback

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.

self :

Repo

expected_checksum :

If provided, validate content against this checksum. [allow-none]

object :

Input

length :

Length of object

cancellable :

Cancellable

callback :

Invoked when content is writed

user_data :

User data for callback

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

self :

a OstreeRepo

result :

a GAsyncResult

out_csum :

A binary SHA256 checksum of the content object. [out][transfer full]

error :

a GError

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.

self :

Repo

refspec :

A refspec

allow_noent :

Do not throw an error if refspec does not exist

out_rev :

A checksum,or NULL if allow_noent is true and it does not exist. [out][transfer full]

error :

Error

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.

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 NULL if allow_noent is true and it does not exist. [out][transfer full]

error :

Error

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.

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

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

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);

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

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.

self :

Repo

objtype :

Expected object type

sha256 :

Checksum string

out_variant :

Metadata object. [out][transfer full]

error :

Error

ostree_repo_load_commit ()

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

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

self :

Repo

checksum :

Commit checksum

out_commit :

Commit. [out][allow-none]

out_state :

Commit state. [out][allow-none]

error :

Error

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, NULL is returned.

self :

Repo

objtype :

Object type

sha256 :

ASCII checksum

out_variant :

Metadata. [out][transfer full]

error :

Error

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.

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

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.

self :

Repo

objtype :

Object type

checksum :

ASCII SHA256 checksum

out_input :

Stream for object. [out]

out_size :

Length of out_input. [out]

cancellable :

Cancellable

error :

Error

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.

self :

Repo

objtype :

Object type

sha256 :

Checksum

out_size :

Size in bytes object occupies physically. [out]

cancellable :

Cancellable

error :

Error

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.

self :

Destination repo

source :

Source repo

objtype :

Object type

checksum :

checksum

cancellable :

Cancellable

error :

Error

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

self :

Destination repo

source :

Source repo

objtype :

Object type

checksum :

checksum

trusted :

If TRUE, assume the source repo is valid and trusted

cancellable :

Cancellable

error :

Error

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.

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

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.

self :

An OstreeRepo

opts :

Options controlling conversion

root :

An OstreeRepoFile for the base directory

archive :

A `struct archive`, but specified as void to avoid a dependency on the libarchive headers

cancellable :

Cancellable

error :

Error

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.

self :

Repo

objtype :

Object type

sha256 :

Checksum

cancellable :

Cancellable

error :

Error

enum OstreeRepoCommitFilterResult

typedef enum {
  OSTREE_REPO_COMMIT_FILTER_ALLOW,
  OSTREE_REPO_COMMIT_FILTER_SKIP
} OstreeRepoCommitFilterResult;

OSTREE_REPO_COMMIT_FILTER_ALLOW

Do commit this object

OSTREE_REPO_COMMIT_FILTER_SKIP

Ignore this object

OstreeRepoCommitFilter ()

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

repo :

Repo

path :

Path to file

file_info :

File information

user_data :

User data

Returns :

OstreeRepoCommitFilterResult saying whether or not to commit this file

OstreeRepoCommitModifier

typedef struct OstreeRepoCommitModifier OstreeRepoCommitModifier;

A structure allowing control over commits.


enum OstreeRepoCommitModifierFlags

typedef enum {
  OSTREE_REPO_COMMIT_MODIFIER_FLAGS_NONE = 0,
  OSTREE_REPO_COMMIT_MODIFIER_FLAGS_SKIP_XATTRS = (1 << 0),
  OSTREE_REPO_COMMIT_MODIFIER_FLAGS_GENERATE_SIZES = (1 << 1)
} OstreeRepoCommitModifierFlags;

OSTREE_REPO_COMMIT_MODIFIER_FLAGS_NONE

No special flags

OSTREE_REPO_COMMIT_MODIFIER_FLAGS_SKIP_XATTRS

Do not process extended attributes

OSTREE_REPO_COMMIT_MODIFIER_FLAGS_GENERATE_SIZES

Generate size information.

ostree_repo_commit_modifier_new ()

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

Returns :

A new commit modifier. [transfer full]

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.

modifier :

An OstreeRepoCommitModifier

callback :

Function to be invoked, should return extended attributes for path

destroy :

Destroy notification

user_data :

Data for callback:

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.

modifier :

An OstreeRepoCommitModifier

sepolicy :

Policy to use for labeling. [allow-none]

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()`. This function can then be used for later calls to `ostree_repo_write_directory_to_mtree()` to optimize commits.

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.

modifier :

Modifier

cache :

A hash table caching device,inode to checksums

ostree_repo_commit_modifier_ref ()

OstreeRepoCommitModifier * ostree_repo_commit_modifier_ref
                                                        (OstreeRepoCommitModifier *modifier);

ostree_repo_commit_modifier_unref ()

void                ostree_repo_commit_modifier_unref   (OstreeRepoCommitModifier *modifier);

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

Returns :

Newly allocated cache. [transfer full]

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.

self :

Repo

dir :

Path to a directory

mtree :

Overlay directory contents into this tree

modifier :

Optional modifier. [allow-none]

cancellable :

Cancellable

error :

Error

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.

self :

Repo

dfd :

Directory file descriptor

path :

Path

mtree :

Overlay directory contents into this tree

modifier :

Optional modifier. [allow-none]

cancellable :

Cancellable

error :

Error

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.

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

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.

self :

Repo

mtree :

Mutable tree

out_file :

An OstreeRepoFile representing mtree's root. [out]

cancellable :

Cancellable

error :

Error

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.

self :

Repo

parent :

ASCII SHA256 checksum for parent, or NULL for none. [allow-none]

subject :

Subject. [allow-none]

body :

Body. [allow-none]

metadata :

GVariant of type a{sv}, or NULL for none. [allow-none]

root :

The tree to point the commit to

out_commit :

Resulting ASCII SHA256 checksum for commit. [out]

cancellable :

Cancellable

error :

Error

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.

self :

Repo

parent :

ASCII SHA256 checksum for parent, or NULL for none. [allow-none]

subject :

Subject. [allow-none]

body :

Body. [allow-none]

metadata :

GVariant of type a{sv}, or NULL for none. [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

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.

self :

Repo

checksum :

ASCII SHA256 commit checksum

out_metadata :

Metadata associated with commit in with format "a{sv}", or NULL if none exists. [out][transfer full]

cancellable :

Cancellable

error :

Error

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.

self :

Repo

checksum :

ASCII SHA256 commit checksum

metadata :

Metadata to associate with commit in with format "a{sv}", or NULL to delete. [allow-none]

cancellable :

Cancellable

error :

Error

enum OstreeRepoCheckoutMode

typedef enum {
  OSTREE_REPO_CHECKOUT_MODE_NONE = 0,
  OSTREE_REPO_CHECKOUT_MODE_USER = 1
} OstreeRepoCheckoutMode;

OSTREE_REPO_CHECKOUT_MODE_NONE

No special options

OSTREE_REPO_CHECKOUT_MODE_USER

Ignore uid/gid of files

enum OstreeRepoCheckoutOverwriteMode

typedef enum {
  OSTREE_REPO_CHECKOUT_OVERWRITE_NONE = 0,
  OSTREE_REPO_CHECKOUT_OVERWRITE_UNION_FILES = 1
} OstreeRepoCheckoutOverwriteMode;

OSTREE_REPO_CHECKOUT_OVERWRITE_NONE

No special options

OSTREE_REPO_CHECKOUT_OVERWRITE_UNION_FILES

When layering checkouts, overwrite earlier files, but keep earlier directories

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.

self :

Repo

mode :

Options controlling all files

overwrite_mode :

Whether or not to overwrite files

destination :

Place tree here

source :

Source tree

source_info :

Source info

cancellable :

Cancellable

error :

Error

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);

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.

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

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.

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

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.

self :

Repo

cancellable :

Cancellable

error :

Error

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.

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

enum OstreeRepoListObjectsFlags

typedef enum {
  OSTREE_REPO_LIST_OBJECTS_LOOSE = (1 << 0),
  OSTREE_REPO_LIST_OBJECTS_PACKED = (1 << 1),
  OSTREE_REPO_LIST_OBJECTS_ALL = (1 << 2),
  OSTREE_REPO_LIST_OBJECTS_NO_PARENTS = (1 << 3),
} OstreeRepoListObjectsFlags;

OSTREE_REPO_LIST_OBJECTS_LOOSE

List only loose (plain file) objects

OSTREE_REPO_LIST_OBJECTS_PACKED

List only packed (compacted into blobs) objects

OSTREE_REPO_LIST_OBJECTS_ALL

List all objects

OSTREE_REPO_LIST_OBJECTS_NO_PARENTS

Only list objects in this repo, not parents

OSTREE_REPO_LIST_OBJECTS_VARIANT_TYPE

#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


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.

self :

Repo

flags :

Flags controlling enumeration

out_objects :

Map of serialized object name to variant data. [out][transfer container][element-type GVariant GVariant]

cancellable :

Cancellable

error :

Error

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.

self :

Repo

start :

List commits starting with this checksum

out_commits :

Map of serialized commit name to variant data. [out][transfer container][element-type GVariant GVariant]

cancellable :

Cancellable

error :

Error

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.

self :

Repo

out_deltas :

String name of deltas (checksum-checksum.delta). [out][element-type utf8][transfer container]

cancellable :

Cancellable

error :

Error

enum OstreeStaticDeltaGenerateOpt

typedef enum {
  OSTREE_STATIC_DELTA_GENERATE_OPT_LOWLATENCY,
  OSTREE_STATIC_DELTA_GENERATE_OPT_MAJOR
} OstreeStaticDeltaGenerateOpt;

Parameters controlling optimization of static deltas.

OSTREE_STATIC_DELTA_GENERATE_OPT_LOWLATENCY

Optimize for speed of delta creation over space

OSTREE_STATIC_DELTA_GENERATE_OPT_MAJOR

Optimize for delta size (may be very slow)

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, and parts in the same directory. Default saves to repository.

self :

Repo

opt :

High level optimization choice

from :

ASCII SHA256 checksum of origin, or NULL

to :

ASCII SHA256 checksum of target

metadata :

Optional metadata. [allow-none]

params :

Parameters, see below. [allow-none]

cancellable :

Cancellable

error :

Error

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.

self :

Repo

dir_or_file :

Path to a directory containing static delta data, or directly to the superblock

skip_validation :

If TRUE, assume data integrity

cancellable :

Cancellable

error :

Error

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

Returns :

A new hash table. [transfer container][element-type GVariant GVariant]

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.

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

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.

repo :

Repo

commit_checksum :

ASCII SHA256 checksum

maxdepth :

Traverse this many parent commits, -1 for unlimited

inout_reachable :

Set of reachable objects

cancellable :

Cancellable

error :

Error

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

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]

ostree_repo_commit_traverse_iter_get_file ()

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]

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.

iter :

An iter

repo :

A repo

commit :

Variant of type OSTREE_OBJECT_TYPE_COMMIT

flags :

Flags

error :

Error

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.

iter :

An iter

repo :

A repo

dirtree :

Variant of type OSTREE_OBJECT_TYPE_DIR_TREE

flags :

Flags

error :

Error

ostree_repo_commit_traverse_iter_next ()

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

iter :

An iter

cancellable :

Cancellable

error :

Error

enum OstreeRepoPruneFlags

typedef enum {
  OSTREE_REPO_PRUNE_FLAGS_NONE,
  OSTREE_REPO_PRUNE_FLAGS_NO_PRUNE,
  OSTREE_REPO_PRUNE_FLAGS_REFS_ONLY
} OstreeRepoPruneFlags;

OSTREE_REPO_PRUNE_FLAGS_NONE

No special options for pruning

OSTREE_REPO_PRUNE_FLAGS_NO_PRUNE

Don't actually delete objects

OSTREE_REPO_PRUNE_FLAGS_REFS_ONLY

Do not traverse individual commit objects, only follow refs

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.

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

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.

self :

Repo

commit :

ASCII SHA256 checksum for commit, or NULL for each non existing commit. [allow-none]

cancellable :

Cancellable

error :

Error

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.

self :

Repo

options :

Options controlling prune process

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

enum OstreeRepoPullFlags

typedef enum {
  OSTREE_REPO_PULL_FLAGS_NONE,
  OSTREE_REPO_PULL_FLAGS_MIRROR = (1 << 0),
  OSTREE_REPO_PULL_FLAGS_COMMIT_ONLY = (1 << 1),
  OSTREE_REPO_PULL_FLAGS_UNTRUSTED = (1 << 2)
} OstreeRepoPullFlags;

OSTREE_REPO_PULL_FLAGS_NONE

No special options for pull

OSTREE_REPO_PULL_FLAGS_MIRROR

Write out refs suitable for mirrors

OSTREE_REPO_PULL_FLAGS_COMMIT_ONLY

Fetch only the commit metadata

OSTREE_REPO_PULL_FLAGS_UNTRUSTED

Don't trust local remote

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.

self :

Repo

remote_name :

Name of remote

refs_to_fetch :

Optional list of refs; if NULL, fetch all configured refs. [array zero-terminated=1][element-type utf8][allow-none]

flags :

Options controlling fetch behavior

progress :

Progress. [allow-none]

cancellable :

Cancellable

error :

Error

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.

self :

Repo

remote_name :

Name of remote

dir_to_pull :

Subdirectory path

refs_to_fetch :

Optional list of refs; if NULL, fetch all configured refs. [array zero-terminated=1][element-type utf8][allow-none]

flags :

Options controlling fetch behavior

progress :

Progress. [allow-none]

cancellable :

Cancellable

error :

Error

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 * 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 * 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 * inherit-transaction (b): Don't initiate, finish or abort a transaction, usefult to do mutliple pulls in one transaction. * http-headers (a(ss)): Additional headers to add to all HTTP requests

self :

Repo

remote_name_or_baseurl :

Name of remote or file:// url

options :

A GVariant a{sv} with an extensible set of flags.

progress :

Progress. [allow-none]

cancellable :

Cancellable

error :

Error

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.

progress :

Async progress

user_data :

User data. [allow-none]

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.

self :

Self

commit_checksum :

SHA256 of given commit to sign

key_id :

Use this GPG key id

homedir :

GPG home directory, or NULL. [allow-none]

cancellable :

A GCancellable

error :

a GError

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.

self :

Self

commit_checksum :

SHA256 of given commit to sign

signature_bytes :

Signature data

cancellable :

A GCancellable

error :

a GError

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 static delta.

self :

Self

key_id :

NULL-terminated array of GPG keys. [array zero-terminated=1][element-type utf8]

homedir :

GPG home directory, or NULL. [allow-none]

cancellable :

A GCancellable

error :

a GError

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.

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

Returns :

an OstreeGpgVerifyResult, or NULL on error. [transfer full]

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.

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

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.

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

Returns :

an OstreeGpgVerifyResult, or NULL on error. [transfer full]

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.

self :

Repository

commit_checksum :

ASCII SHA256 checksum

remote_name :

OSTree remote to use for configuration

cancellable :

Cancellable

error :

Error

Returns :

an OstreeGpgVerifyResult, or NULL on error. [transfer full]

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.

self :

Repo

remote_name :

Name of remote

summary :

Summary data as a GBytes

signatures :

Summary signatures as a GBytes

cancellable :

Cancellable

error :

Error

Returns :

an OstreeGpgVerifyResult, or NULL on error. [transfer full]

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.

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 NULL. [allow-none]

cancellable :

Cancellable

error :

Error