Examples with NodeEngineImpl com.hazelcast.spi.impl.NodeEngineImpl used on opensource projects

Example 46 with NodeEngineImpl

use of com.hazelcast.spi.impl.NodeEngineImpl in project hazelcast by hazelcast.

the class QuorumTest method testQuorumIgnoresMemberAttributeEvents.

@Test
public void testQuorumIgnoresMemberAttributeEvents() {
    final RecordingQuorumFunction function = new RecordingQuorumFunction();
    QuorumConfig quorumConfig = new QuorumConfig().setName(randomString()).setEnabled(true).setQuorumFunctionImplementation(function);
    Config config = new Config().addQuorumConfig(quorumConfig);
    HazelcastInstance hazelcastInstance = createHazelcastInstance(config);
    NodeEngineImpl nodeEngine = getNodeEngineImpl(hazelcastInstance);
    MembershipAwareService service = nodeEngine.getService(QuorumServiceImpl.SERVICE_NAME);
    assertTrueEventually(new AssertTask() {

        @Override
        public void run() throws Exception {
            assertTrue(function.wasCalled);
        }
    });
    function.wasCalled = false;
    MemberAttributeServiceEvent event = mock(MemberAttributeServiceEvent.class);
    service.memberAttributeChanged(event);
    assertFalse(function.wasCalled);
}

Example 47 with NodeEngineImpl

use of com.hazelcast.spi.impl.NodeEngineImpl in project hazelcast by hazelcast.

the class Invocation_BlockingTest method sync_whenManyGettersAndLotsOfWaiting.

/**
     * Tests if the future on a blocking operation can be shared by multiple threads. This tests fails in 3.6 because
     * only 1 thread will be able to swap out CONTINUE_WAIT and all other threads will fail with an OperationTimeoutExcepyion
     */
@Test
public void sync_whenManyGettersAndLotsOfWaiting() throws Exception {
    int callTimeout = 10000;
    Config config = new Config().setProperty(OPERATION_CALL_TIMEOUT_MILLIS.getName(), "" + callTimeout);
    TestHazelcastInstanceFactory factory = createHazelcastInstanceFactory(2);
    HazelcastInstance local = factory.newHazelcastInstance(config);
    HazelcastInstance remote = factory.newHazelcastInstance(config);
    NodeEngineImpl nodeEngine = getNodeEngineImpl(local);
    String key = generateKeyOwnedBy(remote);
    int partitionId = nodeEngine.getPartitionService().getPartitionId(key);
    // first we execute an operation that stall the partition
    InternalOperationService opService = nodeEngine.getOperationService();
    // first we are going to lock
    int otherThreadId = 1;
    opService.createInvocationBuilder(null, new LockOperation(new InternalLockNamespace(key), nodeEngine.toData(key), otherThreadId, -1, -1), partitionId).setCallTimeout(callTimeout).invoke().join();
    // then we are going to send the invocation and share the future by many threads
    int thisThreadId = 2;
    final InternalCompletableFuture<Object> future = opService.createInvocationBuilder(null, new LockOperation(new InternalLockNamespace(key), nodeEngine.toData(key), thisThreadId, -1, -1), partitionId).setCallTimeout(callTimeout).invoke();
    // now we are going to do a get on the future by a whole bunch of threads
    final List<Future> futures = new LinkedList<Future>();
    for (int k = 0; k < 10; k++) {
        futures.add(spawn(new Callable() {

            @Override
            public Object call() throws Exception {
                return future.join();
            }
        }));
    }
    // lets do a very long wait so that the heartbeat/retrying mechanism have kicked in.
    // the lock remains locked; so the threads calling future.get remain blocked
    sleepMillis(callTimeout * 5);
    // unlocking the lock
    opService.createInvocationBuilder(null, new UnlockOperation(new InternalLockNamespace(key), nodeEngine.toData(key), otherThreadId), partitionId).setCallTimeout(callTimeout).invoke().join();
    // now the futures should all unblock
    for (Future f : futures) {
        assertEquals(Boolean.TRUE, f.get());
    }
}

Example 48 with NodeEngineImpl

use of com.hazelcast.spi.impl.NodeEngineImpl in project hazelcast by hazelcast.

the class Invocation_BlockingTest method async_whenMultipleAndThenOnSameFuture.

/**
     * Tests if the future on a blocking operation can be shared by multiple threads. This tests fails in 3.6 because
     * only 1 thread will be able to swap out CONTINUE_WAIT and all other threads will fail with an OperationTimeoutExcepyion
     */
