Examples with Future org.apache.flink.shaded.netty4.io.netty.util.concurrent.Future used on opensource projects

Example 36 with Future

use of org.apache.flink.shaded.netty4.io.netty.util.concurrent.Future in project netty by netty.

the class ReentrantChannelTest method testCloseInFlush.

@Test
public void testCloseInFlush() throws Exception {
    LocalAddress addr = new LocalAddress("testCloseInFlush");
    ServerBootstrap sb = getLocalServerBootstrap();
    sb.bind(addr).sync().channel();
    Bootstrap cb = getLocalClientBootstrap();
    setInterest(Event.WRITE, Event.FLUSH, Event.CLOSE, Event.EXCEPTION);
    Channel clientChannel = cb.connect(addr).sync().channel();
    clientChannel.pipeline().addLast(new ChannelOutboundHandlerAdapter() {

        @Override
        public void write(final ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
            promise.addListener(new GenericFutureListener<Future<? super Void>>() {

                @Override
                public void operationComplete(Future<? super Void> future) throws Exception {
                    ctx.channel().close();
                }
            });
            super.write(ctx, msg, promise);
            ctx.channel().flush();
        }
    });
    clientChannel.write(createTestBuf(2000)).sync();
    clientChannel.closeFuture().sync();
    assertLog("WRITE\nFLUSH\nCLOSE\n");
}

Example 37 with Future

use of org.apache.flink.shaded.netty4.io.netty.util.concurrent.Future in project hive by apache.

the class TestRpc method testRpcServerMultiThread.

@Test
public void testRpcServerMultiThread() throws Exception {
    final RpcServer server = autoClose(new RpcServer(emptyConfig, hiveConf));
    final String msg = "Hello World!";
    Callable<String> callable = () -> {
        Rpc[] rpcs = createRpcConnection(server, emptyConfig, UUID.randomUUID().toString());
        Rpc rpc;
        if (ThreadLocalRandom.current().nextBoolean()) {
            rpc = rpcs[0];
        } else {
            rpc = rpcs[1];
        }
        TestMessage outbound = new TestMessage("Hello World!");
        Future<TestMessage> call = rpc.call(outbound, TestMessage.class);
        TestMessage reply = call.get(10, TimeUnit.SECONDS);
        return reply.message;
    };
    final int numThreads = ThreadLocalRandom.current().nextInt(5) + 5;
    ExecutorService executor = Executors.newFixedThreadPool(numThreads);
    List<java.util.concurrent.Future<String>> futures = new ArrayList<>(numThreads);
    for (int i = 0; i < numThreads; i++) {
        futures.add(executor.submit(callable));
    }
    executor.shutdown();
    for (java.util.concurrent.Future<String> future : futures) {
        assertEquals(msg, future.get());
    }
}

Example 38 with Future

use of org.apache.flink.shaded.netty4.io.netty.util.concurrent.Future in project web3sdk by FISCO-BCOS.

the class ChannelConnections method reconnect.

public void reconnect() {
    List<ConnectionInfo> connectionInfoList = new ArrayList<>();
    int aliveConnectionCount = 0;
    for (ConnectionInfo connectionInfo : connections) {
        String peer = connectionInfo.getHost() + ":" + connectionInfo.getPort();
        ChannelHandlerContext ctx = networkConnections.get(peer);
        if (Objects.isNull(ctx) || !ctx.channel().isActive()) {
            connectionInfoList.add(connectionInfo);
        } else {
            aliveConnectionCount += 1;
        }
    }
    logger.trace(" Keep alive nodes count: {}", aliveConnectionCount);
    for (ConnectionInfo connectionInfo : connectionInfoList) {
        logger.debug(" try reconnect to {}:{}", connectionInfo.getHost(), connectionInfo.getPort());
        bootstrap.connect(connectionInfo.getHost(), connectionInfo.getPort()).addListener((ChannelFutureListener) future -> {
            if (future.isSuccess()) {
                logger.trace(" reconnect to {}:{} success", connectionInfo.getHost(), connectionInfo.getPort());
            } else {
                logger.error(" reconnect to {}:{}, error: {}", connectionInfo.getHost(), connectionInfo.getPort(), future.cause().getMessage());
            }
        });
    }
}

Example 39 with Future

use of org.apache.flink.shaded.netty4.io.netty.util.concurrent.Future in project thingsboard by thingsboard.

the class MqttClientImpl method createSubscription.

private Future<Void> createSubscription(String topic, MqttHandler handler, boolean once, MqttQoS qos) {
    if (this.pendingSubscribeTopics.contains(topic)) {
        Optional<Map.Entry<Integer, MqttPendingSubscription>> subscriptionEntry = this.pendingSubscriptions.entrySet().stream().filter((e) -> e.getValue().getTopic().equals(topic)).findAny();
        if (subscriptionEntry.isPresent()) {
            subscriptionEntry.get().getValue().addHandler(handler, once);
            return subscriptionEntry.get().getValue().getFuture();
        }
    }
    if (this.serverSubscriptions.contains(topic)) {
        MqttSubscription subscription = new MqttSubscription(topic, handler, once);
        this.subscriptions.put(topic, subscription);
        this.handlerToSubscribtion.put(handler, subscription);
        return this.channel.newSucceededFuture();
    }
    Promise<Void> future = new DefaultPromise<>(this.eventLoop.next());
    MqttFixedHeader fixedHeader = new MqttFixedHeader(MqttMessageType.SUBSCRIBE, false, MqttQoS.AT_LEAST_ONCE, false, 0);
    MqttTopicSubscription subscription = new MqttTopicSubscription(topic, qos);
    MqttMessageIdVariableHeader variableHeader = getNewMessageId();
    MqttSubscribePayload payload = new MqttSubscribePayload(Collections.singletonList(subscription));
    MqttSubscribeMessage message = new MqttSubscribeMessage(fixedHeader, variableHeader, payload);
    final MqttPendingSubscription pendingSubscription = new MqttPendingSubscription(future, topic, message, () -> !pendingSubscriptions.containsKey(variableHeader.messageId()));
    pendingSubscription.addHandler(handler, once);
    this.pendingSubscriptions.put(variableHeader.messageId(), pendingSubscription);
    this.pendingSubscribeTopics.add(topic);
    // If not sent, we will send it when the connection is opened
    pendingSubscription.setSent(this.sendAndFlushPacket(message) != null);
    pendingSubscription.startRetransmitTimer(this.eventLoop.next(), this::sendAndFlushPacket);
    return future;
}

Example 40 with Future

use of org.apache.flink.shaded.netty4.io.netty.util.concurrent.Future in project reactor-netty by reactor.

the class FutureMonoTest method testDeferredFutureMonoImmediate.

@Test
void testDeferredFutureMonoImmediate() {
    ImmediateEventExecutor eventExecutor = ImmediateEventExecutor.INSTANCE;
    Supplier<Future<Void>> promiseSupplier = () -> eventExecutor.newFailedFuture(new ClosedChannelException());
    StepVerifier.create(FutureMono.deferFuture(promiseSupplier)).expectError(AbortedException.class).verify(Duration.ofSeconds(30));
}