opengris-scaler 1.12.7__cp313-cp313-musllinux_1_2_x86_64.whl

scaler/io/ymq/interruptive_concurrent_queue.h

@@ -0,0 +1,169 @@
+#pragma once
+
+#ifdef __linux__
+#include <sys/eventfd.h>
+#include <unistd.h>
+#endif  // __linux__
+#ifdef _WIN32
+// clang-format off
+#include <windows.h>
+#include <winsock2.h>
+// clang-format on
+#endif  // _WIN32
+
+// C++
+#include <cstdlib>
+#include <vector>
+
+#include "scaler/io/ymq/error.h"
+#include "third_party/concurrentqueue.h"
+
+namespace scaler {
+namespace ymq {
+
+class EventManager;
+
+#ifdef __linux__
+template <typename T>
+class InterruptiveConcurrentQueue {
+    int _eventFd;
+    moodycamel::ConcurrentQueue<T> _queue;
+
+public:
+    InterruptiveConcurrentQueue(): _queue()
+    {
+        _eventFd = eventfd(0, EFD_NONBLOCK);
+        if (_eventFd == -1) {
+            const int myErrno = errno;
+            switch (myErrno) {
+                case ENFILE:
+                case ENODEV:
+                case ENOMEM:
+                case EMFILE:
+                    unrecoverableError({
+                        Error::ErrorCode::ConfigurationError,
+                        "Originated from",
+                        "eventfd(2)",
+                        "Errno is",
+                        strerror(myErrno),
+                    });
+                    break;
+
+                case EINVAL:
+                default:
+                    unrecoverableError({
+                        Error::ErrorCode::CoreBug,
+                        "Originated from",
+                        "eventfd(2)",
+                        "Errno is",
+                        strerror(myErrno),
+                        "flags",
+                        "EFD_NONBLOCK",
+                    });
+                    break;
+            }
+        }
+    }
+
+    int eventFd() const { return _eventFd; }
+
+    void enqueue(T item)
+    {
+        _queue.enqueue(std::move(item));
+
+        uint64_t u = 1;
+        if (::eventfd_write(_eventFd, u) < 0) {
+            unrecoverableError({
+                Error::ErrorCode::CoreBug,
+                "Originated from",
+                "eventfd_write(2)",
+                "Errno is",
+                strerror(errno),
+            });
+        }
+    }
+
+    // NOTE: this method will block until an item is available
+    std::vector<T> dequeue()
+    {
+        uint64_t u {};
+        if (::eventfd_read(_eventFd, &u) < 0) {
+            if (errno == EAGAIN) {
+                return {};
+            }
+
+            unrecoverableError({
+                Error::ErrorCode::CoreBug,
+                "Originated from",
+                "eventfd_read(2)",
+                "Errno is",
+                strerror(errno),
+            });
+        }
+
+        std::vector<T> vecT(u);
+        for (auto i = 0uz; i < u; ++i) {
+            while (!_queue.try_dequeue(vecT[i]))
+                ;
+        }
+        return vecT;
+    }
+
+    // unmovable, uncopyable
+    InterruptiveConcurrentQueue(const InterruptiveConcurrentQueue&)            = delete;
+    InterruptiveConcurrentQueue& operator=(const InterruptiveConcurrentQueue&) = delete;
+    InterruptiveConcurrentQueue(InterruptiveConcurrentQueue&&)                 = delete;
+    InterruptiveConcurrentQueue& operator=(InterruptiveConcurrentQueue&&)      = delete;
+
+    ~InterruptiveConcurrentQueue() { close(_eventFd); }
+};
+#endif  // __linux__
+
+#ifdef _WIN32
+template <typename T>
+class InterruptiveConcurrentQueue {
+    HANDLE _completionPort;
+    const size_t _key;
+    moodycamel::ConcurrentQueue<T> _queue;
+
+public:
+    InterruptiveConcurrentQueue(HANDLE completionPort, size_t key): _queue(), _completionPort(completionPort), _key(key)
+    {
+    }
+
+    void enqueue(T item)
+    {
+        _queue.enqueue(std::move(item));
+        if (!PostQueuedCompletionStatus(_completionPort, 0, (ULONG_PTR)_key, nullptr)) {
+            unrecoverableError({
+                Error::ErrorCode::CoreBug,
+                "Originated from",
+                "PostQueuedCompletionStatus",
+                "Errno is",
+                GetLastError(),
+            });
+        }
+    }
+
+    // NOTE: this method will block until an item is available
+    // NOTE: On Windows, due to how the polling mechanism work, we can only do it 1 by 1.
+    // NOTE: On Windows, we don't have a guaranteed number of functions, unlike with eventfd.
+    std::vector<T> dequeue()
+    {
+        std::vector<T> vecT(1);
+        while (!_queue.try_dequeue(vecT[0]))
+            ;
+        return vecT;
+    }
+
+    // unmovable, uncopyable
+    InterruptiveConcurrentQueue(const InterruptiveConcurrentQueue&)            = delete;
+    InterruptiveConcurrentQueue& operator=(const InterruptiveConcurrentQueue&) = delete;
+    InterruptiveConcurrentQueue(InterruptiveConcurrentQueue&&)                 = delete;
+    InterruptiveConcurrentQueue& operator=(InterruptiveConcurrentQueue&&)      = delete;
+};
+
+#endif  // _WIN32
+
+}  // namespace ymq
+}  // namespace scaler

