Examples with ServerApi com.mongodb.ServerApi used on opensource projects

Example 1 with ServerApi

use of com.mongodb.ServerApi in project spring-data-mongodb by spring-projects.

the class MongoClientSettingsFactoryBean method createInstance.

@Override
protected MongoClientSettings createInstance() {
    Builder builder = // 
    MongoClientSettings.builder().readPreference(// 
    readPreference).writeConcern(// 
    writeConcern).readConcern(// 
    readConcern).codecRegistry(// 
    codecRegistry).applicationName(// 
    applicationName).autoEncryptionSettings(// 
    autoEncryptionSettings).applyToClusterSettings((settings) -> {
        settings.serverSelectionTimeout(clusterServerSelectionTimeoutMS, TimeUnit.MILLISECONDS);
        if (clusterConnectionMode != null) {
            settings.mode(clusterConnectionMode);
        }
        settings.requiredReplicaSetName(clusterRequiredReplicaSetName);
        if (!CollectionUtils.isEmpty(clusterHosts)) {
            settings.hosts(clusterHosts);
        }
        settings.localThreshold(clusterLocalThresholdMS, TimeUnit.MILLISECONDS);
        // settings.maxWaitQueueSize(clusterMaxWaitQueueSize);
        settings.requiredClusterType(custerRequiredClusterType);
        if (StringUtils.hasText(clusterSrvHost)) {
            settings.srvHost(clusterSrvHost);
        }
    }).applyToConnectionPoolSettings((settings) -> {
        settings.minSize(poolMinSize);
        settings.maxSize(poolMaxSize);
        settings.maxConnectionIdleTime(poolMaxConnectionIdleTimeMS, TimeUnit.MILLISECONDS);
        settings.maxWaitTime(poolMaxWaitTimeMS, TimeUnit.MILLISECONDS);
        settings.maxConnectionLifeTime(poolMaxConnectionLifeTimeMS, TimeUnit.MILLISECONDS);
        // settings.maxWaitQueueSize(poolMaxWaitQueueSize);
        settings.maintenanceFrequency(poolMaintenanceFrequencyMS, TimeUnit.MILLISECONDS);
        settings.maintenanceInitialDelay(poolMaintenanceInitialDelayMS, TimeUnit.MILLISECONDS);
    }).applyToServerSettings((settings) -> {
        settings.minHeartbeatFrequency(serverMinHeartbeatFrequencyMS, TimeUnit.MILLISECONDS);
        settings.heartbeatFrequency(serverHeartbeatFrequencyMS, TimeUnit.MILLISECONDS);
    }).applyToSocketSettings((settings) -> {
        settings.connectTimeout(socketConnectTimeoutMS, TimeUnit.MILLISECONDS);
        settings.readTimeout(socketReadTimeoutMS, TimeUnit.MILLISECONDS);
        settings.receiveBufferSize(socketReceiveBufferSize);
        settings.sendBufferSize(socketSendBufferSize);
    }).applyToSslSettings((settings) -> {
        settings.enabled(sslEnabled);
        if (sslEnabled) {
            settings.invalidHostNameAllowed(sslInvalidHostNameAllowed);
            try {
                settings.context(StringUtils.hasText(sslProvider) ? SSLContext.getInstance(sslProvider) : SSLContext.getDefault());
            } catch (NoSuchAlgorithmException e) {
                throw new IllegalArgumentException(e.getMessage(), e);
            }
        }
    });
    if (streamFactoryFactory != null) {
        builder = builder.streamFactoryFactory(streamFactoryFactory);
    }
    if (retryReads != null) {
        builder = builder.retryReads(retryReads);
    }
    if (retryWrites != null) {
        builder = builder.retryWrites(retryWrites);
    }
    if (uUidRepresentation != null) {
        builder = builder.uuidRepresentation(uUidRepresentation);
    }
    if (serverApi != null) {
        builder = builder.serverApi(serverApi);
    }
    return builder.build();
}

