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

OstreeRepo *        ostree_repo_new                     (GFile *path);

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.

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.

ostree_repo_get_path ()

GFile *             ostree_repo_get_path                (OstreeRepo *self);

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

ostree_repo_copy_config ()

GKeyFile *          ostree_repo_copy_config             (OstreeRepo *self);

ostree_repo_get_parent ()

OstreeRepo *        ostree_repo_get_parent              (OstreeRepo *self);

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

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.

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.

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.

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.

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.

enum OstreeRepoCommitFilterResult

typedef enum {
  OSTREE_REPO_COMMIT_FILTER_ALLOW,
  OSTREE_REPO_COMMIT_FILTER_SKIP
} OstreeRepoCommitFilterResult;

OstreeRepoCommitFilter ()

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

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

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

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.

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.

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.

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.

enum OstreeRepoCheckoutMode

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

enum OstreeRepoCheckoutOverwriteMode

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

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.

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.

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.

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

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

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.

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

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.

enum OstreeRepoPullFlags

typedef enum {
  OSTREE_REPO_PULL_FLAGS_NONE
} OstreeRepoPullFlags;

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.