packaging
/
ostree
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fetcher: Hoist core "mirrored request" API to public 

This is in preparation for the libcurl port. We're basically making public what
we had internally. The next step here is to create `ostree-fetcher-util.[ch]`
that only operates in terms of this lower level API.

Also drop the `_mirrored` from the function name since it's
the default now.

Closes: #636
Approved by: jlebon
This commit is contained in:
Colin Walters 2016-12-22 17:57:04 -05:00 committed by Atomic Bot
parent eceb165013
commit af560047a2
3 changed files with 87 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

117
src/libostree/ostree-fetcher.c
View File

@ -1179,17 +1179,16 @@ on_request_sent (GObject *object,
g_object_unref (task); g_object_unref (task);
} }
static void void
ostree_fetcher_mirrored_request_internal (OstreeFetcher *self, _ostree_fetcher_request_async (OstreeFetcher *self,
GPtrArray *mirrorlist, GPtrArray *mirrorlist,
const char *filename, const char *filename,
gboolean is_stream, OstreeFetcherRequestFlags flags,
guint64 max_size, guint64 max_size,
int priority, int priority,
GCancellable *cancellable, GCancellable *cancellable,
GAsyncReadyCallback callback, GAsyncReadyCallback callback,
gpointer user_data, gpointer user_data)
gpointer source_tag)
{ {
g_autoptr(GTask) task = NULL; g_autoptr(GTask) task = NULL;
OstreeFetcherPendingURI *pending; OstreeFetcherPendingURI *pending;
@ -1205,10 +1204,10 @@ ostree_fetcher_mirrored_request_internal (OstreeFetcher *self,
pending->mirrorlist = g_ptr_array_ref (mirrorlist); pending->mirrorlist = g_ptr_array_ref (mirrorlist);
pending->filename = g_strdup (filename); pending->filename = g_strdup (filename);
pending->max_size = max_size; pending->max_size = max_size;
pending->is_stream = is_stream; pending->is_stream = (flags & OSTREE_FETCHER_REQUEST_FLAG_ENABLE_PARTIAL) == 0;
task = g_task_new (self, cancellable, callback, user_data); task = g_task_new (self, cancellable, callback, user_data);
g_task_set_source_tag (task, source_tag); g_task_set_source_tag (task, _ostree_fetcher_request_async);
g_task_set_task_data (task, pending, (GDestroyNotify) pending_uri_unref); g_task_set_task_data (task, pending, (GDestroyNotify) pending_uri_unref);
/* We'll use the GTask priority for our own priority queue. */ /* We'll use the GTask priority for our own priority queue. */
@ -1220,60 +1219,45 @@ ostree_fetcher_mirrored_request_internal (OstreeFetcher *self,
(GDestroyNotify) g_object_unref); (GDestroyNotify) g_object_unref);
} }
void gboolean
_ostree_fetcher_mirrored_request_with_partial_async (OstreeFetcher *self, _ostree_fetcher_request_finish (OstreeFetcher *self,
GPtrArray *mirrorlist, GAsyncResult *result,
const char *filename, char **out_filename,
guint64 max_size, GInputStream **out_stream,
int priority, GError **error)
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{ {
ostree_fetcher_mirrored_request_internal (self, mirrorlist, filename, FALSE, GTask *task;
max_size, priority, cancellable, OstreeFetcherPendingURI *pending;
callback, user_data, gpointer ret;
_ostree_fetcher_mirrored_request_with_partial_async);
}
char * g_return_val_if_fail (g_task_is_valid (result, self), FALSE);
_ostree_fetcher_mirrored_request_with_partial_finish (OstreeFetcher *self, g_return_val_if_fail (g_async_result_is_tagged (result, _ostree_fetcher_request_async), FALSE);
GAsyncResult *result,
GError **error)
{
g_return_val_if_fail (g_task_is_valid (result, self), NULL);
g_return_val_if_fail (g_async_result_is_tagged (result,
_ostree_fetcher_mirrored_request_with_partial_async), NULL);
return g_task_propagate_pointer (G_TASK (result), error); /* Special dance to implement
} enum FetchResult {
Filename(String path),
Membuf(uint8[])
} in Rust terms
*/
task = (GTask*)result;
pending = g_task_get_task_data (task);
static void ret = g_task_propagate_pointer (task, error);
ostree_fetcher_stream_mirrored_uri_async (OstreeFetcher *self, if (!ret)
GPtrArray *mirrorlist, return FALSE;
const char *filename,
guint64 max_size,
int priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
ostree_fetcher_mirrored_request_internal (self, mirrorlist, filename, TRUE,
max_size, priority, cancellable,
callback, user_data,
ostree_fetcher_stream_mirrored_uri_async);
}
static GInputStream * if (pending->is_stream)
ostree_fetcher_stream_mirrored_uri_finish (OstreeFetcher *self, {
GAsyncResult *result, g_assert (out_stream);
GError **error) *out_stream = ret;
{ }
g_return_val_if_fail (g_task_is_valid (result, self), NULL); else
g_return_val_if_fail (g_async_result_is_tagged (result, {
ostree_fetcher_stream_mirrored_uri_async), NULL); g_assert (out_filename);
*out_filename = ret;
}
return g_task_propagate_pointer (G_TASK (result), error); return TRUE;
} }
guint64 guint64
@ -1322,8 +1306,9 @@ fetch_uri_sync_on_complete (GObject *object,
{ {
FetchUriSyncData *data = user_data; FetchUriSyncData *data = user_data;
data->result_stream = ostree_fetcher_stream_mirrored_uri_finish ((OstreeFetcher*)object, (void)_ostree_fetcher_request_finish ((OstreeFetcher*)object,
result, data->error); result, NULL, &data->result_stream,
data->error);
data->done = TRUE; data->done = TRUE;
} }
@ -1356,9 +1341,9 @@ _ostree_fetcher_mirrored_request_to_membuf (OstreeFetcher *fetcher,
data.done = FALSE; data.done = FALSE;
data.error = error; data.error = error;
ostree_fetcher_stream_mirrored_uri_async (fetcher, mirrorlist, filename, max_size, _ostree_fetcher_request_async (fetcher, mirrorlist, filename, 0, max_size,
OSTREE_FETCHER_DEFAULT_PRIORITY, cancellable, OSTREE_FETCHER_DEFAULT_PRIORITY, cancellable,
fetch_uri_sync_on_complete, &data); fetch_uri_sync_on_complete, &data);
while (!data.done) while (!data.done)
g_main_context_iteration (mainctx, TRUE); g_main_context_iteration (mainctx, TRUE);

29
src/libostree/ostree-fetcher.h
View File

@ -103,18 +103,25 @@ void _ostree_fetcher_set_extra_headers (OstreeFetcher *self,
guint64 _ostree_fetcher_bytes_transferred (OstreeFetcher *self); guint64 _ostree_fetcher_bytes_transferred (OstreeFetcher *self);
void _ostree_fetcher_mirrored_request_with_partial_async (OstreeFetcher *self, typedef enum {
GPtrArray *mirrorlist, OSTREE_FETCHER_REQUEST_FLAG_ENABLE_PARTIAL = (1 << 0)
const char *filename, } OstreeFetcherRequestFlags;
guint64 max_size,
int priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data);
char *_ostree_fetcher_mirrored_request_with_partial_finish (OstreeFetcher *self, void _ostree_fetcher_request_async (OstreeFetcher *self,
GAsyncResult *result, GPtrArray *mirrorlist,
GError **error); const char *filename,
OstreeFetcherRequestFlags flags,
guint64 max_size,
int priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data);
gboolean _ostree_fetcher_request_finish (OstreeFetcher *self,
GAsyncResult *result,
char **out_filename,
GInputStream **out_stream,
GError **error);
gboolean _ostree_fetcher_mirrored_request_to_membuf (OstreeFetcher *fetcher, gboolean _ostree_fetcher_mirrored_request_to_membuf (OstreeFetcher *fetcher,
GPtrArray *mirrorlist, GPtrArray *mirrorlist,

37
src/libostree/ostree-repo-pull.c
View File

@ -707,8 +707,7 @@ content_fetch_on_complete (GObject *object,
OstreeObjectType objtype; OstreeObjectType objtype;
gboolean free_fetch_data = TRUE; gboolean free_fetch_data = TRUE;
temp_path = _ostree_fetcher_mirrored_request_with_partial_finish (fetcher, result, error); if (!_ostree_fetcher_request_finish (fetcher, result, &temp_path, NULL, error))
if (!temp_path)
goto out; goto out;
ostree_object_name_deserialize (fetch_data->object, &checksum, &objtype); ostree_object_name_deserialize (fetch_data->object, &checksum, &objtype);
@ -841,8 +840,7 @@ meta_fetch_on_complete (GObject *object,
g_debug ("fetch of %s%s complete", checksum_obj, g_debug ("fetch of %s%s complete", checksum_obj,
fetch_data->is_detached_meta ? " (detached)" : ""); fetch_data->is_detached_meta ? " (detached)" : "");
temp_path = _ostree_fetcher_mirrored_request_with_partial_finish (fetcher, result, error); if (!_ostree_fetcher_request_finish (fetcher, result, &temp_path, NULL, error))
if (!temp_path)
{ {
if (g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND)) if (g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
{ {
@ -982,8 +980,7 @@ static_deltapart_fetch_on_complete (GObject *object,
g_debug ("fetch static delta part %s complete", fetch_data->expected_checksum); g_debug ("fetch static delta part %s complete", fetch_data->expected_checksum);
temp_path = _ostree_fetcher_mirrored_request_with_partial_finish (fetcher, result, error); if (!_ostree_fetcher_request_finish (fetcher, result, &temp_path, NULL, error))
if (!temp_path)
goto out; goto out;
fd = openat (_ostree_fetcher_get_dfd (fetcher), temp_path, O_RDONLY | O_CLOEXEC); fd = openat (_ostree_fetcher_get_dfd (fetcher), temp_path, O_RDONLY | O_CLOEXEC);
@ -1382,12 +1379,13 @@ enqueue_one_object_request (OtPullData *pull_data,
else else
expected_max_size = 0; expected_max_size = 0;
_ostree_fetcher_mirrored_request_with_partial_async (pull_data->fetcher, mirrorlist, _ostree_fetcher_request_async (pull_data->fetcher, mirrorlist,
obj_subpath, expected_max_size, obj_subpath, OSTREE_FETCHER_REQUEST_FLAG_ENABLE_PARTIAL,
is_meta ? OSTREE_REPO_PULL_METADATA_PRIORITY expected_max_size,
: OSTREE_REPO_PULL_CONTENT_PRIORITY, is_meta ? OSTREE_REPO_PULL_METADATA_PRIORITY
pull_data->cancellable, : OSTREE_REPO_PULL_CONTENT_PRIORITY,
is_meta ? meta_fetch_on_complete : content_fetch_on_complete, fetch_data); pull_data->cancellable,
is_meta ? meta_fetch_on_complete : content_fetch_on_complete, fetch_data);
} }
static gboolean static gboolean
@ -1735,13 +1733,14 @@ process_one_static_delta (OtPullData *pull_data,
} }
else else
{ {
_ostree_fetcher_mirrored_request_with_partial_async (pull_data->fetcher, _ostree_fetcher_request_async (pull_data->fetcher,
pull_data->content_mirrorlist, pull_data->content_mirrorlist,
deltapart_path, size, deltapart_path, OSTREE_FETCHER_REQUEST_FLAG_ENABLE_PARTIAL,
OSTREE_FETCHER_DEFAULT_PRIORITY, size,
pull_data->cancellable, OSTREE_FETCHER_DEFAULT_PRIORITY,
static_deltapart_fetch_on_complete, pull_data->cancellable,
fetch_data); static_deltapart_fetch_on_complete,
fetch_data);
pull_data->n_outstanding_deltapart_fetches++; pull_data->n_outstanding_deltapart_fetches++;
} }
} }