/**
* rpmostreed_repo_lookup_cached_version:
* @repo: Repo
* @refspec: Repository branch
* @version: Version to look for
* @cancellable: Cancellable
* @out_checksum: (out) (allow-none): Commit checksum, or %NULL
* @error: Error
*
* Similar to rpmostreed_repo_lookup_version(), except without pulling
* from a remote repository. It traverses whatever commits are available
* locally in @repo.
*
* Returns: %TRUE on success, %FALSE on failure
*/
gboolean
rpmostreed_repo_lookup_cached_version (OstreeRepo *repo,
const char *refspec,
const char *version,
GCancellable *cancellable,
char **out_checksum,
GError **error)
{
VersionVisitorClosure closure = { version, NULL };
g_autofree char *checksum = NULL;
gboolean ret = FALSE;
g_return_val_if_fail (OSTREE_IS_REPO (repo), FALSE);
g_return_val_if_fail (refspec != NULL, FALSE);
g_return_val_if_fail (version != NULL, FALSE);
if (!ostree_repo_resolve_rev (repo, refspec, FALSE, &checksum, error))
goto out;
while (checksum != NULL)
{
g_autoptr(GVariant) commit = NULL;
gboolean stop = FALSE;
if (!ostree_repo_load_commit (repo, checksum, &commit, NULL, error))
goto out;
if (!version_visitor (repo, checksum, commit, &closure, &stop, error))
goto out;
g_clear_pointer (&checksum, g_free);
if (!stop)
checksum = ostree_commit_get_parent (commit);
}
if (closure.checksum == NULL)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND,
"Version %s not cached in %s", version, refspec);
goto out;
}
if (out_checksum != NULL)
*out_checksum = g_steal_pointer (&closure.checksum);
g_free (closure.checksum);
ret = TRUE;
out:
return ret;
}
static char *
ost_get_prev_commit (OstreeRepo *repo, char *checksum)
{
char *ret = NULL;
gs_unref_variant GVariant *commit = NULL;
gs_unref_variant GVariant *parent_csum_v = NULL;
GError *tmp_error = NULL;
if (!ostree_repo_load_variant (repo, OSTREE_OBJECT_TYPE_COMMIT, checksum,
&commit, &tmp_error))
goto out;
ret = ostree_commit_get_parent (commit);
out:
g_clear_error (&tmp_error);
return ret;
}
static gboolean
metadata_version_unique (OstreeRepo *repo,
const char *checksum,
const char *version,
GError **error)
{
gs_unref_variant GVariant *variant = NULL;
gs_unref_variant GVariant *metadata = NULL;
gs_unref_variant GVariant *value = NULL;
gs_free gchar *parent = NULL;
if (!ostree_repo_load_variant (repo, OSTREE_OBJECT_TYPE_COMMIT, checksum,
&variant, error))
{
if (g_error_matches (*error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
{
g_clear_error (error);
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Do not have full history to validate version metadata is unique.");
}
goto out;
}
metadata = g_variant_get_child_value (variant, 0);
if ((value = g_variant_lookup_value (metadata, "version", NULL)))
if (g_str_equal (version, g_variant_get_string (value, NULL)))
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Version already specified in commit %s", checksum);
goto out;
}
if (!(parent = ostree_commit_get_parent (variant)))
return TRUE;
return metadata_version_unique (repo, parent, version, error);
out:
return FALSE;
}
gboolean
ostree_builtin_fsck (int argc, char **argv, OstreeCommandInvocation *invocation, GCancellable *cancellable, GError **error)
{
g_autoptr(OstreeRepo) repo = NULL;
gboolean found_corruption = FALSE;
g_autoptr(GOptionContext) context = g_option_context_new ("");
if (!ostree_option_context_parse (context, options, &argc, &argv, invocation, &repo, cancellable, error))
return FALSE;
if (!opt_quiet)
g_print ("Validating refs...\n");
/* Validate that the commit for each ref is available */
g_autoptr(GHashTable) all_refs = NULL;
if (!ostree_repo_list_refs (repo, NULL, &all_refs,
cancellable, error))
return FALSE;
GHashTableIter hash_iter;
gpointer key, value;
g_hash_table_iter_init (&hash_iter, all_refs);
while (g_hash_table_iter_next (&hash_iter, &key, &value))
{
const char *refspec = key;
const char *checksum = value;
g_autofree char *ref_name = NULL;
if (!ostree_parse_refspec (refspec, NULL, &ref_name, error))
return FALSE;
if (!fsck_commit_for_ref (repo, checksum, NULL, ref_name,
&found_corruption, cancellable, error))
return FALSE;
}
if (!opt_quiet)
g_print ("Validating refs in collections...\n");
g_autoptr(GHashTable) all_collection_refs = NULL; /* (element-type OstreeCollectionRef utf8) */
if (!ostree_repo_list_collection_refs (repo, NULL, &all_collection_refs,
OSTREE_REPO_LIST_REFS_EXT_EXCLUDE_REMOTES,
cancellable, error))
return FALSE;
g_hash_table_iter_init (&hash_iter, all_collection_refs);
while (g_hash_table_iter_next (&hash_iter, &key, &value))
{
const OstreeCollectionRef *ref = key;
if (!fsck_commit_for_ref (repo, value, ref->collection_id, ref->ref_name,
&found_corruption, cancellable, error))
return FALSE;
}
if (!opt_quiet)
g_print ("Enumerating objects...\n");
g_autoptr(GHashTable) objects = NULL;
if (!ostree_repo_list_objects (repo, OSTREE_REPO_LIST_OBJECTS_ALL,
&objects, cancellable, error))
return FALSE;
g_autoptr(GHashTable) commits = g_hash_table_new_full (ostree_hash_object_name, g_variant_equal,
(GDestroyNotify)g_variant_unref, NULL);
g_autoptr(GPtrArray) tombstones = NULL;
if (opt_add_tombstones)
tombstones = g_ptr_array_new_with_free_func (g_free);
if (opt_verify_back_refs)
opt_verify_bindings = TRUE;
guint n_partial = 0;
g_hash_table_iter_init (&hash_iter, objects);
while (g_hash_table_iter_next (&hash_iter, &key, &value))
{
GVariant *serialized_key = key;
const char *checksum;
OstreeObjectType objtype;
OstreeRepoCommitState commitstate = 0;
g_autoptr(GVariant) commit = NULL;
ostree_object_name_deserialize (serialized_key, &checksum, &objtype);
if (objtype == OSTREE_OBJECT_TYPE_COMMIT)
{
if (!ostree_repo_load_commit (repo, checksum, &commit, &commitstate, error))
return FALSE;
/* If requested, check that all the refs listed in the ref-bindings
* for this commit resolve back to this commit. */
if (opt_verify_back_refs)
{
g_autoptr(GVariant) metadata = g_variant_get_child_value (commit, 0);
const char *collection_id = NULL;
if (!g_variant_lookup (metadata,
OSTREE_COMMIT_META_KEY_COLLECTION_BINDING,
"&s",
&collection_id))
collection_id = NULL;
g_autofree const char **refs = NULL;
if (g_variant_lookup (metadata,
OSTREE_COMMIT_META_KEY_REF_BINDING,
"^a&s",
&refs))
{
for (const char **iter = refs; *iter != NULL; ++iter)
{
g_autofree char *checksum_for_ref = NULL;
if (collection_id != NULL)
{
const OstreeCollectionRef collection_ref = { (char *) collection_id, (char *) *iter };
if (!ostree_repo_resolve_collection_ref (repo, &collection_ref,
TRUE,
OSTREE_REPO_RESOLVE_REV_EXT_NONE,
&checksum_for_ref,
cancellable,
error))
return FALSE;
}
else
{
if (!ostree_repo_resolve_rev (repo, *iter, TRUE,
&checksum_for_ref, error))
return FALSE;
}
if (checksum_for_ref == NULL)
{
if (collection_id != NULL)
return glnx_throw (error,
"Collection–ref (%s, %s) in bindings for commit %s does not exist",
collection_id, *iter, checksum);
else
return glnx_throw (error,
"Ref ‘%s’ in bindings for commit %s does not exist",
*iter, checksum);
}
else if (g_strcmp0 (checksum_for_ref, checksum) != 0)
{
if (collection_id != NULL)
return glnx_throw (error,
"Collection–ref (%s, %s) in bindings for commit %s does not resolve to that commit",
collection_id, *iter, checksum);
else
return glnx_throw (error,
"Ref ‘%s’ in bindings for commit %s does not resolve to that commit",
*iter, checksum);
}
}
}
}
if (opt_add_tombstones)
{
GError *local_error = NULL;
g_autofree char *parent = ostree_commit_get_parent (commit);
if (parent)
{
g_autoptr(GVariant) parent_commit = NULL;
if (!ostree_repo_load_variant (repo, OSTREE_OBJECT_TYPE_COMMIT, parent,
&parent_commit, &local_error))
{
if (g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
{
g_ptr_array_add (tombstones, g_strdup (checksum));
g_clear_error (&local_error);
}
else
{
g_propagate_error (error, local_error);
return FALSE;
}
}
}
}
if (commitstate & OSTREE_REPO_COMMIT_STATE_PARTIAL)
n_partial++;
else
g_hash_table_add (commits, g_variant_ref (serialized_key));
}
}
g_clear_pointer (&objects, (GDestroyNotify) g_hash_table_unref);
if (!opt_quiet)
g_print ("Verifying content integrity of %u commit objects...\n",
(guint)g_hash_table_size (commits));
if (!fsck_reachable_objects_from_commits (repo, commits, &found_corruption,
cancellable, error))
return FALSE;
if (opt_add_tombstones)
{
guint i;
if (tombstones->len)
{
if (!ot_enable_tombstone_commits (repo, error))
return FALSE;
}
for (i = 0; i < tombstones->len; i++)
{
const char *checksum = tombstones->pdata[i];
g_print ("Adding tombstone for commit %s\n", checksum);
if (!ostree_repo_delete_object (repo, OSTREE_OBJECT_TYPE_COMMIT, checksum, cancellable, error))
return FALSE;
}
}
else if (n_partial > 0)
{
g_print ("%u partial commits not verified\n", n_partial);
}
if (found_corruption)
return glnx_throw (error, "Repository corruption encountered");
return TRUE;
}
/**
* ostree_repo_resolve_rev:
* @self: Repo
* @refspec: A refspec
* @allow_noent: Do not throw an error if refspec does not exist
* @out_rev: (out) (transfer full): A checksum,or %NULL if @allow_noent is true and it does not exist
* @error: Error
*
* Look up the given refspec, returning the checksum it references in
* the parameter @out_rev.
*/
gboolean
ostree_repo_resolve_rev (OstreeRepo *self,
const char *refspec,
gboolean allow_noent,
char **out_rev,
GError **error)
{
gboolean ret = FALSE;
g_autofree char *ret_rev = NULL;
g_return_val_if_fail (refspec != NULL, FALSE);
if (ostree_validate_checksum_string (refspec, NULL))
{
ret_rev = g_strdup (refspec);
}
else if (!ostree_repo_resolve_partial_checksum (self, refspec, &ret_rev, error))
goto out;
if (!ret_rev)
{
if (error != NULL && *error != NULL)
goto out;
if (g_str_has_suffix (refspec, "^"))
{
g_autofree char *parent_refspec = NULL;
g_autofree char *parent_rev = NULL;
g_autoptr(GVariant) commit = NULL;
parent_refspec = g_strdup (refspec);
parent_refspec[strlen(parent_refspec) - 1] = '\0';
if (!ostree_repo_resolve_rev (self, parent_refspec, allow_noent, &parent_rev, error))
goto out;
if (!ostree_repo_load_variant (self, OSTREE_OBJECT_TYPE_COMMIT, parent_rev,
&commit, error))
goto out;
if (!(ret_rev = ostree_commit_get_parent (commit)))
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Commit %s has no parent", parent_rev);
goto out;
}
}
else
{
g_autofree char *remote = NULL;
g_autofree char *ref = NULL;
if (!ostree_parse_refspec (refspec, &remote, &ref, error))
goto out;
if (!resolve_refspec (self, remote, ref, allow_noent,
&ret_rev, error))
goto out;
}
}
ret = TRUE;
ot_transfer_out_value (out_rev, &ret_rev);
out:
return ret;
}
GVariant *
rpmostreed_deployment_generate_variant (OstreeDeployment *deployment,
const char *booted_id,
OstreeRepo *repo,
GError **error)
{
g_autoptr(GVariant) commit = NULL;
g_autoptr(RpmOstreeOrigin) origin = NULL;
g_autofree gchar *id = NULL;
GVariant *sigs = NULL; /* floating variant */
GVariantDict dict;
const gchar *osname = ostree_deployment_get_osname (deployment);
const gchar *csum = ostree_deployment_get_csum (deployment);
gint serial = ostree_deployment_get_deployserial (deployment);
gboolean gpg_enabled = FALSE;
if (!ostree_repo_load_variant (repo,
OSTREE_OBJECT_TYPE_COMMIT,
csum,
&commit,
error))
return NULL;
id = rpmostreed_deployment_generate_id (deployment);
origin = rpmostree_origin_parse_deployment (deployment, error);
if (!origin)
return NULL;
g_variant_dict_init (&dict, NULL);
g_variant_dict_insert (&dict, "id", "s", id);
if (osname != NULL)
g_variant_dict_insert (&dict, "osname", "s", osname);
g_variant_dict_insert (&dict, "serial", "i", serial);
g_variant_dict_insert (&dict, "checksum", "s", csum);
if (rpmostree_origin_is_locally_assembled (origin))
{
const char *parent = ostree_commit_get_parent (commit);
g_assert (parent);
g_variant_dict_insert (&dict, "base-checksum", "s", parent);
sigs = rpmostreed_deployment_gpg_results (repo, rpmostree_origin_get_refspec (origin),
parent, &gpg_enabled);
}
else
sigs = rpmostreed_deployment_gpg_results (repo, rpmostree_origin_get_refspec (origin),
csum, &gpg_enabled);
variant_add_commit_details (&dict, commit);
g_variant_dict_insert (&dict, "origin", "s", rpmostree_origin_get_refspec (origin));
if (rpmostree_origin_get_packages (origin) != NULL)
g_variant_dict_insert (&dict, "packages", "^as", rpmostree_origin_get_packages (origin));
if (sigs != NULL)
g_variant_dict_insert_value (&dict, "signatures", sigs);
g_variant_dict_insert (&dict, "gpg-enabled", "b", gpg_enabled);
g_variant_dict_insert (&dict, "unlocked", "s",
ostree_deployment_unlocked_state_to_string (ostree_deployment_get_unlocked (deployment)));
if (booted_id != NULL)
g_variant_dict_insert (&dict, "booted", "b", g_strcmp0 (booted_id, id) == 0);
return g_variant_dict_end (&dict);
}
/**
* rpmostreed_repo_pull_ancestry:
* @repo: Repo
* @refspec: Repository branch
* @visitor: (allow-none): Visitor function to call on each commit
* @visitor_data: (allow-none): User data for @visitor
* @progress: (allow-none): Progress
* @cancellable: Cancellable
* @error: Error
*
* Downloads an ancestry of commit objects starting from @refspec.
*
* If a @visitor function pointer is given, commit objects are downloaded
* in batches and the @visitor function is called for each commit object.
* The @visitor function can stop the recursion, such as when looking for
* a particular commit.
*
* Returns: %TRUE on success, %FALSE on failure
*/
gboolean
rpmostreed_repo_pull_ancestry (OstreeRepo *repo,
const char *refspec,
RpmostreedCommitVisitor visitor,
gpointer visitor_data,
OstreeAsyncProgress *progress,
GCancellable *cancellable,
GError **error)
{
OstreeRepoPullFlags flags;
GVariantDict options;
GVariant *refs_value;
const char *refs_array[] = { NULL, NULL };
g_autofree char *remote = NULL;
g_autofree char *ref = NULL;
g_autofree char *checksum = NULL;
int depth, ii;
gboolean ret = FALSE;
g_return_val_if_fail (OSTREE_IS_REPO (repo), FALSE);
g_return_val_if_fail (refspec != NULL, FALSE);
if (!ostree_parse_refspec (refspec, &remote, &ref, error))
goto out;
/* If no visitor function was provided then we won't be short-circuiting
* the recursion, so pull everything in one shot. Otherwise pull commits
* in increasingly large batches. */
depth = (visitor != NULL) ? 10 : -1;
flags = OSTREE_REPO_PULL_FLAGS_COMMIT_ONLY;
/* It's important to use the ref name instead of a checksum on the first
* pass because we want to search from the latest available commit on the
* remote server, which is not necessarily what the ref name is currently
* pointing at in our local repo. */
refs_array[0] = ref;
while (TRUE)
{
/* Floating reference, transferred to dictionary. */
refs_value = g_variant_new_strv ((const char * const *) refs_array, -1);
g_variant_dict_init (&options, NULL);
g_variant_dict_insert (&options, "depth", "i", depth);
g_variant_dict_insert (&options, "flags", "i", flags);
g_variant_dict_insert_value (&options, "refs", refs_value);
if (!ostree_repo_pull_with_options (repo, remote,
g_variant_dict_end (&options),
progress, cancellable, error))
goto out;
/* First pass only. Now we can resolve the ref to a checksum. */
if (checksum == NULL)
{
if (!ostree_repo_resolve_rev (repo, ref, FALSE, &checksum, error))
goto out;
}
/* If depth is negative (no visitor), this loop is skipped. */
for (ii = 0; ii < depth && checksum != NULL; ii++)
{
g_autoptr(GVariant) commit = NULL;
gboolean stop = FALSE;
if (!ostree_repo_load_commit (repo, checksum, &commit, NULL, error))
goto out;
if (!visitor (repo, checksum, commit, visitor_data, &stop, error))
goto out;
g_clear_pointer (&checksum, g_free);
if (!stop)
checksum = ostree_commit_get_parent (commit);
}
/* Break if no visitor, or visitor told us to stop. */
if (depth < 0 || checksum == NULL)
break;
/* Pull the next batch of commits, twice as many. */
refs_array[0] = checksum;
depth = depth * 2;
}
ret = TRUE;
out:
return ret;
}
/**
* ostree_repo_traverse_commit_union: (skip)
* @repo: Repo
* @commit_checksum: ASCII SHA256 checksum
* @maxdepth: Traverse this many parent commits, -1 for unlimited
* @inout_reachable: Set of reachable objects
* @cancellable: Cancellable
* @error: Error
*
* Update the set @inout_reachable containing all objects reachable
* from @commit_checksum, traversing @maxdepth parent commits.
*/
gboolean
ostree_repo_traverse_commit_union (OstreeRepo *repo,
const char *commit_checksum,
int maxdepth,
GHashTable *inout_reachable,
GCancellable *cancellable,
GError **error)
{
gboolean ret = FALSE;
g_autofree char *tmp_checksum = NULL;
while (TRUE)
{
gboolean recurse = FALSE;
g_autoptr(GVariant) key = NULL;
g_autoptr(GVariant) commit = NULL;
ostree_cleanup_repo_commit_traverse_iter
OstreeRepoCommitTraverseIter iter = { 0, };
key = ostree_object_name_serialize (commit_checksum, OSTREE_OBJECT_TYPE_COMMIT);
if (g_hash_table_contains (inout_reachable, key))
break;
if (!ostree_repo_load_variant_if_exists (repo, OSTREE_OBJECT_TYPE_COMMIT,
commit_checksum, &commit,
error))
goto out;
/* Just return if the parent isn't found; we do expect most
* people to have partial repositories.
*/
if (!commit)
break;
g_hash_table_add (inout_reachable, key);
key = NULL;
if (!ostree_repo_commit_traverse_iter_init_commit (&iter, repo, commit,
OSTREE_REPO_COMMIT_TRAVERSE_FLAG_NONE,
error))
goto out;
if (!traverse_iter (repo, &iter, inout_reachable, cancellable, error))
goto out;
if (maxdepth == -1 || maxdepth > 0)
{
g_free (tmp_checksum);
tmp_checksum = ostree_commit_get_parent (commit);
if (tmp_checksum)
{
commit_checksum = tmp_checksum;
if (maxdepth > 0)
maxdepth -= 1;
recurse = TRUE;
}
}
if (!recurse)
break;
}
ret = TRUE;
out:
return ret;
}
static gboolean
generate_all_deltas (OstreeRepo *repo,
GPtrArray **unwanted_deltas,
GCancellable *cancellable,
GError **error)
{
g_autoptr(GHashTable) all_refs = NULL;
g_autoptr(GHashTable) all_deltas_hash = NULL;
g_autoptr(GHashTable) wanted_deltas_hash = NULL;
g_autoptr(GPtrArray) all_deltas = NULL;
int i;
GHashTableIter iter;
gpointer key, value;
g_autoptr(GVariantBuilder) parambuilder = NULL;
g_autoptr(GVariant) params = NULL;
int n_spawned_delta_generate = 0;
g_autoptr(GMainContextPopDefault) context = NULL;
g_autoptr(GPtrArray) ignore_patterns = g_ptr_array_new_with_free_func ((GDestroyNotify)g_pattern_spec_free);
g_print ("Generating static deltas\n");
parambuilder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
/* Fall back for 1 meg files */
g_variant_builder_add (parambuilder, "{sv}",
"min-fallback-size", g_variant_new_uint32 (1));
params = g_variant_ref_sink (g_variant_builder_end (parambuilder));
if (!ostree_repo_list_static_delta_names (repo, &all_deltas,
cancellable, error))
return FALSE;
wanted_deltas_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
all_deltas_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
for (i = 0; i < all_deltas->len; i++)
g_hash_table_insert (all_deltas_hash,
g_strdup (g_ptr_array_index (all_deltas, i)),
NULL);
if (!ostree_repo_list_refs (repo, NULL, &all_refs,
cancellable, error))
return FALSE;
context = flatpak_main_context_new_default ();
if (opt_static_delta_ignore_refs != NULL)
{
for (i = 0; opt_static_delta_ignore_refs[i] != NULL; i++)
g_ptr_array_add (ignore_patterns,
g_pattern_spec_new (opt_static_delta_ignore_refs[i]));
}
g_hash_table_iter_init (&iter, all_refs);
while (g_hash_table_iter_next (&iter, &key, &value))
{
const char *ref = key;
const char *commit = value;
g_autoptr(GVariant) variant = NULL;
g_autoptr(GVariant) parent_variant = NULL;
g_autofree char *parent_commit = NULL;
g_autofree char *grandparent_commit = NULL;
gboolean ignore_ref = FALSE;
if (g_str_has_prefix (ref, "app/") || g_str_has_prefix (ref, "runtime/"))
{
g_auto(GStrv) parts = g_strsplit (ref, "/", 4);
for (i = 0; i < ignore_patterns->len; i++)
{
GPatternSpec *pattern = g_ptr_array_index(ignore_patterns, i);
if (g_pattern_match_string (pattern, parts[1]))
{
ignore_ref = TRUE;
break;
}
}
}
else if (g_str_has_prefix (ref, "appstream/"))
{
/* Old appstream branch deltas poorly, and most users handle the new format */
ignore_ref = TRUE;
}
else if (g_str_has_prefix (ref, "appstream2/"))
{
/* Always delta this */
ignore_ref = FALSE;
}
else
{
/* Ignore unknown ref types */
ignore_ref = FALSE;
}
if (ignore_ref)
{
g_debug ("Ignoring deltas for ref %s", ref);
continue;
}
if (!ostree_repo_load_variant (repo, OSTREE_OBJECT_TYPE_COMMIT, commit,
&variant, NULL))
{
g_warning ("Couldn't load commit %s", commit);
continue;
}
/* From empty */
if (!g_hash_table_contains (all_deltas_hash, commit))
{
if (!spawn_delta_generation (context, &n_spawned_delta_generate, repo, params,
ref, NULL, commit,
error))
return FALSE;
}
/* Mark this one as wanted */
g_hash_table_insert (wanted_deltas_hash, g_strdup (commit), GINT_TO_POINTER (1));
parent_commit = ostree_commit_get_parent (variant);
if (parent_commit != NULL &&
!ostree_repo_load_variant (repo, OSTREE_OBJECT_TYPE_COMMIT, parent_commit,
&parent_variant, NULL))
{
g_warning ("Couldn't load parent commit %s", parent_commit);
continue;
}
/* From parent */
if (parent_variant != NULL)
{
g_autofree char *from_parent = g_strdup_printf ("%s-%s", parent_commit, commit);
if (!g_hash_table_contains (all_deltas_hash, from_parent))
{
if (!spawn_delta_generation (context, &n_spawned_delta_generate, repo, params,
ref, parent_commit, commit,
error))
return FALSE;
}
/* Mark parent-to-current as wanted */
g_hash_table_insert (wanted_deltas_hash, g_strdup (from_parent), GINT_TO_POINTER (1));
/* We also want to keep around the parent and the grandparent-to-parent deltas
* because otherwise these will be deleted immediately which may cause a race if
* someone is currently downloading them.
* However, there is no need to generate these if they don't exist.
*/
g_hash_table_insert (wanted_deltas_hash, g_strdup (parent_commit), GINT_TO_POINTER (1));
grandparent_commit = ostree_commit_get_parent (parent_variant);
if (grandparent_commit != NULL)
g_hash_table_insert (wanted_deltas_hash,
g_strdup_printf ("%s-%s", grandparent_commit, parent_commit),
GINT_TO_POINTER (1));
}
}
while (n_spawned_delta_generate > 0)
g_main_context_iteration (context, TRUE);
*unwanted_deltas = g_ptr_array_new_with_free_func (g_free);
for (i = 0; i < all_deltas->len; i++)
{
const char *delta = g_ptr_array_index (all_deltas, i);
if (!g_hash_table_contains (wanted_deltas_hash, delta))
g_ptr_array_add (*unwanted_deltas, g_strdup (delta));
}
return TRUE;
}
static gboolean
_ostree_repo_resolve_rev_internal (OstreeRepo *self,
const char *refspec,
gboolean allow_noent,
gboolean fallback_remote,
char **out_rev,
GError **error)
{
g_autofree char *ret_rev = NULL;
g_return_val_if_fail (refspec != NULL, FALSE);
if (ostree_validate_checksum_string (refspec, NULL))
{
ret_rev = g_strdup (refspec);
}
else if (!ostree_repo_resolve_partial_checksum (self, refspec, &ret_rev, error))
return FALSE;
if (!ret_rev)
{
if (error != NULL && *error != NULL)
return FALSE;
if (g_str_has_suffix (refspec, "^"))
{
g_autofree char *parent_refspec = NULL;
g_autofree char *parent_rev = NULL;
g_autoptr(GVariant) commit = NULL;
parent_refspec = g_strdup (refspec);
parent_refspec[strlen(parent_refspec) - 1] = '\0';
if (!ostree_repo_resolve_rev (self, parent_refspec, allow_noent, &parent_rev, error))
return FALSE;
if (!ostree_repo_load_variant (self, OSTREE_OBJECT_TYPE_COMMIT, parent_rev,
&commit, error))
return FALSE;
if (!(ret_rev = ostree_commit_get_parent (commit)))
return glnx_throw (error, "Commit %s has no parent", parent_rev);
}
else
{
g_autofree char *remote = NULL;
g_autofree char *ref = NULL;
if (!ostree_parse_refspec (refspec, &remote, &ref, error))
return FALSE;
if (!resolve_refspec (self, remote, ref, allow_noent,
fallback_remote, &ret_rev, error))
return FALSE;
}
}
ot_transfer_out_value (out_rev, &ret_rev);
return TRUE;
}
