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.async.OperationListener.java

License:Apache License

protected boolean isBreak(RedisAsyncConnection<Object, V> async, Promise<P> promise, Future<F> future) {
    if (!future.isSuccess()) {
        if (future.cause() instanceof RedisTimeoutException) {
            timeoutCallback.execute(promise, async);
            return false;
        } else {/*from   www . j a  v  a2  s.  c  o  m*/
            promise.setFailure(future.cause());
            return true;
        }
    }

    if (promise.isCancelled()) {
        if (async.isMultiMode()) {
            async.discard();
        }
        return true;
    }

    return false;
}

From source file:org.redisson.BaseRemoteService.java

License:Apache License

private void awaitResultAsync(final RemoteInvocationOptions optionsCopy, final RemotePromise<Object> result,
        final RemoteServiceRequest request, final String responseName, final String ackName) {
    RFuture<Boolean> deleteFuture = redisson.getBucket(ackName).deleteAsync();
    deleteFuture.addListener(new FutureListener<Boolean>() {
        @Override/*from   w w  w. ja  v  a  2s  .co m*/
        public void operationComplete(Future<Boolean> future) throws Exception {
            if (!future.isSuccess()) {
                result.tryFailure(future.cause());
                return;
            }

            awaitResultAsync(optionsCopy, result, request, responseName);
        }
    });
}

From source file:org.redisson.BaseRemoteService.java

License:Apache License

protected void awaitResultAsync(final RemoteInvocationOptions optionsCopy, final RemotePromise<Object> result,
        final RemoteServiceRequest request, final String responseName) {
    // poll for the response only if expected
    if (!optionsCopy.isResultExpected()) {
        return;/*from  www .j a  va2s.  c  o  m*/
    }

    RBlockingQueue<RRemoteServiceResponse> responseQueue = redisson.getBlockingQueue(responseName, getCodec());
    RFuture<RRemoteServiceResponse> responseFuture = responseQueue
            .pollAsync(optionsCopy.getExecutionTimeoutInMillis(), TimeUnit.MILLISECONDS);
    responseFuture.addListener(new FutureListener<RRemoteServiceResponse>() {

        @Override
        public void operationComplete(Future<RRemoteServiceResponse> future) throws Exception {
            if (!future.isSuccess()) {
                result.tryFailure(future.cause());
                return;
            }

            if (future.getNow() == null) {
                RemoteServiceTimeoutException e = new RemoteServiceTimeoutException("No response after "
                        + optionsCopy.getExecutionTimeoutInMillis() + "ms for request: " + request);
                result.tryFailure(e);
                return;
            }

            if (future.getNow() instanceof RemoteServiceCancelResponse) {
                result.doCancel();
                return;
            }

            RemoteServiceResponse response = (RemoteServiceResponse) future.getNow();
            if (response.getError() != null) {
                result.tryFailure(response.getError());
                return;
            }

            result.trySuccess(response.getResult());
        }
    });
}

From source file:org.redisson.BaseRemoteService.java

License:Apache License

private RFuture<RemoteServiceAck> tryPollAckAgainAsync(RemoteInvocationOptions optionsCopy,
        final RBlockingQueue<RemoteServiceAck> responseQueue, String ackName) throws InterruptedException {
    final RPromise<RemoteServiceAck> promise = commandExecutor.getConnectionManager().newPromise();
    RFuture<Boolean> ackClientsFuture = commandExecutor.evalWriteAsync(ackName, LongCodec.INSTANCE,
            RedisCommands.EVAL_BOOLEAN,/*from  w  ww  .ja v  a2  s  .  co m*/
            "if redis.call('setnx', KEYS[1], 1) == 1 then " + "redis.call('pexpire', KEYS[1], ARGV[1]);"
                    + "return 0;" + "end;" + "redis.call('del', KEYS[1]);" + "return 1;",
            Arrays.<Object>asList(ackName), optionsCopy.getAckTimeoutInMillis());
    ackClientsFuture.addListener(new FutureListener<Boolean>() {
        @Override
        public void operationComplete(Future<Boolean> future) throws Exception {
            if (!future.isSuccess()) {
                promise.tryFailure(future.cause());
                return;
            }

            if (future.getNow()) {
                RFuture<RemoteServiceAck> pollFuture = responseQueue.pollAsync();
                pollFuture.addListener(new FutureListener<RemoteServiceAck>() {
                    @Override
                    public void operationComplete(Future<RemoteServiceAck> future) throws Exception {
                        if (!future.isSuccess()) {
                            promise.tryFailure(future.cause());
                            return;
                        }

                        promise.trySuccess(future.getNow());
                    }
                });
            } else {
                promise.trySuccess(null);
            }
        }
    });
    return promise;
}

From source file:org.redisson.client.handler.ConnectionWatchdog.java

License:Apache License

