Examples with GridFutureAdapter org.apache.ignite.internal.util.future.GridFutureAdapter used on opensource projects

Example 91 with GridFutureAdapter

use of org.apache.ignite.internal.util.future.GridFutureAdapter in project ignite by apache.

the class IgniteSemaphoreAbstractSelfTest method testAcquireAndExecuteIfFailure.

/**
 * Test to verify the {@link IgniteSemaphore#acquireAndExecute(IgniteCallable, int)}'s behaviour in case of a failure.
 *
 * @throws Exception If failed.
 */
@Test
public void testAcquireAndExecuteIfFailure() {
    IgniteSemaphore semaphore = ignite(0).semaphore("testAcquireAndExecuteIfFailure", 1, true, true);
    ExecutorService executorService = Executors.newSingleThreadExecutor();
    IgniteCallable<Integer> callable = new IgniteCallable<Integer>() {

        @Override
        public Integer call() {
            throw new RuntimeException("Foobar");
        }
    };
    GridTestUtils.assertThrows(log, new Callable<Object>() {

        @Override
        public Object call() throws Exception {
            IgniteFuture igniteFuture = semaphore.acquireAndExecute(callable, 1);
            Runnable runnable = new Runnable() {

                /**
                 * {@inheritDoc}
                 */
                @Override
                public void run() {
                    try {
                        Thread.sleep(1000);
                        IgniteFutureImpl impl = (IgniteFutureImpl<Integer>) igniteFuture;
                        GridFutureAdapter fut = (GridFutureAdapter) (impl.internalFuture());
                        fut.onDone(true);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e.getMessage());
                    }
                }
            };
            executorService.submit(runnable);
            ((IgniteFutureImpl) igniteFuture).internalFuture().get();
            assertTrue(igniteFuture.isDone());
            return null;
        }
    }, RuntimeException.class, "Foobar");
    executorService.shutdown();
}

Example 92 with GridFutureAdapter

use of org.apache.ignite.internal.util.future.GridFutureAdapter in project ignite by apache.

the class GridCacheOrderedPreloadingSelfTest method checkPreloadOrder.

/**
 * @param first First cache mode.
 * @param second Second cache mode.
 * @throws Exception If failed.
 */
private void checkPreloadOrder(CacheMode first, CacheMode second) throws Exception {
    firstCacheMode = first;
    secondCacheMode = second;
    Ignite g = startGrid(0);
    try {
        IgniteCache<Object, Object> cache = g.cache("first");
        // Put some data into cache.
        for (int i = 0; i < 1000; i++) cache.put(i, i);
        for (int i = 1; i < GRID_CNT; i++) startGrid(i);
        // For first node in topology replicated preloader gets completed right away.
        for (int i = 1; i < GRID_CNT; i++) {
            IgniteKernal kernal = (IgniteKernal) grid(i);
            GridFutureAdapter<?> fut1 = (GridFutureAdapter<?>) kernal.internalCache(FIRST_CACHE_NAME).preloader().syncFuture();
            GridFutureAdapter<?> fut2 = (GridFutureAdapter<?>) kernal.internalCache(SECOND_CACHE_NAME).preloader().syncFuture();
            fut1.get();
            fut2.get();
            long firstSyncTime = times.get(i).get(FIRST_CACHE_NAME);
            long secondSyncTime = times.get(i).get(SECOND_CACHE_NAME);
            assertTrue(FIRST_CACHE_NAME + " [syncTime=" + firstSyncTime + "], " + SECOND_CACHE_NAME + " [syncTime=" + secondSyncTime + "]", firstSyncTime <= secondSyncTime);
        }
    } finally {
        stopAllGrids();
    }
}

Example 93 with GridFutureAdapter

use of org.apache.ignite.internal.util.future.GridFutureAdapter in project ignite by apache.

the class GridCacheBinaryObjectMetadataExchangeMultinodeTest method testReadRequestBlockedOnUpdatingMetadata.

/**
 * Verifies that if thread tries to read metadata with ongoing update it gets blocked
 * until acknowledge message arrives.
 */