Example 2 with ServerApi

use of com.mongodb.ServerApi in project spring-data-mongodb by spring-projects.

the class MongoServerApiFactoryBeanTests method createsServerApiForVersionNumber.

// GH-3820
@Test
void createsServerApiForVersionNumber() {
    RootBeanDefinition definition = new RootBeanDefinition(MongoServerApiFactoryBean.class);
    definition.getPropertyValues().addPropertyValue("version", "1");
    definition.getPropertyValues().addPropertyValue("strict", "true");
    DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
    factory.registerBeanDefinition("factory", definition);
    MongoServerApiFactoryBean bean = factory.getBean("&factory", MongoServerApiFactoryBean.class);
    assertThat(ReflectionTestUtils.getField(bean, "strict")).isEqualTo(true);
    ServerApi target = factory.getBean(ServerApi.class);
    assertThat(target.getVersion()).isEqualTo(ServerApiVersion.V1);
    assertThat(target.getDeprecationErrors()).isNotPresent();
    assertThat(target.getStrict()).contains(true);
}

Example 3 with ServerApi

use of com.mongodb.ServerApi in project mongo-java-driver by mongodb.

the class CryptConnection method commandAsync.

@Override
public <T> void commandAsync(final String database, final BsonDocument command, final FieldNameValidator commandFieldNameValidator, final ReadPreference readPreference, final Decoder<T> commandResultDecoder, final SessionContext sessionContext, final ServerApi serverApi, final RequestContext requestContext, final boolean responseExpected, @Nullable final SplittablePayload payload, @Nullable final FieldNameValidator payloadFieldNameValidator, final SingleResultCallback<T> callback) {
    if (serverIsLessThanVersionFourDotTwo(wrapped.getDescription())) {
        callback.onResult(null, new MongoClientException("Auto-encryption requires a minimum MongoDB version of 4.2"));
        return;
    }
    try {
        BasicOutputBuffer bsonOutput = new BasicOutputBuffer();
        BsonBinaryWriter bsonBinaryWriter = new BsonBinaryWriter(new BsonWriterSettings(), new BsonBinaryWriterSettings(getDescription().getMaxDocumentSize()), bsonOutput, getFieldNameValidator(payload, commandFieldNameValidator, payloadFieldNameValidator));
        BsonWriter writer = payload == null ? bsonBinaryWriter : new SplittablePayloadBsonWriter(bsonBinaryWriter, bsonOutput, createSplittablePayloadMessageSettings(), payload, MAX_SPLITTABLE_DOCUMENT_SIZE);
        getEncoder(command).encode(writer, command, EncoderContext.builder().build());
        crypt.encrypt(database, new RawBsonDocument(bsonOutput.getInternalBuffer(), 0, bsonOutput.getSize())).flatMap((Function<RawBsonDocument, Mono<RawBsonDocument>>) encryptedCommand -> Mono.create(sink -> wrapped.commandAsync(database, encryptedCommand, commandFieldNameValidator, readPreference, new RawBsonDocumentCodec(), sessionContext, serverApi, requestContext, responseExpected, null, null, sinkToCallback(sink)))).flatMap(crypt::decrypt).map(decryptedResponse -> commandResultDecoder.decode(new BsonBinaryReader(decryptedResponse.getByteBuffer().asNIO()), DecoderContext.builder().build())).subscribe(decryptedResult -> callback.onResult(decryptedResult, null), e -> callback.onResult(null, e));
    } catch (Throwable t) {
        callback.onResult(null, t);
    }
}

Example 4 with ServerApi

use of com.mongodb.ServerApi in project mongo-java-driver by mongodb.

the class Entities method initClient.

