Example usage for io.vertx.core.streams ReadStream exceptionHandler

Introduction

In this page you can find the example usage for io.vertx.core.streams ReadStream exceptionHandler.

Prototype

ReadStream<T> exceptionHandler(Handler<Throwable> handler);

Source Link

Document

Set an exception handler on the read stream.

Usage

From source file:org.apache.servicecomb.foundation.vertx.stream.PumpCommon.java

License:Apache License

/**
 *
 * @param context// www  .  j a  v  a 2 s  .  c o  m
 * @param readStream
 * @param writeStream
 * @return future of save action<br>
 * <p>important:
 * <p>  if writeStream is AsyncCloseable, future means write complete
 * <p>  if writeStream is not AsyncCloseable, future only means read complete
 */
@SuppressWarnings("unchecked")
public CompletableFuture<Void> pump(Context context, ReadStream<Buffer> readStream,
        WriteStream<Buffer> writeStream) {
    CompletableFuture<Void> readFuture = new CompletableFuture<>();

    writeStream.exceptionHandler(readFuture::completeExceptionally);
    readStream.exceptionHandler(readFuture::completeExceptionally);
    // just means read finished, not means write finished
    readStream.endHandler(readFuture::complete);

    // if readStream(HttpClientResponse) and awriteStream(HttpServerResponse)
    // belongs to difference eventloop
    // maybe will cause deadlock
    // if happened, vertx will print deadlock stacks
    Pump.pump(readStream, writeStream).start();
    try {
        context.runOnContext(v -> readStream.resume());
    } catch (Throwable e) {
        readFuture.completeExceptionally(e);
    }

    if (!AsyncCloseable.class.isInstance(writeStream)) {
        return readFuture;
    }

    return closeWriteStream((AsyncCloseable<Void>) writeStream, readFuture);
}

---

From source file:org.sfs.io.AsyncIO.java

License:Apache License

public static <M> Observable<Void> pump(final ReadStream<M> rs, final EndableWriteStream<M> ws) {
    rs.pause();/*from ww w  .j a v  a 2s  . c o  m*/
    return Observable.defer(() -> {
        ObservableFuture<Void> observableFuture = RxHelper.observableFuture();
        Handler<Throwable> exceptionHandler = throwable -> {
            try {
                ws.drainHandler(null);
                rs.handler(null);
            } catch (Throwable e) {
                observableFuture.fail(e);
                return;
            }
            observableFuture.fail(throwable);
        };
        rs.exceptionHandler(exceptionHandler);
        ws.exceptionHandler(exceptionHandler);
        Handler<Void> drainHandler = event -> {
            try {
                rs.resume();
            } catch (Throwable e) {
                exceptionHandler.handle(e);
            }
        };

        Handler<M> dataHandler = data -> {
            try {
                ws.write(data);
                if (ws.writeQueueFull()) {
                    rs.pause();
                    ws.drainHandler(drainHandler);
                }
            } catch (Throwable e) {
                exceptionHandler.handle(e);
            }
        };
        ws.endHandler(observableFuture::complete);
        rs.endHandler(event -> {
            try {
                ws.end();
            } catch (Throwable e) {
                exceptionHandler.handle(e);
            }
        });
        try {
            rs.handler(dataHandler);
            rs.resume();
        } catch (Throwable e) {
            exceptionHandler.handle(e);
        }
        return observableFuture;
    });
}

---