1

Author: dkropachev

.github/workflows/build-cpack-packages.yml

@@ -103,20 +103,16 @@ jobs:
 
   macos:
     name: macOS packages
-    runs-on: macos-13
+    runs-on: macos-15-intel
     steps:
       - uses: actions/checkout@v4
 
-      - name: Install Docker
-        run: |
-          set -euo pipefail
-          brew install colima docker
-          colima start
-          docker context use colima
-
       - name: Build packages
         run: make build-package
 
+      - name: Build smoke-test application package
+        run: make -C packaging/smoke-test-app package BUILD_TYPE=${{ inputs.build-type }}
+
       - name: Install driver package (pkg)
         run: |
           set -euo pipefail
@@ -130,26 +126,11 @@ jobs:
             sudo installer -pkg "$pkg" -target /
           done
 
-      - name: Build smoke-test application package
-        run: |
-          set -euo pipefail
-          make -C packaging/smoke-test-app package \
-            BUILD_TYPE=${{ inputs.build-type }}
-
       - name: Install smoke-test application package (pkg)
-        run: |
-          set -euo pipefail
-          make -C packaging/smoke-test-app install-pkg
+        run: make -C packaging/smoke-test-app install-pkg
 
       - name: Run smoke-test application against local Scylla
-        run: |
-          set -euo pipefail
-          cleanup() {
-            docker compose -f tests/examples_cluster/docker-compose.yml down --remove-orphans
-          }
-          trap cleanup EXIT
-          docker compose -f tests/examples_cluster/docker-compose.yml up -d --wait
-          /usr/local/bin/scylla-cpp-driver-smoke-test 172.43.0.2
+        run: make -C packaging/smoke-test-app test-package
 
       - name: Collect artifacts
         run: |
@@ -175,6 +156,22 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
+      - name: Install Docker
+        shell: pwsh
+        run: |
+          $ErrorActionPreference = 'Stop'
+          $dockerService = Get-Service -Name docker -ErrorAction SilentlyContinue
+          if (-not $dockerService) {
+            Install-PackageProvider -Name NuGet -MinimumVersion 2.8.5.201 -Force
+            Install-Module -Name DockerMsftProvider -Repository PSGallery -Force
+            Install-Package -Name docker -ProviderName DockerMsftProvider -Force
+          }
+          try {
+            Start-Service docker -ErrorAction Stop
+          } catch {
+            Write-Warning "Docker service failed to start: $($_.Exception.Message)"
+          }
+
       - name: Add WiX to PATH
         shell: pwsh
         run: |

Makefile

@@ -6,6 +6,7 @@ SHELL = bash
 ifeq ($(OS),Windows_NT)
     SHELL := pwsh.exe
     .SHELLFLAGS := -NoProfile -Command
+    .ONESHELL:
 endif
 
 UNAME_S := $(shell uname -s)
@@ -306,14 +307,18 @@ build-examples:
 		$(MAKE) .ubuntu-package-install-dependencies; \
 	fi
 
-.package-build-prepare-windows:
+.package-build-prepare-windows-openssl:
 	if (-not (choco list --local-only --exact openssl.light | Select-String '^openssl.light$$')) {
 	    choco install openssl.light --no-progress -y
-	};
+	}
+
+.package-build-prepare-windows-pkgconfiglite:
 	if (-not (choco list --local-only --exact pkgconfiglite | Select-String '^pkgconfiglite$$')) {
 		choco install pkgconfiglite --no-progress -y
 	}
 
+.package-build-prepare-windows: .package-build-prepare-windows-openssl .package-build-prepare-windows-pkgconfiglite
+
 ifeq ($(OS_TYPE),macos)
 .package-build-prepare:
 else ifeq ($(OS_TYPE),windows)

packaging/smoke-test-app/CMakeLists.txt

@@ -1,135 +1,154 @@
 cmake_minimum_required(VERSION 3.15)
 project(scylla_cpp_driver_smoke_app LANGUAGES C)
 
-# Derive driver version information from the root header so the smoke-app
-# package stays in lockstep with the driver packages.
+# Derive driver version information from pkg-config metadata when the
+# scylla-cpp-driver dev package is available. This keeps the smoke-app
+# aligned with the installed driver packages instead of relying on
+# building the driver from the same CMake project.
 get_filename_component(CPP_DRIVER_ROOT "${CMAKE_CURRENT_LIST_DIR}/.." ABSOLUTE)
 get_filename_component(CPP_DRIVER_ROOT "${CPP_DRIVER_ROOT}/.." ABSOLUTE)
-set(CASS_INCLUDE_DIR "${CPP_DRIVER_ROOT}/include")
 
-file(STRINGS "${CASS_INCLUDE_DIR}/cassandra.h" _VERSION_PARTS
-  REGEX "^#define[ \t]+CASS_VERSION_(MAJOR|MINOR|PATCH|SUFFIX)[ \t]+([0-9]+|\"([^\"]+)\")$")
+find_package(PkgConfig REQUIRED)
+pkg_check_modules(SCYLLA_CPP_DRIVER REQUIRED IMPORTED_TARGET scylla-cpp-driver)
 
-foreach(part MAJOR MINOR PATCH SUFFIX)
-  string(REGEX MATCH "CASS_VERSION_${part}[ \t]+([0-9]+|\"([^\"]+)\")"
-    PROJECT_VERSION_${part} "${_VERSION_PARTS}")
-  if(PROJECT_VERSION_${part})
-    string(REGEX REPLACE "CASS_VERSION_${part}[ \t]+([0-9]+|\"([^\"]+)\")" "\\1"
-      PROJECT_VERSION_${part} "${PROJECT_VERSION_${part}}")
+set(_pkg_config_use_static_libs_saved OFF)
+if(DEFINED PKG_CONFIG_USE_STATIC_LIBS)
+  set(_pkg_config_use_static_libs_saved "${PKG_CONFIG_USE_STATIC_LIBS}")
+endif()
+set(PKG_CONFIG_USE_STATIC_LIBS ON)
+pkg_check_modules(SCYLLA_CPP_DRIVER_STATIC REQUIRED IMPORTED_TARGET scylla-cpp-driver_static)
+if(_pkg_config_use_static_libs_saved)
+  set(PKG_CONFIG_USE_STATIC_LIBS "${_pkg_config_use_static_libs_saved}")
+else()
+  unset(PKG_CONFIG_USE_STATIC_LIBS)
+endif()
+unset(_pkg_config_use_static_libs_saved)
+
+set(PROJECT_VERSION_STRING "")
+if(SCYLLA_CPP_DRIVER_VERSION)
+  set(PROJECT_VERSION_STRING "${SCYLLA_CPP_DRIVER_VERSION}")
+  string(REPLACE "-" ";" _version_parts "${PROJECT_VERSION_STRING}")
+  list(GET _version_parts 0 _numeric_version)
+  list(LENGTH _version_parts _parts_length)
+  if(_parts_length GREATER 1)
+    list(REMOVE_AT _version_parts 0)
+    list(JOIN _version_parts "-" PROJECT_VERSION_SUFFIX)
+  else()
+    set(PROJECT_VERSION_SUFFIX "")
   endif()
-endforeach()
 
-if(NOT PROJECT_VERSION_MAJOR OR NOT PROJECT_VERSION_MINOR)
-  message(FATAL_ERROR "Unable to extract driver version from cassandra.h")
+  string(REPLACE "." ";" _numeric_split "${_numeric_version}")
+  list(LENGTH _numeric_split _numeric_length)
+  if(_numeric_length GREATER 0)
+    list(GET _numeric_split 0 PROJECT_VERSION_MAJOR)
+  else()
+    set(PROJECT_VERSION_MAJOR "")
+  endif()
+  if(_numeric_length GREATER 1)
+    list(GET _numeric_split 1 PROJECT_VERSION_MINOR)
+  else()
+    set(PROJECT_VERSION_MINOR "")
+  endif()
+  if(_numeric_length GREATER 2)
+    list(GET _numeric_split 2 PROJECT_VERSION_PATCH)
+  else()
+    set(PROJECT_VERSION_PATCH "")
+  endif()
 endif()
 
-set(PROJECT_VERSION_STRING
-  "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")
-if(NOT PROJECT_VERSION_PATCH STREQUAL "")
-  set(PROJECT_VERSION_STRING
-    "${PROJECT_VERSION_STRING}.${PROJECT_VERSION_PATCH}")
-endif()
-if(NOT PROJECT_VERSION_SUFFIX STREQUAL "")
-  string(REPLACE "\"" ""
-    PROJECT_VERSION_SUFFIX ${PROJECT_VERSION_SUFFIX})
-  set(PROJECT_VERSION_STRING
-    "${PROJECT_VERSION_STRING}-${PROJECT_VERSION_SUFFIX}")
-endif()
+if(PROJECT_VERSION_STRING STREQUAL "")
+  # Fallback to parsing cassandra.h when pkg-config metadata does not provide
+  # version information (should be rare, but keeps backwards compatibility).
+  set(CASS_INCLUDE_DIR "")
+  foreach(_candidate_dir IN LISTS SCYLLA_CPP_DRIVER_INCLUDE_DIRS)
+    if(EXISTS "${_candidate_dir}/cassandra.h")
+      set(CASS_INCLUDE_DIR "${_candidate_dir}")
+      break()
+    endif()
+  endforeach()
+  if(CASS_INCLUDE_DIR STREQUAL "")
+    set(CASS_INCLUDE_DIR "${CPP_DRIVER_ROOT}/include")
+  endif()
 
-set(CMAKE_C_STANDARD 11)
-set(CMAKE_C_STANDARD_REQUIRED ON)
-set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+  file(STRINGS "${CASS_INCLUDE_DIR}/cassandra.h" _VERSION_PARTS
+    REGEX "^#define[ \t]+CASS_VERSION_(MAJOR|MINOR|PATCH|SUFFIX)[ \t]+([0-9]+|\"([^\"]+)\")$")
 
-find_package(PkgConfig)
-if(PKG_CONFIG_FOUND)
-  pkg_check_modules(SCYLLA_CPP_DRIVER scylla-cpp-driver)
-endif()
+  foreach(part MAJOR MINOR PATCH SUFFIX)
+    string(REGEX MATCH "CASS_VERSION_${part}[ \t]+([0-9]+|\"([^\"]+)\")"
+      PROJECT_VERSION_${part} "${_VERSION_PARTS}")
+    if(PROJECT_VERSION_${part})
+      string(REGEX REPLACE "CASS_VERSION_${part}[ \t]+([0-9]+|\"([^\"]+)\")" "\\1"
+        PROJECT_VERSION_${part} "${PROJECT_VERSION_${part}}")
+    endif()
+  endforeach()
 
-set(DRIVER_INCLUDE_DIRS "")
-set(DRIVER_LIBRARY_DIRS "")
-set(DRIVER_LIBRARIES "")
-set(DRIVER_COMPILE_OPTIONS "")
-set(DRIVER_LINK_OPTIONS "")
-
-if(PKG_CONFIG_FOUND AND SCYLLA_CPP_DRIVER_FOUND)
-  list(APPEND DRIVER_INCLUDE_DIRS ${SCYLLA_CPP_DRIVER_INCLUDE_DIRS})
-  list(APPEND DRIVER_LIBRARY_DIRS ${SCYLLA_CPP_DRIVER_LIBRARY_DIRS})
-  list(APPEND DRIVER_LIBRARIES ${SCYLLA_CPP_DRIVER_LIBRARIES})
-  list(APPEND DRIVER_COMPILE_OPTIONS ${SCYLLA_CPP_DRIVER_CFLAGS_OTHER})
-  list(APPEND DRIVER_LINK_OPTIONS ${SCYLLA_CPP_DRIVER_LDFLAGS_OTHER})
-endif()
+  if(NOT PROJECT_VERSION_MAJOR OR NOT PROJECT_VERSION_MINOR)
+    message(FATAL_ERROR "Unable to extract driver version from metadata or cassandra.h")
+  endif()
 
-if(NOT PKG_CONFIG_FOUND OR NOT SCYLLA_CPP_DRIVER_FOUND)
-  if(NOT DEFINED SCYLLA_CPP_DRIVER_ROOT AND DEFINED ENV{SCYLLA_CPP_DRIVER_ROOT})
-    set(SCYLLA_CPP_DRIVER_ROOT "$ENV{SCYLLA_CPP_DRIVER_ROOT}")
+  set(PROJECT_VERSION_STRING
+    "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")
+  if(NOT PROJECT_VERSION_PATCH STREQUAL "")
+    set(PROJECT_VERSION_STRING
+      "${PROJECT_VERSION_STRING}.${PROJECT_VERSION_PATCH}")
   endif()
-  if(NOT DEFINED SCYLLA_CPP_DRIVER_ROOT)
-    if(WIN32)
-      set(SCYLLA_CPP_DRIVER_ROOT "C:/Program Files/ScyllaDB/Scylla CPP Driver")
-    elseif(APPLE)
-      set(SCYLLA_CPP_DRIVER_ROOT "/usr/local")
-    else()
-      set(SCYLLA_CPP_DRIVER_ROOT "/usr")
-    endif()
+  if(NOT PROJECT_VERSION_SUFFIX STREQUAL "")
+    string(REPLACE "\"" "" PROJECT_VERSION_SUFFIX ${PROJECT_VERSION_SUFFIX})
+    set(PROJECT_VERSION_STRING
+      "${PROJECT_VERSION_STRING}-${PROJECT_VERSION_SUFFIX}")
   endif()
+endif()
 
-  find_path(SCYLLA_CPP_DRIVER_INCLUDE_DIR cassandra.h
-    PATHS
-      "${SCYLLA_CPP_DRIVER_ROOT}/include"
-    PATH_SUFFIXES
-      ""
-      "cassandra"
-      "x86_64-linux-gnu"
-      "x86_64-linux-gnu/cassandra")
-
-  find_library(SCYLLA_CPP_DRIVER_LIBRARY
-    NAMES scylla-cpp-driver
-    PATHS
-      "${SCYLLA_CPP_DRIVER_ROOT}/lib"
-      "${SCYLLA_CPP_DRIVER_ROOT}/lib64"
-      "${SCYLLA_CPP_DRIVER_ROOT}/lib/x86_64-linux-gnu"
-      "${SCYLLA_CPP_DRIVER_ROOT}/lib64/x86_64-linux-gnu")
-
-  if(NOT SCYLLA_CPP_DRIVER_INCLUDE_DIR OR NOT SCYLLA_CPP_DRIVER_LIBRARY)
-    message(FATAL_ERROR
-      "Unable to locate scylla-cpp-driver installation. Set SCYLLA_CPP_DRIVER_ROOT "
-      "or install pkg-config so the package can be discovered automatically.")
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+if(PROJECT_VERSION_SUFFIX)
+  string(REPLACE "\"" "" PROJECT_VERSION_SUFFIX ${PROJECT_VERSION_SUFFIX})
+  if(PROJECT_VERSION_PATCH)
+    set(PROJECT_VERSION_STRING
+      "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}-${PROJECT_VERSION_SUFFIX}")
+  else()
+    set(PROJECT_VERSION_STRING
+      "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}-${PROJECT_VERSION_SUFFIX}")
+  endif()
+elseif(PROJECT_VERSION_STRING STREQUAL "")
+  set(PROJECT_VERSION_STRING
+    "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")
+  if(NOT PROJECT_VERSION_PATCH STREQUAL "")
+    set(PROJECT_VERSION_STRING
+      "${PROJECT_VERSION_STRING}.${PROJECT_VERSION_PATCH}")
   endif()
-
-  set(SCYLLA_CPP_DRIVER_FOUND TRUE)
-  set(DRIVER_INCLUDE_DIRS ${SCYLLA_CPP_DRIVER_INCLUDE_DIR})
-  get_filename_component(_driver_library_dir ${SCYLLA_CPP_DRIVER_LIBRARY} DIRECTORY)
-  set(DRIVER_LIBRARY_DIRS ${_driver_library_dir})
-  set(DRIVER_LIBRARIES ${SCYLLA_CPP_DRIVER_LIBRARY})
 endif()
 
 add_executable(scylla-cpp-driver-smoke-test
   src/smoke_test.c)
+target_link_libraries(scylla-cpp-driver-smoke-test PRIVATE
+  PkgConfig::SCYLLA_CPP_DRIVER)
 
-if(DRIVER_INCLUDE_DIRS)
-  target_include_directories(scylla-cpp-driver-smoke-test PRIVATE
-    ${DRIVER_INCLUDE_DIRS})
-endif()
-
-if(DRIVER_LIBRARY_DIRS)
-  target_link_directories(scylla-cpp-driver-smoke-test PRIVATE
-    ${DRIVER_LIBRARY_DIRS})
-endif()
-
-if(DRIVER_LIBRARIES)
-  target_link_libraries(scylla-cpp-driver-smoke-test PRIVATE
-    ${DRIVER_LIBRARIES})
+add_executable(scylla-cpp-driver-smoke-test-static
+  src/smoke_test.c)
+set_target_properties(scylla-cpp-driver-smoke-test-static PROPERTIES
+  OUTPUT_NAME "scylla-cpp-driver-smoke-test-static")
+if(NOT PKG_CONFIG_EXECUTABLE)
+  message(FATAL_ERROR "pkg-config executable not available for static linkage")
 endif()
-
-if(DRIVER_COMPILE_OPTIONS)
-  target_compile_options(scylla-cpp-driver-smoke-test PRIVATE
-    ${DRIVER_COMPILE_OPTIONS})
+execute_process(
+  COMMAND ${PKG_CONFIG_EXECUTABLE} --libs --static scylla-cpp-driver_static
+  OUTPUT_VARIABLE _smoke_static_libs_output
+  RESULT_VARIABLE _smoke_static_libs_result
+  OUTPUT_STRIP_TRAILING_WHITESPACE)
+if(NOT _smoke_static_libs_result EQUAL 0 OR _smoke_static_libs_output STREQUAL "")
+  message(FATAL_ERROR
+    "Unable to resolve static link flags from scylla-cpp-driver_static pkg-config metadata")
 endif()
-
-if(DRIVER_LINK_OPTIONS)
-  target_link_options(scylla-cpp-driver-smoke-test PRIVATE
-    ${DRIVER_LINK_OPTIONS})
+separate_arguments(_smoke_static_link_libraries UNIX_COMMAND "${_smoke_static_libs_output}")
+if(NOT WIN32)
+  list(APPEND _smoke_static_link_libraries m)
 endif()
+target_link_libraries(scylla-cpp-driver-smoke-test-static PRIVATE
+  ${_smoke_static_link_libraries})
+unset(_smoke_static_libs_output)
+unset(_smoke_static_link_libraries)
 
 set(SMOKE_APP_COMPONENT_NAME "")
 set(SMOKE_APP_COMPONENT_ARGS "")
@@ -138,7 +157,9 @@ if(APPLE)
   set(SMOKE_APP_COMPONENT_ARGS COMPONENT ${SMOKE_APP_COMPONENT_NAME})
 endif()
 
-install(TARGETS scylla-cpp-driver-smoke-test
+install(TARGETS
+  scylla-cpp-driver-smoke-test
+  scylla-cpp-driver-smoke-test-static
   DESTINATION bin
   ${SMOKE_APP_COMPONENT_ARGS})