Examples with Reply org.infinispan.remoting.inboundhandler.Reply used on opensource projects

Example 1 with Reply

use of org.infinispan.remoting.inboundhandler.Reply in project infinispan by infinispan.

the class PrepareProcessedAfterOriginatorCrashTest method testBelatedTransactionDoesntLeak.

public void testBelatedTransactionDoesntLeak() throws Throwable {
    CountDownLatch prepareReceived = new CountDownLatch(1);
    CountDownLatch prepareBlocked = new CountDownLatch(1);
    CountDownLatch prepareExecuted = new CountDownLatch(1);
    Cache receiver = cache(1);
    PerCacheInboundInvocationHandler originalInvocationHandler = TestingUtil.extractComponent(receiver, PerCacheInboundInvocationHandler.class);
    PerCacheInboundInvocationHandler blockingInvocationHandler = new AbstractDelegatingHandler(originalInvocationHandler) {

        @Override
        public void handle(CacheRpcCommand command, Reply reply, DeliverOrder order) {
            if (!(command instanceof PrepareCommand)) {
                delegate.handle(command, reply, order);
                return;
            }
            try {
                prepareReceived.countDown();
                prepareBlocked.await(10, TimeUnit.SECONDS);
            } catch (InterruptedException e) {
                throw new IllegalLifecycleStateException(e);
            }
            log.trace("Processing belated prepare");
            delegate.handle(command, returnValue -> {
                prepareExecuted.countDown();
                reply.reply(returnValue);
            }, order);
        }
    };
    TestingUtil.replaceComponent(receiver, PerCacheInboundInvocationHandler.class, blockingInvocationHandler, true);
    TestingUtil.extractComponentRegistry(receiver).cacheComponents();
    final Object key = getKeyForCache(1);
    fork(() -> {
        try {
            cache(0).put(key, "v");
        } catch (Throwable e) {
        // possible as the node is being killed
        }
    });
    prepareReceived.await(10, TimeUnit.SECONDS);
    killMember(0);
    // give TransactionTable.cleanupStaleTransactions some time to run
    Thread.sleep(5000);
    prepareBlocked.countDown();
    prepareExecuted.await(10, TimeUnit.SECONDS);
    log.trace("Finished waiting for belated prepare to complete");
    final TransactionTable transactionTable = TestingUtil.getTransactionTable(receiver);
    assertEquals(0, transactionTable.getRemoteTxCount());
    assertEquals(0, transactionTable.getLocalTxCount());
    assertFalse(receiver.getAdvancedCache().getLockManager().isLocked(key));
}

Example 2 with Reply

use of org.infinispan.remoting.inboundhandler.Reply in project infinispan by infinispan.

the class JGroupsTransportTest method blockRemoteGets.

private CompletableFuture<Void> blockRemoteGets() {
    CompletableFuture<Void> blocker = new CompletableFuture<>();
    InboundInvocationHandler oldInvocationHandler = TestingUtil.extractGlobalComponent(manager(1), InboundInvocationHandler.class);
    InboundInvocationHandler blockingInvocationHandler = new InboundInvocationHandler() {

        @Override
        public void handleFromCluster(Address origin, ReplicableCommand command, Reply reply, DeliverOrder order) {
            if (command instanceof ClusteredGetCommand) {
                log.tracef("Blocking clustered get");
                blocker.thenRun(() -> oldInvocationHandler.handleFromCluster(origin, command, reply, order));
            } else {
                oldInvocationHandler.handleFromCluster(origin, command, reply, order);
            }
        }

        @Override
        public void handleFromRemoteSite(String origin, XSiteReplicateCommand command, Reply reply, DeliverOrder order) {
            oldInvocationHandler.handleFromRemoteSite(origin, command, reply, order);
        }
    };
    TestingUtil.replaceComponent(manager(1), InboundInvocationHandler.class, blockingInvocationHandler, true);
    return blocker;
}

Example 3 with Reply

use of org.infinispan.remoting.inboundhandler.Reply in project infinispan by infinispan.

the class PushTransferTest method testNodeJoin.