scaler/io/ymq/io_context.cpp

@@ -0,0 +1,98 @@
+
+#include "scaler/io/ymq/io_context.h"
+
+#include <algorithm>  // std::ranges::generate
+#include <cassert>    // assert
+#include <future>
+#include <memory>  // std::make_shared
+#ifdef _WIN32
+// clang-format off
+#include <winsock2.h>
+#include <mswsock.h>
+// clang-format on
+#endif  // _WIN32
+
+#include "scaler/io/ymq/event_loop_thread.h"
+#include "scaler/io/ymq/io_socket.h"
+#include "scaler/io/ymq/typedefs.h"
+
+namespace scaler {
+namespace ymq {
+
+IOContext::IOContext(size_t threadCount) noexcept: _threads(threadCount)
+{
+    assert(threadCount > 0);
+    std::ranges::generate(_threads, std::make_shared<EventLoopThread>);
+#ifdef _WIN32
+    WSADATA wsaData;
+    const int myErrno = WSAStartup(MAKEWORD(2, 2), &wsaData);
+    if (myErrno != 0) {
+        unrecoverableError({
+            Error::ErrorCode::ConfigurationError,
+            "Originated from",
+            "WSAStartup",
+            "Errno is",
+            strerror(myErrno),
+        });
+    }
+#endif  // _WIN32
+}
+
+void IOContext::createIOSocket(
+    Identity identity, IOSocketType socketType, CreateIOSocketCallback onIOSocketCreated) & noexcept
+{
+    static std::atomic<size_t> threadsRoundRobin = 0;
+    auto& thread                                 = _threads[threadsRoundRobin];
+    ++threadsRoundRobin;
+    threadsRoundRobin = threadsRoundRobin % _threads.size();
+    thread->createIOSocket(std::move(identity), socketType, std::move(onIOSocketCreated));
+}
+
+void IOContext::removeIOSocket(std::shared_ptr<IOSocket>& socket) noexcept
+{
+    auto* rawSocket = socket.get();
+    socket.reset();
+
+    // FIXME: This is a tmp fix in order to keep the changes small.
+    // A better fix would be to put "id" in each shared_ptr<EventLoopThread> and query that
+    // id to get the index. This is needed so we shutdown the thread when it's not needed.
+    // The better fix should be implemented in the next PR.
+    int id = -1;
+    {
+        // NOTE: Keep the eventloop thread alive
+        auto eventLoopThread = rawSocket->_eventLoopThread;
+        std::promise<void> promise;
+        auto future = promise.get_future();
+        rawSocket->_eventLoopThread->_eventLoop.executeNow([&promise, rawSocket] {
+            rawSocket->_eventLoopThread->_eventLoop.executeLater([&promise, rawSocket] {
+                rawSocket->_eventLoopThread->removeIOSocket(rawSocket);
+                promise.set_value();
+            });
+        });
+        future.wait();
+        if (eventLoopThread->stopRequested()) {
+            auto it = std::ranges::find_if(_threads, [&](const auto& x) { return x.get() == eventLoopThread.get(); });
+            id      = std::distance(_threads.begin(), it);
+        }
+    }
+    if (id != -1) {
+        assert(_threads[id].use_count() == 1);
+        _threads[id] = std::make_shared<EventLoopThread>();
+    }
+}
+
+void IOContext::requestIOSocketStop(std::shared_ptr<IOSocket> socket) noexcept
+{
+    socket->_eventLoopThread->_eventLoop.executeNow(
+        [socket] { socket->_eventLoopThread->_eventLoop.executeLater([socket] { socket->requestStop(); }); });
+}
+
+IOContext::~IOContext() noexcept
+{
+#ifdef _WIN32
+    WSACleanup();
+#endif  // _WIN32
+}
+
+}  // namespace ymq
+}  // namespace scaler

scaler/io/ymq/io_context.h

