fdo-mirrors/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git synced 2026-02-27 22:10:40 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

cloud-setup: rename get/Get identifiers to req and Req

Browse source 
We're going to extend those to issue methods other than GET.
Also, "request" would've been too long, "req" looks nicer.

Conflicts: code formatting, missing trivial commit in,
provider-azure and gcp, missing 494819bbbf ("cloud-setup: move common
code for get_config() to base class and improve cancellation")

(cherry picked from commit 85ce088616)
(cherry picked from commit 6e8cfbae32)
(cherry picked from commit 20cd11ee49)
(cherry picked from commit 9ce530fa7a)
(cherry picked from commit d6d161a31d)
(cherry picked from commit 977fc2c8c5)
(cherry picked from commit 89ee76409b)
(cherry picked from commit e3d23c7ee0)
(cherry picked from commit 3a0f3ff46f)
This commit is contained in:
Lubomir Rintel 2023-02-27 00:09:40 +01:00 • committed by Íñigo Huguet
parent 9a434ad4ca
commit 5009cf5d54
3 changed files with 82 additions and 82 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

142
clients/cloud-setup/nm-http-client.c
View file

@ -104,12 +104,12 @@ typedef struct {
} GetResult;
static void
_get_result_free (gpointer data)
_req_result_free (gpointer data)
{
GetResult *get_result = data;
GetResult *req_result = data;
g_bytes_unref (get_result->response_data);
nm_g_slice_free (get_result);
g_bytes_unref (req_result->response_data);
nm_g_slice_free (req_result);
}
typedef struct {
@ -156,7 +156,7 @@ static void
_ehandle_complete (EHandleData *edata,
GError *error_take)
{
GetResult *get_result;
GetResult *req_result;
gs_free char *str_tmp_1 = NULL;
long response_code = -1;
@ -200,15 +200,15 @@ _ehandle_complete (EHandleData *edata,
_ehandle_free_ehandle (edata);
get_result = g_slice_new (GetResult);
*get_result = (GetResult) {
req_result = g_slice_new (GetResult);
*req_result = (GetResult) {
.response_code = response_code,
/* This ensures that response_data is always NUL terminated. This is an important guarantee
* that NMHttpClient makes. */
.response_data = g_string_free_to_bytes (g_steal_pointer (&edata->recv_data)),
};
g_task_return_pointer (edata->task, get_result, _get_result_free);
g_task_return_pointer (edata->task, req_result, _req_result_free);
_ehandle_free (edata);
}
@ -259,7 +259,7 @@ _get_cancelled_cb (GObject *object, gpointer user_data)
}
static void
nm_http_client_get (NMHttpClient *self,
nm_http_client_req (NMHttpClient *self,
const char *url,
int timeout_msec,
gssize max_data,
@ -282,7 +282,7 @@ nm_http_client_get (NMHttpClient *self,
edata = g_slice_new (EHandleData);
*edata = (EHandleData) {
.task = nm_g_task_new (self, cancellable, nm_http_client_get, callback, user_data),
.task = nm_g_task_new (self, cancellable, nm_http_client_req, callback, user_data),
.recv_data = g_string_sized_new (NM_MIN (max_data, 245)),
.max_data = max_data,
.url = g_strdup (url),
@ -352,30 +352,30 @@ nm_http_client_get (NMHttpClient *self,
}
static gboolean
nm_http_client_get_finish (NMHttpClient *self,
nm_http_client_req_finish (NMHttpClient *self,
GAsyncResult *result,
long *out_response_code,
GBytes **out_response_data,
GError **error)
{
GetResult *get_result;
GetResult *req_result;
g_return_val_if_fail (NM_IS_HTTP_CLIENT (self), FALSE);
g_return_val_if_fail (nm_g_task_is_valid (result, self, nm_http_client_get), FALSE);
g_return_val_if_fail (nm_g_task_is_valid (result, self, nm_http_client_req), FALSE);
get_result = g_task_propagate_pointer (G_TASK (result), error);
if (!get_result) {
req_result = g_task_propagate_pointer (G_TASK (result), error);
if (!req_result) {
NM_SET_OUT (out_response_code, -1);
NM_SET_OUT (out_response_data, NULL);
return FALSE;
}
NM_SET_OUT (out_response_code, get_result->response_code);
NM_SET_OUT (out_response_code, req_result->response_code);
/* response_data is binary, but is also guaranteed to be NUL terminated! */
NM_SET_OUT (out_response_data, g_steal_pointer (&get_result->response_data));
NM_SET_OUT (out_response_data, g_steal_pointer (&req_result->response_data));
_get_result_free (get_result);
_req_result_free (req_result);
return TRUE;
}
@ -386,62 +386,62 @@ typedef struct {
GTask *task;
char *uri;
const char *const *http_headers;
NMHttpClientPollGetCheckFcn check_fcn;
NMHttpClientPollReqCheckFcn check_fcn;
gpointer check_user_data;
GBytes *response_data;
gsize request_max_data;
long response_code;
int request_timeout_ms;
} PollGetData;
} PollReqData;
static void
_poll_get_data_free (gpointer data)
_poll_req_data_free (gpointer data)
{
PollGetData *poll_get_data = data;
PollReqData *poll_req_data = data;
g_free (poll_get_data->uri);
g_free (poll_req_data->uri);
nm_clear_pointer (&poll_get_data->response_data, g_bytes_unref);
g_free((gpointer) poll_get_data->http_headers);
nm_clear_pointer (&poll_req_data->response_data, g_bytes_unref);
g_free((gpointer) poll_req_data->http_headers);
nm_g_slice_free (poll_get_data);
nm_g_slice_free (poll_req_data);
}
static void
_poll_get_probe_start_fcn (GCancellable *cancellable,
_poll_req_probe_start_fcn (GCancellable *cancellable,
gpointer probe_user_data,
GAsyncReadyCallback callback,
gpointer user_data)
{
PollGetData *poll_get_data = probe_user_data;
PollReqData *poll_req_data = probe_user_data;
/* balanced by _poll_get_probe_finish_fcn() */
g_object_ref (poll_get_data->task);
/* balanced by _poll_req_probe_finish_fcn() */
g_object_ref (poll_req_data->task);
nm_http_client_get (g_task_get_source_object (poll_get_data->task),
poll_get_data->uri,
poll_get_data->request_timeout_ms,
poll_get_data->request_max_data,
poll_get_data->http_headers,
nm_http_client_req (g_task_get_source_object (poll_req_data->task),
poll_req_data->uri,
poll_req_data->request_timeout_ms,
poll_req_data->request_max_data,
poll_req_data->http_headers,
cancellable,
callback,
user_data);
}
static gboolean
_poll_get_probe_finish_fcn (GObject *source,
_poll_req_probe_finish_fcn (GObject *source,
GAsyncResult *result,
gpointer probe_user_data,
GError **error)
{
PollGetData *poll_get_data = probe_user_data;
_nm_unused gs_unref_object GTask *task = poll_get_data->task; /* balance ref from _poll_get_probe_start_fcn() */
PollReqData *poll_req_data = probe_user_data;
_nm_unused gs_unref_object GTask *task = poll_req_data->task; /* balance ref from _poll_req_probe_start_fcn() */
gboolean success;
gs_free_error GError *local_error = NULL;
long response_code;
gs_unref_bytes GBytes *response_data = NULL;
success = nm_http_client_get_finish (g_task_get_source_object (poll_get_data->task),
success = nm_http_client_req_finish (g_task_get_source_object (poll_req_data->task),
result,
&response_code,
&response_data,
@ -455,10 +455,10 @@ _poll_get_probe_finish_fcn (GObject *source,
return FALSE;
}
if (poll_get_data->check_fcn) {
success = poll_get_data->check_fcn (response_code,
if (poll_req_data->check_fcn) {
success = poll_req_data->check_fcn (response_code,
response_data,
poll_get_data->check_user_data,
poll_req_data->check_user_data,
&local_error);
} else
success = (response_code == 200);
@ -471,32 +471,32 @@ _poll_get_probe_finish_fcn (GObject *source,
if (!success)
return FALSE;
poll_get_data->response_code = response_code;
poll_get_data->response_data = g_steal_pointer (&response_data);
poll_req_data->response_code = response_code;
poll_req_data->response_data = g_steal_pointer (&response_data);
return TRUE;
}
static void
_poll_get_done_cb (GObject *source,
_poll_req_done_cb (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
PollGetData *poll_get_data = user_data;
PollReqData *poll_req_data = user_data;
gs_free_error GError *error = NULL;
gboolean success;
success = nmcs_utils_poll_finish (result, NULL, &error);
if (error)
g_task_return_error (poll_get_data->task, g_steal_pointer (&error));
g_task_return_error (poll_req_data->task, g_steal_pointer (&error));
else
g_task_return_boolean (poll_get_data->task, success);
g_task_return_boolean (poll_req_data->task, success);
g_object_unref (poll_get_data->task);
g_object_unref (poll_req_data->task);
}
void
nm_http_client_poll_get (NMHttpClient *self,
nm_http_client_poll_req (NMHttpClient *self,
const char *uri,
int request_timeout_ms,
gssize request_max_data,
@ -504,13 +504,13 @@ nm_http_client_poll_get (NMHttpClient *self,
int ratelimit_timeout_ms,
const char *const *http_headers,
GCancellable *cancellable,
NMHttpClientPollGetCheckFcn check_fcn,
NMHttpClientPollReqCheckFcn check_fcn,
gpointer check_user_data,
GAsyncReadyCallback callback,
gpointer user_data)
{
nm_auto_pop_gmaincontext GMainContext *context = NULL;
PollGetData *poll_get_data;
PollReqData *poll_req_data;
g_return_if_fail (NM_IS_HTTP_CLIENT (self));
g_return_if_fail (uri && uri[0]);
@ -520,9 +520,9 @@ nm_http_client_poll_get (NMHttpClient *self,
g_return_if_fail (ratelimit_timeout_ms >= -1);
g_return_if_fail (!cancellable || G_CANCELLABLE (cancellable));
poll_get_data = g_slice_new (PollGetData);
*poll_get_data = (PollGetData) {
.task = nm_g_task_new (self, cancellable, nm_http_client_poll_get, callback, user_data),
poll_req_data = g_slice_new (PollReqData);
*poll_req_data = (PollReqData) {
.task = nm_g_task_new (self, cancellable, nm_http_client_poll_req, callback, user_data),
.uri = g_strdup (uri),
.request_timeout_ms = request_timeout_ms,
.request_max_data = request_max_data,
@ -533,43 +533,43 @@ nm_http_client_poll_get (NMHttpClient *self,
};
if (http_headers) {
poll_get_data->http_headers =
poll_req_data->http_headers =
nm_utils_strv_dup_packed(http_headers, -1) ?: g_new(const char *, 1);
}
nmcs_wait_for_objects_register (poll_get_data->task);
nmcs_wait_for_objects_register (poll_req_data->task);
g_task_set_task_data (poll_get_data->task,
poll_get_data,
_poll_get_data_free);
g_task_set_task_data (poll_req_data->task,
poll_req_data,
_poll_req_data_free);
context = nm_g_main_context_push_thread_default_if_necessary (nm_http_client_get_main_context (self));
nmcs_utils_poll (poll_timeout_ms,
ratelimit_timeout_ms,
0,
_poll_get_probe_start_fcn,
_poll_get_probe_finish_fcn,
poll_get_data,
_poll_req_probe_start_fcn,
_poll_req_probe_finish_fcn,
poll_req_data,
cancellable,
_poll_get_done_cb,
poll_get_data);
_poll_req_done_cb,
poll_req_data);
}
gboolean
nm_http_client_poll_get_finish (NMHttpClient *self,
nm_http_client_poll_req_finish (NMHttpClient *self,
GAsyncResult *result,
long *out_response_code,
GBytes **out_response_data,
GError **error)
{
PollGetData *poll_get_data;
PollReqData *poll_req_data;
GTask *task;
gboolean success;
gs_free_error GError *local_error = NULL;
g_return_val_if_fail (NM_HTTP_CLIENT (self), FALSE);
g_return_val_if_fail (nm_g_task_is_valid (result, self, nm_http_client_poll_get), FALSE);
g_return_val_if_fail (nm_g_task_is_valid (result, self, nm_http_client_poll_req), FALSE);
task = G_TASK (result);
@ -583,10 +583,10 @@ nm_http_client_poll_get_finish (NMHttpClient *self,
return FALSE;
}
poll_get_data = g_task_get_task_data (task);
poll_req_data = g_task_get_task_data (task);
NM_SET_OUT (out_response_code, poll_get_data->response_code);
NM_SET_OUT (out_response_data, g_steal_pointer (&poll_get_data->response_data));
NM_SET_OUT (out_response_code, poll_req_data->response_code);
NM_SET_OUT (out_response_data, g_steal_pointer (&poll_req_data->response_data));
return TRUE;
}

8
clients/cloud-setup/nm-http-client.h
View file

@ -25,12 +25,12 @@ GMainContext *nm_http_client_get_main_context (NMHttpClient *self);
/*****************************************************************************/
typedef gboolean (*NMHttpClientPollGetCheckFcn) (long response_code,
typedef gboolean (*NMHttpClientPollReqCheckFcn) (long response_code,
GBytes *response_data,
gpointer check_user_data,
GError **error);
void nm_http_client_poll_get (NMHttpClient *self,
void nm_http_client_poll_req (NMHttpClient *self,
const char *uri,
int request_timeout_ms,
gssize request_max_data,
@ -38,12 +38,12 @@ void nm_http_client_poll_get (NMHttpClient *self,
int ratelimit_timeout_ms,
const char *const *http_headers,
GCancellable *cancellable,
NMHttpClientPollGetCheckFcn check_fcn,
NMHttpClientPollReqCheckFcn check_fcn,
gpointer check_user_data,
GAsyncReadyCallback callback,
gpointer user_data);
gboolean nm_http_client_poll_get_finish (NMHttpClient *self,
gboolean nm_http_client_poll_req_finish (NMHttpClient *self,
GAsyncResult *result,
long *out_response_code,
GBytes **out_response_data,

14
clients/cloud-setup/nmcs-provider-ec2.c
View file

@ -92,7 +92,7 @@ _detect_get_meta_data_done_cb (GObject *source,
gs_free_error GError *error = NULL;
gboolean success;
success = nm_http_client_poll_get_finish (NM_HTTP_CLIENT (source),
success = nm_http_client_poll_req_finish (NM_HTTP_CLIENT (source),
result,
NULL,
NULL,
@ -132,7 +132,7 @@ detect (NMCSProvider *provider,
http_client = nmcs_provider_get_http_client (provider);
nm_http_client_poll_get (http_client,
nm_http_client_poll_req (http_client,
(uri = _ec2_uri_concat ("latest/meta-data/")),
HTTP_TIMEOUT_MS,
256*1024,
@ -200,7 +200,7 @@ _get_config_fetch_done_cb (NMHttpClient *http_client,
nm_utils_user_data_unpack (user_data, &iface_data, &hwaddr);
success = nm_http_client_poll_get_finish (http_client,
success = nm_http_client_poll_req_finish (http_client,
result,
NULL,
&response_data,
@ -316,7 +316,7 @@ _get_config_metadata_ready_cb (GObject *source,
nm_g_slice_free (metadata_data);
nm_http_client_poll_get_finish (NM_HTTP_CLIENT (source),
nm_http_client_poll_req_finish (NM_HTTP_CLIENT (source),
result,
NULL,
NULL,
@ -387,7 +387,7 @@ _get_config_metadata_ready_cb (GObject *source,
_LOGD ("get-config: start fetching meta data for #%"G_GSSIZE_FORMAT", %s (%s)", config_iface_data->iface_idx, hwaddr, v_mac_data->path);
iface_data->n_pending++;
nm_http_client_poll_get (http_client,
nm_http_client_poll_req (http_client,
(uri1 = _ec2_uri_interfaces (v_mac_data->path,
NM_STR_HAS_SUFFIX (v_mac_data->path, "/")
? ""
@ -405,7 +405,7 @@ _get_config_metadata_ready_cb (GObject *source,
nm_utils_user_data_pack (iface_data, hwaddr));
iface_data->n_pending++;
nm_http_client_poll_get (http_client,
nm_http_client_poll_req (http_client,
(uri2 = _ec2_uri_interfaces (v_mac_data->path,
NM_STR_HAS_SUFFIX (v_mac_data->path, "/")
? ""
@ -526,7 +526,7 @@ get_config (NMCSProvider *provider,
* MAC addresses, then we poll until we see them. They might not yet be
* around from the start...
*/
nm_http_client_poll_get (nmcs_provider_get_http_client (provider),
nm_http_client_poll_req (nmcs_provider_get_http_client (provider),
(uri = _ec2_uri_interfaces ()),
HTTP_TIMEOUT_MS,
256 * 1024,