squashing. things should work. add a proper message

Author: argmarco-tkd

cpp/meson.options

@@ -90,18 +90,6 @@ option(
     description: 'Arbitrary string that identifies the kind of package (for informational purposes)',
 )
 option('parquet', type: 'feature', description: 'Build the Parquet libraries')
-option(
-    'parquet_build_dbps_libs',
-    type: 'feature',
-    value: 'enabled',
-    description: 'Build DBPS external libraries',
-)
-option(
-    'parquet_dbps_interface_include_dir',
-    type: 'string',
-    value: '',
-    description: 'Path to DBPS interface headers directory (must contain dbpa_interface.h and enums.h, typically .../DataBatchProtectionService/src/common). Used by Parquet external DBPA encryption when building with Meson.',
-)
 option(
     'parquet_build_executables',
     type: 'feature',

cpp/src/arrow/meson.build

@@ -385,17 +385,13 @@ if needs_filesystem
                 {'BUILD_PERFORMANCE_TESTS': 'FALSE'},
                 {'BUILD_SAMPLES': 'FALSE'},
                 {'BUILD_TESTING': 'FALSE'},
+                {'BUILD_WINDOWS_UWP': 'TRUE'},
                 {'CMAKE_UNITY_BUILD': 'FALSE'},
                 {'DISABLE_AZURE_CORE_OPENTELEMETRY': 'TRUE'},
                 {'ENV{AZURE_SDK_DISABLE_AUTO_VCPKG}': 'TRUE'},
                 {'WARNINGS_AS_ERRORS': 'FALSE'},
             )
-            if host_machine.system() == 'windows'
-                azure_opt.add_cmake_defines({'BUILD_WINDOWS_UWP': 'TRUE'})
-            endif
-            if host_machine.system() != 'windows'
-                azure_opt.append_compile_args('cpp', '-fPIC')
-            endif
+            azure_opt.append_compile_args('cpp', '-fPIC')
             azure_proj = cmake.subproject('azure', options: azure_opt)
 
             azure_dep = declare_dependency(
@@ -636,11 +632,13 @@ if needs_testing
 
     gtest_dep = dependency('gtest')
     gtest_main_dep = dependency('gtest_main')
+    gtest_dep = dependency('gtest')
     gmock_dep = dependency('gmock')
 else
     filesystem_dep = disabler()
     gtest_dep = disabler()
     gtest_main_dep = disabler()
+    gtest_dep = disabler()
     gmock_dep = disabler()
 endif
 

cpp/src/parquet/encryption/external/dbpa_test_agent.cc

@@ -149,10 +149,7 @@ DBPATestAgent::~DBPATestAgent() {}
 
 // Export function for creating new instances from shared library
 extern "C" {
-// Keep this symbol visible and retained so dlopen()+dlsym() based tests work reliably
-// under various linkers/flags (e.g. LTO / section GC).
-PARQUET_EXPORT DataBatchProtectionAgentInterface*
-create_new_instance() {
+DataBatchProtectionAgentInterface* create_new_instance() {
   return new parquet::encryption::external::DBPATestAgent();
 }
 }

cpp/src/parquet/encryption/external/test_utils.cc

@@ -20,7 +20,6 @@
 #include <filesystem>
 #include <string>
 #include <vector>
-#include <iostream>
 
 #ifdef __APPLE__
 #  include <mach-o/dyld.h>
@@ -58,21 +57,6 @@ std::string TestUtils::GetExecutableDirectory() {
 }
 
 std::string TestUtils::GetTestLibraryPath() {
-  // Strong override: reuse the same env var as the Python tooling
-  // (`python/scripts/base_app.py`): DBPA_LIBRARY_PATH.
-  //
-  // This allows CI/build systems to provide the exact path to the DBPA agent shared
-  // library, avoiding reliance on executable-path heuristics or current working directory.
-  const char* explicit_path = std::getenv("DBPA_LIBRARY_PATH");
-  if (explicit_path && explicit_path[0]) {
-    std::string p(explicit_path);
-    if (std::filesystem::exists(p)) {
-      return p;
-    }
-    throw std::runtime_error("DBPA_LIBRARY_PATH is set but the file does not exist: " +
-                             p);
-  }
-
   // Check for environment variable to override the executable directory
   const char* cwd_override = std::getenv("PARQUET_TEST_LIBRARY_CWD");
   std::string base_path;
@@ -167,17 +151,7 @@ std::string TestUtils::GetTestLibraryPath() {
     }
   }
 
-  // Provide a detailed error to make CI failures diagnosable.
-  std::string msg = "Could not find DBPA test agent library. Tried:\n";
-  for (const auto& filename : possible_filenames) {
-    for (const auto& directory : possible_directories) {
-      msg += "  - " + (directory + filename) + "\n";
-    }
-  }
-  msg += "PARQUET_TEST_LIBRARY_CWD=";
-  msg += (cwd_override && cwd_override[0]) ? cwd_override : "<unset>";
-  msg += "\n";
-  throw std::runtime_error(msg);
+  throw std::runtime_error("test_utils.cc: Could not find DBPATestAgent library ");
 }
 
 }  // namespace parquet::encryption::external::test

