mirror of
https://github.com/RGBCube/serenity
synced 2025-05-31 12:38:12 +00:00
3ec39fc62e
This will allow LibWeb (and other components) to request a connection to be premade and cached, to make subsequent loads faster.
112 lines
3.4 KiB
C++
112 lines
3.4 KiB
C++
/*
|
|
* Copyright (c) 2021, Ali Mohammad Pur <mpfard@serenityos.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <AK/HashMap.h>
|
|
#include <AK/URL.h>
|
|
#include <AK/Vector.h>
|
|
#include <LibCore/TCPSocket.h>
|
|
#include <LibCore/Timer.h>
|
|
#include <LibTLS/TLSv12.h>
|
|
|
|
namespace RequestServer {
|
|
|
|
enum class CacheLevel {
|
|
ResolveOnly,
|
|
CreateConnection,
|
|
};
|
|
|
|
}
|
|
|
|
namespace RequestServer::ConnectionCache {
|
|
|
|
template<typename Socket>
|
|
struct Connection {
|
|
using QueueType = Vector<Function<void(Core::Socket&)>>;
|
|
using SocketType = Socket;
|
|
|
|
NonnullRefPtr<Socket> socket;
|
|
QueueType request_queue;
|
|
NonnullRefPtr<Core::Timer> removal_timer;
|
|
bool has_started { false };
|
|
};
|
|
|
|
struct ConnectionKey {
|
|
String hostname;
|
|
u16 port { 0 };
|
|
|
|
bool operator==(ConnectionKey const&) const = default;
|
|
};
|
|
|
|
};
|
|
|
|
template<>
|
|
struct AK::Traits<RequestServer::ConnectionCache::ConnectionKey> : public AK::GenericTraits<RequestServer::ConnectionCache::ConnectionKey> {
|
|
static u32 hash(RequestServer::ConnectionCache::ConnectionKey const& key)
|
|
{
|
|
return pair_int_hash(key.hostname.hash(), key.port);
|
|
}
|
|
};
|
|
|
|
namespace RequestServer::ConnectionCache {
|
|
|
|
extern HashMap<ConnectionKey, Vector<Connection<Core::TCPSocket>>> g_tcp_connection_cache;
|
|
extern HashMap<ConnectionKey, Vector<Connection<TLS::TLSv12>>> g_tls_connection_cache;
|
|
|
|
void request_did_finish(URL const&, Core::Socket const*);
|
|
|
|
constexpr static inline size_t MaxConcurrentConnectionsPerURL = 2;
|
|
constexpr static inline size_t ConnectionKeepAliveTimeMilliseconds = 10'000;
|
|
|
|
decltype(auto) get_or_create_connection(auto& cache, URL const& url, auto& job)
|
|
{
|
|
auto start_job = [&job](auto& socket) {
|
|
job.start(socket);
|
|
};
|
|
auto& sockets_for_url = cache.ensure({ url.host(), url.port_or_default() });
|
|
auto it = sockets_for_url.find_if([](auto& connection) { return connection.request_queue.is_empty(); });
|
|
auto did_add_new_connection = false;
|
|
if (it.is_end() && sockets_for_url.size() < ConnectionCache::MaxConcurrentConnectionsPerURL) {
|
|
sockets_for_url.append({
|
|
RemoveCVReference<decltype(cache.begin()->value.at(0))>::SocketType::construct(nullptr),
|
|
{},
|
|
Core::Timer::create_single_shot(ConnectionKeepAliveTimeMilliseconds, nullptr),
|
|
});
|
|
did_add_new_connection = true;
|
|
}
|
|
size_t index;
|
|
if (it.is_end()) {
|
|
if (did_add_new_connection) {
|
|
index = sockets_for_url.size() - 1;
|
|
} else {
|
|
// Find the least backed-up connection (based on how many entries are in their request queue.
|
|
index = 0;
|
|
auto min_queue_size = (size_t)-1;
|
|
for (auto it = sockets_for_url.begin(); it != sockets_for_url.end(); ++it) {
|
|
if (auto queue_size = it->request_queue.size(); min_queue_size > queue_size) {
|
|
index = it.index();
|
|
min_queue_size = queue_size;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
index = it.index();
|
|
}
|
|
auto& connection = sockets_for_url[index];
|
|
if (!connection.has_started) {
|
|
dbgln("Immediately start request for url {} in {}", url, &connection);
|
|
connection.has_started = true;
|
|
connection.removal_timer->stop();
|
|
start_job(*connection.socket);
|
|
} else {
|
|
dbgln("Enqueue request for URL {} in {}", url, &connection);
|
|
connection.request_queue.append(move(start_job));
|
|
}
|
|
return connection;
|
|
}
|
|
|
|
}
|