opengris-scaler 1.12.7__cp311-cp311-manylinux_2_28_x86_64.whl

scaler/io/ymq/io_socket.h

@@ -0,0 +1,121 @@
+#pragma once
+
+#ifdef _WIN32
+// clang-format off
+#include <winsock2.h>
+#include <mswsock.h>
+// clang-format on
+#undef SendMessageCallback
+#endif  // _WIN32
+
+// C++
+#include <atomic>
+#include <map>
+#include <memory>
+#include <optional>
+#include <queue>
+#include <string>
+
+// First-party
+#include "scaler/io/ymq/configuration.h"
+#include "scaler/io/ymq/message.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 {
+
+class EventLoopThread;
+class MessageConnectionTCP;
+class TcpWriteOperation;
+
+class IOSocket {
+public:
+    using ConnectReturnCallback = Configuration::ConnectReturnCallback;
+    using BindReturnCallback    = Configuration::BindReturnCallback;
+    using SendMessageCallback   = Configuration::SendMessageCallback;
+    using RecvMessageCallback   = Configuration::RecvMessageCallback;
+    using Identity              = Configuration::IOSocketIdentity;
+
+    IOSocket(std::shared_ptr<EventLoopThread> eventLoopThread, Identity identity, IOSocketType socketType) noexcept;
+    IOSocket(const IOSocket&)            = delete;
+    IOSocket& operator=(const IOSocket&) = delete;
+    IOSocket(IOSocket&&)                 = delete;
+    IOSocket& operator=(IOSocket&&)      = delete;
+    ~IOSocket() noexcept;
+
+    // NOTE: BELOW FIVE FUNCTIONS ARE USERSPACE API
+    void sendMessage(Message message, SendMessageCallback onMessageSent) noexcept;
+    void recvMessage(RecvMessageCallback onRecvMessage) noexcept;
+
+    void connectTo(sockaddr addr, ConnectReturnCallback onConnectReturn, size_t maxRetryTimes = 8) noexcept;
+    void connectTo(
+        std::string networkAddress, ConnectReturnCallback onConnectReturn, size_t maxRetryTimes = 8) noexcept;
+
+    void bindTo(std::string networkAddress, BindReturnCallback onBindReturn) noexcept;
+
+    void closeConnection(Identity remoteSocketIdentity) noexcept;
+
+    [[nodiscard]] constexpr Identity identity() const { return _identity; }
+
+    [[nodiscard]] constexpr IOSocketType socketType() const { return _socketType; }
+
+    // From Connection Class only
+    // TODO: Maybe figure out a better name than keepInBook. When keepInBook is true, the system will remember this
+    // remote identity and will treat the next connection with that identity as the reincarnation of this identity.
+    // Thus, keeping the identity in the book.
+    void onConnectionDisconnected(MessageConnectionTCP* conn, bool keepInBook = true) noexcept;
+    // From Connection Class only
+    void onConnectionIdentityReceived(MessageConnectionTCP* conn) noexcept;
+
+    // NOTE: These two functions are called respectively by sendMessage and server/client.
+    // Notice that in the each case only the needed information are passed in; so it's less
+    // likely the user passed in combinations that does not make sense. These two calls are
+    // mutual exclusive. Perhaps we need better name, but I failed to come up with one. - gxu
+    void onConnectionCreated(std::string remoteIOSocketIdentity) noexcept;
+    void onConnectionCreated(int fd, sockaddr localAddr, sockaddr remoteAddr, bool responsibleForRetry) noexcept;
+
+    // From TcpClient class only
+    void removeConnectedTcpClient() noexcept;
+
+    void requestStop() noexcept;
+
+    std::shared_ptr<EventLoopThread> _eventLoopThread;
+
+private:
+    const Identity _identity;
+    const IOSocketType _socketType;
+
+    // NOTE: Owning one TcpClient means the user cannot issue another connectTo
+    // when some message connection is retring to connect.
+    std::optional<TcpClient> _tcpClient;
+
+    // NOTE: Owning one TcpServer means the user cannot bindTo multiple addresses.
+    std::optional<TcpServer> _tcpServer;
+
+    // Remote identity to connection map
+    std::map<std::string, std::unique_ptr<MessageConnectionTCP>> _identityToConnection;
+
+    // NOTE: An unestablished connection can be in the following states:
+    //  1. The underlying socket is not yet defined. This happens when user call sendMessage
+    //  before connectTo finishes.
+    //  2. The underlying connection haven't exchange remote identity with its peer. This
+    //  happens upon new socket being created.
+    //  3. The underlying connection contains peer's identity, but connection is broken. This
+    //  happens upon remote end close the socket (or network issue).
+    //  On the other hand, `Established Connection` are stored in _identityToConnection map.
+    //  An established connection is a network connection that is currently connected, and
+    //  exchanged their identity.
+    std::vector<std::unique_ptr<MessageConnectionTCP>> _unestablishedConnection;
+
+    // NOTE: This variable needs to present in the IOSocket level because the user
+    // does not care which connection a message is coming from.
+    std::shared_ptr<std::queue<RecvMessageCallback>> _pendingRecvMessages;
+
+    bool _stopped;
+    bool _connectorDisconnected;
+};
+
+}  // namespace ymq
+}  // namespace scaler

