Examples with Timeout com.mongodb.internal.Timeout used on opensource projects

Example 1 with Timeout

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

the class DefaultConnectionPool method getAsync.

@Override
public void getAsync(final SingleResultCallback<InternalConnection> callback) {
    if (LOGGER.isTraceEnabled()) {
        LOGGER.trace(format("Asynchronously getting a connection from the pool for server %s", serverId));
    }
    connectionPoolListener.connectionCheckOutStarted(new ConnectionCheckOutStartedEvent(serverId));
    Timeout timeout = Timeout.startNow(settings.getMaxWaitTime(NANOSECONDS));
    SingleResultCallback<InternalConnection> eventSendingCallback = (result, failure) -> {
        SingleResultCallback<InternalConnection> errHandlingCallback = errorHandlingCallback(callback, LOGGER);
        if (failure == null) {
            connectionPoolListener.connectionCheckedOut(new ConnectionCheckedOutEvent(getId(result)));
            errHandlingCallback.onResult(result, null);
        } else {
            errHandlingCallback.onResult(null, checkOutFailed(failure));
        }
    };
    try {
        stateAndGeneration.throwIfClosedOrPaused();
    } catch (RuntimeException e) {
        eventSendingCallback.onResult(null, e);
        return;
    }
    asyncWorkManager.enqueue(new Task(timeout, t -> {
        if (t != null) {
            eventSendingCallback.onResult(null, t);
        } else {
            PooledConnection connection;
            try {
                connection = getPooledConnection(timeout);
            } catch (RuntimeException e) {
                eventSendingCallback.onResult(null, e);
                return;
            }
            if (connection.opened()) {
                if (LOGGER.isTraceEnabled()) {
                    LOGGER.trace(format("Pooled connection %s to server %s is already open", getId(connection), serverId));
                }
                eventSendingCallback.onResult(connection, null);
            } else {
                if (LOGGER.isTraceEnabled()) {
                    LOGGER.trace(format("Pooled connection %s to server %s is not yet open", getId(connection), serverId));
                }
                openConcurrencyLimiter.openAsyncWithConcurrencyLimit(connection, timeout, eventSendingCallback);
            }
        }
    }));
}

Example 2 with Timeout

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

the class DefaultConnectionPoolTest method useConcurrently.

private static void useConcurrently(final DefaultConnectionPool pool, final int concurrentUsersCount, final boolean checkoutSync, final boolean checkoutAsync, final float invalidateAndReadyProb, final float invalidateProb, final float readyProb, final ExecutorService executor, final long durationNanos) throws ExecutionException, InterruptedException, TimeoutException {
    assertTrue(invalidateAndReadyProb >= 0 && invalidateAndReadyProb <= 1);
    Runnable spontaneouslyInvalidateReady = () -> {
        if (ThreadLocalRandom.current().nextFloat() < invalidateAndReadyProb) {
            pool.invalidate(null);
            pool.ready();
        }
        if (ThreadLocalRandom.current().nextFloat() < invalidateProb) {
            pool.invalidate(null);
        }
        if (ThreadLocalRandom.current().nextFloat() < readyProb) {
            pool.ready();
        }
    };
    Collection<Future<?>> tasks = new ArrayList<>();
    Timeout duration = Timeout.startNow(durationNanos);
    for (int i = 0; i < concurrentUsersCount; i++) {
        if ((checkoutSync && checkoutAsync) ? i % 2 == 0 : checkoutSync) {
            // check out synchronously and check in
            tasks.add(executor.submit(() -> {
                while (!(duration.expired() || Thread.currentThread().isInterrupted())) {
                    spontaneouslyInvalidateReady.run();
                    InternalConnection conn = null;
                    try {
                        conn = pool.get(TEST_WAIT_TIMEOUT_MILLIS, MILLISECONDS);
                    } catch (MongoConnectionPoolClearedException e) {
                    // expected because we spontaneously invalidate `pool`
                    } finally {
                        if (conn != null) {
                            conn.close();
                        }
                    }
                }
            }));
        } else if (checkoutAsync) {
            // check out asynchronously and check in
            tasks.add(executor.submit(() -> {
                while (!(duration.expired() || Thread.currentThread().isInterrupted())) {
                    spontaneouslyInvalidateReady.run();
                    CompletableFuture<InternalConnection> futureCheckOutCheckIn = new CompletableFuture<>();
                    pool.getAsync((conn, t) -> {
                        if (t != null) {
                            if (t instanceof MongoConnectionPoolClearedException) {
                                // expected because we spontaneously invalidate `pool`
                                futureCheckOutCheckIn.complete(null);
                            } else {
                                futureCheckOutCheckIn.completeExceptionally(t);
                            }
                        } else {
                            conn.close();
                            futureCheckOutCheckIn.complete(null);
                        }
                    });
                    try {
                        futureCheckOutCheckIn.get(TEST_WAIT_TIMEOUT_MILLIS, MILLISECONDS);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        return;
                    } catch (ExecutionException | TimeoutException e) {
                        throw new AssertionError(e);
                    }
                }
            }));
        }
    }
    for (Future<?> task : tasks) {
        task.get(durationNanos + MILLISECONDS.toNanos(TEST_WAIT_TIMEOUT_MILLIS), NANOSECONDS);
    }
}

Example 3 with Timeout

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

the class DefaultConnectionPool method get.

@Override
public InternalConnection get(final long timeoutValue, final TimeUnit timeUnit) {
    connectionPoolListener.connectionCheckOutStarted(new ConnectionCheckOutStartedEvent(serverId));
    Timeout timeout = Timeout.startNow(timeoutValue, timeUnit);
    try {
        stateAndGeneration.throwIfClosedOrPaused();
        PooledConnection connection = getPooledConnection(timeout);
        if (!connection.opened()) {
            connection = openConcurrencyLimiter.openOrGetAvailable(connection, timeout);
        }
        connectionPoolListener.connectionCheckedOut(new ConnectionCheckedOutEvent(getId(connection)));
        return connection;
    } catch (RuntimeException e) {
        throw (RuntimeException) checkOutFailed(e);
    }
}