9 Commits (feature/pgsql-native-backend-protocol)

Author	SHA1	Message	Date
Rene Cannao	baeca0e3dc	test: silence SonarCloud BUG: name truncate-via-temporary in clear_log() ... Three identical SonarCloud BUG-severity findings (one per file) on the truncate-via-temporary idiom: std::ofstream(g_log_path, std::ios::trunc); This creates a temporary std::ofstream whose destructor closes the file — the truncate is the intended side effect. SonarCloud's rule "Name this unused temporary object or remove it" does not understand the side-effect pattern and flags it as a BUG. Issue #5674 triaged all 3 BUG findings as false positives. This commit silences them with the cosmetic fix recommended in that issue: give the temporary a name and (void)-cast it. Same generated code, no behaviour change, but Sonar stops flagging it. Files: test/tap/tests/unit/plugin_{config,lifecycle,manager}_unit-t.cpp	2 months ago
Rene Cannao	cd48c5613e	feat(plugin-chassis): gate chassis ABI additions behind PROXYSQL40 ... The four-phase plugin lifecycle (Step 2.2), pre-execution query-hook ABI (Step 2.1), shared Prometheus registry access (Step 2.3), and generic admin-command alias dispatch (Step 2.5) introduce new plugin ABI surface area — a new descriptor field (register_schemas), new services-struct entries (register_query_hook, get_prometheus_registry, register_command_alias), new public manager methods (invoke_register_schemas_phase, dispatch_query_hook, etc.), and a new startup ordering in main(). These changes should not appear in the v3.x stable/innovative tiers. Wrap every chassis-only declaration, definition, and dispatch path in `#ifdef PROXYSQL40` so the v3.0/v3.1 builds retain the pre-chassis behavior: a single init()-only descriptor layout, two-phase load+init lifecycle, and the hardcoded MYSQLX alias ladder in Admin_Handler.cpp. Changes: * Top-level Makefile: introduce PROXYSQL40 as a distinct tier above PROXYSQL31. Cascade rule: PROXYSQLGENAI=1 implies PROXYSQL40=1 implies PROXYSQL31=1. Bump major version number on PROXYSQL40=1 (previously tied to PROXYSQLGENAI). Export PROXYSQL40 for recursive submakes. * lib/Makefile, src/Makefile: add -DPROXYSQL40 via $(PSQL40) so the compile commands match the top-level tier selection. * include/ProxySQL_Plugin.h: gate the register_schemas descriptor field, query-hook types/enums/typedefs, the alias-registration callback, and the trailing services-struct fields (register_query_hook, get_prometheus_registry, register_command_alias). The pre-chassis descriptor remains six fields (name, abi_version, init, start, stop, status_json) so plugins built against v3.x headers still link and load. * include/ProxySQL_PluginManager.h: gate the chassis-exclusive public methods and private members (schemas_registered, aliases, services_phase_b_, query hook pointers). Provide two declarations of proxysql_load_configured_plugins — the four-phase variant (paired with proxysql_init_configured_plugins) under PROXYSQL40, the legacy single-call variant otherwise. * lib/ProxySQL_PluginManager.cpp: gate every method that belongs to the chassis (invoke_register_schemas_phase, register_command_alias, resolve_alias_to_canonical, register_query_hook, has_query_hook, dispatch_query_hook), plus the services_phase_b_ initialization (nullptr DB handle stubs), the proxysql_dispatch_configured_plugin_ query_hook entry point, and the alternate four-phase body of proxysql_load_configured_plugins / proxysql_init_configured_plugins. The legacy two-phase loader is restored under !PROXYSQL40. get_admindb_service / get_configdb_service / get_statsdb_service stay ungated because they back the unconditional services_ member. * lib/Admin_Handler.cpp: gate the `#include \"ProxySQL_PluginManager.h\"` and restore under !PROXYSQL40 the 16 hardcoded MYSQLX alias vectors plus the 16-deep if-ladder in admin_handler_command_*(). Under PROXYSQL40 the ladder is replaced by a single call to proxysql_resolve_configured_plugin_admin_alias(), which is plugin-agnostic. * src/main.cpp: gate InitConfiguredPlugins and branch the startup sequence in ProxySQL_Main_init_phase2___not_started: - PROXYSQL40: LoadConfiguredPlugins (Phase A+B) -> admin init (C) -> materialize_plugin_tables -> InitConfiguredPlugins (D) -> StartConfiguredPlugins (E). - !PROXYSQL40: admin init -> LoadConfiguredPlugins (combined load+init) -> materialize_plugin_tables -> StartConfiguredPlugins, matching the pre-chassis ordering. * plugins/mysqlx/src/mysqlx_plugin.cpp: split init under PROXYSQL40 into mysqlx_register_schemas (schema + commands) and a minimal mysqlx_init (context only). Under !PROXYSQL40 the original single mysqlx_init remains. Descriptor conditionally wires register_schemas. * plugins/mysqlx/src/mysqlx_admin_schema.cpp: under PROXYSQL40 use the reg() helper to register canonical+aliases via the new ABI; under !PROXYSQL40 fall back to 16 direct register_command() calls (aliases handled by Admin_Handler's hardcoded ladder). * test/tap/test_helpers/fake_plugin.cpp: gate fake_query_hook, fake_register_schemas, fake_descriptor_with_phase_b, the REGISTER_QUERY_HOOK block in fake_init, and the ENABLE_PHASE_B descriptor selection. The pre-chassis descriptor-returning stub is the sole return path under !PROXYSQL40. * test/tap/tests/unit/Makefile: autodetect PROXYSQL40 via invoke_register_schemas_phase (the chassis-exclusive symbol) in the library archive; add -DPROXYSQL40 to fake_plugin .so compilation so the descriptor layout matches the loader's expectations; append the three chassis-only tests (plugin_lifecycle, plugin_prometheus, plugin_query_hook) to UNIT_TESTS only when PROXYSQL40=1. * test/tap/tests/unit/plugin_config_unit-t.cpp, test/tap/tests/unit/plugin_dispatch_unit-t.cpp: compile-time-gate the chassis-only subtests, adjust plan() counts per mode (48/50 with PROXYSQL40, 47/32 without), and provide a proxysql_init_configured_plugins_compat() helper that is a no-op returning true under !PROXYSQL40 so shared test helpers work in both modes. Verification — all plugin unit tests pass in both modes: PROXYSQL40=1 build (chassis enabled): plugin_config_unit-t: 48/48 plugin_dispatch_unit-t: 50/50 plugin_lifecycle_unit-t: 14/14 plugin_query_hook_unit-t: 41/41 PROXYSQL40=0 build (v3.x behavior): plugin_config_unit-t: 47/47 plugin_dispatch_unit-t: 32/32 (plugin_lifecycle, plugin_query_hook not built)	2 months ago
Rene Cannao	f13463d334	feat(plugin-abi): Step 2.2 — four-phase plugin lifecycle ... Adds the register_schemas() callback to the plugin descriptor and wires the loader + main.cpp so that a plugin's schema is declared BEFORE the admin module bootstraps, and the plugin's init() runs AFTER the schema has been materialized. Phase sequence (previously two-phase: load+init): A. load() — dlopen each .so, read the descriptor. B. register_schemas() — NEW, optional; plugin calls services->register_table with its admin/config/stats table defs. Services hand has register_table live but all DB-handle getters stubbed to nullptr. C. ProxySQL_Main_init_Admin_module + GloAdmin->materialize_plugin_tables — admin bootstrap drains the pending-tables list via merge_plugin_tables (first-boot == reload). D. init() — plugin's startup logic with full services (live DB handles pointing at a schema that already contains its own tables). E. start() — plugin launches threads / accept loops. ABI (include/ProxySQL_Plugin.h): * New callback typedef proxysql_plugin_register_schemas_cb. * New descriptor field register_schemas — appended at the end of ProxySQL_PluginDescriptor so existing 6-field initializers leave it null (aggregate init value-initializes the trailing slot). Plugins that left register_schemas null keep the pre-existing two-phase behavior: Phase B is skipped and their init() is responsible for both schema registration and startup work. * Phase-by-phase services availability matrix documented next to ProxySQL_PluginServices. Manager (lib/ProxySQL_PluginManager.cpp): * invoke_register_schemas_phase(err) — public method that runs Phase B for every plugin whose descriptor sets the callback. Uses a "services_phase_b_" variant where DB-handle getters are nullptr stubs; register_query_hook returns false with a warning (hooks cannot register this early). * proxysql_load_configured_plugins() — now stops at Phase B. On success, installs the built manager as the active one so that ProxySQL_Admin::materialize_plugin_tables (which reads from the active manager's pending-tables list) sees the registered tables. * proxysql_init_configured_plugins() — new entry point, calls init_all() for Phase D. Separated from load so admin bootstrap can run between the two. Main (src/main.cpp): * Reorder in ProxySQL_Main_init_phase2___not_started: LoadConfiguredPlugins(); // Phase A + B ProxySQL_Main_init_Admin_module(...); // Phase C GloAdmin->materialize_plugin_tables(); // Phase C (materialize) InitConfiguredPlugins(); // Phase D — NEW StartConfiguredPlugins(); // Phase E * Error messages updated to name the phase that failed. mysqlx plugin: * mysqlx_init split into: - mysqlx_register_schemas() — calls mysqlx_register_admin_schema (pure services->register_table use, no DB access); - mysqlx_init() — wires the plugin context (services, config store, started flag) and returns true. * Descriptor wires the new callback, exercising the full four- phase path end-to-end. Tests: * plugin_lifecycle_unit-t (new) — four cases: both callbacks fire in order; register_schemas-null skips Phase B; Phase-B DB handles return nullptr; Phase-B failure aborts init. * plugin_config_unit-t, plugin_dispatch_unit-t, plugin_query_hook_unit-t — existing tests updated to also call proxysql_init_configured_plugins after proxysql_load_configured_plugins where init side-effects are asserted. test_init_registration_failure_aborts_load reworked: the fake plugin's invalid-table registration happens in init (not register_schemas), so load now succeeds and the failure surfaces at init time. * test_mysqlx_admin_tables / test_mysqlx_listener_smoke — add an explicit invoke_register_schemas_phase() call before init_all() so the mysqlx plugin's schema gets registered under its new split. No behavior change for plugins that didn't opt into Phase B: they still see the same services_ layout and the same {load, init, start, stop} ordering. Opt-in plugins gain DB access from init() against a schema that already contains their tables, eliminating the chicken- and-egg that required ProtocolX's fd5f02947 workaround.	2 months ago
Rene Cannao	9ed621edac	test: substantially expand plugin unit test coverage ... Plugin assertions: 63 → 230 (+167) across 4 binaries. Per-binary deltas (assertions / plan): plugin_registry_unit-t : 25 → 68 (+43) plugin_manager_unit-t : 26 → 83 (+57) plugin_config_unit-t : 12 → 47 (+35) plugin_dispatch_unit-t : - → 32 (new file) New coverage areas: Registry edge cases: - case-insensitive duplicate-table detection (lower vs upper vs mixed) - case-insensitive duplicate-command detection across canonical forms - tabs / newlines / multi-space canonicalisation - leading + trailing spaces, multiple trailing semicolons (incl. interleaved) - internal semicolons preserved (not collapsed) - ";;;" / whitespace-only / "\\t\\n \\r ;" canonicalise to empty → reject - register_table input validation (null name, empty name, null/empty def, out-of-range db_kind) - same-name tables across admin/config/stats kinds all accepted - tables() returns empty for invalid db_kind - insertion-order preservation for both tables and commands - 64-table stress: all stored pointers remain valid after deque growth - 2KB command roundtrip - dispatch result fields (error_code / rows_affected / message) propagated Manager state machine: - load on a missing path: false, non-empty err mentions dlopen, size stays 0 - empty manager: init/start/stop all succeed - idempotent init/start/stop (re-calls are no-ops) - destructor stops started plugins (verified via log) - destructor SKIPS plugins that were never started - destructor doesn't re-run stop if explicit stop_all already happened - register_command failure inside init_all aborts and names the operation - register_table-with-invalid-kind inside init_all aborts and names op Multi-plugin (new fake_plugin2.so): - init/start happen in registration order; stop runs in reverse order (verified via shared log) - second plugin's init failure prevents both starts (no destructor stops) - second plugin's start failure: first plugin (which started) IS stopped by the destructor, second is NOT (never successfully started) Config helpers: - multiple plugins parsed - empty plugins=() clears stale modules - non-string entries (int, bool) silently skipped between strings - missing path bubbles up with the path in err - active manager visibility before/after load and stop - reload replaces previous manager (full lifecycle for both old and new) - reload to empty list: previous plugin stopped, manager nulled - partial-load failure leaves no active manager behind New plugin_dispatch_unit-t: - global dispatcher returns false when no manager active - dispatcher canonicalises input the same way registry does - dispatcher tolerates context with all-null DB pointers - dispatcher returns false after stop, even for a previously-routed command - 8 threads x 250 dispatches concurrent: 2000/2000 succeed, 0 fail - stop helper / start helper safe on null inputs Infrastructure changes: - test/tap/test_helpers/fake_plugin.cpp: parameterised via FAKE_PLUGIN_NAME and FAKE_PLUGIN_ENV_PREFIX so the same source can be compiled into a second .so (libproxysql_fake_plugin2.so) used by multi-plugin tests. Log entries now prefixed with "<name>:" so a shared log file can distinguish events from each plugin. - test/tap/tests/unit/Makefile: builds the second .so, wires it into plugin_manager_unit-t and plugin_config_unit-t, and adds the new plugin_dispatch_unit-t target. All 57 unit-test binaries pass.	2 months ago
Rene Cannao	940e48d2da	test: expand plugin manager, registry, and config unit tests (34 -> 65 assertions) ... Expand plugin_manager_unit-t.cpp from 7 to 20 assertions. Added load error cases (empty path, text file dlopen failure, duplicate load, empty manager init/start/stop, non-existent path) and lifecycle edge cases (stop before start, double init, destructor safety, init after stop, two-plugin full lifecycle). Expand plugin_registry_unit-t.cpp from 15 to 25 assertions. Added command registration edge cases (empty string, null callback, whitespace only, empty SQL dispatch, unregistered command), table registration edge cases (null name, empty def, same name different DB kind), and canonicalization tests (leading/trailing spaces, double spaces + trailing semicolons). Expand plugin_config_unit-t.cpp from 12 to 20 assertions. Added config parsing edge cases (empty plugins list, two plugins, no plugins key, double parse replacement, null manager stop/start/load safety, dispatch disabled after stop).	3 months ago
Rene Cannao	9b87260b70	fix: harden plugin init failures and command dispatch	3 months ago
Rene Cannao	fd5f029474	fix: expose plugin db handles during startup	3 months ago
Rene Cannao	80fa6bee24	fix: cover configured plugin lifecycle wiring	3 months ago
Rene Cannao	804771271b	feat: wire configured plugins into ProxySQL startup	3 months ago