Source code

Author: dankmolot

.gitignore

@@ -9,3 +9,6 @@ install_manifest.txt
 compile_commands.json
 CTestTestfile.cmake
 _deps
+/build*
+.vscode
+CMakeUserPresets.json

.gitmodules

@@ -0,0 +1,58 @@
+cmake_minimum_required(VERSION 3.20)
+
+# Enable IDE folders
+set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+
+# Force x86_64 architecture on MacOSX
+if(APPLE)
+    set(CMAKE_OSX_ARCHITECTURES "x86_64")
+
+    # Disable deprecation warnings
+    add_compile_options(
+        -Wno-deprecated-declarations
+    )
+endif()
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+
+# Get the latest abbreviated commit hash of the working branch
+execute_process(
+    COMMAND git log -1 --format=%h
+    WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
+    OUTPUT_VARIABLE GIT_HASH
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+
+# Get the current working branch
+if(NOT DEFINED GIT_BRANCH)
+    execute_process(
+        COMMAND git rev-parse --abbrev-ref HEAD
+        WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
+        OUTPUT_VARIABLE GIT_BRANCH
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+endif()
+
+project(gm_pgsqloo 
+    VERSION 1.0.0
+    LANGUAGES C CXX
+    HOMEPAGE_URL "https://github.com/Pika-Software/gm_pgsqloo"
+)
+
+# Enable -fPIC flag
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+# Require C++ 20
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS ON)
+
+# Enable multithreaded compilation on Windows
+if(MSVC)
+    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" "/MP")
+endif()
+
+find_package(PostgreSQL REQUIRED)
+find_package(GarrysmodCommon REQUIRED)
+
+add_subdirectory(source)

CMakeLists.txt

@@ -0,0 +1,14 @@
+{
+    "version": 2,
+    "configurePresets": [
+        {
+            "name": "vcpkg",
+            "generator": "Ninja",
+            "binaryDir": "${sourceDir}/build",
+            "cacheVariables": {
+                "CMAKE_TOOLCHAIN_FILE": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake",
+                "BUILD_SHARED_LIBS": "OFF"
+            }
+        }
+    ]
+}

CMakePresets.json

@@ -0,0 +1,10 @@
+message(STATUS "Looking for garrysmod_common...")
+set(GARRYSMOD_COMMON_PATH "GARRYSMOD_COMMON_NOT_FOUND" CACHE PATH "Path to garrysmod_common (https://github.com/dankmolot/garrysmod_common/tree/master-cmake)")
+cmake_path(ABSOLUTE_PATH GARRYSMOD_COMMON_PATH NORMALIZE)
+
+if(NOT IS_DIRECTORY ${GARRYSMOD_COMMON_PATH} OR NOT EXISTS ${GARRYSMOD_COMMON_PATH}/CMakeLists.txt OR ${GARRYSMOD_COMMON_PATH} STREQUAL ${CMAKE_CURRENT_LIST_DIR})
+    message(FATAL_ERROR "Invalid path to garrysmod_common. Please set valid GARRYSMOD_COMMON_PATH")
+endif()
+
+add_subdirectory(${GARRYSMOD_COMMON_PATH} ${CMAKE_BINARY_DIR}/garrysmod_common)
+set(GarrysmodCommon_FOUND TRUE)

cmake/FindGarrysmodCommon.cmake

@@ -0,0 +1,26 @@
+configure_file(config.hpp.in ${CMAKE_BINARY_DIR}/include/config.hpp)
+
+# Include every source file in source directory
+file(GLOB_RECURSE SOURCES RELATIVE ${CMAKE_CURRENT_LIST_DIR} *.cpp *.hpp)
+source_group(TREE ${CMAKE_CURRENT_LIST_DIR} PREFIX "Sources" FILES ${SOURCES})
+
+add_library(pgsqloo SHARED ${SOURCES})
+
+target_link_libraries(pgsqloo PRIVATE
+    gmod::common
+    gmod::helpers
+    PostgreSQL::PostgreSQL
+)
+
+target_include_directories(pgsqloo PRIVATE 
+    ${CMAKE_CURRENT_LIST_DIR}
+    ${CMAKE_BINARY_DIR}/include
+)
+
+set_gmod_suffix_prefix(pgsqloo)
+
+# Autoinstall
+set(AUTOINSTALL "" CACHE PATH "Autoinstall path")
+if(IS_DIRECTORY ${AUTOINSTALL})
+    autoinstall(pgsqloo ${AUTOINSTALL})
+endif()

source/CMakeLists.txt

@@ -0,0 +1,98 @@
+#include "pgsqloo.hpp"
+
+using namespace pgsqloo;
+
+std::vector<Connection*> pgsqloo::connections = {};
+
+struct ConnectionEvent {
+    PGconnPtr conn;
+    GLua::AutoReference callback;
+    PostgresPollingStatusType status = PGRES_POLLING_WRITING;
+    bool is_reset = false;
+};
+
+std::vector<ConnectionEvent> pending_connections = {};
+
+inline bool socket_is_ready(PGconn* conn, PostgresPollingStatusType status) {
+    if (status == PGRES_POLLING_READING || status == PGRES_POLLING_WRITING) {
+        auto socket = check_socket_status(conn);
+        return socket.failed ||
+               ((status == PGRES_POLLING_READING && socket.read_ready) ||
+                (status == PGRES_POLLING_WRITING && socket.write_ready));
+    }
+    return true;
+}
+
+void pgsqloo::connect(GLua::ILuaInterface* lua, std::string_view url,
+                      GLua::AutoReference&& callback) {
+    auto conn = PGconnPtr(PQconnectStart(url.data()), &PQfinish);
+    auto conn_ptr = conn.get();
+
+    if (!conn) {
+        // funnily enough, this probably will instead throw a std::bad_alloc
+        throw std::runtime_error("failed to allocate connection");
+    }
+
+    if (PQstatus(conn_ptr) == CONNECTION_BAD ||
+        PQsetnonblocking(conn_ptr, 1) != 0) {
+        throw std::runtime_error(PQerrorMessage(conn_ptr));
+    }
+
+    auto event = ConnectionEvent{std::move(conn), std::move(callback)};
+    pending_connections.push_back(std::move(event));
+}
+
+// returns true if we finished polling
+// returns false if we need to poll again
+inline bool poll_pending_connection(GLua::ILuaInterface* lua,
+                                    ConnectionEvent& event) {
+    if (!socket_is_ready(event.conn.get(), event.status)) {
+        lua->Msg("socket is not ready (%s)\n",
+                 event.status == PGRES_POLLING_READING ? "reading" : "writing");
+        return false;
+    }
+
+    // TODO: handle reset
+
+    event.status = PQconnectPoll(event.conn.get());
+    lua->Msg("status: %d (%d)\n", event.status, PQstatus(event.conn.get()));
+    if (event.status == PGRES_POLLING_OK) {
+        auto state = new Connection{std::move(event.conn)};
+
+        lua->CreateTable();
+        state->lua_table = GLua::AutoReference(lua);
+
+        connections.push_back(state);
+
+        event.callback.Push();
+        lua->PushBool(true);
+        lua->PushUserType(state, connection_meta);
+        lua->PushMetaTable(connection_meta);
+        lua->SetMetaTable(-2);
+        pcall(lua, 2, 0);
+
+        return true;
+    } else if (event.status == PGRES_POLLING_FAILED) {
+        event.callback.Push();
+        lua->PushBool(false);
+        lua->PushString(PQerrorMessage(event.conn.get()));
+        pcall(lua, 2, 0);
+
+        return true;
+    }
+
+    return false;
+}
+
+void pgsqloo::process_pending_connections(GLua::ILuaInterface* lua) {
+    for (auto it = pending_connections.begin();
+         it != pending_connections.end();) {
+        auto& event = *it;
+
+        if (poll_pending_connection(lua, event)) {
+            it = pending_connections.erase(it);
+        } else {
+            ++it;
+        }
+    }
+}