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:io.grpc.netty.NettyClientTransport.java

License:Apache License

@Override
public ListenableFuture<SocketStats> getStats() {
    final SettableFuture<SocketStats> result = SettableFuture.create();
    if (channel.eventLoop().inEventLoop()) {
        // This is necessary, otherwise we will block forever if we get the future from inside
        // the event loop.
        result.set(getStatsHelper(channel));
        return result;
    }// w  w  w . ja v  a2s.c o  m
    channel.eventLoop().submit(new Runnable() {
        @Override
        public void run() {
            result.set(getStatsHelper(channel));
        }
    }).addListener(new GenericFutureListener<Future<Object>>() {
        @Override
        public void operationComplete(Future<Object> future) throws Exception {
            if (!future.isSuccess()) {
                result.setException(future.cause());
            }
        }
    });
    return result;
}

From source file:io.jsync.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(async, client);
        channel.pipeline().addFirst(sslHandler);
    }//from   w  w  w .  j a v  a2  s.co  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 {
                        async.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:io.lettuce.core.AbstractRedisClient.java

License:Apache License

private static CompletableFuture<Void> toCompletableFuture(Future<?> future) {

    CompletableFuture<Void> promise = new CompletableFuture<>();

    if (future.isDone() || future.isCancelled()) {
        if (future.isSuccess()) {
            promise.complete(null);/*from   ww w.java 2  s .  com*/
        } else {
            promise.completeExceptionally(future.cause());
        }
        return promise;
    }

    future.addListener(f -> {
        if (f.isSuccess()) {
            promise.complete(null);
        } else {
            promise.completeExceptionally(f.cause());
        }
    });

    return promise;
}

From source file:io.lettuce.core.resource.Futures.java

License:Apache License

/**
 * Create a promise that emits a {@code Boolean} value on completion of the {@code future}
 *
 * @param future the future.//from  w  ww  . j a v a2  s. com
 * @return Promise emitting a {@code Boolean} value. {@literal true} if the {@code future} completed successfully, otherwise
 *         the cause wil be transported.
 */
static Promise<Boolean> toBooleanPromise(Future<?> future) {

    DefaultPromise<Boolean> result = new DefaultPromise<>(GlobalEventExecutor.INSTANCE);

    if (future.isDone() || future.isCancelled()) {
        if (future.isSuccess()) {
            result.setSuccess(true);
        } else {
            result.setFailure(future.cause());
        }
        return result;
    }

    future.addListener((GenericFutureListener<Future<Object>>) f -> {

        if (f.isSuccess()) {
            result.setSuccess(true);
        } else {
            result.setFailure(f.cause());
        }
    });
    return result;
}

From source file:io.urmia.api.handler.RestApiHandler.java

License:Open Source License

private void handleGET(final ChannelHandlerContext ctx, final ObjectRequest objectRequest) throws Exception {

    log.info("handleGET req: {}", httpRequest);

    mds.list(ctx.executor(), objectRequest).addListener(new GenericFutureListener<Future<ObjectResponse>>() {
        @Override//from   ww  w . ja  v a  2 s .  c  om
        public void operationComplete(Future<ObjectResponse> future) throws Exception {
            if (!future.isSuccess()) {
                log.error("future failed for handleGET: {}", objectRequest, future.cause());
                sendError(ctx, HttpResponseStatus.INTERNAL_SERVER_ERROR);
                return;
            }

            ObjectResponse objectResponse = future.getNow();

            log.info("result of mds.operate: {} -> {}", objectRequest, objectResponse);

            if (objectResponse instanceof ObjectResponse.EmptyResponse) {
                log.info("nothing found at: {}", objectRequest);
                sendError(ctx, HttpResponseStatus.NOT_FOUND);
                return;

            }

            if (objectResponse instanceof ObjectResponse.SingleObject) {
                log.info("GET is for a file. proxy for downloading: {}", objectResponse);
                setupProxyToGET(ctx, ((ObjectResponse.SingleObject) objectResponse).fullObjectName);
                return;

            }

            if (!(objectResponse instanceof ObjectResponse.MultipleObjects)) {
                log.info("multipleObjects.objects is not MultipleObjects: {}", objectResponse);
                sendError(ctx, HttpResponseStatus.NOT_FOUND);
                return;
            }

            log.info("returning result of mds.list: {}", objectResponse.json());
            ctx.writeAndFlush(objectResponse.encode(), ctx.voidPromise());
        }
    });
}

