private CouchbaseCluster createCouchbaseCluster() { return CouchbaseCluster.create(getCouchbaseEnvironment(), getContainerIpAddress()); }
@Override public Bucket openBucket(String bucketName){ if (bucketPasswords.containsKey(bucketName)) { return cluster.openBucket(bucketName, bucketPasswords.get(bucketName)); } return cluster.openBucket(bucketName); }
public void createBucket(BucketSettings bucketSetting, UserSettings userSettings, boolean primaryIndex) { ClusterManager clusterManager = getCouchbaseCluster().clusterManager(clusterUsername, clusterPassword); // Insert Bucket BucketSettings bucketSettings = clusterManager.insertBucket(bucketSetting); try { // Insert Bucket user clusterManager.upsertUser(AuthDomain.LOCAL, bucketSetting.name(), userSettings); } catch (Exception e) { logger().warn("Unable to insert user '" + bucketSetting.name() + "', maybe you are using older version"); } if (index) { Bucket bucket = getCouchbaseCluster().openBucket(bucketSettings.name(), bucketSettings.password()); new CouchbaseQueryServiceWaitStrategy(bucket).waitUntilReady(this); if (primaryIndex) { bucket.query(Index.createPrimaryIndex().on(bucketSetting.name())); } } }
CouchbaseCluster cluster = CouchbaseCluster.fromConnectionString(cenv, cstrworkaround); serviceKey.generate(CouchbaseCluster.class, dbname, k -> binder.bind(k).toInstance(cluster)); .clusterManager( conf.getString("couchbase.cluster.username"), conf.getString("couchbase.cluster.password")); .orElse(null); buckets.forEach(name -> { Bucket bucket = cluster.openBucket(name, password.apply(name)); log.debug(" bucket opened: {}", name); bind.apply(Bucket.class, "session", cluster.openBucket(session, password.apply(session)));
/** * Establish a connection to a Couchbase cluster. * @param context the configuration context * @throws InitializationException if unable to connect a Couchbase cluster */ @OnEnabled public void onConfigured(final ConfigurationContext context) throws InitializationException { bucketPasswords = new HashMap<>(); for(PropertyDescriptor p : context.getProperties().keySet()){ if(p.isDynamic() && p.getName().startsWith(DYNAMIC_PROP_BUCKET_PASSWORD)){ String bucketName = p.getName().substring(DYNAMIC_PROP_BUCKET_PASSWORD.length()); String password = context.getProperty(p).evaluateAttributeExpressions().getValue(); bucketPasswords.put(bucketName, password); } } final String userName = context.getProperty(USER_NAME).evaluateAttributeExpressions().getValue(); final String userPassword = context.getProperty(USER_PASSWORD).evaluateAttributeExpressions().getValue(); try { cluster = CouchbaseCluster.fromConnectionString(context.getProperty(CONNECTION_STRING).evaluateAttributeExpressions().getValue()); if (!StringUtils.isEmpty(userName) && !StringUtils.isEmpty(userPassword)) { cluster.authenticate(userName, userPassword); } } catch(CouchbaseException e) { throw new InitializationException(e); } }
.connectTimeout(TimeUnit.SECONDS.toMillis(15)) .bootstrapCarrierEnabled(true).build(); CouchbaseCluster cbCluster = CouchbaseCluster.create(cbEnv, "localhost"); Bucket bucket = cbCluster.openBucket("default",""); try { JsonObject content = JsonObject.empty().put("name", "Michael");
@Override protected boolean initiateClient() { for (String host : hosts) { if (host == null) { LOGGER.error("Host Name should not be null."); throw new IllegalArgumentException("Host Name should not be null."); } } cluster = CouchbaseCluster.create(hosts); if (userName != null && password != null) { clusterManager = cluster.clusterManager(userName, password); } else { clusterManager = cluster.clusterManager(); } return true; }
public static CouchbaseCluster createCluster(CouchbaseConfig config, CouchbaseEnvironment couchbaseEnvironment) { final CouchbaseCluster cluster = CouchbaseCluster.create(couchbaseEnvironment, config.hosts()); cluster.authenticate(config.username(), config.password()); return cluster; }
LOGGER.info("Initializing connectivity from ConnectionString..."); if (couchBaseEnvironment != null) { this.couchBaseCluster = CouchbaseCluster.fromConnectionString(couchBaseEnvironment, connectionString); } else { this.couchBaseCluster = CouchbaseCluster.fromConnectionString(connectionString); LOGGER.info("Initializing connectivity from Nodes..."); if (couchBaseEnvironment != null) { this.couchBaseCluster = CouchbaseCluster.create(couchBaseEnvironment, clusterNodes.toArray(new String[0])); } else { this.couchBaseCluster = CouchbaseCluster.create(clusterNodes.toArray(new String[0])); LOGGER.info("Initializing connectivity (Default conf)"); if (couchBaseEnvironment != null) { this.couchBaseCluster = CouchbaseCluster.create(couchBaseEnvironment); } else { this.couchBaseCluster = CouchbaseCluster.create();
public static int getVersion(CouchbaseContainer couchbase) { return couchbase.getCouchbaseCluster().clusterManager(USERNAME, PASSWORD).info(1, TimeUnit.SECONDS).getMinVersion().major(); }
private static void run(ConnectorConfig config, boolean catchUp) throws IOException { final CouchbaseEnvironment env = environmentBuilder(config.couchbase(), config.trustStore()).build(); final CouchbaseCluster cluster = createCluster(config.couchbase(), env); try { final Bucket bucket = cluster.openBucket(config.couchbase().bucket()); final CouchbaseBucketConfig bucketConfig = getBucketConfig(bucket); final CheckpointDao checkpointDao = new CouchbaseCheckpointDao(bucket, config.group().name()); if (catchUp) { setCheckpointToNow(config, checkpointDao); System.out.println("Set checkpoint for connector '" + config.group().name() + "' to match current state of Couchbase bucket."); } else { final int numVbuckets = bucketConfig.numberOfPartitions(); final Set<Integer> vbuckets = IntStream.range(0, numVbuckets).boxed().collect(toSet()); checkpointDao.clear(bucketConfig.uuid(), vbuckets); System.out.println("Cleared checkpoint for connector '" + config.group().name() + "'."); } } finally { cluster.disconnect(); env.shutdown(); } }
public static Bucket getCouchbaseBucket(CouchbaseContainer couchbase) { int version = getVersion(couchbase); if (version == 4) { return couchbase.getCouchbaseCluster().openBucket(BUCKET_NAME, PASSWORD); } else { return couchbase.getCouchbaseCluster().authenticate(USERNAME, PASSWORD).openBucket(BUCKET_NAME); } }
/** * Disconnect from the Couchbase cluster. */ @OnDisabled public void shutdown() { if(cluster != null){ cluster.disconnect(); cluster = null; } }
public static CouchbaseCluster getCouchbaseCluster(String database, CouchbaseCluster couchbaseCluster, String user, String password) { Objects.requireNonNull(database, "database is required"); CouchbaseCluster authenticate = couchbaseCluster.authenticate(user, password); /* ClusterManager clusterManager = authenticate.clusterManager(); List<BucketSettings> buckets = clusterManager.getBuckets(); if(buckets.stream().noneMatch(b -> b.name().equals(database))) { BucketSettings bucketSettings = DefaultBucketSettings.builder().name(database).quota(100); clusterManager.insertBucket(bucketSettings); Bucket bucket = authenticate.openBucket(database); bucket.query(N1qlQuery.simple("CREATE PRIMARY INDEX index_" + database + " on " + database)); bucket.close(); }*/ return authenticate; }
@Override public void close() { couchbaseCluster.clusterManager(); } }
private void stopCluster() { getCouchbaseCluster().disconnect(); getCouchbaseEnvironment().shutdown(); }
public CouchbaseWriter(CouchbaseEnvironment couchbaseEnvironment, Config config) { List<String> hosts = ConfigUtils.getStringList(config, CouchbaseWriterConfigurationKeys.BOOTSTRAP_SERVERS); String password = ConfigUtils.getString(config, CouchbaseWriterConfigurationKeys.PASSWORD, ""); String bucketName = ConfigUtils.getString(config, CouchbaseWriterConfigurationKeys.BUCKET, CouchbaseWriterConfigurationKeys.BUCKET_DEFAULT); _cluster = CouchbaseCluster.create(couchbaseEnvironment, hosts); if(!password.isEmpty()) { _bucket = _cluster.openBucket(bucketName, password, Collections.<Transcoder<? extends Document, ?>>singletonList(_tupleDocumentTranscoder)); } else { _bucket = _cluster.openBucket(bucketName, Collections.<Transcoder<? extends Document, ?>>singletonList(_tupleDocumentTranscoder)); } _operationTimeout = ConfigUtils.getLong(config, CouchbaseWriterConfigurationKeys.OPERATION_TIMEOUT_MILLIS, CouchbaseWriterConfigurationKeys.OPERATION_TIMEOUT_DEFAULT); _operationTimeunit = TimeUnit.MILLISECONDS; _defaultWriteResponseMapper = new GenericWriteResponseWrapper<>(); log.info("Couchbase writer configured with: hosts: {}, bucketName: {}, operationTimeoutInMillis: {}", hosts, bucketName, _operationTimeout); }
private Bucket openBucket(String bucketName, String password) { CouchbaseCluster cluster = getCouchbaseContainer().getCouchbaseCluster(); return cluster.openBucket(bucketName, password); } }
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); } }
public static Version requireCouchbaseVersion(CouchbaseCluster cluster, Version requiredVersion) { final Version actualVersion = cluster.clusterManager().info().getMinVersion(); if (actualVersion.compareTo(requiredVersion) < 0) { throw new RuntimeException("Couchbase Server version " + requiredVersion + " or later required; actual version is " + actualVersion); } return actualVersion; } }