Examples with ConnectionClosedEvent com.mongodb.event.ConnectionClosedEvent used on opensource projects

Example 1 with ConnectionClosedEvent

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

the class DefaultConnectionPool method connectionClosed.

/**
 * Send both current and deprecated events in order to preserve backwards compatibility.
 * Must not throw {@link Exception}s.
 */
private void connectionClosed(final ConnectionPoolListener connectionPoolListener, final ConnectionId connectionId, final ConnectionClosedEvent.Reason reason) {
    connectionPoolListener.connectionRemoved(new com.mongodb.event.ConnectionRemovedEvent(connectionId, getReasonForRemoved(reason)));
    connectionPoolListener.connectionClosed(new ConnectionClosedEvent(connectionId, reason));
}

Example 2 with ConnectionClosedEvent

use of com.mongodb.event.ConnectionClosedEvent 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);
            }
        }
    }
}

Example 3 with ConnectionClosedEvent

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

the class EventMatcher method assertConnectionPoolEventsEquality.

public void assertConnectionPoolEventsEquality(final String client, final BsonArray expectedEventDocuments, final List<Object> events) {
    context.push(ContextElement.ofConnectionPoolEvents(client, expectedEventDocuments, events));
    assertEquals(context.getMessage("Number of events must be the same"), expectedEventDocuments.size(), events.size());
    for (int i = 0; i < events.size(); i++) {
        Object actual = events.get(i);
        BsonDocument expectedEventDocument = expectedEventDocuments.get(i).asDocument();
        String eventType = expectedEventDocument.getFirstKey();
        context.push(ContextElement.ofConnectionPoolEvent(expectedEventDocument, actual, i));
        assertEquals(context.getMessage("Expected event type to match"), eventType, getEventType(actual.getClass()));
        if (actual.getClass().equals(ConnectionPoolClearedEvent.class)) {
            BsonDocument expected = expectedEventDocument.getDocument(eventType);
            ConnectionPoolClearedEvent connectionPoolClearedEvent = (ConnectionPoolClearedEvent) actual;
            if (expected.containsKey("hasServiceId")) {
                boolean hasServiceId = expected.getBoolean("hasServiceId").getValue();
                ObjectId serviceId = connectionPoolClearedEvent.getServiceId();
                if (hasServiceId) {
                    assertNotNull(context.getMessage("Expected serviceId"), serviceId);
                } else {
                    assertNull(context.getMessage("Expected no serviceId"), serviceId);
                }
            }
        } else if (actual.getClass().equals(ConnectionCheckOutFailedEvent.class)) {
            BsonDocument expected = expectedEventDocument.getDocument(eventType);
            ConnectionCheckOutFailedEvent actualEvent = (ConnectionCheckOutFailedEvent) actual;
            if (expected.containsKey("reason")) {
                assertEquals(context.getMessage("Expected reason to match"), expected.getString("reason").getValue(), getReasonString(actualEvent.getReason()));
            }
        } else if (actual.getClass().equals(ConnectionClosedEvent.class)) {
            BsonDocument expected = expectedEventDocument.getDocument(eventType);
            ConnectionClosedEvent actualEvent = (ConnectionClosedEvent) actual;
            if (expected.containsKey("reason")) {
                assertEquals(context.getMessage("Expected reason to match"), expected.getString("reason").getValue(), getReasonString(actualEvent.getReason()));
            }
        }
        context.pop();
    }
    context.pop();
}