From source file:io.urmia.api.handler.RestApiHandler.java

License:Open Source License

private void handleDELETE(final ChannelHandlerContext ctx, final ObjectRequest request) throws IOException {
    log.info("handleDELETE req: {}", httpRequest);

    mds.delete(ctx.executor(), request).addListener(new GenericFutureListener<Future<ObjectResponse>>() {
        @Override/*w  w w  . j  a  va2s .c om*/
        public void operationComplete(Future<ObjectResponse> future) throws Exception {
            if (future.isSuccess()) {
                ObjectResponse response = future.get();
                if (response instanceof ObjectResponse.Failure) {
                    log.warn("error on handleDELETE: {} -> {}", request, response);
                    sendError(ctx, response.encode());
                } else {
                    log.info("successful handleDELETE req: {}, rsp: {}", request, response);
                    ctx.writeAndFlush(response.encode());
                }
            } else {
                log.warn("error on handleDELETE: {}", request, future.cause());
                sendError(ctx, HttpResponseStatus.BAD_REQUEST);
            }
        }
    });

}

From source file:io.urmia.api.handler.RestApiHandler.java

License:Open Source License

private void handleHEAD(final ChannelHandlerContext ctx, final ObjectRequest objectRequest) {

    log.info("handleHEAD uri: {} ", httpRequest.getUri());

    mds.head(ctx.executor(), objectRequest).addListener(new GenericFutureListener<Future<ObjectResponse>>() {
        @Override//from w w  w. j a  v  a 2 s  .c o m
        public void operationComplete(Future<ObjectResponse> future) throws Exception {
            if (future.isSuccess()) {
                ObjectResponse objectResponse = future.get();

                log.info("handleHEAD {} -> {}", objectRequest, objectResponse);

                // todo: use .encode()
                if (objectResponse instanceof ObjectResponse.SingleObject) {
                    ObjectResponse.SingleObject singleObject = (ObjectResponse.SingleObject) objectResponse;

                    FullHttpResponse response = new DefaultFullHttpResponse(HTTP_1_1,
                            HttpResponseStatus.NO_CONTENT);

                    if (singleObject.fullObjectName.attributes.dir) {
                        response.headers().set(CONTENT_TYPE, "application/x-json-stream; type=directory");
                    } else {
                        response.headers().set(CONTENT_MD5, singleObject.fullObjectName.attributes.md5);
                    }

                    ctx.writeAndFlush(response).addListener(new GenericFutureListener<ChannelFuture>() {

                        @Override
                        public void operationComplete(ChannelFuture future) throws Exception {
                            if (future.isSuccess()) {
                                log.info("write success");
                            } else {
                                log.info("write failed: {}", future.cause());
                            }

                        }
                    });

                    return;
                }

                log.warn("error on handleHEAD: {}", objectRequest, future.cause());
                sendError(ctx, ERROR_BAD_REQUEST);
            }
        }
    });

}

From source file:io.urmia.api.handler.RestApiHandler.java

License:Open Source License

private void handlePUTmkdir(final ChannelHandlerContext ctx, ObjectRequest request) throws Exception {
    if (request.isNotDirectory()) {
        log.warn("request is not mkdir: {}", request);
        sendError(ctx, HttpResponseStatus.BAD_REQUEST);
        return;//from w  ww  .  j a v a  2  s  .  co m
    }

    log.info("this is a mkdir: {}", request);
    ExtendedObjectAttributes eoa = new ExtendedObjectAttributes(true, 0, "", uuid.next(), 1,
            System.currentTimeMillis());
    final FullObjectRequest fullObjectRequest = new FullObjectRequest(request, eoa);
    mds.put(ctx.executor(), fullObjectRequest).addListener(new GenericFutureListener<Future<ObjectResponse>>() {
        @Override
        public void operationComplete(Future<ObjectResponse> future) throws Exception {
            if (future.isSuccess()) {
                ObjectResponse response = future.getNow();
                log.info("successful mkdir: {}", response);
                ctx.writeAndFlush(
                        new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.NO_CONTENT),
                        ctx.voidPromise());
                ctx.channel().close();
            } else {
                log.warn("no success on mkdir: {}", future.cause());
                sendError(ctx, HttpResponseStatus.BAD_REQUEST);
            }
        }
    });
}

