karm-http: Distinguish between the client and the transport.

Author: sleepy-monax

src/apps/vaev-browser/main/main.cpp

@@ -13,10 +13,8 @@ Async::Task<> entryPointAsync(Sys::Context& ctx) {
                    ? Mime::parseUrlOrPath(args[0], co_try$(Sys::pwd()))
                    : "about:start"_url;
     Gc::Heap heap;
-    auto client = Http::fallbackClient({
-        Http::simpleClient(),
-        Http::localClient(),
-    });
+    auto client = Http::defaultClient();
+    client->userAgent = "Vaev-Browser/" stringify$(__ck_version_value) ""s;
 
     auto dom = co_await Vaev::Driver::fetchDocumentAsync(heap, *client, url);
 

src/clis/http-get/main.cpp

@@ -19,11 +19,7 @@ Async::Task<> entryPointAsync(Sys::Context& ctx) {
     co_trya$(cmd.execAsync(ctx));
 
     auto url = Mime::parseUrlOrPath(urlArg, co_try$(Sys::pwd()));
-    auto client = Http::fallbackClient({
-        Http::simpleClient(),
-        Http::localClient(),
-    });
-    auto resp = co_trya$(client->getAsync(url));
+    auto resp = co_trya$(Http::getAsync(url));
     if (not resp->body)
         co_return Error::invalidData("no body in response");
 

src/clis/http-head/main.cpp

@@ -19,11 +19,7 @@ Async::Task<> entryPointAsync(Sys::Context& ctx) {
     co_trya$(cmd.execAsync(ctx));
 
     auto url = Mime::parseUrlOrPath(urlArg, co_try$(Sys::pwd()));
-    auto client = Http::fallbackClient({
-        Http::simpleClient(),
-        Http::localClient(),
-    });
-    auto header = co_trya$(client->headAsync(url))->header;
+    auto header = co_trya$(Http::headAsync(url))->header;
     co_try$(header.unparse(Sys::out()));
 
     co_return Ok();

src/libs/karm-http/client.cpp

@@ -4,23 +4,26 @@ module;
 #include <karm-base/rc.h>
 #include <karm-logger/logger.h>
 #include <karm-mime/url.h>
-#include <karm-sys/chan.h>
-#include <karm-sys/file.h>
-#include <karm-sys/lookup.h>
-#include <karm-sys/socket.h>
 
 export module Karm.Http:client;
 
-import Karm.Aio;
-import :request;
-import :response;
+import :transport;
 
 namespace Karm::Http {
 
-export struct Client {
-    virtual ~Client() = default;
+export struct Client : public Transport {
+    String userAgent = "Karm-Http/" stringify$(__ck_version_value) ""s;
+    Rc<Transport> transport;
 
-    virtual Async::Task<Rc<Response>> doAsync(Rc<Request> request) = 0;
+    Client(Rc<Transport> transport)
+        : transport(std::move(transport)) {}
+
+    Async::Task<Rc<Response>> doAsync(Rc<Request> request) override {
+        request->header.add("User-Agent", userAgent);
+        auto resp = co_trya$(transport->doAsync(request));
+        logInfo("\"{} {}\" {} {}", request->method, request->url, toUnderlyingType(resp->code), resp->code);
+        co_return Ok(resp);
+    }
 
     Async::Task<Rc<Response>> getAsync(Mime::Url url) {
         auto req = makeRc<Request>();
@@ -54,173 +57,31 @@ export struct Client {
     }
 };
 
-// MARK: Simple Client ---------------------------------------------------------
-
-static constexpr usize BUF_SIZE = 4096;
-
-struct ContentBody : public Body {
-    Buf<Byte> _resumes;
-    usize _resumesPos = 0;
-    Sys::TcpConnection _conn;
-    usize _contentLength;
-
-    ContentBody(Bytes resumes, Sys::TcpConnection conn, usize contentLength)
-        : _resumes(resumes),
-          _conn(std::move(conn)),
-          _contentLength(contentLength - resumes.len()) {
-    }
-
-    Async::Task<usize> readAsync(MutBytes buf) override {
-        if (_resumesPos < _resumes.len()) {
-            usize n = min(buf.len(), _resumes.len() - _resumesPos);
-            copy(sub(_resumes, _resumesPos, n), buf);
-            _resumesPos += n;
-            co_return n;
-        }
-
-        if (_contentLength == 0) {
-            co_return 0;
-        }
-
-        usize n = min(buf.len(), _contentLength);
-        n = co_trya$(_conn.readAsync(mutSub(buf, 0, n)));
-        _contentLength -= n;
-        co_return n;
-    }
-};
-
-struct ChunkedBody : public Body {
-    Buf<Byte> _buf;
-    Sys::TcpConnection _conn;
-
-    ChunkedBody(Bytes resumes, Sys::TcpConnection conn)
-        : _buf(resumes), _conn(std::move(conn)) {}
-};
-
-struct SimpleClient : public Client {
-    Async::Task<> _sendRequest(Request& request, Sys::TcpConnection& conn) {
-        Io::StringWriter req;
-        co_try$(request.unparse(req));
-        co_trya$(conn.writeAsync(req.bytes()));
-
-        if (auto body = request.body)
-            co_trya$(Aio::copyAsync(**body, conn));
-
-        co_return Ok();
-    }
-
-    Async::Task<Rc<Response>> _recvResponse(Sys::TcpConnection& conn) {
-        Array<u8, BUF_SIZE> buf = {};
-        Io::BufReader reader = sub(buf, 0, co_trya$(conn.readAsync(buf)));
-        auto response = co_try$(Response::read(reader));
-
-        if (auto contentLength = response.header.contentLength()) {
-            response.body = makeRc<ContentBody>(reader.bytes(), std::move(conn), contentLength.unwrap());
-        } else if (auto transferEncoding = response.header.tryGet("Transfer-Encoding"s)) {
-            logWarn("Transfer-Encoding: {} not supported", transferEncoding);
-        } else {
-            // NOTE: When there is no content length, and no transfer encoding,
-            //       we read until the server closes the socket.
-            response.body = makeRc<ContentBody>(reader.bytes(), std::move(conn), Limits<usize>::MAX);
-        }
-
-        co_return Ok(makeRc<Response>(std::move(response)));
-    }
-
-    Async::Task<Rc<Response>> doAsync(Rc<Request> request) override {
-        auto& url = request->url;
-        if (url.scheme != "http")
-            co_return Error::invalidInput("unsupported scheme");
-
-        logDebug("{} {}", request->method, url);
-
-        auto ips = co_trya$(Sys::lookupAsync(url.host));
-        auto port = url.port.unwrapOr(80);
-        Sys::SocketAddr addr{first(ips), (u16)port};
-        auto conn = co_try$(Sys::TcpConnection::connect(addr));
-        co_trya$(_sendRequest(*request, conn));
-        co_return co_trya$(_recvResponse(conn));
-    }
-};
-
-export Rc<Client> simpleClient() {
-    return makeRc<SimpleClient>();
-}
-
-// MARK: Local -----------------------------------------------------------------
-
-struct LocalClient : public Client {
-    Res<Rc<Body>> _load(Mime::Url url) {
-        if (try$(Sys::isFile(url)))
-            return Ok(Body::from(try$(Sys::File::open(url))));
-
-        auto dir = try$(Sys::Dir::open(url));
-        Io::StringWriter sw;
-        Io::Emit e{sw};
-        e("<html><body><h1>Index of {}</h1><ul>", url.path);
-        for (auto& diren : dir.entries()) {
-            if (diren.hidden())
-                continue;
-            e("<li><a href=\"{}\">{}</a></li>", url.join(diren.name), diren.name);
-        }
-        e("</ul></body></html>");
-        return Ok(Body::from(sw.take()));
-    }
-
-    Async::Task<Rc<Response>> doAsync(Rc<Request> request) override {
-        auto response = makeRc<Response>();
-
-        response->code = Code::OK;
-
-        if (request->method == Method::GET)
-            response->body = co_try$(_load(request->url));
-
-        co_return Ok(response);
-    }
-};
-
-export Rc<Client> localClient() {
-    return makeRc<LocalClient>();
-}
-
-// MARK: Fallback --------------------------------------------------------------
-
-struct FallbackClient : public Client {
-    Vec<Rc<Client>> _clients;
-
-    FallbackClient(Vec<Rc<Client>> clients) : _clients(std::move(clients)) {}
-
-    Async::Task<Rc<Response>> doAsync(Rc<Request> request) override {
-        for (auto& client : _clients) {
-            auto res = co_await client->doAsync(request);
-            if (res)
-                co_return res.unwrap();
-        }
-
-        co_return Error::notFound("no client could handle the request");
-    }
-};
+// MARK: Clientless ------------------------------------------------------------
 
-export Rc<Client> fallbackClient(Vec<Rc<Client>> clients) {
-    return makeRc<FallbackClient>(std::move(clients));
+export Rc<Client> defaultClient() {
+    return makeRc<Client>(
+        multiplexTransport({
+            httpTransport(),
+            localTransport(),
+        })
+    );
 }
 
-// MARK: Clientless ------------------------------------------------------------
-
 export Async::Task<Rc<Response>> getAsync(Mime::Url url) {
-    return simpleClient()->getAsync(url);
+    return defaultClient()->getAsync(url);
 }
 
 export Async::Task<Rc<Response>> headAsync(Mime::Url url) {
-    return simpleClient()->headAsync(url);
+    return defaultClient()->headAsync(url);
 }
 
 export Async::Task<Rc<Response>> postAsync(Mime::Url url, Rc<Body> body) {
-    return simpleClient()->postAsync(url, body);
+    return defaultClient()->postAsync(url, body);
 }
 
 export Async::Task<Rc<Response>> doAsync(Rc<Request> request) {
-    return simpleClient()->doAsync(request);
+    return defaultClient()->doAsync(request);
 }
 
 } // namespace Karm::Http

src/libs/karm-http/mod.cpp

@@ -8,3 +8,4 @@ export import :method;
 export import :request;
 export import :response;
 export import :server;
+export import :transport;