How to use

DefaultBucketSettings$Builder

in

com.couchbase.client.java.cluster

/**
 * Adds the bucket.
 *
 * @param name
 *            the name
 */
private void addBucket(String name)
{
  String qouta = csmd.getBucketProperty("bucket.quota");
  int bucketQuota = qouta != null ? Integer.parseInt(qouta) : DEFAULT_RAM_SIZE_IN_MB;
  BucketSettings bucketSettings = new DefaultBucketSettings.Builder().type(BucketType.COUCHBASE).name(name)
      .quota(bucketQuota).build();
  try
  {
    clusterManager.insertBucket(bucketSettings);
    LOGGER.info("Bucket [" + name + "] is added!");
  }
  catch (CouchbaseException ex)
  {
    LOGGER.error("Not able to add bucket [" + name + "].", ex);
    throw new KunderaException("Not able to add bucket [" + name + "].", ex);
  }
}

private void connectToBucket() {
  if (createBucket) {
    final ClusterManager clusterManager = couchbaseCluster.clusterManager(this.clusterUsername, this.clusterPassword);
    if (! clusterManager.hasBucket(this.bucketName)) {
      // Create Bucket
      final DefaultBucketSettings defaultBucketSettings = DefaultBucketSettings.builder()
          .enableFlush(true)
          .name(bucketName).build();
      clusterManager.insertBucket(defaultBucketSettings);
      await()
          .atMost(30, TimeUnit.SECONDS)
          .until(() -> clusterManager.hasBucket(bucketName));
    }
  }
  if (this.bucketPassword != null) {
    this.bucket = couchbaseCluster.openBucket(this.bucketName, this.bucketPassword);
  } else {
    this.bucket = couchbaseCluster.openBucket(this.bucketName);
  }
}

private void createBucket(String database, Map<String, Object> customOptions) {
  final ClusterManager clusterManager = couchbaseCluster
    .clusterManager((String) customOptions.get(CouchbaseOptions.CLUSTER_USERNAME),
      (String) customOptions.get(CouchbaseOptions.CLUSTER_PASSWORD));
  if (!clusterManager.hasBucket(database)) {
    // Create Bucket
    final DefaultBucketSettings.Builder bucketBuilder = DefaultBucketSettings.builder()
      .enableFlush(true)
      .name(database);
    if (isBucketPasswordSet(customOptions)) {
      bucketBuilder.password((String) customOptions.get(CouchbaseOptions.BUCKET_PASSWORD));
    }
    clusterManager.insertBucket(bucketBuilder.build());
    await()
      .atMost(60, TimeUnit.SECONDS)
      .until(() -> clusterManager.hasBucket(database));
  }
}

private static CouchbaseContainer initCouchbaseContainer() {
  CouchbaseContainer couchbaseContainer = new CouchbaseContainer()
      .withNewBucket(DefaultBucketSettings.builder()
          .enableFlush(true)
          .name(TEST_BUCKET)
          .password(DEFAULT_PASSWORD)
          .quota(100)
          .replicas(0)
          .type(BucketType.COUCHBASE)
          .build());
  couchbaseContainer.start();
  return couchbaseContainer;
}

/**
 * Provides a builder to build the bucket settings.
 *
 * @return the bucket settings builder.
 */
public static Builder builder() {
  return new Builder();
}

private DefaultBucketSettings(Builder builder, JsonObject raw) {
  name = builder.name();
  type = builder.type();
  quota = builder.quota();
  port = builder.port();
  password = builder.password();
  replicas = builder.replicas();
  indexReplicas = builder.indexReplicas();
  enableFlush = builder.enableFlush();
  customSettings = builder.customSettings();
  compressionMode = builder.compressionMode();
  ejectionMethod = builder.ejectionMethod();
  this.raw = raw;
}

