Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-30 12:50:58 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Libraries/LibWeb/WebDriver/Client.cpp

363 lines
15 KiB
C++
Raw Normal View History

LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
/*
* Copyright (c) 2022, Florent Castelli <florent.castelli@gmail.com>
* Copyright (c) 2022, Sam Atkins <atkinssj@serenityos.org>
* Copyright (c) 2022, Tobias Christiansen <tobyase@serenityos.org>
* Copyright (c) 2022, Linus Groh <linusg@serenityos.org>
LibWeb: Defer handling of WebDriver endpoint invocations We can currently crash on WebDriver session shutdown when we receive a Delete Session command. This destroys the WebDriver client while we are inside the client's socket's on_ready_to_read callback. This is not allowed by AK::Function. To avoid this, we now only read data from the socket in the callback. We then defer handling the message to break out of the callback.
2024-10-27 14:57:00 -04:00
* Copyright (c) 2022-2024, Tim Flynn <trflynn89@ladybird.org>
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/ByteBuffer.h>
#include <AK/Debug.h>
#include <AK/Format.h>
#include <AK/JsonObject.h>
#include <AK/JsonParser.h>
#include <AK/JsonValue.h>
#include <AK/Span.h>
#include <AK/StringBuilder.h>
#include <AK/StringView.h>
#include <LibCore/DateTime.h>
#include <LibHTTP/HttpResponse.h>
#include <LibWeb/WebDriver/Client.h>
namespace Web::WebDriver {
using RouteHandler = Response (*)(Client&, Parameters, JsonValue);
struct Route {
HTTP::HttpRequest::Method method {};
StringView path;
RouteHandler handler { nullptr };
};
struct MatchedRoute {
RouteHandler handler;
LibWeb+WebContent+WebDriver: Port WebDriver parameters to String This changes the parameters parsed from a WebDriver HTTP request to String for transferring over IPC. Conveniently, most locations these were ultimately passed to only need a StringView.
2023-03-05 15:31:49 -05:00
Vector<String> parameters;
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
};
Everywhere: Remove 'clang-format off' comments that are no longer needed
2023-07-07 22:59:01 -04:00
#define ROUTE(method, path, handler) \
Route \
{ \
HTTP::HttpRequest::method, \
path, \
[](auto& client, auto parameters, auto payload) { \
return client.handler(parameters, move(payload)); \
} \
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
}
// https://w3c.github.io/webdriver/#dfn-endpoints
static constexpr auto s_webdriver_endpoints = Array {
ROUTE(POST, "/session"sv, new_session),
ROUTE(DELETE, "/session/:session_id"sv, delete_session),
ROUTE(GET, "/status"sv, get_status),
ROUTE(GET, "/session/:session_id/timeouts"sv, get_timeouts),
ROUTE(POST, "/session/:session_id/timeouts"sv, set_timeouts),
ROUTE(POST, "/session/:session_id/url"sv, navigate_to),
ROUTE(GET, "/session/:session_id/url"sv, get_current_url),
ROUTE(POST, "/session/:session_id/back"sv, back),
ROUTE(POST, "/session/:session_id/forward"sv, forward),
ROUTE(POST, "/session/:session_id/refresh"sv, refresh),
ROUTE(GET, "/session/:session_id/title"sv, get_title),
ROUTE(GET, "/session/:session_id/window"sv, get_window_handle),
ROUTE(DELETE, "/session/:session_id/window"sv, close_window),
WebContent+WebDriver: Implement `POST /session/{id}/window` endpoint
2022-11-24 20:32:53 -06:00
ROUTE(POST, "/session/:session_id/window"sv, switch_to_window),
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
ROUTE(GET, "/session/:session_id/window/handles"sv, get_window_handles),
LibWeb+WebContent+WebDriver: Add WebDriver endpoint to open new window
2023-03-14 14:09:50 +03:00
ROUTE(POST, "/session/:session_id/window/new"sv, new_window),
WebDriver: Add Routes, IPC definitions, and boilerplates Added the following Routes, IPC definitions, and boilerplates for the missing endpoints: - Switch To Frame - Switch To Parent Frame - Element Clear - Element Send Keys
2024-09-07 12:41:54 -07:00
ROUTE(POST, "/session/:session_id/frame"sv, switch_to_frame),
ROUTE(POST, "/session/:session_id/frame/parent"sv, switch_to_parent_frame),
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
ROUTE(GET, "/session/:session_id/window/rect"sv, get_window_rect),
ROUTE(POST, "/session/:session_id/window/rect"sv, set_window_rect),
ROUTE(POST, "/session/:session_id/window/maximize"sv, maximize_window),
ROUTE(POST, "/session/:session_id/window/minimize"sv, minimize_window),
LibWeb: Define the route for the Fullscreen Window command This was missed in 4eefa292dff3ce6c20f5166a643f673ac924d8c6.
2022-11-13 19:00:38 -05:00
ROUTE(POST, "/session/:session_id/window/fullscreen"sv, fullscreen_window),
WebDriver+WebContent: Add /session/:id:/window/consume-user-activation This extension to the WebDriver spec is defined in the HTML spec, how fun.
2024-05-29 11:14:42 -06:00
ROUTE(POST, "/session/:session_id/window/consume-user-activation"sv, consume_user_activation),
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
ROUTE(POST, "/session/:session_id/element"sv, find_element),
ROUTE(POST, "/session/:session_id/elements"sv, find_elements),
ROUTE(POST, "/session/:session_id/element/:element_id/element"sv, find_element_from_element),
ROUTE(POST, "/session/:session_id/element/:element_id/elements"sv, find_elements_from_element),
LibWeb+WebContent+WebDriver: Implement Find Element From Shadow Root
2022-11-14 19:48:48 -05:00
ROUTE(POST, "/session/:session_id/shadow/:shadow_id/element"sv, find_element_from_shadow_root),
LibWeb+WebContent+WebDriver: Implement Find Elements From Shadow Root
2022-11-14 19:54:17 -05:00
ROUTE(POST, "/session/:session_id/shadow/:shadow_id/elements"sv, find_elements_from_shadow_root),
LibWeb+WebContent+WebDriver: Implement Get Active Element Unfortunately, nothing ever calls DOM::Document::set_active_element at the moment, so this will always return ErrorCode::NoSuchElement.
2022-11-14 19:02:23 -05:00
ROUTE(GET, "/session/:session_id/element/active"sv, get_active_element),
LibWeb+WebContent+WebDriver: Implement Get Element Shadow Root
2022-11-14 19:27:11 -05:00
ROUTE(GET, "/session/:session_id/element/:element_id/shadow"sv, get_element_shadow_root),
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
ROUTE(GET, "/session/:session_id/element/:element_id/selected"sv, is_element_selected),
ROUTE(GET, "/session/:session_id/element/:element_id/attribute/:name"sv, get_element_attribute),
ROUTE(GET, "/session/:session_id/element/:element_id/property/:name"sv, get_element_property),
ROUTE(GET, "/session/:session_id/element/:element_id/css/:name"sv, get_element_css_value),
ROUTE(GET, "/session/:session_id/element/:element_id/text"sv, get_element_text),
ROUTE(GET, "/session/:session_id/element/:element_id/name"sv, get_element_tag_name),
ROUTE(GET, "/session/:session_id/element/:element_id/rect"sv, get_element_rect),
ROUTE(GET, "/session/:session_id/element/:element_id/enabled"sv, is_element_enabled),
WebDriver: Add computedrole endpoint
2023-01-15 10:26:08 -06:00
ROUTE(GET, "/session/:session_id/element/:element_id/computedrole"sv, get_computed_role),
WebDriver: Add computedlabel endpoint
2023-02-19 11:36:08 -06:00
ROUTE(GET, "/session/:session_id/element/:element_id/computedlabel"sv, get_computed_label),
WebDriver+LibWeb: Rename "click" to "element_click" This matches the name used in the spec, and is unambiguous.
2023-01-26 14:11:54 +00:00
ROUTE(POST, "/session/:session_id/element/:element_id/click"sv, element_click),
WebDriver: Add Routes, IPC definitions, and boilerplates Added the following Routes, IPC definitions, and boilerplates for the missing endpoints: - Switch To Frame - Switch To Parent Frame - Element Clear - Element Send Keys
2024-09-07 12:41:54 -07:00
ROUTE(POST, "/session/:session_id/element/:element_id/clear"sv, element_clear),
ROUTE(POST, "/session/:session_id/element/:element_id/value"sv, element_send_keys),
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
ROUTE(GET, "/session/:session_id/source"sv, get_source),
ROUTE(POST, "/session/:session_id/execute/sync"sv, execute_script),
ROUTE(POST, "/session/:session_id/execute/async"sv, execute_async_script),
ROUTE(GET, "/session/:session_id/cookie"sv, get_all_cookies),
ROUTE(GET, "/session/:session_id/cookie/:name"sv, get_named_cookie),
ROUTE(POST, "/session/:session_id/cookie"sv, add_cookie),
ROUTE(DELETE, "/session/:session_id/cookie/:name"sv, delete_cookie),
ROUTE(DELETE, "/session/:session_id/cookie"sv, delete_all_cookies),
WebDriver: Add boilerplate for endpoint 15.7 Perform Actions Following the structure of the ReleaseActions endpoints, define analogous classes and methods for PerformActions
2024-09-02 14:41:24 -04:00
ROUTE(POST, "/session/:session_id/actions"sv, perform_actions),
LibWeb: Stub out `Release Actions` This allows WPT to open the browser, and it no longer instantly crashes
2023-06-17 17:36:00 +02:00
ROUTE(DELETE, "/session/:session_id/actions"sv, release_actions),
LibWeb+WebContent+WebDriver: Implement Dismiss Alert
2022-11-16 07:15:57 -05:00
ROUTE(POST, "/session/:session_id/alert/dismiss"sv, dismiss_alert),
LibWeb+WebContent+WebDriver: Implement Accept Alert
2022-11-16 07:24:22 -05:00
ROUTE(POST, "/session/:session_id/alert/accept"sv, accept_alert),
LibWeb+WebContent+WebDriver: Implement Get Alert Text
2022-11-16 08:26:48 -05:00
ROUTE(GET, "/session/:session_id/alert/text"sv, get_alert_text),
LibWeb+LibWebView+WebContent+WebDriver: Implement Send Alert Text
2022-11-16 08:57:05 -05:00
ROUTE(POST, "/session/:session_id/alert/text"sv, send_alert_text),
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
ROUTE(GET, "/session/:session_id/screenshot"sv, take_screenshot),
ROUTE(GET, "/session/:session_id/element/:element_id/screenshot"sv, take_element_screenshot),
WebDriver: Implement stub for /session/{id}/print
2022-11-27 00:30:03 +01:00
ROUTE(POST, "/session/:session_id/print"sv, print_page),
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
};
// https://w3c.github.io/webdriver/#dfn-match-a-request
static ErrorOr<MatchedRoute, Error> match_route(HTTP::HttpRequest const& request)
{
LibWeb: Hide WebDriver::match_route debug behind its own flag When enabling WEBDRIVER_DEBUG globally, this function's debug spam overpowers the rest of the useful logs.
2024-02-07 08:06:55 -07:00
dbgln_if(WEBDRIVER_ROUTE_DEBUG, "match_route({}, {})", HTTP::to_string_view(request.method()), request.resource());
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
auto request_path = request.resource().view();
LibWeb+WebContent+WebDriver: Port WebDriver parameters to String This changes the parameters parsed from a WebDriver HTTP request to String for transferring over IPC. Conveniently, most locations these were ultimately passed to only need a StringView.
2023-03-05 15:31:49 -05:00
Vector<String> parameters;
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
auto next_segment = [](auto& path) -> Optional<StringView> {
if (auto index = path.find('/'); index.has_value() && (*index + 1) < path.length()) {
path = path.substring_view(*index + 1);
if (index = path.find('/'); index.has_value())
return path.substring_view(0, *index);
return path;
}
path = {};
return {};
};
for (auto const& route : s_webdriver_endpoints) {
LibWeb: Hide WebDriver::match_route debug behind its own flag When enabling WEBDRIVER_DEBUG globally, this function's debug spam overpowers the rest of the useful logs.
2024-02-07 08:06:55 -07:00
dbgln_if(WEBDRIVER_ROUTE_DEBUG, "- Checking {} {}", HTTP::to_string_view(route.method), route.path);
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
if (route.method != request.method())
continue;
auto route_path = route.path;
Optional<bool> match;
auto on_failed_match = [&]() {
request_path = request.resource();
parameters.clear();
match = false;
};
while (!match.has_value()) {
auto request_segment = next_segment(request_path);
auto route_segment = next_segment(route_path);
if (!request_segment.has_value() && !route_segment.has_value())
match = true;
else if (request_segment.has_value() != route_segment.has_value())
on_failed_match();
else if (route_segment->starts_with(':'))
LibWeb+WebContent+WebDriver: Port WebDriver parameters to String This changes the parameters parsed from a WebDriver HTTP request to String for transferring over IPC. Conveniently, most locations these were ultimately passed to only need a StringView.
2023-03-05 15:31:49 -05:00
TRY(parameters.try_append(TRY(String::from_utf8(*request_segment))));
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
else if (request_segment != route_segment)
on_failed_match();
}
if (*match) {
LibWeb: Hide WebDriver::match_route debug behind its own flag When enabling WEBDRIVER_DEBUG globally, this function's debug spam overpowers the rest of the useful logs.
2024-02-07 08:06:55 -07:00
dbgln_if(WEBDRIVER_ROUTE_DEBUG, "- Found match with parameters={}", parameters);
LibWeb+WebContent+WebDriver: Port WebDriver parameters to String This changes the parameters parsed from a WebDriver HTTP request to String for transferring over IPC. Conveniently, most locations these were ultimately passed to only need a StringView.
2023-03-05 15:31:49 -05:00
return MatchedRoute { route.handler, move(parameters) };
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
}
}
return Error::from_code(ErrorCode::UnknownCommand, "The command was not recognized.");
}
LibWeb+WebContentr+WebDriver: Move driver response wrapping to LibWeb Success responses are meant to be wrapped in a JSON object with a single "value" key. Instead of doing this in both WebContent and WebDriver, do it once in LibWeb.
2022-11-13 00:52:44 -05:00
static JsonValue make_success_response(JsonValue value)
{
JsonObject result;
result.set("value", move(value));
return result;
}
Userland: Rename Core::Object to Core::EventReceiver This is a more precise description of what this class actually does.
2023-08-06 18:09:39 +02:00
Client::Client(NonnullOwnPtr<Core::BufferedTCPSocket> socket, Core::EventReceiver* parent)
: Core::EventReceiver(parent)
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
, m_socket(move(socket))
{
m_socket->on_ready_to_read = [this] {
LibWeb: Defer handling of WebDriver endpoint invocations We can currently crash on WebDriver session shutdown when we receive a Delete Session command. This destroys the WebDriver client while we are inside the client's socket's on_ready_to_read callback. This is not allowed by AK::Function. To avoid this, we now only read data from the socket in the callback. We then defer handling the message to break out of the callback.
2024-10-27 14:57:00 -04:00
if (auto result = on_ready_to_read(); result.is_error())
handle_error({}, result.release_error());
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
};
}
Client::~Client()
{
m_socket->close();
}
void Client::die()
{
LibWeb: Defer handling of WebDriver endpoint invocations We can currently crash on WebDriver session shutdown when we receive a Delete Session command. This destroys the WebDriver client while we are inside the client's socket's on_ready_to_read callback. This is not allowed by AK::Function. To avoid this, we now only read data from the socket in the callback. We then defer handling the message to break out of the callback.
2024-10-27 14:57:00 -04:00
// We defer removing this connection to avoid closing its socket while we are inside the on_ready_to_read callback.
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
deferred_invoke([this] { remove_from_parent(); });
}
ErrorOr<void, Client::WrappedError> Client::on_ready_to_read()
{
// FIXME: All this should be moved to LibHTTP and be made spec compliant.
auto buffer = TRY(ByteBuffer::create_uninitialized(m_socket->buffer_size()));
for (;;) {
if (!TRY(m_socket->can_read_without_blocking()))
break;
AK: Rename Stream::{read,write} to Stream::{read_some,write_some} Similar to POSIX read, the basic read and write functions of AK::Stream do not have a lower limit of how much data they read or write (apart from "none at all"). Rename the functions to "read some [data]" and "write some [data]" (with "data" being omitted, since everything here is reading and writing data) to make them sufficiently distinct from the functions that ensure to use the entire buffer (which should be the go-to function for most usages). No functional changes, just a lot of new FIXMEs.
2023-02-24 22:38:01 +01:00
auto data = TRY(m_socket->read_some(buffer));
LibWeb/WebDriver: Wait for more data to arrive if request is incomplete Currently significant portion of requests coming to WebDriver server fails with error while parsing json body because requests are parsed when they are not complete yet. This change solves this by waiting for more data to arrive if HTTP request parser found that there is not enough data yet to parse the whole request. In the future we would probably want to move this logic to LibHTTP because this problem is relevant for any HTTP server.
2023-03-23 03:14:17 +03:00
TRY(m_remaining_request.try_append(StringView { data }));
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
LibWeb/WebDriver: Close client connection socket when EOF is reached Fixes the bug that currently we don't ever close webdriver client connection socket when header "Connection: keep-alive" is specified. This allows to run more WPT tests without running out of free file descriptors :)
2023-06-19 16:16:10 +03:00
if (m_socket->is_eof()) {
die();
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
break;
LibWeb/WebDriver: Close client connection socket when EOF is reached Fixes the bug that currently we don't ever close webdriver client connection socket when header "Connection: keep-alive" is specified. This allows to run more WPT tests without running out of free file descriptors :)
2023-06-19 16:16:10 +03:00
}
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
}
LibWeb/WebDriver: Wait for more data to arrive if request is incomplete Currently significant portion of requests coming to WebDriver server fails with error while parsing json body because requests are parsed when they are not complete yet. This change solves this by waiting for more data to arrive if HTTP request parser found that there is not enough data yet to parse the whole request. In the future we would probably want to move this logic to LibHTTP because this problem is relevant for any HTTP server.
2023-03-23 03:14:17 +03:00
if (m_remaining_request.is_empty())
return {};
LibWeb: Defer handling of WebDriver endpoint invocations We can currently crash on WebDriver session shutdown when we receive a Delete Session command. This destroys the WebDriver client while we are inside the client's socket's on_ready_to_read callback. This is not allowed by AK::Function. To avoid this, we now only read data from the socket in the callback. We then defer handling the message to break out of the callback.
2024-10-27 14:57:00 -04:00
auto parsed_request = HTTP::HttpRequest::from_raw_request(m_remaining_request.string_view().bytes());
// If the request is not complete, we need to wait for more data to arrive.
if (parsed_request.is_error() && parsed_request.error() == HTTP::HttpRequest::ParseError::RequestIncomplete)
return {};
LibWeb/WebDriver: Wait for more data to arrive if request is incomplete Currently significant portion of requests coming to WebDriver server fails with error while parsing json body because requests are parsed when they are not complete yet. This change solves this by waiting for more data to arrive if HTTP request parser found that there is not enough data yet to parse the whole request. In the future we would probably want to move this logic to LibHTTP because this problem is relevant for any HTTP server.
2023-03-23 03:14:17 +03:00
m_remaining_request.clear();
LibWeb: Defer handling of WebDriver endpoint invocations We can currently crash on WebDriver session shutdown when we receive a Delete Session command. This destroys the WebDriver client while we are inside the client's socket's on_ready_to_read callback. This is not allowed by AK::Function. To avoid this, we now only read data from the socket in the callback. We then defer handling the message to break out of the callback.
2024-10-27 14:57:00 -04:00
auto request = parsed_request.release_value();
deferred_invoke([this, request = move(request)]() {
auto body = read_body_as_json(request);
if (body.is_error()) {
handle_error(request, body.release_error());
return;
}
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
LibWeb: Defer handling of WebDriver endpoint invocations We can currently crash on WebDriver session shutdown when we receive a Delete Session command. This destroys the WebDriver client while we are inside the client's socket's on_ready_to_read callback. This is not allowed by AK::Function. To avoid this, we now only read data from the socket in the callback. We then defer handling the message to break out of the callback.
2024-10-27 14:57:00 -04:00
if (auto result = handle_request(request, body.release_value()); result.is_error())
handle_error(request, result.release_error());
});
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
return {};
}
LibWeb: Defer handling of WebDriver endpoint invocations We can currently crash on WebDriver session shutdown when we receive a Delete Session command. This destroys the WebDriver client while we are inside the client's socket's on_ready_to_read callback. This is not allowed by AK::Function. To avoid this, we now only read data from the socket in the callback. We then defer handling the message to break out of the callback.
2024-10-27 14:57:00 -04:00
ErrorOr<JsonValue, Client::WrappedError> Client::read_body_as_json(HTTP::HttpRequest const& request)
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
{
// FIXME: If we received a multipart body here, this would fail badly.
// FIXME: Check the Content-Type is actually application/json.
size_t content_length = 0;
LibWeb: Defer handling of WebDriver endpoint invocations We can currently crash on WebDriver session shutdown when we receive a Delete Session command. This destroys the WebDriver client while we are inside the client's socket's on_ready_to_read callback. This is not allowed by AK::Function. To avoid this, we now only read data from the socket in the callback. We then defer handling the message to break out of the callback.
2024-10-27 14:57:00 -04:00
for (auto const& header : request.headers().headers()) {
Everywhere: Rename equals_ignoring_case => equals_ignoring_ascii_case Let's make it clear that these functions deal with ASCII case only.
2023-03-10 08:48:54 +01:00
if (header.name.equals_ignoring_ascii_case("Content-Length"sv)) {
Everywhere: Use to_number<T> instead of to_{int,uint,float,double} In a bunch of cases, this actually ends up simplifying the code as to_number will handle something such as: ``` Optional<I> opt; if constexpr (IsSigned<I>) opt = view.to_int<I>(); else opt = view.to_uint<I>(); ``` For us. The main goal here however is to have a single generic number conversion API between all of the String classes.
2023-12-23 15:59:14 +13:00
content_length = header.value.to_number<size_t>(TrimWhitespace::Yes).value_or(0);
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
break;
}
}
if (content_length == 0)
return JsonValue {};
LibWeb: Defer handling of WebDriver endpoint invocations We can currently crash on WebDriver session shutdown when we receive a Delete Session command. This destroys the WebDriver client while we are inside the client's socket's on_ready_to_read callback. This is not allowed by AK::Function. To avoid this, we now only read data from the socket in the callback. We then defer handling the message to break out of the callback.
2024-10-27 14:57:00 -04:00
JsonParser json_parser(request.body());
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
return TRY(json_parser.parse());
}
LibWeb: Defer handling of WebDriver endpoint invocations We can currently crash on WebDriver session shutdown when we receive a Delete Session command. This destroys the WebDriver client while we are inside the client's socket's on_ready_to_read callback. This is not allowed by AK::Function. To avoid this, we now only read data from the socket in the callback. We then defer handling the message to break out of the callback.
2024-10-27 14:57:00 -04:00
ErrorOr<void, Client::WrappedError> Client::handle_request(HTTP::HttpRequest const& request, JsonValue body)
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
{
if constexpr (WEBDRIVER_DEBUG) {
LibWeb: Defer handling of WebDriver endpoint invocations We can currently crash on WebDriver session shutdown when we receive a Delete Session command. This destroys the WebDriver client while we are inside the client's socket's on_ready_to_read callback. This is not allowed by AK::Function. To avoid this, we now only read data from the socket in the callback. We then defer handling the message to break out of the callback.
2024-10-27 14:57:00 -04:00
dbgln("Got HTTP request: {} {}", request.method_name(), request.resource());
Everywhere: Add deprecated_ prefix to `JsonValue::to_byte_string` `JsonValue::to_byte_string` has peculiar type-erasure semantics which is not usually intended. Unfortunately, it also has a very stereotypical name which does not warn about unexpected behavior. So let's prefix it with `deprecated_` to make new code use `as_string` if it just wants to get string value or `serialized<StringBuilder>` if it needs to do proper serialization.
2024-01-06 15:49:17 -05:00
dbgln("Body: {}", body);
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
}
LibWeb: Defer handling of WebDriver endpoint invocations We can currently crash on WebDriver session shutdown when we receive a Delete Session command. This destroys the WebDriver client while we are inside the client's socket's on_ready_to_read callback. This is not allowed by AK::Function. To avoid this, we now only read data from the socket in the callback. We then defer handling the message to break out of the callback.
2024-10-27 14:57:00 -04:00
auto [handler, parameters] = TRY(match_route(request));
LibWeb+WebContent+WebDriver: Port WebDriver parameters to String This changes the parameters parsed from a WebDriver HTTP request to String for transferring over IPC. Conveniently, most locations these were ultimately passed to only need a StringView.
2023-03-05 15:31:49 -05:00
auto result = TRY((*handler)(*this, move(parameters), move(body)));
LibWeb: Defer handling of WebDriver endpoint invocations We can currently crash on WebDriver session shutdown when we receive a Delete Session command. This destroys the WebDriver client while we are inside the client's socket's on_ready_to_read callback. This is not allowed by AK::Function. To avoid this, we now only read data from the socket in the callback. We then defer handling the message to break out of the callback.
2024-10-27 14:57:00 -04:00
return send_success_response(request, move(result));
}
void Client::handle_error(HTTP::HttpRequest const& request, WrappedError const& error)
{
error.visit(
[](AK::Error const& error) {
warnln("Internal error: {}", error);
},
[](HTTP::HttpRequest::ParseError const& error) {
warnln("HTTP request parsing error: {}", HTTP::HttpRequest::parse_error_to_string(error));
},
[&](WebDriver::Error const& error) {
if (send_error_response(request, error).is_error())
warnln("Could not send error response");
});
die();
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
}
LibWeb: Defer handling of WebDriver endpoint invocations We can currently crash on WebDriver session shutdown when we receive a Delete Session command. This destroys the WebDriver client while we are inside the client's socket's on_ready_to_read callback. This is not allowed by AK::Function. To avoid this, we now only read data from the socket in the callback. We then defer handling the message to break out of the callback.
2024-10-27 14:57:00 -04:00
ErrorOr<void, Client::WrappedError> Client::send_success_response(HTTP::HttpRequest const& request, JsonValue result)
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
{
LibWeb: Add keep-alive in response headers if it present in request This fix addresses issue where, if request headers contain "Connection: keep-alive", we keep socket open without letting client know that we support keep-alive connections. This can result in a large number of open and unused sockets.
2023-03-20 02:26:07 +03:00
bool keep_alive = false;
LibWeb: Defer handling of WebDriver endpoint invocations We can currently crash on WebDriver session shutdown when we receive a Delete Session command. This destroys the WebDriver client while we are inside the client's socket's on_ready_to_read callback. This is not allowed by AK::Function. To avoid this, we now only read data from the socket in the callback. We then defer handling the message to break out of the callback.
2024-10-27 14:57:00 -04:00
if (auto it = request.headers().headers().find_if([](auto& header) { return header.name.equals_ignoring_ascii_case("Connection"sv); }); !it.is_end())
LibWeb: Add keep-alive in response headers if it present in request This fix addresses issue where, if request headers contain "Connection: keep-alive", we keep socket open without letting client know that we support keep-alive connections. This can result in a large number of open and unused sockets.
2023-03-20 02:26:07 +03:00
keep_alive = it->value.trim_whitespace().equals_ignoring_ascii_case("keep-alive"sv);
LibWeb+WebContentr+WebDriver: Move driver response wrapping to LibWeb Success responses are meant to be wrapped in a JSON object with a single "value" key. Instead of doing this in both WebContent and WebDriver, do it once in LibWeb.
2022-11-13 00:52:44 -05:00
result = make_success_response(move(result));
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
auto content = result.serialized<StringBuilder>();
StringBuilder builder;
LibWeb: Ensure WebDriver response headers are exactly to spec We must send a Cache-Control header, which then also requires that we respond with an HTTP/1.1 response (the Pragma cache option is HTTP/1.0). We should also send the Content-Type header using the same casing as is written in the WebDriver spec (lowercase). Both of these are explicitly tested by WPT.
2024-09-26 16:16:36 -04:00
builder.append("HTTP/1.1 200 OK\r\n"sv);
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
builder.append("Server: WebDriver (SerenityOS)\r\n"sv);
builder.append("X-Frame-Options: SAMEORIGIN\r\n"sv);
builder.append("X-Content-Type-Options: nosniff\r\n"sv);
LibWeb: Add keep-alive in response headers if it present in request This fix addresses issue where, if request headers contain "Connection: keep-alive", we keep socket open without letting client know that we support keep-alive connections. This can result in a large number of open and unused sockets.
2023-03-20 02:26:07 +03:00
if (keep_alive)
builder.append("Connection: keep-alive\r\n"sv);
LibWeb: Ensure WebDriver response headers are exactly to spec We must send a Cache-Control header, which then also requires that we respond with an HTTP/1.1 response (the Pragma cache option is HTTP/1.0). We should also send the Content-Type header using the same casing as is written in the WebDriver spec (lowercase). Both of these are explicitly tested by WPT.
2024-09-26 16:16:36 -04:00
builder.append("Cache-Control: no-cache\r\n"sv);
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
builder.append("Content-Type: application/json; charset=utf-8\r\n"sv);
builder.appendff("Content-Length: {}\r\n", content.length());
builder.append("\r\n"sv);
WebDriver: Do not break WebDriver responses into multiple socket writes WPT uses Python's http.client.HTTPConnection to send/receive WebDriver messages. For some reason, on Linux, we see an ~0.04s delay between the WPT server receiving the WebDriver response headers and its body. There are tests which make north of 1100 of these requests, which adds up to ~44s. These connections are almost always going to be over localhost and able the be sent in a single write. So let's send the response all at once. On my Linux machine, this reduces the runtime of /cookies/name/name.html from 45-60s down to 3-4s.
2024-09-24 18:05:29 -04:00
builder.append(content);
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
WebDriver: Do not break WebDriver responses into multiple socket writes WPT uses Python's http.client.HTTPConnection to send/receive WebDriver messages. For some reason, on Linux, we see an ~0.04s delay between the WPT server receiving the WebDriver response headers and its body. There are tests which make north of 1100 of these requests, which adds up to ~44s. These connections are almost always going to be over localhost and able the be sent in a single write. So let's send the response all at once. On my Linux machine, this reduces the runtime of /cookies/name/name.html from 45-60s down to 3-4s.
2024-09-24 18:05:29 -04:00
TRY(m_socket->write_until_depleted(builder.string_view()));
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
if (!keep_alive)
die();
LibWeb: Defer handling of WebDriver endpoint invocations We can currently crash on WebDriver session shutdown when we receive a Delete Session command. This destroys the WebDriver client while we are inside the client's socket's on_ready_to_read callback. This is not allowed by AK::Function. To avoid this, we now only read data from the socket in the callback. We then defer handling the message to break out of the callback.
2024-10-27 14:57:00 -04:00
log_response(request, 200);
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
return {};
}
LibWeb: Defer handling of WebDriver endpoint invocations We can currently crash on WebDriver session shutdown when we receive a Delete Session command. This destroys the WebDriver client while we are inside the client's socket's on_ready_to_read callback. This is not allowed by AK::Function. To avoid this, we now only read data from the socket in the callback. We then defer handling the message to break out of the callback.
2024-10-27 14:57:00 -04:00
ErrorOr<void, Client::WrappedError> Client::send_error_response(HTTP::HttpRequest const& request, Error const& error)
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
{
// FIXME: Implement to spec.
dbgln_if(WEBDRIVER_DEBUG, "Sending error response: {} {}: {}", error.http_status, error.error, error.message);
auto reason = HTTP::HttpResponse::reason_phrase_for_code(error.http_status);
LibWeb/WebDriver: Ensure error responses are serialized correctly
2024-05-30 16:05:35 +01:00
JsonObject error_response;
error_response.set("error", error.error);
error_response.set("message", error.message);
error_response.set("stacktrace", "");
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
if (error.data.has_value())
LibWeb/WebDriver: Ensure error responses are serialized correctly
2024-05-30 16:05:35 +01:00
error_response.set("data", *error.data);
JsonObject result;
result.set("value", move(error_response));
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
LibWeb: Do not break WebDriver errors into multiple socket writes Very similar to commit e5877cda61eb53cd9c1eebbfaf3c35d084b2973c. By sending as much data as we can in a single write, we see a massive performance improvement on WPT tests that hammer WebDriver with errors. On my Linux machine, this reduces the runtime of: /webdriver/tests/classic/perform_actions/invalid.py from 45-60s down to 3-4s.
2024-09-26 20:57:39 -04:00
auto content = result.serialized<StringBuilder>();
StringBuilder builder;
builder.appendff("HTTP/1.1 {} {}\r\n", error.http_status, reason);
builder.append("Cache-Control: no-cache\r\n"sv);
builder.append("Content-Type: application/json; charset=utf-8\r\n"sv);
builder.appendff("Content-Length: {}\r\n", content.length());
builder.append("\r\n"sv);
builder.append(content);
TRY(m_socket->write_until_depleted(builder.string_view()));
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
LibWeb: Defer handling of WebDriver endpoint invocations We can currently crash on WebDriver session shutdown when we receive a Delete Session command. This destroys the WebDriver client while we are inside the client's socket's on_ready_to_read callback. This is not allowed by AK::Function. To avoid this, we now only read data from the socket in the callback. We then defer handling the message to break out of the callback.
2024-10-27 14:57:00 -04:00
log_response(request, error.http_status);
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
return {};
}
LibWeb: Defer handling of WebDriver endpoint invocations We can currently crash on WebDriver session shutdown when we receive a Delete Session command. This destroys the WebDriver client while we are inside the client's socket's on_ready_to_read callback. This is not allowed by AK::Function. To avoid this, we now only read data from the socket in the callback. We then defer handling the message to break out of the callback.
2024-10-27 14:57:00 -04:00
void Client::log_response(HTTP::HttpRequest const& request, unsigned code)
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
{
LibWeb: Defer handling of WebDriver endpoint invocations We can currently crash on WebDriver session shutdown when we receive a Delete Session command. This destroys the WebDriver client while we are inside the client's socket's on_ready_to_read callback. This is not allowed by AK::Function. To avoid this, we now only read data from the socket in the callback. We then defer handling the message to break out of the callback.
2024-10-27 14:57:00 -04:00
outln("{} :: {:03d} :: {} {}", Core::DateTime::now().to_byte_string(), code, request.method_name(), request.resource());
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
}
}
Reference in a new issue Copy permalink