Examples with Future org.apache.cassandra.utils.concurrent.Future used on opensource projects

Example 26 with Future

use of org.apache.cassandra.utils.concurrent.Future in project cassandra by apache.

the class CoordinatorMessagingTest method testMockedMessagingPrepareFailure.

private void testMockedMessagingPrepareFailure(CountDownLatch prepareLatch) throws InterruptedException, ExecutionException, TimeoutException, NoSuchRepairSessionException {
    // we expect FailSession messages to all participants
    MockMessagingSpy sendFailSessionExpectedSpy = createFailSessionSpy(Lists.newArrayList(PARTICIPANT1, PARTICIPANT2, PARTICIPANT3));
    TimeUUID uuid = registerSession(cfs, true, true);
    CoordinatorSession coordinator = ActiveRepairService.instance.consistent.coordinated.registerSession(uuid, PARTICIPANTS, false);
    AtomicBoolean repairSubmitted = new AtomicBoolean(false);
    Promise<CoordinatedRepairResult> repairFuture = AsyncPromise.uncancellable();
    Supplier<Future<CoordinatedRepairResult>> sessionSupplier = () -> {
        repairSubmitted.set(true);
        return repairFuture;
    };
    // coordinator sends prepare requests to create local session and perform anticompaction
    Assert.assertFalse(repairSubmitted.get());
    // execute repair and start prepare phase
    Future<CoordinatedRepairResult> sessionResult = coordinator.execute(sessionSupplier);
    prepareLatch.countDown();
    // prepare completed
    try {
        sessionResult.get(1, TimeUnit.SECONDS);
        fail("Completed session without failure after prepare failed");
    } catch (ExecutionException e) {
    }
    sendFailSessionExpectedSpy.interceptMessageOut(3).get(1, TimeUnit.SECONDS);
    Assert.assertFalse(repairSubmitted.get());
    Assert.assertTrue(sessionResult.isDone());
    Assert.assertNotNull(sessionResult.cause());
    Assert.assertEquals(ConsistentSession.State.FAILED, coordinator.getState());
    Assert.assertFalse(ActiveRepairService.instance.consistent.local.isSessionInProgress(uuid));
}

Example 27 with Future

use of org.apache.cassandra.utils.concurrent.Future in project cassandra by apache.

the class CoordinatorMessagingTest method testMockedMessagingPrepareTimeout.

@Test
public void testMockedMessagingPrepareTimeout() throws InterruptedException, ExecutionException, TimeoutException, NoSuchRepairSessionException {
    MockMessagingSpy spyPrepare = createPrepareSpy(Collections.emptySet(), Collections.singleton(PARTICIPANT3), new CountDownLatch(0));
    MockMessagingSpy sendFailSessionUnexpectedSpy = createFailSessionSpy(Lists.newArrayList(PARTICIPANT1, PARTICIPANT2, PARTICIPANT3));
    TimeUUID uuid = registerSession(cfs, true, true);
    CoordinatorSession coordinator = ActiveRepairService.instance.consistent.coordinated.registerSession(uuid, PARTICIPANTS, false);
    AtomicBoolean repairSubmitted = new AtomicBoolean(false);
    Promise<CoordinatedRepairResult> repairFuture = AsyncPromise.uncancellable();
    Supplier<Future<CoordinatedRepairResult>> sessionSupplier = () -> {
        repairSubmitted.set(true);
        return repairFuture;
    };
    // coordinator sends prepare requests to create local session and perform anticompaction
    Assert.assertFalse(repairSubmitted.get());
    // execute repair and start prepare phase
    Future<CoordinatedRepairResult> sessionResult = coordinator.execute(sessionSupplier);
    try {
        sessionResult.get(1, TimeUnit.SECONDS);
        fail("Completed session without failure after prepare failed");
    } catch (ExecutionException e) {
        fail("Failed session in prepare failed during timeout from participant");
    } catch (TimeoutException e) {
    // expected
    }
    // we won't send out any fail session message in case of timeouts
    spyPrepare.expectMockedMessage(2).get(100, TimeUnit.MILLISECONDS);
    sendFailSessionUnexpectedSpy.interceptNoMsg(100, TimeUnit.MILLISECONDS);
    Assert.assertFalse(repairSubmitted.get());
    Assert.assertEquals(ConsistentSession.State.PREPARING, coordinator.getState());
    Assert.assertFalse(ActiveRepairService.instance.consistent.local.isSessionInProgress(uuid));
}

