RequestServer+LibHTTP+LibGemini: Cache connections to the same host

This makes connections (particularly TLS-based ones) do the handshaking
stuff only once.
Currently the cache is configured to keep at most two connections evenly
balanced in queue size, and with a grace period of 10s after the last
queued job has finished (after which the connection will be dropped).

Userland/Services/RequestServer/ConnectionCache.h

@@ -0,0 +1,103 @@
+/*
+ * 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::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;
+}
+
+}