opengris-scaler 1.12.7__cp310-cp310-manylinux_2_28_x86_64.whl

scaler/io/ymq/epoll_context.h

@@ -0,0 +1,85 @@
+#pragma once
+#ifdef __linux__
+
+// System
+#include <sys/epoll.h>
+
+// C++
+#include <functional>
+#include <queue>
+
+#include "scaler/io/ymq/configuration.h"
+#include "scaler/io/ymq/timed_queue.h"
+
+// First-party
+#include "scaler/io/ymq/file_descriptor.h"
+#include "scaler/io/ymq/interruptive_concurrent_queue.h"
+#include "scaler/io/ymq/timestamp.h"
+
+namespace scaler {
+namespace ymq {
+
+class EventManager;
+
+// In the constructor, the epoll context should register eventfd/timerfd from
+// This way, the queues need not know about the event manager. We don't use callbacks.
+class EpollContext {
+public:
+    using Function             = Configuration::ExecutionFunction;
+    using DelayedFunctionQueue = std::queue<Function>;
+    using Identifier           = Configuration::ExecutionCancellationIdentifier;
+
+    EpollContext()
+    {
+        _epfd = epoll_create1(0);
+        epoll_event event {};
+
+        event.events   = EPOLLIN | EPOLLET;
+        event.data.u64 = _isInterruptiveFd;
+        epoll_ctl(_epfd, EPOLL_CTL_ADD, _interruptiveFunctions.eventFd(), &event);
+
+        event          = {};
+        event.events   = EPOLLIN | EPOLLET;
+        event.data.u64 = _isTimingFd;
+        epoll_ctl(_epfd, EPOLL_CTL_ADD, _timingFunctions.timingFd(), &event);
+    }
+
+    ~EpollContext()
+    {
+        epoll_ctl(_epfd, EPOLL_CTL_DEL, _interruptiveFunctions.eventFd(), nullptr);
+        epoll_ctl(_epfd, EPOLL_CTL_DEL, _timingFunctions.timingFd(), nullptr);
+
+        close(_epfd);
+    }
+
+    void loop();
+
+    void addFdToLoop(int fd, uint64_t events, EventManager* manager);
+    void removeFdFromLoop(int fd);
+
+    // NOTE: Thread-safe method to communicate with the event loop thread
+    void executeNow(Function func) { _interruptiveFunctions.enqueue(std::move(func)); }
+    // WARN: NOT thread-safe. Thread safety is guaranteed by executeNow.
+    void executeLater(Function func) { _delayedFunctions.emplace(std::move(func)); }
+    // WARN: NOT thread-safe. Thread safety is guaranteed by executeNow.
+    Identifier executeAt(Timestamp timestamp, Function callback)
+    {
+        return _timingFunctions.push(timestamp, std::move(callback));
+    }
+    void cancelExecution(Identifier identifier) { _timingFunctions.cancelExecution(identifier); }
+
+private:
+    void execPendingFunctions();
+    int _epfd;
+    TimedQueue _timingFunctions;
+    DelayedFunctionQueue _delayedFunctions;
+    InterruptiveConcurrentQueue<Function> _interruptiveFunctions;
+    constexpr static const size_t _isInterruptiveFd = 0;
+    constexpr static const size_t _isTimingFd       = 1;
+    constexpr static const size_t _reventSize       = 1024;
+};
+
+}  // namespace ymq
+}  // namespace scaler
+
+#endif  // __linux__

scaler/io/ymq/error.h

