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.connection.pool.ConnectionPool.java

License:Apache License

private void createConnection(final ClientConnectionsEntry entry, final RPromise<T> promise) {
    RFuture<T> connFuture = connect(entry);
    connFuture.addListener(new FutureListener<T>() {
        @Override/*from   w  w  w. ja  v a2 s. co m*/
        public void operationComplete(Future<T> future) throws Exception {
            if (!future.isSuccess()) {
                promiseFailure(entry, promise, future.cause());
                return;
            }

            T conn = future.getNow();
            if (!conn.isActive()) {
                promiseFailure(entry, promise, conn);
                return;
            }

            connectedSuccessful(entry, promise, conn);
        }
    });
}

From source file:org.redisson.connection.ReplicatedConnectionManager.java

License:Apache License

private void scheduleMasterChangeCheck(final ReplicatedServersConfig cfg) {
    monitorFuture = GlobalEventExecutor.INSTANCE.schedule(new Runnable() {
        @Override//  w ww  .  j ava  2  s .  c o  m
        public void run() {
            final URL master = currentMaster.get();
            log.debug("Current master: {}", master);

            final AtomicInteger count = new AtomicInteger(cfg.getNodeAddresses().size());
            for (final URL addr : cfg.getNodeAddresses()) {
                if (isShuttingDown()) {
                    return;
                }

                RFuture<RedisConnection> connectionFuture = connect(cfg, addr);
                connectionFuture.addListener(new FutureListener<RedisConnection>() {
                    @Override
                    public void operationComplete(Future<RedisConnection> future) throws Exception {
                        if (!future.isSuccess()) {
                            log.error(future.cause().getMessage(), future.cause());
                            if (count.decrementAndGet() == 0) {
                                scheduleMasterChangeCheck(cfg);
                            }
                            return;
                        }

                        if (isShuttingDown()) {
                            return;
                        }

                        RedisConnection connection = future.getNow();
                        RFuture<Map<String, String>> result = connection.async(RedisCommands.INFO_REPLICATION);
                        result.addListener(new FutureListener<Map<String, String>>() {
                            @Override
                            public void operationComplete(Future<Map<String, String>> future) throws Exception {
                                if (!future.isSuccess()) {
                                    log.error(future.cause().getMessage(), future.cause());
                                    if (count.decrementAndGet() == 0) {
                                        scheduleMasterChangeCheck(cfg);
                                    }
                                    return;
                                }

                                Role role = Role.valueOf(future.getNow().get(ROLE_KEY));
                                if (Role.master.equals(role)) {
                                    if (master.equals(addr)) {
                                        log.debug("Current master {} unchanged", master);
                                    } else if (currentMaster.compareAndSet(master, addr)) {
                                        log.info("Master has changed from {} to {}", master, addr);
                                        changeMaster(singleSlotRange.getStartSlot(), addr.getHost(),
                                                addr.getPort());
                                    }
                                }

                                if (count.decrementAndGet() == 0) {
                                    scheduleMasterChangeCheck(cfg);
                                }
                            }
                        });
                    }
                });
            }
        }

    }, cfg.getScanInterval(), TimeUnit.MILLISECONDS);
}

From source file:org.redisson.core.RedissonMultiLock.java

License:Apache License