Example 28 with Future

use of org.apache.cassandra.utils.concurrent.Future in project cassandra by apache.

the class CoordinatorSessionTest method failedPropose.

@Test
public void failedPropose() {
    InstrumentedCoordinatorSession coordinator = createInstrumentedSession();
    AtomicBoolean repairSubmitted = new AtomicBoolean(false);
    Promise<CoordinatedRepairResult> repairFuture = AsyncPromise.uncancellable();
    Supplier<Future<CoordinatedRepairResult>> sessionSupplier = () -> {
        repairSubmitted.set(true);
        return repairFuture;
    };
    // coordinator sends prepare requests to create local session and perform anticompaction
    Assert.assertFalse(repairSubmitted.get());
    Assert.assertTrue(coordinator.sentMessages.isEmpty());
    Future<CoordinatedRepairResult> sessionResult = coordinator.execute(sessionSupplier);
    for (InetAddressAndPort participant : PARTICIPANTS) {
        RepairMessage expected = new PrepareConsistentRequest(coordinator.sessionID, COORDINATOR, new HashSet<>(PARTICIPANTS));
        assertMessageSent(coordinator, participant, expected);
    }
    // participants respond to coordinator, and repair begins once all participants have responded with success
    Assert.assertEquals(ConsistentSession.State.PREPARING, coordinator.getState());
    coordinator.handlePrepareResponse(PARTICIPANT1, true);
    Assert.assertEquals(ConsistentSession.State.PREPARING, coordinator.getState());
    coordinator.handlePrepareResponse(PARTICIPANT2, true);
    Assert.assertEquals(ConsistentSession.State.PREPARING, coordinator.getState());
    // set the setRepairing callback to verify the correct state when it's called
    Assert.assertFalse(coordinator.setRepairingCalled);
    coordinator.onSetRepairing = () -> Assert.assertEquals(PREPARED, coordinator.getState());
    coordinator.handlePrepareResponse(PARTICIPANT3, true);
    Assert.assertTrue(coordinator.setRepairingCalled);
    Assert.assertTrue(repairSubmitted.get());
    Assert.assertEquals(ConsistentSession.State.REPAIRING, coordinator.getState());
    ArrayList<RepairSessionResult> results = Lists.newArrayList(createResult(coordinator), createResult(coordinator), createResult(coordinator));
    coordinator.sentMessages.clear();
    repairFuture.trySuccess(CoordinatedRepairResult.success(results));
    // propose messages should have been sent once all repair sessions completed successfully
    for (InetAddressAndPort participant : PARTICIPANTS) {
        RepairMessage expected = new FinalizePropose(coordinator.sessionID);
        assertMessageSent(coordinator, participant, expected);
    }
    // finalize commit messages will be sent once all participants respond with a promize to finalize
    coordinator.sentMessages.clear();
    Assert.assertEquals(ConsistentSession.State.REPAIRING, coordinator.getState());
    coordinator.handleFinalizePromise(PARTICIPANT1, true);
    Assert.assertEquals(ConsistentSession.State.REPAIRING, coordinator.getState());
    Assert.assertFalse(coordinator.failCalled);
    coordinator.handleFinalizePromise(PARTICIPANT2, false);
    Assert.assertEquals(ConsistentSession.State.FAILED, coordinator.getState());
    Assert.assertTrue(coordinator.failCalled);
    // additional success messages should be ignored
    Assert.assertFalse(coordinator.finalizeCommitCalled);
    coordinator.onFinalizeCommit = Assert::fail;
    coordinator.handleFinalizePromise(PARTICIPANT3, true);
    Assert.assertFalse(coordinator.finalizeCommitCalled);
    Assert.assertEquals(ConsistentSession.State.FAILED, coordinator.getState());
    // failure messages should have been sent to all participants
    for (InetAddressAndPort participant : PARTICIPANTS) {
        RepairMessage expected = new FailSession(coordinator.sessionID);
        assertMessageSent(coordinator, participant, expected);
    }
    Assert.assertTrue(sessionResult.isDone());
    Assert.assertNotNull(sessionResult.cause());
}

