Example usage for io.netty.util.concurrent Future cause

List of usage examples for io.netty.util.concurrent Future cause

  1. HOME
  2. Java
  3. io.netty
  4. io.netty.util.concurrent.*
  5. Future
  6. cause

Introduction

In this page you can find the example usage for io.netty.util.concurrent Future cause.

Prototype

Throwable cause();

Source Link

Document

Returns the cause of the failed I/O operation if the I/O operation has failed.

Usage

From source file:org.redisson.RedissonRemoteService.java

License:Apache License

private <T> void subscribe(final Class<T> remoteInterface,
        final RBlockingQueue<RemoteServiceRequest> requestQueue, final ExecutorService executor) {
    RFuture<RemoteServiceRequest> take = requestQueue.takeAsync();
    take.addListener(new FutureListener<RemoteServiceRequest>() {
        @Override/*from  www.jav  a 2  s . co m*/
        public void operationComplete(Future<RemoteServiceRequest> future) throws Exception {
            if (!future.isSuccess()) {
                log.error("Can't process the remote service request.", future.cause());
                if (future.cause() instanceof RedissonShutdownException) {
                    return;
                }
                // re-subscribe after a failed takeAsync
                subscribe(remoteInterface, requestQueue, executor);
                return;
            }

            // do not subscribe now, see
            // https://github.com/mrniko/redisson/issues/493
            // subscribe(remoteInterface, requestQueue);

            final RemoteServiceRequest request = future.getNow();
            // check the ack only if expected
            if (request.getOptions().isAckExpected() && System.currentTimeMillis() - request.getDate() > request
                    .getOptions().getAckTimeoutInMillis()) {
                log.debug("request: {} has been skipped due to ackTimeout");
                // re-subscribe after a skipped ackTimeout
                subscribe(remoteInterface, requestQueue, executor);
                return;
            }

            final String responseName = getResponseQueueName(remoteInterface, request.getRequestId());

            // send the ack only if expected
            if (request.getOptions().isAckExpected()) {
                String ackName = getAckName(remoteInterface, request.getRequestId());
                RFuture<Boolean> ackClientsFuture = commandExecutor.evalWriteAsync(responseName,
                        LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
                        "if redis.call('setnx', KEYS[1], 1) == 1 then "
                                + "redis.call('pexpire', KEYS[1], ARGV[2]);"
                                + "redis.call('rpush', KEYS[2], ARGV[1]);"
                                + "redis.call('pexpire', KEYS[2], ARGV[2]);" + "return 1;" + "end;"
                                + "return 0;",
                        Arrays.<Object>asList(ackName, responseName), encode(new RemoteServiceAck()),
                        request.getOptions().getAckTimeoutInMillis());

                ackClientsFuture.addListener(new FutureListener<Boolean>() {
                    @Override
                    public void operationComplete(Future<Boolean> future) throws Exception {
                        if (!future.isSuccess()) {
                            log.error("Can't send ack for request: " + request, future.cause());
                            if (future.cause() instanceof RedissonShutdownException) {
                                return;
                            }
                            // re-subscribe after a failed send (ack)
                            subscribe(remoteInterface, requestQueue, executor);
                            return;
                        }

                        if (!future.getNow()) {
                            subscribe(remoteInterface, requestQueue, executor);
                            return;
                        }

                        executeMethod(remoteInterface, requestQueue, executor, request);
                    }
                });
            } else {
                executeMethod(remoteInterface, requestQueue, executor, request);
            }
        }

    });
}

From source file:org.redisson.RedissonRemoteService.java

License:Apache License

private <T> void invokeMethod(final Class<T> remoteInterface,
        final RBlockingQueue<RemoteServiceRequest> requestQueue, final RemoteServiceRequest request,
        RemoteServiceMethod method, String responseName, final ExecutorService executor,
        RFuture<RemoteServiceCancelRequest> cancelRequestFuture,
        final AtomicReference<RRemoteServiceResponse> responseHolder) {
    try {/*  w w w  . j  a  va2  s.com*/
        if (method.getBean() instanceof RemoteParams) {
            ((RemoteParams) method.getBean()).setRequestId(request.getRequestId());
        }

        Object result = method.getMethod().invoke(method.getBean(), request.getArgs());

        RemoteServiceResponse response = new RemoteServiceResponse(result);
        responseHolder.compareAndSet(null, response);
    } catch (Exception e) {
        RemoteServiceResponse response = new RemoteServiceResponse(e.getCause());
        responseHolder.compareAndSet(null, response);
        log.error("Can't execute: " + request, e);
    }

    if (cancelRequestFuture != null) {
        cancelRequestFuture.cancel(false);
    }

    // send the response only if expected or task was canceled
    if (request.getOptions().isResultExpected()
            || responseHolder.get() instanceof RemoteServiceCancelResponse) {
        long timeout = 60 * 1000;
        if (request.getOptions().getExecutionTimeoutInMillis() != null) {
            timeout = request.getOptions().getExecutionTimeoutInMillis();
        }

        RFuture<List<?>> clientsFuture = send(timeout, responseName, responseHolder.get());
        clientsFuture.addListener(new FutureListener<List<?>>() {
            @Override
            public void operationComplete(Future<List<?>> future) throws Exception {
                if (!future.isSuccess()) {
                    log.error("Can't send response: " + responseHolder.get() + " for request: " + request,
                            future.cause());
                    if (future.cause() instanceof RedissonShutdownException) {
                        return;
                    }
                }

                // re-subscribe anyways (fail or success) after the send
                // (response)
                subscribe(remoteInterface, requestQueue, executor);
            }
        });
    } else {
        // re-subscribe anyways after the method invocation
        subscribe(remoteInterface, requestQueue, executor);
    }
}