private void reconnect(final RedisConnection connection, final Channel channel) {
    if (connection.getReconnectListener() != null) {
        // new connection used only for channel init
        RedisConnection rc = new RedisConnection(connection.getRedisClient(), channel);
        RPromise<RedisConnection> connectionFuture = new RedissonPromise<RedisConnection>();
        connection.getReconnectListener().onReconnect(rc, connectionFuture);
        connectionFuture.addListener(new FutureListener<RedisConnection>() {
            @Override/*from  ww  w.j a v  a  2 s  .co m*/
            public void operationComplete(Future<RedisConnection> future) throws Exception {
                if (future.isSuccess()) {
                    refresh(connection, channel);
                }
            }
        });
    } else {
        refresh(connection, channel);
    }
}

From source file:org.redisson.cluster.ClusterConnectionManager.java

License:Apache License

private RFuture<Collection<RFuture<Void>>> addMasterEntry(final ClusterPartition partition,
        final ClusterServersConfig cfg) {
    if (partition.isMasterFail()) {
        RedisException e = new RedisException("Failed to add master: " + partition.getMasterAddress()
                + " for slot ranges: " + partition.getSlotRanges() + ". Reason - server has FAIL flag");

        if (partition.getSlotRanges().isEmpty()) {
            e = new RedisException("Failed to add master: " + partition.getMasterAddress()
                    + ". Reason - server has FAIL flag");
        }//from ww w.  ja v a  2 s .c  om
        return newFailedFuture(e);
    }

    final RPromise<Collection<RFuture<Void>>> result = newPromise();
    RFuture<RedisConnection> connectionFuture = connect(cfg, partition.getMasterAddress());
    connectionFuture.addListener(new FutureListener<RedisConnection>() {
        @Override
        public void operationComplete(Future<RedisConnection> future) throws Exception {
            if (!future.isSuccess()) {
                log.error("Can't connect to master: {} with slot ranges: {}", partition.getMasterAddress(),
                        partition.getSlotRanges());
                result.tryFailure(future.cause());
                return;
            }

            final RedisConnection connection = future.getNow();
            RFuture<Map<String, String>> clusterFuture = connection.async(RedisCommands.CLUSTER_INFO);
            clusterFuture.addListener(new FutureListener<Map<String, String>>() {

                @Override
                public void operationComplete(Future<Map<String, String>> future) throws Exception {
                    if (!future.isSuccess()) {
                        log.error("Can't execute CLUSTER_INFO for " + connection.getRedisClient().getAddr(),
                                future.cause());
                        result.tryFailure(future.cause());
                        return;
                    }

                    Map<String, String> params = future.getNow();
                    if ("fail".equals(params.get("cluster_state"))) {
                        RedisException e = new RedisException(
                                "Failed to add master: " + partition.getMasterAddress() + " for slot ranges: "
                                        + partition.getSlotRanges() + ". Reason - cluster_state:fail");
                        log.error("cluster_state:fail for " + connection.getRedisClient().getAddr());
                        result.tryFailure(e);
                        return;
                    }

                    MasterSlaveServersConfig config = create(cfg);
                    config.setMasterAddress(partition.getMasterAddress());

                    final MasterSlaveEntry e;
                    List<RFuture<Void>> futures = new ArrayList<RFuture<Void>>();
                    if (config.getReadMode() == ReadMode.MASTER) {
                        e = new SingleEntry(partition.getSlotRanges(), ClusterConnectionManager.this, config);
                    } else {
                        config.setSlaveAddresses(partition.getSlaveAddresses());

                        e = new MasterSlaveEntry(partition.getSlotRanges(), ClusterConnectionManager.this,
                                config);

                        List<RFuture<Void>> fs = e.initSlaveBalancer(partition.getFailedSlaveAddresses());
                        futures.addAll(fs);
                        if (!partition.getSlaveAddresses().isEmpty()) {
                            log.info("slaves: {} added for slot ranges: {}", partition.getSlaveAddresses(),
                                    partition.getSlotRanges());
                            if (!partition.getFailedSlaveAddresses().isEmpty()) {
                                log.warn("slaves: {} is down for slot ranges: {}",
                                        partition.getFailedSlaveAddresses(), partition.getSlotRanges());
                            }
                        }
                    }

                    RFuture<Void> f = e.setupMasterEntry(config.getMasterAddress().getHost(),
                            config.getMasterAddress().getPort());
                    final RPromise<Void> initFuture = newPromise();
                    futures.add(initFuture);
                    f.addListener(new FutureListener<Void>() {
                        @Override
                        public void operationComplete(Future<Void> future) throws Exception {
                            if (!future.isSuccess()) {
                                log.error("Can't add master: {} for slot ranges: {}",
                                        partition.getMasterAddress(), partition.getSlotRanges());
                                initFuture.tryFailure(future.cause());
                                return;
                            }
                            for (Integer slot : partition.getSlots()) {
                                addEntry(slot, e);
                                lastPartitions.put(slot, partition);
                            }

                            log.info("master: {} added for slot ranges: {}", partition.getMasterAddress(),
                                    partition.getSlotRanges());
                            if (!initFuture.trySuccess(null)) {
                                throw new IllegalStateException();
                            }
                        }
                    });
                    if (!result.trySuccess(futures)) {
                        throw new IllegalStateException();
                    }
                }
            });

        }
    });

    return result;
}