@@ -0,0 +1,44 @@
+#pragma once
+
+// C++
+#include <memory>
+#include <vector>
+
+// First-party
+#include "scaler/io/ymq/configuration.h"
+#include "scaler/io/ymq/typedefs.h"
+
+namespace scaler {
+namespace ymq {
+
+class IOSocket;
+class EventLoopThread;
+
+class IOContext {
+public:
+    using Identity               = Configuration::IOSocketIdentity;
+    using CreateIOSocketCallback = Configuration::CreateIOSocketCallback;
+
+    IOContext(size_t threadCount = 1) noexcept;
+    IOContext(const IOContext&)            = delete;
+    IOContext& operator=(const IOContext&) = delete;
+    IOContext(IOContext&&)                 = delete;
+    IOContext& operator=(IOContext&&)      = delete;
+    ~IOContext() noexcept;
+
+    void createIOSocket(
+        Identity identity, IOSocketType socketType, CreateIOSocketCallback onIOSocketCreated) & noexcept;
+
+    // After user called this method, no other call on the passed in IOSocket should be made.
+    void removeIOSocket(std::shared_ptr<IOSocket>& socket) noexcept;
+
+    void requestIOSocketStop(std::shared_ptr<IOSocket> socket) noexcept;
+
+    constexpr size_t numThreads() const noexcept { return _threads.size(); }
+
+private:
+    std::vector<std::shared_ptr<EventLoopThread>> _threads;
+};
+
+}  // namespace ymq
+}  // namespace scaler

scaler/io/ymq/io_socket.cpp

