Content-addressed object store

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

Functions

OstreeRepo * ostree_repo_new ()
OstreeRepo * ostree_repo_new_default ()
gboolean ostree_repo_open ()
gboolean ostree_repo_create ()
GFile * ostree_repo_get_path ()
OstreeRepoMode ostree_repo_get_mode ()
gboolean ostree_repo_mode_from_string ()
GKeyFile * ostree_repo_get_config ()
GKeyFile * ostree_repo_copy_config ()
OstreeRepo * ostree_repo_get_parent ()
gboolean ostree_repo_write_config ()
gboolean ostree_repo_scan_hardlinks ()
gboolean ostree_repo_prepare_transaction ()
gboolean ostree_repo_commit_transaction ()
gboolean ostree_repo_abort_transaction ()
void ostree_repo_transaction_set_ref ()
void ostree_repo_transaction_set_refspec ()
gboolean ostree_repo_has_object ()
gboolean ostree_repo_write_metadata ()
void ostree_repo_write_metadata_async ()
gboolean ostree_repo_write_metadata_finish ()
gboolean ostree_repo_write_metadata_trusted ()
gboolean ostree_repo_write_metadata_stream_trusted ()
gboolean ostree_repo_write_content ()
gboolean ostree_repo_write_content_trusted ()
void ostree_repo_write_content_async ()
gboolean ostree_repo_write_content_finish ()
gboolean ostree_repo_resolve_rev ()
gboolean ostree_repo_list_refs ()
gboolean ostree_repo_load_variant ()
gboolean ostree_repo_load_variant_if_exists ()
gboolean ostree_repo_load_file ()
gboolean ostree_repo_load_object_stream ()
gboolean ostree_repo_query_object_storage_size ()
gboolean ostree_repo_delete_object ()
OstreeRepoCommitFilterResult (*OstreeRepoCommitFilter) ()
OstreeRepoCommitModifier * ostree_repo_commit_modifier_new ()
OstreeRepoCommitModifier * ostree_repo_commit_modifier_ref ()
void ostree_repo_commit_modifier_unref ()
gboolean ostree_repo_write_directory_to_mtree ()
gboolean ostree_repo_write_archive_to_mtree ()
gboolean ostree_repo_write_mtree ()
gboolean ostree_repo_write_commit ()
gboolean ostree_repo_checkout_tree ()
gboolean ostree_repo_checkout_gc ()
gboolean ostree_repo_read_commit ()
#define OSTREE_REPO_LIST_OBJECTS_VARIANT_TYPE
gboolean ostree_repo_list_objects ()
GHashTable * ostree_repo_traverse_new_reachable ()
gboolean ostree_repo_traverse_commit ()
gboolean ostree_repo_prune ()
gboolean ostree_repo_pull ()

Types and Values

Object Hierarchy


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

Functions

ostree_repo_new ()

OstreeRepo *
ostree_repo_new (GFile *path);

Parameters

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.

Parameters

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.

Parameters

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.

Parameters

self

Repo

 

new_config

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

 

error

a GError

 

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.

Parameters

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.

Parameters

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.

Parameters

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.

Parameters

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.

Parameters

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.

Parameters

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.

Parameters

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.

Parameters

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.

Parameters

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.

Parameters

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 .

Parameters

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.

Parameters

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.

Parameters

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

Parameters

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 .

Parameters

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.

Parameters

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 .

Parameters

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.

Parameters

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.

Parameters

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.

Parameters

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.

Parameters

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.

Parameters

self

Repo

 

objtype

Object type

 

sha256

Checksum

 

cancellable

Cancellable

 

error

Error

 

OstreeRepoCommitFilter ()

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

Parameters

repo

Repo

 

path

Path to file

 

file_info

File information

 

user_data

User data

 

Returns

OstreeRepoCommitFilterResult saying whether or not to commit this file


ostree_repo_commit_modifier_new ()

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

Parameters

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 .

Parameters

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 .

Parameters

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.

Parameters

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 .

Parameters

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

 

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.

Parameters

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.

Parameters

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 .

Parameters

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

 

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.

Parameters

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.

Parameters

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

 

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.

Parameters

self

Repo

 

flags

Options controlling prune process

 

depth

Stop traversal after this many iterations (-1 for unlimited)

 

out_objects_total

Number of objects found.

[out]

out_objects_pruned

Number of objects deleted.

[out]

out_pruned_object_size_total

Storage size in bytes of objects deleted.

[out]

cancellable

Cancellable

 

error

Error

 

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

Parameters

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

 

Types and Values

OstreeRepo

typedef struct OstreeRepo OstreeRepo;

Private instance structure.


enum OstreeRepoMode

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

Members

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

 

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.

Members

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;

   

enum OstreeRepoCommitFilterResult

Members

OSTREE_REPO_COMMIT_FILTER_ALLOW

Do commit this object

 

OSTREE_REPO_COMMIT_FILTER_SKIP

Ignore this object

 

OstreeRepoCommitModifier

typedef struct OstreeRepoCommitModifier OstreeRepoCommitModifier;

A structure allowing control over commits.


enum OstreeRepoCommitModifierFlags

Members

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

   

enum OstreeRepoCheckoutMode

Members

OSTREE_REPO_CHECKOUT_MODE_NONE

No special options

 

OSTREE_REPO_CHECKOUT_MODE_USER

Ignore uid/gid of files

 

enum OstreeRepoCheckoutOverwriteMode

Members

OSTREE_REPO_CHECKOUT_OVERWRITE_NONE

No special options

 

OSTREE_REPO_CHECKOUT_OVERWRITE_UNION_FILES

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

 

enum OstreeRepoListObjectsFlags

Members

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

 

enum OstreeRepoPruneFlags

Members

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

 

enum OstreeRepoPullFlags

Members

OSTREE_REPO_PULL_FLAGS_NONE

No special options for pull