@@ -0,0 +1,132 @@
+#pragma once
+
+#include <algorithm>
+#include <exception>  // std::terminate
+#include <format>
+#include <functional>
+#include <print>
+#include <string>
+
+#include "scaler/io/ymq/timestamp.h"
+#include "scaler/io/ymq/utils.h"
+
+namespace scaler {
+namespace ymq {
+
+struct Error: public std::exception {
+    enum struct ErrorCode {
+        Uninit,
+        InvalidPortFormat,
+        InvalidAddressFormat,
+        ConfigurationError,
+        SignalNotSupported,
+        CoreBug,
+        RepetetiveIOSocketIdentity,
+        RedundantIOSocketRefCount,
+        MultipleConnectToNotSupported,
+        MultipleBindToNotSupported,
+        InitialConnectFailedWithInProgress,
+        SendMessageRequestCouldNotComplete,
+        SetSockOptNonFatalFailure,
+        IPv6NotSupported,
+        RemoteEndDisconnectedOnSocketWithoutGuaranteedDelivery,
+        ConnectorSocketClosedByRemoteEnd,
+        IOSocketStopRequested,
+        BinderSendMessageWithNoAddress,
+    };
+
+    // NOTE:
+    // Format:
+    //    [Timestamp, ": ", Error Explanation, ": ", Other]
+    // For user calls errors:
+    //     Other := ["Originated from", Function Name, items...]
+    // For system calls errors:
+    //     Other := ["Originated from", Function Name, "Errno is", strerror(errno), items...]
+    template <typename... Args>
+    constexpr Error(ErrorCode e, Args&&... args) noexcept
+        : _errorCode(e), _logMsg(argsToString(Timestamp {}, convertErrorToExplanation(e), std::forward<Args>(args)...))
+    {
+    }
+
+    Error() noexcept: _errorCode(ErrorCode::Uninit) {}
+
+    static inline constexpr std::string_view convertErrorToExplanation(ErrorCode e) noexcept
+    {
+        switch (e) {
+            case ErrorCode::Uninit: return "";
+            case ErrorCode::InvalidPortFormat: return "Invalid port format, example input \"tcp://127.0.0.1:2345\"";
+            case ErrorCode::InvalidAddressFormat:
+                return "Invalid address format, example input \"tcp://127.0.0.1:2345\"";
+            case ErrorCode::ConfigurationError:
+                return "An error generated by system call that's likely due to mis-configuration";
+            case ErrorCode::SignalNotSupported:
+                return "A function call was interrupted by signal, but signal handling is not supported";
+            case ErrorCode::CoreBug: return "Likely a bug within the library";
+            case ErrorCode::RepetetiveIOSocketIdentity:
+                return "It is NOT allowed to create two IOSocket with the same identity";
+            case ErrorCode::RedundantIOSocketRefCount:
+                return "It is NOT allowed to hold IOSocket shared_ptr after you try to remove it";
+            case ErrorCode::MultipleConnectToNotSupported:
+                return "Connect to remote end without the previous such request successfully completed or exceeds "
+                       "retry limit is currently NOT supported";
+            case ErrorCode::MultipleBindToNotSupported:
+                return "Bind to multiple IP addresses is currently not supported";
+            case ErrorCode::InitialConnectFailedWithInProgress:
+                return "The first connect(2) call to an socket failed with EINPROGRESS, expected";
+            case ErrorCode::SendMessageRequestCouldNotComplete:
+                return "sendMessage request could not complete. Possibly because the underlying connection has been "
+                       "destructed because it exceeds maximum retry limit";
+            case ErrorCode::SetSockOptNonFatalFailure: return "sendsockopt(3) gets unfatal failure";
+            case ErrorCode::IPv6NotSupported: return "IPv6 is currently not supported";
+            case ErrorCode::RemoteEndDisconnectedOnSocketWithoutGuaranteedDelivery:
+                return "You are using IOSocket::Unicast or IOSocket::Multicast, which do not support guaranteed "
+                       "message delivery, and the connection(s) disconnects";
+            case ErrorCode::ConnectorSocketClosedByRemoteEnd:
+                return "You have an IOSocket with Connector type but the only connection is closed by remote end";
+            case ErrorCode::IOSocketStopRequested: return "Current IOSocket is requested to stop by another thread";
+            case ErrorCode::BinderSendMessageWithNoAddress:
+                return "You call sendMessage with a Binder IOSocket but failed to provide an address";
+        }
+        fprintf(stderr, "Unrecognized ErrorCode value, program exits\n");
+        std::exit(1);
+    }
+
+    constexpr const char* what() const noexcept override { return _logMsg.c_str(); }
+
+    ErrorCode _errorCode;
+    std::string _logMsg;
+};
+
+}  // namespace ymq
+}  // namespace scaler
+
+template <>
+struct std::formatter<scaler::ymq::Error, char> {
+    template <class ParseContext>
+    constexpr ParseContext::iterator parse(ParseContext& ctx) noexcept
+    {
+        return ctx.begin();
+    }
+
+    template <class FmtContext>
+    constexpr FmtContext::iterator format(scaler::ymq::Error e, FmtContext& ctx) const noexcept
+    {
+        return std::ranges::copy(e._logMsg, ctx.out()).out;
+    }
+};
+
+using UnrecoverableErrorFunctionHookPtr = std::function<void(scaler::ymq::Error)>;
+
+[[noreturn]] inline void defaultUnrecoverableError(scaler::ymq::Error e) noexcept
+{
+    std::print(stderr, "{}\n", e);
+    std::exit(1);
+}
+
+inline UnrecoverableErrorFunctionHookPtr unrecoverableErrorFunctionHookPtr = defaultUnrecoverableError;
+
+[[noreturn]] inline void unrecoverableError(scaler::ymq::Error e) noexcept
+{
+    unrecoverableErrorFunctionHookPtr(std::move(e));
+    std::exit(1);
+}