From source file:io.urmia.api.handler.RestApiHandler.java

License:Open Source License

private void setupProxyToGET(final ChannelHandlerContext ctx, final FullObjectName fon) throws Exception {

    log.info("proxy GET storage node: download mode: {}", true);

    final Future<List<String>> futureStorageNodes = mds.storedNodes(ctx.executor(), fon.attributes.etag);

    futureStorageNodes.addListener(new GenericFutureListener<Future<List<String>>>() {
        @Override/* w w  w. j a v  a 2 s  . co  m*/
        public void operationComplete(Future<List<String>> future) throws Exception {
            if (future.isSuccess()) {
                final List<String> st = future.getNow();

                Optional<ServiceInstance<NodeType>> si = findStorageInstanceUp(st);

                if (!si.isPresent()) {
                    log.error("failed to find running node, req: {}", objectRequest);
                    sendError(ctx, HttpResponseStatus.INTERNAL_SERVER_ERROR);
                    return;
                }

                List<ServiceInstance<NodeType>> l = Lists.newArrayList(si.get());
                log.info("proxy storage node: {}, download mode: {}, durability: {}", st, true,
                        objectRequest.getDurability());
                HttpProxyFrontendHandler proxy = new HttpProxyFrontendHandler(l, mds, httpRequest, ctx, true,
                        Optional.<FullObjectName>absent());

                ctx.pipeline().remove("encoder");

                ctx.pipeline().addLast("proxy", proxy);

                proxyMode = true;

                ctx.read(); // todo: can ve removed?

            } else {
                log.error("failed to fetch futureStorageNodes, req: {}", objectRequest, future.cause());
                sendError(ctx, HttpResponseStatus.INTERNAL_SERVER_ERROR);
            }
        }
    });

}

From source file:io.urmia.proxy.HttpProxyFrontendHandler.java

License:Open Source License

private void onComplete(final ChannelHandlerContext ctx, final int index) {
    log.info("onComplete: {}", index);

    completedSet.set(index);/*  w w w .  ja va 2s.  co  m*/

    mds.flagStored(ctx.executor(), storageNodes.get(index).getId(), etag);

    if (completedSet.cardinality() != outboundCount)
        return;

    log.info("all onComplete");

    final String md5;
    final long size;

    if (fon.isPresent()) {
        md5 = fon.get().attributes.md5;
        size = fon.get().attributes.size;

        digestFinal();
    } else {
        // todo: for mln copy md5 and size from original object
        md5 = digestFinal();
        log.info("md5: ", md5);

        size = receivedSize.longValue();
        receivedSize.set(0);
        log.info("size: {}", size);
    }

    ExtendedObjectAttributes eoa = new ExtendedObjectAttributes(false, size, md5, etag.value,
            completedSet.cardinality(), System.currentTimeMillis());
    final FullObjectRequest req = new FullObjectRequest(objectRequest, eoa);

    log.info("mds.put: {}", req);

    mds.put(ctx.executor(), req).addListener(new GenericFutureListener<Future<ObjectResponse>>() {
        @Override
        public void operationComplete(Future<ObjectResponse> future) throws Exception {
            HttpResponseStatus status = future.isSuccess() ? HttpResponseStatus.OK
                    : HttpResponseStatus.BAD_GATEWAY;

            DefaultFullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, status);
            log.info("writing back to client: {}", response);
            ctx.writeAndFlush(response).addListener(new GenericFutureListener<ChannelFuture>() {
                @Override
                public void operationComplete(ChannelFuture future) throws Exception {
                    log.info("write back successful. closing channel");
                    ctx.channel().close();
                }
            });
        }
    });
}