From source file:org.redisson.RedissonSemaphore.java

License:Apache License

@Override
public RFuture<Void> acquireAsync(final int permits) {
    final RPromise<Void> result = newPromise();
    RFuture<Boolean> tryAcquireFuture = tryAcquireAsync(permits);
    tryAcquireFuture.addListener(new FutureListener<Boolean>() {
        @Override//from  ww  w  . j  a va2s.  c  om
        public void operationComplete(Future<Boolean> future) throws Exception {
            if (!future.isSuccess()) {
                result.tryFailure(future.cause());
                return;
            }

            if (future.getNow()) {
                if (!result.trySuccess(null)) {
                    releaseAsync(permits);
                }
                return;
            }

            final RFuture<RedissonLockEntry> subscribeFuture = subscribe();
            subscribeFuture.addListener(new FutureListener<RedissonLockEntry>() {
                @Override
                public void operationComplete(Future<RedissonLockEntry> future) throws Exception {
                    if (!future.isSuccess()) {
                        result.tryFailure(future.cause());
                        return;
                    }

                    acquireAsync(permits, subscribeFuture, result);
                }

            });
        }
    });
    return result;
}

From source file:org.redisson.RedissonSemaphore.java

License:Apache License

private void tryAcquireAsync(final AtomicLong time, final int permits,
        final RFuture<RedissonLockEntry> subscribeFuture, final RPromise<Boolean> result) {
    if (result.isDone()) {
        unsubscribe(subscribeFuture);/*  w  w  w  .jav a2 s.  co  m*/
        return;
    }

    if (time.get() <= 0) {
        unsubscribe(subscribeFuture);
        result.trySuccess(false);
        return;
    }

    final long current = System.currentTimeMillis();
    RFuture<Boolean> tryAcquireFuture = tryAcquireAsync(permits);
    tryAcquireFuture.addListener(new FutureListener<Boolean>() {
        @Override
        public void operationComplete(Future<Boolean> future) throws Exception {
            if (!future.isSuccess()) {
                unsubscribe(subscribeFuture);
                result.tryFailure(future.cause());
                return;
            }

            if (future.getNow()) {
                unsubscribe(subscribeFuture);
                if (!result.trySuccess(true)) {
                    releaseAsync(permits);
                }
                return;
            }

            long elapsed = System.currentTimeMillis() - current;
            time.addAndGet(-elapsed);

            if (time.get() <= 0) {
                unsubscribe(subscribeFuture);
                result.trySuccess(false);
                return;
            }

            // waiting for message
            final long current = System.currentTimeMillis();
            final RedissonLockEntry entry = getEntry();
            synchronized (entry) {
                if (entry.getLatch().tryAcquire()) {
                    tryAcquireAsync(time, permits, subscribeFuture, result);
                } else {
                    final AtomicBoolean executed = new AtomicBoolean();
                    final AtomicReference<Timeout> futureRef = new AtomicReference<Timeout>();
                    final Runnable listener = new Runnable() {
                        @Override
                        public void run() {
                            executed.set(true);
                            if (futureRef.get() != null && !futureRef.get().cancel()) {
                                entry.getLatch().release();
                                return;
                            }
                            long elapsed = System.currentTimeMillis() - current;
                            time.addAndGet(-elapsed);

                            tryAcquireAsync(time, permits, subscribeFuture, result);
                        }
                    };
                    entry.addListener(listener);

                    long t = time.get();
                    if (!executed.get()) {
                        Timeout scheduledFuture = commandExecutor.getConnectionManager()
                                .newTimeout(new TimerTask() {
                                    @Override
                                    public void run(Timeout timeout) throws Exception {
                                        synchronized (entry) {
                                            if (entry.removeListener(listener)) {
                                                long elapsed = System.currentTimeMillis() - current;
                                                time.addAndGet(-elapsed);

                                                tryAcquireAsync(time, permits, subscribeFuture, result);
                                            }
                                        }
                                    }
                                }, t, TimeUnit.MILLISECONDS);
                        futureRef.set(scheduledFuture);
                    }
                }
            }
        }
    });

}

