Content-addressed object store

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

Synopsis

enum                OstreeRepoMode;
OstreeRepo *        ostree_repo_new                     (GFile *path);
gboolean            ostree_repo_check                   (OstreeRepo *self,
                                                         GError **error);
GFile *             ostree_repo_get_path                (OstreeRepo *self);
OstreeRepoMode      ostree_repo_get_mode                (OstreeRepo *self);
gboolean            ostree_repo_mode_from_string        (const char *mode,
                                                         OstreeRepoMode *out_mode,
                                                         GError **error);
GKeyFile *          ostree_repo_get_config              (OstreeRepo *self);
GKeyFile *          ostree_repo_copy_config             (OstreeRepo *self);
OstreeRepo *        ostree_repo_get_parent              (OstreeRepo *self);
gboolean            ostree_repo_write_config            (OstreeRepo *self,
                                                         GKeyFile *new_config,
                                                         GError **error);
gboolean            ostree_repo_prepare_transaction     (OstreeRepo *self,
                                                         gboolean enable_commit_hardlink_scan,
                                                         gboolean *out_transaction_resume,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_commit_transaction      (OstreeRepo *self,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_commit_transaction_with_stats
                                                        (OstreeRepo *self,
                                                         guint *out_metadata_objects_total,
                                                         guint *out_metadata_objects_written,
                                                         guint *out_content_objects_total,
                                                         guint *out_content_objects_written,
                                                         guint64 *out_content_bytes_written,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_abort_transaction       (OstreeRepo *self,
                                                         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_stage_metadata          (OstreeRepo *self,
                                                         OstreeObjectType objtype,
                                                         const char *expected_checksum,
                                                         GVariant *object,
                                                         guchar **out_csum,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                ostree_repo_stage_metadata_async    (OstreeRepo *self,
                                                         OstreeObjectType objtype,
                                                         const char *expected_checksum,
                                                         GVariant *object,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            ostree_repo_stage_metadata_finish   (OstreeRepo *self,
                                                         GAsyncResult *result,
                                                         guchar **out_csum,
                                                         GError **error);
gboolean            ostree_repo_stage_metadata_trusted  (OstreeRepo *self,
                                                         OstreeObjectType objtype,
                                                         const char *checksum,
                                                         GVariant *variant,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_stage_content           (OstreeRepo *self,
                                                         const char *expected_checksum,
                                                         GInputStream *object_input,
                                                         guint64 length,
                                                         guchar **out_csum,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_stage_content_trusted   (OstreeRepo *self,
                                                         const char *checksum,
                                                         GInputStream *object_input,
                                                         guint64 length,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                ostree_repo_stage_content_async     (OstreeRepo *self,
                                                         const char *expected_checksum,
                                                         GInputStream *object,
                                                         guint64 length,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            ostree_repo_stage_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_write_ref               (OstreeRepo *self,
                                                         const char *remote,
                                                         const char *name,
                                                         const char *rev,
                                                         GError **error);
gboolean            ostree_repo_write_refspec           (OstreeRepo *self,
                                                         const char *refspec,
                                                         const char *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_load_variant_c          (OstreeRepo *self,
                                                         OstreeObjectType objtype,
                                                         const guchar *csum,
                                                         GVariant **out_variant,
                                                         GError **error);
gboolean            ostree_repo_load_variant            (OstreeRepo *self,
                                                         OstreeObjectType objtype,
                                                         const char *sha256,
                                                         GVariant **out_variant,
                                                         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_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;
OstreeRepoCommitModifier * ostree_repo_commit_modifier_new
                                                        (OstreeRepoCommitModifierFlags flags,
                                                         OstreeRepoCommitFilter commit_filter,
                                                         gpointer user_data);
OstreeRepoCommitModifier * ostree_repo_commit_modifier_ref
                                                        (OstreeRepoCommitModifier *modifier);
void                ostree_repo_commit_modifier_unref   (OstreeRepoCommitModifier *modifier);
gboolean            ostree_repo_stage_directory_to_mtree
                                                        (OstreeRepo *self,
                                                         GFile *dir,
                                                         OstreeMutableTree *mtree,
                                                         OstreeRepoCommitModifier *modifier,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_stage_archive_to_mtree  (OstreeRepo *self,
                                                         GFile *archive,
                                                         OstreeMutableTree *tree,
                                                         OstreeRepoCommitModifier *modifier,
                                                         gboolean autocreate_parents,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_stage_mtree             (OstreeRepo *self,
                                                         OstreeMutableTree *mtree,
                                                         char **out_contents_checksum,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_stage_commit            (OstreeRepo *self,
                                                         const char *branch,
                                                         const char *parent,
                                                         const char *subject,
                                                         const char *body,
                                                         const char *root_contents_checksum,
                                                         const char *root_metadata_checksum,
                                                         char **out_commit,
                                                         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_gc             (OstreeRepo *self,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_read_commit             (OstreeRepo *self,
                                                         const char *rev,
                                                         GFile **out_root,
                                                         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);
GHashTable *        ostree_repo_traverse_new_reachable  (void);
gboolean            ostree_repo_traverse_dirtree        (OstreeRepo *repo,
                                                         const char *commit_checksum,
                                                         GHashTable *inout_reachable,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            ostree_repo_traverse_commit         (OstreeRepo *repo,
                                                         const char *commit_checksum,
                                                         int maxdepth,
                                                         GHashTable *inout_reachable,
                                                         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);
enum                OstreeRepoPullFlags;
gboolean            ostree_repo_pull                    (OstreeRepo *self,
                                                         const char *remote_name,
                                                         char **refs_to_fetch,
                                                         OstreeRepoPullFlags flags,
                                                         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 two 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. 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.

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_stage_directory_to_mtree() to traverse a physical filesystem and stage content, possibly multiple times.

Once the OstreeMutableTree is complete, stage all of its metadata with ostree_repo_stage_mtree(), and finally create a commit with ostree_repo_stage_commit().

Details

enum OstreeRepoMode

typedef enum {
  OSTREE_REPO_MODE_BARE,
  OSTREE_REPO_MODE_ARCHIVE_Z2
} OstreeRepoMode;

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

OSTREE_REPO_MODE_BARE

Files are stored as themselves; 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_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_check ()

gboolean            ostree_repo_check                   (OstreeRepo *self,
                                                         GError **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_mode_from_string ()

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

ostree_repo_get_config ()

GKeyFile *          ostree_repo_get_config              (OstreeRepo *self);

Returns :

The repository configuration; do not modify. [transfer none]

ostree_repo_copy_config ()

GKeyFile *          ostree_repo_copy_config             (OstreeRepo *self);

Returns :

A newly-allocated copy of the repository config. [transfer full]

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

ostree_repo_prepare_transaction ()

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

ostree_repo_commit_transaction ()

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

ostree_repo_commit_transaction_with_stats ()

gboolean            ostree_repo_commit_transaction_with_stats
                                                        (OstreeRepo *self,
                                                         guint *out_metadata_objects_total,
                                                         guint *out_metadata_objects_written,
                                                         guint *out_content_objects_total,
                                                         guint *out_content_objects_written,
                                                         guint64 *out_content_bytes_written,
                                                         GCancellable *cancellable,
                                                         GError **error);

ostree_repo_abort_transaction ()

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

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

gboolean            ostree_repo_stage_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_stage_metadata_async ()

void                ostree_repo_stage_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 staged

user_data :

Data for callback

ostree_repo_stage_metadata_finish ()

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

ostree_repo_stage_metadata_trusted ()

gboolean            ostree_repo_stage_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_stage_content ()

gboolean            ostree_repo_stage_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_stage_content_trusted ()

gboolean            ostree_repo_stage_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_stage_content_async ()

void                ostree_repo_stage_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 staged

user_data :

User data for callback

ostree_repo_stage_content_finish ()

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

Completes an invocation of ostree_repo_stage_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.

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

gboolean            ostree_repo_write_ref               (OstreeRepo *self,
                                                         const char *remote,
                                                         const char *name,
                                                         const char *rev,
                                                         GError **error);

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

Otherwise, if rev is NULL, then delete the ref name if it exists.

This function merely changes the ref target; it is possible to use it to target earlier commits.

self :

Repo

remote :

Optional remote name. [allow-none]

name :

Name of ref, e.g. foo/bar/baz

rev :

(allow-none); ASCII SHA256 checksum; if NULL, then delete name

error :

Error

ostree_repo_write_refspec ()

gboolean            ostree_repo_write_refspec           (OstreeRepo *self,
                                                         const char *refspec,
                                                         const char *rev,
                                                         GError **error);

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

self :

Repo

refspec :

Optional remote with name of ref, e.g. remotename:foo/bar/baz

rev :

(allow-none); ASCII SHA256 checksum; if NULL, then delete refspec

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

gboolean            ostree_repo_load_variant_c          (OstreeRepo *self,
                                                         OstreeObjectType objtype,
                                                         const guchar *csum,
                                                         GVariant **out_variant,
                                                         GError **error);

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

self :

Repo

objtype :

Expected object type

csum :

Binary checksum

out_variant :

(transfer full): Metadata object. [out]

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 :

(transfer full): Metadata object. [out]

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


ostree_repo_commit_modifier_new ()

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

flags :

Control options for filter

commit_filter :

Function that can inspect individual files. [allow-none]

user_data :

User data. [allow-none]

Returns :

A new commit modifier. [transfer full]

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

gboolean            ostree_repo_stage_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_stage_archive_to_mtree ()

gboolean            ostree_repo_stage_archive_to_mtree  (OstreeRepo *self,
                                                         GFile *archive,
                                                         OstreeMutableTree *tree,
                                                         OstreeRepoCommitModifier *modifier,
                                                         gboolean autocreate_parents,
                                                         GCancellable *cancellable,
                                                         GError **error);

ostree_repo_stage_mtree ()

gboolean            ostree_repo_stage_mtree             (OstreeRepo *self,
                                                         OstreeMutableTree *mtree,
                                                         char **out_contents_checksum,
                                                         GCancellable *cancellable,
                                                         GError **error);

Write all metadata objects for mtree to repo; the resulting out_contents_checksum contains the checksum for the OSTREE_OBJECT_TYPE_DIR_TREE object.

self :

Repo

mtree :

Mutable tree

out_contents_checksum :

Return location for ASCII checksum. [out]

cancellable :

Cancellable

error :

Error

ostree_repo_stage_commit ()

gboolean            ostree_repo_stage_commit            (OstreeRepo *self,
                                                         const char *branch,
                                                         const char *parent,
                                                         const char *subject,
                                                         const char *body,
                                                         const char *root_contents_checksum,
                                                         const char *root_metadata_checksum,
                                                         char **out_commit,
                                                         GCancellable *cancellable,
                                                         GError **error);

Write a commit metadata object, referencing root_contents_checksum and root_metadata_checksum.

self :

Repo

branch :

Name of ref

parent :

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

subject :

Subject

body :

Body

root_contents_checksum :

ASCII SHA256 checksum for OSTREE_OBJECT_TYPE_DIR_TREE

root_metadata_checksum :

ASCII SHA256 checksum for OSTREE_OBJECT_TYPE_DIR_META

out_commit :

Resulting ASCII SHA256 checksum for commit. [out]

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_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 *rev,
                                                         GFile **out_root,
                                                         GCancellable *cancellable,
                                                         GError **error);

Load the content for rev into out_root.

self :

Repo

rev :

Revision (ref or ASCII checksum)

out_root :

An OstreeRepoFile corresponding to the root. [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)
} 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_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]

cancellable :

Cancellable

error :

Error

Returns :

TRUE on success, FALSE on error, and error will be set

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 full][element-type GVariant GVariant]

ostree_repo_traverse_dirtree ()

gboolean            ostree_repo_traverse_dirtree        (OstreeRepo *repo,
                                                         const char *commit_checksum,
                                                         GHashTable *inout_reachable,
                                                         GCancellable *cancellable,
                                                         GError **error);

ostree_repo_traverse_commit ()

gboolean            ostree_repo_traverse_commit         (OstreeRepo *repo,
                                                         const char *commit_checksum,
                                                         int maxdepth,
                                                         GHashTable *inout_reachable,
                                                         GCancellable *cancellable,
                                                         GError **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

enum OstreeRepoPullFlags

typedef enum {
  OSTREE_REPO_PULL_FLAGS_NONE
} OstreeRepoPullFlags;

OSTREE_REPO_PULL_FLAGS_NONE

No special options for pull

ostree_repo_pull ()

gboolean            ostree_repo_pull                    (OstreeRepo *self,
                                                         const char *remote_name,
                                                         char **refs_to_fetch,
                                                         OstreeRepoPullFlags flags,
                                                         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.

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

cancellable :

Cancellable

error :

Error