@@ -0,0 +1,299 @@
+#include "scaler/io/ymq/io_socket.h"
+
+#include <algorithm>
+#include <expected>
+#include <memory>
+#include <optional>
+#include <ranges>
+#include <utility>
+#include <vector>
+
+#include "scaler/io/ymq/error.h"
+#include "scaler/io/ymq/event_loop_thread.h"
+#include "scaler/io/ymq/event_manager.h"
+#include "scaler/io/ymq/message_connection_tcp.h"
+#include "scaler/io/ymq/network_utils.h"
+#include "scaler/io/ymq/tcp_client.h"
+#include "scaler/io/ymq/tcp_server.h"
+#include "scaler/io/ymq/typedefs.h"
+
+namespace scaler {
+namespace ymq {
+
+IOSocket::IOSocket(
+    std::shared_ptr<EventLoopThread> eventLoopThread, Identity identity, IOSocketType socketType) noexcept
+    : _eventLoopThread(eventLoopThread)
+    , _identity(std::move(identity))
+    , _socketType(std::move(socketType))
+    , _pendingRecvMessages(std::make_shared<std::queue<RecvMessageCallback>>())
+    , _stopped {false}
+    , _connectorDisconnected {false}
+{
+}
+
+void IOSocket::sendMessage(Message message, SendMessageCallback onMessageSent) noexcept
+{
+    _eventLoopThread->_eventLoop.executeNow(
+        [this, message = std::move(message), callback = std::move(onMessageSent)] mutable {
+            if (_stopped) {
+                callback(std::unexpected {Error::ErrorCode::IOSocketStopRequested});
+                return;
+            }
+            if (_connectorDisconnected) {
+                callback(std::unexpected {Error::ErrorCode::ConnectorSocketClosedByRemoteEnd});
+                return;
+            }
+            if (!message.address.data() && this->socketType() == IOSocketType::Binder) {
+                callback(std::unexpected {Error::ErrorCode::BinderSendMessageWithNoAddress});
+            }
+
+            MessageConnectionTCP* conn = nullptr;
+
+            std::string address = std::string((char*)message.address.data(), message.address.len());
+            if (this->socketType() == IOSocketType::Connector) {
+                address = "";
+            } else if (this->socketType() == IOSocketType::Multicast) {
+                callback({});  // SUCCESS
+                for (const auto& [addr, conn]: _identityToConnection) {
+                    // TODO: Currently doing N copies of the messages. Find a place to
+                    // store this message and pass in reference.
+                    if (addr.starts_with(address))
+                        conn->sendMessage(message, [](auto) {});
+                }
+                return;
+            }
+
+            if (this->_identityToConnection.contains(address)) {
+                conn = this->_identityToConnection[address].get();
+            } else {
+                const auto it = std::ranges::find(
+                    _unestablishedConnection, address, &MessageConnectionTCP::_remoteIOSocketIdentity);
+                if (it != _unestablishedConnection.end()) {
+                    conn = it->get();
+                } else {
+                    onConnectionCreated(address);
+                    conn = _unestablishedConnection.back().get();
+                }
+            }
+            conn->sendMessage(std::move(message), std::move(callback));
+        });
+}
+
+void IOSocket::recvMessage(RecvMessageCallback onRecvMessage) noexcept
+{
+    _eventLoopThread->_eventLoop.executeNow([this, callback = std::move(onRecvMessage)] mutable {
+        if (_stopped) {
+            callback({{}, Error::ErrorCode::IOSocketStopRequested});
+            return;
+        }
+
+        if (_connectorDisconnected) {
+            callback({{}, Error::ErrorCode::ConnectorSocketClosedByRemoteEnd});
+            return;
+        }
+
+        this->_pendingRecvMessages->emplace(std::move(callback));
+        if (_pendingRecvMessages->size() == 1) {
+            for (const auto& [fd, conn]: _identityToConnection) {
+                if (conn->recvMessage())
+                    return;
+            }
+        }
+    });
+}
+
+void IOSocket::connectTo(sockaddr addr, ConnectReturnCallback onConnectReturn, size_t maxRetryTimes) noexcept
+{
+    _eventLoopThread->_eventLoop.executeNow(
+        [this, addr = std::move(addr), callback = std::move(onConnectReturn), maxRetryTimes] mutable {
+            if (_tcpClient) {
+                unrecoverableError({
+                    Error::ErrorCode::MultipleConnectToNotSupported,
+                    "Originated from",
+                    "IOSocket::connectTo",
+                });
+            }
+
+            _tcpClient.emplace(_eventLoopThread, this->identity(), std::move(addr), std::move(callback), maxRetryTimes);
+            _tcpClient->onCreated();
+        });
+}
+
+void IOSocket::connectTo(
+    std::string networkAddress, ConnectReturnCallback onConnectReturn, size_t maxRetryTimes) noexcept
+{
+    auto res = stringToSockaddr(std::move(networkAddress));
+    connectTo(std::move(res.value()), std::move(onConnectReturn), maxRetryTimes);
+}
+
+void IOSocket::bindTo(std::string networkAddress, BindReturnCallback onBindReturn) noexcept
+{
+    _eventLoopThread->_eventLoop.executeNow(
+        [this, networkAddress = std::move(networkAddress), callback = std::move(onBindReturn)] mutable {
+            if (_tcpServer) {
+                callback(std::unexpected {Error::ErrorCode::MultipleBindToNotSupported});
+                return;
+            }
+            auto res = stringToSockaddr(std::move(networkAddress));
+            assert(res);
+
+            _tcpServer.emplace(_eventLoopThread, this->identity(), std::move(res.value()), std::move(callback));
+            _tcpServer->onCreated();
+        });
+}
+
+void IOSocket::closeConnection(Identity remoteSocketIdentity) noexcept
+{
+    _eventLoopThread->_eventLoop.executeNow([this, remoteIdentity = std::move(remoteSocketIdentity)] {
+        _eventLoopThread->_eventLoop.executeLater([this, remoteIdentity = std::move(remoteIdentity)] {
+            if (_stopped) {
+                return;
+            }
+            // _identityToConnection.erase(remoteIdentity);
+            if (_identityToConnection.contains(remoteIdentity))
+                _identityToConnection[remoteIdentity]->disconnect();
+        });
+    });
+}
+
+// TODO: The function should be separated into onConnectionAborted, onConnectionDisconnected,
+// and probably onConnectionAbortedBeforeEstablished(?)
+void IOSocket::onConnectionDisconnected(MessageConnectionTCP* conn, bool keepInBook) noexcept
+{
+    if (!conn->_remoteIOSocketIdentity) {
+        return;
+    }
+
+    auto connIt = this->_identityToConnection.find(*conn->_remoteIOSocketIdentity);
+
+    _unestablishedConnection.push_back(std::move(connIt->second));
+    this->_identityToConnection.erase(connIt);
+    auto& connPtr = _unestablishedConnection.back();
+
+    if (!keepInBook) {
+        if (IOSocketType::Connector == this->_socketType) {
+            _connectorDisconnected = true;
+            while (this->_pendingRecvMessages->size()) {
+                auto top = std::move(this->_pendingRecvMessages->front());
+                top({Message {}, {Error::ErrorCode::ConnectorSocketClosedByRemoteEnd}});
+                this->_pendingRecvMessages->pop();
+            }
+        }
+        _unestablishedConnection.pop_back();
+        return;
+    }
+
+    if (socketType() == IOSocketType::Unicast || socketType() == IOSocketType::Multicast) {
+        auto destructWriteOp = std::move(connPtr->_writeOperations);
+        connPtr->_writeOperations.clear();
+        while (_pendingRecvMessages->size()) {
+            _pendingRecvMessages->front()(
+                {{}, Error::ErrorCode::RemoteEndDisconnectedOnSocketWithoutGuaranteedDelivery});
+            _pendingRecvMessages->pop();
+        }
+        auto destructReadOp = std::move(connPtr->_receivedReadOperations);
+    }
+
+    if (connPtr->_responsibleForRetry) {
+        connectTo(connPtr->_remoteAddr, [](auto) {});  // as the user callback is one-shot
+    }
+}
+
+// FIXME: This algorithm runs in O(n) complexity. To reduce the complexity of this algorithm
+// to O(lg n), one has to restructure how connections are placed. We would have three lists:
+// - _unconnectedConnections that holds connections with identity but not fd
+// - _unestablishedConnections that holds connections with fd but not identity
+// - _connectingConnections that holds connections with fd and identity
+// And this three lists shall be lookedup in above order based on this rule:
+// - look up in _unestablishedConnections and move this connection to  _connectingConnections
+// - look up _unconnectedConnections to find if there's a connection with the same identity
+//   if so, merge it to this connection that currently resides in _connectingConnections
+// Similar thing for disconnection as well.
+void IOSocket::onConnectionIdentityReceived(MessageConnectionTCP* conn) noexcept
+{
+    auto& s = conn->_remoteIOSocketIdentity;
+    if (socketType() == IOSocketType::Connector) {
+        s = "";
+    }
+
+    auto thisConn = std::find_if(_unestablishedConnection.begin(), _unestablishedConnection.end(), [&](const auto& x) {
+        return x.get() == conn;
+    });
+    _identityToConnection[*s] = std::move(*thisConn);
+    _unestablishedConnection.erase(thisConn);
+
+    auto rge = _unestablishedConnection                                                                        //
+               | std::views::filter([](const auto& x) { return x->_remoteIOSocketIdentity != std::nullopt; })  //
+               | std::views::filter([&s](const auto& x) { return *x->_remoteIOSocketIdentity == *s; })         //
+               | std::views::take(1);
+    if (rge.empty()) {
+        return;
+    }
+
+    auto& targetConn = _identityToConnection[*s];
+
+    auto c = _unestablishedConnection.begin() + (_unestablishedConnection.size() - rge.begin().count());
+
+    while ((*c)->_writeOperations.size()) {
+        targetConn->_writeOperations.emplace_back(std::move((*c)->_writeOperations.front()));
+        (*c)->_writeOperations.pop_front();
+    }
+
+    targetConn->_pendingRecvMessageCallbacks = std::move((*c)->_pendingRecvMessageCallbacks);
+
+    assert(targetConn->_receivedReadOperations.empty());
+    targetConn->_receivedReadOperations = std::move((*c)->_receivedReadOperations);
+
+    _unestablishedConnection.erase(c);
+}
+
+void IOSocket::onConnectionCreated(std::string remoteIOSocketIdentity) noexcept
+{
+    _unestablishedConnection.push_back(
+        std::make_unique<MessageConnectionTCP>(
+            _eventLoopThread, this->identity(), std::move(remoteIOSocketIdentity), _pendingRecvMessages));
+    _unestablishedConnection.back()->onCreated();
+}
+
+void IOSocket::onConnectionCreated(int fd, sockaddr localAddr, sockaddr remoteAddr, bool responsibleForRetry) noexcept
+{
+    _unestablishedConnection.push_back(
+        std::make_unique<MessageConnectionTCP>(
+            _eventLoopThread,
+            fd,
+            std::move(localAddr),
+            std::move(remoteAddr),
+            this->identity(),
+            responsibleForRetry,
+            _pendingRecvMessages));
+    _unestablishedConnection.back()->onCreated();
+}
+
+void IOSocket::removeConnectedTcpClient() noexcept
+{
+    if (this->_tcpClient && this->_tcpClient->_connected) {
+        this->_tcpClient.reset();
+    }
+}
+
+void IOSocket::requestStop() noexcept
+{
+    _stopped = true;
+    while (_pendingRecvMessages->size()) {
+        auto readOp = std::move(_pendingRecvMessages->front());
+        _pendingRecvMessages->pop();
+        readOp({{}, Error::ErrorCode::IOSocketStopRequested});
+    }
+}
+
+IOSocket::~IOSocket() noexcept
+{
+    while (_pendingRecvMessages->size()) {
+        auto readOp = std::move(_pendingRecvMessages->front());
+        _pendingRecvMessages->pop();
+        readOp({{}, Error::ErrorCode::IOSocketStopRequested});
+    }
+}
+
+}  // namespace ymq
+}  // namespace scaler