Content-addressed object store

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

## Synopsis

    typedef             OstreeRepo;
    enum                OstreeRepoMode;
    OstreeRepo *        ostree_repo_new                     (GFile *path);
    OstreeRepo *        ostree_repo_new_default             (void);
    gboolean            ostree_repo_open                    (OstreeRepo *self,
                                                             GCancellable *cancellable,
                                                             GError **error);
    gboolean            ostree_repo_create                  (OstreeRepo *self,
                                                             OstreeRepoMode mode,
                                                             GCancellable *cancellable,
                                                             GError **error);
    GFile *             ostree_repo_get_path                (OstreeRepo *self);
    OstreeRepoMode      ostree_repo_get_mode                (OstreeRepo *self);
    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);
    struct              OstreeRepoTransactionStats;
    gboolean            ostree_repo_scan_hardlinks          (OstreeRepo *self,
                                                             GCancellable *cancellable,
                                                             GError **error);
    gboolean            ostree_repo_prepare_transaction     (OstreeRepo *self,
                                                             gboolean *out_transaction_resume,
                                                             GCancellable *cancellable,
                                                             GError **error);
    gboolean            ostree_repo_commit_transaction      (OstreeRepo *self,
                                                             OstreeRepoTransactionStats *out_stats,
                                                             GCancellable *cancellable,
                                                             GError **error);
    gboolean            ostree_repo_abort_transaction       (OstreeRepo *self,
                                                             GCancellable *cancellable,
                                                             GError **error);
    void                ostree_repo_transaction_set_ref     (OstreeRepo *self,
                                                             const char *remote,
                                                             const char *ref,
                                                             const char *checksum);
    void                ostree_repo_transaction_set_refspec (OstreeRepo *self,
                                                             const char *refspec,
                                                             const char *checksum);
    gboolean            ostree_repo_has_object              (OstreeRepo *self,
                                                             OstreeObjectType objtype,
                                                             const char *checksum,
                                                             gboolean *out_have_object,
                                                             GCancellable *cancellable,
                                                             GError **error);
    gboolean            ostree_repo_write_metadata          (OstreeRepo *self,
                                                             OstreeObjectType objtype,
                                                             const char *expected_checksum,
                                                             GVariant *object,
                                                             guchar **out_csum,
                                                             GCancellable *cancellable,
                                                             GError **error);
    void                ostree_repo_write_metadata_async    (OstreeRepo *self,
                                                             OstreeObjectType objtype,
                                                             const char *expected_checksum,
                                                             GVariant *object,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            ostree_repo_write_metadata_finish   (OstreeRepo *self,
                                                             GAsyncResult *result,
                                                             guchar **out_csum,
                                                             GError **error);
    gboolean            ostree_repo_write_metadata_trusted  (OstreeRepo *self,
                                                             OstreeObjectType objtype,
                                                             const char *checksum,
                                                             GVariant *variant,
                                                             GCancellable *cancellable,
                                                             GError **error);
    gboolean            ostree_repo_write_metadata_stream_trusted
                                                            (OstreeRepo *self,
                                                             OstreeObjectType objtype,
                                                             const char *checksum,
                                                             GInputStream *object_input,
                                                             guint64 length,
                                                             GCancellable *cancellable,
                                                             GError **error);
    gboolean            ostree_repo_write_content           (OstreeRepo *self,
                                                             const char *expected_checksum,
                                                             GInputStream *object_input,
                                                             guint64 length,
                                                             guchar **out_csum,
                                                             GCancellable *cancellable,
                                                             GError **error);
    gboolean            ostree_repo_write_content_trusted   (OstreeRepo *self,
                                                             const char *checksum,
                                                             GInputStream *object_input,
                                                             guint64 length,
                                                             GCancellable *cancellable,
                                                             GError **error);
    void                ostree_repo_write_content_async     (OstreeRepo *self,
                                                             const char *expected_checksum,
                                                             GInputStream *object,
                                                             guint64 length,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            ostree_repo_write_content_finish    (OstreeRepo *self,
                                                             GAsyncResult *result,
                                                             guchar **out_csum,
                                                             GError **error);
    gboolean            ostree_repo_resolve_rev             (OstreeRepo *self,
                                                             const char *refspec,
                                                             gboolean allow_noent,
                                                             char **out_rev,
                                                             GError **error);
    gboolean            ostree_repo_list_refs               (OstreeRepo *self,
                                                             const char *refspec_prefix,
                                                             GHashTable **out_all_refs,
                                                             GCancellable *cancellable,
                                                             GError **error);
    gboolean            ostree_repo_load_variant            (OstreeRepo *self,
                                                             OstreeObjectType objtype,
                                                             const char *sha256,
                                                             GVariant **out_variant,
                                                             GError **error);
    gboolean            ostree_repo_load_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;
    enum                OstreeRepoCommitModifierFlags;
    OstreeRepoCommitModifier * ostree_repo_commit_modifier_new
                                                            (OstreeRepoCommitModifierFlags flags,
                                                             OstreeRepoCommitFilter commit_filter,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy_notify);
    OstreeRepoCommitModifier * ostree_repo_commit_modifier_ref
                                                            (OstreeRepoCommitModifier *modifier);
    void                ostree_repo_commit_modifier_unref   (OstreeRepoCommitModifier *modifier);
    gboolean            ostree_repo_write_directory_to_mtree
                                                            (OstreeRepo *self,
                                                             GFile *dir,
                                                             OstreeMutableTree *mtree,
                                                             OstreeRepoCommitModifier *modifier,
                                                             GCancellable *cancellable,
                                                             GError **error);
    gboolean            ostree_repo_write_archive_to_mtree  (OstreeRepo *self,
                                                             GFile *archive,
                                                             OstreeMutableTree *mtree,
                                                             OstreeRepoCommitModifier *modifier,
                                                             gboolean autocreate_parents,
                                                             GCancellable *cancellable,
                                                             GError **error);
    gboolean            ostree_repo_write_mtree             (OstreeRepo *self,
                                                             OstreeMutableTree *mtree,
                                                             GFile **out_file,
                                                             GCancellable *cancellable,
                                                             GError **error);
    gboolean            ostree_repo_write_commit            (OstreeRepo *self,
                                                             const char *parent,
                                                             const char *subject,
                                                             const char *body,
                                                             GVariant *metadata,
                                                             OstreeRepoFile *root,
                                                             char **out_commit,
                                                             GCancellable *cancellable,
                                                             GError **error);
    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 *ref,
                                                             GFile **out_root,
                                                             char **out_commit,
                                                             GCancellable *cancellable,
                                                             GError **error);
    enum                OstreeRepoListObjectsFlags;
    #define             OSTREE_REPO_LIST_OBJECTS_VARIANT_TYPE
    gboolean            ostree_repo_list_objects            (OstreeRepo *self,
                                                             OstreeRepoListObjectsFlags flags,
                                                             GHashTable **out_objects,
                                                             GCancellable *cancellable,
                                                             GError **error);
    GHashTable *        ostree_repo_traverse_new_reachable  (void);
    gboolean            ostree_repo_traverse_commit         (OstreeRepo *repo,
                                                             const char *commit_checksum,
                                                             int maxdepth,
                                                             GHashTable **out_reachable,
                                                             GCancellable *cancellable,
                                                             GError **error);
    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,
                                                             OstreeAsyncProgress *progress,
                                                             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.

Creating an OstreeRepo does not invoke any file I/O, and thus needs to be initialized, either from an existing contents or with a new repository. If you have an existing repo, use `ostree_repo_open()` to load it from disk and check its validity. To initialize a new repository in the given filepath, use `ostree_repo_create()` instead.

To store content in the repo, first start a transaction with `ostree_repo_prepare_transaction()`. Then create a OstreeMutableTree, and apply functions such as `ostree_repo_write_directory_to_mtree()` to traverse a physical filesystem and write content, possibly multiple times.

Once the OstreeMutableTree is complete, write all of its metadata with `ostree_repo_write_mtree()`, and finally create a commit with `ostree_repo_write_commit()`.

## Details

### OstreeRepo

    typedef struct OstreeRepo OstreeRepo;

Private instance structure.

### enum OstreeRepoMode

    typedef enum {
      OSTREE_REPO_MODE_BARE,
      OSTREE_REPO_MODE_ARCHIVE_Z2
    } 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_new_default ()

    OstreeRepo *        ostree_repo_new_default             (void);

If the current working directory appears to be an OSTree repository, create a new OstreeRepo object for accessing it. Otherwise, use the default system repository located at /ostree/repo.

Returns : | An accessor object for an OSTree repository located at /ostree/repo. [transfer full]

### ostree_repo_open ()

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

### ostree_repo_create ()

    gboolean            ostree_repo_create                  (OstreeRepo *self,
                                                             OstreeRepoMode mode,
                                                             GCancellable *cancellable,
                                                             GError **error);

Create the underlying structure on disk for the repository.

`self` : | An OstreeRepo
`mode` : | The mode to store the repository in
`cancellable` : | Cancellable
`error` : | Error

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

### struct OstreeRepoTransactionStats

    struct OstreeRepoTransactionStats {
      guint metadata_objects_total;
      guint metadata_objects_written;
      guint content_objects_total;
      guint content_objects_written;
      guint64 content_bytes_written;

      guint64 padding1;
      guint64 padding2;
      guint64 padding3;
      guint64 padding4;
    };

A list of statistics for each transaction that may be interesting for reporting purposes.

guint `metadata_objects_total`; | The total number of metadata objects in the repository after this transaction has completed.
guint `metadata_objects_written`; | The number of metadata objects that were written to the repository in this transaction.
guint `content_objects_total`; | The total number of content objects in the repository after this transaction has completed.
guint `content_objects_written`; | The number of content objects that were written to the repository in this transaction.
guint64 `content_bytes_written`; |
guint64 `padding1`; |
guint64 `padding2`; |
guint64 `padding3`; |
guint64 `padding4`; |

### ostree_repo_scan_hardlinks ()

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

When ostree builds a mutable tree from directory like in `ostree_repo_write_directory_to_mtree()`, it has to scan all files that you pass in and compute their checksums. If your commit contains hardlinks from ostree's existing repo, ostree can build a mapping of device numbers and inodes to their checksum.

There is an upfront cost to creating this mapping, as this will scan the entire objects directory. If your commit is composed of mostly hardlinks to existing ostree objects, then this will speed up considerably, so call it before you call `ostree_write_directory_to_mtree()` or similar.

`self` : | An OstreeRepo
`cancellable` : | Cancellable
`error` : | Error

### ostree_repo_prepare_transaction ()

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

Starts or resumes a transaction. In order to write to a repo, you need to start a transaction. You can complete the transaction with `ostree_repo_commit_transaction()`, or abort the transaction with `ostree_repo_abort_transaction()`.

Currently, transactions are not atomic, and aborting a transaction will not erase any data you write during the transaction.

`self` : | An OstreeRepo
`out_transaction_resume` : | Whether this transaction is resuming from a previous one. [allow-none][out]
`cancellable` : | Cancellable
`error` : | Error

### ostree_repo_commit_transaction ()

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

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

`self` : | An OstreeRepo
`out_stats` : | A set of statisitics of things that happened during this transaction. [allow-none][out]
`cancellable` : | Cancellable
`error` : | Error

### ostree_repo_abort_transaction ()

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

### ostree_repo_transaction_set_ref ()

    void                ostree_repo_transaction_set_ref     (OstreeRepo *self,
                                                             const char *remote,
                                                             const char *ref,
                                                             const char *checksum);

If `checksum` is not `NULL`, then record it as the target of ref named `ref`; if `remote` is provided, the ref will appear to originate from that remote.

Otherwise, if `checksum` is `NULL`, then record that the ref should be deleted.

The change will not be written out immediately, but when the transaction is completed with `ostree_repo_complete_transaction()`. If the transaction is instead aborted with `ostree_repo_abort_transaction()`, no changes will be made to the repository.

`self` : | An OstreeRepo
`remote` : | A remote for the ref. [allow-none]
`ref` : | The ref to write
`checksum` : | The checksum to point it to

### ostree_repo_transaction_set_refspec ()

    void                ostree_repo_transaction_set_refspec (OstreeRepo *self,
                                                             const char *refspec,
                                                             const char *checksum);

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

`self` : | An OstreeRepo
`refspec` : | The refspec to write
`checksum` : | The checksum to point it to

### ostree_repo_has_object ()

    gboolean            ostree_repo_has_object              (OstreeRepo *self,
                                                             OstreeObjectType objtype,
                                                             const char *checksum,
                                                             gboolean *out_have_object,
                                                             GCancellable *cancellable,
                                                             GError **error);

Set `out_have_object` to `TRUE` if `self` contains the given object; `FALSE` otherwise.

`self` : | Repo
`objtype` : | Object type
`checksum` : | ASCII SHA256 checksum
`out_have_object` : | `TRUE` if repository contains object. [out]
`cancellable` : | Cancellable
`error` : | Error
Returns : | `FALSE` if an unexpected error occurred, `TRUE` otherwise

### ostree_repo_write_metadata ()

    gboolean            ostree_repo_write_metadata          (OstreeRepo *self,
                                                             OstreeObjectType objtype,
                                                             const char *expected_checksum,
                                                             GVariant *object,
                                                             guchar **out_csum,
                                                             GCancellable *cancellable,
                                                             GError **error);

Store the metadata object `variant`. Return the checksum as `out_csum`.

If `expected_checksum` is not `NULL`, verify it against the computed checksum.

`self` : | Repo
`objtype` : | Object type
`expected_checksum` : | If provided, validate content against this checksum. [allow-none]
`object` : | Metadata
`out_csum` : | Binary checksum. [out][array fixed-size=32][allow-none]
`cancellable` : | Cancellable
`error` : | Error

### ostree_repo_write_metadata_async ()

    void                ostree_repo_write_metadata_async    (OstreeRepo *self,
                                                             OstreeObjectType objtype,
                                                             const char *expected_checksum,
                                                             GVariant *object,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Asynchronously store the metadata object `variant`. If provided, the checksum `expected_checksum` will be verified.

`self` : | Repo
`objtype` : | Object type
`expected_checksum` : | If provided, validate content against this checksum. [allow-none]
`object` : | Metadata
`cancellable` : | Cancellable
`callback` : | Invoked when metadata is writed
`user_data` : | Data for `callback`

### ostree_repo_write_metadata_finish ()

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

### ostree_repo_write_metadata_trusted ()

    gboolean            ostree_repo_write_metadata_trusted  (OstreeRepo *self,
                                                             OstreeObjectType objtype,
                                                             const char *checksum,
                                                             GVariant *variant,
                                                             GCancellable *cancellable,
                                                             GError **error);

Store the metadata object `variant`; the provided `checksum` is trusted.

`self` : | Repo
`objtype` : | Object type
`checksum` : | Store object with this ASCII SHA256 checksum
`variant` : | Metadata object
`cancellable` : | Cancellable
`error` : | Error

### ostree_repo_write_metadata_stream_trusted ()

    gboolean            ostree_repo_write_metadata_stream_trusted
                                                            (OstreeRepo *self,
                                                             OstreeObjectType objtype,
                                                             const char *checksum,
                                                             GInputStream *object_input,
                                                             guint64 length,
                                                             GCancellable *cancellable,
                                                             GError **error);

Store the metadata object `variant`; the provided `checksum` is trusted.

`self` : | Repo
`objtype` : | Object type
`checksum` : | Store object with this ASCII SHA256 checksum
`object_input` : | Metadata object stream
`length` : | Length, may be 0 for unknown
`cancellable` : | Cancellable
`error` : | Error

### ostree_repo_write_content ()

    gboolean            ostree_repo_write_content           (OstreeRepo *self,
                                                             const char *expected_checksum,
                                                             GInputStream *object_input,
                                                             guint64 length,
                                                             guchar **out_csum,
                                                             GCancellable *cancellable,
                                                             GError **error);

Store the content object streamed as `object_input`, with total length `length`. The actual checksum will be returned as `out_csum`.

`self` : | Repo
`expected_checksum` : | If provided, validate content against this checksum. [allow-none]
`object_input` : | Content object stream
`length` : | Length of `object_input`
`out_csum` : | Binary checksum. [out][array fixed-size=32][allow-none]
`cancellable` : | Cancellable
`error` : | Error

### ostree_repo_write_content_trusted ()

    gboolean            ostree_repo_write_content_trusted   (OstreeRepo *self,
                                                             const char *checksum,
                                                             GInputStream *object_input,
                                                             guint64 length,
                                                             GCancellable *cancellable,
                                                             GError **error);

Store the content object streamed as `object_input`, with total length `length`. The given `checksum` will be treated as trusted.

This function should be used when importing file objects from local disk, for example.

`self` : | Repo
`checksum` : | Store content using this ASCII SHA256 checksum
`object_input` : | Content stream
`length` : | Length of `object_input`
`cancellable` : | Cancellable
`error` : | Data for `callback`

### ostree_repo_write_content_async ()

    void                ostree_repo_write_content_async     (OstreeRepo *self,
                                                             const char *expected_checksum,
                                                             GInputStream *object,
                                                             guint64 length,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Asynchronously store the content object `object`. If provided, the checksum `expected_checksum` will be verified.

`self` : | Repo
`expected_checksum` : | If provided, validate content against this checksum. [allow-none]
`object` : | Input
`length` : | Length of `object`
`cancellable` : | Cancellable
`callback` : | Invoked when content is writed
`user_data` : | User data for `callback`

### ostree_repo_write_content_finish ()

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

Completes an invocation of `ostree_repo_write_content_async()`.

`self` : | a OstreeRepo
`result` : | a GAsyncResult
`out_csum` : | A binary SHA256 checksum of the content object. [out][transfer full]
`error` : | a GError

### ostree_repo_resolve_rev ()

    gboolean            ostree_repo_resolve_rev             (OstreeRepo *self,
                                                             const char *refspec,
                                                             gboolean allow_noent,
                                                             char **out_rev,
                                                             GError **error);

Look up the given refspec, returning the checksum it references in the parameter `out_rev`.

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

    gboolean            ostree_repo_load_variant            (OstreeRepo *self,
                                                             OstreeObjectType objtype,
                                                             const char *sha256,
                                                             GVariant **out_variant,
                                                             GError **error);

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

`self` : | Repo
`objtype` : | Expected object type
`sha256` : | Checksum string
`out_variant` : | Metadata object. [out][transfer full]
`error` : | Error

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

### enum OstreeRepoCommitModifierFlags

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

`OSTREE_REPO_COMMIT_MODIFIER_FLAGS_NONE` | No special flags
`OSTREE_REPO_COMMIT_MODIFIER_FLAGS_SKIP_XATTRS` | Do not process extended attributes
`OSTREE_REPO_COMMIT_MODIFIER_FLAGS_GENERATE_SIZES` |

### ostree_repo_commit_modifier_new ()

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

`flags` : | Control options for filter
`commit_filter` : | Function that can inspect individual files. [allow-none]
`user_data` : | User data. [allow-none]
`destroy_notify` : | A GDestroyNotify
Returns : | A new commit modifier. [transfer full]

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

    gboolean            ostree_repo_write_directory_to_mtree
                                                            (OstreeRepo *self,
                                                             GFile *dir,
                                                             OstreeMutableTree *mtree,
                                                             OstreeRepoCommitModifier *modifier,
                                                             GCancellable *cancellable,
                                                             GError **error);

Store objects for `dir` and all children into the repository `self`, overlaying the resulting filesystem hierarchy into `mtree`.

`self` : | Repo
`dir` : | Path to a directory
`mtree` : | Overlay directory contents into this tree
`modifier` : | Optional modifier. [allow-none]
`cancellable` : | Cancellable
`error` : | Error

### ostree_repo_write_archive_to_mtree ()

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

Import an archive file `archive` into the repository, and write its file structure to `mtree`.

`self` : | An OstreeRepo
`archive` : | A path to an archive file
`mtree` : | The OstreeMutableTree to write to
`modifier` : | Optional commit modifier. [allow-none]
`autocreate_parents` : | Autocreate parent directories
`cancellable` : | Cancellable
`error` : | Error

### ostree_repo_write_mtree ()

    gboolean            ostree_repo_write_mtree             (OstreeRepo *self,
                                                             OstreeMutableTree *mtree,
                                                             GFile **out_file,
                                                             GCancellable *cancellable,
                                                             GError **error);

Write all metadata objects for `mtree` to repo; the resulting `out_file` points to the `OSTREE_OBJECT_TYPE_DIR_TREE` object that the `mtree` represented.

`self` : | Repo
`mtree` : | Mutable tree
`out_file` : | An OstreeRepoFile representing `mtree`'s root. [out]
`cancellable` : | Cancellable
`error` : | Error

### ostree_repo_write_commit ()

    gboolean            ostree_repo_write_commit            (OstreeRepo *self,
                                                             const char *parent,
                                                             const char *subject,
                                                             const char *body,
                                                             GVariant *metadata,
                                                             OstreeRepoFile *root,
                                                             char **out_commit,
                                                             GCancellable *cancellable,
                                                             GError **error);

Write a commit metadata object, referencing `root_contents_checksum` and `root_metadata_checksum`.

`self` : | Repo
`parent` : | ASCII SHA256 checksum for parent, or `NULL` for none. [allow-none]
`subject` : | Subject
`body` : | Body. [allow-none]
`metadata` : | GVariant of type a{sv}, or `NULL` for none. [allow-none]
`root` : | The tree to point the commit to
`out_commit` : | Resulting ASCII SHA256 checksum for commit. [out]
`cancellable` : | Cancellable
`error` : | Error

### 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 *ref,
                                                             GFile **out_root,
                                                             char **out_commit,
                                                             GCancellable *cancellable,
                                                             GError **error);

Load the content for `rev` into `out_root`.

`self` : | Repo
`ref` : | Ref or ASCII checksum
`out_root` : | An OstreeRepoFile corresponding to the root. [out]
`out_commit` : | The resolved commit checksum. [out]
`cancellable` : | Cancellable
`error` : | Error

### enum OstreeRepoListObjectsFlags

    typedef enum {
      OSTREE_REPO_LIST_OBJECTS_LOOSE = (1 << 0),
      OSTREE_REPO_LIST_OBJECTS_PACKED = (1 << 1),
      OSTREE_REPO_LIST_OBJECTS_ALL = (1 << 2)
    } 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_commit ()

    gboolean            ostree_repo_traverse_commit         (OstreeRepo *repo,
                                                             const char *commit_checksum,
                                                             int maxdepth,
                                                             GHashTable **out_reachable,
                                                             GCancellable *cancellable,
                                                             GError **error);

Create a new set `out_reachable` containing all objects reachable from `commit_checksum`, traversing `maxdepth` parent commits.

`repo` : | Repo
`commit_checksum` : | ASCII SHA256 checksum
`maxdepth` : | Traverse this many parent commits, -1 for unlimited
`out_reachable` : | Set of reachable objects. [out][element-type GVariant GVariant]
`cancellable` : | Cancellable
`error` : | Error

### enum OstreeRepoPruneFlags

    typedef enum {
      OSTREE_REPO_PRUNE_FLAGS_NONE,
      OSTREE_REPO_PRUNE_FLAGS_NO_PRUNE,
      OSTREE_REPO_PRUNE_FLAGS_REFS_ONLY
    } OstreeRepoPruneFlags;

`OSTREE_REPO_PRUNE_FLAGS_NONE` | No special options for pruning
`OSTREE_REPO_PRUNE_FLAGS_NO_PRUNE` | Don't actually delete objects
`OSTREE_REPO_PRUNE_FLAGS_REFS_ONLY` | Do not traverse individual commit objects, only follow refs

### ostree_repo_prune ()

    gboolean            ostree_repo_prune                   (OstreeRepo *self,
                                                             OstreeRepoPruneFlags flags,
                                                             gint depth,
                                                             gint *out_objects_total,
                                                             gint *out_objects_pruned,
                                                             guint64 *out_pruned_object_size_total,
                                                             GCancellable *cancellable,
                                                             GError **error);

Delete content from the repository. By default, this function will only delete "orphaned" objects not referred to by any commit. This can happen during a local commit operation, when we have written content objects but not saved the commit referencing them.

However, if `OSTREE_REPO_PRUNE_FLAGS_REFS_ONLY` is provided, instead of traversing all commits, only refs will be used. Particularly when combined with `depth`, this is a convenient way to delete history from the repository.

Use the `OSTREE_REPO_PRUNE_FLAGS_NO_PRUNE` to just determine statistics on objects that would be deleted, without actually deleting them.

`self` : | Repo
`flags` : | Options controlling prune process
`depth` : | Stop traversal after this many iterations (-1 for unlimited)
`out_objects_total` : | Number of objects found. [out]
`out_objects_pruned` : | Number of objects deleted. [out]
`out_pruned_object_size_total` : | Storage size in bytes of objects deleted. [out]
`cancellable` : | Cancellable
`error` : | Error

### 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,
                                                             OstreeAsyncProgress *progress,
                                                             GCancellable *cancellable,
                                                             GError **error);

Connect to the remote repository, fetching the specified set of refs `refs_to_fetch`. For each ref that is changed, download the commit, all metadata, and all content objects, storing them safely on disk in `self`.

`self` : | Repo
`remote_name` : | Name of remote
`refs_to_fetch` : | Optional list of refs; if `NULL`, fetch all configured refs. [array zero-terminated=1][element-type utf8][allow-none]
`flags` : | Options controlling fetch behavior
`progress` : | Progress. [allow-none]
`cancellable` : | Cancellable
`error` : | Error