## 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 *repo,
                                                             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,
                                                             gsize *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);
                        OstreeRepoCommitModifier;
    OstreeRepoCommitModifier * ostree_repo_commit_modifier_new
                                                            (void);
    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;
    void                ostree_repo_checkout_tree_async     (OstreeRepo *self,
                                                             OstreeRepoCheckoutMode mode,
                                                             OstreeRepoCheckoutOverwriteMode overwrite_mode,
                                                             GFile *destination,
                                                             OstreeRepoFile *source,
                                                             GFileInfo *source_info,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            ostree_repo_checkout_tree_finish    (OstreeRepo *self,
                                                             GAsyncResult *result,
                                                             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 *repo,
                                                             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);

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

### ostree_repo_write_refspec ()

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

### ostree_repo_list_refs ()

    gboolean            ostree_repo_list_refs               (OstreeRepo *repo,
                                                             const char *refspec_prefix,
                                                             GHashTable **out_all_refs,
                                                             GCancellable *cancellable,
                                                             GError **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,
                                                             gsize *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 {
      volatile gint refcount;

      guint reserved_flags : 31;
      guint skip_xattrs : 1;

      OstreeRepoCommitFilter filter;
      gpointer user_data;

      gpointer reserved[3];
    } OstreeRepoCommitModifier;

A structure allowing control over commits.

### ostree_repo_commit_modifier_new ()

    OstreeRepoCommitModifier * ostree_repo_commit_modifier_new
                                                            (void);

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

    void                ostree_repo_checkout_tree_async     (OstreeRepo *self,
                                                             OstreeRepoCheckoutMode mode,
                                                             OstreeRepoCheckoutOverwriteMode overwrite_mode,
                                                             GFile *destination,
                                                             OstreeRepoFile *source,
                                                             GFileInfo *source_info,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

### ostree_repo_checkout_tree_finish ()

    gboolean            ostree_repo_checkout_tree_finish    (OstreeRepo *self,
                                                             GAsyncResult *result,
                                                             GError **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 *repo,
                                                             OstreeRepoPruneFlags flags,
                                                             gint depth,
                                                             gint *out_objects_total,
                                                             gint *out_objects_pruned,
                                                             guint64 *out_pruned_object_size_total,
                                                             GCancellable *cancellable,
                                                             GError **error);

### enum OstreeRepoPullFlags

    typedef enum {
      OSTREE_REPO_PULL_FLAGS_NONE,
      OSTREE_REPO_PULL_FLAGS_RELATED
    } OstreeRepoPullFlags;

`OSTREE_REPO_PULL_FLAGS_NONE` | No special options for pull
`OSTREE_REPO_PULL_FLAGS_RELATED` | Fetch objects referred to by each commit

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