@readymadeit/mcp 0.0.0-stage → 0.1.0

package/bundle/hkp-rt/lib/src/services/http_server/http_stream_listener.cpp

@@ -0,0 +1,270 @@
+#include "./http_stream_listener.h"
+
+#include <charconv>
+#include <cmath>
+#include <limits>
+#include <string_view>
+
+#include <boost/asio.hpp>
+#include <boost/beast.hpp>
+
+#include "./http_session.h"
+
+namespace net = boost::asio;
+using tcp = net::ip::tcp;
+
+namespace hkp {
+
+namespace {
+
+// What the kernel may hold for one listener on top of its queue. Kept small:
+// audio sitting in a socket buffer is audio the listener hears late, and only
+// what is still in the queue can be dropped to bring it back to the live edge.
+// About a second at 128 kbit/s.
+constexpr int kSendBufferBytes = 16 * 1024;
+
+} // namespace
+
+HttpStreamListener::HttpStreamListener(std::shared_ptr<Session> session, std::size_t maxQueueBytes,
+                                       std::chrono::milliseconds stallTimeout,
+                                       std::function<void(HttpStreamListener*)> onClosed)
+  : m_session(std::move(session))
+  , m_queue(maxQueueBytes)
+  , m_onClosed(std::move(onClosed))
+  , m_stallTimeout(stallTimeout)
+{
+}
+
+void HttpStreamListener::start(const std::string& contentType)
+{
+  auto& stream = m_session->tcpStream();
+  // The request's read timeout must not end a response that is meant to last.
+  stream.expires_never();
+  // Chunks are small and due now; waiting to fill a segment only adds latency.
+  boost::system::error_code ec;
+  stream.socket().set_option(tcp::no_delay(true), ec);
+  stream.socket().set_option(net::socket_base::send_buffer_size(kSendBufferBytes), ec);
+
+  m_connectedAt = std::chrono::steady_clock::now();
+  const auto remote = stream.socket().remote_endpoint(ec);
+  if (!ec)
+  {
+    m_address = remote.address().to_string() + ":" + std::to_string(remote.port());
+  }
+  m_userAgent = m_session->getRequestHeader("user-agent");
+  m_range = m_session->getRequestHeader("range");
+
+  m_head = "HTTP/1.1 200 OK\r\n"
+           "Content-Type: " + contentType + "\r\n"
+           "Cache-Control: no-cache, no-store\r\n"
+           "Access-Control-Allow-Origin: *\r\n"
+           "Connection: close\r\n"
+           "\r\n";
+  pump();
+  watchForHangUp();
+}
+
+void HttpStreamListener::deliver(const StreamChunk& chunk)
+{
+  net::post(m_session->tcpStream().get_executor(), [self = shared_from_this(), chunk]() {
+    if (self->m_closed)
+    {
+      return;
+    }
+    // Checked as chunks arrive, which is exactly when a stalled listener
+    // matters: a stream that has stopped strands nobody.
+    const bool writing = self->m_headWriting || self->m_queue.writing();
+    if (writing && std::chrono::steady_clock::now() - self->m_writeStartedAt > self->m_stallTimeout)
+    {
+      return self->finish();
+    }
+    self->m_dropped += self->m_queue.push(chunk);
+    self->pump();
+  });
+}
+
+void HttpStreamListener::pump()
+{
+  if (m_closed)
+  {
+    return;
+  }
+  auto& socket = m_session->tcpStream().socket();
+
+  if (!m_headSent)
+  {
+    if (m_headWriting)
+    {
+      return;
+    }
+    m_headWriting = true;
+    m_writeStartedAt = std::chrono::steady_clock::now();
+    net::async_write(socket, net::buffer(m_head),
+      [self = shared_from_this()](const boost::system::error_code& ec, std::size_t) {
+        self->m_headWriting = false;
+        if (ec)
+        {
+          return self->finish();
+        }
+        self->m_headSent = true;
+        self->pump();
+      });
+    return;
+  }
+
+  auto chunk = m_queue.beginWrite();
+  if (!chunk)
+  {
+    return;
+  }
+  // The handler holds the chunk, so the bytes outlive the write even if the
+  // queue drops it meanwhile.
+  m_writeStartedAt = std::chrono::steady_clock::now();
+  net::async_write(socket, net::buffer(*chunk),
+    [self = shared_from_this(), chunk](const boost::system::error_code& ec, std::size_t written) {
+      self->m_queue.endWrite();
+      if (ec)
+      {
+        return self->finish();
+      }
+      self->m_bytesSent += written;
+      self->pump();
+    });
+}
+
+nlohmann::json HttpStreamListener::describe() const
+{
+  const auto connected = std::chrono::duration<double>(std::chrono::steady_clock::now() - m_connectedAt);
+  nlohmann::json description = {
+    {"address", m_address},
+    {"userAgent", m_userAgent},
+    {"seconds", std::round(connected.count() * 10.0) / 10.0},
+    {"bytesSent", m_bytesSent.load()},
+    {"droppedChunks", m_dropped.load()},
+  };
+  if (!m_range.empty())
+  {
+    description["range"] = m_range;
+  }
+  return description;
+}
+
+void HttpStreamListener::watchForHangUp()
+{
+  // A listener sends nothing after its request, so the only thing a read can
+  // finish with is the caller going away — which then shows at once, rather
+  // than at the next write.
+  m_session->tcpStream().socket().async_read_some(net::buffer(m_readBuffer),
+    [self = shared_from_this()](const boost::system::error_code& ec, std::size_t) {
+      if (ec)
+      {
+        return self->finish();
+      }
+      self->watchForHangUp();
+    });
+}
+
+void HttpStreamListener::finish()
+{
+  if (m_closed)
+  {
+    return;
+  }
+  m_closed = true;
+  boost::system::error_code ec;
+  m_session->tcpStream().socket().close(ec);
+  if (auto onClosed = std::move(m_onClosed))
+  {
+    onClosed(this);
+  }
+}
+
+void HttpStreamListener::close()
+{
+  // Reached from StreamBroadcast::closeAll once the listener has left, from
+  // whichever thread ended the stream. While the server runs, closing belongs
+  // on the connection's strand like everything else; once its thread has
+  // stopped nothing runs there, and a posted close would wait for a restart
+  // that may never come, so the socket is closed here.
+  const auto executor = m_session->tcpStream().get_executor();
+  auto& context = static_cast<net::io_context&>(net::query(executor, net::execution::context));
+  if (!context.stopped())
+  {
+    net::post(executor, [self = shared_from_this()]() {
+      self->m_onClosed = nullptr;
+      self->finish();
+    });
+    return;
+  }
+  m_closed = true;
+  m_onClosed = nullptr;
+  boost::system::error_code ec;
+  m_session->tcpStream().socket().close(ec);
+}
+
+std::optional<std::pair<std::uint64_t, std::uint64_t>> boundedRange(const std::string& header)
+{
+  constexpr std::string_view prefix = "bytes=";
+  if (header.rfind(prefix, 0) != 0)
+  {
+    return std::nullopt;
+  }
+  const auto spec = header.substr(prefix.size());
+  const auto dash = spec.find('-');
+  if (dash == std::string::npos || dash == 0 || dash + 1 >= spec.size()
+      || spec.find_first_not_of("0123456789-") != std::string::npos
+      || spec.find('-', dash + 1) != std::string::npos)
+  {
+    return std::nullopt;
+  }
+  // A number too large to hold is not a range that can be answered, and is
+  // treated like any other malformed one.
+  const auto parse = [&spec](std::size_t from, std::size_t to) -> std::optional<std::uint64_t> {
+    std::uint64_t value = 0;
+    const char* begin = spec.data() + from;
+    const char* end = spec.data() + to;
+    const auto result = std::from_chars(begin, end, value);
+    if (result.ec != std::errc{} || result.ptr != end)
+    {
+      return std::nullopt;
+    }
+    return value;
+  };
+  const auto first = parse(0, dash);
+  const auto last = parse(dash + 1, spec.size());
+  // A span covering the whole 64-bit space has a length that cannot be held
+  // either.
+  if (!first || !last || *last < *first
+      || *last - *first == std::numeric_limits<std::uint64_t>::max())
+  {
+    return std::nullopt;
+  }
+  return std::make_pair(*first, *last);
+}
+
+void answerRangeProbe(const std::shared_ptr<Session>& session, const std::string& contentType,
+                      std::uint64_t first, std::uint64_t last, const std::vector<uint8_t>& sample)
+{
+  const auto length = std::min<std::uint64_t>(last - first + 1, sample.size());
+  auto response = std::make_shared<std::string>(
+    "HTTP/1.1 206 Partial Content\r\n"
+    "Content-Type: " + contentType + "\r\n"
+    "Content-Range: bytes " + std::to_string(first) + "-" + std::to_string(first + length - 1) + "/*\r\n"
+    "Content-Length: " + std::to_string(length) + "\r\n"
+    "Cache-Control: no-cache, no-store\r\n"
+    "Access-Control-Allow-Origin: *\r\n"
+    "Connection: close\r\n"
+    "\r\n");
+  response->append(reinterpret_cast<const char*>(sample.data()), length);
+
+  auto& socket = session->tcpStream().socket();
+  session->tcpStream().expires_never();
+  net::async_write(socket, net::buffer(*response),
+    [session, response](const boost::system::error_code&, std::size_t) {
+      boost::system::error_code ec;
+      session->tcpStream().socket().shutdown(tcp::socket::shutdown_both, ec);
+      session->tcpStream().socket().close(ec);
+    });
+}
+
+} // namespace hkp

