use of com.mongodb.event.ConnectionPoolReadyEvent in project mongo-java-driver by mongodb.
the class ServerDiscoveryAndMonitoringProseTests method testConnectionPoolManagement.
/**
* See
* <a href="https://github.com/mongodb/specifications/blob/master/source/server-discovery-and-monitoring/server-discovery-and-monitoring-tests.rst#connection-pool-management">Connection Pool Management</a>.
*/
@Test
@Ignore
@SuppressWarnings("try")
public void testConnectionPoolManagement() throws InterruptedException {
assumeTrue(serverVersionAtLeast(4, 3));
assumeFalse(isServerlessTest());
BlockingQueue<Object> events = new LinkedBlockingQueue<>();
ServerMonitorListener serverMonitorListener = new ServerMonitorListener() {
@Override
public void serverHeartbeatSucceeded(final ServerHeartbeatSucceededEvent event) {
put(events, event);
}
@Override
public void serverHeartbeatFailed(final ServerHeartbeatFailedEvent event) {
put(events, event);
}
};
ConnectionPoolListener connectionPoolListener = new ConnectionPoolListener() {
@Override
public void connectionPoolReady(final ConnectionPoolReadyEvent event) {
put(events, event);
}
@Override
public void connectionPoolCleared(final ConnectionPoolClearedEvent event) {
put(events, event);
}
};
String appName = "SDAMPoolManagementTest";
MongoClientSettings clientSettings = getMongoClientSettingsBuilder().applicationName(appName).applyToClusterSettings(ClusterFixture::setDirectConnection).applyToServerSettings(builder -> builder.heartbeatFrequency(100, TimeUnit.MILLISECONDS).addServerMonitorListener(serverMonitorListener)).applyToConnectionPoolSettings(builder -> builder.addConnectionPoolListener(connectionPoolListener)).build();
try (MongoClient unused = MongoClients.create(clientSettings)) {
/* Note that ServerHeartbeatSucceededEvent type is sometimes allowed but never required.
* This is because DefaultServerMonitor does not send such events in situations when a server check happens as part
* of a connection handshake. */
assertPoll(events, ServerHeartbeatSucceededEvent.class, singleton(ConnectionPoolReadyEvent.class));
configureFailPoint(new BsonDocument().append("configureFailPoint", new BsonString("failCommand")).append("mode", new BsonDocument().append("times", new BsonInt32(2))).append("data", new BsonDocument().append("failCommands", new BsonArray(asList(new BsonString("isMaster"), new BsonString("hello")))).append("errorCode", new BsonInt32(1234)).append("appName", new BsonString(appName))));
assertPoll(events, ServerHeartbeatSucceededEvent.class, new HashSet<>(asList(ServerHeartbeatFailedEvent.class, ConnectionPoolClearedEvent.class)));
assertPoll(events, null, new HashSet<>(asList(ServerHeartbeatSucceededEvent.class, ConnectionPoolReadyEvent.class)));
} finally {
disableFailPoint("failCommand");
}
}
use of com.mongodb.event.ConnectionPoolReadyEvent in project mongo-java-driver by mongodb.
the class AbstractConnectionPoolTest method shouldPassAllOutcomes.
@Test
public void shouldPassAllOutcomes() throws Exception {
try {
for (BsonValue cur : definition.getArray("operations")) {
final BsonDocument operation = cur.asDocument();
String name = operation.getString("name").getValue();
if (name.equals("start")) {
String target = operation.getString("target", new BsonString("")).getValue();
executorServiceMap.put(target, Executors.newSingleThreadExecutor(r -> {
Thread result = Executors.defaultThreadFactory().newThread(r);
result.setName(target);
return result;
}));
} else if (name.equals("wait")) {
Thread.sleep(operation.getNumber("ms").intValue());
} else if (name.equals("waitForThread")) {
String target = operation.getString("target", new BsonString("")).getValue();
Exception exceptionFromFuture = futureMap.remove(target).get(5, TimeUnit.SECONDS);
if (exceptionFromFuture != null) {
throw exceptionFromFuture;
}
} else if (name.equals("waitForEvent")) {
Class<?> eventClass = getEventClass(operation.getString("event").getValue());
assumeNotNull(eventClass);
long timeoutMillis = operation.getNumber("timeout", new BsonInt64(TimeUnit.SECONDS.toMillis(5))).longValue();
listener.waitForEvent(eventClass, operation.getNumber("count").intValue(), timeoutMillis, TimeUnit.MILLISECONDS);
} else if (name.equals("clear")) {
pool.invalidate(null);
} else if (name.equals("ready")) {
pool.ready();
} else if (name.equals("close")) {
pool.close();
} else if (name.equals("checkOut") || name.equals("checkIn")) {
Callable<Exception> callable = createCallable(operation);
if (operation.containsKey("thread")) {
String threadTarget = operation.getString("thread").getValue();
ExecutorService executorService = executorServiceMap.get(threadTarget);
futureMap.put(threadTarget, executorService.submit(callable));
} else {
callable.call();
}
} else {
throw new UnsupportedOperationException("No support for " + name);
}
}
} catch (Exception e) {
if (!definition.containsKey("error")) {
throw e;
}
BsonDocument errorDocument = definition.getDocument("error");
String exceptionType = errorDocument.getString("type").getValue();
if (exceptionType.equals("PoolClosedError")) {
assertEquals(IllegalStateException.class, e.getClass());
} else if (exceptionType.equals("WaitQueueTimeoutError")) {
if (e.getClass() != MongoTimeoutException.class) {
throw e;
}
} else {
throw e;
}
}
if (definition.containsKey("events")) {
Iterator<Object> actualEventsIterator = getNonIgnoredActualEvents().iterator();
BsonArray expectedEvents = definition.getArray("events");
for (BsonValue cur : expectedEvents) {
BsonDocument expectedEvent = cur.asDocument();
String type = expectedEvent.getString("type").getValue();
if (type.equals("ConnectionPoolCreated")) {
ConnectionPoolCreatedEvent actualEvent = getNextEvent(actualEventsIterator, ConnectionPoolCreatedEvent.class);
assertAddressMatch(expectedEvent, actualEvent.getServerId().getAddress());
assertEquals(settings, actualEvent.getSettings());
} else if (type.equals("ConnectionPoolCleared")) {
ConnectionPoolClearedEvent actualEvent = getNextEvent(actualEventsIterator, ConnectionPoolClearedEvent.class);
assertAddressMatch(expectedEvent, actualEvent.getServerId().getAddress());
} else if (type.equals("ConnectionPoolReady")) {
ConnectionPoolReadyEvent actualEvent = getNextEvent(actualEventsIterator, ConnectionPoolReadyEvent.class);
assertAddressMatch(expectedEvent, actualEvent.getServerId().getAddress());
} else if (type.equals("ConnectionPoolClosed")) {
ConnectionPoolClosedEvent actualEvent = getNextEvent(actualEventsIterator, ConnectionPoolClosedEvent.class);
assertAddressMatch(expectedEvent, actualEvent.getServerId().getAddress());
} else if (type.equals("ConnectionCreated")) {
ConnectionCreatedEvent actualEvent = getNextEvent(actualEventsIterator, ConnectionCreatedEvent.class);
assertConnectionIdMatch(expectedEvent, actualEvent.getConnectionId());
} else if (type.equals("ConnectionReady")) {
ConnectionReadyEvent actualEvent = getNextEvent(actualEventsIterator, ConnectionReadyEvent.class);
assertAddressMatch(expectedEvent, actualEvent.getConnectionId().getServerId().getAddress());
} else if (type.equals("ConnectionClosed")) {
ConnectionClosedEvent actualEvent = getNextEvent(actualEventsIterator, ConnectionClosedEvent.class);
assertConnectionIdMatch(expectedEvent, actualEvent.getConnectionId());
assertReasonMatch(expectedEvent, actualEvent);
} else if (type.equals("ConnectionCheckOutStarted")) {
ConnectionCheckOutStartedEvent actualEvent = getNextEvent(actualEventsIterator, ConnectionCheckOutStartedEvent.class);
assertAddressMatch(expectedEvent, actualEvent.getServerId().getAddress());
} else if (type.equals("ConnectionCheckOutFailed")) {
ConnectionCheckOutFailedEvent actualEvent = getNextEvent(actualEventsIterator, ConnectionCheckOutFailedEvent.class);
assertAddressMatch(expectedEvent, actualEvent.getServerId().getAddress());
assertReasonMatch(expectedEvent, actualEvent);
} else if (type.equals("ConnectionCheckedOut")) {
ConnectionCheckedOutEvent actualEvent = getNextEvent(actualEventsIterator, ConnectionCheckedOutEvent.class);
assertConnectionIdMatch(expectedEvent, actualEvent.getConnectionId());
} else if (type.equals("ConnectionCheckedIn")) {
ConnectionCheckedInEvent actualEvent = getNextEvent(actualEventsIterator, ConnectionCheckedInEvent.class);
assertConnectionIdMatch(expectedEvent, actualEvent.getConnectionId());
} else {
throw new UnsupportedOperationException("Unsupported event type " + type);
}
}
}
}
Aggregations