Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-19 15:43:20 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Services/RequestServer/ConnectionFromClient.h

80 lines
3.1 KiB
C
Raw Normal View History

Services: Rename ProtocolServer to RequestServer The current ProtocolServer was really only used for requests, and with the recent introduction of the WebSocket service, long-lasting connections with another server are not part of it. To better reflect this, this commit renames it to RequestServer. This commit also changes the existing 'protocol' portal to 'request', the existing 'protocol' user and group to 'request', and most mentions of the 'download' aspect of the request to 'request' when relevant, to make everything consistent across the system. Note that LibProtocol still exists as-is, but the more generic Client class and the more specific Download class have both been renamed to a more accurate RequestClient and Request to match the new names. This commit only change names, not behaviors.
2021-04-23 22:45:52 +02:00
/*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/HashMap.h>
RequestServer: Handle IPC requests on multiple threads concurrently Previously RS handled all the requests in an event loop, leading to issues with connections being started in the middle of other connections being started (and potentially blowing up the stack), ultimately causing requests to be delayed because of other requests. This commit reworks the way we handle these (specifically starting connections) by first serialising the requests, and then performing them in multiple threads concurrently; which yields a significant loading performance and reliability increase.
2024-05-08 20:15:05 +02:00
#include <LibCore/SharedCircularQueue.h>
Userland: Rename IPC ClientConnection => ConnectionFromClient This was done with CLion's automatic rename feature and with: find . -name ClientConnection.h | rename 's/ClientConnection\.h/ConnectionFromClient.h/' find . -name ClientConnection.cpp | rename 's/ClientConnection\.cpp/ConnectionFromClient.cpp/'
2022-02-25 12:18:30 +02:00
#include <LibIPC/ConnectionFromClient.h>
RequestServer: Handle IPC requests on multiple threads concurrently Previously RS handled all the requests in an event loop, leading to issues with connections being started in the middle of other connections being started (and potentially blowing up the stack), ultimately causing requests to be delayed because of other requests. This commit reworks the way we handle these (specifically starting connections) by first serialising the requests, and then performing them in multiple threads concurrently; which yields a significant loading performance and reliability increase.
2024-05-08 20:15:05 +02:00
#include <LibThreading/MutexProtected.h>
#include <LibThreading/ThreadPool.h>
Everywhere: Merge the WebSocket service into RequestServer This keeps the APIs separate as they are wildly different, a future improvement could be to somehow unify the APIs (if possible). Closes #23080.
2024-03-06 01:50:52 +01:00
#include <LibWebSocket/WebSocket.h>
Services: Rename ProtocolServer to RequestServer The current ProtocolServer was really only used for requests, and with the recent introduction of the WebSocket service, long-lasting connections with another server are not part of it. To better reflect this, this commit renames it to RequestServer. This commit also changes the existing 'protocol' portal to 'request', the existing 'protocol' user and group to 'request', and most mentions of the 'download' aspect of the request to 'request' when relevant, to make everything consistent across the system. Note that LibProtocol still exists as-is, but the more generic Client class and the more specific Download class have both been renamed to a more accurate RequestClient and Request to match the new names. This commit only change names, not behaviors.
2021-04-23 22:45:52 +02:00
#include <RequestServer/Forward.h>
#include <RequestServer/RequestClientEndpoint.h>
#include <RequestServer/RequestServerEndpoint.h>
namespace RequestServer {
Userland: Rename IPC ClientConnection => ConnectionFromClient This was done with CLion's automatic rename feature and with: find . -name ClientConnection.h | rename 's/ClientConnection\.h/ConnectionFromClient.h/' find . -name ClientConnection.cpp | rename 's/ClientConnection\.cpp/ConnectionFromClient.cpp/'
2022-02-25 12:18:30 +02:00
class ConnectionFromClient final
: public IPC::ConnectionFromClient<RequestClientEndpoint, RequestServerEndpoint> {
C_OBJECT(ConnectionFromClient);
Services: Rename ProtocolServer to RequestServer The current ProtocolServer was really only used for requests, and with the recent introduction of the WebSocket service, long-lasting connections with another server are not part of it. To better reflect this, this commit renames it to RequestServer. This commit also changes the existing 'protocol' portal to 'request', the existing 'protocol' user and group to 'request', and most mentions of the 'download' aspect of the request to 'request' when relevant, to make everything consistent across the system. Note that LibProtocol still exists as-is, but the more generic Client class and the more specific Download class have both been renamed to a more accurate RequestClient and Request to match the new names. This commit only change names, not behaviors.
2021-04-23 22:45:52 +02:00
public:
RequestServer+LibHTTP: Cancel requests on client exit That usually happens in "exceptional" states when the client exits unexpectedly (crash, force quit mid-load, etc), leading to the job flush timer firing and attempting to write to a nonexistent object (the client). This commit makes RS simply cancel such jobs; cancelled jobs in this state simply go away instead of sending notifications around.
2024-07-28 00:22:58 +02:00
~ConnectionFromClient() override;
Services: Rename ProtocolServer to RequestServer The current ProtocolServer was really only used for requests, and with the recent introduction of the WebSocket service, long-lasting connections with another server are not part of it. To better reflect this, this commit renames it to RequestServer. This commit also changes the existing 'protocol' portal to 'request', the existing 'protocol' user and group to 'request', and most mentions of the 'download' aspect of the request to 'request' when relevant, to make everything consistent across the system. Note that LibProtocol still exists as-is, but the more generic Client class and the more specific Download class have both been renamed to a more accurate RequestClient and Request to match the new names. This commit only change names, not behaviors.
2021-04-23 22:45:52 +02:00
virtual void die() override;
void did_receive_headers(Badge<Request>, Request&);
void did_finish_request(Badge<Request>, Request&, bool success);
void did_progress_request(Badge<Request>, Request&);
void did_request_certificates(Badge<Request>, Request&);
RequestServer: Handle IPC requests on multiple threads concurrently Previously RS handled all the requests in an event loop, leading to issues with connections being started in the middle of other connections being started (and potentially blowing up the stack), ultimately causing requests to be delayed because of other requests. This commit reworks the way we handle these (specifically starting connections) by first serialising the requests, and then performing them in multiple threads concurrently; which yields a significant loading performance and reliability increase.
2024-05-08 20:15:05 +02:00
struct StartRequest {
i32 request_id;
ByteString method;
URL::URL url;
LibHTTP+RequestServer: Use HTTP::HeaderMap for request headers No longer just for response headers! The same type is obviously useful and ergonomic when making requests as well.
2024-06-09 13:46:04 +02:00
HTTP::HeaderMap request_headers;
RequestServer: Handle IPC requests on multiple threads concurrently Previously RS handled all the requests in an event loop, leading to issues with connections being started in the middle of other connections being started (and potentially blowing up the stack), ultimately causing requests to be delayed because of other requests. This commit reworks the way we handle these (specifically starting connections) by first serialising the requests, and then performing them in multiple threads concurrently; which yields a significant loading performance and reliability increase.
2024-05-08 20:15:05 +02:00
ByteBuffer request_body;
Core::ProxyData proxy_data;
};
struct EnsureConnection {
URL::URL url;
CacheLevel cache_level;
};
using Work = Variant<StartRequest, EnsureConnection, Empty>;
void worker_do_work(Work);
RequestServer: Make the ThreadPool global Previously we made one thread pool per ipc client, which is excessive and can eat up all the available fds very fast. Fixes #760.
2024-07-22 22:52:21 +02:00
private:
explicit ConnectionFromClient(NonnullOwnPtr<Core::LocalSocket>);
virtual Messages::RequestServer::ConnectNewClientResponse connect_new_client() override;
virtual Messages::RequestServer::IsSupportedProtocolResponse is_supported_protocol(ByteString const&) override;
virtual void start_request(i32 request_id, ByteString const&, URL::URL const&, HTTP::HeaderMap const&, ByteBuffer const&, Core::ProxyData const&) override;
virtual Messages::RequestServer::StopRequestResponse stop_request(i32) override;
virtual Messages::RequestServer::SetCertificateResponse set_certificate(i32, ByteString const&, ByteString const&) override;
virtual void ensure_connection(URL::URL const& url, ::RequestServer::CacheLevel const& cache_level) override;
virtual Messages::RequestServer::WebsocketConnectResponse websocket_connect(URL::URL const&, ByteString const&, Vector<ByteString> const&, Vector<ByteString> const&, HTTP::HeaderMap const&) override;
virtual Messages::RequestServer::WebsocketReadyStateResponse websocket_ready_state(i32) override;
virtual Messages::RequestServer::WebsocketSubprotocolInUseResponse websocket_subprotocol_in_use(i32) override;
virtual void websocket_send(i32, bool, ByteBuffer const&) override;
virtual void websocket_close(i32, u16, ByteString const&) override;
virtual Messages::RequestServer::WebsocketSetCertificateResponse websocket_set_certificate(i32, ByteString const&, ByteString const&) override;
LibProtocol+RequestServer: Add IPC to dump RequestServer connection info This was available on Serenity by sending SIGINFO to RequestServer. Add an IPC so we may see this info while running the browser.
2024-08-03 13:24:56 -04:00
virtual void dump_connection_info() override;
RequestServer: Handle IPC requests on multiple threads concurrently Previously RS handled all the requests in an event loop, leading to issues with connections being started in the middle of other connections being started (and potentially blowing up the stack), ultimately causing requests to be delayed because of other requests. This commit reworks the way we handle these (specifically starting connections) by first serialising the requests, and then performing them in multiple threads concurrently; which yields a significant loading performance and reliability increase.
2024-05-08 20:15:05 +02:00
Threading::MutexProtected<HashMap<i32, OwnPtr<Request>>> m_requests;
Everywhere: Merge the WebSocket service into RequestServer This keeps the APIs separate as they are wildly different, a future improvement could be to somehow unify the APIs (if possible). Closes #23080.
2024-03-06 01:50:52 +01:00
HashMap<i32, RefPtr<WebSocket::WebSocket>> m_websockets;
RequestServer: Handle IPC requests on multiple threads concurrently Previously RS handled all the requests in an event loop, leading to issues with connections being started in the middle of other connections being started (and potentially blowing up the stack), ultimately causing requests to be delayed because of other requests. This commit reworks the way we handle these (specifically starting connections) by first serialising the requests, and then performing them in multiple threads concurrently; which yields a significant loading performance and reliability increase.
2024-05-08 20:15:05 +02:00
void enqueue(Work);
RequestServer: Serialise accesses to IPC::Connection Most of IPC::Connection is thread-safe, but the responsiveness timer is very much not so, this commit makes sure only one thread can send stuff through IPC to avoid having threads racing in IPC::Connection. This is simply less work than making sure everything IPC::Connection uses (now and later) is thread-safe.
2024-05-19 18:12:28 +02:00
Threading::Mutex m_ipc_mutex;
Services: Rename ProtocolServer to RequestServer The current ProtocolServer was really only used for requests, and with the recent introduction of the WebSocket service, long-lasting connections with another server are not part of it. To better reflect this, this commit renames it to RequestServer. This commit also changes the existing 'protocol' portal to 'request', the existing 'protocol' user and group to 'request', and most mentions of the 'download' aspect of the request to 'request' when relevant, to make everything consistent across the system. Note that LibProtocol still exists as-is, but the more generic Client class and the more specific Download class have both been renamed to a more accurate RequestClient and Request to match the new names. This commit only change names, not behaviors.
2021-04-23 22:45:52 +02:00
};
}
Reference in a new issue Copy permalink