fdo-mirrors/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git synced 2026-05-07 11:58:12 +02: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"),
missing 599fe234ea ("cloud-setup: use nm_strv_dup_packed() in
nm_http_client_poll_get()")

(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)
(cherry picked from commit 5009cf5d54)
This commit is contained in:
Lubomir Rintel 2023-02-27 00:09:40 +01:00 • committed by Íñigo Huguet
parent 1e4c7280cc
commit b512f77a01
3 changed files with 81 additions and 81 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -105,12 +105,12 @@ typedef struct {
} GetResult; } GetResult;
static void 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); g_bytes_unref (req_result->response_data);
nm_g_slice_free (get_result); nm_g_slice_free (req_result);
} }
typedef struct { typedef struct {
@ -157,7 +157,7 @@ static void
_ehandle_complete (EHandleData *edata, _ehandle_complete (EHandleData *edata,
GError *error_take) GError *error_take)
{ {
GetResult *get_result; GetResult *req_result;
gs_free char *str_tmp_1 = NULL; gs_free char *str_tmp_1 = NULL;
long response_code = -1; long response_code = -1;
@ -201,15 +201,15 @@ _ehandle_complete (EHandleData *edata,
_ehandle_free_ehandle (edata); _ehandle_free_ehandle (edata);
get_result = g_slice_new (GetResult); req_result = g_slice_new (GetResult);
*get_result = (GetResult) { *req_result = (GetResult) {
.response_code = response_code, .response_code = response_code,
/* This ensures that response_data is always NUL terminated. This is an important guarantee /* This ensures that response_data is always NUL terminated. This is an important guarantee
* that NMHttpClient makes. */ * that NMHttpClient makes. */
.response_data = g_string_free_to_bytes (g_steal_pointer (&edata->recv_data)), .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); _ehandle_free (edata);
} }
@ -260,7 +260,7 @@ _get_cancelled_cb (GObject *object, gpointer user_data)
} }
static void static void
nm_http_client_get (NMHttpClient *self, nm_http_client_req (NMHttpClient *self,
const char *url, const char *url,
int timeout_msec, int timeout_msec,
gssize max_data, gssize max_data,
@ -283,7 +283,7 @@ nm_http_client_get (NMHttpClient *self,
edata = g_slice_new (EHandleData); edata = g_slice_new (EHandleData);
*edata = (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)), .recv_data = g_string_sized_new (NM_MIN (max_data, 245)),
.max_data = max_data, .max_data = max_data,
.url = g_strdup (url), .url = g_strdup (url),
@ -353,30 +353,30 @@ nm_http_client_get (NMHttpClient *self,
} }
static gboolean static gboolean
nm_http_client_get_finish (NMHttpClient *self, nm_http_client_req_finish (NMHttpClient *self,
GAsyncResult *result, GAsyncResult *result,
long *out_response_code, long *out_response_code,
GBytes **out_response_data, GBytes **out_response_data,
GError **error) 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_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); req_result = g_task_propagate_pointer (G_TASK (result), error);
if (!get_result) { if (!req_result) {
NM_SET_OUT (out_response_code, -1); NM_SET_OUT (out_response_code, -1);
NM_SET_OUT (out_response_data, NULL); NM_SET_OUT (out_response_data, NULL);
return FALSE; 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! */ /* 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; return TRUE;
} }
@ -387,62 +387,62 @@ typedef struct {
GTask *task; GTask *task;
char *uri; char *uri;
const char *const *http_headers; const char *const *http_headers;
NMHttpClientPollGetCheckFcn check_fcn; NMHttpClientPollReqCheckFcn check_fcn;
gpointer check_user_data; gpointer check_user_data;
GBytes *response_data; GBytes *response_data;
gsize request_max_data; gsize request_max_data;
long response_code; long response_code;
int request_timeout_ms; int request_timeout_ms;
} PollGetData; } PollReqData;
static void 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); nm_clear_pointer (&poll_req_data->response_data, g_bytes_unref);
g_strfreev ((char **) poll_get_data->http_headers); g_strfreev ((char **) poll_req_data->http_headers);
nm_g_slice_free (poll_get_data); nm_g_slice_free (poll_req_data);
} }
static void static void
_poll_get_probe_start_fcn (GCancellable *cancellable, _poll_req_probe_start_fcn (GCancellable *cancellable,
gpointer probe_user_data, gpointer probe_user_data,
GAsyncReadyCallback callback, GAsyncReadyCallback callback,
gpointer user_data) gpointer user_data)
{ {
PollGetData *poll_get_data = probe_user_data; PollReqData *poll_req_data = probe_user_data;
/* balanced by _poll_get_probe_finish_fcn() */ /* balanced by _poll_req_probe_finish_fcn() */
g_object_ref (poll_get_data->task); g_object_ref (poll_req_data->task);
nm_http_client_get (g_task_get_source_object (poll_get_data->task), nm_http_client_req (g_task_get_source_object (poll_req_data->task),
poll_get_data->uri, poll_req_data->uri,
poll_get_data->request_timeout_ms, poll_req_data->request_timeout_ms,
poll_get_data->request_max_data, poll_req_data->request_max_data,
poll_get_data->http_headers, poll_req_data->http_headers,
cancellable, cancellable,
callback, callback,
user_data); user_data);
} }
static gboolean static gboolean
_poll_get_probe_finish_fcn (GObject *source, _poll_req_probe_finish_fcn (GObject *source,
GAsyncResult *result, GAsyncResult *result,
gpointer probe_user_data, gpointer probe_user_data,
GError **error) GError **error)
{ {
PollGetData *poll_get_data = probe_user_data; PollReqData *poll_req_data = probe_user_data;
_nm_unused gs_unref_object GTask *task = poll_get_data->task; /* balance ref from _poll_get_probe_start_fcn() */ _nm_unused gs_unref_object GTask *task = poll_req_data->task; /* balance ref from _poll_req_probe_start_fcn() */
gboolean success; gboolean success;
gs_free_error GError *local_error = NULL; gs_free_error GError *local_error = NULL;
long response_code; long response_code;
gs_unref_bytes GBytes *response_data = NULL; 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, result,
&response_code, &response_code,
&response_data, &response_data,
@ -456,10 +456,10 @@ _poll_get_probe_finish_fcn (GObject *source,
return FALSE; return FALSE;
} }
if (poll_get_data->check_fcn) { if (poll_req_data->check_fcn) {
success = poll_get_data->check_fcn (response_code, success = poll_req_data->check_fcn (response_code,
response_data, response_data,
poll_get_data->check_user_data, poll_req_data->check_user_data,
&local_error); &local_error);
} else } else
success = (response_code == 200); success = (response_code == 200);
@ -472,32 +472,32 @@ _poll_get_probe_finish_fcn (GObject *source,
if (!success) if (!success)
return FALSE; return FALSE;
poll_get_data->response_code = response_code; poll_req_data->response_code = response_code;
poll_get_data->response_data = g_steal_pointer (&response_data); poll_req_data->response_data = g_steal_pointer (&response_data);
return TRUE; return TRUE;
} }
static void static void
_poll_get_done_cb (GObject *source, _poll_req_done_cb (GObject *source,
GAsyncResult *result, GAsyncResult *result,
gpointer user_data) gpointer user_data)
{ {
PollGetData *poll_get_data = user_data; PollReqData *poll_req_data = user_data;
gs_free_error GError *error = NULL; gs_free_error GError *error = NULL;
gboolean success; gboolean success;
success = nmcs_utils_poll_finish (result, NULL, &error); success = nmcs_utils_poll_finish (result, NULL, &error);
if (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 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 void
nm_http_client_poll_get (NMHttpClient *self, nm_http_client_poll_req (NMHttpClient *self,
const char *uri, const char *uri,
int request_timeout_ms, int request_timeout_ms,
gssize request_max_data, gssize request_max_data,
@ -505,13 +505,13 @@ nm_http_client_poll_get (NMHttpClient *self,
int ratelimit_timeout_ms, int ratelimit_timeout_ms,
const char *const *http_headers, const char *const *http_headers,
GCancellable *cancellable, GCancellable *cancellable,
NMHttpClientPollGetCheckFcn check_fcn, NMHttpClientPollReqCheckFcn check_fcn,
gpointer check_user_data, gpointer check_user_data,
GAsyncReadyCallback callback, GAsyncReadyCallback callback,
gpointer user_data) gpointer user_data)
{ {
nm_auto_pop_gmaincontext GMainContext *context = NULL; 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 (NM_IS_HTTP_CLIENT (self));
g_return_if_fail (uri && uri[0]); g_return_if_fail (uri && uri[0]);
@ -521,9 +521,9 @@ nm_http_client_poll_get (NMHttpClient *self,
g_return_if_fail (ratelimit_timeout_ms >= -1); g_return_if_fail (ratelimit_timeout_ms >= -1);
g_return_if_fail (!cancellable || G_CANCELLABLE (cancellable)); g_return_if_fail (!cancellable || G_CANCELLABLE (cancellable));
poll_get_data = g_slice_new (PollGetData); poll_req_data = g_slice_new (PollReqData);
*poll_get_data = (PollGetData) { *poll_req_data = (PollReqData) {
.task = nm_g_task_new (self, cancellable, nm_http_client_poll_get, callback, user_data), .task = nm_g_task_new (self, cancellable, nm_http_client_poll_req, callback, user_data),
.uri = g_strdup (uri), .uri = g_strdup (uri),
.request_timeout_ms = request_timeout_ms, .request_timeout_ms = request_timeout_ms,
.request_max_data = request_max_data, .request_max_data = request_max_data,
@ -533,39 +533,39 @@ nm_http_client_poll_get (NMHttpClient *self,
.http_headers = NM_CAST_STRV_CC (g_strdupv ((char **) http_headers)), .http_headers = NM_CAST_STRV_CC (g_strdupv ((char **) http_headers)),
}; };
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, g_task_set_task_data (poll_req_data->task,
poll_get_data, poll_req_data,
_poll_get_data_free); _poll_req_data_free);
context = nm_g_main_context_push_thread_default_if_necessary (nm_http_client_get_main_context (self)); context = nm_g_main_context_push_thread_default_if_necessary (nm_http_client_get_main_context (self));
nmcs_utils_poll (poll_timeout_ms, nmcs_utils_poll (poll_timeout_ms,
ratelimit_timeout_ms, ratelimit_timeout_ms,
0, 0,
_poll_get_probe_start_fcn, _poll_req_probe_start_fcn,
_poll_get_probe_finish_fcn, _poll_req_probe_finish_fcn,
poll_get_data, poll_req_data,
cancellable, cancellable,
_poll_get_done_cb, _poll_req_done_cb,
poll_get_data); poll_req_data);
} }
gboolean gboolean
nm_http_client_poll_get_finish (NMHttpClient *self, nm_http_client_poll_req_finish (NMHttpClient *self,
GAsyncResult *result, GAsyncResult *result,
long *out_response_code, long *out_response_code,
GBytes **out_response_data, GBytes **out_response_data,
GError **error) GError **error)
{ {
PollGetData *poll_get_data; PollReqData *poll_req_data;
GTask *task; GTask *task;
gboolean success; gboolean success;
gs_free_error GError *local_error = NULL; gs_free_error GError *local_error = NULL;
g_return_val_if_fail (NM_HTTP_CLIENT (self), FALSE); 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); task = G_TASK (result);
@ -579,10 +579,10 @@ nm_http_client_poll_get_finish (NMHttpClient *self,
return FALSE; 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_code, poll_req_data->response_code);
NM_SET_OUT (out_response_data, g_steal_pointer (&poll_get_data->response_data)); NM_SET_OUT (out_response_data, g_steal_pointer (&poll_req_data->response_data));
return TRUE; 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, GBytes *response_data,
gpointer check_user_data, gpointer check_user_data,
GError **error); GError **error);
void nm_http_client_poll_get (NMHttpClient *self, void nm_http_client_poll_req (NMHttpClient *self,
const char *uri, const char *uri,
int request_timeout_ms, int request_timeout_ms,
gssize request_max_data, gssize request_max_data,
@ -38,12 +38,12 @@ void nm_http_client_poll_get (NMHttpClient *self,
int ratelimit_timeout_ms, int ratelimit_timeout_ms,
const char *const *http_headers, const char *const *http_headers,
GCancellable *cancellable, GCancellable *cancellable,
NMHttpClientPollGetCheckFcn check_fcn, NMHttpClientPollReqCheckFcn check_fcn,
gpointer check_user_data, gpointer check_user_data,
GAsyncReadyCallback callback, GAsyncReadyCallback callback,
gpointer user_data); gpointer user_data);
gboolean nm_http_client_poll_get_finish (NMHttpClient *self, gboolean nm_http_client_poll_req_finish (NMHttpClient *self,
GAsyncResult *result, GAsyncResult *result,
long *out_response_code, long *out_response_code,
GBytes **out_response_data, 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; gs_free_error GError *error = NULL;
gboolean success; 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, result,
NULL, NULL,
NULL, NULL,
@ -132,7 +132,7 @@ detect (NMCSProvider *provider,
http_client = nmcs_provider_get_http_client (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/")), (uri = _ec2_uri_concat ("latest/meta-data/")),
HTTP_TIMEOUT_MS, HTTP_TIMEOUT_MS,
256*1024, 256*1024,
@ -200,7 +200,7 @@ _get_config_fetch_done_cb (NMHttpClient *http_client,
nm_utils_user_data_unpack (user_data, &iface_data, &hwaddr); 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, result,
NULL, NULL,
&response_data, &response_data,
@ -316,7 +316,7 @@ _get_config_metadata_ready_cb (GObject *source,
nm_g_slice_free (metadata_data); 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, result,
NULL, NULL,
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); _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++; 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, (uri1 = _ec2_uri_interfaces (v_mac_data->path,
NM_STR_HAS_SUFFIX (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)); nm_utils_user_data_pack (iface_data, hwaddr));
iface_data->n_pending++; 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, (uri2 = _ec2_uri_interfaces (v_mac_data->path,
NM_STR_HAS_SUFFIX (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 * MAC addresses, then we poll until we see them. They might not yet be
* around from the start... * 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 ()), (uri = _ec2_uri_interfaces ()),
HTTP_TIMEOUT_MS, HTTP_TIMEOUT_MS,
256 * 1024, 256 * 1024,