Feature - Compute API (#8)

* Basic Impl for Compute Endpoints

* Compute Initialize

* Auto Versioning for Tags and Releases

* Brief Docs and Compute Naming

* Retry Logic for Http Client and Compute Unit Tests

* Update ReadMe & Github Workflows

Author: Calvinjmin

.github/workflows/release.yml

@@ -0,0 +1,123 @@
+name: Auto Release
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Get current version and calculate next version
+        id: version
+        run: |
+          # Get current version from CMakeLists.txt
+          CURRENT_VERSION=$(grep -oP 'VERSION \K[0-9]+\.[0-9]+\.[0-9]+' CMakeLists.txt | head -1)
+          echo "Current version in CMakeLists.txt: $CURRENT_VERSION"
+
+          # Get latest tag
+          LATEST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "v0.0.0")
+          LATEST_VERSION=${LATEST_TAG#v}
+          echo "Latest git tag: $LATEST_TAG ($LATEST_VERSION)"
+
+          # Parse current version
+          IFS='.' read -r -a VERSION_PARTS <<< "$CURRENT_VERSION"
+          MAJOR="${VERSION_PARTS[0]}"
+          MINOR="${VERSION_PARTS[1]}"
+          PATCH="${VERSION_PARTS[2]}"
+
+          # Auto-increment patch version
+          PATCH=$((PATCH + 1))
+          NEW_VERSION="$MAJOR.$MINOR.$PATCH"
+
+          echo "New version: $NEW_VERSION"
+          echo "version=$NEW_VERSION" >> $GITHUB_OUTPUT
+          echo "tag=v$NEW_VERSION" >> $GITHUB_OUTPUT
+          echo "prev_tag=$LATEST_TAG" >> $GITHUB_OUTPUT
+
+      - name: Update version in all files
+        run: |
+          VERSION="${{ steps.version.outputs.version }}"
+          echo "Updating version to $VERSION in all files..."
+
+          # Update CMakeLists.txt
+          sed -i "s/VERSION [0-9]\+\.[0-9]\+\.[0-9]\+/VERSION $VERSION/" CMakeLists.txt
+
+          # Update Doxyfile
+          sed -i "s/PROJECT_NUMBER[[:space:]]*=[[:space:]]*\"[0-9]\+\.[0-9]\+\.[0-9]\+\"/PROJECT_NUMBER         = \"$VERSION\"/" Doxyfile
+
+          # Update vcpkg.json
+          sed -i "s/\"version\":[[:space:]]*\"[0-9]\+\.[0-9]\+\.[0-9]\+\"/\"version\": \"$VERSION\"/" vcpkg.json
+
+          # Update packaging/vcpkg-port/vcpkg.json
+          sed -i "s/\"version\":[[:space:]]*\"[0-9]\+\.[0-9]\+\.[0-9]\+\"/\"version\": \"$VERSION\"/" packaging/vcpkg-port/vcpkg.json
+
+          # Update include/databricks/version.h
+          sed -i "s/constexpr const char \*VERSION = \"[0-9]\+\.[0-9]\+\.[0-9]\+\"/constexpr const char *VERSION = \"$VERSION\"/" include/databricks/version.h
+
+          # Update README.md - Latest Release line
+          sed -i "s/\*\*Latest Release\*\*:[[:space:]]*\[v[0-9]\+\.[0-9]\+\.[0-9]\+\]/**Latest Release**: [v$VERSION]/" README.md
+          sed -i "s|/releases/tag/v[0-9]\+\.[0-9]\+\.[0-9]\+|/releases/tag/v$VERSION|" README.md
+
+          echo "Version updated to $VERSION in all files"
+
+      - name: Generate release notes
+        id: notes
+        run: |
+          PREV_TAG="${{ steps.version.outputs.prev_tag }}"
+
+          if [ "$PREV_TAG" = "v0.0.0" ]; then
+            # First release - get all commits
+            COMMITS=$(git log --pretty=format:"- %s (%h)" --reverse)
+          else
+            # Get commits since last tag
+            COMMITS=$(git log ${PREV_TAG}..HEAD --pretty=format:"- %s (%h)" --reverse)
+          fi
+
+          # Create release notes
+          cat > release_notes.md <<EOF
+          ## What's Changed
+
+          $COMMITS
+
+          ---
+
+          **Full Changelog**: https://github.com/${{ github.repository }}/compare/${PREV_TAG}...v${{ steps.version.outputs.version }}
+          EOF
+
+          echo "Generated release notes:"
+          cat release_notes.md
+
+      - name: Commit version bump
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add CMakeLists.txt Doxyfile vcpkg.json packaging/vcpkg-port/vcpkg.json include/databricks/version.h README.md
+          git commit -m "chore: bump version to ${{ steps.version.outputs.version }}"
+          git push origin main
+
+      - name: Create and push tag
+        run: |
+          git tag -a "v${{ steps.version.outputs.version }}" -m "Release v${{ steps.version.outputs.version }}"
+          git push origin "v${{ steps.version.outputs.version }}"
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: v${{ steps.version.outputs.version }}
+          name: Release v${{ steps.version.outputs.version }}
+          body_path: release_notes.md
+          draft: false
+          prerelease: false
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

CMakeLists.txt

@@ -94,6 +94,8 @@ set(SOURCES
     src/core/client.cpp
     src/core/config.cpp
     src/jobs/jobs.cpp
+    src/compute/compute_types.cpp
+    src/compute/compute.cpp
     src/connection_pool.cpp
     src/internal/pool_manager.cpp
     src/internal/logger.cpp
@@ -106,6 +108,8 @@ set(HEADERS
     include/databricks/connection_pool.h
     include/databricks/version.h
     include/databricks/jobs/jobs.h
+    include/databricks/compute/compute.h
+    include/databricks/compute/compute_types.h
 )
 
 # Internal headers (not installed)

README.md

@@ -631,6 +631,43 @@ int main() {
 
 For a complete example, see `examples/basic/jobs_example.cpp`.
 
+### Compute/Clusters API
+
+Manage Databricks compute clusters programmatically:
+
+```cpp
+#include <databricks/compute/compute.h>
+#include <databricks/core/config.h>
+
+int main() {
+    databricks::AuthConfig auth = databricks::AuthConfig::from_environment();
+    databricks::Compute compute(auth);
+
+    // List clusters
+    auto clusters = compute.list_compute();
+    for (const auto& c : clusters) {
+        std::cout << c.cluster_name << " [" << c.state << "]" << std::endl;
+    }
+
+    // Lifecycle management
+    compute.start_compute("cluster-id");
+    compute.restart_compute("cluster-id");
+    compute.terminate_compute("cluster-id");
+
+    return 0;
+}
+```
+
+**Features:**
+- List/get cluster details
+- Start, restart, and terminate clusters
+- Cluster state tracking (PENDING, RUNNING, TERMINATED, etc.)
+- Automatic HTTP retry logic with exponential backoff
+
+**HTTP Retry Logic:**
+
+All REST API calls automatically retry on transient failures (408, 429, 500-504) with exponential backoff (1s, 2s, 4s). This is built into the HTTP client and requires no configuration
+
 ### Direct ConnectionPool Management
 
 For advanced users who need fine-grained control over connection pools:

include/databricks/compute/compute.h

@@ -0,0 +1,106 @@
+#pragma once
+
+#include "databricks/core/config.h"
+#include "databricks/compute/compute_types.h"
+
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace databricks {
+    /**
+     * @brief Client for interacting with the Databricks Clusters/Compute API
+     *
+     * The Clusters API allows you to create, manage, and control compute clusters
+     * in your Databricks workspace. This implementation uses Clusters API 2.0.
+     *
+     * Example usage:
+     * @code
+     * databricks::AuthConfig auth = databricks::AuthConfig::from_environment();
+     * databricks::Compute compute(auth);
+     *
+     * // List all compute clusters
+     * auto cluster_list = compute.list_compute();
+     *
+     * // Get specific compute cluster details
+     * auto cluster = compute.get_compute("1234-567890-abcde123");
+     *
+     * // Start a terminated compute cluster
+     * compute.start_compute("1234-567890-abcde123");
+     * @endcode
+     */
+    class Compute {
+        public:
+            /**
+             * @brief Construct a Compute API client
+             * @param auth Authentication configuration with host and token
+             */
+            explicit Compute(const AuthConfig& auth);
+
+            /**
+             * @brief Destructor
+             */
+            ~Compute();
+
+            // Disable copy
+            Compute(const Compute&) = delete;
+            Compute& operator=(const Compute&) = delete;
+
+            /**
+             * @brief List all compute clusters in the workspace
+             *
+             * @return Vector of Cluster objects
+             * @throws std::runtime_error if the API request fails
+             */
+            std::vector<Cluster> list_compute();
+
+            /**
+             * @brief Get detailed information about a specific compute cluster
+             *
+             * @param cluster_id The unique identifier of the cluster
+             * @return Cluster object with full details
+             * @throws std::runtime_error if the cluster is not found or the API request fails
+             */
+            Cluster get_compute(const std::string& cluster_id);
+
+            /**
+             * @brief Start a terminated compute cluster
+             *
+             * @param cluster_id The unique identifier of the cluster to start
+             * @return true if the operation was successful
+             * @throws std::runtime_error if the API request fails
+             */
+            bool start_compute(const std::string& cluster_id);
+
+            /**
+             * @brief Terminate a running compute cluster
+             *
+             * @param cluster_id The unique identifier of the cluster to terminate
+             * @return true if the operation was successful
+             * @throws std::runtime_error if the API request fails
+             *
+             * @note This stops the cluster but does not permanently delete it.
+             *       Terminated clusters can be restarted.
+             */
+            bool terminate_compute(const std::string& cluster_id);
+
+            /**
+             * @brief Restart a compute cluster
+             *
+             * @param cluster_id The unique identifier of the cluster to restart
+             * @return true if the operation was successful
+             * @throws std::runtime_error if the API request fails
+             *
+             * @note This will terminate and then start the cluster with the same configuration.
+             */
+            bool restart_compute(const std::string& cluster_id);
+
+        private:
+            class Impl;
+            std::unique_ptr<Impl> pimpl_;
+
+            bool compute_operation(const std::string& cluster_id, const std::string& endpoint, const std::string& operation_name);
+            static std::vector<Cluster> parse_compute_list(const std::string& json_str);
+            static Cluster parse_compute(const std::string& json_str);
+    };
+} // namespace databricks

include/databricks/compute/compute_types.h

@@ -0,0 +1,78 @@
+#pragma once
+
+#include <string>
+#include <map>
+#include <cstdint>
+
+namespace databricks {
+
+    /**
+     * @brief Enumeration of possible cluster lifecycle states
+     *
+     * Represents the various states a Databricks cluster can be in during its lifecycle.
+     */
+    enum class ClusterStateEnum {
+        PENDING,      ///< Cluster is being created
+        RUNNING,      ///< Cluster is running and ready for use
+        RESTARTING,   ///< Cluster is restarting
+        RESIZING,     ///< Cluster is being resized
+        TERMINATING,  ///< Cluster is being terminated
+        TERMINATED,   ///< Cluster has been terminated
+        ERROR,        ///< Cluster is in an error state
+        UNKNOWN       ///< Unknown or unrecognized state
+    };
+
+    /**
+     * @brief Parse a cluster state string into ClusterStateEnum
+     * @param state_str String representation of the cluster state
+     * @return ClusterStateEnum corresponding to the string
+     */
+    ClusterStateEnum parse_cluster_state(const std::string& state_str);
+
+    /**
+     * @brief Convert ClusterStateEnum to string representation
+     * @param state ClusterStateEnum value
+     * @return String representation of the state
+     */
+    std::string cluster_state_to_string(ClusterStateEnum state);
+
+    /**
+     * @brief Represents a Databricks cluster
+     *
+     * Clusters are compute resources used to run notebooks, jobs, and other workloads.
+     * This struct contains the core metadata about a cluster configuration and its state.
+     */
+    struct Cluster {
+        std::string cluster_id;                      ///< Unique identifier for the cluster
+        std::string cluster_name;                    ///< Display name of the cluster
+        std::string state;                           ///< Current lifecycle state (e.g., "RUNNING", "TERMINATED")
+        std::string creator_user_name;               ///< Username of the cluster creator
+        uint64_t start_time = 0;                     ///< Unix timestamp in milliseconds when cluster started
+        uint64_t terminated_time = 0;                ///< Unix timestamp in milliseconds when cluster terminated (0 if running)
+        std::string spark_version;                   ///< Spark runtime version (e.g., "11.3.x-scala2.12")
+        std::string node_type_id;                    ///< Cloud provider instance type (e.g., "i3.xlarge")
+        int num_workers = 0;                         ///< Number of worker nodes in the cluster
+        std::map<std::string, std::string> custom_tags; ///< User-defined tags for organization and tracking
+    };
+
+    /**
+     * @brief Represents detailed state information for a cluster
+     *
+     * Provides more granular state information including state messages
+     * that can help diagnose issues or understand cluster status.
+     */
+    struct ClusterState {
+        std::string cluster_id;                              ///< Unique identifier for the cluster
+        ClusterStateEnum cluster_state = ClusterStateEnum::UNKNOWN;  ///< Enumerated state value (default: UNKNOWN)
+        std::string state_message;                           ///< Human-readable message describing the state
+
+        /**
+         * @brief Parse a ClusterState from JSON string
+         * @param json_str JSON representation of cluster state
+         * @return Parsed ClusterState object
+         * @throws std::runtime_error if parsing fails
+         */
+        static ClusterState from_json(const std::string& json_str);
+    };
+
+} // namespace databricks