下面列出了com.fasterxml.jackson.core.util.BufferRecycler#com.mongodb.MongoClientSettings 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
/**
* This method also is responsible for caching the {@code resumeAfter} value for the change
* stream.
*/
private void setCachedResultAndResumeToken() {
MongoChangeStreamCursor<ChangeStreamDocument<Document>> changeStreamCursor =
getChangeStreamIterable(sourceConfig, mongoClient).cursor();
ChangeStreamDocument<Document> firstResult = changeStreamCursor.tryNext();
if (firstResult != null) {
cachedResult =
new BsonDocumentWrapper<>(
firstResult,
ChangeStreamDocument.createCodec(
Document.class, MongoClientSettings.getDefaultCodecRegistry()));
}
cachedResumeToken =
firstResult != null ? firstResult.getResumeToken() : changeStreamCursor.getResumeToken();
changeStreamCursor.close();
}
/**
* Get default mongodb database reference or initiate it if not initialized.
*
* @param connectionString MongoDB standard connection string
* @param database mongodb database name
* @return MongoDB mongodb client database reference.
*/
public static MongoDatabase getOrInitDefaultDatabase(String connectionString, String database) {
if (DEFAULT_DATABASE == null) {
synchronized (LOCK) {
if (DEFAULT_DATABASE == null) {
if (!StringUtil.isEmpty(connectionString)) {
DEFAULT_CLIENT = MongoClients.create(connectionString);
CodecRegistry pojoCodecRegistry = fromRegistries(
/*fromCodecs(new StringCodecExt()),*/
MongoClientSettings.getDefaultCodecRegistry(),
fromProviders(PojoCodecProvider.builder().automatic(true).build()));
DEFAULT_DATABASE = DEFAULT_CLIENT.getDatabase(database).withCodecRegistry(pojoCodecRegistry);
} else {
throw new RuntimeException("No datasource configuration found for mongodb.");
}
}
}
}
return DEFAULT_DATABASE;
}
private static MongoClient getClient(Boolean useCredentials, String replicaSet) {
MongoClientSettings.Builder settings = MongoClientSettings.builder();
if (useCredentials) {
MongoCredential credentials = MongoCredential.createCredential(
USER, ADMIN_DB, PASSWORD.toCharArray());
settings.credential(credentials);
}
StringBuilder connectionString = new StringBuilder(String.format("mongodb://%s:%d", HOST, PORT));
if (replicaSet != null) {
connectionString.append(String.format("/?replicaSet=%s", REPLICA_SET));
}
ConnectionString uri = new ConnectionString(connectionString.toString());
settings.applyConnectionString(uri);
settings.readPreference(ReadPreference.primaryPreferred());
return MongoClients.create(settings.build());
}
private DatabaseManager() {
final MongoClientSettings.Builder settingsBuilder = MongoClientSettings.builder()
.codecRegistry(CODEC_REGISTRY)
.applicationName(String.format("Shadbot V%s", Config.VERSION));
if (!Config.IS_SNAPSHOT) {
final String username = CredentialManager.getInstance().get(Credential.DATABASE_USERNAME);
final String pwd = CredentialManager.getInstance().get(Credential.DATABASE_PWD);
final String host = CredentialManager.getInstance().get(Credential.DATABASE_HOST);
final String port = CredentialManager.getInstance().get(Credential.DATABASE_PORT);
if (username != null && pwd != null && host != null && port != null) {
settingsBuilder.applyConnectionString(new ConnectionString(
String.format("mongodb://%s:%[email protected]%s:%s/%s", username, pwd, host, port, Config.DATABASE_NAME)));
}
}
this.client = MongoClients.create(settingsBuilder.build());
final MongoDatabase database = this.client.getDatabase(Config.DATABASE_NAME);
this.premiumCollection = new PremiumCollection(database);
this.guildsCollection = new GuildsCollection(database);
this.lotteryCollection = new LotteryCollection(database);
this.usersCollection = new UsersCollection(database);
}
private List<String> getHostList(Object arg) {
if (!(arg instanceof MongoClientSettings)) {
return Collections.emptyList();
}
final MongoClientSettings mongoClientSettings = (MongoClientSettings) arg;
List<ServerAddress> lists = mongoClientSettings.getClusterSettings().getHosts();
final List<String> hostList = new ArrayList<String>();
for (ServerAddress sa : lists) {
final String hostAddress = HostAndPort.toHostAndPortString(sa.getHost(), sa.getPort());
hostList.add(hostAddress);
}
return hostList;
}
AggregationQuery(Query query, PathNaming pathNaming) {
this.query = maybeRewriteDistinctToGroupBy(query);
this.pathNaming = Objects.requireNonNull(pathNaming, "naming");
BiMap<Expression, String> biMap = HashBiMap.create();
List<Path> paths = Stream.concat(query.projections().stream(), Stream.concat(query.groupBy().stream(), query.collations().stream().map(Collation::expression)))
.map(AggregationQuery::extractPath).collect(Collectors.toList());
@SuppressWarnings("unchecked")
ExpressionNaming naming = ExpressionNaming.from(UniqueCachedNaming.of(paths.iterator()));
paths.forEach(p -> biMap.put(p, naming.name(p)));
this.projectionNaming = ExpressionNaming.from(UniqueCachedNaming.of(query.projections()));
this.naming = ImmutableBiMap.copyOf(biMap);
this.codecRegistry = MongoClientSettings.getDefaultCodecRegistry();
}
/**
* write with Jackson read with Bson.
* Inverse of {@link #bsonThenJackson(String)}
*/
private void jacksonThenBson(String json) throws IOException {
ObjectNode toWrite = maybeWrap(mapper.readTree(json));
BasicOutputBuffer buffer = new BasicOutputBuffer();
BsonWriter writer = new BsonBinaryWriter(buffer);
BsonGenerator generator = new BsonGenerator(0, writer);
// write with jackson
mapper.writeValue(generator, toWrite);
BsonBinaryReader reader = new BsonBinaryReader(ByteBuffer.wrap(buffer.toByteArray()));
// read with BSON
BsonDocument actual = MongoClientSettings.getDefaultCodecRegistry()
.get(BsonDocument.class)
.decode(reader, DecoderContext.builder().build());
// compare results
BsonDocument expected = BsonDocument.parse(toWrite.toString());
if (!expected.equals(actual)) {
check(maybeUnwrap(actual)).is(maybeUnwrap(expected));
Assertions.fail("Should have failed before");
}
}
/**
* write with BSON read with jackson.
* inverse of {@link #jacksonThenBson(String)}
*/
private void bsonThenJackson(String json) throws IOException {
ObjectNode toWrite = maybeWrap(mapper.readTree(json));
BasicOutputBuffer buffer = new BasicOutputBuffer();
BsonWriter writer = new BsonBinaryWriter(buffer);
// write with BSON
BsonDocument expected = BsonDocument.parse(toWrite.toString());
MongoClientSettings.getDefaultCodecRegistry().get(BsonDocument.class)
.encode(writer, expected, EncoderContext.builder().build());
BsonBinaryReader reader = new BsonBinaryReader(ByteBuffer.wrap(buffer.toByteArray()));
IOContext ioContext = new IOContext(new BufferRecycler(), null, false);
BsonParser parser = new BsonParser(ioContext, 0, reader);
// read with jackson
BsonDocument actual = BsonDocument.parse(mapper.readValue(parser, JsonNode.class).toString());
if (!actual.equals(expected)) {
check(maybeUnwrap(actual)).is(maybeUnwrap(expected));
Assertions.fail("Should have failed before");
}
}
protected TestBase() {
Builder builder = MongoClientSettings.builder();
try {
builder.uuidRepresentation(mapperOptions.getUuidRepresentation());
} catch(Exception ignored) {
// not a 4.0 driver
}
MongoClientSettings clientSettings = builder
.applyConnectionString(new ConnectionString(getMongoURI()))
.build();
this.mongoClient = MongoClients.create(clientSettings);
this.database = getMongoClient().getDatabase(TEST_DB_NAME);
this.ds = Morphia.createDatastore(getMongoClient(), database.getName());
ds.setQueryFactory(new DefaultQueryFactory());
}
private MongoDb4Provider(final String connectionStringSource, final boolean isCapped,
final Integer collectionSize) {
LOGGER.debug("Creating ConnectionString {}...", connectionStringSource);
this.connectionString = new ConnectionString(connectionStringSource);
LOGGER.debug("Created ConnectionString {}", connectionString);
LOGGER.debug("Creating MongoClientSettings...");
// @formatter:off
final MongoClientSettings settings = MongoClientSettings.builder()
.applyConnectionString(this.connectionString)
.codecRegistry(CODEC_REGISTRIES)
.build();
// @formatter:on
LOGGER.debug("Created MongoClientSettings {}", settings);
LOGGER.debug("Creating MongoClient {}...", settings);
this.mongoClient = MongoClients.create(settings);
LOGGER.debug("Created MongoClient {}", mongoClient);
String databaseName = this.connectionString.getDatabase();
LOGGER.debug("Getting MongoDatabase {}...", databaseName);
this.mongoDatabase = this.mongoClient.getDatabase(databaseName);
LOGGER.debug("Got MongoDatabase {}", mongoDatabase);
this.isCapped = isCapped;
this.collectionSize = collectionSize;
}
static MongoClient mongoClient(String connectionString, int connectionTimeoutSeconds) {
MongoClientSettings settings = MongoClientSettings
.builder()
.applyConnectionString(new ConnectionString(connectionString))
.applyToClusterSettings(b -> {
b.serverSelectionTimeout(connectionTimeoutSeconds, SECONDS);
})
.build();
return MongoClients.create(settings);
}
@Override
public void initialize(GenericApplicationContext context) {
context.registerBean(MongoClientSettingsBuilderCustomizer.class, () -> new MongoReactiveAutoConfiguration.NettyDriverConfiguration().nettyDriverCustomizer(context.getDefaultListableBeanFactory().getBeanProvider(MongoClientSettings.class)));
MongoReactiveAutoConfiguration configuration = new MongoReactiveAutoConfiguration();
context.registerBean(MongoClient.class, () -> configuration.reactiveStreamsMongoClient(this.properties, context.getEnvironment(), context.getBeanProvider(MongoClientSettingsBuilderCustomizer.class), context.getBeanProvider(MongoClientSettings.class)), (definition) -> {
if (embeddedServer) {
definition.setDependsOn("embeddedMongoServer");
}
});
}
@Bean
MongoClient mongoClient(MongoProperties properties) {
ConnectionString connectionString = new ConnectionString(properties.determineUri());
MongoClientSettings.Builder builder = MongoClientSettings
.builder()
.streamFactoryFactory(NettyStreamFactory::new)
.applyToClusterSettings(b -> b.applyConnectionString(connectionString))
.applyToConnectionPoolSettings(b -> b.applyConnectionString(connectionString))
.applyToServerSettings(b -> b.applyConnectionString(connectionString))
.applyToSslSettings(b -> b.applyConnectionString(connectionString))
.applyToSocketSettings(b -> b.applyConnectionString(connectionString))
.codecRegistry(fromRegistries(
MongoClients.getDefaultCodecRegistry(),
fromProviders(PojoCodecProvider.builder()
.automatic(true)
.register(News.class)
.build())
));
if (connectionString.getReadPreference() != null) {
builder.readPreference(connectionString.getReadPreference());
}
if (connectionString.getReadConcern() != null) {
builder.readConcern(connectionString.getReadConcern());
}
if (connectionString.getWriteConcern() != null) {
builder.writeConcern(connectionString.getWriteConcern());
}
if (connectionString.getApplicationName() != null) {
builder.applicationName(connectionString.getApplicationName());
}
return MongoClients.create(builder.build());
}
default MongoClient mongoClient() {
ConnectionString connectionString = new ConnectionString("mongodb://localhost/news");
MongoClientSettings.Builder builder = MongoClientSettings.builder()
.streamFactoryFactory(NettyStreamFactory::new)
.applyToClusterSettings((cs) -> cs
.applyConnectionString(connectionString))
.applyToConnectionPoolSettings(cps -> cps
.applyConnectionString(connectionString))
.applyToServerSettings(ss -> ss
.applyConnectionString(connectionString))
// TODO: Do not work with JDK11 without the next line being commented (null is not allowed)
//.credential(connectionString.getCredential())
.applyToSslSettings(ss -> ss
.applyConnectionString(connectionString))
.applyToSocketSettings(ss -> ss
.applyConnectionString(connectionString))
.codecRegistry(fromRegistries(
MongoClients.getDefaultCodecRegistry(),
fromProviders(PojoCodecProvider.builder()
.automatic(true)
.register(News.class)
.build())
));
if (connectionString.getReadPreference() != null) {
builder.readPreference(connectionString.getReadPreference());
}
if (connectionString.getReadConcern() != null) {
builder.readConcern(connectionString.getReadConcern());
}
if (connectionString.getWriteConcern() != null) {
builder.writeConcern(connectionString.getWriteConcern());
}
if (connectionString.getApplicationName() != null) {
builder.applicationName(connectionString.getApplicationName());
}
return MongoClients.create(builder.build());
}
private static void initializeReplicaSet(final List<IMongodConfig> mongodConfigList) throws UnknownHostException {
final String arbitrerAddress = "mongodb://" + mongodConfigList.get(0).net().getServerAddress().getHostName() + ":"
+ mongodConfigList.get(0).net().getPort();
final MongoClientSettings mo = MongoClientSettings.builder()
.applyConnectionString(new ConnectionString(arbitrerAddress)).build();
try (MongoClient mongo = MongoClients.create(mo)) {
final MongoDatabase mongoAdminDB = mongo.getDatabase("admin");
Document cr = mongoAdminDB.runCommand(new Document("isMaster", 1));
LOGGER.infof("isMaster: %s", cr);
// Build replica set configuration settings
final Document rsConfiguration = buildReplicaSetConfiguration(mongodConfigList);
LOGGER.infof("replSetSettings: %s", rsConfiguration);
// Initialize replica set
cr = mongoAdminDB.runCommand(new Document("replSetInitiate", rsConfiguration));
LOGGER.infof("replSetInitiate: %s", cr);
// Check replica set status before to proceed
await()
.pollInterval(100, TimeUnit.MILLISECONDS)
.atMost(1, TimeUnit.MINUTES)
.until(() -> {
Document result = mongoAdminDB.runCommand(new Document("replSetGetStatus", 1));
LOGGER.infof("replSetGetStatus: %s", result);
return !isReplicaSetStarted(result);
});
}
}
public ReactiveMongoClient createReactiveMongoClient(String clientName)
throws MongoException {
MongoClientSettings mongoConfiguration = createMongoConfiguration(getMatchingMongoClientConfig(clientName));
com.mongodb.reactivestreams.client.MongoClient client = com.mongodb.reactivestreams.client.MongoClients
.create(mongoConfiguration);
ReactiveMongoClientImpl reactive = new ReactiveMongoClientImpl(client);
reactiveMongoClients.put(clientName, reactive);
return reactive;
}
private static void initializeReplicaSet(final List<IMongodConfig> mongodConfigList) throws UnknownHostException {
final String arbitrerAddress = "mongodb://" + mongodConfigList.get(0).net().getServerAddress().getHostName() + ":"
+ mongodConfigList.get(0).net().getPort();
final MongoClientSettings mo = MongoClientSettings.builder()
.applyConnectionString(new ConnectionString(arbitrerAddress)).build();
try (MongoClient mongo = MongoClients.create(mo)) {
final MongoDatabase mongoAdminDB = mongo.getDatabase("admin");
Document cr = mongoAdminDB.runCommand(new Document("isMaster", 1));
LOGGER.infof("isMaster: %s", cr);
// Build replica set configuration settings
final Document rsConfiguration = buildReplicaSetConfiguration(mongodConfigList);
LOGGER.infof("replSetSettings: %s", rsConfiguration);
// Initialize replica set
cr = mongoAdminDB.runCommand(new Document("replSetInitiate", rsConfiguration));
LOGGER.infof("replSetInitiate: %s", cr);
// Check replica set status before to proceed
await()
.pollInterval(100, TimeUnit.MILLISECONDS)
.atMost(1, TimeUnit.MINUTES)
.until(() -> {
Document result = mongoAdminDB.runCommand(new Document("replSetGetStatus", 1));
LOGGER.infof("replSetGetStatus: %s", result);
return !isReplicaSetStarted(result);
});
}
}
@Override
public void customize(ComponentProxyComponent component, Map<String, Object> options) {
MongoCustomizersUtil.replaceAdminDBIfMissing(options);
// Set connection parameter
if (!options.containsKey("mongoConnection")) {
if (options.containsKey("user") && options.containsKey("password")
&& options.containsKey("host")) {
ConnectionParamsConfiguration mongoConf = new ConnectionParamsConfiguration(cast(options));
// We need to force consumption in order to perform property placeholder done by Camel
consumeOption(camelContext, options, "password", String.class, mongoConf::setPassword);
LOGGER.debug("Creating and registering a client connection to {}", mongoConf);
MongoClientSettings.Builder settings = MongoClientSettings.builder();
MongoCredential credentials = MongoCredential.createCredential(
mongoConf.getUser(),
mongoConf.getAdminDB(),
mongoConf.getPassword().toCharArray());
ConnectionString uri = new ConnectionString(mongoConf.getMongoClientURI());
settings.applyConnectionString(uri);
settings.credential(credentials);
MongoClient mongoClient = MongoClients.create(settings.build());
options.put("mongoConnection", mongoClient);
if (!options.containsKey("connectionBean")) {
//We safely put a default name instead of leaving null
options.put("connectionBean", String.format("%s-%s", mongoConf.getHost(), mongoConf.getUser()));
}
} else {
LOGGER.warn(
"Not enough information provided to set-up the MongoDB client. Required at least host, user and " +
"password.");
}
}
}
/**
* Returns the local collection representing the given namespace for raw document operations.
*
* @param namespace the namespace referring to the local collection.
* @return the local collection representing the given namespace for raw document operations.
*/
MongoCollection<BsonDocument> getLocalCollection(final MongoNamespace namespace) {
return getLocalCollection(
namespace,
BsonDocument.class,
MongoClientSettings.getDefaultCodecRegistry());
}
private MongoClientWrapperBuilder() {
mongoClientSettingsBuilder = MongoClientSettings.builder();
mongoClientSettingsBuilder.readPreference(ReadPreference.primaryPreferred());
dittoMongoClientSettingsBuilder = DittoMongoClientSettings.getBuilder();
connectionString = null;
defaultDatabaseName = null;
sslEnabled = false;
eventLoopGroup = null;
}
private MongoDatabase createDatabase(CodecRegistry registry) {
if (uri == null) throw new Error("uri must not be null");
String database = uri.getDatabase();
if (database == null) throw new Error("uri must have database, uri=" + uri);
var watch = new StopWatch();
try {
connectionPoolSettings.maxWaitTime(timeoutInMs, TimeUnit.MILLISECONDS); // pool checkout timeout
var socketSettings = SocketSettings.builder()
.connectTimeout((int) timeoutInMs, TimeUnit.MILLISECONDS)
.readTimeout((int) timeoutInMs, TimeUnit.MILLISECONDS)
.build();
var clusterSettings = ClusterSettings.builder()
.serverSelectionTimeout(timeoutInMs * 3, TimeUnit.MILLISECONDS) // able to try 3 servers
.build();
var settings = MongoClientSettings.builder()
.applicationName(LogManager.APP_NAME)
.codecRegistry(registry)
.applyToConnectionPoolSettings(builder -> builder.applySettings(connectionPoolSettings.build()))
.applyToSocketSettings(builder -> builder.applySettings(socketSettings))
.applyToClusterSettings(builder -> builder.applySettings(clusterSettings))
.applyConnectionString(uri)
.build();
mongoClient = MongoClients.create(settings);
return mongoClient.getDatabase(database);
} finally {
logger.info("create mongo client, uri={}, elapsed={}", uri, watch.elapsed());
}
}
@Test
void append() {
var param = new BsonLogParam(Filters.eq("field", "value"), MongoClientSettings.getDefaultCodecRegistry());
var builder = new StringBuilder();
param.append(builder, Set.of(), 1000);
assertThat(builder.toString()).isEqualTo("{\"field\": \"value\"}");
}
@Override
@Bean
public com.mongodb.client.MongoClient mongoClient() {
final CodecRegistry pojoCodecRegistry = fromRegistries(MongoClient.getDefaultCodecRegistry(),
fromProviders(PojoCodecProvider.builder().automatic(true).build()));
final String connectionsString = String.format("mongodb://%s:%[email protected]%s:%s", this.username, this.password, this.host, this.port);
final MongoClientSettings settings = MongoClientSettings.builder()
.codecRegistry(pojoCodecRegistry)
.applyConnectionString(new ConnectionString(
connectionsString))
.build();
return MongoClients.create(settings);
}
@Override
public void customize(MongoClientSettings.Builder clientSettingsBuilder) {
super.customize(clientSettingsBuilder);
CommandListener listener = clientSettingsBuilder.build().getCommandListeners()
.get(0);
listener.commandStarted(new CommandStartedEvent(0, null, "", "",
BDDMockito.mock(BsonDocument.class)));
listener.commandSucceeded(new CommandSucceededEvent(1, null, "",
BDDMockito.mock(BsonDocument.class), 100));
}
public MongoClientImpl(Vertx vertx, JsonObject config, String dataSourceName, MongoClientSettings settings) {
Objects.requireNonNull(vertx);
Objects.requireNonNull(config);
Objects.requireNonNull(dataSourceName);
Objects.requireNonNull(settings);
this.vertx = (VertxInternal) vertx;
this.creatingContext = this.vertx.getOrCreateContext();
this.holder = lookupHolder(dataSourceName, config);
this.mongo = holder.mongo(vertx, settings);
this.useObjectId = config.getBoolean("useObjectId", false);
creatingContext.addCloseHook(this);
}
synchronized com.mongodb.reactivestreams.client.MongoClient mongo(Vertx vertx, MongoClientSettings settings) {
if (mongo == null) {
MongoClientOptionsParser parser = new MongoClientOptionsParser(vertx, config);
mongo = MongoClients.create(settings);
db = mongo.getDatabase(parser.database());
}
return mongo;
}
@Test
public void ssl_should_be_disabled_by_default() {
// given
final JsonObject configWithoutSSLInfo = new JsonObject().put(
"connection_string", "mongodb://localhost:27017/mydb?replicaSet=myRs"
);
// when
final MongoClientSettings parsedSettings = new MongoClientOptionsParser(vertx, configWithoutSSLInfo).settings();
// then
assertFalse(parsedSettings.getSslSettings().isEnabled());
assertFalse(parsedSettings.getSslSettings().isInvalidHostNameAllowed());
}
@Test
public void should_not_include_any_stream_type_by_default_for_backwards_compatibility() {
// given
final JsonObject noStreamTypeProvided = new JsonObject().put(
"connection_string", "mongodb://localhost:27017/mydb?replicaSet=myRs"
);
// when
final MongoClientSettings parsedSettings = new MongoClientOptionsParser(vertx, noStreamTypeProvided).settings();
// then
assertNull(parsedSettings.getStreamFactoryFactory());
}
@Parameters(method = "validSteamTypes")
@Test
public void should_parse_stream_type_from_config_property(String streamTypeString, Class<StreamFactoryFactory> streamType) {
// given
final JsonObject cfgWithStreamTypeProvided = new JsonObject().put("streamType", streamTypeString);
// when
final MongoClientSettings parsedSettings = new MongoClientOptionsParser(vertx, cfgWithStreamTypeProvided).settings();
// then
assertThat(parsedSettings.getStreamFactoryFactory(), instanceOf(streamType));
}
private String getReadPreference(Object arg) {
if (!(arg instanceof MongoClientSettings)) {
return null;
}
final MongoClientSettings mongoClientSettings = (MongoClientSettings) arg;
return mongoClientSettings.getReadPreference().getName();
}