Fix metadata purge interval configuration to use REST API

The previous implementation used couchbase-cli setting-compaction which
only sets cluster-wide defaults, not per-bucket settings. This resulted
in autoCompactionSettings: false at bucket level.

Changes:
- Use REST API POST to /pools/default/buckets/{bucket} instead of CLI
- Add required parameters:
  - autoCompactionDefined=true (enables per-bucket override)
  - purgeInterval=0.04 (1 hour minimum)
  - parallelDBAndViewCompaction=false (required parameter)
- Add get_metadata_purge_interval() to verify configuration
- Add check_cbs_config example to inspect current settings
- Improve get function to search purgeInterval in multiple locations

Per-bucket configuration overrides cluster-wide defaults and allows
independent purge interval settings for testing.

Verified: purgeInterval now appears at bucket root level and is set
to 0.04 days (1 hour).

References:
- https://docs.couchbase.com/server/current/rest-api/rest-autocompact-per-bucket.html
- Couchbase docs on cluster-wide vs per-bucket auto-compaction

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: pimpin

examples/check_cbs_config.rs

@@ -0,0 +1,12 @@
+mod utils;
+
+use utils::*;
+
+fn main() {
+    println!("=== CBS Configuration Check ===\n");
+
+    println!("Checking current metadata purge interval configuration:");
+    get_metadata_purge_interval();
+
+    println!("\n=== Check complete ===");
+}

examples/docker-conf/couchbase-server-dev/configure-server.sh

@@ -53,12 +53,21 @@ function configureBucketCompaction() {
     # Configure metadata purge interval to 1 hour (0.04 days) - CBS minimum
     # This is important for tombstone purge testing with Sync Gateway
     # Default is 3 days, which is too long for testing
-    couchbase-cli setting-compaction \
-        -c 127.0.0.1:8091 \
-        --username $COUCHBASE_ADMINISTRATOR_USERNAME \
-        --password $COUCHBASE_ADMINISTRATOR_PASSWORD \
-        --bucket $COUCHBASE_BUCKET \
-        --metadata-purge-interval 0.04
+    #
+    # IMPORTANT: Must use REST API to configure per-bucket auto-compaction
+    # The couchbase-cli setting-compaction command only sets cluster-wide defaults
+    #
+    # Required parameters:
+    # - autoCompactionDefined=true: Enable per-bucket auto-compaction override
+    # - purgeInterval=0.04: Metadata purge interval (1 hour minimum)
+    # - parallelDBAndViewCompaction: Required parameter for auto-compaction
+    curl -X POST \
+        -u "$COUCHBASE_ADMINISTRATOR_USERNAME:$COUCHBASE_ADMINISTRATOR_PASSWORD" \
+        "http://127.0.0.1:8091/pools/default/buckets/$COUCHBASE_BUCKET" \
+        -d "autoCompactionDefined=true" \
+        -d "purgeInterval=0.04" \
+        -d "parallelDBAndViewCompaction=false"
+
     if [[ $? != 0 ]]; then
         return 1
     fi

examples/utils/cbs_admin.rs

@@ -143,6 +143,74 @@ pub fn check_doc_in_cbs(doc_id: &str) {
     }
 }
 
+pub fn get_metadata_purge_interval() {
+    let url = format!("{CBS_URL}/pools/default/buckets/{CBS_BUCKET}");
+
+    let response = reqwest::blocking::Client::new()
+        .get(&url)
+        .basic_auth(CBS_ADMIN_USER, Some(CBS_ADMIN_PWD))
+        .send();
+
+    match response {
+        Ok(resp) => {
+            let status = resp.status();
+            if let Ok(text) = resp.text() {
+                if let Ok(json) = serde_json::from_str::<serde_json::Value>(&text) {
+                    // Search for purgeInterval in multiple possible locations
+                    let locations = vec![
+                        (
+                            "autoCompactionSettings.purgeInterval",
+                            json.get("autoCompactionSettings")
+                                .and_then(|a| a.get("purgeInterval")),
+                        ),
+                        ("purgeInterval", json.get("purgeInterval")),
+                    ];
+
+                    let mut found = false;
+                    for (path, value) in locations {
+                        if let Some(purge_interval) = value {
+                            println!(
+                                "✓ CBS metadata purge interval (at {path}): {}",
+                                purge_interval
+                            );
+                            if let Some(days) = purge_interval.as_f64() {
+                                println!(
+                                    "  = {days} days (~{:.1} hours, ~{:.0} minutes)",
+                                    days * 24.0,
+                                    days * 24.0 * 60.0
+                                );
+                            }
+                            found = true;
+                            break;
+                        }
+                    }
+
+                    if !found {
+                        println!("⚠ purgeInterval not found in bucket config");
+                        if let Some(auto_compact) = json.get("autoCompactionSettings") {
+                            println!("  autoCompactionSettings content:");
+                            println!("  {}", serde_json::to_string_pretty(auto_compact).unwrap());
+                        }
+                        println!("\n  Searching for 'purge' related fields...");
+                        if let Some(obj) = json.as_object() {
+                            for (key, value) in obj {
+                                if key.to_lowercase().contains("purge") {
+                                    println!("  Found: {} = {}", key, value);
+                                }
+                            }
+                        }
+                    }
+                } else {
+                    println!("Get metadata purge interval: status={status}, could not parse JSON");
+                }
+            } else {
+                println!("Get metadata purge interval: status={status}, could not read response");
+            }
+        }
+        Err(e) => println!("Get metadata purge interval error: {e}"),
+    }
+}
+
 pub fn set_metadata_purge_interval(days: f64) {
     const MIN_PURGE_INTERVAL_DAYS: f64 = 0.04; // 1 hour minimum per CBS spec
 
@@ -180,4 +248,8 @@ pub fn set_metadata_purge_interval(days: f64) {
         }
         Err(e) => println!("Set metadata purge interval error: {e}"),
     }
+
+    // Verify the setting was applied
+    println!("\nVerifying configuration:");
+    get_metadata_purge_interval();
 }