Example 29 with Future

use of org.apache.cassandra.utils.concurrent.Future in project cassandra by apache.

the class CoordinatorSessionTest method successCase.

/**
 * Tests the complete coordinator side consistent repair cycle
 */
@Test
public void successCase() {
    InstrumentedCoordinatorSession coordinator = createInstrumentedSession();
    AtomicBoolean repairSubmitted = new AtomicBoolean(false);
    Promise<CoordinatedRepairResult> repairFuture = AsyncPromise.uncancellable();
    Supplier<Future<CoordinatedRepairResult>> sessionSupplier = () -> {
        repairSubmitted.set(true);
        return repairFuture;
    };
    // coordinator sends prepare requests to create local session and perform anticompaction
    Assert.assertFalse(repairSubmitted.get());
    Assert.assertTrue(coordinator.sentMessages.isEmpty());
    Future<CoordinatedRepairResult> sessionResult = coordinator.execute(sessionSupplier);
    for (InetAddressAndPort participant : PARTICIPANTS) {
        RepairMessage expected = new PrepareConsistentRequest(coordinator.sessionID, COORDINATOR, new HashSet<>(PARTICIPANTS));
        assertMessageSent(coordinator, participant, expected);
    }
    // participants respond to coordinator, and repair begins once all participants have responded with success
    Assert.assertEquals(ConsistentSession.State.PREPARING, coordinator.getState());
    coordinator.handlePrepareResponse(PARTICIPANT1, true);
    Assert.assertEquals(ConsistentSession.State.PREPARING, coordinator.getState());
    coordinator.handlePrepareResponse(PARTICIPANT2, true);
    Assert.assertEquals(ConsistentSession.State.PREPARING, coordinator.getState());
    // set the setRepairing callback to verify the correct state when it's called
    Assert.assertFalse(coordinator.setRepairingCalled);
    coordinator.onSetRepairing = () -> Assert.assertEquals(PREPARED, coordinator.getState());
    coordinator.handlePrepareResponse(PARTICIPANT3, true);
    Assert.assertTrue(coordinator.setRepairingCalled);
    Assert.assertTrue(repairSubmitted.get());
    Assert.assertEquals(ConsistentSession.State.REPAIRING, coordinator.getState());
    ArrayList<RepairSessionResult> results = Lists.newArrayList(createResult(coordinator), createResult(coordinator), createResult(coordinator));
    coordinator.sentMessages.clear();
    repairFuture.trySuccess(CoordinatedRepairResult.success(results));
    // propose messages should have been sent once all repair sessions completed successfully
    for (InetAddressAndPort participant : PARTICIPANTS) {
        RepairMessage expected = new FinalizePropose(coordinator.sessionID);
        assertMessageSent(coordinator, participant, expected);
    }
    // finalize commit messages will be sent once all participants respond with a promize to finalize
    coordinator.sentMessages.clear();
    Assert.assertEquals(ConsistentSession.State.REPAIRING, coordinator.getState());
    coordinator.handleFinalizePromise(PARTICIPANT1, true);
    Assert.assertEquals(ConsistentSession.State.REPAIRING, coordinator.getState());
    coordinator.handleFinalizePromise(PARTICIPANT2, true);
    Assert.assertEquals(ConsistentSession.State.REPAIRING, coordinator.getState());
    // set the finalizeCommit callback so we can verify the state when it's called
    Assert.assertFalse(coordinator.finalizeCommitCalled);
    coordinator.onFinalizeCommit = () -> Assert.assertEquals(FINALIZE_PROMISED, coordinator.getState());
    coordinator.handleFinalizePromise(PARTICIPANT3, true);
    Assert.assertTrue(coordinator.finalizeCommitCalled);
    Assert.assertEquals(ConsistentSession.State.FINALIZED, coordinator.getState());
    for (InetAddressAndPort participant : PARTICIPANTS) {
        RepairMessage expected = new FinalizeCommit(coordinator.sessionID);
        assertMessageSent(coordinator, participant, expected);
    }
    Assert.assertTrue(sessionResult.isDone());
    sessionResult.syncUninterruptibly();
}