package/bundle/hkp-rt/lib/src/services/http_server/http_stream_listener.h

@@ -0,0 +1,104 @@
+#pragma once
+
+#include <array>
+#include <atomic>
+#include <chrono>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <nlohmann/json.hpp>
+
+#include "../../common/stream_broadcast.h"
+
+namespace hkp {
+
+class Session;
+
+// Answers a bounded Range request on a live stream — WebKit asks for
+// `bytes=0-1` before it plays anything, to learn what the resource is — with
+// that many bytes from the start of `sample`, and closes. A live stream has no
+// byte 0 to return, so this is an answer to the question being asked (what
+// does it start with, and are ranges understood) rather than a position; the
+// total length is given as unknown. Answered with the endless stream instead,
+// the probe stays open for as long as the player does and counts as a second
+// listener.
+void answerRangeProbe(const std::shared_ptr<Session>& session, const std::string& contentType,
+                      std::uint64_t first, std::uint64_t last, const std::vector<uint8_t>& sample);
+
+// The bounds of a `bytes=first-last` Range header, or nothing where it is
+// absent, open-ended or not of that form.
+std::optional<std::pair<std::uint64_t, std::uint64_t>> boundedRange(const std::string& header);
+
+// One caller listening to an endpoint's stream.
+//
+// Takes over the caller's connection once its request has been read: sends a
+// response head with no length, then every chunk it is handed, for as long as
+// the caller stays connected. `Connection: close` rather than chunked encoding,
+// so the body is just the stream and ends when the connection does — which is
+// what every player, however old, understands.
+//
+// Everything that touches the connection runs on its strand, and every write is
+// asynchronous: deliver() only queues, so the thread publishing the stream is
+// never held up by a listener. What a listener cannot take fast enough is
+// dropped from its own queue (see ChunkQueue), never from anyone else's.
+//
+// A caller that stops reading without hanging up — a paused player, a request
+// a browser parked rather than closed — is not listening, however long its
+// connection stays open. Once a write has been waiting longer than the stall
+// timeout the listener is let go, so the count says who is actually hearing
+// the stream.
+class HttpStreamListener : public StreamListener,
+                           public std::enable_shared_from_this<HttpStreamListener>
+{
+public:
+  // `onClosed` runs once, on the connection's strand, when the stream ends for
+  // any reason — the caller hanging up, a failed write, close().
+  HttpStreamListener(std::shared_ptr<Session> session, std::size_t maxQueueBytes,
+                     std::chrono::milliseconds stallTimeout,
+                     std::function<void(HttpStreamListener*)> onClosed);
+
+  // Sends the response head. Call on the connection's strand, before the
+  // listener joins a broadcast.
+  void start(const std::string& contentType);
+
+  void deliver(const StreamChunk& chunk) override;
+  // Safe from any thread.
+  void close() override;
+
+  // How many chunks this listener missed because it fell behind.
+  std::size_t droppedChunks() const { return m_dropped; }
+
+  // Who this is and how it is doing, for the endpoint's state. Safe from any
+  // thread: what it reads is either fixed at start() or atomic.
+  nlohmann::json describe() const;
+
+private:
+  void pump();
+  void watchForHangUp();
+  void finish();
+
+  std::shared_ptr<Session> m_session;
+  ChunkQueue m_queue;
+  std::function<void(HttpStreamListener*)> m_onClosed;
+  std::string m_head;
+  bool m_headSent = false;
+  bool m_headWriting = false;
+  bool m_closed = false;
+  std::chrono::milliseconds m_stallTimeout;
+  // When the write in progress began; meaningful only while one is.
+  std::chrono::steady_clock::time_point m_writeStartedAt;
+  std::atomic<std::size_t> m_dropped{0};
+  std::atomic<std::uint64_t> m_bytesSent{0};
+  // Fixed at start(), before the listener joins anything.
+  std::string m_address;
+  std::string m_userAgent;
+  std::string m_range;
+  std::chrono::steady_clock::time_point m_connectedAt;
+  std::array<char, 256> m_readBuffer{};
+};
+
+} // namespace hkp

