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

Example 6 with RequestException

use of org.opendaylight.controller.cluster.access.concepts.RequestException 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);
    }
}