public void testNodeJoin() throws Exception {
    List<MagicKey> keys = init();
    EmbeddedCacheManager cm4 = addClusterEnabledCacheManager(TestDataSCI.INSTANCE, null, TRANSPORT_FLAGS);
    cm4.defineConfiguration(CACHE_NAME, defaultConfig.build());
    int startTopologyId = c1.getAdvancedCache().getDistributionManager().getCacheTopology().getTopologyId();
    BlockingLocalTopologyManager bltm = BlockingLocalTopologyManager.replaceTopologyManager(cm4, CACHE_NAME);
    CountDownLatch statePushedLatch = new CountDownLatch(1);
    CountDownLatch stateAppliedLatch = new CountDownLatch(1);
    TestingUtil.addCacheStartingHook(cm4, (name, cr) -> {
        PerCacheInboundInvocationHandler originalHandler = cr.getComponent(PerCacheInboundInvocationHandler.class);
        AbstractDelegatingHandler newHandler = new AbstractDelegatingHandler(originalHandler) {

            @Override
            public void handle(CacheRpcCommand command, Reply reply, DeliverOrder order) {
                // StateResponseCommand is topology-aware, so handle() just queues it on the remote executor
                if (command instanceof StateResponseCommand) {
                    log.tracef("State received on %s", cm4.getAddress());
                    statePushedLatch.countDown();
                }
                originalHandler.handle(command, response -> {
                    log.tracef("State applied on %s", cm4.getAddress());
                    stateAppliedLatch.countDown();
                    reply.reply(response);
                }, order);
            }
        };
        BasicComponentRegistry bcr = cr.getComponent(BasicComponentRegistry.class);
        bcr.replaceComponent(PerCacheInboundInvocationHandler.class.getName(), newHandler, false);
        cr.rewire();
        cr.cacheComponents();
    });
    Future<Cache> c4Future = fork(() -> cm4.getCache(CACHE_NAME));
    // Any StateResponseCommand should be delayed until node 4 has the TRANSITORY topology
    assertTrue(statePushedLatch.await(10, TimeUnit.SECONDS));
    assertFalse(stateAppliedLatch.await(100, TimeUnit.MILLISECONDS));
    // Finish the rebalance, unblocking the StateResponseCommand(s)
    bltm.confirmTopologyUpdate(CacheTopology.Phase.TRANSITORY);
    assertEquals(0, stateAppliedLatch.getCount());
    bltm.confirmTopologyUpdate(CacheTopology.Phase.NO_REBALANCE);
    Cache c4 = c4Future.get(30, TimeUnit.SECONDS);
    TestingUtil.blockUntilViewsReceived(30000, false, c1, c2, c3, c4);
    TestingUtil.waitForNoRebalance(c1, c2, c3, c4);
    for (MagicKey key : keys) {
        int copies = Stream.of(c1, c2, c3, c4).mapToInt(c -> c.getAdvancedCache().getDataContainer().containsKey(key) ? 1 : 0).sum();
        assertEquals("Key " + key + " has incorrect number of copies", 2, copies);
    }
}

Example 4 with Reply

use of org.infinispan.remoting.inboundhandler.Reply in project infinispan by infinispan.

the class JGroupsTransport method processRequest.

private void processRequest(org.jgroups.Address src, short flags, byte[] buffer, int offset, int length, long requestId) {
    try {
        DeliverOrder deliverOrder = decodeDeliverMode(flags);
        if (src.equals(((JGroupsAddress) getAddress()).getJGroupsAddress())) {
            // DISCARD ignores the DONT_LOOPBACK flag, see https://issues.jboss.org/browse/JGRP-2205
            if (log.isTraceEnabled())
                log.tracef("Ignoring request %d from self without total order", requestId);
            return;
        }
        ReplicableCommand command = (ReplicableCommand) marshaller.objectFromByteBuffer(buffer, offset, length);
        Reply reply;
        if (requestId != Request.NO_REQUEST_ID) {
            if (log.isTraceEnabled())
                log.tracef("%s received request %d from %s: %s", getAddress(), requestId, src, command);
            reply = response -> sendResponse(src, response, requestId, command);
        } else {
            if (log.isTraceEnabled())
                log.tracef("%s received command from %s: %s", getAddress(), src, command);
            reply = Reply.NO_OP;
        }
        if (src instanceof SiteAddress) {
            String originSite = ((SiteAddress) src).getSite();
            XSiteReplicateCommand<?> xsiteCommand = (XSiteReplicateCommand<?>) command;
            xsiteCommand.setOriginSite(originSite);
            invocationHandler.handleFromRemoteSite(originSite, xsiteCommand, reply, deliverOrder);
        } else {
            invocationHandler.handleFromCluster(fromJGroupsAddress(src), command, reply, deliverOrder);
        }
    } catch (Throwable t) {
        CLUSTER.errorProcessingRequest(requestId, src, t);
        Exception e = t instanceof Exception ? ((Exception) t) : new CacheException(t);
        sendResponse(src, new ExceptionResponse(e), requestId, null);
    }
}

Example 5 with Reply

use of org.infinispan.remoting.inboundhandler.Reply in project infinispan by infinispan.

the class ScatteredStreamIteratorTest method blockStateTransfer.

@Override
protected <K> void blockStateTransfer(Cache<?, ?> cache, CheckPoint checkPoint) {
    // TODO Replace with Mocks.blockInboundCacheRpcCommand() once ISPN-10864 is fixed
    Executor executor = extractGlobalComponent(cache.getCacheManager(), ExecutorService.class, KnownComponentNames.NON_BLOCKING_EXECUTOR);
    TestingUtil.wrapInboundInvocationHandler(cache, handler -> new AbstractDelegatingHandler(handler) {

        @Override
        public void handle(CacheRpcCommand command, Reply reply, DeliverOrder order) {
            if (!(command instanceof ScatteredStateGetKeysCommand)) {
                delegate.handle(command, reply, order);
                return;
            }
            checkPoint.trigger(Mocks.BEFORE_INVOCATION);
            // Scattered cache iteration blocks and waits for state transfer to fetch the values
            // if a segment is owned in the pending CH, so we can't block forever
            // Instead we just block for 2 seconds to verify ISPN-10984
            checkPoint.future(Mocks.BEFORE_RELEASE, 2, TimeUnit.SECONDS, executor).whenComplete((ignored1, ignored2) -> delegate.handle(command, reply, order)).thenCompose(ignored -> {
                checkPoint.trigger(Mocks.AFTER_INVOCATION);
                return checkPoint.future(Mocks.AFTER_RELEASE, 20, TimeUnit.SECONDS, executor);
            });
        }
    });
}