scaler/io/ymq/event_loop.h

@@ -0,0 +1,55 @@
+#pragma once
+
+// C++
+#include <concepts>
+#include <cstdint>  // uint64_t
+#include <functional>
+
+// First-party
+#include "scaler/io/ymq/configuration.h"
+#include "scaler/io/ymq/epoll_context.h"
+#include "scaler/io/ymq/iocp_context.h"
+
+namespace scaler {
+namespace ymq {
+
+struct Timestamp;
+class EventManager;
+
+template <class Backend>
+concept EventLoopBackend = requires(Backend backend, Backend::Function f) {
+    { backend.executeNow(std::move(f)) } -> std::same_as<void>;
+    { backend.executeLater(std::move(f)) } -> std::same_as<void>;
+    { backend.executeAt(Timestamp {}, std::move(f)) } -> std::integral;
+    { backend.cancelExecution(0) } -> std::same_as<void>;
+
+    backend.addFdToLoop(int {}, uint64_t {}, (EventManager*)nullptr);
+    { backend.removeFdFromLoop(int {}) } -> std::same_as<void>;
+};
+
+template <EventLoopBackend Backend = EpollContext>
+class EventLoop {
+    Backend backend;
+
+public:
+    using Function   = Backend::Function;
+    using Identifier = Backend::Identifier;
+
+    void loop() { backend.loop(); }
+
+    void executeNow(Function func) { backend.executeNow(std::move(func)); }
+    void executeLater(Function func) { backend.executeLater(std::move(func)); }
+
+    Identifier executeAt(Timestamp timestamp, Function func) { return backend.executeAt(timestamp, std::move(func)); }
+    void cancelExecution(Identifier identifier) { backend.cancelExecution(identifier); }
+
+    auto addFdToLoop(int fd, uint64_t events, EventManager* manager)
+    {
+        return backend.addFdToLoop(fd, events, manager);
+    }
+
+    void removeFdFromLoop(int fd) { backend.removeFdFromLoop(fd); }
+};
+
+}  // namespace ymq
+}  // namespace scaler

scaler/io/ymq/event_loop_thread.cpp

