mirror of
https://github.com/LadybirdBrowser/ladybird.git
synced 2025-07-28 19:59:17 +00:00
RequestServer: Retrieve timing info from curl and pipe it to LibWeb
This timing info will be used to create a PerformanceResourceTiming entry.
This commit is contained in:
Luke Wilde
Andrew Kaster
parent
21d26c5c3e
commit
209b10e53e
Notes:
github-actions[bot]
2025-03-06 16:02:28 +00:00
Author: https://github.com/Lubrsi
Commit: 209b10e53e
Pull-request: https://github.com/LadybirdBrowser/ladybird/pull/3704
Reviewed-by: https://github.com/ADKaster ✅
12 changed files with 268 additions and 51 deletions
43
Libraries/LibRequests/ALPNHttpVersion.h
Normal file
43
Libraries/LibRequests/ALPNHttpVersion.h
Normal file
|
|
@ -0,0 +1,43 @@
|
|||
/*
|
||||
* Copyright (c) 2025, Luke Wilde <luke@ladybird.org>
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-2-Clause
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <AK/FlyString.h>
|
||||
|
||||
namespace Requests {
|
||||
|
||||
// https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids
|
||||
enum class ALPNHttpVersion {
|
||||
None,
|
||||
Http1_0,
|
||||
Http1_1,
|
||||
Http2_TLS,
|
||||
Http2_TCP,
|
||||
Http3,
|
||||
};
|
||||
|
||||
inline FlyString alpn_http_version_to_fly_string(ALPNHttpVersion version)
|
||||
{
|
||||
switch (version) {
|
||||
case ALPNHttpVersion::None:
|
||||
return ""_fly_string;
|
||||
case ALPNHttpVersion::Http1_0:
|
||||
return "http/1.0"_fly_string;
|
||||
case ALPNHttpVersion::Http1_1:
|
||||
return "http/1.1"_fly_string;
|
||||
case ALPNHttpVersion::Http2_TLS:
|
||||
return "h2"_fly_string;
|
||||
case ALPNHttpVersion::Http2_TCP:
|
||||
return "h2c"_fly_string;
|
||||
case ALPNHttpVersion::Http3:
|
||||
return "h3"_fly_string;
|
||||
default:
|
||||
VERIFY_NOT_REACHED();
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -11,5 +11,6 @@ namespace Requests {
|
|||
class Request;
|
||||
class RequestClient;
|
||||
class WebSocket;
|
||||
struct RequestTimingInfo;
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -53,12 +53,13 @@ void Request::set_buffered_request_finished_callback(BufferedRequestFinished on_
|
|||
m_internal_buffered_data->reason_phrase = reason_phrase;
|
||||
};
|
||||
|
||||
on_finish = [this, on_buffered_request_finished = move(on_buffered_request_finished)](auto total_size, auto network_error) {
|
||||
on_finish = [this, on_buffered_request_finished = move(on_buffered_request_finished)](auto total_size, auto& timing_info, auto network_error) {
|
||||
auto output_buffer = ByteBuffer::create_uninitialized(m_internal_buffered_data->payload_stream.used_buffer_size()).release_value_but_fixme_should_propagate_errors();
|
||||
m_internal_buffered_data->payload_stream.read_until_filled(output_buffer).release_value_but_fixme_should_propagate_errors();
|
||||
|
||||
on_buffered_request_finished(
|
||||
total_size,
|
||||
timing_info,
|
||||
network_error,
|
||||
m_internal_buffered_data->response_headers,
|
||||
m_internal_buffered_data->response_code,
|
||||
|
|
@ -83,10 +84,10 @@ void Request::set_unbuffered_request_callbacks(HeadersReceived on_headers_receiv
|
|||
set_up_internal_stream_data(move(on_data_received));
|
||||
}
|
||||
|
||||
void Request::did_finish(Badge<RequestClient>, u64 total_size, Optional<NetworkError> const& network_error)
|
||||
void Request::did_finish(Badge<RequestClient>, u64 total_size, RequestTimingInfo const& timing_info, Optional<NetworkError> const& network_error)
|
||||
{
|
||||
if (on_finish)
|
||||
on_finish(total_size, network_error);
|
||||
on_finish(total_size, timing_info, network_error);
|
||||
}
|
||||
|
||||
void Request::did_receive_headers(Badge<RequestClient>, HTTP::HeaderMap const& response_headers, Optional<u32> response_code, Optional<String> const& reason_phrase)
|
||||
|
|
@ -115,9 +116,10 @@ void Request::set_up_internal_stream_data(DataReceived on_data_available)
|
|||
m_internal_stream_data->read_stream = MUST(Core::File::adopt_fd(fd(), Core::File::OpenMode::Read));
|
||||
|
||||
auto user_on_finish = move(on_finish);
|
||||
on_finish = [this](auto total_size, auto network_error) {
|
||||
on_finish = [this](auto total_size, auto const& timing_info, auto network_error) {
|
||||
m_internal_stream_data->total_size = total_size;
|
||||
m_internal_stream_data->network_error = network_error;
|
||||
m_internal_stream_data->timing_info = timing_info;
|
||||
m_internal_stream_data->request_done = true;
|
||||
m_internal_stream_data->on_finish();
|
||||
};
|
||||
|
|
@ -125,7 +127,7 @@ void Request::set_up_internal_stream_data(DataReceived on_data_available)
|
|||
m_internal_stream_data->on_finish = [this, user_on_finish = move(user_on_finish)]() {
|
||||
if (!m_internal_stream_data->user_finish_called && (!m_internal_stream_data->read_stream || m_internal_stream_data->read_stream->is_eof())) {
|
||||
m_internal_stream_data->user_finish_called = true;
|
||||
user_on_finish(m_internal_stream_data->total_size, m_internal_stream_data->network_error);
|
||||
user_on_finish(m_internal_stream_data->total_size, m_internal_stream_data->timing_info, m_internal_stream_data->network_error);
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -15,6 +15,7 @@
|
|||
#include <LibCore/Notifier.h>
|
||||
#include <LibHTTP/HeaderMap.h>
|
||||
#include <LibRequests/NetworkErrorEnum.h>
|
||||
#include <LibRequests/RequestTimingInfo.h>
|
||||
|
||||
namespace Requests {
|
||||
|
||||
|
|
@ -36,7 +37,7 @@ public:
|
|||
int fd() const { return m_fd; }
|
||||
bool stop();
|
||||
|
||||
using BufferedRequestFinished = Function<void(u64 total_size, Optional<NetworkError> const& network_error, HTTP::HeaderMap const& response_headers, Optional<u32> response_code, Optional<String> reason_phrase, ReadonlyBytes payload)>;
|
||||
using BufferedRequestFinished = Function<void(u64 total_size, RequestTimingInfo const& timing_info, Optional<NetworkError> const& network_error, HTTP::HeaderMap const& response_headers, Optional<u32> response_code, Optional<String> reason_phrase, ReadonlyBytes payload)>;
|
||||
|
||||
// Configure the request such that the entirety of the response data is buffered. The callback receives that data and
|
||||
// the response headers all at once. Using this method is mutually exclusive with `set_unbuffered_data_received_callback`.
|
||||
|
|
@ -44,7 +45,7 @@ public:
|
|||
|
||||
using HeadersReceived = Function<void(HTTP::HeaderMap const& response_headers, Optional<u32> response_code, Optional<String> const& reason_phrase)>;
|
||||
using DataReceived = Function<void(ReadonlyBytes data)>;
|
||||
using RequestFinished = Function<void(u64 total_size, Optional<NetworkError> network_error)>;
|
||||
using RequestFinished = Function<void(u64 total_size, RequestTimingInfo const& timing_info, Optional<NetworkError> network_error)>;
|
||||
|
||||
// Configure the request such that the response data is provided unbuffered as it is received. Using this method is
|
||||
// mutually exclusive with `set_buffered_request_finished_callback`.
|
||||
|
|
@ -52,7 +53,7 @@ public:
|
|||
|
||||
Function<CertificateAndKey()> on_certificate_requested;
|
||||
|
||||
void did_finish(Badge<RequestClient>, u64 total_size, Optional<NetworkError> const& network_error);
|
||||
void did_finish(Badge<RequestClient>, u64 total_size, RequestTimingInfo const& timing_info, Optional<NetworkError> const& network_error);
|
||||
void did_receive_headers(Badge<RequestClient>, HTTP::HeaderMap const& response_headers, Optional<u32> response_code, Optional<String> const& reason_phrase);
|
||||
void did_request_certificates(Badge<RequestClient>);
|
||||
|
||||
|
|
@ -94,6 +95,7 @@ private:
|
|||
u32 total_size { 0 };
|
||||
Optional<NetworkError> network_error;
|
||||
bool request_done { false };
|
||||
RequestTimingInfo timing_info;
|
||||
Function<void()> on_finish {};
|
||||
bool user_finish_called { false };
|
||||
};
|
||||
|
|
|
|||
|
|
@ -69,11 +69,11 @@ bool RequestClient::set_certificate(Badge<Request>, Request& request, ByteString
|
|||
return IPCProxy::set_certificate(request.id(), move(certificate), move(key));
|
||||
}
|
||||
|
||||
void RequestClient::request_finished(i32 request_id, u64 total_size, Optional<NetworkError> const& network_error)
|
||||
void RequestClient::request_finished(i32 request_id, u64 total_size, RequestTimingInfo const& timing_info, Optional<NetworkError> const& network_error)
|
||||
{
|
||||
RefPtr<Request> request;
|
||||
if ((request = m_requests.get(request_id).value_or(nullptr))) {
|
||||
request->did_finish({}, total_size, network_error);
|
||||
request->did_finish({}, total_size, timing_info, network_error);
|
||||
}
|
||||
m_requests.remove(request_id);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,6 +9,7 @@
|
|||
#include <AK/HashMap.h>
|
||||
#include <LibHTTP/HeaderMap.h>
|
||||
#include <LibIPC/ConnectionToServer.h>
|
||||
#include <LibRequests/RequestTimingInfo.h>
|
||||
#include <LibRequests/WebSocket.h>
|
||||
#include <LibWebSocket/WebSocket.h>
|
||||
#include <RequestServer/RequestClientEndpoint.h>
|
||||
|
|
@ -42,7 +43,7 @@ private:
|
|||
virtual void die() override;
|
||||
|
||||
virtual void request_started(i32, IPC::File const&) override;
|
||||
virtual void request_finished(i32, u64, Optional<NetworkError> const&) override;
|
||||
virtual void request_finished(i32, u64, RequestTimingInfo const&, Optional<NetworkError> const&) override;
|
||||
virtual void certificate_requested(i32) override;
|
||||
virtual void headers_became_available(i32, HTTP::HeaderMap const&, Optional<u32> const&, Optional<String> const&) override;
|
||||
|
||||
|
|
|
|||
77
Libraries/LibRequests/RequestTimingInfo.h
Normal file
77
Libraries/LibRequests/RequestTimingInfo.h
Normal file
|
|
@ -0,0 +1,77 @@
|
|||
/*
|
||||
* Copyright (c) 2025, Luke Wilde <luke@ladybird.org>
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-2-Clause
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <AK/FlyString.h>
|
||||
#include <LibIPC/Decoder.h>
|
||||
#include <LibIPC/Encoder.h>
|
||||
#include <LibRequests/ALPNHttpVersion.h>
|
||||
|
||||
namespace Requests {
|
||||
|
||||
struct RequestTimingInfo {
|
||||
long domain_lookup_start_microseconds { 0 };
|
||||
long domain_lookup_end_microseconds { 0 };
|
||||
long connect_start_microseconds { 0 };
|
||||
long connect_end_microseconds { 0 };
|
||||
long secure_connect_start_microseconds { 0 };
|
||||
long request_start_microseconds { 0 };
|
||||
long response_start_microseconds { 0 };
|
||||
long response_end_microseconds { 0 };
|
||||
long encoded_body_size { 0 };
|
||||
ALPNHttpVersion http_version_alpn_identifier { ALPNHttpVersion::None };
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
namespace IPC {
|
||||
|
||||
template<>
|
||||
inline ErrorOr<void> encode(Encoder& encoder, Requests::RequestTimingInfo const& timing_info)
|
||||
{
|
||||
TRY(encoder.encode(timing_info.domain_lookup_start_microseconds));
|
||||
TRY(encoder.encode(timing_info.domain_lookup_end_microseconds));
|
||||
TRY(encoder.encode(timing_info.connect_start_microseconds));
|
||||
TRY(encoder.encode(timing_info.connect_end_microseconds));
|
||||
TRY(encoder.encode(timing_info.secure_connect_start_microseconds));
|
||||
TRY(encoder.encode(timing_info.request_start_microseconds));
|
||||
TRY(encoder.encode(timing_info.response_start_microseconds));
|
||||
TRY(encoder.encode(timing_info.response_end_microseconds));
|
||||
TRY(encoder.encode(timing_info.encoded_body_size));
|
||||
TRY(encoder.encode(timing_info.http_version_alpn_identifier));
|
||||
return {};
|
||||
}
|
||||
|
||||
template<>
|
||||
inline ErrorOr<Requests::RequestTimingInfo> decode(Decoder& decoder)
|
||||
{
|
||||
auto domain_lookup_start_microseconds = TRY(decoder.decode<long>());
|
||||
auto domain_lookup_end_microseconds = TRY(decoder.decode<long>());
|
||||
auto connect_start_microseconds = TRY(decoder.decode<long>());
|
||||
auto connect_end_microseconds = TRY(decoder.decode<long>());
|
||||
auto secure_connect_start_microseconds = TRY(decoder.decode<long>());
|
||||
auto request_start_microseconds = TRY(decoder.decode<long>());
|
||||
auto response_start_microseconds = TRY(decoder.decode<long>());
|
||||
auto response_end_microseconds = TRY(decoder.decode<long>());
|
||||
auto encoded_body_size = TRY(decoder.decode<long>());
|
||||
auto http_version_alpn_identifier = TRY(decoder.decode<Requests::ALPNHttpVersion>());
|
||||
|
||||
return Requests::RequestTimingInfo {
|
||||
.domain_lookup_start_microseconds = domain_lookup_start_microseconds,
|
||||
.domain_lookup_end_microseconds = domain_lookup_end_microseconds,
|
||||
.connect_start_microseconds = connect_start_microseconds,
|
||||
.connect_end_microseconds = connect_end_microseconds,
|
||||
.secure_connect_start_microseconds = secure_connect_start_microseconds,
|
||||
.request_start_microseconds = request_start_microseconds,
|
||||
.response_start_microseconds = response_start_microseconds,
|
||||
.response_end_microseconds = response_end_microseconds,
|
||||
.encoded_body_size = encoded_body_size,
|
||||
.http_version_alpn_identifier = http_version_alpn_identifier,
|
||||
};
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -12,6 +12,7 @@
|
|||
#include <AK/Debug.h>
|
||||
#include <AK/ScopeGuard.h>
|
||||
#include <LibJS/Runtime/Completion.h>
|
||||
#include <LibRequests/RequestTimingInfo.h>
|
||||
#include <LibWeb/Bindings/MainThreadVM.h>
|
||||
#include <LibWeb/Bindings/PrincipalHostDefined.h>
|
||||
#include <LibWeb/Cookie/Cookie.h>
|
||||
|
|
@ -2399,7 +2400,7 @@ WebIDL::ExceptionOr<GC::Ref<PendingResponse>> nonstandard_resource_loader_file_o
|
|||
}
|
||||
});
|
||||
|
||||
auto on_complete = GC::create_function(vm.heap(), [&vm, &realm, pending_response, stream](bool success, Optional<StringView> error_message) {
|
||||
auto on_complete = GC::create_function(vm.heap(), [&vm, &realm, pending_response, stream](bool success, Requests::RequestTimingInfo const&, Optional<StringView> error_message) {
|
||||
HTML::TemporaryExecutionContext execution_context { realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes };
|
||||
|
||||
// 16.1.1.2. Otherwise, if the bytes transmission for response’s message body is done normally and stream is readable,
|
||||
|
|
@ -2422,7 +2423,7 @@ WebIDL::ExceptionOr<GC::Ref<PendingResponse>> nonstandard_resource_loader_file_o
|
|||
|
||||
ResourceLoader::the().load_unbuffered(load_request, on_headers_received, on_data_received, on_complete);
|
||||
} else {
|
||||
auto on_load_success = GC::create_function(vm.heap(), [&realm, &vm, request, pending_response](ReadonlyBytes data, HTTP::HeaderMap const& response_headers, Optional<u32> status_code, Optional<String> const& reason_phrase) {
|
||||
auto on_load_success = GC::create_function(vm.heap(), [&realm, &vm, request, pending_response](ReadonlyBytes data, Requests::RequestTimingInfo const&, HTTP::HeaderMap const& response_headers, Optional<u32> status_code, Optional<String> const& reason_phrase) {
|
||||
(void)request;
|
||||
dbgln_if(WEB_FETCH_DEBUG, "Fetch: ResourceLoader load for '{}' complete", request->url());
|
||||
if constexpr (WEB_FETCH_DEBUG)
|
||||
|
|
@ -2442,7 +2443,7 @@ WebIDL::ExceptionOr<GC::Ref<PendingResponse>> nonstandard_resource_loader_file_o
|
|||
pending_response->resolve(response);
|
||||
});
|
||||
|
||||
auto on_load_error = GC::create_function(vm.heap(), [&realm, &vm, request, pending_response](ByteString const& error, Optional<u32> status_code, Optional<String> const& reason_phrase, ReadonlyBytes data, HTTP::HeaderMap const& response_headers) {
|
||||
auto on_load_error = GC::create_function(vm.heap(), [&realm, &vm, request, pending_response](ByteString const& error, Requests::RequestTimingInfo const&, Optional<u32> status_code, Optional<String> const& reason_phrase, ReadonlyBytes data, HTTP::HeaderMap const& response_headers) {
|
||||
(void)request;
|
||||
dbgln_if(WEB_FETCH_DEBUG, "Fetch: ResourceLoader load for '{}' failed: {} (status {})", request->url(), error, status_code.value_or(0));
|
||||
if constexpr (WEB_FETCH_DEBUG)
|
||||
|
|
|
|||
|
|
@ -110,10 +110,10 @@ RefPtr<Resource> ResourceLoader::load_resource(Resource::Type type, LoadRequest&
|
|||
|
||||
load(
|
||||
request,
|
||||
GC::create_function(m_heap, [resource](ReadonlyBytes data, HTTP::HeaderMap const& headers, Optional<u32> status_code, Optional<String> const&) {
|
||||
GC::create_function(m_heap, [resource](ReadonlyBytes data, Requests::RequestTimingInfo const&, HTTP::HeaderMap const& headers, Optional<u32> status_code, Optional<String> const&) {
|
||||
resource->did_load({}, data, headers, status_code);
|
||||
}),
|
||||
GC::create_function(m_heap, [resource](ByteString const& error, Optional<u32> status_code, Optional<String> const&, ReadonlyBytes data, HTTP::HeaderMap const& headers) {
|
||||
GC::create_function(m_heap, [resource](ByteString const& error, Requests::RequestTimingInfo const&, Optional<u32> status_code, Optional<String> const&, ReadonlyBytes data, HTTP::HeaderMap const& headers) {
|
||||
resource->did_fail({}, error, data, headers, status_code);
|
||||
}));
|
||||
|
||||
|
|
@ -240,23 +240,26 @@ void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> succes
|
|||
request.start_timer();
|
||||
|
||||
if (should_block_request(request)) {
|
||||
error_callback->function()("Request was blocked", {}, {}, {}, {});
|
||||
error_callback->function()("Request was blocked", {}, {}, {}, {}, {});
|
||||
return;
|
||||
}
|
||||
|
||||
auto respond_directory_page = [](LoadRequest const& request, URL::URL const& url, GC::Root<SuccessCallback> success_callback, GC::Root<ErrorCallback> error_callback) {
|
||||
// FIXME: Implement timing info for directory requests.
|
||||
Requests::RequestTimingInfo fixme_implement_timing_info {};
|
||||
|
||||
auto maybe_response = load_file_directory_page(url);
|
||||
if (maybe_response.is_error()) {
|
||||
log_failure(request, maybe_response.error());
|
||||
if (error_callback)
|
||||
error_callback->function()(ByteString::formatted("{}", maybe_response.error()), 500u, {}, {}, {});
|
||||
error_callback->function()(ByteString::formatted("{}", maybe_response.error()), fixme_implement_timing_info, 500u, {}, {}, {});
|
||||
return;
|
||||
}
|
||||
|
||||
log_success(request);
|
||||
HTTP::HeaderMap response_headers;
|
||||
response_headers.set("Content-Type"sv, "text/html"sv);
|
||||
success_callback->function()(maybe_response.release_value().bytes(), response_headers, {}, {});
|
||||
success_callback->function()(maybe_response.release_value().bytes(), fixme_implement_timing_info, response_headers, {}, {});
|
||||
};
|
||||
|
||||
if (url.scheme() == "about") {
|
||||
|
|
@ -266,9 +269,12 @@ void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> succes
|
|||
HTTP::HeaderMap response_headers;
|
||||
response_headers.set("Content-Type", "text/html; charset=UTF-8");
|
||||
|
||||
// FIXME: Implement timing info for about requests.
|
||||
Requests::RequestTimingInfo fixme_implement_timing_info {};
|
||||
|
||||
// About version page
|
||||
if (url.path_segment_at_index(0) == "version") {
|
||||
success_callback->function()(MUST(load_about_version_page()).bytes(), response_headers, {}, {});
|
||||
success_callback->function()(MUST(load_about_version_page()).bytes(), fixme_implement_timing_info, response_headers, {}, {});
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -276,12 +282,12 @@ void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> succes
|
|||
auto resource = Core::Resource::load_from_uri(MUST(String::formatted("resource://ladybird/{}.html", url.path_segment_at_index(0))));
|
||||
if (!resource.is_error()) {
|
||||
auto data = resource.value()->data();
|
||||
success_callback->function()(data, response_headers, {}, {});
|
||||
success_callback->function()(data, fixme_implement_timing_info, response_headers, {}, {});
|
||||
return;
|
||||
}
|
||||
|
||||
Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(m_heap, [success_callback, response_headers = move(response_headers)] {
|
||||
success_callback->function()(ByteString::empty().to_byte_buffer(), response_headers, {}, {});
|
||||
Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(m_heap, [success_callback, response_headers = move(response_headers), fixme_implement_timing_info = move(fixme_implement_timing_info)] {
|
||||
success_callback->function()(ByteString::empty().to_byte_buffer(), fixme_implement_timing_info, response_headers, {}, {});
|
||||
}));
|
||||
return;
|
||||
}
|
||||
|
|
@ -291,7 +297,7 @@ void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> succes
|
|||
if (data_url_or_error.is_error()) {
|
||||
auto error_message = data_url_or_error.error().string_literal();
|
||||
log_failure(request, error_message);
|
||||
error_callback->function()(error_message, {}, {}, {}, {});
|
||||
error_callback->function()(error_message, {}, {}, {}, {}, {});
|
||||
return;
|
||||
}
|
||||
auto data_url = data_url_or_error.release_value();
|
||||
|
|
@ -306,7 +312,10 @@ void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> succes
|
|||
log_success(request);
|
||||
|
||||
Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(m_heap, [data = move(data_url.body), response_headers = move(response_headers), success_callback] {
|
||||
success_callback->function()(data, response_headers, {}, {});
|
||||
// FIXME: Implement timing info for data requests.
|
||||
Requests::RequestTimingInfo fixme_implement_timing_info {};
|
||||
|
||||
success_callback->function()(data, fixme_implement_timing_info, response_headers, {}, {});
|
||||
}));
|
||||
return;
|
||||
}
|
||||
|
|
@ -316,7 +325,7 @@ void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> succes
|
|||
if (resource.is_error()) {
|
||||
log_failure(request, resource.error());
|
||||
if (error_callback)
|
||||
error_callback->function()(ByteString::formatted("{}", resource.error()), {}, {}, {}, {});
|
||||
error_callback->function()(ByteString::formatted("{}", resource.error()), {}, {}, {}, {}, {});
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -331,8 +340,11 @@ void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> succes
|
|||
auto data = resource.value()->data();
|
||||
auto response_headers = response_headers_for_file(URL::percent_decode(url.serialize_path()), resource.value()->modified_time());
|
||||
|
||||
// FIXME: Implement timing info for resource requests.
|
||||
Requests::RequestTimingInfo fixme_implement_timing_info {};
|
||||
|
||||
log_success(request);
|
||||
success_callback->function()(data, response_headers, {}, {});
|
||||
success_callback->function()(data, fixme_implement_timing_info, response_headers, {}, {});
|
||||
|
||||
return;
|
||||
}
|
||||
|
|
@ -352,7 +364,7 @@ void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> succes
|
|||
if (file_or_error.is_error()) {
|
||||
log_failure(request, file_or_error.error());
|
||||
if (error_callback)
|
||||
error_callback->function()(ByteString::formatted("{}", file_or_error.error()), {}, {}, {}, {});
|
||||
error_callback->function()(ByteString::formatted("{}", file_or_error.error()), {}, {}, {}, {}, {});
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -369,7 +381,7 @@ void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> succes
|
|||
if (st_or_error.is_error()) {
|
||||
log_failure(request, st_or_error.error());
|
||||
if (error_callback)
|
||||
error_callback->function()(ByteString::formatted("{}", st_or_error.error()), {}, {}, {}, {});
|
||||
error_callback->function()(ByteString::formatted("{}", st_or_error.error()), {}, {}, {}, {}, {});
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -378,7 +390,7 @@ void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> succes
|
|||
if (maybe_file.is_error()) {
|
||||
log_failure(request, maybe_file.error());
|
||||
if (error_callback)
|
||||
error_callback->function()(ByteString::formatted("{}", maybe_file.error()), {}, {}, {}, {});
|
||||
error_callback->function()(ByteString::formatted("{}", maybe_file.error()), {}, {}, {}, {}, {});
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -387,15 +399,18 @@ void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> succes
|
|||
if (maybe_data.is_error()) {
|
||||
log_failure(request, maybe_data.error());
|
||||
if (error_callback)
|
||||
error_callback->function()(ByteString::formatted("{}", maybe_data.error()), {}, {}, {}, {});
|
||||
error_callback->function()(ByteString::formatted("{}", maybe_data.error()), {}, {}, {}, {}, {});
|
||||
return;
|
||||
}
|
||||
|
||||
auto data = maybe_data.release_value();
|
||||
auto response_headers = response_headers_for_file(URL::percent_decode(request.url().serialize_path()), st_or_error.value().st_mtime);
|
||||
|
||||
// FIXME: Implement timing info for file requests.
|
||||
Requests::RequestTimingInfo fixme_implement_timing_info {};
|
||||
|
||||
log_success(request);
|
||||
success_callback->function()(data, response_headers, {}, {});
|
||||
success_callback->function()(data, fixme_implement_timing_info, response_headers, {}, {});
|
||||
});
|
||||
|
||||
page->client().request_file(move(file_request));
|
||||
|
|
@ -411,7 +426,7 @@ void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> succes
|
|||
auto protocol_request = start_network_request(request);
|
||||
if (!protocol_request) {
|
||||
if (error_callback)
|
||||
error_callback->function()("Failed to start network request"sv, {}, {}, {}, {});
|
||||
error_callback->function()("Failed to start network request"sv, {}, {}, {}, {}, {});
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -426,7 +441,7 @@ void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> succes
|
|||
timer->start();
|
||||
}
|
||||
|
||||
auto on_buffered_request_finished = [this, success_callback, error_callback, request, &protocol_request = *protocol_request](auto, auto const& network_error, auto& response_headers, auto status_code, auto const& reason_phrase, ReadonlyBytes payload) mutable {
|
||||
auto on_buffered_request_finished = [this, success_callback, error_callback, request, &protocol_request = *protocol_request](auto, auto const& timing_info, auto const& network_error, auto& response_headers, auto status_code, auto const& reason_phrase, ReadonlyBytes payload) mutable {
|
||||
handle_network_response_headers(request, response_headers);
|
||||
|
||||
// NOTE: We finish the network request *after* invoking callbacks, otherwise a nested
|
||||
|
|
@ -449,12 +464,12 @@ void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> succes
|
|||
|
||||
log_failure(request, error_builder.string_view());
|
||||
if (error_callback)
|
||||
error_callback->function()(error_builder.to_byte_string(), status_code, reason_phrase, payload, response_headers);
|
||||
error_callback->function()(error_builder.to_byte_string(), timing_info, status_code, reason_phrase, payload, response_headers);
|
||||
return;
|
||||
}
|
||||
|
||||
log_success(request);
|
||||
success_callback->function()(payload, response_headers, status_code, reason_phrase);
|
||||
success_callback->function()(payload, timing_info, response_headers, status_code, reason_phrase);
|
||||
};
|
||||
|
||||
protocol_request->set_buffered_request_finished_callback(move(on_buffered_request_finished));
|
||||
|
|
@ -463,8 +478,9 @@ void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> succes
|
|||
|
||||
auto not_implemented_error = ByteString::formatted("Protocol not implemented: {}", url.scheme());
|
||||
log_failure(request, not_implemented_error);
|
||||
if (error_callback)
|
||||
error_callback->function()(not_implemented_error, {}, {}, {}, {});
|
||||
if (error_callback) {
|
||||
error_callback->function()(not_implemented_error, {}, {}, {}, {}, {});
|
||||
}
|
||||
}
|
||||
|
||||
void ResourceLoader::load_unbuffered(LoadRequest& request, GC::Root<OnHeadersReceived> on_headers_received, GC::Root<OnDataReceived> on_data_received, GC::Root<OnComplete> on_complete)
|
||||
|
|
@ -475,19 +491,19 @@ void ResourceLoader::load_unbuffered(LoadRequest& request, GC::Root<OnHeadersRec
|
|||
request.start_timer();
|
||||
|
||||
if (should_block_request(request)) {
|
||||
on_complete->function()(false, "Request was blocked"sv);
|
||||
on_complete->function()(false, {}, "Request was blocked"sv);
|
||||
return;
|
||||
}
|
||||
|
||||
if (!url.scheme().is_one_of("http"sv, "https"sv)) {
|
||||
// FIXME: Non-network requests from fetch should not go through this path.
|
||||
on_complete->function()(false, "Cannot establish connection non-network scheme"sv);
|
||||
on_complete->function()(false, {}, "Cannot establish connection non-network scheme"sv);
|
||||
return;
|
||||
}
|
||||
|
||||
auto protocol_request = start_network_request(request);
|
||||
if (!protocol_request) {
|
||||
on_complete->function()(false, "Failed to start network request"sv);
|
||||
on_complete->function()(false, {}, "Failed to start network request"sv);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -500,15 +516,15 @@ void ResourceLoader::load_unbuffered(LoadRequest& request, GC::Root<OnHeadersRec
|
|||
on_data_received->function()(data);
|
||||
};
|
||||
|
||||
auto protocol_complete = [this, on_complete, request, &protocol_request = *protocol_request](u64, Optional<Requests::NetworkError> const& network_error) {
|
||||
auto protocol_complete = [this, on_complete, request, &protocol_request = *protocol_request](u64, Requests::RequestTimingInfo const& timing_info, Optional<Requests::NetworkError> const& network_error) {
|
||||
finish_network_request(protocol_request);
|
||||
|
||||
if (!network_error.has_value()) {
|
||||
log_success(request);
|
||||
on_complete->function()(true, {});
|
||||
on_complete->function()(true, timing_info, {});
|
||||
} else {
|
||||
log_failure(request, "Request finished with error"sv);
|
||||
on_complete->function()(false, "Request finished with error"sv);
|
||||
on_complete->function()(false, timing_info, "Request finished with error"sv);
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -26,15 +26,15 @@ public:
|
|||
|
||||
RefPtr<Resource> load_resource(Resource::Type, LoadRequest&);
|
||||
|
||||
using SuccessCallback = GC::Function<void(ReadonlyBytes, HTTP::HeaderMap const& response_headers, Optional<u32> status_code, Optional<String> const& reason_phrase)>;
|
||||
using ErrorCallback = GC::Function<void(ByteString const&, Optional<u32> status_code, Optional<String> const& reason_phrase, ReadonlyBytes payload, HTTP::HeaderMap const& response_headers)>;
|
||||
using SuccessCallback = GC::Function<void(ReadonlyBytes, Requests::RequestTimingInfo const&, HTTP::HeaderMap const& response_headers, Optional<u32> status_code, Optional<String> const& reason_phrase)>;
|
||||
using ErrorCallback = GC::Function<void(ByteString const&, Requests::RequestTimingInfo const&, Optional<u32> status_code, Optional<String> const& reason_phrase, ReadonlyBytes payload, HTTP::HeaderMap const& response_headers)>;
|
||||
using TimeoutCallback = GC::Function<void()>;
|
||||
|
||||
void load(LoadRequest&, GC::Root<SuccessCallback> success_callback, GC::Root<ErrorCallback> error_callback = nullptr, Optional<u32> timeout = {}, GC::Root<TimeoutCallback> timeout_callback = nullptr);
|
||||
|
||||
using OnHeadersReceived = GC::Function<void(HTTP::HeaderMap const& response_headers, Optional<u32> status_code, Optional<String> const& reason_phrase)>;
|
||||
using OnDataReceived = GC::Function<void(ReadonlyBytes data)>;
|
||||
using OnComplete = GC::Function<void(bool success, Optional<StringView> error_message)>;
|
||||
using OnComplete = GC::Function<void(bool success, Requests::RequestTimingInfo const& timing_info, Optional<StringView> error_message)>;
|
||||
|
||||
void load_unbuffered(LoadRequest&, GC::Root<OnHeadersReceived>, GC::Root<OnDataReceived>, GC::Root<OnComplete>);
|
||||
|
||||
|
|
|
|||
|
|
@ -14,6 +14,7 @@
|
|||
#include <LibCore/Proxy.h>
|
||||
#include <LibCore/Socket.h>
|
||||
#include <LibRequests/NetworkErrorEnum.h>
|
||||
#include <LibRequests/RequestTimingInfo.h>
|
||||
#include <LibRequests/WebSocket.h>
|
||||
#include <LibTLS/TLSv12.h>
|
||||
#include <LibTextCodec/Decoder.h>
|
||||
|
|
@ -382,12 +383,14 @@ void ConnectionFromClient::start_request(i32 request_id, ByteString const& metho
|
|||
m_resolver->dns.lookup(host, DNS::Messages::Class::IN, { DNS::Messages::ResourceType::A, DNS::Messages::ResourceType::AAAA })
|
||||
->when_rejected([this, request_id](auto const& error) {
|
||||
dbgln("StartRequest: DNS lookup failed: {}", error);
|
||||
async_request_finished(request_id, 0, Requests::NetworkError::UnableToResolveHost);
|
||||
// FIXME: Implement timing info for DNS lookup failure.
|
||||
async_request_finished(request_id, 0, {}, Requests::NetworkError::UnableToResolveHost);
|
||||
})
|
||||
.when_resolved([this, request_id, host, url, method, request_body, request_headers, proxy_data](auto const& dns_result) {
|
||||
if (dns_result->records().is_empty() || dns_result->cached_addresses().is_empty()) {
|
||||
dbgln("StartRequest: DNS lookup failed for '{}'", host);
|
||||
async_request_finished(request_id, 0, Requests::NetworkError::UnableToResolveHost);
|
||||
// FIXME: Implement timing info for DNS lookup failure.
|
||||
async_request_finished(request_id, 0, {}, Requests::NetworkError::UnableToResolveHost);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -522,6 +525,75 @@ static Requests::NetworkError map_curl_code_to_network_error(CURLcode const& cod
|
|||
}
|
||||
}
|
||||
|
||||
static Requests::RequestTimingInfo get_timing_info_from_curl_easy_handle(CURL* easy_handle)
|
||||
{
|
||||
/*
|
||||
* curl_easy_perform()
|
||||
* |
|
||||
* |--QUEUE
|
||||
* |--|--NAMELOOKUP
|
||||
* |--|--|--CONNECT
|
||||
* |--|--|--|--APPCONNECT
|
||||
* |--|--|--|--|--PRETRANSFER
|
||||
* |--|--|--|--|--|--POSTTRANSFER
|
||||
* |--|--|--|--|--|--|--STARTTRANSFER
|
||||
* |--|--|--|--|--|--|--|--TOTAL
|
||||
* |--|--|--|--|--|--|--|--REDIRECT
|
||||
*/
|
||||
|
||||
auto get_timing_info = [easy_handle](auto option) {
|
||||
curl_off_t time_value = 0;
|
||||
auto result = curl_easy_getinfo(easy_handle, option, &time_value);
|
||||
VERIFY(result == CURLE_OK);
|
||||
return time_value;
|
||||
};
|
||||
|
||||
auto queue_time = get_timing_info(CURLINFO_QUEUE_TIME_T);
|
||||
auto domain_lookup_time = get_timing_info(CURLINFO_NAMELOOKUP_TIME_T);
|
||||
auto connect_time = get_timing_info(CURLINFO_CONNECT_TIME_T);
|
||||
auto secure_connect_time = get_timing_info(CURLINFO_APPCONNECT_TIME_T);
|
||||
auto request_start_time = get_timing_info(CURLINFO_PRETRANSFER_TIME_T);
|
||||
auto response_start_time = get_timing_info(CURLINFO_STARTTRANSFER_TIME_T);
|
||||
auto response_end_time = get_timing_info(CURLINFO_TOTAL_TIME_T);
|
||||
auto encoded_body_size = get_timing_info(CURLINFO_SIZE_DOWNLOAD_T);
|
||||
|
||||
long http_version = 0;
|
||||
auto get_version_result = curl_easy_getinfo(easy_handle, CURLINFO_HTTP_VERSION, &http_version);
|
||||
VERIFY(get_version_result == CURLE_OK);
|
||||
|
||||
auto http_version_alpn = Requests::ALPNHttpVersion::None;
|
||||
switch (http_version) {
|
||||
case CURL_HTTP_VERSION_1_0:
|
||||
http_version_alpn = Requests::ALPNHttpVersion::Http1_0;
|
||||
break;
|
||||
case CURL_HTTP_VERSION_1_1:
|
||||
http_version_alpn = Requests::ALPNHttpVersion::Http1_1;
|
||||
break;
|
||||
case CURL_HTTP_VERSION_2_0:
|
||||
http_version_alpn = Requests::ALPNHttpVersion::Http2_TLS;
|
||||
break;
|
||||
case CURL_HTTP_VERSION_3:
|
||||
http_version_alpn = Requests::ALPNHttpVersion::Http3;
|
||||
break;
|
||||
default:
|
||||
http_version_alpn = Requests::ALPNHttpVersion::None;
|
||||
break;
|
||||
}
|
||||
|
||||
return Requests::RequestTimingInfo {
|
||||
.domain_lookup_start_microseconds = queue_time,
|
||||
.domain_lookup_end_microseconds = queue_time + domain_lookup_time,
|
||||
.connect_start_microseconds = queue_time + domain_lookup_time,
|
||||
.connect_end_microseconds = queue_time + domain_lookup_time + connect_time + secure_connect_time,
|
||||
.secure_connect_start_microseconds = queue_time + domain_lookup_time + connect_time,
|
||||
.request_start_microseconds = queue_time + domain_lookup_time + connect_time + secure_connect_time + request_start_time,
|
||||
.response_start_microseconds = queue_time + domain_lookup_time + connect_time + secure_connect_time + response_start_time,
|
||||
.response_end_microseconds = queue_time + domain_lookup_time + connect_time + secure_connect_time + response_end_time,
|
||||
.encoded_body_size = encoded_body_size,
|
||||
.http_version_alpn_identifier = http_version_alpn,
|
||||
};
|
||||
}
|
||||
|
||||
void ConnectionFromClient::check_active_requests()
|
||||
{
|
||||
int msgs_in_queue = 0;
|
||||
|
|
@ -547,6 +619,7 @@ void ConnectionFromClient::check_active_requests()
|
|||
auto* request = static_cast<ActiveRequest*>(application_private);
|
||||
|
||||
if (!request->is_connect_only) {
|
||||
auto timing_info = get_timing_info_from_curl_easy_handle(msg->easy_handle);
|
||||
request->flush_headers_if_needed();
|
||||
|
||||
auto result_code = msg->data.result;
|
||||
|
|
@ -562,7 +635,7 @@ void ConnectionFromClient::check_active_requests()
|
|||
}
|
||||
}
|
||||
|
||||
async_request_finished(request->request_id, request->downloaded_so_far, network_error);
|
||||
async_request_finished(request->request_id, request->downloaded_so_far, timing_info, network_error);
|
||||
}
|
||||
|
||||
m_active_requests.remove(request->request_id);
|
||||
|
|
|
|||
|
|
@ -1,11 +1,12 @@
|
|||
#include <LibHTTP/HeaderMap.h>
|
||||
#include <LibRequests/NetworkErrorEnum.h>
|
||||
#include <LibRequests/RequestTimingInfo.h>
|
||||
#include <LibURL/URL.h>
|
||||
|
||||
endpoint RequestClient
|
||||
{
|
||||
request_started(i32 request_id, IPC::File fd) =|
|
||||
request_finished(i32 request_id, u64 total_size, Optional<Requests::NetworkError> network_error) =|
|
||||
request_finished(i32 request_id, u64 total_size, Requests::RequestTimingInfo timing_info, Optional<Requests::NetworkError> network_error) =|
|
||||
headers_became_available(i32 request_id, HTTP::HeaderMap response_headers, Optional<u32> status_code, Optional<String> reason_phrase) =|
|
||||
|
||||
// Websocket API
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue