Merge branch 'main' into fluss-admin-inst-and-cache

Author: toxicteddy00077

.asf.yaml

@@ -19,7 +19,9 @@
 
 github:
   description: "Rust Client for Apache Fluss (Incubating)"
-  homepage: https://fluss.apache.org/
+  homepage: https://clients.fluss.apache.org/
+  ghp_branch: gh-pages
+  ghp_path: /
   features:
     issues: true
     projects: false

.github/workflows/build_and_test_cpp.yml

@@ -70,9 +70,9 @@ jobs:
           cmake -B build -DFLUSS_ENABLE_TESTING=ON -DCMAKE_BUILD_TYPE=Debug
           cmake --build build --parallel
 
-      - name: Run C++ integration tests
+      - name: Run C++ integration tests (parallel)
         working-directory: bindings/cpp
-        run: cd build && ctest --output-on-failure --timeout 300
+        run: cd build && ctest -j$(nproc) --output-on-failure --timeout 300
         env:
           RUST_LOG: DEBUG
           RUST_BACKTRACE: full

.github/workflows/build_and_test_python.yml

@@ -73,9 +73,9 @@ jobs:
           uv sync --extra dev
           uv run maturin develop
 
-      - name: Run Python integration tests
+      - name: Run Python integration tests (parallel)
         working-directory: bindings/python
-        run: uv run pytest test/ -v
+        run: uv run pytest test/ -v -n auto
         env:
           RUST_LOG: DEBUG
           RUST_BACKTRACE: full

.github/workflows/deploy_documentation.yml

