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

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

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

Introduction

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

Prototype

boolean isSuccess();

Source Link

Document

Returns true if and only if the I/O operation was completed successfully.

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  w w  w.j  a v  a2  s  . c  o 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 executeMethod(final Class<T> remoteInterface,
        final RBlockingQueue<RemoteServiceRequest> requestQueue, final ExecutorService executor,
        final RemoteServiceRequest request) {
    final RemoteServiceMethod method = beans
            .get(new RemoteServiceKey(remoteInterface, request.getMethodName(), request.getSignatures()));
    final String responseName = getResponseQueueName(remoteInterface, request.getRequestId());

    RBlockingQueue<RemoteServiceCancelRequest> cancelRequestQueue = redisson
            .getBlockingQueue(getCancelRequestQueueName(remoteInterface, request.getRequestId()), getCodec());
    final RFuture<RemoteServiceCancelRequest> cancelRequestFuture = cancelRequestQueue.takeAsync();

    final AtomicReference<RRemoteServiceResponse> responseHolder = new AtomicReference<RRemoteServiceResponse>();

    final java.util.concurrent.Future<?> submitFuture = executor.submit(new Runnable() {
        @Override// w  w w . j a va 2s. c o  m
        public void run() {
            invokeMethod(remoteInterface, requestQueue, request, method, responseName, executor,
                    cancelRequestFuture, responseHolder);
        }
    });

    cancelRequestFuture.addListener(new FutureListener<RemoteServiceCancelRequest>() {
        @Override
        public void operationComplete(Future<RemoteServiceCancelRequest> future) throws Exception {
            if (!future.isSuccess()) {
                return;
            }

            boolean res = submitFuture.cancel(future.getNow().isMayInterruptIfRunning());
            if (res) {
                RemoteServiceCancelResponse response = new RemoteServiceCancelResponse();
                if (!responseHolder.compareAndSet(null, response)) {
                    response = new RemoteServiceCancelResponse(false);
                }
                // could be removed not from future object
                if (future.getNow().getResponseId() != null) {
                    String cancelResponseName = getResponseQueueName(remoteInterface,
                            future.getNow().getResponseId());
                    send(60 * 1000, cancelResponseName, response);
                }
            }
        }
    });
}

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 {/*from  ww  w  .  ja  v a 2s.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/* ww  w .  j  a  v a  2s . 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(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);/*from  w ww. java2 s  .  com*/
        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 w  w  w. j av a  2  s . com*/
        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//ww  w. ja  va  2  s .c  om
        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.redisson.RedissonWriteLock.java

License:Apache License

@Override
public RFuture<Boolean> forceUnlockAsync() {
    RFuture<Boolean> result = commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE,
            RedisCommands.EVAL_BOOLEAN,//from w  w  w. j a v a 2  s. c o  m
            "if (redis.call('hget', KEYS[1], 'mode') == 'write') then " + "redis.call('del', KEYS[1]); "
                    + "redis.call('publish', KEYS[2], ARGV[1]); " + "return 1; " + "else " + "return 0; "
                    + "end;",
            Arrays.<Object>asList(getName(), getChannelName()), LockPubSub.unlockMessage);

    result.addListener(new FutureListener<Boolean>() {
        @Override
        public void operationComplete(Future<Boolean> future) throws Exception {
            if (future.isSuccess() && future.getNow()) {
                cancelExpirationRenewal();
            }
        }
    });

    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 w ww.  j a  va2 s. com

    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);
    }//from w w w .  j  ava2  s  .c  o m
    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;
}