scaler/io/ymq/iocp_context.cpp

@@ -0,0 +1,102 @@
+#ifdef _WIN32
+
+#include "scaler/io/ymq/iocp_context.h"
+
+#include <cerrno>
+#include <functional>
+
+#include "scaler/io/ymq/error.h"
+#include "scaler/io/ymq/event_manager.h"
+
+namespace scaler {
+namespace ymq {
+
+void IocpContext::execPendingFunctions()
+{
+    while (_delayedFunctions.size()) {
+        auto top = std::move(_delayedFunctions.front());
+        top();
+        _delayedFunctions.pop();
+    }
+}
+
+void IocpContext::loop()
+{
+    std::array<OVERLAPPED_ENTRY, _reventSize> events {};
+    ULONG n         = 0;
+    const bool res  = GetQueuedCompletionStatusEx(_completionPort, events.data(), _reventSize, &n, INFINITE, true);
+    uint64_t revent = 0;
+    if (!res) {
+        const int lastError = GetLastError();
+        if (lastError == WAIT_IO_COMPLETION) {
+            auto vec = _timingFunctions.dequeue();
+            std::ranges::for_each(vec, [](auto& x) { x(); });
+            return;
+        }
+
+        if (lastError == ERROR_ABANDONED_WAIT_0) {
+            revent |= IOCP_SOCKET_CLOSED;
+        } else {
+            unrecoverableError({
+                Error::ErrorCode::CoreBug,
+                "Originated from",
+                "GetQueuedCompletionStatusEx",
+                "Errno is",
+                lastError,
+            });
+        }
+    }
+
+    // NOTE: Timer events are handled above
+    for (auto it = events.begin(); it != events.begin() + n; ++it) {
+        auto current_event = *it;
+        if (current_event.lpCompletionKey == _isInterruptiveFd) {
+            auto vec = _interruptiveFunctions.dequeue();
+            std::ranges::for_each(vec, [](auto&& x) { x(); });
+            continue;
+        }
+        if (current_event.lpCompletionKey == _isSocket) {
+            auto event = (EventManager*)(current_event.lpOverlapped);
+            // TODO: Figure out whether there is a better way to remove overlapped entry from the IOCP queue
+            if (!event) {
+                continue;
+            }
+            // TODO: Figure out the best stuff to put in
+            event->onEvents(revent);
+        }
+    }
+    execPendingFunctions();
+}
+
+void IocpContext::addFdToLoop(int fd, uint64_t, EventManager*)
+{
+    const DWORD threadCount = 1;
+    if (!CreateIoCompletionPort((HANDLE)(SOCKET)fd, _completionPort, _isSocket, threadCount)) {
+        const int lastError = GetLastError();
+        // NOTE: This is when the same fd being added to the loop more than once, normal.
+        if (lastError == ERROR_INVALID_PARAMETER) {
+            return;
+        }
+
+        unrecoverableError({
+            Error::ErrorCode::CoreBug,
+            "Originated from",
+            "CreateIoCompletionPort",
+            "Errno is",
+            lastError,
+        });
+    }
+}
+
+// NOTE: IOCP is based on single action instead of the file handle.
+//  The file handle is automaticaly released when one call closesocket(fd).
+//  This interface is required by the concept, and we need it for select(2) or poll(2).
+//  Instead of relaxing constraint, we leave the implementation empty.
+void IocpContext::removeFdFromLoop(int fd)
+{
+}
+
+}  // namespace ymq
+}  // namespace scaler
+
+#endif  // _WIN32