private void lock(final Promise<Void> promise, final long waitTime, final long leaseTime, final TimeUnit unit)
        throws InterruptedException {
    final AtomicInteger tryLockRequestsAmount = new AtomicInteger();
    final Map<Future<Boolean>, RLock> tryLockFutures = new HashMap<Future<Boolean>, RLock>(locks.size());

    FutureListener<Boolean> listener = new FutureListener<Boolean>() {

        AtomicBoolean unlock = new AtomicBoolean();

        @Override//from  w  w w  .  j  a v  a2  s  .  c  o  m
        public void operationComplete(Future<Boolean> future) throws Exception {
            if (!future.isSuccess()) {
                // unlock once
                if (unlock.compareAndSet(false, true)) {
                    for (RLock lock : locks) {
                        lock.unlockAsync();
                    }

                    promise.setFailure(future.cause());
                }
                return;
            }

            Boolean res = future.getNow();
            // unlock once
            if (!res && unlock.compareAndSet(false, true)) {
                for (RLock lock : locks) {
                    lock.unlockAsync();
                }

                RLock lock = tryLockFutures.get(future);
                lock.lockAsync().addListener(new FutureListener<Void>() {
                    @Override
                    public void operationComplete(Future<Void> future) throws Exception {
                        if (!future.isSuccess()) {
                            promise.setFailure(future.cause());
                            return;
                        }

                        lock(promise, waitTime, leaseTime, unit);
                    }
                });
            }
            if (!unlock.get() && tryLockRequestsAmount.decrementAndGet() == 0) {
                promise.setSuccess(null);
            }
        }
    };

    for (RLock lock : locks) {
        if (lock.isHeldByCurrentThread()) {
            continue;
        }

        tryLockRequestsAmount.incrementAndGet();
        if (waitTime > 0 || leaseTime > 0) {
            tryLockFutures.put(lock.tryLockAsync(waitTime, leaseTime, unit), lock);
        } else {
            tryLockFutures.put(lock.tryLockAsync(), lock);
        }
    }

    for (Future<Boolean> future : tryLockFutures.keySet()) {
        future.addListener(listener);
    }
}

From source file:org.redisson.EvictionScheduler.java

License:Apache License

public void runCleanTask(final String name, String timeoutSetName, long currentDate) {

    final Long lastExpired = lastExpiredTime.get(name);
    long now = System.currentTimeMillis();
    if (lastExpired == null) {
        if (lastExpiredTime.putIfAbsent(name, now) != null) {
            return;
        }//ww w. j av a 2s.  c  o  m
    } else if (lastExpired + expireTaskExecutionDelay >= now) {
        if (!lastExpiredTime.replace(name, lastExpired, now)) {
            return;
        }
    } else {
        return;
    }

    Future<Integer> future = cleanupExpiredEntires(name, timeoutSetName, null, valuesAmountToClean);

    future.addListener(new FutureListener<Integer>() {
        @Override
        public void operationComplete(Future<Integer> future) throws Exception {
            executor.getConnectionManager().getGroup().schedule(new Runnable() {
                @Override
                public void run() {
                    lastExpiredTime.remove(name, lastExpired);
                }
            }, expireTaskExecutionDelay * 3, TimeUnit.SECONDS);

            if (!future.isSuccess()) {
                log.warn("Can't execute clean task for expired values. RSetCache name: " + name,
                        future.cause());
                return;
            }
        }
    });
}

From source file:org.redisson.executor.TasksService.java

License:Apache License

public RFuture<Boolean> cancelExecutionAsync(final String requestId) {
    final Class<?> syncInterface = RemoteExecutorService.class;
    String requestQueueName = getRequestQueueName(syncInterface);

    if (!redisson.getMap(tasksName, LongCodec.INSTANCE).containsKey(requestId)) {
        return RedissonPromise.newSucceededFuture(false);
    }//from   w w w . j av  a 2  s  .  com

    final RPromise<Boolean> result = new RedissonPromise<Boolean>();

    RBlockingQueue<RemoteServiceRequest> requestQueue = redisson.getBlockingQueue(requestQueueName, codec);

    RemoteServiceRequest request = new RemoteServiceRequest(requestId);
    RFuture<Boolean> removeFuture = removeAsync(requestQueue, request);
    removeFuture.addListener(new FutureListener<Boolean>() {
        @Override
        public void operationComplete(Future<Boolean> future) throws Exception {
            if (!future.isSuccess()) {
                result.tryFailure(future.cause());
                return;
            }

            if (future.getNow()) {
                result.trySuccess(true);
            } else {
                String cancelRequestMapName = getCancelRequestMapName(syncInterface);

                RMap<String, RemoteServiceCancelRequest> canceledRequests = redisson
                        .getMap(cancelRequestMapName, codec);
                canceledRequests.putAsync(requestId, new RemoteServiceCancelRequest(true, true));
                canceledRequests.expireAsync(60, TimeUnit.SECONDS);

                String cancelResponseMapName = getCancelResponseMapName(syncInterface);
                final RPromise<RemoteServiceCancelResponse> response = new RedissonPromise<RemoteServiceCancelResponse>();
                scheduleCheck(cancelResponseMapName, requestId, response);
                response.addListener(new FutureListener<RemoteServiceCancelResponse>() {
                    @Override
                    public void operationComplete(Future<RemoteServiceCancelResponse> future) throws Exception {
                        if (!future.isSuccess()) {
                            result.tryFailure(future.cause());
                            return;
                        }

                        if (response.getNow() == null) {
                            result.trySuccess(false);
                            return;
                        }
                        result.trySuccess(response.getNow().isCanceled());
                    }
                });
            }
        }
    });

    return result;
}