@@ -0,0 +1,64 @@
+
+#include "scaler/io/ymq/event_loop_thread.h"
+
+#include <cassert>
+#include <memory>
+
+#include "scaler/io/ymq/error.h"
+#include "scaler/io/ymq/event_manager.h"
+#include "scaler/io/ymq/io_socket.h"
+
+namespace scaler {
+namespace ymq {
+
+void EventLoopThread::createIOSocket(std::string identity, IOSocketType socketType, CreateIOSocketCallback callback)
+{
+    if (thread.get_id() == std::thread::id()) {
+        thread = std::jthread([this](std::stop_token token) {
+            while (!token.stop_requested()) {
+                this->_eventLoop.loop();
+            }
+        });
+    }
+
+    _eventLoop.executeNow([this, callback = std::move(callback), identity = std::move(identity), socketType] mutable {
+        auto [iterator, inserted] = _identityToIOSocket.try_emplace(
+            identity, std::make_shared<IOSocket>(shared_from_this(), identity, socketType));
+
+        if (!inserted) {
+            unrecoverableError({
+                Error::ErrorCode::RepetetiveIOSocketIdentity,
+                "Originated from (in EventLoopThread::createIOSocket)",
+                __PRETTY_FUNCTION__,
+                "Your input identity",
+                identity,
+            });
+        }
+
+        auto ptr = iterator->second;
+
+        callback(ptr);
+    });
+}
+
+void EventLoopThread::removeIOSocket(IOSocket* target)
+{
+    auto useCount = _identityToIOSocket[target->identity()].use_count();
+    if (useCount != 1) {
+        unrecoverableError({
+            Error::ErrorCode::RedundantIOSocketRefCount,
+            "Originated from",
+            __PRETTY_FUNCTION__,
+            "use_count",
+            useCount,
+        });
+    }
+
+    _identityToIOSocket.erase(target->identity());
+    if (_identityToIOSocket.empty()) {
+        thread.request_stop();
+    }
+}
+
+}  // namespace ymq
+}  // namespace scaler

scaler/io/ymq/event_loop_thread.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <memory>
+#include <thread>
+
+#include "scaler/io/ymq/configuration.h"
+#include "scaler/io/ymq/event_loop.h"
+#include "scaler/io/ymq/typedefs.h"
+
+namespace scaler {
+namespace ymq {
+
+class IOSocket;
+
+class EventLoopThread: public std::enable_shared_from_this<EventLoopThread> {
+public:
+    std::map<std::string, std::shared_ptr<IOSocket>> _identityToIOSocket;
+    using PollingContext         = Configuration::PollingContext;
+    using CreateIOSocketCallback = Configuration::CreateIOSocketCallback;
+    EventLoop<PollingContext> _eventLoop;
+    // Why not make the class a friend class of IOContext?
+    // Because the removeIOSocket method is a bit trickier than addIOSocket,
+    // the IOSocket that is being removed will first remove every
+    // MessageConnectionTCP managed by it from the EventLoop, before it removes
+    // it self from ioSockets. return eventLoop.executeNow(createIOSocket());
+    void createIOSocket(std::string identity, IOSocketType socketType, CreateIOSocketCallback callback);
+
+    void removeIOSocket(IOSocket* target);
+    // EventLoop<PollingContext>& getEventLoop();
+    // IOSocket* getIOSocketByIdentity(size_t identity);
+
+    bool stopRequested() { return thread.get_stop_source().stop_requested(); }
+
+    EventLoopThread(const EventLoopThread&)            = delete;
+    EventLoopThread& operator=(const EventLoopThread&) = delete;
+    EventLoopThread()                                  = default;
+
+private:
+    std::jthread thread;
+};
+
+}  // namespace ymq
+}  // namespace scaler

scaler/io/ymq/event_manager.h