scaler/io/ymq/iocp_context.h

@@ -0,0 +1,83 @@
+#pragma once
+#ifdef _WIN32
+
+// clang-format off
+#include <windows.h>
+#include <winsock2.h>
+// clang-format on
+
+// C++
+#include <functional>
+#include <queue>
+
+#include "scaler/io/ymq/configuration.h"
+#include "scaler/io/ymq/timed_queue.h"
+
+// First-party
+#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 IocpContext {
+public:
+    using Function             = Configuration::ExecutionFunction;
+    using DelayedFunctionQueue = std::queue<Function>;
+    using Identifier           = Configuration::ExecutionCancellationIdentifier;
+    HANDLE _completionPort;
+
+    // TODO: Handle error with unrecoverable error in the next PR.
+    IocpContext()
+        : _completionPort(CreateIoCompletionPort(INVALID_HANDLE_VALUE, nullptr, (ULONG_PTR)0, 1))
+        , _timingFunctions(_completionPort, _isTimingFd)
+        , _interruptiveFunctions(_completionPort, _isInterruptiveFd)
+    {
+        if (!_completionPort) {
+            unrecoverableError({
+                Error::ErrorCode::CoreBug,
+                "Originated from",
+                "CreateIoCompletionPort",
+                "Errno is",
+                GetLastError(),
+            });
+        }
+    }
+
+    ~IocpContext() { CloseHandle(_completionPort); }
+
+    void loop();
+
+    void addFdToLoop(int fd, uint64_t, EventManager*);
+    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();
+    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 _isSocket         = 2;
+    constexpr static const size_t _reventSize       = 128;  // Reduced for linter.
+};
+
+}  // namespace ymq
+}  // namespace scaler
+
+#endif  // _WIN32

scaler/io/ymq/logging.h