package/bundle/hkp-rt/lib/src/services/http_server/request_decode.h

@@ -0,0 +1,164 @@
+#pragma once
+
+#include <algorithm>
+#include <cctype>
+#include <optional>
+#include <string>
+
+#include <types/types.h>
+
+/**
+ * Turning an incoming HTTP request into pipeline data.
+ *
+ * Shared by the http-server services so both describe a request the same way:
+ * JSON `meta` plus the body in whichever single form is useful — decoded when
+ * the content type says what the bytes mean, raw otherwise.
+ */
+namespace hkp::request_decode {
+
+/**
+ * A request presents itself as a file transfer when it names an attachment or
+ * carries the chunked-upload headers. That, not the content type, is what
+ * separates "store these bytes" from "here is a payload" — an uploaded .txt or
+ * .json arrives with a textual content type but is still a file.
+ */
+inline bool isFileTransfer(const std::string& contentDisposition,
+                           const std::string& uploadId)
+{
+  return contentDisposition.find("filename=") != std::string::npos || !uploadId.empty();
+}
+
+/** Extract the filename from a Content-Disposition value, e.g. "photo.jpg". */
+inline std::string extractFilename(const std::string& contentDisposition)
+{
+  std::string filename = "upload";
+  auto pos = contentDisposition.find("filename=");
+  if (pos != std::string::npos)
+  {
+    filename = contentDisposition.substr(pos + 9);
+    filename.erase(std::remove(filename.begin(), filename.end(), '"'),  filename.end());
+    filename.erase(std::remove(filename.begin(), filename.end(), '\''), filename.end());
+    filename.erase(0, filename.find_first_not_of(" \t"));
+    auto last = filename.find_last_not_of(" \t\r\n");
+    if (last != std::string::npos) filename.resize(last + 1);
+  }
+  return filename;
+}
+
+inline std::string toLower(std::string value)
+{
+  std::transform(value.begin(), value.end(), value.begin(),
+                 [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+  return value;
+}
+
+/** Content type with any parameters ("; charset=utf-8") stripped. */
+inline std::string mediaType(const std::string& contentType)
+{
+  auto semicolon = contentType.find(';');
+  auto bare = semicolon == std::string::npos ? contentType : contentType.substr(0, semicolon);
+  auto first = bare.find_first_not_of(" \t");
+  if (first == std::string::npos) return "";
+  auto last = bare.find_last_not_of(" \t");
+  return toLower(bare.substr(first, last - first + 1));
+}
+
+inline std::string urlDecode(const std::string& value)
+{
+  std::string out;
+  out.reserve(value.size());
+  for (std::size_t i = 0; i < value.size(); ++i)
+  {
+    if (value[i] == '+')
+    {
+      out.push_back(' ');
+    }
+    else if (value[i] == '%' && i + 2 < value.size())
+    {
+      try
+      {
+        out.push_back(static_cast<char>(std::stoi(value.substr(i + 1, 2), nullptr, 16)));
+        i += 2;
+      }
+      catch (const std::exception&)
+      {
+        out.push_back(value[i]); // not a valid escape — keep it verbatim
+      }
+    }
+    else
+    {
+      out.push_back(value[i]);
+    }
+  }
+  return out;
+}
+
+/** Parse "a=1&b=two" into a JSON object of decoded key/value pairs. */
+inline json parseQueryString(const std::string& query)
+{
+  auto fields = json::object();
+  std::size_t start = 0;
+  while (start < query.size())
+  {
+    auto end = query.find('&', start);
+    if (end == std::string::npos) end = query.size();
+    auto pair = query.substr(start, end - start);
+    if (!pair.empty())
+    {
+      auto eq = pair.find('=');
+      if (eq == std::string::npos)
+        fields[urlDecode(pair)] = "";
+      else
+        fields[urlDecode(pair.substr(0, eq))] = urlDecode(pair.substr(eq + 1));
+    }
+    start = end + 1;
+  }
+  return fields;
+}
+
+/** The request target arrives raw, so the query still has to be split off. */
+inline void splitTarget(const std::string& target, std::string& path, json& query)
+{
+  auto mark = target.find('?');
+  path  = mark == std::string::npos ? target : target.substr(0, mark);
+  query = mark == std::string::npos ? json::object()
+                                    : parseQueryString(target.substr(mark + 1));
+}
+
+/**
+ * Decode a body whose content type says what its bytes mean. Returns nullopt
+ * when the bytes should be left raw, which includes malformed input: a public
+ * endpoint takes whatever it is given, and failing the request would be worse
+ * than handing the pipeline the bytes to look at.
+ */
+inline std::optional<json> decodeBody(const std::string& body, const std::string& contentType)
+{
+  if (body.empty()) return std::nullopt;
+
+  const auto type = mediaType(contentType);
+  const auto endsWith = [](const std::string& s, const std::string& suffix) {
+    return s.size() >= suffix.size() &&
+           s.compare(s.size() - suffix.size(), suffix.size(), suffix) == 0;
+  };
+
+  if (type == "application/json" || endsWith(type, "+json"))
+  {
+    auto parsed = json::parse(body, nullptr, /*allow_exceptions=*/false);
+    if (parsed.is_discarded()) return std::nullopt;
+    return parsed;
+  }
+
+  if (type == "application/x-www-form-urlencoded")
+  {
+    return parseQueryString(body);
+  }
+
+  if (type.rfind("text/", 0) == 0)
+  {
+    return json(body);
+  }
+
+  return std::nullopt;
+}
+
+} // namespace hkp::request_decode