@Test
public void testReadRequestBlockedOnUpdatingMetadata() throws Exception {
    final CyclicBarrier barrier = new CyclicBarrier(2);
    applyDiscoveryHook = false;
    final Ignite ignite0 = startGrid(0);
    final Ignite ignite1 = startGrid(1);
    final GridFutureAdapter finishFut = new GridFutureAdapter();
    applyDiscoveryHook = true;
    discoveryHook = new DiscoveryHook() {

        private volatile IgniteEx ignite;

        @Override
        public void beforeDiscovery(DiscoveryCustomMessage customMsg) {
            if (finishFut.isDone())
                return;
            if (customMsg instanceof MetadataUpdateAcceptedMessage) {
                MetadataUpdateAcceptedMessage acceptedMsg = (MetadataUpdateAcceptedMessage) customMsg;
                if (acceptedMsg.typeId() == BINARY_TYPE_ID && acceptedMsg.acceptedVersion() == 2) {
                    Object binaryProc = U.field(ignite.context(), "cacheObjProc");
                    Object transport = U.field(binaryProc, "transport");
                    try {
                        barrier.await(MAX_AWAIT, TimeUnit.MILLISECONDS);
                        Map syncMap = U.field(transport, "syncMap");
                        GridTestUtils.waitForCondition(new PA() {

                            @Override
                            public boolean apply() {
                                return syncMap.size() == 1;
                            }
                        }, MAX_AWAIT);
                        assertEquals("unexpected size of syncMap: ", 1, syncMap.size());
                        Object syncKey = syncMap.keySet().iterator().next();
                        int typeId = U.field(syncKey, "typeId");
                        assertEquals("unexpected typeId: ", BINARY_TYPE_ID, typeId);
                        int ver = U.field(syncKey, "ver");
                        assertEquals("unexpected pendingVersion: ", 2, ver);
                        finishFut.onDone();
                    } catch (Throwable t) {
                        finishFut.onDone(t);
                    }
                }
            }
        }

        @Override
        public void ignite(IgniteEx ignite) {
            this.ignite = ignite;
        }
    };
    final IgniteEx ignite2 = startGrid(2);
    discoveryHook.ignite(ignite2);
    // Unfinished PME may affect max await timeout.
    awaitPartitionMapExchange();
    // Update metadata (version 1).
    ignite0.executorService(ignite0.cluster().forLocal()).submit(new Runnable() {

        @Override
        public void run() {
            addIntField(ignite0, "f1", 101, 1);
        }
    }).get();
    // Update metadata (version 2).
    ignite1.executorService(ignite1.cluster().forLocal()).submit(new Runnable() {

        @Override
        public void run() {
            addStringField(ignite1, "f2", "str", 2);
        }
    });
    // Read metadata.
    IgniteFuture readFut = ignite2.compute(ignite2.cluster().forLocal()).callAsync(new IgniteCallable<Object>() {

        @Override
        public Object call() throws Exception {
            barrier.await(MAX_AWAIT, TimeUnit.MILLISECONDS);
            return ((BinaryObject) ignite2.cache(DEFAULT_CACHE_NAME).withKeepBinary().get(1)).field("f1");
        }
    });
    finishFut.get(MAX_AWAIT);
    assertEquals(101, readFut.get(MAX_AWAIT));
}

Example 94 with GridFutureAdapter

use of org.apache.ignite.internal.util.future.GridFutureAdapter in project ignite by apache.

the class DurableBackgroundTasksProcessorSelfTest method testNotFailNodeWhenNodeStoppindAndDeleteTasks.

/**
 * Checks that stopping the node does not fail the node when deleting tasks.
 *
 * @throws Exception If failed.
 */
