JCBC-1647 BucketManager doesn't recognize ephemeral bucket ejection values

Motivation
----------
Allow users to create and manage ephemeral and memcached buckets.

Modifications
-------------
Deprecate EjectionPolicy in favor of EvictionPolicyType,
which is the new standard name for this thing across all SDKs.

Add the "noEviction" and "nruEviction" policies used by ephemeral buckets.

Let server assign the default eviction policy for
each bucket type to avoid the client getting it wrong.

When posting the settings to the server, omit settings that
aren't applicable to the bucket type, so the server doesn't
return an error message.

Customize Eviction/EjectionPolicy Jackson serialization using
@JsonValue instead of @JsonProperty so we don't need to
specify the alias redundantly.

Add integration tests for creating different bucket types.
Centralize the bucket cleanup code in an "AfterEach" method
to ensure all the test buckets get dropped.

Change-Id: Icaec7beda5bda4d33f6db1728e37c826b7000f77
Reviewed-on: http://review.couchbase.org/c/couchbase-jvm-clients/+/131387
Tested-by: Build Bot <[email protected]>
Reviewed-by: Michael Reiche <[email protected]>

Author: dnault

java-client/src/integrationTest/java/com/couchbase/client/java/manager/bucket/BucketManagerIntegrationTest.java

@@ -31,13 +31,21 @@
 import com.couchbase.client.test.IgnoreWhen;
 import com.couchbase.client.test.Util;
 import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 
 import java.time.Duration;
+import java.util.HashSet;
 import java.util.Map;
+import java.util.Set;
 import java.util.UUID;
 
+import static com.couchbase.client.java.manager.bucket.BucketType.MEMCACHED;
+import static com.couchbase.client.java.manager.bucket.EvictionPolicyType.FULL;
+import static com.couchbase.client.java.manager.bucket.EvictionPolicyType.NO_EVICTION;
+import static com.couchbase.client.java.manager.bucket.EvictionPolicyType.NOT_RECENTLY_USED;
+import static com.couchbase.client.java.manager.bucket.EvictionPolicyType.VALUE_ONLY;
 import static com.couchbase.client.test.Util.waitUntilCondition;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
@@ -53,6 +61,7 @@ class BucketManagerIntegrationTest extends JavaIntegrationTest {
   private static Cluster cluster;
   private static ClusterEnvironment environment;
   private static BucketManager buckets;
+  private final Set<String> bucketsToDrop = new HashSet<>();
 
   @BeforeAll
   static void setup() {
@@ -63,6 +72,21 @@ static void setup() {
     bucket.waitUntilReady(Duration.ofSeconds(5));
   }
 
+  @AfterEach
+  void dropBuckets() {
+    try {
+      for (String bucketName : bucketsToDrop) {
+        try {
+          buckets.dropBucket(bucketName);
+        } catch (BucketNotFoundException e) {
+          // that's fine, the test probably dropped the bucket already
+        }
+      }
+    } finally {
+      bucketsToDrop.clear();
+    }
+  }
+
   @AfterAll
   static void tearDown() {
     cluster.disconnect();
@@ -74,8 +98,7 @@ private void waitUntilHealthy(String bucket) {
       try {
         BucketSettings bkt = buckets.getBucket(bucket);
         return bkt.healthy();
-      }
-      catch (BucketNotFoundException err) {
+      } catch (BucketNotFoundException err) {
         return false;
       }
     });
@@ -86,8 +109,7 @@ private void waitUntilDropped(String bucket) {
       try {
         buckets.getBucket(bucket);
         return false;
-      }
-      catch (BucketNotFoundException err) {
+      } catch (BucketNotFoundException err) {
         return true;
       }
     });
@@ -118,11 +140,57 @@ void getAllBuckets() {
     }
   }
 