From source file:org.redisson.MapWriterPromise.java

License:Apache License

public MapWriterPromise(RFuture<R> f, final CommandAsyncExecutor commandExecutor, final MapWriterTask<R> task) {
    f.addListener(new FutureListener<R>() {
        @Override/* w  w w. ja va2s  . com*/
        public void operationComplete(final Future<R> future) throws Exception {
            if (!future.isSuccess()) {
                tryFailure(future.cause());
                return;
            }

            if (task.condition(future)) {
                commandExecutor.getConnectionManager().getExecutor().execute(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            task.execute();
                        } catch (Exception e) {
                            tryFailure(e);
                            return;
                        }
                        trySuccess(future.getNow());
                    }
                });
            } else {
                trySuccess(future.getNow());
            }
        }
    });
}

From source file:org.redisson.misc.ConnectionPool.java

License:Apache License

private Future<T> connectTo(final ClientConnectionsEntry entry) {
    T conn = poll(entry);//from  w  w  w  .j  a va  2s . c om
    if (conn != null) {
        if (!conn.isActive()) {
            return promiseFailure(entry, conn);
        }

        return promiseSuccessful(entry, conn);
    }

    final Promise<T> promise = connectionManager.newPromise();
    Future<T> connFuture = connect(entry);
    connFuture.addListener(new FutureListener<T>() {
        @Override
        public void operationComplete(Future<T> future) throws Exception {
            if (!future.isSuccess()) {
                releaseConnection(entry);

                promiseFailure(entry, promise, future.cause());
                return;
            }

            T conn = future.getNow();
            if (!conn.isActive()) {
                promiseFailure(entry, promise, conn);
                return;
            }

            promiseSuccessful(entry, promise, conn);
        }
    });
    return promise;
}

From source file:org.redisson.misc.TransferListener.java

License:Apache License

@Override
public void operationComplete(Future<T> future) throws Exception {
    if (!future.isSuccess()) {
        promise.tryFailure(future.cause());
        return;// ww w.j a  va 2  s  .  c  om
    }

    promise.trySuccess(future.getNow());
}

From source file:org.redisson.OperationListener.java

License:Apache License

protected boolean isBreak(RedisAsyncConnection<Object, V> async, Promise<V> promise, Future<F> future) {
    if (!future.isSuccess()) {
        promise.setFailure(future.cause());
        return true;
    }/*  w w w  .  j  a  v a2s.  c  o m*/
    if (promise.isCancelled()) {
        if (async.isMultiMode()) {
            async.discard();
        }
        return true;
    }

    return false;
}

From source file:org.redisson.QueueTransferTask.java

License:Apache License

private void addListener(RFuture<Long> startTimeFuture) {
    startTimeFuture.addListener(new FutureListener<Long>() {
        @Override//from   www.  ja va 2 s .c om
        public void operationComplete(io.netty.util.concurrent.Future<Long> future) throws Exception {
            if (!future.isSuccess()) {
                if (future.cause() instanceof RedissonShutdownException) {
                    return;
                }
                log.error(future.cause().getMessage(), future.cause());
                scheduleTask(System.currentTimeMillis() + 5 * 1000L);
                return;
            }

            if (future.getNow() != null) {
                scheduleTask(future.getNow());
            }
        }
    });
}