@Test
public void testNotFailNodeWhenNodeStoppindAndDeleteTasks() throws Exception {
    IgniteEx n = startGrid(0);
    ObservingCheckpointListener observingCpLsnr = new ObservingCheckpointListener();
    dbMgr(n).addCheckpointListener(observingCpLsnr);
    n.cluster().state(ACTIVE);
    CheckpointWorkflow cpWorkflow = checkpointWorkflow(n);
    List<CheckpointListener> cpLs = cpWorkflow.getRelevantCheckpointListeners(dbMgr(n).checkpointedDataRegions());
    assertTrue(cpLs.contains(observingCpLsnr));
    assertTrue(cpLs.contains(durableBackgroundTask(n)));
    assertTrue(cpLs.indexOf(observingCpLsnr) < cpLs.indexOf(durableBackgroundTask(n)));
    SimpleTask simpleTask = new SimpleTask("t");
    IgniteInternalFuture<Void> taskFut = durableBackgroundTask(n).executeAsync(simpleTask, true);
    simpleTask.onExecFut.get(getTestTimeout());
    GridFutureAdapter<Void> startStopFut = new GridFutureAdapter<>();
    GridFutureAdapter<Void> finishStopFut = new GridFutureAdapter<>();
    observingCpLsnr.repeatOnMarkCheckpointBeginConsumer = true;
    observingCpLsnr.onMarkCheckpointBeginConsumer = ctx -> {
        if (n.context().isStopping()) {
            startStopFut.onDone();
            finishStopFut.get(getTestTimeout());
            observingCpLsnr.repeatOnMarkCheckpointBeginConsumer = false;
        }
    };
    IgniteInternalFuture<Void> stopFut = runAsync(() -> stopAllGrids(false));
    startStopFut.get(getTestTimeout());
    simpleTask.taskFut.onDone(DurableBackgroundTaskResult.complete(null));
    taskFut.get(getTestTimeout());
    finishStopFut.onDone();
    stopFut.get(getTestTimeout());
    assertNull(n.context().failure().failureContext());
    assertThrows(log, () -> durableBackgroundTask(n).executeAsync(simpleTask, true), IgniteException.class, null);
}

Example 95 with GridFutureAdapter

use of org.apache.ignite.internal.util.future.GridFutureAdapter in project ignite by apache.

the class InboundConnectionHandler method onFirstMessage.

/**
 * @param ses Session.
 * @param msg Message.
 */