+  @Test
+  void createEphemeralBucketWithDefaultEvictionPolicy() {
+    String name = UUID.randomUUID().toString();
+    createBucket(BucketSettings.create(name).bucketType(BucketType.EPHEMERAL));
+    BucketSettings settings = buckets.getBucket(name);
+    assertEquals(NO_EVICTION, settings.evictionPolicy());
+  }
+
+  @Test
+  void createEphemeralBucketWithNruEvictionPolicy() {
+    String name = UUID.randomUUID().toString();
+    createBucket(BucketSettings.create(name)
+        .bucketType(BucketType.EPHEMERAL)
+        .evictionPolicy(NOT_RECENTLY_USED));
+
+    BucketSettings settings = buckets.getBucket(name);
+    assertEquals(NOT_RECENTLY_USED, settings.evictionPolicy());
+  }
+
+  @Test
+  void createCouchbaseBucketWithDefaultEvictionPolicy() {
+    String name = UUID.randomUUID().toString();
+    createBucket(BucketSettings.create(name)
+        .bucketType(BucketType.COUCHBASE));
+    BucketSettings settings = buckets.getBucket(name);
+    assertEquals(VALUE_ONLY, settings.evictionPolicy());
+  }
+
+  @Test
+  void createCouchbaseBucketWithFullEvictionPolicy() {
+    String name = UUID.randomUUID().toString();
+    createBucket(BucketSettings.create(name)
+        .bucketType(BucketType.COUCHBASE)
+        .evictionPolicy(FULL));
+    BucketSettings settings = buckets.getBucket(name);
+    assertEquals(FULL, settings.evictionPolicy());
+  }
+
+  @Test
+  void createMemcachedBucket() {
+    String name = UUID.randomUUID().toString();
+    createBucket(BucketSettings.create(name).bucketType(MEMCACHED));
+    BucketSettings settings = buckets.getBucket(name);
+    assertEquals(MEMCACHED, settings.bucketType());
+  }
+
   @Test
   void createAndDropBucket() {
     String name = UUID.randomUUID().toString();
 
-    buckets.createBucket(BucketSettings.create(name));
+    createBucket(BucketSettings.create(name));
     waitUntilHealthy(name);
     assertTrue(buckets.getAllBuckets().containsKey(name));
 
@@ -136,7 +204,7 @@ void flushBucket() {
     Bucket bucket = cluster.bucket(config().bucketname());
     Collection collection = bucket.defaultCollection();
 
-    String id =  UUID.randomUUID().toString();
+    String id = UUID.randomUUID().toString();
     collection.upsert(id, "value");
     assertTrue(collection.exists(id).exists());
 
@@ -146,21 +214,15 @@ void flushBucket() {
 
   @Test
   void failIfBucketFlushDisabled() {
-    String bucketName =  UUID.randomUUID().toString();
-    buckets.createBucket(BucketSettings.create(bucketName).flushEnabled(false));
-    waitUntilCondition(() -> buckets.getAllBuckets().containsKey(bucketName));
+    String bucketName = UUID.randomUUID().toString();
+    createBucket(BucketSettings.create(bucketName).flushEnabled(false));
     assertThrows(BucketNotFlushableException.class, () -> buckets.flushBucket(bucketName));
   }
 
   @Test
   void createShouldFailWhenPresent() {
-    assertThrows(
-      BucketExistsException.class,
-      () -> {
-        buckets.createBucket(BucketSettings.create(config().bucketname()));
-        waitUntilHealthy(config().bucketname());
-      }
-    );
+    assertThrows(BucketExistsException.class, () ->
+        buckets.createBucket(BucketSettings.create(config().bucketname())));
   }
 
   @Test
@@ -188,15 +250,11 @@ void updateShouldFailIfNotPresent() {
   void createWithMoreThanOneReplica() {
     String name = UUID.randomUUID().toString();
 
-    buckets.createBucket(BucketSettings.create(name).numReplicas(3));
+    createBucket(BucketSettings.create(name).numReplicas(3));
     waitUntilHealthy(name);
 
     BucketSettings bucket = buckets.getBucket(name);
     assertEquals(3, bucket.numReplicas());
-
-    buckets.dropBucket(name);
-    waitUntilDropped(name);
-    assertFalse(buckets.getAllBuckets().containsKey(name));
   }
 
   /**
@@ -207,4 +265,9 @@ private void assertCreatedBucket(final BucketSettings settings) {
     assertTrue(settings.ramQuotaMB() > 0);
   }
 
+  private void createBucket(BucketSettings settings) {
+    buckets.createBucket(settings);
+    bucketsToDrop.add(settings.name());
+    waitUntilHealthy(settings.name());
+  }
 }

java-client/src/main/java/com/couchbase/client/java/manager/bucket/AsyncBucketManager.java

@@ -38,6 +38,7 @@
 import static com.couchbase.client.core.deps.io.netty.handler.codec.http.HttpMethod.POST;
 import static com.couchbase.client.core.logging.RedactableArgument.redactMeta;
 import static com.couchbase.client.core.util.UrlQueryStringBuilder.urlEncode;
+import static com.couchbase.client.java.manager.bucket.BucketType.MEMCACHED;
 import static com.couchbase.client.java.manager.bucket.CreateBucketOptions.createBucketOptions;
 import static com.couchbase.client.java.manager.bucket.DropBucketOptions.dropBucketOptions;
 import static com.couchbase.client.java.manager.bucket.FlushBucketOptions.flushBucketOptions;
@@ -115,18 +116,25 @@ private UrlQueryStringBuilder convertSettingsToParams(final BucketSettings setti
     UrlQueryStringBuilder params = UrlQueryStringBuilder.createForUrlSafeNames();
 
     params.add("ramQuotaMB", settings.ramQuotaMB());
-    params.add("replicaNumber", settings.numReplicas());
+    if (settings.bucketType() != MEMCACHED) {
+      params.add("replicaNumber", settings.numReplicas());
+    }
     params.add("flushEnabled", settings.flushEnabled() ? 1 : 0);
     params.add("maxTTL", settings.maxExpiry().getSeconds());
-    params.add("evictionPolicy", settings.ejectionPolicy().alias());
+    if (settings.evictionPolicy() != null) {
+      // let server assign the default policy for this bucket type
+      params.add("evictionPolicy", settings.evictionPolicy().alias());
+    }
     params.add("compressionMode", settings.compressionMode().alias());
 
     // The following values must not be changed on update
     if (!update) {
       params.add("name", settings.name());
       params.add("bucketType", settings.bucketType().alias());
       params.add("conflictResolutionType", settings.conflictResolutionType().alias());
-      params.add("replicaIndex", settings.replicaIndexes() ? 1 : 0);
+      if (settings.bucketType() != BucketType.EPHEMERAL) {
+        params.add("replicaIndex", settings.replicaIndexes() ? 1 : 0);
+      }
     }
 
     return params;

java-client/src/main/java/com/couchbase/client/java/manager/bucket/BucketSettings.java

@@ -42,7 +42,7 @@ public class BucketSettings {
   private CompressionMode compressionMode = CompressionMode.PASSIVE;
   private BucketType bucketType = BucketType.COUCHBASE;
   private ConflictResolutionType conflictResolutionType = ConflictResolutionType.SEQUENCE_NUMBER;
-  private EjectionPolicy evictionPolicy = EjectionPolicy.VALUE_ONLY;
+  private EvictionPolicyType evictionPolicy = null; // null means default for the bucket type
   private boolean healthy = true;
 
   public static BucketSettings create(final String name) {
@@ -81,7 +81,7 @@ public BucketSettings(
     @JsonProperty("compressionMode") final CompressionMode compressionMode,
     @JsonProperty("bucketType") final BucketType bucketType,
     @JsonProperty("conflictResolutionType") final ConflictResolutionType conflictResolutionType,
-    @JsonProperty("evictionPolicy") final EjectionPolicy evictionPolicy
+    @JsonProperty("evictionPolicy") final EvictionPolicyType evictionPolicy
   ) {
     this.name = name;
     this.flushEnabled = controllers.containsKey("flush");
@@ -161,7 +161,15 @@ public ConflictResolutionType conflictResolutionType() {
     return conflictResolutionType;
   }
 
+  /**
+   * @deprecated Please use {@link #evictionPolicy} instead.
+   */
+  @Deprecated
   public EjectionPolicy ejectionPolicy() {
+    return EjectionPolicy.of(evictionPolicy);
+  }
+
+  public EvictionPolicyType evictionPolicy() {
     return evictionPolicy;
   }
 
@@ -223,8 +231,21 @@ public BucketSettings conflictResolutionType(ConflictResolutionType conflictReso
     return this;
   }
 
+  /**
+   * @param ejectionPolicy (nullable) policy to use, or null for default policy for the bucket type.
+   * @deprecated Please use {@link #evictionPolicy} instead.
+   */
+  @Deprecated
   public BucketSettings ejectionPolicy(EjectionPolicy ejectionPolicy) {
-    this.evictionPolicy = requireNonNull(ejectionPolicy);
+    this.evictionPolicy = ejectionPolicy == null ? null : ejectionPolicy.toEvictionPolicy();
+    return this;
+  }
+
+  /**
+   * @param evictionPolicy (nullable) policy to use, or null for default policy for the bucket type.
+   */
+  public BucketSettings evictionPolicy(EvictionPolicyType evictionPolicy) {
+    this.evictionPolicy = evictionPolicy;
     return this;
   }
 

java-client/src/main/java/com/couchbase/client/java/manager/bucket/EjectionPolicy.java

@@ -17,21 +17,88 @@
 package com.couchbase.client.java.manager.bucket;
 
 import com.couchbase.client.core.annotation.Stability;
-import com.couchbase.client.core.deps.com.fasterxml.jackson.annotation.JsonProperty;
+import com.couchbase.client.core.deps.com.fasterxml.jackson.annotation.JsonValue;
 
+/**
+ * @deprecated Please use {@link EvictionPolicyType} instead.
+ */
 @Stability.Volatile
+@Deprecated
 public enum EjectionPolicy {
-  @JsonProperty("valueOnly") VALUE_ONLY("valueOnly"),
-  @JsonProperty("fullEviction") FULL("fullEviction");
+  /**
+   * During ejection, only the value will be ejected (key and metadata will remain in memory).
+   * <p>
+   * Value Ejection needs more system memory, but provides better performance than Full Ejection.
+   * <p>
+   * This value is only valid for buckets of type {@link BucketType#COUCHBASE}.
+   */
+  VALUE_ONLY("valueOnly"),
+
+  /**
+   * During ejection, everything (including key, metadata, and value) will be ejected.
+   * <p>
+   * Full Ejection reduces the memory overhead requirement, at the cost of performance.
+   * <p>
+   * This value is only valid for buckets of type {@link BucketType#COUCHBASE}.
+   */
+  FULL("fullEviction"),
+
+  /**
+   * Couchbase Server keeps all data until explicitly deleted, but will reject
+   * any new data if you reach the quota (dedicated memory) you set for your bucket.
+   * <p>
+   * This value is only valid for buckets of type {@link BucketType#EPHEMERAL}.
+   */
+  NO_EVICTION("noEviction"),
+
+  /**
+   * When the memory quota is reached, Couchbase Server ejects data that has
+   * not been used recently.
+   * <p>
+   * This value is only valid for buckets of type {@link BucketType#EPHEMERAL}.
+   */
+  NOT_RECENTLY_USED("nruEviction");
 
   private final String alias;
 
   EjectionPolicy(String alias) {
     this.alias = alias;
   }
 
+  @JsonValue
   public String alias() {
     return alias;
   }
 
+  @Stability.Internal
+  static EjectionPolicy of(EvictionPolicyType evictionPolicy) {
+    switch (evictionPolicy) {
+      case FULL:
+        return FULL;
+      case VALUE_ONLY:
+        return VALUE_ONLY;
+      case NO_EVICTION:
+        return NO_EVICTION;
+      case NOT_RECENTLY_USED:
+        return NOT_RECENTLY_USED;
+      default:
+        throw new RuntimeException("Unrecognized EvictionPolicyType alias: " + evictionPolicy.alias());
+    }
+  }
+
+  @Stability.Internal
+  EvictionPolicyType toEvictionPolicy() {
+    switch (this) {
+      case FULL:
+        return EvictionPolicyType.FULL;
+      case VALUE_ONLY:
+        return EvictionPolicyType.VALUE_ONLY;
+      case NO_EVICTION:
+        return EvictionPolicyType.NO_EVICTION;
+      case NOT_RECENTLY_USED:
+        return EvictionPolicyType.NOT_RECENTLY_USED;
+      default:
+        throw new RuntimeException("Don't know how to convert " + this + " to " + EvictionPolicyType.class.getSimpleName());
+    }
+  }
 }