@Test
public void async_whenMultipleAndThenOnSameFuture() throws Exception {
    int callTimeout = 5000;
    Config config = new Config().setProperty(OPERATION_CALL_TIMEOUT_MILLIS.getName(), "" + callTimeout);
    TestHazelcastInstanceFactory factory = createHazelcastInstanceFactory(2);
    HazelcastInstance local = factory.newHazelcastInstance(config);
    final HazelcastInstance remote = factory.newHazelcastInstance(config);
    NodeEngineImpl nodeEngine = getNodeEngineImpl(local);
    String key = generateKeyOwnedBy(remote);
    int partitionId = nodeEngine.getPartitionService().getPartitionId(key);
    // first we execute an operation that stall the partition.
    InternalOperationService opService = nodeEngine.getOperationService();
    // first we are going to lock
    int otherThreadId = 1;
    opService.createInvocationBuilder(null, new LockOperation(new InternalLockNamespace(key), nodeEngine.toData(key), otherThreadId, -1, -1), partitionId).setCallTimeout(callTimeout).invoke().join();
    // then we are going to send another lock request by a different thread; so it can't complete
    int thisThreadId = 2;
    final InternalCompletableFuture<Object> future = opService.createInvocationBuilder(null, new LockOperation(new InternalLockNamespace(key), nodeEngine.toData(key), thisThreadId, -1, -1), partitionId).setCallTimeout(callTimeout).invoke();
    // then we register a bunch of listeners
    int listenerCount = 10;
    final CountDownLatch listenersCompleteLatch = new CountDownLatch(listenerCount);
    for (int k = 0; k < 10; k++) {
        future.andThen(new ExecutionCallback<Object>() {

            @Override
            public void onResponse(Object response) {
                if (Boolean.TRUE.equals(response)) {
                    listenersCompleteLatch.countDown();
                } else {
                    System.out.println(response);
                }
            }

            @Override
            public void onFailure(Throwable t) {
                t.printStackTrace();
            }
        });
    }
    // let's do a very long wait so that the heartbeat/retrying mechanism have kicked in.
    // the lock remains locked; so the threads calling future.get remain blocked
    sleepMillis(callTimeout * 5);
    // unlocking the lock
    opService.createInvocationBuilder(null, new UnlockOperation(new InternalLockNamespace(key), nodeEngine.toData(key), otherThreadId), partitionId).setCallTimeout(callTimeout).invoke().join();
    // and all the listeners should complete
    assertOpenEventually(listenersCompleteLatch);
}

Example 49 with NodeEngineImpl

use of com.hazelcast.spi.impl.NodeEngineImpl in project hazelcast by hazelcast.

the class Invocation_BlockingTest method sync_whenGetTimeout.

/**
     * Checks if a get with a timeout is called, and the timeout expires, that we get a TimeoutException.
     */
@Test
public void sync_whenGetTimeout() throws Exception {
    Config config = new Config();
    TestHazelcastInstanceFactory factory = createHazelcastInstanceFactory(2);
    HazelcastInstance local = factory.newHazelcastInstance(config);
    HazelcastInstance remote = factory.newHazelcastInstance(config);
    warmUpPartitions(factory.getAllHazelcastInstances());
    NodeEngineImpl nodeEngine = getNodeEngineImpl(local);
    String key = generateKeyOwnedBy(remote);
    int partitionId = nodeEngine.getPartitionService().getPartitionId(key);
    // first we execute an operation that stall the partition
    InternalOperationService opService = nodeEngine.getOperationService();
    opService.invokeOnPartition(null, new SlowOperation(SECONDS.toMillis(5)), partitionId);
    // then we execute a lock operation that won't be executed because the partition is blocked.
    LockOperation op = new LockOperation(new InternalLockNamespace(key), nodeEngine.toData(key), 1, -1, -1);
    InternalCompletableFuture<Object> future = opService.createInvocationBuilder(null, op, partitionId).invoke();
    // we do a get with a very short timeout; so we should get a TimeoutException
    try {
        future.get(1, SECONDS);
        fail();
    } catch (TimeoutException expected) {
        ignore(expected);
    }
    //if we do a get with a long enough timeout, the call will complete without a problem
    Object result = future.get(60, SECONDS);
    assertEquals(Boolean.TRUE, result);
}

Example 50 with NodeEngineImpl

use of com.hazelcast.spi.impl.NodeEngineImpl in project hazelcast by hazelcast.

the class Invocation_BlockingTest method async_whenHeartbeatTimeout.

/**
     * Tests that an ExecutionCallback is called when an OperationTimeoutException happens. This is a problem in 3.6
     * since async calls don't get the same timeout logic.
     */
@Test
public void async_whenHeartbeatTimeout() {
    int callTimeout = 5000;
    Config config = new Config().setProperty(OPERATION_CALL_TIMEOUT_MILLIS.getName(), "" + callTimeout);
    TestHazelcastInstanceFactory factory = createHazelcastInstanceFactory(2);
    HazelcastInstance local = factory.newHazelcastInstance(config);
    HazelcastInstance remote = factory.newHazelcastInstance(config);
    warmUpPartitions(factory.getAllHazelcastInstances());
    NodeEngineImpl nodeEngine = getNodeEngineImpl(local);
    String key = generateKeyOwnedBy(remote);
    int partitionId = nodeEngine.getPartitionService().getPartitionId(key);
    // first we execute an operation that stall the partition.
    InternalOperationService opService = nodeEngine.getOperationService();
    opService.invokeOnPartition(null, new SlowOperation(5 * callTimeout), partitionId);
    // then we execute a lock operation that won't be executed because the partition is blocked.
    LockOperation op = new LockOperation(new InternalLockNamespace(key), nodeEngine.toData(key), 1, -1, -1);
    InternalCompletableFuture<Object> future = opService.createInvocationBuilder(null, op, partitionId).setCallTimeout(callTimeout).invoke();
    // then we register our callback
    final ExecutionCallback<Object> callback = getExecutionCallbackMock();
    future.andThen(callback);
    // and we eventually expect to fail with an OperationTimeoutException
    assertFailsEventuallyWithOperationTimeoutException(callback);
}