@@ -0,0 +1,163 @@
+#pragma once
+
+#include <concepts>
+#include <cstddef>
+#include <format>
+#include <fstream>
+#include <memory>
+#include <print>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+#include "scaler/io/ymq/timestamp.h"
+#include "scaler/io/ymq/utils.h"
+
+namespace scaler {
+namespace ymq {
+
+class Logger {
+public:
+    enum LoggingLevel { critical = 0, error = 1, warning = 2, info = 3, debug = 4, notset = 5 };
+
+// Sound default logging level based on build type.
+#ifdef NDEBUG  // Release build
+    static constexpr LoggingLevel DEFAULT_LOGGING_LEVEL = LoggingLevel::info;
+#else  // Debug build
+    static constexpr LoggingLevel DEFAULT_LOGGING_LEVEL = LoggingLevel::debug;
+#endif
+
+    Logger(
+        std::string log_format             = "%(levelname)s: %(message)s",
+        std::vector<std::string> log_paths = {"/dev/stdout"},
+        LoggingLevel level                 = DEFAULT_LOGGING_LEVEL)
+        : _log_paths(std::move(log_paths)), _level(level)
+    {
+        preprocessFormat(log_format);
+    }
+
+    static LoggingLevel stringToLogLevel(std::string_view level_sv)
+    {
+        if (level_sv == "CRITICAL")
+            return LoggingLevel::critical;
+        if (level_sv == "ERROR")
+            return LoggingLevel::error;
+        if (level_sv == "WARNING")
+            return LoggingLevel::warning;
+        if (level_sv == "INFO")
+            return LoggingLevel::info;
+        if (level_sv == "DEBUG")
+            return LoggingLevel::debug;
+        return LoggingLevel::info;  // Default
+    }
+
+    static constexpr std::string_view convertLevelToString(LoggingLevel level)
+    {
+        switch (level) {
+            case debug: return "DEBG";
+            case info: return "INFO";
+            case error: return "EROR";
+            case warning: return "WARN";
+            case critical: return "CTIC";
+            case notset: return "NOTSET";
+        }
+        return "UNKNOWN";
+    }
+
+    template <typename... Args>
+    void log(LoggingLevel level, Args&&... args) const
+    {
+        if (level > _level) {
+            return;
+        }
+
+        std::ostringstream output_stream;
+        for (const auto& part: _processed_format) {
+            if (part.is_token) {
+                if (part.content == "levelname") {
+                    output_stream << convertLevelToString(level);
+                } else if (part.content == "asctime") {
+                    output_stream << Timestamp {};
+                } else if (part.content == "message") {
+                    if constexpr (sizeof...(args) > 0) {
+                        (output_stream << ... << std::forward<Args>(args));
+                    }
+                } else if (part.content == "name") {
+                    output_stream << "cpp-logger";
+                } else if (part.content == "lineno") {
+                    output_stream << "0";
+                } else {
+                    // Unknown token, print literally
+                    output_stream << "%(" << part.content << ")s";
+                }
+            } else {
+                output_stream << part.content;
+            }
+        }
+
+        std::string formatted_message = output_stream.str();
+
+        for (auto log_path: _log_paths) {
+            if (log_path.empty() || log_path == "/dev/stdout") {
+                // Use std::print and flush for immediate output to the terminal
+                std::print("{}\n", formatted_message);
+                std::fflush(stdout);
+            } else {
+                // Open the file in append mode and write the log message
+                std::ofstream log_file(log_path, std::ios_base::app);
+                if (log_file.is_open()) {
+                    log_file << formatted_message << std::endl;
+                } else {
+                    throw std::runtime_error("Error: Could not open log file: " + log_path + "\n" + formatted_message);
+                }
+            }
+        }
+    }
+
+private:
+    struct FormatPart {
+        std::string content;
+        bool is_token;
+    };
+
+    std::vector<FormatPart> _processed_format;
+    std::vector<std::string> _log_paths;
+    LoggingLevel _level;
+
+    void preprocessFormat(const std::string& format)
+    {
+        size_t last_pos = 0;
+        size_t find_pos = 0;
+
+        while ((find_pos = format.find('%', last_pos)) != std::string::npos) {
+            if (find_pos > last_pos) {
+                _processed_format.push_back({format.substr(last_pos, find_pos - last_pos), false});
+            }
+
+            if (format.length() > find_pos + 1 && format[find_pos + 1] == '%') {
+                _processed_format.push_back({"%", false});
+                last_pos = find_pos + 2;
+                continue;
+            }
+
+            if (format.length() > find_pos + 1 && format[find_pos + 1] == '(') {
+                size_t token_end = format.find(")s", find_pos + 2);
+                if (token_end != std::string::npos) {
+                    std::string token = format.substr(find_pos + 2, token_end - (find_pos + 2));
+                    _processed_format.push_back({token, true});
+                    last_pos = token_end + 2;
+                    continue;
+                }
+            }
+            _processed_format.push_back({"%", false});
+            last_pos = find_pos + 1;
+        }
+
+        if (last_pos < format.length()) {
+            _processed_format.push_back({format.substr(last_pos), false});
+        }
+    }
+};
+
+}  // namespace ymq
+}  // namespace scaler

scaler/io/ymq/message.h

@@ -0,0 +1,15 @@
+
+#pragma once
+
+#include "scaler/io/ymq/bytes.h"
+
+namespace scaler {
+namespace ymq {
+
+struct Message {
+    Bytes address;  // Address of the message
+    Bytes payload;  // Payload of the message
+};
+
+}  // namespace ymq
+}  // namespace scaler

scaler/io/ymq/message_connection.h

@@ -0,0 +1,16 @@
+#pragma once
+
+// C++
+#include <functional>
+
+// First-party
+#include "scaler/io/ymq/bytes.h"
+
+class MessageConnection {
+public:
+    using SendMessageContinuation = std::function<void()>;
+    using RecvMessageContinuation = std::function<void(Bytes)>;
+
+    void send(Bytes data, SendMessageContinuation k);
+    void recv(RecvMessageContinuation k);
+};