private void onFirstMessage(final GridNioSession ses, Message msg) {
    UUID sndId;
    ConnectionKey connKey;
    if (msg instanceof NodeIdMessage) {
        sndId = U.bytesToUuid(((NodeIdMessage) msg).nodeIdBytes(), 0);
        connKey = new ConnectionKey(sndId, 0, -1);
    } else {
        assert msg instanceof HandshakeMessage : msg;
        HandshakeMessage msg0 = (HandshakeMessage) msg;
        sndId = ((HandshakeMessage) msg).nodeId();
        connKey = new ConnectionKey(sndId, msg0.connectionIndex(), msg0.connectCount());
    }
    if (log.isDebugEnabled())
        log.debug("Remote node ID received: " + sndId);
    final ClusterNode rmtNode = nodeGetter.apply(sndId);
    if (rmtNode == null) {
        DiscoverySpi discoverySpi = igniteExSupplier.get().configuration().getDiscoverySpi();
        boolean unknownNode = true;
        if (discoverySpi instanceof TcpDiscoverySpi) {
            TcpDiscoverySpi tcpDiscoverySpi = (TcpDiscoverySpi) discoverySpi;
            ClusterNode node0 = tcpDiscoverySpi.getNode0(sndId);
            if (node0 != null) {
                assert node0.isClient() : node0;
                if (node0.version().compareTo(VERSION_SINCE_CLIENT_COULD_WAIT_TO_CONNECT) >= 0)
                    unknownNode = false;
            }
        } else if (discoverySpi instanceof IgniteDiscoverySpi)
            unknownNode = !((IgniteDiscoverySpi) discoverySpi).knownNode(sndId);
        if (unknownNode) {
            U.warn(log, "Close incoming connection, unknown node [nodeId=" + sndId + ", ses=" + ses + ']');
            ses.send(new RecoveryLastReceivedMessage(UNKNOWN_NODE)).listen(fut -> ses.close());
        } else
            ses.send(new RecoveryLastReceivedMessage(NEED_WAIT)).listen(fut -> ses.close());
        return;
    }
    ses.addMeta(CONSISTENT_ID_META, rmtNode.consistentId());
    final ConnectionKey old = ses.addMeta(CONN_IDX_META, connKey);
    assert old == null;
    ClusterNode locNode = locNodeSupplier.get();
    if (ses.remoteAddress() == null)
        return;
    assert msg instanceof HandshakeMessage : msg;
    HandshakeMessage msg0 = (HandshakeMessage) msg;
    if (log.isDebugEnabled()) {
        log.debug("Received handshake message [locNodeId=" + locNode.id() + ", rmtNodeId=" + sndId + ", msg=" + msg0 + ']');
    }
    if (isChannelConnIdx(msg0.connectionIndex()))
        ses.send(new RecoveryLastReceivedMessage(0));
    else if (cfg.usePairedConnections() && usePairedConnections(rmtNode, attributeNames.pairedConnection())) {
        final GridNioRecoveryDescriptor recoveryDesc = nioSrvWrapper.inRecoveryDescriptor(rmtNode, connKey);
        ConnectClosureNew c = new ConnectClosureNew(ses, recoveryDesc, rmtNode);
        boolean reserve = recoveryDesc.tryReserve(msg0.connectCount(), c);
        if (reserve)
            connectedNew(recoveryDesc, ses, true);
        else {
            if (c.failed) {
                ses.send(new RecoveryLastReceivedMessage(ALREADY_CONNECTED));
                closeStaleConnections(connKey);
            }
        }
    } else {
        assert connKey.connectionIndex() >= 0 : connKey;
        GridCommunicationClient[] curClients = clientPool.clientFor(sndId);
        GridCommunicationClient oldClient = curClients != null && connKey.connectionIndex() < curClients.length ? curClients[connKey.connectionIndex()] : null;
        if (oldClient instanceof GridTcpNioCommunicationClient) {
            if (log.isInfoEnabled())
                log.info("Received incoming connection when already connected " + "to this node, rejecting [locNode=" + locNode.id() + ", rmtNode=" + sndId + ']');
            ses.send(new RecoveryLastReceivedMessage(ALREADY_CONNECTED));
            closeStaleConnections(connKey);
            return;
        }
        GridFutureAdapter<GridCommunicationClient> fut = new GridFutureAdapter<>();
        GridFutureAdapter<GridCommunicationClient> oldFut = clientPool.putIfAbsentFut(connKey, fut);
        final GridNioRecoveryDescriptor recoveryDesc = nioSrvWrapper.inRecoveryDescriptor(rmtNode, connKey);
        if (oldFut == null) {
            curClients = clientPool.clientFor(sndId);
            oldClient = curClients != null && connKey.connectionIndex() < curClients.length ? curClients[connKey.connectionIndex()] : null;
            if (oldClient instanceof GridTcpNioCommunicationClient) {
                assert oldClient.connectionIndex() == connKey.connectionIndex() : oldClient;
                if (log.isInfoEnabled())
                    log.info("Received incoming connection when already connected " + "to this node, rejecting [locNode=" + locNode.id() + ", rmtNode=" + sndId + ']');
                ses.send(new RecoveryLastReceivedMessage(ALREADY_CONNECTED));
                closeStaleConnections(connKey);
                fut.onDone(oldClient);
                return;
            }
            boolean reserved = recoveryDesc.tryReserve(msg0.connectCount(), new ConnectClosure(ses, recoveryDesc, rmtNode, connKey, msg0, true, fut));
            if (log.isDebugEnabled()) {
                log.debug("Received incoming connection from remote node " + "[rmtNode=" + rmtNode.id() + ", reserved=" + reserved + ", recovery=" + recoveryDesc + ']');
            }
            if (reserved) {
                try {
                    GridTcpNioCommunicationClient client = connected(recoveryDesc, ses, rmtNode, msg0.received(), true, true);
                    fut.onDone(client);
                } finally {
                    clientPool.removeFut(connKey, fut);
                }
            }
        } else {
            if (oldFut instanceof ConnectFuture && locNode.order() < rmtNode.order()) {
                if (log.isInfoEnabled()) {
                    log.info("Received incoming connection from remote node while " + "connecting to this node, rejecting [locNode=" + locNode.id() + ", locNodeOrder=" + locNode.order() + ", rmtNode=" + rmtNode.id() + ", rmtNodeOrder=" + rmtNode.order() + ']');
                }
                ses.send(new RecoveryLastReceivedMessage(ALREADY_CONNECTED));
            } else {
                boolean reserved = recoveryDesc.tryReserve(msg0.connectCount(), new ConnectClosure(ses, recoveryDesc, rmtNode, connKey, msg0, true, fut));
                GridTcpNioCommunicationClient client = null;
                if (reserved)
                    client = connected(recoveryDesc, ses, rmtNode, msg0.received(), true, true);
                if (oldFut instanceof ConnectionRequestFuture && !oldFut.isDone())
                    oldFut.onDone(client);
            }
        }
    }
}