Examples with RuntimeRequestException org.opendaylight.controller.cluster.access.concepts.RuntimeRequestException used on opensource projects

Example 6 with RuntimeRequestException

use of org.opendaylight.controller.cluster.access.concepts.RuntimeRequestException in project controller by opendaylight.

the class AbstractTransmitQueueTest method testPoison.

@Test
public void testPoison() throws Exception {
    final Request<?, ?> request = new TransactionPurgeRequest(TRANSACTION_IDENTIFIER, 0L, probe.ref());
    final Consumer<Response<?, ?>> callback = createConsumerMock();
    final long now = Ticker.systemTicker().read();
    queue.enqueueOrForward(new ConnectionEntry(request, callback, now), now);
    queue.poison(new RuntimeRequestException("fail", new RuntimeException("fail")));
    verify(callback).accept(any(TransactionFailure.class));
    Assert.assertTrue(queue.isEmpty());
}

Example 7 with RuntimeRequestException

use of org.opendaylight.controller.cluster.access.concepts.RuntimeRequestException in project controller by opendaylight.

the class AbstractTransactionRequestTest method toRequestFailureTest.

@Test
public void toRequestFailureTest() {
    final Throwable cause = new Throwable();
    final RequestException exception = new RuntimeRequestException("fail", cause);
    final TransactionFailure failure = object().toRequestFailure(exception);
    Assert.assertNotNull(failure);
}

Example 8 with RuntimeRequestException

use of org.opendaylight.controller.cluster.access.concepts.RuntimeRequestException in project controller by opendaylight.

the class ClientActorBehavior method backendConnectFinished.

private void backendConnectFinished(final Long shard, final AbstractClientConnection<T> oldConn, final T backend, final Throwable failure) {
    if (failure != null) {
        if (failure instanceof TimeoutException) {
            if (!oldConn.equals(connections.get(shard))) {
                // AbstractClientConnection will remove itself when it decides there is no point in continuing,
                // at which point we want to stop retrying
                LOG.info("{}: stopping resolution of shard {} on stale connection {}", persistenceId(), shard, oldConn, failure);
                return;
            }
            LOG.debug("{}: timed out resolving shard {}, scheduling retry in {}", persistenceId(), shard, RESOLVE_RETRY_DURATION, failure);
            context().executeInActor(b -> {
                resolveConnection(shard, oldConn);
                return b;
            }, RESOLVE_RETRY_DURATION);
            return;
        }
        LOG.error("{}: failed to resolve shard {}", persistenceId(), shard, failure);
        final RequestException cause;
        if (failure instanceof RequestException) {
            cause = (RequestException) failure;
        } else {
            cause = new RuntimeRequestException("Failed to resolve shard " + shard, failure);
        }
        oldConn.poison(cause);
        return;
    }
    LOG.info("{}: resolved shard {} to {}", persistenceId(), shard, backend);
    final long stamp = connectionsLock.writeLock();
    try {
        final Stopwatch sw = Stopwatch.createStarted();
        // Create a new connected connection
        final ConnectedClientConnection<T> newConn = new ConnectedClientConnection<>(oldConn, backend);
        LOG.info("{}: resolving connection {} to {}", persistenceId(), oldConn, newConn);
        // Start reconnecting without the old connection lock held
        final ConnectionConnectCohort cohort = Verify.verifyNotNull(connectionUp(newConn));
        // Lock the old connection and get a reference to its entries
        final Collection<ConnectionEntry> replayIterable = oldConn.startReplay();
        // Finish the connection attempt
        final ReconnectForwarder forwarder = Verify.verifyNotNull(cohort.finishReconnect(replayIterable));
        // Cancel sleep debt after entries were replayed, before new connection starts receiving.
        newConn.cancelDebt();
        // Install the forwarder, unlocking the old connection
        oldConn.finishReplay(forwarder);
        // Make sure new lookups pick up the new connection
        if (!connections.replace(shard, oldConn, newConn)) {
            final AbstractClientConnection<T> existing = connections.get(oldConn.cookie());
            LOG.warn("{}: old connection {} does not match existing {}, new connection {} in limbo", persistenceId(), oldConn, existing, newConn);
        } else {
            LOG.info("{}: replaced connection {} with {} in {}", persistenceId(), oldConn, newConn, sw);
        }
    } finally {
        connectionsLock.unlockWrite(stamp);
    }
}

Example 9 with RuntimeRequestException

use of org.opendaylight.controller.cluster.access.concepts.RuntimeRequestException in project controller by opendaylight.

the class ModuleShardBackendResolverTest method testGetBackendInfoFail.

@Test
public void testGetBackendInfoFail() throws Exception {
    final CompletionStage<ShardBackendInfo> i = moduleShardBackendResolver.getBackendInfo(0L);
    final ConnectClientRequest req = contextProbe.expectMsgClass(ConnectClientRequest.class);
    final RuntimeException cause = new RuntimeException();
    final ConnectClientFailure response = req.toRequestFailure(new RuntimeRequestException("fail", cause));
    contextProbe.reply(response);
    final CompletionStage<ShardBackendInfo> stage = moduleShardBackendResolver.getBackendInfo(0L);
    final ExecutionException caught = TestUtils.assertOperationThrowsException(() -> TestUtils.getWithTimeout(stage.toCompletableFuture()), ExecutionException.class);
    Assert.assertEquals(cause, caught.getCause());
}