Examples with ModifyTransactionRequest org.opendaylight.controller.cluster.access.commands.ModifyTransactionRequest used on opensource projects

Example 16 with ModifyTransactionRequest

use of org.opendaylight.controller.cluster.access.commands.ModifyTransactionRequest in project controller by opendaylight.

the class LocalReadWriteProxyTransactionTest method testApplyModifyTransactionRequestAbort.

@Test
public void testApplyModifyTransactionRequestAbort() throws Exception {
    final TestProbe probe = createProbe();
    final ModifyTransactionRequestBuilder builder = new ModifyTransactionRequestBuilder(TRANSACTION_ID, probe.ref());
    builder.setSequence(0L);
    builder.setAbort();
    final ModifyTransactionRequest request = builder.build();
    final Consumer<Response<?, ?>> callback = createCallbackMock();
    transaction.replayModifyTransactionRequest(request, callback, Ticker.systemTicker().read());
    getTester().expectTransactionRequest(AbortLocalTransactionRequest.class);
}

Example 17 with ModifyTransactionRequest

use of org.opendaylight.controller.cluster.access.commands.ModifyTransactionRequest in project controller by opendaylight.

the class RemoteProxyTransactionTest method testForwardToRemoteModifyCommitSimple.

@Test
public void testForwardToRemoteModifyCommitSimple() throws Exception {
    final TestProbe probe = createProbe();
    final ModifyTransactionRequestBuilder builder = new ModifyTransactionRequestBuilder(TRANSACTION_ID, probe.ref());
    builder.setSequence(0L);
    builder.setCommit(false);
    final ModifyTransactionRequest request = builder.build();
    final ModifyTransactionRequest received = testForwardToRemote(request, ModifyTransactionRequest.class);
    Assert.assertEquals(request.getPersistenceProtocol(), received.getPersistenceProtocol());
    Assert.assertEquals(request.getModifications(), received.getModifications());
    Assert.assertEquals(request.getTarget(), received.getTarget());
}

Example 18 with ModifyTransactionRequest

use of org.opendaylight.controller.cluster.access.commands.ModifyTransactionRequest in project controller by opendaylight.

the class RemoteProxyTransactionTest method testForwardToRemoteModifyCommit3Phase.

@Test
public void testForwardToRemoteModifyCommit3Phase() throws Exception {
    final TestProbe probe = createProbe();
    final ModifyTransactionRequestBuilder builder = new ModifyTransactionRequestBuilder(TRANSACTION_ID, probe.ref());
    builder.setSequence(0L);
    builder.setCommit(true);
    final ModifyTransactionRequest request = builder.build();
    final ModifyTransactionRequest received = testForwardToRemote(request, ModifyTransactionRequest.class);
    Assert.assertEquals(request.getPersistenceProtocol(), received.getPersistenceProtocol());
    Assert.assertEquals(request.getModifications(), received.getModifications());
    Assert.assertEquals(request.getTarget(), received.getTarget());
}

Example 19 with ModifyTransactionRequest

use of org.opendaylight.controller.cluster.access.commands.ModifyTransactionRequest in project controller by opendaylight.

the class RemoteProxyTransactionTest method testDirectCommit.

@Override
@Test
public void testDirectCommit() throws Exception {
    transaction.seal();
    final ListenableFuture<Boolean> result = transaction.directCommit();
    final TransactionTester<RemoteProxyTransaction> tester = getTester();
    final ModifyTransactionRequest req = tester.expectTransactionRequest(ModifyTransactionRequest.class);
    Assert.assertTrue(req.getPersistenceProtocol().isPresent());
    Assert.assertEquals(PersistenceProtocol.SIMPLE, req.getPersistenceProtocol().get());
    tester.replySuccess(new TransactionCommitSuccess(TRANSACTION_ID, req.getSequence()));
    assertFutureEquals(true, result);
}

Example 20 with ModifyTransactionRequest

use of org.opendaylight.controller.cluster.access.commands.ModifyTransactionRequest in project controller by opendaylight.

the class AbstractProxyTransaction method replayMessages.

// Called with the connection locked
final void replayMessages(final ProxyHistory successorHistory, final Iterable<ConnectionEntry> enqueuedEntries) {
    final SuccessorState local = getSuccessorState();
    final State prevState = local.getPrevState();
    final AbstractProxyTransaction successor = successorHistory.createTransactionProxy(getIdentifier(), isSnapshotOnly(), local.isDone());
    LOG.debug("{} created successor {}", this, successor);
    local.setSuccessor(successor);
    // Replay successful requests first
    if (!successfulRequests.isEmpty()) {
        // We need to find a good timestamp to use for successful requests, as we do not want to time them out
        // nor create timing inconsistencies in the queue -- requests are expected to be ordered by their enqueue
        // time. We will pick the time of the first entry available. If there is none, we will just use current
        // time, as all other requests will get enqueued afterwards.
        final ConnectionEntry firstInQueue = Iterables.getFirst(enqueuedEntries, null);
        final long now = firstInQueue != null ? firstInQueue.getEnqueuedTicks() : parent.currentTime();
        for (Object obj : successfulRequests) {
            if (obj instanceof TransactionRequest) {
                LOG.debug("Forwarding successful request {} to successor {}", obj, successor);
                successor.doReplayRequest((TransactionRequest<?>) obj, resp -> {
                /*NOOP*/
                }, now);
            } else {
                Verify.verify(obj instanceof IncrementSequence);
                final IncrementSequence increment = (IncrementSequence) obj;
                successor.doReplayRequest(new IncrementTransactionSequenceRequest(getIdentifier(), increment.getSequence(), localActor(), isSnapshotOnly(), increment.getDelta()), resp -> {
                /*NOOP*/
                }, now);
                LOG.debug("Incrementing sequence {} to successor {}", obj, successor);
            }
        }
        LOG.debug("{} replayed {} successful requests", getIdentifier(), successfulRequests.size());
        successfulRequests.clear();
    }
    // Now replay whatever is in the connection
    final Iterator<ConnectionEntry> it = enqueuedEntries.iterator();
    while (it.hasNext()) {
        final ConnectionEntry e = it.next();
        final Request<?, ?> req = e.getRequest();
        if (getIdentifier().equals(req.getTarget())) {
            Verify.verify(req instanceof TransactionRequest, "Unhandled request %s", req);
            LOG.debug("Replaying queued request {} to successor {}", req, successor);
            successor.doReplayRequest((TransactionRequest<?>) req, e.getCallback(), e.getEnqueuedTicks());
            it.remove();
        }
    }
    /*
         * Check the state at which we have started the reconnect attempt. State transitions triggered while we were
         * reconnecting have been forced to slow paths, which will be unlocked once we unblock the state latch
         * at the end of this method.
         */
    if (SEALED.equals(prevState)) {
        LOG.debug("Proxy {} reconnected while being sealed, propagating state to successor {}", this, successor);
        final long enqueuedTicks = parent.currentTime();
        final java.util.Optional<ModifyTransactionRequest> optState = flushState();
        if (optState.isPresent()) {
            successor.handleReplayedRemoteRequest(optState.get(), null, enqueuedTicks);
        }
        if (successor.markSealed()) {
            successor.sealAndSend(Optional.of(enqueuedTicks));
        }
    }
}