private void initClient(final BsonDocument entity, final String id, final Function<MongoClientSettings, MongoClient> mongoClientSupplier, final boolean waitForPoolAsyncWorkManagerStart) {
    if (!SUPPORTED_CLIENT_ENTITY_OPTIONS.containsAll(entity.keySet())) {
        throw new UnsupportedOperationException("Client entity contains unsupported options: " + entity.keySet() + ". Supported options are " + SUPPORTED_CLIENT_ENTITY_OPTIONS);
    }
    MongoClientSettings.Builder clientSettingsBuilder;
    if (entity.getBoolean("useMultipleMongoses", BsonBoolean.FALSE).getValue() && (isSharded() || isLoadBalanced())) {
        assumeTrue("Multiple mongos connection string not available for sharded cluster", !isSharded() || getMultiMongosConnectionString() != null);
        assumeTrue("Multiple mongos connection string not available for load-balanced cluster", !isLoadBalanced() || getMultiMongosConnectionString() != null);
        clientSettingsBuilder = getMultiMongosMongoClientSettingsBuilder();
    } else {
        clientSettingsBuilder = getMongoClientSettingsBuilder();
    }
    if (entity.containsKey("observeEvents")) {
        List<String> ignoreCommandMonitoringEvents = entity.getArray("ignoreCommandMonitoringEvents", new BsonArray()).stream().map(type -> type.asString().getValue()).collect(Collectors.toList());
        ignoreCommandMonitoringEvents.add("configureFailPoint");
        TestCommandListener testCommandListener = new TestCommandListener(entity.getArray("observeEvents").stream().map(type -> type.asString().getValue()).collect(Collectors.toList()), ignoreCommandMonitoringEvents, entity.getBoolean("observeSensitiveCommands", BsonBoolean.FALSE).getValue());
        clientSettingsBuilder.addCommandListener(testCommandListener);
        putEntity(id + "-command-listener", testCommandListener, clientCommandListeners);
        TestConnectionPoolListener testConnectionPoolListener = new TestConnectionPoolListener(entity.getArray("observeEvents").stream().map(type -> type.asString().getValue()).collect(Collectors.toList()));
        clientSettingsBuilder.applyToConnectionPoolSettings(builder -> builder.addConnectionPoolListener(testConnectionPoolListener));
        putEntity(id + "-connection-pool-listener", testConnectionPoolListener, clientConnectionPoolListeners);
    } else {
        // Regardless of whether events are observed, we still need to track some info about the pool in order to implement
        // the assertNumberConnectionsCheckedOut operation
        TestConnectionPoolListener testConnectionPoolListener = new TestConnectionPoolListener();
        clientSettingsBuilder.applyToConnectionPoolSettings(builder -> builder.addConnectionPoolListener(testConnectionPoolListener));
        putEntity(id + "-connection-pool-listener", testConnectionPoolListener, clientConnectionPoolListeners);
    }
    if (entity.containsKey("storeEventsAsEntities")) {
        BsonArray storeEventsAsEntitiesArray = entity.getArray("storeEventsAsEntities");
        for (BsonValue eventValue : storeEventsAsEntitiesArray) {
            BsonDocument eventDocument = eventValue.asDocument();
            String key = eventDocument.getString("id").getValue();
            BsonArray eventList = eventDocument.getArray("events");
            List<BsonDocument> eventDocumentList = synchronizedList(new ArrayList<>());
            putEntity(key, eventDocumentList, eventsMap);
            if (eventList.stream().map(value -> value.asString().getValue()).anyMatch(value -> value.startsWith("Command"))) {
                clientSettingsBuilder.addCommandListener(new EntityCommandListener(eventList.stream().map(value -> value.asString().getValue()).collect(Collectors.toSet()), eventDocumentList));
            }
            if (eventList.stream().map(value -> value.asString().getValue()).anyMatch(value -> value.startsWith("Pool") || value.startsWith("Connection"))) {
                clientSettingsBuilder.applyToConnectionPoolSettings(builder -> builder.addConnectionPoolListener(new EntityConnectionPoolListener(eventList.stream().map(value -> value.asString().getValue()).collect(Collectors.toSet()), eventDocumentList)));
            }
        }
    }
    clientSettingsBuilder.applyToServerSettings(builder -> {
        builder.heartbeatFrequency(50, TimeUnit.MILLISECONDS);
        builder.minHeartbeatFrequency(50, TimeUnit.MILLISECONDS);
    });
    if (entity.containsKey("uriOptions")) {
        entity.getDocument("uriOptions").forEach((key, value) -> {
            switch(key) {
                case "retryReads":
                    clientSettingsBuilder.retryReads(value.asBoolean().getValue());
                    break;
                case "retryWrites":
                    clientSettingsBuilder.retryWrites(value.asBoolean().getValue());
                    break;
                case "readConcernLevel":
                    clientSettingsBuilder.readConcern(new ReadConcern(ReadConcernLevel.fromString(value.asString().getValue())));
                    break;
                case "w":
                    clientSettingsBuilder.writeConcern(new WriteConcern(value.asInt32().intValue()));
                    break;
                case "maxPoolSize":
                    clientSettingsBuilder.applyToConnectionPoolSettings(builder -> builder.maxSize(value.asNumber().intValue()));
                    break;
                case "waitQueueTimeoutMS":
                    clientSettingsBuilder.applyToConnectionPoolSettings(builder -> builder.maxWaitTime(value.asNumber().longValue(), TimeUnit.MILLISECONDS));
                    break;
                case "loadBalanced":
                    if (value.asBoolean().getValue()) {
                        clientSettingsBuilder.applyToClusterSettings(builder -> builder.mode(ClusterConnectionMode.LOAD_BALANCED));
                    }
                    break;
                case "appname":
                    clientSettingsBuilder.applicationName(value.asString().getValue());
                    break;
                default:
                    throw new UnsupportedOperationException("Unsupported uri option: " + key);
            }
        });
    }
    if (entity.containsKey("serverApi")) {
        BsonDocument serverApiDocument = entity.getDocument("serverApi");
        String apiVersion = serverApiDocument.getString("version").getValue();
        ServerApi.Builder serverApiBuilder = ServerApi.builder().version(ServerApiVersion.findByValue(apiVersion));
        if (serverApiDocument.containsKey("deprecationErrors")) {
            serverApiBuilder.deprecationErrors(serverApiDocument.getBoolean("deprecationErrors").getValue());
        }
        if (serverApiDocument.containsKey("strict")) {
            serverApiBuilder.strict(serverApiDocument.getBoolean("strict").getValue());
        }
        clientSettingsBuilder.serverApi(serverApiBuilder.build());
    }
    putEntity(id, mongoClientSupplier.apply(clientSettingsBuilder.build()), clients);
    if (waitForPoolAsyncWorkManagerStart) {
        waitForPoolAsyncWorkManagerStart();
    }
}

Example 5 with ServerApi

use of com.mongodb.ServerApi in project spring-data-mongodb by spring-projects.

the class MongoServerApiFactoryBeanTests method createsServerApiForVersionString.

// GH-3820
@Test
void createsServerApiForVersionString() {
    RootBeanDefinition definition = new RootBeanDefinition(MongoServerApiFactoryBean.class);
    definition.getPropertyValues().addPropertyValue("version", "V1");
    definition.getPropertyValues().addPropertyValue("deprecationErrors", "true");
    DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
    factory.registerBeanDefinition("factory", definition);
    MongoServerApiFactoryBean bean = factory.getBean("&factory", MongoServerApiFactoryBean.class);
    assertThat(ReflectionTestUtils.getField(bean, "deprecationErrors")).isEqualTo(true);
    ServerApi target = factory.getBean(ServerApi.class);
    assertThat(target.getVersion()).isEqualTo(ServerApiVersion.V1);
    assertThat(target.getDeprecationErrors()).contains(true);
    assertThat(target.getStrict()).isNotPresent();
}