From source file:org.redisson.RedissonSemaphore.java

License:Apache License

private void acquireAsync(final int permits, final RFuture<RedissonLockEntry> subscribeFuture,
        final RPromise<Void> result) {
    if (result.isDone()) {
        unsubscribe(subscribeFuture);/*from  ww w  . j a  v  a2s  .c o  m*/
        return;
    }

    RFuture<Boolean> tryAcquireFuture = tryAcquireAsync(permits);
    tryAcquireFuture.addListener(new FutureListener<Boolean>() {
        @Override
        public void operationComplete(Future<Boolean> future) throws Exception {
            if (!future.isSuccess()) {
                unsubscribe(subscribeFuture);
                result.tryFailure(future.cause());
                return;
            }

            if (future.getNow()) {
                unsubscribe(subscribeFuture);
                if (!result.trySuccess(null)) {
                    releaseAsync(permits);
                }
                return;
            }

            final RedissonLockEntry entry = getEntry();
            synchronized (entry) {
                if (entry.getLatch().tryAcquire(permits)) {
                    acquireAsync(permits, subscribeFuture, result);
                } else {
                    Runnable listener = new Runnable() {
                        @Override
                        public void run() {
                            acquireAsync(permits, subscribeFuture, result);
                        }
                    };
                    entry.addListener(listener);
                }
            }
        }
    });
}

From source file:org.redisson.RedissonSemaphore.java

License:Apache License

@Override
public RFuture<Boolean> tryAcquireAsync(final int permits, long waitTime, TimeUnit unit) {
    final RPromise<Boolean> result = newPromise();
    final AtomicLong time = new AtomicLong(unit.toMillis(waitTime));
    final long current = System.currentTimeMillis();
    RFuture<Boolean> tryAcquireFuture = tryAcquireAsync(permits);
    tryAcquireFuture.addListener(new FutureListener<Boolean>() {
        @Override/*from ww  w . j a  v a2s  . c o  m*/
        public void operationComplete(Future<Boolean> future) throws Exception {
            if (!future.isSuccess()) {
                result.tryFailure(future.cause());
                return;
            }

            if (future.getNow()) {
                if (!result.trySuccess(true)) {
                    releaseAsync(permits);
                }
                return;
            }

            long elapsed = System.currentTimeMillis() - current;
            time.addAndGet(-elapsed);

            if (time.get() <= 0) {
                result.trySuccess(false);
                return;
            }

            final long current = System.currentTimeMillis();
            final AtomicReference<Timeout> futureRef = new AtomicReference<Timeout>();
            final RFuture<RedissonLockEntry> subscribeFuture = subscribe();
            subscribeFuture.addListener(new FutureListener<RedissonLockEntry>() {
                @Override
                public void operationComplete(Future<RedissonLockEntry> future) throws Exception {
                    if (!future.isSuccess()) {
                        result.tryFailure(future.cause());
                        return;
                    }

                    if (futureRef.get() != null) {
                        futureRef.get().cancel();
                    }

                    long elapsed = System.currentTimeMillis() - current;
                    time.addAndGet(-elapsed);

                    if (time.get() < 0) {
                        unsubscribe(subscribeFuture);
                        result.trySuccess(false);
                        return;
                    }

                    tryAcquireAsync(time, permits, subscribeFuture, result);
                }
            });

            if (!subscribeFuture.isDone()) {
                Timeout scheduledFuture = commandExecutor.getConnectionManager().newTimeout(new TimerTask() {
                    @Override
                    public void run(Timeout timeout) throws Exception {
                        if (!subscribeFuture.isDone()) {
                            result.trySuccess(false);
                        }
                    }
                }, time.get(), TimeUnit.MILLISECONDS);
                futureRef.set(scheduledFuture);
            }
        }
    });

    return result;
}

From source file:org.springframework.messaging.tcp.reactor.Reactor2TcpClient.java

License:Apache License