From source file:org.redisson.cluster.ClusterConnectionManager.java

License:Apache License

private void checkClusterState(final ClusterServersConfig cfg, final Iterator<URL> iterator,
        final AtomicReference<Throwable> lastException) {
    if (!iterator.hasNext()) {
        log.error("Can't update cluster state", lastException.get());
        scheduleClusterChangeCheck(cfg, null);
        return;/*from   w  w w. j ava2 s . c  om*/
    }
    if (!getShutdownLatch().acquire()) {
        return;
    }
    final URL uri = iterator.next();
    RFuture<RedisConnection> connectionFuture = connect(cfg, uri);
    connectionFuture.addListener(new FutureListener<RedisConnection>() {
        @Override
        public void operationComplete(Future<RedisConnection> future) throws Exception {
            if (!future.isSuccess()) {
                lastException.set(future.cause());
                getShutdownLatch().release();
                checkClusterState(cfg, iterator, lastException);
                return;
            }

            RedisConnection connection = future.getNow();
            updateClusterState(cfg, connection, iterator, uri);
        }
    });
}

From source file:org.redisson.command.CommandAsyncService.java

License:Apache License

@Override
public <T, R> RFuture<Collection<R>> readAllAsync(RedisCommand<T> command, Object... params) {
    final RPromise<Collection<R>> mainPromise = connectionManager.newPromise();
    final Set<MasterSlaveEntry> nodes = connectionManager.getEntrySet();
    final List<R> results = new ArrayList<R>();
    final AtomicInteger counter = new AtomicInteger(nodes.size());
    FutureListener<R> listener = new FutureListener<R>() {
        @Override// www. j a v  a 2s  .com
        public void operationComplete(Future<R> future) throws Exception {
            if (!future.isSuccess()) {
                mainPromise.tryFailure(future.cause());
                return;
            }

            R result = future.getNow();
            if (result instanceof Collection) {
                synchronized (results) {
                    results.addAll((Collection) result);
                }
            } else {
                synchronized (results) {
                    results.add(result);
                }
            }

            if (counter.decrementAndGet() == 0 && !mainPromise.isDone()) {
                mainPromise.trySuccess(results);
            }
        }
    };

    for (MasterSlaveEntry entry : nodes) {
        RPromise<R> promise = connectionManager.newPromise();
        promise.addListener(listener);
        async(true, new NodeSource(entry), connectionManager.getCodec(), command, params, promise, 0);
    }
    return mainPromise;
}

From source file:org.redisson.command.CommandAsyncService.java

License:Apache License

private <R, T> void retryReadRandomAsync(final RedisCommand<T> command, final RPromise<R> mainPromise,
        final List<MasterSlaveEntry> nodes, final Object... params) {
    final RPromise<R> attemptPromise = connectionManager.newPromise();
    attemptPromise.addListener(new FutureListener<R>() {
        @Override/*from   ww  w  .  j  a  va 2s . co  m*/
        public void operationComplete(Future<R> future) throws Exception {
            if (future.isSuccess()) {
                if (future.getNow() == null) {
                    if (nodes.isEmpty()) {
                        mainPromise.trySuccess(null);
                    } else {
                        retryReadRandomAsync(command, mainPromise, nodes, params);
                    }
                } else {
                    mainPromise.trySuccess(future.getNow());
                }
            } else {
                mainPromise.tryFailure(future.cause());
            }
        }
    });

    MasterSlaveEntry entry = nodes.remove(0);
    async(true, new NodeSource(entry), connectionManager.getCodec(), command, params, attemptPromise, 0);
}

From source file:org.redisson.command.CommandAsyncService.java

License:Apache License

private <T, R> RFuture<R> allAsync(boolean readOnlyMode, RedisCommand<T> command,
        final SlotCallback<T, R> callback, Object... params) {
    final RPromise<R> mainPromise = connectionManager.newPromise();
    final Set<MasterSlaveEntry> nodes = connectionManager.getEntrySet();
    final AtomicInteger counter = new AtomicInteger(nodes.size());
    FutureListener<T> listener = new FutureListener<T>() {
        @Override/*from   ww w.  j av a  2s  .  c o m*/
        public void operationComplete(Future<T> future) throws Exception {
            if (!future.isSuccess()) {
                mainPromise.tryFailure(future.cause());
                return;
            }

            if (callback != null) {
                callback.onSlotResult(future.getNow());
            }
            if (counter.decrementAndGet() == 0) {
                if (callback != null) {
                    mainPromise.trySuccess(callback.onFinish());
                } else {
                    mainPromise.trySuccess(null);
                }
            }
        }
    };

    for (MasterSlaveEntry entry : nodes) {
        RPromise<T> promise = connectionManager.newPromise();
        promise.addListener(listener);
        async(readOnlyMode, new NodeSource(entry), connectionManager.getCodec(), command, params, promise, 0);
    }
    return mainPromise;
}