@@ -0,0 +1,81 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+name: Deploy Documentation
+
+on:
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ./website
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-node@v6
+        with:
+          node-version: 24
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Build website
+        run: npm run build
+
+      - name: Deploy to gh-pages branch
+        working-directory: .
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+
+          # Create a temporary directory with the built site
+          TMPDIR=$(mktemp -d)
+          cp -r website/build/* "$TMPDIR"
+
+          # Switch to the gh-pages branch (create orphan if it doesn't exist)
+          if git ls-remote --exit-code origin gh-pages; then
+            git fetch origin gh-pages
+            git checkout gh-pages
+          else
+            git checkout --orphan gh-pages
+            git rm -rf .
+          fi
+
+          # Replace contents with the new build
+          git rm -rf . || true
+          git clean -fdx
+          cp -r "$TMPDIR"/* .
+          rm -rf "$TMPDIR"
+
+          # Commit and push
+          git add -A
+          if git diff --cached --quiet; then
+            echo "No changes to deploy."
+          else
+            git commit -m "Deploy website from ${GITHUB_SHA::8}"
+            git push origin gh-pages
+          fi

.github/workflows/release_python.yml

@@ -94,37 +94,55 @@ jobs:
 
       - name: Install protoc (Windows)
         if: runner.os == 'Windows'
-        run: choco install protobuf -y
+        run: choco install protoc -y
         shell: pwsh
 
+      # Install protoc in manylinux container (x86_64/aarch64); script shared via YAML anchor
       - uses: PyO3/maturin-action@v1
         with:
           working-directory: bindings/python
           target: ${{ matrix.target }}
           command: build
           args: --release -o dist -i python3.9
           manylinux: ${{ matrix.manylinux || 'auto' }}
+          before-script-linux: &protoc-install |
+            set -e
+            ARCH=$(uname -m)
+            case "$ARCH" in
+              x86_64)  ZIP=protoc-27.1-linux-x86_64.zip ;;
+              aarch64) ZIP=protoc-27.1-linux-aarch_64.zip ;;
+              *) echo "Unsupported arch $ARCH"; exit 1 ;;
+            esac
+            curl -sLO "https://github.com/protocolbuffers/protobuf/releases/download/v27.1/${ZIP}"
+            python3 -c "import zipfile; zipfile.ZipFile('${ZIP}').extractall('/tmp/protoc_install')"
+            chmod +x /tmp/protoc_install/bin/protoc
+            rm -f "${ZIP}"
+            export PATH="/tmp/protoc_install/bin:$PATH"
+            export PROTOC=/tmp/protoc_install/bin/protoc
       - uses: PyO3/maturin-action@v1
         with:
           working-directory: bindings/python
           target: ${{ matrix.target }}
           command: build
           args: --release -o dist -i python3.10
           manylinux: ${{ matrix.manylinux || 'auto' }}
+          before-script-linux: *protoc-install
       - uses: PyO3/maturin-action@v1
         with:
           working-directory: bindings/python
           target: ${{ matrix.target }}
           command: build
           args: --release -o dist -i python3.11
           manylinux: ${{ matrix.manylinux || 'auto' }}
+          before-script-linux: *protoc-install
       - uses: PyO3/maturin-action@v1
         with:
           working-directory: bindings/python
           target: ${{ matrix.target }}
           command: build
           args: --release -o dist -i python3.12
           manylinux: ${{ matrix.manylinux || 'auto' }}
+          before-script-linux: *protoc-install
 
       - name: Upload wheels
         uses: actions/upload-artifact@v4

.gitignore

@@ -25,6 +25,8 @@ __pycache__/
 *.py[cod]
 *$py.class
 *.so
+*.dylib
+*.dSYM/
 *.egg-info/
 dist/
 build/

bindings/cpp/CMakeLists.txt

@@ -256,6 +256,7 @@ if (FLUSS_ENABLE_TESTING)
     FetchContent_MakeAvailable(googletest)
 
     enable_testing()
+    include(GoogleTest)
 
     file(GLOB TEST_SOURCE_FILES "test/*.cpp")
     add_executable(fluss_cpp_test ${TEST_SOURCE_FILES})
@@ -267,5 +268,17 @@ if (FLUSS_ENABLE_TESTING)
         ${PROJECT_SOURCE_DIR}/test
     )
 
-    add_test(NAME fluss_cpp_integration_tests COMMAND fluss_cpp_test)
+    # Individual tests for parallel execution via ctest -j.
+    gtest_discover_tests(fluss_cpp_test
+        PROPERTIES
+            TIMEOUT 120
+            FIXTURES_REQUIRED fluss_cluster
+    )
+
+    # Cleanup: stop Docker containers after all tests finish.
+    # Mirrors Python's pytest_unconfigure and Rust's atexit cleanup.
+    add_test(NAME fluss_cluster_cleanup COMMAND fluss_cpp_test --cleanup)
+    set_tests_properties(fluss_cluster_cleanup PROPERTIES
+        FIXTURES_CLEANUP fluss_cluster
+    )
 endif()

bindings/cpp/src/connection.cpp

@@ -47,15 +47,13 @@ Connection& Connection::operator=(Connection&& other) noexcept {
 }
 
 Result Connection::Create(const Configuration& config, Connection& out) {
-    try {
-        auto ffi_config = utils::to_ffi_config(config);
-        out.conn_ = ffi::new_connection(ffi_config);
-        return utils::make_ok();
-    } catch (const rust::Error& e) {
-        return utils::make_client_error(e.what());
-    } catch (const std::exception& e) {
-        return utils::make_client_error(e.what());
+    auto ffi_config = utils::to_ffi_config(config);
+    auto ffi_result = ffi::new_connection(ffi_config);
+    auto result = utils::from_ffi_result(ffi_result.result);
+    if (result.Ok()) {
+        out.conn_ = utils::ptr_from_ffi<ffi::Connection>(ffi_result);
     }
+    return result;
 }
 
 bool Connection::Available() const { return conn_ != nullptr; }
@@ -65,30 +63,26 @@ Result Connection::GetAdmin(Admin& out) {
         return utils::make_client_error("Connection not available");
     }
 
-    try {
-        out.admin_ = conn_->get_admin();
-        return utils::make_ok();
-    } catch (const rust::Error& e) {
-        return utils::make_client_error(e.what());
-    } catch (const std::exception& e) {
-        return utils::make_client_error(e.what());
+    auto ffi_result = conn_->get_admin();
+    auto result = utils::from_ffi_result(ffi_result.result);
+    if (result.Ok()) {
+        out.admin_ = utils::ptr_from_ffi<ffi::Admin>(ffi_result);
     }
+    return result;
 }
 
 Result Connection::GetTable(const TablePath& table_path, Table& out) {
     if (!Available()) {
         return utils::make_client_error("Connection not available");
     }
 
-    try {
-        auto ffi_path = utils::to_ffi_table_path(table_path);
-        out.table_ = conn_->get_table(ffi_path);
-        return utils::make_ok();
-    } catch (const rust::Error& e) {
-        return utils::make_client_error(e.what());
-    } catch (const std::exception& e) {
-        return utils::make_client_error(e.what());
+    auto ffi_path = utils::to_ffi_table_path(table_path);
+    auto ffi_result = conn_->get_table(ffi_path);
+    auto result = utils::from_ffi_result(ffi_result.result);
+    if (result.Ok()) {
+        out.table_ = utils::ptr_from_ffi<ffi::Table>(ffi_result);
     }
+    return result;
 }
 
 }  // namespace fluss

bindings/cpp/src/ffi_converter.hpp

@@ -19,6 +19,8 @@
 
 #pragma once
 
+#include <cassert>
+
 #include "fluss.hpp"
 #include "lib.rs.h"
 
@@ -37,6 +39,12 @@ inline Result from_ffi_result(const ffi::FfiResult& ffi_result) {
     return Result{ffi_result.error_code, std::string(ffi_result.error_message)};
 }
 
+template <typename T>
+inline T* ptr_from_ffi(const ffi::FfiPtrResult& r) {
+    assert(r.ptr != 0 && "ptr_from_ffi: null pointer in FfiPtrResult");
+    return reinterpret_cast<T*>(r.ptr);
+}
+
 inline ffi::FfiTablePath to_ffi_table_path(const TablePath& path) {
     ffi::FfiTablePath ffi_path;
     ffi_path.database_name = rust::String(path.database_name);