private void createBucket(ClusterManager clusterManager, CouchbaseBuildDefinition buildDefinition) {
  LOG.info("Creating bucket '{}'", buildDefinition.getBucketName());
  BucketSettings bucketSettings = new DefaultBucketSettings.Builder()
      .type(BucketType.COUCHBASE)
      .name(buildDefinition.getBucketName())
      .password(buildDefinition.getBucketPassword())
      .quota(buildDefinition.getBucketSizeInMB())
      .build();
  clusterManager.insertBucket(bucketSettings);
  LOG.debug("Bucket '{}' created", buildDefinition.getBucketName());
}

/**
 * Helper method to create bucket settings with a name and default settings.
 *
 * @param name the name of the bucket
 * @return bucket settings with defaults.
 */
public static DefaultBucketSettings create(final String name) {
  return builder().name(name).build();
}

      .withClusterAdmin(USERNAME, PASSWORD)
      .withNewBucket(DefaultBucketSettings.builder()
          .password(PASSWORD)
          .name(BUCKET_NAME)
          .quota(100)
          .type(BucketType.COUCHBASE)
          .build());
  couchbase.start();
}, Exception.class);

      .withClusterAdmin(USERNAME, PASSWORD)
      .withNewBucket(DefaultBucketSettings.builder()
          .password(PASSWORD)
          .name(BUCKET_NAME)
          .quota(100)
          .type(BucketType.COUCHBASE)
          .build());
  couchbase.start();
}, Exception.class);

      .withClusterAdmin(USERNAME, PASSWORD)
      .withNewBucket(DefaultBucketSettings.builder()
          .password(PASSWORD)
          .name(BUCKET_NAME)
          .quota(100)
          .type(BucketType.COUCHBASE)
          .build());
  couchbase.start();
}, Exception.class);

      .withClusterAdmin(USERNAME, PASSWORD)
      .withNewBucket(DefaultBucketSettings.builder()
          .password(PASSWORD)
          .name(BUCKET_NAME)
          .quota(100)
          .type(BucketType.COUCHBASE)
          .build());
  couchbase.start();
}, Exception.class);

@BeforeClass
public static void setUp() {
  TestUtil.ignoreException(() -> {
    couchbase = new CouchbaseContainer()
        .withClusterAdmin(USERNAME, PASSWORD)
        .withNewBucket(DefaultBucketSettings.builder()
            .password(PASSWORD)
            .name(BUCKET_NAME)
            .quota(100)
            .type(BucketType.COUCHBASE)
            .build());
    couchbase.start();
  }, Exception.class);
  assumeNotNull(couchbase);
  assumeTrue("couchbase must be running", couchbase.isRunning());
  boolean isFilled = fillDB(couchbase.getCouchbaseCluster());
  assumeTrue("should fill Couchbase with data", isFilled);
  HOST = getUrl(couchbase);
  couchbaseBucket = getCouchbaseBucket(couchbase);
  graphDB = new TestGraphDatabaseFactory().newImpermanentDatabaseBuilder()
      .setConfig("apoc." + CouchbaseManager.COUCHBASE_CONFIG_KEY + CONNECTION_TIMEOUT_CONFIG_KEY,
          CONNECTION_TIMEOUT_CONFIG_VALUE)
      .setConfig("apoc." + CouchbaseManager.COUCHBASE_CONFIG_KEY + SOCKET_CONNECT_TIMEOUT_CONFIG_KEY,
          SOCKET_CONNECT_TIMEOUT_CONFIG_VALUE)
      .setConfig("apoc." + CouchbaseManager.COUCHBASE_CONFIG_KEY + KV_TIMEOUT_CONFIG_KEY,
          KV_TIMEOUT_CONFIG_VALUE)
      .newGraphDatabase();
}

protected static BucketSettings getDefaultBucketSettings() {
  return DefaultBucketSettings.builder()
    .enableFlush(true)
    .name(TEST_BUCKET)
    .password(DEFAULT_PASSWORD)
    .quota(100)
    .replicas(0)
    .type(BucketType.COUCHBASE)
    .build();
}