cpp/src/parquet/encryption/external_dbpa_encryption.cc

@@ -62,17 +62,8 @@ std::unique_ptr<dbps::external::DataBatchProtectionAgentInterface> LoadAndInitia
   // Step 1: Get path to the shared library
   auto it = configuration_properties.find(SHARED_LIBRARY_PATH_KEY);
   if (it == configuration_properties.end()) {
-    std::string msg = "Required configuration key '" + SHARED_LIBRARY_PATH_KEY +
-                      "' not found in configuration_properties. Present keys: ";
-    bool first = true;
-    for (const auto& kv : configuration_properties) {
-      if (!first) msg += ", ";
-      first = false;
-      msg += kv.first;
-    }
-    if (first) {
-      msg += "<none>";
-    }
+    const auto msg = "Required configuration key '" + SHARED_LIBRARY_PATH_KEY +
+                     "' not found in configuration_properties";
     ARROW_LOG(ERROR) << msg;
     throw ParquetException(msg);
   }
@@ -439,19 +430,6 @@ ExternalDBPAEncryptorAdapter* ExternalDBPAEncryptorAdapterFactory::GetEncryptor(
     auto app_context = external_file_encryption_properties->app_context();
     auto connection_config_for_algorithm = configuration_properties.at(algorithm);
 
-    if (::arrow::util::ArrowLog::IsLevelEnabled(
-            ::arrow::util::ArrowLogLevel::ARROW_DEBUG)) {
-      ARROW_LOG(DEBUG) << "ExternalDBPAEncryptorAdapterFactory::GetEncryptor - "
-                          "selected configuration_properties for EXTERNAL_DBPA_V1:";
-      if (connection_config_for_algorithm.empty()) {
-        ARROW_LOG(DEBUG) << "  <empty map>";
-      } else {
-        for (const auto& [k, v] : connection_config_for_algorithm) {
-          ARROW_LOG(DEBUG) << "  [" << k << "]: [" << v << "]";
-        }
-      }
-    }
-
     std::string key_id;
     try {
       auto key_metadata =
@@ -681,19 +659,6 @@ std::unique_ptr<DecryptorInterface> ExternalDBPADecryptorAdapterFactory::GetDecr
   auto connection_config_for_algorithm = configuration_properties.at(algorithm);
   auto key_value_metadata = column_chunk_metadata->key_value_metadata();
 
-  if (::arrow::util::ArrowLog::IsLevelEnabled(
-          ::arrow::util::ArrowLogLevel::ARROW_DEBUG)) {
-    ARROW_LOG(DEBUG) << "ExternalDBPADecryptorAdapterFactory::GetDecryptor - "
-                        "selected configuration_properties for EXTERNAL_DBPA_V1:";
-    if (connection_config_for_algorithm.empty()) {
-      ARROW_LOG(DEBUG) << "  <empty map>";
-    } else {
-      for (const auto& [k, v] : connection_config_for_algorithm) {
-        ARROW_LOG(DEBUG) << "  [" << k << "]: [" << v << "]";
-      }
-    }
-  }
-
   std::string key_id;
   try {
     auto key_metadata = KeyMetadata::Parse(crypto_metadata->key_metadata());

cpp/src/parquet/meson.build

@@ -65,8 +65,6 @@ if not thrift_dep.found()
         {
             'BUILD_COMPILER': 'OFF',
             'BUILD_EXAMPLES': 'OFF',
-            'BUILD_TESTING': 'OFF',
-            'BUILD_TESTS': 'OFF',
             'BUILD_TUTORIALS': 'OFF',
             'CMAKE_UNITY_BUILD': 'OFF',
             'WITH_AS3': 'OFF',
@@ -129,7 +127,10 @@ if openssl_dep.found()
     # External DBPA integration and its header-only deps are only relevant when
     # encryption support is enabled (i.e., OpenSSL is available).
     if needs_parquet_encryption or get_option('parquet_require_encryption').auto()
-        tcb_span_dep = dependency('tcb_span', fallback: ['tcb-span', 'tcb_span_dep'])
+        tcb_span_dep = dependency(
+            'tcb_span',
+            fallback: ['tcb-span', 'tcb_span_dep'],
+        )
         magic_enum_dep = dependency(
             'magic_enum_header_only',
             fallback: ['magic-enum', 'magic_enum_dep'],
@@ -139,38 +140,17 @@ if openssl_dep.found()
         #
         # We do not build DBPS agents as part of Arrow's Meson build. We only need the
         # DBPS interface headers (dbpa_interface.h, enums.h, etc.) for compilation.
-        #
-        # Resolution order:
-        # - If user provides a local include dir (Meson option or env var), use it.
-        # - Otherwise, fall back to Meson's wrap subproject `dbps_agent`, which downloads
-        #   and unpacks DBPS sources, and exposes only the interface headers via a tiny
-        #   header-only Meson wrapper (cpp/subprojects/packagefiles/dbps_agent).
-        fs = import('fs')
-        dbps_inc = get_option('parquet_dbps_interface_include_dir')
-        if dbps_inc != ''
-            if not fs.exists(dbps_inc / 'dbpa_interface.h')
-                error('parquet_dbps_interface_include_dir/PARQUET_DBPS_INTERFACE_INCLUDE_DIR was set, but dbpa_interface.h was not found in: ' + dbps_inc)
-            endif
-            dbps_interface_dep = declare_dependency(compile_args: ['-I' + dbps_inc])
-        else
-            dbps_sp = subproject('dbps_agent')
-            dbps_interface_dep = dbps_sp.get_variable('dbps_interface_dep')
-        endif
+        # These are obtained via Meson's wrap subproject `dbps_agent`, which downloads
+        # and unpacks DBPS sources, and exposes only the interface headers via a tiny
+        # header-only Meson wrapper (cpp/subprojects/packagefiles/dbps_agent).
+        dbps_sp = subproject('dbps_agent')
+        dbps_interface_dep = dbps_sp.get_variable('dbps_interface_dep')
 
         parquet_deps += [dbps_interface_dep, tcb_span_dep, magic_enum_dep]
 
-        if get_option('parquet_build_dbps_libs').enabled()
-            warning(
-                'Meson does not build DBPS shared libraries. Provide your own agent shared library and set configuration_properties["agent_library_path"], or build DBPS via its CMake build separately.',
-            )
-        endif
-
         # Build the in-tree DBPA test agent shared library used by external encryption tests.
         # CMake builds this as `DBPATestAgent` when ARROW_TESTING is enabled; Meson needs an
         # equivalent target so tests can dlopen() `libDBPATestAgent.so`.
-        #
-        # Keep it Meson-native (no CMake), and place the output next to parquet test
-        # executables so `TestUtils::GetTestLibraryPath()` can find it via the executable dir.
         if needs_testing
             dbpa_test_agent_lib = shared_library(
                 'DBPATestAgent',
@@ -190,23 +170,11 @@ else
     parquet_srcs += files('encryption/aes_encryption_nossl.cc')
 endif
 
-
-# Parquet's CMake build uses explicit export macros and (on ELF) a version script
-# to control symbol visibility. Meson doesn't currently replicate that machinery.
-# With Meson's default hidden visibility, some non-exported-but-test-used symbols
-# (e.g. EncodingProperties, IsParquetCipherSupported) are not linkable from test
-# executables. When building tests/benchmarks, relax visibility to avoid link
-# failures in Meson CI.
-parquet_symbol_visibility = 'inlineshidden'
-if needs_testing
-    parquet_symbol_visibility = 'default'
-endif
-
 parquet_lib = library(
     'arrow-parquet',
     sources: parquet_srcs,
     dependencies: parquet_deps,
-    gnu_symbol_visibility: parquet_symbol_visibility,
+    gnu_symbol_visibility: 'inlineshidden',
 )
 
 parquet_dep = declare_dependency(
@@ -332,7 +300,10 @@ parquet_tests = {
         ),
     },
     'file_deserialize_test': {
-        'sources': files('file_deserialize_test.cc', 'encryption/external/test_utils.cc'),
+        'sources': files(
+            'encryption/external/test_utils.cc',
+            'file_deserialize_test.cc',
+        ),
     },
     'schema_test': {'sources': files('schema_test.cc')},
 }
@@ -402,18 +373,11 @@ foreach key, val : parquet_tests
         # Make DBPATestAgent lookup deterministic under Meson. Some CI setups may
         # not allow /proc/self/exe resolution or run tests with unexpected cwd.
         'PARQUET_TEST_LIBRARY_CWD': meson.current_build_dir(),
-        # Reuse the standard env var used by Python tooling (`base_app.py`).
-        # Prefer this in C++ as well.
         'DBPA_LIBRARY_PATH': dbpa_test_agent_path,
         # Hardcode DBPA logging for Meson test runs to aid CI diagnostics.
         'PARQUET_DBPA_LOG_LEVEL': 'INFO',
     }
-    test(
-        test_name,
-        exc,
-        depends: dbpa_test_agent_lib,
-        env: test_env,
-    )
+    test(test_name, exc, depends: dbpa_test_agent_lib, env: test_env)
 endforeach
 
 parquet_benchmarks = {