Example 30 with Future

use of org.apache.cassandra.utils.concurrent.Future in project cassandra by apache.

the class CoordinatorSessionTest method failedRepairs.

@Test
public void failedRepairs() {
    InstrumentedCoordinatorSession coordinator = createInstrumentedSession();
    AtomicBoolean repairSubmitted = new AtomicBoolean(false);
    Promise<CoordinatedRepairResult> repairFuture = AsyncPromise.uncancellable();
    Supplier<Future<CoordinatedRepairResult>> sessionSupplier = () -> {
        repairSubmitted.set(true);
        return repairFuture;
    };
    // coordinator sends prepare requests to create local session and perform anticompaction
    Assert.assertFalse(repairSubmitted.get());
    Assert.assertTrue(coordinator.sentMessages.isEmpty());
    Future<CoordinatedRepairResult> sessionResult = coordinator.execute(sessionSupplier);
    for (InetAddressAndPort participant : PARTICIPANTS) {
        PrepareConsistentRequest expected = new PrepareConsistentRequest(coordinator.sessionID, COORDINATOR, new HashSet<>(PARTICIPANTS));
        assertMessageSent(coordinator, participant, expected);
    }
    // participants respond to coordinator, and repair begins once all participants have responded with success
    Assert.assertEquals(ConsistentSession.State.PREPARING, coordinator.getState());
    coordinator.handlePrepareResponse(PARTICIPANT1, true);
    Assert.assertEquals(ConsistentSession.State.PREPARING, coordinator.getState());
    coordinator.handlePrepareResponse(PARTICIPANT2, true);
    Assert.assertEquals(ConsistentSession.State.PREPARING, coordinator.getState());
    // set the setRepairing callback to verify the correct state when it's called
    Assert.assertFalse(coordinator.setRepairingCalled);
    coordinator.onSetRepairing = () -> Assert.assertEquals(PREPARED, coordinator.getState());
    coordinator.handlePrepareResponse(PARTICIPANT3, true);
    Assert.assertTrue(coordinator.setRepairingCalled);
    Assert.assertTrue(repairSubmitted.get());
    Assert.assertEquals(ConsistentSession.State.REPAIRING, coordinator.getState());
    List<Collection<Range<Token>>> ranges = Arrays.asList(coordinator.ranges, coordinator.ranges, coordinator.ranges);
    ArrayList<RepairSessionResult> results = Lists.newArrayList(createResult(coordinator), null, createResult(coordinator));
    coordinator.sentMessages.clear();
    Assert.assertFalse(coordinator.failCalled);
    coordinator.onFail = () -> Assert.assertEquals(REPAIRING, coordinator.getState());
    repairFuture.trySuccess(CoordinatedRepairResult.create(ranges, results));
    Assert.assertTrue(coordinator.failCalled);
    // all participants should have been notified of session failure
    for (InetAddressAndPort participant : PARTICIPANTS) {
        RepairMessage expected = new FailSession(coordinator.sessionID);
        assertMessageSent(coordinator, participant, expected);
    }
    Assert.assertTrue(sessionResult.isDone());
    Assert.assertNotNull(sessionResult.cause());
}