@@ -0,0 +1,81 @@
+#pragma once
+
+// C++
+#ifdef __linux__
+#include <sys/epoll.h>
+#endif  // __linux__
+#ifdef _WIN32
+#include <windows.h>
+#endif  // _WIN32
+
+#include <concepts>
+#include <cstdint>  // uint64_t
+#include <functional>
+#include <memory>
+
+// First-party
+#include "scaler/io/ymq/configuration.h"
+
+namespace scaler {
+namespace ymq {
+
+class EventLoopThread;
+
+// TODO: Add the _fd back
+#ifdef _WIN32
+class EventManager: public OVERLAPPED {
+#endif  // _WIN32
+#ifdef __linux__
+    class EventManager {
+#endif  // __linux
+        // FileDescriptor _fd;
+
+    public:
+        void onEvents(uint64_t events)
+        {
+#ifdef __linux__
+            if constexpr (std::same_as<Configuration::PollingContext, EpollContext>) {
+                int realEvents = (int)events;
+                if ((realEvents & EPOLLHUP) && !(realEvents & EPOLLIN)) {
+                    onClose();
+                }
+                if (realEvents & (EPOLLERR | EPOLLHUP)) {
+                    onError();
+                }
+                if (realEvents & (EPOLLIN | EPOLLRDHUP)) {
+                    onRead();
+                }
+                if (realEvents & EPOLLOUT) {
+                    onWrite();
+                }
+            }
+#endif  // __linux__
+#ifdef _WIN32
+            if constexpr (std::same_as<Configuration::PollingContext, IocpContext>) {
+                onRead();
+                onWrite();
+                if (events & IOCP_SOCKET_CLOSED) {
+                    onClose();
+                }
+            }
+#endif  // _WIN32
+        }
+
+        // User that registered them should have everything they need
+        // In the future, we might add more onXX() methods, for now these are all we need.
+        using OnEventCallback = std::function<void()>;
+        OnEventCallback onRead;
+        OnEventCallback onWrite;
+        OnEventCallback onClose;
+        OnEventCallback onError;
+        // EventManager(): _fd {} {}
+        EventManager()
+        {
+#ifdef _WIN32
+            ZeroMemory(this, sizeof(*this));
+#endif  // _WIN32
+        };
+    };
+
+}  // namespace ymq
+}  // namespace scaler

scaler/io/ymq/file_descriptor.h

@@ -0,0 +1,203 @@
+#pragma once
+
+// System
+#include <sys/epoll.h>
+#include <sys/eventfd.h>
+#include <sys/socket.h>
+#include <sys/timerfd.h>
+#include <unistd.h>
+
+// C
+#include <cerrno>
+
+// C++
+#include <expected>
+#include <optional>
+
+// First-party
+#include "scaler/io/ymq/common.h"
+
+class FileDescriptor {
+    int fd;
+
+    FileDescriptor(int fd): fd(fd) {}
+
+public:
+    ~FileDescriptor() noexcept(false)
+    {
+        if (auto code = close(fd) < 0)
+            throw std::system_error(errno, std::system_category(), "Failed to close file descriptor");
+
+        this->fd = -1;
+    }
+
+    FileDescriptor(): fd(-1) {}
+
+    // move-only
+    FileDescriptor(const FileDescriptor&)            = delete;
+    FileDescriptor& operator=(const FileDescriptor&) = delete;
+    FileDescriptor(FileDescriptor&& other) noexcept: fd(other.fd)
+    {
+        other.fd = -1;  // prevent double close
+    }
+    FileDescriptor& operator=(FileDescriptor&& other) noexcept
+    {
+        if (this != &other) {
+            if (fd >= 0) {
+                close(fd);  // close current fd
+            }
+            fd       = other.fd;
+            other.fd = -1;  // prevent double close
+        }
+        return *this;
+    }
+
+    static std::expected<FileDescriptor, Errno> socket(int domain, int type, int protocol)
+    {
+        if (int fd = ::socket(domain, type, protocol) < 0) {
+            return std::unexpected {errno};
+        } else {
+            return FileDescriptor(fd);
+        }
+    }
+
+    static std::expected<FileDescriptor, Errno> eventfd(int initval, int flags)
+    {
+        if (int fd = ::eventfd(initval, flags) < 0) {
+            return std::unexpected {errno};
+        } else {
+            return FileDescriptor(fd);
+        }
+    }
+
+    static std::expected<FileDescriptor, Errno> timerfd(clockid_t clock, int flags)
+    {
+        if (int fd = ::timerfd_create(clock, flags) < 0) {
+            return std::unexpected {errno};
+        } else {
+            return FileDescriptor(fd);
+        }
+    }
+
+    static std::expected<FileDescriptor, Errno> epollfd()
+    {
+        if (int fd = ::epoll_create1(0) < 0) {
+            return std::unexpected {errno};
+        } else {
+            return FileDescriptor(fd);
+        }
+    }
+
+    std::optional<Errno> listen(int backlog)
+    {
+        if (::listen(fd, backlog) < 0) {
+            return errno;
+        } else {
+            return std::nullopt;
+        }
+    }
+
+    std::expected<FileDescriptor, Errno> accept(sockaddr& addr, socklen_t& addrlen)
+    {
+        if (auto fd2 = ::accept(fd, &addr, &addrlen) < 0) {
+            return std::unexpected {errno};
+        } else {
+            return FileDescriptor(fd2);
+        }
+    }
+
+    std::optional<Errno> connect(const sockaddr& addr, socklen_t addrlen)
+    {
+        if (::connect(fd, &addr, addrlen) < 0) {
+            return errno;
+        } else {
+            return std::nullopt;
+        }
+    }
+
+    std::optional<Errno> bind(const sockaddr& addr, socklen_t addrlen)
+    {
+        if (::bind(fd, &addr, addrlen) < 0) {
+            return errno;
+        } else {
+            return std::nullopt;
+        }
+    }
+
+    std::expected<ssize_t, Errno> read(void* buf, size_t count)
+    {
+        ssize_t n = ::read(fd, buf, count);
+        if (n < 0) {
+            return std::unexpected {errno};
+        } else {
+            return n;
+        }
+    }
+
+    std::expected<ssize_t, Errno> write(const void* buf, size_t count)
+    {
+        ssize_t n = ::write(fd, buf, count);
+        if (n < 0) {
+            return std::unexpected {errno};
+        } else {
+            return n;
+        }
+    }
+
+    std::optional<Errno> eventfd_signal()
+    {
+        uint64_t u = 1;
+        if (::eventfd_write(fd, u) < 0) {
+            return errno;
+        } else {
+            return std::nullopt;
+        }
+    }
+
+    std::optional<Errno> eventfd_wait()
+    {
+        uint64_t u;
+        if (::eventfd_read(fd, &u) < 0) {
+            return errno;
+        } else {
+            return std::nullopt;
+        }
+    }
+
+    std::optional<Errno> timerfd_settime(const itimerspec& new_value, itimerspec* old_value = nullptr)
+    {
+        if (::timerfd_settime(fd, 0, &new_value, old_value) < 0) {
+            return errno;
+        } else {
+            return std::nullopt;
+        }
+    }
+
+    std::optional<Errno> timerfd_wait()
+    {
+        uint64_t u;
+        if (::read(fd, &u, sizeof(u)) < 0) {
+            return errno;
+        } else {
+            return std::nullopt;
+        }
+    }
+
+    std::optional<Errno> epoll_ctl(int op, FileDescriptor& other, epoll_event* event)
+    {
+        if (::epoll_ctl(fd, op, other.fd, event) < 0) {
+            return errno;
+        } else {
+            return std::nullopt;
+        }
+    }
+
+    std::expected<int, Errno> epoll_wait(epoll_event* events, int maxevents, int timeout)
+    {
+        if (auto n = ::epoll_wait(fd, events, maxevents, timeout) < 0) {
+            return errno;
+        } else {
+            return n;
+        }
+    }
+};