@Override
public ListenableFuture<Void> shutdown() {
    synchronized (this.tcpClients) {
        this.stopping = true;
    }//from  ww  w  .  ja  va  2 s .  c  om

    Promise<Void> promise = Streams.from(this.tcpClients)
            .flatMap(new Function<TcpClient<Message<P>, Message<P>>, Promise<Void>>() {
                @Override
                public Promise<Void> apply(final TcpClient<Message<P>, Message<P>> client) {
                    return client.shutdown().onComplete(new Consumer<Promise<Void>>() {
                        @Override
                        public void accept(Promise<Void> voidPromise) {
                            tcpClients.remove(client);
                        }
                    });
                }
            }).next();

    if (this.eventLoopGroup != null) {
        final Promise<Void> eventLoopPromise = Promises.prepare();
        promise.onComplete(new Consumer<Promise<Void>>() {
            @Override
            public void accept(Promise<Void> voidPromise) {
                eventLoopGroup.shutdownGracefully().addListener(new FutureListener<Object>() {
                    @Override
                    public void operationComplete(Future<Object> future) throws Exception {
                        if (future.isSuccess()) {
                            eventLoopPromise.onComplete();
                        } else {
                            eventLoopPromise.onError(future.cause());
                        }
                    }
                });
            }
        });
        promise = eventLoopPromise;
    }
    return new PassThroughPromiseToListenableFutureAdapter<Void>(promise);
}

From source file:org.vertx.java.core.net.impl.DefaultNetSocket.java

License:Open Source License

@Override
public NetSocket ssl(final Handler<Void> handler) {
    SslHandler sslHandler = channel.pipeline().get(SslHandler.class);
    if (sslHandler == null) {
        sslHandler = helper.createSslHandler(vertx, client);
        channel.pipeline().addFirst(sslHandler);
    }//  ww  w. j  a  v  a  2 s .  c  om
    sslHandler.handshakeFuture().addListener(new GenericFutureListener<Future<Channel>>() {
        @Override
        public void operationComplete(final Future<Channel> future) throws Exception {
            if (context.isOnCorrectWorker(channel.eventLoop())) {
                if (future.isSuccess()) {
                    try {
                        vertx.setContext(context);
                        handler.handle(null);
                    } catch (Throwable t) {
                        context.reportException(t);
                    }
                } else {
                    context.reportException(future.cause());
                }

            } else {
                context.execute(new Runnable() {
                    public void run() {
                        if (future.isSuccess()) {
                            handler.handle(null);
                        } else {
                            context.reportException(future.cause());
                        }
                    }
                });
            }
        }
    });
    return this;
}

From source file:org.vootoo.client.netty.connect.SimpleConnectionPool.java

License:Apache License

public Channel acquireConnect() throws NettyConnectLessException {
    Future<Channel> future = acquire();

    // see https://netty.io/4.0/api/io/netty/channel/ChannelFuture.html
    // use bootstrap.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, connectTimeout);
    // so await without timeout
    future.awaitUninterruptibly();/*w  ww.  java 2  s . co  m*/

    assert future.isDone();

    if (future.isCancelled()) {
        // Connection attempt cancelled by user
        throw new NettyConnectLessException("connection cancelled tcp=" + socketAddress);
    } else if (!future.isSuccess()) {
        throw new NettyConnectLessException(
                "connect tcp=" + socketAddress + " fail within " + connectTimeout + "ms time!", future.cause());
    } else {
        // Connection established successfully
        Channel channel = future.getNow();

        if (logger.isDebugEnabled()) {
            logger.debug("acquire connect success channel={}", channel);
        }

        assert channel != null;

        if (channel == null) {
            throw new NettyConnectLessException("connect tcp=" + socketAddress + " fail within "
                    + connectTimeout + "ms time, future.getNow return null!");
        }

        return channel;
    }
}

From source file:org.waarp.common.crypto.ssl.WaarpSslUtility.java

License:Open Source License

/**
 * Wait for the handshake on the given channel (better to use addSslHandler when handler is added after channel is active)
 * /*from   w  ww. ja v  a2s.c  om*/
 * @param channel
 * @return True if the Handshake is done correctly
 */
public static boolean waitForHandshake(Channel channel) {
    final ChannelHandler handler = channel.pipeline().first();
    if (handler instanceof SslHandler) {
        logger.debug("Start handshake SSL: " + channel);
        final SslHandler sslHandler = (SslHandler) handler;
        // Get the SslHandler and begin handshake ASAP.
        // Get notified when SSL handshake is done.
        Future<Channel> handshakeFuture = sslHandler.handshakeFuture();
        try {
            handshakeFuture.await(sslHandler.getHandshakeTimeoutMillis() + 100);
        } catch (InterruptedException e1) {
        }
        logger.debug("Handshake: " + handshakeFuture.isSuccess() + ": " + channel, handshakeFuture.cause());
        if (!handshakeFuture.isSuccess()) {
            channel.close();
            return false;
        }
        return true;
    } else {
        logger.error("SSL Not found but connected: " + handler.getClass().getName());
        return true;
    }
}