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

Example 6 with CommandStartedEvent

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

the class ReadConcernTest method shouldIncludeReadConcernInCommand.

@Test
public void shouldIncludeReadConcernInCommand() throws InterruptedException {
    Mono.from(mongoClient.getDatabase(getDefaultDatabaseName()).getCollection("test").withReadConcern(ReadConcern.LOCAL).find()).block(TIMEOUT_DURATION);
    List<CommandEvent> events = commandListener.getCommandStartedEvents();
    BsonDocument commandDocument = new BsonDocument("find", new BsonString("test")).append("readConcern", ReadConcern.LOCAL.asDocument()).append("filter", new BsonDocument());
    assertEventsEquality(singletonList(new CommandStartedEvent(1, null, getDefaultDatabaseName(), "find", commandDocument)), events);
}

Example 7 with CommandStartedEvent

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

the class AbstractUnifiedTest method executeOperations.

private void executeOperations(final BsonArray operations, final boolean throwExceptions) {
    FailPoint failPoint = null;
    ServerAddress currentPrimary = null;
    try {
        for (BsonValue cur : operations) {
            final BsonDocument operation = cur.asDocument();
            String operationName = operation.getString("name").getValue();
            BsonValue expectedResult = operation.get("result");
            String receiver = operation.getString("object").getValue();
            ClientSession clientSession = receiver.startsWith("session") ? sessionsMap.get(receiver) : null;
            if (clientSession == null) {
                clientSession = operation.getDocument("arguments", new BsonDocument()).containsKey("session") ? sessionsMap.get(operation.getDocument("arguments").getString("session").getValue()) : null;
            }
            try {
                if (operationName.equals("startTransaction")) {
                    BsonDocument arguments = operation.getDocument("arguments", new BsonDocument());
                    if (arguments.containsKey("options")) {
                        TransactionOptions transactionOptions = createTransactionOptions(arguments.getDocument("options"));
                        nonNullClientSession(clientSession).startTransaction(transactionOptions);
                    } else {
                        nonNullClientSession(clientSession).startTransaction();
                    }
                } else if (operationName.equals("commitTransaction")) {
                    nonNullClientSession(clientSession).commitTransaction();
                } else if (operationName.equals("abortTransaction")) {
                    nonNullClientSession(clientSession).abortTransaction();
                } else if (operationName.equals("withTransaction")) {
                    final BsonDocument arguments = operation.getDocument("arguments", new BsonDocument());
                    TransactionOptions transactionOptions = null;
                    if (arguments.containsKey("options")) {
                        transactionOptions = createTransactionOptions(arguments.getDocument("options"));
                    }
                    if (transactionOptions == null) {
                        nonNullClientSession(clientSession).withTransaction(new TransactionBody<Object>() {

                            @Override
                            public Void execute() {
                                executeOperations(arguments.getDocument("callback").getArray("operations"), true);
                                return null;
                            }
                        });
                    } else {
                        nonNullClientSession(clientSession).withTransaction(new TransactionBody<Object>() {

                            @Override
                            public Void execute() {
                                executeOperations(arguments.getDocument("callback").getArray("operations"), true);
                                return null;
                            }
                        }, transactionOptions);
                    }
                } else if (operationName.equals("targetedFailPoint")) {
                    assertNull(failPoint);
                    failPoint = new TargetedFailPoint(operation);
                    failPoint.executeFailPoint();
                } else if (operationName.equals("configureFailPoint")) {
                    assertNull(failPoint);
                    failPoint = new FailPoint(operation);
                    failPoint.executeFailPoint();
                } else if (operationName.equals("startThread")) {
                    String target = operation.getDocument("arguments").getString("name").getValue();
                    executorServiceMap.put(target, Executors.newSingleThreadExecutor());
                } else if (operationName.equals("runOnThread")) {
                    String target = operation.getDocument("arguments").getString("name").getValue();
                    ExecutorService executorService = executorServiceMap.get(target);
                    Callable<Exception> callable = createCallable(operation.getDocument("arguments").getDocument("operation"));
                    futureMap.put(target, executorService.submit(callable));
                } else if (operationName.equals("wait")) {
                    Thread.sleep(operation.getDocument("arguments").getNumber("ms").longValue());
                } else if (operationName.equals("waitForThread")) {
                    String target = operation.getDocument("arguments").getString("name").getValue();
                    Exception exceptionFromFuture = futureMap.remove(target).get(5, SECONDS);
                    if (exceptionFromFuture != null) {
                        throw exceptionFromFuture;
                    }
                } else if (operationName.equals("waitForEvent")) {
                    String event = operation.getDocument("arguments").getString("event").getValue();
                    int count = operation.getDocument("arguments").getNumber("count").intValue();
                    long timeoutMillis = TimeUnit.SECONDS.toMillis(5);
                    switch(event) {
                        case "PoolClearedEvent":
                            connectionPoolListener.waitForEvent(ConnectionPoolClearedEvent.class, count, timeoutMillis, MILLISECONDS);
                            break;
                        case "PoolReadyEvent":
                            connectionPoolListener.waitForEvent(ConnectionPoolReadyEvent.class, count, timeoutMillis, MILLISECONDS);
                            break;
                        case "ServerMarkedUnknownEvent":
                            serverListener.waitForEvent(ServerType.UNKNOWN, count, timeoutMillis, MILLISECONDS);
                            break;
                        default:
                            throw new UnsupportedOperationException("Unsupported event type: " + event);
                    }
                } else if (operationName.equals("assertEventCount")) {
                    String event = operation.getDocument("arguments").getString("event").getValue();
                    int expectedCount = operation.getDocument("arguments").getNumber("count").intValue();
                    int actualCount = -1;
                    switch(event) {
                        case "PoolClearedEvent":
                            actualCount = connectionPoolListener.countEvents(ConnectionPoolClearedEvent.class);
                            break;
                        case "PoolReadyEvent":
                            actualCount = connectionPoolListener.countEvents(ConnectionPoolReadyEvent.class);
                            break;
                        case "ServerMarkedUnknownEvent":
                            actualCount = serverListener.countEvents(ServerType.UNKNOWN);
                            break;
                        default:
                            throw new UnsupportedOperationException("Unsupported event type: " + event);
                    }
                    assertEquals(event + " counts not equal", expectedCount, actualCount);
                } else if (operationName.equals("recordPrimary")) {
                    currentPrimary = getCurrentPrimary();
                } else if (operationName.equals("waitForPrimaryChange")) {
                    long startTimeMillis = System.currentTimeMillis();
                    int timeoutMillis = operation.getDocument("arguments").getNumber("timeoutMS").intValue();
                    ServerAddress newPrimary = getCurrentPrimary();
                    while (newPrimary == null || newPrimary.equals(currentPrimary)) {
                        if (startTimeMillis + timeoutMillis <= System.currentTimeMillis()) {
                            fail("Timed out waiting for primary change");
                        }
                        // noinspection BusyWait
                        Thread.sleep(50);
                        newPrimary = getCurrentPrimary();
                    }
                } else if (operationName.equals("runAdminCommand")) {
                    collectionHelper.runAdminCommand(operation.getDocument("arguments").getDocument("command"));
                } else if (operationName.equals("assertSessionPinned")) {
                    final BsonDocument arguments = operation.getDocument("arguments", new BsonDocument());
                    assertNotNull(sessionsMap.get(arguments.getString("session").getValue()).getPinnedServerAddress());
                } else if (operationName.equals("assertSessionUnpinned")) {
                    final BsonDocument arguments = operation.getDocument("arguments", new BsonDocument());
                    assertNull(sessionsMap.get(arguments.getString("session").getValue()).getPinnedServerAddress());
                } else if (operationName.equals("assertSessionTransactionState")) {
                    final BsonDocument arguments = operation.getDocument("arguments", new BsonDocument());
                    ClientSession session = sessionsMap.get(arguments.getString("session").getValue());
                    String state = arguments.getString("state").getValue();
                    if (state.equals("starting") || state.equals("in_progress")) {
                        assertTrue(session.hasActiveTransaction());
                    } else {
                        assertFalse(session.hasActiveTransaction());
                    }
                } else if (operationName.equals("endSession")) {
                    clientSession.close();
                } else if (operation.getBoolean("error", BsonBoolean.FALSE).getValue()) {
                    try {
                        helper.getOperationResults(operation, clientSession);
                        fail("Error expected but none thrown");
                    } catch (Exception e) {
                    // Expected failure ignore
                    }
                } else if (operationName.equals("assertDifferentLsidOnLastTwoCommands")) {
                    List<CommandEvent> events = lastTwoCommandEvents();
                    String eventsJson = commandListener.getCommandStartedEvents().stream().map(e -> ((CommandStartedEvent) e).getCommand().toJson()).collect(Collectors.joining(", "));
                    assertNotEquals(eventsJson, ((CommandStartedEvent) events.get(0)).getCommand().getDocument("lsid"), ((CommandStartedEvent) events.get(1)).getCommand().getDocument("lsid"));
                } else if (operationName.equals("assertSameLsidOnLastTwoCommands")) {
                    List<CommandEvent> events = lastTwoCommandEvents();
                    String eventsJson = commandListener.getCommandStartedEvents().stream().map(e -> ((CommandStartedEvent) e).getCommand().toJson()).collect(Collectors.joining(", "));
                    assertEquals(eventsJson, ((CommandStartedEvent) events.get(0)).getCommand().getDocument("lsid"), ((CommandStartedEvent) events.get(1)).getCommand().getDocument("lsid"));
                } else if (operationName.equals("assertSessionDirty")) {
                    assertNotNull(clientSession);
                    assertNotNull(clientSession.getServerSession());
                    assertTrue(clientSession.getServerSession().isMarkedDirty());
                } else if (operationName.equals("assertSessionNotDirty")) {
                    assertNotNull(clientSession);
                    assertNotNull(clientSession.getServerSession());
                    assertFalse(clientSession.getServerSession().isMarkedDirty());
                } else if (operationName.equals("assertCollectionExists")) {
                    assertCollectionExists(operation, true);
                } else if (operationName.equals("assertCollectionNotExists")) {
                    assertCollectionExists(operation, false);
                } else if (operationName.equals("assertIndexExists")) {
                    assertIndexExists(operation, true);
                } else if (operationName.equals("assertIndexNotExists")) {
                    assertIndexExists(operation, false);
                } else {
                    BsonDocument actualOutcome = helper.getOperationResults(operation, clientSession);
                    if (expectedResult != null) {
                        BsonValue actualResult = actualOutcome.get("result");
                        if (actualResult.isDocument()) {
                            if (((BsonDocument) actualResult).containsKey("recoveryToken")) {
                                ((BsonDocument) actualResult).remove("recoveryToken");
                            }
                        }
                        assertEquals("Expected operation result differs from actual", expectedResult, actualResult);
                    }
                }
                assertFalse(String.format("Expected error '%s' but none thrown for operation %s", getErrorContainsField(expectedResult), operationName), hasErrorContainsField(expectedResult));
                assertFalse(String.format("Expected error code '%s' but none thrown for operation %s", getErrorCodeNameField(expectedResult), operationName), hasErrorCodeNameField(expectedResult));
            } catch (RuntimeException e) {
                if (!assertExceptionState(e, expectedResult, operationName) || throwExceptions) {
                    throw e;
                }
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    } finally {
        if (failPoint != null) {
            failPoint.disableFailPoint();
        }
    }
}

Example 8 with CommandStartedEvent

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

the class AtlasDataLakeKillCursorsProseTest method testKillCursorsOnAtlasDataLake.

@Test
public void testKillCursorsOnAtlasDataLake() {
    // Initiate find command
    MongoCursor<Document> cursor = client.getDatabase(DATABASE_NAME).getCollection(COLLECTION_NAME).find().batchSize(2).cursor();
    CommandSucceededEvent findCommandSucceededEvent = commandListener.getCommandSucceededEvent("find");
    BsonDocument findCommandResponse = findCommandSucceededEvent.getResponse();
    MongoNamespace cursorNamespace = new MongoNamespace(findCommandResponse.getDocument("cursor").getString("ns").getValue());
    // Initiate killCursors command
    cursor.close();
    CommandStartedEvent killCursorsCommandStartedEvent = commandListener.getCommandStartedEvent("killCursors");
    CommandSucceededEvent killCursorsCommandSucceededEvent = commandListener.getCommandSucceededEvent("killCursors");
    BsonDocument killCursorsCommand = killCursorsCommandStartedEvent.getCommand();
    assertEquals(cursorNamespace.getDatabaseName(), killCursorsCommandStartedEvent.getDatabaseName());
    assertEquals(cursorNamespace.getCollectionName(), killCursorsCommand.getString("killCursors").getValue());
    BsonInt64 cursorId = findCommandResponse.getDocument("cursor").getInt64("id");
    assertEquals(cursorId, killCursorsCommand.getArray("cursors").getValues().get(0).asInt64());
    assertEquals(cursorId, killCursorsCommandSucceededEvent.getResponse().getArray("cursorsKilled").get(0).asInt64());
}

Example 9 with CommandStartedEvent

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

the class AbstractChangeStreamsTest method filterCommandStartedEvents.

private List<CommandEvent> filterCommandStartedEvents() {
    List<CommandEvent> events = commandListener.getEvents();
    List<CommandEvent> filteredEvents = new ArrayList<CommandEvent>();
    for (int i = 0; i < events.size(); i++) {
        CommandEvent event = events.get(i);
        if (event instanceof CommandStartedEvent && !event.getCommandName().toLowerCase().equals("killcursors")) {
            filteredEvents.add(event);
        }
    }
    return filteredEvents;
}

Example 10 with CommandStartedEvent

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

the class AbstractClientSideEncryptionDeadlockTest method assertEventEquality.

private void assertEventEquality(final TestCommandListener commandListener, final List<ExpectedEvent> expectedStartEvents) {
    List<CommandEvent> actualStartedEvents = commandListener.getCommandStartedEvents();
    assertEquals(expectedStartEvents.size(), actualStartedEvents.size());
    for (int i = 0; i < expectedStartEvents.size(); i++) {
        ExpectedEvent expectedEvent = expectedStartEvents.get(i);
        CommandStartedEvent actualEvent = (CommandStartedEvent) actualStartedEvents.get(i);
        assertEquals(expectedEvent.getDatabase(), actualEvent.getDatabaseName(), "Database name");
        assertEquals(expectedEvent.getCommandName(), actualEvent.getCommandName(), "Command name");
    }
}